rasipr.cpp
上传用户:dangjiwu
上传日期:2013-07-19
资源大小:42019k
文件大小:8k
源码类别:

Symbian

开发平台:

Visual 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 "hxcom.h"
  36. #include "hxtypes.h"
  37. #ifdef _WINDOWS
  38. #include <windows.h>
  39. #endif
  40. #include "hxresult.h"
  41. #include "racodec.h"
  42. #include "hxacodec.h"
  43. #include "wrapsipr2.h"
  44. /*
  45.  *  PROTOTYPES
  46.  */
  47. #ifdef _MACINTOSH
  48. #ifndef _MAC_MACHO
  49. extern "C"
  50. {
  51.     // Default routines
  52.     OSErr __initialize (CFragInitBlockPtr pInitBlock);
  53.     void __terminate(void);
  54.     
  55.     // Our routines
  56.     OSErr InitEntryPoint (CFragInitBlockPtr pInitBlock);
  57.     void TermEntryPoint(void);
  58. }
  59. #endif
  60. #endif
  61. /*
  62.  *  GLOBALS
  63.  */
  64. /*
  65.  *  FUNCTIONS
  66.  */
  67. #ifdef _WIN32
  68. #if !defined(_STATICALLY_LINKED)
  69. #ifndef _WINCE
  70. BOOL WINAPI DllMain (HINSTANCE hDLL, DWORD dwReason, LPVOID lpReserved)
  71. #else
  72. BOOL WINAPI DllMain (HANDLE hDLL, DWORD dwReason, LPVOID lpReserved)
  73. #endif
  74. {
  75.     return TRUE;
  76. }
  77. #endif /* #if !defined(_STATICALLY_LINKED) */
  78. #endif //_WIN32
  79. #ifdef _WIN16
  80. int CALLBACK LibMain (HINSTANCE hinst, WORD wDataSeg, WORD cbHeap, LPSTR lpszCmdLine)
  81. {
  82.     return TRUE;
  83. }
  84. int CALLBACK _WEP (int I)
  85. {
  86.     return TRUE;
  87. }
  88. #endif //_WIN16
  89. #ifdef _MACINTOSH
  90. #ifndef _MAC_MACHO
  91. OSErr InitEntryPoint (CFragInitBlockPtr pInitBlock)
  92. {
  93.     OSErr result = noErr;
  94.     
  95.     result = __initialize (pInitBlock);
  96.     
  97. //    HoldLibraryInMemory();
  98.     
  99.     return result;
  100. }
  101. void TermEntryPoint (void)
  102. {
  103.     __terminate();
  104.     
  105. //    UnholdLibraryInMemory();
  106. }
  107. #endif
  108. #endif
  109. /*
  110.  * NEW COOKIE API
  111.  */
  112. // preview compatibility only - obsolete
  113. HX_RESULT HXEXPORT ENTRYPOINT(RAOpenCodec) (RACODEC* pCodecRef)
  114. {
  115.     CSiproCodec*    thisCodec = new CSiproCodec;
  116.     if (pCodecRef)
  117. *pCodecRef = (RACODEC) thisCodec;
  118.     return HXR_OK;
  119. }
  120. HX_RESULT HXEXPORT ENTRYPOINT(RAOpenCodec2) (RACODEC* pCodecRef, const char* pCodecPath)
  121. {
  122.     // Note: The codec path is now obtained from this library's global
  123.     // DLLAccess object, which is set in the SetDLLAccessPaths() exported
  124.     // function. The loader of this library should have already called the
  125.     // SetDLLAccessPaths() function to set the codec path. -DPS
  126.     CSiproCodec*    thisCodec = new CSiproCodec;
  127.     if (pCodecRef)
  128. *pCodecRef = (RACODEC) thisCodec;
  129.     return HXR_OK;
  130. }
  131. HX_RESULT HXEXPORT ENTRYPOINT(RACloseCodec) (RACODEC codecRef)
  132. {
  133.     delete (CSiproCodec*)codecRef;
  134.     return HXR_OK;
  135. }
  136. // Older SDK uses *this* function to determine the number of codec flavors.
  137. // However, if this function returns more than 4 (the original number of
  138. // Sipro flavors), that SDK will fail...
  139. UINT16 HXEXPORT ENTRYPOINT(RAGetNumberOfFlavors) (RACODEC codecRef)
  140. {
  141.     UINT16 retVal = 0;
  142.     if (codecRef)
  143.     {
  144.         retVal = ((CSiproCodec*)codecRef)->mGetNumberOfFlavors();
  145.     }
  146.     
  147.     return retVal;
  148. }
  149. // This is the *new* function that will return the true number of supported
  150. // Sipro flavors.  The Build Engine will check for the existence of this
  151. // function, and use its result.  If this function does not exist it will
  152. // query the function above (RAGetNumberOfFlavors)
  153. // -Gregc 
  154. // It is currently commented out since no new flavors have been added to
  155. // Sipro since G2 Gold. If new flavor is added, un-comment this and
  156. // export the function.
  157. //UINT16 HXEXPORT ENTRYPOINT(RAGetNumberOfFlavors2) (RACODEC codecRef)
  158. //{
  159. //   UINT16 retVal = 0;
  160. //
  161. //    if (codecRef)
  162. //    {
  163. //        retVal = ((CSiproCodec*)codecRef)->mGetNumberOfFlavors2();
  164. //    }
  165. //    
  166. //    return retVal;
  167. //}
  168. void * HXEXPORT ENTRYPOINT(RAGetFlavorProperty)(RACODEC codecRef, UINT16 flvIndex, UINT16 Property, UINT16 * pSize)
  169. {
  170.     void* pRet = NULL;
  171.     
  172.     if (codecRef)
  173.     {
  174.         return ((CSiproCodec*)codecRef)->mGetFlavorProperty(flvIndex, Property, pSize);
  175.     }
  176.     
  177.     return pRet;
  178. }
  179. HX_RESULT HXEXPORT ENTRYPOINT(RASetFlavor) (RACODEC codecRef, UINT16 flvIndex)
  180. {
  181.     if (codecRef)
  182. return ((CSiproCodec*)codecRef)->mSetFlavor(flvIndex);
  183.     else
  184. return HXR_INVALID_PARAMETER;
  185. }
  186. void HXEXPORT ENTRYPOINT(RASetPwd) (RACODEC codecRef, const char *pPwd)
  187. {
  188.     if (codecRef)
  189. ((CSiproCodec*)codecRef)->mSetPassword(pPwd);
  190. }
  191. #ifdef _DECODER
  192. HX_RESULT HXEXPORT ENTRYPOINT(RAInitDecoder) (RACODEC codecRef, void* pParam)
  193. {
  194.     return ((CSiproCodec*)codecRef)->mInitDecoder();
  195. }
  196. HX_RESULT HXEXPORT ENTRYPOINT(RADecode) (RACODEC codecRef, Byte* in, UINT32 inLength, Byte* out, UINT32 *pOutLength, UINT32 UserData)
  197. {
  198.     return ((CSiproCodec*)codecRef)->mDecode(in, inLength, out, pOutLength, UserData);
  199. }
  200. HX_RESULT HXEXPORT ENTRYPOINT(RAFlush) (RACODEC codecRef, Byte* outBuf, UINT32* pOutLength)
  201. {
  202.     // Re-initialize codec instead of skipping interpolation
  203.     // because Alan is afraid of the filter going unstable.
  204.     ((CSiproCodec*)codecRef)->mInitDecoder();
  205.     if (pOutLength)
  206. *pOutLength = 0;
  207.     return HXR_OK;
  208. }
  209. void HXEXPORT ENTRYPOINT(RAFreeDecoder) (RACODEC codecRef)
  210. {
  211.     ((CSiproCodec*)codecRef)->mFreeDecoder();
  212. }
  213. #endif // _DECODER
  214. #ifdef _ENCODER
  215. HX_RESULT HXEXPORT ENTRYPOINT(RAInitEncoder) (RACODEC codecRef, void* pParams)
  216. {
  217.     if( NULL == pParams )
  218.     {
  219. return HXR_INVALID_PARAMETER;
  220.     }
  221.     RAENCODER_INIT_PARAMS* pInitParams = (RAENCODER_INIT_PARAMS*)pParams;
  222.     return ((CSiproCodec*)codecRef)->mInitEncoder(
  223. pInitParams->sampleRate, 
  224. pInitParams->bitsPerSample, 
  225. &(pInitParams->numSamplesIn), 
  226. &(pInitParams->numBytesOut) );
  227. }
  228. void HXEXPORT ENTRYPOINT(RAEncode) (RACODEC codecRef, UINT16* inBuf, Byte* outBuf)
  229. {
  230.     ((CSiproCodec*)codecRef)->mEncode((short*)inBuf, outBuf);
  231. }
  232. void HXEXPORT ENTRYPOINT(RAFreeEncoder) (RACODEC codecRef)
  233. {
  234.     ((CSiproCodec*)codecRef)->mFreeEncoder();
  235. }
  236. #if !defined(_STATICALLY_LINKED)
  237. int RAHaveSetPassword(void)
  238. {
  239. return 1 ; // yes we do
  240. }
  241. #endif
  242. #endif // _ENCODER
  243. HX_RESULT HXEXPORT ENTRYPOINT(RAGetGUID) (UCHAR* pGUID)
  244. {
  245.     return CSiproCodec::mGetGUID(pGUID);
  246. }
  247. HX_RESULT HXEXPORT ENTRYPOINT(RAGetDecoderBackendGUID) (RACODEC codecRef, UCHAR* pGUID)
  248. {
  249.     // look mom, no backend!
  250.     return HXR_NOTIMPL ;
  251. }
  252. HX_RESULT HXEXPORT ENTRYPOINT(RAGetBackend) (RACODEC codecRef, void*** pFuncList)
  253. {
  254.     return HXR_NOTIMPL ;
  255. }
  256. HX_RESULT HXEXPORT ENTRYPOINT(RASetComMode) (RACODEC codecRef)
  257. {
  258.   if (codecRef)
  259.   {
  260.     return ((CSiproCodec*)codecRef)->mSetComMode();
  261.   }
  262.   return HXR_FAIL;
  263. }
  264. #if defined(_ENCODER) && !defined(_STATICALLY_LINKED)
  265. /*
  266.  * RACreateEncoderInstance lives in a static library. If no
  267.  * module references RACreateEncoderInstance, it won't get
  268.  * linked in on Unix.
  269.  * To make sure that RACreateEncoderInstance gets linked against
  270.  * we make it an unresolved symbol in this module.
  271.  */
  272. static FPRACreateEncoderInstance temp = RACreateEncoderInstance ;
  273. #endif /* !defined(_STATICALLY_LINKED) */