1 /*

     2 * Copyright (c) 2004-2007 Nokia Corporation and/or its subsidiary(-ies). 

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

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

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  Implementations for CTTSAlgorithmManager methods.

    15 *

    16 */

    17 

    18 

    19 // INCLUDE FILES

    20 #include <barsc.h>

    21 #include <bautils.h>

    22 #include <barsread.h>

    23 #include <nssdevtts.rsg>

    24 #include <AudioPreference.h>

    25 #include <data_caging_path_literals.hrh>

    26 #include "devttsalgorithmmanager.h"

    27 #include "rubydebug.h"

    28 

    29 #ifdef _DEBUG

    30 #include <e32svr.h>

    31 #endif

    32 

    33 // CONSTANTS

    34 _LIT( KResourceFileName, "nssdevtts.rsc" );

    35 

    36 // Default audio priority

    37 const TInt KDefaultPriority = KAudioPriorityVoiceDial;

    38 

    39 #ifdef DEVTTS_AUDIOBUFFER_TO_FILE

    40 const TFileName KAudioBufferFileName( _L( "c:\\documents\\devttsaudio" ) );

    41 const TFileName KAudioBufferFileNameExtension( _L( ".raw" ) );

    42 #endif

    43 

    44 // ============================ MEMBER FUNCTIONS ===============================

    45 

    46 // -----------------------------------------------------------------------------

    47 // CTTSAlgorithmManager::CTTSAlgorithmManager

    48 // C++ default constructor can NOT contain any code, that

    49 // might leave.

    50 // -----------------------------------------------------------------------------

    51 //

    52 CTTSAlgorithmManager::CTTSAlgorithmManager( MDevTTSObserver& aObserver ):

    53         iPaused( EFalse ),

    54         iObserver( aObserver ),

    55         iAudio( NULL ),

    56         iAudioState( ETTSAudioPlayerNotInitialized ),

    57         iHw( NULL ),

    58         iError( KErrNone ),

    59         iState( EDevTTSNotInitialized ),

    60         iMode( EDevTTSSoundDeviceMode ),

    61         iLastBufferFromTts( EFalse ),

    62         iTtpHw( NULL ), 

    63 #ifdef DEVTTS_3DB_HACK

    64 		iApplyGain( ETrue ),

    65 #endif

    66         iNlp( NULL ),

    67         iNlpInitialized( EFalse )

    68     {

    69     // Nothing

    70     }

    71 

    72 // -----------------------------------------------------------------------------

    73 // CTTSAlgorithmManager::ConstructL

    74 // Symbian 2nd phase constructor can leave.

    75 // -----------------------------------------------------------------------------

    76 //

    77 void CTTSAlgorithmManager::ConstructL(/*CConsoleBase* console*/)

    78     {

    79     RUBY_DEBUG_BLOCK( "CTTSAlgorithmManager::ConstructL" );

    80     

    81     TBool boolStereo( EFalse );

    82     TUint intStereo( 0 );

    83     TUint bitsPerSample( 16 );

    84     TUint samplingRate( 16000 );

    85     TUint bufferSize( 4096 );

    86     TInt defaultPriority( 0 );

    87     

    88     // Try to find resource file first from MMC, then from C-drive and only 

    89     // after that from flash

    90     // letters for drives in search order

    91     const TBuf<2> KResourceDrives = _L("cz"); 

    92     

    93     // load resources

    94     RResourceFile resourceFile;

    95     RFs fs;

    96     User::LeaveIfError( fs.Connect() );

    97     CleanupClosePushL( fs );

    98     

    99     TFileName name;

   100     TInt i( 0 );

   101     // try to find from the first driver

   102     name.Append( KResourceDrives[i] );

   103     name.Append( ':' );

   104     name.Append( KDC_RESOURCE_FILES_DIR );

   105     name.Append( KResourceFileName );

   106 

   107     TBool found( EFalse );

   108     

   109     while ( !found && i < KResourceDrives.Length() )

   110         {

   111         name[0] = KResourceDrives[i++];

   112        

   113         if ( BaflUtils::FileExists(fs, name) )

   114             {

   115             // open resource

   116             resourceFile.OpenL( fs, name );

   117             CleanupClosePushL( resourceFile );

   118             found = ETrue;

   119             }

   120         }

   121             

   122     if ( !found )

   123         {

   124         User::Leave( KErrNotFound );

   125         }

   126 

   127     HBufC8* configurations = resourceFile.AllocReadLC( R_DEVTTS_CONFIGURATIONS );

   128     

   129     TResourceReader resReader;

   130     resReader.SetBuffer( configurations );

   131     

   132     // Sampling rate

   133     samplingRate = resReader.ReadUint32();

   134 

   135     // Bits per sample

   136     bitsPerSample = resReader.ReadUint32();

   137     

   138     // Mono / Stereo

   139     intStereo = resReader.ReadUint32();

   140 

   141     // Buffer size

   142     bufferSize = resReader.ReadUint32();

   143 

   144 #ifdef __WINS__

   145     // CMMFDevSound uses currently buffer size of 16384 in emulator. 

   146     RUBY_DEBUG0( "CTTSAlgorithmManager::ConstructL - Hard coded buffer size in use!" );

   147     bufferSize = 16384;

   148 #endif

   149 

   150     // Priority

   151     defaultPriority = KDefaultPriority;

   152     

   153     if ( intStereo == 0 )

   154         {

   155         boolStereo = EFalse;

   156         }

   157     else

   158         {

   159         boolStereo = ETrue;

   160         }

   161         

   162     // Cleanup configurations, resourceFile, fs

   163     CleanupStack::PopAndDestroy( configurations );    

   164     CleanupStack::PopAndDestroy( &resourceFile );

   165     CleanupStack::PopAndDestroy( &fs );

   166 

   167     // Create new TtsHwDevice instance

   168     iHw = CTtsHwDevice::NewL( *this, samplingRate, bufferSize );

   169     

   170     // Create audio playback instance

   171     iAudio = CDevTTSAudio::NewL( *this, defaultPriority );

   172     

   173     iState = EDevTTSStopped;

   174     

   175     // Start audio device initialization process

   176     iAudio->InitializeL();

   177 

   178     // Wait for callback only if it is asynchronous

   179     // (state will be something else if it is synchronous)

   180     if ( iAudioState == ETTSAudioPlayerNotInitialized )

   181         {

   182         if ( !iAudioWait.IsStarted() )

   183             {

   184             RUBY_DEBUG0( "CTTSAlgorithmManager::ConstructL iAudioWait.Start()" );

   185             iAudioWait.Start();

   186             }

   187         }

   188         

   189     iAudio->ConfigL( samplingRate, bitsPerSample, boolStereo, bufferSize);

   190 

   191     // Create & initialize TtpHwDevice

   192     iTtpHw = CASRSTtpHwDevice::NewL( *this );

   193     iTtpHw->InitializeL();

   194     iTtpHw->SetPhonemeNotationL( _L( "NIPA8" ) );

   195     

   196     // Create NlpHwDevice

   197     TRAPD( error, iNlp = CNlpHwDevice::NewL( *this ) );

   198     if ( error == KErrNone )

   199         {

   200         iNlp->InitializeL();

   201         iNlpInitialized = ETrue;

   202         }

   203     else

   204         {

   205         iNlpInitialized = EFalse;

   206         }

   207 

   208 #ifdef DEVTTS_AUDIOBUFFER_TO_FILE

   209     User::LeaveIfError( iSession.Connect() );

   210     iFileOpen = EFalse;

   211     iFileCounter = 0;

   212 #endif

   213 

   214     RUBY_DEBUG1( "CTTSAlgorithmManager config, sampling rate: %d", samplingRate );

   215     RUBY_DEBUG1( "CTTSAlgorithmManager config, bits per sample: %d", bitsPerSample);

   216     RUBY_DEBUG1( "CTTSAlgorithmManager config, mono/stereo: %d", intStereo);

   217     RUBY_DEBUG1( "CTTSAlgorithmManager config, buffer size: %d", bufferSize);

   218     }

   219 

   220 // -----------------------------------------------------------------------------

   221 // CTTSAlgorithmManager::NewL

   222 // Two-phased constructor.

   223 // -----------------------------------------------------------------------------

   224 //

   225 CTTSAlgorithmManager* CTTSAlgorithmManager::NewL( MDevTTSObserver& aObserver/*, CConsoleBase* console*/ )

   226     {

   227     CTTSAlgorithmManager* self = new( ELeave ) CTTSAlgorithmManager(aObserver);

   228     

   229     CleanupStack::PushL( self );

   230     self->ConstructL( /*console*/ );

   231     CleanupStack::Pop( self );

   232     

   233     return self;

   234     }

   235 

   236 // -----------------------------------------------------------------------------

   237 // CTTSAlgorithmManager::~CTTSAlgorithmManager

   238 // Destructor.

   239 // -----------------------------------------------------------------------------

   240 //

   241 CTTSAlgorithmManager::~CTTSAlgorithmManager()

   242     {

   243     if ( iAudio )

   244         {

   245         iAudio->Clear();

   246         delete iAudio;

   247         iAudio = NULL;

   248         }

   249     if ( iHw )

   250         {

   251         delete iHw;

   252         iHw = NULL;

   253         }

   254     if ( iTtpHw )

   255         {

   256         iTtpHw->Clear();

   257         delete iTtpHw;

   258         iTtpHw = NULL;

   259         }

   260     if ( iNlp )

   261         {

   262         iNlp->Clear();

   263         delete iNlp;

   264         iNlp = NULL;

   265         }

   266 #ifdef DEVTTS_AUDIOBUFFER_TO_FILE

   267     iSession.Close();

   268 #endif

   269     }

   270 

   271 

   272 // -----------------------------------------------------------------------------

   273 // CTTSAlgorithmManager::AddStyleL

   274 // Forwards call to TtsHwDevice

   275 // -----------------------------------------------------------------------------

   276 //

   277 TTtsStyleID CTTSAlgorithmManager::AddStyleL( const TTtsStyle& aStyle )

   278     {

   279     return iHw->AddStyleL( aStyle );

   280     }

   281 

   282 // -----------------------------------------------------------------------------

   283 // CTTSAlgorithmManager::Balance

   284 // Forwards call to the CDevTTSAudio.

   285 // -----------------------------------------------------------------------------

   286 //

   287 TInt CTTSAlgorithmManager::Balance()

   288     {

   289     return iAudio->Balance();

   290     }

   291 

   292 // -----------------------------------------------------------------------------

   293 // CTTSAlgorithmManager::BufferProcessed

   294 // Forwards call to TtsHwDevice

   295 // -----------------------------------------------------------------------------

   296 //

   297 void CTTSAlgorithmManager::BufferProcessed( const TDesC8& aBuffer )

   298     {

   299     // Client should call this only when buffers are provided to client

   300     if ( iMode == EDevTTSClientMode )

   301         {

   302         iHw->BufferProcessed( aBuffer );

   303         }

   304     }

   305 

   306 // -----------------------------------------------------------------------------

   307 // CTTSAlgorithmManager::CustomInterface

   308 // Not in use currently. Now returns NULL.

   309 // -----------------------------------------------------------------------------

   310 //

   311 TAny* CTTSAlgorithmManager::CustomInterface( TUid /*aInterfaceID*/ )

   312     {

   313     return NULL;

   314     }

   315 

   316 // -----------------------------------------------------------------------------

   317 // CTTSAlgorithmManager::DeleteStyleL

   318 // Forwards call to the actual implementation object.

   319 // -----------------------------------------------------------------------------

   320 //

   321 void CTTSAlgorithmManager::DeleteStyleL( TTtsStyleID aStyleID )

   322     {

   323     iHw->DeleteStyleL( aStyleID );

   324     }

   325 

   326 // -----------------------------------------------------------------------------

   327 // CTTSAlgorithmManager::GetPositionL

   328 // Forwards call to TtsHwDevice

   329 // -----------------------------------------------------------------------------

   330 //

   331 void CTTSAlgorithmManager::GetPositionL( TTimeIntervalMicroSeconds& aTime ) const

   332     {

   333     iHw->GetPositionL( aTime );

   334     }

   335 

   336 // -----------------------------------------------------------------------------

   337 // CTTSAlgorithmManager::GetPositionL

   338 // Forwards call to TtsHwDevice

   339 // -----------------------------------------------------------------------------

   340 //

   341 void CTTSAlgorithmManager::GetPositionL( TTtsSegment& aSegment, TInt& aWordIndex ) const

   342     {

   343     iHw->GetPositionL( aSegment, aWordIndex );

   344     }

   345 

   346 

   347 // -----------------------------------------------------------------------------

   348 // CTTSAlgorithmManager::IsLanguageSupported

   349 // Forwards call to TtsHwDevice

   350 // -----------------------------------------------------------------------------

   351 //

   352 TBool CTTSAlgorithmManager::IsLanguageSupported( TLanguage aLanguage ) const

   353     {

   354     return iHw->IsLanguageSupported( aLanguage );

   355     }

   356 

   357 // -----------------------------------------------------------------------------

   358 // CTTSAlgorithmManager::MaxVolume

   359 // Forwards call to the CDevTTSAudio.

   360 // -----------------------------------------------------------------------------

   361 //

   362 TInt CTTSAlgorithmManager::MaxVolume()

   363     {

   364     return iAudio->MaxVolume();

   365     }

   366 

   367 // -----------------------------------------------------------------------------

   368 // CTTSAlgorithmManager::NumberOfStyles

   369 // Forwards call to TtsHwDevice

   370 // -----------------------------------------------------------------------------

   371 //

   372 TUint16 CTTSAlgorithmManager::NumberOfStyles() const

   373     {

   374     return iHw->NumberOfStyles();

   375     }

   376 

   377 // -----------------------------------------------------------------------------

   378 // CTTSAlgorithmManager::Pause

   379 // Pauses synthesis process in TtsHwDevice and also audio playback if needed.

   380 // -----------------------------------------------------------------------------

   381 //

   382 void CTTSAlgorithmManager::Pause()

   383     {

   384     // Do nothing if not synthesizing currently

   385     if ( iState != EDevTTSSynthesizing )

   386         {

   387         return;

   388         }

   389     

   390     // Stop synthesis and playback

   391     iHw->Pause();

   392 

   393     if( iMode == EDevTTSSoundDeviceMode )

   394         {

   395         // Do a complete stop to the audio player instead of pause.

   396         // Pausing and resuming after that leads to the situation where all of

   397         // the data won't be played...

   398         iAudio->Stop();

   399         iAudioState = ETTSAudioPlayerPaused;

   400         }

   401     

   402     iState = EDevTTSPrimed;

   403     iPaused = ETrue;

   404     }

   405 

   406 // -----------------------------------------------------------------------------

   407 // CTTSAlgorithmManager::PrimeSynthesisL

   408 // Prepares a synthesizing process, data will be read from client using a 

   409 // stream.

   410 // -----------------------------------------------------------------------------

   411 //

   412 void CTTSAlgorithmManager::PrimeSynthesisL( MTtsSegmentStream& aStream ) 

   413     {

   414     // Not yet in use, leave every time

   415     // @todo: Remove this when functionality is available

   416     User::Leave( KErrNotSupported );

   417     

   418     // Do the state check    

   419     if ( iState == EDevTTSNotInitialized )

   420         {

   421         User::Leave( KErrNotReady );

   422         }

   423     

   424     if ( iState != EDevTTSStopped )

   425         {

   426         User::Leave( KErrInUse );

   427         }

   428     

   429     iHw->PrimeSynthesisL( aStream );

   430     

   431     iState = EDevTTSPrimed;

   432     }

   433 

   434 // -----------------------------------------------------------------------------

   435 // CTTSAlgorithmManager::PrimeSynthesisL

   436 // Prepares a synthesizing process.

   437 // -----------------------------------------------------------------------------

   438 //

   439 void CTTSAlgorithmManager::PrimeSynthesisL( CTtsParsedText& aText )

   440     {

   441     RUBY_DEBUG_BLOCK( "CTTSAlgorithmManager::PrimeSynthesisL" );

   442 

   443     // Do the state check

   444     

   445     if ( iState == EDevTTSNotInitialized )

   446         {

   447         User::Leave( KErrNotReady );

   448         }

   449     

   450     if (iState != EDevTTSStopped)

   451         {

   452         User::Leave( KErrInUse );

   453         }

   454     

   455     // 1. Analyze structure if no segments in the parsed text object

   456     if ( aText.NumberOfSegments() == 0 )

   457         {

   458         iHw->AnalyzeStructureL( aText );

   459         }

   460 

   461     // 2. Call NLP if there is written text

   462     if ( ( aText.Text() != KNullDesC16 ) && iNlpInitialized )

   463         {

   464         

   465         TBool useNlp( ETrue );

   466         TInt counter( 0 );

   467         

   468         // Loop through content types of segments to find out if NLP should be used

   469         for ( counter = 0; counter < aText.NumberOfSegments(); counter++ )

   470             {

   471             TTtsSegment segment = aText.SegmentL( counter );

   472             TTtsStyleID styleID = segment.StyleID();

   473             TTtsStyle& style = StyleL( styleID );

   474             

   475             if ( !style.iNlp )

   476                 {

   477                 useNlp = EFalse;                

   478                 }

   479             }

   480         

   481         if ( useNlp )

   482             {

   483             // If language is not specified, run LID before NLP

   484             for ( counter = 0; counter < aText.NumberOfSegments(); counter++ )

   485                 {

   486                 TTtsSegment segment = aText.SegmentL( counter );

   487                 TTtsStyleID styleID = segment.StyleID();

   488                 TTtsStyle& style = StyleL( styleID );

   489 

   490                 if ( style.iLanguage == ELangOther )

   491                     {

   492                     RArray<TLanguage> languages;

   493                     RArray<TInt> scores;

   494                 

   495                     // Only one result is needed

   496                     iTtpHw->LanguageIdentificationL( segment.TextPtr(), 1, languages, scores );

   497 

   498                     if ( languages.Count() == 0 )

   499                         {

   500                         languages.Close();

   501                         scores.Close();

   502                         User::Leave( KErrGeneral );

   503                         }

   504 

   505                     style.iLanguage = languages[0];

   506 

   507                     RUBY_DEBUG1( "CTTSAlgorithmManager::PrimeSynthesisL called LID [lang id: %d] before NLP", style.iLanguage );

   508 

   509                     languages.Close();

   510                     scores.Close();

   511                     }

   512                 }

   513             }

   514             

   515         if ( useNlp )

   516             {

   517             iNlp->NormalizeTextL( aText );

   518             }

   519         }

   520 

   521     // Set the phoneme notation which is given within parsed text into TTP

   522     // Do this only if no phonemesequence is given and if notation is something

   523     // else than the default

   524     if ( ( aText.PhonemeNotation() != KNullDesC16 ) && ( aText.PhonemeSequence() == KNullDesC8 ) )

   525         {

   526         iTtpHw->SetPhonemeNotationL( aText.PhonemeNotation() );

   527         }

   528 

   529     // 3. Do the TTP if phoneme sequence not available

   530     if ( aText.PhonemeSequence() == KNullDesC8 )

   531         {

   532         // If also text is NULL, argument is not ok

   533         if ( aText.Text() == KNullDesC16 )

   534             {

   535             User::Leave( KErrArgument );

   536             }

   537         

   538 #ifdef __SIND_MULTIPLE_SEGMENTS

   539         RArray<TInt> segmentPhonemeLengths;

   540         CleanupClosePushL(segmentPhonemeLengths);

   541 #endif // __SIND_MULTIPLE_SEGMENTS

   542         // Find the style attached to each segment

   543         for ( TInt i = 0; i < aText.NumberOfSegments(); i++ )

   544             {

   545             TTtsSegment segment = aText.SegmentL( i );

   546             TTtsStyleID styleID = segment.StyleID();

   547             TTtsStyle& style = StyleL( styleID );

   548             

   549             RUBY_DEBUG1( "CTTSAlgorithmManager::PrimeSynthesisL calling TTP with lang id [%d]", style.iLanguage );

   550 

   551             HBufC8* phonemeBuffer = iTtpHw->ConvertTextL( segment.TextPtr(), style.iLanguage );

   552             

   553             if ( phonemeBuffer == NULL )

   554                 {

   555                 RUBY_DEBUG0( "CTTSAlgorithmManager::PrimeSynthesisL TTP returned NULL, calling again with ELangOther" );

   556 

   557                 // Try with another approach, use ELangOther as language and let

   558                 // the LID to do the job

   559                 if ( style.iLanguage != ELangOther )

   560                     {

   561                     style.iLanguage = ELangOther;

   562                     phonemeBuffer = iTtpHw->ConvertTextL( segment.TextPtr(), style.iLanguage );

   563                     RUBY_DEBUG1( "CTTSAlgorithmManager::PrimeSynthesisL LID returned lang id [%d]", style.iLanguage );

   564                     if ( phonemeBuffer == NULL )

   565                         {

   566                         User::Leave( KErrGeneral );

   567                         }

   568                     }

   569                 else

   570                     {

   571                     User::Leave( KErrGeneral );

   572                     }

   573                 }

   574 

   575             CleanupStack::PushL( phonemeBuffer );

   576 

   577 #ifdef __SIND_MULTIPLE_SEGMENTS

   578             // Append segment's phone sequence to CTtsparsedText's phoneme sequence

   579             HBufC8*  phonemeSeq = HBufC8::NewLC( aText.PhonemeSequence().Length() + phonemeBuffer->Des().Length() );

   580             phonemeSeq->Des().Append( aText.PhonemeSequence() );

   581             phonemeSeq->Des().Append( phonemeBuffer->Des() );

   582             // Set new phoneme sequence

   583             aText.SetPhonemeSequenceL( *phonemeSeq );

   584             CleanupStack::PopAndDestroy( phonemeSeq );

   585             

   586             // Save the length of segment's phoneme sequence

   587             segmentPhonemeLengths.AppendL( phonemeBuffer->Des().Length() );

   588 

   589 #else

   590             aText.SetPhonemeSequenceL( phonemeBuffer->Des() );

   591             

   592             segment.SetPhonemeSequencePtr( aText.PhonemeSequence() );

   593             // Add modified segment to parsed text

   594             aText.DeleteSegmentL( i );

   595             aText.AddSegmentL( segment, i );

   596 #endif // __SIND_MULTIPLE_SEGMENTS

   597             

   598             // phonemeBuffer

   599             CleanupStack::PopAndDestroy( phonemeBuffer );

   600             }

   601         

   602 #ifdef __SIND_MULTIPLE_SEGMENTS

   603         // Put pointers of the whole phone sequence in CTtsParsedText

   604         // to their respective segments 

   605         TInt position( 0 );

   606         for ( TInt i = 0; i < aText.NumberOfSegments(); i++ )

   607             {

   608             TTtsSegment segment = aText.SegmentL( i );

   609             segment.SetPhonemeSequencePtr( aText.PhonemeSequence().Mid( position, segmentPhonemeLengths[i] ) );

   610             // Add modified segment to parsed text

   611             aText.DeleteSegmentL( i );

   612             aText.AddSegmentL( segment, i );

   613             // Move the position to next segments starting position

   614             position += segmentPhonemeLengths[i];

   615             }

   616         

   617         // Release resources allocated by RArray    

   618         CleanupStack::PopAndDestroy( &segmentPhonemeLengths );

   619 #endif // __SIND_MULTIPLE_SEGMENTS

   620         

   621         }

   622 

   623 #ifdef DEVTTS_3DB_HACK

   624 	iApplyGain = ETrue;

   625 #endif

   626 

   627 

   628     // 4. Analyze prosody

   629     iHw->AnalyzeProsodyL( aText );    

   630     

   631     // 5. Prime TtsHwDevice

   632     iHw->PrimeSynthesisL( aText );

   633     

   634     iState = EDevTTSPrimed;

   635     }

   636 

   637 // -----------------------------------------------------------------------------

   638 // CTTSAlgorithmManager::SetAudioPriority

   639 // Forwards call to the CDevTTSAudio

   640 // -----------------------------------------------------------------------------

   641 //

   642 void CTTSAlgorithmManager::SetAudioPriority( TInt aPriority, TDevTTSAudioPreference aPref )

   643     {

   644     iAudio->SetAudioPriority( aPriority, aPref );

   645     }

   646 

   647 // -----------------------------------------------------------------------------

   648 // CTTSAlgorithmManager::SetAudioOutputL

   649 // Forwards call to the CDevTTSAudio

   650 // -----------------------------------------------------------------------------

   651 //

   652 void CTTSAlgorithmManager::SetAudioOutputL( TInt aAudioOutput )

   653     {

   654     iAudio->SetAudioOutputL( aAudioOutput );

   655     }

   656 

   657 // -----------------------------------------------------------------------------

   658 // CTTSAlgorithmManager::SetBalance

   659 // Forwards call to the CDevTTSAudio

   660 // -----------------------------------------------------------------------------

   661 //

   662 void CTTSAlgorithmManager::SetBalance( TInt aBalance )

   663     {

   664     iAudio->SetBalance( aBalance );

   665     }

   666 

   667 // -----------------------------------------------------------------------------

   668 // CTTSAlgorithmManager::SetPositionL

   669 // Forwards call to TtsHwDevice

   670 // -----------------------------------------------------------------------------

   671 //

   672 void CTTSAlgorithmManager::SetPositionL( const TTimeIntervalMicroSeconds& aTime )

   673     {

   674     iHw->SetPositionL( aTime );

   675     }

   676 

   677 // -----------------------------------------------------------------------------

   678 // CTTSAlgorithmManager::SetPositionL

   679 // Forwards call to TtsHwDevice

   680 // -----------------------------------------------------------------------------

   681 //

   682 void CTTSAlgorithmManager::SetPositionL( const TTtsSegment& aSegment, 

   683                                          TInt aWordIndex )

   684     {

   685     iHw->SetPositionL( aSegment, aWordIndex );

   686     }

   687 

   688 // -----------------------------------------------------------------------------

   689 // CTTSAlgorithmManager::SetVolume

   690 // Forwards call to the CDevTTSAudio

   691 // -----------------------------------------------------------------------------

   692 //

   693 void CTTSAlgorithmManager::SetVolume( TInt aVolume )

   694     {

   695     iAudio->SetVolume( aVolume );

   696     }

   697 

   698 // -----------------------------------------------------------------------------

   699 // CTTSAlgorithmManager::SetVolumeRamp

   700 // Forwards call to the CDevTTSAudio

   701 // -----------------------------------------------------------------------------

   702 //

   703 void CTTSAlgorithmManager::SetVolumeRamp( const TTimeIntervalMicroSeconds& aRampDuration )

   704     {

   705     iAudio->SetVolumeRamp( aRampDuration );

   706     }

   707 

   708 // -----------------------------------------------------------------------------

   709 // CTTSAlgorithmManager::Stop

   710 // Stop synthesis process as well as audio playback if running.

   711 // -----------------------------------------------------------------------------

   712 //

   713 void CTTSAlgorithmManager::Stop()

   714     {

   715     if ( iState == EDevTTSNotInitialized )

   716         {

   717         // Just to play it safe, do nothing if not initialized

   718         return;

   719         }

   720     

   721     if ( iAudioState == ETTSAudioPlayerPlaying )

   722         {

   723         iAudio->Stop();

   724         iAudioState = ETTSAudioPlayerIdle;

   725         }

   726     if ( iState == EDevTTSSynthesizing || iState == EDevTTSPrimed )

   727         {

   728         iHw->Stop();

   729         }

   730     

   731     iState = EDevTTSStopped;

   732     

   733     // Clear paused flag. might be that we are stopping after pausing

   734     iPaused = EFalse;

   735     }

   736 

   737 // -----------------------------------------------------------------------------

   738 // CTTSAlgorithmManager::StyleL

   739 // Forwards call to TtsHwDevice

   740 // -----------------------------------------------------------------------------

   741 //

   742 TTtsStyle& CTTSAlgorithmManager::StyleL( TTtsStyleID aStyleID ) const

   743     {

   744     return iHw->StyleL( aStyleID );

   745     }

   746 

   747 // -----------------------------------------------------------------------------

   748 // CTTSAlgorithmManager::StyleL

   749 // Forwards call to TtsHwDevice

   750 // -----------------------------------------------------------------------------

   751 //

   752 TTtsStyle& CTTSAlgorithmManager::StyleL( TUint16 aIndex ) const

   753     {

   754     return iHw->StyleL(  aIndex );

   755     }

   756 

   757 // -----------------------------------------------------------------------------

   758 // CTTSAlgorithmManager::SynthesizeL

   759 // Starts or resumes synthesis process. 

   760 // -----------------------------------------------------------------------------

   761 //

   762 void CTTSAlgorithmManager::SynthesizeL( TDevTTSOutputMode aOutputMode ) 

   763     {

   764     

   765     if ( (iState == EDevTTSNotInitialized) || (iState == EDevTTSStopped) )

   766         {

   767         User::Leave( KErrNotReady );

   768         }

   769     

   770     if ( iState != EDevTTSPrimed )

   771         {

   772         User::Leave( KErrInUse );

   773         }

   774     

   775     // If iPaused flag is set, we know that there is an

   776     // ongoing synthesis process and we should resume that instead of starting

   777     // a new one.

   778     if ( iPaused )

   779         {

   780         // Resume synthesis by calling hwdevice

   781         iHw->SynthesizeL();

   782         

   783         if ( iMode == EDevTTSSoundDeviceMode )

   784             {

   785             iAudio->PlayInitL();

   786             

   787             iAudioState = ETTSAudioPlayerPlaying;

   788             }

   789         iState = EDevTTSSynthesizing;

   790         iPaused = EFalse;

   791         return;

   792         }

   793     

   794     iMode = aOutputMode;

   795     

   796     // Start synthesizing by calling hwdevice

   797     iHw->SynthesizeL();

   798     iLastBufferFromTts = EFalse;

   799     

   800     if ( iMode == EDevTTSSoundDeviceMode )

   801         {

   802         // Check the audio player state

   803         if ( iAudioState == ETTSAudioPlayerNotInitialized || 

   804             iAudioState == ETTSAudioPlayerError )

   805             {

   806             User::Leave( KErrNotReady );

   807             }

   808         

   809         if ( iAudioState == ETTSAudioPlayerPlaying )

   810             {

   811             User::Leave( KErrInUse );

   812             }

   813         

   814         // Initialize audio device so that it is ready for playback

   815         iAudio->PlayInitL();

   816         

   817         iAudioState = ETTSAudioPlayerPlaying;

   818         }

   819     

   820     iState = EDevTTSSynthesizing;

   821 

   822     RUBY_DEBUG0( "CTTSAlgorithmManager::SynthesizeL started" );

   823     }

   824 

   825 // -----------------------------------------------------------------------------

   826 // CTTSAlgorithmManager::Volume

   827 // Forwards call to the CDevTTSAudio.

   828 // -----------------------------------------------------------------------------

   829 //

   830 TInt CTTSAlgorithmManager::Volume()

   831     {

   832     return iAudio->Volume();

   833     }

   834 

   835 

   836 // ========================== CALLBACKS FROM DEVTTSAUDIO =======================

   837 

   838 

   839 // -----------------------------------------------------------------------------

   840 // CTTSAlgorithmManager::InitializeComplete

   841 // Audio has been initialized.

   842 // -----------------------------------------------------------------------------

   843 //

   844 void CTTSAlgorithmManager::MdtaoInitializeComplete(TInt aError) 

   845     {

   846     if ( aError == KErrNone )

   847         {

   848         iAudioState = ETTSAudioPlayerIdle;

   849         RUBY_DEBUG0( "CTTSAlgorithmManager::InitializeComplete ok" );

   850         }

   851     else

   852         {

   853         iAudioState = ETTSAudioPlayerError;

   854         RUBY_DEBUG0( "CTTSAlgorithmManager::InitializeComplete ERROR" );

   855         }

   856         

   857     if ( iAudioWait.IsStarted() )

   858         {

   859         RUBY_DEBUG0( "DEVTTS iAudioWait.AsyncStop()" );                	

   860         iAudioWait.AsyncStop();

   861         }                   

   862     }

   863 

   864 // -----------------------------------------------------------------------------

   865 // CTTSAlgorithmManager::MdtaoBufferToBeFilled

   866 // Audio player wants a new buffer so that it can be played.

   867 // -----------------------------------------------------------------------------

   868 //

   869 void CTTSAlgorithmManager::MdtaoBufferToBeFilled( TDes8& aBuffer, 

   870                                                   TInt aSizeRequested )

   871     {

   872     RUBY_DEBUG1( "CTTSAlgorithmManager::MdtaoBufferToBeFilled size of wanted audio buffer: %d bytes", aSizeRequested );

   873     

   874     // Sometimes it might happen that we get still one callback even though

   875     // DevSound is not anymore playing

   876     if ( iAudioState != ETTSAudioPlayerPlaying )

   877         {

   878         RUBY_DEBUG0( "CTTSAlgorithmManager::MdtaoBufferToBeFilled called even though iAudioState != ETTSAudioPlayerPlaying" );

   879         return;

   880         }

   881 

   882     const TUint8* buffer = iPlaybackBuffer.Ptr();

   883     

   884     if ( iStartPoint >= iStopPoint )

   885         {

   886         // Underflow, nothing to be sent to audio out

   887         aBuffer.FillZ( aSizeRequested );

   888         aBuffer.SetLength( aSizeRequested );

   889         

   890         iAudio->PlayData( iLastBufferFromTts );

   891         return;

   892         }

   893     

   894     TInt copyLength = 0;

   895     // Tells if the whole buffer given by TtsHwDevice has been played

   896     TBool last = EFalse;

   897     

   898     if ( ( iStartPoint + aSizeRequested ) >= iStopPoint )

   899         {

   900         // We get to the end of the data that needs to be played

   901         last = ETrue;

   902         copyLength = iStopPoint - iStartPoint + 1;

   903         

   904         // Empty buffer

   905         aBuffer.FillZ();

   906         }

   907     else

   908         {

   909         // Fill the whole requested size

   910         copyLength = aSizeRequested;

   911         }

   912     

   913     // Copy data to audio out buffer

   914     aBuffer.Copy( &buffer[iStartPoint], copyLength);

   915 

   916 #ifdef DEVTTS_3DB_HACK

   917 	if( iApplyGain ) 

   918 	{

   919 		const TInt32 KSqrt2FXP = 0x00002d41L;

   920 		const TInt32 KSqrt2Shift = 13;

   921 		TPtr16 audioData((TUint16*)(aBuffer.Ptr()), copyLength/2, copyLength/2);

   922 		for( int i=0; i<copyLength/2; ++i )

   923 		{

   924 			TInt16 sample = audioData[i];

   925 			TInt32 newvalue = (sample * KSqrt2FXP) >> KSqrt2Shift; 

   926 			if(newvalue > 0x7fffL | newvalue < -0x8000L) 

   927 			{

   928 				

   929 				iApplyGain = EFalse;

   930 				break;

   931 			}

   932 			audioData[i] = newvalue;

   933 		}

   934 	}

   935 #endif

   936     

   937     // Notify TtsHwDevice

   938     if ( last )

   939         {

   940         iHw->BufferProcessed( iPlaybackBuffer );

   941         }

   942     

   943     RUBY_DEBUG1( "CTTSAlgorithmManager::MdtaoBufferToBeFilled Audio buffer size filled: %d bytes\n", aBuffer.Length() );

   944     

   945     iStartPoint = iStartPoint + copyLength;

   946     

   947     iAudio->PlayData( iLastBufferFromTts );

   948     }

   949 

   950 // -----------------------------------------------------------------------------

   951 // CTTSAlgorithmManager::PlayFinished

   952 // Checks the incoming error code and sets the audio state accordingly.

   953 // -----------------------------------------------------------------------------

   954 //

   955 void CTTSAlgorithmManager::MdtaoPlayFinished( TInt aError )

   956     {

   957     iAudioState = ETTSAudioPlayerIdle;

   958     

   959     if ( aError == KErrNone ) 

   960         {

   961         // Don't put error code to aError since MthdTtsCompleted can

   962         // be called with error code before this function is called

   963         RUBY_DEBUG0( "CTTSAlgorithmManager::MdtaoPlayFinished ok" );

   964         }

   965     else

   966         {

   967         // Audio is interrupted by something with higher priority.

   968         // Keep idle state for audio player since application might

   969         // try again with better luck. (When there is no other apps trying

   970         // to access audio out.)

   971         iError = aError;

   972         

   973         // Stop TTS Hw device too

   974         iHw->Stop();

   975         

   976         RUBY_DEBUG0( "CTTSAlgorithmManager::MdtaoPlayFinished audio interrupted" );

   977         }

   978  

   979     // Move automatically to stopped state

   980     iState = EDevTTSStopped;

   981     

   982     // Call the client

   983     iObserver.MdtoEvent( EDevTTSEventComplete, iError );

   984     }

   985 

   986 

   987 

   988 // ========================== CALLBACKS FROM TtsHwDevice =======================

   989 

   990 

   991 // -----------------------------------------------------------------------------

   992 // CTTSAlgorithmManager::MthdTtsCompleted

   993 // Called by TtsHwDevice when synthesis has completed

   994 // -----------------------------------------------------------------------------

   995 //

   996 void CTTSAlgorithmManager::MthdTtsCompleted( TInt aStatus )

   997     {

   998     iState = EDevTTSStopped;

   999     

  1000     // Mark that previous received buffer is the last one

  1001     iLastBufferFromTts = ETrue;

  1002     

  1003     iError = aStatus;

  1004     

  1005     // Do the callback to client, handled by MdtaoPlayFinished if in sound device mode

  1006     if ( iMode == EDevTTSClientMode )

  1007         {

  1008         iObserver.MdtoEvent( EDevTTSEventComplete, aStatus );

  1009         }

  1010 

  1011 #ifdef DEVTTS_AUDIOBUFFER_TO_FILE

  1012     iFile.Close();

  1013     iFileOpen = EFalse;

  1014 #endif

  1015     }

  1016 

  1017 // -----------------------------------------------------------------------------

  1018 // CTTSAlgorithmManager::MthdCustomEvent

  1019 // Custom event from TtsHwDevice

  1020 // -----------------------------------------------------------------------------

  1021 //

  1022 void CTTSAlgorithmManager::MthdCustomEvent( TInt /*aEvent*/, TInt /*aStatus*/, 

  1023                                            const TDesC8& /*aParameter*/ )

  1024     {

  1025     }

  1026 

  1027 // -----------------------------------------------------------------------------

  1028 // CTTSAlgorithmManager::MthdProcessBuffer

  1029 // Prepares buffer for playback or forwards callback to client, depends on the

  1030 // operation mode.

  1031 // -----------------------------------------------------------------------------

  1032 //

  1033 void CTTSAlgorithmManager::MthdProcessBuffer( const TDesC8& aBuffer )

  1034     {

  1035     RUBY_DEBUG0( "CTTSAlgorithmManager::MthdProcessBuffer" );

  1036     

  1037 #ifdef DEVTTS_AUDIOBUFFER_TO_FILE

  1038     if ( iFileOpen == EFalse )

  1039         {

  1040         TFileName filename;

  1041         filename.Append( KAudioBufferFileName );

  1042         filename.AppendNum( iFileCounter );

  1043         filename.Append( KAudioBufferFileNameExtension );

  1044 

  1045         iFile.Replace( iSession, filename, EFileWrite );

  1046         iFileOpen = ETrue;

  1047         iFileCounter++;

  1048         }

  1049     TInt size( 0 );

  1050     iFile.Size( size );

  1051     iFile.Seek( ESeekEnd, size );

  1052     iFile.Write( aBuffer );

  1053 #endif

  1054 

  1055     // Handle buffer internally if in sound device mode, otherwise just 

  1056     // forward the callback to client

  1057     if ( iMode == EDevTTSSoundDeviceMode )

  1058         {

  1059         // Store pointer to buffer

  1060         iPlaybackBuffer.Set( aBuffer );

  1061         // Mark start and stop points for the audio playback

  1062         iStartPoint = 0;

  1063         iStopPoint = aBuffer.Size() - 1;

  1064         }

  1065     else

  1066         {

  1067         iObserver.MdtoProcessBuffer( aBuffer );

  1068         }

  1069     }

  1070 

  1071 // -----------------------------------------------------------------------------

  1072 // CTTSAlgorithmManager::MthdoConfigurationData

  1073 // Forwards callback to client.

  1074 // -----------------------------------------------------------------------------

  1075 //

  1076 HBufC8* CTTSAlgorithmManager::MthdoConfigurationData( TUint32 aPackageType, 

  1077                                                       TUint32 aPackageID,

  1078                                                       TUint32 aStartPosition,

  1079                                                       TUint32 aEndPosition )

  1080     {

  1081     return iObserver.MdtoConfigurationData( aPackageType, aPackageID, 

  1082                                             aStartPosition, aEndPosition );

  1083     }

  1084 

  1085 

  1086 // ====================== CALLBACKS FROM MASRSTtpHwDeviceObserver ==============

  1087 

  1088 // -----------------------------------------------------------------------------

  1089 // CTTSAlgorithmManager::MathdoConfigurationData

  1090 // Forwards callback to client.

  1091 // -----------------------------------------------------------------------------

  1092 //

  1093 HBufC8* CTTSAlgorithmManager::MathdoConfigurationData( TUint32 aPackageType, 

  1094                                                        TUint32 aPackageID,

  1095                                                        TUint32 aStartPosition,

  1096                                                        TUint32 aEndPosition )

  1097     {

  1098     return iObserver.MdtoConfigurationData( aPackageType, aPackageID, 

  1099                                             aStartPosition, aEndPosition );

  1100     }

  1101 

  1102 // -----------------------------------------------------------------------------

  1103 // CTTSAlgorithmManager::MathdoWordListReady

  1104 // Should not be called since we always use synchrnous TTP.

  1105 // -----------------------------------------------------------------------------

  1106 //

  1107 void CTTSAlgorithmManager::MathdoWordListReady( const TInt /*aError*/ )

  1108     {

  1109     // Do nothing

  1110     }

  1111 

  1112 

  1113 

  1114 // ====================== CALLBACKS FROM MNlpHwDeviceObserver ==================

  1115 

  1116 

  1117 // -----------------------------------------------------------------------------

  1118 // MNlpHwDeviceObserver::MnhdNlpCompleted

  1119 // Called when asynchronous NLP processing has been completed

  1120 // -----------------------------------------------------------------------------

  1121 //

  1122 void CTTSAlgorithmManager::MnhdoNlpCompleted( TInt /*aStatus*/ )

  1123     {

  1124     // Should not be called currently since NLP is handled synchronously

  1125     }

  1126 

  1127 // -----------------------------------------------------------------------------

  1128 // CTTSAlgorithmManager::MnhdoConfigurationData

  1129 // NLP calls when it needs its configuration data to be loaded

  1130 // -----------------------------------------------------------------------------

  1131 //

  1132 HBufC8* CTTSAlgorithmManager::MnhdoConfigurationData( TUint32 aPackageType, 

  1133                                                       TUint32 aPackageID, 

  1134                                                       TUint32 aStartPosition, 

  1135                                                       TUint32 aEndPosition )