/*

* 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:  This file contains the implementation of Algorithm Manager,

*               a submodule of DevASR.

*

*/

// INCLUDE FILES

#include <mmfdatabuffer.h>

#include <AudioPreference.h>

#include <nssdevasr.h>

#include "devasrsrsalgorithmmanager.h"

#include "devasrvmalgorithmmanager.h"

#include "rubydebug.h"

#include "devasrcenrep.h"

#include "srsfbldvariant.hrh"

// CONSTANTS

const TInt KPlay = 1;

const TInt KRecord = KPlay + 1;

// Extra error values

const TInt KErrTooEarly = -100; // if speech was started too early

const TInt KErrNoSpeech = -101; // if it was silent 

const TInt KErrTooLong  = -102; // if speech did not stop before timeout

const TInt KErrTooShort = -103; // if speech was too short

// Default priority for recording

const TInt KDefaultPriority = KAudioPriorityVoiceDial;

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

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

// CSRSAlgorithmManager::CSRSAlgorithmManager

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

// might leave.

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

//

CSRSAlgorithmManager::CSRSAlgorithmManager( MDevASRObserver& aObserver )

                                           : CActive( CActive::EPriorityStandard ),

                                             iDevASRObserver( &aObserver ),

                                             iDevSound( NULL ),

                                             iCurrentVolume( 0 ),

                                             iCurrentGain( 0 ),

                                             iRecognitionAlgMgr( NULL ),

                                             iVMAlgorithmManager( NULL ),

                                             iStartRecognition( EFalse ),

                                             iPendingRequestSpeechData( EFalse ),

                                             iStartPoint( 0 ),

                                             iStopPoint( 0 ),

                                             iAudioBuffer( NULL ),

                                             iPtr( NULL, 0, 0 ),

                                             iOverallLength( 0 ),

                                             iOverallSampled( 0 ),

                                             iProcessingUtterance( EFalse ),

                                             iEndFlag( 0 ),

                                             iStartFrame( 0 ),

                                             iEndFrame( 0 ),

                                             iFrameLength( 0 ),

                                             iBufferStartPoint( 0 ),

                                             iBufferEndPoint( 0 ),

                                             iDevASRState( EDASRIdle ),

                                             iDevSoundState( ESoundDeviceNotInitialized ),

                                             iRequestFunction( 0 ),

                                             iBufferUnderConstruction( NULL ),

                                             iConstructionPoint( 0 ),

                                             iPreSamplingStarted( EFalse )

    {

    RUBY_DEBUG0( "CSRSAlgorithmManager::CSRSAlgorithmManager()" );

#ifdef AUDIOBUFFER_TO_FILE

    iFileCreated = EFalse;

#endif

    }

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

// CSRSAlgorithmManager::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CSRSAlgorithmManager::ConstructL()

    {

    RUBY_DEBUG_BLOCK( "CSRSAlgorithmManager::ConstructL()" );

    // Resource handler reads the DevASR resource file

    iResourceHandler = CDevASRResourceHandler::NewL();

    iRecognitionAlgMgr = CRecognitionAlgMgr::NewL( *this );

    iVMAlgorithmManager = CVMAlgorithmManager::NewL( *iDevASRObserver, *this );

    // Queue containing audio buffers

    iAudioBufferQue = new ( ELeave ) TSglQue<CQueItem>( _FOFF( CQueItem, iLink ) );

    // Set default priority settings

    iPrioritySettings.iState = EMMFStateRecording;

    iPrioritySettings.iPriority = KDefaultPriority;

    iPrioritySettings.iPref = ( TMdaPriorityPreference ) KAudioPrefVocosRecog;

    // CenRep utility class

    CDevAsrCenRep* cenRep = CDevAsrCenRep::NewL();

    CleanupStack::PushL( cenRep );

    iRecognitionAlgMgr->SetRejection( cenRep->RejectionValue() );

    CleanupStack::PopAndDestroy( cenRep );

    CActiveScheduler::Add( this );

    RUBY_DEBUG1( "associated DevSound instance [%x]", iDevSound );

    RUBY_DEBUG1( "associated Recognition AlgMgr instance [%x]", iRecognitionAlgMgr );

    RUBY_DEBUG1( "associated Vocabulary AlgMgr instance [%x]", iRecognitionAlgMgr );

    }

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

// CSRSAlgorithmManager::NewL

// Two-phased constructor.

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

//

