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

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

Symbian

开发平台：

C/C++

audrendf.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. // 
  38. //  audio format for QuickTime renderer for RealMedia Architecture.
  39. //
  40. // Notes:
  41. // This class puts together the audio packets and decodes the audio data.
  42. // There are still unresolved problems with this code - audio data gets
  43. // dropped. This only occurs when there is more than one frame of audio
  44. // data per packet - like MP3. Also, audio services doesn't seem to be 
  45. // releasing the audio buffers. This is a huge problem when trying to 
  46. // listen to CD quality audio for any amount of time. Another problem - 
  47. // the current implementation will not work when one audio frame spans 
  48. // multiple rtp packets. The code from the video renderer will need to be 
  49. // adapted to work with audio. The class CQTPacket does all the QuickTime
  50. // header parsing. See the notes in that file for more info on the QT header
  51. // structure.
  52. // 
  54. /****************************************************************************
  55.  *  Defines
  56.  */
  57. #define MAX_DECODE_GRANULARITY     200     // in milliseconds
  58. #define DEFAULT_AUDIO_PREROLL     2000    // in milliseconds
  59. #if defined(HELIX_FEATURE_MIN_HEAP)
  60. #define MAXIMUM_AUDIO_PREROLL     3000    // in milliseconds
  61. #else
  62. #define MAXIMUM_AUDIO_PREROLL     15000    // in milliseconds
  63. #endif
  66. /****************************************************************************
  67.  *  Includes
  68.  */
  69. #include "hlxclib/stdio.h"
  70. #include "hlxclib/string.h"
  72. // #include "netbyte.h"
  73. #include "hxtypes.h"
  74. #include "hxresult.h"
  75. #include "hxcom.h"
  76. #include "hxcomm.h"
  77. #include "hxausvc.h"
  78. #include "ihxpckts.h"
  79. #include "hxerror.h"
  81. #include "hxcore.h"
  82. #include "hxupgrd.h"
  83. #include "hxslist.h"
  84. #include "hxassert.h"
  86. #include "hxstrutl.h"
  88. #include "hxheap.h"
  90. #ifdef _DEBUG
  91. #undef HX_THIS_FILE
  92. static const char HX_THIS_FILE[] = __FILE__;
  93. #endif
  95. #include "hxtick.h"
  97. #include "audrend.h"
  98. #include "audrendf.h"
  101. /****************************************************************************
  102.  *  CAudioFormat
  103.  */
  104. /****************************************************************************
  105.  *  Constructor/Destructor
  106.  */
  107. CAudioFormat::CAudioFormat(IHXCommonClassFactory* pCommonClassFactory,
  108.    CAudioRenderer* pAudioRenderer)
  109.     : m_pCommonClassFactory(pCommonClassFactory)
  110.     , m_pContext(NULL)
  111.     , m_pPendingPacketQueue(NULL)
  112.     , m_ulForceDiscardUntilTime(NO_TIME_SET)
  113.     , m_bPostStartTime(FALSE)
  114.     , m_ulTrackStartTime(0)
  115.     , m_ulTrackEndTime(NO_TIME_SET)
  116.     , m_pAudioFmt(NULL)
  117.     , m_fCompressionRatio(1.0)
  118.     , m_ulStartTime(0)
  119.     , m_lRefCount(0)
  120. {
  121.     if (m_pCommonClassFactory)
  122.     {
  123. m_pCommonClassFactory->AddRef();
  124.     }
  126.     m_pContext = pAudioRenderer->GetContext();
  127.     if (m_pContext)
  128.     {
  129. m_pContext->AddRef();
  130.     }
  132.     // NULL out the AU String
  133.     memset(&m_szAUStr[0], 0, MAX_AUSTR_SIZE);
  134. }
  136. CAudioFormat::~CAudioFormat()
  137. {
  138.     HX_DELETE(m_pAudioFmt);
  140.     FlushQueues();    
  141.     HX_DELETE(m_pPendingPacketQueue);
  143.     HX_RELEASE(m_pCommonClassFactory);
  144.     HX_RELEASE(m_pContext);
  145. }
  148. /****************************************************************************
  149.  *  CAudioFormat::Init
  150.  */
  151. HX_RESULT CAudioFormat::Init(IHXValues* pHeader)
  152. {
  153.     HX_RESULT retVal = HXR_FAIL;
  155.     if (pHeader)
  156.     {
  157.         m_pAudioFmt = new HXAudioFormat;
  158.         if (m_pAudioFmt)
  159.         {
  160.             m_pPendingPacketQueue = new CHXSimpleList;
  161.             if (m_pPendingPacketQueue)
  162.             {
  163.                 m_pAudioFmt->uChannels       = (UINT16) GetULONG32Property(pHeader, "Channels", 1);
  164.                 m_pAudioFmt->uBitsPerSample  = (UINT16) GetULONG32Property(pHeader, "BitsPerSample", 16);
  165.                 m_pAudioFmt->ulSamplesPerSec = GetULONG32Property(pHeader, "SamplesPerSecond", 8000);
  166.                 // MaxBlockSize - default to 200ms of data
  167. #ifdef HELIX_FEATURE_FLP_AUDREND
  168.                 m_pAudioFmt->uMaxBlockSize = (UINT16)
  169.                     (((double) (m_pAudioFmt->ulSamplesPerSec)) * 
  170.                      ((double) (m_pAudioFmt->uBitsPerSample)) * 
  171.                      ((double) (m_pAudioFmt->uChannels)) *
  172.                      MAX_DECODE_GRANULARITY /
  173.                      8000.0 +
  174.                      ((double) (m_pAudioFmt->uBitsPerSample)) * // Compensate for possible round off
  175.                      ((double) (m_pAudioFmt->uChannels)) /
  176.                      8.0);
  177. #else   // HELIX_FEATURE_FLP_AUDREND
  178.                 HX_ASSERT((((UINT32) (m_pAudioFmt->ulSamplesPerSec)) * 
  179.                            ((UINT32) (m_pAudioFmt->uBitsPerSample)) * 
  180.                            ((UINT32) (m_pAudioFmt->uChannels))) < 
  181.                           (((ULONG32) 0xFFFFFFFF) / MAX_DECODE_GRANULARITY));
  183.                 m_pAudioFmt->uMaxBlockSize = (UINT16)
  184.                     (((UINT32) (m_pAudioFmt->ulSamplesPerSec)) * 
  185.                      ((UINT32) (m_pAudioFmt->uBitsPerSample)) * 
  186.                      ((UINT32) (m_pAudioFmt->uChannels)) *
  187.                      MAX_DECODE_GRANULARITY /
  188.                      8000 +
  189.                      ((UINT32) (m_pAudioFmt->uBitsPerSample)) * // Compensate for possible round off
  190.                      ((UINT32) (m_pAudioFmt->uChannels)) /
  191.                      8);
  192. #endif  // HELIX_FEATURE_FLP_AUDREND
  193.                 // Clear return value
  194.                 retVal = HXR_OK;
  195.             }
  196.         }
  197.     }
  199.     return retVal;
  200. }
  203. /****************************************************************************
  204.  *    CAudioFormat::GetDefaultPreroll
  205.  */
  206. ULONG32 CAudioFormat::GetDefaultPreroll(IHXValues* pValues)
  207. {
  208.     return DEFAULT_AUDIO_PREROLL;
  209. }
  211. ULONG32 CAudioFormat::GetMaximumPreroll(IHXValues* pValues)
  212. {
  213.     return MAXIMUM_AUDIO_PREROLL;
  214. }
  216. void CAudioFormat::FlushQueues(void)
  217. {
  218.     if (m_pPendingPacketQueue != NULL)
  219.     {
  220. CMediaPacket* pQTPkt;
  221. while (!m_pPendingPacketQueue->IsEmpty())
  222. {
  223.     // empty all of the pending packets
  224.     // and delete them
  225.     pQTPkt = (CMediaPacket*) m_pPendingPacketQueue->RemoveHead();
  226.     CMediaPacket::DeletePacket(pQTPkt);
  227. }
  228.     }
  229. }
  232. HX_RESULT CAudioFormat::GetAudioFormat(HXAudioFormat& audioFmt)
  233. {
  234.     audioFmt.uChannels = m_pAudioFmt->uChannels;
  235.     audioFmt.uBitsPerSample = m_pAudioFmt->uBitsPerSample;
  236.     audioFmt.ulSamplesPerSec = m_pAudioFmt->ulSamplesPerSec;
  237.     audioFmt.uMaxBlockSize = m_pAudioFmt->uMaxBlockSize;
  239.     return HXR_OK;
  240. }
  243. /****************************************************************************
  244.  *  CAudioFormat::Enqueue
  245.  */
  246. BOOL CAudioFormat::Enqueue(IHXPacket* pPacket)
  247. {
  248.     CMediaPacket* pFramePacket = NULL;
  249.     HX_RESULT retVal = HXR_OK;
  251.     HX_ASSERT(m_pPendingPacketQueue);
  253.     pFramePacket = CreateAssembledPacket(pPacket);
  255.     if (pFramePacket)
  256.     {
  257. m_pPendingPacketQueue->AddTail(pFramePacket);
  258.     }
  259.     
  260.     return retVal;
  261. }
  264. HX_RESULT CAudioFormat::CreateAudioFrame(HXAudioData& audioData, 
  265.  AUDIO_STATE audioState)
  266. {
  267.     HX_RESULT retVal = HXR_NO_DATA;
  268.     BOOL bTryAgain;
  270.     do
  271.     {
  272. bTryAgain = FALSE;
  274. HX_RELEASE(audioData.pData);
  275. audioData.ulAudioTime = 0;
  277. retVal = DecodeAudioData(audioData, audioState == AUDIO_END_OF_PACKETS);
  279. if (retVal == HXR_OK)
  280. {
  281.     if (AdjustAudioData(audioData))
  282.     {
  283. // once we are passed the start time, disable it as a
  284. // a requirement to prevent clipping on wrap-around
  285. m_bPostStartTime = TRUE;
  287. // if we've fulfilled the discard, reset state
  288. if ((m_ulForceDiscardUntilTime != NO_TIME_SET) && 
  289.     IsTimeGreater(audioData.ulAudioTime + 
  290.     ConvertBytesToMs(audioData.pData->GetSize()),
  291.     m_ulForceDiscardUntilTime))
  292. {
  293.     m_ulForceDiscardUntilTime = NO_TIME_SET;
  294. }
  295.     }
  296.     else
  297.     {
  298. retVal = HXR_NO_DATA;
  299. HX_RELEASE(audioData.pData);
  300. bTryAgain = TRUE;
  301.     }
  302. }
  303.     } while (bTryAgain);
  305.     return retVal;
  306. }
  309. CMediaPacket* CAudioFormat::PeekAudioPacket(void)
  310. {
  311.     CMediaPacket* pAudioPacket = NULL;
  313.     if (m_pPendingPacketQueue && (!m_pPendingPacketQueue->IsEmpty()))
  314.     {
  315. pAudioPacket = (CMediaPacket*) m_pPendingPacketQueue->GetHead();
  316.     }
  318.     return pAudioPacket;
  319. }
  322. CMediaPacket* CAudioFormat::GetAudioPacket(void)
  323. {
  324.     CMediaPacket* pAudioPacket = NULL;
  326.     if (m_pPendingPacketQueue && (!m_pPendingPacketQueue->IsEmpty()))
  327.     {
  328. pAudioPacket = (CMediaPacket*) m_pPendingPacketQueue->RemoveHead();
  329.     }
  331.     return pAudioPacket;
  332. }
  335. HX_RESULT CAudioFormat::PutAudioPacket(CMediaPacket* pMediaPacket)
  336. {
  337.     HX_RESULT retVal = HXR_FAIL;
  339.     HX_ASSERT(m_pPendingPacketQueue);
  341.     if (m_pPendingPacketQueue && pMediaPacket)
  342.     {
  343. m_pPendingPacketQueue->AddTail(pMediaPacket);
  344. retVal = HXR_OK;
  345.     }
  347.     return retVal;
  348. }
  350. CMediaPacket* CAudioFormat::CreateAssembledPacket(IHXPacket* pPayloadPacket)
  351. {
  352.     return NULL;
  353. }
  356. HX_RESULT CAudioFormat::DecodeAudioData(HXAudioData& audioData,
  357. BOOL bFlushCodec)
  358. {
  359.     return HXR_NOTIMPL;
  360. }
  362.     
  363. void CAudioFormat::DiscardAudioUntil(UINT32 ulTimestamp)
  364. {
  365.     BOOL bDone = FALSE;
  367.     // cannot equal NO_TIME_SET so we bump it up one
  368.     if (ulTimestamp == NO_TIME_SET)
  369.     {
  370. ulTimestamp += 1;
  371.     }
  373.     m_ulForceDiscardUntilTime = ulTimestamp;
  375.     // look through the re-assembled packet queue and delete data
  376.     // from there that's earlier than the discard until time
  377.     CMediaPacket* pQTPkt;
  378.     while (!m_pPendingPacketQueue->IsEmpty())
  379.     {
  380. pQTPkt = (CMediaPacket*) m_pPendingPacketQueue->GetHead();
  381. if (pQTPkt->m_ulTime >= ulTimestamp)
  382. {
  383.     break;
  384. }
  386. m_pPendingPacketQueue->RemoveHead();
  387. CMediaPacket::DeletePacket(pQTPkt);
  388.     }
  389. }
  391. void CAudioFormat::Reset(void)
  392. {
  393.     m_bPostStartTime = FALSE;
  394.     m_ulForceDiscardUntilTime = NO_TIME_SET;
  396.     FlushQueues();
  397. }
  399. void CAudioFormat::OverrideFactory(IHXCommonClassFactory* pCommonClassFactory)
  400. {
  401.     HX_ASSERT(pCommonClassFactory);
  403.     if (pCommonClassFactory)
  404.     {
  405. HX_RELEASE(m_pCommonClassFactory);
  406. m_pCommonClassFactory = pCommonClassFactory;
  407. m_pCommonClassFactory->AddRef();
  408.     }
  409. }
  411. void CAudioFormat::SetCompressionRation(double fCompressionRatio)
  412. {
  413.     HX_ASSERT(fCompressionRatio > 0.0);
  414.     
  415.     if (fCompressionRatio > 0.0)
  416.     {
  417. m_fCompressionRatio = fCompressionRatio;
  418.     }
  419. }
  422. UINT32 CAudioFormat::ConvertMsToBytes(UINT32 ulMs)
  423. {
  424. #ifdef HELIX_FEATURE_FLP_AUDREND
  425.     return (UINT32)(((double) ulMs) * 
  426.     ((double) m_pAudioFmt->uChannels) * 
  427.     ((double) m_pAudioFmt->uBitsPerSample) *
  428.     ((double) m_pAudioFmt->ulSamplesPerSec) / 
  429.     8000.0 + 
  430.     0.5);
  431. #else // HELIX_FEATURE_FLP_AUDREND
  432.     UINT32 ulBitsPerSecond = ((UINT32) m_pAudioFmt->uChannels) * 
  433.      ((UINT32) m_pAudioFmt->uBitsPerSample) *
  434.      ((UINT32) m_pAudioFmt->ulSamplesPerSec);
  436.     HX_ASSERT(ulMs < (((ULONG32) 0xFFFFF05F) / ulBitsPerSecond));
  438.     return (ulMs * ulBitsPerSecond + 4000) / 8000;
  439. #endif // HELIX_FEATURE_FLP_AUDREND
  440. }
  442. UINT32 CAudioFormat::ConvertBytesToMs(UINT32 ulBytes)
  443. {    
  444. #ifdef HELIX_FEATURE_FLP_AUDREND
  445.     return (UINT32)(((double) ulBytes) * 
  446.     8000.0 /
  447.     (((double) m_pAudioFmt->uChannels) * 
  448.      ((double) m_pAudioFmt->uBitsPerSample) *
  449.      ((double) m_pAudioFmt->ulSamplesPerSec)) + 
  450.     0.5);
  451. #else // HELIX_FEATURE_FLP_AUDREND
  452.     UINT32 ulBitsPerSecond = ((UINT32) m_pAudioFmt->uChannels) * 
  453.      ((UINT32) m_pAudioFmt->uBitsPerSample) *
  454.      ((UINT32) m_pAudioFmt->ulSamplesPerSec);
  456.     HX_ASSERT(ulBytes < 536871);
  458.     return ((ulBytes * 8000) / ulBitsPerSecond + 
  459.     ((ulBytes * 8000) % ulBitsPerSecond + (ulBitsPerSecond >> 1)) / ulBitsPerSecond);
  460. #endif // HELIX_FEATURE_FLP_AUDREND
  461. }
  463. UINT32 CAudioFormat::ConvertMsToSamples(UINT32 ulMs)
  464. {
  465. #ifdef HELIX_FEATURE_FLP_AUDREND
  466.     return (UINT32)(((double) ulMs) /
  467.     1000.0 *
  468.     ((double) m_pAudioFmt->uChannels) *
  469.     ((double) m_pAudioFmt->ulSamplesPerSec) +
  470.     0.5);
  471. #else // HELIX_FEATURE_FLP_AUDREND
  473.     UINT32 ulCombinedSamplesPerSecond = ((UINT32) m_pAudioFmt->uChannels) *
  474.         ((UINT32) m_pAudioFmt->ulSamplesPerSec);
  476.     return ((ulMs / 1000) * ulCombinedSamplesPerSecond +
  477.     ((ulMs % 1000) * ulCombinedSamplesPerSecond + 500) / 1000);
  478. #endif // HELIX_FEATURE_FLP_AUDREND
  479. }
  481. UINT32 CAudioFormat::ConvertSamplesToMs(UINT32 ulSamples)
  482. {
  483. #ifdef HELIX_FEATURE_FLP_AUDREND
  484.     return (UINT32)(((double) ulSamples) /
  485.     (((double) m_pAudioFmt->uChannels) *
  486.      ((double) m_pAudioFmt->ulSamplesPerSec)) *
  487.     1000.0 + 
  488.     0.5);
  489. #else // HELIX_FEATURE_FLP_AUDREND
  491.     UINT32 ulCombinedSamplesPerSecond = ((UINT32) m_pAudioFmt->uChannels) *
  492.         ((UINT32) m_pAudioFmt->ulSamplesPerSec);
  494.     return ((ulSamples / ulCombinedSamplesPerSecond) * 1000 +
  495.     ((ulSamples % ulCombinedSamplesPerSecond) * 1000 + 500) / ulCombinedSamplesPerSecond);
  496. #endif // HELIX_FEATURE_FLP_AUDREND
  497. }
  499. UINT32 CAudioFormat::ConvertBytesToSamples(UINT32 ulBytes)
  500. {
  501. #ifdef HELIX_FEATURE_FLP_AUDREND
  502.     return (UINT32)(((double) ulBytes) *
  503.     8.0 /
  504.     ((double) m_pAudioFmt->uBitsPerSample) +
  505.     0.5);
  506. #else // HELIX_FEATURE_FLP_AUDREND
  508.     UINT32 ulBitsPerSample = ((UINT32) m_pAudioFmt->uBitsPerSample);
  510.     return (((ulBytes / ulBitsPerSample) << 3) +
  511.     (((ulBytes % ulBitsPerSample) << 3) + (ulBitsPerSample >> 1)) / ulBitsPerSample);
  512. #endif // HELIX_FEATURE_FLP_AUDREND
  513. }
  515. UINT32 CAudioFormat::ConvertSamplesToBytes(UINT32 ulSamples)
  516. {    
  517. #ifdef HELIX_FEATURE_FLP_AUDREND
  518.     return (UINT32)(((double) ulSamples) *
  519.     ((double) m_pAudioFmt->uBitsPerSample) /
  520.     8.0 + 
  521.     0.5);
  522. #else // HELIX_FEATURE_FLP_AUDREND
  524.     UINT32 ulBitsPerSample = ((UINT32) m_pAudioFmt->uBitsPerSample);
  526.     return ((ulSamples / 8) * ulBitsPerSample +
  527.     ((ulSamples % 8) * ulBitsPerSample + 4) / 8);
  528. #endif // HELIX_FEATURE_FLP_AUDREND
  529. }
  531. UINT32 CAudioFormat::ConvertCompressedBytesToMs(UINT32 ulBytes)
  532. {
  533.     return (UINT32)(((double) ulBytes) * 
  534.     8000.0 /
  535.     ((double) m_pAudioFmt->uChannels) * 
  536.     ((double) m_pAudioFmt->uBitsPerSample) *
  537.     ((double) m_pAudioFmt->ulSamplesPerSec) *
  538.     m_fCompressionRatio +
  539.     0.5);
  540. }
  542. UINT32 CAudioFormat::ConvertMsToCompressedBytes(UINT32 ulMs)
  543. {
  544.     return (UINT32)(((double) ulMs) * 
  545.     ((double) m_pAudioFmt->uChannels) * 
  546.     ((double) m_pAudioFmt->uBitsPerSample) *
  547.     ((double) m_pAudioFmt->ulSamplesPerSec) / 
  548.     8000.0 /
  549.     m_fCompressionRatio + 
  550.     0.5);
  551. }
  553. UINT32 CAudioFormat::ConvertMsToTime(UINT32 ulMs)
  554. {
  555. #ifdef HELIX_FEATURE_FLP_AUDREND
  556.     return (UINT32)(((double) ulMs) /
  557.     1000.0 *
  558.     ((double) m_pAudioFmt->ulSamplesPerSec) +
  559.     0.5);
  560. #else // HELIX_FEATURE_FLP_AUDREND
  562.     UINT32 ulSamplesPerSec = ((UINT32) m_pAudioFmt->ulSamplesPerSec);
  564.     return ((ulMs / 1000) * ulSamplesPerSec +
  565.     ((ulMs % 1000) * ulSamplesPerSec + 500) / 1000);
  566. #endif // HELIX_FEATURE_FLP_AUDREND
  567. }
  569. UINT32 CAudioFormat::ConvertTimeToMs(UINT32 ulTime)
  570. {   
  571. #ifdef HELIX_FEATURE_FLP_AUDREND
  572.     return (UINT32)(((double) ulTime) /
  573.     ((double) m_pAudioFmt->ulSamplesPerSec) *
  574.     1000.0 + 
  575.     0.5);
  576. #else // HELIX_FEATURE_FLP_AUDREND
  578.     UINT32 ulSamplesPerSec = ((UINT32) m_pAudioFmt->ulSamplesPerSec);
  580.     return ((ulTime / ulSamplesPerSec) * 1000 +
  581.     ((ulTime % ulSamplesPerSec) * 1000 + (ulSamplesPerSec >> 1)) / ulSamplesPerSec);
  582. #endif // HELIX_FEATURE_FLP_AUDREND
  583. }
  586. BOOL CAudioFormat::ClipAudioBuffer(HXAudioData* pAudioData, 
  587.      UINT32 ulAudioTime, 
  588.      BOOL bFromStart)
  589. {
  590.     BOOL bResult = FALSE;
  591.     UINT32 ulDuration = 0;
  592.     UINT32 ulSize = 0;
  593.     UINT32 ulExtraInMs = 0;
  594.     UINT32 ulExtraInBytes = 0;
  595.     IHXBuffer* pBuffer = NULL;
  597.     HX_ASSERT(pAudioData);
  598.     HX_ASSERT(pAudioData->pData);
  600.     ulSize = (pAudioData->pData)->GetSize();
  602.     // caculate the worth of this data in ms
  603.     ulDuration = ConvertBytesToMs(ulSize);
  604.     
  605.     // trim off any extra bytes
  606.     if (bFromStart)
  607.     {
  608. HX_ASSERT(IsTimeLess(pAudioData->ulAudioTime, ulAudioTime));
  610. if (IsTimeGreater(pAudioData->ulAudioTime + ulDuration, ulAudioTime))
  611. {       
  612.     // trim off partial data
  613.     ulExtraInMs = ulAudioTime - pAudioData->ulAudioTime;
  615.     // convert to bytes
  616.     ulExtraInBytes = ConvertMsToBytes(ulExtraInMs);
  618.     // align in sample boundary
  619.     ulExtraInBytes -= (ulExtraInBytes % (m_pAudioFmt->uBitsPerSample * 
  620.        m_pAudioFmt->uChannels / 8));
  622.     m_pCommonClassFactory->CreateInstance(CLSID_IHXBuffer, 
  623. (void**) &pBuffer);
  625.     if (pBuffer)
  626.     {
  627. if (pBuffer->Set((pAudioData->pData)->GetBuffer() + ulExtraInBytes, 
  628.   ulSize - ulExtraInBytes)
  629.     == HXR_OK)
  630. {
  631.     pAudioData->pData->Release();
  633.     pAudioData->pData = pBuffer;    
  634.     pAudioData->ulAudioTime = ulAudioTime;
  636.     bResult = TRUE;
  637. }
  638. else
  639. {
  640.     pBuffer->Release();
  641. }
  642.     }
  643. }
  644.     }
  645.     else
  646.     {
  647. HX_ASSERT(IsTimeGreater(pAudioData->ulAudioTime + ulDuration, ulAudioTime));
  649. if (IsTimeLess(pAudioData->ulAudioTime, ulAudioTime))
  650. {
  651.     // trim off the extra ones
  652.     ulExtraInMs = pAudioData->ulAudioTime + ulDuration - ulAudioTime;
  654.     // convert to bytes
  655.     ulExtraInBytes = ConvertMsToBytes(ulExtraInMs);
  657.     // align in sample boundary
  658.     ulExtraInBytes -= (ulExtraInBytes % (m_pAudioFmt->uBitsPerSample * 
  659.        m_pAudioFmt->uChannels / 8));
  661.     m_pCommonClassFactory->CreateInstance(CLSID_IHXBuffer, 
  662. (void**) &pBuffer);
  664.     if (pBuffer)
  665.     {
  666. if (pBuffer->Set((pAudioData->pData)->GetBuffer(), 
  667.  ulSize - ulExtraInBytes)
  668.     == HXR_OK)
  669. {
  670.     pAudioData->pData->Release();
  672.     pAudioData->pData = pBuffer;
  674.     bResult = TRUE;
  675. }
  676. else
  677. {
  678.     pAudioData->pData;
  679. }
  680.     }   
  681. }
  682.     }
  684.     return bResult;
  685. }
  688. inline BOOL CAudioFormat::AdjustAudioData(REF(HXAudioData) audioData)
  689. {
  690.     BOOL bResult = TRUE;
  691.     UINT32 ulDuration = 0;
  692.     UINT32 ulSize = 0;
  693.     UINT32 ulExtraInMs = 0;
  694.     UINT32 ulExtraInBytes = 0;
  695.     IHXBuffer* pBuffer = NULL;
  697.     if (((!m_bPostStartTime) && (m_ulTrackStartTime != NO_TIME_SET)) || 
  698. (m_ulTrackEndTime != NO_TIME_SET) ||
  699. (m_ulForceDiscardUntilTime != NO_TIME_SET))
  700.     {
  701. ulSize = (audioData.pData)->GetSize();
  703. // caculate the worth of this data in ms
  704. ulDuration = ConvertBytesToMs(ulSize);
  706. // trim off any extra bytes
  707. if (((!m_bPostStartTime) &&
  708.      (m_ulTrackStartTime != NO_TIME_SET) && 
  709.      IsTimeLess(audioData.ulAudioTime, m_ulTrackStartTime)) ||
  710.     ((m_ulForceDiscardUntilTime != NO_TIME_SET) && 
  711.      IsTimeLess(audioData.ulAudioTime, m_ulForceDiscardUntilTime)))
  712. {
  713.     UINT32 ulStartTimeToUse = m_ulTrackStartTime;
  714.     
  715.     if (m_bPostStartTime ||
  716. (ulStartTimeToUse == NO_TIME_SET) ||
  717. IsTimeLess(m_ulTrackStartTime, m_ulForceDiscardUntilTime))
  718.     {
  719. ulStartTimeToUse = m_ulForceDiscardUntilTime;
  720.     }
  722.     bResult = ClipAudioBuffer(&audioData,
  723.       ulStartTimeToUse,
  724.       TRUE);
  725. }
  727. if ((m_ulTrackEndTime != NO_TIME_SET) &&
  728.     bResult &&
  729.     IsTimeGreater((audioData.ulAudioTime + ulDuration), m_ulTrackEndTime))
  730. {
  731.     bResult = ClipAudioBuffer(&audioData,
  732.       m_ulTrackEndTime,
  733.       FALSE);
  734. }
  735.     }
  737.     return bResult;
  738. }
  741. // *** IUnknown methods ***
  742. /****************************************************************************
  743. *  IUnknown::QueryInterface                                    ref:  hxcom.h
  744. *
  745. *  This routine indicates which interfaces this object supports. If a given
  746. *  interface is supported, the object's reference count is incremented, and
  747. *  a reference to that interface is returned. Otherwise a NULL object and
  748. *  error code are returned. This method is called by other objects to
  749. *  discover the functionality of this object.
  750. */
  751. STDMETHODIMP CAudioFormat::QueryInterface(REFIID riid, void** ppvObj)
  752. {
  753.     if (IsEqualIID(riid, IID_IUnknown))
  754.     {
  755. AddRef();
  756. *ppvObj = (IUnknown*) this;
  757. return HXR_OK;
  758.     }
  759.     
  760.     *ppvObj = NULL;
  761.     return HXR_NOINTERFACE;
  762. }
  764. /****************************************************************************
  765. *  IUnknown::AddRef                                            ref:  hxcom.h
  766. *
  767. *  This routine increases the object reference count in a thread safe
  768. *  manner. The reference count is used to manage the lifetime of an object.
  769. *  This method must be explicitly called by the user whenever a new
  770. *  reference to an object is used.
  771. */
  772. STDMETHODIMP_(ULONG32) CAudioFormat::AddRef()
  773. {
  774.     return InterlockedIncrement(&m_lRefCount);
  775. }
  777. /****************************************************************************
  778. *  IUnknown::Release                                           ref:  hxcom.h
  779. *
  780. *  This routine decreases the object reference count in a thread safe
  781. *  manner, and deletes the object if no more references to it exist. It must
  782. *  be called explicitly by the user whenever an object is no longer needed.
  783. */
  784. STDMETHODIMP_(ULONG32) CAudioFormat::Release()
  785. {
  786.     if (InterlockedDecrement(&m_lRefCount) > 0)
  787.     {
  788.         return m_lRefCount;
  789.     }
  790.     
  791.     delete this;
  792.     return 0;
  793. }
  795. UINT32 CAudioFormat::GetULONG32Property(IHXValues*  pValues,
  796.                                         const char* pszName,
  797.                                         UINT32      ulDefault)
  798. {
  799.     UINT32 ulRet = ulDefault;
  801.     if (pValues && pszName)
  802.     {
  803.         pValues->GetPropertyULONG32(pszName, ulRet);
  804.     }
  806.     return ulRet;
  807. }