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

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

Symbian

开发平台：

C/C++

mp4vpyld.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 _APPEND_VOL_HEADER
  40. // #define _DONOT_SEGMENT
  41. // #define _ASSERT_ON_LOSS
  42. // #define _DUMP_FIRST_NFRAMES 5
  43. #define _OVERALLOC_CODEC_DATA 3
  45. #define MP4V_RN_PAYLOAD_MIME_TYPE     "video/X-RN-MP4"
  46. #define MP4V_3016_PAYLOAD_MIME_TYPE     "video/MP4V-ES"
  47. #define MP4V_RN_3GPP_H263_PAYLOAD_MIME_TYPE "video/X-RN-3GPP-H263"
  49. #define FLUSH_ALL_PACKETS   0xFFFFFFFF
  51. #define MAX_FRAME_SEGMENTS 1024
  52. #define NUM_OVERLAP_SEGMENTS 256
  54. #define DLFT_MAX_PACKET_DATA_SIZE   0x7FFFFFFF
  56. #define CHAR_LF 0x0a
  57. #define CHAR_CR 0x0d
  59. #define MAX_INT_TEXT_LENGTH 10
  62. /****************************************************************************
  63.  *  Includes
  64.  */
  65. #include "hxtypes.h"
  66. #include "hxwintyp.h"
  67. #include "hxcom.h"
  68. #include "hxcomm.h"
  70. #include "hxassert.h"
  71. #include "hxslist.h"
  72. #include "hxstrutl.h"
  73. #include "hxcomm.h"
  74. #include "ihxpckts.h"
  75. #include "hxformt.h"
  76. #include "hxrendr.h"
  77. #include "hxformt.h"
  78. #include "hxengin.h"
  80. #include "sdptools.h"
  81. #include "mp4desc.h"
  82. #include "mp4vpyld.h"
  83. #include "mp4pyldutil.h"
  86. MP4VPayloadFormat::MP4VPayloadFormat(CHXBufferMemoryAllocator* pAllocator)
  87.     : m_lRefCount (0)
  88.     , m_pClassFactory (NULL)
  89.     , m_pStreamHeader (NULL)
  90.     , m_pVOLHeader (NULL)
  91.     , m_ulVOLHeaderSize (0)
  92.     , m_ulSamplesPerSecond(1000)
  93.     , m_bFlushed (FALSE)
  94.     , m_bFirstPacket (TRUE)
  95.     , m_bFirstFrame (TRUE)
  96.     , m_bUsesRTPPackets (FALSE)
  97.     , m_bRTPPacketTested(FALSE)
  98.     , m_pAllocator (pAllocator)
  99.     , m_bPacketize (FALSE)
  100.     , m_ulFrameCount (0)
  101.     , m_uSeqNumber (0)
  102.     , m_bPictureStarted (FALSE)
  103.     , m_ulMaxPacketDataSize(DLFT_MAX_PACKET_DATA_SIZE)
  104.     , m_PayloadID (PYID_X_HX_MP4)
  105. {
  106.     if (m_pAllocator)
  107.     {
  108. m_pAllocator->AddRef();
  109.     }
  110. }
  112. MP4VPayloadFormat::~MP4VPayloadFormat()
  113. {
  114.     FlushPackets(FLUSH_ALL_PACKETS);
  116.     HX_VECTOR_DELETE(m_pVOLHeader);
  117.     if (m_pAllocator)
  118.     {
  119.         m_pAllocator->Release();
  120.         m_pAllocator = NULL;
  121.     }
  122.     HX_RELEASE(m_pClassFactory);
  123.     HX_RELEASE(m_pStreamHeader);
  124. }
  126. // *** IUnknown methods ***
  128. /////////////////////////////////////////////////////////////////////////
  129. //  Method:
  130. // IUnknown::QueryInterface
  131. //  Purpose:
  132. // Implement this to export the interfaces supported by your
  133. // object.
  134. //
  135. STDMETHODIMP
  136. MP4VPayloadFormat::QueryInterface(REFIID riid, void** ppvObj)
  137. {
  138.     QInterfaceList qiList[] =
  139.     {
  140. { GET_IIDHANDLE(IID_IUnknown), this },
  141. { GET_IIDHANDLE(IID_IHXPayloadFormatObject), (IHXPayloadFormatObject*) this },
  142.     };
  143.     return ::QIFind(qiList, QILISTSIZE(qiList), riid, ppvObj);
  144. }
  146. /////////////////////////////////////////////////////////////////////////
  147. //  Method:
  148. // IUnknown::AddRef
  149. //  Purpose:
  150. // Everyone usually implements this the same... feel free to use
  151. // this implementation.
  152. //
  153. STDMETHODIMP_(ULONG32)
  154. MP4VPayloadFormat::AddRef()
  155. {
  156.     return InterlockedIncrement(&m_lRefCount);
  157. }
  159. /////////////////////////////////////////////////////////////////////////
  160. //  Method:
  161. // IUnknown::Release
  162. //  Purpose:
  163. // Everyone usually implements this the same... feel free to use
  164. // this implementation.
  165. //
  166. STDMETHODIMP_(ULONG32)
  167. MP4VPayloadFormat::Release()
  168. {
  169.     if (InterlockedDecrement(&m_lRefCount) > 0)
  170.     {
  171.         return m_lRefCount;
  172.     }
  174.     delete this;
  175.     return 0;
  176. }
  179. STDMETHODIMP
  180. MP4VPayloadFormat::Init(IUnknown* pContext,
  181. BOOL bPacketize)
  182. {
  183.     HX_RESULT retVal = HXR_OK;
  185.     HX_RELEASE(m_pClassFactory);
  187.     m_bPacketize = bPacketize;
  189.     if (SUCCEEDED(retVal))
  190.     {
  191. retVal = pContext->QueryInterface(IID_IHXCommonClassFactory,
  192.   (void**) &m_pClassFactory);
  193.     }
  195.     return retVal;
  196. }
  198. STDMETHODIMP
  199. MP4VPayloadFormat::Reset()
  200. {
  201.     // Release all input packets we have stored
  202.     FlushPackets(FLUSH_ALL_PACKETS);
  204.     m_bFlushed = FALSE;
  205.     m_bFirstPacket = TRUE;
  206.     m_bFirstFrame = TRUE;
  207.     m_bPictureStarted = FALSE;
  208.     m_bUsesRTPPackets = FALSE;
  209.     m_bRTPPacketTested = FALSE;
  210.     m_ulFrameCount = 0;
  211.     m_uSeqNumber = 0;
  213.     m_TSConverter.Reset();
  215.     return HXR_OK;
  216. }
  218. STDMETHODIMP
  219. MP4VPayloadFormat::SetStreamHeader(IHXValues* pHeader)
  220. {
  221.     HX_RESULT retVal = HXR_OK;
  223.     HX_ASSERT(pHeader);
  225.     HX_RELEASE(m_pStreamHeader);
  226.     m_pStreamHeader = pHeader;
  227.     if (m_pStreamHeader)
  228.     {
  229. m_pStreamHeader->AddRef();
  230.     }
  232.     if (m_bPacketize)
  233.     {
  234. retVal = SetPacketizerHeader(pHeader);
  235.     }
  236.     else
  237.     {
  238. retVal = SetAssemblerHeader(pHeader);
  239.     }
  241.     return retVal;
  242. }
  244. HX_RESULT MP4VPayloadFormat::SetPacketizerHeader(IHXValues* pHeader)
  245. {
  246.     IHXBuffer* pMimeType = NULL;
  247.     const char* pMimeTypeData = NULL;
  248.     HX_RESULT retVal = HXR_OK;
  250.     if (SUCCEEDED(retVal))
  251.     {
  252. retVal = pHeader->GetPropertyCString("MimeType", pMimeType);
  253.     }
  255.     if (SUCCEEDED(retVal))
  256.     {
  257. pMimeTypeData = (char*) pMimeType->GetBuffer();
  259. retVal = HXR_FAIL;
  260. if (pMimeTypeData)
  261. {
  262.     retVal = HXR_OK;
  263. }
  264.     }
  266.     if (SUCCEEDED(retVal))
  267.     {
  268. if (strcasecmp(pMimeTypeData, MP4V_3016_PAYLOAD_MIME_TYPE) == 0)
  269. {
  270.     m_PayloadID = PYID_MP4V_ES;
  271.     if (DLFT_MAX_PACKET_DATA_SIZE != m_ulMaxPacketDataSize)
  272.     {
  273. retVal = pHeader->SetPropertyULONG32
  274.     ("MaxPacketSize", m_ulMaxPacketDataSize);
  275.     }
  276. }
  277. else if (strcasecmp(pMimeTypeData, MP4V_RN_PAYLOAD_MIME_TYPE) == 0)
  278. {
  279.     m_PayloadID = PYID_X_HX_MP4;
  280. }
  281. else if (strcasecmp(pMimeTypeData, MP4V_RN_3GPP_H263_PAYLOAD_MIME_TYPE) == 0)
  282. {
  283.     m_PayloadID = PYID_X_HX_3GPP_H263;
  284. }
  285.     }
  287.     HX_RELEASE(pMimeType);
  289.     return retVal;
  290. }
  292. HX_RESULT MP4VPayloadFormat::SetAssemblerHeader(IHXValues* pHeader)
  293. {
  294.     IHXBuffer* pMimeType = NULL;
  295.     const char* pMimeTypeData = NULL;
  296.     HX_RESULT retVal = HXR_OK;
  298.     HX_VECTOR_DELETE(m_pVOLHeader);
  299.     m_ulVOLHeaderSize = 0;
  301.     if (SUCCEEDED(retVal))
  302.     {
  303. retVal = pHeader->GetPropertyCString("MimeType", pMimeType);
  304.     }
  306.     if (SUCCEEDED(retVal))
  307.     {
  308. pMimeTypeData = (char*) pMimeType->GetBuffer();
  310. retVal = HXR_FAIL;
  311. if (pMimeTypeData)
  312. {
  313.     retVal = HXR_OK;
  314. }
  315.     }
  317.     if (SUCCEEDED(retVal))
  318.     {
  319. if (strcasecmp(pMimeTypeData, MP4V_3016_PAYLOAD_MIME_TYPE) == 0)
  320. {
  321.     m_PayloadID = PYID_MP4V_ES;
  322.     retVal = SetAssembler3016Header(pHeader);
  323. }
  324. else if (strcasecmp(pMimeTypeData, MP4V_RN_PAYLOAD_MIME_TYPE) == 0)
  325. {
  326.     m_PayloadID = PYID_X_HX_MP4;
  327.     retVal = SetAssemblerHXHeader(pHeader);
  328. }
  329. else if (strcasecmp(pMimeTypeData, MP4V_RN_3GPP_H263_PAYLOAD_MIME_TYPE) == 0)
  330. {
  331.     m_PayloadID = PYID_X_HX_3GPP_H263;
  332.     retVal = SetAssemblerHX3GPPH263Header(pHeader);
  333. }
  334.     }
  336.     if (SUCCEEDED(retVal))
  337.     {
  338. m_ulSamplesPerSecond = 0;
  339. m_pStreamHeader->GetPropertyULONG32("SamplesPerSecond",
  340.     m_ulSamplesPerSecond);
  341.     }
  343.     HX_RELEASE(pMimeType);
  345.     return retVal;
  346. }
  348. HX_RESULT MP4VPayloadFormat::SetAssembler3016Header(IHXValues* pHeader)
  349. {
  350.     ULONG32 ulTryIdx = 0;
  351.     char *pData = NULL;
  352.     IHXBuffer* pConfigBuffer = NULL;
  353.     char* pConfigStringData;
  354.     HX_RESULT retVal = HXR_NO_DATA;
  356.     retVal = CHXMP4PayloadUtil::GetFMTPConfig(pHeader, m_pClassFactory,
  357.       pConfigBuffer);
  359.     if (retVal == HXR_OK)
  360.     {
  361. m_ulVOLHeaderSize = pConfigBuffer->GetSize();
  363. if (m_ulVOLHeaderSize > 0)
  364. {
  365.     m_pVOLHeader = new UINT8 [m_ulVOLHeaderSize];
  367.     if (m_pVOLHeader)
  368.     {
  369. memcpy(m_pVOLHeader, pConfigBuffer->GetBuffer(),
  370.        m_ulVOLHeaderSize);
  371.     }
  372.     else
  373.     {
  374. m_ulVOLHeaderSize = 0;
  375. retVal = HXR_OUTOFMEMORY;
  376.     }
  377. }
  378.     }
  380.     HX_RELEASE(pConfigBuffer);
  382.     return retVal;
  383. }
  385. HX_RESULT MP4VPayloadFormat::SetAssemblerHXHeader(IHXValues* pHeader)
  386. {
  387.     ES_Descriptor ESDesc;
  388.     DecoderConfigDescriptor* pDCDesc = NULL;
  389.     DecoderSpecifcInfo* pDSIDesc = NULL;
  390.     IHXBuffer* pESDescriptor = NULL;
  392.     UINT8* pESDescData;
  393.     ULONG32 ulESDescSize;
  395.     HX_RESULT retVal = HXR_OK;
  397.     HX_VECTOR_DELETE(m_pVOLHeader);
  398.     m_ulVOLHeaderSize = 0;
  400.     retVal = m_pStreamHeader->GetPropertyBuffer("OpaqueData",
  401. pESDescriptor);
  403.     if (SUCCEEDED(retVal))
  404.     {
  405. retVal = HXR_INVALID_PARAMETER;
  406. if (pESDescriptor)
  407. {
  408.     retVal = HXR_OK;
  409. }
  410.     }
  412.     if (SUCCEEDED(retVal))
  413.     {
  414. pESDescData = pESDescriptor->GetBuffer();
  415. ulESDescSize = pESDescriptor->GetSize();
  417. retVal = ESDesc.Unpack(pESDescData, ulESDescSize);
  418.     }
  420.     HX_RELEASE(pESDescriptor);
  422.     if (SUCCEEDED(retVal))
  423.     {
  424. retVal = HXR_FAIL;
  425. pDCDesc = ESDesc.m_pDecConfigDescr;
  427. if (pDCDesc)
  428. {
  429.     pDSIDesc = pDCDesc->m_pDecSpecificInfo;
  430.     retVal = HXR_OK;
  431. }
  432.     }
  434.     if (SUCCEEDED(retVal) && pDSIDesc)
  435.     {
  436. m_ulVOLHeaderSize = pDSIDesc->m_ulLength;
  438. if (m_ulVOLHeaderSize > 0)
  439. {
  440.     m_pVOLHeader = new UINT8 [m_ulVOLHeaderSize];
  442.     if (m_pVOLHeader == NULL)
  443.     {
  444. m_ulVOLHeaderSize = 0;
  445. retVal = HXR_OUTOFMEMORY;
  446.     }
  447. }
  448.     }
  450.     if (SUCCEEDED(retVal))
  451.     {
  452. if (m_ulVOLHeaderSize > 0)
  453. {
  454.     memcpy(m_pVOLHeader, pDSIDesc->m_pData, m_ulVOLHeaderSize); /* Flawfinder: ignore */
  455. }
  456.     }
  458.     return retVal;
  459. }
  461. HX_RESULT MP4VPayloadFormat::SetAssemblerHX3GPPH263Header(IHXValues* pHeader)
  462. {
  463.     HX_RESULT retVal = HXR_OK;
  465.     // We'll let H263 decoder initialize with in-band bitstream
  466.     HX_VECTOR_DELETE(m_pVOLHeader);
  467.     m_ulVOLHeaderSize = 0;
  469.     return retVal;
  470. }
  472. STDMETHODIMP
  473. MP4VPayloadFormat::GetStreamHeader(REF(IHXValues*) pHeader)
  474. {
  475.     HX_ASSERT(m_pStreamHeader);
  476.     pHeader = m_pStreamHeader;
  477.     pHeader->AddRef();
  479.     return HXR_OK;
  480. }
  483. STDMETHODIMP
  484. MP4VPayloadFormat::SetPacket(IHXPacket* pPacket)
  485. {
  486.     HX_RESULT retVal;
  488.     HX_ASSERT(pPacket);
  490.     if (!m_bRTPPacketTested)
  491.     {
  492. IHXRTPPacket* pRTPPacket = NULL;
  494. m_bUsesRTPPackets = (pPacket->QueryInterface(
  495. IID_IHXRTPPacket,
  496. (void**) &pRTPPacket)
  497.     == HXR_OK);
  499. m_bRTPPacketTested = TRUE;
  501. HX_RELEASE(pRTPPacket);
  503. if (!m_bUsesRTPPackets)
  504. {
  505.     m_ulSamplesPerSecond = 1000; // RDT time stamp
  506. }
  508. HX_ASSERT(m_ulSamplesPerSecond != 0);
  510. m_TSConverter.SetBase(m_ulSamplesPerSecond,
  511.       1000);
  512.     }
  514.     // Add this packet to our list of input packets
  515.     pPacket->AddRef();
  516.     m_InputPackets.AddTail(pPacket);
  518.     if (m_bPacketize)
  519.     {
  520. retVal = SetPacketizerPacket(pPacket);
  521.     }
  522.     else
  523.     {
  524. retVal = SetAssemblerPacket(pPacket);
  525.     }
  527.     return retVal;
  528. }
  530. HX_RESULT MP4VPayloadFormat::SetPacketizerPacket(IHXPacket* pPacket)
  531. {
  532.     if (m_bFirstFrame)
  533.     {
  534. m_bFirstFrame = FALSE;
  535.     }
  537.     return HXR_OK;
  538. }
  540. HX_RESULT MP4VPayloadFormat::SetAssemblerPacket(IHXPacket* pPacket)
  541. {
  542.     BOOL bNewPictureStart;
  544.     if (!pPacket->IsLost())
  545.     {
  546. bNewPictureStart = IsPictureStart(pPacket);
  548. if (m_bFirstPacket)
  549. {
  550.     m_bFirstPacket = FALSE;
  551.     m_ulFrameTime = GetPacketTime(pPacket);
  552. }
  554. if ((GetPacketTime(pPacket) != m_ulFrameTime) ||
  555.     (bNewPictureStart && m_bPictureStarted))
  556. {
  557.     m_ulFrameCount++;
  558.     m_ulFrameTime = GetPacketTime(pPacket);
  559. }
  561. if (pPacket->GetASMRuleNumber() == 1)
  562. {
  563.     m_ulFrameCount++;
  564.     m_bFirstPacket = TRUE;
  565.     m_bPictureStarted = FALSE;
  566. }
  567. else if (!m_bPictureStarted)
  568. {
  569.     m_bPictureStarted = bNewPictureStart;
  570. }
  571.     }
  573.     return HXR_OK;
  574. }
  577. STDMETHODIMP
  578. MP4VPayloadFormat::GetPacket(REF(IHXPacket*) pOutPacket)
  579. {
  580.     HX_RESULT retVal = HXR_OK;
  581.     IHXPacket* pPacket = NULL;
  583.     if (m_InputPackets.IsEmpty())
  584.     {
  585. if (m_bFlushed)
  586. {
  587.     // We have used up all available input
  588.     retVal = HXR_STREAM_DONE;
  589. }
  590. else
  591. {
  592.     // We don't have enough input
  593.     // data to produce a packet
  594.     retVal = HXR_INCOMPLETE;
  595. }
  596.     }
  597.     else
  598.     {
  599. if (m_bPacketize)
  600. {
  601.     retVal = GetPacketizerPacket(pOutPacket);
  602. }
  603. else
  604. {
  605.     retVal = GetAssemblerPacket(pOutPacket);
  606. }
  607.     }
  609.     return retVal;
  610. }
  612. HX_RESULT MP4VPayloadFormat::GetPacketizerPacket(IHXPacket* &pOutPacket)
  613. {
  614.     HX_RESULT retVal = HXR_INCOMPLETE;
  616.     if (m_OutputPackets.GetCount() > 0)
  617.     {
  618. pOutPacket = (IHXPacket*) m_OutputPackets.RemoveHead();
  619. retVal = HXR_OK;
  620.     }
  622.     if (retVal == HXR_INCOMPLETE)
  623.     {
  624. IHXPacket* pRawPacket = NULL;
  626. do
  627. {
  628.     HX_RELEASE(pRawPacket);
  629.     retVal = GetRawPacketizerPacket(pRawPacket);
  630. } while ((retVal == HXR_OK) && (!IsValidPacket(pRawPacket)));
  632. if (retVal == HXR_OK)
  633. {
  634.     retVal = FragmentPacket(pRawPacket);
  635.     pRawPacket->Release();
  636. }
  638. if (retVal == HXR_OK)
  639. {
  640.     HX_ASSERT(m_OutputPackets.GetCount() > 0);
  642.     retVal = HXR_INCOMPLETE;
  643.     if (m_OutputPackets.GetCount() > 0)
  644.     {
  645. pOutPacket = (IHXPacket*) m_OutputPackets.RemoveHead();
  646. retVal = HXR_OK;
  647.     }
  648. }
  649.     }
  651.     return retVal;
  652. }
  655. HX_RESULT MP4VPayloadFormat::FragmentPacket(IHXPacket* pPacket)
  656. {
  657.     HX_RESULT retVal = HXR_OK;
  658.     IHXBuffer* pPacketBuffer = pPacket->GetBuffer();
  659.     ULONG32 ulRemainingSize = pPacketBuffer->GetSize();
  661.     if (ulRemainingSize > m_ulMaxPacketDataSize)
  662.     {
  663. UINT8* pRemainingData = pPacketBuffer->GetBuffer();
  664. ULONG32 ulFragmentSize = m_ulMaxPacketDataSize;
  665. IHXPacket* pNewPacket = NULL;
  666. IHXBuffer* pNewBuffer = NULL;
  667. IHXRTPPacket* pRTPPacket = NULL;
  669. if (m_bUsesRTPPackets)
  670. {
  671.     if (SUCCEEDED(retVal))
  672.     {
  673. retVal = pPacket->QueryInterface(IID_IHXRTPPacket,
  674.     (void**) &pRTPPacket);
  675.     }
  676. }
  678. do
  679. {
  680.     // Create new packet
  681.     if (SUCCEEDED(retVal))
  682.     {
  683. if (m_bUsesRTPPackets)
  684. {
  685.     retVal = m_pClassFactory->CreateInstance(CLSID_IHXRTPPacket,
  686.      (void**) &pNewPacket);
  687. }
  688. else
  689. {
  690.     retVal = m_pClassFactory->CreateInstance(CLSID_IHXPacket,
  691.      (void**) &pNewPacket);
  692. }
  693.     }
  695.     // Create new buffer
  696.     if (SUCCEEDED(retVal))
  697.     {
  698. retVal = m_pClassFactory->CreateInstance(CLSID_IHXBuffer,
  699.  (void**) &pNewBuffer);
  700.     }
  702.     // Set Buffer
  703.     if (SUCCEEDED(retVal))
  704.     {
  705. retVal = pNewBuffer->Set(pRemainingData, ulFragmentSize);
  706.     }
  708.     // Set the new packet
  709.     if (SUCCEEDED(retVal))
  710.     {
  711. if (SUCCEEDED(retVal))
  712. {
  713.     if (m_bUsesRTPPackets)
  714.     {
  715. retVal = ((IHXRTPPacket*) pNewPacket)->SetRTP(
  716.     pNewBuffer,
  717.     pRTPPacket->GetTime(),
  718.     pRTPPacket->GetRTPTime(),
  719.     pRTPPacket->GetStreamNumber(),
  720.     pRTPPacket->GetASMFlags(),
  721.     (ulRemainingSize > m_ulMaxPacketDataSize) ?
  722. 0 : pRTPPacket->GetASMRuleNumber());
  723.     }
  724.     else
  725.     {
  726. retVal = ((IHXRTPPacket*) pNewPacket)->Set(
  727.     pNewBuffer,
  728.     pPacket->GetTime(),
  729.     pPacket->GetStreamNumber(),
  730.     pPacket->GetASMFlags(),
  731.     (ulRemainingSize > m_ulMaxPacketDataSize) ?
  732. 0 : pPacket->GetASMRuleNumber());
  733.     }
  734. }
  735.     }
  737.     pRemainingData += ulFragmentSize;
  738.     ulRemainingSize -= ulFragmentSize;
  739.     if (ulRemainingSize < ulFragmentSize)
  740.     {
  741. ulFragmentSize = ulRemainingSize;
  742.     }
  744.     if (SUCCEEDED(retVal))
  745.     {
  746. pNewPacket->AddRef();
  747. m_OutputPackets.AddTail(pNewPacket);
  748.     }
  750.     HX_RELEASE(pNewBuffer);
  751.     HX_RELEASE(pNewPacket);
  752. } while (SUCCEEDED(retVal) && (ulRemainingSize > 0));
  754. HX_RELEASE(pRTPPacket);
  755.     }
  756.     else
  757.     {
  758. pPacket->AddRef();
  759. m_OutputPackets.AddTail(pPacket);
  760.     }
  762.     HX_RELEASE(pPacketBuffer);
  764.     return retVal;
  765. }
  768. HX_RESULT MP4VPayloadFormat::GetRawPacketizerPacket(IHXPacket* &pOutPacket)
  769. {
  770.     IHXPacket* pPacket;
  771.     IHXPacket* pAfterPacket = NULL;
  772.     IHXRTPPacket* pRTPPacket = NULL;
  773.     UINT16 uASMRuleNumber;
  774.     BOOL bMarker = TRUE;
  775.     BOOL bNewPictureStart = TRUE;
  776.     HX_RESULT retVal = HXR_INCOMPLETE;
  778.     if ((m_InputPackets.GetCount() > 1) ||
  779. m_bFlushed)
  780.     {
  781. retVal = HXR_OK;
  782. pPacket = (IHXPacket*) m_InputPackets.RemoveHead();
  784. if (!m_bPictureStarted)
  785. {
  786.     m_bPictureStarted = IsPictureStart(pPacket);
  787. }
  789. if (m_bFirstPacket)
  790. {
  791.     m_bFirstPacket = FALSE;
  792. }
  794. // Determine marker usage
  795. if (m_InputPackets.GetCount() > 0)
  796. {
  797.     pAfterPacket = (IHXPacket*) m_InputPackets.GetHead();
  798. }
  800. if (pAfterPacket)
  801. {
  802.     bNewPictureStart = IsPictureStart(pAfterPacket);
  804.     bMarker = ((GetPacketTime(pPacket) != GetPacketTime(pAfterPacket)) ||
  805.        (bNewPictureStart && m_bPictureStarted));
  807.     if (bMarker)
  808.     {
  809. m_bPictureStarted = bNewPictureStart;
  810.     }
  811. }
  812. else
  813. {
  814.     bMarker = m_bFlushed;
  815. }
  818. uASMRuleNumber = bMarker ? 1 : 0;
  820. // If rule number must change, create new packet
  821. if (uASMRuleNumber != pPacket->GetASMRuleNumber())
  822. {
  823.     IHXPacket* pNewPacket = NULL;
  825.     if (m_bUsesRTPPackets)
  826.     {
  827. retVal = m_pClassFactory->CreateInstance(CLSID_IHXRTPPacket,
  828.  (void**) &pNewPacket);
  830. if (SUCCEEDED(retVal))
  831. {
  832.     retVal = pPacket->QueryInterface(IID_IHXRTPPacket,
  833.      (void**) &pRTPPacket);
  834. }
  835.     }
  836.     else
  837.     {
  838. retVal = m_pClassFactory->CreateInstance(CLSID_IHXPacket,
  839.  (void**) &pNewPacket);
  840.     }
  842.     if (SUCCEEDED(retVal))
  843.     {
  844. IHXBuffer* pBuffer = pPacket->GetBuffer();
  846. if (m_bUsesRTPPackets)
  847. {
  848.     retVal = ((IHXRTPPacket*) pNewPacket)->SetRTP(
  849. pBuffer,
  850. pRTPPacket->GetTime(),
  851. pRTPPacket->GetRTPTime(),
  852. pRTPPacket->GetStreamNumber(),
  853. pRTPPacket->GetASMFlags(),
  854. uASMRuleNumber);
  855. }
  856. else
  857. {
  858.     retVal = ((IHXRTPPacket*) pNewPacket)->Set(
  859. pBuffer,
  860. pPacket->GetTime(),
  861. pPacket->GetStreamNumber(),
  862. pPacket->GetASMFlags(),
  863. uASMRuleNumber);
  864. }
  866. HX_RELEASE(pBuffer);
  867.     }
  869.     pPacket->Release();
  870.     pPacket = NULL;
  872.     if (SUCCEEDED(retVal))
  873.     {
  874. pPacket = pNewPacket;
  875. pNewPacket = NULL;
  876.     }
  878.     HX_RELEASE(pNewPacket);
  879.     HX_RELEASE(pRTPPacket);
  880. }
  882. if (SUCCEEDED(retVal))
  883. {
  884.     pOutPacket = pPacket;
  885. }
  886.     }
  888.     return retVal;
  889. }
  891. HX_RESULT MP4VPayloadFormat::GetAssemblerPacket(IHXPacket* &pOutPacket)
  892. {
  893.     HX_RESULT retVal = HXR_NOTIMPL;
  895.     return retVal;
  896. }
  898. void MP4VPayloadFormat::FlushPackets(ULONG32 ulCount)
  899. {
  900.     IHXPacket* pDeadPacket;
  902.     while ((ulCount > 0) && (!m_InputPackets.IsEmpty()))
  903.     {
  904. pDeadPacket = (IHXPacket*) m_InputPackets.RemoveHead();
  905. HX_RELEASE(pDeadPacket);
  906. if (ulCount != FLUSH_ALL_PACKETS)
  907. {
  908.     ulCount--;
  909. }
  910.     }
  911. }
  913. ULONG32 MP4VPayloadFormat::CountValidPackets(ULONG32 ulCount)
  914. {
  915.     IHXPacket* pPacket;
  916.     LISTPOSITION listPos;
  917.     ULONG32 ulValidCount = 0;
  919.     listPos = m_InputPackets.GetHeadPosition();
  921.     while ((ulCount > 0) && (listPos != NULL))
  922.     {
  923. pPacket = (IHXPacket*) m_InputPackets.GetNext(listPos);
  924. HX_ASSERT(pPacket);
  925. if (!pPacket->IsLost())
  926. {
  927.     ulValidCount++;
  928. }
  930. ulCount--;
  931.     }
  933.     return ulValidCount;
  934. }
  936. ULONG32 MP4VPayloadFormat::SumPacketSizes(ULONG32 ulCount)
  937. {
  938.     IHXPacket* pPacket;
  939.     IHXBuffer* pBuffer;
  940.     LISTPOSITION listPos;
  941.     ULONG32 ulSize = 0;
  943.     listPos = m_InputPackets.GetHeadPosition();
  945.     while ((ulCount > 0) && (listPos != NULL))
  946.     {
  947. pPacket = (IHXPacket*) m_InputPackets.GetNext(listPos);
  948. HX_ASSERT(pPacket);
  949. if (!pPacket->IsLost())
  950. {
  951.     pBuffer = pPacket->GetBuffer();
  953.     if (pBuffer)
  954.     {
  955. ulSize += pBuffer->GetSize();
  956. pBuffer->Release();
  957.     }
  958. }
  960. ulCount--;
  961.     }
  963.     return ulSize;
  964. }
  966. HX_RESULT MP4VPayloadFormat::CreateHXCodecPacket(UINT32* &pHXCodecDataOut)
  967. {
  968.     HX_RESULT retVal = HXR_INCOMPLETE;
  970.     if (m_ulFrameCount > 0)
  971.     {
  972. // Compute frame size and count segments
  973. ULONG32 ulFrameSize = 0;
  974. ULONG32 ulSegmentCount = 0;
  975. ULONG32 ulSegmentSize;
  976. ULONG32 ulFrameTime = 0;
  977. ULONG32 ulValidSegmentCount = 0;
  978. IHXPacket* pPacket;
  979. IHXBuffer* pBuffer = NULL;
  980. LISTPOSITION listPos;
  981. ULONG32 ulIdx;
  982. BOOL bIsLost;
  983. BOOL bPictureStarted = FALSE;
  984. BOOL bNewPictureStart;
  985. HXCODEC_DATA* pHXCodecData = NULL;
  986. HXCODEC_SEGMENTINFO* pHXCodecSegmentInfo;
  987. ULONG32* pData = NULL;
  989. retVal = HXR_OK;
  991. // Gather Frame Information - until valid frame detected
  992. do
  993. {
  994.     listPos = m_InputPackets.GetHeadPosition();
  995.             if( listPos == NULL )
  996.             {
  997.                 return HXR_OUTOFMEMORY;
  998.             }
  1000.     do
  1001.     {
  1002. if (ulSegmentCount >= MAX_FRAME_SEGMENTS)
  1003. {
  1004.     HX_ASSERT(pPacket);
  1006.     FlushPackets(ulSegmentCount - NUM_OVERLAP_SEGMENTS);
  1008.     ulSegmentCount = NUM_OVERLAP_SEGMENTS;
  1009.     ulFrameSize = SumPacketSizes(NUM_OVERLAP_SEGMENTS);
  1010.     ulValidSegmentCount = CountValidPackets(NUM_OVERLAP_SEGMENTS);
  1011. }
  1013. pPacket = (IHXPacket*) m_InputPackets.GetNext(listPos);
  1015. if (!pPacket->IsLost())
  1016. {
  1017.     bNewPictureStart = IsPictureStart(pPacket);
  1019.     if (ulValidSegmentCount > 0)
  1020.     {
  1021. if ((GetPacketTime(pPacket) != ulFrameTime) ||
  1022.     (bPictureStarted && bNewPictureStart))
  1023. {
  1024.     break;
  1025. }
  1026.     }
  1027.     else
  1028.     {
  1029. ulFrameTime = GetPacketTime(pPacket);
  1030.     }
  1032.     if (!bPictureStarted)
  1033.     {
  1034. bPictureStarted = bNewPictureStart;
  1035.     }
  1037.     ulValidSegmentCount++;
  1039.     pBuffer = pPacket->GetBuffer();
  1040. }
  1042. if (pBuffer)
  1043. {
  1044.     ulFrameSize += pBuffer->GetSize();
  1045.     pBuffer->Release();
  1046.     pBuffer = NULL;
  1047. }
  1049. ulSegmentCount++;
  1050.     } while (pPacket->GetASMRuleNumber() != 1);
  1052.     m_ulFrameCount--;
  1053. } while ((ulValidSegmentCount == 0) &&
  1054.  (m_ulFrameCount > 0));
  1056. if (ulValidSegmentCount == 0)
  1057. {
  1058.     retVal = HXR_INCOMPLETE;
  1059. }
  1061. // Allocate codec data header
  1062. if (retVal == HXR_OK)
  1063. {
  1064.     HX_ASSERT(ulSegmentCount != 0);
  1065.     HX_ASSERT(ulValidSegmentCount != 0);
  1067. #ifdef _APPEND_VOL_HEADER
  1068.     if (m_bFirstFrame)
  1069.     {
  1070. ulFrameSize += m_ulVOLHeaderSize;
  1071.     }
  1072. #endif // _APPEND_VOL_HEADER
  1074.     pData = new ULONG32[(sizeof(HXCODEC_DATA) +
  1075.          sizeof(HXCODEC_SEGMENTINFO) *
  1076.          (ulSegmentCount - 1)) / 4 + 1];
  1078.     retVal = HXR_OUTOFMEMORY;
  1079.     if (pData)
  1080.     {
  1081. retVal = HXR_OK;
  1082.     }
  1083. }
  1085. // Init. codec data header
  1086. if (retVal == HXR_OK)
  1087. {
  1088.     pHXCodecData = (HXCODEC_DATA*) pData;
  1090.     pHXCodecData->dataLength = ulFrameSize;
  1091.     pHXCodecData->timestamp = ulFrameTime;
  1092.     pHXCodecData->sequenceNum = m_uSeqNumber;
  1093.     pHXCodecData->flags = 0;
  1094.     pHXCodecData->lastPacket = FALSE;
  1095.     pHXCodecData->numSegments = ulSegmentCount;
  1096.     pHXCodecData->data = NULL;
  1098.     if ((ulFrameSize > 0)
  1099. #ifndef _OVERALLOC_CODEC_DATA
  1100. &&
  1101. (
  1102.  (ulValidSegmentCount > 1) ||
  1103.  (m_pAllocator == NULL)
  1104. #ifdef _APPEND_VOL_HEADER
  1105.  || m_bFirstFrame
  1106. #endif // _APPEND_VOL_HEADER
  1107.         )
  1108. #endif // _OVERALLOC_CODEC_DATA
  1109.        )
  1110.     {
  1111. #ifdef _OVERALLOC_CODEC_DATA
  1112. ulFrameSize += _OVERALLOC_CODEC_DATA;   // over allocate since codec reads 24bits at a time
  1113. #endif // _OVERALLOC_CODEC_DATA
  1115. if (m_pAllocator)
  1116. {
  1117.     IHXUnknown* pIUnkn = NULL;
  1118.     HX20ALLOCPROPS allocRequest;
  1119.     HX20ALLOCPROPS allocActual;
  1121.     allocRequest.uBufferSize = ulFrameSize;
  1122.     allocRequest.nNumBuffers = 0;
  1123.     m_pAllocator->SetProperties(&allocRequest, &allocActual);
  1124.     pHXCodecData->data = m_pAllocator->GetPacketBuffer(&pIUnkn);
  1125. }
  1126. else
  1127. {
  1128.     pHXCodecData->data = (UINT8*) new ULONG32 [ulFrameSize / 4 + 1];
  1129. }
  1131. if (pHXCodecData->data == NULL)
  1132. {
  1133.     retVal = HXR_OUTOFMEMORY;
  1134. }
  1135.     }
  1136. }
  1138. // Build Codec Data
  1139. if (retVal == HXR_OK)
  1140. {
  1141.     BOOL bNoneLost = TRUE;
  1142.     pHXCodecSegmentInfo = (HXCODEC_SEGMENTINFO*) &(pHXCodecData->Segments[0]);
  1144.     ulFrameSize = 0;
  1146.     for (ulIdx = 0; ulIdx < ulSegmentCount; ulIdx++)
  1147.     {
  1148. HX_ASSERT(!m_InputPackets.IsEmpty());
  1150. pPacket = (IHXPacket*) m_InputPackets.RemoveHead();
  1152. HX_ASSERT(pPacket);
  1154. ulSegmentSize = 0;
  1156. pHXCodecSegmentInfo[ulIdx].ulSegmentOffset = ulFrameSize;
  1158. bIsLost = pPacket->IsLost();
  1159. if (!bIsLost)
  1160. {
  1161.     pBuffer = pPacket->GetBuffer();
  1163.     if (pHXCodecData->data)
  1164.     {
  1165. if (m_bFirstFrame)
  1166. {
  1167. #ifdef _APPEND_VOL_HEADER
  1168.     memcpy(pHXCodecData->data, m_pVOLHeader, m_ulVOLHeaderSize); /* Flawfinder: ignore */
  1169.     ulFrameSize += m_ulVOLHeaderSize;
  1170. #endif // _APPEND_VOL_HEADER
  1171.     m_bFirstFrame = FALSE;
  1172. }
  1174. if (pBuffer)
  1175. {
  1176.     ulSegmentSize = pBuffer->GetSize();
  1178.     HX_ASSERT(pHXCodecData->dataLength >= (ulFrameSize + ulSegmentSize));
  1180.     memcpy(pHXCodecData->data + ulFrameSize, /* Flawfinder: ignore */
  1181.    pBuffer->GetBuffer(),
  1182.    ulSegmentSize);
  1184.     pBuffer->Release();
  1185. }
  1186.     }
  1187.     else
  1188.     {
  1189. HX_ASSERT(m_pAllocator);
  1190. HX_ASSERT(ulValidSegmentCount == 1);
  1191. #ifdef _APPEND_VOL_HEADER
  1192. HX_ASSERT(m_bFirstFrame == FALSE);
  1193. #endif // _APPEND_VOL_HEADER
  1195. if (pBuffer)
  1196. {
  1197.     ulSegmentSize = pBuffer->GetSize();
  1198.     pHXCodecData->data = m_pAllocator->AddBuffer(pBuffer);
  1199.     pBuffer->Release();
  1200. }
  1201.     }
  1203.     ulFrameSize += ulSegmentSize;
  1204. }
  1206. pHXCodecSegmentInfo[ulIdx].bIsValid = !bIsLost;
  1207. bNoneLost = (bNoneLost && (!bIsLost));
  1209. pPacket->Release();
  1210.     }
  1212.     if (bNoneLost)
  1213.     {
  1214. pHXCodecData->numSegments = 1;
  1215.     }
  1216. #ifdef _ASSERT_ON_LOSS
  1217.     else
  1218.     {
  1219. HX_ASSERT(FALSE);
  1220.     }
  1221. #endif // _ASSERT_ON_LOSS
  1223. #ifdef _DONOT_SEGMENT
  1224.     pHXCodecData->numSegments = 1;
  1225.     pHXCodecSegmentInfo[0].bIsValid = bNoneLost;
  1226. #endif // _DONOT_SEGMENT
  1227. }
  1229. // Finalize Results
  1230. if (retVal == HXR_OK)
  1231. {
  1232.     pHXCodecDataOut = pData;
  1233. }
  1234. else
  1235. {
  1236.     if (pHXCodecData && pHXCodecData->data)
  1237.     {
  1238. m_pAllocator->ReleasePacketPtr(pHXCodecData->data);
  1239.     }
  1240.     HX_VECTOR_DELETE(pData);
  1241. }
  1243. #ifdef _DUMP_FIRST_NFRAMES
  1244. if (m_uSeqNumber < _DUMP_FIRST_NFRAMES)
  1245. {
  1246.     char pFileName[100]; /* Flawfinder: ignore */
  1248.     SafeSprintf(pFileName, 100, "%s%d", "c:\fframe.bin", m_uSeqNumber);
  1250.     FILE* pFile = fopen(pFileName, "wb");
  1252.     if (pFile)
  1253.     {
  1254. fprintf(pFile, "T=%ld;B=%ld:", pHXCodecData->timestamp, pHXCodecData->dataLength);
  1255. fwrite(pHXCodecData->data, sizeof(UINT8), pHXCodecData->dataLength, pFile);
  1256. fclose(pFile);
  1257.     }
  1258. }
  1259. #endif // _DUMP_FIRST_NFRAMES
  1261. m_uSeqNumber++;
  1262.     }
  1264.     return retVal;
  1265. }
  1268. STDMETHODIMP
  1269. MP4VPayloadFormat::Flush()
  1270. {
  1271.     m_bFlushed = TRUE;
  1273.     return HXR_OK;
  1274. }
  1277. BOOL MP4VPayloadFormat::IsPictureStart(IHXPacket* pPacket)
  1278. {
  1279.     if (m_PayloadID == PYID_X_HX_MP4)
  1280.     {
  1281. ULONG32 ulIdx;
  1282. ULONG32 ulSize = 0;
  1283. UINT8* pData = NULL;
  1284. IHXBuffer* pBuffer;
  1286. pBuffer = pPacket->GetBuffer();
  1288. if (pBuffer)
  1289. {
  1290.     ulSize = pBuffer->GetSize();
  1291.     if (ulSize >= 4)
  1292.     {
  1293. ulSize -= 4;
  1294. pData = pBuffer->GetBuffer();
  1295.     }
  1297.     pBuffer->Release();
  1298. }
  1300. if (pData)
  1301. {
  1302.     ulIdx = 0;
  1304.     do
  1305.     {
  1306. if (pData[ulIdx++] == 0x00)
  1307. {
  1308.     if (pData[ulIdx++] == 0x00)
  1309.     {
  1310. if (pData[ulIdx] == 0x01)
  1311. {
  1312.     ulIdx++;
  1313.     if (pData[ulIdx] == 0xb6)
  1314.     {
  1315. return TRUE;
  1316.     }
  1317. }
  1318. else
  1319. {
  1320.     ulIdx--;
  1321. }
  1322.     }
  1323. }
  1324.     } while (ulIdx < ulSize);
  1325. }
  1326.     }
  1328.     return FALSE;
  1329. }
  1332. BOOL MP4VPayloadFormat::IsValidPacket(IHXPacket* pPacket)
  1333. {
  1334.     if (m_PayloadID == PYID_X_HX_MP4)
  1335.     {
  1336. ULONG32 ulSize;
  1337. UINT8* pData = NULL;
  1338. IHXBuffer* pBuffer = pPacket->GetBuffer();
  1340. if (pBuffer)
  1341. {
  1342.     ulSize = pBuffer->GetSize();
  1343.     if (ulSize >= 4)
  1344.     {
  1345. ulSize -= 4;
  1346. pData = pBuffer->GetBuffer();
  1347.     }
  1349.     pBuffer->Release();
  1350. }
  1352. if (pData)
  1353. {
  1354.     // Should be more sophisiticated here and fully parse the
  1355.     // headeres and make sure there is no data of substance
  1356.     // following the headers - for this prototype code it
  1357.     // is good enough
  1358.     if ((pData[0] == 0x00) &&
  1359. (pData[1] == 0x00) &&
  1360. (pData[2] == 0x01) &&
  1361. ((pData[3] == 0x00) ||
  1362. (pData[3] == 0x20)))
  1363.     {
  1364. return FALSE;
  1365.     }
  1366. }
  1367.     }
  1369.     return TRUE;
  1370. }
  1373. ULONG32 MP4VPayloadFormat::GetPacketTime(IHXPacket* pPacket)
  1374. {
  1375.     ULONG32 ulTime;
  1377.     HX_ASSERT(pPacket);
  1379.     if (m_bUsesRTPPackets && (m_ulSamplesPerSecond != 0))
  1380.     {
  1381. ulTime = ((IHXRTPPacket*) pPacket)->GetRTPTime();
  1383. ulTime = m_TSConverter.Convert(ulTime);
  1384.     }
  1385.     else
  1386.     {
  1387. ulTime = pPacket->GetTime();
  1388.     }
  1390.     return ulTime;
  1391. }