diff -r 8ce15fced3a6 -r cad71a31b7fc srsf/devasr/src/devasrvmalgorithmmanager.cpp --- a/srsf/devasr/src/devasrvmalgorithmmanager.cpp Thu Aug 19 09:56:14 2010 +0300 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,443 +0,0 @@ -/* -* 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