--- a/srsf/devasr/src/devasrsrsalgorithmmanager.cpp Thu Aug 19 09:56:14 2010 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,2150 +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 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;
-
- TRAPD( error, GetGrammarL( aGrammarID, &siActiveGrammar, &siNonActiveGrammar ) );
- if ( error != KErrNone )
- {
- return EFalse;
- }
-
- if ( siActiveGrammar != NULL )
- {
- return ETrue;
- }
- else if ( siNonActiveGrammar != NULL )
- {
- return EFalse;
- }
-
- return EFalse;
- }
-
-
-// -----------------------------------------------------------------------------
-// CSRSAlgorithmManager::LoadGrammarL
-// Load the specified grammar into the recognizer.
-// -----------------------------------------------------------------------------
-//
-void CSRSAlgorithmManager::LoadGrammarL( const CSIGrammar& aGrammar )
- {
- RUBY_DEBUG_BLOCK( "CSRSAlgorithmManager::LoadGrammarL(si non-compiled)" );
-
- iRecognitionAlgMgr->LoadGrammarL( aGrammar );
- }
-
-
-// -----------------------------------------------------------------------------
-// CSRSAlgorithmManager::LoadGrammarL
-// Load the specified grammar into the recognizer.
-// -----------------------------------------------------------------------------
-//
-void CSRSAlgorithmManager::LoadGrammarL( const CSICompiledGrammar& aGrammar )
- {
- RUBY_DEBUG_BLOCK( "CSRSAlgorithmManager::LoadGrammarL(si compiled)" );
-
- iRecognitionAlgMgr->LoadGrammarL( aGrammar );
- }
-
-
-// -----------------------------------------------------------------------------
-// CSRSAlgorithmManager::LoadGrammarL
-// Unloads the specified grammar from the recognizer.
-// -----------------------------------------------------------------------------
-//
-void CSRSAlgorithmManager::UnloadGrammarL( const CSIGrammar& aGrammar )
- {
- RUBY_DEBUG_BLOCK( "CSRSAlgorithmManager::UnloadGrammarL(si non-compiled)" );
-
- iRecognitionAlgMgr->UnloadGrammarL( aGrammar );
- }
-
-
-// -----------------------------------------------------------------------------
-// CSRSAlgorithmManager::UnloadGrammarL
-// Unloads the specified grammar from the recognizer.
-// -----------------------------------------------------------------------------
-//
-void CSRSAlgorithmManager::UnloadGrammarL( const CSICompiledGrammar& aGrammar )
- {
- RUBY_DEBUG_BLOCK( "CSRSAlgorithmManager::UnloadGrammarL(si compiled)" );
-
- iRecognitionAlgMgr->UnloadGrammarL( aGrammar );
- }
-
-
-// -----------------------------------------------------------------------------
-// CSRSAlgorithmManager::ActivateGrammarL
-// Unload the specified grammar from the recognizer.
-// -----------------------------------------------------------------------------
-//
-void CSRSAlgorithmManager::ActivateGrammarL( const TSIGrammarID aGrammarID )
- {
- RUBY_DEBUG_BLOCK( "CSRSAlgorithmManager::ActivateGrammarL()" );
-
- iRecognitionAlgMgr->ActivateGrammarL( aGrammarID );
- }
-
-
-// -----------------------------------------------------------------------------
-// CSRSAlgorithmManager::DeactivateGrammarL
-// Unload the specified grammar from the recognizer.
-// -----------------------------------------------------------------------------
-//
-void CSRSAlgorithmManager::DeactivateGrammarL( const TSIGrammarID aGrammarID )
- {
- RUBY_DEBUG_BLOCK( "CSRSAlgorithmManager::DeactivateGrammarL()" );
-
- iRecognitionAlgMgr->DeactivateGrammarL( aGrammarID );
- }
-
-
-// -----------------------------------------------------------------------------
-// CSRSRecognitionAlgMgr::GetGrammar
-// Find grammar based on identifier
-// -----------------------------------------------------------------------------
-//
-void CSRSAlgorithmManager::GetGrammarL( const TSIGrammarID aGrammarID,
- CSICompiledGrammar** aSIActiveGrammar,
- CSICompiledGrammar** aSIDeActivatedGrammar )
- {
- RUBY_DEBUG_BLOCK( "CSRSAlgorithmManager::GetGrammarL()" );
-
- iRecognitionAlgMgr->GetGrammarL( aGrammarID,
- aSIActiveGrammar,
- aSIDeActivatedGrammar );
- }
-
-
-// -----------------------------------------------------------------------------
-// CSRSAlgorithmManager::UnloadRule
-// Request to unload rule.
-// -----------------------------------------------------------------------------
-//
-void CSRSAlgorithmManager::UnloadRule( TSIGrammarID aGrammarID,
- TSIRuleID aRuleID )
- {
- RUBY_DEBUG0( "CSRSAlgorithmManager::UnloadRule()" );
-
- iRecognitionAlgMgr->UnloadRule( aGrammarID, aRuleID );
- }
-
-
-// -----------------------------------------------------------------------------
-// CSRSAlgorithmManager::LoadEngineParametersL
-// Load the specified recognizer parameter(s).
-// -----------------------------------------------------------------------------
-//
-void CSRSAlgorithmManager::LoadEnginePropertiesL( const RArray<TInt>& aParameterId,
- const RArray<TInt>& aParameterValue )
- {
- RUBY_DEBUG_BLOCK( "CSRSAlgorithmManager::LoadEnginePropertiesL()" );
-
- // Check that parameter ids are valid, settable values
- for ( TInt i = 0; i < aParameterId.Count(); i++ )
- {
- if ( ( aParameterId[i] != KDevASRSendFeatures ) &&
- ( aParameterId[i] != KDevASRAdaptation ) )
- {
- User::Leave( KErrNotSupported );
- }
- }
- iRecognitionAlgMgr->LoadEnginePropertiesL( aParameterId, aParameterValue );
- iVMAlgorithmManager->LoadEnginePropertiesL( aParameterId, aParameterValue );
- }
-
-
-// -----------------------------------------------------------------------------
-// CSRSAlgorithmManager::LoadLexiconL
-// Load the specified lexicion into the recognizer.
-// -----------------------------------------------------------------------------
-//
-void CSRSAlgorithmManager::LoadLexiconL( const CSILexicon& aLexicon )
- {
- RUBY_DEBUG_BLOCK( "CSRSAlgorithmManager::LoadLexiconL()" );
-
- iSILexicon = &aLexicon;
-
- iRecognitionAlgMgr->LoadLexiconL( aLexicon );
- }
-
-
-// -----------------------------------------------------------------------------
-// CSRSAlgorithmManager::LoadModelsL
-// Load the specified models into the recognizer.
-// -----------------------------------------------------------------------------
-//
-void CSRSAlgorithmManager::LoadModelsL( const CSIModelBank& aModels )
- {
- RUBY_DEBUG_BLOCK( "CSRSAlgorithmManager::LoadModelsL()" );
-
- iSIModelBank = &aModels;
-
- iRecognitionAlgMgr->LoadModelsL( aModels );
- }
-
-
-// -----------------------------------------------------------------------------
-// CSRSAlgorithmManager::UtteranceData
-// Get the recorded audio data accumulated during training.
-// -----------------------------------------------------------------------------
-//
-void CSRSAlgorithmManager::GetUtteranceData( TDes8* /*aBuffer*/,
- TTimeIntervalMicroSeconds32& /*aDuration*/ )
- {
- RUBY_DEBUG0( "CSRSAlgorithmManager::GetUtteranceData()" );
- // Not supported
- }
-
-
-// -----------------------------------------------------------------------------
-// CSRSAlgorithmManager::HandlePlay
-// Asynchronously handles the play request.
-// -----------------------------------------------------------------------------
-//
-void CSRSAlgorithmManager::HandlePlayL()
- {
- RUBY_DEBUG0( "CSRSAlgorithmManager::HandlePlayL()" );
- }
-
-
-// -----------------------------------------------------------------------------
-// CSRSAlgorithmManager::StartRecognition
-// Request to begin recording.
-// -----------------------------------------------------------------------------
-//
-void CSRSAlgorithmManager::StartRecognition( TTimeIntervalMicroSeconds32 aRecordDuration )
- {
- RUBY_DEBUG0( "CSRSAlgorithmManager::StartRecognition()" );
-
- iEndFlag = EFalse;
- iRecordDuration = aRecordDuration;
- iRequestFunction = KRecord;
- Ready( KErrNone );
- }
-
-// -----------------------------------------------------------------------------
-// CSRSAlgorithmManager::PreStartSamplingL
-// Pre-starts sampling
-// -----------------------------------------------------------------------------
-//
-void CSRSAlgorithmManager::PreStartSamplingL()
- {
- RUBY_DEBUG_BLOCK( "" );
-#ifdef __FULLDUPLEX_CHANGE
- InitializeDevSoundL();
- StartDevSoundL();
- iPreSamplingStarted = ETrue;
-#endif // __FULLDUPLEX_CHANGE
- }
-
-// -----------------------------------------------------------------------------
-// CSRSAlgorithmManager::StopRecognition
-// Request to stop recording.
-// -----------------------------------------------------------------------------
-//
-void CSRSAlgorithmManager::StopRecognition()
- {
- RUBY_DEBUG0( "CSRSAlgorithmManager::StopRecognition()" );
-
- iEndFlag = ETrue;
- }
-
-
-// -----------------------------------------------------------------------------
-// CSRSAlgorithmManager::HandleRecord
-// Asynchronously handles the recording request.
-// -----------------------------------------------------------------------------
-//
-void CSRSAlgorithmManager::HandleRecordL()
- {
- RUBY_DEBUG_BLOCK( "CSRSAlgorithmManager::HandleRecordL()" );
-
- if ( StateTransition( EDASRSampling ) ) // Attempt to change state
- {
- // Allocate a buffer big enough for recording.
-
- if ( iRecordDuration.Int() == 0 )
- {
- iOverallLength = 0;
- }
- else
- {
- TInt bytesPerSecond = ( TInt ) ( iResourceHandler->iSamplingRate * ( iResourceHandler->iBitsPerSample / 8 ) );
- iOverallLength = ( TInt) ( iRecordDuration.Int() * 0.000001 * bytesPerSecond );
- }
-
- iOverallSampled = 0;
-
- TInt err = KErrNone;
-
-
- // Start the devSound only if client does not provide utterance data.
- if ( iMode == ESiRecognition )
- {
-#ifdef __FULLDUPLEX_CHANGE
- if ( !iPreSamplingStarted )
- {
- TRAP( err, StartDevSoundL() );
- }
-#else
- iDevSound->SetPrioritySettings( iPrioritySettings );
- TRAP( err, iDevSound->RecordInitL() );
-#endif // __FULLDUPLEX_CHANGE
-
- // Mark that recognition should be started when first buffer arrives
- iStartRecognition = ETrue;
- }
- else
- {
- TRAPD ( error, iRecognitionAlgMgr->StartRecognitionL() );
- if ( error != KErrNone )
- {
- iRecognitionAlgMgr->Cancel();
- StateTransition( EDASRIdle );
- iDevASRObserver->DevASREvent( EDevASRRecord, error );
- }
- }
-
- if ( err == KErrNone )
- {
- iDevSoundState = ESoundDeviceRecord;
- iDevASRObserver->DevASREvent( EDevASRRecordStarted, KErrNone );
-
- // Empty audio buffer queue if there happens to be some garbage
- // from previous recognition.
- while ( !iAudioBufferQue->IsEmpty() )
- {
- iQueItem = iAudioBufferQue->First();
- iAudioBufferQue->Remove( *iQueItem );
- delete iQueItem;
- iQueItem = NULL;
- }
- delete iBufferUnderConstruction;
- iBufferUnderConstruction = NULL;
- iConstructionPoint = 0;
- iPendingRequestSpeechData = EFalse;
- }
- else
- {
- RUBY_DEBUG1( "RecordInitL() Error: %d", err );
- iRecognitionAlgMgr->Cancel();
- StateTransition( EDASRIdle );
- iDevASRObserver->DevASREvent( EDevASRRecord, err );
- }
- }
- else // Wrong state to handle this request
- {
- iDevASRObserver->DevASREvent( EDevASRRecord, KErrAsrInvalidState );
-
- RUBY_DEBUG1( "HandleRecord in wrong state: %d", iDevASRState );
- }
-
- }
-
-
-// -----------------------------------------------------------------------------
-// CSRSAlgorithmManager::StartRecSession
-// Signal the start of a recognition sesion.
-// -----------------------------------------------------------------------------
-//
-TInt CSRSAlgorithmManager::StartRecSession( TRecognizerMode aMode )
- {
- RUBY_DEBUG0( "CSRSAlgorithmManager::StartRecSession()" );
-
- TInt err( KErrNone );
-
-#ifdef __FULLDUPLEX_CHANGE
- if ( !iPreSamplingStarted )
- {
- TRAP( err, InitializeDevSoundL() );
- }
-#else
- TRAP( err, InitializeDevSoundL() );
-#endif // __FULLDUPLEX_CHANGE
-
- if ( err == KErrNone )
- {
- iMode = aMode;
-
- err = iRecognitionAlgMgr->StartRecSession( aMode );
- if ( err == KErrNone )
- {
- StateTransition( EDASRPreRecognition );
- }
- }
-
- return err;
- }
-
-
-// -----------------------------------------------------------------------------
-// CSRSAlgorithmManager::EndRecSession
-// Signal the end of a recognition sesion.
-// -----------------------------------------------------------------------------
-//
-void CSRSAlgorithmManager::EndRecSession()
- {
- RUBY_DEBUG0( "CSRSAlgorithmManager::EndRecSession()" );
-
- iRecognitionAlgMgr->EndRecSession();
- StateTransition( EDASRIdle );
- if ( iDevASRState == EDASRIdle )
- {
- iSIModelBank = NULL;
- iSILexicon = NULL;
- }
-
- delete iDevSound;
- iDevSound = NULL;
- }
-
-
-// -----------------------------------------------------------------------------
-// CSRSAlgorithmManager::SendSpeechData
-// Gives data buffer to recognizer.
-// -----------------------------------------------------------------------------
-//
-void CSRSAlgorithmManager::SendSpeechData( TPtrC8& aBuffer, TBool aEnd )
- {
- if ( iMode == ESiRecognitionSpeechInput )
- {
- iRecognitionAlgMgr->SendSpeechData( aBuffer, aEnd );
- }
- }
-
-
-// -----------------------------------------------------------------------------
-// CSRSAlgorithmManager::Cancel
-// Cancels the current and any on going requests/tasks.
-// -----------------------------------------------------------------------------
-//
-void CSRSAlgorithmManager::Cancel()
- {
- RUBY_DEBUG0( "CSRSAlgorithmManager::Cancel()" );
-
- iVMAlgorithmManager->Cancel();
-
- iRecognitionAlgMgr->Cancel();
-
- if( iDevASRState != EDASRIdle )
- {
- //StateTransition( EDASRPreRecognition );
- // Force to pre recognition state
- iDevASRState = EDASRPreRecognition;
- }
-
- if ( iDevSoundState != ESoundDeviceNotInitialized )
- {
- RUBY_DEBUG0( "CSRSAlgorithmManager::Cancel(), Stopping DevSound..." );
-
- if ( iMode == ESiRecognition )
- {
- if ( iDevSound )
- {
- iDevSound->Stop();
- }
- }
- iDevSoundState = ESoundDeviceStopped;
- }
-
- CActive::Cancel();
- }
-
-
-// -----------------------------------------------------------------------------
-// CRecognitionAlgMgr::DoCancel
-// Cancels the current and any on going CActive requests/tasks.
-// -----------------------------------------------------------------------------
-//
-void CSRSAlgorithmManager::DoCancel()
- {
- RUBY_DEBUG0( "CSRSAlgorithmManager::DoCancel()" );
- }
-
-
-// -----------------------------------------------------------------------------
-// CSRSAlgorithmManager::EmptyBuffer
-// Copies the contents of the received buffer to the holding buffer. Subsequent
-// call to EmptyBuffer will append to existing buffer.
-// -----------------------------------------------------------------------------
-//
-TInt CSRSAlgorithmManager::EmptyBuffer( CMMFDataBuffer& aBuffer,
- TInt aBufferLength )
- {
- RUBY_DEBUG1( "CSRSAlgorithmManager::EmptyBuffer(): Len=%d bytes", aBufferLength );
-
- TInt i = 0;
- TInt status = KErrNone;
- TBool iBufferCreated = EFalse;
-#ifdef __WINS__
- TInt KNumberOfBuffers = iResourceHandler->iBuffersInWins;
-#else
- TInt KNumberOfBuffers = iResourceHandler->iBuffersInThumb;
-#endif
-
- TDes8& ReceivedData = aBuffer.Data();
- TInt iSize = ReceivedData.Length();
-
-#ifdef __FULLDUPLEX_CHANGE
- // If state is not EDASRSampling, then end immediately
- // Samples will be negelected until real recognition starts
- if ( iDevASRState != EDASRRecognitionSampling )
- {
- iDevSound->RecordData();
- return status;
- }
- else
- {
- // Reset pre-sampling flag
- iPreSamplingStarted = EFalse;
- }
-#endif // __FULLDUPLEX_CHANGE
-
- // If DevSound has not filled the whole buffer, something
- // is wrong in the sampling
- if( aBufferLength < ReceivedData.MaxLength() )
- {
- status = KErrEof;
- }
-
- // iOverallLength checks how much is sampled during all the callbacks
- if ( iOverallLength != 0 )
- {
- if ( iOverallSampled >= iOverallLength )
- {
- status = KErrOverflow;
- }
- }
-
- TInt silentFrames = iResourceHandler->iSilenceFrames;
-
- // Create new buffer if previous one has been queued
- if ( iBufferUnderConstruction == NULL )
- {
- iBufferUnderConstruction = new TUint8[ iSize * KNumberOfBuffers ];
- if ( !iBufferUnderConstruction )
- {
- return KErrNoMemory;
- }
- iConstructionPoint = 0;
- }
-
- // Copy data, put silence into the beginning of buffer if needed
- for ( i = 0; i < iSize; i++ )
- {
- if ( ( iOverallSampled + i ) < silentFrames )
- {
- // Do not copy zeros
- //iBufferUnderConstruction[ iConstructionPoint ] = 0;
- }
- else
- {
- iBufferUnderConstruction[ iConstructionPoint ] = ReceivedData[ i ];
- iConstructionPoint++;
- }
- }
-
- // Count the number of sampled bytes
- iOverallSampled = iOverallSampled + iSize;
-
- // If internal buffer overflowed or EOF, mark this the final block of data
- // Mark as the final block also if EndRecord() has been explicitly called
- if ( ( status == KErrOverflow ) || ( status == KErrEof ) || iEndFlag )
- {
- CQueItem* qItem( NULL );
- TRAPD( err, qItem = CQueItem::NewL( &iBufferUnderConstruction[0], iConstructionPoint ) );
- if ( err != KErrNone )
- {
- return err;
- }
- qItem->iFinalBlock = ETrue;
- iEndFlag = EFalse;
- iAudioBufferQue->AddLast( *qItem );
- iBufferUnderConstruction = NULL;
- iConstructionPoint = 0;
- iBufferCreated = ETrue;
-
- RUBY_DEBUG0( "CSRSAlgorithmManager::EmptyBuffer(): Sampling ended due to timeout!!" );
- }
- else
- {
- // Notify devsound
- iDevSound->RecordData();
-
- // If next buffer does not fit to the buffer under construction
- // put it to queue and start new when next callback arrives
- if ( iConstructionPoint + iSize > iSize * KNumberOfBuffers )
- {
- // Put data to queue
- CQueItem* qItem( NULL );
- TRAPD( err, qItem = CQueItem::NewL( &iBufferUnderConstruction[0], iConstructionPoint ) );
- if ( err != KErrNone )
- {
- return err;
- }
- qItem->iFinalBlock = EFalse;
- iAudioBufferQue->AddLast( *qItem );
- iBufferCreated = ETrue;
- }
- }
-
- if ( iBufferCreated )
- {
-
-#ifdef AUDIOBUFFER_TO_FILE
- TInt connectError = iFs.Connect();
- if ( connectError != KErrNone )
- {
- return connectError;
- }
- _LIT( KBufferFileName, "C:\\documents\\devasraudiobuffer.raw" );
- if ( !iFileCreated )
- {
- iBufferDataFile.Replace( iFs, KBufferFileName, EFileWrite );
- iFileCreated = ETrue;
- }
- else
- {
- TInt openError = iBufferDataFile.Open( iFs, KBufferFileName, EFileWrite );
- if ( openError != KErrNone )
- {
- return openError;
- }
- }
-
- TPtr8 ptr( &iBufferUnderConstruction[0], iConstructionPoint, iConstructionPoint );
- TInt pos = 0;
- iBufferDataFile.Seek( ESeekEnd, pos );
- iBufferDataFile.Write( pos, ptr );
- iBufferDataFile.Close();
- iFs.Close();
-#endif
-
- iBufferUnderConstruction = NULL;
- iConstructionPoint = 0;
-
- // Start recognition if it has not been already started
- if ( iStartRecognition )
- {
- TRAP( status, iRecognitionAlgMgr->StartRecognitionL() );
- iStartRecognition = EFalse;
- }
-
- // If RequestSpeechData() gets called when there is no data in queue, we
- // should call it again to deliver the new data to recognizer
- if ( iPendingRequestSpeechData )
- {
- iPendingRequestSpeechData = EFalse;
- RequestSpeechData();
- }
- }
-
- return status;
- }
-
-
-// -----------------------------------------------------------------------------
-// CSRSAlgorithmManager::FillBuffer
-// Copies a portion of the holding buffer to the received buffer.
-// -----------------------------------------------------------------------------
-//
-TInt CSRSAlgorithmManager::FillBuffer( CMMFDataBuffer& /*aBuffer*/,
- TInt /*aBufferLength*/ )
- {
- RUBY_DEBUG0( "CSRSAlgorithmManager::FillBuffer()" );
-
- return KErrNotSupported;
- }
-
-
-// -----------------------------------------------------------------------------
-// CSRSAlgorithmManager::SetPrioritySettings
-// Store the priority setting for the sound device.
-// -----------------------------------------------------------------------------
-//
-void CSRSAlgorithmManager::SetPrioritySettings( const TMMFPrioritySettings& aPrioritySettings )
- {
- iPrioritySettings = aPrioritySettings;
- // Always use preference meant for recognition
- iPrioritySettings.iPref = ( TMdaPriorityPreference ) KAudioPrefVocosRecog;
- }
-
-
-// -----------------------------------------------------------------------------
-// CSRSAlgorithmManager::InitializeDevSoundL
-//
-// -----------------------------------------------------------------------------
-//
-void CSRSAlgorithmManager::InitializeDevSoundL()
- {
- if ( !iDevSound )
- {
- // Instance
- iDevSound = CMMFDevSound::NewL();
- }
-
- // Initialization
- iDevSound->InitializeL( *this, EMMFStateRecording );
-
- // Wait for initialization callback
- if ( !iAudioWait.IsStarted() )
- {
- iAudioWait.Start();
- }
-
- // Configuration
- ConfigureSoundDeviceL();
- }
-
-
-// -----------------------------------------------------------------------------
-// CSRSAlgorithmManager::StartDevSoundL
-//
-// -----------------------------------------------------------------------------
-//
-void CSRSAlgorithmManager::StartDevSoundL()
- {
- RUBY_DEBUG_BLOCK( "" );
- iDevSound->SetPrioritySettings( iPrioritySettings );
- iDevSound->RecordInitL();
- iDevSoundState = ESoundDeviceRecord;
- }
-
-
-// -----------------------------------------------------------------------------
-// CSRSAlgorithmManager::StateTransition
-// Change to the specified state if possible. If state change is invalid,
-// EFalse is returned, otherwise, ETrue.
-// -----------------------------------------------------------------------------
-//
-TBool CSRSAlgorithmManager::StateTransition( TDevASRState aTargetState )
- {
-
- TBool result = ETrue;
-
-#ifdef _DEBUG
- DevASRState();
-#endif
-
- switch ( aTargetState )
- {
- case EDASRIdle:
- iDevASRState = aTargetState;
- break;
-
- case EDASRInitTrain:
- if ( iDevASRState == EDASRIdle )
- {
- iDevASRState = aTargetState;
- }
- else
- {
- result = EFalse;
- }
- break;
-
- case EDASRTrain:
- if ( ( iDevASRState == EDASRTrain ) ||
- ( iDevASRState == EDASRInitTrain ) ||
- ( iDevASRState == EDASRTrainSampling ) )
- {
- iDevASRState = aTargetState;
- }
- else
- {
- result = EFalse;
- }
- break;
-
- case EDASRSampling:
- if ( iDevASRState == EDASRTrain )
- {
- iDevASRState = EDASRTrainSampling;
- }
- else if ( iDevASRState == EDASRRecognition )
- {
- iDevASRState = EDASRRecognitionSampling;
- }
- else
- {
- result = EFalse;
- }
- break;
-
- case EDASRPlayback:
- if ( iDevASRState == EDASRIdle )
- {
- iDevASRState = EDASRPlayback;
- }
- else if ( iDevASRState == EDASRPreRecognition )
- {
- iDevASRState = EDASRRecognitionPlayback;
- }
- else
- {
- result = EFalse;
- }
- break;
-
- case EDASRPreRecognition:
- if ( ( iDevASRState == EDASRIdle ) ||
- ( iDevASRState == EDASRRecognition ) ||
- ( iDevASRState == EDASRRecognitionPlayback ) )
- {
- iDevASRState = aTargetState;
- }
- else
- {
- result = EFalse;
- }
- break;
-
- case EDASRRecognitionPlayback:
- if (iDevASRState == EDASRPreRecognition)
- {
- iDevASRState = aTargetState;
- }
- else
- {
- result=EFalse;
- }
- break;
-
- case EDASRInitRecognition:
- if ((iDevASRState == EDASRInitRecognition) ||
- (iDevASRState == EDASRPreRecognition))
- {
- iDevASRState = aTargetState;
- }
- else
- {
- result=EFalse;
- }
- break;
-
- case EDASRRecognition:
- if ( ( iDevASRState == EDASRInitRecognition ) ||
- ( iDevASRState == EDASRRecognitionSampling ) )
- {
- iDevASRState = aTargetState;
- }
- else
- {
- result = EFalse;
- }
- break;
-
- case EDASRCancel:
- break;
-
- default:
- RUBY_DEBUG1( "Invalid state: %d", aTargetState );
- break;
- };
-
-#ifdef _DEBUG
- DevASRState();
- iRecognitionAlgMgr->AlgorithmState();
-#endif
- return result;
- }
-
-
-// -----------------------------------------------------------------------------
-// CSRSAlgorithmManager::TranslateError
-// Translate internal errors to system errors
-// -----------------------------------------------------------------------------
-//
-TInt CSRSAlgorithmManager::TranslateError( TInt aError )
- {
- RUBY_DEBUG1( "CSRSAlgorithmManager::TranslateError(%d)", aError );
-
- TInt error = aError;
-
- switch ( aError )
- {
- case KErrTooEarly:
- error = KErrAsrSpeechTooEarly;
- break;
- case KErrNoSpeech:
- error = KErrAsrNoSpeech;
- break;
- case KErrTooLong:
- error = KErrAsrSpeechTooLong;
- break;
- case KErrTooShort:
- error = KErrAsrSpeechTooShort;
- break;
- default:
- RUBY_DEBUG1( "Unmapped Error: %d", aError );
- break;
- };
-
- return error;
- }
-
-
-// -----------------------------------------------------------------------------
-// DevSound Observer MIXIN implementation begins
-// -----------------------------------------------------------------------------
-
-// -----------------------------------------------------------------------------
-// CSRSAlgorithmManager::InitializeComplete
-// Initialization of DevSound is complete.
-// -----------------------------------------------------------------------------
-//
-void CSRSAlgorithmManager::InitializeComplete( TInt aError )
- {
- RUBY_DEBUG1( "InitializeComplete[%d]", aError );
-
- if ( aError == KErrNone )
- {
- iDevSoundState = ESoundDeviceInitialized;
- }
-
- // Free wait loop
- if ( iAudioWait.IsStarted() )
- {
- iAudioWait.AsyncStop();
- }
- }
-
-// -----------------------------------------------------------------------------
-// CSRSAlgorithmManager::ToneFinished
-// Finished playing tones
-// -----------------------------------------------------------------------------
-//
-void CSRSAlgorithmManager::ToneFinished( TInt /*aError*/ )
- {
- // Should never be called because no tone services is required.
- }
-
-
-// -----------------------------------------------------------------------------
-// CSRSAlgorithmManager::BufferToBeFilled
-// Buffer from DevSound to be filled with audio data.
-// -----------------------------------------------------------------------------
-//
-void CSRSAlgorithmManager::BufferToBeFilled( CMMFBuffer* aBuffer )
- {
- CMMFDataBuffer* buffer = STATIC_CAST( CMMFDataBuffer*, aBuffer );
-
- if ( FillBuffer( *buffer, aBuffer->RequestSize() ) == KErrNone )
- {
- iDevSound->PlayData();
- }
- }
-
-// -----------------------------------------------------------------------------
-// CSRSAlgorithmManager::PlayError
-// Playing of an audio sample has completed successfully or otherwise.
-// -----------------------------------------------------------------------------
-//
-void CSRSAlgorithmManager::PlayError( TInt aError )
- {
- RUBY_DEBUG1( "CSRSAlgorithmManager::PlayError[%d]", aError );
-
- if ( iDevASRState != EDASRIdle )
- {
-
- if ( iDevASRState == EDASRRecognitionPlayback )
- {
- StateTransition( EDASRPreRecognition );
- }
- else
- {
- StateTransition( EDASRIdle );
- }
-
- if ( aError == KErrUnderflow )
- {
- iDevASRObserver->DevASREvent( EDevASRPlay, KErrNone );
- }
- else
- {
- iDevASRObserver->DevASREvent( EDevASRPlay, aError );
- }
-
- }
-
- }
-
-// -----------------------------------------------------------------------------
-// CSRSAlgorithmManager::BufferToBeEmptied
-// An audio buffer is ready to be emptied.
-// -----------------------------------------------------------------------------
-//
-void CSRSAlgorithmManager::BufferToBeEmptied( CMMFBuffer* aBuffer )
- {
- RUBY_DEBUG0( "" );
- if ( iDevASRState == EDASRIdle && !iPreSamplingStarted )
- {
- RUBY_DEBUG0( "stopping devsound" );
- iDevSound->Stop();
- iDevSoundState = ESoundDeviceStopped;
- return;
- }
-
- RUBY_DEBUG0( "processing callback" );
- CMMFDataBuffer* buffer = STATIC_CAST( CMMFDataBuffer*, aBuffer );
- EmptyBuffer( *buffer, aBuffer->RequestSize() );
- }
-
-
-// -----------------------------------------------------------------------------
-// CSRSAlgorithmManager::RecordError
-// Recording has completed successfully or otherwise.
-// -----------------------------------------------------------------------------
-//
-void CSRSAlgorithmManager::RecordError( TInt aError )
- {
- RUBY_DEBUG1( "CSRSAlgorithmManager::RecordError[%d]", aError );
-
- iPreSamplingStarted = EFalse;
- iRecognitionAlgMgr->Cancel();
- StateTransition( EDASRIdle );
- iDevASRObserver->DevASREvent( EDevASRRecord, aError );
- }
-
-
-// -----------------------------------------------------------------------------
-// CSRSAlgorithmManager::ConvertError
-// Conversion has completed successfully or otherwise.
-// -----------------------------------------------------------------------------
-//
-void CSRSAlgorithmManager::ConvertError( TInt /*aError*/ )
- {
- // This method should never be called.
- }
-
-
-// -----------------------------------------------------------------------------
-// CSRSAlgorithmManager::RecordError
-// Callback for custom commands
-// -----------------------------------------------------------------------------
-//
-void CSRSAlgorithmManager::DeviceMessage( TUid /*aMessageType*/,
- const TDesC8& /*aMsg*/ )
- {
- RUBY_DEBUG0( "CSRSAlgorithmManager::DeviceMessage" );
- }
-
-// -----------------------------------------------------------------------------
-// CSRSAlgorithmManager::SendEventToClient
-// Receives and event from DevSound send it to the appropriate handler.
-// -----------------------------------------------------------------------------
-//
-void CSRSAlgorithmManager::SendEventToClient( const TMMFEvent& aEvent )
- {
- RUBY_DEBUG0( "CSRSAlgorithmManager::SendEventToClient()" );
-
- if ( aEvent.iErrorCode != KErrNone )
- {
- if ( iDevSoundState == ESoundDeviceRecord )
- {
- RecordError( aEvent.iErrorCode );
- }
- else if ( iDevSoundState == ESoundDevicePlayback )
- {
- PlayError( aEvent.iErrorCode );
- }
- }
-
- }
-
-
-// -----------------------------------------------------------------------------
-// DevSound Observer MIXIN impl ends
-// -----------------------------------------------------------------------------
-
-
-// -----------------------------------------------------------------------------
-// RecognitionAlgMgr Observer MIXIN implementation begins
-// -----------------------------------------------------------------------------
-
-// -----------------------------------------------------------------------------
-// CSRSAlgorithmManager::AdaptComplete
-// Model adaptation has finished.
-// -----------------------------------------------------------------------------
-//
-void CSRSAlgorithmManager::AdaptComplete( TInt aResultCode )
- {
- RUBY_DEBUG1( "CSRSAlgorithmManager::AdaptComplete(%d)", aResultCode );
-
- iDevASRObserver->DevASREvent( EDevASRAdapt, aResultCode );
- }
-
-
-// -----------------------------------------------------------------------------
-// CSRSAlgorithmManager::InitFEComplete
-// Initialization of frontend algorithm has completed.
-// -----------------------------------------------------------------------------
-//
-void CSRSAlgorithmManager::InitFEComplete( TInt aResultCode )
- {
- RUBY_DEBUG1( "CSRSAlgorithmManager::InitFEComplete(%d)", aResultCode );
-
- // Ignore events if we're idle.
- if ( ( iDevASRState == EDASRInitTrain ) || ( iDevASRState == EDASRInitRecognition ) )
- {
- if ( aResultCode == KErrNone )
- {
- if ( iDevASRState == EDASRInitTrain )
- {
- iDevASRState = EDASRTrain;
- }
- else if ( iDevASRState == EDASRInitRecognition )
- {
- iDevASRState = EDASRRecognition;
- }
- iDevASRObserver->DevASREvent( EDevASRInitFrontend, aResultCode );
- }
- else
- {
- StateTransition( EDASRIdle );
- iDevASRObserver->DevASREvent( EDevASRInitFrontend, TranslateError( aResultCode ) );
- }
- }
- }
-
-// -----------------------------------------------------------------------------
-// CSRSAlgorithmManager::InitRecognizerBEComplete
-// Initialization of backend algorithm for recognition has completed.
-// -----------------------------------------------------------------------------
-//
-void CSRSAlgorithmManager::InitRecognizerBEComplete( TInt aResultCode )
- {
- RUBY_DEBUG1( "CSRSAlgorithmManager::InitRecognizerBEComplete(%d)", aResultCode );
-
- if ( StateTransition( EDASRInitRecognition ) )
- {
- if ( aResultCode == KErrNone )
- {
- iDevASRObserver->DevASREvent( EDevASRInitRecognitionBackend, aResultCode );
- }
- else
- {
- StateTransition( EDASRIdle );
- iDevASRObserver->DevASREvent( EDevASRInitRecognitionBackend, TranslateError( aResultCode ) );
- }
- }
-
- }
-
-// -----------------------------------------------------------------------------
-// CSRSAlgorithmManager::LoadGrammarComplete
-// Loading of grammar into recognizer has completed.
-// -----------------------------------------------------------------------------
-//
-void CSRSAlgorithmManager::LoadGrammarComplete( TInt aResultCode )
- {
- RUBY_DEBUG1( "CSRSAlgorithmManager::LoadGrammarComplete(%d)", aResultCode );
-
- TDevASREvent event = EDevASRLoadGrammar;
-
- if ( aResultCode == KErrNone )
- {
- iDevASRObserver->DevASREvent( event, aResultCode );
- }
- else
- {
- //StateTransition( EDASRIdle );
- iDevASRObserver->DevASREvent( event, TranslateError( aResultCode ) );
- }
- }
-
-
-// -----------------------------------------------------------------------------
-// CSRSAlgorithmManager::UnloadGrammarComplete
-// Grammar has beed unloaded.
-// -----------------------------------------------------------------------------
-//
-void CSRSAlgorithmManager::UnloadGrammarComplete( TInt aResultCode )
- {
- RUBY_DEBUG1( "CSRSAlgorithmManager::UnloadGrammarComplete(%d)", aResultCode );
-
- TDevASREvent event = EDevASRUnloadGrammar;
-
- if ( aResultCode == KErrNone )
- {
- iDevASRObserver->DevASREvent( event, aResultCode );
- }
- else
- {
- iDevASRObserver->DevASREvent( event, TranslateError( aResultCode ) );
- }
- }
-
-
-// -----------------------------------------------------------------------------
-// CSRSAlgorithmManager::ActivateGrammarComplete
-// Grammar activation has been completed.
-// -----------------------------------------------------------------------------
-//
-void CSRSAlgorithmManager::ActivateGrammarComplete( TInt aResultCode )
- {
- RUBY_DEBUG1( "CSRSAlgorithmManager::ActivateGrammarComplete(%d)", aResultCode );
-
- if ( iDevASRState == EDASRPreRecognition )
- {
- iDevASRObserver->DevASREvent( EDevASRActivateGrammar, aResultCode );
- }
- }
-
-
-// -----------------------------------------------------------------------------
-// CSRSAlgorithmManager::DeActivateGrammarComplete
-// Grammar deactivation has been completed.
-// -----------------------------------------------------------------------------
-//
-void CSRSAlgorithmManager::DeActivateGrammarComplete( TInt aResultCode )
- {
- RUBY_DEBUG1( "CSRSAlgorithmManager::DeActivateGrammarComplete(%d)", aResultCode );
-
- if ( iDevASRState == EDASRPreRecognition )
- {
- iDevASRObserver->DevASREvent( EDevASRDeactivateGrammar, aResultCode );
- }
- }
-
-
-// -----------------------------------------------------------------------------
-// CSRSAlgorithmManager::LoadLexiconComplete
-// Loading of lexicon into recognizer has completed.
-// -----------------------------------------------------------------------------
-//
-void CSRSAlgorithmManager::LoadLexiconComplete( TInt aResultCode )
- {
- RUBY_DEBUG1( "CSRSAlgorithmManager::LoadLexiconComplete(%d)", aResultCode );
-
- if ( aResultCode == KErrNone )
- {
- iDevASRObserver->DevASREvent( EDevASRLoadLexicon, aResultCode );
- }
- else
- {
- //StateTransition( EDASRIdle );
- iDevASRObserver->DevASREvent( EDevASRLoadLexicon, TranslateError( aResultCode ) );
- }
- }
-
-
-// -----------------------------------------------------------------------------
-// CSRSAlgorithmManager::LoadModelsComplete
-// Loading of models into recognizer has completed.
-// -----------------------------------------------------------------------------
-//
-void CSRSAlgorithmManager::LoadModelsComplete( TInt aResultCode )
- {
- RUBY_DEBUG1( "CSRSAlgorithmManager::LoadModelsComplete(%d)", aResultCode );
-
- if ( aResultCode == KErrNone )
- {
- iDevASRObserver->DevASREvent( EDevASRLoadModels, aResultCode );
- }
- else
- {
- //StateTransition( EDASRIdle );
- iDevASRObserver->DevASREvent( EDevASRLoadModels, TranslateError( aResultCode ) );
- }
- }
-
-
-// -----------------------------------------------------------------------------
-// CSRSAlgorithmManager::RequestSpeechData
-// Speech data is needed.
-// -----------------------------------------------------------------------------
-//
-void CSRSAlgorithmManager::RequestSpeechData()
- {
- RUBY_DEBUG0( "CSRSAlgorithmManager::RequestSpeechData()" );
-
- if ( iMode == ESiRecognitionSpeechInput )
- {
- iDevASRObserver->RequestSpeechData();
- }
- else
- {
- // The processed sample descriptor can be deleted
- delete iQueItem;
- iQueItem = NULL;
-
- if ( ( iDevASRState == EDASRTrainSampling ) || ( iDevASRState == EDASRRecognitionSampling ) )
- {
- // Check if there's more data to send and if so, send the next block of data
- if ( iAudioBufferQue->IsEmpty() )
- {
- iPendingRequestSpeechData = ETrue;
- iProcessingUtterance = EFalse;
- }
- else
- {
- iQueItem = iAudioBufferQue->First();
- iRecognitionAlgMgr->SendSpeechData( iQueItem->iDataBlock, iQueItem->iFinalBlock );
- iAudioBufferQue->Remove( *iQueItem );
- }
- }
- }
- }
-
-
-// -----------------------------------------------------------------------------
-// CSRSAlgorithmManager::FeatureVectorDataRcvd
-// Feature vector data received from frontend.
-// -----------------------------------------------------------------------------
-//
-void CSRSAlgorithmManager::FeatureVectorDataRcvd( const TDesC8& aFV,
- TInt32 aSNR,
- TInt32 aPosition )
- {
- iDevASRObserver->FeatureVectorDataRcvd( aFV, aSNR, aPosition );
- }
-
-
-// -----------------------------------------------------------------------------
-// CSRSAlgorithmManager::EouDetected
-// Frontend finished extracting feature vectors from PCM data.
-// -----------------------------------------------------------------------------
-//
-void CSRSAlgorithmManager::EouDetected( TInt aResultCode )
- {
- RUBY_DEBUG1( "CSRSAlgorithmManager::EouDetected(%d)", aResultCode );
-
- if ( iDevASRState == EDASRTrainSampling )
- {
-
- if ( aResultCode != KErrNone )
- {
- RUBY_DEBUG1( "CSRSAlgorithmManager::EouDetected(): Training ERROR %d", aResultCode );
-
- StateTransition( EDASRIdle );
- iDevSound->Stop();
- iDevSoundState = ESoundDeviceStopped;
- iDevASRObserver->DevASREvent( EDevASRTrain, TranslateError( aResultCode ) );
- return;
- }
-
- // If we fail to get the utterance duration, there's probably not enough frames to calculate
- // utterance duration. We will fail training with "too short".
- if ( !iRecognitionAlgMgr->GetUtteranceDuration(iStartFrame, iEndFrame, iFrameLength) )
- {
- StateTransition(EDASRIdle);
- iDevSound->Stop();
- iDevSoundState = ESoundDeviceStopped;
- iDevASRObserver->DevASREvent( EDevASRTrain, KErrAsrSpeechTooShort );
- return;
- }
-
- RUBY_DEBUG1( "Start frame: %d", iStartFrame );
- RUBY_DEBUG1( "End frame: %d", iEndFrame );
- RUBY_DEBUG1( "Frame Length: %f", iFrameLength );
-
- // Now, calculate the start and end point in the audio buffer for encoding
-
- RUBY_DEBUG1( "Padding start frames: %d", iResourceHandler->iPadStartFrames );
-
- // Pad additional frame to start and end to prevent clipping during utterance playback.
-
- if( (iStartFrame - iResourceHandler->iPadStartFrames) <= 0 )
- {
- iStartFrame = 0;
- }
- else
- {
- iStartFrame = iStartFrame - iResourceHandler->iPadStartFrames;
- }
-
- iBufferStartPoint = (TUint32)(iStartFrame * iFrameLength * iResourceHandler->iSamplingRate * 2);
-
- RUBY_DEBUG1( "Padding start frames: %d", iResourceHandler->iPadEndFrames );
-
- iBufferEndPoint = (TUint32)((iEndFrame + iResourceHandler->iPadEndFrames) * iFrameLength *
- iResourceHandler->iSamplingRate * 2);
-
- if ( iBufferEndPoint >= iStartPoint - 1 ) // Do not pad beyond recorded point
- {
- iBufferEndPoint = iStartPoint - 1; // Set to the last byte recorded
- }
-
- if ( iBufferEndPoint > iStopPoint ) // Cannot pad more than buffer size allows
- {
- iBufferEndPoint = iStopPoint;
- }
-
- StateTransition(EDASRTrain);
- iDevSound->Stop();
- iDevSoundState = ESoundDeviceStopped;
- }
-
- // It is possible that the frontend has completed processing while the audio
- // buffer is not yet full.
- // The recording can be stopped as the frontend has detected end of utterance.
-
- else if ( iDevASRState == EDASRRecognitionSampling )
- {
-
- if ( ( aResultCode != KErrNone ) && ( aResultCode != KErrTooLong ) )
- {
- RUBY_DEBUG1( "CSRSAlgorithmManager::EouDetected(): Recognition ERROR %d", aResultCode );
-
- StateTransition( EDASRIdle );
- iRecognitionAlgMgr->Cancel();
- iDevSound->Stop();
- iDevASRObserver->DevASREvent( EDevASRRecognize, TranslateError( aResultCode ) );
- return;
- }
-
- StateTransition( EDASRRecognition );
-
- iDevSound->Stop();
-
- iDevSoundState = ESoundDeviceStopped;
- }
- else // We are in the wrong state to handle this event
- {
- RUBY_DEBUG0( "CSRSAlgorithmManager::EouDetected(): WRONG STATE" );
- return;
- }
-
- iDevASRObserver->DevASREvent( EDevASREouDetected, KErrNone );
- }
-
-
-// -----------------------------------------------------------------------------
-// CSRSAlgorithmManager::TrainComplete
-// The training backend has finished processing feature vectors. A Model is
-// created.
-// -----------------------------------------------------------------------------
-//
-void CSRSAlgorithmManager::TrainComplete( TInt aResultCode )
- {
- RUBY_DEBUG1( "CSRSAlgorithmManager::TrainComplete(%d)", aResultCode );
-
- if ( iDevASRState == EDASRTrain )
- {
- // Training is complete, DevASR can return to Idle state.
- StateTransition( EDASRIdle );
-
- iDevASRObserver->DevASREvent( EDevASRTrain, TranslateError( aResultCode ) );
- }
- }
-
-
-// -----------------------------------------------------------------------------
-// CSRSAlgorithmManager::UnloadRuleComplete
-// Rule has been blacklisted successfully or otherwise.
-// -----------------------------------------------------------------------------
-//
-void CSRSAlgorithmManager::UnloadRuleComplete( TInt aResultCode )
- {
- RUBY_DEBUG1( "CSRSAlgorithmManager::UnloadRuleComplete(%d)", aResultCode );
-
- iDevASRObserver->DevASREvent( EDevASRUnloadRule, aResultCode );
- }
-
-
-// -----------------------------------------------------------------------------
-// CSRSAlgorithmManager::RecognitionComplete
-// The recognition backend has finished processing feature vectors. A recognition
-// result is created.
-// -----------------------------------------------------------------------------
-//
-void CSRSAlgorithmManager::RecognitionComplete( TInt aResultCode )
- {
- RUBY_DEBUG1( "CSRSAlgorithmManager::RecognitionComplete(%d)", aResultCode );
-
- // Recognition is complete, DevASR can return to pre-recognition state
- if ( StateTransition( EDASRPreRecognition ) )
- {
- // Mark that sampling can be ended if not stopped yet
- iEndFlag = ETrue;
- iDevASRObserver->DevASREvent( EDevASRRecognize, TranslateError( aResultCode ) );
- }
- else
- {
- if ( iDevASRState == EDASRRecognitionSampling )
- {
- StateTransition( EDASRRecognition );
- iDevSound->Stop();
- iDevSoundState = ESoundDeviceStopped;
- iDevASRObserver->DevASREvent( EDevASREouDetected, KErrNone );
- StateTransition( EDASRPreRecognition );
- iDevASRObserver->DevASREvent( EDevASRRecognize, TranslateError( aResultCode ) );
- }
- }
- }
-
-
-// -----------------------------------------------------------------------------
-// RecAlgMgr Observer MIXIN impl ends
-// -----------------------------------------------------------------------------
-
-// -----------------------------------------------------------------------------
-// MVmAlgMgrObserver MIXIN impl starts
-// -----------------------------------------------------------------------------
-
-// -----------------------------------------------------------------------------
-// CSRSAlgorithmManager::CombineComplete
-// Grammar combination is ready.
-// -----------------------------------------------------------------------------
-//
-void CSRSAlgorithmManager::CombineComplete( HBufC8* aResult, TInt aError )
- {
- // Forward call to reco alg manager
- iRecognitionAlgMgr->CombineComplete( aResult, aError );
- }
-
-
-// -----------------------------------------------------------------------------
-// MVmAlgMgrObserver MIXIN impl ends
-// -----------------------------------------------------------------------------
-
-
-// -----------------------------------------------------------------------------
-// Active object implementation begins
-// -----------------------------------------------------------------------------
-
-
-// -----------------------------------------------------------------------------
-// CSRSAlgorithmManager::RunL
-// Handle the requested function asynchronously.
-// result is created.
-// -----------------------------------------------------------------------------
-//
-void CSRSAlgorithmManager::RunL()
- {
-
- switch ( iRequestFunction )
- {
- case KRecord:
- TRAPD( err, HandleRecordL() );
- if ( err )
- {
- iRecognitionAlgMgr->Cancel();
- StateTransition( EDASRIdle );
- iDevASRObserver->DevASREvent( EDevASRRecord, TranslateError( err ) );
- }
- break;
-
- case KPlay:
-
- TRAPD( err1, HandlePlayL() );
- if ( err1 )
- {
- StateTransition( EDASRIdle );
- iDevASRObserver->DevASREvent( EDevASRPlay, TranslateError( err1 ) );
- }
- break;
-
- default:
- break;
- };
- }
-
-
-// -----------------------------------------------------------------------------
-// CSRSAlgorithmManager::Ready
-// Utility function to post a request complete.
-// result is created.
-// -----------------------------------------------------------------------------
-//
-void CSRSAlgorithmManager::Ready( const TInt aStatus )
- {
- TRequestStatus* stat = &iStatus;
- User::RequestComplete( stat, aStatus );
- SetActive();
- }
-
-
-// -----------------------------------------------------------------------------
-// Active object impl ends
-// -----------------------------------------------------------------------------
-
-
-// -----------------------------------------------------------------------------
-// CSRSAlgorithmManager::DevASRState
-// Utility function print out the state of DevASR for unit testing.
-// result is created.
-// -----------------------------------------------------------------------------
-//
-void CSRSAlgorithmManager::DevASRState()
- {
-
-#ifdef _DEBUG
- switch ( iDevASRState )
- {
- case EDASRIdle:
- RUBY_DEBUG1( "DevASR is: [%d] - EDASRIdle", iDevASRState );
- break;
-
- case EDASRInitTrain:
- RUBY_DEBUG1( "DevASR is: [%d] - EDASRInitTrain", iDevASRState );
- break;
-
- case EDASRTrain:
- RUBY_DEBUG1( "DevASR is: [%d] - EDASRTrain", iDevASRState );
- break;
-
- case EDASRRecognitionSampling:
- RUBY_DEBUG1( "DevASR is: [%d] - EDASRRecognitionSampling", iDevASRState );
- break;
-
- case EDASRTrainSampling:
- RUBY_DEBUG1( "DevASR is: [%d] - EDASRTrainSampling", iDevASRState );
- break;
-
- case EDASRPlayback:
- RUBY_DEBUG1( "DevASR is: [%d] - EDASRPlayback", iDevASRState );
- break;
-
- case EDASRPreRecognition:
- RUBY_DEBUG1( "DevASR is: [%d] - EDASRPreRecognition", iDevASRState );
- break;
-
- case EDASRRecognitionPlayback:
- RUBY_DEBUG1( "DevASR is: [%d] - EDASRRecognitionPlayback", iDevASRState );
- break;
-
- case EDASRInitRecognition:
- RUBY_DEBUG1( "DevASR is: [%d] - EDASRInitRecognition", iDevASRState );
- break;
-
- case EDASRRecognition:
- RUBY_DEBUG1( "DevASR is: [%d] - EDASRRecognition", iDevASRState );
- break;
-
- case EDASRCancel:
- RUBY_DEBUG1( "DevASR is: [%d] - EDASRCancel", iDevASRState );
- default:
- RUBY_DEBUG1( "DevASR is: [%d] - Unknown", iDevASRState );
- break;
- };
-#endif
-
- }