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

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. // include
  36. #include "hxtypes.h"
  37. #include "hxwintyp.h"
  38. #include "hxcom.h"
  39. #include "hxresult.h"
  40. #include "ihxpckts.h"
  41. // hxmisc
  42. #include "baseobj.h"
  43. #include "unkimp.h"
  44. // hxcont
  45. #include "hxbuffer.h"
  46. #include "hxslist.h"
  47. #include "hxmap.h"
  48. // pxcomlib
  49. #include "pxrect.h"
  50. #include "pxcolor.h"
  51. #include "pxeffect.h"
  52. #include "rpfile.h"
  53. // hxdebug
  54. #include "hxheap.h"
  55. #ifdef _DEBUG
  56. #undef HX_THIS_FILE
  57. static char HX_THIS_FILE[] = __FILE__;
  58. #endif
  59. BEGIN_INTERFACE_LIST(PXRealPixFile)
  60. END_INTERFACE_LIST
  61. PXRealPixFile::PXRealPixFile()
  62. {
  63.     m_pTitleStr           = NULL;
  64.     m_pAuthorStr          = NULL;
  65.     m_pCopyrightStr       = NULL;
  66.     m_ulStart             = 0;
  67.     m_ulDuration          = 0;
  68.     m_ulPreroll           = 0;
  69.     m_ulBitrate           = 0;
  70.     m_ulWidth             = 0;
  71.     m_ulHeight            = 0;
  72.     m_ulTimeFormat        = kTimeFormatMilliseconds;
  73.     m_ulBackgroundColor   = 0; // in 0x00RRGGBB format
  74.     m_ulBackgroundOpacity = 255;
  75.     m_ulDefaultMaxFps     = 0;
  76.     m_bDefaultAspectFlag  = TRUE;
  77.     m_bDefaultCenterFlag  = FALSE;
  78.     m_pDefaultURLStr      = NULL;
  79.     m_ulContentVersion    = HX_ENCODE_PROD_VERSION(0, 0, 0, 0);
  80.     m_pImageMap           = NULL;
  81.     m_pEffectsList        = NULL;
  82.     m_pFileNameStr        = NULL;
  83. }
  84. PXRealPixFile::~PXRealPixFile()
  85. {
  86.     HX_RELEASE(m_pTitleStr);
  87.     HX_RELEASE(m_pAuthorStr);
  88.     HX_RELEASE(m_pCopyrightStr);
  89.     HX_RELEASE(m_pDefaultURLStr);
  90.     ClearImageMap();
  91.     ClearEffectsList();
  92.     HX_DELETE(m_pImageMap);
  93.     HX_DELETE(m_pEffectsList);
  94.     HX_RELEASE(m_pFileNameStr);
  95. }
  96. void PXRealPixFile::ClearImageMap()
  97. {
  98.     if (m_pImageMap)
  99.     {
  100.         // Run through the map, deleting all image objects
  101.         POSITION pos = m_pImageMap->GetStartPosition();
  102.         while (pos)
  103.         {
  104.             // Get the object pointer at the current position
  105.             // and advance to the next position
  106.             LONG32 lKey     = 0;
  107.             void*  pElement = NULL;
  108.             m_pImageMap->GetNextAssoc(pos, lKey, pElement);
  109.             // Release the object
  110.             PXImageInfo* pInfo = (PXImageInfo*) pElement;
  111.             HX_DELETE(pInfo);
  112.         }
  113.         // Clear the map
  114.         m_pImageMap->RemoveAll();
  115.     }
  116. }
  117. void PXRealPixFile::ClearEffectsList()
  118. {
  119.     if (m_pEffectsList)
  120.     {
  121.         LISTPOSITION pos = m_pEffectsList->GetHeadPosition();
  122.         while (pos)
  123.         {
  124.             PXEffect* pEffect = (PXEffect*) m_pEffectsList->GetNext(pos);
  125.             HX_RELEASE(pEffect);
  126.         }
  127.         m_pEffectsList->RemoveAll();
  128.     }
  129. }
  130. HX_RESULT PXRealPixFile::AddImage(UINT32 ulHandle, const char* pszName)
  131. {
  132.     HX_RESULT retVal = HXR_OK;
  133.     IHXBuffer* pTmp = NULL;
  134.     retVal           = SetString(pszName, &pTmp);
  135.     if (SUCCEEDED(retVal))
  136.     {
  137.         retVal = AddImage(ulHandle, pTmp);
  138.     }
  139.     HX_RELEASE(pTmp);
  140.     return retVal;
  141. }
  142. HX_RESULT PXRealPixFile::AddImage(UINT32 ulHandle, IHXBuffer* pName)
  143. {
  144.     HX_RESULT retVal = HXR_OK;
  145.     if (ulHandle && pName)
  146.     {
  147.         if (!m_pImageMap)
  148.         {
  149.             m_pImageMap = new CHXMapLongToObj();
  150.             if (!m_pImageMap)
  151.             {
  152.                 retVal = HXR_OUTOFMEMORY;
  153.             }
  154.         }
  155.         if (SUCCEEDED(retVal))
  156.         {
  157.             // Create a PXImageInfo object
  158.             PXImageInfo* pInfo = new PXImageInfo;
  159.             if (pInfo)
  160.             {
  161.                 // Set the handle
  162.                 pInfo->m_ulHandle = ulHandle;
  163.                 // Set the string
  164.                 pInfo->m_pNameStr = pName;
  165.                 pInfo->m_pNameStr->AddRef();
  166.                 // Check if there is already an entry in the map
  167.                 void* pVoid    = NULL;
  168.                 BOOL  bPresent = m_pImageMap->Lookup((LONG32) ulHandle, pVoid);
  169.                 if (bPresent)
  170.                 {
  171.                     retVal = HXR_FAIL;
  172.                 }
  173.                 else
  174.                 {
  175.                     // Put the entry into the map
  176.                     m_pImageMap->SetAt((LONG32) ulHandle, (void*) pInfo);
  177.                 }
  178.             }
  179.             else
  180.             {
  181.                 retVal = HXR_OUTOFMEMORY;
  182.             }
  183.             if (FAILED(retVal))
  184.             {
  185.                 HX_DELETE(pInfo);
  186.             }
  187.         }
  188.     }
  189.     else
  190.     {
  191.         retVal = HXR_INVALID_PARAMETER;
  192.     }
  193.     return retVal;
  194. }
  195. UINT32 PXRealPixFile::GetNumImages() const
  196. {
  197.     UINT32 ulRet = 0;
  198.     if (m_pImageMap)
  199.     {
  200.         ulRet = m_pImageMap->GetCount();
  201.     }
  202.     return ulRet;
  203. }
  204. UINT32 PXRealPixFile::GetNumImagesWithNoSize() const
  205. {
  206.     UINT32 ulRet = 0;
  207.     if (m_pImageMap)
  208.     {
  209.         POSITION pos = m_pImageMap->GetStartPosition();
  210.         while (pos)
  211.         {
  212.             // Get the object pointer at the current position
  213.             // and advance to the next position
  214.             LONG32 lKey     = 0;
  215.             void*  pElement = NULL;
  216.             m_pImageMap->GetNextAssoc(pos, lKey, pElement);
  217.             // Check the PXImageInfo object
  218.             if (pElement)
  219.             {
  220.                 PXImageInfo* pInfo = (PXImageInfo*) pElement;
  221.                 if (pInfo->m_lErrorStatus != HXR_OK)
  222.                 {
  223.                     ulRet++;
  224.                 }
  225.             }
  226.         }
  227.     }
  228.     return ulRet;
  229. }
  230. HX_RESULT PXRealPixFile::GetImageIterator(REF(void*) rpIterator)
  231. {
  232.     HX_RESULT retVal = HXR_OK;
  233.     if (m_pImageMap)
  234.     {
  235.         POSITION pos = m_pImageMap->GetStartPosition();
  236.         if (pos)
  237.         {
  238.             rpIterator = pos;
  239.         }
  240.         else
  241.         {
  242.             retVal = HXR_FAIL;
  243.         }
  244.     }
  245.     else
  246.     {
  247.         retVal = HXR_NOT_INITIALIZED;
  248.     }
  249.     return retVal;
  250. }
  251. HX_RESULT PXRealPixFile::GetNextImageHandle(REF(void*) rpIterator, REF(UINT32) rulHandle)
  252. {
  253.     HX_RESULT retVal = HXR_OK;
  254.     if (m_pImageMap)
  255.     {
  256.         if (rpIterator)
  257.         {
  258.             // Get the object pointer at the current position
  259.             // and advance to the next position
  260.             LONG32 lKey     = 0;
  261.             void*  pElement = NULL;
  262.             m_pImageMap->GetNextAssoc(rpIterator, lKey, pElement);
  263.             // The handle *is* the key
  264.             rulHandle = (UINT32) lKey;
  265.         }
  266.         else
  267.         {
  268.             retVal = HXR_FAIL;
  269.         }
  270.     }
  271.     else
  272.     {
  273.         retVal = HXR_NOT_INITIALIZED;
  274.     }
  275.     return retVal;
  276. }
  277. BOOL PXRealPixFile::IsImagePresent(UINT32 ulHandle)
  278. {
  279.     BOOL bPresent = FALSE;
  280.     if (m_pImageMap)
  281.     {
  282.         void* pVoid = NULL;
  283.         bPresent    = m_pImageMap->Lookup((LONG32) ulHandle, pVoid);
  284.     }
  285.     return bPresent;
  286. }
  287. HX_RESULT PXRealPixFile::GetImageName(UINT32 ulHandle, REF(IHXBuffer*) rpNameStr)
  288. {
  289.     PXImageInfo* pInfo  = NULL;
  290.     HX_RESULT    retVal = GetImageInfo(ulHandle, pInfo);
  291.     if (SUCCEEDED(retVal))
  292.     {
  293.         if (pInfo->m_pNameStr)
  294.         {
  295.             HX_RELEASE(rpNameStr);
  296.             rpNameStr = pInfo->m_pNameStr;
  297.             rpNameStr->AddRef();
  298.         }
  299.         else
  300.         {
  301.             retVal = HXR_FAIL;
  302.         }
  303.     }
  304.     return retVal;
  305. }
  306. HX_RESULT PXRealPixFile::GetImageName(UINT32 ulHandle, REF(const char*) rpszName)
  307. {
  308.     PXImageInfo* pInfo  = NULL;
  309.     HX_RESULT    retVal = GetImageInfo(ulHandle, pInfo);
  310.     if (SUCCEEDED(retVal))
  311.     {
  312.         rpszName = (const char*) (pInfo->m_pNameStr ? pInfo->m_pNameStr->GetBuffer() : NULL);
  313.     }
  314.     return retVal;
  315. }
  316. const char* PXRealPixFile::GetImageName(UINT32 ulHandle)
  317. {
  318.     const char* pszName = NULL;
  319.     GetImageName(ulHandle, pszName);
  320.     return pszName;
  321. }
  322. HX_RESULT PXRealPixFile::SetImageName(UINT32 ulHandle, IHXBuffer* pNameStr)
  323. {
  324.     PXImageInfo* pInfo  = NULL;
  325.     HX_RESULT    retVal = GetImageInfo(ulHandle, pInfo);
  326.     if (SUCCEEDED(retVal))
  327.     {
  328.         HX_RELEASE(pInfo->m_pNameStr);
  329.         retVal = SetString(pNameStr, &pInfo->m_pNameStr);
  330.     }
  331.     return retVal;
  332. }
  333. HX_RESULT PXRealPixFile::SetImageName(UINT32 ulHandle, const char* pszName)
  334. {
  335.     PXImageInfo* pInfo  = NULL;
  336.     HX_RESULT    retVal = GetImageInfo(ulHandle, pInfo);
  337.     if (SUCCEEDED(retVal))
  338.     {
  339.         HX_RELEASE(pInfo->m_pNameStr);
  340.         retVal = SetString(pszName, &pInfo->m_pNameStr);
  341.     }
  342.     return retVal;
  343. }
  344. HX_RESULT PXRealPixFile::GetImageErrorStatus(UINT32 ulHandle, REF(HX_RESULT) rlStatus)
  345. {
  346.     PXImageInfo* pInfo  = NULL;
  347.     HX_RESULT    retVal = GetImageInfo(ulHandle, pInfo);
  348.     if (SUCCEEDED(retVal))
  349.     {
  350.         rlStatus = pInfo->m_lErrorStatus;
  351.     }
  352.     return retVal;
  353. }
  354. HX_RESULT PXRealPixFile::SetImageErrorStatus(UINT32 ulHandle, HX_RESULT lStatus)
  355. {
  356.     PXImageInfo* pInfo  = NULL;
  357.     HX_RESULT    retVal = GetImageInfo(ulHandle, pInfo);
  358.     if (SUCCEEDED(retVal))
  359.     {
  360.         pInfo->m_lErrorStatus = lStatus;
  361.     }
  362.     return retVal;
  363. }
  364. HX_RESULT PXRealPixFile::GetImageSize(UINT32 ulHandle, REF(UINT32) rulSize)
  365. {
  366.     PXImageInfo* pInfo  = NULL;
  367.     HX_RESULT    retVal = GetImageInfo(ulHandle, pInfo);
  368.     if (SUCCEEDED(retVal))
  369.     {
  370.         rulSize = pInfo->m_ulSize;
  371.     }
  372.     return retVal;
  373. }
  374. UINT32 PXRealPixFile::GetImageSize(UINT32 ulHandle)
  375. {
  376.     UINT32 ulSize = 0;
  377.     GetImageSize(ulHandle, ulSize);
  378.     return ulSize;
  379. }
  380. HX_RESULT PXRealPixFile::SetImageSize(UINT32 ulHandle, UINT32 ulSize)
  381. {
  382.     PXImageInfo* pInfo  = NULL;
  383.     HX_RESULT    retVal = GetImageInfo(ulHandle, pInfo);
  384.     if (SUCCEEDED(retVal))
  385.     {
  386.         if (ulSize)
  387.         {
  388.             pInfo->m_ulSize       = ulSize;
  389.             pInfo->m_lErrorStatus = HXR_OK;
  390.         }
  391.         else
  392.         {
  393.             retVal = HXR_FAIL;
  394.         }
  395.     }
  396.     return retVal;
  397. }
  398. BOOL PXRealPixFile::IsImageSizeInitialized(UINT32 ulHandle)
  399. {
  400.     BOOL         bRet  = FALSE;
  401.     PXImageInfo* pInfo = NULL;
  402.     GetImageInfo(ulHandle, pInfo);
  403.     if (pInfo && pInfo->m_lErrorStatus == HXR_OK)
  404.     {
  405.         bRet = TRUE;
  406.     }
  407.     return bRet;
  408. }
  409. HX_RESULT PXRealPixFile::GetImageFileMimeType(UINT32 ulHandle, REF(IHXBuffer*) rpMimeStr)
  410. {
  411.     PXImageInfo* pInfo  = NULL;
  412.     HX_RESULT    retVal = GetImageInfo(ulHandle, pInfo);
  413.     if (SUCCEEDED(retVal))
  414.     {
  415.         if (pInfo->m_pFileMimeStr)
  416.         {
  417.             HX_RELEASE(rpMimeStr);
  418.             rpMimeStr = pInfo->m_pFileMimeStr;
  419.             rpMimeStr->AddRef();
  420.         }
  421.         else
  422.         {
  423.             retVal = HXR_FAIL;
  424.         }
  425.     }
  426.     return retVal;
  427. }
  428. HX_RESULT PXRealPixFile::GetImageFileMimeType(UINT32 ulHandle, REF(const char*) rpszMime)
  429. {
  430.     PXImageInfo* pInfo  = NULL;
  431.     HX_RESULT    retVal = GetImageInfo(ulHandle, pInfo);
  432.     if (SUCCEEDED(retVal))
  433.     {
  434.         rpszMime = (const char*) (pInfo->m_pFileMimeStr ? pInfo->m_pFileMimeStr->GetBuffer() : NULL);
  435.     }
  436.     return retVal;
  437. }
  438. const char* PXRealPixFile::GetImageFileMimeType(UINT32 ulHandle)
  439. {
  440.     const char* pszMime = NULL;
  441.     GetImageFileMimeType(ulHandle, pszMime);
  442.     return pszMime;
  443. }
  444. HX_RESULT PXRealPixFile::SetImageFileMimeType(UINT32 ulHandle, IHXBuffer* pMimeStr)
  445. {
  446.     PXImageInfo* pInfo  = NULL;
  447.     HX_RESULT    retVal = GetImageInfo(ulHandle, pInfo);
  448.     if (SUCCEEDED(retVal))
  449.     {
  450.         HX_RELEASE(pInfo->m_pFileMimeStr);
  451.         retVal = SetString(pMimeStr, &pInfo->m_pFileMimeStr);
  452.     }
  453.     return retVal;
  454. }
  455. HX_RESULT PXRealPixFile::SetImageFileMimeType(UINT32 ulHandle, const char* pszMime)
  456. {
  457.     PXImageInfo* pInfo  = NULL;
  458.     HX_RESULT    retVal = GetImageInfo(ulHandle, pInfo);
  459.     if (SUCCEEDED(retVal))
  460.     {
  461.         HX_RELEASE(pInfo->m_pFileMimeStr);
  462.         retVal = SetString(pszMime, &pInfo->m_pFileMimeStr);
  463.     }
  464.     return retVal;
  465. }
  466. HX_RESULT PXRealPixFile::GetImageStreamMimeType(UINT32 ulHandle, REF(IHXBuffer*) rpMimeStr)
  467. {
  468.     PXImageInfo* pInfo  = NULL;
  469.     HX_RESULT    retVal = GetImageInfo(ulHandle, pInfo);
  470.     if (SUCCEEDED(retVal))
  471.     {
  472.         if (pInfo->m_pStreamMimeStr)
  473.         {
  474.             HX_RELEASE(rpMimeStr);
  475.             rpMimeStr = pInfo->m_pStreamMimeStr;
  476.             rpMimeStr->AddRef();
  477.         }
  478.         else
  479.         {
  480.             retVal = HXR_FAIL;
  481.         }
  482.     }
  483.     return retVal;
  484. }
  485. HX_RESULT PXRealPixFile::GetImageStreamMimeType(UINT32 ulHandle, REF(const char*) rpszMime)
  486. {
  487.     PXImageInfo* pInfo  = NULL;
  488.     HX_RESULT    retVal = GetImageInfo(ulHandle, pInfo);
  489.     if (SUCCEEDED(retVal))
  490.     {
  491.         rpszMime = (const char*) (pInfo->m_pStreamMimeStr ? pInfo->m_pStreamMimeStr->GetBuffer() : NULL);
  492.     }
  493.     return retVal;
  494. }
  495. const char* PXRealPixFile::GetImageStreamMimeType(UINT32 ulHandle)
  496. {
  497.     const char* pszMime = NULL;
  498.     GetImageStreamMimeType(ulHandle, pszMime);
  499.     return pszMime;
  500. }
  501. HX_RESULT PXRealPixFile::SetImageStreamMimeType(UINT32 ulHandle, IHXBuffer* pMimeStr)
  502. {
  503.     PXImageInfo* pInfo  = NULL;
  504.     HX_RESULT    retVal = GetImageInfo(ulHandle, pInfo);
  505.     if (SUCCEEDED(retVal))
  506.     {
  507.         HX_RELEASE(pInfo->m_pStreamMimeStr);
  508.         retVal = SetString(pMimeStr, &pInfo->m_pStreamMimeStr);
  509.     }
  510.     return retVal;
  511. }
  512. HX_RESULT PXRealPixFile::SetImageStreamMimeType(UINT32 ulHandle, const char* pszMime)
  513. {
  514.     PXImageInfo* pInfo  = NULL;
  515.     HX_RESULT    retVal = GetImageInfo(ulHandle, pInfo);
  516.     if (SUCCEEDED(retVal))
  517.     {
  518.         HX_RELEASE(pInfo->m_pStreamMimeStr);
  519.         retVal = SetString(pszMime, &pInfo->m_pStreamMimeStr);
  520.     }
  521.     return retVal;
  522. }
  523. HX_RESULT PXRealPixFile::GetAllImageInfo(UINT32 ulHandle, REF(UINT32) rulSize, REF(IHXBuffer*) rpNameStr,
  524.                                          REF(IHXBuffer*) rpFileMimeStr, REF(IHXBuffer*) rpStreamMimeStr)
  525. {
  526.     PXImageInfo* pInfo  = NULL;
  527.     HX_RESULT    retVal = GetImageInfo(ulHandle, pInfo);
  528.     if (SUCCEEDED(retVal))
  529.     {
  530.         rulSize        = pInfo->m_ulSize;
  531.         if (pInfo->m_pNameStr)
  532.         {
  533.             HX_RELEASE(rpNameStr);
  534.             rpNameStr = pInfo->m_pNameStr;
  535.             rpNameStr->AddRef();
  536.         }
  537.         if (pInfo->m_pFileMimeStr)
  538.         {
  539.             HX_RELEASE(rpFileMimeStr);
  540.             rpFileMimeStr = pInfo->m_pFileMimeStr;
  541.             rpFileMimeStr->AddRef();
  542.         }
  543.         if (pInfo->m_pStreamMimeStr)
  544.         {
  545.             HX_RELEASE(rpStreamMimeStr);
  546.             rpStreamMimeStr = pInfo->m_pStreamMimeStr;
  547.             rpStreamMimeStr->AddRef();
  548.         }
  549.     }
  550.     return retVal;
  551. }
  552. HX_RESULT PXRealPixFile::GetAllImageInfo(UINT32 ulHandle, REF(UINT32) rulSize, REF(const char*) rpszName,
  553.                                          REF(const char*) rpszFileMime, REF(const char*) rpszStreamMime)
  554. {
  555.     PXImageInfo* pInfo  = NULL;
  556.     HX_RESULT    retVal = GetImageInfo(ulHandle, pInfo);
  557.     if (SUCCEEDED(retVal))
  558.     {
  559.         rulSize        = pInfo->m_ulSize;
  560.         rpszName       = (const char*) (pInfo->m_pNameStr ? pInfo->m_pNameStr->GetBuffer() : NULL);
  561.         rpszFileMime   = (const char*) (pInfo->m_pFileMimeStr ? pInfo->m_pFileMimeStr->GetBuffer() : NULL);
  562.         rpszStreamMime = (const char*) (pInfo->m_pStreamMimeStr ? pInfo->m_pStreamMimeStr->GetBuffer() : NULL);
  563.     }
  564.     return retVal;
  565. }
  566. BOOL PXRealPixFile::AllImageSizesInitialized()
  567. {
  568.     BOOL bRet = TRUE;
  569.     if (m_pImageMap)
  570.     {
  571.         // Run through the map, deleting all image objects
  572.         POSITION pos = m_pImageMap->GetStartPosition();
  573.         while (pos)
  574.         {
  575.             // Get the object pointer at the current position
  576.             // and advance to the next position
  577.             LONG32 lKey     = 0;
  578.             void*  pElement = NULL;
  579.             m_pImageMap->GetNextAssoc(pos, lKey, pElement);
  580.             // Check the PXImageInfo object
  581.             if (pElement)
  582.             {
  583.                 PXImageInfo* pInfo = (PXImageInfo*) pElement;
  584.                 if (pInfo->m_lErrorStatus == HXR_NOT_INITIALIZED)
  585.                 {
  586.                     bRet = FALSE;
  587.                     break;
  588.                 }
  589.             }
  590.         }
  591.     }
  592.     return bRet;
  593. }
  594. BOOL PXRealPixFile::AllImageSizesOK()
  595. {
  596.     BOOL bRet = TRUE;
  597.     if (m_pImageMap)
  598.     {
  599.         // Run through the map, deleting all image objects
  600.         POSITION pos = m_pImageMap->GetStartPosition();
  601.         while (pos)
  602.         {
  603.             // Get the object pointer at the current position
  604.             // and advance to the next position
  605.             LONG32 lKey     = 0;
  606.             void*  pElement = NULL;
  607.             m_pImageMap->GetNextAssoc(pos, lKey, pElement);
  608.             // Check the PXImageInfo object
  609.             if (pElement)
  610.             {
  611.                 PXImageInfo* pInfo = (PXImageInfo*) pElement;
  612.                 if (pInfo->m_lErrorStatus != HXR_OK)
  613.                 {
  614.                     bRet = FALSE;
  615.                     break;
  616.                 }
  617.             }
  618.         }
  619.     }
  620.     return bRet;
  621. }
  622. HX_RESULT PXRealPixFile::GetFailedImageName(REF(IHXBuffer*) rpFailedNameStr)
  623. {
  624.     HX_RESULT retVal = HXR_FAIL;
  625.     if (m_pImageMap)
  626.     {
  627.         // Run through the map, deleting all image objects
  628.         POSITION pos = m_pImageMap->GetStartPosition();
  629.         while (pos)
  630.         {
  631.             // Get the object pointer at the current position
  632.             // and advance to the next position
  633.             LONG32 lKey     = 0;
  634.             void*  pElement = NULL;
  635.             m_pImageMap->GetNextAssoc(pos, lKey, pElement);
  636.             // Check the PXImageInfo object
  637.             if (pElement)
  638.             {
  639.                 PXImageInfo* pInfo = (PXImageInfo*) pElement;
  640.                 if (pInfo->m_lErrorStatus != HXR_OK)
  641.                 {
  642.                     if (pInfo->m_pNameStr)
  643.                     {
  644.                         HX_RELEASE(rpFailedNameStr);
  645.                         rpFailedNameStr = pInfo->m_pNameStr;
  646.                         rpFailedNameStr->AddRef();
  647.                         retVal = HXR_OK;
  648.                         break;
  649.                     }
  650.                 }
  651.             }
  652.         }
  653.     }
  654.     return retVal;
  655. }
  656. HX_RESULT PXRealPixFile::AddEffect(PXEffect* pEffect)
  657. {
  658.     HX_RESULT retVal = HXR_OK;
  659.     if (pEffect)
  660.     {
  661.         if (!m_pEffectsList)
  662.         {
  663.             m_pEffectsList = new CHXSimpleList();
  664.             if (!m_pEffectsList)
  665.             {
  666.                 retVal = HXR_OUTOFMEMORY;
  667.             }
  668.         }
  669.         if (SUCCEEDED(retVal))
  670.         {
  671.             // Check for a few shortcuts before searching the whole list
  672.             // If there aren't any elements in the queue, we know just to
  673.             // add ourselves to the end of the list.
  674.             if (m_pEffectsList->GetCount() > 0)
  675.             {
  676.                 // Now we check the last element in the queue. If our start time is
  677.                 // greater than or equal to its start time, then we know just to
  678.                 // add ourselves at the tail of the queue.
  679.                 PXEffect *pTailEffect = (PXEffect *) m_pEffectsList->GetTail();
  680.                 if (pTailEffect)
  681.                 {
  682.                     if (pEffect->GetStart() < pTailEffect->GetStart())
  683.                     {
  684.                         // Now we have to search the list.
  685.                         // Insert effect into list which is sorted by increasing start time
  686.                         // We look for the first effect which has a start time greater
  687.                         // than the one we're inserting
  688.                         LISTPOSITION pos = m_pEffectsList->GetHeadPosition();
  689.                         while (pos)
  690.                         {
  691.                             PXEffect *pListEffect = (PXEffect *) m_pEffectsList->GetAt(pos);
  692.                             if (pListEffect)
  693.                             {
  694.                                 if (pListEffect->GetStart() > pEffect->GetStart())
  695.                                 {
  696.                                     // Addref effect before insertion
  697.                                     pEffect->AddRef();
  698.                                     // Insert into the list
  699.                                     m_pEffectsList->InsertBefore(pos, (void *) pEffect);
  700.                                     break;
  701.                                 }
  702.                                 m_pEffectsList->GetNext(pos);
  703.                             }
  704.                             else
  705.                             {
  706.                                 retVal = HXR_FAIL;
  707.                                 break;
  708.                             }
  709.                         }
  710.                         // If we added ourselves in the above loop, then pos will be non-NULL.
  711.                         // If we DIDN'T add ourselves in the above loop, then pos will be NULL.
  712.                         if (!pos)
  713.                         {
  714.                             // We didn't find an effect with a start time greater, so
  715.                             // this effect must be the new largest start time, so
  716.                             // we add this effect to the tail of the list. 
  717.                             //
  718.                             pEffect->AddRef();
  719.                             m_pEffectsList->AddTail((void *) pEffect);
  720.                         }
  721.                     }
  722.                     else
  723.                     {
  724.                         // Addref before adding to the list
  725.                         pEffect->AddRef();
  726.                         // Add it to the list
  727.                         m_pEffectsList->AddTail((void *) pEffect);
  728.                     }
  729.                 }
  730.                 else
  731.                 {
  732.                     retVal = HXR_FAIL;
  733.                 }
  734.             }
  735.             else
  736.             {
  737.                 // Addref the effect object before adding to the list
  738.                 pEffect->AddRef();
  739.                 // Add it to the list
  740.                 m_pEffectsList->AddTail((void *) pEffect);
  741.             }
  742.         }
  743.     }
  744.     else
  745.     {
  746.         retVal = HXR_INVALID_PARAMETER;
  747.     }
  748.     return retVal;
  749. }
  750. UINT32 PXRealPixFile::GetNumEffects() const
  751. {
  752.     UINT32 ulRet = 0;
  753.     if (m_pEffectsList)
  754.     {
  755.         ulRet = m_pEffectsList->GetCount();
  756.     }
  757.     return ulRet;
  758. }
  759. HX_RESULT PXRealPixFile::GetEffectHeadIterator(REF(void*) rpIterator)
  760. {
  761.     HX_RESULT retVal = HXR_OK;
  762.     if (m_pEffectsList)
  763.     {
  764.         LISTPOSITION pos = m_pEffectsList->GetHeadPosition();
  765.         if (pos)
  766.         {
  767.             rpIterator = pos;
  768.         }
  769.         else
  770.         {
  771.             retVal = HXR_FAIL;
  772.         }
  773.     }
  774.     else
  775.     {
  776.         retVal = HXR_FAIL;
  777.     }
  778.     return retVal;
  779. }
  780. HX_RESULT PXRealPixFile::GetEffectTailIterator(REF(void*) rpIterator)
  781. {
  782.     HX_RESULT retVal = HXR_OK;
  783.     if (m_pEffectsList)
  784.     {
  785.         LISTPOSITION pos = m_pEffectsList->GetTailPosition();
  786.         if (pos)
  787.         {
  788.             rpIterator = pos;
  789.         }
  790.         else
  791.         {
  792.             retVal = HXR_FAIL;
  793.         }
  794.     }
  795.     else
  796.     {
  797.         retVal = HXR_FAIL;
  798.     }
  799.     return retVal;
  800. }
  801. HX_RESULT PXRealPixFile::GetAtNextEffect(REF(void*) rpIterator, REF(PXEffect*) rpEffect)
  802. {
  803.     HX_RESULT retVal = HXR_OK;
  804.     if (m_pEffectsList)
  805.     {
  806.         if (rpIterator)
  807.         {
  808.             rpEffect = (PXEffect*) m_pEffectsList->GetAtNext(rpIterator);
  809.             if (rpEffect)
  810.             {
  811.                 rpEffect->AddRef();
  812.             }
  813.             else
  814.             {
  815.                 retVal = HXR_FAIL;
  816.             }
  817.         }
  818.         else
  819.         {
  820.             retVal = HXR_FAIL;
  821.         }
  822.     }
  823.     else
  824.     {
  825.         retVal = HXR_NOT_INITIALIZED;
  826.     }
  827.     return retVal;
  828. }
  829. HX_RESULT PXRealPixFile::GetNextEffect(REF(void*) rpIterator, REF(PXEffect*) rpEffect)
  830. {
  831.     HX_RESULT retVal = HXR_OK;
  832.     if (m_pEffectsList)
  833.     {
  834.         if (rpIterator)
  835.         {
  836.             rpEffect = (PXEffect*) m_pEffectsList->GetNext(rpIterator);
  837.             if (rpEffect)
  838.             {
  839.                 rpEffect->AddRef();
  840.             }
  841.             else
  842.             {
  843.                 retVal = HXR_FAIL;
  844.             }
  845.         }
  846.         else
  847.         {
  848.             retVal = HXR_FAIL;
  849.         }
  850.     }
  851.     else
  852.     {
  853.         retVal = HXR_NOT_INITIALIZED;
  854.     }
  855.     return retVal;
  856. }
  857. HX_RESULT PXRealPixFile::GetPrevEffect(REF(void*) rpIterator, REF(PXEffect*) rpEffect)
  858. {
  859.     HX_RESULT retVal = HXR_OK;
  860.     if (m_pEffectsList)
  861.     {
  862.         if (rpIterator)
  863.         {
  864.             rpEffect = (PXEffect*) m_pEffectsList->GetPrev(rpIterator);
  865.             if (rpEffect)
  866.             {
  867.                 rpEffect->AddRef();
  868.             }
  869.             else
  870.             {
  871.                 retVal = HXR_FAIL;
  872.             }
  873.         }
  874.         else
  875.         {
  876.             retVal = HXR_FAIL;
  877.         }
  878.     }
  879.     else
  880.     {
  881.         retVal = HXR_NOT_INITIALIZED;
  882.     }
  883.     return retVal;
  884. }
  885. HX_RESULT PXRealPixFile::GetCurrentEffect(void* pIterator, REF(PXEffect*) rpEffect)
  886. {
  887.     HX_RESULT retVal = HXR_OK;
  888.     if (m_pEffectsList)
  889.     {
  890.         if (pIterator)
  891.         {
  892.             rpEffect = (PXEffect*) m_pEffectsList->GetAt(pIterator);
  893.             if (rpEffect)
  894.             {
  895.                 rpEffect->AddRef();
  896.             }
  897.             else
  898.             {
  899.                 retVal = HXR_FAIL;
  900.             }
  901.         }
  902.         else
  903.         {
  904.             retVal = HXR_FAIL;
  905.         }
  906.     }
  907.     else
  908.     {
  909.         retVal = HXR_NOT_INITIALIZED;
  910.     }
  911.     return retVal;
  912. }
  913. HX_RESULT PXRealPixFile::GetImageInfo(UINT32 ulHandle, REF(PXImageInfo*) rpInfo)
  914. {
  915.     HX_RESULT retVal = HXR_OK;
  916.     if (m_pImageMap)
  917.     {
  918.         void *pVoid   = NULL;
  919.         BOOL bPresent = m_pImageMap->Lookup((LONG32) ulHandle, pVoid);
  920.         if (bPresent && pVoid)
  921.         {
  922.             rpInfo = (PXImageInfo*) pVoid;
  923.         }
  924.         else
  925.         {
  926.             retVal = HXR_FAIL;
  927.         }
  928.     }
  929.     else
  930.     {
  931.         retVal = HXR_NOT_INITIALIZED;
  932.     }
  933.     return retVal;
  934. }
  935. HX_RESULT PXRealPixFile::PostParseInit()
  936. {
  937.     HX_RESULT retVal = HXR_OK;
  938.     // First we need to set the first and last use effect flags.
  939.     // To set the first use flags, we initialize a map and
  940.     // run forward through the list of effects. Whenever we see
  941.     // an image used, we check to see if there's an entry in the
  942.     // map already. If not, then it's the first time this image
  943.     // has been used, so we mark the first use flag as true
  944.     // and then put an entry in the map. For last use flags,
  945.     // we do the same thing, but run through the effects in reverse.
  946.     //
  947.     // First, create the map
  948.     CHXMapLongToObj* pMap = new CHXMapLongToObj();
  949.     if (pMap)
  950.     {
  951.         // Now do a forward run through the effects
  952.         PXEffect*    pEffect = NULL;
  953.         LISTPOSITION pos     = m_pEffectsList->GetHeadPosition();
  954.         while (pos)
  955.         {
  956.             pEffect = (PXEffect*) m_pEffectsList->GetNext(pos);
  957.             if (pEffect)
  958.             {
  959.                 if (pEffect->HasTarget())
  960.                 {
  961.                     // Is there already an entry in the map for this image?
  962.                     void* pVoid    = NULL;
  963.                     BOOL  bPresent = pMap->Lookup((LONG32) pEffect->GetTarget(), pVoid);
  964.                     if (bPresent)
  965.                     {
  966.                         // This image has already been used, so clear the FirstUse flag
  967.                         pEffect->SetFirstUse(FALSE);
  968.                     }
  969.                     else
  970.                     {
  971.                         // This image has NOT been used so far, so set the FirstUse flag
  972.                         pEffect->SetFirstUse(TRUE);
  973.                         // And also put an entry in the map for this image. It
  974.                         // doesn't matter what the entry is, just that there IS
  975.                         // an entry in the map
  976.                         pMap->SetAt((LONG32) pEffect->GetTarget(), (void*) 1);
  977.                     }
  978.                 }
  979.             }
  980.         }
  981.         // Now clear the map to get ready for a backwards run
  982.         pMap->RemoveAll();
  983.         // Now run through the effects in reverse, doing the same thing
  984.         pos = m_pEffectsList->GetTailPosition();
  985.         while (pos)
  986.         {
  987.             PXEffect* pEffect = (PXEffect*) m_pEffectsList->GetPrev(pos);
  988.             if (pEffect)
  989.             {
  990.                 if (pEffect->HasTarget())
  991.                 {
  992.                     // Is there already an entry in the map for this image?
  993.                     void* pVoid    = NULL;
  994.                     BOOL  bPresent = pMap->Lookup((LONG32) pEffect->GetTarget(), pVoid);
  995.                     if (bPresent)
  996.                     {
  997.                         // This image has already been used, so clear the LastUse flag
  998.                         pEffect->SetLastUse(FALSE);
  999.                     }
  1000.                     else
  1001.                     {
  1002.                         // This image has NOT been used so far, so set the LastUse flag
  1003.                         pEffect->SetLastUse(TRUE);
  1004.                         // And also put an entry in the map for this image. It
  1005.                         // doesn't matter what the entry is, just that there IS
  1006.                         // an entry in the map
  1007.                         pMap->SetAt((LONG32) pEffect->GetTarget(), (void*) 1);
  1008.                     }
  1009.                 }
  1010.             }
  1011.         }
  1012.     }
  1013.     else
  1014.     {
  1015.         retVal = HXR_OUTOFMEMORY;
  1016.     }
  1017.     HX_DELETE(pMap);
  1018.     // Now we need to check if we need to compute the duration. If the duration is
  1019.     // still zero at this point, then it was never set in parsing. Therefore,
  1020.     // we need to calculate it from the effects
  1021.     if (!m_ulDuration)
  1022.     {
  1023.         // Run through the effects list, find the max end time.
  1024.         UINT32       ulMaxTime = 0;
  1025.         LISTPOSITION pos       = m_pEffectsList->GetHeadPosition();
  1026.         while (pos)
  1027.         {
  1028.             PXEffect* pEffect = (PXEffect*) m_pEffectsList->GetNext(pos);
  1029.             if (pEffect)
  1030.             {
  1031.                 if (pEffect->GetEnd() > ulMaxTime)
  1032.                 {
  1033.                     ulMaxTime = pEffect->GetEnd();
  1034.                 }
  1035.             }
  1036.         }
  1037.         // We don't let the duration be exactly zero.
  1038.         if (!ulMaxTime)
  1039.         {
  1040.             ulMaxTime = kMinDuration;
  1041.         }
  1042.         // Now set the duration of the presentation to this duration
  1043.         m_ulDuration = ulMaxTime;
  1044.     }
  1045.     return retVal;
  1046. }