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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > Symbian > 查看源码
qtffplin.cpp
资源名称：142_61_thumb_advanced.rar　[点击查看]
上传用户：dangjiwu
上传日期：2013-07-19
资源大小：42019k
文件大小：58k
源码类别：

Symbian

开发平台：

Visual C++

qtffplin.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 NO_STREAM_SET 0xFFFF
  40. #define FSWCHR_MAX_CHILD_COUNT    20
  43. /****************************************************************************
  44.  * Includes
  45.  */
  46. #include "qtffplin.ver"
  48. #include "hxtypes.h"
  49. #include "hxcom.h"
  50. #include "hxstrutl.h"
  51. #include "hxcomm.h"
  52. #include "ihxpckts.h"
  53. #include "hxfiles.h"
  54. #include "hxformt.h"
  55. #include "hxplugn.h"
  56. #include "hxpends.h"
  57. #include "hxengin.h"
  58. #include "hxerror.h"
  59. #include "hxupgrd.h"
  60. #include "hxmon.h"
  61. #include "hxbrdcst.h"
  62. #include "hxcore.h"
  63. #include "hxprefs.h"
  64. #include "defslice.h"
  65. #include "qtres.h"
  66. #include "hxsdesc.h"
  67. #include "hxstring.h"
  68. #include "qtffplin.h"
  69. #include "netbyte.h"
  70. #include "hxver.h"
  71. #include "hxxres.h"
  72. #include "hxxrsmg.h"
  73. #include "dbcs.h"
  75. #include "sdpchunk.h"
  76. #include "sdppyldinfo.h"
  78. #include "qtffrefcounter.h"
  79. #include "qttrack.h"
  80. #include "qtpktasm.h"
  82. /****************************************************************************
  83.  * Constants
  84.  */
  85. #define QTFF_AU_PREFIX "FileFormat/"
  86. #define QTFF_AU_PREFIX_SIZE (sizeof(QTFF_AU_PREFIX) - 1)
  87. #define MAX_EXTENSION_SIZE 256
  89. #define QTBUFFERFRAGMENT_POOL_SIZE     50
  90. #define QTBUFFERFRAGMENT_INITIAL_POOL_SIZE  5
  92. const char* const CQTFileFormat::zm_pDescription    = "RealNetworks Mpeg4 File Format Plugin";
  93. const char* const CQTFileFormat::zm_pCopyright      = HXVER_COPYRIGHT;
  94. const char* const CQTFileFormat::zm_pMoreInfoURL    = HXVER_MOREINFO;
  96. #define EXT_3GP     "3gp"
  97. #define EXT_3G2     "3g2"
  98. #define EXT_MP4     "mp4"
  99. #define EXT_M4A     "m4a"
  100. #define EXT_MOV     "mov", "qt"
  102. #define ONM_3GP     "3GPP-MP4 Files (*.3gp, *.3g2)"
  103. #define ONM_MP4     "MP4 Files (*.mp4)"
  104. #define ONM_MOV     "QuickTime Files (*.mov, *.qt)"
  106. const char* const CQTFileFormat::zm_pFileMimeTypes[]  = {"application/x-pn-quicktime-stream", "audio/3gpp", "video/3gpp", NULL};
  108. const char* const CQTFileFormat::zm_pFileExtensions[] = {EXT_MOV, EXT_MP4, EXT_3GP, EXT_3G2, EXT_M4A, NULL};
  110. const char* const CQTFileFormat::zm_pFileOpenNames[] = {ONM_MOV, ONM_MP4, ONM_3GP, NULL};
  112. const char* const CQTFileFormat::zm_pPacketFormats[]  = {"rtp", "rdt", NULL};
  114. #define WIDTH_METANAME "Width"
  115. #define HEIGHT_METANAME "Height"
  118. /****************************************************************************
  119.  * Globals
  120.  */
  121. g_base_nRefCount_qtff_TypeModifier INT32 g_base_nRefCount_qtff = 0;
  124. /****************************************************************************
  125.  *  Constructor/Destructor
  126.  */
  127. CQTFileFormat::CQTFileFormat()
  128.     : m_lRefCount(0)
  129.     , m_pContext(NULL)
  130.     , m_pFFResponse(NULL)
  131.     , m_pClassFactory(NULL)
  132.     , m_pScheduler(NULL)
  133.     , m_pRequest(NULL)
  134.     , m_pFileSwitcher(NULL)
  135.     , m_pAtomizer(NULL)
  136.     , m_pPacketAssembler(NULL)
  137.     , m_State(QTFF_Offline)
  138.     , m_pPacketCache(NULL)
  139.     , m_uNextPacketStreamNum(NO_STREAM_SET)
  140.     , m_ulPendingSeekTime(0)
  141.     , m_pErrorMessages(NULL)
  142.     , m_bQTLicensed(FALSE)
  143.     , m_bMP4Licensed(FALSE)
  144.     , m_uFormatFlavor(MAX_QTFORMAT_FLAVOR)
  145.     , m_bViewSourceRequest(FALSE)
  146. #ifdef QTCONFIG_BFRAG_FACTORY
  147.     , m_pBufferFragmentFactory(NULL)
  148. #endif // QTCONFIG_BFRAG_FACTORY
  149.     , m_ulStreamMetaInfoMask(META_INFO_NONE)
  150. {
  151.     g_nRefCount_qtff++;
  152. }
  154. CQTFileFormat::~CQTFileFormat()
  155. {
  156.     Close();
  157.     g_nRefCount_qtff--;
  158. }
  161. /************************************************************************
  162.  *  IHXPlugin methods
  163.  */
  164. /************************************************************************
  165.  *  IHXPlugin::InitPlugin
  166.  *  Purpose:
  167.  *    Initializes the plugin for use. This interface must always be
  168.  *    called before any other method is called. This is primarily needed 
  169.  *    so that the plugin can have access to the context for creation of
  170.  *    IHXBuffers and IMalloc.
  171.  */
  172. STDMETHODIMP CQTFileFormat::InitPlugin(IUnknown* /*IN*/ pContext)
  173. {
  174.     HX_RESULT retVal = HXR_OK;
  176.     if (pContext)
  177.     {
  178. m_pContext = pContext;
  179. m_pContext->AddRef();
  180.     }
  181.     else
  182.     {
  183. retVal = HXR_INVALID_PARAMETER;
  184.     }
  186.     /*
  187.      * Check for license
  188.      */     
  189.     if (SUCCEEDED(retVal))
  190.     {
  191. retVal = CheckLicense();
  192.     }
  194.     if (SUCCEEDED(retVal))
  195.     {
  196. HX_ASSERT(!m_pErrorMessages);
  197. pContext->QueryInterface(IID_IHXErrorMessages, 
  198.     (void**) &m_pErrorMessages);
  200. retVal = pContext->QueryInterface(IID_IHXCommonClassFactory,
  201.     (void**)&m_pClassFactory);
  202.     }
  204.     if (SUCCEEDED(retVal))
  205.     {
  206. retVal = pContext->QueryInterface(IID_IHXScheduler,
  207.     (void**)&m_pScheduler);
  208.     }
  210.     return retVal;
  211. }
  213. /************************************************************************
  214.  *  IHXPlugin::GetPluginInfo
  215.  *  Purpose:
  216.  *    Returns the basic information about this plugin. Including:
  217.  *
  218.  *    bLoadMultiple whether or not this plugin DLL can be loaded
  219.  * multiple times. All File Formats must set
  220.  * this value to TRUE.
  221.  *    pDescription which is used in about UIs (can be NULL)
  222.  *    pCopyright which is used in about UIs (can be NULL)
  223.  *    pMoreInfoURL which is used in about UIs (can be NULL)
  224.  */
  225. STDMETHODIMP CQTFileFormat::GetPluginInfo
  226. (
  227.     REF(BOOL) bLoadMultiple,
  228.     REF(const char*) pDescription,
  229.     REF(const char*) pCopyright,
  230.     REF(const char*) pMoreInfoURL,
  231.     REF(ULONG32) ulVersionNumber
  232. )
  233. {
  234.     bLoadMultiple = TRUE;   // Must be true for file formats.
  236.     pDescription    = (const char*) zm_pDescription;
  237.     pCopyright     = (const char*) zm_pCopyright;
  238.     pMoreInfoURL    = (const char*) zm_pMoreInfoURL;
  239.     ulVersionNumber = TARVER_ULONG32_VERSION;
  241.     return HXR_OK;
  242. }
  244. /************************************************************************
  245.  *  IHXFileFormatObject methods
  246.  */
  247. /************************************************************************
  248.  *  GetFileFormatInfo
  249.  *  Purpose:
  250.  *    If this object is a file format object this method returns
  251.  *    information vital to the instantiation of file format plugins.
  252.  *    If this object is not a file format object, it should return
  253.  *    HXR_UNEXPECTED.
  254.  */
  255. STDMETHODIMP CQTFileFormat::GetFileFormatInfo
  256. (
  257.     REF(const char**) /*OUT*/ pFileMimeTypes,
  258.     REF(const char**) /*OUT*/ pFileExtensions,
  259.     REF(const char**) /*OUT*/ pFileOpenNames
  260. )
  261. {
  262.     pFileMimeTypes  = (const char**) zm_pFileMimeTypes;
  263.     pFileExtensions = (const char**) zm_pFileExtensions;
  264.     pFileOpenNames  = (const char**) zm_pFileOpenNames;
  266.     return HXR_OK;
  267. }
  269. /************************************************************************
  270.  *  InitFileFormat
  271.  */
  272. STDMETHODIMP CQTFileFormat::InitFileFormat
  273. (
  274.     IHXRequest* /*IN*/ pRequest, 
  275.     IHXFormatResponse* /*IN*/ pFileFormatResponse,
  276.     IHXFileObject* /*IN*/  pFileObject
  277. )
  278. {
  279.     HX_RESULT retVal = HXR_OK;
  281.     if (m_State != QTFF_Offline)
  282.     {
  283. return HXR_UNEXPECTED;
  284.     }
  286.     m_State = QTFF_Init;
  288.     if ((pFileFormatResponse == NULL) ||
  289. (pFileObject == NULL))
  290.     {
  291. retVal = HXR_FAIL;
  292.     }
  294.     HX_RELEASE(m_pFFResponse);
  295.     m_pFFResponse = pFileFormatResponse;
  296.     m_pFFResponse->AddRef();
  298.     HX_RELEASE(m_pRequest);
  299.     m_pRequest = pRequest;
  300.     if (m_pRequest)
  301.     {
  302. m_pRequest->AddRef();
  303.     }
  305.     if (SUCCEEDED(retVal) && m_pRequest)
  306.     {
  307. IHXValues* pRequestHeaders = NULL;
  308. if (SUCCEEDED(m_pRequest->GetRequestHeaders(pRequestHeaders)) &&
  309.     pRequestHeaders)
  310. {
  311.     ULONG32 ulVal = 0;
  313.     if (SUCCEEDED(pRequestHeaders->GetPropertyULONG32(
  314.     "ViewSourceInfoHeaders",
  315.     ulVal)))
  316.     {
  317. m_bViewSourceRequest = ((ulVal == 0) ? FALSE : TRUE);
  318.     }
  320.     IHXBuffer* pBuffer = NULL;
  321.     retVal = pRequestHeaders->GetPropertyCString("AcceptMetaInfo",
  322.      pBuffer);
  323.     if(SUCCEEDED(retVal))
  324.     {
  325. retVal = ExtractAcceptMetaInfo(pBuffer);
  326.     }
  328.             // We want to proceed even if metadata fails.
  329.             retVal = HXR_OK;
  331.     HX_RELEASE(pBuffer);
  332. }
  333. HX_RELEASE(pRequestHeaders);
  334.     }
  336.     if (SUCCEEDED(retVal))
  337.     {
  338. HX_RELEASE(m_pFileSwitcher);
  339. HX_RELEASE(m_pAtomizer);
  341. #ifdef QTCONFIG_FSWITCHER
  342. m_pFileSwitcher = (IHXFileSwitcher*) new CFileSwitcher();
  343. #else // QTCONFIG_FSWITCHER
  344. m_pFileSwitcher = (IHXFileSwitcher*) new CFileSwitcherPassthrough();
  345. #endif // QTCONFIG_FSWITCHER
  346. if (m_pFileSwitcher)
  347. {
  348.     m_pFileSwitcher->AddRef();
  349. }
  350. else
  351. {
  352.     retVal = HXR_OUTOFMEMORY;
  353. }
  354.     }
  356.     if (SUCCEEDED(retVal))
  357.     {
  358. m_pAtomizer = new CAtomizer();
  359. if (m_pAtomizer)
  360. {
  361.     m_pAtomizer->AddRef();
  362. }
  363. else
  364. {
  365.     retVal = HXR_OUTOFMEMORY;
  366. }
  367.     }
  369.     if (SUCCEEDED(retVal))
  370.     {
  371. m_pPacketAssembler = new CQTPacketAssembler();
  372. if (m_pPacketAssembler)
  373. {
  374.     m_pPacketAssembler->AddRef();
  375.     retVal = m_pPacketAssembler->Init(this);
  376. }
  377. else
  378. {
  379.     retVal = HXR_OUTOFMEMORY;
  380. }
  381.     }
  383.     if (SUCCEEDED(retVal))
  384.     {
  385. retVal = m_pFileSwitcher->Init(pFileObject,
  386.        HX_FILE_READ | HX_FILE_BINARY,
  387.        (IHXFileResponse*) this,
  388.        m_pContext,
  389.        FSWCHR_MAX_CHILD_COUNT);
  390.     }
  392.     if (FAILED(retVal))
  393.     {
  394. m_State = QTFF_Error;
  395.     }
  397.     return retVal;
  398. }
  400. HX_RESULT
  401. CQTFileFormat::ExtractAcceptMetaInfo(IHXBuffer* pRequestedInfoBuffer)
  402. {
  403.     HX_RESULT res = HXR_OK;
  405.     if(!pRequestedInfoBuffer)
  406.     {
  407. res = HXR_POINTER;
  408. HX_ASSERT(FALSE);
  409. return res;
  410.     }
  412.     const char* pRequestedInfo = NULL;
  413.     if (pRequestedInfoBuffer)
  414.     {
  415. pRequestedInfo = (const char*) pRequestedInfoBuffer->GetBuffer();
  416.     }
  418.     if(*pRequestedInfo == '*')
  419.     {
  420. m_ulStreamMetaInfoMask |= META_INFO_ALL;
  421.     }
  422. #ifdef QTCONFIG_SERVER
  423.     else if (pRequestedInfo)
  424.     {     
  425. const char* pName;
  426. ULONG32 ulNameLength;
  428. // Set requested Meta Info
  429. do
  430. {
  431.     pName = pRequestedInfo;
  432.     
  433.     while ((*pRequestedInfo != '') &&
  434.    (*pRequestedInfo != ','))
  435.     {
  436. pRequestedInfo++;
  437.     }
  438.     
  439.     ulNameLength = (ULONG32) (pRequestedInfo - pName);
  441.     if (ulNameLength > 0)
  442.     {
  443. if ((strlen(WIDTH_METANAME) == ulNameLength) &&
  444.     (strncmp(pName, WIDTH_METANAME, ulNameLength) == 0))
  445. {
  446.     m_ulStreamMetaInfoMask |= META_INFO_WIDTH;
  447. }
  448. else if ((strlen(HEIGHT_METANAME) == ulNameLength) &&
  449.  (strncmp(pName, HEIGHT_METANAME, ulNameLength) == 0))
  450. {
  451.     m_ulStreamMetaInfoMask |= META_INFO_HEIGHT;
  452. }
  453.     }
  455.     if (*pRequestedInfo == '')
  456.     {
  457. break;
  458.     }
  460.     pRequestedInfo++;
  461. } while (TRUE);
  462.     } 
  463. #endif // QTCONFIG_SERVER
  465.     return res;
  466. }
  469. HX_RESULT CQTFileFormat::MakeFileHeader(HX_RESULT status)
  470. {
  471.     HX_RESULT retVal;
  472.     IHXValues* pHeader = NULL;
  473.     IHXBuffer* pTitle = NULL;
  475.     // Check the license
  476. #ifdef QTCONFIG_SERVER
  477.     if(SUCCEEDED(status))
  478.     {
  479.         switch(m_TrackManager.GetFType())
  480.         {
  481.             case QT_FTYPE_QT:
  482.             case QT_FTYPE_UNKNOWN:
  483.             {
  484.                 if(!m_bQTLicensed)
  485.                 {
  486.                     ReportError(IDS_ERR_QT_NOTLICENSED, HXR_NOT_LICENSED);
  487.                     return m_pFFResponse->FileHeaderReady(
  488.                         HXR_NOT_LICENSED, NULL);
  489.                 }
  490.                 break;
  491.             }
  492.             case QT_FTYPE_MP4:
  493.             {
  494.                 if(!m_bMP4Licensed)
  495.                 {
  496.                     ReportError(IDS_ERR_MP4_NOTLICENSED, HXR_NOT_LICENSED);
  497.                     return m_pFFResponse->FileHeaderReady(
  498.                         HXR_NOT_LICENSED, NULL);
  499.                 }
  500.                 break;
  501.             }
  502.         }
  503.     }
  504. #endif // QTCONFIG_SERVER
  506.     // Create needed buffers
  507.     if (SUCCEEDED(status))
  508.     {
  509. status = m_pClassFactory->CreateInstance(CLSID_IHXValues,
  510.  (void**) &pHeader);
  511.     }
  512.     
  513.     if (SUCCEEDED(status))
  514.     {
  515. status = m_pClassFactory->CreateInstance(CLSID_IHXBuffer,
  516.  (void**) &pTitle);
  517.     }
  519.     // Set Title
  520.     if (SUCCEEDED(status) && (m_MovieInfo.GetNameLength() > 0))
  521.     {
  522. UCHAR* pTitleMem;
  523. ULONG32 ulTitleMemLength = 0;
  525. status = pTitle->SetSize(m_MovieInfo.GetNameLength() + 1);
  526. if (SUCCEEDED(status))
  527. {
  528.     pTitle->Get(pTitleMem, ulTitleMemLength);
  529.     memcpy(pTitleMem, m_MovieInfo.GetName(), ulTitleMemLength - 1); /* Flawfinder: ignore */
  530.     pTitleMem[ulTitleMemLength - 1] = '';
  532.     pHeader->SetPropertyBuffer("Title", pTitle);
  533. }
  534.     }
  536.     HX_RELEASE(pTitle);
  538.     if (SUCCEEDED(status))
  539.     {
  540. status = GetSessionIdentity(pHeader, &m_MovieInfo);
  541.     }
  543. #ifdef QTCONFIG_ALTERNATE_STREAMS
  544.     // Set stream groupings
  545.     if (SUCCEEDED(status))
  546.     {
  547. UINT16 uStrmIdx;
  548. ULONG32 ulGroupID;
  549. ULONG32 ulGroupBitrate;
  550. CQTTrack* pTrack;
  551. IHXValues* pGroupInfo = NULL;
  553. for (uStrmIdx = 0; 
  554.      uStrmIdx < m_TrackManager.GetNumStreams();
  555.      uStrmIdx++)
  556. {
  557.     pTrack = m_TrackManager.GetStreamTrack(uStrmIdx);
  559.     if (pTrack->m_TrackInfo.GetSDPLength() > 0)
  560.     {
  561. retVal = SDPParseChunk(
  562.     (char*) pTrack->m_TrackInfo.GetSDP(),
  563.     pTrack->m_TrackInfo.GetSDPLength(),
  564.     pGroupInfo,
  565.     m_pClassFactory,
  566.     SDPCTX_Group,
  567.     FALSE);
  569. if (pGroupInfo &&
  570.     (pGroupInfo->GetPropertyULONG32("AlternateGroupID",
  571.     ulGroupID)
  572.      == HXR_OK))
  573. {
  574.     if (pGroupInfo->GetPropertyULONG32("AlternateGroupBitrate",
  575.        ulGroupBitrate)
  576. != HXR_OK)
  577.     {
  578. ulGroupBitrate = 0;
  579.     }
  581.     status = m_TrackManager.AddStreamToGroup(
  582. uStrmIdx,
  583. (UINT16) ulGroupID,
  584. ulGroupBitrate);
  585. }
  586.    
  587. HX_RELEASE(pGroupInfo);
  589. if (FAILED(status))
  590. {
  591.     break;
  592. }
  593.     }
  594. }
  595.     }
  597.     // Make Default subscriptions
  598.     if (SUCCEEDED(status))
  599.     {
  600. status = m_TrackManager.SubscribeDefault();
  601.     }
  603.     // If we are running in player, eliminate inactive stream tracks
  604.     if (SUCCEEDED(status))
  605.     {
  606. IHXClientEngine *pPlayer = NULL;
  608. if (SUCCEEDED(m_pContext->QueryInterface(IID_IHXClientEngine, 
  609.  (void**) &pPlayer)))
  610. {
  611.     // Running in player
  612.     status = m_TrackManager.RemoveInactiveStreams();
  613. }
  615. HX_RELEASE(pPlayer);
  616.     }
  617. #endif // QTCONFIG_ALTERNATE_STREAMS
  619.     // Set General properties, Stream Count and duration
  620.     if (SUCCEEDED(status))
  621.     {
  622. pHeader->SetPropertyULONG32("IsRealDataType", 0);
  623. pHeader->SetPropertyULONG32("StreamCount",  
  624.     m_TrackManager.GetNumStreams());
  625. pHeader->SetPropertyULONG32("Duration",
  626.     (ULONG32) ((1000.0 * ((double) m_MovieInfo.GetMovieDuration())) /
  627.                m_MovieInfo.GetMovieTimeScale()));
  628.     }
  630.     // Set the licensing information: Basically this information is used by the
  631.     // Broadcast Receiver plug-in to check and see if the RealServer is actually
  632.     // licensed to receive this content
  633. #ifdef QTCONFIG_SERVER
  634.     if(SUCCEEDED(status) && (!m_bViewSourceRequest))
  635.     {
  636.         switch(m_TrackManager.GetFType())
  637.         {
  638.             case QT_FTYPE_QT:
  639.             case QT_FTYPE_UNKNOWN:
  640.             {
  641.                 IHXBuffer* pFileTypeBuf = NULL;
  642.                 IHXBuffer* pLicenseKeyBuf = NULL;
  643.                 m_pClassFactory->CreateInstance(CLSID_IHXBuffer, (void**)&pFileTypeBuf);
  644.                 m_pClassFactory->CreateInstance(CLSID_IHXBuffer, (void**)&pLicenseKeyBuf);
  645.                 pFileTypeBuf->Set((const BYTE*)"QuickTime", strlen("QuickTime") + 1);
  646.                 pLicenseKeyBuf->Set((const BYTE*)REGISTRY_QUICKTIME_ENABLED, strlen(REGISTRY_QUICKTIME_ENABLED) + 1);
  648.                 pHeader->SetPropertyCString("FileType", pFileTypeBuf);
  649.                 pHeader->SetPropertyCString("LicenseKey", pLicenseKeyBuf);
  650.                 pHeader->SetPropertyULONG32("DefaultLicenseValue", LICENSE_QUICKTIME_ENABLED);
  651.                 HX_RELEASE(pFileTypeBuf);
  652.                 HX_RELEASE(pLicenseKeyBuf);
  653.                 break;
  654.             }
  655.             case QT_FTYPE_MP4:
  656.             {
  657.                 IHXBuffer* pFileTypeBuf = NULL;
  658.                 IHXBuffer* pLicenseKeyBuf = NULL;
  659.                 m_pClassFactory->CreateInstance(CLSID_IHXBuffer, (void**)&pFileTypeBuf);
  660.                 m_pClassFactory->CreateInstance(CLSID_IHXBuffer, (void**)&pLicenseKeyBuf);
  661.                 pFileTypeBuf->Set((const BYTE*)"MPEG4", strlen("MPEG4") + 1);
  662.                 pLicenseKeyBuf->Set((const BYTE*)REGISTRY_REALMP4_ENABLED, strlen(REGISTRY_REALMP4_ENABLED) + 1);
  664.                 pHeader->SetPropertyCString("FileType", pFileTypeBuf);
  665.                 pHeader->SetPropertyCString("LicenseKey", pLicenseKeyBuf);
  666.                 pHeader->SetPropertyULONG32("DefaultLicenseValue", LICENSE_REALMP4_ENABLED);
  667.                 HX_RELEASE(pFileTypeBuf);
  668.                 HX_RELEASE(pLicenseKeyBuf);
  669.                 break;
  670.             }
  671.         }
  672.     }
  673. #endif // QTCONFIG_SERVER
  675.     // Set Requested Meta Information
  676.     if (SUCCEEDED(status))
  677.     {
  678. IHXValues* pHeaders = NULL;
  679. IHXBuffer* pBuffer = NULL;
  681. if (m_pRequest &&
  682.     (m_pRequest->GetRequestHeaders(pHeaders) == HXR_OK) &&
  683.     pHeaders)
  684. {     
  685.     pHeaders->Release();
  686. }
  688. status = AddMetaInfo(pHeader);
  690. // We no longer need the request so release it
  691. HX_RELEASE(m_pRequest);
  692.     }
  694.     // Set View Source specific information
  695. #ifdef HELIX_FEATURE_VIEWSOURCE
  696.     if (SUCCEEDED(status) && m_bViewSourceRequest)
  697.     {
  698. IHXBuffer* pCStringBuffer = NULL;
  700. status = m_pClassFactory->CreateInstance(CLSID_IHXBuffer,
  701.  (void**) &pCStringBuffer);
  702. if (SUCCEEDED(status))
  703. {
  704.     const char* pString = "Not Hinted";
  706.     if (m_TrackManager.IsHinted())
  707.     {
  708. pString = "Hinted";
  709.     }
  711.     status = pCStringBuffer->Set((UINT8*) pString, strlen(pString) + 1);
  712. }
  714. if (SUCCEEDED(status))
  715. {
  716.     status = pHeader->SetPropertyCString("Characteristic", pCStringBuffer);
  717. }
  719. HX_RELEASE(pCStringBuffer);
  721. if (SUCCEEDED(status))
  722. {
  723.     status = pHeader->SetPropertyULONG32("ViewSourceInfoHeaders", 1);
  724. }
  725.     }
  726. #endif // HELIX_FEATURE_VIEWSOURCE
  728.     if (FAILED(status))
  729.     {
  730. HX_RELEASE(pHeader);
  731.     }
  733.     retVal = m_pFFResponse->FileHeaderReady(status, pHeader);
  735.     HX_RELEASE(pHeader);
  737.     return retVal;
  738. }
  740. HX_RESULT CQTFileFormat::ObtainStreamHeader(UINT16 unStreamNumber,
  741.     IHXValues* &pHeader)
  742. {
  743.     HX_RESULT retVal = HXR_OK;
  744.     CQTTrack* pTrack = NULL;
  745.     
  746.     pHeader = NULL;
  748.     // Check Entry requirements
  749.     if (m_State != QTFF_Ready)
  750.     {
  751. retVal = HXR_UNEXPECTED;
  752.     }
  754.     if (SUCCEEDED(retVal))
  755.     {
  756. retVal = HXR_INVALID_PARAMETER;
  757. if (unStreamNumber < m_TrackManager.GetNumStreams())
  758. {
  759.     retVal = HXR_OK;
  760. }
  761.     }
  763.     // See if made header is already available
  764.     if (SUCCEEDED(retVal))
  765.     {
  766. pTrack = m_TrackManager.GetStreamTrack(unStreamNumber);
  767. if (pTrack->m_TrackInfo.GetHeader(pHeader) != HXR_OK)
  768. {
  769.     retVal = BuildStreamHeader(pHeader,
  770.        pTrack,
  771.        &pTrack->m_TrackInfo,
  772.        &m_MovieInfo,
  773.        &m_TrackManager,
  774.        m_pClassFactory);
  775. }
  776.     }
  778.     if (SUCCEEDED(retVal))
  779.     {
  780. HX_ASSERT(pHeader);
  781. pHeader->SetPropertyULONG32("StreamNumber", unStreamNumber);
  782.     }
  784.     return retVal;
  785. }
  787. HX_RESULT CQTFileFormat::BuildStreamHeader(IHXValues* &pHeader,
  788.    CQTTrack* pTrack,
  789.    CQT_TrackInfo_Manager* pTrackInfo,
  790.    CQT_MovieInfo_Manager* pMovieInfo,
  791.    CQTTrackManager* pTrackManager,
  792.    IHXCommonClassFactory* pClassFactory)
  793. {
  794.     IHXBuffer* pName = NULL;
  795.     IHXBuffer* pASMRuleBook = NULL;
  796.     IHXBuffer* pMimeType = NULL;
  797.     ULONG32 ulPayloadType = QT_BAD_PAYLOAD;
  798.     ULONG32 ulAvgBitRate = 0;
  799.     ULONG32 ulMaxBitRate = 0;
  800.     ULONG32 ulPreroll = 0;
  801.     ULONG32 ulPredata = 0;
  802.     ULONG32 ulWidth = 0;
  803.     ULONG32 ulHeight = 0;
  804.     ULONG32 ulChannels = 0;
  805.     HX_RESULT retVal = HXR_OK;
  807.     // Create needed buffers
  808.     if (!pHeader)
  809.     {
  810. retVal = pClassFactory->CreateInstance(CLSID_IHXValues,
  811.  (void**) &pHeader);
  812.     }
  814.     if (SUCCEEDED(retVal))
  815.     {
  816. retVal = pClassFactory->CreateInstance(CLSID_IHXBuffer,
  817.  (void**) &pName);
  818.     }
  820.     if (SUCCEEDED(retVal))
  821.     {
  822. retVal = pClassFactory->CreateInstance(CLSID_IHXBuffer,
  823.  (void**) &pASMRuleBook);
  824.     }
  826.     // Set Stream Name
  827.     if (SUCCEEDED(retVal) && (pTrackInfo->GetNameLength() > 0))
  828.     {
  829. UCHAR* pNameMem;
  830. ULONG32 ulNameMemLength = 0;
  832. retVal = pName->SetSize(pTrackInfo->GetNameLength() + 1);
  833. if (SUCCEEDED(retVal))
  834. {
  835.     pName->Get(pNameMem, ulNameMemLength);
  836.     memcpy(pNameMem, pTrackInfo->GetName(), /* Flawfinder: ignore */
  837.    ulNameMemLength - 1);
  838.     pNameMem[ulNameMemLength - 1] = '';
  840.     pHeader->SetPropertyCString("StreamName", pName);
  841. }
  842.     }
  844.     HX_RELEASE(pName);
  846.     // Set Opaque Data - if any
  847.     if (SUCCEEDED(retVal) && (pTrackInfo->GetOpaqueDataLength() > 0))
  848.     {
  849. IHXBuffer* pOpaqueData = NULL;
  851. retVal = pClassFactory->CreateInstance(CLSID_IHXBuffer,
  852.        (void**) &pOpaqueData);
  854. if (SUCCEEDED(retVal))
  855. {
  856.     UCHAR* pOpaqueDataMem;
  857.     ULONG32 ulOpaqueDataLength = 0;
  859.     retVal = pOpaqueData->SetSize(pTrackInfo->GetOpaqueDataLength());
  860.     if (SUCCEEDED(retVal))
  861.     {
  862. pOpaqueData->Get(pOpaqueDataMem, ulOpaqueDataLength);
  863. memcpy(pOpaqueDataMem, /* Flawfinder: ignore */
  864.        pTrackInfo->GetOpaqueData(),
  865.        ulOpaqueDataLength);
  866. pHeader->SetPropertyBuffer("OpaqueData", pOpaqueData);
  867.     }
  868. }
  870. HX_RELEASE(pOpaqueData);
  871.     }
  873.     if (SUCCEEDED(retVal))
  874.     {
  875. retVal = GetPayloadIdentity(pHeader, pTrack, pTrackInfo);
  876.     }
  877.     
  878.     // Set Duration, AvgBitRate and Preroll
  879.     if (SUCCEEDED(retVal))
  880.     {
  881. ULONG32 ulDuration;
  883. ulDuration = (ULONG32) ((pTrackInfo->GetTrackDuration()
  884.  * 1000.0)
  885. / pMovieInfo->GetMovieTimeScale());
  887. ulAvgBitRate = pTrackInfo->GetAvgBitrate();
  889. ulMaxBitRate = pTrackInfo->GetMaxBitrate();
  891. ulPreroll = pTrackInfo->GetPreroll();
  892. ulPredata = pTrackInfo->GetPredata();
  894. ulWidth = pTrackInfo->GetTrackWidth();
  895. ulHeight= pTrackInfo->GetTrackHeight();
  897. if ((ulAvgBitRate == 0) && (ulDuration > 0))
  898. {
  899.     ULONG32 ulTrackSize = pTrackInfo->GetTrackSize();
  901.     if (ulTrackSize == 0)
  902.     {
  903.     pTrack->ComputeTrackSize(ulTrackSize);
  904. }
  906.     ulAvgBitRate = (ULONG32) ((((double) ulTrackSize) * 8000.0) 
  907.       / ulDuration + 0.5);
  908. }
  910. if (ulAvgBitRate == 0)
  911. {
  912.     ulAvgBitRate = SDPMapPayloadToBitrate(ulPayloadType);
  913. }
  915. pHeader->SetPropertyULONG32("Duration", ulDuration);
  917. if (ulAvgBitRate != 0)
  918. {
  919.     pHeader->SetPropertyULONG32("AvgBitRate", ulAvgBitRate);
  920. }
  922. if (ulMaxBitRate != 0)
  923. {
  924.     pHeader->SetPropertyULONG32("MaxBitRate", ulMaxBitRate);
  925. }
  927. if (ulPreroll != 0)
  928. {
  929.     pHeader->SetPropertyULONG32("Preroll", ulPreroll);
  930. }
  932. if (ulPredata != 0)
  933. {
  934.     pHeader->SetPropertyULONG32("Predata", ulPredata);
  935. }
  937. if(ulWidth != 0)
  938. {
  939.     pHeader->SetPropertyULONG32(WIDTH_METANAME, ulWidth);
  940. }
  942. if(ulHeight != 0)
  943. {
  944.     pHeader->SetPropertyULONG32(HEIGHT_METANAME, ulHeight);
  945. }
  946.     }
  948.     if (SUCCEEDED(retVal))
  949.     {
  950. // .mp4 and .mov files may produce streams with out-of-order time stamps
  951. // Client core does not normally expect this in RDT protocol so set this
  952. // property to alert client core of this fact.
  953. pHeader->SetPropertyULONG32("HasOutOfOrderTS", 1);
  954.     }
  956.     // Set ASM Rule Book
  957.     if (SUCCEEDED(retVal))
  958.     {
  959. char pRuleBook[128]; /* Flawfinder: ignore */
  961. #ifdef QTCONFIG_SERVER
  962. pHeader->GetPropertyULONG32("RTPPayloadType", ulPayloadType);
  964. if (pTrackManager->GetEType() != QT_ETYPE_CLIENT)
  965. {
  966.     // Server Side
  967.     retVal = HXR_FAIL;
  968.     if (ulPayloadType != QT_BAD_PAYLOAD)
  969.     {
  970. retVal = HXR_OK;
  971.     }
  973.     if (SUCCEEDED(retVal))
  974.     {
  975. BOOL bSupportedPayload = SDPIsKnownPayload(ulPayloadType);
  977. pHeader->GetPropertyCString("MimeType", pMimeType);
  979. // This is not a standard payload - 
  980. // but maybe the encoding is standard
  981. if (!bSupportedPayload && pMimeType)
  982. {
  983.     bSupportedPayload = (SDPMapMimeToPayload(pMimeType, 
  984.      ulPayloadType)
  985.  == HXR_OK);
  986. }
  988. // Set the ASM rule book
  989. if ((ulAvgBitRate > 0)
  990. #ifndef QTFORCE_AVG_BITRATE_DELIVERY
  991.     && bSupportedPayload
  992.     && SDPIsFixedRatePayload(ulPayloadType)
  993. #endif // QTFORCE_AVG_BITRATE_DELIVERY
  994.    )
  995. {
  996.     // divide avg bitrate
  997.     UINT32 ulAvgBandwidth = ulAvgBitRate / 2;
  999.     SafeSprintf(pRuleBook, 128, 
  1000.     "Marker=%d,AverageBandwidth=%d;"
  1001.     "Marker=%d,AverageBandwidth=%d;",
  1002.     (QTASM_MARKER_ON_RULE == 0) ? 1 : 0,
  1003.     ulAvgBitRate - ulAvgBandwidth,
  1004.     (QTASM_MARKER_ON_RULE == 0) ? 0 : 1,
  1005.     ulAvgBandwidth);
  1006. }
  1007. else
  1008. {
  1009.     if (ulAvgBitRate > 0)
  1010.     {
  1011. SafeSprintf(pRuleBook, 128, "Marker=%d,AverageBandwidth=%d,TimeStampDelivery=TRUE;"
  1012.    "Marker=%d,AverageBandwidth=0,TimeStampDelivery=TRUE;",
  1013.         (QTASM_MARKER_ON_RULE == 0) ? 1 : 0,
  1014. ulAvgBitRate,
  1015. (QTASM_MARKER_ON_RULE == 0) ? 0 : 1);
  1016.     }
  1017.     else
  1018.     {
  1019. SafeSprintf(pRuleBook, 128, "Marker=%d,TimeStampDelivery=TRUE;"
  1020.    "Marker=%d,TimeStampDelivery=TRUE;",
  1021.         (QTASM_MARKER_ON_RULE == 0) ? 1 : 0,
  1022. (QTASM_MARKER_ON_RULE == 0) ? 0 : 1);
  1023.     }
  1024. }
  1025.     }
  1026. }
  1027. else
  1028. #endif // QTCONFIG_SERVER
  1029. {
  1030.     // Player Side
  1031.     SafeSprintf(pRuleBook, 128, "Marker=%d;Marker=%d;",
  1032. (QTASM_MARKER_ON_RULE == 0) ? 1 : 0,
  1033. (QTASM_MARKER_ON_RULE == 0) ? 0 : 1);
  1034. }
  1037. if (SUCCEEDED(retVal))
  1038. {
  1039.     retVal = pASMRuleBook->Set((UCHAR*) pRuleBook, strlen(pRuleBook) + 1);
  1040. }
  1042. if (SUCCEEDED(retVal))
  1043. {
  1044.     pHeader->SetPropertyCString("ASMRuleBook", pASMRuleBook);
  1045. }
  1046.     }
  1048.     HX_RELEASE(pASMRuleBook);
  1049.     HX_RELEASE(pMimeType);
  1051.     return retVal;
  1052. }
  1054. HX_RESULT CQTFileFormat::GetSessionIdentity(IHXValues* pHeader,
  1055.     CQT_MovieInfo_Manager* pMovieInfo)
  1056. {
  1057.     return HXR_OK;
  1058. }
  1060. HX_RESULT CQTFileFormat::GetPayloadIdentity(IHXValues* pHeader,
  1061.     CQTTrack* pTrack,
  1062.     CQT_TrackInfo_Manager* pTrackInfo)
  1063. {
  1064.     HX_RESULT retVal = HXR_OK;
  1066.     if (SUCCEEDED(retVal))
  1067.     {
  1068. const char* pMimeType = pTrackInfo->GetMimeType();
  1069. retVal = HXR_FAIL;
  1070. if (pMimeType)
  1071. {
  1072.     IHXBuffer* pMimeTypeBuffer = NULL;
  1073.     UINT32 ulMimeTypeLength = strlen(pMimeType);
  1074.     retVal = m_pClassFactory->CreateInstance(CLSID_IHXBuffer,
  1075.      (void**) &pMimeTypeBuffer);
  1077.     if (SUCCEEDED(retVal))
  1078.     {
  1079. retVal = pMimeTypeBuffer->SetSize(ulMimeTypeLength + 1);
  1080.     }
  1082.     if (SUCCEEDED(retVal))
  1083.     {
  1084. memcpy(pMimeTypeBuffer->GetBuffer(), /* Flawfinder: ignore */
  1085.        pMimeType,
  1086.        ulMimeTypeLength + 1);
  1087. retVal = pHeader->SetPropertyCString("MimeType", pMimeTypeBuffer);
  1088.     }
  1090.     HX_RELEASE(pMimeTypeBuffer);
  1091. }
  1092.     }
  1094.     if (SUCCEEDED(retVal))
  1095.     {
  1096. ULONG32 ulTimeScale = pTrackInfo->GetMediaTimeScale();
  1098. retVal = HXR_FAIL;
  1099. if (ulTimeScale != 0)
  1100. {
  1101.     retVal = pHeader->SetPropertyULONG32("SamplesPerSecond", ulTimeScale);
  1102. }
  1103.     }
  1105.     if (SUCCEEDED(retVal))
  1106.     {
  1107. ULONG32 ulPayloadType = pTrackInfo->GetPayloadType();
  1109. retVal = HXR_FAIL;
  1110. if (ulPayloadType != QT_BAD_PAYLOAD)
  1111. {
  1112.     retVal = pHeader->SetPropertyULONG32("RTPPayloadType", ulPayloadType);
  1113. }
  1114.     }
  1116.     return retVal;
  1117. }
  1120. /************************************************************************
  1121.  *  GetPacket
  1122.  *  Method:
  1123.  * IHXFileFormatObject::GetPacket
  1124.  *  Purpose:
  1125.  * Called by controller to ask the file format for the next packet
  1126.  * for a particular stream in the file. The file format should call
  1127.  * IHXFileFormatResponse::Data*() for the IHXFileFormatResponse
  1128.  * object that was passed in during initialization, when the packet
  1129.  * is available.
  1130.  */
  1131. STDMETHODIMP CQTFileFormat::GetPacket(UINT16 unStreamNumber)
  1132. {
  1133.     HX_RESULT retVal;
  1135.     if (unStreamNumber < m_TrackManager.GetNumStreams())
  1136.     {
  1137. switch (m_State)
  1138. {
  1139. case QTFF_Ready:
  1140.     if (unStreamNumber == m_uNextPacketStreamNum)
  1141.     {
  1142. // Process this packet request
  1143. // - but replace stream's cache first
  1144. HX_ASSERT(m_pPacketCache);
  1146. m_State = QTFF_GetPacket;
  1147. return m_TrackManager.GetStreamTrack(unStreamNumber)->
  1148. GetPacket(unStreamNumber);
  1149.     }
  1150.     else if (m_pPacketCache)
  1151.     {
  1152. // Delay processing packet for stream until its turn
  1153. if (!m_pPacketCache[unStreamNumber].bStreamDone)
  1154. {
  1155.     if (!m_pPacketCache[unStreamNumber].bPending)
  1156.     {
  1157. m_pPacketCache[unStreamNumber].bPending = TRUE;
  1158. return HXR_OK;
  1159.     }
  1160.     else
  1161.     {
  1162. retVal = HXR_UNEXPECTED;
  1163.     }
  1164. }
  1165. else
  1166. {
  1167.     retVal = m_pFFResponse->StreamDone(unStreamNumber);
  1168. }
  1169.     }
  1170.     else
  1171.     {
  1172. // Packet Cache not primed - start priming
  1174. // To save memory, release streams not used
  1175. m_TrackManager.RemoveInactiveStreams(TRUE);
  1177. m_State = QTFF_PrimeCache;
  1178. m_pPacketCache = new 
  1179.     CPacketCache[m_TrackManager.GetNumStreams()];
  1180. if (m_pPacketCache)
  1181. {
  1182.     m_pPacketCache[unStreamNumber].bPending = TRUE;
  1184.     if (m_TrackManager.IsStreamTrackActive(0))
  1185.     {
  1186. return m_TrackManager.GetStreamTrack(0)->
  1187.     GetPacket(0);
  1188.     }
  1189.     else
  1190.     {
  1191. return PacketReady(0, 
  1192.    HXR_STREAM_DONE,
  1193.    NULL);
  1194.     }
  1195. }
  1196. else
  1197. {
  1198.     retVal = HXR_OUTOFMEMORY;
  1199.     m_State = QTFF_Error;
  1200. }
  1201.     }
  1202.     break;
  1204. case QTFF_GetPacket:
  1205. case QTFF_PrimeCache:
  1206.     // Delay processing packet for stream until Ready
  1207.     HX_ASSERT(m_pPacketCache);
  1209.     if (!m_pPacketCache[unStreamNumber].bStreamDone)
  1210.     {
  1211. if (!m_pPacketCache[unStreamNumber].bPending)
  1212. {
  1213.     m_pPacketCache[unStreamNumber].bPending = TRUE;
  1214.     return HXR_OK;
  1215. }
  1216. else
  1217. {
  1218.     retVal = HXR_UNEXPECTED;
  1219. }
  1220.     }
  1221.     else
  1222.     {
  1223. retVal = m_pFFResponse->StreamDone(unStreamNumber);
  1224.     }
  1225.     break;
  1227. default:
  1228.     retVal = HXR_UNEXPECTED;
  1229.     break;
  1230. }
  1231.     }
  1232.     else
  1233.     {
  1234. retVal = HXR_INVALID_PARAMETER;
  1235.     }
  1237.     return retVal;
  1238. }
  1240. /************************************************************************
  1241.  *  Seek
  1242.  *  Purpose:
  1243.  * Called by controller to tell the file format to seek to the 
  1244.  * nearest packet to the requested offset. The file format should 
  1245.  * call IHXFileFormatResponse::SeekDone() for the IHXFileFormat-
  1246.  * Session object that was passed in during initialization, when 
  1247.  * the seek has completed.
  1248.  */
  1249. STDMETHODIMP CQTFileFormat::Seek(ULONG32 ulOffset)
  1250. {
  1251.     UINT16 uStreamNum;
  1252.     HX_RESULT retVal = HXR_OK;
  1254.     switch (m_State)
  1255.     {
  1256.     case QTFF_Ready:
  1257. for (uStreamNum = 0;
  1258.      uStreamNum < m_TrackManager.GetNumStreams();
  1259.      uStreamNum++)
  1260. {
  1261.     if (m_TrackManager.IsStreamTrackActive(uStreamNum))
  1262.     {
  1263. m_TrackManager.GetStreamTrack(uStreamNum)->Seek(ulOffset);
  1264.     }
  1265. }
  1267. m_uNextPacketStreamNum = NO_STREAM_SET;
  1268. HX_VECTOR_DELETE(m_pPacketCache);
  1270. retVal = m_pFFResponse->SeekDone(HXR_OK);
  1271. break;
  1273.     case QTFF_GetPacket:
  1274.     case QTFF_PrimeCache:
  1275.     case QTFF_SeekPending:
  1276. m_State = QTFF_SeekPending;
  1277. m_ulPendingSeekTime = ulOffset;
  1278. break;
  1280.     default:
  1281. retVal = HXR_UNEXPECTED;
  1282. break;
  1283.     }
  1285.     return retVal;
  1286. }
  1288. /************************************************************************
  1289.  *  WriteDone
  1290.  *  Purpose:
  1291.  * Notification interface provided by users of the IHXFileObject
  1292.  * interface. This method is called by the IHXFileObject when the
  1293.  * last write to the file is complete.
  1294.  */
  1295. STDMETHODIMP CQTFileFormat::WriteDone(HX_RESULT status)
  1296. {
  1297.     return HXR_UNEXPECTED;
  1298. }
  1300. /************************************************************************
  1301.  *  SeekDone
  1302.  *  Purpose:
  1303.  * Notification interface provided by users of the IHXFileObject
  1304.  * interface. This method is called by the IHXFileObject when the
  1305.  * last seek in the file is complete.
  1306.  */
  1307. STDMETHODIMP CQTFileFormat::SeekDone(HX_RESULT status)
  1308. {
  1309.     return HXR_UNEXPECTED;
  1310. }
  1312. /************************************************************************
  1313.  *  Close
  1314.  */
  1315. STDMETHODIMP CQTFileFormat::Close()
  1316. {
  1317.     m_State = QTFF_Error;
  1319.     HX_RELEASE(m_pContext);
  1320.     HX_RELEASE(m_pRequest);
  1321.     HX_RELEASE(m_pFFResponse);
  1322.     HX_RELEASE(m_pClassFactory);
  1323.     HX_RELEASE(m_pScheduler);
  1324.     HX_RELEASE(m_pErrorMessages);
  1325.     if (m_pFileSwitcher)
  1326.     {
  1327. m_pFileSwitcher->Close(this);
  1328. m_pFileSwitcher->Release();
  1329. m_pFileSwitcher = NULL;
  1330.     }
  1331.     if (m_pAtomizer)
  1332.     {
  1333. m_pAtomizer->Close();
  1334. m_pAtomizer->Release();
  1335. m_pAtomizer = NULL;
  1336.     }
  1337.     HX_RELEASE(m_pPacketAssembler);
  1338. #ifdef QTCONFIG_BFRAG_FACTORY
  1339.     HX_RELEASE(m_pBufferFragmentFactory);
  1340. #endif // QTCONFIG_BFRAG_FACTORY
  1341.     HX_VECTOR_DELETE(m_pPacketCache);
  1343.     m_TrackManager.CloseTracks();
  1345.     return HXR_OK;
  1346. }
  1348. /************************************************************************
  1349.  *  IHXFileResponse
  1350.  */
  1351. /************************************************************************
  1352.  *  InitDone
  1353.  *  Purpose:
  1354.  *    Notification interface provided by users of the IHXFileObject
  1355.  *    interface. This method is called by the IHXFileObject when the
  1356.  *    initialization of the file is complete, and the Mime type is
  1357.  *    available for the request file. If the URL is not valid for the
  1358.  *    file system, the status HXR_FAILED should be returned,
  1359.  *    with a mime type of NULL. If the URL is valid but the mime type
  1360.  *    is unknown, then the status HXR_OK should be returned with
  1361.  *    a mime type of NULL.
  1362.  */
  1363. STDMETHODIMP CQTFileFormat::InitDone(HX_RESULT status)
  1364. {
  1365.     HX_RESULT retVal = HXR_OK;
  1367.     switch (m_State)
  1368.     {
  1369.     case QTFF_Init:
  1370. if (SUCCEEDED(status))
  1371. {
  1372.     status = m_pAtomizer->Init((IUnknown*)(IHXFileSwitcher*) m_pFileSwitcher,
  1373.        (IUnknown*)(IHXAtomizerResponse*) this,
  1374.        (IUnknown*)(IHXAtomizationCommander*) this);
  1375. }
  1377. m_State = SUCCEEDED(status) ? QTFF_Ready : QTFF_Error;
  1379. retVal = m_pFFResponse->InitDone(status);
  1380. break;
  1382.     default:
  1383. retVal = HXR_UNEXPECTED;
  1384. break;
  1385.     }
  1387.     return retVal;
  1388. }
  1391. /************************************************************************
  1392.  *  CloseDone
  1393.  *  Purpose:
  1394.  * Notification interface provided by users of the IHXFileObject
  1395.  * interface. This method is called by the IHXFileObject when the
  1396.  * close of the file is complete.
  1397.  */
  1398. STDMETHODIMP CQTFileFormat::CloseDone(HX_RESULT status)
  1399. {
  1400.     // nothing to do
  1401.     return HXR_OK;
  1402. }
  1404. /************************************************************************
  1405.  *  ReadDone
  1406.  *  Purpose:
  1407.  * Notification interface provided by users of the IHXFileObject
  1408.  * interface. This method is called by the IHXFileObject when the
  1409.  * last read from the file is complete and a buffer is available.
  1410.  */
  1411. STDMETHODIMP CQTFileFormat::ReadDone(HX_RESULT status,
  1412.     IHXBuffer* pBuffer)
  1413. {
  1414.     return HXR_UNEXPECTED;
  1415. }
  1417. /************************************************************************
  1418.  *  IHXAtomizationCommander
  1419.  */
  1420. /************************************************************************
  1421.  *  GetAtomCommand
  1422.  */
  1423. QTAtomizerCmd CQTFileFormat::GetAtomCommand(QTAtomType AtomType, CQTAtom* pParent)
  1424. {
  1425.     QTAtomizerCmd eCmd = ATMZR_CMD_LOAD;
  1427.     switch (AtomType)
  1428.     {
  1429.     case QT_udta:
  1430. if (pParent->GetType() == QT_HXROOT)
  1431. {
  1432.     eCmd = ATMZR_CMD_SKIP;
  1433. }
  1434. break;
  1436.     default:
  1437. // do nothing;
  1438. break;
  1439.     }
  1441.     return eCmd;
  1442. }
  1445. /************************************************************************
  1446.  *  IHXAtomizerResponse
  1447.  */
  1448. /************************************************************************
  1449.  *  AtomReady
  1450.  */
  1451. HX_RESULT CQTFileFormat::AtomReady(HX_RESULT status, CQTAtom* pRootAtom)
  1452. {
  1453.     HX_RESULT retVal = HXR_UNEXPECTED;
  1454.     CQTPacketizerFactory* pPacketizerFactory = NULL;
  1456.     switch (m_State)
  1457.     {
  1458.     case QTFF_Atomize:
  1459. if (SUCCEEDED(status))
  1460. {
  1461.     HX_ASSERT(pRootAtom);
  1462.     
  1463.     pRootAtom->AddRef();
  1464.     
  1465.     if (m_pAtomizer)
  1466.     {
  1467. m_pAtomizer->Close();
  1468. m_pAtomizer->Release();
  1469. m_pAtomizer = NULL;
  1470.     } 
  1471. }
  1472. else
  1473. {
  1474.     pRootAtom = NULL;
  1475. }
  1477. if (SUCCEEDED(status))
  1478. {
  1479.     IHXClientEngine* pPlayer = NULL;
  1480.     if (SUCCEEDED(m_pContext->QueryInterface(IID_IHXClientEngine, 
  1481.      (void**)&pPlayer)))
  1482.     {
  1483. m_TrackManager.SetEType(QT_ETYPE_CLIENT);
  1484.     }
  1485.     else
  1486.     {
  1487. m_TrackManager.SetEType(QT_ETYPE_SERVER);
  1488.     }
  1489.     HX_RELEASE(pPlayer);
  1490. }
  1492. if (SUCCEEDED(status))
  1493. {
  1494.     status = m_TrackManager.ManageTracks(pRootAtom);
  1495. }
  1497. #ifdef QTCONFIG_PACKETIZER_FACTORY
  1498. if (SUCCEEDED(status))
  1499. {
  1500.     pPacketizerFactory = BuildPacketizerFactory();
  1501.     if (!pPacketizerFactory)
  1502.     {
  1503. status = HXR_OUTOFMEMORY;
  1504.     }
  1505. }
  1506. #endif // QTCONFIG_PACKETIZER_FACTORY
  1508. if (SUCCEEDED(status))
  1509. {
  1510.     BOOL bIgnoreHintTracks = FALSE;
  1511.     while (1)
  1512.     {
  1513. status = m_TrackManager.ReadyTracks(bIgnoreHintTracks, 
  1514.          m_bViewSourceRequest);
  1516.           if (SUCCEEDED(status))
  1517. {
  1518.     status = m_MovieInfo.Init(pRootAtom->FindPresentChild(QT_moov),
  1519.       &m_TrackManager);
  1520. }
  1522.           if (SUCCEEDED(status))
  1523.           {         
  1524.          /*
  1525.          * return some error to indicate try something else
  1526.          */
  1527.          status = m_TrackManager.InitTracks(this, 
  1528.             m_pPacketAssembler,
  1529.             pPacketizerFactory);
  1530.          
  1532.          if ((HXR_NOT_SUPPORTED == status) && 
  1533. (bIgnoreHintTracks = !bIgnoreHintTracks))
  1534.     {
  1535. m_MovieInfo.Clear();
  1536. m_TrackManager.ResetTracks();
  1537.     }
  1538.     else
  1539.     {
  1540.      /*
  1541.           * Until we add support for unhinted content on the server....
  1542.           * 
  1543.           * Verify that hint tracks are present and log a warning message if
  1544.           * they're missing
  1545.           */          
  1546.      WarnIfNotHinted(status, bIgnoreHintTracks);
  1547.     
  1548.      /*
  1549.       * XXXGo - Change warning to take into account
  1550.       * hintrack and license for dynamic pktization
  1551.       * e.g. force pktization yet not licensed for dynamic pktization...
  1552.       */      
  1553.          
  1554.           if (FAILED(status) && m_bViewSourceRequest)
  1555.           {
  1556.          // For view source, proceed attempting to return as much
  1557.          // information as possible
  1558.          status = HXR_OK;
  1559.           }
  1561. break;
  1562.     }
  1563. }
  1564. else
  1565. {
  1566.     break;
  1567. }
  1568.     }
  1569. }
  1571. HX_DELETE(pPacketizerFactory);
  1573. #ifdef QTCONFIG_BFRAG_FACTORY
  1574. if (SUCCEEDED(status))
  1575. {
  1576.     HX_RELEASE(m_pBufferFragmentFactory);
  1577.     m_pBufferFragmentFactory = new CBufferFragmentFactory(
  1578. m_TrackManager.GetNumStreams() * QTBUFFERFRAGMENT_POOL_SIZE,
  1579. m_TrackManager.GetNumStreams() * QTBUFFERFRAGMENT_INITIAL_POOL_SIZE);
  1581.     retVal = HXR_OUTOFMEMORY;
  1582.     if (m_pBufferFragmentFactory)
  1583.     {
  1584. m_pBufferFragmentFactory->AddRef();
  1585. retVal = HXR_OK;
  1586.     }
  1587. }
  1588. #endif // QTCONFIG_BFRAG_FACTORY
  1590. HX_RELEASE(pRootAtom);
  1592. m_State = SUCCEEDED(status) ? QTFF_Ready : QTFF_Error;
  1594. retVal = MakeFileHeader(status);
  1595. break;
  1597.     default:
  1598. // nothing to do
  1599. break;
  1600.     }
  1602.     return retVal;
  1603. }
  1606. /************************************************************************
  1607.  *  IHXASMSource
  1608.  */
  1609. /************************************************************************
  1610.  *  Subscribe
  1611.  */
  1612. STDMETHODIMP CQTFileFormat::Subscribe(UINT16 uStreamNum,
  1613.       UINT16 uRuleNumber)
  1614. {
  1615.     return m_TrackManager.Subscribe(uStreamNum);
  1616. }
  1618. /************************************************************************
  1619.  *  Unsubscribe
  1620.  */
  1621. STDMETHODIMP CQTFileFormat::Unsubscribe(UINT16 uStreamNum,
  1622. UINT16 uRuleNumber)
  1623. {
  1624.     return m_TrackManager.Unsubscribe(uStreamNum);
  1625. }
  1628. /************************************************************************
  1629.  *      Method:
  1630.  *          IHXPacketFormat::GetSupportedPacketFormats
  1631.  *      Purpose:
  1632.  *          Obtains a list of packet formats supported by this file format
  1633.  */
  1634. STDMETHODIMP CQTFileFormat::GetSupportedPacketFormats
  1635. (
  1636.     REF(const char**) /*OUT*/ pPacketFormats
  1637. )
  1638. {
  1639.     pPacketFormats = (const char**) zm_pPacketFormats;
  1640.     return HXR_OK;
  1641. }
  1643. /************************************************************************
  1644.  *      Method:
  1645.  *          IHXPacketFormat::SetPacketFormat
  1646.  *      Purpose:
  1647.  *          Sets the packet type for this file format
  1648.  */
  1649. STDMETHODIMP CQTFileFormat::SetPacketFormat
  1650. (
  1651.     const char* pPacketFormat
  1652. )
  1653. {
  1654.     if (strcasecmp(pPacketFormat, "rtp") == 0)
  1655.     {
  1656.         m_ulPacketFormat = QTFF_RTP_FORMAT;
  1657.     }
  1658.     else
  1659.     {
  1660.         m_ulPacketFormat = QTFF_RDT_FORMAT;
  1661.     }
  1662.     return HXR_OK;
  1663. }
  1666. /************************************************************************
  1667.  *  Main Interface
  1668.  */
  1669. /************************************************************************
  1670.  *  PacketReady
  1671.  */
  1672. HX_RESULT CQTFileFormat::PacketReady(UINT16 uStreamNum, 
  1673.      HX_RESULT status, 
  1674.      IHXPacket* pPacket)
  1675. {
  1676.     HX_RESULT retVal;
  1677.     IHXPacket *pPacketToSend;
  1679.     switch (m_State)
  1680.     {
  1681.     case QTFF_GetPacket:
  1682. pPacketToSend = m_pPacketCache[uStreamNum].pPacket;
  1684. HX_ASSERT(pPacketToSend);
  1686. if (status == HXR_OK)
  1687. {
  1688.     HX_ASSERT(pPacket);
  1690.     m_pPacketCache[uStreamNum].pPacket = pPacket;
  1691.     pPacket->AddRef();
  1692. }
  1693. else
  1694. {
  1695.     m_pPacketCache[uStreamNum].pPacket = NULL;
  1696.     m_pPacketCache[uStreamNum].bStreamDone = TRUE;
  1697.     if (status == HXR_STREAM_DONE)
  1698.     {
  1699. status = HXR_OK;
  1700.     }
  1701. }
  1703. AddRef();   // Make Sure we do not die as a result of PacketReady
  1705. m_pPacketCache[uStreamNum].bPending = FALSE;
  1706. retVal = m_pFFResponse->PacketReady(status, pPacketToSend);
  1708. if (pPacketToSend)
  1709. {
  1710.     pPacketToSend->Release();
  1711. }
  1713. // Make sure the state did not change as result of PacketReady()
  1714. // The possible change is due to invocation of Close on PacketReady
  1715. if (m_State == QTFF_GetPacket)
  1716. {
  1717.     m_State = QTFF_Ready;
  1719.     // see if a pending request needs to be fullfilled
  1720.     m_uNextPacketStreamNum = GetNextPacketStreamNum();
  1721.     if ((m_uNextPacketStreamNum != NO_STREAM_SET) &&
  1722. m_pPacketCache[m_uNextPacketStreamNum].bPending)
  1723.     {
  1724. m_State = QTFF_GetPacket;
  1725. retVal = m_TrackManager.GetStreamTrack(m_uNextPacketStreamNum)->
  1726.     GetPacket(m_uNextPacketStreamNum);
  1727.     }
  1728. }
  1730. Release();
  1732. return retVal;
  1734.     case QTFF_PrimeCache:
  1735. if (status == HXR_OK)
  1736. {
  1737.     HX_ASSERT(pPacket);
  1739.     m_pPacketCache[uStreamNum].pPacket = pPacket;
  1740.     pPacket->AddRef();
  1741. }
  1742. else
  1743. {
  1744.     m_pPacketCache[uStreamNum].pPacket = NULL;
  1745.     m_pPacketCache[uStreamNum].bStreamDone = TRUE;
  1746.     if (status == HXR_STREAM_DONE)
  1747.     {
  1748. if (m_pPacketCache[uStreamNum].bPending)
  1749. {
  1750.     AddRef();   // Make sure we do not die
  1752.     m_pPacketCache[uStreamNum].bPending = FALSE;
  1753.     retVal = m_pFFResponse->StreamDone(uStreamNum);
  1755.     if (m_State != QTFF_PrimeCache)
  1756.     {
  1757. // StreamDone must have closed us
  1758. Release();
  1760. break;
  1761.     }
  1763.     Release();
  1764. }
  1765.     }
  1766.     else
  1767.     {
  1768. // Fatal failure
  1769. retVal = HandleFailure(status);
  1771. break;
  1772.     }
  1773. }
  1775. uStreamNum++;
  1776. if (uStreamNum < m_TrackManager.GetNumStreams())
  1777. {
  1778.     // we still have stream packets to prime
  1779.     if (m_TrackManager.IsStreamTrackActive(uStreamNum))
  1780.     {
  1781. retVal = m_TrackManager.GetStreamTrack(uStreamNum)->
  1782.     GetPacket(uStreamNum);
  1783.     }
  1784.     else
  1785.     {
  1786. retVal = PacketReady(uStreamNum, 
  1787.      HXR_STREAM_DONE,
  1788.      NULL);
  1789.     }
  1790. }
  1791. else
  1792. {
  1793.     // we are done priming the packets
  1794.     retVal = HXR_OK;
  1795.     m_State = QTFF_Ready;
  1797.     // see if a pending request needs to be fullfilled
  1798.     m_uNextPacketStreamNum = GetNextPacketStreamNum();
  1799.     if ((m_uNextPacketStreamNum != NO_STREAM_SET) &&
  1800. m_pPacketCache[m_uNextPacketStreamNum].bPending)
  1801.     {
  1802. m_State = QTFF_GetPacket;
  1803. retVal = m_TrackManager.
  1804.     GetStreamTrack(m_uNextPacketStreamNum)->
  1805. GetPacket(m_uNextPacketStreamNum);
  1806.     }
  1807. }
  1808. break;
  1810.     case QTFF_SeekPending:
  1811. HX_VECTOR_DELETE(m_pPacketCache);
  1812. m_uNextPacketStreamNum = NO_STREAM_SET;
  1813. m_State = QTFF_Ready;
  1815. retVal = Seek(m_ulPendingSeekTime);
  1816. break;
  1818.     default:
  1819. retVal = HXR_UNEXPECTED;
  1820. break;
  1821.     }
  1823.     return retVal;
  1824. }
  1827. /************************************************************************
  1828.  *  Protected Methods
  1829.  */
  1830. CQTPacketizerFactory* CQTFileFormat::BuildPacketizerFactory(void)
  1831. {
  1832. #ifdef QTCONFIG_PACKETIZER_FACTORY
  1833.     return new CQTPacketizerFactory();
  1834. #else // QTCONFIG_PACKETIZER_FACTORY
  1835.     return NULL;
  1836. #endif // QTCONFIG_PACKETIZER_FACTORY
  1837. }
  1839. /************************************************************************
  1840.  *  Private Methods
  1841.  */
  1842. /************************************************************************
  1843.  *  GetNextPacketStreamNum
  1844.  */
  1845. inline UINT16 CQTFileFormat::GetNextPacketStreamNum(void)
  1846. {
  1847.     UINT16 uStreamNum;
  1848.     ULONG32 ulLowestTime = 0xFFFFFFFF;
  1849.     UINT16 uNextPacketStream = NO_STREAM_SET;
  1851.     HX_ASSERT(m_pPacketCache);
  1853.     for (uStreamNum = 0;
  1854.  uStreamNum < m_TrackManager.GetNumStreams();
  1855.  uStreamNum++)
  1856.     {
  1857. if (!m_pPacketCache[uStreamNum].bStreamDone)
  1858. {
  1859.     HX_ASSERT(m_pPacketCache[uStreamNum].pPacket);
  1861.     if (ulLowestTime >
  1862. m_pPacketCache[uStreamNum].pPacket->GetTime())
  1863.     {
  1864. uNextPacketStream = uStreamNum;
  1865. ulLowestTime = m_pPacketCache[uStreamNum].
  1866.     pPacket->GetTime();
  1867.     }
  1868. }
  1869.     }
  1871.     return uNextPacketStream;
  1872. }
  1874. /************************************************************************
  1875.  *  HandleFailure
  1876.  */
  1877. HX_RESULT CQTFileFormat::HandleFailure(HX_RESULT status)
  1878. {
  1879.     HX_RESULT retVal = HXR_OK;
  1881.     HX_ASSERT(FAILED(status));
  1883.     switch (m_State)
  1884.     {
  1885.     case QTFF_PrimeCache:
  1886. {
  1887.     UINT16 uStreamNum = 0;
  1888.     m_State = QTFF_Error;
  1889.     
  1890.     AddRef();
  1892.     while (m_pPacketCache &&
  1893.    (uStreamNum < m_TrackManager.GetNumStreams()))
  1894.     {
  1895. if (m_pPacketCache[uStreamNum].bPending)
  1896. {
  1897.     m_pPacketCache[uStreamNum].bPending = FALSE;
  1898.     m_pFFResponse->PacketReady(status, NULL);
  1899. }
  1900. uStreamNum++;
  1901.     }
  1903.     Release();
  1904. }
  1905. break;
  1907.     default:
  1908. retVal = HXR_UNEXPECTED;
  1909. break;
  1910.     }
  1912.     return retVal;
  1913. }
  1915. /************************************************************************
  1916.  *  a standard way of pulling a error string out of a resource file in a 
  1917.  *  localization friendly manner :)
  1918.  */
  1919. void 
  1920. CQTFileFormat::ReportError(UINT32 ulErrorID, HX_RESULT retVal)
  1921. {
  1922.     // Try to get the string from the resource manager
  1923.     CHXString cErrStr;
  1924.     HX_RESULT errRet = GetResourceErrorString(ulErrorID, cErrStr);
  1925.     if (errRet != HXR_OK)
  1926.     {
  1927.         switch (ulErrorID)
  1928.         {
  1929.             case IDS_ERR_QT_NOTLICENSED:
  1930.                 cErrStr = ERRSTR_QT_NOTLICENSED;
  1931.                 break;
  1932.             default:
  1933.                 cErrStr = ERRSTR_QT_GENERALERROR;
  1934.                 break;
  1935.         }
  1936.     }
  1937.  
  1938.     if (m_pErrorMessages)
  1939.     {
  1940.         m_pErrorMessages->Report(HXLOG_CRIT, retVal, 0, (const char*) cErrStr,  NULL);
  1941.     }
  1942. }
  1944. HX_RESULT 
  1945. CQTFileFormat::GetResourceErrorString(UINT32 ulErrorID, CHXString& rErrorStr)
  1946. {
  1947.     IHXExternalResourceManager* pResMgr = NULL;
  1948.     HX_RESULT retVal = m_pContext->QueryInterface(IID_IHXExternalResourceManager, (void**) &pResMgr);
  1949.     if (retVal != HXR_OK)
  1950.     {
  1951.         return retVal;
  1952.     }
  1954. IHXExternalResourceReader* pResRdr = NULL;
  1955.     retVal = pResMgr->CreateExternalResourceReader(CORE_RESOURCE_SHORT_NAME, pResRdr);
  1956.     if (retVal != HXR_OK)
  1957.     {
  1958.         HX_RELEASE(pResMgr);
  1959.         return retVal;
  1960.     }
  1962.     IHXXResource* pRes = pResRdr->GetResource(HX_RT_STRING, ulErrorID);
  1963.     if(!pRes)
  1964.     {
  1965.         HX_RELEASE(pResRdr);
  1966.         HX_RELEASE(pResMgr);
  1967.         return HXR_FAIL;
  1968.     }
  1970.     // Assign the error string to the out parameter
  1971.     rErrorStr = (const char*) pRes->ResourceData();
  1973.     // Release all references
  1974.     HX_RELEASE(pRes);
  1975.     HX_RELEASE(pResRdr);
  1976.     HX_RELEASE(pResMgr);
  1978.     return HXR_OK;
  1979. }
  1981. /************************************************************************
  1982.  *  AddMetaInfo
  1983.  */
  1984. HX_RESULT CQTFileFormat::AddMetaInfo(IHXValues* pHeader)
  1985. {
  1986.     BOOL bAddAll;
  1988.     ULONG32 ulPresentationWidth = 0;
  1989.     ULONG32 ulPresentationHeight = 0;
  1990.     
  1991.     HX_ASSERT(pHeader);
  1993.     if ((m_TrackManager.GetEType() == QT_ETYPE_CLIENT) || 
  1994. (m_ulStreamMetaInfoMask & META_INFO_ALL) ||
  1995. (m_ulStreamMetaInfoMask & META_INFO_WIDTH) ||
  1996. (m_ulStreamMetaInfoMask & META_INFO_HEIGHT))
  1997.     {
  1998. UINT16 uStreamCount;
  1999. CQTTrack* pTrack;
  2001. // Collect Meta Info
  2002. for (uStreamCount = m_TrackManager.GetNumStreams();
  2003.      uStreamCount != 0;
  2004.      uStreamCount--)
  2005. {
  2006.     pTrack = m_TrackManager.GetStreamTrack(uStreamCount - 1);
  2008.     ulPresentationWidth += pTrack->m_TrackInfo.GetTrackWidth();
  2009.     ulPresentationHeight += pTrack->m_TrackInfo.GetTrackHeight();
  2010. }
  2011.     }
  2013.     bAddAll = ((m_TrackManager.GetEType() == QT_ETYPE_CLIENT) || 
  2014.        (m_ulStreamMetaInfoMask & META_INFO_ALL));
  2016.     if (bAddAll)
  2017.     {
  2018. if (ulPresentationWidth > 0)
  2019. {
  2020.     pHeader->SetPropertyULONG32(WIDTH_METANAME, 
  2021. ulPresentationWidth);
  2022. }
  2023. if (ulPresentationHeight > 0)
  2024. {
  2025.     pHeader->SetPropertyULONG32(HEIGHT_METANAME, 
  2026. ulPresentationHeight);
  2027. }
  2028.     }
  2029. #ifdef QTCONFIG_SERVER
  2030.     else if((m_ulStreamMetaInfoMask & META_INFO_ALL) ||
  2031. (m_ulStreamMetaInfoMask & META_INFO_WIDTH) ||
  2032. (m_ulStreamMetaInfoMask & META_INFO_HEIGHT))
  2033.     {     
  2034. if (ulPresentationWidth > 0 &&
  2035.     ((m_ulStreamMetaInfoMask & META_INFO_ALL) ||
  2036.     (m_ulStreamMetaInfoMask & META_INFO_WIDTH)))
  2037. {
  2038.     pHeader->SetPropertyULONG32(WIDTH_METANAME, 
  2039. ulPresentationWidth);
  2040. }
  2042. if (ulPresentationHeight > 0 &&
  2043.     ((m_ulStreamMetaInfoMask & META_INFO_ALL) ||
  2044.     (m_ulStreamMetaInfoMask & META_INFO_HEIGHT)))
  2045. {
  2046.     pHeader->SetPropertyULONG32(HEIGHT_METANAME, 
  2047. ulPresentationHeight);
  2048. }
  2049.     } 
  2050. #endif // QTCONFIG_SERVER
  2052.     return HXR_OK;
  2053. }
  2055. #ifdef QTCONFIG_SERVER
  2056. /************************************************************************
  2057.  *  CheckLicense
  2058.  */
  2059. HX_RESULT CQTFileFormat::CheckLicense(void)
  2060. {
  2061.     HX_ASSERT(m_pContext);
  2062.     
  2063.     IHXClientEngine* pPlayer = NULL;
  2064.     IHXRemoteBroadcastServices* pRBServices = NULL;
  2065.     if (SUCCEEDED(m_pContext->QueryInterface(IID_IHXClientEngine, (void**)&pPlayer))
  2066.         || SUCCEEDED(m_pContext->QueryInterface(IID_IHXRemoteBroadcastServices, (void**)&pRBServices)))
  2067.     {
  2068.         // Data types are always licensed on the Player and iqslta
  2069.         m_bQTLicensed = TRUE;
  2070. m_bMP4Licensed = TRUE;
  2071.     }
  2072.     else
  2073.     {    
  2074.         // On the Server, check the license section of the registry
  2075.         IHXRegistry* pRegistry = NULL;        
  2076. if (HXR_OK != m_pContext->QueryInterface(IID_IHXRegistry, 
  2077. (void**)&pRegistry))
  2078. {
  2079.     return HXR_UNEXPECTED;
  2080. }
  2082.         INT32 nLicensed = 0;
  2083.         if (!SUCCEEDED(pRegistry->GetIntByName(REGISTRY_QUICKTIME_ENABLED, 
  2084.             nLicensed)))
  2085.         {
  2086.             /* take default */
  2087.             nLicensed = LICENSE_QUICKTIME_ENABLED;
  2088.         }
  2089.         m_bQTLicensed = (nLicensed) ? (TRUE) : (FALSE);
  2091.         if (!SUCCEEDED(pRegistry->GetIntByName(REGISTRY_REALMP4_ENABLED, 
  2092.             nLicensed)))
  2093.         {
  2094.             /* take default */
  2095.             nLicensed = LICENSE_REALMP4_ENABLED;
  2096.         }
  2097.         m_bMP4Licensed = (nLicensed) ? (TRUE) : (FALSE);
  2099.         HX_RELEASE(pRegistry);
  2100.     }
  2101.     HX_RELEASE(pPlayer);
  2102.     HX_RELEASE(pRBServices);
  2104.     return HXR_OK;
  2105. }
  2107. /************************************************************************
  2108.  *  WarnIfNotHinted
  2109.  */
  2110. void CQTFileFormat::WarnIfNotHinted(HX_RESULT status, BOOL bIgnoreHintTracks)
  2111. {    
  2112.     /*
  2113.      * log what's going on...
  2114.      */    
  2115.     if ((m_TrackManager.GetEType() == QT_ETYPE_SERVER) && m_pErrorMessages
  2116. && HXR_OK == status)
  2117.     {
  2118.         /*
  2119.          * Check the registry to see if warnings are disabled.
  2120.          */
  2121.         INT32 nWarningDisabled = 0;
  2122.         IHXRegistry* pRegistry = NULL;
  2123.         if (m_pContext &&
  2124.             (HXR_OK == m_pContext->QueryInterface(IID_IHXRegistry, 
  2125.                                                  (void**)&pRegistry)))
  2126.         {
  2127.             pRegistry->GetIntByName("config.DisableHintingWarning",
  2128.                                     nWarningDisabled);
  2129.         }
  2130.         HX_RELEASE(pRegistry);
  2132.         if (nWarningDisabled)
  2133.         {
  2134.             return;
  2135.         }
  2137. const char* pszIgnore = 
  2138.     "Handling HINTED content - ignoring Hint Tracks (URL: /%s)n";
  2139. const char* pszHint = 
  2140.     "Handling HINTED content - using Hint Tracks (URL: /%s)n";
  2141. const char* pszNotHinted = 
  2142.     "Handling UNHINTED content (URL: /%s)n";
  2143. const char* pszMsg;
  2145. if (bIgnoreHintTracks)
  2146. {
  2147.     pszMsg = pszIgnore;
  2148. }
  2149. else if (m_TrackManager.IsHinted())
  2150. {
  2151.     pszMsg = pszHint;
  2152.     HX_ASSERT(HXR_NOT_LICENSED != status); // can't ever be this error
  2153. }
  2154. else
  2155. {
  2156.     pszMsg = pszNotHinted;
  2157. }
  2159.         const char* pReqURL = NULL;        
  2160.         UINT32 ulMaxURLLen = 1024 * 2;
  2161.         UINT32 ulBuffLen = ulMaxURLLen + strlen(pszMsg) + 1;
  2163.         HX_RESULT status = HXR_OK;
  2164.         if (m_pRequest)
  2165.         {
  2166.             status = m_pRequest->GetURL(pReqURL);
  2167.         }
  2169.         if (SUCCEEDED(status) && pReqURL)
  2170.         {
  2171.             UINT32 ulURLLen = strlen(pReqURL);
  2172.             if (ulURLLen >  ulMaxURLLen)
  2173.             {
  2174.                 pReqURL += ulURLLen - ulMaxURLLen;  
  2175.             }
  2176.         }
  2177.         else 
  2178.         {
  2179.             pReqURL = " ";
  2180.         }
  2182.         NEW_FAST_TEMP_STR(pszTmpStr, 4096, ulBuffLen);
  2183.         snprintf(pszTmpStr, ulBuffLen, pszMsg, pReqURL); 
  2184.         m_pErrorMessages->Report(HXLOG_WARNING, HXR_OK, 0, pszTmpStr, NULL);
  2185.         DELETE_FAST_TEMP_STR(pszTmpStr);
  2186.     }
  2187. }
  2188. #else // QTCONFIG_SERVER
  2189. HX_RESULT CQTFileFormat::CheckLicense(void)
  2190. {
  2191.     return HXR_OK;
  2192. }
  2194. void CQTFileFormat::WarnIfNotHinted(HX_RESULT status, BOOL bIgnoreHintTracks)
  2195. {
  2196.     return;
  2197. }
  2198. #endif // QTCONFIG_SERVER
  2200. /************************************************************************
  2201.  * Method:
  2202.  *     IHXThreadSafeMethods::IsThreadSafe
  2203.  */
  2204. STDMETHODIMP_(UINT32) CQTFileFormat::IsThreadSafe()
  2205. {
  2206.     return HX_THREADSAFE_METHOD_FF_GETPACKET |
  2207.    HX_THREADSAFE_METHOD_FSR_READDONE;
  2208. }
  2210. /************************************************************************
  2211.  *  IUnknown methods
  2212.  */
  2213. STDMETHODIMP CQTFileFormat::QueryInterface(REFIID riid, void** ppvObj)
  2214. {
  2215.     QInterfaceList qiList[] =
  2216.     {
  2217. { GET_IIDHANDLE(IID_IUnknown), (IUnknown*) (IHXPlugin*) this},
  2218. { GET_IIDHANDLE(IID_IHXPlugin), (IHXPlugin*) this},
  2219. { GET_IIDHANDLE(IID_IHXFileFormatObject), (IHXFileFormatObject*) this},
  2220. { GET_IIDHANDLE(IID_IHXAtomizerResponse), (IHXAtomizerResponse*) this},
  2221. { GET_IIDHANDLE(IID_IHXAtomizationCommander), (IHXAtomizationCommander*) this},
  2222. #ifdef QTCONFIG_ALTERNATE_STREAMS
  2223. { GET_IIDHANDLE(IID_IHXASMSource), (IHXASMSource*) this},
  2224. #endif // QTCONFIG_ALTERNATE_STREAMS
  2225. { GET_IIDHANDLE(IID_IHXPacketFormat), (IHXPacketFormat*) this},
  2226. { GET_IIDHANDLE(IID_IHXFileSwitcher), (IHXFileSwitcher*) m_pFileSwitcher},
  2227. { GET_IIDHANDLE(IID_IHXCommonClassFactory), m_pClassFactory},
  2228. { GET_IIDHANDLE(IID_IHXScheduler), m_pScheduler}
  2229.     };
  2231.     return QIFind(qiList, QILISTSIZE(qiList), riid, ppvObj);
  2232. }
  2234. STDMETHODIMP_(ULONG32) CQTFileFormat::AddRef()
  2235. {
  2236.     return InterlockedIncrement(&m_lRefCount);
  2237. }
  2239. STDMETHODIMP_(ULONG32) CQTFileFormat::Release()
  2240. {
  2241.     if (InterlockedDecrement(&m_lRefCount) > 0)
  2242.     {
  2243.         return m_lRefCount;
  2244.     }
  2246.     delete this;
  2247.     return 0;
  2248. }
  2251. /************************************************************************
  2252.  *  GetFileHeader
  2253.  *  Purpose:
  2254.  * Called by controller to ask the file format for the number of
  2255.  * headers in the file. The file format should call the 
  2256.  * IHXFormatResponse::StreamCountReady() for the IHXFileFormat-
  2257.  * Session object that was passed in during initialization, when the
  2258.  * header count is available.
  2259.  */
  2260. STDMETHODIMP CQTFileFormat::GetFileHeader()
  2261. {
  2262.     HX_RESULT retVal = HXR_UNEXPECTED;
  2264.     if (m_State == QTFF_Ready)
  2265.     {
  2266. if (m_pAtomizer)
  2267. {
  2268.     // This must be the first call to GetFileHeader - Atomize
  2269.     m_State = QTFF_Atomize;
  2270.     retVal = m_pAtomizer->Atomize();
  2271. }
  2272. else
  2273. {
  2274.     retVal = MakeFileHeader(HXR_OK);
  2275. }
  2276.     }
  2277.     
  2278.     return retVal;
  2279. }
  2282. /************************************************************************
  2283.  *  GetStreamHeader
  2284.  *  Purpose:
  2285.  * Called by controller to ask the file format for the header for
  2286.  * a particular stream in the file. The file format should call 
  2287.  * IHXFileFormatResponse::HeaderReady() for the IHXFileFormatResponse
  2288.  * object that was passed in during initialization, when the header
  2289.  * is available.
  2290.  */
  2291. STDMETHODIMP CQTFileFormat::GetStreamHeader(UINT16 unStreamNumber)
  2292. {
  2293.     HX_RESULT retVal;
  2294.     IHXValues* pHeader;
  2296.     retVal = ObtainStreamHeader(unStreamNumber, pHeader);
  2298.     if (SUCCEEDED(retVal))
  2299.     {
  2300. retVal = m_pFFResponse->StreamHeaderReady(retVal, pHeader);
  2301.     }
  2303.     HX_RELEASE(pHeader);
  2305.     return retVal;
  2306. }