/*

* Copyright (c) 2004-2005 Nokia Corporation and/or its subsidiary(-ies). 

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:  Audio playback wrapper for DevTTS.

*

*/

// INCLUDE FILES

#include "devttsaudio.h"

#include "devttscenrep.h"

#include <AudioPreference.h>

#include <AudioOutput.h>

#include <mmfbase.h>

#include "rubydebug.h"

// CONSTANTS

// Sample rates

const TUint KSampleRate8k = 8000;

const TUint KSampleRate11k = 11025;

const TUint KSampleRate16k = 16000;

const TUint KSampleRate22k = 22050;

const TUint KSampleRate32k = 32000;

const TUint KSampleRate44k = 44100;

const TUint KSampleRate48k = 48000;

const TUint KSampleRate88k = 88200;

const TUint KSampleRate96k = 96000;

// Bits per sample

const TUint KBitsPerSample8 = 8;

const TUint KBitsPerSample16 = 16;

// Volume min

const TUint KMinVolume = 0;

const TUint KBalanceMiddle = 100;

// Default audio priority

// ============================ MEMBER FUNCTIONS ===============================

// -----------------------------------------------------------------------------

// CDevTTSAudio::CDevTTSAudio

// C++ default constructor can NOT contain any code, that

// might leave.

// -----------------------------------------------------------------------------

//

CDevTTSAudio::CDevTTSAudio( MDevTTSAudioObserver& aObserver, TInt aPriority ) : 

        iObserver( aObserver ), 

        iDevsound( NULL ),

        iBuffer( NULL ),

        iPriority( aPriority ),

        iBalance( KDevTTSBalanceMiddle ),

        iVolume( KMinVolume )

    {

    // Nothing

    }

// -----------------------------------------------------------------------------

// CDevTTSAudio::ConstructL

// Symbian 2nd phase constructor can leave.

// -----------------------------------------------------------------------------

//

void CDevTTSAudio::ConstructL()

    {

    RUBY_DEBUG_BLOCK( "CDevTTSAudio::ConstructL" );

    // Construct DevSound object

    iDevsound = CMMFDevSound::NewL();

#ifndef __WINS__// This is not supported in emulator

    iAudioOutput = CAudioOutput::NewL( *iDevsound );

#endif

    // Handler for the CenRep settings

    CDevTtsCenRep* cenrep = CDevTtsCenRep::NewL();

    CleanupStack::PushL( cenrep ); 

    // Set volume to default

    RUBY_DEBUG0( "CDevTTSAudio::ConstructL Set volume" );

    SetVolume( cenrep->Volume( MaxVolume() ) );

    CleanupStack::PopAndDestroy( cenrep );

    // Set default playback priority

    SetAudioPriority( KAudioPriorityVoiceDial, 

                      (TDevTTSAudioPreference) KAudioPrefVocosPlayback );

    }

// -----------------------------------------------------------------------------

// CDevTTSAudio::NewL

// Two-phased constructor.

// -----------------------------------------------------------------------------

//

