--- a/srsf/devasr/src/devasrrecognitionalgmgr.cpp Thu Aug 19 09:56:14 2010 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,1571 +0,0 @@
-/*
-* 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 Recognition Algorithm
-* Manager, a submodule of DevASR.
-*
-*/
-
-
-// INCLUDE FILES
-#ifdef _DEBUG
-#include <e32svr.h>
-#endif
-#include "devasrrecognitionalgmgr.h"
-#include "rubydebug.h"
-
-// CONSTANTS
-const TInt KInitFrontEnd = 1;
-//const TInt KInitTrainBE = 2;
-const TInt KInitRecognizerBE = 3;
-const TInt KLoadGrammar = 4;
-const TInt KLoadLexicon = 5;
-const TInt KLoadModels = 6;
-//const TInt KUtteranceDataRcvd = 7;
-const TInt KActivateGrammar = 8;
-const TInt KDeActivateGrammar = 9;
-const TInt KUnloadRule = 10;
-const TInt KUnloadGrammar = 11;
-
-//_LIT( KPanicDescriptor, "CRecognitionAlgMgr Panic" );
-
-// ============================ MEMBER FUNCTIONS ===============================
-
-// -----------------------------------------------------------------------------
-// CRecognitionAlgMgr::CRecognitionAlgMgr
-// C++ default constructor can NOT contain any code, that
-// might leave.
-// -----------------------------------------------------------------------------
-//
-CRecognitionAlgMgr::CRecognitionAlgMgr( MRecAlgMgrObserver& aObserver )
- : CActive( CActive::EPriorityStandard ),
- iRecAlgMgrObserver( &aObserver ),
- iCombinedGrammar( NULL ),
- iCombineNeeded( ETrue ),
- iInitialized( EFalse ),
- iRecoHw( NULL ),
- iAdaptHw( NULL ),
- iSDModelBank( NULL ),
- iSIModelBank( NULL ),
- iSDGrammar( NULL ),
- iSIGrammar( NULL ),
- iSICompGrammar( NULL ),
- iSDCompGrammar( NULL ),
- iSDLexicon( NULL ),
- iSILexicon( NULL ),
- iFEState( EIdle ),
- iBEState( EIdle ),
- iFeatures( EFalse ),
- iAdaptation( ETrue ),
- iAdaptationData( NULL )
- {
- RUBY_DEBUG0( "CRecognitionAlgMgr::CRecognitionAlgMgr()" );
- }
-
-
-// -----------------------------------------------------------------------------
-// CRecognitionAlgMgr::ConstructL
-// Symbian 2nd phase constructor can leave.
-// -----------------------------------------------------------------------------
-//
-void CRecognitionAlgMgr::ConstructL()
- {
- RUBY_DEBUG_BLOCK( "CRecognitionAlgMgr::ConstructL()" );
-
- iRecoHw = CASRSRecognitionHwDevice::NewL( *this );
- iRecoHw->InitializeL();
-
- iAdaptHw = CASRSAdaptHwDevice::NewL( *this );
- iAdaptHw->InitializeL();
-
- CActiveScheduler::Add(this);
-
- RUBY_DEBUG1( "CRecognitionAlgMgr::ConstructL(): RecoHwDevice instance [%x]", iRecoHw );
- }
-
-
-// -----------------------------------------------------------------------------
-// CRecognitionAlgMgr::NewL
-// Two-phased constructor.
-// -----------------------------------------------------------------------------
-//
-CRecognitionAlgMgr* CRecognitionAlgMgr::NewL( MRecAlgMgrObserver& aObserver )
- {
- RUBY_DEBUG_BLOCK( "CRecognitionAlgMgr::ConstructL()" );
-
- CRecognitionAlgMgr* self = new ( ELeave ) CRecognitionAlgMgr( aObserver );
-
- CleanupStack::PushL( self );
- self->ConstructL();
- CleanupStack::Pop( self );
-
- return self;
- }
-
-
-// -----------------------------------------------------------------------------
-// CRecognitionAlgMgr::~CRecognitionAlgMgr
-// Destructor
-// -----------------------------------------------------------------------------
-//
-CRecognitionAlgMgr::~CRecognitionAlgMgr()
- {
- RUBY_DEBUG0( "CRecognitionAlgMgr::~CRecognitionAlgMgr()" );
-
- iSIActiveGrammars.Reset();
- iSIDeActivatedGrammars.Reset();
- iNBestList.Reset();
- iScores.Reset();
-
- if ( iRecoHw != NULL )
- {
- iRecoHw->Clear();
- delete iRecoHw;
- }
-
- if ( iAdaptHw != NULL )
- {
- iAdaptHw->Clear();
- delete iAdaptHw;
- }
-
- delete iCombinedGrammar;
-
- iBlackList.ResetAndDestroy();
- iBlackList.Close();
-
- delete iAdaptationData;
- }
-
-
-// -----------------------------------------------------------------------------
-// CRecognitionAlgMgr::AdaptModelsL
-// Adapts models.
-// -----------------------------------------------------------------------------
-//
-void CRecognitionAlgMgr::AdaptModelsL( const CSIResultSet& aResultSet,
- TInt aResultIndex,
- TLanguage aLanguage )
- {
- RUBY_DEBUG_BLOCK( "CRecognitionAlgMgr::AdaptModelsL()" );
-
- RUBY_DEBUG1( "CRecognitionAlgMgr::AdaptModelsL aResultIndex: %x", aResultIndex );
-
- // TODO: Not too nice to remove consts like this
- CSIResult& iCorrectResult = ( CSIResult& ) aResultSet.AtL( aResultIndex );
-
- // Check that we have a modelbank to adapt
- if ( iSIModelBank == NULL )
- {
- User::Leave( KErrNotReady );
- }
-
- CSIResultSet& iResultSet = ( CSIResultSet& ) aResultSet;
- iAdaptHw->StartAdaptationL( iResultSet.AdaptationData(),
- *iSIModelBank,
- iCorrectResult.Pronunciation(),
- aLanguage );
- }
-
-
-// -----------------------------------------------------------------------------
-// CRecognitionAlgMgr::InitFrontEnd
-// Receives the initialize frontend request and starts an asynchronous handler
-// for the request.
-// -----------------------------------------------------------------------------
-//
-void CRecognitionAlgMgr::InitFrontEnd( TRecognizerMode aMode )
- {
- RUBY_DEBUG0( "CRecognitionAlgMgr::InitFrontEnd()" );
-
- // Save arguments and set code
- iMode = aMode;
- iRequestFunction = KInitFrontEnd;
- Ready( KErrNone );
- }
-
-
-// -----------------------------------------------------------------------------
-// CRecognitionAlgMgr::HandleInitFrontEnd
-// Asynchronously handles the initialize frontend request. The front-end module
-// is started as a result.
-// -----------------------------------------------------------------------------
-//
-void CRecognitionAlgMgr::HandleInitFrontEnd()
- {
- RUBY_DEBUG0( "CRecognitionAlgMgr::HandleInitFrontEnd()" );
-
- if ( !iInitialized )
- {
- iRecAlgMgrObserver->InitFEComplete( KErrNotReady );
- return;
- }
-
- if ( iFEState != EIdle )
- {
- iRecAlgMgrObserver->InitFEComplete( KErrInUse );
- return;
- }
-
- if ( iMode != ESiRecognition && iMode != ESiRecognitionSpeechInput )
- {
- iRecAlgMgrObserver->InitFEComplete( KErrNotSupported );
- return;
- }
-
- TInt error = KErrNone;
-
- if ( iFeatures || iAdaptation )
- {
- TRAP( error, iRecoHw->InitRecognizerFEL( ETrue ) );
- }
- else
- {
- TRAP( error, iRecoHw->InitRecognizerFEL( EFalse ) );
- }
-
- iRecAlgMgrObserver->InitFEComplete( error );
- }
-
-
-// -----------------------------------------------------------------------------
-// CRecognitionAlgMgr::InitRecognizerBE
-// Receives the initialize recognition backend request and starts an asynchronous
-// handler for the request.
-// -----------------------------------------------------------------------------
-//
-void CRecognitionAlgMgr::InitRecognizerBE( CSIResultSet& aResult )
- {
- RUBY_DEBUG0( "CRecognitionAlgMgr::InitRecognizerBE()" );
-
- // Save arguments and set code
- iSDResult = NULL;
- iSIResult = &aResult;
- iRequestFunction = KInitRecognizerBE;
- Ready( KErrNone );
- }
-
-
-// -----------------------------------------------------------------------------
-// CRecognitionAlgMgr::HandleInitRecognizerBE
-// Asynchronously handles the initialize recognition backend request. The backend
-// module for recognition function is started as a result.
-// -----------------------------------------------------------------------------
-//
-void CRecognitionAlgMgr::HandleInitRecognizerBE()
- {
- RUBY_DEBUG0( "CRecognitionAlgMgr::HandleInitRecognizerBE()" );
-
- if ( !iInitialized )
- {
- iRecAlgMgrObserver->InitRecognizerBEComplete( KErrNotReady );
- return;
- }
-
- if ( iBEState != EIdle )
- {
- iRecAlgMgrObserver->InitRecognizerBEComplete( KErrInUse );
- return;
- }
- TInt error( KErrNone );
- if ( iSDResult )
- {
- iRecAlgMgrObserver->InitRecognizerBEComplete( KErrNotSupported );
- return;
- }
- else if ( iSIResult )
- {
- // Call RecoHwDevice
- if ( ( iSIActiveGrammars.Count() == 0 ) || ( iSIModelBank == NULL ) )
- {
- // Guess it is ok to leave with KErrNotReady if all necessary
- iRecAlgMgrObserver->InitRecognizerBEComplete( KErrNotReady );
- return;
- }
- else
- {
- if ( iCombineNeeded )
- {
- delete iCombinedGrammar;
- iCombinedGrammar = NULL;
-
- TRAPD( error, iRecAlgMgrObserver->CombineGrammarL( iSIActiveGrammars, iBlackList ) );
- if ( error != KErrNone )
- {
- iRecAlgMgrObserver->InitRecognizerBEComplete( error );
- }
- // Wait for the callback from grammar compilation!
- return;
- }
- // Call reco HW device
- TRAP( error, iRecoHw->InitRecognizerBEL( iCombinedGrammar->Des(), *iSIModelBank ) );
- if ( error != KErrNone )
- {
- iRecAlgMgrObserver->InitRecognizerBEComplete( error );
- }
- }
- }
- else
- {
- error = KErrArgument;
- }
-
- if ( error == KErrNone )
- {
- iBEState = EProcessing;
- }
- }
-
-
-// -----------------------------------------------------------------------------
-// CRecognitionAlgMgr::LoadGrammarL
-// Receives the load grammar request and start the asynchronous handler.
-// -----------------------------------------------------------------------------
-//
-void CRecognitionAlgMgr::LoadGrammarL( const CSIGrammar& aGrammar )
- {
- RUBY_DEBUG_BLOCK( "CRecognitionAlgMgr::LoadGrammarL()" );
-
- if ( IsActive() )
- {
- // Callback before the request function returns
- User::Leave( KErrServerBusy );
- return;
- }
-
- // Save arguments and set code
- iSIGrammar = &aGrammar;
- iRequestFunction = KLoadGrammar;
- Ready( KErrNone );
- }
-
-
-// -----------------------------------------------------------------------------
-// CRecognitionAlgMgr::LoadGrammarL
-// Receives the load grammar request and start the asynchronous handler.
-// -----------------------------------------------------------------------------
-//
-void CRecognitionAlgMgr::LoadGrammarL( const CSICompiledGrammar& aGrammar )
- {
- RUBY_DEBUG_BLOCK( "CRecognitionAlgMgr::LoadGrammarL()" );
-
- if ( IsActive() )
- {
- // Callback before the request function returns
- User::Leave( KErrServerBusy );
- return;
- }
-
- // Save arguments and set code
- iSICompGrammar = &aGrammar;
-/* __ASSERT_DEBUG( iSDGrammar == NULL, User::Panic( KPanicDescriptor, KErrCorrupt ) );
- __ASSERT_DEBUG( iSIGrammar == NULL, User::Panic( KPanicDescriptor, KErrCorrupt ) );*/
- iRequestFunction = KLoadGrammar;
- Ready( KErrNone );
- }
-
-
-// -----------------------------------------------------------------------------
-// CRecognitionAlgMgr::HandleLoadGrammar
-// Asynchronous handler for Load Grammar request.
-// -----------------------------------------------------------------------------
-//
-void CRecognitionAlgMgr::HandleLoadGrammar()
- {
- RUBY_DEBUG0( "CRecognitionAlgMgr::HandleLoadGrammar()" );
-
- TInt error( KErrNone );
-
- if ( !iInitialized )
- {
- iRecAlgMgrObserver->LoadGrammarComplete( KErrNotReady );
- return;
- }
-
- if ( iSICompGrammar )
- {
-
- if ( iSICompGrammar->Count() < 1 )
- {
- iRecAlgMgrObserver->LoadGrammarComplete( KErrArgument );
- return;
- }
-
- error = iSIActiveGrammars.Append( iSICompGrammar );
-
- iSICompGrammar = NULL;
-
- // Mark that there is need to recombine grammars
- iCombineNeeded = ETrue;
-
- iRecAlgMgrObserver->LoadGrammarComplete( error );
-
- }
- else
- {
- iRecAlgMgrObserver->LoadGrammarComplete( KErrNotSupported );
- }
- }
-
-
-// -----------------------------------------------------------------------------
-// CRecognitionAlgMgr::UnloadGrammarL
-// Receives the unload grammar request and start the asynchronous handler.
-// -----------------------------------------------------------------------------
-//
-void CRecognitionAlgMgr::UnloadGrammarL( const CSIGrammar& aGrammar )
- {
- RUBY_DEBUG_BLOCK( "CRecognitionAlgMgr::UnloadGrammarL()" );
-
- if ( IsActive() )
- {
- // Callback before the request function returns
- User::Leave( KErrServerBusy );
- return;
- }
-
- // Save arguments and set code
- iSIGrammar = &aGrammar;
- iRequestFunction = KUnloadGrammar;
- Ready( KErrNone );
- }
-
-
-// -----------------------------------------------------------------------------
-// CRecognitionAlgMgr::UnloadGrammarL
-// Receives the unload grammar request and start the asynchronous handler.
-// -----------------------------------------------------------------------------
-//
-void CRecognitionAlgMgr::UnloadGrammarL( const CSICompiledGrammar& aGrammar )
- {
- RUBY_DEBUG_BLOCK( "CRecognitionAlgMgr::UnloadGrammarL()" );
-
- if ( IsActive() )
- {
- // Callback before the request function returns
- User::Leave( KErrServerBusy );
- return;
- }
-
- // Save arguments and set code
- iSICompGrammar = &aGrammar;
- iRequestFunction = KUnloadGrammar;
- Ready( KErrNone );
- }
-
-
-// -----------------------------------------------------------------------------
-// CRecognitionAlgMgr::HandleUnloadGrammar
-// Asynchronous handler for Load Grammar request.
-// -----------------------------------------------------------------------------
-//
-void CRecognitionAlgMgr::HandleUnloadGrammar()
- {
- RUBY_DEBUG0( "CRecognitionAlgMgr::HandleUnloadGrammar()" );
-
- CSICompiledGrammar* siActiveGrammar = NULL;
- CSICompiledGrammar* siNonActiveGrammar = NULL;
-
- if ( !iInitialized )
- {
- iRecAlgMgrObserver->UnloadGrammarComplete( KErrNotReady );
- return;
- }
-
- if ( iSICompGrammar )
- {
-
- TRAPD( error, GetGrammarL( iSICompGrammar->GrammarID(), &siActiveGrammar, &siNonActiveGrammar ) ); // Leaves if not found
- if ( error != KErrNone )
- {
- iRecAlgMgrObserver->UnloadGrammarComplete( error );
- return;
- }
-
- if ( siActiveGrammar )
- {
- // Remove grammar from active grammars
- iSIActiveGrammars.Remove( iSIActiveGrammars.Find( siActiveGrammar ) );
- // Mark that there is need to recombine grammars
- iCombineNeeded = ETrue;
- }
- else if ( siNonActiveGrammar )
- {
- // Remove grammar from deactive
- iSIActiveGrammars.Remove( iSIActiveGrammars.Find( siActiveGrammar ) );
- // No need to set recombination flag
- }
- else
- {
- iRecAlgMgrObserver->UnloadGrammarComplete( KErrNotFound );
- return;
- }
- }
- else
- {
- iRecAlgMgrObserver->UnloadGrammarComplete( KErrNotSupported );
- return;
- }
-
- iRecAlgMgrObserver->UnloadGrammarComplete( KErrNone );
- }
-
-
-// -----------------------------------------------------------------------------
-// CRecognitionAlgMgr::GetGrammarL
-// Find grammar based on identifier
-// -----------------------------------------------------------------------------
-//
-void CRecognitionAlgMgr::GetGrammarL( const TSIGrammarID aGrammarID,
- CSICompiledGrammar** aSIActiveGrammar,
- CSICompiledGrammar** aSIDeActivatedGrammar )
- {
- RUBY_DEBUG_BLOCK( "CRecognitionAlgMgr::GetGrammarL()" );
-
- // Find the grammar.
- // One of the arrays should contain the specified grammar and
- // others are empty.
- TInt i( 0 );
-
- // SI active grammars.
- for ( i = 0; i < iSIActiveGrammars.Count(); i++ )
- {
- if ( aGrammarID == iSIActiveGrammars[i]->GrammarID() )
- {
- // Grammar found.
- *aSIActiveGrammar = iSIActiveGrammars[i];
- *aSIDeActivatedGrammar = NULL;
- return;
- }
- }
-
- // SI deactived grammars.
- for ( i = 0; i < iSIDeActivatedGrammars.Count(); i++ )
- {
- if ( aGrammarID == iSIDeActivatedGrammars[i]->GrammarID() )
- {
- // Grammar found.
- *aSIDeActivatedGrammar = iSIDeActivatedGrammars[i];
- *aSIActiveGrammar = NULL;
- return;
- }
- }
-
- User::Leave( KErrNotFound );
- }
-
-
-// -----------------------------------------------------------------------------
-// CRecognitionAlgMgr::ActivateGrammarL
-// Receives the load grammar request and start the asynchronous handler.
-// -----------------------------------------------------------------------------
-//
-void CRecognitionAlgMgr::ActivateGrammarL( const TSIGrammarID aGrammarID )
- {
- RUBY_DEBUG_BLOCK( "CRecognitionAlgMgr::ActivateGrammarL()" );
-
- if ( IsActive() )
- {
- User::Leave( KErrServerBusy );
- }
-
- iRequestFunction = KActivateGrammar;
- iGrammarID = aGrammarID;
- Ready( KErrNone );
- }
-
-
-// -----------------------------------------------------------------------------
-// CRecognitionAlgMgr::HandleActivateGrammar
-// Asynchronous handler for activate grammar request.
-// -----------------------------------------------------------------------------
-//
-void CRecognitionAlgMgr::HandleActivateGrammar()
- {
- RUBY_DEBUG0( "CRecognitionAlgMgr::HandleActivateGrammar()" );
-
- CSICompiledGrammar* siActiveGrammar = NULL;
- CSICompiledGrammar* siNonActiveGrammar = NULL;
-
- if ( !iInitialized )
- {
- iRecAlgMgrObserver->ActivateGrammarComplete( KErrNotReady );
- }
-
- // Find the grammar
- TRAPD( error, GetGrammarL( iGrammarID, &siActiveGrammar, &siNonActiveGrammar ) ); // Leaves if not found
- if ( error != KErrNone )
- {
- iRecAlgMgrObserver->ActivateGrammarComplete( error );
- }
-
- if ( siActiveGrammar )
- {
- // Do nothing since grammar is already active
- }
- else if ( siNonActiveGrammar )
- {
- // Move item from non-active grammar list to active list
- iSIActiveGrammars.Append( siNonActiveGrammar );
- iSIDeActivatedGrammars.Remove( iSIDeActivatedGrammars.Find( siNonActiveGrammar ) );
- // Mark that there is need to recombine grammars
- iCombineNeeded = ETrue;
- }
- else
- {
- iRecAlgMgrObserver->ActivateGrammarComplete( KErrNotFound );
- return;
- }
-
- iRecAlgMgrObserver->ActivateGrammarComplete( KErrNone );
- }
-
-
-// -----------------------------------------------------------------------------
-// CRecognitionAlgMgr::DeactivateGrammarL
-// Receives the load grammar request and start the asynchronous handler.
-// -----------------------------------------------------------------------------
-//
-void CRecognitionAlgMgr::DeactivateGrammarL( const TSIGrammarID aGrammarID )
- {
- RUBY_DEBUG_BLOCK( "CRecognitionAlgMgr::DeactivateGrammarL()" );
-
- if ( IsActive() )
- {
- User::Leave( KErrServerBusy );
- }
-
- iRequestFunction = KDeActivateGrammar;
- iGrammarID = aGrammarID;
- Ready( KErrNone );
- }
-
-
-// -----------------------------------------------------------------------------
-// CRecognitionAlgMgr::HandleDeActivateGrammar
-// Asynchronous handler for deactivate grammar request.
-// -----------------------------------------------------------------------------
-//
-void CRecognitionAlgMgr::HandleDeActivateGrammar()
- {
- RUBY_DEBUG0( "CRecognitionAlgMgr::HandleDeActivateGrammar()" );
-
- CSICompiledGrammar* siActiveGrammar = NULL;
- CSICompiledGrammar* siNonActiveGrammar = NULL;
-
- if ( !iInitialized )
- {
- iRecAlgMgrObserver->DeActivateGrammarComplete( KErrNotReady );
- }
-
- // Find the grammar
- TRAPD( error, GetGrammarL( iGrammarID, &siActiveGrammar, &siNonActiveGrammar ) ); // Leaves if not found
- if ( error != KErrNone )
- {
- iRecAlgMgrObserver->DeActivateGrammarComplete( error );
- }
-
- if ( siActiveGrammar )
- {
- // Move item from active grammar list to non-active list
- iSIDeActivatedGrammars.Append( siActiveGrammar );
- iSIActiveGrammars.Remove( iSIActiveGrammars.Find( siActiveGrammar ) );
- // Mark that there is need to recombine grammars
- iCombineNeeded = ETrue;
- }
- else if ( siNonActiveGrammar )
- {
- // Do nothing since grammar is already inactive
- }
- else
- {
- iRecAlgMgrObserver->DeActivateGrammarComplete( KErrNotFound );
- return;
- }
-
- iRecAlgMgrObserver->DeActivateGrammarComplete( KErrNone );
- }
-
-
-// -----------------------------------------------------------------------------
-// CRecognitionAlgMgr::LoadLexiconL
-// Receives the load lexicon request and start the asynchronous handler.
-// -----------------------------------------------------------------------------
-//
-void CRecognitionAlgMgr::LoadLexiconL( const CSILexicon& aLexicon )
- {
- RUBY_DEBUG_BLOCK( "CRecognitionAlgMgr::LoadLexiconL()" );
-
- // Save arguments and set code
- if ( IsActive() )
- {
- // Callback before the request function returns
- User::Leave( KErrServerBusy );
- return;
- }
-
- iSILexicon = &aLexicon;
-
- iRequestFunction = KLoadLexicon;
- Ready( KErrNone );
- }
-
-
-// -----------------------------------------------------------------------------
-// CRecognitionAlgMgr::HandleLoadLexicon
-// Asynchronous handler for Load Lexicon request.
-// -----------------------------------------------------------------------------
-//
-void CRecognitionAlgMgr::HandleLoadLexicon()
- {
- RUBY_DEBUG0( "CRecognitionAlgMgr::HandleLoadLexicon()" );
-
- TInt error( KErrNone );
-
- if ( !iInitialized )
- {
- iRecAlgMgrObserver->LoadLexiconComplete( KErrNotReady );
- return;
- }
-
- if ( iSDLexicon )
- {
- iSDLexicon = NULL;
- iRecAlgMgrObserver->LoadLexiconComplete( KErrNotSupported );
- return;
- }
- else if ( iSILexicon )
- {
- }
- else
- {
- error = KErrArgument;
- }
-
- // Do not load empty lexicon
- if ( iSILexicon && iSILexicon->Count() == 0 )
- {
- iSILexicon = NULL;
- iRecAlgMgrObserver->LoadLexiconComplete( KErrArgument );
- return;
- }
-
-/* __ASSERT_DEBUG( iSDLexicon == NULL, User::Panic( KPanicDescriptor, KErrCorrupt ) );
- __ASSERT_DEBUG( iSILexicon == NULL, User::Panic( KPanicDescriptor, KErrCorrupt ) );*/
-
- iRecAlgMgrObserver->LoadLexiconComplete( error );
- }
-
-
-// -----------------------------------------------------------------------------
-// CRecognitionAlgMgr::LoadModelsL
-// Receives the load models request and start the asynchronous handler.
-// -----------------------------------------------------------------------------
-//
-void CRecognitionAlgMgr::LoadModelsL( const CSDModelBank& aModels )
- {
- RUBY_DEBUG_BLOCK( "CRecognitionAlgMgr::LoadModelsL()" );
-
- if ( IsActive() )
- {
- User::Leave( KErrServerBusy );
- return;
- }
-
- // Save arguments and set code
- iSDModelBank = ( CSDModelBank* ) &aModels;
- iRequestFunction = KLoadModels;
- Ready( KErrNone );
- }
-
-
-// -----------------------------------------------------------------------------
-// CRecognitionAlgMgr::LoadModelsL
-// Receives the load models request and start the asynchronous handler.
-// -----------------------------------------------------------------------------
-//
-void CRecognitionAlgMgr::LoadModelsL( const CSIModelBank& aModels )
- {
- RUBY_DEBUG_BLOCK( "CRecognitionAlgMgr::LoadModelsL()" );
-
- if ( IsActive() )
- {
- User::Leave( KErrServerBusy );
- }
-
- // Save arguments and set code
- iSIModelBank = ( CSIModelBank* ) &aModels;
- iRequestFunction = KLoadModels;
- Ready( KErrNone );
- }
-
-
-// -----------------------------------------------------------------------------
-// CRecognitionAlgMgr::HandleLoadModels
-// Asynchronous handler for Load Models request.
-// -----------------------------------------------------------------------------
-//
-void CRecognitionAlgMgr::HandleLoadModels()
- {
- RUBY_DEBUG0( "CRecognitionAlgMgr::HandleLoadModels()" );
-
- TInt error( KErrNone );
-
- if ( !iInitialized )
- {
- iSDModelBank = NULL;
- iSIModelBank = NULL;
- iRecAlgMgrObserver->LoadModelsComplete( KErrNotReady );
- return;
- }
-
- if ( iSDModelBank )
- {
- // SD modelbank not supported
- iSDModelBank = NULL;
- iRecAlgMgrObserver->LoadModelsComplete( KErrNotSupported );
- return;
- }
- else if ( iSIModelBank )
- {
- }
- else
- {
- error = KErrArgument;
- }
-
- if ( iSIModelBank && iSIModelBank->Count() < 1 )
- {
- iSIModelBank = NULL;
- iRecAlgMgrObserver->LoadModelsComplete( KErrArgument );
- return;
- }
-
-/* __ASSERT_DEBUG( iSDModelBank == NULL, User::Panic( KPanicDescriptor, KErrCorrupt ) );
- __ASSERT_DEBUG( iSIModelBank == NULL, User::Panic( KPanicDescriptor, KErrCorrupt ) );*/
-
- iRecAlgMgrObserver->LoadModelsComplete( error );
- }
-
-
-// -----------------------------------------------------------------------------
-// CRecognitionAlgMgr::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 CRecognitionAlgMgr::GetEnginePropertiesL( const RArray<TInt>& aPropertyId,
- RArray<TInt>& aPropertyValue )
- {
- RUBY_DEBUG_BLOCK( "CRecognitionAlgMgr::GetEnginePropertiesL()" );
-
- for ( TInt index = 0; index < aPropertyId.Count(); index++ )
- {
- switch( aPropertyId[index] )
- {
- case KDevASRSendFeatures:
- if ( iFeatures )
- {
- aPropertyValue[index] = 1;
- }
- else
- {
- aPropertyValue[index] = 0;
- }
- break;
-
- case KDevASRAdaptation:
- if ( iAdaptation )
- {
- aPropertyValue[index] = 1;
- }
- else
- {
- aPropertyValue[index] = 0;
- }
- break;
-
- default:
- break;
-
- }
- }
- }
-
-
-// -----------------------------------------------------------------------------
-// CRecognitionAlgMgr::LoadEnginePropertiesL
-// Loads properties to engine, invalid IDs are neglected.
-// -----------------------------------------------------------------------------
-//
-void CRecognitionAlgMgr::LoadEnginePropertiesL( const RArray<TInt>& aParameterId,
- const RArray<TInt>& aParameterValue )
- {
- RUBY_DEBUG_BLOCK( "CRecognitionAlgMgr::LoadEnginePropertiesL()" );
-
- for ( TInt index = 0; index < aParameterId.Count(); index++ )
- {
- switch( aParameterId[index] )
- {
- case KDevASRSendFeatures:
- if ( aParameterValue[index] == 0 )
- {
- iFeatures = EFalse;
- }
- else
- {
- iFeatures = ETrue;
- }
- break;
-
- case KDevASRAdaptation:
- if ( aParameterValue[index] == 0 )
- {
- iAdaptation = EFalse;
- }
- else
- {
- iAdaptation = ETrue;
- }
- break;
-
- default:
- break;
- }
- }
- }
-
-
-// -----------------------------------------------------------------------------
-// CRecognitionAlgMgr::SendSpeechData
-// Sends utterance data to recognizer.
-// -----------------------------------------------------------------------------
-//
-void CRecognitionAlgMgr::SendSpeechData( TPtrC8& aBuffer, TBool aEnd )
- {
- iRecoHw->SendSpeechData( aBuffer, aEnd );
- }
-
-
-// -----------------------------------------------------------------------------
-// CRecognitionAlgMgr::StartRecSession
-// Signal the start of a recognition sesion.
-// -----------------------------------------------------------------------------
-//
-TInt CRecognitionAlgMgr::StartRecSession( TRecognizerMode aMode )
- {
- RUBY_DEBUG0( "CRecognitionAlgMgr::StartRecSession()" );
-
- TInt error( KErrNone );
-
- if ( !iInitialized )
- {
- return KErrNotReady;
- }
-
- if ( aMode == ESiRecognition )
- {
- iMode = aMode;
- }
- else if ( aMode == ESiRecognitionSpeechInput )
- {
- iMode = aMode;
- }
- else
- {
- return KErrNotSupported;
- }
-
- return error;
- }
-
-
-// -----------------------------------------------------------------------------
-// CRecognitionAlgMgr::StartRecognitionL
-// Start recognition.
-// -----------------------------------------------------------------------------
-//
-void CRecognitionAlgMgr::StartRecognitionL()
- {
- RUBY_DEBUG_BLOCK( "CRecognitionAlgMgr::StartRecognitionL()" );
-
- if ( !iInitialized )
- {
- return;
- }
-
- // Reset the result IDs
- iNBestList.Reset();
- iScores.Reset();
-
- iRecoHw->StartRecognitionL( iNBestList, iScores );
- }
-
-
-// -----------------------------------------------------------------------------
-// CRecognitionAlgMgr::EndRecSession
-// Signal the end of a recognition sesion.
-// -----------------------------------------------------------------------------
-//
-void CRecognitionAlgMgr::EndRecSession()
- {
- RUBY_DEBUG0( "CRecognitionAlgMgr::EndRecSession()" );
-
- // Reset grammars etc.
- iSIActiveGrammars.Reset();
- iSIDeActivatedGrammars.Reset();
- iNBestList.Reset();
- iScores.Reset();
- iBlackList.ResetAndDestroy();
-
- delete iCombinedGrammar;
- iCombinedGrammar = NULL;
-
- iCombineNeeded = ETrue;
- iSDModelBank = NULL;
- iSIModelBank = NULL;
- iSDGrammar = NULL;
- iSIGrammar = NULL;
- iSICompGrammar = NULL;
- iSDCompGrammar = NULL;
- iSDLexicon = NULL;
- iSILexicon = NULL;
- iFEState = EIdle;
- iBEState = EIdle;
- }
-
-
-// -----------------------------------------------------------------------------
-// CRecognitionAlgMgr::Cancel
-// Cancels the current and any on going requests/tasks.
-// -----------------------------------------------------------------------------
-//
-void CRecognitionAlgMgr::Cancel()
- {
- RUBY_DEBUG0( "CRecognitionAlgMgr::Cancel()" );
-
- iRecoHw->StopRecognition();
-
- iFEState = EIdle;
- iBEState = EIdle;
-
- iAdaptHw->CancelAdaptation();
-
- CActive::Cancel();
- }
-
-
-// -----------------------------------------------------------------------------
-// CRecognitionAlgMgr::DoCancel
-// Cancels the current and any on going requests/tasks.
-// -----------------------------------------------------------------------------
-//
-void CRecognitionAlgMgr::DoCancel()
- {
- RUBY_DEBUG0( "CRecognitionAlgMgr::DoCancel()" );
- }
-
-
-// -----------------------------------------------------------------------------
-// CRecognitionAlgMgr::GetUtteranceDuration
-// Get start and end point of utterance.
-// -----------------------------------------------------------------------------
-//
-TBool CRecognitionAlgMgr::GetUtteranceDuration( TUint32& /*aStartFrame*/,
- TUint32& /*aEndFrame*/,
- TReal& /*aFrameLength*/ )
- {
- RUBY_DEBUG0( "CRecognitionAlgMgr::GetUtteranceDuration()" );
-
- return EFalse;
- }
-
-
-// -----------------------------------------------------------------------------
-// CRecognitionAlgMgr::UnloadRule
-// Unloads one rule from specified grammar.
-// -----------------------------------------------------------------------------
-//
-void CRecognitionAlgMgr::UnloadRule( TSIGrammarID aGrammarID, TSIRuleID aRuleID )
- {
- RUBY_DEBUG0( "CRecognitionAlgMgr::UnloadRule()" );
-
- if ( !IsActive() )
- {
- iGrammarID = aGrammarID;
- iRuleID = aRuleID;
- iRequestFunction = KUnloadRule;
- Ready( KErrNone );
- }
- }
-
-
-// -----------------------------------------------------------------------------
-// CRecognitionAlgMgr::HandleUnloadRule
-// Asynchrounous handler for rule unload.
-// -----------------------------------------------------------------------------
-//
-void CRecognitionAlgMgr::HandleUnloadRule()
- {
- RUBY_DEBUG0( "CRecognitionAlgMgr::HandleUnloadRule()" );
-
- TInt error = KErrNone;
- CSICompiledGrammar* siActiveGrammar = NULL;
- CSICompiledGrammar* siNonActiveGrammar = NULL;
- CSICompiledGrammar* siGrammar = NULL;
-
- if ( !iInitialized )
- {
- iRecAlgMgrObserver->UnloadRuleComplete( KErrNotReady );
- }
-
- TRAP( error, GetGrammarL( iGrammarID, &siActiveGrammar, &siNonActiveGrammar ) );
- if ( error != KErrNone )
- {
- iRecAlgMgrObserver->UnloadRuleComplete( error );
- return;
- }
-
- if ( siActiveGrammar != NULL )
- {
- siGrammar = siActiveGrammar;
- }
- else if ( siNonActiveGrammar != NULL )
- {
- siGrammar = siNonActiveGrammar;
- }
- else
- {
- iRecAlgMgrObserver->UnloadRuleComplete( KErrNotFound );
- return;
- }
-
- // Check that given rule id can be found from the given grammar
- if ( siGrammar->Find( iRuleID ) < 0 )
- {
- iRecAlgMgrObserver->UnloadRuleComplete( KErrNotFound );
- return;
- }
-
- // Fetch the actual rule object based on rule id
- TRAP_IGNORE(
-
- CSIRule& blackRule = siGrammar->AtL( siGrammar->Find( iRuleID ) );
-
- // Loop through the rule variants in blacklisted rule
- for ( TInt i = 0; i < blackRule.Count(); i++ )
- {
- // AtL should not leave in any case since i is every time
- // within range 0..Count()-1
- CSIRuleVariant& blackVariant = blackRule.AtL( i );
-
- // Create rule variant info
- TSIRuleVariantInfo* info = new TSIRuleVariantInfo( iGrammarID, iRuleID, blackVariant.RuleVariantID() );
- if ( !info )
- {
- iRecAlgMgrObserver->UnloadRuleComplete( KErrNoMemory );
- return;
- }
-
- iBlackList.Append( info );
- }
- ); // TRAP_IGNORE
-
- // Mark that new combination is needed
- // iCombineNeeded = ETrue;
-
- iRecAlgMgrObserver->UnloadRuleComplete( error );
- }
-
-
-// -----------------------------------------------------------------------------
-// CRecognitionAlgMgr::CombineComplete
-// Notifies that grammar combination has been done.
-// -----------------------------------------------------------------------------
-//
-void CRecognitionAlgMgr::CombineComplete( HBufC8* aResult, TInt aError )
- {
- RUBY_DEBUG0( "CRecognitionAlgMgr::CombineComplete()" );
-
- if ( aError != KErrNone )
- {
- iRecAlgMgrObserver->InitRecognizerBEComplete( aError );
- return;
- }
-
- delete iCombinedGrammar;
- iCombinedGrammar = NULL;
- iCombinedGrammar = aResult;
-
- // Do the rest of BE initialization
- TRAPD( error, iRecoHw->InitRecognizerBEL( iCombinedGrammar->Des(), *iSIModelBank ) );
- if ( error != KErrNone )
- {
- iRecAlgMgrObserver->InitRecognizerBEComplete( error );
- }
- }
-
-
-// -----------------------------------------------------------------------------
-// MASRAdaptationHwDeviceObserver MIXIN impl begins
-// -----------------------------------------------------------------------------
-
-// -----------------------------------------------------------------------------
-// CRecognitionAlgMgr::MaahdAdaptationComplete
-// Model adaptation has been completed.
-// -----------------------------------------------------------------------------
-//
-void CRecognitionAlgMgr::MaahdAdaptationComplete( TInt aError )
- {
-// iAdaptHw->ClearAdaptation();
- iRecAlgMgrObserver->AdaptComplete( aError );
- }
-
-
-// -----------------------------------------------------------------------------
-// MASRAdaptationHwDeviceObserver MIXIN impl begins
-// -----------------------------------------------------------------------------
-
-
-
-// -----------------------------------------------------------------------------
-// MASRSRecogHwDeviceObserver MIXIN impl begins
-// -----------------------------------------------------------------------------
-
-
-// -----------------------------------------------------------------------------
-// CRecognitionAlgMgr::MarhdoRequestSpeechData
-// Forwards request to upper layers.
-// -----------------------------------------------------------------------------
-//
-void CRecognitionAlgMgr::MarhdoRequestSpeechData()
- {
- iRecAlgMgrObserver->RequestSpeechData();
- }
-
-
-// -----------------------------------------------------------------------------
-// CRecognitionAlgMgr::MarhdoInitializationComplete
-// Initialization of Hw Device has been completed.
-// -----------------------------------------------------------------------------
-//
-void CRecognitionAlgMgr::MarhdoInitializationComplete( TInt aError )
- {
- if ( aError == KErrNone )
- {
- iInitialized = ETrue;
- }
- }
-
-
-// -----------------------------------------------------------------------------
-// CRecognitionAlgMgr::MarhdoRecognizerFEComplete
-// FE has been initialized.
-// -----------------------------------------------------------------------------
-//
-void CRecognitionAlgMgr::MarhdoInitRecognizerFEComplete( TInt aError )
- {
- RUBY_DEBUG1( "CRecognitionAlgMgr::MarhdoInitRecognizerFEComplete(), Status: %d", aError );
-
- if ( aError == KErrNone )
- {
- iFEState = EIdle;
- }
- iRecAlgMgrObserver->InitFEComplete( aError );
- }
-
-
-// -----------------------------------------------------------------------------
-// CRecognitionAlgMgr::MarhdoRecognizerBEComplete
-// BE has been initialized.
-// -----------------------------------------------------------------------------
-//
-void CRecognitionAlgMgr::MarhdoInitRecognizerBEComplete( TInt aError )
- {
- RUBY_DEBUG1( "CRecognitionAlgMgr::MarhdoInitRecognizerBEComplete(), Status: %d", aError );
-
- if ( aError == KErrNone )
- {
- iBEState = EIdle;
- }
- iRecAlgMgrObserver->InitRecognizerBEComplete( aError );
- }
-
-
-// -----------------------------------------------------------------------------
-// CRecognitionAlgMgr::MarhdoRecognitionComplete
-// Recognition has been completed
-// -----------------------------------------------------------------------------
-//
-void CRecognitionAlgMgr::MarhdoRecognitionComplete( TInt aError )
- {
- RUBY_DEBUG1( "CRecognitionAlgMgr::MarhdoRecognitionComplete, Status: %d", aError );
-
- if ( iCombinedGrammar == NULL )
- {
- RUBY_DEBUG0( "CRecognitionAlgMgr::HandleMarhdoRecognitionComplete, Cancelled" );
- delete iAdaptationData;
- iAdaptationData = NULL;
- iRecAlgMgrObserver->RecognitionComplete( KErrCancel );
- return;
- }
-
- // Resolve result
- iRecAlgMgrObserver->ResolveResult( iNBestList, *iSIResult, iSIActiveGrammars,
- iCombinedGrammar->Des()/*, *iSIModelBank*/ );
-
-
- RUBY_DEBUG1( "CRecognitionAlgMgr::MarhdoRecognitionComplete, result resolved, result count: %d", iSIResult->Count() );
-
- TRAP_IGNORE(
-
- // Put scores in place
- for ( TInt i = 0; i < iSIResult->Count(); i++ )
- {
- // Should not leave since we are every time within range
- CSIResult& result = iSIResult->AtL( i );
-
- if ( i < iScores.Count() )
- {
- result.SetScore( iScores[i] );
- }
- else
- {
- result.SetScore( 0 );
- }
- }
-
- ); // TRAP_IGNORE
-
- iScores.Reset();
-
- RUBY_DEBUG0( "CRecognitionAlgMgr::MarhdoRecognitionComplete, scores in place" );
-
- // Put adaptation data in place if needed
- if ( iAdaptation )
- {
- iSIResult->SetAdaptationData( iAdaptationData );
- // Result set gains ownership, no need to delete
- iAdaptationData = NULL;
- RUBY_DEBUG0( "CRecognitionAlgMgr::MarhdoRecognitionComplete, adaptation data in place" );
- }
-
- iBEState = EIdle;
- iFEState = EIdle;
- iRecAlgMgrObserver->RecognitionComplete( aError );
-
- RUBY_DEBUG0( "CRecognitionAlgMgr::MarhdoRecognitionComplete, ok, event sent" );
- }
-
-
-// -----------------------------------------------------------------------------
-// CRecognitionAlgMgr::MarhdoEouDetected
-// Called when EOU has been detected, no need to send samples anymore.
-// -----------------------------------------------------------------------------
-//
-void CRecognitionAlgMgr::MarhdoEouDetected( TInt aError )
- {
- RUBY_DEBUG1( "CRecognitionAlgMgr::MarhdoEouDetected(), Status: %d", aError );
-
- iRecAlgMgrObserver->EouDetected( aError );
- }
-
-
-// -----------------------------------------------------------------------------
-// CRecognitionAlgMgr::MarhdoFeatureVector
-// Feature vector sent by AsrRecognitionHwDevice
-// -----------------------------------------------------------------------------
-//
-void CRecognitionAlgMgr::MarhdoFeatureVector( const TDesC8& aFV,
- TInt32 aSNR,
- TInt32 aPosition )
- {
- RUBY_DEBUG0( "CRecognitionAlgMgr::FeatureVectorDataRcvd()" );
-
- // Collect data to one buffer
- if ( iAdaptation )
- {
- if ( aPosition == 0 )
- {
- // Clear previous data if exists
- if ( iAdaptationData )
- {
- delete iAdaptationData;
- iAdaptationData = NULL;
- }
- // Copy data to new buffer
- iAdaptationData = HBufC8::New( aFV.Length() );
- if ( !iAdaptationData )
- {
- return;
- }
- TPtr8 bufferPtr( iAdaptationData->Des() );
- bufferPtr.Copy( aFV.Ptr(), aFV.Length() );
- }
- else if ( aPosition > 0 )
- {
- if ( iAdaptationData != NULL )
- {
- // Append data to existing buffer
- iAdaptationData = iAdaptationData->ReAlloc( iAdaptationData->Length() + aFV.Length() );
- // Check that we got enough memory for new buffer
- if ( iAdaptationData == NULL )
- {
- return;
- }
- TPtr8 bufferPtr( iAdaptationData->Des() );
- bufferPtr.Append( aFV );
- }
- else
- {
- // Do a new buffer since there is no existing one
- iAdaptationData = HBufC8::New( aFV.Length() );
- if ( !iAdaptationData )
- {
- return;
- }
- TPtr8 bufferPtr( iAdaptationData->Des() );
- bufferPtr.Copy( aFV.Ptr(), aFV.Length() );
- }
- }
- }
- // Same callback to client if needed
- if ( iFeatures )
- {
- iRecAlgMgrObserver->FeatureVectorDataRcvd( aFV, aSNR, aPosition );
- }
- }
-
-
-// -----------------------------------------------------------------------------
-// MASRSRecogHwDeviceObserver MIXIN impl ends
-// -----------------------------------------------------------------------------
-
-
-// -----------------------------------------------------------------------------
-// Active object implementation begins
-// -----------------------------------------------------------------------------
-
-
-// -----------------------------------------------------------------------------
-// CRecognitionAlgMgr::RunL
-// Invoke by the active scheduler when a request completes.
-// -----------------------------------------------------------------------------
-//
-void CRecognitionAlgMgr::RunL()
- {
- RUBY_DEBUG_BLOCK( "CRecognitionAlgMgr::RunL()" );
-
- switch(iRequestFunction)
- {
- case KInitFrontEnd:
- HandleInitFrontEnd();
- break;
-
- case KInitRecognizerBE:
- HandleInitRecognizerBE();
- break;
-
- case KLoadGrammar:
- HandleLoadGrammar();
- break;
-
- case KLoadLexicon:
- HandleLoadLexicon();
- break;
-
- case KLoadModels:
- HandleLoadModels();
- break;
-
- case KActivateGrammar:
- HandleActivateGrammar();
- break;
-
- case KDeActivateGrammar:
- HandleDeActivateGrammar();
- break;
-
- case KUnloadRule:
- HandleUnloadRule();
- break;
-
- case KUnloadGrammar:
- HandleUnloadGrammar();
- break;
-
- default:
- break;
- };
-
- }
-
-
-// -----------------------------------------------------------------------------
-// CRecognitionAlgMgr::Ready
-// Utility function to post a request complete
-// -----------------------------------------------------------------------------
-//
-void CRecognitionAlgMgr::Ready( const TInt aStatus )
- {
- TRequestStatus* stat = &iStatus;
- User::RequestComplete( stat, aStatus );
- SetActive();
- }
-
-
-// -----------------------------------------------------------------------------
-// Active object impl ends
-// -----------------------------------------------------------------------------
-
-
-// -----------------------------------------------------------------------------
-// CRecognitionAlgMgr::AlgorithmState
-// Utility function to print out the state of the algorithms.
-// -----------------------------------------------------------------------------
-//
-void CRecognitionAlgMgr::AlgorithmState()
- {
-#ifdef _DEBUG
- switch ( iFEState )
- {
- case EIdle:
- RUBY_DEBUG1( "Recognition algorithm is: [%d] - EIdle", iFEState );
- break;
-
- case EProcessing:
- RUBY_DEBUG1( "Recognition algorithm is: [%d] - EProcessing", iFEState );
- break;
-
- case ECancel:
- RUBY_DEBUG1( "Recognition algorithm is: [%d] - ECancel", iFEState );
- break;
-
- default:
- break;
- };
-#endif
- }
-
-// -----------------------------------------------------------------------------
-// CRecognitionAlgMgr::SetRejection
-// Set rejection threshold.
-// -----------------------------------------------------------------------------
-//
-void CRecognitionAlgMgr::SetRejection( TUint32 aRejection )
- {
- RUBY_DEBUG0( "CRecognitionAlgMgr::SetRejection()" );
-
- iRecoHw->SetRejection( aRejection );
- }