home *** CD-ROM | disk | FTP | other *** search
/ CD Actual Thematic 25: Programming / pc_actual_25.iso / C_C++ / BorlandCompiler / freecommandLinetools.exe / Include / dxsurfb.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  2000-06-27  |  14.2 KB  |  517 lines
  1. /*******************************************************************************
  2. * DXSurfB.cpp *
  3. *------------*
  4. *   Description:
  5. *    This module contains the CDXBaseSurface implementaion.
  6. *-------------------------------------------------------------------------------
  7. *  Created By: RAL                                  Date: 02/12/1998
  8. *  Copyright (C) 1998 Microsoft Corporation
  9. *  All Rights Reserved
  10. *
  11. *-------------------------------------------------------------------------------
  12. *  Revisions:
  13. *
  14. *******************************************************************************/
  15. //--- Additional includes
  16. #include "stdafx.h"
  17. #include <DXTrans.h>
  18. #include "DXSurfB.h"
  19. #include "new.h"
  20.  
  21. CDXBaseSurface::CDXBaseSurface() :
  22.     m_ulLocks(0),
  23.     m_ulThreadsWaiting(0),
  24.     m_Height(0),
  25.     m_Width(0),
  26.     m_pFreePtr(NULL),
  27.     m_dwStatusFlags(DXSURF_READONLY),
  28.     m_dwAppData(0)
  29. {
  30.     m_hSemaphore = CreateSemaphore(NULL, 0, MAXLONG, NULL);
  31.     m_ulNumInRequired = m_ulMaxInputs = 0;
  32. }
  33.  
  34. HRESULT CDXBaseSurface::FinalConstruct()
  35. {
  36.     return m_hSemaphore ? S_OK : E_OUTOFMEMORY;
  37. }
  38.  
  39. void CDXBaseSurface::FinalRelease()
  40. {
  41.     while (m_pFreePtr)
  42.     {
  43.         CDXBaseARGBPtr *pNext = m_pFreePtr->m_pNext;
  44.         DeleteARGBPointer(m_pFreePtr);
  45.         m_pFreePtr = pNext;
  46.     }
  47.     if (m_hSemaphore)
  48.     {
  49.         CloseHandle(m_hSemaphore);
  50.     }
  51. }
  52.  
  53. STDMETHODIMP CDXBaseSurface::GetGenerationId(ULONG *pGenerationId)
  54. {
  55.     if (DXIsBadWritePtr(pGenerationId, sizeof(*pGenerationId)))
  56.     {
  57.         return E_POINTER;
  58.     }
  59.     Lock();
  60.     OnUpdateGenerationId();
  61.     *pGenerationId = m_dwGenerationId;
  62.     Unlock();
  63.     return S_OK;
  64. }
  65.  
  66. STDMETHODIMP CDXBaseSurface::IncrementGenerationId(BOOL /*bRefresh */)
  67. {
  68.     Lock();
  69.     m_dwGenerationId++;
  70.     Unlock();
  71.     return S_OK;
  72. }
  73.  
  74.  
  75. STDMETHODIMP CDXBaseSurface::GetObjectSize(ULONG *pcbSize)
  76. {
  77.     HRESULT hr = S_OK;
  78.     if (DXIsBadWritePtr(pcbSize, sizeof(*pcbSize)))
  79.     {
  80.         hr = E_POINTER;
  81.     }
  82.     else
  83.     {
  84.     Lock();
  85.         *pcbSize = OnGetObjectSize();
  86.         Unlock();
  87.     }
  88.     return hr;
  89. }
  90.  
  91. STDMETHODIMP CDXBaseSurface::MapBoundsIn2Out
  92.     (const DXBNDS *pInBounds, ULONG ulNumInBnds, ULONG /*ulOutIndex*/, DXBNDS *pOutBounds)
  93. {
  94.     HRESULT hr = S_OK;
  95.     if (DXIsBadWritePtr(pOutBounds, sizeof(*pOutBounds)))
  96.     {
  97.         hr = E_POINTER;
  98.     }
  99.     else
  100.     {
  101.         Lock();
  102.         new(pOutBounds) CDXDBnds(m_Width, m_Height);
  103.         Unlock();
  104.     }
  105.     return hr;    
  106. }
  107.  
  108. STDMETHODIMP CDXBaseSurface::InitSurface(IUnknown *pDirectDraw,
  109.                                          const DDSURFACEDESC * pDDSurfaceDesc,
  110.                                          const GUID * pFormatId,
  111.                                          const DXBNDS *pBounds,
  112.                                          DWORD dwFlags)
  113. {
  114.     HRESULT hr = S_OK;
  115.     if (pDDSurfaceDesc || DXIsBadReadPtr(pBounds, sizeof(*pBounds)) || pBounds->eType != DXBT_DISCRETE)
  116.     {
  117.         hr = E_INVALIDARG;
  118.     }
  119.     else
  120.     {
  121.         _EnterCritWith0PtrLocks();
  122.         if (m_Width)
  123.         {
  124.             hr = HRESULT_FROM_WIN32(ERROR_ALREADY_INITIALIZED);
  125.         }
  126.         else
  127.         {
  128.             CDXDBnds *pbnds = (CDXDBnds *)pBounds;
  129.             hr = OnSetSize(pbnds->Width(), pbnds->Height());
  130.         }
  131.         Unlock();
  132.     }
  133.     return hr;
  134. }
  135.  
  136.  
  137. STDMETHODIMP CDXBaseSurface::GetPixelFormat(GUID *pFormat, DXSAMPLEFORMATENUM *pSampleFormatEnum)
  138. {
  139.     HRESULT hr = S_OK;
  140.     if (DX_IS_BAD_OPTIONAL_WRITE_PTR(pFormat) ||
  141.         DX_IS_BAD_OPTIONAL_WRITE_PTR(pSampleFormatEnum))
  142.     {
  143.         hr = E_POINTER;
  144.     }
  145.     else
  146.     {
  147.         if (pFormat) *pFormat = SurfaceCLSID();
  148.         if (pSampleFormatEnum) *pSampleFormatEnum = SampleFormatEnum();
  149.     }
  150.     return hr;
  151. }
  152.  
  153. STDMETHODIMP CDXBaseSurface::GetBounds(DXBNDS* pBounds)
  154. {
  155.     HRESULT hr = S_OK;
  156.     if (DXIsBadWritePtr(pBounds, sizeof(*pBounds)))
  157.     {
  158.         hr = E_POINTER;
  159.     }
  160.     else
  161.     {
  162.         Lock();
  163.         new(pBounds) CDXDBnds(m_Width, m_Height);
  164.         Unlock();
  165.     }
  166.     return hr;    
  167. } 
  168.  
  169. STDMETHODIMP CDXBaseSurface::GetStatusFlags(DWORD* pdwStatusFlags)
  170. {
  171.     HRESULT hr = S_OK;
  172.     if (DXIsBadWritePtr(pdwStatusFlags, sizeof(*pdwStatusFlags)))
  173.     {
  174.         hr = E_POINTER;
  175.     }
  176.     else
  177.     {
  178.         Lock();
  179.         *pdwStatusFlags = m_dwStatusFlags;
  180.         Unlock();
  181.     }
  182.     return hr;    
  183. } 
  184.  
  185. STDMETHODIMP CDXBaseSurface::SetStatusFlags(DWORD dwStatusFlags )
  186. {
  187.     _EnterCritWith0PtrLocks();
  188.     // BUGBUG -- Think about this
  189.     m_dwStatusFlags = dwStatusFlags | DXSURF_READONLY;
  190.     m_dwGenerationId++;
  191.     Unlock();
  192.     return S_OK;
  193. } 
  194.  
  195. STDMETHODIMP CDXBaseSurface::GetDirectDrawSurface(REFIID riid, void **ppSurface)
  196. {
  197.     return E_NOTIMPL;
  198. }
  199.  
  200. STDMETHODIMP CDXBaseSurface::LockSurface(const DXBNDS *pBounds, ULONG ulTimeOut,
  201.                                          DWORD dwFlags, REFIID riid, void **ppPointer,
  202.                                          DWORD * pGenerationId)
  203. {
  204.     HRESULT hr = S_OK;
  205.     BOOL bMPLockOnly = m_bInMultiThreadWorkProc;
  206.  
  207.     if (!bMPLockOnly) Lock();
  208.     m_MPWorkProcCrit.Lock();
  209.  
  210.     if (m_Width == 0)
  211.     {
  212.         hr = E_FAIL;    // BUGBUG -- What code??
  213.     }
  214.     else
  215.     {
  216.         RECT r;
  217.         r.top = r.left = 0;
  218.         r.right = m_Width;
  219.         r.bottom = m_Height;
  220.         if (pBounds)
  221.         {
  222.             if (pBounds->eType != DXBT_DISCRETE)
  223.             {
  224.                 hr = DXTERR_INVALID_BOUNDS;
  225.             }
  226.             else
  227.             {
  228.                 ((CDXDBnds *)pBounds)->GetXYRect(r);
  229.                 if (r.top < 0 || r.left < 0 || (ULONG)r.right > m_Width || (ULONG)r.bottom > m_Height || r.bottom <= r.top || r.right <= r.left)
  230.                 {
  231.                     hr = DXTERR_INVALID_BOUNDS;
  232.                 }
  233.             }
  234.         }
  235.         if (SUCCEEDED(hr))
  236.         {
  237.             CDXBaseARGBPtr * pPtr = m_pFreePtr;
  238.             if (pPtr)
  239.             {
  240.                 m_pFreePtr = pPtr->m_pNext;
  241.             }
  242.             else
  243.             {
  244.                 hr = CreateARGBPointer(this, &pPtr);
  245.             }
  246.             if (SUCCEEDED(hr))
  247.             {
  248.                 hr = pPtr->InitFromLock(r, ulTimeOut, dwFlags, riid, ppPointer);
  249.                 if (pGenerationId)
  250.                 {
  251.                     if (DXIsBadWritePtr(pGenerationId, sizeof(*pGenerationId)))
  252.                     {
  253.                         hr = E_POINTER;
  254.                     }
  255.                     else
  256.                     {
  257.                         *pGenerationId = m_dwGenerationId;
  258.                     }
  259.                 }
  260.                 if (SUCCEEDED(hr))
  261.                 {
  262.                     m_ulLocks++;
  263.                 }
  264.                 else
  265.                 {
  266.                     pPtr->m_pNext = m_pFreePtr;
  267.                     m_pFreePtr = pPtr;
  268.                 }
  269.             }
  270.         }
  271.     }
  272.     m_MPWorkProcCrit.Unlock();
  273.     if (!bMPLockOnly) Unlock();
  274.     return hr;
  275. }
  276.  
  277. void CDXBaseSurface::_InternalUnlock(CDXBaseARGBPtr *pPtrToUnlock)
  278. {
  279.     BOOL bMPLockOnly = m_bInMultiThreadWorkProc;
  280.  
  281.     if (!bMPLockOnly) Lock();
  282.     m_MPWorkProcCrit.Lock();
  283.     pPtrToUnlock->m_pNext = m_pFreePtr;
  284.     m_pFreePtr = pPtrToUnlock;
  285.     m_ulLocks--;
  286.     if ((m_ulLocks == 0) && m_ulThreadsWaiting)
  287.     {
  288.         ReleaseSemaphore(m_hSemaphore, m_ulThreadsWaiting, NULL);
  289.         m_ulThreadsWaiting = 0;
  290.     }
  291.     m_MPWorkProcCrit.Unlock();
  292.     if (!bMPLockOnly) Unlock();
  293.  
  294.     IUnknown *punkOuter = GetControllingUnknown();
  295.     punkOuter->Release();   // Release pointer's reference to us
  296.                             // which could kill us!  Don't touch
  297.                             // any members after this point.
  298. }
  299.  
  300. //
  301. //  Picking interface needs to test the appropriate point for hit testing
  302. //
  303. HRESULT CDXBaseSurface::OnSurfacePick(const CDXDBnds & OutPoint, ULONG & ulInputIndex, CDXDVec & InVec)
  304. {
  305.     HRESULT hr;
  306.     IDXARGBReadPtr *pPtr;
  307.     hr = LockSurface(&OutPoint, m_ulLockTimeOut, DXLOCKF_READ, 
  308.                      IID_IDXARGBReadPtr, (void **)&pPtr, NULL);
  309.     if( SUCCEEDED(hr) )
  310.     {
  311.         DXPMSAMPLE val;
  312.         pPtr->UnpackPremult(&val, 1, FALSE);
  313.         pPtr->Release();
  314.         hr = val.Alpha ? DXT_S_HITOUTPUT : S_FALSE;
  315.     }
  316.     else
  317.     {
  318.         if (hr == DXTERR_INVALID_BOUNDS) hr = S_FALSE;
  319.     }
  320.     return hr;
  321. }
  322.  
  323. /*****************************************************************************
  324. * RegisterSurface (STATIC member function)
  325. *-----------------------------------------------------------------------------
  326. *   Description:
  327. *-----------------------------------------------------------------------------
  328. *   Created By: RAL                                 Date: 12/10/97
  329. *-----------------------------------------------------------------------------
  330. *   Parameters:
  331. *****************************************************************************/
  332. HRESULT CDXBaseSurface::
  333. RegisterSurface(REFCLSID rcid, int ResourceId, ULONG cCatImpl, const CATID * pCatImpl,
  334.                 ULONG cCatReq, const CATID * pCatReq, BOOL bRegister)
  335. {
  336.     HRESULT hr = bRegister ? _Module.UpdateRegistryFromResource(ResourceId, bRegister) : S_OK;
  337.     if (SUCCEEDED(hr))
  338.     {
  339.         CComPtr<ICatRegister> pCatRegister;
  340.         HRESULT hr = CoCreateInstance(CLSID_StdComponentCategoriesMgr, NULL, CLSCTX_ALL, IID_ICatRegister, (void **)&pCatRegister);
  341.         if (SUCCEEDED(hr))
  342.         {
  343.             if (bRegister)
  344.             {
  345.                 hr = pCatRegister->RegisterClassImplCategories(rcid, cCatImpl, (CATID *)pCatImpl);
  346.                 if (SUCCEEDED(hr) && cCatReq && pCatReq) {
  347.                     hr = pCatRegister->RegisterClassReqCategories(rcid, cCatReq, (CATID *)pCatReq);
  348.                 }
  349.             } 
  350.             else
  351.             {
  352.                 pCatRegister->UnRegisterClassImplCategories(rcid, cCatImpl, (CATID *)pCatImpl);
  353.                 if (cCatReq && pCatReq)
  354.                 {
  355.                     pCatRegister->UnRegisterClassReqCategories(rcid, cCatReq, (CATID *)pCatReq);
  356.                 }
  357.             }
  358.         }
  359.     }
  360.     if ((!bRegister) && SUCCEEDED(hr)) 
  361.     { 
  362.         _Module.UpdateRegistryFromResource(ResourceId, bRegister);
  363.     }
  364.     return hr;
  365. }
  366.  
  367. //
  368. //  CDXBaseARGBPtr
  369. //
  370. STDMETHODIMP CDXBaseARGBPtr::QueryInterface(REFIID riid, void ** ppv)
  371. {
  372.     if (IsEqualGUID(riid, IID_IUnknown) ||
  373.         IsEqualGUID(riid, IID_IDXARGBReadPtr))
  374.     {
  375.         *ppv = (IDXARGBReadPtr *)this;
  376.         m_ulRefCount++;
  377.         return S_OK;
  378.     }
  379.     else
  380.     {
  381.         *ppv = NULL;
  382.         return E_NOINTERFACE;
  383.     }
  384. }
  385.  
  386.  
  387. ULONG STDMETHODCALLTYPE CDXBaseARGBPtr::AddRef()
  388. {
  389.     return ++m_ulRefCount;
  390. }
  391.  
  392. ULONG STDMETHODCALLTYPE CDXBaseARGBPtr::Release()
  393. {
  394.     --m_ulRefCount;
  395.     ULONG c = m_ulRefCount;
  396.     if (c == 0)
  397.     {
  398.         m_pSurface->_InternalUnlock(this);  // Don't touch members after this call.
  399.     }
  400.     return c;
  401. }
  402.  
  403. HRESULT STDMETHODCALLTYPE CDXBaseARGBPtr::GetSurface(REFIID riid, void **ppSurface)
  404. {
  405.     return m_pSurface->GetControllingUnknown()->QueryInterface(riid, ppSurface);
  406. }
  407.  
  408.  
  409. DXSAMPLEFORMATENUM STDMETHODCALLTYPE CDXBaseARGBPtr::GetNativeType(DXNATIVETYPEINFO *pInfo)
  410. {
  411.     if (pInfo)
  412.     {
  413.         memset(pInfo, 0, sizeof(pInfo));
  414.     }
  415.     return m_pSurface->SampleFormatEnum();
  416. }
  417.  
  418.  
  419. void STDMETHODCALLTYPE CDXBaseARGBPtr::Move(long cSamples)
  420. {
  421.     m_FillInfo.x += cSamples;
  422.     //--- Moving one column past the end is okay
  423.     _ASSERT((long)m_FillInfo.x <= m_LockedRect.right);
  424. }
  425.  
  426. void STDMETHODCALLTYPE CDXBaseARGBPtr::MoveToRow(ULONG y)
  427. {
  428.     m_FillInfo.x = m_LockedRect.left;
  429.     m_FillInfo.y = y + m_LockedRect.top;
  430.     _ASSERT((long)m_FillInfo.y < m_LockedRect.bottom);
  431. }
  432.  
  433. void STDMETHODCALLTYPE CDXBaseARGBPtr::MoveToXY(ULONG x, ULONG y)
  434. {
  435.     m_FillInfo.x = x + m_LockedRect.left;
  436.     m_FillInfo.y = y + m_LockedRect.top;
  437.     //--- Moving one column past the end is okay
  438.     _ASSERT((long)m_FillInfo.x <= m_LockedRect.right);
  439.     _ASSERT((long)m_FillInfo.y < m_LockedRect.bottom);
  440. }
  441.  
  442. ULONG STDMETHODCALLTYPE CDXBaseARGBPtr::MoveAndGetRunInfo(ULONG Row, const DXRUNINFO ** ppInfo)
  443. {
  444.     m_FillInfo.x = m_LockedRect.left;
  445.     m_FillInfo.y = Row + m_LockedRect.top;
  446.     _ASSERT((long)m_FillInfo.y < m_LockedRect.bottom);
  447.     *ppInfo = &m_RunInfo;
  448.     return 1;
  449. }
  450.  
  451. DXSAMPLE *STDMETHODCALLTYPE CDXBaseARGBPtr::Unpack(DXSAMPLE *pSamples, ULONG cSamples, BOOL bMove)
  452. {
  453.     m_FillInfo.pSamples = pSamples;
  454.     m_FillInfo.cSamples = cSamples;
  455.     m_FillInfo.bPremult = false;
  456.     FillSamples(m_FillInfo);
  457.     if (bMove) m_FillInfo.x += cSamples;
  458.     return pSamples;
  459. }
  460.  
  461. DXPMSAMPLE *STDMETHODCALLTYPE CDXBaseARGBPtr::UnpackPremult(DXPMSAMPLE *pSamples, ULONG cSamples, BOOL bMove)
  462. {
  463.     m_FillInfo.pSamples = pSamples;
  464.     m_FillInfo.cSamples = cSamples;
  465.     m_FillInfo.bPremult = true;
  466.     FillSamples(m_FillInfo);
  467.     if (bMove) m_FillInfo.x += cSamples;
  468.     return pSamples;
  469. }
  470.  
  471. void STDMETHODCALLTYPE CDXBaseARGBPtr::UnpackRect(const DXPACKEDRECTDESC *pDesc)
  472. {
  473.     DXPtrFillInfo FillInfo;
  474.     FillInfo.pSamples = pDesc->pSamples;
  475.     FillInfo.cSamples = pDesc->rect.right - pDesc->rect.left;
  476.     FillInfo.x = pDesc->rect.left + m_LockedRect.left;
  477.     FillInfo.bPremult = pDesc->bPremult;
  478.     ULONG YLimit = pDesc->rect.bottom + m_LockedRect.top;
  479.     for (FillInfo.y = pDesc->rect.top + m_LockedRect.top;
  480.          FillInfo.y < YLimit;
  481.          FillInfo.y++)
  482.     {
  483.         FillSamples(FillInfo);
  484.         FillInfo.pSamples += FillInfo.cSamples;
  485.     }
  486. }
  487.  
  488. HRESULT CDXBaseARGBPtr::InitFromLock(const RECT & rect, ULONG /*ulTimeOut*/, DWORD dwLockFlags, REFIID riid, void ** ppv)
  489. {
  490.     HRESULT hr = S_OK;
  491.     if (dwLockFlags & DXLOCKF_READWRITE)
  492.     {
  493.         hr = E_INVALIDARG;
  494.     }
  495.     else
  496.     {
  497.         m_LockedRect = rect;
  498.         m_RunInfo.Count = rect.right - rect.left;
  499.         if (m_pSurface->SampleFormatEnum() & DXPF_TRANSPARENCY)
  500.         {
  501.             m_RunInfo.Type = DXRUNTYPE_UNKNOWN;
  502.         }
  503.         else
  504.         {
  505.             m_RunInfo.Type = DXRUNTYPE_OPAQUE;
  506.         }
  507.         m_FillInfo.x = rect.left;
  508.         m_FillInfo.y = rect.top;
  509.         hr = QueryInterface(riid, ppv);
  510.         if (SUCCEEDED(hr))
  511.         {
  512.             m_pSurface->GetControllingUnknown()->AddRef();
  513.         }
  514.     }
  515.     return hr;
  516. }
  517.