vidplin.cpp
上传用户:zhongxx05
上传日期:2007-06-06
资源大小:33641k
文件大小:8k
源码类别:

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. #if defined _UNIX
  36. int some_friggin_ctor_dtor_ism_vidplin_cpp_smp_aak_pm_don_pg_jp = 0;
  37. #endif
  38. #include "hxtypes.h"
  39. #include "hxcom.h"
  40. #ifdef HELIX_FEATURE_VIDEO_REAL
  41. #include "rvxvideo.h"
  42. #endif // HELIX_FEATURE_VIDEO_REAL
  43. #ifdef HELIX_FEATURE_VIDEO_MPEG4
  44. #include "mp4video.h"
  45. #endif // HELIX_FEATURE_VIDEO_MPEG4
  46. #ifdef HELIX_FEATURE_VIDEO_H263
  47. #include "h263video.h"
  48. #endif // HELIX_FEATURE_VIDEO_H263
  49. #include "vidplin.h"
  50. HX_RESULT (STDAPICALLTYPE* const VideoPluginFactory::m_fpEntryArray[])(IUnknown**)={
  51. #ifdef HELIX_FEATURE_VIDEO_REAL
  52.     CRVXVideoRenderer::HXCreateInstance,
  53. #endif // HELIX_FEATURE_VIDEO_REAL
  54. #ifdef HELIX_FEATURE_VIDEO_MPEG4
  55.     CMP4VideoRenderer::HXCreateInstance,
  56. #endif // HELIX_FEATURE_VIDEO_MPEG4
  57. #ifdef HELIX_FEATURE_VIDEO_H263
  58.     CH263VideoRenderer::HXCreateInstance,
  59. #endif // HELIX_FEATURE_VIDEO_H263
  60.     0};
  61. HX_RESULT (STDAPICALLTYPE* const VideoPluginFactory::m_fpExitArray[])()={0};
  62. HX_RESULT (STDAPICALLTYPE* const VideoPluginFactory::m_fpUnloadArray[])()={
  63. #ifdef HELIX_FEATURE_VIDEO_REAL
  64.     CRVXVideoRenderer::CanUnload,
  65. #endif // HELIX_FEATURE_VIDEO_REAL
  66. #ifdef HELIX_FEATURE_VIDEO_MPEG4
  67.     CMP4VideoRenderer::CanUnload,
  68. #endif // HELIX_FEATURE_VIDEO_MPEG4
  69. #ifdef HELIX_FEATURE_VIDEO_H263
  70.     CH263VideoRenderer::CanUnload,
  71. #endif // HELIX_FEATURE_VIDEO_H263
  72.     0};
  73. HX_RESULT (STDAPICALLTYPE* const VideoPluginFactory::m_fpUnloadArray2[])()={
  74. #ifdef HELIX_FEATURE_VIDEO_REAL
  75.     CRVXVideoRenderer::CanUnload2,
  76. #endif // HELIX_FEATURE_VIDEO_REAL
  77. #ifdef HELIX_FEATURE_VIDEO_MPEG4
  78.     CMP4VideoRenderer::CanUnload2,
  79. #endif // HELIX_FEATURE_VIDEO_MPEG4
  80. #ifdef HELIX_FEATURE_VIDEO_H263
  81.     CH263VideoRenderer::CanUnload2,
  82. #endif // HELIX_FEATURE_VIDEO_H263
  83.     0};
  84. /****************************************************************************
  85.  *
  86.  *  Function:
  87.  *
  88.  *  HXCreateInstance()
  89.  *
  90.  *  Purpose:
  91.  *
  92.  *  Function implemented by all plugin DLL's to create an instance of
  93.  *  any of the objects supported by the DLL. This method is similar to
  94.  *  Window's CoCreateInstance() in its purpose, except that it only
  95.  *  creates objects from this plugin DLL.
  96.  *
  97.  *  NOTE: Aggregation is never used. Therefore and outer unknown is
  98.  *  not passed to this function, and you do not need to code for this
  99.  *  situation.
  100.  *
  101.  */
  102. STDAPI HXCreateInstance
  103. (
  104.     IUnknown**  /*OUT*/ ppIUnknown
  105. )
  106. {
  107.     *ppIUnknown = (IUnknown*)(IHXPlugin*)new VideoPluginFactory();
  108.     if (*ppIUnknown)
  109.     {
  110. (*ppIUnknown)->AddRef();
  111. return HXR_OK;
  112.     }
  113.     return HXR_OUTOFMEMORY;
  114. }
  115. /****************************************************************************
  116.  *
  117.  *  Function:
  118.  *
  119.  *  HXShutdown()
  120.  *
  121.  *  Purpose:
  122.  *
  123.  *  Function implemented by all plugin DLL's to free any *global*
  124.  *  resources. This method is called just before the DLL is unloaded.
  125.  *
  126.  */
  127. STDAPI HXShutdown()
  128. {
  129.     HX_RESULT (STDAPICALLTYPE * const *itterator)(void) = &(VideoPluginFactory::m_fpExitArray[0]);
  130.     while(*itterator)
  131.     {
  132. (*itterator++)();
  133.     }
  134.     return HXR_OK;
  135. }
  136. /****************************************************************************
  137.  *
  138.  *  Function:
  139.  *
  140.  *  CanUnload()
  141.  *
  142.  *  Purpose:
  143.  *
  144.  *  Function implemented by all plugin DLL's if it returns HXR_OK
  145.  *  then the pluginhandler can unload the DLL
  146.  *
  147.  */
  148. STDAPI ENTRYPOINT(CanUnload2)(void)
  149. {
  150.     for( int i=0; VideoPluginFactory::m_fpUnloadArray2[i]; i++ )
  151.     {
  152.         if( (VideoPluginFactory::m_fpUnloadArray2[i])() != HXR_OK )
  153.         {
  154.             return HXR_FAIL;
  155.         }
  156.     }
  157.     return HXR_OK;
  158. }
  159. STDAPI ENTRYPOINT(CanUnload)(void)
  160. {
  161.     return ENTRYPOINT(CanUnload2)();
  162. }
  163. /////////////////////////////////////////////////////////////////////////
  164. //  Method:
  165. //      VideoPluginFactory
  166. //  Purpose:
  167. //      Constructor. Counts the number of functions within the
  168. //      Entry Array. Would have liked to use:
  169. //      return (sizeof(m_fpEntryArray)/sizeof(m_fpEntryArray[0]))-1;
  170. //      But for some strange reason the complier spits at it...
  171. //
  172. VideoPluginFactory::VideoPluginFactory()
  173. {
  174.     m_lRefCount = 0;
  175.     for(m_usNumOfPlugins = 0;
  176. m_fpEntryArray[m_usNumOfPlugins];
  177. m_usNumOfPlugins++) {};
  178. }
  179. /////////////////////////////////////////////////////////////////////////
  180. //  Method:
  181. //  IUnknown::QueryInterface
  182. //  Purpose:
  183. //  Implement this to export the interfaces supported by your
  184. //  object.
  185. //
  186. STDMETHODIMP VideoPluginFactory::QueryInterface(REFIID riid, void** ppvObj)
  187. {
  188.     if (IsEqualIID(riid, IID_IUnknown))
  189.     {
  190. AddRef();
  191. *ppvObj = (IUnknown *)this;
  192. return HXR_OK;
  193.     }
  194.     else if (IsEqualIID(riid, IID_IHXPluginFactory))
  195.     {
  196. AddRef();
  197. *ppvObj = (IHXPluginFactory *)this;
  198. return HXR_OK;
  199.     }
  200.     *ppvObj = NULL;
  201.     return HXR_NOINTERFACE;
  202. }
  203. /////////////////////////////////////////////////////////////////////////
  204. //  Method:
  205. //      VideoPluginFactory::AddRef
  206. //  Purpose:
  207. //      Everyone usually implements this the same... feel free to use
  208. //      this implementation.
  209. //
  210. STDMETHODIMP_(ULONG32) VideoPluginFactory::AddRef()
  211. {
  212.     return InterlockedIncrement(&m_lRefCount);
  213. }
  214. /////////////////////////////////////////////////////////////////////////
  215. //  Method:
  216. //      VideoPluginFactory::Release
  217. //  Purpose:
  218. //      Everyone usually implements this the same... feel free to use
  219. //      this implementation.
  220. //
  221. STDMETHODIMP_(ULONG32) VideoPluginFactory::Release()
  222. {
  223.     if (InterlockedDecrement(&m_lRefCount) > 0)
  224.     {
  225.         return m_lRefCount;
  226.     }
  227.     delete this;
  228.     return 0;
  229. }
  230. /////////////////////////////////////////////////////////////////////////
  231. //  Method:
  232. //      VideoPluginFactory::GetNumPlugins
  233. //  Purpose:
  234. //      Returns an int, the number of plugins in this DLL.
  235. //
  236. //
  237. STDMETHODIMP_(UINT16) VideoPluginFactory::GetNumPlugins()
  238. {
  239.     return m_usNumOfPlugins;
  240. }
  241. /////////////////////////////////////////////////////////////////////////
  242. //  Method:
  243. //      VideoPluginFactory::GetPlugin
  244. //  Purpose:
  245. //      Returns an IUnknown Reference to the specified Interface
  246. //
  247. //
  248. STDMETHODIMP VideoPluginFactory::GetPlugin(UINT16 uindex, IUnknown** pPlugin)
  249. {
  250.     if (uindex < m_usNumOfPlugins)
  251.     {
  252. return m_fpEntryArray[uindex](pPlugin);
  253.     }
  254.     *pPlugin=0;
  255.     return HXR_NOINTERFACE;
  256. }