archive
/
windows-xp
mirror of https://github.com/tongzx/nt5src
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Source code of Windows XP (NT5)
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
8 Commits
1 Branch
0 Tags
2.0 GiB
 
 
 
 
 
 
Tree: 744f0b4006
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '744f0b4006'
${ noResults }
windows-xp/Source/XPSP1/NT/multimedia/directx/dxg/d3d8/fw/mipsurf.cpp

668 lines
18 KiB
Raw Blame History

/*==========================================================================
*
* Copyright (C) 1999-2000 Microsoft Corporation. All Rights Reserved.
*
* File: mipsurf.cpp
* Content: Implementation of the CMipSurface and CDriverMipSurface
* classes.
*
*
***************************************************************************/
#include "ddrawpr.h"
#include "mipsurf.hpp"
// IUnknown methods
#undef DPF_MODNAME
#define DPF_MODNAME "CMipSurface::QueryInterface"
STDMETHODIMP CMipSurface::QueryInterface (REFIID riid,
void **ppvObj)
{
API_ENTER(Device());
if (!VALID_PTR_PTR(ppvObj))
{
DPF_ERR("Invalid ppvObj parameter for QueryInterface for a Surface of a Texture");
return D3DERR_INVALIDCALL;
}
if (!VALID_PTR(&riid, sizeof(GUID)))
{
DPF_ERR("Invalid guid memory address to QueryInterface for a Surface of a Texture");
return D3DERR_INVALIDCALL;
}
if (riid == IID_IDirect3DSurface8 ||
riid == IID_IUnknown)
{
*ppvObj = static_cast<void*>(static_cast<IDirect3DSurface8 *>(this));
AddRef();
return S_OK;
}
DPF_ERR("Unsupported Interface identifier passed to QueryInterface for a Surface of a Texture");
// Null out param
*ppvObj = NULL;
return E_NOINTERFACE;
} // QueryInterface
#undef DPF_MODNAME
#define DPF_MODNAME "CMipSurface::AddRef"
STDMETHODIMP_(ULONG) CMipSurface::AddRef()
{
API_ENTER_NO_LOCK(Device());
#ifdef DEBUG
m_cRefDebug++;
#endif // DEBUG
return m_pParent->AddRefImpl();
} // AddRef
#undef DPF_MODNAME
#define DPF_MODNAME "CMipSurface::Release"
STDMETHODIMP_(ULONG) CMipSurface::Release()
{
API_ENTER_SUBOBJECT_RELEASE(Device());
#ifdef DEBUG
m_cRefDebug--;
if (m_cRefDebug & 0x80000000)
{
DPF_ERR("A level of a mip-map has been released more often than it has been add-ref'ed! Danger!!");
}
#endif // DEBUG
return m_pParent->ReleaseImpl();
} // Release
// IBuffer methods
#undef DPF_MODNAME
#define DPF_MODNAME "CMipSurface::SetPrivateData"
STDMETHODIMP CMipSurface::SetPrivateData(REFGUID riid,
CONST void *pvData,
DWORD cbData,
DWORD dwFlags)
{
API_ENTER(Device());
return m_pParent->SetPrivateDataImpl(riid,
pvData,
cbData,
dwFlags,
m_iLevel);
} // SetPrivateData
#undef DPF_MODNAME
#define DPF_MODNAME "CMipSurface::GetPrivateData"
STDMETHODIMP CMipSurface::GetPrivateData(REFGUID riid,
void *pvData,
DWORD *pcbData)
{
API_ENTER(Device());
return m_pParent->GetPrivateDataImpl(riid,
pvData,
pcbData,
m_iLevel);
} // GetPrivateData
#undef DPF_MODNAME
#define DPF_MODNAME "CMipSurface::FreePrivateData"
STDMETHODIMP CMipSurface::FreePrivateData(REFGUID riid)
{
API_ENTER(Device());
return m_pParent->FreePrivateDataImpl(riid,
m_iLevel);
} // FreePrivateData
#undef DPF_MODNAME
#define DPF_MODNAME "CMipSurface::GetContainer"
STDMETHODIMP CMipSurface::GetContainer(REFIID riid,
void **ppContainer)
{
API_ENTER(Device());
return m_pParent->QueryInterface(riid, ppContainer);
} // OpenContainer
#undef DPF_MODNAME
#define DPF_MODNAME "CMipSurface::GetDevice"
STDMETHODIMP CMipSurface::GetDevice(IDirect3DDevice8 **ppDevice)
{
API_ENTER(Device());
return m_pParent->GetDevice(ppDevice);
} // OpenDevice
// IDirect3DSurface8 methods
#undef DPF_MODNAME
#define DPF_MODNAME "CMipSurface::GetDesc"
STDMETHODIMP CMipSurface::GetDesc(D3DSURFACE_DESC *pDesc)
{
API_ENTER(Device());
// If parameters are bad, then we should fail some stuff
if (!VALID_WRITEPTR(pDesc, sizeof(D3DSURFACE_DESC)))
{
DPF_ERR("bad pointer for pDesc passed to GetDesc for a Level of a Texture");
return D3DERR_INVALIDCALL;
}
// The internal desc indicates the real
// format and pool. We need to report
// back the original data
*pDesc = InternalGetDesc();
pDesc->Pool = m_pParent->GetUserPool();
pDesc->Format = m_pParent->GetUserFormat();
pDesc->Usage &= D3DUSAGE_EXTERNAL;
// We're done
return S_OK;
} // GetDesc
#undef DPF_MODNAME
#define DPF_MODNAME "CMipSurface::InternalGetDesc"
D3DSURFACE_DESC CMipSurface::InternalGetDesc() const
{
// We basically get our surface desc from our parent
// and then modify the width and height fields.
D3DSURFACE_DESC desc;
desc = *m_pParent->Desc();
desc.Width >>= m_iLevel;
desc.Height >>= m_iLevel;
if (desc.Width == 0)
{
desc.Width = 1;
}
if (desc.Height == 0)
{
desc.Height = 1;
}
// Also need to modify the type field
desc.Type = D3DRTYPE_SURFACE;
// Also modify the size field
desc.Size = CPixel::ComputeSurfaceSize(desc.Width,
desc.Height,
desc.Format);
// We're done
return desc;
} // InternalGetDesc
#undef DPF_MODNAME
#define DPF_MODNAME "CMipSurface::LockRect"
STDMETHODIMP CMipSurface::LockRect(D3DLOCKED_RECT *pLockedRectData,
CONST RECT *pRect,
DWORD dwFlags)
{
API_ENTER(Device());
// This is a high-frequency API, so we put parameter
// checking into debug only
#ifdef DEBUG
// If parameters are bad, then we should fail some stuff
if (!VALID_WRITEPTR(pLockedRectData, sizeof(D3DLOCKED_RECT)))
{
DPF_ERR("bad pointer for pLockedRectData passed to LockRect for a Level of a Texture");
return D3DERR_INVALIDCALL;
}
// Zero out returned data (in debug at least)
ZeroMemory(pLockedRectData, sizeof(D3DLOCKED_RECT));
// Validate Rect
if (pRect != NULL)
{
DWORD Width = m_pParent->Desc()->Width >> m_iLevel;
DWORD Height = m_pParent->Desc()->Height >> m_iLevel;
if (!CPixel::IsValidRect(m_pParent->Desc()->Format,
Width,
Height,
pRect))
{
DPF_ERR("LockRect for a level of a Texture failed");
return D3DERR_INVALIDCALL;
}
}
if (dwFlags & ~D3DLOCK_SURF_VALID)
{
if (dwFlags & D3DLOCK_DISCARD)
{
if (dwFlags & D3DLOCK_READONLY)
{
DPF_ERR("D3DLOCK_READONLY is not allowed with D3DLOCK_DISCARD");
return D3DERR_INVALIDCALL;
}
if (!(m_pParent->Desc()->Usage & D3DUSAGE_DYNAMIC))
{
DPF_ERR("D3DLOCK_DISCARD is allowed only with dynamic textures");
return D3DERR_INVALIDCALL;
}
if (m_iLevel > 0)
{
DPF_ERR("D3DLOCK_DISCARD is allowed only on level 0"
" (the top mip level). DISCARD in this case will discard"
" the entire mipmap.");
return D3DERR_INVALIDCALL;
}
if (pRect != NULL)
{
DPF_ERR("Subrects not allowed with D3DLOCK_DISCARD");
return D3DERR_INVALIDCALL;
}
}
else
{
DPF_ERR("Invalid dwFlags parameter passed to LockRect for a Level of a Texture");
DPF_EXPLAIN_BAD_LOCK_FLAGS(0, dwFlags & ~D3DLOCK_SURF_VALID);
return D3DERR_INVALIDCALL;
}
}
#endif // DEBUG
// We do this checking in retail too. Must stay in.
if (!m_isLockable)
{
m_pParent->ReportWhyLockFailed();
return D3DERR_INVALIDCALL;
}
// WARNING: For performance reasons, this code is
// duplicated in CMipSurface::InternalLockRect
// Only one lock outstanding at a time is supported
if (m_isLocked)
{
DPF_ERR("LockRect failed on a mip level; surface was already locked.");
return D3DERR_INVALIDCALL;
}
// Notify the parent/device if we are about to be modified
if ( (m_pParent->GetUserPool() != D3DPOOL_SCRATCH) && (!(dwFlags & D3DLOCK_READONLY)) )
{
m_pParent->OnSurfaceLock(m_iLevel, pRect, dwFlags);
}
// Figure out our stride/pointer to bits
// CONSIDER: maybe we should cache our pitch/starting
// pointer to make this call much cheaper.
m_pParent->ComputeMipMapOffset(m_iLevel,
pRect,
pLockedRectData);
// Mark ourselves as locked
m_isLocked = 1;
// Done
return S_OK;
} // CMipSurface::LockRect
HRESULT CMipSurface::InternalLockRect(D3DLOCKED_RECT *pLockedRectData,
CONST RECT *pRect,
DWORD dwFlags)
{
// WARNING: For performance reasons, this code is
// duplicated in CMipSurface::LockRect
// Only one lock outstanding at a time is supported
if (m_isLocked)
{
DPF_ERR("LockRect failed on a mip level; surface was already locked.");
return D3DERR_INVALIDCALL;
}
// Notify the parent/device if we are about to be modified
if ( (m_pParent->GetUserPool() != D3DPOOL_SCRATCH) && (!(dwFlags & D3DLOCK_READONLY)) )
{
m_pParent->OnSurfaceLock(m_iLevel, pRect, dwFlags);
}
// Figure out our stride/pointer to bits
// CONSIDER: maybe we should cache our pitch/starting
// pointer to make this call much cheaper.
m_pParent->ComputeMipMapOffset(m_iLevel,
pRect,
pLockedRectData);
// Mark ourselves as locked
m_isLocked = 1;
// Done
return S_OK;
} // InternalLockRect
#undef DPF_MODNAME
#define DPF_MODNAME "CMipSurface::UnlockRect"
STDMETHODIMP CMipSurface::UnlockRect()
{
API_ENTER(Device());
#ifdef DEBUG
// If we aren't locked; then something is wrong
if (m_isLocked == 0)
{
DPF_ERR("UnlockRect failed on a mip level; surface wasn't locked.");
return D3DERR_INVALIDCALL;
}
#endif // DEBUG
// Clear our locked state
m_isLocked = 0;
// If we are lock-once; then we mark ourselves as not lockable
if (m_pParent->Desc()->Usage & D3DUSAGE_LOADONCE)
{
m_isLockable = FALSE;
}
// Done
return S_OK;
} // UnlockRect
#undef DPF_MODNAME
#define DPF_MODNAME "CMipSurface::InternalUnlockRect"
HRESULT CMipSurface::InternalUnlockRect()
{
// All this is copied into UnlockRect for speed;
// maintain both paths !!!
// Clear our locked state
m_isLocked = 0;
// If we are lock-once; then we mark ourselves as not lockable
if (m_pParent->Desc()->Usage & D3DUSAGE_LOADONCE)
{
m_isLockable = FALSE;
}
// Done
return S_OK;
} // InternalUnlockRect
//
// CDriverMipSurface class modifies the implementation
// of the LockRect and UnlockRect methods of the CMipSurface class
//
#undef DPF_MODNAME
#define DPF_MODNAME "CDriverMipSurface::LockRect"
STDMETHODIMP CDriverMipSurface::LockRect(D3DLOCKED_RECT *pLockedRectData,
CONST RECT *pRect,
DWORD dwFlags)
{
API_ENTER(Device());
// If parameters are bad, then we should fail some stuff
if (!VALID_WRITEPTR(pLockedRectData, sizeof(D3DLOCKED_RECT)))
{
DPF_ERR("bad pointer for m_pLockedRectData passed to LockRect for a Level of a Texture");
return D3DERR_INVALIDCALL;
}
// Zero out returned data
ZeroMemory(pLockedRectData, sizeof(D3DLOCKED_RECT));
// Validate Rect
if (pRect != NULL)
{
DWORD Width = m_pParent->Desc()->Width >> m_iLevel;
DWORD Height = m_pParent->Desc()->Height >> m_iLevel;
if (!CPixel::IsValidRect(m_pParent->Desc()->Format,
Width,
Height,
pRect))
{
DPF_ERR("LockRect for a level of a Texture failed");
return D3DERR_INVALIDCALL;
}
}
if (dwFlags & ~D3DLOCK_SURF_VALID)
{
if (dwFlags & D3DLOCK_DISCARD)
{
if (dwFlags & D3DLOCK_READONLY)
{
DPF_ERR("D3DLOCK_READONLY is not allowed with D3DLOCK_DISCARD");
return D3DERR_INVALIDCALL;
}
if (!(m_pParent->Desc()->Usage & D3DUSAGE_DYNAMIC))
{
DPF_ERR("D3DLOCK_DISCARD is allowed only with dynamic textures");
return D3DERR_INVALIDCALL;
}
if (m_iLevel > 0)
{
DPF_ERR("D3DLOCK_DISCARD is allowed only on level 0"
" (the top mip level). DISCARD in this case will discard"
" the entire mipmap.");
return D3DERR_INVALIDCALL;
}
if (pRect != NULL)
{
DPF_ERR("Subrects not allowed with D3DLOCK_DISCARD");
return D3DERR_INVALIDCALL;
}
}
else
{
DPF_ERR("Invalid dwFlags parameter passed to LockRect for a Level of a Texture");
DPF_EXPLAIN_BAD_LOCK_FLAGS(0, dwFlags & ~D3DLOCK_SURF_VALID);
return D3DERR_INVALIDCALL;
}
}
if (!m_isLockable)
{
m_pParent->ReportWhyLockFailed();
return D3DERR_INVALIDCALL;
}
return InternalLockRect(pLockedRectData, pRect, dwFlags);
} // LockRect
#undef DPF_MODNAME
#define DPF_MODNAME "CDriverMipSurface::InternalLockRect"
HRESULT CDriverMipSurface::InternalLockRect(D3DLOCKED_RECT *pLockedRectData,
CONST RECT *pRect,
DWORD dwFlags)
{
// Only one lock outstanding at a time is supported
if (m_isLocked)
{
DPF_ERR("LockRect failed on a mip level; surface was already locked for a Level of a Texture");
return D3DERR_INVALIDCALL;
}
// Notify the parent/device if we are about to be accessed.
// Driver textures may be written to by HW through
// SRT/DrawPrim as well as UpdateTexture. So we may need to sync
// with the current command batch.
m_pParent->OnSurfaceLock(m_iLevel, pRect, dwFlags);
// Prepare a LockData structure for the HAL call
D3D8_LOCKDATA lockData = {
Device()->GetHandle(),
m_hKernelHandle
};
if (pRect != NULL)
{
lockData.bHasRect = TRUE;
lockData.rArea = *((RECTL *) pRect);
}
else
{
lockData.bHasRect = FALSE;
}
lockData.dwFlags = dwFlags;
HRESULT hr = Device()->GetHalCallbacks()->Lock(&lockData);
if (FAILED(hr))
{
DPF_ERR("Failed to lock driver mip-map surface");
return hr;
}
// Fill in the Locked_Rect fields
D3DFORMAT Format = m_pParent->Desc()->Format;
if (CPixel::IsDXT(Format))
{
// Pitch is the number of bytes for
// one row's worth of blocks for linear formats
// Convert to blocks
UINT Width = (m_pParent->Desc()->Width + 3)/4;
for (UINT i = 0; i < m_iLevel; i++)
{
// Shrink width by half round up to 1 block
if (Width > 1)
{
Width ++;
Width >>= 1;
}
}
// At least one block
if (Width == 0)
Width = 1;
if (Format == D3DFMT_DXT1)
{
// 8 bytes per block for DXT1
pLockedRectData->Pitch = Width * 8;
}
else
{
// 16 bytes per block for DXT2-5
pLockedRectData->Pitch = Width * 16;
}
}
else
{
pLockedRectData->Pitch = lockData.lPitch;
}
pLockedRectData->pBits = lockData.lpSurfData;
#ifdef DEBUG
if ((dwFlags & D3DLOCK_DISCARD))
{
DXGASSERT(m_iLevel == 0);
if (!CPixel::IsFourCC(Format) &&
!CPixel::IsIHVFormat(Format))
{
DXGASSERT(pRect == NULL);
memset(pLockedRectData->pBits, 0xDD, pLockedRectData->Pitch * m_pParent->Desc()->Height);
for (UINT i = 1; i < m_pParent->GetLevelCount(); ++i)
{
D3DLOCKED_RECT Rect;
HRESULT hr = m_pParent->LockRect(i, &Rect, NULL, 0);
if (FAILED(hr))
{
DPF(1, "Lock to mipsublevel failed. Not good.");
break;
}
D3DSURFACE_DESC LevelDesc;
m_pParent->GetLevelDesc(i, &LevelDesc);
memset(Rect.pBits, 0xDD, Rect.Pitch * LevelDesc.Height);
m_pParent->UnlockRect(i);
}
}
}
#endif // DEBUG
// Mark ourselves as locked
m_isLocked = 1;
// Done
return S_OK;
} // CDriverMipSurface::InternalLockRect
#undef DPF_MODNAME
#define DPF_MODNAME "CDriverMipSurface::UnlockRect"
STDMETHODIMP CDriverMipSurface::UnlockRect()
{
API_ENTER(Device());
// If we aren't locked; then something is wrong
if (m_isLocked == 0)
{
DPF_ERR("UnlockRect failed on a mip level; surface wasn't locked.");
return D3DERR_INVALIDCALL;
}
DXGASSERT(m_isLockable);
return InternalUnlockRect();
} // CDriverMipSurface::UnlockRect
#undef DPF_MODNAME
#define DPF_MODNAME "CDriverMipSurface::InternalUnlockRect"
HRESULT CDriverMipSurface::InternalUnlockRect()
{
// Call the driver to perform the unlock
D3D8_UNLOCKDATA unlockData = {
m_pParent->Device()->GetHandle(),
m_hKernelHandle
};
HRESULT hr = Device()->GetHalCallbacks()->Unlock(&unlockData);
if (FAILED(hr))
{
DPF_ERR("Driver surface failed to unlock for a Level of a Texture");
return hr;
}
// Clear our locked state
m_isLocked = 0;
// If we are lock-once; then we mark ourselves as not lockable
if (m_pParent->Desc()->Usage & D3DUSAGE_LOADONCE)
{
m_isLockable = FALSE;
}
// Done
return S_OK;
} // CDriverMipSurface::UnlockRect
// End of file : mipsurf.cpp