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

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

Symbian

开发平台：

C/C++

rpfile.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 RPFILE_H
  37. #define RPFILE_H
  39. class CHXMapLongToObj;
  40. class CHXSimpleList;
  42. class PXRealPixFile : public CHXBaseCountingObject,
  43.                       public CUnknownIMP
  44. {
  45.     DECLARE_UNKNOWN(PXRealPixFile)
  46. public:
  47.     enum
  48.     {
  49.         kTimeFormatDHMS         = 0,
  50.         kTimeFormatMilliseconds = 1
  51.     };
  53.     HX_RESULT   SetTitle(const char* pszTitle);
  54.     HX_RESULT   SetTitle(IHXBuffer* pTitleStr);
  55.     HX_RESULT   GetTitle(IHXBuffer** ppTitleStr);
  57.     HX_RESULT   SetAuthor(const char* pszAuthor);
  58.     HX_RESULT   SetAuthor(IHXBuffer* pAuthorStr);
  59.     HX_RESULT   GetAuthor(IHXBuffer** ppAuthorStr);
  61.     HX_RESULT   SetCopyright(const char* pszCopyright);
  62.     HX_RESULT   SetCopyright(IHXBuffer* pCopyrightStr);
  63.     HX_RESULT   GetCopyright(IHXBuffer** ppCopyrightStr);
  65.     void        SetStart(UINT32 ulStart);
  66.     UINT32      GetStart() const;
  68.     void        SetDuration(UINT32 ulDuration);
  69.     UINT32      GetDuration() const;
  71.     void        SetPreroll(UINT32 ulPreroll);
  72.     UINT32      GetPreroll() const;
  74.     void        SetBitrate(UINT32 ulBitrate);
  75.     UINT32      GetBitrate() const;
  77.     void        SetDisplayWidth(UINT32 ulWidth);
  78.     UINT32      GetDisplayWidth() const;
  80.     void        SetDisplayHeight(UINT32 ulHeight);
  81.     UINT32      GetDisplayHeight() const;
  83.     HX_RESULT   SetTimeFormat(UINT32 ulTimeFormat);
  84.     UINT32      GetTimeFormat() const;
  86.     void        SetBackgroundColor(UINT32 ulColor); // in 0x00RRGGBB register format
  87.     void        SetBackgroundColor(BYTE ucRed, BYTE ucGreen, BYTE ucBlue);
  88.     UINT32      GetBackgroundColor() const;
  90.     void        SetBackgroundOpacity(UINT32 ulOpacity);
  91.     UINT32      GetBackgroundOpacity() const;
  93.     void        SetDefaultMaxFps(UINT32 ulMaxFps);
  94.     UINT32      GetDefaultMaxFps() const;
  96.     void        SetDefaultAspectFlag(BOOL bAspectFlag);
  97.     BOOL        GetDefaultAspectFlag() const;
  99.     void        SetDefaultCenterFlag(BOOL bCenterFlag);
  100.     BOOL        GetDefaultCenterFlag() const;
  102.     HX_RESULT   SetDefaultURL(const char* pszDefaultURL);
  103.     HX_RESULT   SetDefaultURL(IHXBuffer* pDefaultURLStr);
  104.     HX_RESULT   GetDefaultURL(IHXBuffer** ppDefaultURLStr);
  106.     void        SetContentVersion(UINT32 ulVersion);
  107.     void        SetContentVersionToAtLeast(UINT32 ulVersion);
  108.     UINT32      GetContentVersion() const;
  111.     HX_RESULT   AddImage(UINT32 ulHandle, const char* pszName);
  112.     HX_RESULT   AddImage(UINT32 ulHandle, IHXBuffer* pName);
  113.     UINT32      GetNumImages() const;
  114.     UINT32      GetNumImagesWithNoSize() const;
  115.     HX_RESULT   GetImageIterator(REF(void*) rpIterator);
  116.     HX_RESULT   GetNextImageHandle(REF(void*) rpIterator, REF(UINT32) rulHandle);
  117.     BOOL        IsImagePresent(UINT32 ulHandle);
  118.     HX_RESULT   GetImageName(UINT32 ulHandle, REF(IHXBuffer*) rpNameStr);
  119.     HX_RESULT   GetImageName(UINT32 ulHandle, REF(const char*) rpszName);
  120.     const char* GetImageName(UINT32 ulHandle);
  121.     HX_RESULT   SetImageName(UINT32 ulHandle, IHXBuffer* pNameStr);
  122.     HX_RESULT   SetImageName(UINT32 ulHandle, const char* pszName);
  123.     HX_RESULT   GetImageErrorStatus(UINT32 ulHandle, REF(HX_RESULT) rlStatus);
  124.     HX_RESULT   SetImageErrorStatus(UINT32 ulHandle, HX_RESULT lStatus);
  125.     HX_RESULT   GetImageSize(UINT32 ulHandle, REF(UINT32) rulSize);
  126.     UINT32      GetImageSize(UINT32 ulHandle);
  127.     HX_RESULT   SetImageSize(UINT32 ulHandle, UINT32 ulSize);
  128.     BOOL        IsImageSizeInitialized(UINT32 ulHandle);
  129.     HX_RESULT   GetImageFileMimeType(UINT32 ulHandle, REF(IHXBuffer*) rpMimeStr);
  130.     HX_RESULT   GetImageFileMimeType(UINT32 ulHandle, REF(const char*) rpszMime);
  131.     const char* GetImageFileMimeType(UINT32 ulHandle);
  132.     HX_RESULT   SetImageFileMimeType(UINT32 ulHandle, IHXBuffer* pMimeStr);
  133.     HX_RESULT   SetImageFileMimeType(UINT32 ulHandle, const char* pszMime);
  134.     HX_RESULT   GetImageStreamMimeType(UINT32 ulHandle, REF(IHXBuffer*) rpMimeStr);
  135.     HX_RESULT   GetImageStreamMimeType(UINT32 ulHandle, REF(const char*) rpszMime);
  136.     const char* GetImageStreamMimeType(UINT32 ulHandle);
  137.     HX_RESULT   SetImageStreamMimeType(UINT32 ulHandle, IHXBuffer* pMimeStr);
  138.     HX_RESULT   SetImageStreamMimeType(UINT32 ulHandle, const char* pszMime);
  139.     HX_RESULT   GetAllImageInfo(UINT32 ulHandle, REF(UINT32) rulSize, REF(IHXBuffer*) rpNameStr,
  140.                                 REF(IHXBuffer*) rpFileMimeStr, REF(IHXBuffer*) rpStreamMimeStr);
  141.     HX_RESULT   GetAllImageInfo(UINT32 ulHandle, REF(UINT32) rulSize, REF(const char*) rpszName,
  142.                                 REF(const char*) rpszFileMime, REF(const char*) rpszStreamMime);
  143.     BOOL        AllImageSizesInitialized();
  144.     BOOL        AllImageSizesOK();
  145.     HX_RESULT   GetFailedImageName(REF(IHXBuffer*) rpFailedNameStr);
  147.     HX_RESULT   AddEffect(PXEffect* pEffect);
  148.     UINT32      GetNumEffects() const;
  149.     HX_RESULT   GetEffectHeadIterator(REF(void*) rpIterator);
  150.     HX_RESULT   GetEffectTailIterator(REF(void*) rpIterator);
  151.     HX_RESULT   GetAtNextEffect(REF(void*) rpIterator, REF(PXEffect*) rpEffect);
  152.     HX_RESULT   GetNextEffect(REF(void*) rpIterator, REF(PXEffect*) rpEffect);
  153.     HX_RESULT   GetPrevEffect(REF(void*) rpIterator, REF(PXEffect*) rpEffect);
  154.     HX_RESULT   GetCurrentEffect(void* pIterator, REF(PXEffect*) rpEffect);
  156.     HX_RESULT   SetFileName(const char* pszFileName);
  157.     HX_RESULT   SetFileName(IHXBuffer* pFileNameStr);
  158.     HX_RESULT   GetFileName(IHXBuffer** ppFileNameStr);
  159.     const char* GetFileName();
  161.     HX_RESULT   PostParseInit();
  162. protected:
  163.     PXRealPixFile();
  164.     virtual ~PXRealPixFile();
  166.     // private enums
  167.     enum
  168.     {
  169.         kMinDuration = 100
  170.     };
  172.     class PXImageInfo
  173.     {
  174.     public:
  175.         PXImageInfo()
  176.         {
  177.             m_ulHandle       = 0;
  178.             m_ulSize         = 0xFFFFFFFF;
  179.             m_pNameStr       = NULL;
  180.             m_pFileMimeStr   = NULL;
  181.             m_pStreamMimeStr = NULL;
  182.             m_lErrorStatus   = HXR_NOT_INITIALIZED;
  183.         };
  185.         ~PXImageInfo()
  186.         {
  187.             HX_RELEASE(m_pNameStr);
  188.             HX_RELEASE(m_pFileMimeStr);
  189.             HX_RELEASE(m_pStreamMimeStr);
  190.         };
  192.         UINT32      m_ulHandle;
  193.         UINT32      m_ulSize;
  194.         IHXBuffer* m_pNameStr;
  195.         IHXBuffer* m_pFileMimeStr;
  196.         IHXBuffer* m_pStreamMimeStr;
  197.         HX_RESULT   m_lErrorStatus;
  198.     };
  200.     void            ClearImageMap();
  201.     void            ClearEffectsList();
  202.     HX_RESULT       SetString(const char* pszStr, IHXBuffer** ppStr);
  203.     HX_RESULT       SetString(IHXBuffer* pStr, IHXBuffer** ppStr);
  204.     HX_RESULT       GetString(IHXBuffer* pInStr, IHXBuffer** ppOutStr);
  205.     HX_RESULT       GetImageInfo(UINT32 ulHandle, REF(PXImageInfo*) rpInfo);
  207.     IHXBuffer*       m_pTitleStr;
  208.     IHXBuffer*       m_pAuthorStr;
  209.     IHXBuffer*       m_pCopyrightStr;
  210.     UINT32           m_ulStart;
  211.     UINT32           m_ulDuration;
  212.     UINT32           m_ulPreroll;
  213.     UINT32           m_ulBitrate;
  214.     UINT32           m_ulWidth;
  215.     UINT32           m_ulHeight;
  216.     UINT32           m_ulTimeFormat;
  217.     UINT32           m_ulBackgroundColor;
  218.     UINT32           m_ulBackgroundOpacity;
  219.     UINT32           m_ulDefaultMaxFps;
  220.     BOOL             m_bDefaultAspectFlag;
  221.     BOOL             m_bDefaultCenterFlag;
  222.     IHXBuffer*       m_pDefaultURLStr;
  223.     UINT32           m_ulContentVersion;
  224.     CHXMapLongToObj* m_pImageMap;
  225.     CHXSimpleList*   m_pEffectsList;
  226.     IHXBuffer*       m_pFileNameStr;
  227. };
  229. inline HX_RESULT PXRealPixFile::SetString(const char* pszStr, IHXBuffer** ppStr)
  230. {
  231.     HX_RESULT retVal = HXR_OK;
  233.     if (pszStr && ppStr)
  234.     {
  235.         HX_RELEASE(*ppStr);
  236.         *ppStr = (IHXBuffer*) new CHXBuffer();
  237.         if (*ppStr)
  238.         {
  239.             (*ppStr)->AddRef();
  240.             retVal = (*ppStr)->SetSize(strlen(pszStr) + 1);
  241.             if (SUCCEEDED(retVal))
  242.             {
  243.                 strcpy((char*) (*ppStr)->GetBuffer(), pszStr); /* Flawfinder: ignore */
  244.             }
  245.         }
  246.         else
  247.         {
  248.             retVal = HXR_OUTOFMEMORY;
  249.         }
  250.     }
  251.     else
  252.     {
  253.         return HXR_INVALID_PARAMETER;
  254.     }
  256.     return retVal;
  257. }
  259. inline HX_RESULT PXRealPixFile::SetString(IHXBuffer* pStr, IHXBuffer** ppStr)
  260. {
  261.     HX_RESULT retVal = HXR_OK;
  263.     if (pStr && ppStr)
  264.     {
  265.         if (pStr->GetBuffer())
  266.         {
  267.             if (strlen((const char*) pStr->GetBuffer()) > 0)
  268.             {
  269.                 HX_RELEASE(*ppStr);
  270.                 *ppStr = pStr;
  271.                 (*ppStr)->AddRef();
  272.             }
  273.             else
  274.             {
  275.                 retVal = HXR_FAIL;
  276.             }
  277.         }
  278.         else
  279.         {
  280.             retVal = HXR_FAIL;
  281.         }
  282.     }
  283.     else
  284.     {
  285.         retVal = HXR_INVALID_PARAMETER;
  286.     }
  287.     
  288.     return retVal;
  289. }
  291. inline HX_RESULT PXRealPixFile::GetString(IHXBuffer* pInStr, IHXBuffer** ppOutStr)
  292. {
  293.     HX_RESULT retVal = HXR_OK;
  295.     if (ppOutStr)
  296.     {
  297.         if (pInStr)
  298.         {
  299.             *ppOutStr = pInStr;
  300.             (*ppOutStr)->AddRef();
  301.         }
  302.         else
  303.         {
  304.             retVal = HXR_NOT_INITIALIZED;
  305.         }
  306.     }
  307.     else
  308.     {
  309.         retVal = HXR_INVALID_PARAMETER;
  310.     }
  312.     return retVal;
  313. }
  315. inline HX_RESULT PXRealPixFile::SetTitle(const char* pszTitle)
  316. {
  317.     return SetString(pszTitle, &m_pTitleStr);
  318. }
  320. inline HX_RESULT PXRealPixFile::SetTitle(IHXBuffer* pTitleStr)
  321. {
  322.     return SetString(pTitleStr, &m_pTitleStr);
  323. }
  325. inline HX_RESULT PXRealPixFile::GetTitle(IHXBuffer** ppTitleStr)
  326. {
  327.     return GetString(m_pTitleStr, ppTitleStr);
  328. }
  330. inline HX_RESULT PXRealPixFile::SetAuthor(const char* pszAuthor)
  331. {
  332.     return SetString(pszAuthor, &m_pAuthorStr);
  333. }
  335. inline HX_RESULT PXRealPixFile::SetAuthor(IHXBuffer* pAuthorStr)
  336. {
  337.     return SetString(pAuthorStr, &m_pAuthorStr);
  338. }
  340. inline HX_RESULT PXRealPixFile::GetAuthor(IHXBuffer** ppAuthorStr)
  341. {
  342.     return GetString(m_pAuthorStr, ppAuthorStr);
  343. }
  345. inline HX_RESULT PXRealPixFile::SetCopyright(const char* pszCopyright)
  346. {
  347.     return SetString(pszCopyright, &m_pCopyrightStr);
  348. }
  350. inline HX_RESULT PXRealPixFile::SetCopyright(IHXBuffer* pCopyrightStr)
  351. {
  352.     return SetString(pCopyrightStr, &m_pCopyrightStr);
  353. }
  355. inline HX_RESULT PXRealPixFile::GetCopyright(IHXBuffer** ppCopyrightStr)
  356. {
  357.     return GetString(m_pCopyrightStr, ppCopyrightStr);
  358. }
  360. inline HX_RESULT PXRealPixFile::SetDefaultURL(const char* pszDefaultURL)
  361. {
  362.     return SetString(pszDefaultURL, &m_pDefaultURLStr);
  363. }
  365. inline HX_RESULT PXRealPixFile::SetDefaultURL(IHXBuffer* pDefaultURLStr)
  366. {
  367.     return SetString(pDefaultURLStr, &m_pDefaultURLStr);
  368. }
  370. inline HX_RESULT PXRealPixFile::GetDefaultURL(IHXBuffer** ppDefaultURLStr)
  371. {
  372.     return GetString(m_pDefaultURLStr, ppDefaultURLStr);
  373. }
  375. inline void PXRealPixFile::SetStart(UINT32 ulStart)
  376. {
  377.     m_ulStart = ulStart;
  378. }
  380. inline UINT32 PXRealPixFile::GetStart() const
  381. {
  382.     return m_ulStart;
  383. }
  385. inline void PXRealPixFile::SetDuration(UINT32 ulDuration)
  386. {
  387.     m_ulDuration = ulDuration;
  388. }
  390. inline UINT32 PXRealPixFile::GetDuration() const
  391. {
  392.     return m_ulDuration;
  393. }
  395. inline void PXRealPixFile::SetPreroll(UINT32 ulPreroll)
  396. {
  397.     m_ulPreroll = ulPreroll;
  398. }
  400. inline UINT32 PXRealPixFile::GetPreroll() const
  401. {
  402.     return m_ulPreroll;
  403. }
  405. inline void PXRealPixFile::SetBitrate(UINT32 ulBitrate)
  406. {
  407.     m_ulBitrate = ulBitrate;
  408. }
  410. inline UINT32 PXRealPixFile::GetBitrate() const
  411. {
  412.     return m_ulBitrate;
  413. }
  415. inline void PXRealPixFile::SetDisplayWidth(UINT32 ulWidth)
  416. {
  417.     m_ulWidth = ulWidth;
  418. }
  420. inline UINT32 PXRealPixFile::GetDisplayWidth() const
  421. {
  422.     return m_ulWidth;
  423. }
  425. inline void PXRealPixFile::SetDisplayHeight(UINT32 ulHeight)
  426. {
  427.     m_ulHeight = ulHeight;
  428. }
  430. inline UINT32 PXRealPixFile::GetDisplayHeight() const
  431. {
  432.     return m_ulHeight;
  433. }
  435. inline HX_RESULT PXRealPixFile::SetTimeFormat(UINT32 ulTimeFormat)
  436. {
  437.     HX_RESULT retVal = HXR_OK;
  439.     if (ulTimeFormat == kTimeFormatDHMS ||
  440.         ulTimeFormat == kTimeFormatMilliseconds)
  441.     {    
  442.         m_ulTimeFormat = ulTimeFormat;
  443.     }
  444.     else
  445.     {
  446.         retVal = HXR_FAIL;
  447.     }
  449.     return retVal;
  450. }
  452. inline UINT32 PXRealPixFile::GetTimeFormat() const
  453. {
  454.     return m_ulTimeFormat;
  455. }
  457. inline void PXRealPixFile::SetBackgroundColor(UINT32 ulColor)
  458. {
  459.     m_ulBackgroundColor = ulColor;
  460. }
  462. inline void PXRealPixFile::SetBackgroundColor(BYTE ucRed, BYTE ucGreen, BYTE ucBlue)
  463. {
  464.     m_ulBackgroundColor = (ucRed << 16) | (ucGreen << 8) | ucBlue;
  465. }
  467. inline UINT32 PXRealPixFile::GetBackgroundColor() const
  468. {
  469.     return m_ulBackgroundColor;
  470. }
  472. inline void PXRealPixFile::SetBackgroundOpacity(UINT32 ulOpacity)
  473. {
  474.     m_ulBackgroundOpacity = (ulOpacity > 255 ? 255 : ulOpacity);
  475. }
  477. inline UINT32 PXRealPixFile::GetBackgroundOpacity() const
  478. {
  479.     return m_ulBackgroundOpacity;
  480. }
  482. inline void PXRealPixFile::SetDefaultMaxFps(UINT32 ulMaxFps)
  483. {
  484.     m_ulDefaultMaxFps = ulMaxFps;
  485. }
  487. inline UINT32 PXRealPixFile::GetDefaultMaxFps() const
  488. {
  489.     return m_ulDefaultMaxFps;
  490. }
  492. inline void PXRealPixFile::SetDefaultAspectFlag(BOOL bAspectFlag)
  493. {
  494.     m_bDefaultAspectFlag = bAspectFlag;
  495. }
  497. inline BOOL PXRealPixFile::GetDefaultAspectFlag() const
  498. {
  499.     return m_bDefaultAspectFlag;
  500. }
  502. inline void PXRealPixFile::SetDefaultCenterFlag(BOOL bCenterFlag)
  503. {
  504.     m_bDefaultCenterFlag = bCenterFlag;
  505. }
  507. inline BOOL PXRealPixFile::GetDefaultCenterFlag() const
  508. {
  509.     return m_bDefaultCenterFlag;
  510. }
  512. inline void PXRealPixFile::SetContentVersion(UINT32 ulVersion)
  513. {
  514.     m_ulContentVersion = ulVersion;
  515. }
  517. inline void PXRealPixFile::SetContentVersionToAtLeast(UINT32 ulVersion)
  518. {
  519.     if (m_ulContentVersion < ulVersion)
  520.     {
  521.         m_ulContentVersion = ulVersion;
  522.     }
  523. }
  525. inline UINT32 PXRealPixFile::GetContentVersion() const
  526. {
  527.     return m_ulContentVersion;
  528. }
  530. inline HX_RESULT PXRealPixFile::SetFileName(const char* pszFileName)
  531. {
  532.     return SetString(pszFileName, &m_pFileNameStr);
  533. }
  535. inline HX_RESULT PXRealPixFile::SetFileName(IHXBuffer* pFileNameStr)
  536. {
  537.     return SetString(pFileNameStr, &m_pFileNameStr);
  538. }
  540. inline HX_RESULT PXRealPixFile::GetFileName(IHXBuffer** ppFileNameStr)
  541. {
  542.     return GetString(m_pFileNameStr, ppFileNameStr);
  543. }
  545. inline const char* PXRealPixFile::GetFileName()
  546. {
  547.     const char* pszRet = NULL;
  548.     if (m_pFileNameStr)
  549.     {
  550.         pszRet = (const char*) m_pFileNameStr->GetBuffer();
  551.     }
  552.     return pszRet;
  553. }
  555. #endif