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

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

Symbian

开发平台：

C/C++

audio_session-mda.cpp：源码内容
  1. /* ***** BEGIN LICENSE BLOCK ***** 
  2.  * Version: RCSL 1.0/RPSL 1.0 
  3.  *  
  4.  * Portions Copyright (c) 1995-2003 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. #if defined (HELIX_CONFIG_CALYPSO_AUDIO_PREF)
  37. #include <calypso/audiopreference.h>
  38. #endif
  39. #include <mda/common/audio.h>
  41. #include "hxcom.h"
  42. #include "hxslist.h"
  43. #include "hxausvc.h"
  44. #include "hxbuffer.h"
  45. #include "audio_session-mda.h"
  46. #include "hxtick.h"
  48. static const TInt KClientPriority = 69; //EMdaPriorityNormal;
  49. #if defined(HELIX_CONFIG_CALYPSO_AUDIO_PREF)
  50. static const TMdaPriorityPreference KPriorityPref = (TMdaPriorityPreference)KAudioPrefComposer; 
  51. #else
  52. static const TMdaPriorityPreference KPriorityPref = EMdaPriorityPreferenceTime;
  53. #endif // SERIES60_PLAYER
  55. const INT32 WriteBufferDepth = 10; // Number of buffers we allow in the queue before blocking the caller
  57. ////////////////////////////////////////////////////
  58. //
  59. static TInt FlagToNumber(TMdaAudioDataSettings::TAudioCaps flag)
  60. {
  61.     switch( flag )
  62.     {
  63.     case TMdaAudioDataSettings::ESampleRate8000Hz:
  64.         return 8000;
  65.     case TMdaAudioDataSettings::ESampleRate11025Hz:
  66.         return 11025;
  67.     case TMdaAudioDataSettings::ESampleRate16000Hz:
  68.         return 16000;
  69.     case TMdaAudioDataSettings::ESampleRate22050Hz:
  70.         return 22050;
  71.     case TMdaAudioDataSettings::ESampleRate32000Hz:
  72.         return 32000;
  73.     case TMdaAudioDataSettings::ESampleRate44100Hz:
  74.         return 44100;
  75.     case TMdaAudioDataSettings::ESampleRate48000Hz:
  76.         return 48000;
  77.     case TMdaAudioDataSettings::EChannelsMono:
  78.         return 1;
  79.     case TMdaAudioDataSettings::EChannelsStereo:
  80.         return 2;
  81.     default:
  82.         return 0;
  83.         break;
  84.     }
  85.     return 0;
  86. }
  88. static TMdaAudioDataSettings::TAudioCaps NumberToFlag(TInt num)
  89. {
  90.     switch(num)
  91.     {
  92.     case 1:
  93.         return  TMdaAudioDataSettings::EChannelsMono;
  94.     case 2:
  95.         return  TMdaAudioDataSettings::EChannelsStereo;
  96.     case 8000:
  97.         return  TMdaAudioDataSettings::ESampleRate8000Hz;
  98.     case 11025:
  99.         return  TMdaAudioDataSettings::ESampleRate11025Hz;
  100.     case 16000:
  101.         return  TMdaAudioDataSettings::ESampleRate16000Hz;
  102.     case 22050:
  103.         return  TMdaAudioDataSettings::ESampleRate22050Hz;
  104.     case 32000:
  105.         return  TMdaAudioDataSettings::ESampleRate32000Hz;
  106.     case 44100:
  107.         return  TMdaAudioDataSettings::ESampleRate44100Hz;
  108.     case 48000:
  109.         return  TMdaAudioDataSettings::ESampleRate48000Hz;
  110.     default:
  111.         return (TMdaAudioDataSettings::TAudioCaps)0;
  112.         break;
  113.     }
  114.     return (TMdaAudioDataSettings::TAudioCaps)0;
  115. }
  117. HXSymbianAudioTimeline::HXSymbianAudioTimeline()
  118. {
  119.     Reset(0);
  120. }
  122. HXSymbianAudioTimeline::~HXSymbianAudioTimeline()
  123. {}
  125. void HXSymbianAudioTimeline::Reset(UINT32 ulByteRate)
  126. {
  127.     m_ulByteRate = ulByteRate;
  129.     ClearWritten();
  131.     m_ulBaseSec = 0;
  132.     m_ulBaseSubSecBytes = 0;
  134.     m_ulLastGetTime = 0;
  135. }
  137. void HXSymbianAudioTimeline::OnWrite(UINT32 ulBytes)
  138. {
  139.     UINT32 ulSum = m_ulSubSecBytes + ulBytes;
  140.     UINT32 ulSec = ulSum / m_ulByteRate;
  142.     m_ulSecWritten += ulSec;
  143.     m_ulSubSecBytes = ulSum - (ulSec * m_ulByteRate);
  144. }
  146. UINT32 HXSymbianAudioTimeline::GetPlaybackTime()
  147. {
  148.     UINT32 ulBaseMs = GetMs(m_ulBaseSec, m_ulBaseSubSecBytes);
  149.     UINT32 ulWrittenMs = GetWrittenTime();
  150.     UINT32 ulRet = ulBaseMs;
  151.     UINT32 ulDeviceTimeMs = GetWallclockTime();
  152.     
  153.     // Only use the device time if it
  154.     // is less than the amount of data
  155.     // written
  156.     if (ulWrittenMs > ulDeviceTimeMs)
  157.     {
  158.         ulRet += ulDeviceTimeMs;
  159.     }
  160.     else
  161.     {
  162.         ulRet += ulWrittenMs;
  163.     }
  165.     // Enforce monotonically increasing return values
  166.     if (ulRet >= m_ulLastGetTime)
  167.     {
  168.         m_ulLastGetTime = ulRet;
  169.     }
  170.     else
  171.     {
  172.         ulRet = m_ulLastGetTime;
  173.     }
  175.     return ulRet;
  176. }
  178. UINT32 HXSymbianAudioTimeline::GetWrittenTime() const
  179. {
  180.     return GetMs(m_ulSecWritten, m_ulSubSecBytes);
  181. }
  184. UINT32 HXSymbianAudioTimeline::GetWallclockTime() const
  185. {
  186.     UINT32 ulRet = m_ulDevTimeMs;
  188.     if (m_ulDevTimeMs)
  189.     {
  190.         ulRet += HX_GET_TICKCOUNT() - m_ulWallclockTime;
  191.     }
  193.     return ulRet;
  194. }
  196. void HXSymbianAudioTimeline::OnPlay()
  197. {
  198.     ClearWritten();
  199. }
  201. void HXSymbianAudioTimeline::OnPauseOrUnderflow()
  202. {
  203.     // Add the written time to the base time
  204.     m_ulBaseSec += m_ulSecWritten;
  205.     m_ulBaseSubSecBytes += m_ulSubSecBytes;
  207.     // Normalize the base time values
  208.     while (m_ulBaseSubSecBytes >= m_ulByteRate)
  209.     {
  210.         m_ulBaseSec++;
  211.         m_ulBaseSubSecBytes -= m_ulByteRate;
  212.     }
  213.     
  214.     // Clear the bytes written state
  215.     ClearWritten();
  216. }
  218. BOOL HXSymbianAudioTimeline::NeedDeviceTime() const
  219. {
  220.     // We only want a device time if we don't haven't
  221.     // received a non-zero device time.
  222.     return (m_ulDevTimeMs == 0);
  223. }
  226. void HXSymbianAudioTimeline::SetDeviceTime(UINT32 ulDeviceTimeMs)
  227. {
  228.     if (NeedDeviceTime())
  229.     {
  230.         m_ulDevTimeMs = ulDeviceTimeMs;
  231.         m_ulWallclockTime = HX_GET_TICKCOUNT();
  232.     }
  233. }
  235. UINT32 HXSymbianAudioTimeline::GetMs(UINT32 ulSec, UINT32 ulSubSec) const
  236. {
  237.     UINT32 ulRet = ulSec * 1000;
  239.     if (m_ulByteRate)
  240.     {
  241.         ulRet += (ulSubSec * 1000) / m_ulByteRate;
  242.     }
  244.     return ulRet;
  245. }
  247. void HXSymbianAudioTimeline::ClearWritten()
  248. {
  249.     m_ulSecWritten = 0;
  250.     m_ulSubSecBytes = 0;
  252.     m_ulDevTimeMs = 0;
  253.     m_ulWallclockTime = 0;
  254. }
  256. //
  257. // class HXSymbianAudioSession:
  258. //
  260. //
  261. // HXSymbianAudioSession::ctor:
  262. //
  263. // add the session to the server
  264. //
  265. HXSymbianAudioSession::HXSymbianAudioSession(RThread& client,
  266.                                              HXSymbianAudioServer* pServer)
  267.     : CSession(client),
  268.       m_pServer(pServer),
  269.       m_pStream(0),
  270.       m_sampleRate(TMdaAudioDataSettings::ESampleRate8000Hz),
  271.       m_channels(TMdaAudioDataSettings::EChannelsMono),
  272.       m_pData(0, 0),
  273.       m_wantsNotify(false),
  274.       m_reason(KErrNone),
  275.       m_open(false),
  276.       m_writeComplete(true),
  277.       m_bPaused(TRUE),
  278.       m_bWritePending(FALSE)
  279. {
  280.     // add the session to the server
  281.     m_pServer->AddSession();
  282. }
  284. //
  285. // HXSymbianAudioSession::dtor
  286. //
  287. HXSymbianAudioSession::~HXSymbianAudioSession()
  288. {
  289.     DoCleanup();
  290. }
  293. //
  294. // HXSymbianAudioSession::NewL
  295. //
  296. // creates a new session
  297. //
  298. HXSymbianAudioSession* HXSymbianAudioSession::NewL(RThread& client,
  299.                                                    HXSymbianAudioServer* pServer)
  300. {
  301.     HXSymbianAudioSession* pSession =
  302.         new (ELeave) HXSymbianAudioSession(client, pServer);
  304.     return pSession;
  305. }
  307. //
  308. // HXSymbianAudioSession::ServiceL
  309. //
  310. // services a client message
  311. //
  312. void HXSymbianAudioSession::ServiceL(const RMessage& mesg)
  313. {
  314.     switch (mesg.Function()) 
  315.     {
  316.     case HXSymbianAudioServer::EAS_Init:
  317.         Init();
  318.         break;
  319.     case HXSymbianAudioServer::EAS_Play:
  320.         Play();
  321.         break;
  322.     case HXSymbianAudioServer::EAS_Pause:
  323.         Pause();
  324.         break;
  325.     case HXSymbianAudioServer::EAS_Write:
  326.         Write();
  327.         break;
  328.     case HXSymbianAudioServer::EAS_CancelWrite:
  329.         if (!m_writeComplete)
  330.         {
  331.             m_writeComplete = true;
  332.             m_writeMessage.Complete(KErrCancel);
  333.         }
  334.         mesg.Complete(KErrNone);
  335.         break;
  336.     case HXSymbianAudioServer::EAS_GetTime:
  337.         GetTime();
  338.         break;
  339.     case HXSymbianAudioServer::EAS_GetBlocksBuffered:
  340.         GetBlocksBuffered();
  341.         break;
  342.     case HXSymbianAudioServer::EAS_SetVolume:
  343.         SetVolume();
  344.         break;
  345.     case HXSymbianAudioServer::EAS_GetVolume:
  346.         GetVolume();
  347.         break;
  348.     case HXSymbianAudioServer::EAS_GetMaxVolume:
  349.         GetMaxVolume();
  350.         break;
  351.     case HXSymbianAudioServer::EAS_GetMinVolume:
  352.         GetMinVolume();
  353.         break;
  354.     case HXSymbianAudioServer::EAS_Stop:
  355.         Stop();
  356.         break;
  357.     case HXSymbianAudioServer::EAS_RequestDeviceTakenNotification:
  358.         RequestDeviceTakenNotification();
  359.         break;
  360.     case HXSymbianAudioServer::EAS_CancelDeviceTakenNotification:
  361.         CancelDeviceTakenNotification();
  362.         break;
  363.     default:
  364.         mesg.Complete(KErrNotSupported);
  365.         break;
  366.     }
  367. }
  369. //
  370. // HXSymbianAudioSession::Init
  371. //
  372. // 1. Matches input sample rate to output sample rate
  373. //    by building a sample rate converter, if necessary.
  374. // 2. Opens and initializes the audio device.
  375. //
  376. void HXSymbianAudioSession::Init()
  377. {
  378.     TInt err = KErrNone;
  380.     // translate the audio props to flags needed by interface
  381.     m_sampleRate = NumberToFlag(Message().Int0());
  382.     m_channels   = NumberToFlag(Message().Int1());
  384.     m_timeline.Reset(GetByteRate());
  385.     m_bPaused = TRUE;
  387.     if (m_open)
  388.     {
  389.         TRAP(err, m_pStream->SetAudioPropertiesL(m_sampleRate,
  390.                                                  m_channels));
  392.         Message().Complete(err);
  393.     }
  394.     else 
  395.     {
  396.         TRAP(err, (m_pStream = CMdaAudioOutputStream::NewL(*this)));
  398.         if(KErrNone == err)
  399.         {
  400.             // open the audio device
  401.             m_settings.iSampleRate = m_sampleRate;
  402.             m_settings.iChannels = m_channels;
  403.             m_settings.iVolume = m_pStream->MaxVolume()/2;
  404.             m_settings.iFlags = 0;
  405.             m_pStream->Open(&m_settings);
  406.         }
  407.         else
  408.         {
  409.             Message().Complete(err);
  410.         }
  411.     }
  412. }
  414. void HXSymbianAudioSession::DoCleanup()
  415. {
  416.     while(!m_bufferList.IsEmpty())
  417.     {
  418.         IHXBuffer* pBuf = (IHXBuffer*)m_bufferList.RemoveHead();
  419.         HX_RELEASE(pBuf);
  420.     }
  422.     if (m_wantsNotify)
  423.     {
  424.         m_notifyRequest.Complete(KErrCancel);
  425.         m_wantsNotify = false;
  426.     }
  428.     if (m_pStream)
  429.     {
  430.         m_pStream->Stop();
  431.         delete m_pStream;
  432.         m_pStream = 0;
  433.         m_open = false;
  434.     }
  436.     // remove session from server
  437.     if( m_pServer)
  438.     {
  439.         m_pServer->DelSession();
  440.         m_pServer = 0;
  441.     }
  442. }
  444. //
  445. // HXSymbianAudioSession::Play
  446. //
  447. void HXSymbianAudioSession::Play()
  448. {
  449.     if (m_reason != KErrNone)
  450.         m_reason = KErrNone;
  452.     // reset audio properties in case they changed on us
  453.     TRAPD(error, m_pStream->SetAudioPropertiesL(m_sampleRate,
  454.                                                 m_channels));
  455.     m_pStream->SetPriority(KClientPriority, KPriorityPref);
  456.     m_timeline.OnPlay();
  457.     m_bPaused = FALSE;
  459.     if (ReadyToWrite())
  460.     {
  461.         error = WriteNextBuffer();
  462.     }
  464.     Message().Complete(error);
  465. }
  467. //
  468. // HXSymbianAudioSession::Pause
  469. //
  470. void HXSymbianAudioSession::Pause()
  471. {
  472.     m_timeline.OnPauseOrUnderflow();
  473.     m_bPaused = TRUE;
  475.     if (m_pStream)
  476.     {
  477.         m_pStream->Stop();
  478.     }
  479.     Message().Complete(KErrNone);
  480. }
  482. //
  483. // HXSymbianAudioSession::Write
  484. //
  485. //
  486. void HXSymbianAudioSession::Write()
  487. {
  488.     TInt result = KErrArgument;
  489.     IHXBuffer* pAudioBuf = (IHXBuffer*)Message().Ptr0();
  491.     if (pAudioBuf)
  492.     {
  493.         if (m_bufferList.AddTail(pAudioBuf))
  494.         {
  495.             pAudioBuf->AddRef();
  497.             if (ReadyToWrite())
  498.             {
  499.                 result = WriteNextBuffer();
  501.                 if (KErrNone != result)
  502.                 {
  503.                     // Remove the buffer we just appended
  504.                     // to the list
  505.                     m_bufferList.RemoveTail();
  507.                     // Release our reference to the buffer
  508.                     HX_RELEASE(pAudioBuf);
  509.                 }
  510.             }
  511.             else
  512.             {
  513.                 result = KErrNone;
  514.             }
  515.         }
  516.         else
  517.         {
  518.             result = KErrNoMemory;
  519.         }
  520.         
  521.     }
  523.     if( m_bufferList.GetCount() < WriteBufferDepth ||
  524.         KErrNone != result )
  525.     {
  526.         //We have slots free and no errors so we can complete the
  527.         //message.
  528.         m_writeComplete = true;
  529.         Message().Complete(result);
  530.     }
  531.     else
  532.     {
  533.         // We need to delay notifying the caller until the current
  534.         // write completes
  535.         m_writeComplete = false;
  536.         m_writeMessage = Message();
  537.     }
  538.     
  539. }
  541. //
  542. // HXSymbianAudioSession::GetTime
  543. //
  544. // Return the current playback position -- converts from
  545. // microseconds to milliseconds
  546. //
  547. void HXSymbianAudioSession::GetTime()
  548. {
  549.     Message().Complete(m_timeline.GetPlaybackTime());
  550. }
  553. //
  554. // HXSymbianAudioSession::GetBlocksBuffered
  555. //
  556. // Return the number of blocks buffered by this object.
  557. //
  558. void HXSymbianAudioSession::GetBlocksBuffered()
  559. {
  560.     Message().Complete(m_bufferList.GetCount());
  561. }
  563. //
  564. // HXSymbianAudioSession::SetVolume
  565. //
  566. // set the volume -- convert from 0-100 to 0-max range
  567. //
  568. void HXSymbianAudioSession::SetVolume()
  569. {
  570.     if (m_pStream)
  571.     {
  572.         m_pStream->SetVolume(Message().Int0());
  573.     }
  574.     Message().Complete(0);
  575. }
  577. //
  578. // HXSymbianAudioSession::GetVolume
  579. //
  580. // get the current volume normalized to 0-100 range
  581. //
  582. void HXSymbianAudioSession::GetVolume()
  583. {
  584.     TInt vol = 0;
  585.     if (m_pStream)
  586.     {
  587.         vol = m_pStream->Volume();
  588.     }
  589.     Message().Complete(vol);
  590. }
  592. //
  593. // HXSymbianAudioSession::GetMaxVolume
  594. //
  595. // get the maxium device volume
  596. //
  597. void HXSymbianAudioSession::GetMaxVolume()
  598. {
  599.     TInt maxVol = 0;
  600.     if (m_pStream)
  601.     {
  602.         maxVol = m_pStream->MaxVolume();
  603.     }
  605.     Message().Complete(maxVol);
  606. }
  608. //
  609. // HXSymbianAudioSession::GetMinVolume
  610. //
  611. // get the minimum device volume
  612. //
  613. void HXSymbianAudioSession::GetMinVolume()
  614. {
  615.     Message().Complete(0);
  616. }
  619. //
  620. // HXSymbianAudioSession::Stop
  621. //
  622. // stop playback
  623. //
  624. void HXSymbianAudioSession::Stop()
  625. {
  626.     m_bPaused = TRUE;
  627.     if(m_pStream)
  628.     {
  629.         m_pStream->Stop();
  630.     }
  631.     
  632.     // Cleanup any remaining buffers
  633.     while(!m_bufferList.IsEmpty())
  634.     {
  635.         IHXBuffer* pBuf = (IHXBuffer*)m_bufferList.RemoveHead();
  636.         HX_RELEASE(pBuf);
  637.     }
  639.     m_timeline.Reset(GetByteRate());
  641.     Message().Complete(KErrNone);
  642. }
  644. void
  645. HXSymbianAudioSession::RequestDeviceTakenNotification()
  646. {
  647.     m_wantsNotify = true;
  648.     m_notifyRequest = Message();
  649. }
  651. void
  652. HXSymbianAudioSession::CancelDeviceTakenNotification()
  653. {
  654.     if (m_wantsNotify)
  655.     {
  656.         m_notifyRequest.Complete(KErrCancel);
  657.         m_wantsNotify = false;
  658.     }
  659. }
  661. //
  662. // HXSymbianAudioSession::NotifyDeviceTaken
  663. //
  664. // notify the client that the audio device has been taken if a
  665. // notification requrest has been made 
  666. //
  667. void HXSymbianAudioSession::NotifyDeviceTaken()
  668. {
  669.     if (m_wantsNotify)
  670.     {
  671.         m_notifyRequest.Complete(m_reason);
  672.         m_wantsNotify = false;
  673.     }
  674. }
  676. //
  677. // callbacks
  678. //
  680. void HXSymbianAudioSession::MaoscOpenComplete(TInt error)
  681. {
  682.     if (error == KErrNone)
  683.     {
  684.         m_open = true;
  686.         TRAP(error, m_pStream->SetAudioPropertiesL(m_sampleRate,
  687.                                                    m_channels));
  688.         m_pStream->SetPriority(KClientPriority, KPriorityPref);
  689.     }
  691.     Message().Complete(error);
  692. }
  694. void HXSymbianAudioSession::MaoscBufferCopied(TInt error, const TDesC8& buf)
  695. {
  696.     m_bWritePending = FALSE;
  698.     // Check to see if we need a device time
  699.     if (m_timeline.NeedDeviceTime())
  700.     {
  701.         m_timeline.SetDeviceTime(GetDeviceMs());
  702.     }
  704.     if (!m_bufferList.IsEmpty())
  705.     {
  706.         // We should always enter here because the
  707.         // last buffer written is at the head of the list.
  709.         // We want to remove this buffer from the list since
  710.         // this call is the completion of last WriteL() call.
  711.         IHXBuffer* pBuf = (IHXBuffer*)m_bufferList.RemoveHead();
  712.         HX_RELEASE(pBuf);
  713.     }
  715.     if (ReadyToWrite())
  716.     {
  717.         error = WriteNextBuffer();
  718.     }
  720.     if( !m_writeComplete &&
  721.         (m_bufferList.GetCount() < WriteBufferDepth))
  722.     {
  723.         m_writeComplete = true;
  724.         m_writeMessage.Complete(error);
  725.     }
  727.     
  728. }
  730. void HXSymbianAudioSession::MaoscPlayComplete(TInt error)
  731. {
  732.     if (KErrUnderflow == error)
  733.     {
  734.         m_timeline.OnPauseOrUnderflow();
  735.     }
  737.     //If the media server is stopping for any reason make sure we
  738.     //honor any outstanding completes.
  739.     if( !m_writeComplete )
  740.     {
  741.         m_writeComplete = true;
  742.         m_writeMessage.Complete(error);
  743.     }
  745.     int resetErr;
  746.     TRAP(resetErr, m_pStream->SetAudioPropertiesL(m_sampleRate,
  747.                                                   m_channels));
  748.     m_pStream->SetPriority(KClientPriority, KPriorityPref);
  750.     if (error == KErrAbort)
  751.     {
  752.         m_reason = error;
  753.         m_pServer->NotifyDeviceTaken();
  754.     }
  756. }
  758. UINT32 HXSymbianAudioSession::GetByteRate() const
  759. {
  760.     return 2 * FlagToNumber(m_sampleRate) * FlagToNumber(m_channels);
  761. }
  764. UINT32 HXSymbianAudioSession::GetDeviceMs()
  765. {
  766.     UINT32 ulRet = 0;
  768.     if (m_pStream)
  769.     {
  770.         TTimeIntervalMicroSeconds pos = m_pStream->Position();
  771.         TInt64 millisecs = pos.Int64() / 1000;
  772.    
  773.         ulRet = millisecs.Low();
  774.     }
  776.     return ulRet;
  777. }
  779. BOOL HXSymbianAudioSession::ReadyToWrite() const
  780. {
  781.     return !m_bWritePending && !m_bPaused && !m_bufferList.IsEmpty();
  782. }
  784. TInt HXSymbianAudioSession::WriteNextBuffer()
  785. {
  786.     // Write the next buffer in the list
  787.     IHXBuffer* pBuffer = (IHXBuffer*)m_bufferList.GetHead();
  789.     TInt result = KErrNone;
  791.     if (pBuffer)
  792.     {
  793.         if( m_pStream )
  794.         {
  795.             int len = pBuffer->GetSize();
  796.             m_pData.Set((TUint8*)pBuffer->GetBuffer(), len, len);
  797.             TRAP(result, m_pStream->WriteL(m_pData));
  798.         }
  799.         else
  800.         {
  801.             // oom earlier?
  802.             result = KErrNotReady;
  803.         }
  804.     }
  806.     if (KErrNone == result)
  807.     {
  808.         m_timeline.OnWrite(pBuffer->GetSize());
  809.         m_bWritePending = TRUE;
  810.     }
  811.     else
  812.     {
  813.         m_bWritePending = FALSE;
  814.     }
  816.     return result;
  817. }