Symaptic: os/mm/mmdevicefw/speechrecogsupport/ASR/inc/mmf/common/SpeechRecognitionDataDevASR.h@260cb5ec6c19

     1 // Copyright (c) 2002-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 //

    16 #ifndef __SPEECHRECOGNITIONDATADEVASR_H__

    17 #define __SPEECHRECOGNITIONDATADEVASR_H__

    19 //  INCLUDES

    20 #include <mmf/common/speechrecognitiondatacommon.h>

    23 // FORWARD DECLARATION

    24 class TDiagnostic;

    27 // CLASS DECLARATION

    29 /**

    30 @publishedAll

    31 @released

    33 Class to encapsulate a Speaker Dependent Rule.

    35 @since 8.0

    36 */

    37 class CSDRule : public CBase

    38 {

    39 public:// Constructors and destructor

    41 	/**

    42     Destructor.

    43     */

    44 	IMPORT_C ~CSDRule();

    46     /**

    47     Instantiates an instance of CSDRule.

    49 	@param  aRuleID

    50 			The rule identifier.

    51 	@param  aLexiconID

    52 	        The lexicon identifier.

    53 	@param  aPronunciationID

    54 	        The pronunciation identifier.

    56 	@return A pointer to a CSDRule object.

    57     */

    58 	IMPORT_C static CSDRule* NewL(TRuleID aRuleID, TLexiconID aLexiconID, TPronunciationID aPronunciationID);

    60 	/**

    61     Instantiates an instance of CSDRule and leaves a pointer on the cleanup stack.

    63 	@param  aRuleID

    64 	        The rule identifier.

    65 	@param  aLexiconID

    66 	        The lexicon identifier.

    67 	@param  aPronunciationID

    68 	        The pronunciation identifier.

    70 	@return A pointer to a CSDRule object.

    71 	*/

    72 	IMPORT_C static CSDRule* NewLC(TRuleID aRuleID, TLexiconID aLexiconID, TPronunciationID aPronunciationID);

    75 	/**

    76 	Returns the rule ID of the result.

    78 	@return The rule identifier.

    80 	@since 8.0

    81 	*/

    82 	IMPORT_C TRuleID RuleID() const;

    84 	/**

    85 	Returns the lexicon ID of the result.

    87 	@return The lexicon identifier.

    89     @since 8.0

    90 	*/

    91 	IMPORT_C TLexiconID LexiconID() const;

    93 	/**

    94 	Returns the pronunciation ID of the result.

    96 	@return The pronunciation identifier.

    98 	@since 8.0

    99 	*/

   100 	IMPORT_C TPronunciationID PronunciationID() const;

   102 private:

   103 	void ConstructL();

   104 	CSDRule(TRuleID aRuleID, TLexiconID aLexiconID, TPronunciationID aPronunciationID);

   106 private:

   107 	TRuleID iRuleID;

   108 	TLexiconID iLexiconID;

   109 	TPronunciationID iPronunciationID;

   110 };

   113 /**

   114 @publishedAll

   115 @released

   117 Class to encapsulate a Speaker Dependent Grammar.

   119 A grammar consists of a list of rules.

   121 @since  8.0

   122 */

   123 class CSDGrammar : public CBase

   124 {

   125 public:// Constructors and destructor

   127 	/**

   128 	Destructor.

   129 	*/

   130 	IMPORT_C ~CSDGrammar();

   132     /**

   133     Instantiates an instance of CSDGrammar.

   135 	@param  aGrammarID

   136 	        The grammar identifier.

   138 	@return A pointer to a CSDGrammar object.

   139 	*/

   140 	IMPORT_C static CSDGrammar* NewL(TGrammarID aGrammarID);

   142 	/**

   143 	Instantiates an instance of CSDGrammar and leaves a pointer on the cleanup stack.

   145 	@param  aGrammarID

   146 	        The grammar identifier.

   148 	@return A pointer to CSDGrammar object.

   149 	*/

   150 	IMPORT_C static CSDGrammar* NewLC(TGrammarID aGrammarID);

   152 	/**

   153 	Returns the grammar ID of the result.

   155 	@return The grammar identifier.

   157 	@since  8.0

   158 	*/

   159 	IMPORT_C TGrammarID GrammarID() const;

   161 	/**

   162     Adds a rule to the grammar.

   164 	@param  aRule

   165 	        A reference to a CSDRule object.

   167 	@return An error code indicating if the function call was successful. KErrNone on success, otherwise

   168 	        another of the system-wide error codes.

   170 	@since 8.0

   171 	*/

   172 	IMPORT_C TInt Add(CSDRule& aRule);

   174 	/**

   175 	Deletes a rule from the grammar.

   177 	@param  aRuleID

   178 	        The rule identifier to delete.

   180 	@since  8.0

   181     */

   182 	IMPORT_C void Delete(TRuleID aRuleID);

   184 	/**

   185 	Returns a rule based at an index.

   187 	@param  aIndex

   188 	        An index value. The value must not be negative and must not be greater than the number

   189 	        of rules currently in the grammar, otherwise the function will panic.

   191 	@return A reference to a CSDRule object.

   193 	@since  8.0

   194 	*/

   195 	IMPORT_C const CSDRule& At(TInt aIndex) const;

   197 	/**

   198 	Finds a rule in the grammar based on the rule ID.

   200 	@param  aRuleID

   201 	        The rule identifier.

   203 	@return The index of the first matching rule within the grammar. Returns KErrNotFound, if a

   204 	        matching rule can not be found.

   206 	@since  8.0

   207 	*/

   208 	IMPORT_C TInt FindRule(TRuleID aRuleID) const;

   210 	/**

   211 	Returns the number of rules in the grammar

   213 	@return The number of rules.

   215 	@since  8.0

   216 	*/

   217 	IMPORT_C TInt Count() const;

   219 private:

   220 	void ConstructL();

   221 	CSDGrammar(TGrammarID aGrammarID);

   223 private:

   224 	TGrammarID iGrammarID;

   225 	RPointerArray<CSDRule> iRuleArray;

   226 };

   229 /**

   230 @publishedAll

   231 @released

   233 Class to encapsulate a Speaker Dependent Pronunciation.

   235 @since  8.0

   236 */

   237 class CSDPronunciation : public CBase

   238 {

   239 public:// Constructors and destructor

   241 	/**

   242 	Destructor.

   243 	*/

   244 	IMPORT_C ~CSDPronunciation();

   246 	/**

   247     Instantiates an instance of CSDPronunciation.

   249 	@param  aPronunciationID

   250 	        The pronunciation identifier.

   251 	@param  aModelBankID

   252 	        The model bank identifier.

   253 	@param  aPhonemeID

   254 	        The phoneme identifier.

   256 	@return A pointer to a CSDPronunciation object.

   257 	*/

   258 	IMPORT_C static CSDPronunciation* NewL(TPronunciationID aPronunciationID, TModelBankID aModelBankID, TPhonemeID aPhonemeID);

   260 	/**

   261 	Instantiates an instance of CSDPronunciation and leaves a pointer on the cleanup stack.

   263 	@param  aPronunciationID

   264 	        The pronunciation identifier.

   265 	@param  aModelBankID

   266 	        The model bank identifier.

   267 	@param  aPhonemeID

   268 	        The phoneme identifier.

   270 	@return A pointer to a CSDPronunciation object.

   271 	*/

   272 	IMPORT_C static CSDPronunciation* NewLC(TPronunciationID aPronunciationID, TModelBankID aModelBankID, TPhonemeID aPhonemeID);

   274 	/**

   275 	Returns the pronunciation ID of this lexicon entry.

   277 	@return The pronunciation identifier.

   279 	@since  8.0

   280 	*/

   281 	IMPORT_C TPronunciationID PronunciationID() const;

   283 	/**

   284 	Returns the ID of the model bank.

   286 	@return The model bank identifier.

   288 	@since  8.0

   289 	*/

   290 	IMPORT_C TModelBankID ModelBankID() const;

   292 	/**

   293 	Returns the phoneme ID of this lexicon entry.

   295 	@return The phoneme identifier.

   297 	@since 8.0

   298 	*/

   299 	IMPORT_C TPhonemeID PhonemeID() const;

   301 private:

   302 	void ConstructL();

   303 	CSDPronunciation(TPronunciationID aPronunciationID, TModelBankID aModelBankID, TPhonemeID aPhonemeID);

   305 private:

   306 	TPronunciationID iPronunciationID;

   307 	TModelBankID iModelBankID;

   308 	TPhonemeID iPhonemeID;

   309 };

   312 /**

   313 @publishedAll

   314 @released

   316 Class to encapsulate a Speaker Dependent Lexicon.

   318 @since 8.0

   319 */

   320 class CSDLexicon : public CBase

   321 {

   322 public:// Constructors and destructor

   324 	/**

   325     Destructor.

   326 	*/

   327 	IMPORT_C ~CSDLexicon();

   329 	/**

   330 	Instantiates an instance of CSDLexicon.

   332 	@param  aLexiconID

   333 	        The lexicon identifier.

   335 	@return A pointer to a CSDLexicon object.

   336     */

   337 	IMPORT_C static CSDLexicon* NewL(TLexiconID aLexiconID);

   339 	/**

   340     Instantiates an instance of CSDGrammar and leaves a pointer on the cleanup stack.

   342 	@param  aLexiconID

   343 	        The lexicon identifier.

   345 	@return A pointer to a CSDLexicon object.

   346 	*/

   347 	IMPORT_C static CSDLexicon* NewLC(TLexiconID aLexiconID);

   349 	/**

   350 	Returns the ID of the lexicon.

   352 	@return The lexicon identifier.

   354 	@since 8.0

   355 	*/

   356 	IMPORT_C TLexiconID LexiconID() const;

   358 	/**

   359 	Adds a lexicon entry to the lexicon.

   361 	@param aPronunciation

   362 	       A reference to a CSDPronunciation object.

   364 	@return An error code indicating if the function call was successful. KErrNone on success, otherwise

   365 	        another of the system-wide error codes.

   367 	@since  8.0

   368 	*/

   369 	IMPORT_C TInt Add(CSDPronunciation& aPronunciation);

   371 	/**

   372 	Returns a pronunciation based at an index.

   374 	@param  aIndex

   375 	        The pronunciation index. This value must not be negative and must not be greater than

   376 	        the number of pronunciations currently in the lexicon, otherwise the function will

   377 	        panic.

   379 	@return A reference to a CSDPronunciation object.

   381 	@since  8.0

   382 	*/

   383 	IMPORT_C const CSDPronunciation& At(TInt aIndex) const;

   385 	/**

   386 	Finds a pronunciation based on the specified pronunciation ID.

   388 	@param  aPronunciationID

   389 	        The pronunciation identifier.

   391 	@return The index of the first matching pronunciation within the lexicon. Returns KErrNotFound,

   392 	        if a matching pronunciation can not be found.

   393     */

   394 	IMPORT_C TInt FindPronunciation(TPronunciationID aPronunciationID) const;

   396 	/**

   397     Returns the number of lexicon entries in the lexicon.

   399 	@return The number of pronunciations.

   401 	@since  8.0

   402 	*/

   403 	IMPORT_C TInt Count() const;

   405 private:

   406 	void ConstructL();

   407 	CSDLexicon(TLexiconID aLexiconID);

   409 private:

   410 	TLexiconID iLexiconID;

   411 	RPointerArray<CSDPronunciation> iPronunciationArray;

   412 };

   415 /**

   416 @publishedAll

   417 @released

   419 Class to encapsulate a Speaker Dependent Model created during the training process.

   421 @since  8.0

   422 */

   423 class CSDModel : public CBase

   424 {

   425 public:// Constructors and destructor

   427 	/**

   428     Destructor.

   429 	*/

   430 	IMPORT_C ~CSDModel();

   432 	/**

   433     Instantiates an instance of a CSDModel.

   435 	@return A pointer to a CSDModel object.

   436 	*/

   437 	IMPORT_C static CSDModel* NewL();

   439 	/**

   440     Instantiates an instance of a CSDModel.

   442 	@return A pointer to a CSDModel object.

   443 	*/

   444 	IMPORT_C static CSDModel* NewLC();

   446 	/**

   447     Instantiates an instance of a CSDModel.

   449 	@param  aPhonemeID

   450 	        The phoneme identifier.

   452 	@return A pointer to a CSDModel object.

   453 	*/

   454 	IMPORT_C static CSDModel* NewL(TPhonemeID aPhonemeID);

   456 	/**

   457     Instantiates an instance of a CSDModel.

   459 	@param  aPhonemeID

   460 	        The phoneme identifier.

   462 	@return A pointer to a CSDModel object.

   463 	*/

   464 	IMPORT_C static CSDModel* NewLC(TPhonemeID aPhonemeID);

   466 	/**

   467 	Sets the phoneme ID of this model.

   469 	@param aPhonemeID

   470 	       The phoneme identifier.

   472 	@since  8.0

   473 	*/

   474 	IMPORT_C void SetPhonemeID(TPhonemeID aPhonemeID);

   476 	/**

   477     Returns the phoneme ID of this model.

   479 	@return The phoneme identifier.

   481 	@since  8.0

   482 	*/

   483 	IMPORT_C TPhonemeID PhonemeID() const;

   485 	/**

   486 	Sets the acoustic model of the model.

   488 	@param  aAcousticModel

   489 	        A pointer descriptor containing the acoustic model (binary).

   491     @since  8.0

   492 	*/

   493 	IMPORT_C void SetAcousticModel(TPtr8& aAcousticModel);

   495 	/**

   496     Gets a pointer to the acoustic model of this model.

   498 	@return A descriptor to the acoustic model data.

   500 	@since  8.0

   501 	*/

   502 	IMPORT_C const TDesC8& AcousticModel() const;

   504 private:

   505 	void ConstructL();

   506 	CSDModel();

   507 	CSDModel(TPhonemeID aPhonemeID);

   509 private:

   510 	TPhonemeID iPhonemeID;

   511 	TPtr8 iAcousticModelPtr;

   512 };

   515 /**

   516 @publishedAll

   517 @released

   519 Class to encapsulate a Speaker Dependent Model Bank used by the recognizer during the

   520 recognition process.

   522 @since 8.0

   523 */

   524 class CSDModelBank : public CBase

   525 {

   526 public:// Constructors and destructor

   528 	/**

   529     Destructor.

   530 	*/

   531 	IMPORT_C ~CSDModelBank();

   533 	/**

   534 	Instantiates an instance of a CSDModelBank.

   536 	@param  aModelBankID

   537 	        The model bank identifier.

   539 	@return A pointer to a CSDModelBank object.

   540 	*/

   541 	IMPORT_C static CSDModelBank* NewL(TModelBankID aModelBankID);

   543 	/**

   544 	Instantiates an instance of a CSDModelBank and leaves a pointer on the cleanup stack.

   546 	@param  aModelBankID

   547 	        The model bank identifier.

   549 	@return A pointer to a CSDModelBank object.

   550 	*/

   551 	IMPORT_C static CSDModelBank* NewLC(TModelBankID aModelBankID);

   553     /**

   554 	Returns the model bank ID of the model bank.

   556 	@return The model bank identifier.

   558 	@since 8.0

   559 	*/

   560 	IMPORT_C TModelBankID ModelBankID() const;

   562 	/**

   563 	Adds a model to the model bank.

   565 	@param aModel

   566 	       The reference to CSDModel object.

   568 	@return An error code indicating if the function call was successful. KErrNone on success, otherwise

   569 	        another of the system-wide error codes.

   571 	@since 8.0

   572 	*/

   573 	IMPORT_C TInt Add(CSDModel& aModel);

   575 	/**

   576     Returns a model at the given index.

   578 	@param  aIndex

   579 	        A reference to a CSDModel object.

   581     @return The index of the first matching model within the model bank. Returns KErrNotFound, if a

   582 	        matching model can not be found.

   584     @since  8.0

   585     */

   586 	IMPORT_C const CSDModel& At(TInt aIndex) const;

   588 	/**

   589 	Finds a model based on the specified phoneme ID.

   591 	@param  aPhonemeID

   592 	        The phoneme ID.

   594 	@return The index of the first matching model within the model bank. Returns KErrNotFound, if a

   595 	        matching model can not be found.

   597 	@since  8.0

   598 	*/

   599 	IMPORT_C TInt FindModel(TPhonemeID aPhonemeID) const;

   601 	/**

   602 	Returns the number of models in the model bank.

   604 	@return The number of models in the model bank.

   606 	@since  8.0

   607 	*/

   608 	IMPORT_C TInt Count() const;

   610 private:

   611 	void ConstructL();

   612 	CSDModelBank(TModelBankID aModelBankID);

   614 private:

   615 	TModelBankID iModelBankID;

   616 	RPointerArray<CSDModel> iModelArray;

   617 };

   620 /**

   621 @publishedAll

   622 @released

   624 Class to encapsulate a Recognition Result

   626 @since 8.0

   627 */

   628 class CSDResult : public CBase

   629 {

   630 public:// Constructors and destructor

   632 	/**

   633 	Destructor.

   634 	*/

   635 	IMPORT_C ~CSDResult();

   637 	/**

   638 	Instantiates an instance of a CSDResult.

   640 	@return A pointer to a CSDResult object.

   641 	*/

   642 	IMPORT_C static CSDResult* NewL();

   644 	/**

   645 	Instantiates an instance of CSDResult and leaves a pointer on the cleanup stack.

   647 	@return A pointer to a CSDResult object.

   648 	*/

   649 	IMPORT_C static CSDResult* NewLC();

   651 	/**

   652 	Instantiates an instance of a CSDResult.

   654 	@param  aGrammarID

   655 	        The grammar identifier.

   656 	@param  aRuleID

   657 	        The rule identifier.

   659 	@return A pointer to a CSDResult object.

   660 	*/

   661 	IMPORT_C static CSDResult* NewL(TGrammarID aGrammarID, TRuleID aRuleID);

   663 	/**

   664 	Instantiates an instance of a CSDResult and leaves a pointer on the cleanup stack.

   666 	@param  aGrammarID

   667 	        The grammar identifier.

   668 	@param  aRuleID

   669 	        The rule identifier.

   671 	@return A pointer to a CSDResult object.

   672 	*/

   673 	IMPORT_C static CSDResult* NewLC(TGrammarID aGrammarID, TRuleID aRuleID);

   675 	/**

   676 	Sets the grammar ID on the result.

   678 	@param  aGrammarID

   679 	        The grammar identifier.

   681 	@since  8.0

   682 	*/

   683 	IMPORT_C void SetGrammarID(TGrammarID aGrammarID);

   685 	/**

   686     Returns the grammar ID of the result.

   688 	@return The grammar identifier.

   690 	@since 8.0

   691 	*/

   692 	IMPORT_C TGrammarID GrammarID() const;

   694 	/**

   695     Sets the rule ID of the result.

   697 	@param  aRuleID

   698 	        The rule identifier.

   700 	@since  8.0

   701 	*/

   702 	IMPORT_C void SetRuleID(TRuleID aRuleID);

   704 	/**

   705     Returns the rule ID of the result.

   707 	@return The rule identifier.

   709 	@since  8.0

   710 	*/

   711 	IMPORT_C TRuleID RuleID() const;

   713 	/**

   714     Sets the score for this result.

   716 	@param aScore

   717 	       The score of this result.

   719 	@since 8.0

   720 	*/

   721 	IMPORT_C void SetScore(const TInt32 aScore);

   723 	/**

   724 	Returns the score of this result.

   726 	@return The score of this result.

   728 	@since 8.0

   729 	*/

   730 	IMPORT_C TInt32 Score() const;

   732 private:

   733 	void ConstructL();

   734 	CSDResult();

   735 	CSDResult(TGrammarID aGrammarID, TRuleID aRuleID);

   737 private:

   738 	TGrammarID iGrammarID;

   739 	TRuleID iRuleID;

   740 	TInt32 iScore;

   741 };

   744 /**

   745 @publishedAll

   746 @released

   748 CSDResultSet encapsulates a set of result objects returned by the recognizer at the end of the

   749 recognition process. A result set may include additional diagnostic information for error analysis.

   751 @since  8.0

   752 */

   753 class CSDResultSet : public CBase

   754 {

   755 public:// Constructors and destructor

   757 	/**

   758     Destructor.

   759 	*/

   760 	IMPORT_C ~CSDResultSet();

   762 	/**

   763 	Instantiates an instance of CSDResultSet.

   765 	@return A pointer to a CSDResultSet object.

   766 	*/

   767 	IMPORT_C static CSDResultSet* NewL();

   769 	/**

   770 	Instantiates an instance of CSDResultSet and leaves a pointer on the cleanup stack.

   772 	@return A pointer to a CSDResultSet object.

   773 	*/

   774 	IMPORT_C static CSDResultSet* NewLC();

   776 	/**

   777 	Adds a result to the rule set.

   779 	@param  aResult

   780 	        A reference to the result object to be added.

   782 	@return An error code indicating if the function call was successful. KErrNone on success, otherwise

   783 	        another of the system-wide error codes.

   785 	@since  8.0

   786 	*/

   787 	IMPORT_C TInt Add(CSDResult& aResult);

   789 	/**

   790     Returns a result at a given index within the result set.

   792 	@param  aIndex

   793 	        The index in the result set.

   795 	@return  A reference to CSDResult object.

   797 	@since  8.0

   798 	*/

   799 	IMPORT_C const CSDResult& At(TInt aIndex);

   801 	/**

   802     Returns the number of results in the result set.

   804 	@return The number of results in the result set.

   806     @since  8.0

   807 	*/

   808 	IMPORT_C TInt Count() const;

   810 	/**

   811 	Sets the diagnostic of this result set.

   813 	@param  aDiagnostic

   814 	        A reference to the diagostic object.

   816 	@since  8.0

   817 	*/

   818 	IMPORT_C void SetDiagnostic(TDiagnostic& aDiagnostic);

   820 	/**

   821     Gets the diagnostic of this result set.

   823 	@return A reference to A TDiagnostic object.

   825 	@since  8.0

   826 	*/

   827 	IMPORT_C const TDiagnostic& Diagnostic() const;

   829 private:

   830 	void ConstructL();

   831 	CSDResultSet();

   833 private:

   834 	RPointerArray<CSDResult> iResultArray;

   835 	TDiagnostic* iDiagnostic;

   836 };

   839 #endif

author	sl
	Tue, 10 Jun 2014 14:32:02 +0200
changeset 1	260cb5ec6c19
permissions	-rw-r--r--