CSRSAlgorithmManager* CSRSAlgorithmManager::NewL( MDevASRObserver& aObserver )

    {

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

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CSRSAlgorithmManager::~CSRSAlgorithmManager

// Destructor.

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

//

CSRSAlgorithmManager::~CSRSAlgorithmManager()

    {

    RUBY_DEBUG0( "CSRSAlgorithmManager::~CSRSAlgorithmManager()" );

    //delete iAudioBuffer;

    delete iQueItem;

    // Empty audio queue if there happens to be something

    if ( iAudioBufferQue )

        {

        while ( !iAudioBufferQue->IsEmpty() )

            {

            iQueItem = iAudioBufferQue->First();

            iAudioBufferQue->Remove( *iQueItem );

            delete iQueItem;

            }

        delete iAudioBufferQue;

        }

    delete iBufferUnderConstruction;

    iBufferUnderConstruction = NULL;

    iConstructionPoint = 0;

    delete iDevSound;

    delete iRecognitionAlgMgr;

    delete iVMAlgorithmManager;

    delete iResourceHandler;

    }

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

// CSRSAlgorithmManager::AdaptL

// Adapts vocabulary and models based on correct result.

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

//

void CSRSAlgorithmManager::AdaptL( const CSIResultSet& aResultSet, 

                                   TInt aResultIndex )

    {

    RUBY_DEBUG_BLOCK( "CSRSAlgorithmManager::AdaptL()" );

    // Adapt vocab

    iVMAlgorithmManager->AdaptVocabL( aResultSet, aResultIndex );

    // Find language of correct result

    const CSIResult& iCorrectResult = aResultSet.AtL( aResultIndex );

    TSIGrammarID grammarID = iCorrectResult.GrammarID();

    TSIRuleID ruleID = iCorrectResult.RuleID();

    TSIRuleVariantID ruleVariantID = iCorrectResult.RuleVariantID();

    CSICompiledGrammar* siActiveGrammar = NULL;

    CSICompiledGrammar* siNonActiveGrammar = NULL;

    CSICompiledGrammar* siGrammar = NULL;

    TRAPD( error, GetGrammarL( grammarID, &siActiveGrammar, &siNonActiveGrammar ) );

    User::LeaveIfError( error );

    TInt index = 0;

    if ( siActiveGrammar != NULL )

        {

        siGrammar = siActiveGrammar;

        }

    else if ( siNonActiveGrammar != NULL )

        {

        siGrammar = siNonActiveGrammar;

        }

    else

        {

        User::Leave( KErrNotFound );	

        }

    index = siGrammar->Find( ruleID );

    User::LeaveIfError( index );

    CSIRule& rule = siGrammar->AtL( index );

    index = rule.Find( ruleVariantID );

    User::LeaveIfError( index );

    CSIRuleVariant& ruleVariant = rule.AtL( index );

    // Adapt models

    iRecognitionAlgMgr->AdaptModelsL( aResultSet, aResultIndex, ruleVariant.Language() );

    }

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

// CSRSAlgorithmManager::CompileGrammarL

// Forward call to CVMAlgorithmManager.

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

//

void CSRSAlgorithmManager::CompileGrammarL( CSICompiledGrammar& aGrammar/*,

                                            CSIModelBank& aModelBank*/ )

    {

    RUBY_DEBUG_BLOCK( "CSRSAlgorithmManager::CompileGrammarL()" );

    iVMAlgorithmManager->CompileGrammarL( aGrammar/*, aModelBank*/ );

    }

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

// CSRSAlgorithmManager::ComputeNewGrammarSizeL

// Forward call to CVMAlgorithmManager.

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

//

void CSRSAlgorithmManager::ComputeNewGrammarSizeL( const CSIGrammar& aGrammar, 

                                                   const TUint32 aTargetNRuleVariants, 

                                                   const TUint32 aMaxNRuleVariants, 

                                                   const RArray<TUint>& aNewRuleScores, 

                                                   RArray<TUint>& aNNeNRuleVariants, 

                                                   TUint32& aNPrune )

    {

    RUBY_DEBUG_BLOCK( "CSRSAlgorithmManager::ComputeNewGrammarSizeL()" );

    iVMAlgorithmManager->ComputeNewGrammarSizeL( aGrammar,

                                                 aTargetNRuleVariants,

                                                 aMaxNRuleVariants,

                                                 aNewRuleScores,

                                                 aNNeNRuleVariants,

                                                 aNPrune );

    }

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

// CSRSAlgorithmManager::PruneGrammar

// Forward call to CVMAlgorithmManager.

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

//

TBool CSRSAlgorithmManager::PruneGrammar( const CSIGrammar& aGrammar, 

                                          const TUint32 aMinNumber, 

                                          RArray<TSIRuleVariantInfo>& aPrunedRuleVariants )

    {

    return iVMAlgorithmManager->PruneGrammar( aGrammar, aMinNumber, aPrunedRuleVariants );

    }

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

// CSRSAlgorithmManager::StartTrainingFromTextL

// Forward call to CVMAlgorithmManager.

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

// 

void CSRSAlgorithmManager::StartTrainingFromTextL( CSITtpWordList& aWordList, 

                                                   const RArray<TLanguage>& aDefaultLanguage, 

                                                   const RArray<TUint32>& aMaxNPronunsForWord )

    {

    RUBY_DEBUG_BLOCK( "CSRSAlgorithmManager::StartTrainingFromTextL()" );

    iVMAlgorithmManager->TrainFromTextL( aWordList, aDefaultLanguage, aMaxNPronunsForWord );

    }

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

// CSRSAlgorithmManager::ResolveResult

// Forward call to CVMAlgorithmManager.

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

// 

void CSRSAlgorithmManager::ResolveResult( const RArray<TUint>& aNBestIDs,

                                          CSIResultSet& aSIResultSet,

                                          const RPointerArray<CSICompiledGrammar>& aSICompiledGrammar,

                                          const TDesC8& aCombinedData/*,

                                          CSIModelBank& iSIModelBank*/ )

    {

    iVMAlgorithmManager->ResolveResult( aNBestIDs, aSIResultSet, 

                                        aSICompiledGrammar, aCombinedData/*,

                                        iSIModelBank*/ );

    }

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

// CSRSAlgorithmManager::CombineGrammarL

// Forward call to CVMAlgorithmManager.

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

// 

void CSRSAlgorithmManager::CombineGrammarL( const RPointerArray<CSICompiledGrammar>& aCompiledGrammars,

                                            const RPointerArray<TSIRuleVariantInfo>& aExcludedRules )

    {

    RUBY_DEBUG_BLOCK( "CSRSAlgorithmManager::CombineGrammarL()" );

    iVMAlgorithmManager->CombineGrammarL( aCompiledGrammars, aExcludedRules );

    }

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

// CSRSAlgorithmManager::ConfigureSoundDeviceL

// Configure sound device according to resource file parameters

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

//

void CSRSAlgorithmManager::ConfigureSoundDeviceL()

    {

    RUBY_DEBUG_BLOCK( "CSRSAlgorithmManager::ConfigureSoundDeviceL()" );

	// Fetch the default configuration from DevSound

    iDevSoundCapabilities = iDevSound->Config();

	// Now, configure it according to resource file parameters

    switch ( iResourceHandler->iSamplingRate )

		{

		case 8000:

			iDevSoundCapabilities.iRate = EMMFSampleRate8000Hz;

			break;

		case 11025:

			iDevSoundCapabilities.iRate = EMMFSampleRate11025Hz;

			break;

		case 16000:

			iDevSoundCapabilities.iRate = EMMFSampleRate16000Hz;

			break;

		case 22050:

			iDevSoundCapabilities.iRate = EMMFSampleRate22050Hz;

			break;

		case 32000:

			iDevSoundCapabilities.iRate = EMMFSampleRate32000Hz;

			break;

		case 44100:

			iDevSoundCapabilities.iRate = EMMFSampleRate44100Hz;

			break;

		case 48000:

			iDevSoundCapabilities.iRate = EMMFSampleRate48000Hz;

			break;

		case 88200:

			iDevSoundCapabilities.iRate = EMMFSampleRate88200Hz;

			break;

		case 96000:

			iDevSoundCapabilities.iRate = EMMFSampleRate96000Hz;

			break;

		default:

			iDevSoundCapabilities.iRate = EMMFSampleRate8000Hz;

			break;

		}

    iDevSoundCapabilities.iBufferSize = iResourceHandler->iBufferSize;

    if ( iResourceHandler->iBitsPerSample == 8 )

        {

        iDevSoundCapabilities.iEncoding = EMMFSoundEncoding8BitPCM;

        }

    else

        {

        iDevSoundCapabilities.iEncoding = EMMFSoundEncoding16BitPCM;

        }

	// Now, configure DevSound according to new parameters.

    iDevSound->SetConfigL( iDevSoundCapabilities );

    RUBY_DEBUG1( "DevSound Max Volume = %d", iDevSound->MaxVolume() );

    RUBY_DEBUG1( "DevSound Max Gain = %d", iDevSound->MaxGain() );

    // In order to avoid truncation, computation must be done this way.

    iCurrentVolume = ( ( iDevSound->MaxVolume() * iResourceHandler->iSpeakerVolume ) + 50 ) / 100;

    iCurrentGain = ( ( iDevSound->MaxGain() * iResourceHandler->iMicrophoneGain ) + 50 ) / 100;

    // The speaker volume is set to the percentage of max volume supported.

    iDevSound->SetVolume( iCurrentVolume );

    // The gain is set to the percentage of max gain supported.

    iDevSound->SetGain( iCurrentGain );

    iDevSoundCapabilities = iDevSound->Config();

    RUBY_DEBUG1( "DevSound Set Volume = %d", iCurrentVolume );

    RUBY_DEBUG1( "DevSound Set Gain = %d", iCurrentGain );

    RUBY_DEBUG1( "DevSound Buffer Size = %d", iDevSoundCapabilities.iBufferSize );

    }

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

// CSRSAlgorithmManager::GetEnginePropertiesL

// Retreive the properties of the underlying speech recognition engine.

// An array of values corresponding to the querried identifiers will be populated.

// The function may leave with KErrArgument.

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

//

void CSRSAlgorithmManager::GetEnginePropertiesL( const RArray<TInt>& aPropertyId,

                                                 RArray<TInt>& aPropertyValue )

    {

    RUBY_DEBUG_BLOCK( "SRSAlgorithmManager::EnginePropertiesL()" );

    // Check that arrays are ok

    if ( aPropertyId.Count() != aPropertyValue.Count() )

        {

        User::Leave( KErrArgument );

        }

	// Run through the engine properties and fill in known values

    for ( TInt index = 0; index < aPropertyId.Count(); index++)

        {

        switch( aPropertyId[index] )

            {

            case KSamplingRate:

                aPropertyValue[index] = iResourceHandler->iSamplingRate;

                break;

            case KBitsPerSample:

                aPropertyValue[index] = iResourceHandler->iBitsPerSample;

                break;

            default:

                break;

            }

        }

	// Get engine properties from other sources.

    iRecognitionAlgMgr->GetEnginePropertiesL( aPropertyId, aPropertyValue );

    iVMAlgorithmManager->GetEnginePropertiesL( aPropertyId, aPropertyValue );

    }

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

// CSRSAlgorithmManager::InitFrontEnd

// Initializes the recognition front end.

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

//

void CSRSAlgorithmManager::InitFrontEnd( TRecognizerMode aMode )

    {

    RUBY_DEBUG0( "CSRSAlgorithmManager::InitFrontEnd()" );

	iProcessingUtterance = EFalse;

    if ( iMode != aMode )

        {

        return;

        }

    StateTransition( EDASRInitRecognition );

    iRecognitionAlgMgr->InitFrontEnd( aMode );

    }

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

// CSRSAlgorithmManager::InitRecognizerBE

// Initializes the recognition back-end. The module responsible for recognition

// function is started as a result.

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

//

void CSRSAlgorithmManager::InitRecognizerBE( CSIResultSet& aResult )

    {

    RUBY_DEBUG0( "CSRSAlgorithmManager::InitRecognizerBE()" );

    iRecognitionAlgMgr->InitRecognizerBE( aResult );

    }

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

// CSRSAlgorithmManager::IsGrammarLoaded

// Checks if grammar has been loaded.

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

//

TBool CSRSAlgorithmManager::IsGrammarLoaded( TSIGrammarID aGrammarID )

    {

    CSICompiledGrammar* siActiveGrammar = NULL;

    CSICompiledGrammar* siNonActiveGrammar = NULL;

    TRAPD( error, GetGrammarL( aGrammarID, &siActiveGrammar, &siNonActiveGrammar ) );

    if ( error != KErrNone )

        {

        return EFalse;

        }

    if ( siActiveGrammar != NULL )

        {

        return ETrue;

        }

    else if ( siNonActiveGrammar != NULL )

        {

        return ETrue;

        }

    return EFalse;

    }

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

// CSRSAlgorithmManager::IsGrammarActive

// Checks if grammar is currently active.

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

//

TBool CSRSAlgorithmManager::IsGrammarActive( TSIGrammarID aGrammarID )

    {

    RUBY_DEBUG0( "CSRSAlgorithmManager::IsGrammarActive()" );

    CSICompiledGrammar* siActiveGrammar = NULL;

    CSICompiledGrammar* siNonActiveGrammar = NULL;