audio_session-mmf.cpp

来自「symbian 下的helix player源代码」· C++ 代码 · 共 641 行 · 第 1/2 页

    m_bPaused = FALSE;
    Message().Complete(err);
}

//
// HXSymbianAudioSession::Pause
//
void HXSymbianAudioSession::Pause()
{
    m_bPaused = TRUE;

    if( m_ulStartTime )
        m_ulPauseTime += HX_GET_TICKCOUNT()-m_ulStartTime;
    m_ulStartTime = 0;

    //Only pause the stream if we have actually started to play.
    if (m_pStream && m_pData)
    {
        m_pStream->Pause();
    }

    Message().Complete(KErrNone);
}

//
// HXSymbianAudioSession::Write
//
//
void HXSymbianAudioSession::Write()
{
    TInt result = KErrArgument;
    TInt err = KErrNone;
    IHXBuffer* pAudioBuf = (IHXBuffer*)Message().Ptr0();

    if (pAudioBuf)
    {
        if (m_bufferList.AddTail(pAudioBuf))
        {
            result = KErrNone;
        }
        else
        {
            result = KErrNoMemory;
        }
    }


    Message().Complete(result);
    
    if( m_bBufferNeedsFilling && m_pData )
    {
        BufferToBeFilled(m_pData);
        m_bBufferNeedsFilling = false;
    }
}

//
// HXSymbianAudioSession::GetTime
//
// Return the current playback position -- converts from
// microseconds to milliseconds
//
void HXSymbianAudioSession::GetTime()
{
    TInt nMSTime = 0;
    TInt nSamples = m_pStream->SamplesPlayed();

    
    nMSTime = (nSamples+m_nUnderflowSampleCount)*1000/m_uSampleRate;

//     if(m_ulStartTime)
//         nMSTime = HX_GET_TICKCOUNT()-m_ulStartTime;
    
//     nMSTime += m_ulPauseTime;

    Message().Complete(nMSTime);
}


//
// HXSymbianAudioSession::GetBlocksBuffered
//
// Return the number of blocks buffered by this object.
//
void HXSymbianAudioSession::GetBlocksBuffered()
{
    TInt nTmp = m_bufferList.GetCount();
    Message().Complete(nTmp);
}

//
// HXSymbianAudioSession::SetVolume
//
// set the volume -- convert from 0-100 to 0-max range
//
void HXSymbianAudioSession::SetVolume()
{
    if (m_pStream)
    {
        m_pStream->SetVolume(Message().Int0());
    }
    Message().Complete(0);
}

//
// HXSymbianAudioSession::GetVolume
//
// get the current volume normalized to 0-100 range
//
void HXSymbianAudioSession::GetVolume()
{
    TInt vol = 0;
    if (m_pStream)
    {
        vol = m_pStream->Volume();
    }
    Message().Complete(vol);
}

//
// HXSymbianAudioSession::GetMaxVolume
//
// get the maxium device volume
//
void HXSymbianAudioSession::GetMaxVolume()
{
    TInt maxVol = 0;
    if (m_pStream)
    {
        maxVol = m_pStream->MaxVolume();
    }

    Message().Complete(maxVol);
}

//
// HXSymbianAudioSession::GetMinVolume
//
// get the minimum device volume
//
void HXSymbianAudioSession::GetMinVolume()
{
    Message().Complete(0);
}


//
// HXSymbianAudioSession::Stop
//
// stop playback
//
void HXSymbianAudioSession::Stop()
{
    m_bPlayInited           = FALSE;
    m_ulStartTime           = 0;
    m_ulPauseTime           = 0;
    m_nUnderflowSampleCount = 0;
    m_nLastSampleCount      = 0;

    if(m_pStream)
    {
        m_pStream->Stop();
        m_pData = NULL;
    }
    
    // Cleanup any remaining buffers
    while(!m_bufferList.IsEmpty())
    {
        IHXBuffer* pBuf = (IHXBuffer*)m_bufferList.RemoveHead();
        HX_RELEASE(pBuf);
    }

    Message().Complete(KErrNone);
}

void
HXSymbianAudioSession::RequestDeviceTakenNotification()
{
    m_wantsNotify = true;
    m_notifyRequest = Message();
}

