diff -r cad71a31b7fc -r e36f3802f733 srsf/devasr/src/devasrvmalgorithmmanager.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/srsf/devasr/src/devasrvmalgorithmmanager.cpp Wed Sep 01 12:29:17 2010 +0100 @@ -0,0 +1,443 @@ +/* +* Copyright (c) 2004 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: Algorithm manager for grammar handling algorihtms. +* +*/ + + +// INCLUDE FILES +#include "devasrvmalgorithmmanager.h" +//#include "DevASRSrsAlgorithmManager.h" +#include +#include +#include "rubydebug.h" + + +// ============================ MEMBER FUNCTIONS =============================== + +// ----------------------------------------------------------------------------- +// CVMAlgorithmManager::CVMAlgorithmManager +// C++ default constructor can NOT contain any code, that +// might leave. +// ----------------------------------------------------------------------------- +// +CVMAlgorithmManager::CVMAlgorithmManager( MDevASRObserver& aObserver, + MVmAlgMgrObserver& aVmObserver ) + : iGrCompiler( NULL ), + iVocMan( NULL ), + iTtp( NULL ), + iObserver( aObserver ), + iTtpState( ETtpStateUninitialized ), + iGrState( EGrStateUninitialized ), + iVmAlgObserver( aVmObserver ) + { + // Nothing + } + + +// ----------------------------------------------------------------------------- +// CVMAlgorithmManager::ConstructL +// Symbian 2nd phase constructor can leave. +// ----------------------------------------------------------------------------- +// +void CVMAlgorithmManager::ConstructL() + { + RUBY_DEBUG_BLOCK( "CVMAlgorithmManager::ConstructL()" ); + + // TtpHwDevice + iTtp = CASRSTtpHwDevice::NewL( *this ); + iTtp->InitializeL(); + iTtp->SetPhonemeNotationL( _L("NIPA8" ) ); + iTtpState = ETtpStateIdle; + // Grammar compiler HW device + iGrCompiler = CASRSGrCompilerHwDevice::NewL( *this ); + iGrCompiler->InitializeL(); + iGrState = EGrStateIdle; + // VocManHwDevice + iVocMan = CASRSVocManHwDevice::NewL(); + iVocMan->InitializeL(); + } + + +// ----------------------------------------------------------------------------- +// CVMAlgorithmManager::NewL +// Two-phased constructor. +// ----------------------------------------------------------------------------- +// +CVMAlgorithmManager* CVMAlgorithmManager::NewL( MDevASRObserver& aObserver, + MVmAlgMgrObserver& aVmObserver ) + { + CVMAlgorithmManager* self = new( ELeave ) CVMAlgorithmManager( aObserver, aVmObserver ); + + CleanupStack::PushL( self ); + self->ConstructL(); + CleanupStack::Pop(); + + return self; + } + + +// ----------------------------------------------------------------------------- +// CVMAlgorithmManager::~CVMAlgorithmManager +// Destructor +// ----------------------------------------------------------------------------- +// +CVMAlgorithmManager::~CVMAlgorithmManager() + { + if ( iGrCompiler != NULL ) + { + iGrCompiler->Clear(); + } + delete iGrCompiler; + iGrCompiler = NULL; + if ( iVocMan != NULL ) + { + iVocMan->Clear(); + } + delete iVocMan; + iVocMan = NULL; + if ( iTtp != NULL ) + { + iTtp->Clear(); + } + delete iTtp; + iTtp = NULL; +// iDataArray.ResetAndDestroy(); + } + + +// ----------------------------------------------------------------------------- +// CVMAlgorithmManager::AdaptVocabL +// Use CASRVocManHwDevice to adapt rule. +// ----------------------------------------------------------------------------- +// +void CVMAlgorithmManager::AdaptVocabL( const CSIResultSet& aResultSet, + TInt aResultIndex ) + { + RUBY_DEBUG_BLOCK( "CVMAlgorithmManager::AdaptVocabL()" ); + + 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, iVmAlgObserver.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 ); + + // Do the actual vocabulary adaptation using VocManHwDevice + TRAP( error, iVocMan->AdaptL( ruleVariantID, rule ) ); + // Neglect possible error since it just might be due to the reason + // that there are no proper parameters in place within the RuleVariants.. + } + + +// ----------------------------------------------------------------------------- +// CVMAlgorithmManager::ComputeNewGrammarSizeL +// Use CASRVocManHwDevice to compute size. +// ----------------------------------------------------------------------------- +// +void CVMAlgorithmManager::ComputeNewGrammarSizeL( const CSIGrammar& aGrammar, + const TUint32 aTargetNRuleVariants, + const TUint32 aMaxNRuleVariants, + const RArray& aNewRuleScores, + RArray& aNNeNRuleVariants, + TUint32& aNPrune ) + { + RUBY_DEBUG_BLOCK( "CVMAlgorithmManager::ComputeNewGrammarSizeL()" ); + + iVocMan->ComputeNRuleVariantsL( aGrammar, aTargetNRuleVariants, + aMaxNRuleVariants, aNewRuleScores, + aNNeNRuleVariants, aNPrune ); + } + + +// ----------------------------------------------------------------------------- +// CVMAlgorithmManager::CompileGrammarL +// Compiles SI grammar. +// ----------------------------------------------------------------------------- +// +void CVMAlgorithmManager::CompileGrammarL( CSICompiledGrammar& aGrammar/*, + CSIModelBank& aModelBank*/ ) + { + RUBY_DEBUG_BLOCK( "CVMAlgorithmManager::CompileGrammarL()" ); + + if ( iGrState == EGrStateUninitialized ) + { + User::Leave( KErrNotReady ); + } + if ( iGrState == EGrStateBusyCombining || iGrState == EGrStateBusyCompiling ) + { + User::Leave( KErrInUse ); + } + + iGrState = EGrStateBusyCompiling; + + iGrCompiler->CompileGrammarL( aGrammar/*, aModelBank*/ ); + } + + +// ----------------------------------------------------------------------------- +// CVMAlgorithmManager::CombineGrammarL +// Combines a list of grammars. +// ----------------------------------------------------------------------------- +// +void CVMAlgorithmManager::CombineGrammarL( const RPointerArray& aCompiledGrammars, + const RPointerArray& aExcludedRules ) + { + RUBY_DEBUG_BLOCK( "CVMAlgorithmManager::CombineGrammarL()" ); + + if ( iGrState == EGrStateUninitialized ) + { + User::Leave( KErrNotReady ); + } + if ( iGrState == EGrStateBusyCombining || iGrState == EGrStateBusyCompiling ) + { + User::Leave( KErrInUse ); + } + + iGrState = EGrStateBusyCombining; + + iGrCompiler->CombineGrammarL( aCompiledGrammars, aExcludedRules ); + } + +// ----------------------------------------------------------------------------- +// CVMAlgorithmManager::PruneGrammar +// Use CASRVocManHwDevice to prune a grammar. +// ----------------------------------------------------------------------------- +// +TBool CVMAlgorithmManager::PruneGrammar( const CSIGrammar& aGrammar, + const TUint32 aMinNumber, + RArray& aPrunedRuleVariants ) + { + return iVocMan->Prune( aGrammar, aMinNumber, aPrunedRuleVariants ); + } + + +// ----------------------------------------------------------------------------- +// CVMAlgorithmManager::ResolveResult +// Use CASRVocManHwDevice to resolve a result. +// ----------------------------------------------------------------------------- +// +void CVMAlgorithmManager::ResolveResult( const RArray& aNBestIDs, + CSIResultSet& aSIResultSet, + const RPointerArray& aSICompiledGrammar, + const TDesC8& aCombinedData/*, + CSIModelBank& iSIModelBank*/ ) + { + iGrCompiler->ResolveResult( aNBestIDs, aSIResultSet, + aSICompiledGrammar, aCombinedData ); + } + + +// ----------------------------------------------------------------------------- +// CVMAlgorithmManager::TrainFromText +// Use CVMAlgorithmManager to train from text. +// ----------------------------------------------------------------------------- +// +void CVMAlgorithmManager::TrainFromTextL( CSITtpWordList& aWordList, + const RArray& aDefaultLanguage, + const RArray& aMaxNPronunsForWord ) + { + RUBY_DEBUG_BLOCK( "CVMAlgorithmManager::TrainFromTextL()" ); + + if ( iTtpState == ETtpStateUninitialized ) + { + User::Leave( KErrNotReady ); + } + if ( iTtpState == ETtpStateBusy ) + { + User::Leave( KErrInUse ); + } + + iTtpState = ETtpStateBusy; + + TRAPD( error, iTtp->ConvertWordListL( aWordList, aDefaultLanguage, aMaxNPronunsForWord ) ); + if ( error != KErrNone ) + { + iTtpState = ETtpStateIdle; + User::Leave( error ); + } + } + + +// ----------------------------------------------------------------------------- +// CVMAlgorithmManager::Cancel +// Use CVMAlgorithmManager to cancel training. +// ----------------------------------------------------------------------------- +// +void CVMAlgorithmManager::Cancel() + { + if ( iTtpState == ETtpStateBusy ) + { + iTtp->CancelWordListConversion(); + } + if ( iGrState == EGrStateBusyCompiling ) + { + iGrCompiler->CancelCompilation(); + } + if ( iGrState == EGrStateBusyCombining ) + { + iGrCompiler->CancelCombination(); + } + } + + +// ----------------------------------------------------------------------------- +// GetEnginePropertiesL +// Returns properties of the underlying engines. +// ----------------------------------------------------------------------------- +// +void CVMAlgorithmManager::GetEnginePropertiesL( const RArray& /*aPropertyId*/, + RArray& /*aPropertyValue*/ ) + { + // Do nothing + } + +// ----------------------------------------------------------------------------- +// CVMAlgorithmManager::LoadEnginePropertiesL +// Loads properties to engine, invalid IDs are neglected. +// ----------------------------------------------------------------------------- +// +void CVMAlgorithmManager::LoadEnginePropertiesL( const RArray& /*aParameterId*/, + const RArray& /*aParameterValue*/ ) + { + // Do nothing + } + +// ----------------------------------------------------------------------------- +// MASRTtpHwDeviceObserver mixin begins +// ----------------------------------------------------------------------------- + + +// ----------------------------------------------------------------------------- +// CVMAlgorithmManager::MathdoConfigurationData +// +// ----------------------------------------------------------------------------- +// +HBufC8* CVMAlgorithmManager::MathdoConfigurationData( TUint32 aPackageType, + TUint32 aPackageID, + TUint32 aStartPosition, + TUint32 aEndPosition ) + { + // Call DevASR observer + return iObserver.ConfigurationData( aPackageType, aPackageID, + aStartPosition, aEndPosition ); + } + + +// ----------------------------------------------------------------------------- +// CVMAlgorithmManager::MathdoWordListReady +// +// ----------------------------------------------------------------------------- +// +void CVMAlgorithmManager::MathdoWordListReady( const TInt aError ) + { + RUBY_DEBUG0( "CVMAlgorithmManager::MathdoWordListReady()" ); + + iTtpState = ETtpStateIdle; + + // Call DevASR observer + iObserver.DevASREvent( EDevASRTrainFromText, aError ); + } + + +// ----------------------------------------------------------------------------- +// MASRTtpHwDeviceObserver mixin ends +// ----------------------------------------------------------------------------- + + +// ----------------------------------------------------------------------------- +// MASRGrCompilerObserver mixin begins +// ----------------------------------------------------------------------------- + +// ----------------------------------------------------------------------------- +// CVMAlgorithmManager::MghdoGrammarCompilerComplete +// +// ----------------------------------------------------------------------------- +// +void CVMAlgorithmManager::MghdoGrammarCompilerComplete( TInt aError ) + { + iGrState = EGrStateIdle; + // Forward callback to DevASR observer + iObserver.DevASREvent( EDevASRGrammarCompile, aError ); + } + +// ----------------------------------------------------------------------------- +// CVMAlgorithmManager::MghdoGrammarCombinerComplete +// +// ----------------------------------------------------------------------------- +// +void CVMAlgorithmManager::MghdoGrammarCombinerComplete( HBufC8* aResult, + TInt aError ) + { + iGrState = EGrStateIdle; + iVmAlgObserver.CombineComplete( aResult, aError ); + } + +// ----------------------------------------------------------------------------- +// CVMAlgorithmManager::MghdoSILexiconL +// +// ----------------------------------------------------------------------------- +// +CSILexicon* CVMAlgorithmManager::MghdoSILexiconL( TSILexiconID anID ) + { + RUBY_DEBUG_BLOCK( "CVMAlgorithmManager::MghdoSILexiconL()" ); + + return iObserver.SILexiconL( anID ); + } + +// ----------------------------------------------------------------------------- +// CVMAlgorithmManager::MghdoConfigurationData +// +// ----------------------------------------------------------------------------- +// +HBufC8* CVMAlgorithmManager::MghdoConfigurationData( TUint32 aPackageType, + TUint32 aPackageID, + TUint32 aStartPosition, + TUint32 aEndPosition ) + { + // Call DevASR observer + return iObserver.ConfigurationData( aPackageType, aPackageID, + aStartPosition, aEndPosition ); + } + + +// ----------------------------------------------------------------------------- +// MASRGrCompilerObserver mixin ends +// ----------------------------------------------------------------------------- + +// End of File