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

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

Symbian

开发平台：

C/C++

qttrack.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 _LOG_DATA_ACCESS
  40. #define QTTRACKCACHE_PAGE_SIZE 0x0000FFFF
  43. /****************************************************************************
  44.  *  Includes
  45.  */
  46. #include "qtpktasm.h"
  48. #include "qtffplin.h"
  49. #include "qtpacketizerfct.h"
  50. #include "qttrack.h"
  51. #include "qtffrefcounter.h"
  54. /****************************************************************************
  55.  *  Class CQTTrack
  56.  */
  57. /****************************************************************************
  58.  *  Constructor/Destructor
  59.  */
  60. CQTTrack::CQTTrack(CQTAtom* pTrackAtom)
  61.     : m_pTrackAtom((CQT_trak_Atom*) pTrackAtom)
  62.     , m_pFileFormat(NULL)
  63.     , m_pPacketAssembler(NULL)
  64.     , m_pReadFileNameBuffer(NULL)
  65.     , m_pReadFileName(NULL)
  66.     , m_pFileSwitcher(NULL)
  67.     , m_pPacketizer(NULL)
  68.     , m_pClassFactory(NULL)
  69.     , m_ulTrackID(0)
  70.     , m_bTrackDone(FALSE)
  71.     , m_PendingState(QTT_Offline)
  72.     , m_uStreamNumber(0)
  73.     , m_ulReadSize(0)
  74.     , m_ulReadPageSize(0)
  75.     , m_ulReadPageOffset(0)
  76.     , m_uBytesPerCBlock(0)
  77.     , m_uSamplesPerCBlock(0)
  78.     , m_lRefCount(0)
  79.     , m_ulLastSampleDescIdx(0)
  80. {
  81.     CQT_tkhd_Atom* pTrackHeaderAtom = NULL;
  83.     HX_ASSERT(pTrackAtom);
  84.     pTrackAtom->AddRef();
  85.     
  86.     if (pTrackAtom)
  87.     {
  88. pTrackHeaderAtom = (CQT_tkhd_Atom*) 
  89.     pTrackAtom->FindPresentChild(QT_tkhd);
  90.     }
  91.     
  92.     if (pTrackHeaderAtom)
  93.     {
  94. m_ulTrackID = pTrackHeaderAtom->Get_TrackID();
  95.     }
  97.     g_nRefCount_qtff++;
  98. }
  100. CQTTrack::~CQTTrack()
  101. {
  102.     Close();
  104.     g_nRefCount_qtff--;
  105. }
  107. /****************************************************************************
  108.  *  Main Interface
  109.  */
  110. /****************************************************************************
  111.  *  Init
  112.  */
  113. HX_RESULT CQTTrack::Init(CQTFileFormat *pFileFormat,
  114.  CQTPacketAssembler *pPacketAssembler,
  115.  CQTPacketizerFactory* pPacketizerFactory,
  116.  const char* pProtocol)
  117. {
  118.     CQTAtom* pAtom = NULL;
  119.     BOOL bIsStreamTrack = FALSE;
  120.     HX_RESULT retVal = HXR_OK;
  122.     if (!m_pTrackAtom)
  123.     {
  124. retVal = HXR_UNEXPECTED;
  125.     }
  127.     pAtom = m_pTrackAtom;
  129.     m_uBytesPerCBlock = 0;
  130.     m_uSamplesPerCBlock = 0;
  132.     if (SUCCEEDED(retVal))
  133.     {
  134. HX_ASSERT(pFileFormat);
  136. bIsStreamTrack = pFileFormat->m_TrackManager.IsStreamTrack(this);
  138. m_pFileFormat = pFileFormat;
  139. pFileFormat->AddRef();
  141. HX_ASSERT(pPacketAssembler);
  143. m_pPacketAssembler = pPacketAssembler;
  144. pPacketAssembler->AddRef();
  146. retVal = pFileFormat->QueryInterface(
  147.     IID_IHXFileSwitcher,
  148.     (void**) &m_pFileSwitcher);
  149.     }
  151.     if (SUCCEEDED(retVal))
  152.     {
  153. retVal = pFileFormat->QueryInterface(IID_IHXCommonClassFactory,
  154.      (void**) &m_pClassFactory);
  155.     }
  157.     if (SUCCEEDED(retVal))
  158.     {
  159. CQT_tkhd_Atom* pTrackHeaderAtom = NULL;
  161. HX_ASSERT(m_pFileSwitcher);
  163. if (pAtom)
  164. {
  165.     pTrackHeaderAtom = (CQT_tkhd_Atom*) 
  166.        pAtom->FindPresentChild(QT_tkhd);
  167. }
  169. if (pTrackHeaderAtom)
  170. {
  171.     m_ulTrackID = pTrackHeaderAtom->Get_TrackID();
  172. }
  173. else
  174. {
  175.     retVal = HXR_FAIL;
  176. }
  177.     }
  179.     if (SUCCEEDED(retVal))
  180.     {
  181. IHXCommonClassFactory* pClassFactory = NULL;
  182. CQTAtom* pChildAtom = NULL;
  184. if (pAtom)
  185. {
  186.     pAtom = pAtom->FindPresentChild(QT_mdia);
  187. }
  189. if (pAtom)
  190. {
  191.     pAtom = pAtom->FindPresentChild(QT_minf);
  192. }
  194. if (pAtom)
  195. {
  196.     pChildAtom = pAtom->FindPresentChild(QT_dinf);
  197. }
  199. retVal = pFileFormat->QueryInterface(
  200.     IID_IHXCommonClassFactory,
  201.     (void**) &pClassFactory);
  203. if (SUCCEEDED(retVal))
  204. {
  205.     retVal = m_DataRef.Init(pChildAtom, pClassFactory);
  206. }
  208. HX_RELEASE(pClassFactory);
  209.     }
  211.     if (retVal == HXR_OK)
  212.     {
  213. if (pAtom)
  214. {
  215.     pAtom = pAtom->FindPresentChild(QT_stbl);
  216. }
  218. retVal = m_SampleSize.Init(pAtom);
  219.     }
  221.     if (retVal == HXR_OK)
  222.     {
  223. retVal = m_SampleToChunk.Init(pAtom);
  224.     }
  226.     if (retVal == HXR_OK)
  227.     {
  228. retVal = m_TimeToSample.Init(pAtom);
  229.     }
  231.     if (retVal == HXR_OK)
  232.     {
  233. retVal = m_ChunkToOffset.Init(pAtom);
  234.     }
  236.     if (retVal == HXR_OK)
  237.     {
  238. retVal = m_SampleDesc.Init(pAtom);
  239.     }
  241.     if ((retVal == HXR_OK) && bIsStreamTrack)
  242.     {
  243. retVal = m_TrackInfo.Init(pFileFormat->GetContext(),
  244.   m_pTrackAtom,
  245.   &m_SampleDesc,
  246.   &pFileFormat->m_TrackManager,
  247.   &pFileFormat->m_MovieInfo);
  248.     }
  250.     if ((retVal == HXR_OK) && bIsStreamTrack)
  251.     {
  252. retVal = InitPacketizer(m_pPacketizer,
  253. pPacketizerFactory,
  254. pProtocol,
  255. &m_TrackInfo,
  256. &pFileFormat->m_MovieInfo,
  257. &pFileFormat->m_TrackManager,
  258. this,
  259. pFileFormat->GetContext());
  260.     }
  262.     if ((retVal == HXR_OK) && bIsStreamTrack)
  263.     {
  264. CQTAtom* pChildAtom = NULL;
  266. pChildAtom = m_pTrackAtom->FindPresentChild(QT_edts);
  268. retVal = m_TrackEdit.Init(
  269.     pChildAtom,
  270.     pFileFormat->m_MovieInfo.GetMovieTimeScale(),
  271.     m_TrackInfo.GetMediaTimeScale());
  272.     }
  274.     if ((retVal == HXR_OK) && bIsStreamTrack)
  275.     {
  276. retVal = Seek(0);
  278. if (retVal == HXR_STREAM_DONE)
  279. {
  280.     retVal = HXR_OK;
  281. }
  282.     }
  284.     HX_RELEASE(m_pTrackAtom);
  286.     return retVal;
  287. }
  289. /****************************************************************************
  290.  *  Close
  291.  */
  292. void CQTTrack::Close(void)
  293. {
  294.     m_PendingState = QTT_Offline;
  296.     HX_RELEASE(m_pTrackAtom);
  297.     HX_RELEASE(m_pFileFormat);
  298.     HX_RELEASE(m_pPacketAssembler);
  299.     HX_RELEASE(m_pReadFileNameBuffer);
  300.     HX_RELEASE(m_pFileSwitcher);
  301.     HX_RELEASE(m_pPacketizer);
  302.     HX_RELEASE(m_pClassFactory);
  303. }
  305. /****************************************************************************
  306.  *  Seek
  307.  */
  308. HX_RESULT CQTTrack::Seek(ULONG32 ulTime)
  309. {
  310.     if (m_pPacketizer)
  311.     {
  312. m_pPacketizer->Reset();
  313.     }
  315.     m_bTrackDone = !m_TrackEdit.EstablishByTime(ulTime);
  317.     if (!m_bTrackDone)
  318.     {
  319. m_bTrackDone = !SequenceToTime(m_TrackEdit,
  320.        m_TimeToSample,
  321.        m_SampleToChunk,
  322.        QTTRK_USE_KEY_FRAMES);
  323.     }
  325.     return m_bTrackDone ? HXR_STREAM_DONE : HXR_OK;
  326. }
  328. /****************************************************************************
  329.  *  GetPacket
  330.  */
  331. HX_RESULT CQTTrack::GetPacket(UINT16 uStreamNum)
  332. {
  333.     HX_RESULT retVal = HXR_STREAM_DONE;
  335.     m_uStreamNumber = uStreamNum;
  337.     if (m_pPacketizer)
  338.     {
  339. IHXPacket* pPacket = NULL;
  341. retVal = m_pPacketizer->GetPacket(pPacket);
  343. if (retVal != HXR_INCOMPLETE)
  344. {
  345.     m_pFileFormat->PacketReady(m_uStreamNumber, 
  346. retVal, 
  347. pPacket);
  348.     
  349.     HX_RELEASE(pPacket);
  350.     
  351.     return HXR_OK;
  352. }
  354. retVal = HXR_STREAM_DONE;
  355.     }
  357.     if (!m_bTrackDone)
  358.     {
  359. m_PendingState = QTT_SampleRead;
  361. // Locate Sample
  362. if (m_ChunkToOffset.EstablishByChunk(
  363. m_SampleToChunk.GetChunkNum()) &&
  364.     m_SampleSize.EstablishBySample(
  365. m_TimeToSample.GetSampleNumber(),
  366. m_SampleToChunk.GetChunkSampleNum()) &&
  367.     m_SampleDesc.EstablishByIdx(
  368. m_SampleToChunk.GetSampleDescIdx()) &&
  369.     m_DataRef.EstablishByIdx(
  370. m_SampleDesc.GetDataRefIdx()))
  371. {
  372.     ULONG32 ulFileOffset = m_ChunkToOffset.GetChunkOffset() +
  373.    m_SampleSize.GetChunkSampleOffset();
  375. #ifdef QTCONFIG_TRACK_CACHE
  376.     if (m_DataRef.GetDataRefName() == NULL)
  377.     {
  378. if (m_TrackCache.IsInPage(ulFileOffset, m_SampleSize.GetSampleSize()))
  379. {
  380.     IHXBuffer* pBuffer;
  381.     UINT32 ulPageOffset;
  382.     m_TrackCache.Get(ulFileOffset,
  383.      pBuffer,
  384.      ulPageOffset);
  386.     return ReturnPacket(HXR_OK,
  387. pBuffer,
  388. ulPageOffset, 
  389. m_SampleSize.GetSampleSize());
  390. }
  391.     }
  392. #endif // QTCONFIG_TRACK_CACHE
  394.     retVal = LoadData(
  395. m_DataRef.GetDataRefName(),
  396. ulFileOffset,
  397. m_SampleSize.GetSampleSize());
  398. }
  399. else
  400. {
  401.     retVal = ReturnPacket(retVal, NULL);
  402. }
  403.     }
  404.     else
  405.     {
  406. retVal = ReturnPacket(retVal, NULL);
  407.     }
  409.     return retVal;
  410. }
  412. /****************************************************************************
  413.  *  ComputeTrackSize
  414.  */
  415. HX_RESULT CQTTrack::ComputeTrackSize(ULONG32& ulTrackSizeOut)
  416. {
  417.     ULONG32 ulTrackSize = 0;
  418.     ULONG32 ulCurrentMediaTime = m_TrackEdit.GetMediaTime();
  419.     HX_RESULT retVal = Seek(0);
  421.     if (SUCCEEDED(retVal))
  422.     {
  423. do
  424. {
  425.     if (!m_SampleSize.EstablishBySample(
  426.     m_TimeToSample.GetSampleNumber(),
  427.     m_SampleToChunk.GetChunkSampleNum()))
  428.     {
  429. break;
  430.     }
  432.     ulTrackSize += m_SampleSize.GetSampleSize();
  433. } while (AdvanceSample(m_TrackEdit,
  434.        m_TimeToSample,
  435.        m_SampleToChunk));
  437. ulTrackSizeOut = ulTrackSize;
  438.     }
  440.     Seek(ulCurrentMediaTime);
  442.     return retVal;
  443. }
  445. /****************************************************************************
  446.  *  IHXThreadSafeMethods method
  447.  */
  448. /****************************************************************************
  449.  *  IsThreadSafe
  450.  */
  451. STDMETHODIMP_(UINT32)
  452. CQTTrack::IsThreadSafe()
  453. {
  454.     return HX_THREADSAFE_METHOD_FF_GETPACKET | HX_THREADSAFE_METHOD_FSR_READDONE;
  455. }
  458. /****************************************************************************
  459.  *  Protected Functions
  460.  */
  461. /****************************************************************************
  462.  *  InitPacketizer
  463.  */
  464. HX_RESULT CQTTrack::InitPacketizer(IHXPayloadFormatObject* &pPacketizer,
  465.    CQTPacketizerFactory* pPacketizerFactory,
  466.    const char* pProtocol,
  467.    CQT_TrackInfo_Manager* pTrackInfo,
  468.    CQT_MovieInfo_Manager* pMovieInfo,
  469.    CQTTrackManager* pTrackManager,
  470.    CQTTrack* pTrack,
  471.    IUnknown* pContext)
  472. {
  473.     HX_RESULT retVal = HXR_OK;
  475. #ifdef QTCONFIG_PACKETIZER_FACTORY
  476.     if (pPacketizerFactory)
  477.     {
  478. retVal = pPacketizerFactory->Construct(pPacketizer,
  479.        pProtocol,
  480.        pTrackInfo,
  481.        pMovieInfo,
  482.        pTrackManager,
  483.        pTrack,
  484.        pContext);
  486. if (retVal == HXR_NO_DATA)
  487. {
  488.     retVal = HXR_OK;
  489. }
  490.     }
  492.     if (SUCCEEDED(retVal))
  493.     {
  494. if (pPacketizer)
  495. {
  496.     IHXValues* pHeader = NULL;
  498.     retVal = pPacketizer->Init(pContext, TRUE);
  500.     if (SUCCEEDED(retVal))
  501.     {
  502. retVal = m_pFileFormat->BuildStreamHeader(pHeader,
  503.   this,
  504.   pTrackInfo,
  505.   pMovieInfo,
  506.   pTrackManager,
  507.   m_pClassFactory);
  508.     }
  510.     if (SUCCEEDED(retVal))
  511.     {
  512. retVal = pPacketizer->SetStreamHeader(pHeader);
  513.     }
  515.     HX_RELEASE(pHeader);
  517.     if (SUCCEEDED(retVal))
  518.     {
  519. retVal = pPacketizer->GetStreamHeader(pHeader);
  520.     }
  522.     if (SUCCEEDED(retVal))
  523.     {
  524. pTrackInfo->SetHeader(pHeader);
  525.     }
  527.     HX_RELEASE(pHeader);
  528. }
  529.     }
  530. #endif // QTCONFIG_PACKETIZER_FACTORY
  532.     return retVal;
  533. }
  535. /****************************************************************************
  536.  *  LoadData
  537.  */
  538. HX_RESULT CQTTrack::LoadData(IHXBuffer* pFileName,
  539.     ULONG32 ulOffset,
  540.     ULONG32 ulSize)
  541. {
  542.     HX_RELEASE(m_pReadFileNameBuffer);
  543.     m_pReadFileName = NULL;
  545. #ifdef _LOG_DATA_ACCESS
  546.     FILE* pf = fopen("C:\qt_access.txt", "a");
  547.     fprintf(pf, "%d %d %dn", m_ulTrackID, ulOffset, ulSize);
  548.     fclose(pf);
  549. #endif // _LOG_DATA_ACCESS
  551. #ifdef QTCONFIG_TRACK_CACHE
  552.     m_TrackCache.ReleasePage();
  553. #endif // QTCONFIG_TRACK_CACHE
  555.     m_ulReadSize = ulSize;
  556.     m_ulReadPageSize = ulSize;
  557.     m_ulReadPageOffset = ulOffset;
  558.     
  559.     if (pFileName)
  560.     {
  561. m_pReadFileNameBuffer = pFileName;
  562. pFileName->AddRef();
  563. m_pReadFileName = (char *) pFileName->GetBuffer();
  564.     }
  565. #ifdef QTCONFIG_TRACK_CACHE
  566.     else if (m_TrackCache.IsEnabled() && (ulSize < QTTRACKCACHE_PAGE_SIZE))
  567.     {
  568. m_ulReadPageSize = QTTRACKCACHE_PAGE_SIZE;
  569.     }
  570. #endif // QTCONFIG_TRACK_CACHE
  572.     return m_pFileSwitcher->Seek(   ulOffset,
  573.     FALSE,
  574.     (IHXFileResponse*) this,
  575.     m_pReadFileName);
  576. }
  578. /****************************************************************************
  579.  *  DataReady
  580.  */
  581. HX_RESULT CQTTrack::DataReady(HX_RESULT status, IHXBuffer *pBuffer)
  582. {
  583. #ifdef QTCONFIG_TRACK_CACHE
  584.     if (status == HXR_OK)
  585.     {
  586. if (m_ulReadPageSize > m_ulReadSize)
  587. {
  588.     m_TrackCache.SetPage(m_ulReadPageOffset, pBuffer);
  589. }
  590.     }
  591.     else
  592.     {
  593. if (m_TrackCache.IsEnabled())
  594. {
  595.     m_TrackCache.Enable(FALSE);
  596.     return LoadData(m_pReadFileNameBuffer,
  597.     m_ulReadPageOffset,
  598.     m_ulReadSize);
  599. }
  600.     }
  601. #endif // QTCONFIG_TRACK_CACHE
  603.     switch (m_PendingState)
  604.     {
  605.     case QTT_SegmentRead:
  606. m_PendingState = QTT_Offline;
  608. if (m_pPacketAssembler)
  609. {
  610.     return m_pPacketAssembler->SegmentReady(status, pBuffer,
  611.     0, m_ulReadSize);
  612. }
  613. break;
  615.     case QTT_SampleRead:
  616. m_PendingState = QTT_Offline;
  617. return ReturnPacket(status, pBuffer, 0, m_ulReadSize);
  618.     }
  620.     return HXR_UNEXPECTED;
  621. }
  623. /****************************************************************************
  624.  *  ReturnPacket
  625.  */
  626. HX_RESULT CQTTrack::ReturnPacket(HX_RESULT status, 
  627.  IHXBuffer *pBuffer)
  628. {
  629.     return ReturnPacket(status,
  630. pBuffer,
  631. 0,
  632. pBuffer ? pBuffer->GetSize() : 0);
  633. }
  635. /****************************************************************************
  636.  *  ReturnPacket
  637.  */
  638. HX_RESULT CQTTrack::ReturnPacket(HX_RESULT status, 
  639. IHXBuffer *pBuffer,
  640. ULONG32 ulOffset,
  641. ULONG32 ulSize)
  642. {
  643.     ULONG32 ulTime = (ULONG32) (m_TrackEdit.GetRealTime() + 0.5);
  644.     ULONG32 ulRTPTime = m_TrackEdit.GetMediaTime() + 
  645. m_TimeToSample.GetCompositionOffset();
  646.     IHXPacket* pPacket = NULL;
  647.     HX_RESULT retVal = HXR_OK;
  649.     if (pBuffer)
  650.     {
  651. #ifdef QTCONFIG_BFRAG
  652. if ((ulOffset != 0) || (ulSize != pBuffer->GetSize()))
  653. {
  654. #ifdef QTCONFIG_BFRAG_FACTORY
  655.     pBuffer = 
  656. m_pFileFormat->m_pBufferFragmentFactory->WrapFragment(
  657.     pBuffer, ulOffset, ulSize);
  658. #else // QTCONFIG_BFRAG_FACTORY
  659.     pBuffer = new CBufferFragment(pBuffer, ulOffset, ulSize);
  660.     
  661.     if (pBuffer)
  662.     {
  663. pBuffer->AddRef();
  664.     }
  665. #endif // QTCONFIG_BFRAG_FACTORY
  666. }
  667. else
  668. #else // QTCONFIG_BFRAG
  669. HX_ASSERT((ulOffset == 0) && (ulSize == pBuffer->GetSize()));
  670. #endif // QTCONFIG_BFRAG
  671. {
  672.     pBuffer->AddRef();
  673. }
  674.     }
  676.     // Form packet
  677.     if (status == HXR_OK)
  678.     {
  679. status = m_pClassFactory->CreateInstance(CLSID_IHXRTPPacket,
  680.  (void**) &pPacket);
  681.     }
  683.     if (pBuffer)
  684.     {
  685. if (status == HXR_OK)
  686. {
  687.     status = ((IHXRTPPacket*) pPacket)->SetRTP(
  688. pBuffer,
  689. ulTime,
  690. ulRTPTime,
  691. m_uStreamNumber,
  692. m_TimeToSample.IsOnSyncSample() ? 
  693.     (HX_ASM_SWITCH_ON | HX_ASM_SWITCH_OFF) :
  694.     HX_ASM_SWITCH_OFF,     // ASM Flags
  695. QTASM_MARKER_ON_RULE);
  696. }
  698. pBuffer->Release();
  699. pBuffer = NULL;
  700.     }
  701.     
  702.     if (status == HXR_OK)
  703.     {
  704. m_ulLastSampleDescIdx = m_SampleToChunk.GetSampleDescIdx();
  705. m_bTrackDone = !AdvanceSample(m_TrackEdit,
  706.       m_TimeToSample,
  707.       m_SampleToChunk);
  708.     }
  709.     else
  710.     {
  711. m_bTrackDone = TRUE;
  712.     }
  714.     if (m_pPacketizer)
  715.     {
  716. if (status == HXR_OK)
  717. {
  718.     m_pPacketizer->SetPacket(pPacket);
  719. }
  721. HX_RELEASE(pPacket);
  723. if (m_bTrackDone)
  724. {
  725.     m_pPacketizer->Flush();
  726. }
  728. status = m_pPacketizer->GetPacket(pPacket);
  730. if (status == HXR_INCOMPLETE)
  731. {
  732.     if (!m_bTrackDone)
  733.     {
  734. status = GetPacket(m_uStreamNumber);
  735. if (status == HXR_OK)
  736. {
  737.     return status;
  738. }
  739.     }
  740.     else
  741.     {
  742. status = HXR_STREAM_DONE;
  743.     }
  744. }
  745.     }
  747.     retVal = m_pFileFormat->PacketReady(m_uStreamNumber, status, pPacket);
  749.     HX_RELEASE(pPacket);
  751.     return retVal;
  752. }
  754. /****************************************************************************
  755.  *  SequenceToTime
  756.  */
  757. BOOL CQTTrack::SequenceToTime(CQT_TrackEdit_Manager &TrackEdit,
  758.      CQT_TimeToSample_Manager &TimeToSample,
  759.      CQT_SampleToChunk_Manager &SampleToChunk,
  760.      BOOL bUseNonKeyFrames)
  761. {
  762.     BOOL bOverSeek;
  764.     do
  765.     {
  766. bOverSeek = !( bUseNonKeyFrames ?
  767. TimeToSample.EstablishByMediaTime(
  768.     TrackEdit.GetMediaTime()) :
  769. TimeToSample.EstablishAtKeyByMediaTime(
  770.     TrackEdit.GetMediaTime()));
  771.     } while ((!bOverSeek) &&
  772.      TrackEdit.AdvanceByMediaTime(
  773. TimeToSample.GetLastMediaSyncTime(), bOverSeek) &&
  774.      (!bOverSeek));
  776.     if (!bOverSeek)
  777.     {
  778. bOverSeek = !SampleToChunk.EstablishBySample(
  779.     TimeToSample.GetSampleNumber());
  780.     }
  782.     return !bOverSeek;
  783. }
  785. /****************************************************************************
  786.  *  AdvanceSample
  787.  */
  788. BOOL CQTTrack::AdvanceSample(CQT_TrackEdit_Manager &TrackEdit,
  789.     CQT_TimeToSample_Manager &TimeToSample,
  790.     CQT_SampleToChunk_Manager &SampleToChunk)
  791. {
  792.     BOOL bStreamDone;
  794.     if (TrackEdit.AdvanceByMediaTime(
  795.     TimeToSample.GetSampleDuration(),
  796.     bStreamDone))
  797.     {
  798. // Advancement in time caused change in edit segment
  799. if (!bStreamDone)
  800. {
  801.     bStreamDone = !SequenceToTime(TrackEdit,
  802.   TimeToSample,
  803.   SampleToChunk,
  804.   QTTRK_USE_ANY_FRAME);
  805. }
  806.     }
  807.     else
  808.     {
  809. bStreamDone = ((!TimeToSample.AdvanceBySample()) ||
  810.        (!SampleToChunk.AdvanceBySample()));
  811.     }
  813.     return !bStreamDone;
  814. }
  816. /****************************************************************************
  817.  *  IHXFileResponse methods 
  818.  */
  819. /****************************************************************************
  820.  *  ReadDone
  821.  */
  822. STDMETHODIMP CQTTrack::ReadDone(HX_RESULT status,
  823. IHXBuffer* pBuffer)
  824. {
  825.     return DataReady(status, pBuffer);
  826. }
  828. /****************************************************************************
  829.  *  SeekDone
  830.  */
  831. STDMETHODIMP CQTTrack::SeekDone(HX_RESULT status)
  832. {
  833.     if (SUCCEEDED(status))
  834.     {
  835. return m_pFileSwitcher->Read( m_ulReadPageSize,
  836. (IHXFileResponse*) this,
  837. m_pReadFileName);
  838.     }
  840.     return DataReady(status, NULL);
  841. }
  843. /****************************************************************************
  844.  *  IUnknown methods
  845.  */
  846. /////////////////////////////////////////////////////////////////////////
  847. //  Method:
  848. // IUnknown::QueryInterface
  849. //
  850. STDMETHODIMP CQTTrack::QueryInterface(REFIID riid, void** ppvObj)
  851. {
  852.     if (IsEqualIID(riid, IID_IHXThreadSafeMethods))
  853.     {
  854. AddRef();
  855. *ppvObj = (IHXThreadSafeMethods*) this;
  856. return HXR_OK;
  857.     }
  858.     else if (IsEqualIID(riid, IID_IUnknown))
  859.     {
  860. AddRef();
  861. *ppvObj = this;
  862. return HXR_OK;
  863.     }
  865.     *ppvObj = NULL;
  867.     return HXR_NOINTERFACE;
  868. }
  870. /////////////////////////////////////////////////////////////////////////
  871. //  Method:
  872. // IUnknown::AddRef
  873. //
  874. STDMETHODIMP_(ULONG32) CQTTrack::AddRef()
  875. {
  876.     return InterlockedIncrement(&m_lRefCount);
  877. }
  879. /////////////////////////////////////////////////////////////////////////
  880. //  Method:
  881. // IUnknown::Release
  882. //
  883. STDMETHODIMP_(ULONG32) CQTTrack::Release()
  884. {
  885.     if (InterlockedDecrement(&m_lRefCount) > 0)
  886.     {
  887.         return m_lRefCount;
  888.     }
  890.     delete this;
  891.     return 0;
  892. }