mpapktparse.cpp
上传用户:dangjiwu
上传日期:2013-07-19
资源大小:42019k
文件大小:15k
源码类别:

Symbian

开发平台:

Visual C++

  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 ***** */ 
  35. #include "hxtypes.h"
  36. #include "hlxclib/stdio.h"
  37. #include "hxcom.h"              // IUnknown
  38. #include "hxcomm.h"            // IHXCommonClassFactory
  39. #include "ihxpckts.h"           // IHXBuffer, IHXPacket, IHXValues
  40. #include "hxplugn.h"           // IHXPlugin
  41. #include "hxrendr.h"           // IHXRenderer
  42. #include "hxengin.h"           // IHXInterruptSafe
  43. #include "hxcore.h"            // IHXStream
  44. #include "hxausvc.h"           // Audio Services
  45. #include "hxmon.h"             // IHXStatistics
  46. #include "hxupgrd.h"           // IHXUpgradeCollection
  47. #include "hxslist.h"            // CHXSimpleList
  48. #include "carray.h"             // CHXPtrArray
  49. #include "tconverter.h"
  50. #include "hxstrutl.h"
  51. #include "mpadecobj.h"          // MPEG Audio Decoder (selects fixed-pt or floating-pt based on HELIX_CONFIG_FIXEDPOINT)
  52. #include "mp3format.h"          // MP3 formatter
  53. #ifdef DEMUXER
  54. #include "xmddemuxer.h"         // Demuxer
  55. #include "xmdtypes.h"
  56. #endif
  57. #include "mp3rend.h"            // CRnMp3Ren
  58. #include "pktparse.h"           // CPacketParser
  59. #include "mpapktparse.h"        // CMpaPacketParser
  60. CMpaPacketParser::CMpaPacketParser() :    
  61.     CPacketParser(),
  62.     m_pPacket(NULL),    
  63.     m_bPacketLoss(FALSE)
  64. {
  65.     m_bReformatted = FALSE;
  66. }
  67. CMpaPacketParser::~CMpaPacketParser()
  68. {
  69.     HX_RELEASE(m_pPacket);
  70. }
  71. /********************************************************************
  72.  * CMpaPacketParser::AddPacket: Adds a packet. Assumes that all frames 
  73.  * in the packet will be retrieved before AddPacket is called again. 
  74.  * Will not queue packets.
  75.  */
  76. HX_RESULT
  77. CMpaPacketParser::AddPacket(IHXPacket* pPacket, INT32 streamOffsetTime)
  78. {
  79. #ifdef SIM_PKT_LOSS
  80.     static int nPackets = 0;
  81.     if (++nPackets % 10 == 0)
  82.     {
  83.         m_bPacketLoss = TRUE;
  84.         return HXR_FAIL;
  85.     }
  86. #endif //SIM_PKT_LOSS 
  87.     HX_ASSERT(pPacket);
  88.     if(pPacket->IsLost())
  89.     {
  90.         m_bPacketLoss = TRUE;
  91.         return HXR_FAIL;
  92.     }
  93.     else
  94.     {
  95.         // Save this packet        
  96.         HX_RELEASE(m_pPacket);
  97.         m_pPacket = pPacket;
  98.         m_pPacket->AddRef();
  99.         m_lStreamOffsetTime = streamOffsetTime;
  100.     }
  101.     return HXR_OK;
  102. }
  103. HX_RESULT
  104. CMpaPacketParser::RenderAll()
  105. {
  106.     if(!m_pRenderer || !m_pFmt || !m_pPacket)
  107.     {
  108.         return HXR_FAIL;
  109.     }
  110.     UINT32 ulSize;
  111.     UCHAR* pBuffer;    
  112.     IHXBuffer* pBufObj = m_pPacket->GetBuffer();    
  113.     if(!pBufObj)
  114.     {
  115.         // Null buffer?
  116.         return HXR_FAIL;
  117.     }
  118.     pBufObj->Get(pBuffer, ulSize);
  119.     if(!pBuffer || !ulSize)
  120.     {
  121.         // empty packet!
  122.         HX_RELEASE(pBufObj);
  123.         return HXR_FAIL;
  124.     }
  125.     if(!ParseHeaders(pBuffer, ulSize))
  126.     {
  127.         HX_RELEASE(pBufObj);
  128.         return HXR_FAIL;
  129.     }
  130.     if (m_bPacketLoss)
  131.     {
  132.         HandlePacketLoss();
  133.         m_bPacketLoss = FALSE;
  134.     }
  135.     if(m_dNextPts == 0.0)
  136.     {
  137.         m_dNextPts = m_pPacket->GetTime();
  138.         if(m_lStreamOffsetTime > m_dNextPts)
  139.         {
  140.             m_dNextPts =  0;
  141.         }
  142.         else
  143.         {
  144.             m_dNextPts -= m_lStreamOffsetTime;
  145.         }
  146.     }
  147.     HX_RESULT retVal = HXR_OK;
  148.     // Packets may exceed the decode buffer size, so copy the
  149.     // packet iteratively if necessary.
  150.     do
  151.     {
  152.         // Copy packet data to decode buffer to prevent a potential
  153.         // access vioaltion in the mp3 decoder and to deal with rtp
  154.         // packet fragmentation.
  155.         UINT32 ulCopy = min(ulSize, DEC_BUFFER_SIZE - m_ulDecBufBytes);
  156.         memcpy(m_pDecBuffer + m_ulDecBufBytes, pBuffer, ulCopy); /* Flawfinder: ignore */
  157.         m_ulDecBufBytes += ulCopy;
  158.     
  159.         pBuffer += ulCopy;
  160.         ulSize -= ulCopy;
  161.         // Use these temp variables to pass to the decoder
  162.         UCHAR   *pDec = m_pDecBuffer;
  163.         UINT32  ulDec = m_ulDecBufBytes;
  164.         int nFrameSize = 0;
  165.         INT32 lScan = 0;
  166.         // Do we need to init our decoder
  167.         if (!m_pDecoder)
  168.         {
  169.             lScan = m_pFmt->ScanForSyncWord(pDec, ulDec, nFrameSize);
  170.             if (lScan >= 0)
  171.             {
  172.                 pDec += lScan;
  173.                 ulDec -= lScan;
  174.                 m_ulDecBufBytes -= lScan;
  175.             }
  176.             else
  177.             {
  178.                 // If our buffer is full and we could not find a frame,
  179.                 // we have bad data.  So skip 3/4 of buffered data.
  180.                 if (DEC_BUFFER_SIZE == m_ulDecBufBytes)
  181.                 {
  182.                     pDec += DEC_BUFFER_SIZE * 3 / 4;
  183.                     m_ulDecBufBytes -= DEC_BUFFER_SIZE * 3 / 4;
  184.                 }
  185.                 
  186.                 ulDec = 0;
  187.             }
  188.             if (ulDec && !InitDecoder(pDec, ulDec, FALSE))
  189.             {
  190.                 HX_RELEASE(pBufObj);
  191.                 return HXR_FAIL;
  192.             }
  193.         }
  194.         // Decode all frames in this buffer
  195.         while (ulDec)
  196.         {
  197.             // Make sure we don't have a packet frag
  198.             if (!m_pFmt->CheckValidFrame(pDec, ulDec))
  199.             {
  200.                 // Scan through any bad data in the file
  201.                 nFrameSize = 0;
  202.                 lScan = m_pFmt->ScanForSyncWord(pDec, ulDec, nFrameSize);
  203.                 if (lScan >= 0)
  204.                 {
  205.                     pDec += lScan;
  206.                     ulDec -= lScan;
  207.                     m_ulDecBufBytes -= lScan;
  208.                 }
  209.                 else
  210.                 {
  211.                     // If our buffer is full and we could not find a frame,
  212.                     // we have bad data.  So skip 3/4 of buffered data.
  213.                     if (DEC_BUFFER_SIZE == m_ulDecBufBytes)
  214.                     {
  215.                         pDec += DEC_BUFFER_SIZE * 3 / 4;
  216.                         m_ulDecBufBytes -= DEC_BUFFER_SIZE * 3 / 4;
  217.                     }
  218.                     break;
  219.                 }
  220.             }
  221.             // Decode and render this frame
  222.             ulDec = DecodeAndRender(pDec, ulDec, m_dNextPts, m_bPacketLoss);
  223.             if (ulDec)
  224.             {
  225.                 if(ulDec > m_ulDecBufBytes)
  226.                     ulDec = m_ulDecBufBytes;
  227.                 pDec += ulDec;
  228.                 m_ulDecBufBytes -= ulDec;
  229.                 ulDec = m_ulDecBufBytes;
  230.                 m_dNextPts += m_dFrameTime;
  231.             }
  232.             else
  233.             {
  234.                 retVal = HXR_OUTOFMEMORY;
  235.                 break;
  236.             }
  237.         }
  238.         // Copy the leftovers to the start of the buffer
  239.         if (m_ulDecBufBytes)
  240.             memmove(m_pDecBuffer, pDec, m_ulDecBufBytes);
  241.     } while (ulSize);
  242.     HX_RELEASE(pBufObj);
  243.     return retVal;
  244. }
  245. void
  246. CMpaPacketParser::RestartStream(void)
  247. {
  248.     m_bPacketLoss = FALSE;
  249.     m_ulDecBufBytes = 0;
  250.     HX_RELEASE(m_pLastPCMBuffer);
  251.     m_dLastPCMTime = 0.0;
  252. }
  253. C2250PacketParser::~C2250PacketParser()
  254. {
  255.     HX_DELETE(m_pTsConvert);
  256. }
  257. void C2250PacketParser::PostSeek(UINT32 time)
  258. {
  259.     CMpaPacketParser::PostSeek(time);
  260.     HX_DELETE(m_pTsConvert);
  261. }
  262. BOOL
  263. C2250PacketParser::ParseHeaders(UCHAR*& pBuffer, UINT32& ulSize)
  264. {
  265.     // Skip rtp payload header
  266.     // Check for bad or unknown packets
  267.     if(pBuffer[0] || pBuffer[1])
  268.         return FALSE;
  269.     // Only extract the rtp pts for a packet containing the start of a frame
  270.     if (!pBuffer[2] && !pBuffer[3] && !m_pPacket->IsLost())
  271.     {
  272.         IHXRTPPacket *pRtpPacket = NULL;
  273.         m_pPacket->QueryInterface(IID_IHXRTPPacket, (void**)&pRtpPacket);
  274.         if (pRtpPacket)
  275.         {
  276.             if (!m_pTsConvert)
  277.             {
  278.                 m_pTsConvert = new CHXTimestampConverter(CHXTimestampConverter::FACTORS,
  279.  1,
  280.  90);
  281. if (m_pTsConvert)
  282. {
  283.     m_pTsConvert->setHXAnchor(m_pPacket->GetTime());
  284. }
  285.             }
  286.             if (m_pTsConvert)
  287.                 m_dNextPts = m_pTsConvert->rtp2hxa(pRtpPacket->GetRTPTime());
  288.             else
  289.                 m_dNextPts = pRtpPacket->GetRTPTime()/90.0;
  290.             pRtpPacket->Release();
  291.             
  292.     if(m_lStreamOffsetTime > m_dNextPts)
  293.                 m_dNextPts =  0;
  294.             else
  295.                 m_dNextPts -= m_lStreamOffsetTime;
  296.         }        
  297.     }
  298.     // If we lost packets, resync with the start of a frame
  299.     else if (m_bPacketLoss)
  300.     {
  301.         return FALSE;
  302.     }
  303.     pBuffer += 4;
  304.     ulSize -= 4;
  305.     return TRUE;
  306. }
  307. void C2250PacketParser::HandlePacketLoss()
  308. {
  309.     // Render the last PCM buffer for the number of frames we lost
  310.     if (m_pLastPCMBuffer)
  311.     {
  312.         double dTime = m_dLastPCMTime + m_dFrameTime;
  313.         int nLostFrames = (int)((m_dNextPts - dTime) / m_dFrameTime + .5);
  314.         for (int i=0; i<nLostFrames; i++)
  315.         {
  316.             m_pRenderer->Render(m_pLastPCMBuffer, dTime);
  317.             dTime += m_dFrameTime;
  318.         }
  319.     }
  320.     // Remove any partial audio frames in the decode buffer
  321.     m_ulDecBufBytes = 0;
  322. }
  323. #ifdef DEMUXER
  324. CSysPacketParser::CSysPacketParser(BOOL bMPEG2, IHXRegistry* pRegistry) : 
  325.     CMpaPacketParser(),
  326.     m_pRegistry(pRegistry),
  327.     m_llLastPts(0),
  328.     m_llFirstPts(0),
  329.     m_ulPlayTime(0),
  330.     m_bCheckVcdBug(TRUE),
  331.     m_bVcdBug(FALSE)
  332. {
  333.     m_pDemuxer = new CDemuxer(bMPEG2);
  334. }
  335. BOOL
  336. CSysPacketParser::Demux(UCHAR*& pBuffer, UINT32& ulSize, UINT32 ulFragSize)
  337. {
  338.     if(!m_pDemuxer)
  339.     {
  340.         return TRUE;
  341.     }
  342.      // Get the es data
  343.     Packet packet;
  344.     m_pDemuxer->Demux_ul(pBuffer, ulSize, &packet);
  345.     pBuffer = packet.pData;
  346.     ulSize = packet.lBytes;
  347.     // Sync clock with the first stream time stamp
  348.     if (m_dNextPts == 0.0)
  349.     {
  350.         if (!packet.cHasPts)
  351.         {
  352.             return FALSE;
  353.         }
  354.         m_llFirstPts = packet.llPts;
  355.         m_llLastPts = packet.llPts;
  356.         INT32 lTime = m_pPacket->GetTime();
  357.         // Set the first timestamp in the registry (don't include the stream
  358.         // offset in this value since the video renderer needs the offset
  359.         // in its timestamps for proper a/v sync).
  360.         INT32 nDelta = (INT32)(packet.llPts/UNITS_CONVERSION_MS) - lTime;
  361. // This fixes 108347, dont synchronize against a bad packet when starting playback
  362. if( nDelta < 0 && lTime == 0 )
  363. {
  364.     nDelta = 0;
  365.     packet.llPts = 0;
  366.     m_llFirstPts = m_llLastPts = 0;
  367. }
  368.         if(m_pRegistry)
  369.         {
  370.     m_pRegistry->SetIntByName("FirstPts", nDelta);
  371.         }
  372.         
  373.         if(m_lStreamOffsetTime > lTime)
  374.         {
  375.             lTime =  0;
  376.         }
  377.         else
  378.         {
  379.             lTime -= m_lStreamOffsetTime;
  380.         }
  381.         
  382.         m_dNextPts = lTime;
  383.         #if defined _DEBUG && defined _WIN32
  384.         char szTmp[256]; /* Flawfinder: ignore */
  385.         SafeSprintf(szTmp, 256, "Audio Pts %ldn", (UINT32)m_dNextPts);
  386.         //OutputDebugString(szTmp);
  387.         #endif
  388.         m_ulPlayTime = lTime;
  389.     }
  390.     else if (packet.llPts)
  391.     {
  392.         // Make sure we inited our decoder before doing ts manipulation
  393.         if (m_ulBitRate)
  394.         {
  395.             // Update the pts (stream ts - 1st stream ts + playtime)
  396.             double dNewTs = (double)(packet.llPts - m_llFirstPts) / 
  397.                             (double)UNITS_CONVERSION_MS + m_ulPlayTime;
  398.             // Pts refer to the first frame in this packet, so if we have
  399.             // a partial frame in our decode buffer, the new pts is not
  400.             // for that frame.  Decrement the new pts by on frame time to
  401.             // sync with the partial frame.
  402.             if (ulFragSize)
  403.             {
  404.                 // Ok, some vcds generate erroneous time stamps. The pts
  405.                 // refers to the first byte in the packet not instead of
  406.                 // the first frame.  Try and catch this bug here and adjust.
  407.                 
  408.                 if (m_bCheckVcdBug)
  409.                 {
  410.                     m_bCheckVcdBug = FALSE;
  411.                     if ((dNewTs - ulFragSize * 1000 / (m_ulBitRate>>3)) - 
  412.                         m_dNextPts <= 1)
  413.                     {
  414.                         m_bVcdBug = TRUE;
  415.                     }
  416.                 }
  417.                 
  418.                 if (m_bVcdBug)
  419.                     dNewTs -= ulFragSize * 1000 / (m_ulBitRate>>3);
  420.                 else
  421.                     dNewTs -= m_dFrameTime;
  422.             }
  423.             // Dynamic timestamp change
  424.             // Look for timestamps that go backwards or are less than 1000.
  425.             // An encoder is supposed to send timestamps at least every .7 sec
  426.             INT32 lDelta = dNewTs - m_dNextPts;
  427.             if (abs(lDelta) > 1000)
  428.             {
  429.                 if(m_pRegistry)
  430.                 {
  431.                     m_pRegistry->SetIntByName("FirstPts", 
  432.                         (INT32)(packet.llPts/UNITS_CONVERSION_MS) - 
  433.                         (INT32)m_dNextPts);
  434.                 }
  435.                 m_llFirstPts = packet.llPts - 
  436.                                 (INT64)m_dNextPts*UNITS_CONVERSION_MS + 
  437.                                 (INT64)m_ulPlayTime*UNITS_CONVERSION_MS;
  438.             }
  439.             else
  440.                 m_dNextPts = dNewTs;
  441.         }
  442.         
  443.         m_llLastPts = packet.llPts;
  444.     }
  445.     return TRUE;
  446. }
  447. #endif // DEMUXER