开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > Symbian > 查看源码
hxvsurf.h
资源名称：helix.src.0812.rar　[点击查看]
上传用户：zhongxx05
上传日期：2007-06-06
资源大小：33641k
文件大小：26k
源码类别：

Symbian

开发平台：

C/C++

hxvsurf.h：源码内容
  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 ***** */ 
  36. #ifndef _HXVSURF_H_
  37. #define _HXVSURF_H_
  39. /*
  40.  * Forward declarations of some interfaces defined or used here-in.
  41.  */
  42. typedef _INTERFACE  IHXBuffer IHXBuffer;
  43. typedef _INTERFACE  IHXValues IHXValues;
  45. /****************************************************************************
  46.  *
  47.  *  Video Surface Data Structures and Constants
  48.  */
  49. typedef struct _HXBitmapInfoHeader
  50. {
  51.     UINT32  biSize;
  52.     INT32   biWidth;
  53.     INT32   biHeight;
  54.     UINT16  biPlanes;
  55.     UINT16  biBitCount;
  56.     UINT32  biCompression;
  57.     UINT32  biSizeImage;
  58.     INT32   biXPelsPerMeter;
  59.     INT32   biYPelsPerMeter;
  60.     UINT32  biClrUsed;
  61.     UINT32  biClrImportant;
  62.     UINT32  rcolor;
  63.     UINT32  gcolor;
  64.     UINT32  bcolor;
  66. } HXBitmapInfoHeader;
  68. /*
  69.  * HXBitmapInfo structure.
  70.  */
  71. typedef struct _HXBitmapInfo
  72. {
  73.     struct
  74.     {
  75.         UINT32  biSize;         /* use OFFSETOF(dwBitMask) here     */
  76.         INT32   biWidth;        /* image width (in pixels)          */
  77.         INT32   biHeight;       /* image height                     */
  78.         UINT16  biPlanes;       /* # of bitplanes; always use 1     */
  79.         UINT16  biBitCount;     /* average # bits/pixel             */
  80.         UINT32  biCompression;  /* one of the RMA_... FOURCC codes  */
  81.         UINT32  biSizeImage;    /* = width * height * bitCount / 8  */
  82.         INT32   biXPelsPerMeter;/* always 0                         */
  83.         INT32   biYPelsPerMeter;/* always 0                         */
  84.         UINT32  biClrUsed;      /* !0, if 8-bit RGB; 0, otherwise   */
  85.         UINT32  biClrImportant; /* !0, if 8-bit RGB; 0, otherwise   */
  87.     } bmiHeader;
  89.     union
  90.     {
  91.         UINT32  dwBitMask[3];   /* color masks (for BI_BITFIELDS)   */
  92.         UINT32  dwPalette[256]; /* palette (for 8-bit RGB image)    */
  93.     } un;
  95. } HXBitmapInfo;
  97. typedef UINT32  HX_COMPRESSION_TYPE;
  99. /*
  100.  * Structure for source inputs used in IHXVideoSurface2::ColorConvert
  101.  */
  102. typedef struct _tagSourceInputStruct
  103. {
  104.     UCHAR*  *aSrcInput;
  105.     INT32   *aSrcPitch;
  106.     INT32   nNumInputs;
  107. } SourceInputStruct;
  109. /*
  110.  * Structure for alpha blending in IHXVideoSurface2
  111.  */
  112. typedef struct _tagAlphaStruct
  113. {
  114.     UCHAR*      pBuffer;        /* buffer for source image data     */
  115.     UINT32      ulFourCC;       /* fourcc of pBuffer                */
  116.     INT32       lPitch;         /* pitch of pBuffer                 */
  117.     UINT32      ulImageWidth;   /* source image width               */
  118.     UINT32      ulImageHeight;  /* source image height              */
  119.     HXxRect     rcImageRect;    /* subrect of src image requested   */ 
  121. } AlphaStruct;
  123. /*
  124.  * Structure for IHXVideoSurface2::GetVideoMem
  125.  */
  126. typedef struct _tagVideoMemStruct
  127. {
  128.     UCHAR*          pVidMem;    /* pointer to video memory          */
  129.     INT32           lPitch;     /* pitch of pVidMem                 */
  130.     HXBitmapInfoHeader  bmi;   /* desciption of pVidMem            */
  131.     AlphaStruct*    pAlphaList; /* alpha blending list              */
  132.     UINT32          ulCount;    /* alpha blending list length       */
  133. } VideoMemStruct;
  135. /*
  136.  * Windows DIB formats & MKFOURCC() macro:
  137.  */
  138. #ifndef BI_RGB
  139. #define BI_RGB          0L      /* RGB-8, 16, 24, or 32             */
  140. #define BI_RLE8         1L      /* 8-bit RLE compressed image       */
  141. #define BI_RLE4         2L      /* 4-bit RLE compressed image       */
  142. #define BI_BITFIELDS    3L      /* RGB 555, 565, etc.               */
  143. #endif
  144. #ifndef MKFOURCC
  145. #define MKFOURCC(c0,c1,c2,c3)   
  146.         ((UINT32)(BYTE)(c0) | ((UINT32)(BYTE)(c1) << 8) |   
  147.         ((UINT32)(BYTE)(c2) << 16) | ((UINT32)(BYTE)(c3) << 24))
  148. #endif
  150. /*
  151.  * RMA image formats:
  152.  */
  153. #define HX_RGB         BI_RGB  /* Windows-compatible RGB formats:  */
  154. #define HX_RLE8        BI_RLE8
  155. #define HX_RLE4        BI_RLE4
  156. #define HX_BITFIELDS   BI_BITFIELDS
  157. #define HX_I420        MKFOURCC('I','4','2','0') /* planar YCrCb   */
  158. #define HX_YV12        MKFOURCC('Y','V','1','2') /* planar YVU420  */
  159. #define HX_YUY2        MKFOURCC('Y','U','Y','2') /* packed YUV422  */
  160. #define HX_UYVY        MKFOURCC('U','Y','V','Y') /* packed YUV422  */
  161. #define HX_YVU9        MKFOURCC('Y','V','U','9') /* Intel YVU9     */
  162. #define HX_ARGB        MKFOURCC('A','R','G','B') /* ARGB32         */
  163. #define HX_DVPF        MKFOURCC('D','V','P','F') /* dvpf           */
  165. /*
  166.  * Non-standard FOURCC formats (these are just few aliases to what can be
  167.  * represented by the standard formats, and they are left for backward
  168.  * compatibility only).
  169.  */
  170. #define HXCOLOR_RGB3_ID     MKFOURCC('3','B','G','R') /* RGB-32 ??      */
  171. #define HXCOLOR_RGB24_ID    MKFOURCC('B','G','R',' ') /* top-down RGB-24*/
  172. #define HXCOLOR_RGB565_ID   MKFOURCC('6','B','G','R') /* RGB-16 565     */
  173. #define HXCOLOR_RGB555_ID   MKFOURCC('5','B','G','R') /* RGB-16 555     */
  174. #define HXCOLOR_8BIT_ID     MKFOURCC('T','I','B','8') /* RGB-8 w. pal-e */
  175. #define HXCOLOR_YUV420_ID   MKFOURCC('2','V','U','Y') /* planar YCrCb   */
  176. #define HXCOLOR_YUVA_ID     MKFOURCC('Y','U','V','A') /* planar YCrCb   */
  177. #define HXCOLOR_YUV411_ID   MKFOURCC('1','V','U','Y') /* ???            */
  178. #define HXCOLOR_YUVRAW_ID   MKFOURCC('R','V','U','Y') /* ???            */
  180. /*
  181.  * Flags for IHXVideoSurface2
  182.  */
  184. /* Flags for GetVideoMemory */
  185. #define HX_WAIT_FOREVER    0       /* Do not return until a buffer is available */
  186. #define HX_WAIT_NEVER      1       /* Return an error if no buffer is available */
  188. /* Flags for Present */
  189. #define HX_MODE_TIMED      0       /* Synchronize the frame to IHXRenderTimeLine */
  190. #define HX_MODE_IMMEDIATE  1       /* Display the frame ASAP */
  191. #define HX_MODE_REFRESH    (1<<1)  /* Refresh the current frame */
  194. /****************************************************************************
  195.  *
  196.  *  Interface:
  197.  *
  198.  *  IHXVideoSurface
  199.  *
  200.  *  Purpose:
  201.  *
  202.  *  Interface for IHXVideoSurface objects.
  203.  *
  204.  *  IID_IHXVideoSurface:
  205.  *
  206.  *  {00002200-0901-11d1-8B06-00A024406D59}
  207.  *
  208.  */
  210. DEFINE_GUID(IID_IHXVideoSurface, 0x00002200, 0x901, 0x11d1, 0x8b,
  211.     0x6, 0x0, 0xa0, 0x24, 0x40, 0x6d, 0x59);
  213. #undef  INTERFACE
  214. #define INTERFACE   IHXVideoSurface
  216. DECLARE_INTERFACE_(IHXVideoSurface, IUnknown)
  217. {
  218.     /*
  219.      * IUnknown methods
  220.      */
  221.     STDMETHOD(QueryInterface)   (THIS_
  222.                 REFIID riid,
  223.                 void** ppvObj) PURE;
  225.     STDMETHOD_(ULONG32,AddRef)  (THIS) PURE;
  227.     STDMETHOD_(ULONG32,Release) (THIS) PURE;
  229.     /*
  230.      * IHXVideoSurface methods usually called by renderers to
  231.      * Draw on the surface
  232.      */
  233.     STDMETHOD(Blt)      (THIS_
  234.                 UCHAR*          /*IN*/  pImageBits,
  235.                 HXBitmapInfoHeader*    /*IN*/  pBitmapInfo,
  236.                 REF(HXxRect)        /*IN*/  rDestRect,
  237.                 REF(HXxRect)        /*IN*/  rSrcRect) PURE;
  239.     /************************************************************************
  240.      *  Method:
  241.      *      IHXVideoSurface::BeginOptimizedBlt
  242.      *  Purpose:
  243.      *      Called by renderer to commit to a bitmap format for all future
  244.      *      OptimizedBlt calls.
  245.      */
  246.     STDMETHOD(BeginOptimizedBlt)(THIS_
  247.                 HXBitmapInfoHeader*    /*IN*/  pBitmapInfo) PURE;
  249.     /************************************************************************
  250.      *  Method:
  251.      *      IHXVideoSurface::OptimizedBlt
  252.      *  Purpose:
  253.      *      Called by renderer to draw to the video surface, in the format
  254.      *      previously specified by calling BeginOptimizedBlt.
  255.      */
  256.     STDMETHOD(OptimizedBlt) (THIS_
  257.                 UCHAR*          /*IN*/  pImageBits,
  258.                 REF(HXxRect)        /*IN*/  rDestRect,
  259.                 REF(HXxRect)        /*IN*/  rSrcRect) PURE;
  261.     /************************************************************************
  262.      *  Method:
  263.      *      IHXVideoSurface::EndOptimizedBlt
  264.      *  Purpose:
  265.      *      Called by renderer allow the video surface to cleanup after all
  266.      *      OptimizedBlt calls have been made.
  267.      */
  268.     STDMETHOD(EndOptimizedBlt)  (THIS) PURE;
  270.     /************************************************************************
  271.      *  Method:
  272.      *      IHXVideoSurface::GetOptimizedFormat
  273.      *  Purpose:
  274.      *      Called by the client to find out what compression type the
  275.      *      renderer committed to when it called BeginOptimizedBlt.
  276.      */
  277.     STDMETHOD(GetOptimizedFormat)(THIS_
  278.                 REF(HX_COMPRESSION_TYPE) /*OUT*/ ulType) PURE;
  280.     /************************************************************************
  281.      *  Method:
  282.      *      IHXVideoSurface::GetPreferredFormat
  283.      *  Purpose:
  284.      *      Called by renderer to find out what compression type the video
  285.      *      surface would prefer to be given in BeginOptimizedBlt.
  286.      */
  287.     STDMETHOD(GetPreferredFormat)(THIS_
  288.                 REF(HX_COMPRESSION_TYPE) /*OUT*/ ulType) PURE;
  289. };
  291. /****************************************************************************
  292.  *
  293.  *  Interface:
  294.  *
  295.  *  IHXVideoHook
  296.  *
  297.  *  Purpose:
  298.  *
  299.  *  Interface for IHXVideoHook objects.
  300.  *
  301.  *  IID_IHXVideoHook:
  302.  *
  303.  *  {00002202-0901-11d1-8B06-00A024406D59}
  304.  *
  305.  */
  307. DEFINE_GUID(IID_IHXVideoHook, 0x00002202, 0x901, 0x11d1, 0x8b,
  308.     0x6, 0x0, 0xa0, 0x24, 0x40, 0x6d, 0x59);
  310. #undef INTERFACE
  311. #define INTERFACE   IHXVideoHook
  313. DECLARE_INTERFACE_(IHXVideoHook, IUnknown)
  314. {
  315.     /*
  316.      * IUnknown methods
  317.      */
  318.     STDMETHOD(QueryInterface) (THIS_
  319.  REFIID riid,
  320.  void** ppvObj) PURE;
  322.     STDMETHOD_(ULONG32,AddRef) (THIS) PURE;
  324.     STDMETHOD_(ULONG32,Release) (THIS) PURE;
  326.     /***
  327.      * IHXVideoHook::OnVideoFrame
  328.      ***
  329.      * This method will be called from the drawing thread, with the current
  330.      * frame, right before the frame is blitted to the screen. All 3rd party
  331.      * calculations that occur here are delaying the timely delivery of the 
  332.      * frame to the screen. They should be as optimized as possible.  pInFrame
  333.      * is the input frame buffer pOutFrame should be set to contain the output
  334.      * data on return, and destRect is provided so that the 3rd party can make
  335.      * sense of mouse events, but cannot be changed and does not have any
  336.      * direct bearing on image size.  srcRect is provided for inspection only
  337.      * for compatibility with the possible future addition of unfixed size
  338.      * input frames.  The client is responcible for maintaining and freeing
  339.      * the memory which they return in pOutFrame.  Simply setting pOutFrame to
  340.      * pInFrame is acceptable for in-place modifications as a result since it
  341.      * will still only be freed the requisite one time.
  342.      ***/
  344.     STDMETHOD(OnVideoFrame) (THIS_
  345.  UCHAR* /* In */ pInFrame,
  346.                                  ULONG32 /* In */ ulTimeStamp,
  347.  REF(HXxRect) /* In */ srcRect,
  348.  REF(HXxRect) /* In */ destRect,
  349.  REF(UCHAR*) /* Out */ pOutFrame) PURE;
  351.     /***
  352.      * IHXVideoHook::HandleHookEvent
  353.      ***
  354.      * This method provides a quick pass through by which events received by 
  355.      * the IHXVideoHookSink, such as mouse clicks, can be handed on to 
  356.      * registered IHXVideoHook objects.  Hook objects can use or ignore this
  357.      * information but setting the handled member of the passed HXxEvent is 
  358.      * not allowed.
  359.      ***/
  360.     
  361.     STDMETHOD(HandleHookEvent) (THIS_
  362.  HXxEvent* pEvent) PURE;
  364.     /***
  365.      * IHXVideoHook::GetProperties
  366.      ***
  367.      * This method provides a way for holders of an IHXVideoHook object to 
  368.      * query it for descriptive information.  Suggested property bindings are:
  369.      *  "Description" - CString describing plugin functionality.
  370.      *    "Copyright" - CString copyright notice.
  371.      *     "MoreInfo" - CString URL for obtaining more info.
  372.      *     "Version" - ULONG32 version number.
  373.      *  "InputFormat" - IHXBuffer containing input HXBitmapInfoHeader
  374.      *                  flattened as UCHAR array.
  375.      * "OutputFormat" - IHXBuffer containing output HXBitmapInfoHeader 
  376.      *                  flattened as UCHAR array.
  377.      * Others can obviously be included for specific hook-hook 
  378.      * communications, and more may also be required.
  379.      ***/
  380.     
  381.     STDMETHOD(GetProperties) (THIS_
  382.  REF(IHXValues*)   /* Out */ properties) PURE;
  384.     /***
  385.      * IHXVideoHook::HookAddedNotification
  386.      ***
  387.      * This method is called by the IHXVideoHookSink for all of its 
  388.      * registered hooks whenever it registers another.  This allows 
  389.      * registered hooks to redo their checking of the other hooks whenever
  390.      * new ones enter the loop.
  391.      ***/
  393.     STDMETHOD(HookAddedNotification) (THIS_
  394.  IHXVideoHook* pNewHook) PURE;
  395. };
  397. /****************************************************************************
  398.  *
  399.  *  Interface:
  400.  *
  401.  *  IHXVideoHookSink
  402.  *
  403.  *  Purpose:
  404.  *
  405.  *  Interface for IHXVideoHookSink objects.
  406.  *
  407.  *  IID_IHXVideoHookSink:
  408.  *
  409.  *  {00002201-0901-11d1-8B06-00A024406D59}
  410.  *
  411.  */
  413. DEFINE_GUID(IID_IHXVideoHookSink, 0x00002201, 0x901, 0x11d1, 0x8b,
  414.     0x6, 0x0, 0xa0, 0x24, 0x40, 0x6d, 0x59);
  416. #undef INTERFACE
  417. #define INTERFACE   IHXVideoHookSink
  419. DECLARE_INTERFACE_(IHXVideoHookSink, IUnknown)
  420. {
  421.     /*
  422.      * IUnknown methods
  423.      */
  424.     STDMETHOD(QueryInterface) (THIS_
  425.  REFIID riid,
  426.  void** ppvObj) PURE;
  428.     STDMETHOD_(ULONG32,AddRef) (THIS) PURE;
  430.     STDMETHOD_(ULONG32,Release) (THIS) PURE;
  432.     /***
  433.      * IHXVideoHookSink::AddVideoHook
  434.      ***
  435.      * This method is called by an IHXVideoHook object which wishes to 
  436.      * connect to the receiving IHXVideoHookSink object to obtain video 
  437.      * frames immediately prior to blitting.  pHook is the object requesting 
  438.      * registry, and pOptions is an IHXValues object containing optional
  439.      * special flags affecting behavior. pFrameFormat should point to a
  440.      * pre-allocated HXBitmapInfoHeader struct which on exit is filled in
  441.      * with the bitmap format in which frame data will be supplied to 
  442.      * OnVideoFrame() and to which it will be expected to conform on exit of
  443.      * OnVideoFrame().  If this format is inappropriate for input or output
  444.      * formats, then after registration the IHXVideoHook object should use
  445.      * the IHXVideoHookSink object's  SetInputFormat() and/or
  446.      * SetOutputFormat() methods to arrive at a mutually acceptable exchange
  447.      * format, or to determine that none is available and take appropriate
  448.      * action.
  449.      ***
  450.      * pOptions:
  451.      * "ReceivesEvents" - 0:No, !0:Yes
  452.      * "ReceivesHookAdded" - 0:No, !0:Yes
  453.      * "ReceivesFrames" - 0:No, !0:Yes
  454.      * "TakesAnySize" - 0:No, !0:Yes
  455.      ***/
  457.     STDMETHOD(AddVideoHook) (THIS_
  458.      IHXVideoHook*     /* In */    pHook,
  459.      IHXValues*     /* I/O */   pOptions,
  460.      HXBitmapInfoHeader*   /* Out */   pFrameFormat) PURE;
  462.     /***
  463.      * IHXVideoHookSink::ForceSurfaceUpdate
  464.      ***
  465.      * This method provides a mechanism by which event-driven IHXVideoHook 
  466.      * objects can request that they be given a new image if the mouse is
  467.      * clicked (for example).  The entire frame is "damaged" so that 
  468.      * everything will be redrawn.
  469.      ***/
  471.     STDMETHOD(ForceSurfaceUpdate) (THIS) PURE;
  473.     /***
  474.      * IHXVideoHookSink::SetInputFormat
  475.      * IHXVideoHookSink::SetOutputFormat
  476.      ***
  477.      * These methods provide a way for the IHXVideoHookSink to negotiate 
  478.      * with its registered IHXVideoHook objects about what image formats 
  479.      * they require or return respectively.  pHook is the hook object
  480.      * which is requesting a change in format, pRequested points to an 
  481.      * HXBitmapInfoHeader describing the format which the hook wants (either
  482.      * to receive or return).
  483.      * This method returns HXR_FAIL and does not change formats, unless
  484.      * pRequested matches an acceptable format exactly, that format is
  485.      * registered for future frame transactions, and HXR_OK is returned.
  486.      * Should be called immediately after registration.
  487.      ***/
  489.     STDMETHOD(SetInputFormat) (THIS_
  490.  IHXVideoHook* pHook,
  491.  HXBitmapInfoHeader* pRequested) PURE;
  493.     STDMETHOD(SetOutputFormat) (THIS_
  494.  IHXVideoHook* pHook,
  495.  HXBitmapInfoHeader* pRequested) PURE;
  497.     /***
  498.      * IHXVideoHookSink::GetVideoHookCount
  499.      ***
  500.      * This method returns the number of IHXVideoHook objects registered 
  501.      * with this IHXVideoHookSink.  This value is only useful in the short 
  502.      * term as order and count may change for IHXVideoHook objects without
  503.      * notice.  Do not use it to store access to a given hook.
  504.      ***/
  506.     STDMETHOD_(UINT16,GetVideoHookCount) (THIS) PURE;
  508.     /***
  509.      * IHXVideoHookSink::GetVideoHook
  510.      ***
  511.      * This method provides access to registered IHXVideoHook objects by 
  512.      * index with valid indecies ranging from 0 to n-1 inclusive, where n
  513.      * is the value returned by GetVideoHookCount(), provided no sources
  514.      * have been added or removed since it was last called.
  515.      ***/
  517.     STDMETHOD(GetVideoHook) (THIS_
  518.  UINT16  nIndex,
  519.  REF(IUnknown*) pUnknown) PURE;
  520. };
  522. // $Private:
  524. /****************************************************************************
  525.  *
  526.  *  Interface:
  527.  *
  528.  *  IHXRenderTimeLine
  529.  *
  530.  *  Purpose:
  531.  *
  532.  *  Provide IHXVideoSurface2 a time line for scheduling its video frames
  533.  *
  534.  *  IID_IHXRenderTimeLine:
  535.  *
  536.  *  {00002204-0901-11d1-8B06-00A024406D59}
  537.  *
  538.  */
  540. DEFINE_GUID(IID_IHXRenderTimeLine, 0x00002204, 0x901, 0x11d1, 0x8b,
  541.     0x6, 0x0, 0xa0, 0x24, 0x40, 0x6d, 0x59);
  542.  
  543. #undef  INTERFACE
  544. #define INTERFACE   IHXRenderTimeLine
  546. DECLARE_INTERFACE_(IHXRenderTimeLine, IUnknown)
  547. {
  548.     /*
  549.      * IUnknown methods
  550.      */
  551.     STDMETHOD(QueryInterface)   (THIS_
  552.                 REFIID riid,
  553.                 void** ppvObj) PURE;
  554.  
  555.     STDMETHOD_(ULONG32,AddRef)  (THIS) PURE;
  556.  
  557.     STDMETHOD_(ULONG32,Release) (THIS) PURE;
  558.  
  559.  
  560.     /************************************************************************
  561.      *  Method:
  562.      *      IHXRenderTimeLine::GetTimeLineValue
  563.      *  Purpose:
  564.      *      Get the current presentation time
  565.      *
  566.      *  Notes:
  567.      *      returns HXR_TIMELINE_SUSPENDED when the time line is suspended
  568.      */
  569.     STDMETHOD (GetTimeLineValue) (THIS_ /*OUT*/ REF(UINT32) ulTime) PURE;
  571. };
  573. /****************************************************************************
  574.  *
  575.  *  Interface:
  576.  *
  577.  *  IHXVideoSurface2
  578.  *
  579.  *  Purpose:
  580.  *
  581.  *  Provides hardware video buffers to render plugins
  582.  *
  583.  *  IID_IHXVideoSurface2:
  584.  *
  585.  *  {00002203-0901-11d1-8B06-00A024406D59}
  586.  *
  587.  */
  589. DEFINE_GUID(IID_IHXVideoSurface2, 0x00002203, 0x901, 0x11d1, 0x8b,
  590.     0x6, 0x0, 0xa0, 0x24, 0x40, 0x6d, 0x59);
  591.  
  592. #undef  INTERFACE
  593. #define INTERFACE   IHXVideoSurface2
  595. DECLARE_INTERFACE_(IHXVideoSurface2, IUnknown)
  596. {
  597.     /*
  598.      * IUnknown methods
  599.      */
  600.     STDMETHOD(QueryInterface)   (THIS_
  601.                 REFIID riid,
  602.                 void** ppvObj) PURE;
  603.  
  604.     STDMETHOD_(ULONG32,AddRef)  (THIS) PURE;
  605.  
  606.     STDMETHOD_(ULONG32,Release) (THIS) PURE;
  607.  
  608.  
  609.     /************************************************************************
  610.      *  Method:
  611.      *      IHXVideoSurface2::SetProperties
  612.      *  Purpose:
  613.      *      Request ulNumBuffers hardware buffers of the format described
  614.      *      in bmi.  ulNumBuffers will contain the number of buffers actually
  615.      *      allocated.
  616.      *      pClock is the renderer's clock used for scheduling the video
  617.      *      frames received in the Present call.  A NULL clock causes Present
  618.      *      to ignore the timestamp and display synchronously.
  619.      */
  620.     STDMETHOD (SetProperties) (THIS_ /*IN/OUT*/ HXBitmapInfoHeader* bmi,
  621.                                      /*IN/OUT*/ REF(UINT32) ulNumBuffers,
  622.                                      /*IN*/     IHXRenderTimeLine* pClock) PURE;
  625.     /************************************************************************
  626.      *  Method:
  627.      *      IHXVideoSurface2::GetVideoMem
  628.      *  Purpose:
  629.      *      Requests the next available hardware video buffer.
  630.      *      If the presentation contains alpha blending, the blended regions
  631.      *      of the will be requested via VideoMemStruct.pAlphaList.  Fill
  632.      *      each AlphaStruct with the subrect of the video frame specified
  633.      *      by AlphaStruct.rcImageRect.  IHXVideoSurface2 will then alpha
  634.      *      blend the video with the presentation.
  635.      *     
  636.      *      This call blocks until a video buffer is available.  bmi 
  637.      *      describes the buffer returned.
  638.      *
  639.      *  Notes:
  640.      *      The buffer format can change with each call so bmi must be
  641.      *      checked everytime.
  642.      */
  643.     STDMETHOD (GetVideoMem) (THIS_ VideoMemStruct* /*IN/OUT*/ pVidMem,
  644.                                    UINT32 ulFlags) PURE;
  647.     /************************************************************************
  648.      *  Method:
  649.      *      IHXVideoSurface2::ReleaseVideoMem
  650.      *  Purpose:
  651.      *      Called on a buffer returned from GetVideoMem to discard the
  652.      *      buffer without displaying it.
  653.      */
  654.     STDMETHOD (ReleaseVideoMem) (THIS_ VideoMemStruct* pVidMem) PURE;
  656.     /************************************************************************
  657.      *  Method:
  658.      *      IHXVideoSurface2::Present
  659.      *  Purpose:
  660.      *      Called by renderer to put a video image on the screen at absoulte
  661.      *      time lTime.  prDestRect and prSrcRect are relative coordinates.
  662.      *      prSrcRect with all zeros defaults to the entire surface dimensions
  663.      *      and prDestRect with all zeros defaults to the entire client widnow.
  664.      *
  665.      *  Notes:
  666.      *      This is an asynchronous method.
  667.      */
  668.     STDMETHOD (Present) (THIS_
  669.                          VideoMemStruct* pVidMem,
  670.                          INT32 lTime,
  671.                          UINT32 ulFlags,
  672.                          HXxRect *prDestRect,
  673.                          HXxRect *prSrcRect) PURE;
  675.     /************************************************************************
  676.      *  Method:
  677.      *      IHXVideoSurface2::ColorConvert
  678.      *  Purpose:
  679.      *      Called by renderer to transform one video format to another.
  680.      *      It is optimized for writing to hardware memory.
  681.      */
  682.     STDMETHOD (ColorConvert) (THIS_
  683.                               INT32 fourCCIn, 
  684.                               HXxSize *pSrcSize,
  685.                               HXxRect *prSrcRect,
  686.                               SourceInputStruct *pInput,
  687.                               INT32 fourCCOut,
  688.                               UCHAR *pDestBuffer, 
  689.                               HXxSize *pDestSize, 
  690.                               HXxRect *prDestRect, 
  691.                               int nDestPitch) PURE;
  693.     
  694.     /************************************************************************
  695.      *  Method:
  696.      *      IHXVideoSurface2::Flush
  697.      *  Purpose:
  698.      *      Cancel any pending Present calls.
  699.      */
  700.     STDMETHOD_(void, Flush)(THIS) PURE;
  702.     /************************************************************************
  703.      *  Method:
  704.      *      IHXVideoSurface2::PresentIfReady
  705.      *  Purpose:
  706.      *      Optional method called by renderer to check the status of the
  707.      *      next Present. If will display the next image if it is time.  This
  708.      *      method assists the scheduler that is not getting its time slices
  709.      *      due to OS latency, non-cooperative multi-tasking, or any other
  710.      *      reason.
  711.      */
  712.     STDMETHOD (PresentIfReady) (THIS) PURE;
  713. };
  714. // $EndPrivate.
  716. // $Private:
  718. /****************************************************************************
  719.  *
  720.  *  Interface:
  721.  *
  722.  *  IHXSubRectVideoSurface
  723.  *
  724.  *  Purpose:
  725.  *
  726.  *  Interface for IHXSubRectVideoSurface objects.
  727.  *
  728.  *  IID_IHXSubRectVideoSurface:
  729.  *
  730.  *  {00002205-0901-11d1-8B06-00A024406D59}
  731.  *
  732.  */
  734. DEFINE_GUID(IID_IHXSubRectVideoSurface, 0x00002205, 0x901, 0x11d1, 0x8b,
  735.     0x6, 0x0, 0xa0, 0x24, 0x40, 0x6d, 0x59);
  737. #undef  INTERFACE
  738. #define INTERFACE   IHXSubRectVideoSurface
  740. DECLARE_INTERFACE_(IHXSubRectVideoSurface, IHXVideoSurface)
  741. {
  742.     STDMETHOD(BltSubRects)( THIS_
  743.                             UCHAR*               /*IN*/  pImageBits,
  744.                             HXBitmapInfoHeader* /*IN*/  pBitmapInfo,
  745.                             HXxBoxRegion*          /*IN*/  pDestRects,
  746.                             HXxBoxRegion*          /*IN*/  pSrcRects,
  747.                             float                        fScaleFactorX,
  748.                             float                        fScaleFactorY
  749.                             ) PURE;
  750. };
  751. // $EndPrivate.
  754. #endif /* _HXVSURF_H_ */