/*

* Copyright (c) 2004-2007 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:  Implementations for CTTSAlgorithmManager methods.

*

*/

// INCLUDE FILES

#include <barsc.h>

#include <bautils.h>

#include <barsread.h>

#include <nssdevtts.rsg>

#include <AudioPreference.h>

#include <data_caging_path_literals.hrh>

#include "devttsalgorithmmanager.h"

#include "rubydebug.h"

#ifdef _DEBUG

#include <e32svr.h>

#endif

// CONSTANTS

_LIT( KResourceFileName, "nssdevtts.rsc" );

// Default audio priority

const TInt KDefaultPriority = KAudioPriorityVoiceDial;

#ifdef DEVTTS_AUDIOBUFFER_TO_FILE

const TFileName KAudioBufferFileName( _L( "c:\\documents\\devttsaudio" ) );

const TFileName KAudioBufferFileNameExtension( _L( ".raw" ) );

#endif

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

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

// CTTSAlgorithmManager::CTTSAlgorithmManager

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

// might leave.

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

//

CTTSAlgorithmManager::CTTSAlgorithmManager( MDevTTSObserver& aObserver ):

        iPaused( EFalse ),

        iObserver( aObserver ),

        iAudio( NULL ),

        iAudioState( ETTSAudioPlayerNotInitialized ),

        iHw( NULL ),

        iError( KErrNone ),

        iState( EDevTTSNotInitialized ),

        iMode( EDevTTSSoundDeviceMode ),

        iLastBufferFromTts( EFalse ),

        iTtpHw( NULL ), 

#ifdef DEVTTS_3DB_HACK

		iApplyGain( ETrue ),

#endif

        iNlp( NULL ),

        iNlpInitialized( EFalse )

    {

    // Nothing

    }

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

// CTTSAlgorithmManager::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CTTSAlgorithmManager::ConstructL(/*CConsoleBase* console*/)

    {

    RUBY_DEBUG_BLOCK( "CTTSAlgorithmManager::ConstructL" );

    TBool boolStereo( EFalse );

    TUint intStereo( 0 );

    TUint bitsPerSample( 16 );

    TUint samplingRate( 16000 );

    TUint bufferSize( 4096 );

    TInt defaultPriority( 0 );

    // Try to find resource file first from MMC, then from C-drive and only 

    // after that from flash

    // letters for drives in search order

    const TBuf<2> KResourceDrives = _L("cz"); 

    // load resources

    RResourceFile resourceFile;

    RFs fs;

    User::LeaveIfError( fs.Connect() );

    CleanupClosePushL( fs );

    TFileName name;

    TInt i( 0 );

    // try to find from the first driver

    name.Append( KResourceDrives[i] );

    name.Append( ':' );

    name.Append( KDC_RESOURCE_FILES_DIR );

    name.Append( KResourceFileName );

    TBool found( EFalse );

    while ( !found && i < KResourceDrives.Length() )

        {

        name[0] = KResourceDrives[i++];

        if ( BaflUtils::FileExists(fs, name) )

            {

            // open resource

            resourceFile.OpenL( fs, name );

            CleanupClosePushL( resourceFile );

            found = ETrue;

            }

        }

    if ( !found )

        {

        User::Leave( KErrNotFound );

        }

    HBufC8* configurations = resourceFile.AllocReadLC( R_DEVTTS_CONFIGURATIONS );

    TResourceReader resReader;

    resReader.SetBuffer( configurations );

    // Sampling rate

    samplingRate = resReader.ReadUint32();

    // Bits per sample

    bitsPerSample = resReader.ReadUint32();

    // Mono / Stereo

    intStereo = resReader.ReadUint32();

    // Buffer size

    bufferSize = resReader.ReadUint32();

#ifdef __WINS__

    // CMMFDevSound uses currently buffer size of 16384 in emulator. 

    RUBY_DEBUG0( "CTTSAlgorithmManager::ConstructL - Hard coded buffer size in use!" );

    bufferSize = 16384;

#endif

    // Priority

    defaultPriority = KDefaultPriority;

    if ( intStereo == 0 )

        {

        boolStereo = EFalse;

        }

    else

        {

        boolStereo = ETrue;

        }

    // Cleanup configurations, resourceFile, fs

    CleanupStack::PopAndDestroy( configurations );    

    CleanupStack::PopAndDestroy( &resourceFile );

    CleanupStack::PopAndDestroy( &fs );

    // Create new TtsHwDevice instance

    iHw = CTtsHwDevice::NewL( *this, samplingRate, bufferSize );

    // Create audio playback instance

    iAudio = CDevTTSAudio::NewL( *this, defaultPriority );

    iState = EDevTTSStopped;

    // Start audio device initialization process

    iAudio->InitializeL();

    // Wait for callback only if it is asynchronous

    // (state will be something else if it is synchronous)

    if ( iAudioState == ETTSAudioPlayerNotInitialized )

        {

        if ( !iAudioWait.IsStarted() )

            {

            RUBY_DEBUG0( "CTTSAlgorithmManager::ConstructL iAudioWait.Start()" );

            iAudioWait.Start();

            }

        }

    iAudio->ConfigL( samplingRate, bitsPerSample, boolStereo, bufferSize);

    // Create & initialize TtpHwDevice

    iTtpHw = CASRSTtpHwDevice::NewL( *this );

    iTtpHw->InitializeL();

    iTtpHw->SetPhonemeNotationL( _L( "NIPA8" ) );

    // Create NlpHwDevice

    TRAPD( error, iNlp = CNlpHwDevice::NewL( *this ) );

    if ( error == KErrNone )

        {

        iNlp->InitializeL();

        iNlpInitialized = ETrue;

        }

    else

        {

        iNlpInitialized = EFalse;

        }

#ifdef DEVTTS_AUDIOBUFFER_TO_FILE

    User::LeaveIfError( iSession.Connect() );

    iFileOpen = EFalse;

    iFileCounter = 0;

#endif

    RUBY_DEBUG1( "CTTSAlgorithmManager config, sampling rate: %d", samplingRate );

    RUBY_DEBUG1( "CTTSAlgorithmManager config, bits per sample: %d", bitsPerSample);

    RUBY_DEBUG1( "CTTSAlgorithmManager config, mono/stereo: %d", intStereo);

    RUBY_DEBUG1( "CTTSAlgorithmManager config, buffer size: %d", bufferSize);

    }

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

