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

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

Symbian

开发平台：

Visual C++

mp4afmt.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 _BYPASS_DECODER
  40. // #define _SILENT_PLAY
  41. // #define ENABLE_FRAME_TRACE
  42. #define _IGNORE_UNSUPPORTED // must be defined if _BYPASS_DECODER is defined
  44. #define MIN_ACCEPTBALE_DATA_REMAINDER 1 // in bytes
  45. #define MP4_DEFAULT_AUDIO_PREROLL 2000 // in milliseconds
  46. #define MAX_TOLERABLE_TIME_GAP 5 // in milliseconds
  49. /****************************************************************************
  50.  *  Includes
  51.  */
  52. #include "mp4afmt.h"
  53. #include "mp4adec.h"
  55. #include "hxtick.h"
  56. #include "hxassert.h"
  57. #include "hxstrutl.h"
  59. #include "mp4audio.h"
  60. #include "mp4apyld.h"
  61. #include "mp4gpyld.h"
  62. #include "amrpyld.h"
  63. #include "hxamrpyld.h"
  64. #if defined(HELIX_FEATURE_AUDIO_CODEC_MP3)
  65. #include "mp3draft.h"
  66. #endif /* #if defined(HELIX_FEATURE_AUDIO_CODEC_MP3) */
  69. /****************************************************************************
  70.  *  Debug
  71.  */
  72. #ifdef ENABLE_FRAME_TRACE
  73. #define MAX_FRAME_TRACE_ENTRIES 100000
  74. ULONG32 ulFrameTraceIdx = 0;
  75. LONG32 frameTraceArray[MAX_FRAME_TRACE_ENTRIES][4];
  77. void DumpFrameEntries(void)
  78. {
  79.     FILE* pFile = NULL;
  80.     ULONG32 ulIdx;
  82.     if (ulFrameTraceIdx > 0)
  83.     {
  84. pFile = fopen("c:\mp4a.txt", "wb");
  85.     }
  87.     if (pFile)
  88.     {
  89. for (ulIdx = 0; ulIdx < ulFrameTraceIdx; ulIdx++)
  90. {
  91.     fprintf(pFile, "%c(%d=%d) = %dn", (char) frameTraceArray[ulIdx][1], 
  92.    frameTraceArray[ulIdx][2],
  93.    frameTraceArray[ulIdx][3],
  94.    frameTraceArray[ulIdx][0]);
  95. }
  97. fclose(pFile);
  98.     }
  100.     ulFrameTraceIdx = 0;
  101. }
  102. #endif // ENABLE_FRAME_TRACE
  105. /****************************************************************************
  106.  *  Locals
  107.  */
  110. /****************************************************************************
  111.  *  Method:
  112.  *    CMP4AudioFormat::CMP4AudioFormat
  113.  *
  114.  */
  115. CMP4AudioFormat::CMP4AudioFormat(IHXCommonClassFactory* pCommonClassFactory,
  116.  CMP4AudioRenderer* pMP4AudioRenderer)
  117.     : CAudioFormat(pCommonClassFactory, pMP4AudioRenderer)
  118.     , m_pRssm(NULL)
  119.     , m_bNewAssembledFrame(TRUE)
  120.     , m_ulAUDuration(0)
  121.     , m_ulLastDecodedEndTime(0)
  122.     , m_ulLastFrameTime(0)
  123.     , m_ulCodecDelayMs(0)
  124.     , m_bCanChangeAudioStream(FALSE)
  125.     , m_ulMaxDecoderOutputBytes(0)
  126.     , m_ulMaxDecoderOutputSamples(0)
  127.     , m_pDecoderBuffer(NULL)
  128.     , m_ulDecoderBufferSize(0)
  129.     , m_pDecoderModule(NULL)
  130.     , m_pDecoderInstance(NULL)
  131.     , m_pMP4AudioRenderer(pMP4AudioRenderer)
  132. {
  133.     // Register the payload format builders with m_fmtFactory
  134.     RegisterPayloadFormats();
  136.     HX_ASSERT(m_pCommonClassFactory);
  137. }
  140. /****************************************************************************
  141.  *  Method:
  142.  *    CMP4AudioFormat::~CMP4AudioFormat
  143.  *
  144.  */
  145. CMP4AudioFormat::~CMP4AudioFormat()
  146. {
  147.     _Reset();
  149.     HX_RELEASE(m_pDecoderInstance);
  150.     HX_DELETE(m_pDecoderModule);
  151.     HX_VECTOR_DELETE(m_pDecoderBuffer);
  152.     HX_RELEASE(m_pRssm);
  154. #ifdef ENABLE_FRAME_TRACE
  155.     DumpFrameEntries();
  156. #endif // ENABLE_FRAME_TRACE
  157. }
  160. /****************************************************************************
  161.  *  Method:
  162.  *    CMP4AudioFormat::Init
  163.  *
  164.  */
  165. HX_RESULT CMP4AudioFormat::Init(IHXValues* pHeader)
  166. {
  167.     HX_RESULT retVal = CAudioFormat::Init(pHeader);
  169.     // Open the Decoder Module
  170.     if (SUCCEEDED(retVal))
  171.     {
  172. m_pDecoderModule = CreateDecoder();
  174. retVal = HXR_OUTOFMEMORY;
  175. if (m_pDecoderModule)
  176. {
  177.     retVal = HXR_OK;
  178. }
  179.     }
  181.     if (SUCCEEDED(retVal))
  182.     {
  183. retVal = m_pDecoderModule->Open(pHeader, 
  184. &m_pDecoderInstance,
  185. m_pContext);
  186. #if defined(HELIX_FEATURE_AUTOUPGRADE)
  187.         if (FAILED(retVal) && retVal == HXR_REQUEST_UPGRADE)
  188.         {
  189.             // If we returned a HXR_REQUEST_UPGRADE, then we 
  190.             // failed to load the decoder binary. Therefore, we
  191.             // will copy the decoder's AU string into our
  192.             // own AU String
  193.             SafeStrCpy(m_szAUStr, // m_szAUStr is from our parent class
  194.                        m_pDecoderModule->GetAutoUpgradeString(),
  195.                        MAX_AUSTR_SIZE);
  196.         }
  197. #endif /* #if defined(HELIX_FEATURE_AUTOUPGRADE) */
  198.     }
  200. #if defined(HELIX_FEATURE_STATS)
  201.     if (SUCCEEDED(retVal))
  202.     {
  203. char* pVal = (char*) m_pDecoderModule->GetCodecName();
  205. if (pVal)
  206. {
  207.     m_pMP4AudioRenderer->ReportStat(AS_CODEC_NAME, pVal);
  208. }
  210. pVal = (char*) m_pDecoderModule->GetCodecFourCC();
  212. if (pVal)
  213. {
  214.     m_pMP4AudioRenderer->ReportStat(AS_CODEC_4CC, pVal);
  215. }
  216.     }
  217. #endif /* #if defined(HELIX_FEATURE_STATS) */
  219.     // Create Packet Assembler
  220.     if (SUCCEEDED(retVal))
  221.     {
  222.         retVal = m_fmtFactory.BuildFormat(m_pCommonClassFactory, FALSE, 
  223.                                           pHeader, m_pRssm);
  224. #if defined(HELIX_FEATURE_AUTOUPGRADE)
  225.         if (FAILED(retVal) && retVal == HXR_REQUEST_UPGRADE)
  226.         {
  227.             // If BuildFormat returns HXR_REQUEST_UPGRADE, then
  228.             // it means that no depacketizer had successful calls
  229.             // to Init() and SetStreamHeader(), but at least one
  230.             // of the depacketizers returned HXR_REQUEST_UPGRADE.
  231.             //
  232.             // Copy our own mime type into the AU string
  233.             IHXBuffer* pMimeTypeStr = NULL;
  234.             pHeader->GetPropertyCString("MimeType", pMimeTypeStr);
  235.             if (pMimeTypeStr)
  236.             {
  237.                 SafeStrCpy(m_szAUStr, // m_szAUStr is from our parent class
  238.                            (const char*) pMimeTypeStr->GetBuffer(),
  239.                            MAX_AUSTR_SIZE);
  240.             }
  241.             HX_RELEASE(pMimeTypeStr);
  242.         }
  243. #endif /* #if defined(HELIX_FEATURE_AUTOUPGRADE) */
  245. #ifdef _IGNORE_UNSUPPORTED
  246. if (FAILED(retVal))
  247. {
  248.     HX_RELEASE(m_pDecoderInstance);
  249.     retVal = HXR_OK;
  250. }
  251. #endif // _IGNORE_UNSUPPORTED
  252.     }
  253.     
  254.     // Open Codec Instance
  255.     if (SUCCEEDED(retVal) && m_pDecoderInstance)
  256.     {
  257. HX_ASSERT(m_pDecoderModule);
  259. ULONG32 ulBitstreamHeaderSize;
  260. const UINT8* pBitstreamHeader;
  261.         UINT8 unBitstreamType;
  263. ulBitstreamHeaderSize = m_pRssm->GetBitstreamHeaderSize();
  264. pBitstreamHeader = m_pRssm->GetBitstreamHeader();
  265. unBitstreamType = m_pRssm->GetBitstreamType();
  267. retVal = HXR_FAIL;
  268. if (pBitstreamHeader && (ulBitstreamHeaderSize > 0))
  269. {
  270.     retVal = HXR_OK;
  271. }
  273. if (SUCCEEDED(retVal))
  274. {
  275.     retVal = m_pDecoderInstance->OpenDecoder(unBitstreamType, // eCfgDesc
  276.      pBitstreamHeader,
  277.      ulBitstreamHeaderSize);
  278.             if (FAILED(retVal))
  279.             {
  280. #if defined(HELIX_FEATURE_AUTOUPGRADE)
  281.                 // If we failed in our OpenDecoder() call, then the
  282.                 // decoder must be a version which does not support the
  283.                 // particular profile which we passed in. Therefore,
  284.                 // we will AU with the "qtplayer" string to instruct
  285.                 // the TLC to attempt to play this file other means.
  286.                 //
  287.                 // Copy into our parent class's AU string buffer
  288.                 SafeStrCpy(m_szAUStr, // m_szAUStr is from our parent class
  289.                            "qtplayer",
  290.                            MAX_AUSTR_SIZE);
  291. #endif /* #if defined(HELIX_FEATURE_AUTOUPGRADE) */
  292.                 // When CAudioFormat::Init() returns to where it was called
  293.                 // from CAudioRenderer::OnHeader(), then if the return code
  294.                 // is HXR_REQUEST_UPGRADE, then it will assume it needs
  295.                 // to AU, and will look for an AU string from CAudioFormat.
  296.                 // So we need to return HXR_REQUEST_UPGRADE.
  297.                 retVal = HXR_REQUEST_UPGRADE;
  298.             }
  299. }
  301. #ifdef _IGNORE_UNSUPPORTED
  302. if (FAILED(retVal) && retVal != HXR_REQUEST_UPGRADE)
  303. {
  304.     HX_RELEASE(m_pDecoderInstance);
  305.     retVal = HXR_OK;
  306. }
  307. #endif // _IGNORE_UNSUPPORTED
  308.     }
  310.     // Inquire and set Audio data parameters
  311.     if (SUCCEEDED(retVal) && m_pDecoderInstance)
  312.     {
  313.         retVal = UpdateAudioFormat(m_ulLastDecodedEndTime, TRUE);
  314.     }
  316.     if (SUCCEEDED(retVal))
  317.     {
  318. m_bCanChangeAudioStream = CanChangeAudioStream();
  319.     }
  321. #ifdef _BYPASS_DECODER
  322.     HX_RELEASE(m_pDecoderInstance);
  323. #endif // _BYPASS_DECODER
  325.     return retVal;
  326. }
  329. /****************************************************************************
  330.  *    CMP4AudioFormat::GetDefaultPreroll
  331.  */
  332. ULONG32 CMP4AudioFormat::GetDefaultPreroll(IHXValues* pValues)
  333. {
  334.     return MP4_DEFAULT_AUDIO_PREROLL;
  335. }
  337. HX_RESULT CMP4AudioFormat::UpdateAudioFormat(ULONG32& ulAnchorTime, 
  338.      BOOL bForceUpdate)
  339. {
  340.     HX_RESULT retVal = HXR_FAIL;
  342.     if (m_pDecoderInstance && m_pAudioFmt && m_pRssm)
  343.     {
  344. UINT32 ulChannels = 0;
  345. BOOL bFormatChanged = FALSE;
  347.         // Set the bits per sample (always 16 bits per sample)
  348.         m_pAudioFmt->uBitsPerSample = 16;                 
  349.         // Set number of channels
  350.         retVal = m_pDecoderInstance->GetNChannels(ulChannels);
  351.         if (SUCCEEDED(retVal))
  352.         {
  353.             retVal = HXR_FAIL;
  354.     if (ulChannels)
  355.     {
  356. retVal = HXR_OK;
  358. if ((ulChannels != m_pAudioFmt->uChannels) || bForceUpdate)
  359. {
  360.     bFormatChanged = TRUE;
  361. }
  362.     }
  363.         }
  364.         // Set the sample rate
  365.         if (SUCCEEDED(retVal))
  366.         {
  367.             UINT32 ulSampleRate = 0;
  368.             retVal = m_pDecoderInstance->GetSampleRate(ulSampleRate);
  369.             if (SUCCEEDED(retVal))
  370.             {
  371.                 retVal = HXR_FAIL;
  372.                 if (ulSampleRate)
  373.                 {
  374.     retVal = HXR_OK;
  376.     if ((m_pAudioFmt->ulSamplesPerSec != ulSampleRate) || 
  377. bForceUpdate)
  378.     {
  379. ULONG32 ulAnchorInMs = m_TSConverter.Convert(ulAnchorTime);
  381. m_pAudioFmt->uChannels = (UINT16) ulChannels;
  382. m_pAudioFmt->ulSamplesPerSec = ulSampleRate;
  384. ulAnchorTime =  ConvertMsToTime(ulAnchorInMs);
  386. ConfigureRssm(ulAnchorInMs);
  388. m_TSConverter.SetBase(ulSampleRate, 1000);
  389. m_TSConverter.SetOffset(ulAnchorInMs);
  391. bFormatChanged = TRUE;
  392.     }
  393.     else
  394.     {
  395. m_pAudioFmt->uChannels = (UINT16) ulChannels;
  396.     }  
  397.                 }
  398.             }
  399.         }
  400.         // Set the max samples out
  401.         if (SUCCEEDED(retVal))
  402.         {
  403.             UINT32 ulMaxSamplesOut = 0;
  404.             retVal = m_pDecoderInstance->GetMaxSamplesOut(ulMaxSamplesOut);
  405.             if (SUCCEEDED(retVal))
  406.             {
  407.                 retVal = HXR_FAIL;
  408.                 if (ulMaxSamplesOut)
  409.                 {
  410.                     retVal = HXR_OK;
  412.     if ((ulMaxSamplesOut != m_ulMaxDecoderOutputSamples) || 
  413. bForceUpdate)
  414.     {
  415. // Save the max samples out
  416. m_ulMaxDecoderOutputSamples = ulMaxSamplesOut;
  417. // Compute and set the AU duration
  418. m_ulAUDuration = m_ulMaxDecoderOutputSamples / m_pAudioFmt->uChannels;
  419. m_pRssm->SetAUDuration(m_ulAUDuration);
  420. // Compute the max output in bytes
  421. m_ulMaxDecoderOutputBytes = CAudioFormat::ConvertSamplesToBytes(m_ulMaxDecoderOutputSamples);
  422. // Save the max block size
  423. m_pAudioFmt->uMaxBlockSize = (UINT16) m_ulMaxDecoderOutputBytes;
  425. bFormatChanged = TRUE;
  426.     }
  427.                 }
  428.             }
  429.         }
  430.         // Set the codec delay in samples
  431.         if (bFormatChanged && SUCCEEDED(retVal))
  432.         {
  433.             UINT32 ulCodecDelaySamples = 0;
  434.             retVal = m_pDecoderInstance->GetDelay(ulCodecDelaySamples);
  435.             if (SUCCEEDED(retVal))
  436.             {
  437.                 // Compute and save the codec delay in ms
  438.                 m_ulCodecDelayMs = CAudioFormat::ConvertSamplesToMs(ulCodecDelaySamples);
  439.             }
  440.         }
  441.         // Allocate Decoder Buffer
  442.         if (SUCCEEDED(retVal))
  443.         {
  444.             // Did the size change?
  445.             if (m_ulDecoderBufferSize != m_ulMaxDecoderOutputBytes)
  446.             {
  447.                 retVal = HXR_OUTOFMEMORY;
  448.                 HX_VECTOR_DELETE(m_pDecoderBuffer);
  449.                 m_pDecoderBuffer = new UINT8 [m_ulMaxDecoderOutputBytes];
  450.                 if (m_pDecoderBuffer)
  451.                 {
  452.     retVal = HXR_OK;
  453.                     m_ulDecoderBufferSize = m_ulMaxDecoderOutputBytes;
  454.                 }
  455.             }
  456.         }
  457.     }
  459.     return retVal;
  460. }
  462. HX_RESULT CMP4AudioFormat::ConfigureRssm(ULONG32 ulAnchorInMs)
  463. {
  464.     HX_RESULT retVal = HXR_UNEXPECTED;
  466.     if (m_pRssm)
  467.     {
  468. CTSConverter tempConverter;
  469. ULONG32 ulRssmTimeBase;
  470. ULONG32 ulRssmAnchor;
  471. ULONG32 ulDecoderAnchor;
  472. ULONG32 ulSamplingRate = m_pAudioFmt->ulSamplesPerSec;
  474. retVal = HXR_OK;
  476. if (ulSamplingRate == 0)
  477. {
  478.     ulSamplingRate = 1000;
  479. }
  481. m_pRssm->SetSamplingRate(ulSamplingRate);
  482. m_pRssm->SetTimeAnchor(ulAnchorInMs);
  484. ulRssmTimeBase = m_pRssm->GetTimeBase();
  485. if (ulRssmTimeBase == 0)
  486. {
  487.     ulRssmTimeBase = m_pAudioFmt->ulSamplesPerSec;
  488. }
  490. m_InputTSConverter.SetBase(ulRssmTimeBase, 
  491.    m_pAudioFmt->ulSamplesPerSec);
  493. tempConverter.SetBase(1000, ulRssmTimeBase);
  494. ulRssmAnchor = tempConverter.ConvertVector(ulAnchorInMs);
  495. tempConverter.SetBase(1000, m_pAudioFmt->ulSamplesPerSec);
  496. ulDecoderAnchor = tempConverter.ConvertVector(ulAnchorInMs);
  498. m_InputTSConverter.SetAnchor(ulRssmAnchor, ulDecoderAnchor);
  499.     }
  501.     return retVal;
  502. }
  504. /****************************************************************************
  505.  *  Method:
  506.  *    CMP4AudioFormat::CreateAssembledPacket
  507.  *
  508.  */
  509. CMediaPacket* CMP4AudioFormat::CreateAssembledPacket(IHXPacket* pPacket)
  510. {
  511.     CMediaPacket* pLastFramePacket = NULL;
  512.     CMediaPacket* pFramePacket = NULL;
  514.     if (m_pRssm)
  515.     {
  516. if (pPacket)
  517. {
  518.     m_pRssm->SetPacket(pPacket);
  519. }
  520. else
  521. {
  522.     m_pRssm->Flush();
  523. }
  525. if (m_pRssm->CreateMediaPacket(pLastFramePacket) == HXR_OK)
  526. {
  527.     HX_ASSERT(pLastFramePacket);
  528.     
  529.     do
  530.     {
  531. pFramePacket = NULL;
  532. if (m_pRssm->CreateMediaPacket(pFramePacket) == HXR_OK)
  533. {
  534.     HX_ASSERT(pFramePacket);
  535.     
  536.     if (pLastFramePacket)
  537.     {
  538. CAudioFormat::PutAudioPacket(pLastFramePacket);
  539.     }
  540.     
  541.     pLastFramePacket = pFramePacket;
  542. }
  543.     } while (pFramePacket);
  544. }
  545.     }
  547.     return pLastFramePacket;
  548. }
  551. /****************************************************************************
  552.  *  Method:
  553.  *    CMP4AudioFormat::DecodeAudioData
  554.  *
  555.  */
  556. HX_RESULT CMP4AudioFormat::DecodeAudioData(HXAudioData& audioData,
  557.    BOOL bFlushCodec)
  558. {
  559.     ULONG32 ulBytesDecoded;
  560.     ULONG32 ulSamplesProduced;
  561.     ULONG32 ulBytesProduced;
  562.     ULONG32 ulNextDecodeStartTime;
  563.     ULONG32 ulPacketBasedNextDecodeStartTime;
  564.     HX_RESULT retVal = HXR_NO_DATA;
  565.     HX_RESULT checkStatus;
  567.     CMediaPacket* pAssembledFrame = NULL;
  569.     if (bFlushCodec)
  570.     {
  571. pAssembledFrame = CreateAssembledPacket(NULL);
  572.         if (pAssembledFrame)
  573.         {
  574.             CAudioFormat::PutAudioPacket(pAssembledFrame);
  575.         }
  576.     }
  578.     while ((pAssembledFrame = CAudioFormat::PeekAudioPacket()) &&
  579.    (retVal == HXR_NO_DATA))
  580.     {
  581. ulBytesDecoded = 0;
  582. ulSamplesProduced = 0;
  583. ulBytesProduced = 0;
  584. ulNextDecodeStartTime = m_ulLastDecodedEndTime;
  586. if (m_bNewAssembledFrame)
  587. {
  588.     LONG32 lDecodeStartOffset;
  590.     m_bNewAssembledFrame = FALSE;
  592.     // Filter uot fluctuations in time-stamps present in some poorly generated audio streams.
  593.     ulPacketBasedNextDecodeStartTime = m_InputTSConverter.Convert(pAssembledFrame->m_ulTime);
  594.     lDecodeStartOffset = ulPacketBasedNextDecodeStartTime - ulNextDecodeStartTime;
  595.     if (lDecodeStartOffset >= ((LONG32) m_ulLastFrameTime))
  596.     {
  597. ulNextDecodeStartTime = ulPacketBasedNextDecodeStartTime;
  598.     }
  600.     // Estimate audio frame time if unknown
  601.     if (pAssembledFrame->m_ulFlags & MDPCKT_HAS_UKNOWN_TIME_FLAG)
  602.     {
  603. if (CAudioRenderer::CmpTime(m_ulLastDecodedEndTime, ulNextDecodeStartTime) >= 0)
  604. {
  605.     ulNextDecodeStartTime = m_ulLastDecodedEndTime;
  607.     if (pAssembledFrame->m_ulFlags & MDPCKT_FOLLOWS_LOSS_FLAG)
  608.     {
  609. ulNextDecodeStartTime += m_ulLastFrameTime;
  610.     }
  611. }
  612.     }
  614.     // See if there was loss we need to conceal
  615.     if (pAssembledFrame->m_ulFlags & MDPCKT_FOLLOWS_LOSS_FLAG)
  616.     {
  617. if (CAudioRenderer::CmpTime(ulNextDecodeStartTime, m_ulLastDecodedEndTime) > 0)
  618. {
  619.     ULONG32 ulTimeLost = ulNextDecodeStartTime - 
  620.  m_ulLastDecodedEndTime;
  622.     if (CAudioFormat::ConvertTimeToMs(ulTimeLost) > MAX_TOLERABLE_TIME_GAP)
  623.     {
  624. ULONG32 ulSamplesLost = CAudioFormat::ConvertTimeToSamples(ulTimeLost);
  626. #ifdef ENABLE_FRAME_TRACE
  627. if (ulFrameTraceIdx < MAX_FRAME_TRACE_ENTRIES)
  628. {
  629.     frameTraceArray[ulFrameTraceIdx][2] = m_ulLastDecodedEndTime;
  630.     frameTraceArray[ulFrameTraceIdx][3] = CAudioFormat::ConvertTimeToMs(frameTraceArray[ulFrameTraceIdx][2]);
  631.     frameTraceArray[ulFrameTraceIdx][0] = 
  632. (LONG32) ulTimeLost;
  633.     frameTraceArray[ulFrameTraceIdx++][1] = 'G';
  634. }
  635. #endif // ENABLE_FRAME_TRACE
  637. // Conceal the lost samples
  638. if (m_pDecoderInstance)
  639. {
  640.     m_pDecoderInstance->Conceal(ulSamplesLost);
  641.     ulNextDecodeStartTime = m_ulLastDecodedEndTime;
  642. #ifdef ENABLE_FRAME_TRACE
  643.     if (ulFrameTraceIdx < MAX_FRAME_TRACE_ENTRIES)
  644.     {
  645. frameTraceArray[ulFrameTraceIdx][2] = ulNextDecodeStartTime;
  646. frameTraceArray[ulFrameTraceIdx][3] = CAudioFormat::ConvertTimeToMs(frameTraceArray[ulFrameTraceIdx][2]);
  647. frameTraceArray[ulFrameTraceIdx][0] = 
  648.     (LONG32) ulSamplesLost;
  649. frameTraceArray[ulFrameTraceIdx++][1] = 'C';
  650.     }
  651. #endif // ENABLE_FRAME_TRACE
  652. }
  653.     }
  654. }
  655.     }
  656. }
  659. checkStatus = CheckDecoderInstance(m_pDecoderInstance);
  660. if (FAILED(checkStatus))
  661. {
  662.     return checkStatus;
  663. }
  665.     // Decode some samples
  667. if (((CMediaPacket::GetBufferSize(pAssembledFrame) != 
  668.       pAssembledFrame->m_ulDataSize) &&
  669.      (pAssembledFrame->m_ulDataSize < MIN_ACCEPTBALE_DATA_REMAINDER))
  670. #ifdef _IGNORE_UNSUPPORTED
  671.     || (!m_pDecoderInstance)
  672. #endif // _IGNORE_UNSUPPORTED
  673.    )
  674. {
  675.     ulSamplesProduced = 0;
  676.     ulBytesDecoded = pAssembledFrame->m_ulDataSize;
  677. }
  678. else
  679. {
  680.     ulSamplesProduced = m_ulMaxDecoderOutputSamples;
  682.     ProcessAssembledFrame(pAssembledFrame);
  684.     retVal = m_pDecoderInstance->Decode(pAssembledFrame->m_pData,
  685. pAssembledFrame->m_ulDataSize,
  686. ulBytesDecoded,
  687. (INT16*) m_pDecoderBuffer,
  688. ulSamplesProduced,
  689. bFlushCodec);
  690.     if (retVal != HXR_OK)
  691.     {
  692. ulBytesDecoded = 0;
  693. ulSamplesProduced = 0;
  694.     }
  695. #ifdef ENABLE_FRAME_TRACE
  696.     if (ulFrameTraceIdx < MAX_FRAME_TRACE_ENTRIES)
  697.     {
  698. frameTraceArray[ulFrameTraceIdx][2] = ulNextDecodeStartTime;
  699. frameTraceArray[ulFrameTraceIdx][3] = CAudioFormat::ConvertTimeToMs(frameTraceArray[ulFrameTraceIdx][2]);
  700. frameTraceArray[ulFrameTraceIdx][0] = 
  701.     (LONG32) ulBytesDecoded;
  702. frameTraceArray[ulFrameTraceIdx++][1] = 'B';
  703.     }
  704.     if (ulFrameTraceIdx < MAX_FRAME_TRACE_ENTRIES)
  705.     {
  706. frameTraceArray[ulFrameTraceIdx][2] = ulNextDecodeStartTime;
  707. frameTraceArray[ulFrameTraceIdx][3] = CAudioFormat::ConvertTimeToMs(frameTraceArray[ulFrameTraceIdx][2]);
  708. frameTraceArray[ulFrameTraceIdx][0] = 
  709.     (LONG32) ulSamplesProduced;
  710. frameTraceArray[ulFrameTraceIdx++][1] = 'D';
  711.     }
  712. #endif // ENABLE_FRAME_TRACE
  713. }
  715. // Adjust ramaining data pointers based on bytes consumed
  716. HX_ASSERT(ulBytesDecoded <= pAssembledFrame->m_ulDataSize);
  717. if (ulBytesDecoded <= pAssembledFrame->m_ulDataSize)
  718. {
  719.     pAssembledFrame->m_ulDataSize -= ulBytesDecoded;
  720. }
  721. else
  722. {
  723.     pAssembledFrame->m_ulDataSize = 0;
  724. }
  725. pAssembledFrame->m_pData += ulBytesDecoded;
  727. // Place decoded data into the audio buffer
  728. if (ulSamplesProduced > 0)
  729. {
  730.     if (m_bCanChangeAudioStream && m_pDecoderInstance)
  731.     {
  732. retVal = UpdateAudioFormat(ulNextDecodeStartTime);
  733. if (FAILED(checkStatus))
  734. {
  735.     retVal = checkStatus;
  736. }
  737.     }
  739. #ifndef _SILENT_PLAY
  740.     if (SUCCEEDED(retVal))
  741.     {
  742. retVal = HXR_OK;
  744. ulBytesProduced = CAudioFormat::ConvertSamplesToBytes(ulSamplesProduced);
  746. if (retVal == HXR_OK)
  747. {
  748.     retVal = m_pCommonClassFactory->CreateInstance(
  749.     CLSID_IHXBuffer, 
  750.     (void**) &audioData.pData);
  751. }
  753. if (retVal == HXR_OK)
  754. {
  755.     retVal = audioData.pData->Set(
  756.     m_pDecoderBuffer,
  757.     ulBytesProduced);
  758. }
  760. if (retVal == HXR_OK)
  761. {
  762.     audioData.ulAudioTime = m_TSConverter.Convert(ulNextDecodeStartTime) -
  763.     m_ulCodecDelayMs;
  764. }
  765.     }
  766. #endif // _SILENT_PLAY
  767. }
  769. m_ulLastFrameTime = CAudioFormat::ConvertSamplesToTime(ulSamplesProduced);
  770. m_ulLastDecodedEndTime = ulNextDecodeStartTime + m_ulLastFrameTime;
  771.  
  772. if ((pAssembledFrame->m_ulDataSize == 0) ||
  773.     ((ulSamplesProduced == 0) && (ulBytesDecoded == 0)))
  774. {
  775.     CMediaPacket* pDeadAssembledFrame = CAudioFormat::GetAudioPacket();
  777.     HX_ASSERT(pAssembledFrame == pDeadAssembledFrame);
  779.     CMediaPacket::DeletePacket(pDeadAssembledFrame);
  780.     m_bNewAssembledFrame = TRUE;
  781. }
  783. if (ulSamplesProduced > 0)
  784. {
  785.     break;
  786. }
  787.     }
  789.     return retVal;
  790. }
  793. /****************************************************************************
  794.  *  Method:
  795.  *    CMP4AudioFormat::Reset
  796.  *
  797.  */
  798. void CMP4AudioFormat::Reset()
  799. {
  800.     _Reset();
  801.     CAudioFormat::Reset();
  802. }
  804. BOOL CMP4AudioFormat::CanChangeAudioStream()
  805. {
  806.     BOOL bRet = FALSE;
  808.     if (m_pDecoderModule)
  809.     {
  810.         bRet = m_pDecoderModule->CanChangeAudioStream();
  811.     }
  813.     return bRet;
  814. }
  816. void CMP4AudioFormat::RegisterPayloadFormats()
  817. {
  818.     // Register the various payload format builder functions
  819.     // with the payload format factory
  821. #if defined(HELIX_FEATURE_AUDIO_CODEC_AAC) || defined(HELIX_FEATURE_AUDIO_CODEC_RAAC)
  822.     // MPEG4 audio formats
  823.     m_fmtFactory.RegisterBuilder(&MP4APayloadFormat::Build);
  824. #endif // defined(HELIX_FEATURE_AUDIO_CODEC_AAC)
  826. #if defined(HELIX_FEATURE_ISMA) || defined(HELIX_FEATURE_AUDIO_RALF)
  827.     m_fmtFactory.RegisterBuilder(&MP4GPayloadFormat::Build);
  828. #endif // defined(HELIX_FEATURE_ISMA) || defined(HELIX_FEATURE_AUDIO_RALF)
  830.     // AMR formats
  831. #if defined(HELIX_FEATURE_AUDIO_CODEC_AMRNB) || defined(HELIX_FEATURE_AUDIO_CODEC_AMRWB)
  832.     m_fmtFactory.RegisterBuilder(&CAMRPayloadFormat::Build);
  833.     m_fmtFactory.RegisterBuilder(&CHXAMRPayloadFormat::Build);
  834. #endif // defined(HELIX_FEATURE_AUDIO_CODEC_AMRNB) || defined(HELIX_FEATURE_AUDIO_CODEC_AMRWB)
  836. #if defined(HELIX_FEATURE_AUDIO_CODEC_MP3)
  837.     // MP3 format
  838.     m_fmtFactory.RegisterBuilder(&CMP3DraftPayloadFormat::Build);
  839. #endif /* #if defined(HELIX_FEATURE_AUDIO_CODEC_MP3) */
  840. }
  842. void CMP4AudioFormat::_Reset(void)
  843. {
  844.     if (m_pRssm)
  845.     {
  846. m_pRssm->Reset();
  847. m_pRssm->SetTimeAnchor(GetStartTime());
  849. ConfigureRssm(GetStartTime());
  850.     }
  852.     if (m_pDecoderInstance)
  853.     {
  854. m_pDecoderInstance->Reset();
  855.     }
  857.     m_ulLastDecodedEndTime = 0;
  858.     m_ulLastFrameTime = 0;
  859.     m_bNewAssembledFrame = TRUE;
  861.     m_TSConverter.Reset();
  862.     m_TSConverter.SetOffset(GetStartTime());
  863. }