CDevTTSAudio* CDevTTSAudio::NewL( MDevTTSAudioObserver& aObserver, 

                                  TInt aPriority )

    {

    CDevTTSAudio* self = new( ELeave ) CDevTTSAudio( aObserver, aPriority );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

// -----------------------------------------------------------------------------

// CDevTTSAudio::~CDevTTSAudio

// Destructor

// -----------------------------------------------------------------------------

//

CDevTTSAudio::~CDevTTSAudio()

    {

    delete iAudioOutput; 

    delete iDevsound; 

    }

// -----------------------------------------------------------------------------

// CDevTTSAudio::InitializeL

// Initializes audio playback device.

// -----------------------------------------------------------------------------

//

void CDevTTSAudio::InitializeL() 

    {

    iDevsound->InitializeL(*(this), EMMFStatePlaying );

    }

// -----------------------------------------------------------------------------

// CDevTTSAudio::ConfigL

// Configures audio playback device.

// -----------------------------------------------------------------------------

//

void CDevTTSAudio::ConfigL( TUint aSamplingRate, TUint aBitsPerSample, 

                            TBool aStereo, TUint aBufferSize )

    {

    // Resolve configuration

    iDevCap = iDevsound->Config();

    // Set the preferred buffer size

    iDevCap.iBufferSize = aBufferSize;

    // Resolve sampling rate

    switch ( aSamplingRate )

        {

        case KSampleRate8k:

            iDevCap.iRate = EMMFSampleRate8000Hz;

            break;

        case KSampleRate11k:

            iDevCap.iRate = EMMFSampleRate11025Hz;

            break;

        case KSampleRate16k:

            iDevCap.iRate = EMMFSampleRate16000Hz;

            break;

        case KSampleRate22k:

            iDevCap.iRate = EMMFSampleRate22050Hz;

            break;

        case KSampleRate32k:

            iDevCap.iRate = EMMFSampleRate32000Hz;

            break;

        case KSampleRate44k:

            iDevCap.iRate = EMMFSampleRate44100Hz;

            break;

        case KSampleRate48k:

            iDevCap.iRate = EMMFSampleRate48000Hz;

            break;

        case KSampleRate88k:

            iDevCap.iRate = EMMFSampleRate88200Hz;

            break;

        case KSampleRate96k:

            iDevCap.iRate = EMMFSampleRate96000Hz;

            break;

        default:

            User::Leave(KErrNotSupported);

            break;

        }

    // Resolve bits per sample

    switch ( aBitsPerSample )

        {

        case KBitsPerSample8:

            iDevCap.iEncoding = EMMFSoundEncoding8BitPCM;

            break;

        case KBitsPerSample16:

            iDevCap.iEncoding = EMMFSoundEncoding16BitPCM;

            break;

        default:

            User::Leave(KErrNotSupported);

            break;

        }

    // Resolve mono/stereo

    if ( aStereo )

        {

        iDevCap.iChannels = EMMFStereo;

        }

    else

        {

        iDevCap.iChannels = EMMFMono;

        }

    // Set DevSound configuration in place

    iDevsound->SetConfigL( iDevCap );

    // Set the audio priority settings to default

    iAudioPriority.iPriority = KAudioPriorityVoiceDial;

    iAudioPriority.iPref = ( TMdaPriorityPreference ) KAudioPrefVocosPlayback;

    iAudioPriority.iState = EMMFStatePlaying;

    iDevsound->SetPrioritySettings( iAudioPriority );

    }

// -----------------------------------------------------------------------------

// CDevTTSAudio::Clear

// No counter part for initialize in DevSound. Function is in this class just

// for future convenience.

// -----------------------------------------------------------------------------

//

void CDevTTSAudio::Clear()

    {

    // Nothing

    }

// -----------------------------------------------------------------------------

// CDevTTSAudio::PlayInitL

// Forwards call to DevSound.

// -----------------------------------------------------------------------------

//

void CDevTTSAudio::PlayInitL()

    {

    iDevsound->PlayInitL();

    }

// -----------------------------------------------------------------------------

// CDevTTSAudio::PlayData

// Forwards call to DevSound.

// -----------------------------------------------------------------------------

//

void CDevTTSAudio::PlayData( TBool aLastBuffer ) 

    {

    iBuffer->SetLastBuffer( aLastBuffer );

    iDevsound->PlayData();

    }

// -----------------------------------------------------------------------------

// CDevTTSAudio::SetAudioPriority

// Resolves arguments and forwards call to DevSound.

// -----------------------------------------------------------------------------

//

void CDevTTSAudio::SetAudioPriority( TInt aPriority, TDevTTSAudioPreference aPref )

    {

    // Set the priority settings

    iPriority = aPriority;

    iAudioPriority.iPriority = aPriority;

    iAudioPriority.iState = EMMFStatePlaying;

    iAudioPriority.iPref = ( TMdaPriorityPreference ) aPref;

    iDevsound->SetPrioritySettings( iAudioPriority );

    }

// -----------------------------------------------------------------------------

// CDevTTSAudio::SetAudioOutputL

// 

// -----------------------------------------------------------------------------

// 

void CDevTTSAudio::SetAudioOutputL( TInt aAudioOutput )

    {

    RUBY_DEBUG1( "Setting output to %d", aAudioOutput );

    if ( iAudioOutput )

        {

        iAudioOutput->SetAudioOutputL( 

            (CAudioOutput::TAudioOutputPreference)aAudioOutput );

        }

    }

// -----------------------------------------------------------------------------

// CDevTTSAudio::Balance

// Forwards call to DevSound.

// -----------------------------------------------------------------------------

//

TInt CDevTTSAudio::Balance()

    {

    return iBalance;

    }

// -----------------------------------------------------------------------------

// CDevTTSAudio::SetBalance

// Checks parameter validity and forwards call to DevSound.

// -----------------------------------------------------------------------------

//

void CDevTTSAudio::SetBalance( TInt aBalance )

    {

    TInt right( 0 );

    TInt left( 0 );

    if ( ( aBalance > KDevTTSBalanceRight ) || ( aBalance < KDevTTSBalanceLeft ) )

        {

        return;

        }

    iBalance = aBalance;

    if ( aBalance < 0 )

        {

        left = KBalanceMiddle;

        right = KBalanceMiddle + aBalance;

        }

    else if ( aBalance > 0 )

        {

        left = KBalanceMiddle - aBalance;

        right = KBalanceMiddle;

        }

    else

        {

        left = KBalanceMiddle;

        right = KBalanceMiddle;

        }

    RUBY_DEBUG2( "CDevTTSAudio::SetBalance Balance setting left: %d, right: %d", left, right );

    TRAPD( error, iDevsound->SetPlayBalanceL( left, right ) );

    if ( error == KErrNone )

        {

        RUBY_DEBUG0( "CDevTTSAudio::SetBalance Balance set" );

        }

    else

        {

        RUBY_DEBUG1( "CDevTTSAudio::SetBalance Balance set error: %d", error );

        }

    }

// -----------------------------------------------------------------------------

// CDevTTSAudio::SetVolume

// Forwards call to DevSound.

// -----------------------------------------------------------------------------

//

void CDevTTSAudio::SetVolume( TInt aVolume )

    {

    if ( ( aVolume > iDevsound->MaxVolume() ) || ( aVolume < KMinVolume ) )

        {

        return;

        }

    iVolume = aVolume;

    RUBY_DEBUG1( "CDevTTSAudio::SetVolume %i", aVolume ); 

    iDevsound->SetVolume( aVolume );

    }

// -----------------------------------------------------------------------------

// CDevTTSAudio::SetVolumeRamp

// Forwards call to DevSound.

// -----------------------------------------------------------------------------

//

void CDevTTSAudio::SetVolumeRamp( const TTimeIntervalMicroSeconds& aRampDuration )

    {

    iDevsound->SetVolumeRamp( aRampDuration );

    }

// -----------------------------------------------------------------------------

// CDevTTSAudio::MaxVolume

// Returns DevSound maximum volume.

// -----------------------------------------------------------------------------

//

TInt CDevTTSAudio::MaxVolume()

    {

    return iDevsound->MaxVolume();

    }

// -----------------------------------------------------------------------------

// CDevTTSAudio::Volume

// Forwards call to DevSound.

// -----------------------------------------------------------------------------

//

TInt CDevTTSAudio::Volume()

    {

    return iVolume;

    }

// -----------------------------------------------------------------------------

// CDevTTSAudio::Stop

// Forwards call to DevSound.

// -----------------------------------------------------------------------------

//

void CDevTTSAudio::Stop()

    {

    iDevsound->Stop();

    }

// -----------------------------------------------------------------------------

// CDevTTSAudio::Pause

// Forwards call to DevSound.

// -----------------------------------------------------------------------------

//

void CDevTTSAudio::Pause()

    {

    iDevsound->Pause();

    }

// ========================== MDevSoundObserver CALLBACKS ======================

// -----------------------------------------------------------------------------

// CDevTTSAudio::InitializeComplete

// Forwards callback

// -----------------------------------------------------------------------------

//

void CDevTTSAudio::InitializeComplete( TInt aError ) 

    {

    iObserver.MdtaoInitializeComplete( aError );

    }

// -----------------------------------------------------------------------------

// CDevTTSAudio::ToneFinished

// Not needed when using only waveform playback

// -----------------------------------------------------------------------------

//

void CDevTTSAudio::ToneFinished(TInt /*aError*/)

    {

    }

// -----------------------------------------------------------------------------

// CDevTTSAudio::BufferToBeFilled

// Forwards callback

// -----------------------------------------------------------------------------

//

void CDevTTSAudio::BufferToBeFilled( CMMFBuffer* aBuffer )

    {

    iBuffer = aBuffer;

    CMMFDataBuffer* buffer = STATIC_CAST( CMMFDataBuffer*, aBuffer );

    iObserver.MdtaoBufferToBeFilled( buffer->Data(), aBuffer->RequestSize() );

    }

// -----------------------------------------------------------------------------

// CDevTTSAudio::PlayError

// Forwards callback.

// Spec says that KErrNone is used when audio playback is ok. In practise it

// seems that KErrUnderflow means the same thing.

// -----------------------------------------------------------------------------

//

void CDevTTSAudio::PlayError( TInt aError )

    {

    if ( aError == KErrNone || aError == KErrUnderflow ) 

        {

        iObserver.MdtaoPlayFinished( KErrNone );

        }

    else

        {

        iObserver.MdtaoPlayFinished( aError );

        }

    }

// -----------------------------------------------------------------------------

// CDevTTSAudio::BufferToBeEmptied

// Not needed when using only waveform playback

// -----------------------------------------------------------------------------

//

void CDevTTSAudio::BufferToBeEmptied( CMMFBuffer* /*aBuffer*/ )

    {

    }

// -----------------------------------------------------------------------------

// CDevTTSAudio::RecordError

// Not needed when using only waveform playback

// -----------------------------------------------------------------------------

//

void CDevTTSAudio::RecordError( TInt /*aError*/ )

    {

    }

// -----------------------------------------------------------------------------

// CDevTTSAudio::ConvertError

// Not needed when using only waveform playback

// -----------------------------------------------------------------------------

//

void CDevTTSAudio::ConvertError( TInt /*aError*/ )

    {

    }

// -----------------------------------------------------------------------------

// CDevTTSAudio::DeviceMessage

// Not needed, no custom commands issued to audio hw device

// -----------------------------------------------------------------------------

//

void CDevTTSAudio::DeviceMessage( TUid /*aMessageType*/, const TDesC8& /*aMsg*/ )

    {

    }

// -----------------------------------------------------------------------------

// CDevTTSAudio::SendEventToClient

// Called when an attempt to acquire a sound device is rejected by audio policy 

// server

// -----------------------------------------------------------------------------

//

void CDevTTSAudio::SendEventToClient( const TMMFEvent& /*aEvent*/ )

    {

    // Inform our own observer

    iObserver.MdtaoPlayFinished( KErrCancel );

    }

// End of File