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

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

Symbian

开发平台：

C/C++

qtatmmgs.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_MP4_AUDIO
  41. #define TRACK_SDP_CHUNK_SIZE 512
  43. /****************************************************************************
  44.  *  Includes
  45.  */
  46. #include "qtatmmgs.h"
  47. #include "qttrkmgr.h"
  48. #include "mp4desc.h"
  49. #include "hxstrutl.h"
  51. #include "rtptypes.h"
  52. #include "rtsputil.h"
  54. #ifndef QTCONFIG_SPEED_OVER_SIZE
  55. #include "qtatmmgs_inline.h"
  56. #endif // QTCONFIG_SPEED_OVER_SIZE
  58. /****************************************************************************
  59.  *  Track Edit Manager
  60.  */
  61. #define QT_MAX_MOVIE_DURATION 0xFFFFFFFF
  63. /****************************************************************************
  64.  *  Constructor/Destructor
  65.  */
  66. CQT_TrackEdit_Manager::CQT_TrackEdit_Manager(void)
  67.     : m_pEditListAtom(NULL)
  68.     , m_ulMovieTimeScale(1)
  69.     , m_ulMediaTimeScale(1)
  70.     , m_ulNumEdits(0)
  71.     , m_ulCurrentEditIdx(0)
  72.     , m_ulCurrentEditTime(0)
  73.     , m_ulCurrentInEditTime(0)
  74.     , m_ulCurrentEditDuration(QT_MAX_MOVIE_DURATION)
  75.     , m_ulCurrentMediaStartTime(0)
  76. {
  77.     ;
  78. }
  80. CQT_TrackEdit_Manager::~CQT_TrackEdit_Manager(void)
  81. {
  82.     HX_RELEASE(m_pEditListAtom);
  83. }
  85. /****************************************************************************
  86.  *  Main Interface
  87.  */
  88. /****************************************************************************
  89.  *  Init
  90.  */
  91. HX_RESULT CQT_TrackEdit_Manager::Init(CQTAtom* pAtom,
  92.       ULONG32 ulMovieTimeScale,
  93.       ULONG32 ulMediaTimeScale)
  94. {
  95.     HX_RESULT retVal = HXR_OK;
  97.     HX_ASSERT(ulMovieTimeScale);
  98.     HX_ASSERT(ulMediaTimeScale);
  99.     
  100.     m_ulMovieTimeScale = ulMovieTimeScale;
  101.     m_ulMediaTimeScale = ulMediaTimeScale;
  102.     m_ulNumEdits = 0;
  103.     
  104.     HX_RELEASE(m_pEditListAtom);
  106.     if (pAtom)
  107.     {
  108. if (pAtom->GetType() == QT_elst)
  109. {
  110.     m_pEditListAtom = (CQT_elst_Atom*) pAtom;
  111. }
  112. else
  113. {
  114.     m_pEditListAtom = (CQT_elst_Atom*) pAtom->FindPresentChild(QT_elst);
  115. }
  117. if (m_pEditListAtom)
  118. {
  119.     m_pEditListAtom->AddRef();
  120.     m_ulNumEdits = m_pEditListAtom->Get_NumEntries();
  121. }
  122.     }
  124.     if (!EstablishByTime(0))
  125.     {
  126. retVal = HXR_FAIL;
  128. // Reset State
  129. HX_RELEASE(m_pEditListAtom);
  130. m_ulNumEdits = 0;
  131. EstablishByTime(0);
  132.     }
  134.     return retVal;
  135. }
  138. /****************************************************************************
  139.  *  EstablishByMovieTime
  140.  */
  141. BOOL CQT_TrackEdit_Manager::EstablishByTime(ULONG32 ulTime)
  142. {
  143.     m_ulCurrentEditIdx = 0;
  144.     m_ulCurrentEditTime = 0;
  145.     m_ulCurrentInEditTime = (ULONG32) (ulTime / 1000.0 *
  146.        m_ulMediaTimeScale +
  147.        0.5);
  149.     if (m_ulNumEdits > 0)
  150.     {
  151. m_ulCurrentEditDuration = MovieToMediaUnits(
  152.     m_pEditListAtom->Get_TrackDuration(0));
  153. m_ulCurrentMediaStartTime = m_pEditListAtom->Get_MediaTime(0);
  154. return SequenceToEdit();
  155.     }
  156.     else
  157.     {
  158. m_ulCurrentEditDuration = QT_MAX_MOVIE_DURATION;
  159. m_ulCurrentMediaStartTime = 0;
  160.     }
  162.     return TRUE;
  163. }
  165. /****************************************************************************
  166.  *  Private Methods
  167.  */
  168. /****************************************************************************
  169.  *  SequenceToEdit
  170.  */
  171. BOOL CQT_TrackEdit_Manager::SequenceToEdit(void)
  172. {
  173.     while ((m_ulCurrentMediaStartTime == QT_EMPTY_EDIT) ||
  174.    (m_ulCurrentInEditTime >= m_ulCurrentEditDuration))
  175.     {
  176. m_ulCurrentEditIdx++;
  178. if (m_ulCurrentEditIdx < m_ulNumEdits)
  179. {
  180.     if (m_ulCurrentMediaStartTime != QT_EMPTY_EDIT)
  181.     {
  182. m_ulCurrentInEditTime -= m_ulCurrentEditDuration;
  183.     }
  184.     m_ulCurrentEditTime += m_ulCurrentEditDuration;
  185.     m_ulCurrentEditDuration = MovieToMediaUnits(
  186. m_pEditListAtom->Get_TrackDuration(
  187.     m_ulCurrentEditIdx));
  188.     m_ulCurrentMediaStartTime = m_pEditListAtom->Get_MediaTime(
  189.     m_ulCurrentEditIdx);
  190. }
  191. else
  192. {
  193.     m_ulCurrentEditIdx--;
  194.     return FALSE;
  195. }
  196.     }
  198.     return TRUE;
  199. }
  202. /****************************************************************************
  203.  *  Sample To Chunk Manager
  204.  */
  205. #define QT_MAX_SAMPLES_PER_CHUNK 0xFFFFFFFF
  206. #define QT_NULL_CHUNK_NUM 0
  208. /****************************************************************************
  209.  *  Constructor/Destructor
  210.  */
  211. CQT_SampleToChunk_Manager::CQT_SampleToChunk_Manager(void)
  212.     : m_ulNumEntries(0)
  213.     , m_pSampleToChunkAtom(NULL)
  214.     , m_ulSampleInChunkNum(0)
  215.     , m_ulCurrentChunk(0)
  216.     , m_ulNextEntryChunk(QT_NULL_CHUNK_NUM)
  217.     , m_ulCurrentEntryIdx(0)
  218.     , m_ulSamplesPerChunk(QT_MAX_SAMPLES_PER_CHUNK)
  219.     , m_ulSampleNumber(0)
  220.     , m_ulSampleDescIdx(QT_BAD_IDX)
  221. #ifdef _STCO_ZERO_BASED_IQ
  222.     , m_ulChunkNumOffset(0)
  223. #endif // _STCO_ZERO_BASED_IQ
  224. {
  225.     ;
  226. }
  228. CQT_SampleToChunk_Manager::~CQT_SampleToChunk_Manager()
  229. {
  230.     HX_RELEASE(m_pSampleToChunkAtom);
  231. }
  233. /****************************************************************************
  234.  *  Init
  235.  */
  236. HX_RESULT CQT_SampleToChunk_Manager::Init(CQTAtom* pAtom)
  237. {
  238.     HX_RESULT retVal = HXR_OK;
  240.     HX_RELEASE(m_pSampleToChunkAtom);
  241.     m_ulNumEntries = 0;
  242.     m_ulSampleNumber = 0;
  244.     if (pAtom)
  245.     {
  246. if (pAtom->GetType() == QT_stsc)
  247. {
  248.     m_pSampleToChunkAtom = (CQT_stsc_Atom*) pAtom;
  249. }
  250. else
  251. {
  252.     m_pSampleToChunkAtom = (CQT_stsc_Atom*) pAtom->FindPresentChild(QT_stsc);
  253. }
  255. if (m_pSampleToChunkAtom)
  256. {
  257.     m_pSampleToChunkAtom->AddRef();
  258.     m_ulNumEntries = m_pSampleToChunkAtom->Get_NumEntries();
  259. }
  260.     }
  262.     if (m_ulNumEntries == 0)
  263.     {
  264. EstablishBySample(0);
  265. retVal = HXR_NO_DATA;
  266.     }
  267.     else
  268.     {
  269. m_ulSampleNumber = 2;  // Force full initialization
  270. retVal = EstablishBySample(1) ? HXR_OK : HXR_FAIL;
  272. #ifdef _STCO_ZERO_BASED_IQ
  273. m_ulChunkNumOffset = 0;
  275. if (retVal == HXR_OK)
  276. {
  277.     if ((m_ulCurrentChunk == 0) ||
  278. (m_ulSampleDescIdx == ((ULONG32) -1)))
  279.     {
  280. m_ulCurrentChunk = 1;
  281. m_ulNextEntryChunk++;
  282. m_ulSampleDescIdx++;
  283. m_ulChunkNumOffset = 1;
  284.     }
  285. }
  286. #endif // _STCO_ZERO_BASED_IQ
  287.     }
  289.     return retVal;
  290. }
  292. /****************************************************************************
  293.  *  EstablishBySample
  294.  */
  295. BOOL CQT_SampleToChunk_Manager::EstablishBySample(ULONG32 ulSampleNum)
  296. {
  297.     if (m_ulNumEntries > 0)
  298.     {
  299. HX_ASSERT(ulSampleNum);
  301. if (ulSampleNum >= m_ulSampleNumber)
  302. {
  303.     // Search Forward
  304.     m_ulSampleInChunkNum += (ulSampleNum - m_ulSampleNumber);
  305.     m_ulSampleNumber = ulSampleNum;
  307.     return SequenceToChunk();
  308. }
  309. else if (ulSampleNum > (m_ulSampleNumber >> 1))
  310. {
  311.     // Search in Reverse
  312.     m_ulSampleInChunkNum = m_ulSamplesPerChunk -
  313.    m_ulSampleInChunkNum +
  314.    m_ulSampleNumber -
  315.    ulSampleNum +
  316.    1;
  317.     m_ulSampleNumber = ulSampleNum;
  319.     if (SequenceReverseToChunk())
  320.     {
  321. m_ulSampleInChunkNum = m_ulSamplesPerChunk -
  322.        m_ulSampleInChunkNum +
  323.        1;
  325. return TRUE;
  326.     }
  327. }
  328. else
  329. {
  330.     // Search Forward from the beginning
  331.     m_ulSampleInChunkNum = ulSampleNum;
  332.     m_ulCurrentEntryIdx = 0;
  333.     m_ulCurrentChunk = m_pSampleToChunkAtom->Get_FirstChunk(0)
  334. #ifdef _STCO_ZERO_BASED_IQ
  335.        + m_ulChunkNumOffset
  336. #endif // _STCO_ZERO_BASED_IQ
  337.        ;
  338.     m_ulSamplesPerChunk = m_pSampleToChunkAtom->Get_SamplesPerChunk(0);
  339.     m_ulSampleDescIdx = m_pSampleToChunkAtom->Get_SampleDescID(0) - 1
  340. #ifdef _STCO_ZERO_BASED_IQ
  341.         + m_ulChunkNumOffset
  342. #endif // _STCO_ZERO_BASED_IQ
  343.        ;
  345.     if (m_ulNumEntries > 1)
  346.     {
  347. m_ulNextEntryChunk = m_pSampleToChunkAtom->
  348.     Get_FirstChunk(1)
  349. #ifdef _STCO_ZERO_BASED_IQ
  350.     + m_ulChunkNumOffset
  351. #endif // _STCO_ZERO_BASED_IQ
  352.     ;
  353.     }
  354.     else
  355.     {
  356. // No more chunk entries
  357. m_ulNextEntryChunk = QT_NULL_CHUNK_NUM;
  358.     }
  360.     m_ulSampleNumber = ulSampleNum;
  362.     return SequenceToChunk();
  363. }
  364.     }
  365.     else
  366.     {
  367. m_ulSampleNumber = 0;
  368. m_ulSampleInChunkNum = 0;
  369. m_ulCurrentChunk = 0;
  370. m_ulSamplesPerChunk = QT_MAX_SAMPLES_PER_CHUNK;
  371. m_ulSampleDescIdx = QT_BAD_IDX;
  372. #ifdef _STCO_ZERO_BASED_IQ
  373. m_ulChunkNumOffset = 0;
  374. #endif // _STCO_ZERO_BASED_IQ
  375.     }
  377.     return FALSE;
  378. }
  380. /****************************************************************************
  381.  *  Private Methods
  382.  */
  383. /****************************************************************************
  384.  *  SequenceToChunk
  385.  */
  386. #ifdef STCMGR_USE_MODULUS_SEQUENCING
  388. // This sequencing algorithm has better efficiency (than non-modulus 
  389. // sequencing) on files containing many chunks per table entry and/or those 
  390. // whose progression through the table is irratic (has skipps).
  391. BOOL CQT_SampleToChunk_Manager::SequenceToChunk(void)
  392. {
  393.     ULONG32 ulTargetChunk;
  394.     BOOL bEntryIdxChanged;
  396.     if (m_ulSampleInChunkNum > m_ulSamplesPerChunk)
  397.     {
  398. bEntryIdxChanged = FALSE;
  400. do
  401. {
  402.     if (m_ulSamplesPerChunk == 0)
  403.     {
  404. ulTargetChunk = m_ulCurrentChunk + 1;
  405.     }
  406.     else
  407.     {
  408. ulTargetChunk = m_ulCurrentChunk +
  409.      (m_ulSampleInChunkNum - 1) /
  410. m_ulSamplesPerChunk;
  411.     }
  413.     if ((ulTargetChunk >= m_ulNextEntryChunk) &&
  414. (m_ulNextEntryChunk != QT_NULL_CHUNK_NUM))
  415.     {
  416. m_ulSampleInChunkNum -= (m_ulNextEntryChunk -
  417.  m_ulCurrentChunk) *
  418. m_ulSamplesPerChunk;
  419. m_ulCurrentChunk = m_ulNextEntryChunk;
  420. m_ulCurrentEntryIdx++;
  421. bEntryIdxChanged = TRUE;
  423. m_ulSamplesPerChunk = m_pSampleToChunkAtom->
  424.     Get_SamplesPerChunk(m_ulCurrentEntryIdx);
  426. if ((m_ulCurrentEntryIdx + 1) < m_ulNumEntries)
  427. {
  428.     m_ulNextEntryChunk = m_pSampleToChunkAtom->
  429. Get_FirstChunk(m_ulCurrentEntryIdx + 1);
  430. }
  431. else
  432. {
  433.     // No more chunk entries
  434.     m_ulNextEntryChunk = QT_NULL_CHUNK_NUM;
  435. }
  436.     }
  437.     else
  438.     {
  439. m_ulCurrentChunk = ulTargetChunk;
  440. if (m_ulSamplesPerChunk != 0)
  441. {  
  442.     m_ulSampleInChunkNum = (m_ulSampleInChunkNum - 1) %
  443.     m_ulSamplesPerChunk +
  444.     1;
  445. }
  446. else
  447. {
  448.     // encountered empty chunk at the end of table
  449.     return FALSE;
  450. }
  451.     }
  452. } while (m_ulSampleInChunkNum > m_ulSamplesPerChunk);
  454. if (bEntryIdxChanged)
  455. {
  456.     m_ulSampleDescIdx = m_pSampleToChunkAtom->
  457. Get_SampleDescID(m_ulCurrentEntryIdx) - 1
  458. #ifdef _STCO_ZERO_BASED_IQ
  459. + m_ulChunkNumOffset
  460. #endif // _STCO_ZERO_BASED_IQ
  461.        ;
  462. }
  463.     }
  465.     return TRUE;
  466. }
  468. #else // STCMGR_USE_MODULUS_SEQUENCING
  470. // This sequencing algorithm is more efficient for files
  471. // containing fewer chunks per table entry and/or those
  472. // whose progression through the chunks involves fewer
  473. // skipps.
  474. BOOL CQT_SampleToChunk_Manager::SequenceToChunk(void)
  475. {
  476.     BOOL bEntryIdxChanged;
  478.     if (m_ulSampleInChunkNum > m_ulSamplesPerChunk)
  479.     {
  480. bEntryIdxChanged = FALSE;
  482. do
  483. {
  484.     m_ulSampleInChunkNum = m_ulSampleInChunkNum - m_ulSamplesPerChunk;
  485.     m_ulCurrentChunk++;
  486.     
  487.     if (m_ulCurrentChunk == m_ulNextEntryChunk)
  488.     {
  489. m_ulCurrentEntryIdx++;
  490. bEntryIdxChanged = TRUE;
  492. m_ulSamplesPerChunk = m_pSampleToChunkAtom->
  493.     Get_SamplesPerChunk(m_ulCurrentEntryIdx);
  495. if ((m_ulCurrentEntryIdx + 1) < m_ulNumEntries)
  496. {
  497.     m_ulNextEntryChunk = m_pSampleToChunkAtom->
  498. Get_FirstChunk(m_ulCurrentEntryIdx + 1)
  499. #ifdef _STCO_ZERO_BASED_IQ
  500. + m_ulChunkNumOffset
  501. #endif // _STCO_ZERO_BASED_IQ
  502. ;
  503. }
  504. else
  505. {
  506.     // No more chunk entries
  507.     m_ulNextEntryChunk = QT_NULL_CHUNK_NUM;
  508. }
  509.     }
  510.     else if ((m_ulSamplesPerChunk == 0) && 
  511. (m_ulNextEntryChunk == QT_NULL_CHUNK_NUM))
  512.     {
  513. return FALSE;
  514.     }
  515. } while (m_ulSampleInChunkNum > m_ulSamplesPerChunk);
  517. if (bEntryIdxChanged)
  518. {
  519.     m_ulSampleDescIdx = m_pSampleToChunkAtom->
  520. Get_SampleDescID(m_ulCurrentEntryIdx) - 1
  521. #ifdef _STCO_ZERO_BASED_IQ
  522. + m_ulChunkNumOffset
  523. #endif // _STCO_ZERO_BASED_IQ
  524. ;
  525. }
  526.     }
  528.     return TRUE;
  529. }
  531. #endif // STCMGR_USE_MODULUS_SEQUENCING
  533. /****************************************************************************
  534.  *  SequenceReverseToChunk
  535.  */
  536. BOOL CQT_SampleToChunk_Manager::SequenceReverseToChunk(void)
  537. {
  538.     ULONG32 ulEntryFirstChunk;
  539.     BOOL bEntryIdxChanged;
  541.     if (m_ulSampleInChunkNum > m_ulSamplesPerChunk)
  542.     {
  543. bEntryIdxChanged = FALSE;
  545. ulEntryFirstChunk = m_pSampleToChunkAtom->
  546.     Get_FirstChunk(m_ulCurrentEntryIdx);
  548. do
  549. {
  550.     m_ulSampleInChunkNum = m_ulSampleInChunkNum - m_ulSamplesPerChunk;
  551.     m_ulCurrentChunk--;
  552.     
  553.     if (m_ulCurrentChunk < ulEntryFirstChunk)
  554.     {
  555. if (m_ulCurrentEntryIdx == 0)
  556. {
  557.     return FALSE;
  558. }
  560. m_ulCurrentEntryIdx--;
  561. bEntryIdxChanged = TRUE;
  563. m_ulSamplesPerChunk = m_pSampleToChunkAtom->
  564.     Get_SamplesPerChunk(m_ulCurrentEntryIdx);
  565. ulEntryFirstChunk = m_pSampleToChunkAtom->
  566.     Get_FirstChunk(m_ulCurrentEntryIdx);
  567.     }
  568. } while (m_ulSampleInChunkNum > m_ulSamplesPerChunk);
  570. if (bEntryIdxChanged)
  571. {
  572.     m_ulSampleDescIdx = m_pSampleToChunkAtom->
  573. Get_SampleDescID(m_ulCurrentEntryIdx) - 1
  574. #ifdef _STCO_ZERO_BASED_IQ
  575. + m_ulChunkNumOffset
  576. #endif // _STCO_ZERO_BASED_IQ
  577. ;
  578. }
  580. if ((m_ulCurrentEntryIdx + 1) < m_ulNumEntries)
  581. {
  582.     m_ulNextEntryChunk = m_pSampleToChunkAtom->
  583. Get_FirstChunk(m_ulCurrentEntryIdx + 1)
  584. #ifdef _STCO_ZERO_BASED_IQ
  585. + m_ulChunkNumOffset
  586. #endif // _STCO_ZERO_BASED_IQ
  587. ;
  588. }
  589. else
  590. {
  591.     // No more chunk entries
  592.     m_ulNextEntryChunk = QT_NULL_CHUNK_NUM;
  593. }
  594.     }
  596.     return TRUE;
  597. }
  600. #define INVALID_COMP_SAMPLE_NUM     0xFFFFFFFF
  602. /****************************************************************************
  603.  *  Time To Sample Manager
  604.  */
  605. /****************************************************************************
  606.  *  Constructor/Destructor
  607.  */
  608. CQT_TimeToSample_Manager::CQT_TimeToSample_Manager(void)
  609.     : m_pTimeToSampleAtom(NULL)
  610.     , m_pCompOffsetAtom(NULL)
  611.     , m_pSyncSampleAtom(NULL)
  612.     , m_ulNumEntries(0)
  613.     , m_ulCurrentEntryIdx(0)
  614.     , m_ulSampleNumber(0)
  615.     , m_ulSamplesLeftInEntry(0)
  616.     , m_ulSampleDuration(0)
  617.     , m_ulLastSyncTime(0)
  618.     , m_ulNumCompEntries(0)
  619.     , m_ulCurrentCompEntryIdx(0)
  620.     , m_ulCompSampleNumber(INVALID_COMP_SAMPLE_NUM)
  621.     , m_ulSamplesLeftInCompEntry(0)
  622.     , m_ulCompOffset(0)
  623.     , m_ulNumSyncEntries(0)
  624.     , m_ulCurrentSyncEntryIdx(0)
  625.     , m_ulSyncSampleNumber(0)
  626. #ifdef _STSS_ZERO_BASED_IQ
  627.     , m_ulKeyFrameNumOffset(0)
  628. #endif // _STSS_ZERO_BASED_IQ
  629. {
  630.     ;
  631. }
  633. CQT_TimeToSample_Manager::~CQT_TimeToSample_Manager()
  634. {
  635.     HX_RELEASE(m_pTimeToSampleAtom);
  636.     HX_RELEASE(m_pCompOffsetAtom);
  637.     HX_RELEASE(m_pSyncSampleAtom);
  638. }
  640. /****************************************************************************
  641.  *  Init
  642.  */
  643. HX_RESULT CQT_TimeToSample_Manager::Init(CQTAtom* pAtom)
  644. {
  645.     HX_RESULT retVal = HXR_OK;
  647.     HX_RELEASE(m_pTimeToSampleAtom);
  648.     HX_RELEASE(m_pCompOffsetAtom);
  649.     HX_RELEASE(m_pSyncSampleAtom);
  650.     
  651.     m_ulNumEntries = 0;
  652.     m_ulCompSampleNumber = INVALID_COMP_SAMPLE_NUM;
  654.     if (pAtom)
  655.     {
  656. if (pAtom->GetType() == QT_stts)
  657. {
  658.     m_pTimeToSampleAtom = (CQT_stts_Atom*) pAtom;
  659. }
  660. else
  661. {
  662.     m_pTimeToSampleAtom = (CQT_stts_Atom*) pAtom->
  663.     FindPresentChild(QT_stts);
  664.     m_pCompOffsetAtom = (CQT_ctts_Atom*) pAtom->
  665.     FindPresentChild(QT_ctts);
  666. }
  668. if (m_pTimeToSampleAtom)
  669. {
  670.     m_pTimeToSampleAtom->AddRef();
  671.     m_ulNumEntries = m_pTimeToSampleAtom->Get_NumEntries();
  672. }
  674. if (m_pCompOffsetAtom)
  675. {
  676.     m_pCompOffsetAtom->AddRef();
  677.     m_ulNumCompEntries = m_pCompOffsetAtom->Get_NumEntries();
  678. }
  679.     }
  681.     if (m_ulNumEntries > 0)
  682.     {
  683. if (pAtom != m_pTimeToSampleAtom)
  684. {
  685.     m_pSyncSampleAtom = (CQT_stss_Atom*) pAtom->
  686.     FindPresentChild(QT_stss);
  687.     if (m_pSyncSampleAtom)
  688.     {
  689. ULONG32 ulNumSyncEntries = 0;
  691. ulNumSyncEntries = m_pSyncSampleAtom->Get_NumEntries();
  693. #ifdef _STSS_ZERO_BASED_IQ
  694. if (ulNumSyncEntries > 0)
  695. {
  696.     ULONG32 ulKeyFrameSample;
  698.     ulKeyFrameSample = m_pSyncSampleAtom->
  699.     Get_SampleNum(0);
  700.     if (ulKeyFrameSample == 0)
  701.     {
  702. m_ulKeyFrameNumOffset = 1;
  703.     }
  704. }
  705. #endif // _STSS_ZERO_BASED_IQ
  707. #ifdef _STSS_TRACK_SYNC
  708. m_ulNumSyncEntries = ulNumSyncEntries;
  709. #endif // _STSS_TRACK_SYNC
  711. m_pSyncSampleAtom->AddRef();
  712.     }
  713. }
  714.     }
  716.     retVal = EstablishByMediaTime(0) ? HXR_OK : HXR_NO_DATA;
  718.     return retVal;
  719. }
  721. /****************************************************************************
  722.  *  EstablishAtKeyByMediaTime
  723.  */
  724. BOOL CQT_TimeToSample_Manager::EstablishAtKeyByMediaTime(ULONG32 ulMediaTime)
  725. {
  726.     ULONG32 ulSyncEntryIdx;
  727.     ULONG32 ulKeyFrameSample;
  728.     ULONG32 ulNumSyncEntries = 0;
  729.     BOOL bEstablished = FALSE;
  731.     if (EstablishByMediaTime(ulMediaTime))
  732.     {
  733. ulNumSyncEntries = m_ulNumSyncEntries;
  734. if ((ulNumSyncEntries == 0) && m_pSyncSampleAtom)
  735. {
  736.     ulNumSyncEntries = m_pSyncSampleAtom->Get_NumEntries();
  737. }
  739. bEstablished = (ulNumSyncEntries == 0);
  741. for (ulSyncEntryIdx = m_ulCurrentSyncEntryIdx; 
  742.      ulSyncEntryIdx < ulNumSyncEntries;
  743.      ulSyncEntryIdx++)
  744. {
  745.     ulKeyFrameSample = m_pSyncSampleAtom->
  746. Get_SampleNum(ulSyncEntryIdx) + m_ulKeyFrameNumOffset;
  747.     while (ulKeyFrameSample >= m_ulSampleNumber)
  748.     {
  749. if (ulKeyFrameSample == m_ulSampleNumber)
  750. {
  751.     // Key Sample lined up with the Sample
  752.     return TRUE;
  753. }
  755. // We'll try to line up the Sample with the key sample
  756. if (!AdvanceBySample())
  757. {
  758.     return FALSE;
  759. }
  761. // Keep track of how for beyond initally requested time
  762. // the key frame was found.
  763. m_ulLastSyncTime += m_ulSampleDuration;
  764.     }
  765. }
  766.     }
  768.     return bEstablished;
  769. }
  771. /****************************************************************************
  772.  *  EstablishByMediaTime
  773.  */
  774. BOOL CQT_TimeToSample_Manager::EstablishByMediaTime(ULONG32 ulMediaTime)
  775. {
  776.     BOOL bIsEstablished;
  778.     m_ulCurrentEntryIdx = 0;
  779.     m_ulLastSyncTime = 0;
  780.     m_ulCurrentSyncEntryIdx = 0;
  781.     
  782.     if (m_ulNumEntries > 0)
  783.     {
  784. m_ulSampleNumber = 0;
  785. m_ulSamplesLeftInEntry = m_pTimeToSampleAtom->Get_SampleCount(0);
  786. m_ulSampleDuration = m_pTimeToSampleAtom->Get_SampleDuration(0);
  787.     }
  788.     else
  789.     {
  790. m_ulSampleNumber = 0;
  791. m_ulSamplesLeftInEntry = 0;
  792. m_ulSampleDuration = 0;
  793.     }
  795.     if (m_ulNumSyncEntries > 0)
  796.     {
  797. m_ulSyncSampleNumber = m_pSyncSampleAtom->Get_SampleNum(0) +
  798.        m_ulKeyFrameNumOffset;
  799.     }
  800.     else
  801.     {
  802. m_ulSyncSampleNumber = 0;
  803.     }
  805.     bIsEstablished = EstablishCompBySample(0);
  807.     if (bIsEstablished)
  808.     {
  809. bIsEstablished = AdvanceBySample();
  810.     }
  812.     if (bIsEstablished)
  813.     {
  814. while (ulMediaTime > 0)
  815. {
  816.     if (ulMediaTime >= m_ulSampleDuration)
  817.     {
  818. ulMediaTime -= m_ulSampleDuration;
  819.     }
  820.     else
  821.     {
  822. m_ulLastSyncTime = m_ulSampleDuration - ulMediaTime;
  823. ulMediaTime = 0;
  824.     }
  826.     if (!AdvanceBySample())
  827.     {
  828. bIsEstablished = FALSE;
  829. break;
  830.     }
  831. }
  832.     }
  834.     return bIsEstablished;
  835. }
  837. /****************************************************************************
  838.  *  EstablishCompByOffset
  839.  */
  840. BOOL CQT_TimeToSample_Manager::EstablishCompBySample(ULONG32 ulSampleNum)
  841. {
  842.     BOOL bIsEstablished = TRUE;
  844.     if (m_ulNumCompEntries == 0)
  845.     {
  846. return bIsEstablished;
  847.     }
  849.     if (m_ulCompSampleNumber >= ulSampleNum)
  850.     {
  851. m_ulCompSampleNumber = 0;
  852. m_ulCurrentCompEntryIdx = 0;
  853. m_ulSamplesLeftInCompEntry = m_pCompOffsetAtom->Get_SampleCount(0);
  854. m_ulCompOffset = m_pCompOffsetAtom->Get_SampleOffset(0);
  855.     }
  857.     while (m_ulCompSampleNumber < ulSampleNum)
  858.     {
  859. if (!(bIsEstablished = AdvanceCompBySample()))
  860. {
  861.     break;
  862. }
  863.     }
  865.     return bIsEstablished;
  866. }
  869. /****************************************************************************
  870.  *  Sample Size Manager
  871.  */
  872. /****************************************************************************
  873.  *  Constructor/Destructor
  874.  */
  875. CQT_SampleSize_Manager::CQT_SampleSize_Manager(void)
  876.     : m_pSampleSizeAtom(NULL)
  877.     , m_ulGenericSize(0)
  878.     , m_ulNumEntries(0)
  879.     , m_ulSampleSize(0)
  880.     , m_ulChunkSize(0)
  881.     , m_ulChunkSampleOffset(0)
  882.     , m_ulChunkStartSampleNum(QT_BAD_IDX)
  883.     , m_ulSampleNum(QT_BAD_IDX)
  884. {
  885.     ;
  886. }
  888. CQT_SampleSize_Manager::~CQT_SampleSize_Manager()
  889. {
  890.     HX_RELEASE(m_pSampleSizeAtom);
  891. }
  893. /****************************************************************************
  894.  *  Init
  895.  */
  896. HX_RESULT CQT_SampleSize_Manager::Init(CQTAtom *pAtom)
  897. {
  898.     HX_RESULT retVal = HXR_OK;
  900.     HX_RELEASE(m_pSampleSizeAtom);
  901.     m_ulGenericSize = 0;
  902.     m_ulSampleSize = 0;
  903.     m_ulChunkSampleOffset = 0;
  904.     m_ulChunkSize = 0;
  905.     m_ulNumEntries = 0;
  906.     m_ulChunkStartSampleNum = QT_BAD_IDX;
  907.     m_ulSampleNum = QT_BAD_IDX;
  909.     if (pAtom)
  910.     {
  911. if (pAtom->GetType() == QT_stsz)
  912. {
  913.     m_pSampleSizeAtom = (CQT_stsz_Atom*) pAtom;
  914. }
  915. else
  916. {
  917.     m_pSampleSizeAtom = (CQT_stsz_Atom*) pAtom->FindPresentChild(QT_stsz);
  918. }
  920. if (m_pSampleSizeAtom)
  921. {
  922.     m_pSampleSizeAtom->AddRef();
  923.     m_ulGenericSize = m_pSampleSizeAtom->Get_SampleSize();
  924.     m_ulNumEntries = m_pSampleSizeAtom->Get_NumEntries();
  925. }
  926.     }
  928.     if (m_ulGenericSize == 0)
  929.     {
  930. if (m_ulNumEntries == 0)
  931. {
  932.     retVal = HXR_NO_DATA;
  933. }
  934.     }
  935.     else
  936.     {
  937. m_ulSampleSize = m_ulGenericSize;
  938. // All samples have the same size - do not need the table
  939. HX_RELEASE(m_pSampleSizeAtom);
  940. m_ulNumEntries = 0;
  941.     }
  943.     return retVal;
  944. }
  946. /****************************************************************************
  947.  *  EstablishBySample
  948.  */
  949. BOOL CQT_SampleSize_Manager::EstablishBySample(ULONG32 ulSampleNum, 
  950.        ULONG32 ulChunkSampleNum,
  951.        ULONG32 ulSamplesPerChunk)
  952. {
  953.     ULONG32 ulChunkStartSampleNum;
  954.     ULONG32 ulChunkEndSampleNum;
  956.     if ((ulChunkSampleNum > 0) &&
  957. (ulSampleNum >= ulChunkSampleNum))
  958.     {
  959. if (ulSamplesPerChunk < ulChunkSampleNum)
  960. {
  961.     ulSamplesPerChunk = ulChunkSampleNum;
  962. }
  964. if (m_ulGenericSize)
  965. {
  966.     m_ulChunkSampleOffset = (ulChunkSampleNum - 1) * m_ulGenericSize;
  967.     m_ulChunkSize = ulSamplesPerChunk * m_ulGenericSize;
  968.     return TRUE;
  969. }
  971. ulChunkStartSampleNum = ulSampleNum - ulChunkSampleNum;
  972. ulChunkEndSampleNum = ulChunkStartSampleNum + ulSamplesPerChunk;
  974. if (ulChunkEndSampleNum
  975.     <= m_ulNumEntries)
  976. {
  977.     // Convert to 0 based index for efficiency
  978.     ulSampleNum--;
  979.     
  980.     if (m_ulChunkStartSampleNum == ulChunkStartSampleNum)
  981.     {
  982. if (m_ulSampleNum == ulSampleNum)   // m_ulSampleNum is 1 based
  983. {
  984.     m_ulChunkSampleOffset += m_ulSampleSize;
  985.     m_ulSampleSize = m_pSampleSizeAtom->Get_SampleSize(m_ulSampleNum++);
  986.     return TRUE;
  987. }
  988. else if (m_ulSampleNum == (ulSampleNum + 1))
  989. {
  990.     // Already computed
  991.     return TRUE;
  992. }
  993.     }
  995.     // Convert to 0 based index for efficiency
  996.     ulChunkSampleNum--;
  997.     
  998.     m_ulSampleSize = m_pSampleSizeAtom->Get_SampleSize(ulSampleNum);
  999.     m_ulChunkStartSampleNum = ulChunkStartSampleNum;
  1000.     m_ulSampleNum = ulSampleNum + 1;
  1001.     
  1002.     for (m_ulChunkSampleOffset = 0;
  1003.  ulChunkStartSampleNum < ulSampleNum;
  1004.  ulChunkStartSampleNum++)
  1005.     {
  1006. m_ulChunkSampleOffset += m_pSampleSizeAtom->
  1007.     Get_SampleSize(ulChunkStartSampleNum);
  1008.     }
  1010.     /*** Not needed
  1011.     m_ulChunkSize = m_ulChunkSampleOffset;
  1012.     do
  1013.     {
  1014. m_ulChunkSize += m_pSampleSizeAtom->
  1015.     Get_SampleSize(ulChunkStartSampleNum++);
  1016.     } while (ulChunkStartSampleNum < ulChunkEndSampleNum);
  1017.     ***/
  1018.     
  1019.     return TRUE;
  1020. }
  1021.     }
  1023.     return FALSE;
  1024. }
  1027. /****************************************************************************
  1028.  *  Chunk To Offset Manager
  1029.  */
  1030. /****************************************************************************
  1031.  *  Constructor/Destructor
  1032.  */
  1033. CQT_ChunkToOffset_Manager::CQT_ChunkToOffset_Manager(void)
  1034.     : m_pChunkToOffsetAtom(NULL)
  1035.     , m_ulChunkOffset(0)
  1036.     , m_ulNumEntries(0)
  1037. {
  1038.     ;
  1039. }
  1041. CQT_ChunkToOffset_Manager::~CQT_ChunkToOffset_Manager()
  1042. {
  1043.     HX_RELEASE(m_pChunkToOffsetAtom);
  1044. }
  1046. /****************************************************************************
  1047.  *  Main Interface
  1048.  */
  1049. HX_RESULT CQT_ChunkToOffset_Manager::Init(CQTAtom* pAtom)
  1050. {
  1051.     HX_RESULT retVal = HXR_OK;
  1053.     HX_RELEASE(m_pChunkToOffsetAtom);
  1054.     m_ulChunkOffset = 0;
  1055.     m_ulNumEntries = 0;
  1057.     if (pAtom)
  1058.     {
  1059. if (pAtom->GetType() == QT_stco)
  1060. {
  1061.     m_pChunkToOffsetAtom = (CQT_stco_Atom*) pAtom;
  1062. }
  1063. else
  1064. {
  1065.     m_pChunkToOffsetAtom = (CQT_stco_Atom*) pAtom->FindPresentChild(QT_stco);
  1066. }
  1068. if (m_pChunkToOffsetAtom)
  1069. {
  1070.     m_pChunkToOffsetAtom->AddRef();
  1071.     m_ulNumEntries = m_pChunkToOffsetAtom->Get_NumEntries();
  1072. }
  1073.     }
  1075.     if (m_ulNumEntries == 0)
  1076.     {
  1077. retVal = HXR_FAIL;
  1078. HX_RELEASE(m_pChunkToOffsetAtom);
  1079.     }
  1080.    
  1081.     return retVal;
  1082. }
  1085. /****************************************************************************
  1086.  *  Sample Description Manager
  1087.  */
  1088. /****************************************************************************
  1089.  *  Constructor/Destructor
  1090.  */
  1091. CQT_SampleDescription_Manager::CQT_SampleDescription_Manager(void)
  1092.     : m_ulSampleDescIdx(QT_BAD_IDX)
  1093.     , m_pSampleDescriptionAtom(NULL)
  1094.     , m_pSampleDesc(NULL)
  1095.     , m_ulDataRefIdx(QT_BAD_IDX)
  1096.     , m_ulDataFormat(0)
  1097.     , m_ulRTPTimeScale(0)
  1098.     , m_lTimeStampOffset(0)
  1099.     , m_lSequenceNumOffset(0)
  1100.     , m_ulNumEntries(0)
  1101.     , m_ulDataRefIdxOffset(1)
  1102. {
  1103.     ;
  1104. }
  1106. CQT_SampleDescription_Manager::~CQT_SampleDescription_Manager()
  1107. {
  1108.     HX_RELEASE(m_pSampleDescriptionAtom);
  1109. }
  1111. /****************************************************************************
  1112.  *  Main Interface Manager
  1113.  */
  1114. HX_RESULT CQT_SampleDescription_Manager::Init(CQTAtom* pAtom)
  1115. {
  1116.     HX_RESULT retVal = HXR_OK;
  1118.     HX_RELEASE(m_pSampleDescriptionAtom);
  1119.     m_ulSampleDescIdx = QT_BAD_IDX;
  1120.     m_pSampleDesc = NULL;
  1121.     m_ulDataRefIdx = QT_BAD_IDX;
  1122.     m_ulDataFormat = 0;
  1123.     m_ulRTPTimeScale = 0;
  1124.     m_lTimeStampOffset = 0;
  1125.     m_lSequenceNumOffset = 0;
  1126.     m_ulNumEntries = 0;
  1128.     if (pAtom)
  1129.     {
  1130. if (pAtom->GetType() == QT_stsd)
  1131. {
  1132.     m_pSampleDescriptionAtom = (CQT_stsd_Atom*) pAtom;
  1133. }
  1134. else
  1135. {
  1136.     m_pSampleDescriptionAtom = (CQT_stsd_Atom*) pAtom->FindPresentChild(QT_stsd);
  1137. }
  1139. if (m_pSampleDescriptionAtom)
  1140. {
  1141.     m_pSampleDescriptionAtom->AddRef();
  1142.     m_ulNumEntries = m_pSampleDescriptionAtom->Get_NumEntries();
  1143. }
  1144.     }
  1146. #ifdef _STSD_ZERO_BASED_IQ
  1147.     ULONG32 ulIdx;
  1149.     for (ulIdx = 0; ulIdx < m_ulNumEntries; ulIdx++)
  1150.     {
  1151. if (EstablishByIdx(ulIdx))
  1152. {
  1153.     if (m_ulDataRefIdx == ((ULONG32) -1))
  1154.     {
  1155. m_ulDataRefIdxOffset = 0;
  1156. break;
  1157.     }
  1158. }
  1159.     }
  1161.     m_ulSampleDescIdx = QT_BAD_IDX;
  1162. #endif // _STSD_ZERO_BASED_IQ
  1164.     retVal = EstablishByIdx(0) ? HXR_OK : HXR_FAIL;
  1166.    
  1167.     return retVal;
  1168. }
  1170. /****************************************************************************
  1171.  *  Private Methods
  1172.  */
  1173. BOOL CQT_SampleDescription_Manager::ParseSampleDescription(void)
  1174. {
  1175.     BOOL bSuccess = TRUE;
  1176.     ULONG32 ulTaggedEntryIdx = 0;
  1177.     CQT_stsd_Atom::TaggedEntry* pTaggedEntry;
  1179.     // Find The Needed Sample
  1180.     m_pSampleDesc = m_pSampleDescriptionAtom->
  1181. Get_SampleDesc(m_ulSampleDescIdx);
  1183.     // Extract Needed Fixed Sample Fields
  1184.     m_ulDataRefIdx = m_pSampleDescriptionAtom->
  1185. Get_DataRefIdx(m_pSampleDesc) - m_ulDataRefIdxOffset;
  1186.     m_ulDataFormat = m_pSampleDescriptionAtom->
  1187. Get_DataFormat(m_pSampleDesc);
  1189.     m_ulRTPTimeScale = 0;
  1190.     m_lTimeStampOffset = 0;
  1191.     m_lSequenceNumOffset = 0;
  1193.     if (m_ulDataFormat == QT_rtp)
  1194.     {
  1195. // Extract Needed Tagged Entries
  1196. while ((pTaggedEntry = m_pSampleDescriptionAtom->
  1197.     Get_TaggedEntry((CQT_stsd_Atom::HintArrayEntry *) m_pSampleDesc, 
  1198.     ulTaggedEntryIdx)) != NULL)
  1199. {
  1200.     switch (CQTAtom::GetUL32(pTaggedEntry->pTag))
  1201.     {
  1202.     case QT_tims:
  1203. m_ulRTPTimeScale = CQTAtom::GetUL32(pTaggedEntry->pData);
  1204. break;
  1205.     case QT_tsro:
  1206. m_lTimeStampOffset = (LONG32) CQTAtom::GetUL32(pTaggedEntry->pData);
  1207. break;
  1208.     case QT_snro:
  1209. m_lSequenceNumOffset = (LONG32) CQTAtom::GetUL32(pTaggedEntry->pData);
  1210. break;
  1211.     default:
  1212. // nothing to do
  1213. break;
  1214.     }
  1215.     
  1216.     ulTaggedEntryIdx++;
  1217. }
  1218. bSuccess = (m_ulRTPTimeScale > 0);
  1219.     }
  1221.     return bSuccess;
  1222. }
  1225. /****************************************************************************
  1226.  *  Data Reference Manager
  1227.  */
  1228. /****************************************************************************
  1229.  *  Constructor/Destructor
  1230.  */
  1231. CQT_DataReference_Manager::CQT_DataReference_Manager(void)
  1232.     : m_pDataReferenceAtom(NULL)
  1233.     , m_ulDataRefIdx(QT_BAD_IDX)
  1234.     , m_pDataRefName(NULL)
  1235.     , m_pClassFactory(NULL)
  1236.     , m_ulNumEntries(0)
  1237. {
  1238.     ;
  1239. }
  1241. CQT_DataReference_Manager::~CQT_DataReference_Manager()
  1242. {
  1243.     HX_RELEASE(m_pDataReferenceAtom);
  1244.     HX_RELEASE(m_pDataRefName);
  1245.     HX_RELEASE(m_pClassFactory);
  1246. }
  1248. /****************************************************************************
  1249.  *  Main Interface
  1250.  */
  1251. HX_RESULT CQT_DataReference_Manager::Init
  1252. (
  1253.     CQTAtom* pAtom,
  1254.     IHXCommonClassFactory* pClassFactory
  1255. )
  1256. {
  1257.     HX_RESULT retVal = HXR_OK;
  1259.     HX_RELEASE(m_pDataReferenceAtom);
  1260.     HX_RELEASE(m_pDataRefName);
  1261.     HX_RELEASE(m_pClassFactory);
  1263.     m_ulDataRefIdx = QT_BAD_IDX;
  1264.     m_ulNumEntries = 0;
  1266.     if (pAtom)
  1267.     {
  1268. HX_ASSERT(pClassFactory);
  1269. m_pClassFactory = pClassFactory;
  1270. pClassFactory->AddRef();
  1272. if (pAtom->GetType() == QT_dref)
  1273. {
  1274.     m_pDataReferenceAtom = (CQT_dref_Atom*) pAtom;
  1275. }
  1276. else
  1277. {
  1278.     m_pDataReferenceAtom = (CQT_dref_Atom*) pAtom->FindPresentChild(QT_dref);
  1279. }
  1281. if (m_pDataReferenceAtom)
  1282. {
  1283.     m_pDataReferenceAtom->AddRef();
  1284.     m_ulNumEntries = m_pDataReferenceAtom->Get_NumEntries();
  1285. }
  1286.     }
  1288.     retVal = EstablishByIdx(0) ? HXR_OK : HXR_FAIL;
  1289.    
  1290.     return retVal;
  1291. }
  1293. /****************************************************************************
  1294.  *  Private methods
  1295.  */
  1296. BOOL CQT_DataReference_Manager::ParseDataReference(void)
  1297. {
  1298.     CQT_dref_Atom::ArrayEntry* pRefEntry;
  1299.     BOOL bSuccess = TRUE;
  1301.     HX_RELEASE(m_pDataRefName);
  1303.     pRefEntry = m_pDataReferenceAtom->GetRefEntry(m_ulDataRefIdx);
  1305.     if (!m_pDataReferenceAtom->Get_RefFlags(pRefEntry))
  1306.     {
  1307. bSuccess = FALSE;
  1309. #ifdef QTCONFIG_ALLOW_EXTERNAL_DATAREFS
  1310. /* handle Mac. Alias and form m_pDataRefName */        
  1311. UINT8* pDataRef = (UINT8*) 
  1312.   m_pDataReferenceAtom->Get_RefData(pRefEntry);
  1313. ULONG32 ulCurrentPos = pDataRef - m_pDataReferenceAtom->GetData();
  1314. ULONG32 ulDataRefLength = m_pDataReferenceAtom->GetDataSize();
  1315. UINT8* pRelPath = NULL;
  1316. ULONG32 ulPathLength = 0;
  1318. if (ulDataRefLength > ulCurrentPos)
  1319. {
  1320.     ulDataRefLength -= ulCurrentPos;
  1321.     bSuccess = FindRelPath(pDataRef, 
  1322.    ulDataRefLength, 
  1323.    pRelPath, 
  1324.    ulPathLength);
  1325. }
  1327. if (bSuccess)
  1328. {
  1329.     HX_ASSERT(pRelPath);
  1330.     HX_ASSERT(ulPathLength);
  1332.     bSuccess = FALSE;
  1333.     if (SUCCEEDED(m_pClassFactory->CreateInstance(
  1334. CLSID_IHXBuffer, 
  1335. (void**) &m_pDataRefName)))
  1336.     {
  1337. if (m_pDataRefName->SetSize(ulPathLength + 1) == HXR_OK)
  1338. {
  1339.     UINT8* pData = m_pDataRefName->GetBuffer();
  1341.     bSuccess = TRUE;
  1343.     memcpy(pData, /* Flawfinder: ignore */
  1344.    pRelPath,
  1345.    ulPathLength);
  1346.     pData[ulPathLength] = '';
  1348.     while (*pData != '')
  1349.     {
  1350. if (*pData == ':')
  1351. {
  1352.     *pData = '/';
  1353. }
  1355. pData++;
  1356.     }
  1357. }
  1358.     }
  1359. }
  1360. #endif // QTCONFIG_ALLOW_EXTERNAL_DATAREFS
  1361.     }
  1363.     return bSuccess;
  1364. }
  1367. /****************************************************************************
  1368.  *  FindRelPath
  1369.  */
  1370. #ifdef QTCONFIG_ALLOW_EXTERNAL_DATAREFS
  1371. BOOL CQT_DataReference_Manager::FindRelPath(UINT8* pData, 
  1372.     ULONG32 ulDataLength, 
  1373.     UINT8* &pRelPath, 
  1374.     ULONG32 &ulPathLength)
  1375. {
  1376.     UINT8* pCurrentPos;
  1377.     UINT8* pPathStart;
  1378.     UINT8* pPathEnd;
  1379.     BOOL bSuccess = FALSE;
  1380.     INT16 lNLvlTo;
  1381.     INT16 lNLvlFrom;
  1382.     CQT_dref_Atom::ItemEntry* pItem;
  1384.     pCurrentPos = pData + (sizeof(CQT_dref_Atom::DataRef) - 1);
  1386.     bSuccess = (((ULONG32) (pCurrentPos - 
  1387.     pData + 
  1388.     sizeof(CQT_dref_Atom::ItemEntry) - 
  1389.     1)) <= ulDataLength);
  1391.     if (bSuccess)
  1392.     {
  1393. CQT_dref_Atom::DataRef* pDataRef = (CQT_dref_Atom::DataRef*) pData;
  1395. lNLvlTo = CQTAtom::GetI16(pDataRef->pNLvlTo);
  1396. lNLvlFrom = CQTAtom::GetI16(pDataRef->pNLvlFrom);
  1398. // Make sure the path give is relative
  1399. bSuccess = ((lNLvlTo >= 0) && (lNLvlFrom >= 0));
  1400.     }
  1401.   
  1402.     // Search for the absolute pathname marker
  1403.     if (bSuccess)
  1404.     {
  1405. ULONG32 ulIdx;
  1407. bSuccess = FALSE;
  1409. for (ulIdx = QT_ALIS_MAXCOUNT; ulIdx != 0; ulIdx--)
  1410. {
  1411.     pItem = (CQT_dref_Atom::ItemEntry*) pCurrentPos;
  1412.     
  1413.     if ((CQTAtom::GetI16(pItem->pType) == QT_ALIS_ABSPATH) ||
  1414. (CQTAtom::GetI16(pItem->pType) == QT_ALIS_END))
  1415.     {
  1416. bSuccess = (CQTAtom::GetI16(pItem->pType) == QT_ALIS_ABSPATH);
  1417. break;
  1418.     }
  1419.     
  1420.     pCurrentPos = pItem->pData + 
  1421.   ((CQTAtom::GetI16(pItem->pSize) + 1) & ~1);
  1422.     
  1423.     bSuccess = (((ULONG32) (pCurrentPos - pData)) <= ulDataLength);
  1424. }
  1425.     }
  1426.     
  1427.     if (bSuccess)
  1428.     {
  1429. // Strip off the absolute portions
  1430. pPathStart = pItem->pData;
  1431. pPathEnd = (pPathStart + CQTAtom::GetUI16(pItem->pSize));
  1433. pCurrentPos = pPathEnd;
  1435. bSuccess = (((ULONG32) (pCurrentPos - pData)) <= ulDataLength);
  1436.     }
  1438.     if (bSuccess)
  1439.     {
  1440. while (lNLvlTo && (pCurrentPos >= pPathStart))
  1441. {
  1442.     if (*(pCurrentPos--) == ':')
  1443.     {
  1444. lNLvlTo--;
  1445.     }
  1446. }
  1448. pCurrentPos++;
  1449. if(*pCurrentPos == ':')
  1450. {
  1451.     pCurrentPos++;
  1452. }
  1454. pRelPath = pCurrentPos;
  1455. ulPathLength = pPathEnd + 1 - pCurrentPos;
  1457. bSuccess = (ulPathLength != 0);
  1458.     }
  1460.     return bSuccess;
  1461. }
  1463. #else // QTCONFIG_ALLOW_EXTERNAL_DATAREFS
  1465. /****************************************************************************
  1466.  *  FindRelPath
  1467.  */
  1468. BOOL CQT_DataReference_Manager::FindRelPath(UINT8* pData, 
  1469.     ULONG32 ulDataLength, 
  1470.     UINT8* &pRelPath, 
  1471.     ULONG32 &ulPathLength)
  1472. {
  1473.     return FALSE;
  1474. }
  1476. #endif // QTCONFIG_ALLOW_EXTERNAL_DATAREFS
  1479. /****************************************************************************
  1480.  *  Track Info Manager
  1481.  */
  1482. /****************************************************************************
  1483.  *  Constructor/Destructor
  1484.  */
  1485. CQT_TrackInfo_Manager::CQT_TrackInfo_Manager(void)
  1486.     : m_pNameAtom(NULL)
  1487.     , m_pSDPAtom(NULL)
  1488.     , m_ulMediaTimeScale(0)
  1489.     , m_ulPayloadType(QT_BAD_PAYLOAD)
  1490.     , m_ulTrackDuration(0)
  1491.     , m_ulTrackSize(0)
  1492.     , m_ulRefTrackID(QT_BAD_IDX)
  1493.     , m_ulAvgBitrate(0)
  1494.     , m_ulMaxBitrate(0)
  1495.     , m_ulPreroll(0)
  1496.     , m_ulPredata(0)
  1497.     , m_ulTrackWidth(0)
  1498.     , m_ulTrackHeight(0)
  1499.     , m_ulFrameWidth(0)
  1500.     , m_ulFrameHeight(0)
  1501.     , m_ulChannels(0)
  1502.     , m_ulTrackMatrixTransformX(0)
  1503.     , m_ulTrackMatrixTransformY(0)
  1504.     , m_pPayloadTypeAtom(NULL)
  1505.     , m_pName(NULL)
  1506.     , m_pSDP(NULL)
  1507.     , m_pMimeType(NULL)
  1508.     , m_pOpaqueData(NULL)
  1509.     , m_ulOpaqueDataSize(0)
  1510.     , m_pHeader(NULL)
  1511.     , m_bOpaqueDataShouldBeDeleted(FALSE)
  1512.     , m_ulNumSamplesInOpaqueData(0)
  1513. {
  1514.     ;
  1515. }
  1517. CQT_TrackInfo_Manager::~CQT_TrackInfo_Manager()
  1518. {
  1519.     Clear();
  1520. }
  1522. /****************************************************************************
  1523.  *  Main Interface
  1524.  */
  1525. HX_RESULT CQT_TrackInfo_Manager::Init(IUnknown* pContext,
  1526.       CQTAtom* pAtom,
  1527.       CQT_SampleDescription_Manager* pSampleDescManager,
  1528.       CQTTrackManager* pTrackManager,
  1529.       CQT_MovieInfo_Manager* pMovieInfo)
  1530. {
  1531.     HX_RESULT retVal = HXR_OK;
  1532.     
  1533.     Clear();
  1534.     
  1535.     if (pAtom->GetType() != QT_trak)
  1536.     {
  1537. pAtom = NULL;
  1538.     }
  1540.     // Extract Track Type
  1541.     if (pAtom)
  1542.     {
  1543. CQT_hdlr_Atom* pHdlrAtom = CQTTrackManager::GetTrackAtomHdlr(
  1544. (CQT_trak_Atom *) pAtom);
  1546. if (pHdlrAtom)
  1547. {
  1548.     m_TrackType = pHdlrAtom->Get_CompSubtype();
  1549. }
  1550. else
  1551. {
  1552.     // Fail
  1553.     pAtom = NULL;
  1554. }
  1555.     }
  1557.     // Extract track duration
  1558.     if (pAtom)
  1559.     {
  1560. CQT_tkhd_Atom* pTrackHeaderAtom = NULL;
  1562. pTrackHeaderAtom = (CQT_tkhd_Atom*) 
  1563.    pAtom->FindPresentChild(QT_tkhd);
  1565. if (pTrackHeaderAtom)
  1566. {
  1567.     m_ulTrackDuration = pTrackHeaderAtom->Get_Duration();
  1568.     m_ulTrackWidth    = (UINT32) pTrackHeaderAtom->Get_TrackWidth();
  1569.     m_ulTrackHeight   = (UINT32) pTrackHeaderAtom->Get_TrackHeight();
  1570.     // /These are the offsets from the origin (video's upper left):
  1571.     m_ulTrackMatrixTransformX = (UINT32) pTrackHeaderAtom->Get_TrackMatrixTx();
  1572.     m_ulTrackMatrixTransformY = (UINT32) pTrackHeaderAtom->Get_TrackMatrixTy();
  1573. }
  1574. else
  1575. {
  1576.     pAtom = NULL;
  1577. }
  1578.     }
  1580.     // Extract Track Time Scale
  1581.     if (pAtom)
  1582.     {
  1583. CQTAtom* pChildAtom = pAtom->FindPresentChild(QT_mdia);
  1585. if (pChildAtom)
  1586. {
  1587.     CQT_mdhd_Atom* pMediaHeaderAtom = (CQT_mdhd_Atom*)
  1588.        pChildAtom->FindPresentChild(QT_mdhd);
  1589.     if (pMediaHeaderAtom)
  1590.     {
  1591. m_ulMediaTimeScale = pMediaHeaderAtom->Get_TimeScale();
  1592.     }
  1593. }
  1595. if (m_ulMediaTimeScale == 0)
  1596. {
  1597.     pAtom = NULL;
  1598. }
  1599.     }
  1601.     if (pAtom)
  1602.     {
  1603. switch (m_TrackType)
  1604. {
  1605. case QT_hint:
  1606.     retVal = InitHinted(pAtom,
  1607. pSampleDescManager,
  1608. pTrackManager,
  1609. pMovieInfo);
  1612.             if (HXR_OK == retVal && m_pSDPAtom)
  1613.             {
  1614.                 retVal = CheckForcePacketization(m_pSDPAtom, pContext);
  1615.             }
  1617. #ifdef _IGNORE_MP4_AUDIO
  1618.     if (pTrackManager->GetFType() == QT_FTYPE_MP4)
  1619.     {
  1620. const char* pSDPData = (char*) GetSDP();
  1622. if (pSDPData && (GetSDPLength() >= (sizeof("audio") - 1)))
  1623. {
  1624.     if (strncmp(pSDPData, "m=audio", sizeof("audio") - 1) == 0)
  1625.     {
  1626. retVal = HXR_IGNORE;
  1627.     }
  1628. }
  1629.     }
  1630. #endif // _IGNORE_MP4_AUDIO
  1631.     break;
  1633. case QT_soun:
  1634. #ifdef _IGNORE_MP4_AUDIO
  1635.     if (pTrackManager->GetFType() == QT_FTYPE_MP4)
  1636.     {
  1637. retVal = HXR_IGNORE;
  1638. break;
  1639.     }
  1640. #endif // _IGNORE_MP4_AUDIO
  1642. case QT_vide:
  1643. case QT_text:
  1644.     retVal = InitNonHinted(pAtom,
  1645.    pSampleDescManager,
  1646.    pTrackManager,
  1647.    pMovieInfo);
  1648.     break;
  1650. default:
  1651.     // not supported
  1652.     retVal = HXR_IGNORE;
  1653. }
  1655. if (FAILED(retVal))
  1656. {
  1657.     pAtom = NULL;
  1658. }
  1659.     }
  1661.     if (SUCCEEDED(retVal) && (pAtom == NULL))
  1662.     {
  1663. retVal = HXR_FAIL;
  1664.     }
  1665.    
  1666.     return retVal;
  1667. }
  1669. ULONG32 CQT_TrackInfo_Manager::GetNameLength(void)
  1670. {
  1671.     ULONG32 ulSize = 0;
  1672.     
  1673.     if (m_pNameAtom)
  1674.     {
  1675. ulSize = m_pNameAtom->GetDataSize();
  1676.     }
  1677.     else if (m_pName)
  1678.     {
  1679. ulSize = strlen(m_pName);
  1680.     }
  1681.     
  1682.     return ulSize;
  1683. }
  1685. const UINT8* CQT_TrackInfo_Manager::GetName(void)
  1686. {
  1687.     return m_pNameAtom ? m_pNameAtom->GetData() : ((UINT8*) m_pName);
  1688. }
  1690. ULONG32 CQT_TrackInfo_Manager::GetSDPLength(void)
  1691. {
  1692.     ULONG32 ulSize = 0;
  1693.     
  1694.     if (m_pSDPAtom)
  1695.     {
  1696. ulSize = m_pSDPAtom->GetDataSize();
  1697.     }
  1698.     else if (m_pSDP)
  1699.     {
  1700. ulSize = strlen(m_pSDP);
  1701.     }
  1702.     
  1703.     return ulSize;
  1704. }
  1706. const UINT8* CQT_TrackInfo_Manager::GetSDP(void)
  1707. {
  1708.     return m_pSDPAtom ? m_pSDPAtom->GetData() : ((UINT8*) m_pSDP);
  1709. }
  1711. ULONG32 CQT_TrackInfo_Manager::GetOpaqueDataLength(void)
  1712. {    
  1713.     return m_ulOpaqueDataSize;
  1714. }
  1716. const UINT8* CQT_TrackInfo_Manager::GetOpaqueData(void)
  1717. {
  1718.     return m_pOpaqueData;
  1719. }
  1721. const UINT32 CQT_TrackInfo_Manager::GetNumSamplesInOpaqueData(void)
  1722. {
  1723.     return m_ulNumSamplesInOpaqueData;
  1724. }
  1726. HX_RESULT CQT_TrackInfo_Manager::GetHeader(IHXValues* &pHeader)
  1727. {
  1728.     HX_RESULT retVal = HXR_FAIL;
  1730.     if (m_pHeader)
  1731.     {
  1732. pHeader = m_pHeader;
  1733. pHeader->AddRef();
  1734. retVal = HXR_OK;
  1735.     }
  1737.     return retVal;
  1738. }
  1740. void CQT_TrackInfo_Manager::SetHeader(IHXValues* pHeader)
  1741. {
  1742.     HX_RELEASE(m_pHeader);
  1744.     m_pHeader = pHeader;
  1745.     if (m_pHeader)
  1746.     {
  1747. m_pHeader->AddRef();
  1748.     }
  1749. }
  1751. /****************************************************************************
  1752.  *  Private functions
  1753.  */
  1754. void CQT_TrackInfo_Manager::Clear(void)
  1755. {
  1756.     HX_RELEASE(m_pNameAtom);
  1757.     HX_RELEASE(m_pSDPAtom);
  1758.     HX_RELEASE(m_pPayloadTypeAtom);
  1759.     HX_RELEASE(m_pHeader);
  1760.     HX_VECTOR_DELETE(m_pSDP);
  1761.     HX_VECTOR_DELETE(m_pMimeType);
  1763.     m_ulMediaTimeScale = 0;
  1764.     m_ulTrackDuration = 0;
  1765.     m_ulTrackSize = 0;
  1766.     m_ulRefTrackID = QT_BAD_IDX;
  1767.     m_ulTrackWidth = 0;
  1768.     m_ulTrackHeight = 0;
  1769.     m_ulFrameWidth = 0;
  1770.     m_ulFrameHeight = 0;
  1772.     m_ulTrackMatrixTransformX = m_ulTrackMatrixTransformY = 0;
  1773.     m_ulOpaqueDataSize = 0;
  1774.     if (m_bOpaqueDataShouldBeDeleted  &&  m_pOpaqueData)
  1775.     {
  1776. delete [] m_pOpaqueData;
  1777. m_pOpaqueData = NULL;
  1778. m_ulOpaqueDataSize = 0;
  1779. m_bOpaqueDataShouldBeDeleted = FALSE;
  1780. m_ulNumSamplesInOpaqueData = 0;
  1781.     }
  1782. }
  1784. HX_RESULT CQT_TrackInfo_Manager::InitNonHinted(CQTAtom* pAtom,
  1785.        CQT_SampleDescription_Manager* pSampleDescManager,
  1786.        CQTTrackManager* pTrackManager,
  1787.        CQT_MovieInfo_Manager* pMovieInfo)
  1788. {
  1789.     const char* pMediaType = NULL;
  1790.     const char* pMediaName = NULL;
  1791.     UINT8 uProfileObjectIndication = MP4OBJ_FORBIDDEN;
  1792.     UINT8 uStreamType = MP4STRM_FORBIDDEN;
  1794.     HX_RESULT retVal = HXR_OK;
  1796.     // Form Track name
  1797.     switch (m_TrackType)
  1798.     {
  1799.     case QT_vide:
  1800. m_pName = "Video Track";
  1801. break;
  1802.     case QT_soun:
  1803. m_pName = "Audio Track";
  1804. break;
  1805.     case QT_text:
  1806. m_pName = "Text Track";
  1807. break;
  1808.     default:
  1809. retVal = HXR_IGNORE;
  1810. break;
  1811.     }
  1813.     m_ulOpaqueDataSize = 0;
  1814.     if (m_bOpaqueDataShouldBeDeleted  &&  m_pOpaqueData)
  1815.     {
  1816. delete [] m_pOpaqueData;
  1817. m_pOpaqueData = NULL;
  1818.     }
  1819.     m_ulOpaqueDataSize = 0;
  1820.     m_bOpaqueDataShouldBeDeleted = FALSE;
  1821.     m_ulNumSamplesInOpaqueData = 0;
  1823.     // Extract Opaque Data
  1824.     if ((retVal == HXR_OK) && pAtom)
  1825.     {
  1826. if (pSampleDescManager->GetNumEntries() == 1)
  1827. {
  1828.     CQT_stsd_Atom::ArrayEntry* pSampleDescEntry = 
  1829. pSampleDescManager->GetSampleDescEntry();
  1830.     ULONG32 ulSampleDescEntrySize = 
  1831. CQTAtom::GetUL32(pSampleDescEntry->pSize);
  1833.     if (pTrackManager->GetFType() == QT_FTYPE_MP4)
  1834.     {
  1835. switch (pSampleDescManager->GetDataFormat())
  1836. {
  1837. case QT_mp4v:
  1838.     if (ulSampleDescEntrySize > 
  1839. sizeof(CQT_stsd_Atom::VideoMP4ArrayEntry))
  1840.     {
  1841. m_pOpaqueData = ((CQT_stsd_Atom::VideoMP4ArrayEntry*) 
  1842.     pSampleDescEntry)->pESDescriptor;
  1843.     }
  1844.     break;
  1845. case QT_mp4a:
  1846.     if (ulSampleDescEntrySize > 
  1847. sizeof(CQT_stsd_Atom::AudioMP4ArrayEntry))
  1848.                     {
  1849.                         m_ulChannels = CQTAtom::GetUI16((UINT8*)
  1850.                             (((CQT_stsd_Atom::AudioArrayEntry*) 
  1851.     pSampleDescEntry)->pNumChannels));
  1852. m_pOpaqueData = ((CQT_stsd_Atom::AudioMP4ArrayEntry*) 
  1853.     pSampleDescEntry)->pESDescriptor;
  1854.     }
  1855.     break;
  1856. case QT_s263:
  1857.     if (ulSampleDescEntrySize > 
  1858. sizeof(CQT_stsd_Atom::VideoS263ArrayEntry))
  1859.     {
  1860.                         m_ulFrameWidth = CQTAtom::GetUI16((UINT8*)
  1861.                            (((CQT_stsd_Atom::VideoS263ArrayEntry*)
  1862.                            pSampleDescEntry)->pWidth));
  1863.                         m_ulFrameHeight = CQTAtom::GetUI16((UINT8*)
  1864.                            (((CQT_stsd_Atom::VideoS263ArrayEntry*)
  1865.                            pSampleDescEntry)->pHeight));
  1867. m_pOpaqueData = ((CQT_stsd_Atom::VideoS263ArrayEntry*) 
  1868.     pSampleDescEntry)->pDecoderSpecificInfo;
  1869.     }
  1870.     break;
  1871. case QT_samr:
  1872.     if (ulSampleDescEntrySize > 
  1873. sizeof(CQT_stsd_Atom::AudioSAMRArrayEntry))
  1874.     {
  1875. m_pOpaqueData = ((CQT_stsd_Atom::AudioSAMRArrayEntry*) 
  1876.     pSampleDescEntry)->pDecoderSpecificInfo;
  1877.     }
  1878.     break;
  1879. case QT_sawb:
  1880.     if (ulSampleDescEntrySize > 
  1881. sizeof(CQT_stsd_Atom::AudioSAWBArrayEntry))
  1882.     {
  1883. m_pOpaqueData = ((CQT_stsd_Atom::AudioSAWBArrayEntry*) 
  1884.     pSampleDescEntry)->pDecoderSpecificInfo;
  1885.     }
  1886.     break;
  1887. #ifdef QTCONFIG_TIMEDTEXT_PACKETIZER
  1888. case QT_tx3g:
  1889.     m_ulNumSamplesInOpaqueData = 1;
  1890.     // /Use entire descEntry as opaque stream data; unpack it
  1891.     // in renderer:
  1892.     if (ulSampleDescEntrySize >= 
  1893.     sizeof(CQT_stsd_Atom::TextSampleEntry))
  1894.     {
  1895. CQT_stsd_Atom* pSampleDescAtom =
  1896. pSampleDescManager->GetSampleDescriptionAtom();
  1897. m_pOpaqueData = pSampleDescAtom->GetData();
  1898. m_ulOpaqueDataSize = pSampleDescAtom->GetDataSize();
  1899.     }
  1900.     else
  1901.     {
  1902. retVal = HXR_UNEXPECTED;
  1903. m_ulNumSamplesInOpaqueData = 0;
  1904.     }
  1905.     break;
  1906. #endif // QTCONFIG_TIMEDTEXT_PACKETIZER
  1907. default:
  1908.     retVal = HXR_IGNORE;
  1909.     break;
  1910. }
  1911.     }
  1912.     else
  1913.     {
  1914. switch (m_TrackType)
  1915. {
  1916. case QT_vide:
  1917.     if (ulSampleDescEntrySize >=
  1918. sizeof(CQT_stsd_Atom::VideoArrayEntry))
  1919.     {
  1920. m_pOpaqueData = ((CQT_stsd_Atom::VideoArrayEntry*) 
  1921.     pSampleDescEntry)->pVersion;
  1922.     }
  1923.     break;
  1924. case QT_soun:
  1925.     if (ulSampleDescEntrySize >=
  1926. sizeof(CQT_stsd_Atom::AudioArrayEntry))
  1927.     {
  1928. m_pOpaqueData = ((CQT_stsd_Atom::AudioArrayEntry*) 
  1929.     pSampleDescEntry)->pVersion;
  1930.     }
  1931.     break;
  1932. default:
  1933.     retVal = HXR_IGNORE;
  1934.     break;
  1935. }
  1936.     }
  1938.     if (m_pOpaqueData)
  1939.     {
  1940. m_ulOpaqueDataSize = ulSampleDescEntrySize - 
  1941.      (m_pOpaqueData - ((UINT8*) pSampleDescEntry));
  1943. #ifndef HELIX_FEATURE_3GPPCLIENT_ONLY
  1944. if ((pSampleDescManager->GetDataFormat() == QT_mp4v) || 
  1945.     (pSampleDescManager->GetDataFormat() == QT_mp4a))
  1946. {
  1947.     ES_Descriptor ESDesc;
  1948.     DecoderConfigDescriptor* pDCDesc = NULL;
  1949.     UINT8* pOpaqueData = m_pOpaqueData;
  1950.     ULONG32 ulOpaqueDataSize = m_ulOpaqueDataSize;
  1951.     
  1952.     retVal = ESDesc.Unpack(pOpaqueData, ulOpaqueDataSize);
  1953.     
  1954.     if (SUCCEEDED(retVal))
  1955.     {
  1956. retVal = HXR_FAIL;
  1957. pDCDesc = ESDesc.m_pDecConfigDescr;
  1959. if (pDCDesc)
  1960. {
  1961.     m_ulAvgBitrate = pDCDesc->m_ulAvgBitrate;
  1962.     m_ulMaxBitrate = pDCDesc->m_ulMaxBitrate;
  1963.     uProfileObjectIndication = pDCDesc->m_uObjectProfileIndication;
  1964.     uStreamType = pDCDesc->m_uStreamType;
  1965.     retVal = HXR_OK;
  1966. }
  1967.     }
  1968.     
  1969. #ifdef _TINF_NO_MEDIA_SCALE_IQ
  1970.     if (SUCCEEDED(retVal) && pMovieInfo)
  1971.     {
  1972. // PacketVideo format records sample times in movie
  1973. // scale.  That format also has a flaw in ES_Descriptor
  1974. // that forces ES_Descriptor into the alternate 
  1975. // parsing mode which results in setting of the
  1976. // SIZE_HEADER_INCLUSIVE flag. Thus, the media time scale 
  1977. // is corrected based on this condition.
  1978. if (ESDesc.m_ulFlags &
  1979.     MP4BaseDescriptor::SIZE_HEADER_INCLUSIVE)
  1980. {
  1981.     m_ulMediaTimeScale = pMovieInfo->GetMovieTimeScale();
  1982. }
  1983.     }
  1984. #endif // _TINF_NO_MEDIA_SCALE_IQ
  1985. }
  1986. #endif // HELIX_FEATURE_3GPPCLIENT_ONLY
  1987.     }
  1988.     else
  1989.     {
  1990. if (retVal == HXR_OK)
  1991. {
  1992.     retVal = HXR_FAIL;
  1993. }
  1994.     }
  1995. }
  1996. #ifdef QTCONFIG_TIMEDTEXT_PACKETIZER
  1997. else if (pSampleDescManager->GetNumEntries() > 1  &&
  1998. QT_tx3g == pSampleDescManager->GetDataFormat())
  1999. {
  2000.     // /Cycle through and combine these into one opaque blob for
  2001.     // the stream header:
  2002.     UINT32 ulNumEntries = pSampleDescManager->GetNumEntries();
  2003.     CQT_stsd_Atom* pSampleDescAtom =
  2004.     pSampleDescManager->GetSampleDescriptionAtom();
  2005.     if (pSampleDescAtom  &&  ulNumEntries)
  2006.     {
  2007. m_ulNumSamplesInOpaqueData = ulNumEntries;
  2008. m_ulOpaqueDataSize = pSampleDescAtom->GetDataSize();
  2009. m_pOpaqueData = pSampleDescAtom->GetData();
  2010.     }
  2011. }
  2012. #endif // QTCONFIG_TIMEDTEXT_PACKETIZER
  2013.     }
  2015.     // Form SDP Segment
  2016.     if ((retVal == HXR_OK) && pAtom)
  2017.     {
  2018. // Set default media name
  2019. if (pTrackManager->GetFType() == QT_FTYPE_MP4)
  2020. {
  2021.     pMediaName = "X-RN-MP4-RAWAU";
  2022. }
  2023. else
  2024. {
  2025.     pMediaName = "X-RN-QT-RAWAU";
  2026. }
  2028. switch (m_TrackType)
  2029. {
  2030. case QT_vide:
  2031.     pMediaType = "video";
  2032.     switch (pSampleDescManager->GetDataFormat())
  2033.     {
  2034.     case QT_mp4v:
  2035.     case QT_mp4a:
  2036. pMediaName = "X-RN-MP4";
  2037. break;
  2038.     case QT_s263:
  2039. pMediaName = "X-RN-3GPP-H263";
  2040. break;
  2041.     default:
  2042. // nothing to do
  2043. break;
  2044.     }
  2045.     break;
  2046.     
  2047.     case QT_soun:
  2048. pMediaType = "audio";
  2049. switch (pSampleDescManager->GetDataFormat())
  2050. {
  2051. #ifndef HELIX_FEATURE_3GPPCLIENT_ONLY
  2052. case QT_mp4v:
  2053. case QT_mp4a:
  2054.     if ((uProfileObjectIndication == MP4OBJ_VISUAL_ISO_IEC_11172_3) &&
  2055. (uStreamType == MP4STRM_AUDIO))
  2056.     {
  2057. pMediaName = "MPEG-ELEMENTARY";
  2058. m_pOpaqueData = NULL;
  2059. m_ulOpaqueDataSize = 0;
  2060. m_ulPreroll = 1000;
  2061.     }
  2062.     break;
  2063. #endif // HELIX_FEATURE_3GPPCLIENT_ONLY
  2064. case QT_samr:
  2065.     pMediaName = "X-RN-3GPP-AMR";
  2066.     break;
  2067. case QT_sawb:
  2068.     pMediaName = "X-RN-3GPP-AMR-WB";
  2069.     break;
  2070. default:
  2071.     // nothing to do
  2072.     break;
  2073. }
  2074. break;
  2076. #ifdef QTCONFIG_TIMEDTEXT_PACKETIZER
  2077. case QT_text:
  2078.     pMediaType = "video";
  2079.     pMediaName = "X-RN-3GPP-TEXT";
  2080.     break;
  2081. #endif // QTCONFIG_TIMEDTEXT_PACKETIZER
  2082.     
  2083. default:
  2084.     pMediaType = "application";
  2085.     break;
  2086. }
  2088. m_ulPayloadType = RTP_PAYLOAD_RTSP;
  2090. #ifdef QTCONFIG_SERVER
  2091. HX_VECTOR_DELETE(m_pSDP);
  2092. m_pSDP = new char [TRACK_SDP_CHUNK_SIZE];
  2093. retVal = HXR_OUTOFMEMORY;
  2095. if (m_pSDP)
  2096. {
  2097.     char* pWriter;
  2098.     char* pWriterEnd = m_pSDP + TRACK_SDP_CHUNK_SIZE;
  2099.     retVal = HXR_OK;
  2100.     
  2101.     pWriter = m_pSDP;
  2102.     
  2103.     pWriter += SafeSprintf(pWriter, pWriterEnd - pWriter,
  2104.    "m=%s 0 RTP/AVP %drn", 
  2105.    pMediaType, 
  2106.    m_ulPayloadType);
  2107.     
  2108.     pWriter += SafeSprintf(pWriter, pWriterEnd - pWriter,
  2109.    "a=rtpmap:%d %s/%drn",
  2110.    m_ulPayloadType,
  2111.    pMediaName,
  2112.    m_ulMediaTimeScale);
  2114.     HX_ASSERT((pWriter - m_pSDP) < TRACK_SDP_CHUNK_SIZE);
  2115. }
  2116. #endif // QTCONFIG_SERVER
  2117.     }
  2119.     if ((retVal == HXR_OK) && pAtom)
  2120.     {
  2121. HX_ASSERT(pMediaType);
  2122. HX_ASSERT(pMediaName);
  2124. ULONG32 ulMediaTypeLen = strlen(pMediaType);
  2125. ULONG32 ulMediaNameLen = strlen(pMediaName);
  2127. m_pMimeType = new char [ulMediaTypeLen + ulMediaNameLen + 2];
  2129. retVal = HXR_OUTOFMEMORY;
  2130. if (m_pMimeType)
  2131. {
  2132.     retVal = HXR_OK;
  2134.     strcpy(m_pMimeType, pMediaType); /* Flawfinder: ignore */
  2135.     strcpy(m_pMimeType + ulMediaTypeLen + 1, pMediaName); /* Flawfinder: ignore */
  2136.     m_pMimeType[ulMediaTypeLen] = '/';
  2137. }
  2138.     }
  2140.     return retVal;
  2141. }
  2143. /****************************************************************************
  2144.  *  Movie Info Manager
  2145.  */
  2146. /****************************************************************************
  2147.  *  Constructor/Destructor
  2148.  */
  2149. CQT_MovieInfo_Manager::CQT_MovieInfo_Manager(void)
  2150.     : m_ulMovieTimeScale(0)
  2151.     , m_ulMovieDuration(0)
  2152.     , m_pNameAtom(NULL)
  2153.     , m_pRTPSDPAtom(NULL)
  2154. {
  2155.     ;
  2156. }
  2158. CQT_MovieInfo_Manager::~CQT_MovieInfo_Manager()
  2159. {
  2160.     Clear();
  2161. }
  2163. void CQT_MovieInfo_Manager::Clear()
  2164. {
  2165.     HX_RELEASE(m_pNameAtom);
  2166.     HX_RELEASE(m_pRTPSDPAtom);
  2167. }
  2169. /****************************************************************************
  2170.  *  Main Interface
  2171.  */
  2172. HX_RESULT CQT_MovieInfo_Manager::Init(CQTAtom* pAtom, 
  2173.       CQTTrackManager* pTrackManager)
  2174. {
  2175.     HX_RESULT retVal;
  2177.     m_ulMovieTimeScale = 0;
  2178.     m_ulMovieDuration = 0;
  2179.     HX_RELEASE(m_pNameAtom);
  2180.     HX_RELEASE(m_pRTPSDPAtom);
  2182.     if (pAtom && (pAtom->GetType() != QT_moov))
  2183.     {
  2184. pAtom = NULL;
  2185.     }
  2187.     if (pAtom)
  2188.     {
  2189. CQT_mvhd_Atom *pMovieHeaderAtom = NULL;
  2191. pMovieHeaderAtom = (CQT_mvhd_Atom*) 
  2192.    pAtom->FindPresentChild(QT_mvhd);
  2194. if (pMovieHeaderAtom)
  2195. {
  2196.     m_ulMovieTimeScale = pMovieHeaderAtom->Get_TimeScale();
  2197.     m_ulMovieDuration = pMovieHeaderAtom->Get_Duration();
  2198. }
  2199. else
  2200. {
  2201.     pAtom = NULL;
  2202. }
  2203.     }
  2205.     if (pAtom)
  2206.     {
  2207. pAtom = pAtom->FindPresentChild(QT_udta);
  2208.     }
  2210.     if (pAtom)
  2211.     {
  2212. m_pNameAtom = (CQT_name_Atom*) pAtom->FindPresentChild(QT_name);
  2213. if (m_pNameAtom)
  2214. {
  2215.     m_pNameAtom->AddRef();
  2216. }
  2218. pAtom = pAtom->FindPresentChild(QT_hnti);
  2219.     }
  2221.     ParseMovieHintInfo(pAtom);
  2222.     
  2223.     retVal = m_ulMovieTimeScale ? HXR_OK : HXR_FAIL;
  2224.    
  2225.     return retVal;
  2226. }