void
HXSymbianAudioSession::CancelDeviceTakenNotification()
{
    if (m_wantsNotify)
    {
        m_notifyRequest.Complete(KErrCancel);
        m_wantsNotify = false;
    }
}

//
// HXSymbianAudioSession::NotifyDeviceTaken
//
// notify the client that the audio device has been taken if a
// notification requrest has been made 
//
void HXSymbianAudioSession::NotifyDeviceTaken()
{
    if (m_wantsNotify)
    {
        m_notifyRequest.Complete(m_reason);
        m_wantsNotify = false;
    }
}

//
// callbacks
//

//MDevSoundObserver callbacks
void HXSymbianAudioSession::InitializeComplete(TInt aError)
{
    TInt err = KErrNone;
    TRAP(err, (m_pStream->CMMFDevSound::SetConfigL(m_Settings)));
    
    if( KErrNone == err )
    {
        m_open = true;
    }
    m_InitMessage.Complete(err);
}

void HXSymbianAudioSession::BufferToBeFilled(CMMFBuffer* aBuffer)
{
    TInt err = KErrUnderflow;

    m_pData = aBuffer;

    m_nLastSampleCount = m_pStream->SamplesPlayed();

    if( aBuffer )
    {
        //Called whenever the media server needs more data to play.
        if( !m_bufferList.IsEmpty())
        {
            TDes8&  dataDesc  = ((CMMFDataBuffer*)aBuffer)->Data();
            int nRequestSize  = aBuffer->RequestSize();
            int nTotalWritten = 0;

            //Clear out the descriptor.
            dataDesc = TPtrC8(NULL, 0 );
            while( !m_bufferList.IsEmpty() )
            {
                //Fill up as much as we can.
                IHXBuffer* pBuffer = (IHXBuffer*)m_bufferList.GetHead();
                int len = pBuffer->GetSize();
                if( nTotalWritten+len < nRequestSize )
                {
                    TPtrC8 desc((TUint8*)pBuffer->GetBuffer(), len);
                    dataDesc.Append(desc);
                    IHXBuffer* pTmp = (IHXBuffer*)m_bufferList.RemoveHead();
                    HX_RELEASE(pTmp);
                }
                else
                {
                    break;
                }
                nTotalWritten += len;

                //XXXGfw break here is intentional. I don't want to do
                //combined writes right now.
                break;
            }

            m_pStream->PlayData();
            
        }
        else
        {
            m_bBufferNeedsFilling = true;
        }
    }
}

void HXSymbianAudioSession::PlayError(TInt aError)
{
    TInt err = KErrNone;
    m_reason = aError;
    m_pData  = NULL;
    switch(aError)
    {
       case KErrUnderflow:
           //HX_ASSERT(NULL=="Underflow.");
           TMMFPrioritySettings prioritySettings;
           
           prioritySettings.iPref     = KPriorityPref;
           prioritySettings.iPriority = KClientPriority;
           
           m_pStream->SetPrioritySettings(prioritySettings);
           TRAP(err, m_pStream->PlayInitL());
           m_bPlayInited = TRUE;
           m_nUnderflowSampleCount += m_nLastSampleCount;
           break;
       case KErrAccessDenied: 
           NotifyDeviceTaken();
           break;
       case KErrCancel:
           HX_ASSERT(NULL=="PlayError -- KErrCancel");
           break;
       case KErrInUse:
           NotifyDeviceTaken();
           break;
       default:
           HX_ASSERT(NULL=="unknown error");
           break;
    }
}

//These are never used in PCM playback, just recording or converting.
void HXSymbianAudioSession::ToneFinished(TInt aError) {}
void HXSymbianAudioSession::RecordError(TInt aError)  {}
void HXSymbianAudioSession::ConvertError(TInt aError) {}
void HXSymbianAudioSession::BufferToBeEmptied(CMMFBuffer* aBuffer) {}
void HXSymbianAudioSession::DeviceMessage(TUid aMessageType, const TDesC8& aMsg) {}
void HXSymbianAudioSession::SendEventToClient(const TMMFEvent& aEvent) {}