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

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

Symbian

开发平台：

C/C++

qttrkmgr.cpp：源码内容
  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. /****************************************************************************
  37.  *  Defines
  38.  */
  39. //#define _IGNORE_HINTS
  41. #define INV_HINT_TRACK_IDX  0xFFFFFFFF
  42. #define INV_STREAM_NUM     0xFFFF
  45. /****************************************************************************
  46.  *  Includes
  47.  */
  48. #include "qttrkmgr.h"
  49. #include "qttrack.h"
  52. /****************************************************************************
  53.  *  Class CTrackManager
  54.  */
  55. /****************************************************************************
  56.  *  Constructor/Destructor
  57.  */
  58. CQTTrackManager::CQTTrackManager(void)
  59.     : m_uNumTracks(0)
  60.     , m_uNumStreams(0)
  61.     , m_pTrackTable(NULL)
  62.     , m_pStreamToTrackMap(NULL)
  63.     , m_pTrackAtomList(new CHXSimpleList)
  64.     , m_pHintTrackIdxList(new CHXSimpleList)
  65.     , m_bSubscriptionWindowClosed(FALSE)
  66.     , m_bHintTracksActive(FALSE)
  67.     , m_bHinted(FALSE)
  68.     , m_pIodsAtom(NULL)
  69.     , m_pFtypAtom(NULL)
  70.     , m_FType(QT_FTYPE_UNKNOWN)
  71.     , m_EType(QT_ETYPE_UNKNOWN)
  72. {
  73.     HX_ASSERT(m_pTrackAtomList);
  74.     HX_ASSERT(m_pHintTrackIdxList);
  75. }
  78. CQTTrackManager::~CQTTrackManager()
  79. {
  80.     Clear();
  81. }
  84. /****************************************************************************
  85.  *  Main Interface
  86.  */
  87. /****************************************************************************
  88.  *  ManageTracks
  89.  */
  90. HX_RESULT CQTTrackManager::ManageTracks(CQTAtom *pRootAtom)
  91. {
  92.     if ((m_pTrackAtomList == NULL) ||
  93. (m_pHintTrackIdxList == NULL))
  94.     {
  95. HX_ASSERT(!"shouldn't happen");
  96. return HXR_UNEXPECTED;
  97.     }
  99.     AddTracks(pRootAtom);
  101.     if (m_FType == QT_FTYPE_UNKNOWN)
  102.     {
  103. m_FType = QT_FTYPE_QT;
  104.     }
  106.     return HXR_OK;
  107. }
  109. /****************************************************************************
  110.  *  ReadyTracks
  111.  */
  112. HX_RESULT CQTTrackManager::ReadyTracks(BOOL bIgnoreHintTracks,
  113.        BOOL bFallbackToTracks)
  114. {
  115.     HX_RESULT retVal = HXR_OK;
  117. #ifdef _IGNORE_HINTS
  118.     bIgnoreHintTracks = TRUE;
  119. #endif // _IGNORE_HINTS
  121.     if ((m_pTrackAtomList == NULL) ||
  122. (m_pHintTrackIdxList == NULL) ||
  123. (m_pTrackAtomList->GetCount() == 0))
  124.     {
  125. HX_ASSERT(!"shouldn't happen");
  126. retVal = HXR_CORRUPT_FILE;
  127.     }
  129.     if (SUCCEEDED(retVal))
  130.     {
  131. m_uNumStreams = 0;
  132. m_uNumTracks = m_pTrackAtomList->GetCount();
  134. if (!bIgnoreHintTracks)
  135. {
  136.     m_uNumStreams = m_pHintTrackIdxList->GetCount();
  137. }
  139. m_bHinted = (m_uNumStreams != 0);
  140. m_bHintTracksActive = m_bHinted;
  142. DecideHintTrackActivation(bFallbackToTracks);
  144. if (m_uNumStreams <= 0)
  145. {
  146.     retVal = HXR_FAIL; // No Streamable Tracks
  147. }
  148.     }
  150.     // Allocate Tables
  151.     if (SUCCEEDED(retVal))
  152.     {
  153. HX_ASSERT(!m_pTrackTable);
  154. HX_ASSERT(!m_pStreamToTrackMap);
  156. m_pStreamToTrackMap = new CQTStream [m_uNumStreams];
  157. m_pTrackTable = new CQTTrackTable [m_uNumTracks];
  159. if ((m_pStreamToTrackMap == NULL) ||
  160.     (m_pTrackTable == NULL))
  161. {
  162.     retVal = HXR_OUTOFMEMORY;
  163. }
  164.     }
  166.     // Fill Tables with info.
  167.     if (SUCCEEDED(retVal))
  168.     {
  169. LISTPOSITION HintTrackIdxListPosition;
  170. LISTPOSITION TrackAtomListPosition;
  171. ULONG32 ulHintTrackIdx = INV_HINT_TRACK_IDX;
  172. UINT16 uStreamTrackCount = 0;
  173. UINT16 uHintTrackCount = 0;
  174. CQTAtom* pTrackAtom;
  175. UINT16 uTrackIdx = 0;
  177. HintTrackIdxListPosition = m_pHintTrackIdxList->GetHeadPosition();
  178. TrackAtomListPosition = m_pTrackAtomList->GetHeadPosition();
  180. if (HintTrackIdxListPosition)
  181. {
  182.     ulHintTrackIdx = (UINT32) m_pHintTrackIdxList->GetNext(
  183. HintTrackIdxListPosition);
  184. }
  186. do
  187. {
  188.     pTrackAtom = (CQTAtom*) m_pTrackAtomList->GetNext(
  189. TrackAtomListPosition);
  191.     HX_ASSERT(pTrackAtom);
  193.     if (uTrackIdx == ulHintTrackIdx)
  194.     {
  195. // This is a hint track
  196. if (m_bHintTracksActive)
  197. {
  198.     retVal = CreateHintTrack(pTrackAtom,
  199.      uTrackIdx,
  200.      uStreamTrackCount);
  201.     if (retVal != HXR_OK)
  202.     {
  203. break;
  204.     }
  205. }
  207. uHintTrackCount++;
  209. if (uHintTrackCount < m_pHintTrackIdxList->GetCount())
  210. {
  211.     ulHintTrackIdx = (UINT32) m_pHintTrackIdxList->GetNext(
  212.     HintTrackIdxListPosition);
  213. }
  214.     }
  215.     else
  216.     {
  217. // This a standard track
  218. m_pTrackTable[uTrackIdx].m_pTrack = new CQTTrack(pTrackAtom);
  219. if (m_pTrackTable[uTrackIdx].m_pTrack == NULL)
  220. {
  221.     retVal = HXR_OUTOFMEMORY;
  222.     break;
  223. }
  225.      m_pTrackTable[uTrackIdx].m_pTrackAtom = pTrackAtom;
  226. pTrackAtom->AddRef();
  228. if (!m_bHintTracksActive)
  229. {
  230.     HX_ASSERT(uStreamTrackCount < m_uNumStreams);
  232.     if (uStreamTrackCount < m_uNumStreams)
  233.     {
  234. m_pStreamToTrackMap[uStreamTrackCount].m_pQTTrack =
  235.     m_pTrackTable[uTrackIdx].m_pTrack;
  237. uStreamTrackCount++;
  238.     }
  239. }
  241. // For now keep references to all "standard" tracks.
  242. // To do : reference only "standard" tracks referenced
  243. //         by hint tracks - when hint tracks are active
  244. m_pTrackTable[uTrackIdx].m_uRefCount++;
  245.     }
  247.     if (m_pTrackTable[uTrackIdx].m_pTrack)
  248.     {
  249. m_pTrackTable[uTrackIdx].m_pTrack->AddRef();
  250.     }
  252.     uTrackIdx++;
  253. } while (uTrackIdx < m_uNumTracks);
  254.     }
  256.     // Free Unreferenced Standard Tracks
  257.     if (SUCCEEDED(retVal))
  258.     {
  259. UINT16 uTrackIdx;
  261. for (uTrackIdx = 0; uTrackIdx < m_uNumTracks; uTrackIdx++)
  262. {
  263.     if (m_pTrackTable[uTrackIdx].m_uRefCount == 0)
  264.     {
  265. HX_RELEASE(m_pTrackTable[uTrackIdx].m_pTrack);
  266. HX_RELEASE(m_pTrackTable[uTrackIdx].m_pTrackAtom);
  267.     }
  268. }
  269.     }
  271.     if (FAILED(retVal))
  272.     {
  273. Clear();
  274.     }
  276.     return retVal;
  277. }
  279. /****************************************************************************
  280.  *  CloseTracks
  281.  */
  282. void CQTTrackManager::CloseTracks(void)
  283. {
  284.     UINT16 uTrackIdx;
  286.     if (m_pTrackTable)
  287.     {
  288. for (uTrackIdx = 0; uTrackIdx < m_uNumTracks; uTrackIdx++)
  289. {
  290.     if (m_pTrackTable[uTrackIdx].m_pTrack)
  291.     {
  292. m_pTrackTable[uTrackIdx].m_pTrack->Close();
  293. m_pTrackTable[uTrackIdx].m_pTrack->Release();
  294. m_pTrackTable[uTrackIdx].m_pTrack = NULL;
  295.     }
  296.     HX_RELEASE(m_pTrackTable[uTrackIdx].m_pTrackAtom);
  297. }
  298.     }
  300.     Clear();
  301. }
  303. /****************************************************************************
  304.  *  ResetTracks - reset what's done in ReadyTracks()
  305.  */
  306. void CQTTrackManager::ResetTracks(void)
  307. {
  308.     if (m_pTrackTable)
  309.     {
  310. for (UINT16 uTrackIdx = 0; uTrackIdx < m_uNumTracks; uTrackIdx++)
  311. {
  312.     if (m_pTrackTable[uTrackIdx].m_pTrack)
  313.     {
  314. m_pTrackTable[uTrackIdx].m_pTrack->Close();
  315. m_pTrackTable[uTrackIdx].m_pTrack->Release();
  316. m_pTrackTable[uTrackIdx].m_pTrack = NULL;
  317.     }
  319.     HX_RELEASE(m_pTrackTable[uTrackIdx].m_pTrackAtom);
  320. }
  321.     }
  323.     HX_VECTOR_DELETE(m_pTrackTable);
  324.     HX_VECTOR_DELETE(m_pStreamToTrackMap);
  326.     m_uNumTracks = 0;
  327.     m_uNumStreams = 0;
  328. }
  330. /****************************************************************************
  331.  *  InitTracks
  332.  */
  333. HX_RESULT CQTTrackManager::InitTracks(CQTFileFormat *pFileFormat,
  334.       CQTPacketAssembler *pPacketAssembler,
  335.       CQTPacketizerFactory* pPacketizerFactory,
  336.       const char* pProtocol)
  337. {
  338.     UINT16 uTrackIdx;
  339.     HX_RESULT retVal = HXR_OK;
  341.     if (m_pTrackTable)
  342.     {
  343. UINT16 uStreamNum;
  344. BOOL bSomeStreamsDeactivated = FALSE;
  346. for (uTrackIdx = 0;
  347.      SUCCEEDED(retVal) && (uTrackIdx < m_uNumTracks);
  348.      uTrackIdx++)
  349. {
  350.     if (m_pTrackTable[uTrackIdx].m_pTrack)
  351.     {
  352. retVal = m_pTrackTable[uTrackIdx].m_pTrack->Init(pFileFormat,
  353.  pPacketAssembler,
  354.  pPacketizerFactory,
  355.  pProtocol);
  357. uStreamNum = GetTrackStreamNum(m_pTrackTable[uTrackIdx].m_pTrack);
  359. if (uStreamNum < m_uNumStreams)
  360. {
  361.     m_pStreamToTrackMap[uStreamNum].m_bActive = (retVal == HXR_OK);
  362.     bSomeStreamsDeactivated = bSomeStreamsDeactivated ||
  363.       (!m_pStreamToTrackMap[uStreamNum].m_bActive);
  365.     if ((retVal == HXR_IGNORE) ||
  366. (retVal == HXR_NO_DATA))
  367.     {
  368. retVal = HXR_OK;
  369.     }
  370. }
  371.     }
  372. }
  374. // Some streams could have been
  375.         // disabled during initialization - remove the inactive ones
  376. if (SUCCEEDED(retVal) && bSomeStreamsDeactivated)
  377. {
  378.     retVal = RemoveInactiveStreams();
  380. #ifdef QTCONFIG_ALTERNATE_STREAMS
  381.     // Return remaining streams to inactive (unsubscribed) state
  382.     if (SUCCEEDED(retVal))
  383.     {
  384. for (uTrackIdx = 0; uTrackIdx < m_uNumStreams; uTrackIdx++)
  385. {
  386.     m_pStreamToTrackMap[uTrackIdx].m_bActive = FALSE;
  387. }
  389. m_bSubscriptionWindowClosed = FALSE;
  390.     }
  391. #endif // QTCONFIG_ALTERNATE_STREAMS
  392. }
  394. // After track initialization, release all Track Atoms from
  395. // the track manager
  396. for (uTrackIdx = 0;
  397.      uTrackIdx < m_uNumTracks;
  398.      uTrackIdx++)
  399. {
  400.     HX_RELEASE(m_pTrackTable[uTrackIdx].m_pTrackAtom);
  401. }
  402.     }
  403.     else
  404.     {
  405. retVal = HXR_UNEXPECTED;
  406.     }
  408.     if (SUCCEEDED(retVal))
  409.     {
  410.         // Release Lists
  411. DeleteTrackAtomList();
  412. HX_DELETE(m_pHintTrackIdxList);
  413.     }
  415.     return retVal;
  416. }
  418. #ifdef QTCONFIG_ALTERNATE_STREAMS
  419. /****************************************************************************
  420.  *  AddStreamToGroup
  421.  */
  422. HX_RESULT CQTTrackManager::AddStreamToGroup(UINT16 uStreamNumber,
  423.     UINT16 uGroup,
  424.     ULONG32 ulBitrate)
  425. {
  426.     HX_RESULT retVal = HXR_FAIL;
  428.     HX_ASSERT(m_pStreamToTrackMap);
  429.     HX_ASSERT(uStreamNumber < m_uNumStreams);
  431.     if (uStreamNumber < m_uNumStreams)
  432.     {
  433. m_pStreamToTrackMap[uStreamNumber].m_uGroup = uGroup;
  434. m_pStreamToTrackMap[uStreamNumber].m_ulBitrate = ulBitrate;
  435. m_pStreamToTrackMap[uStreamNumber].m_bGroupped = TRUE;
  437. retVal = HXR_OK;
  438.     }
  440.     return retVal;
  441. }
  443. /****************************************************************************
  444.  *  SubscribeDefault
  445.  */
  446. HX_RESULT CQTTrackManager::SubscribeDefault(void)
  447. {
  448.     UINT16 uStrmIdx;
  449.     HX_RESULT retVal = HXR_OUTOFMEMORY;
  450.     BOOL* pVisitedArray = new BOOL [m_uNumStreams];
  452.     HX_ASSERT(m_pStreamToTrackMap);
  453.     HX_ASSERT(pVisitedArray);
  455.     if (pVisitedArray)
  456.     {
  457. for (uStrmIdx = 0; uStrmIdx < m_uNumStreams; uStrmIdx++)
  458. {
  459.     pVisitedArray[uStrmIdx] = FALSE;
  460. }
  462. retVal = HXR_OK;
  463.     }
  465.     if (SUCCEEDED(retVal))
  466.     {
  467. for (uStrmIdx = 0; uStrmIdx < m_uNumStreams; uStrmIdx++)
  468. {
  469.     if (!pVisitedArray[uStrmIdx])
  470.     {
  471. if (m_pStreamToTrackMap[uStrmIdx].m_bGroupped)
  472. {
  473.     // Activate the highest bitrate stream in the group
  474.     UINT16 uSubIdx;
  475.     UINT16 uGroup = m_pStreamToTrackMap[uStrmIdx].m_uGroup;
  476.     ULONG32 ulHighBitrate = m_pStreamToTrackMap[uStrmIdx].m_ulBitrate;
  477.     UINT16 uHighIdx = uStrmIdx;
  479.     m_pStreamToTrackMap[uStrmIdx].m_bActive = FALSE;
  481.     for (uSubIdx = uStrmIdx + 1; uSubIdx < m_uNumStreams; uSubIdx++)
  482.     {
  483. if (m_pStreamToTrackMap[uStrmIdx].m_uGroup == uGroup)
  484. {
  485.     m_pStreamToTrackMap[uSubIdx].m_bActive = FALSE;
  487.     if (m_pStreamToTrackMap[uSubIdx].m_ulBitrate > ulHighBitrate)
  488.     {
  489. ulHighBitrate = m_pStreamToTrackMap[uSubIdx].m_ulBitrate;
  490. uHighIdx = uSubIdx;
  491.     }
  493.     pVisitedArray[uSubIdx] = TRUE;
  494. }
  495.     }
  497.     m_pStreamToTrackMap[uHighIdx].m_bActive = TRUE;
  498. }
  499. else
  500. {
  501.     m_pStreamToTrackMap[uStrmIdx].m_bActive = TRUE;
  502. }
  504. pVisitedArray[uStrmIdx] = TRUE;
  505.     }
  506. }
  507.     }
  509.     HX_VECTOR_DELETE(pVisitedArray);
  511.     return retVal;
  512. }
  514. /****************************************************************************
  515.  *  Subscribe
  516.  */
  517. HX_RESULT CQTTrackManager::Subscribe(UINT16 uStreamNum)
  518. {
  519.     HX_RESULT retVal = HXR_UNEXPECTED;
  521.     if (!m_bSubscriptionWindowClosed)
  522.     {
  523. HX_ASSERT(m_pStreamToTrackMap);
  524. HX_ASSERT(uStreamNum < m_uNumStreams);
  526. retVal = HXR_FAIL;
  528. if (uStreamNum < m_uNumStreams)
  529. {
  530.     if (m_pStreamToTrackMap[uStreamNum].m_bGroupped)
  531.     {
  532. UINT16 uStrmIdx;
  533. UINT16 uGroup = m_pStreamToTrackMap[uStreamNum].m_uGroup;
  535. // There can be only one stream subscribed in a group
  536. for (uStrmIdx = 0; uStrmIdx < m_uNumStreams; uStrmIdx++)
  537. {
  538.     if (m_pStreamToTrackMap[uStrmIdx].m_uGroup == uGroup)
  539.     {
  540. m_pStreamToTrackMap[uStrmIdx].m_bActive = FALSE;
  541.     }
  542. }
  543.     }
  545.     m_pStreamToTrackMap[uStreamNum].m_bActive = TRUE;
  547.     retVal = HXR_OK;
  548. }
  549.     }
  551.     return retVal;
  552. }
  554. /****************************************************************************
  555.  *  Unsubscribe
  556.  */
  557. HX_RESULT CQTTrackManager::Unsubscribe(UINT16 uStreamNum)
  558. {
  559.     HX_RESULT retVal = HXR_UNEXPECTED;
  561.     if (!m_bSubscriptionWindowClosed)
  562.     {
  563. HX_ASSERT(uStreamNum < m_uNumStreams);
  565. retVal = HXR_FAIL;
  566. if (uStreamNum < m_uNumStreams)
  567. {
  568.     m_pStreamToTrackMap[uStreamNum].m_bActive = FALSE;
  570.     retVal = HXR_OK;
  571. }
  572.     }
  574.     return retVal;
  575. }
  576. #else // QTCONFIG_ALTERNATE_STREAMS
  578. HX_RESULT CQTTrackManager::AddStreamToGroup(UINT16 uStreamNumber,
  579.     UINT16 uGroup,
  580.     ULONG32 ulBitrate)
  581. {
  582.     return HXR_NOTIMPL;
  583. }
  585. HX_RESULT CQTTrackManager::SubscribeDefault(void)
  586. {
  587.     return HXR_NOTIMPL;
  588. }
  590. HX_RESULT CQTTrackManager::Subscribe(UINT16 uStreamNum)
  591. {
  592.     return HXR_NOTIMPL;
  593. }
  595. HX_RESULT CQTTrackManager::Unsubscribe(UINT16 uStreamNum)
  596. {
  597.     return HXR_NOTIMPL;
  598. }
  600. #endif // QTCONFIG_ALTERNATE_STREAMS
  602. /****************************************************************************
  603.  *  RemoveInactiveStreams
  604.  */
  605. HX_RESULT CQTTrackManager::RemoveInactiveStreams(BOOL bLeaveReferences)
  606. {
  607.     HX_RESULT retVal = HXR_FAIL;
  609.     HX_ASSERT(m_pStreamToTrackMap);
  611.     UINT16 uActiveStreamCount = GetNumActiveStreams();
  613.     if (uActiveStreamCount > 0)
  614.     {
  615. CQTStream* pNewStreamToTrackMap = NULL;
  617. retVal = HXR_OK;
  619. if (!bLeaveReferences)
  620. {
  621.     pNewStreamToTrackMap = new CQTStream [uActiveStreamCount];
  623.     retVal = HXR_OUTOFMEMORY;
  624.     if (pNewStreamToTrackMap)
  625.     {
  626. retVal = HXR_OK;
  627.     }
  628. }
  630. if (SUCCEEDED(retVal))
  631. {
  632.     UINT16 uStrmIdx;
  633.     UINT16 uNewStrmIdx = 0;
  635.     for (uStrmIdx = 0; uStrmIdx < m_uNumStreams; uStrmIdx++)
  636.     {
  637. if (m_pStreamToTrackMap[uStrmIdx].m_bActive)
  638. {
  639.     if (!bLeaveReferences)
  640.     {
  641. HX_ASSERT(uNewStrmIdx < uActiveStreamCount);
  643. pNewStreamToTrackMap[uNewStrmIdx] =
  644.     m_pStreamToTrackMap[uStrmIdx];
  645. uNewStrmIdx++;
  646.     }
  647. }
  648. else
  649. {
  650.     ReleaseTrack(m_pStreamToTrackMap[uStrmIdx].m_pQTTrack);
  651. }
  652.     }
  654.     if (!bLeaveReferences)
  655.     {
  656. delete [] m_pStreamToTrackMap;
  657. m_pStreamToTrackMap = pNewStreamToTrackMap;
  658. m_uNumStreams = uActiveStreamCount;
  659.     }
  660. }
  662. m_bSubscriptionWindowClosed = TRUE;
  663.     }
  665.     return retVal;
  666. }
  668. /****************************************************************************
  669.  *  IsStreamTrack
  670.  */
  671. BOOL CQTTrackManager::IsStreamTrack(CQTTrack* pTrack)
  672. {
  673.     UINT16 uStreamCount = 0;
  674.     CQTStream* pStreamTracer = m_pStreamToTrackMap;
  676.     HX_ASSERT(pTrack);
  678.     while (uStreamCount < m_uNumStreams)
  679.     {
  680. if (pTrack == pStreamTracer->m_pQTTrack)
  681. {
  682.     return TRUE;
  683. }
  685. pStreamTracer++;
  686. uStreamCount++;
  687.     }
  689.     return FALSE;
  690. }
  693. UINT16 CQTTrackManager::GetTrackStreamNum(CQTTrack* pTrack)
  694. {
  695.     UINT16 uStreamCount = 0;
  696.     CQTStream* pStreamTracer = m_pStreamToTrackMap;
  698.     HX_ASSERT(pTrack);
  700.     while (uStreamCount < m_uNumStreams)
  701.     {
  702. if (pTrack == pStreamTracer->m_pQTTrack)
  703. {
  704.     return uStreamCount;
  705. }
  707. pStreamTracer++;
  708. uStreamCount++;
  709.     }
  711.     return INV_STREAM_NUM;
  712. }
  715. /****************************************************************************
  716.  *  GetTrackById
  717.  */
  718. CQTTrack* CQTTrackManager::GetTrackById(ULONG32 ulTrackID)
  719. {
  720.     UINT16 uTrackCount = 0;
  721.     CQTTrackTable* pTableTracer = m_pTrackTable;
  723.     while (uTrackCount < m_uNumTracks)
  724.     {
  725. if (pTableTracer->m_pTrack && (ulTrackID == pTableTracer->m_pTrack->GetID()))
  726. {
  727.     return pTableTracer->m_pTrack;
  728. }
  730. uTrackCount++;
  731. pTableTracer++;
  732.     }
  734.     return NULL;
  735. }
  737. /****************************************************************************
  738.  *  GetAtomById
  739.  */
  740. CQTAtom* CQTTrackManager::GetTrackAtomById(ULONG32 ulTrackID)
  741. {
  742.     UINT16 uTrackCount = 0;
  743.     CQTTrackTable* pTableTracer = m_pTrackTable;
  745.     while (uTrackCount < m_uNumTracks)
  746.     {
  747. if (ulTrackID == pTableTracer->m_pTrack->GetID())
  748. {
  749.     return pTableTracer->m_pTrackAtom;
  750. }
  752. uTrackCount++;
  753. pTableTracer++;
  754.     }
  756.     return NULL;
  757. }
  759. /****************************************************************************
  760.  *  GetTrackAtomHdlr
  761.  */
  762. CQT_hdlr_Atom* CQTTrackManager::GetTrackAtomHdlr(CQT_trak_Atom* pTrakAtom)
  763. {
  764.     CQT_mdia_Atom* pMdiaAtom;
  765.     CQT_hdlr_Atom* pHdlrAtom = NULL;
  767.     pMdiaAtom = (CQT_mdia_Atom*) pTrakAtom->FindPresentChild(QT_mdia);
  768.     if (pMdiaAtom)
  769.     {
  770. pHdlrAtom = (CQT_hdlr_Atom*) pMdiaAtom->FindPresentChild(QT_hdlr);
  771.     }
  773.     return pHdlrAtom;
  774. }
  776. /****************************************************************************
  777.  *  GetTrackAtomStbl
  778.  */
  779. CQT_stbl_Atom* CQTTrackManager::GetTrackAtomStbl(CQT_trak_Atom* pTrakAtom)
  780. {
  781.     CQT_mdia_Atom* pMdiaAtom;
  782.     CQT_hdlr_Atom* pMinfAtom;
  783.     CQT_stbl_Atom* pStblAtom = NULL;
  785.     pMdiaAtom = (CQT_mdia_Atom*) pTrakAtom->FindPresentChild(QT_mdia);
  786.     if (pMdiaAtom)
  787.     {
  788. pMinfAtom = (CQT_hdlr_Atom*) pMdiaAtom->FindPresentChild(QT_minf);
  789. if (pMinfAtom)
  790. {
  791.     pStblAtom = (CQT_stbl_Atom*) pMinfAtom->FindPresentChild(QT_stbl);
  792. }
  793.     }
  795.     return pStblAtom;
  796. }
  798. /****************************************************************************
  799.  *  IsHintTrackAtom
  800.  */
  801. BOOL CQTTrackManager::IsHintTrackAtom(CQT_trak_Atom* pTrakAtom)
  802. {
  803.     CQT_hdlr_Atom* pHdlrAtom = GetTrackAtomHdlr(pTrakAtom);
  805.     if (pHdlrAtom &&
  806. /*** MBO: To strict for some files
  807. (pHdlrAtom->Get_CompType() == QT_mhlr) &&
  808. ***/
  809. (pHdlrAtom->Get_CompSubtype() == QT_hint))
  810.     {
  811. return TRUE;
  812.     }
  814.     return FALSE;
  815. }
  817. /****************************************************************************
  818.  *  IsNonEmptyTrackAtom
  819.  */
  820. BOOL CQTTrackManager::IsNonEmptyTrackAtom(CQT_trak_Atom* pTrakAtom)
  821. {
  822.     CQT_SampleSize_Manager sampleSize;
  823.     CQT_stbl_Atom* pStblAtom = GetTrackAtomStbl(pTrakAtom);
  825.     if (pStblAtom)
  826.     {
  827. if (sampleSize.Init(pStblAtom) == HXR_OK)
  828. {
  829.     return TRUE;
  830. }
  831.     }
  833.     return FALSE;
  834. }
  837. /****************************************************************************
  838.  *  Private Methods
  839.  */
  840. /****************************************************************************
  841.  *  AddTracks
  842.  */
  843. void CQTTrackManager::AddTracks(CQTAtom *pRootAtom)
  844. {
  845.     UINT16 uChildCount;
  847.     if (pRootAtom->GetType() == QT_trak)
  848.     {
  849. BOOL bAdd = TRUE;
  851. if (IsHintTrackAtom((CQT_trak_Atom *) pRootAtom))
  852. {
  853.     bAdd = IsNonEmptyTrackAtom((CQT_trak_Atom*) pRootAtom);
  855.     if (bAdd)
  856.     {
  857. m_pHintTrackIdxList->AddTail(
  858.     (void *) m_pTrackAtomList->GetCount());
  859.     }
  860. }
  862. if (bAdd)
  863. {
  864.     m_pTrackAtomList->AddTail(pRootAtom);
  865.     pRootAtom->AddRef();
  866. }
  867.     }
  868.     else if (((pRootAtom->GetType() == QT_HXROOT) ||
  869.       (pRootAtom->GetType() == QT_moov)) &&
  870.      (uChildCount = pRootAtom->GetPresentChildCount()))
  871.     {
  872. CQTAtom::ChildIterator i = pRootAtom->BeginChildren();
  874. do
  875. {
  876.     AddTracks(*i);
  877.     if ((--uChildCount) == 0)
  878.     {
  879. break;
  880.     }
  882.     ++i;
  883. } while (TRUE);
  884.     }
  885.     else if (pRootAtom->GetType() == QT_iods)
  886.     {
  887. HX_ASSERT(m_pIodsAtom == NULL);
  888. if (m_pIodsAtom == NULL)
  889. {
  890.     m_pIodsAtom = (CQT_iods_Atom*) pRootAtom;
  891.     m_pIodsAtom->AddRef();
  892.     m_FType = QT_FTYPE_MP4;
  893. }
  894.     }
  895.     else if (pRootAtom->GetType() == QT_ftyp)
  896.     {
  897. HX_ASSERT(m_pFtypAtom == NULL);
  898. if (m_pFtypAtom == NULL)
  899. {
  900.     UINT32 ulBrand;
  901.     BOOL bKeepLooking;
  902.     UINT32 ulCompBrandIdx = 0;
  903.     UINT32 ulNumCompBrands = 0;
  904.     m_pFtypAtom = (CQT_ftyp_Atom*) pRootAtom;
  905.     m_pFtypAtom->AddRef();
  907.     ulBrand = m_pFtypAtom->Get_MajorBrand();
  908.     ulNumCompBrands = m_pFtypAtom->Get_NumCompatibleBrands();
  910.     do
  911.     {
  912. bKeepLooking = FALSE;
  914. switch (ulBrand)
  915. {
  916. case QT_isom:
  917. case QT_3gp4:
  918. case QT_3gp5:
  919. case QT_mp41:
  920. case QT_mp42:
  921. case QT_mmp4:
  922. case QT_m4a:
  923.     m_FType = QT_FTYPE_MP4;
  924.     break;
  926. default:
  927.     if (ulCompBrandIdx < ulNumCompBrands)
  928.     {
  929. ulBrand = m_pFtypAtom->Get_CompatibleBrand(ulCompBrandIdx);
  930.      ulCompBrandIdx++;
  931. bKeepLooking = TRUE;
  932.     }
  933.     break;
  934. }
  935.     } while (bKeepLooking);
  936. }
  937.     }
  938. }
  940. /****************************************************************************
  941.  *  DeleteTrackAtomList
  942.  */
  943. void CQTTrackManager::DeleteTrackAtomList(void)
  944. {
  945.     if (m_pTrackAtomList)
  946.     {
  947. CQTAtom *pAtom;
  949. while (!m_pTrackAtomList->IsEmpty())
  950. {
  951.     pAtom = (CQTAtom*) m_pTrackAtomList->RemoveHead();
  952.     HX_ASSERT(pAtom);
  953.     pAtom->Release();
  954. }
  956. delete m_pTrackAtomList;
  957. m_pTrackAtomList = NULL;
  958.     }
  959. }
  961. /****************************************************************************
  962.  *  Clear
  963.  */
  964. void CQTTrackManager::Clear(void)
  965. {
  966.     HX_VECTOR_DELETE(m_pTrackTable);
  967.     HX_VECTOR_DELETE(m_pStreamToTrackMap);
  969.     DeleteTrackAtomList();
  970.     HX_DELETE(m_pHintTrackIdxList);
  972.     HX_RELEASE(m_pIodsAtom);
  973.     HX_RELEASE(m_pFtypAtom);
  975.     m_uNumTracks = 0;
  976.     m_uNumStreams = 0;
  977. }
  980. /****************************************************************************
  981.  *  GetNumActiveStreams
  982.  */
  983. UINT16 CQTTrackManager::GetNumActiveStreams(void)
  984. {
  985.     UINT16 uStrmIdx;
  986.     UINT16 uActiveCount = 0;
  988.     HX_ASSERT(m_pStreamToTrackMap);
  990.     for (uStrmIdx = 0; uStrmIdx < m_uNumStreams; uStrmIdx++)
  991.     {
  992. if (m_pStreamToTrackMap[uStrmIdx].m_bActive)
  993. {
  994.     uActiveCount++;
  995. }
  996.     }
  998.     return uActiveCount;
  999. }
  1002. /****************************************************************************
  1003.  *  ReleaseTrack
  1004.  */
  1005. void CQTTrackManager::ReleaseTrack(CQTTrack* pQTTrack)
  1006. {
  1007.     // Remove Track from the Track Table
  1008.     if (m_pTrackTable)
  1009.     {
  1010. UINT16 uTrackCount = 0;
  1011. CQTTrackTable* pTableTracer = m_pTrackTable;
  1013. while (uTrackCount < m_uNumTracks)
  1014. {
  1015.     if (pTableTracer->m_pTrack == pQTTrack)
  1016.     {
  1017. HX_RELEASE(pTableTracer->m_pTrack);
  1018. HX_RELEASE(pTableTracer->m_pTrackAtom);
  1019. break;
  1020.     }
  1022.     uTrackCount++;
  1023.     pTableTracer++;
  1024. }
  1025.     }
  1027.     // Remove The track from the Stream Map (if there)
  1028.     if (m_pStreamToTrackMap)
  1029.     {
  1030. UINT16 uStreamCount = 0;
  1031. CQTStream* pStreamTracer = m_pStreamToTrackMap;
  1033. while (uStreamCount < m_uNumStreams)
  1034. {
  1035.     if (pStreamTracer->m_pQTTrack == pQTTrack)
  1036.     {
  1037. pStreamTracer->m_pQTTrack = NULL;
  1038. pStreamTracer->m_bActive = FALSE;
  1039. pStreamTracer->m_bGroupped = FALSE;
  1040. pStreamTracer->m_uGroup = 0;
  1041. pStreamTracer->m_ulBitrate = 0;
  1043. break;
  1044.     }
  1046.     uStreamCount++;
  1047.     pStreamTracer++;
  1048. }
  1049.     }
  1050. }
  1054. /****************************************************************************
  1055.  *  CQTTrackManager::CQTTrackTable
  1056.  */
  1057. /****************************************************************************
  1058.  *  Destructor
  1059.  */
  1060. CQTTrackManager::CQTTrackTable::~CQTTrackTable()
  1061. {
  1062.     if (m_pTrack)
  1063.     {
  1064. m_pTrack->Release();
  1065.     }
  1067.     if (m_pTrackAtom)
  1068.     {
  1069. m_pTrackAtom->Release();
  1070.     }
  1071. }