Category

Development Platform
Home > SourceCode/Document > Communication-Mobile > Symbian > View Code
audio_session-mda.cpp
Package: 142_61_thumb_advanced.rar　[view]
Upload User: dangjiwu
Upload Date: 2013-07-19
Package Size: 42019k
Code Size: 19k
Category:

Symbian

Development Platform:

Visual C++

audio_session-mda.cpp：Code Content
  1. /* ***** BEGIN LICENSE BLOCK *****
  2.  * Source last modified: $Id: audio_session-mda.cpp,v 1.2.2.6 2004/07/09 02:01:29 hubbe Exp $
  3.  * 
  4.  * Portions Copyright (c) 1995-2004 RealNetworks, Inc. All Rights Reserved.
  5.  * 
  6.  * The contents of this file, and the files included with this file,
  7.  * are subject to the current version of the RealNetworks Public
  8.  * Source License (the "RPSL") available at
  9.  * http://www.helixcommunity.org/content/rpsl unless you have licensed
  10.  * the file under the current version of the RealNetworks Community
  11.  * Source License (the "RCSL") available at
  12.  * http://www.helixcommunity.org/content/rcsl, in which case the RCSL
  13.  * will apply. You may also obtain the license terms directly from
  14.  * RealNetworks.  You may not use this file except in compliance with
  15.  * the RPSL or, if you have a valid RCSL with RealNetworks applicable
  16.  * to this file, the RCSL.  Please see the applicable RPSL or RCSL for
  17.  * the rights, obligations and limitations governing use of the
  18.  * contents of the file.
  19.  * 
  20.  * Alternatively, the contents of this file may be used under the
  21.  * terms of the GNU General Public License Version 2 or later (the
  22.  * "GPL") in which case the provisions of the GPL are applicable
  23.  * instead of those above. If you wish to allow use of your version of
  24.  * this file only under the terms of the GPL, and not to allow others
  25.  * to use your version of this file under the terms of either the RPSL
  26.  * or RCSL, indicate your decision by deleting the provisions above
  27.  * and replace them with the notice and other provisions required by
  28.  * the GPL. If you do not delete the provisions above, a recipient may
  29.  * use your version of this file under the terms of any one of the
  30.  * RPSL, the RCSL or the GPL.
  31.  * 
  32.  * This file is part of the Helix DNA Technology. RealNetworks is the
  33.  * developer of the Original Code and owns the copyrights in the
  34.  * portions it created.
  35.  * 
  36.  * This file, and the files included with this file, is distributed
  37.  * and made available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY
  38.  * KIND, EITHER EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS
  39.  * ALL SUCH WARRANTIES, INCLUDING WITHOUT LIMITATION, ANY WARRANTIES
  40.  * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, QUIET
  41.  * ENJOYMENT OR NON-INFRINGEMENT.
  42.  * 
  43.  * Technology Compatibility Kit Test Suite(s) Location:
  44.  *    http://www.helixcommunity.org/content/tck
  45.  * 
  46.  * Contributor(s):
  47.  * 
  48.  * ***** END LICENSE BLOCK ***** */
  50. #if defined (HELIX_CONFIG_CALYPSO_AUDIO_PREF)
  51. #include <calypso/audiopreference.h>
  52. #endif
  53. #include <mda/common/audio.h>
  55. #include "hxcom.h"
  56. #include "hxslist.h"
  57. #include "hxausvc.h"
  58. #include "hxbuffer.h"
  59. #include "audio_session-mda.h"
  60. #include "hxtick.h"
  62. static const TInt KClientPriority = 69; //EMdaPriorityNormal;
  63. #if defined(HELIX_CONFIG_CALYPSO_AUDIO_PREF)
  64. static const TMdaPriorityPreference KPriorityPref = (TMdaPriorityPreference)KAudioPrefComposer; 
  65. #else
  66. static const TMdaPriorityPreference KPriorityPref = EMdaPriorityPreferenceTime;
  67. #endif // SERIES60_PLAYER
  69. const INT32 WriteBufferDepth = 10; // Number of buffers we allow in the queue before blocking the caller
  71. ////////////////////////////////////////////////////
  72. //
  73. static TInt FlagToNumber(TMdaAudioDataSettings::TAudioCaps flag)
  74. {
  75.     switch( flag )
  76.     {
  77.     case TMdaAudioDataSettings::ESampleRate8000Hz:
  78.         return 8000;
  79.     case TMdaAudioDataSettings::ESampleRate11025Hz:
  80.         return 11025;
  81.     case TMdaAudioDataSettings::ESampleRate16000Hz:
  82.         return 16000;
  83.     case TMdaAudioDataSettings::ESampleRate22050Hz:
  84.         return 22050;
  85.     case TMdaAudioDataSettings::ESampleRate32000Hz:
  86.         return 32000;
  87.     case TMdaAudioDataSettings::ESampleRate44100Hz:
  88.         return 44100;
  89.     case TMdaAudioDataSettings::ESampleRate48000Hz:
  90.         return 48000;
  91.     case TMdaAudioDataSettings::EChannelsMono:
  92.         return 1;
  93.     case TMdaAudioDataSettings::EChannelsStereo:
  94.         return 2;
  95.     default:
  96.         return 0;
  97.         break;
  98.     }
  99.     return 0;
  100. }
  102. static TMdaAudioDataSettings::TAudioCaps NumberToFlag(TInt num)
  103. {
  104.     switch(num)
  105.     {
  106.     case 1:
  107.         return  TMdaAudioDataSettings::EChannelsMono;
  108.     case 2:
  109.         return  TMdaAudioDataSettings::EChannelsStereo;
  110.     case 8000:
  111.         return  TMdaAudioDataSettings::ESampleRate8000Hz;
  112.     case 11025:
  113.         return  TMdaAudioDataSettings::ESampleRate11025Hz;
  114.     case 16000:
  115.         return  TMdaAudioDataSettings::ESampleRate16000Hz;
  116.     case 22050:
  117.         return  TMdaAudioDataSettings::ESampleRate22050Hz;
  118.     case 32000:
  119.         return  TMdaAudioDataSettings::ESampleRate32000Hz;
  120.     case 44100:
  121.         return  TMdaAudioDataSettings::ESampleRate44100Hz;
  122.     case 48000:
  123.         return  TMdaAudioDataSettings::ESampleRate48000Hz;
  124.     default:
  125.         return (TMdaAudioDataSettings::TAudioCaps)0;
  126.         break;
  127.     }
  128.     return (TMdaAudioDataSettings::TAudioCaps)0;
  129. }
  131. HXSymbianAudioTimeline::HXSymbianAudioTimeline()
  132. {
  133.     Reset(0);
  134. }
  136. HXSymbianAudioTimeline::~HXSymbianAudioTimeline()
  137. {}
  139. void HXSymbianAudioTimeline::Reset(UINT32 ulByteRate)
  140. {
  141.     m_ulByteRate = ulByteRate;
  143.     ClearWritten();
  145.     m_ulBaseSec = 0;
  146.     m_ulBaseSubSecBytes = 0;
  148.     m_ulLastGetTime = 0;
  149. }
  151. void HXSymbianAudioTimeline::OnWrite(UINT32 ulBytes)
  152. {
  153.     UINT32 ulSum = m_ulSubSecBytes + ulBytes;
  154.     UINT32 ulSec = ulSum / m_ulByteRate;
  156.     m_ulSecWritten += ulSec;
  157.     m_ulSubSecBytes = ulSum - (ulSec * m_ulByteRate);
  158. }
  160. UINT32 HXSymbianAudioTimeline::GetPlaybackTime()
  161. {
  162.     UINT32 ulBaseMs = GetMs(m_ulBaseSec, m_ulBaseSubSecBytes);
  163.     UINT32 ulWrittenMs = GetWrittenTime();
  164.     UINT32 ulRet = ulBaseMs;
  165.     UINT32 ulDeviceTimeMs = GetWallclockTime();
  166.     
  167.     // Only use the device time if it
  168.     // is less than the amount of data
  169.     // written
  170.     if (ulWrittenMs > ulDeviceTimeMs)
  171.     {
  172.         ulRet += ulDeviceTimeMs;
  173.     }
  174.     else
  175.     {
  176.         ulRet += ulWrittenMs;
  177.     }
  179.     // Enforce monotonically increasing return values
  180.     if (ulRet >= m_ulLastGetTime)
  181.     {
  182.         m_ulLastGetTime = ulRet;
  183.     }
  184.     else
  185.     {
  186.         ulRet = m_ulLastGetTime;
  187.     }
  189.     return ulRet;
  190. }
  192. UINT32 HXSymbianAudioTimeline::GetWrittenTime() const
  193. {
  194.     return GetMs(m_ulSecWritten, m_ulSubSecBytes);
  195. }
  198. UINT32 HXSymbianAudioTimeline::GetWallclockTime() const
  199. {
  200.     UINT32 ulRet = m_ulDevTimeMs;
  202.     if (m_ulDevTimeMs)
  203.     {
  204.         ulRet += HX_GET_TICKCOUNT() - m_ulWallclockTime;
  205.     }
  207.     return ulRet;
  208. }
  210. void HXSymbianAudioTimeline::OnPlay()
  211. {
  212.     ClearWritten();
  213. }
  215. void HXSymbianAudioTimeline::OnPauseOrUnderflow()
  216. {
  217.     // Add the written time to the base time
  218.     m_ulBaseSec += m_ulSecWritten;
  219.     m_ulBaseSubSecBytes += m_ulSubSecBytes;
  221.     // Normalize the base time values
  222.     while (m_ulBaseSubSecBytes >= m_ulByteRate)
  223.     {
  224.         m_ulBaseSec++;
  225.         m_ulBaseSubSecBytes -= m_ulByteRate;
  226.     }
  227.     
  228.     // Clear the bytes written state
  229.     ClearWritten();
  230. }
  232. BOOL HXSymbianAudioTimeline::NeedDeviceTime() const
  233. {
  234.     // We only want a device time if we don't haven't
  235.     // received a non-zero device time.
  236.     return (m_ulDevTimeMs == 0);
  237. }
  240. void HXSymbianAudioTimeline::SetDeviceTime(UINT32 ulDeviceTimeMs)
  241. {
  242.     if (NeedDeviceTime())
  243.     {
  244.         m_ulDevTimeMs = ulDeviceTimeMs;
  245.         m_ulWallclockTime = HX_GET_TICKCOUNT();
  246.     }
  247. }
  249. UINT32 HXSymbianAudioTimeline::GetMs(UINT32 ulSec, UINT32 ulSubSec) const
  250. {
  251.     UINT32 ulRet = ulSec * 1000;
  253.     if (m_ulByteRate)
  254.     {
  255.         ulRet += (ulSubSec * 1000) / m_ulByteRate;
  256.     }
  258.     return ulRet;
  259. }
  261. void HXSymbianAudioTimeline::ClearWritten()
  262. {
  263.     m_ulSecWritten = 0;
  264.     m_ulSubSecBytes = 0;
  266.     m_ulDevTimeMs = 0;
  267.     m_ulWallclockTime = 0;
  268. }
  270. //
  271. // class HXSymbianAudioSession:
  272. //
  274. //
  275. // HXSymbianAudioSession::ctor:
  276. //
  277. // add the session to the server
  278. //
  279. HXSymbianAudioSession::HXSymbianAudioSession(RThread& client,
  280.                                              HXSymbianAudioServer* pServer)
  281.     : CSession(client),
  282.       m_pServer(pServer),
  283.       m_pStream(0),
  284.       m_sampleRate(TMdaAudioDataSettings::ESampleRate8000Hz),
  285.       m_channels(TMdaAudioDataSettings::EChannelsMono),
  286.       m_pData(0, 0),
  287.       m_wantsNotify(false),
  288.       m_reason(KErrNone),
  289.       m_open(false),
  290.       m_bPaused(TRUE),
  291.       m_bWritePending(FALSE)
  292. {
  293.     // add the session to the server
  294.     m_pServer->AddSession();
  295. }
  297. //
  298. // HXSymbianAudioSession::dtor
  299. //
  300. HXSymbianAudioSession::~HXSymbianAudioSession()
  301. {
  302.     DoCleanup();
  303. }
  306. //
  307. // HXSymbianAudioSession::NewL
  308. //
  309. // creates a new session
  310. //
  311. HXSymbianAudioSession* HXSymbianAudioSession::NewL(RThread& client,
  312.                                                    HXSymbianAudioServer* pServer)
  313. {
  314.     HXSymbianAudioSession* pSession =
  315.         new (ELeave) HXSymbianAudioSession(client, pServer);
  317.     return pSession;
  318. }
  320. //
  321. // HXSymbianAudioSession::ServiceL
  322. //
  323. // services a client message
  324. //
  325. void HXSymbianAudioSession::ServiceL(const RMessage& mesg)
  326. {
  327.     switch (mesg.Function()) 
  328.     {
  329.     case HXSymbianAudioServer::EAS_Init:
  330.         Init();
  331.         break;
  332.     case HXSymbianAudioServer::EAS_Play:
  333.         Play();
  334.         break;
  335.     case HXSymbianAudioServer::EAS_Pause:
  336.         Pause();
  337.         break;
  338.     case HXSymbianAudioServer::EAS_Write:
  339.         Write();
  340.         break;
  341.     case HXSymbianAudioServer::EAS_CancelWrite:
  342.         mesg.Complete(KErrNone);
  343.         break;
  344.     case HXSymbianAudioServer::EAS_GetTime:
  345.         GetTime();
  346.         break;
  347.     case HXSymbianAudioServer::EAS_GetBlocksBuffered:
  348.         GetBlocksBuffered();
  349.         break;
  350.     case HXSymbianAudioServer::EAS_SetVolume:
  351.         SetVolume();
  352.         break;
  353.     case HXSymbianAudioServer::EAS_GetVolume:
  354.         GetVolume();
  355.         break;
  356.     case HXSymbianAudioServer::EAS_GetMaxVolume:
  357.         GetMaxVolume();
  358.         break;
  359.     case HXSymbianAudioServer::EAS_GetMinVolume:
  360.         GetMinVolume();
  361.         break;
  362.     case HXSymbianAudioServer::EAS_Stop:
  363.         Stop();
  364.         break;
  365.     case HXSymbianAudioServer::EAS_RequestDeviceTakenNotification:
  366.         RequestDeviceTakenNotification();
  367.         break;
  368.     case HXSymbianAudioServer::EAS_CancelDeviceTakenNotification:
  369.         CancelDeviceTakenNotification();
  370.         break;
  371.     default:
  372.         mesg.Complete(KErrNotSupported);
  373.         break;
  374.     }
  375. }
  377. //
  378. // HXSymbianAudioSession::Init
  379. //
  380. // 1. Matches input sample rate to output sample rate
  381. //    by building a sample rate converter, if necessary.
  382. // 2. Opens and initializes the audio device.
  383. //
  384. void HXSymbianAudioSession::Init()
  385. {
  386.     TInt err = KErrNone;
  388.     // translate the audio props to flags needed by interface
  389.     m_sampleRate = NumberToFlag(Message().Int0());
  390.     m_channels   = NumberToFlag(Message().Int1());
  392.     m_timeline.Reset(GetByteRate());
  393.     m_bPaused = TRUE;
  395.     if (m_open)
  396.     {
  397.         TRAP(err, m_pStream->SetAudioPropertiesL(m_sampleRate,
  398.                                                  m_channels));
  400.         Message().Complete(err);
  401.     }
  402.     else 
  403.     {
  404.         TRAP(err, (m_pStream = CMdaAudioOutputStream::NewL(*this)));
  406.         if(KErrNone == err)
  407.         {
  408.             // open the audio device
  409.             m_settings.iSampleRate = m_sampleRate;
  410.             m_settings.iChannels = m_channels;
  411.             m_settings.iVolume = m_pStream->MaxVolume()/2;
  412.             m_settings.iFlags = 0;
  413.             m_pStream->Open(&m_settings);
  414.         }
  415.         else
  416.         {
  417.             Message().Complete(err);
  418.         }
  419.     }
  420. }
  422. void HXSymbianAudioSession::DoCleanup()
  423. {
  424.     while(!m_bufferList.IsEmpty())
  425.     {
  426.         IHXBuffer* pBuf = (IHXBuffer*)m_bufferList.RemoveHead();
  427.         HX_RELEASE(pBuf);
  428.     }
  430.     if (m_wantsNotify)
  431.     {
  432.         m_notifyRequest.Complete(KErrCancel);
  433.         m_wantsNotify = false;
  434.     }
  436.     if (m_pStream)
  437.     {
  438.         m_pStream->Stop();
  439.         delete m_pStream;
  440.         m_pStream = 0;
  441.         m_open = false;
  442.     }
  444.     // remove session from server
  445.     if( m_pServer)
  446.     {
  447.         m_pServer->DelSession();
  448.         m_pServer = 0;
  449.     }
  450. }
  452. //
  453. // HXSymbianAudioSession::Play
  454. //
  455. void HXSymbianAudioSession::Play()
  456. {
  457.     if (m_reason != KErrNone)
  458.         m_reason = KErrNone;
  460.     // reset audio properties in case they changed on us
  461.     TRAPD(error, m_pStream->SetAudioPropertiesL(m_sampleRate,
  462.                                                 m_channels));
  463.     m_pStream->SetPriority(KClientPriority, KPriorityPref);
  464.     m_timeline.OnPlay();
  465.     m_bPaused = FALSE;
  467.     if (ReadyToWrite())
  468.     {
  469.         error = WriteNextBuffer();
  470.     }
  472.     Message().Complete(error);
  473. }
  475. //
  476. // HXSymbianAudioSession::Pause
  477. //
  478. void HXSymbianAudioSession::Pause()
  479. {
  480.     m_timeline.OnPauseOrUnderflow();
  481.     m_bPaused = TRUE;
  483.     if (m_pStream)
  484.     {
  485.         m_pStream->Stop();
  486.     }
  487.     Message().Complete(KErrNone);
  488. }
  490. //
  491. // HXSymbianAudioSession::Write
  492. //
  493. //
  494. void HXSymbianAudioSession::Write()
  495. {
  496.     TInt result = KErrArgument;
  497.     IHXBuffer* pAudioBuf = (IHXBuffer*)Message().Ptr0();
  499.     if (pAudioBuf)
  500.     {
  501.         if (m_bufferList.AddTail(pAudioBuf))
  502.         {
  503.             if (ReadyToWrite())
  504.             {
  505.                 result = WriteNextBuffer();
  507.                 if (KErrNone != result)
  508.                 {
  509.                     // Remove the buffer we just appended
  510.                     // to the list
  511.                     m_bufferList.RemoveTail();
  513.                     // Release our reference to the buffer
  514.                     HX_RELEASE(pAudioBuf);
  515.                 }
  516.             }
  517.             else
  518.             {
  519.                 result = KErrNone;
  520.             }
  521.         }
  522.         else
  523.         {
  524.             result = KErrNoMemory;
  525.         }
  526.         
  527.     }
  529.     Message().Complete(result);
  530. }
  532. //
  533. // HXSymbianAudioSession::GetTime
  534. //
  535. // Return the current playback position -- converts from
  536. // microseconds to milliseconds
  537. //
  538. void HXSymbianAudioSession::GetTime()
  539. {
  540.     Message().Complete(m_timeline.GetPlaybackTime());
  541. }
  544. //
  545. // HXSymbianAudioSession::GetBlocksBuffered
  546. //
  547. // Return the number of blocks buffered by this object.
  548. //
  549. void HXSymbianAudioSession::GetBlocksBuffered()
  550. {
  551.     Message().Complete(m_bufferList.GetCount());
  552. }
  554. //
  555. // HXSymbianAudioSession::SetVolume
  556. //
  557. // set the volume -- convert from 0-100 to 0-max range
  558. //
  559. void HXSymbianAudioSession::SetVolume()
  560. {
  561.     if (m_pStream)
  562.     {
  563.         m_pStream->SetVolume(Message().Int0());
  564.     }
  565.     Message().Complete(0);
  566. }
  568. //
  569. // HXSymbianAudioSession::GetVolume
  570. //
  571. // get the current volume normalized to 0-100 range
  572. //
  573. void HXSymbianAudioSession::GetVolume()
  574. {
  575.     TInt vol = 0;
  576.     if (m_pStream)
  577.     {
  578.         vol = m_pStream->Volume();
  579.     }
  580.     Message().Complete(vol);
  581. }
  583. //
  584. // HXSymbianAudioSession::GetMaxVolume
  585. //
  586. // get the maxium device volume
  587. //
  588. void HXSymbianAudioSession::GetMaxVolume()
  589. {
  590.     TInt maxVol = 0;
  591.     if (m_pStream)
  592.     {
  593.         maxVol = m_pStream->MaxVolume();
  594.     }
  596.     Message().Complete(maxVol);
  597. }
  599. //
  600. // HXSymbianAudioSession::GetMinVolume
  601. //
  602. // get the minimum device volume
  603. //
  604. void HXSymbianAudioSession::GetMinVolume()
  605. {
  606.     Message().Complete(0);
  607. }
  610. //
  611. // HXSymbianAudioSession::Stop
  612. //
  613. // stop playback
  614. //
  615. void HXSymbianAudioSession::Stop()
  616. {
  617.     m_bPaused = TRUE;
  618.     if(m_pStream)
  619.     {
  620.         m_pStream->Stop();
  621.     }
  622.     
  623.     // Cleanup any remaining buffers
  624.     while(!m_bufferList.IsEmpty())
  625.     {
  626.         IHXBuffer* pBuf = (IHXBuffer*)m_bufferList.RemoveHead();
  627.         HX_RELEASE(pBuf);
  628.     }
  630.     m_timeline.Reset(GetByteRate());
  632.     Message().Complete(KErrNone);
  633. }
  635. void
  636. HXSymbianAudioSession::RequestDeviceTakenNotification()
  637. {
  638.     m_wantsNotify = true;
  639.     m_notifyRequest = Message();
  640. }
  642. void
  643. HXSymbianAudioSession::CancelDeviceTakenNotification()
  644. {
  645.     if (m_wantsNotify)
  646.     {
  647.         m_notifyRequest.Complete(KErrCancel);
  648.         m_wantsNotify = false;
  649.     }
  650. }
  652. //
  653. // HXSymbianAudioSession::NotifyDeviceTaken
  654. //
  655. // notify the client that the audio device has been taken if a
  656. // notification requrest has been made 
  657. //
  658. void HXSymbianAudioSession::NotifyDeviceTaken()
  659. {
  660.     if (m_wantsNotify)
  661.     {
  662.         m_notifyRequest.Complete(m_reason);
  663.         m_wantsNotify = false;
  664.     }
  665. }
  667. //
  668. // callbacks
  669. //
  671. void HXSymbianAudioSession::MaoscOpenComplete(TInt error)
  672. {
  673.     if (error == KErrNone)
  674.     {
  675.         m_open = true;
  677.         TRAP(error, m_pStream->SetAudioPropertiesL(m_sampleRate,
  678.                                                    m_channels));
  679.         m_pStream->SetPriority(KClientPriority, KPriorityPref);
  680.     }
  682.     Message().Complete(error);
  683. }
  685. void HXSymbianAudioSession::MaoscBufferCopied(TInt error, const TDesC8& buf)
  686. {
  687.     m_bWritePending = FALSE;
  689.     // Check to see if we need a device time
  690.     if (m_timeline.NeedDeviceTime())
  691.     {
  692.         m_timeline.SetDeviceTime(GetDeviceMs());
  693.     }
  695.     if (!m_bufferList.IsEmpty())
  696.     {
  697.         // We should always enter here because the
  698.         // last buffer written is at the head of the list.
  700.         // We want to remove this buffer from the list since
  701.         // this call is the completion of last WriteL() call.
  702.         IHXBuffer* pBuf = (IHXBuffer*)m_bufferList.RemoveHead();
  703.         HX_RELEASE(pBuf);
  704.     }
  706.     if (ReadyToWrite())
  707.     {
  708.         error = WriteNextBuffer();
  709.     }
  711. }
  713. void HXSymbianAudioSession::MaoscPlayComplete(TInt error)
  714. {
  715.     if (KErrUnderflow == error)
  716.     {
  717.         m_timeline.OnPauseOrUnderflow();
  718.     }
  720.     int resetErr;
  721.     TRAP(resetErr, m_pStream->SetAudioPropertiesL(m_sampleRate,
  722.                                                   m_channels));
  723.     m_pStream->SetPriority(KClientPriority, KPriorityPref);
  725.     if (error == KErrAbort)
  726.     {
  727.         m_reason = error;
  728.         m_pServer->NotifyDeviceTaken();
  729.     }
  731. }
  733. UINT32 HXSymbianAudioSession::GetByteRate() const
  734. {
  735.     return 2 * FlagToNumber(m_sampleRate) * FlagToNumber(m_channels);
  736. }
  739. UINT32 HXSymbianAudioSession::GetDeviceMs()
  740. {
  741.     UINT32 ulRet = 0;
  743.     if (m_pStream)
  744.     {
  745.         TTimeIntervalMicroSeconds pos = m_pStream->Position();
  746.         TInt64 millisecs = pos.Int64() / 1000;
  747.    
  748.         ulRet = millisecs.Low();
  749.     }
  751.     return ulRet;
  752. }
  754. BOOL HXSymbianAudioSession::ReadyToWrite() const
  755. {
  756.     return !m_bWritePending && !m_bPaused && !m_bufferList.IsEmpty();
  757. }
  759. TInt HXSymbianAudioSession::WriteNextBuffer()
  760. {
  761.     // Write the next buffer in the list
  762.     IHXBuffer* pBuffer = (IHXBuffer*)m_bufferList.GetHead();
  764.     TInt result = KErrNone;
  766.     if (pBuffer)
  767.     {
  768.         if( m_pStream )
  769.         {
  770.             int len = pBuffer->GetSize();
  771.             m_pData.Set((TUint8*)pBuffer->GetBuffer(), len, len);
  772.             TRAP(result, m_pStream->WriteL(m_pData));
  773.         }
  774.         else
  775.         {
  776.             // oom earlier?
  777.             result = KErrNotReady;
  778.         }
  779.     }
  781.     if (KErrNone == result)
  782.     {
  783.         m_timeline.OnWrite(pBuffer->GetSize());
  784.         m_bWritePending = TRUE;
  785.     }
  786.     else
  787.     {
  788.         m_bWritePending = FALSE;
  789.     }
  791.     return result;
  792. }