// CTTSAlgorithmManager::NewL

// Two-phased constructor.

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

//

CTTSAlgorithmManager* CTTSAlgorithmManager::NewL( MDevTTSObserver& aObserver/*, CConsoleBase* console*/ )

    {

    CTTSAlgorithmManager* self = new( ELeave ) CTTSAlgorithmManager(aObserver);

    CleanupStack::PushL( self );

    self->ConstructL( /*console*/ );

    CleanupStack::Pop( self );

    return self;

    }

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

// CTTSAlgorithmManager::~CTTSAlgorithmManager

// Destructor.

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

//

CTTSAlgorithmManager::~CTTSAlgorithmManager()

    {

    if ( iAudio )

        {

        iAudio->Clear();

        delete iAudio;

        iAudio = NULL;

        }

    if ( iHw )

        {

        delete iHw;

        iHw = NULL;

        }

    if ( iTtpHw )

        {

        iTtpHw->Clear();

        delete iTtpHw;

        iTtpHw = NULL;

        }

    if ( iNlp )

        {

        iNlp->Clear();

        delete iNlp;

        iNlp = NULL;

        }

#ifdef DEVTTS_AUDIOBUFFER_TO_FILE

    iSession.Close();

#endif

    }

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

// CTTSAlgorithmManager::AddStyleL

// Forwards call to TtsHwDevice

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

//

TTtsStyleID CTTSAlgorithmManager::AddStyleL( const TTtsStyle& aStyle )

    {

    return iHw->AddStyleL( aStyle );

    }

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

// CTTSAlgorithmManager::Balance

// Forwards call to the CDevTTSAudio.

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

//

TInt CTTSAlgorithmManager::Balance()

    {

    return iAudio->Balance();

    }

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

// CTTSAlgorithmManager::BufferProcessed

// Forwards call to TtsHwDevice

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

//

void CTTSAlgorithmManager::BufferProcessed( const TDesC8& aBuffer )

    {

    // Client should call this only when buffers are provided to client

    if ( iMode == EDevTTSClientMode )

        {

        iHw->BufferProcessed( aBuffer );

        }

    }

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

// CTTSAlgorithmManager::CustomInterface

// Not in use currently. Now returns NULL.

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

//

TAny* CTTSAlgorithmManager::CustomInterface( TUid /*aInterfaceID*/ )

    {

    return NULL;

    }

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

// CTTSAlgorithmManager::DeleteStyleL

// Forwards call to the actual implementation object.

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

//

void CTTSAlgorithmManager::DeleteStyleL( TTtsStyleID aStyleID )

    {

    iHw->DeleteStyleL( aStyleID );

    }

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

// CTTSAlgorithmManager::GetPositionL

// Forwards call to TtsHwDevice

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

//

void CTTSAlgorithmManager::GetPositionL( TTimeIntervalMicroSeconds& aTime ) const

    {

    iHw->GetPositionL( aTime );

    }

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

// CTTSAlgorithmManager::GetPositionL

// Forwards call to TtsHwDevice

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

//

void CTTSAlgorithmManager::GetPositionL( TTtsSegment& aSegment, TInt& aWordIndex ) const

    {

    iHw->GetPositionL( aSegment, aWordIndex );

    }

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

// CTTSAlgorithmManager::IsLanguageSupported

// Forwards call to TtsHwDevice

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

//

