baseroot.h
上传用户:zhongxx05
上传日期:2007-06-06
资源大小:33641k
文件大小:10k
源码类别:

Symbian

开发平台:

C/C++

  1. /* ***** BEGIN LICENSE BLOCK ***** 
  2.  * Version: RCSL 1.0/RPSL 1.0 
  3.  *  
  4.  * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. 
  5.  *      
  6.  * The contents of this file, and the files included with this file, are 
  7.  * subject to the current version of the RealNetworks Public Source License 
  8.  * Version 1.0 (the "RPSL") available at 
  9.  * http://www.helixcommunity.org/content/rpsl unless you have licensed 
  10.  * the file under the RealNetworks Community Source License Version 1.0 
  11.  * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, 
  12.  * in which case the RCSL will apply. You may also obtain the license terms 
  13.  * directly from RealNetworks.  You may not use this file except in 
  14.  * compliance with the RPSL or, if you have a valid RCSL with RealNetworks 
  15.  * applicable to this file, the RCSL.  Please see the applicable RPSL or 
  16.  * RCSL for the rights, obligations and limitations governing use of the 
  17.  * contents of the file.  
  18.  *  
  19.  * This file is part of the Helix DNA Technology. RealNetworks is the 
  20.  * developer of the Original Code and owns the copyrights in the portions 
  21.  * it created. 
  22.  *  
  23.  * This file, and the files included with this file, is distributed and made 
  24.  * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 
  25.  * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, 
  26.  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS 
  27.  * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 
  28.  * 
  29.  * Technology Compatibility Kit Test Suite(s) Location: 
  30.  *    http://www.helixcommunity.org/content/tck 
  31.  * 
  32.  * Contributor(s): 
  33.  *  
  34.  * ***** END LICENSE BLOCK ***** */ 
  35. #include "coloracc.h"
  36. #include "hxvsurf.h"
  37. #include "hxengin.h"
  38. #include "hxslist.h"
  39. #ifndef _BASEROOT_H_
  40. #define _BASEROOT_H_
  41. // Forward declarations
  42. class CBaseRootSurface;
  43. class CHXBaseSite;
  44. #define HX_WINDOWLESS_DEBUG       0
  45. #define HX_WINDOWLESS_MINIMAL     1
  46. #define HX_WINDOWLESS_COMPOSITION 2
  47. #define TEXTOVERLAY "TextOverlay"
  48. // You would think that Video and System would be exclusive. 
  49. // Not so. There is a default which allows the system to decide.
  50. #define HX_ACCELERATION_ON     1
  51. #define HX_USE_VIDEO_MEMORY    2
  52. #define HX_USE_SYSTEM_MEMORY   4
  53. struct CModesDesc
  54. {
  55.    UINT32 m_nWidth;
  56.    UINT32 m_nHeight;
  57.    UINT32 m_nBitCount;
  58.    UINT32 m_fourCC;
  59. };
  60. class CBaseRootSurface : public IUnknown
  61. {
  62. public:
  63.     virtual ~CBaseRootSurface();
  64.     CBaseRootSurface(IUnknown* pContext, CHXBaseSite* pSite);
  65.     static CBaseRootSurface* Create(IUnknown* pContext, CHXBaseSite* pSite);
  66.     //IUnknown methods
  67.     STDMETHOD(QueryInterface) (THIS_ REFIID riid, void** ppvObj);
  68.     STDMETHOD_(ULONG32,AddRef) (THIS);
  69.     STDMETHOD_(ULONG32,Release) (THIS);
  70.     //BLTing methods.
  71.     STDMETHOD(Blt) (THIS_ UCHAR*                pImageData,
  72.                           HXBitmapInfoHeader*   pBitmapInfo,
  73.                           REF(HXxRect)          rDestRect,
  74.                           REF(HXxRect)          rSrcRect,
  75.                           CHXBaseSite*          pSite);
  76.     STDMETHOD(BeginOptimizedBlt)(THIS_ HXBitmapInfoHeader* pBitmapInfo);
  77.     STDMETHOD(OptimizedBlt) (THIS_ UCHAR* pImageBits,
  78.                                    REF(HXxRect) rDestRect,
  79.                                    REF(HXxRect) rSrcRect);
  80.     STDMETHOD(EndOptimizedBlt) (THIS);
  81.     STDMETHOD(GetOptimizedFormat)(THIS_ REF(HX_COMPRESSION_TYPE) ulType);
  82.     STDMETHOD(GetPreferredFormat)(THIS_ REF(HX_COMPRESSION_TYPE) ulType);
  83.     void BltComposition();
  84.     void         DestroySurfaces();
  85.     void         ReInitSurfaces();
  86.     void         FillBorders();
  87.     virtual void SetResolution(int x, int y, int depth, void* pWindow);
  88.     void         SetBltLock(BOOL bSet);
  89.     virtual void GetDisplayModes(CModesDesc* pModesDesc, INT32* nNumModes);
  90.     HX_RESULT    Lock(UINT32 nID);
  91.     HX_RESULT    Unlock(UINT32 nID, HXxWindow* pWindow, CHXBaseSite* pSite=NULL);
  92.     BOOL         IsCompositionEnabled();
  93.     virtual void ModifyBoundsRect(HXxRect* pRect);
  94.     HX_RESULT    MinimalLock();
  95.     HX_RESULT    MinimalUnlock(HXxWindow* pWindow);
  96.     HX_RESULT    SizeChanged();
  97.     virtual void _PreFlightBlt(HXxRect& dst) {}
  98.     virtual BOOL _OptimizedSurfaceOpened();
  99.     virtual UINT32 _GetNumberOfMonitors() { return 1; }
  100.     virtual BOOL _RectOnNthMonitor(HXxRect rect, UINT32 uMonitor, HXxRect& intersectRect);
  101.     virtual BOOL _IsHardwareAccelerationAvail();
  102.     virtual BOOL _AcquireHardwareAcceleration();
  103.     virtual BOOL _LoseHardwareAcceleration();
  104.     virtual BOOL _EnableHardwareAcceleration();
  105.     virtual BOOL _DisableHardwareAcceleration();
  106.     virtual void DrawFocusRect(int nSurfaceCID,
  107.                               HXxSize *pSurfaceSize,
  108.                               UCHAR *pVidMem,
  109.                               CHXBaseSite* pSite);
  110. #ifdef _WINDOWS
  111.     IHXPlayer*  GetPlayer();
  112. #endif
  113.     void         LockCompMutex(); 
  114.     void         UnlockCompMutex();
  115.     ColorFuncAccess* GetColorAccess() {return zm_pColorAcc;}
  116.    
  117. protected:
  118.     HXMutex*    m_pMutex;
  119.     HXMutex*    m_pCompMutex;
  120.     CHXSimpleList m_pBltRects;
  121.     LONG32       m_lRefCount;
  122.     IUnknown*    m_pContext;
  123.     CHXBaseSite* m_pSite;    
  124.     UINT32       m_fSurfaceType;
  125.     INT32        m_nBLTMode;
  126.     INT32        m_nCompositionSurfaceCID;
  127.     HXxSize      m_allocatedScratchSize;
  128.     UCHAR*       m_pCompositionSurface;
  129.     HXxSize      m_allocatedCompositionSize;
  130.     INT32        m_nCompositionPitch;
  131.     HXxRect      m_boundsRect;
  132.     HXxSize      m_compositionSize;
  133.     BOOL         m_bCompositionSurfaceCreated;
  134. #ifdef _WIN32
  135.     BITMAPINFO   m_bmiComposition;
  136. #else
  137.     HXBitmapInfo m_bmiComposition;
  138. #endif   
  139. #ifdef _WINDOWS
  140.     IHXPlayer*  m_pPlayer;
  141. #endif
  142.    
  143.     BOOL         m_bUseCardMemory;
  144.     CHXBaseSite* m_pUnlockingSite;
  145.     ColorFuncAccess* zm_pColorAcc;
  146.     
  147.     HX_RESULT DebugBlt( UCHAR*                pImageData,
  148.                         HXBitmapInfoHeader*  pBitmapInfo,
  149.                         REF(HXxRect)          rDestRect,
  150.                         REF(HXxRect)          rSrcRect);
  151.     HX_RESULT MinimalBlt( UCHAR* pImageData, HXBitmapInfoHeader* pBitmapInfo,
  152.                           REF(HXxRect) rDestRect, REF(HXxRect) rSrcRect, CHXBaseSite* pSite);
  153.     // Pure virtuals....
  154.    
  155.     /************************************************************************
  156.      *  Method:
  157.      *      _BltFromScratchToComposition
  158.      *  Purpose:
  159.      *      Transfer data from the scratch surface to the composition surface.
  160.      *      This may not be applicable on some platforms.
  161.      */
  162.     virtual void _BltFromScratchToComposition(HXxRect& rDestRect, HXxRect& rSrcRect)=0;
  163.     
  164.     /************************************************************************
  165.      *  Method:
  166.      *      _DebugBlt
  167.      *  Purpose:
  168.      *      Draw pImageData on the root surface's site.
  169.      */
  170.     virtual HX_RESULT _DebugBlt( UCHAR*                 pImageData,
  171.                                  HXBitmapInfoHeader*    pBitmapInfo,
  172.                                  REF(HXxRect)           rDestRect,
  173.                                  REF(HXxRect)           rSrcRect) = 0;
  174.     /************************************************************************
  175.      *  Method:
  176.      *      _GetYUVScratchWidthHeight
  177.      *  Purpose:
  178.      *      Query the dimensions of the scratch surface
  179.      */
  180.     virtual void _GetYUVScratchWidthHeight(UINT32* pWidth, UINT32* pHeight) = 0;
  181.     /************************************************************************
  182.      *  Method:
  183.      *      _CreateYUVScratchSurface
  184.      *  Purpose:
  185.      *      Create an offscreen yuv surface.  This is used when we need to
  186.      *      perform a 2 stage color converter (source->scratch->dest).
  187.      */
  188.     virtual void _CreateYUVScratchSurface(UINT32 width, UINT32 height) = 0;
  189.     /************************************************************************
  190.      *  Method:
  191.      *      _GetYUVScratchSurfacePointer
  192.      *  Purpose:
  193.      *      Get a writable pointer and the pitch of the scratch buffer.
  194.      */
  195.     virtual void _GetYUVScratchSurfacePointer(UCHAR** pYUVBits, INT32* YUVPitch) = 0;
  196.     /************************************************************************
  197.      *  Method:
  198.      *      CreateScratchSurface
  199.      *  Purpose:
  200.      *      Create an offscreen RGB surface to a 2 stage color convert
  201.      *      when going from YUV->RGB.
  202.      */
  203.     virtual HX_RESULT CreateScratchSurface( int nCompositionSurfaceCID,
  204.                                             HXxSize* pSize) = 0;
  205.     /************************************************************************
  206.      *  Method:
  207.      *      ScratchLock
  208.      *  Purpose:
  209.      *      Get a writable pointer and the pitch of the scratch buffer.
  210.      */
  211.     virtual HX_RESULT ScratchLock(UCHAR** pBits, INT32* pPitch) = 0;
  212.     /************************************************************************
  213.      *  Method:
  214.      *      ScratchUnlock
  215.      *  Purpose:
  216.      *      Finished writing to the scratch buffer.
  217.      */
  218.     virtual HX_RESULT ScratchUnlock(UCHAR* pBits) = 0;
  219.     /************************************************************************
  220.      *  Method:
  221.      *      _MinimalUnlock
  222.      *  Purpose:
  223.      *      Unlocks the composition surface for writing
  224.      */
  225.     virtual HX_RESULT _MinimalUnlock(HXxWindow* pWindow) = 0;
  226.     /************************************************************************
  227.      *  Method:
  228.      *      _LockComposition
  229.      *  Purpose:
  230.      *      Locks the composition surface for writing
  231.      */
  232.     virtual HX_RESULT _LockComposition(UCHAR** pBits, INT32* pPitch)=0;
  233.     /************************************************************************
  234.      *  Method:
  235.      *      _CreateCompositionSurface
  236.      *  Purpose:
  237.      *      Create an offscreen video surface matching the size and format
  238.      *      of the top level site.
  239.      */
  240.     virtual HX_RESULT _CreateCompositionSurface() = 0;
  241.     /************************************************************************
  242.      *  Method:
  243.      *      _DestroyCompositionSurface
  244.      *  Purpose:
  245.      *      Destroy the composition surface
  246.      */
  247.     virtual HX_RESULT _DestroyCompositionSurface() = 0;
  248.     virtual void _MinimalBlt(HXxRect& src, HXxRect& dest);
  249.     virtual void _FillBorders() {};
  250.     virtual void CreateColorAccess(IUnknown* pUnk) {zm_pColorAcc = new ColorFuncAccess(pUnk);}
  251.    
  252. private:
  253. };
  254. #endif  /* _BASEROOT_H_ */