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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > Symbian > 查看源码
hxvsurf.h
资源名称：142_61_thumb_advanced.rar　[点击查看]
上传用户：dangjiwu
上传日期：2013-07-19
资源大小：42019k
文件大小：27k
源码类别：

Symbian

开发平台：

Visual C++

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