TBool CTTSAlgorithmManager::IsLanguageSupported( TLanguage aLanguage ) const

    {

    return iHw->IsLanguageSupported( aLanguage );

    }

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

// CTTSAlgorithmManager::MaxVolume

// Forwards call to the CDevTTSAudio.

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

//

TInt CTTSAlgorithmManager::MaxVolume()

    {

    return iAudio->MaxVolume();

    }

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

// CTTSAlgorithmManager::NumberOfStyles

// Forwards call to TtsHwDevice

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

//

TUint16 CTTSAlgorithmManager::NumberOfStyles() const

    {

    return iHw->NumberOfStyles();

    }

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

// CTTSAlgorithmManager::Pause

// Pauses synthesis process in TtsHwDevice and also audio playback if needed.

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

//

void CTTSAlgorithmManager::Pause()

    {

    // Do nothing if not synthesizing currently

    if ( iState != EDevTTSSynthesizing )

        {

        return;

        }

    // Stop synthesis and playback

    iHw->Pause();

    if( iMode == EDevTTSSoundDeviceMode )

        {

        // Do a complete stop to the audio player instead of pause.

        // Pausing and resuming after that leads to the situation where all of

        // the data won't be played...

        iAudio->Stop();

        iAudioState = ETTSAudioPlayerPaused;

        }

    iState = EDevTTSPrimed;

    iPaused = ETrue;

    }

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

// CTTSAlgorithmManager::PrimeSynthesisL

// Prepares a synthesizing process, data will be read from client using a 

// stream.

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

//

void CTTSAlgorithmManager::PrimeSynthesisL( MTtsSegmentStream& aStream ) 

    {

    // Not yet in use, leave every time

    // @todo: Remove this when functionality is available

    User::Leave( KErrNotSupported );

    // Do the state check    

    if ( iState == EDevTTSNotInitialized )

        {

        User::Leave( KErrNotReady );

        }

    if ( iState != EDevTTSStopped )

        {

        User::Leave( KErrInUse );

        }

    iHw->PrimeSynthesisL( aStream );

    iState = EDevTTSPrimed;

    }

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

// CTTSAlgorithmManager::PrimeSynthesisL

// Prepares a synthesizing process.

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

//

void CTTSAlgorithmManager::PrimeSynthesisL( CTtsParsedText& aText )

    {

    RUBY_DEBUG_BLOCK( "CTTSAlgorithmManager::PrimeSynthesisL" );

    // Do the state check

    if ( iState == EDevTTSNotInitialized )

        {

        User::Leave( KErrNotReady );

        }

    if (iState != EDevTTSStopped)

        {

        User::Leave( KErrInUse );

        }

    // 1. Analyze structure if no segments in the parsed text object

    if ( aText.NumberOfSegments() == 0 )

        {

        iHw->AnalyzeStructureL( aText );

        }

    // 2. Call NLP if there is written text

    if ( ( aText.Text() != KNullDesC16 ) && iNlpInitialized )

        {

        TBool useNlp( ETrue );

        TInt counter( 0 );

        // Loop through content types of segments to find out if NLP should be used

        for ( counter = 0; counter < aText.NumberOfSegments(); counter++ )

            {

            TTtsSegment segment = aText.SegmentL( counter );

            TTtsStyleID styleID = segment.StyleID();

            TTtsStyle& style = StyleL( styleID );

            if ( !style.iNlp )

                {

                useNlp = EFalse;                

                }

            }

        if ( useNlp )

            {

            // If language is not specified, run LID before NLP

            for ( counter = 0; counter < aText.NumberOfSegments(); counter++ )

                {

                TTtsSegment segment = aText.SegmentL( counter );

                TTtsStyleID styleID = segment.StyleID();

                TTtsStyle& style = StyleL( styleID );

                if ( style.iLanguage == ELangOther )

                    {

                    RArray<TLanguage> languages;

                    RArray<TInt> scores;

                    // Only one result is needed

                    iTtpHw->LanguageIdentificationL( segment.TextPtr(), 1, languages, scores );

                    if ( languages.Count() == 0 )

                        {

                        languages.Close();

                        scores.Close();

                        User::Leave( KErrGeneral );

                        }

                    style.iLanguage = languages[0];

                    RUBY_DEBUG1( "CTTSAlgorithmManager::PrimeSynthesisL called LID [lang id: %d] before NLP", style.iLanguage );

                    languages.Close();

                    scores.Close();

                    }

                }

            }

        if ( useNlp )

            {

            iNlp->NormalizeTextL( aText );

            }

        }

    // Set the phoneme notation which is given within parsed text into TTP

    // Do this only if no phonemesequence is given and if notation is something

    // else than the default

    if ( ( aText.PhonemeNotation() != KNullDesC16 ) && ( aText.PhonemeSequence() == KNullDesC8 ) )

        {

        iTtpHw->SetPhonemeNotationL( aText.PhonemeNotation() );

        }