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

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. /****************************************************************************
  36.  *  Defines
  37.  */
  38. /****************************************************************************
  39.  *  Includes
  40.  */
  41. #include "hxresult.h"
  42. #include "fileindextable.h"
  43. /****************************************************************************
  44.  *  Class CFileIndexTable
  45.  */
  46. /****************************************************************************
  47.  *  Constructor/Destructor
  48.  */
  49. CFileIndexTable::CFileIndexTable(void)
  50.     : m_uNumStreams(0)
  51.     , m_pStreamIndexTable(NULL)
  52. {
  53.     ;
  54. }
  55. CFileIndexTable::~CFileIndexTable()
  56. {
  57.     _Close();
  58. }
  59. /****************************************************************************
  60.  *  Main Interface
  61.  */
  62. /****************************************************************************
  63.  *  Init
  64.  */
  65. HX_RESULT CFileIndexTable::Init(UINT16 uNumStreams,
  66. UINT32 ulTimeGranularity,
  67. UINT32 ulMaxEntries,
  68. BOOL bUseAuxData)
  69. {
  70.     UINT32 ulIdx;
  71.     HX_RESULT retVal = HXR_OK;
  72.     _Close();
  73.     m_uNumStreams = uNumStreams;
  74.     if (m_uNumStreams != 0)
  75.     {
  76. m_pStreamIndexTable = new CStreamIndexTable [m_uNumStreams];
  77. retVal = HXR_OUTOFMEMORY;
  78. if (m_pStreamIndexTable)
  79. {
  80.     retVal = HXR_OK;
  81. }
  82.     }
  83.     for (ulIdx = 0; SUCCEEDED(retVal) && (ulIdx < uNumStreams); ulIdx++)
  84.     {
  85. retVal = m_pStreamIndexTable[ulIdx].Init(ulTimeGranularity,
  86.  ulMaxEntries,
  87.  bUseAuxData);
  88.     }
  89.     return retVal;
  90. }
  91. /****************************************************************************
  92.  *  SetIndex
  93.  */
  94. HX_RESULT CFileIndexTable::SetIndex(UINT16 uStreamNumber,
  95.     UINT32 ulTime,
  96.     UINT32 ulOffset,
  97.     void* pAuxData)
  98. {
  99.     if (uStreamNumber >= m_uNumStreams)
  100.     {
  101. return HXR_FAIL;
  102.     }
  103.     return m_pStreamIndexTable[uStreamNumber].SetIndex(ulTime,
  104.        ulOffset,
  105.        pAuxData);
  106. }
  107. /****************************************************************************
  108.  *  GetIndex
  109.  */
  110. HX_RESULT CFileIndexTable::GetIndex(UINT16 uStreamNumber,
  111.     UINT32& ulTime,
  112.     UINT32& ulOffset,
  113.     void** ppAuxData)
  114. {
  115.     if (uStreamNumber >= m_uNumStreams)
  116.     {
  117. return HXR_FAIL;
  118.     }
  119.     return m_pStreamIndexTable[uStreamNumber].GetIndex(ulTime,
  120.        ulOffset,
  121.        ppAuxData);
  122. }
  123. /****************************************************************************
  124.  *  HasIndex
  125.  */
  126. BOOL CFileIndexTable::HasIndex(UINT16 uStreamNumber,
  127.        UINT32 ulTime)
  128. {
  129.     if (uStreamNumber >= m_uNumStreams)
  130.     {
  131. return FALSE;
  132.     }
  133.     return m_pStreamIndexTable[uStreamNumber].HasIndex(ulTime);
  134. }
  135. /****************************************************************************
  136.  *  UpdateGranularity
  137.  */
  138. void CFileIndexTable::UpdateGranularity(UINT32 ulTimeGranularity)
  139. {
  140.     UINT16 ulIdx;
  141.     for (ulIdx = 0; ulIdx < m_uNumStreams; ulIdx++)
  142.     {
  143. m_pStreamIndexTable[ulIdx].UpdateGranularity(ulTimeGranularity);
  144.     }
  145. }
  146. /****************************************************************************
  147.  *  UpdateTimeRange
  148.  */
  149. void CFileIndexTable::UpdateTimeRange(UINT16 uStreamNumber, UINT32 ulTime)
  150. {
  151.     if (uStreamNumber < m_uNumStreams)
  152.     {
  153. m_pStreamIndexTable[uStreamNumber].UpdateTimeRange(ulTime);
  154.     }
  155. }
  156. /****************************************************************************
  157.  *  Close
  158.  */
  159. void CFileIndexTable::Close(void)
  160. {
  161.     _Close();
  162. }
  163. /****************************************************************************
  164.  *  Private Methods
  165.  */
  166. /****************************************************************************
  167.  *  _Close
  168.  */
  169. void CFileIndexTable::_Close(void)
  170. {
  171.     m_uNumStreams = 0;
  172.         
  173.     HX_VECTOR_DELETE(m_pStreamIndexTable);
  174. }
  175. /****************************************************************************
  176.  *  Class CStreamIndexTable
  177.  */
  178. /****************************************************************************
  179.  *  Constructor/Destructor
  180.  */
  181. CStreamIndexTable::CStreamIndexTable(void)
  182.     : m_pIndexTable(NULL)
  183.     , m_pAuxDataTable(NULL)
  184.     , m_ulMaxEntries(0)
  185.     , m_ulTimeGranulairty(0)
  186.     , m_ulLastTime(0)
  187.     , m_ulRangeTime(0)
  188. {
  189.     ;
  190. }
  191. CStreamIndexTable::~CStreamIndexTable()
  192. {
  193.     _Close();
  194. }
  195. /****************************************************************************
  196.  *  Main Interface
  197.  */
  198. /****************************************************************************
  199.  *  Init
  200.  */
  201. HX_RESULT CStreamIndexTable::Init(UINT32 ulTimeGranularity,
  202.   UINT32 ulMaxEntries,
  203.   BOOL bUseAuxData)
  204. {
  205.     HX_RESULT retVal = HXR_OK;
  206.     _Close();
  207.     m_ulMaxEntries = ulMaxEntries;
  208.     m_ulTimeGranulairty = ulTimeGranularity;
  209.     if (m_ulMaxEntries != 0)
  210.     {
  211. m_pIndexTable = new IndexEntry [m_ulMaxEntries];
  212. retVal = HXR_OUTOFMEMORY;
  213. if (m_pIndexTable)
  214. {
  215.     retVal = HXR_OK;
  216. }
  217. if (SUCCEEDED(retVal) && bUseAuxData)
  218. {
  219.     m_pAuxDataTable = new void* [m_ulMaxEntries];
  220.     retVal = HXR_OUTOFMEMORY;
  221.     if (m_pAuxDataTable)
  222.     {
  223. retVal = HXR_OK;
  224.     }
  225. }
  226.     }
  227.     return retVal;
  228. }
  229. /****************************************************************************
  230.  *  SetIndex
  231.  */
  232. HX_RESULT CStreamIndexTable::SetIndex(UINT32 ulTime,
  233.       UINT32 ulOffset,
  234.       void* pAuxData)
  235. {
  236.     HX_RESULT retVal = HXR_FAIL;
  237.     if (m_ulNumEntries >= m_ulMaxEntries)
  238.     {
  239. return HXR_FAIL;
  240.     }
  241.     if ((m_ulNumEntries == 0) ||
  242. ((ulTime > m_ulLastTime) &&
  243.  ((ulTime - m_ulLastTime) >= m_ulTimeGranulairty)))
  244.     {
  245. m_ulLastTime = ulTime;
  246. if (m_ulLastTime > m_ulRangeTime)
  247. {
  248.     m_ulRangeTime = m_ulLastTime;
  249. }
  250. m_pIndexTable[m_ulNumEntries].m_ulTime = ulTime;
  251. m_pIndexTable[m_ulNumEntries].m_ulOffset = ulOffset;
  252. if (m_pAuxDataTable)
  253. {
  254.     m_pAuxDataTable[m_ulNumEntries] = pAuxData;
  255. }
  256. m_ulNumEntries++;
  257. retVal = HXR_OK;
  258.     }
  259.     return retVal;
  260. }
  261. /****************************************************************************
  262.  *  GetIndex
  263.  */
  264. HX_RESULT CStreamIndexTable::GetIndex(UINT32& ulTime,
  265.       UINT32& ulOffset,
  266.       void** ppAuxData)
  267. {
  268.     HX_RESULT retVal = HXR_OK;
  269.     ULONG32 ulTargetTime = ulTime;
  270.     ULONG32 ulTableIdx;
  271.     
  272.     // Estimate Table Index to search from
  273.     ulTableIdx = ulTargetTime / m_ulTimeGranulairty;
  274.     if (m_ulNumEntries == 0)
  275.     {
  276. retVal = HXR_FAIL;
  277.     }
  278.     if (ulTableIdx >= m_ulNumEntries)
  279.     {
  280. ulTableIdx = m_ulNumEntries - 1;
  281.     }
  282.     // Scan Forward
  283.     while (((ulTableIdx + 1) < (m_ulNumEntries - 1)) &&
  284.    (m_pIndexTable[ulTableIdx + 1].m_ulTime < ulTargetTime))
  285.     {
  286. ulTableIdx++;
  287.     }
  288.     // Scan Backwards
  289.     while ((ulTableIdx > 0) &&
  290.    (m_pIndexTable[ulTableIdx].m_ulTime > ulTargetTime))
  291.     {
  292. ulTableIdx--;
  293.     }
  294.     // Report results
  295.     ulTime = m_pIndexTable[ulTableIdx].m_ulTime;
  296.     ulOffset = m_pIndexTable[ulTableIdx].m_ulOffset;
  297.     if (m_pAuxDataTable)
  298.     {
  299. if (ppAuxData)
  300. {
  301.     *ppAuxData = m_pAuxDataTable[ulTableIdx];
  302. }
  303.     }
  304.     
  305.     retVal = (m_ulRangeTime < ulTargetTime) ? HXR_AT_END : HXR_OK;
  306.     return retVal;
  307. }
  308. /****************************************************************************
  309.  *  HasIndex
  310.  */
  311. BOOL CStreamIndexTable::HasIndex(UINT32 ulTime)
  312. {
  313.     return (ulTime <= m_ulLastTime);
  314. }
  315. /****************************************************************************
  316.  *  UpdateGranularity
  317.  */
  318. void CStreamIndexTable::UpdateGranularity(UINT32 ulTimeGranularity)
  319. {
  320.     m_ulTimeGranulairty = ulTimeGranularity;
  321. }
  322. /****************************************************************************
  323.  *  UpdateTimeRange
  324.  */
  325. void CStreamIndexTable::UpdateTimeRange(UINT32 ulTime)
  326. {
  327.     if (m_ulRangeTime < ulTime)
  328.     {
  329. m_ulRangeTime = ulTime;
  330.     }
  331. }
  332. /****************************************************************************
  333.  *  Close
  334.  */
  335. void CStreamIndexTable::Close(void)
  336. {
  337.     _Close();
  338. }
  339. /****************************************************************************
  340.  *  Private Methods
  341.  */
  342. /****************************************************************************
  343.  *  _Close
  344.  */
  345. void CStreamIndexTable::_Close(void)
  346. {
  347.     m_ulNumEntries = 0;
  348.     m_ulMaxEntries = 0;
  349.     m_ulLastTime = 0;
  350.     m_ulRangeTime = 0;
  351.         
  352.     HX_VECTOR_DELETE(m_pIndexTable);
  353.     HX_VECTOR_DELETE(m_pAuxDataTable);
  354. }