/*******************************************************************************
* DXHelper.h *
*------------*
* Description:
* This is the header file for core helper functions implementation.
*-------------------------------------------------------------------------------
* Created By: Edward W. Connell Date: 07/11/95
* Copyright (C) 1995 Microsoft Corporation
* All Rights Reserved
*
*-------------------------------------------------------------------------------
* Revisions:
*
*******************************************************************************/
#ifndef DXHelper_h
#define DXHelper_h
#include <DXTError.h>
#include <DXBounds.h>
#include <DXTrans.h>
#include <limits.h>
#include <crtdbg.h>
#include <malloc.h>
#include <math.h>
//=== Constants ==============================================================
#define DX_MMX_COUNT_CUTOFF 16
//=== Class, Enum, Struct and Union Declarations =============================
/*** DXLIMAPINFO
* This structure is used by the array linear interpolation and image
* filtering routines.
*/
typedef struct DXLIMAPINFO
{
float IndexFrac;
USHORT Index;
BYTE Weight;
} DXLIMAPINFO;
//
// Declare this class as a global to use for determining when to call MMX optimized
// code. You can use MinMMXOverCount to determine if MMX instructions are present.
// Typically, you would only want to use MMX instructions when you have a reasonably
// large number of pixels to work on. In this case your code can always be coded like
// this:
//
// if (CountOfPixelsToDo >= g_MMXInfo.MinMMXOverCount())
// {
// Do MMX Stuff
// } else {
// Do integer / float based stuff
// }
//
// If you code your MMX sequences like this, you will not have to use a special test
// for the presence of MMX since the MinMMXOverCount will be set to 0xFFFFFFFF if there
// is no MMX present on the processor.
//
// You do not need to use this unless your module needs to conditionally execute MMX vs
// non-MMX code. If you only call the helper functions provided by DXTrans.Dll, such as
// DXOverArrayMMX, you do NOT need this test. You can always call these functions and they
// will use the MMX code path only when MMX instructions are present.
//
class CDXMMXInfo
{
ULONG m_MinMMXOver;
public:
CDXMMXInfo()
{
#ifndef _X86_
m_MinMMXOver = 0xFFFFFFFF;
#else
m_MinMMXOver = DX_MMX_COUNT_CUTOFF;
__try
{
__asm
{
//--- Try the MMX exit multi-media state instruction
EMMS;
}
}
__except( GetExceptionCode() == EXCEPTION_ILLEGAL_INSTRUCTION )
{
//--- MMX instructions not available
m_MinMMXOver = 0xFFFFFFFF;
}
#endif
}
inline ULONG MinMMXOverCount() { return m_MinMMXOver; }
};
//=== Function Prototypes ==========================================
_DXTRANS_IMPL_EXT void WINAPI
DXLinearInterpolateArray( const DXBASESAMPLE* pSamps, DXLIMAPINFO* pMapInfo,
DXBASESAMPLE* pResults, DWORD dwResultCount );
_DXTRANS_IMPL_EXT void WINAPI
DXLinearInterpolateArray( const DXBASESAMPLE* pSamps, PUSHORT pIndexes,
PBYTE pWeights, DXBASESAMPLE* pResults,
DWORD dwResultCount );
//
// DXOverArray
//
// Composits an array of source samples over the samples in the pDest buffer.
//
// pDest - Pointer to the samples that will be modified by compositing the pSrc
// samples over the pDest samples.
// pSrc - The samples to composit over the pDest samples
// nCount - The number of samples to process
//
_DXTRANS_IMPL_EXT void WINAPI
DXOverArray(DXPMSAMPLE* pDest, const DXPMSAMPLE* pSrc, ULONG nCount);
//
// DXOverArrayMMX
//
// Identical to DXOverArray except that the MMX instruction set will be used for
// large arrays of samples. If the CPU does not support MMX, you may still call
// this function, which will perform the same operation without the use of the MMX
// unit.
//
// Note that it is LESS EFFICIENT to use this function if the majority of the pixels
// in the pSrc buffer are either clear (alpha 0) or opaque (alpha 0xFF). This is
// because the MMX code must process every pixel and can not special case clear or
// opaque pixels. If there are a large number of translucent pixels then this function
// is much more efficent than DXOverArray.
//
// pDest - Pointer to the samples that will be modified by compositing the pSrc
// samples over the pDest samples.
// pSrc - The samples to composit over the pDest samples
// nCount - The number of samples to process
//
_DXTRANS_IMPL_EXT void WINAPI
DXOverArrayMMX(DXPMSAMPLE* pDest, const DXPMSAMPLE* pSrc, ULONG nCount);
//
// DXConstOverArray
//
// Composits a single color over an array of samples.
//
// pDest - Pointer to the samples that will be modified by compositing the color (val)
// over the pDest samples.
// val - The premultiplied color value to composit over the pDest array.
// nCount - The number of samples to process
//
_DXTRANS_IMPL_EXT void WINAPI
DXConstOverArray(DXPMSAMPLE* pDest, const DXPMSAMPLE & val, ULONG nCount);
//
// DXConstOverArray
//
// Composits a single color over an array of samples.
//
// pDest - Pointer to the samples that will be modified by compositing the samples
// in the buffer over the color (val).
// val - The premultiplied color value to composit under the pDest array.
// nCount - The number of samples to process
//
_DXTRANS_IMPL_EXT void WINAPI
DXConstUnderArray(DXPMSAMPLE* pDest, const DXPMSAMPLE & val, ULONG nCount);
//===================================================================================
//
// Dithering Helpers
//
// Image transforms are sometimes asked to dither their output. This helper function
// should be used by all image transforms to enusure a consistant dither pattern.
//
// DXDitherArray is used to dither pixels prior to writing them to a DXSurface.
// The caller must fill in the DXDITHERDESC structure, setting X and Y to the
// output surface X,Y coordinates that the pixels will be placed in. The samples
// will be modified in place.
//
// Once the samples have been dithered, they should be written to or composited with
// the destination surface.
//
#define DX_DITHER_HEIGHT 4 // The dither pattern is 4x4 pixels
#define DX_DITHER_WIDTH 4
typedef struct DXDITHERDESC
{
DXBASESAMPLE * pSamples; // Pointer to the 32-bit samples to dither
ULONG cSamples; // Count of number of samples in pSamples buffer
ULONG x; // X coordinate of the output surface
ULONG y; // Y coordinate of the output surface
DXSAMPLEFORMATENUM DestSurfaceFmt; // Pixel format of the output surface
} DXDITHERDESC;
_DXTRANS_IMPL_EXT void WINAPI
DXDitherArray(const DXDITHERDESC *pDitherDesc);
//=== Enumerated Set Definitions =============================================
//=== Function Type Definitions ==============================================
//=== Class, Struct and Union Definitions ====================================
//=== Inline Functions =======================================================
//===================================================================================
//
// Memory allocation helpers.
//
// These macros are used to allocate arrays of samples from the stack (using _alloca)
// and cast them to the appropriate type. The ulNumSamples parameter is the count
// of samples required.
//
#define DXBASESAMPLE_Alloca( ulNumSamples ) \
(DXBASESAMPLE *)_alloca( (ulNumSamples) * sizeof( DXBASESAMPLE ) )
#define DXSAMPLE_Alloca( ulNumSamples ) \
(DXSAMPLE *)_alloca( (ulNumSamples) * sizeof( DXSAMPLE ) )
#define DXPMSAMPLE_Alloca( ulNumSamples ) \
(DXPMSAMPLE *)_alloca( (ulNumSamples) * sizeof( DXPMSAMPLE ) )
//===================================================================================
//
// Critical section helpers.
//
// These C++ classes, CDXAutoObjectLock and CDXAutoCritSecLock are used within functions
// to automatically claim critical sections upon constuction, and the critical section
// will be released when the object is destroyed (goes out of scope).
//
// The macros DXAUTO_OBJ_LOCK and DX_AUTO_SEC_LOCK(s) are normally used at the beginning
// of a function that requires a critical section. Any exit from the scope in which the
// auto-lock was taken will automatically release the lock.
//
#ifdef __ATLCOM_H__ //--- Only enable these if ATL is being used
class CDXAutoObjectLock
{
protected:
CComObjectRootEx<CComMultiThreadModel>* m_pObject;
public:
CDXAutoObjectLock(CComObjectRootEx<CComMultiThreadModel> * const pobject)
{
m_pObject = pobject;
m_pObject->Lock();
};
~CDXAutoObjectLock() {
m_pObject->Unlock();
};
};
#define DXAUTO_OBJ_LOCK CDXAutoObjectLock lck(this);
#define DXAUTO_OBJ_LOCK_( t ) CDXAutoObjectLock lck(t);
class CDXAutoCritSecLock
{
protected:
CComAutoCriticalSection* m_pSec;
public:
CDXAutoCritSecLock(CComAutoCriticalSection* pSec)
{
m_pSec = pSec;
m_pSec->Lock();
};
~CDXAutoCritSecLock()
{
m_pSec->Unlock();
};
};
#define DXAUTO_SEC_LOCK( s ) CDXAutoCritSecLock lck(s);
#endif // __ATLCOM_H__
//--- This function is used to compute the coefficient for a gaussian filter coordinate
inline float DXGaussCoeff( double x, double y, double Sigma )
{
double TwoSigmaSq = 2 * ( Sigma * Sigma );
return (float)(exp( ( -(x*x + y*y) / TwoSigmaSq ) ) /
( 3.1415927 * TwoSigmaSq ));
}
//--- This function is used to initialize a gaussian convolution filter
inline void DXInitGaussianFilter( float* pFilter, ULONG Width, ULONG Height, double Sigma )
{
int i, NumCoeff = Width * Height;
float val, CoeffAdjust, FilterSum = 0.;
double x, y;
double LeftX = -(double)(Width / 2);
double RightX = Width - LeftX;
double TopY = -(double)(Height / 2);
double BottomY = Height - TopY;
for( y = -TopY; y <= BottomY; y += 1. )
{
for( x = -LeftX; x <= RightX; x += 1. )
{
val = DXGaussCoeff( x, y, Sigma );
pFilter[i++] = val;
}
}
//--- Normalize filter (make it sum to 1.0)
for( i = 0; i < NumCoeff; ++i ) FilterSum += pFilter[i];
if( FilterSum < 1. )
{
CoeffAdjust = 1.f / FilterSum;
for( i = 0; i < NumCoeff; ++i )
{
pFilter[i] *= CoeffAdjust;
}
}
} /* DXInitGaussianFilter*/
//
// DXConvertToGray
//
// Translates a color sample to a gray scale sample
//
// Sample - The sample to convert to gray scale.
// Return value is the gray scale sample.
//
inline DXBASESAMPLE DXConvertToGray( DXBASESAMPLE Sample )
{
DWORD v = Sample;
DWORD r = (BYTE)(v >> 16);
DWORD g = (BYTE)(v >> 8);
DWORD b = (BYTE)(v);
DWORD sat = (r*306 + g*601 + b*117) / 1024;
v &= 0xFF000000;
v |= (sat << 16) | (sat << 8) | sat;
return v;
} /* DXConvertToGray */
//--- This returns into the destination the value of the source
// sample scaled by its own alpha (producing a premultiplied alpha sample)
//
inline DXPMSAMPLE DXPreMultSample(const DXSAMPLE & Src)
{
if(Src.Alpha == 255 )
{
return (DWORD)Src;
}
else if(Src.Alpha == 0 )
{
return 0;
}
else
{
unsigned t1, t2;
t1 = (Src & 0x00ff00ff) * Src.Alpha + 0x00800080;
t1 = ((t1 + ((t1 >> 8) & 0x00ff00ff)) >> 8) & 0x00ff00ff;
t2 = (((Src >> 8) & 0x000000ff) | 0x01000000) * Src.Alpha + 0x00800080;
t2 = (t2 + ((t2 >> 8) & 0x00ff00ff)) & 0xff00ff00;
return (t1 | t2);
}
} /* DXPreMultSample */
inline DXPMSAMPLE * DXPreMultArray(DXSAMPLE *pBuffer, ULONG cSamples)
{
for (ULONG i = 0; i < cSamples; i++)
{
BYTE SrcAlpha = pBuffer[i].Alpha;
if (SrcAlpha != 0xFF)
{
if (SrcAlpha == 0)
{
pBuffer[i] = 0;
}
else
{
DWORD S = pBuffer[i];
DWORD t1 = (S & 0x00ff00ff) * SrcAlpha + 0x00800080;
t1 = ((t1 + ((t1 >> 8) & 0x00ff00ff)) >> 8) & 0x00ff00ff;
DWORD t2 = (((S >> 8) & 0x000000ff) | 0x01000000) * SrcAlpha + 0x00800080;
t2 = (t2 + ((t2 >> 8) & 0x00ff00ff)) & 0xff00ff00;
pBuffer[i] = (t1 | t2);
}
}
}
return (DXPMSAMPLE *)pBuffer;
}
inline DXSAMPLE DXUnPreMultSample(const DXPMSAMPLE & Src)
{
if(Src.Alpha == 255 || Src.Alpha == 0)
{
return (DWORD)Src;
}
else
{
DXSAMPLE Dst;
Dst.Blue = (BYTE)((Src.Blue * 255) / Src.Alpha);
Dst.Green = (BYTE)((Src.Green * 255) / Src.Alpha);
Dst.Red = (BYTE)((Src.Red * 255) / Src.Alpha);
Dst.Alpha = Src.Alpha;
return Dst;
}
} /* DXUnPreMultSample */
inline DXSAMPLE * DXUnPreMultArray(DXPMSAMPLE *pBuffer, ULONG cSamples)
{
for (ULONG i = 0; i < cSamples; i++)
{
BYTE SrcAlpha = pBuffer[i].Alpha;
if (SrcAlpha != 0xFF && SrcAlpha != 0)
{
pBuffer[i].Blue = (BYTE)((pBuffer[i].Blue * 255) / SrcAlpha);
pBuffer[i].Green = (BYTE)((pBuffer[i].Green * 255) / SrcAlpha);
pBuffer[i].Red = (BYTE)((pBuffer[i].Red * 255) / SrcAlpha);
}
}
return (DXSAMPLE *)pBuffer;
}
//
// This returns the result of 255-Alpha which is computed by doing a NOT
//
inline BYTE DXInvertAlpha( BYTE Alpha ) { return (BYTE)~Alpha; }
inline DWORD DXScaleSample( DWORD Src, ULONG beta )
{
ULONG t1, t2;
t1 = (Src & 0x00ff00ff) * beta + 0x00800080;
t1 = ((t1 + ((t1 >> 8) & 0x00ff00ff)) >> 8) & 0x00ff00ff;
t2 = ((Src >> 8) & 0x00ff00ff) * beta + 0x00800080;
t2 = (t2 + ((t2 >> 8) & 0x00ff00ff)) & 0xff00ff00;
return (DWORD)(t1 | t2);
}
inline DWORD DXScaleSamplePercent( DWORD Src, float Percent )
{
if (Percent > (254.0f / 255.0f)) {
return Src;
}
else
{
return DXScaleSample(Src, (BYTE)(Percent * 255));
}
}
inline void DXCompositeOver(DXPMSAMPLE & Dst, const DXPMSAMPLE & Src)
{
if (Src.Alpha)
{
ULONG Beta = DXInvertAlpha(Src.Alpha);
if (Beta)
{
Dst = Src + DXScaleSample(Dst, Beta);
}
else
{
Dst = Src;
}
}
}
inline DXPMSAMPLE DXCompositeUnder(DXPMSAMPLE Dst, DXPMSAMPLE Src )
{
return Dst + DXScaleSample(Src, DXInvertAlpha(Dst.Alpha));
}
inline DXBASESAMPLE DXApplyLookupTable(const DXBASESAMPLE Src, const BYTE * pTable)
{
DXBASESAMPLE Dest;
Dest.Blue = pTable[Src.Blue];
Dest.Green = pTable[Src.Green];
Dest.Red = pTable[Src.Red];
Dest.Alpha = pTable[Src.Alpha];
return Dest;
}
inline DXBASESAMPLE * DXApplyLookupTableArray(DXBASESAMPLE *pBuffer, ULONG cSamples, const BYTE * pTable)
{
for (ULONG i = 0; i < cSamples; i++)
{
DWORD v = pBuffer[i];
DWORD a = pTable[v >> 24];
DWORD r = pTable[(BYTE)(v >> 16)];
DWORD g = pTable[(BYTE)(v >> 8)];
DWORD b = pTable[(BYTE)v];
pBuffer[i] = (a << 24) | (r << 16) | (g << 8) | b;
}
return pBuffer;
}
inline DXBASESAMPLE * DXApplyColorChannelLookupArray(DXBASESAMPLE *pBuffer,
ULONG cSamples,
const BYTE * pAlphaTable,
const BYTE * pRedTable,
const BYTE * pGreenTable,
const BYTE * pBlueTable)
{
for (ULONG i = 0; i < cSamples; i++)
{
pBuffer[i].Blue = pBlueTable[pBuffer[i].Blue];
pBuffer[i].Green = pGreenTable[pBuffer[i].Green];
pBuffer[i].Red = pRedTable[pBuffer[i].Red];
pBuffer[i].Alpha = pAlphaTable[pBuffer[i].Alpha];
}
return pBuffer;
}
//
// CDXScale helper class
//
// This class uses a pre-computed lookup table to scale samples. For scaling large
// arrays of samples to a constant scale, this is much faster than using even MMX
// instructions. This class is usually declared as a member of another class and
// is most often used to apply a global opacity to a set of samples.
//
// When using this class, you must always check for the two special cases of clear
// and opaque before calling any of the scaling member functions. Do this by using
// the ScaleType() inline function. Your code should look somthing like this:
//
// if (ScaleType() == DXRUNTYPE_CLEAR)
// Do whatever you do for a 0 alpha set of samples -- usually just ignore them
// else if (ScaleType() == DXRUNTYPE_OPAQUE)
// Do whatever you would do for a non-scaled set of samples
// else
// Scale the samples by using ScaleSample or one of the ScaleArray members
//
// If you call any of the scaling members when the ScaleType() is either clear or
// opaque, you will GP fault becuase the lookup table will not be allocated.
//
// The scale can be set using either a floating point number between 0 and 1 using:
// CDXScale::SetScale / CDXScale::GetScale
// or you can use a byte integer value by using:
// CDXScale::SetScaleAlphaValue / CDXScale::GetScaleAlphaValue
//
class CDXScale
{
private:
float m_Scale;
BYTE m_AlphaScale;
BYTE *m_pTable;
HRESULT InternalSetScale(BYTE Scale)
{
if (m_AlphaScale == Scale) return S_OK;
if (Scale == 0 || Scale == 255)
{
delete m_pTable;
m_pTable = NULL;
}
else
{
if(!m_pTable)
{
m_pTable = new BYTE[256];
if(!m_pTable )
{
return E_OUTOFMEMORY;
}
}
for (int i = 0; i < 256; ++i )
{
m_pTable[i] = (BYTE)((i * Scale) / 255);
}
}
m_AlphaScale = Scale;
return S_OK;
}
public:
CDXScale() :
m_Scale(1.0f),
m_AlphaScale(0xFF),
m_pTable(NULL)
{}
~CDXScale()
{
delete m_pTable;
}
DXRUNTYPE ScaleType()
{
if (m_AlphaScale == 0) return DXRUNTYPE_CLEAR;
if (m_AlphaScale == 0xFF) return DXRUNTYPE_OPAQUE;
return DXRUNTYPE_TRANS;
}
HRESULT SetScaleAlphaValue(BYTE Alpha)
{
HRESULT hr = InternalSetScale(Alpha);
if (SUCCEEDED(hr))
{
m_Scale = ((float)Alpha) / 255.0f;
}
return hr;
}
BYTE GetScaleAlphaValue(void)
{
return m_AlphaScale;
}
HRESULT SetScale(float Scale)
{
HRESULT hr = S_OK;
if(( Scale < 0.0f ) || ( Scale > 1.0f ) )
{
hr = E_INVALIDARG;
}
else
{
ULONG IntScale = (ULONG)(Scale * 256.0f); // Round up alpha (.9999 = 255 = Solid)
if (IntScale > 255)
{
IntScale = 255;
}
hr = SetScaleAlphaValue((BYTE)IntScale);
if (SUCCEEDED(hr))
{
m_Scale = Scale;
}
}
return hr;
}
float GetScale() const
{
return m_Scale;
}
DXRUNTYPE ScaleType() const
{
return (m_pTable ? DXRUNTYPE_TRANS : (m_AlphaScale ? DXRUNTYPE_OPAQUE : DXRUNTYPE_CLEAR));
}
DWORD ScaleSample(const DWORD s) const
{
return DXApplyLookupTable((DXBASESAMPLE)s, m_pTable);
}
DXBASESAMPLE * ScaleBaseArray(DXBASESAMPLE * pBuffer, ULONG cSamples) const
{
return DXApplyLookupTableArray(pBuffer, cSamples, m_pTable);
}
DXPMSAMPLE * ScalePremultArray(DXPMSAMPLE * pBuffer, ULONG cSamples) const
{
return (DXPMSAMPLE *)DXApplyLookupTableArray(pBuffer, cSamples, m_pTable);
}
DXSAMPLE * ScaleArray(DXSAMPLE * pBuffer, ULONG cSamples) const
{
return (DXSAMPLE *)DXApplyLookupTableArray(pBuffer, cSamples, m_pTable);
}
DXSAMPLE * ScaleArrayAlphaOnly(DXSAMPLE *pBuffer, ULONG cSamples) const
{
const BYTE *pTable = m_pTable;
for (ULONG i = 0; i < cSamples; i++)
{
pBuffer[i].Alpha = pTable[pBuffer[i].Alpha];
}
return pBuffer;
}
};
inline DWORD DXWeightedAverage( DXBASESAMPLE S1, DXBASESAMPLE S2, ULONG Wgt )
{
_ASSERT( Wgt < 256 );
ULONG t1, t2;
ULONG InvWgt = Wgt ^ 0xFF;
t1 = (((S1 & 0x00ff00ff) * Wgt) + ((S2 & 0x00ff00ff) * InvWgt )) + 0x00800080;
t1 = ((t1 + ((t1 >> 8) & 0x00ff00ff)) >> 8) & 0x00ff00ff;
t2 = ((((S1 >> 8) & 0x00ff00ff) * Wgt) + (((S2 >> 8) & 0x00ff00ff) * InvWgt )) + 0x00800080;
t2 = (t2 + ((t2 >> 8) & 0x00ff00ff)) & 0xff00ff00;
return (t1 | t2);
} /* DXWeightedAverage */
inline void DXWeightedAverageArray( DXBASESAMPLE* pS1, DXBASESAMPLE* pS2, ULONG Wgt,
DXBASESAMPLE* pResults, DWORD dwCount )
{
_ASSERT( pS1 && pS2 && pResults && dwCount );
for( DWORD i = 0; i < dwCount; ++i )
{
pResults[i] = DXWeightedAverage( pS1[i], pS2[i], Wgt );
}
} /* DXWeightedAverageArray */
inline void DXWeightedAverageArrayOver( DXPMSAMPLE* pS1, DXPMSAMPLE* pS2, ULONG Wgt,
DXPMSAMPLE* pResults, DWORD dwCount )
{
_ASSERT( pS1 && pS2 && pResults && dwCount );
DWORD i;
if( Wgt == 255 )
{
for( i = 0; i < dwCount; ++i )
{
DXCompositeOver( pResults[i], pS1[i] );
}
}
else
{
for( i = 0; i < dwCount; ++i )
{
DXPMSAMPLE Avg = DXWeightedAverage( (DXBASESAMPLE)pS1[i],
(DXBASESAMPLE)pS2[i], Wgt );
DXCompositeOver( pResults[i], Avg );
}
}
} /* DXWeightedAverageArrayOver */
inline void DXScalePremultArray(DXPMSAMPLE *pBuffer, ULONG cSamples, BYTE Weight)
{
for (DXPMSAMPLE *pBuffLimit = pBuffer + cSamples; pBuffer < pBuffLimit; pBuffer++)
{
*pBuffer = DXScaleSample(*pBuffer, Weight);
}
}
//
//
inline HRESULT DXClipToOutputWithPlacement(CDXDBnds & LogicalOutBnds, const CDXDBnds * pClipBnds, CDXDBnds & PhysicalOutBnds, const CDXDVec *pPlacement)
{
if(pClipBnds && (!LogicalOutBnds.IntersectBounds(*pClipBnds)))
{
return S_FALSE; // no intersect, we're done
}
else
{
CDXDVec vClipPos(false);
LogicalOutBnds.GetMinVector( vClipPos );
if (pPlacement)
{
vClipPos -= *pPlacement;
}
PhysicalOutBnds += vClipPos;
if (!LogicalOutBnds.IntersectBounds(PhysicalOutBnds))
{
return S_FALSE;
}
PhysicalOutBnds = LogicalOutBnds;
PhysicalOutBnds -= vClipPos;
}
return S_OK;
}
//
// Helper for converting a color ref to a DXSAMPLE
//
inline DWORD DXSampleFromColorRef(COLORREF cr)
{
DXSAMPLE Samp(0xFF, GetRValue(cr), GetGValue(cr), GetBValue(cr));
return Samp;
}
//
// Fill an entire surface with a color
//
inline HRESULT DXFillSurface( IDXSurface *pSurface, DXPMSAMPLE Color,
BOOL bDoOver = FALSE, ULONG ulTimeOut = 10000 )
{
IDXARGBReadWritePtr * pPtr;
HRESULT hr = pSurface->LockSurface( NULL, ulTimeOut, DXLOCKF_READWRITE,
IID_IDXARGBReadWritePtr, (void **)&pPtr, NULL);
if( SUCCEEDED(hr) )
{
pPtr->FillRect(NULL, Color, bDoOver);
pPtr->Release();
}
return hr;
} /* DXFillSurface */
//
// Fill a specified sub-rectangle of a surface with a color.
//
inline HRESULT DXFillSurfaceRect( IDXSurface *pSurface, RECT & rect, DXPMSAMPLE Color,
BOOL bDoOver = FALSE, ULONG ulTimeOut = 10000 )
{
CDXDBnds bnds(rect);
IDXARGBReadWritePtr * pPtr;
HRESULT hr = pSurface->LockSurface( &bnds, ulTimeOut, DXLOCKF_READWRITE,
IID_IDXARGBReadWritePtr, (void **)&pPtr, NULL);
if( SUCCEEDED(hr) )
{
pPtr->FillRect(NULL, Color, bDoOver);
pPtr->Release();
}
return hr;
} /* DXFillSurfaceRect */
//
// The DestBnds height and width must be greater than or equal to the source bounds.
//
// The dwFlags parameter uses the flags defined by IDXSurfaceFactory::BitBlt:
//
// DXBOF_DO_OVER
// DXBOF_DITHER
//
inline HRESULT DXBitBlt(IDXSurface * pDest, const CDXDBnds & DestBnds,
IDXSurface * pSrc, const CDXDBnds & SrcBnds,
DWORD dwFlags, ULONG ulTimeout)
{
IDXARGBReadPtr * pIn;
HRESULT hr;
hr = pSrc->LockSurface( &SrcBnds, INFINITE,
(dwFlags & DXBOF_DO_OVER) ? (DXLOCKF_READ | DXLOCKF_WANTRUNINFO) : DXLOCKF_READ,
IID_IDXARGBReadPtr, (void**)&pIn, NULL);
if(SUCCEEDED(hr))
{
IDXARGBReadWritePtr * pOut;
hr = pDest->LockSurface( &DestBnds, INFINITE, DXLOCKF_READWRITE,
IID_IDXARGBReadWritePtr, (void**)&pOut, NULL );
if (SUCCEEDED(hr))
{
DXSAMPLEFORMATENUM InNativeType = pIn->GetNativeType(NULL);
DXSAMPLEFORMATENUM OutNativeType = pOut->GetNativeType(NULL);
BOOL bSrcIsOpaque = !(InNativeType & (DXPF_TRANSLUCENCY | DXPF_TRANSPARENCY));
const ULONG Width = SrcBnds.Width();
DXPMSAMPLE *pSrcBuff = NULL;
if( InNativeType != DXPF_PMARGB32 )
{
pSrcBuff = DXPMSAMPLE_Alloca(Width);
}
//
// Don't dither unless the dest has a greater error term than the source.
//
if ((dwFlags & DXBOF_DITHER) &&
((OutNativeType & DXPF_ERRORMASK) <= (InNativeType & DXPF_ERRORMASK)))
{
dwFlags &= (~DXBOF_DITHER);
}
if ((dwFlags & DXBOF_DITHER) || ((dwFlags & DXBOF_DO_OVER) && bSrcIsOpaque== 0))
{
//--- Allocate a working output buffer if necessary
DXPMSAMPLE *pDestBuff = NULL;
if( OutNativeType != DXPF_PMARGB32 )
{
pDestBuff = DXPMSAMPLE_Alloca(Width);
}
//--- Process each output row
// Note: Output coordinates are relative to the lock region
const ULONG Height = SrcBnds.Height();
if (dwFlags & DXBOF_DITHER)
{
DXPMSAMPLE * pSrcDitherBuff = pSrcBuff;
if (pSrcDitherBuff == NULL)
{
pSrcDitherBuff = DXPMSAMPLE_Alloca(Width);
}
const BOOL bCopy = ((dwFlags & DXBOF_DO_OVER) == 0);
//
// Set up the dither descriptor (some things are constant)
//
DXDITHERDESC dd;
dd.pSamples = pSrcDitherBuff;
dd.DestSurfaceFmt = OutNativeType;
for(ULONG Y = 0; Y < Height; ++Y )
{
dd.x = DestBnds.Left();
dd.y = DestBnds.Top() + Y;
const DXRUNINFO *pRunInfo;
ULONG cRuns = pIn->MoveAndGetRunInfo(Y, &pRunInfo);
pOut->MoveToRow( Y );
do
{
ULONG ulRunLen = pRunInfo->Count;
if (pRunInfo->Type == DXRUNTYPE_CLEAR)
{
pIn->Move(ulRunLen);
if (bCopy)
{
//
// The only way to avoid calling a constructor function to create
// a pmsample from 0 is to declare a variable and then assign it!
//
DXPMSAMPLE NullColor;
NullColor = 0;
pOut->FillAndMove(pSrcDitherBuff, NullColor, ulRunLen, FALSE);
}
else
{
pOut->Move(ulRunLen);
}
dd.x += ulRunLen;
}
else
{
pIn->UnpackPremult(pSrcDitherBuff, ulRunLen, TRUE);
dd.cSamples = ulRunLen;
DXDitherArray(&dd);
dd.x += ulRunLen;
if (bCopy || pRunInfo->Type == DXRUNTYPE_OPAQUE)
{
pOut->PackPremultAndMove(pSrcDitherBuff, ulRunLen);
}
else
{
pOut->OverArrayAndMove(pDestBuff, pSrcDitherBuff, ulRunLen);
}
}
pRunInfo++;
cRuns--;
} while (cRuns);
}
}
else
{
for(ULONG Y = 0; Y < Height; ++Y )
{
const DXRUNINFO *pRunInfo;
ULONG cRuns = pIn->MoveAndGetRunInfo(Y, &pRunInfo);
pOut->MoveToRow( Y );
do
{
ULONG ulRunLen = pRunInfo->Count;
switch (pRunInfo->Type)
{
case DXRUNTYPE_CLEAR:
pIn->Move(ulRunLen);
pOut->Move(ulRunLen);
break;
case DXRUNTYPE_OPAQUE:
pOut->CopyAndMoveBoth(pDestBuff, pIn, ulRunLen, TRUE);
break;
case DXRUNTYPE_TRANS:
{
DXPMSAMPLE *pSrc = pIn->UnpackPremult(pSrcBuff, ulRunLen, TRUE);
DXPMSAMPLE *pDest = pOut->UnpackPremult(pDestBuff, ulRunLen, FALSE);
DXOverArrayMMX(pDest, pSrc, ulRunLen);
pOut->PackPremultAndMove(pDestBuff, ulRunLen);
break;
}
case DXRUNTYPE_UNKNOWN:
{
pOut->OverArrayAndMove(pDestBuff,
pIn->UnpackPremult(pSrcBuff, ulRunLen, TRUE),
ulRunLen);
break;
}
}
pRunInfo++;
cRuns--;
} while (cRuns);
}
}
}
else // if ((dwFlags & DXBOF_DITHER) || ((dwFlags & DXBOF_DO_OVER) && bSrcIsOpaque== 0))
{
// This code is run if:
//
// !(dwFlags & DXBOF_DITHER)
// && !((dwFlags & DXBOF_DO_OVER) && bSrcIsOpaque == 0)
//
// In English:
//
// This code is run if 1) dithering is not required
// and 2) blending with output is not required because it was
// not requested or because it's not needed because the source
// pixels are all opaque.
// hrDD is initialized to failure so that in the event that the
// pixel formats don't match or the pixel format supports
// transparency, the CopyRect will still run.
HRESULT hrDD = E_FAIL;
DXSAMPLEFORMATENUM formatIn = pIn->GetNativeType(NULL);
// If the pixel formats match and do not support transparency
// (because it's not supported by ddraw yet) try to use a
// ddraw blit instead of CopyRect.
if ((formatIn == pOut->GetNativeType(NULL))
&& !(formatIn & DXPF_TRANSPARENCY))
{
CComPtr<IDirectDrawSurface> cpDDSrc;
// Get source ddraw surface pointer.
hrDD = pSrc->QueryInterface(IID_IDirectDrawSurface,
(void **)&cpDDSrc);
if (SUCCEEDED(hrDD))
{
CComPtr<IDirectDrawSurface> cpDDDest;
// Get destination ddraw surface pointer.
hrDD = pDest->QueryInterface(IID_IDirectDrawSurface,
(void **)&cpDDDest);
if (SUCCEEDED(hrDD))
{
RECT rcSrc;
RECT rcDest;
SrcBnds.GetXYRect(rcSrc);
DestBnds.GetXYRect(rcDest);
// Attempt the ddraw blit.
hrDD = cpDDDest->Blt(&rcDest, cpDDSrc, &rcSrc,
0, NULL);
}
}
}
// If hrDD has failed at this point, it means a direct draw blit
// was not possible and a CopyRect is needed to perform the
// copy.
if (FAILED(hrDD))
{
pOut->CopyRect(pSrcBuff, NULL, pIn, NULL, bSrcIsOpaque);
}
}
pOut->Release();
}
pIn->Release();
}
return hr;
}
inline HRESULT DXSrcCopy(HDC hdcDest, int nXDest, int nYDest, int nWidth, int nHeight,
IDXSurface *pSrcSurface, int nXSrc, int nYSrc)
{
IDXDCLock *pDCLock;
HRESULT hr = pSrcSurface->LockSurfaceDC(NULL, INFINITE, DXLOCKF_READ, &pDCLock);
if (SUCCEEDED(hr))
{
::BitBlt(hdcDest, nXDest, nYDest, nWidth, nHeight, pDCLock->GetDC(), nXSrc, nYSrc, SRCCOPY);
pDCLock->Release();
}
return hr;
}
//
//=== Pointer validation functions
//
inline BOOL DXIsBadReadPtr( const void* pMem, UINT Size )
{
#if !defined( _DEBUG ) && defined( DXTRANS_NOROBUST )
return false;
#else
return ::IsBadReadPtr( pMem, Size );
#endif
}
inline BOOL DXIsBadWritePtr( void* pMem, UINT Size )
{
#if !defined( _DEBUG ) && defined( DXTRANS_NOROBUST )
return false;
#else
return ::IsBadWritePtr( pMem, Size );
#endif
}
inline BOOL DXIsBadInterfacePtr( const IUnknown* pUnknown )
{
#if !defined( _DEBUG ) && defined( DXTRANS_NOROBUST )
return false;
#else
return ( ::IsBadReadPtr( pUnknown, sizeof( *pUnknown ) ) ||
::IsBadCodePtr( (FARPROC)((void **)pUnknown)[0] ))?
(true):(false);
#endif
}
#define DX_IS_BAD_OPTIONAL_WRITE_PTR(p) ((p) && DXIsBadWritePtr(p, sizeof(p)))
#define DX_IS_BAD_OPTIONAL_READ_PTR(p) ((p) && DXIsBadReadPtr(p, sizeof(p)))
#define DX_IS_BAD_OPTIONAL_INTERFACE_PTR(p) ((p) && DXIsBadInterfacePtr(p))
#endif /* This must be the last line in the file */