1 /*

     2 * Copyright (c) 2005 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:  XML-Parser used to parse motion patterns.

    15 *

    16 */

    17 

    18 

    19 // INCLUDE FILES

    20 #include "C3DAudioXMLParser.h"

    21 #include "tdaudioconstants.h"	// K3DAudioRepositoryUid

    22 #include <f32file.h>			// RFs

    23 #include <s32mem.h>				// RBufWriteStream

    24 #include <centralrepository.h>	// CRepository

    25 

    26 

    27 #include "RingingTone3DPluginDebug.h"

    28 #include <ProfileInternal.hrh> // for TProfile3DToneEffect and TProfile3DToneEcho

    29 

    30 #include <pathinfo.h>

    31 #include <driveinfo.h>

    32 #include <data_caging_path_literals.hrh>

    33 

    34 

    35 //CONSTANTS

    36 const TInt32 KRingingTone3DAudioEComPluginUID = 0x10208ADF;

    37 

    38 

    39 // 3DTone pattern dir

    40 _LIT( K3DTonesDir, "3DTones" );

    41 

    42 // 3DTone pattern files

    43 _LIT( KPatternCircle,     "1circular.xml" );

    44 _LIT( KPatternFlyBy,      "2flyby.xml" );

    45 _LIT( KPatternZigZag,     "3zigzag.xml" );

    46 _LIT( KPatternRandomWalk, "4meander.xml" );

    47 _LIT( KPatternChaos,      "5random.xml" );

    48 

    49 

    50 // Elements

    51 _LIT8( KInitElement, "initialization");

    52 _LIT8( KPositionElement, "position" );

    53 _LIT8( KUpdateElement, "update" );

    54 _LIT8( KVelocityElement, "velocity" );

    55 _LIT8( KLoopElement, "loop" );

    56 

    57 // Attribute names.

    58 _LIT8( KPatternName, "name" );

    59 _LIT8( KPatternReverb, "reverb" );

    60 _LIT8( KPatternDoppler, "doppler" );

    61 _LIT8( KXCoordinate, "x" );

    62 _LIT8( KYCoordinate, "y" );

    63 _LIT8( KZCoordinate, "z" );

    64 _LIT8( KDTime, "dTime" );

    65 _LIT8( KScalarVelocity, "scalar" );

    66 _LIT8( KLoopCount, "count" );

    67 

    68 // Attribute values

    69 _LIT8( KReverbPresetOne, "Livingroom" );

    70 _LIT8( KReverbPresetTwo, "Cave" );

    71 _LIT8( KReverbPresetThree, "Stone Corridor" );

    72 _LIT8( KReverbPresetFour, "Forest" );

    73 _LIT8( KReverbPresetFive, "Sewerpipe" );

    74 _LIT8( KReverbPresetSix, "Underwater" );

    75 _LIT8( KBooleanTrue, "true" );

    76 

    77 

    78 

    79 /******************************************************************************

    80  * class C3DAudioXMLParser

    81  ******************************************************************************/

    82 

    83 

    84 

    85 // -----------------------------------------------------------------------------

    86 // C3DAudioXMLParser::NewL

    87 // Two-phased constructor.

    88 // -----------------------------------------------------------------------------

    89 //		

    90 C3DAudioXMLParser* C3DAudioXMLParser::NewL()

    91 	{

    92 	C3DAudioXMLParser* self = C3DAudioXMLParser::NewLC();

    93     CleanupStack::Pop( self );

    94     return self;

    95 	}

    96 

    97 

    98 // -----------------------------------------------------------------------------

    99 // C3DAudioXMLParser::NewLC

   100 // Two-phased constructor. Leaves pointer on cleanup stack.

   101 // -----------------------------------------------------------------------------

   102 //		

   103 C3DAudioXMLParser* C3DAudioXMLParser::NewLC()

   104 	{

   105 	C3DAudioXMLParser * self = new ( ELeave ) C3DAudioXMLParser();

   106     CleanupStack::PushL( self );

   107     self->ConstructL();

   108     return self;	

   109 	}

   110 

   111 

   112 // Destructor

   113 C3DAudioXMLParser::~C3DAudioXMLParser()

   114 	{

   115 	delete iParser;

   116 	delete iParsedPattern;

   117    	iFsSession.Close();

   118 	}

   119 

   120 

   121 // -----------------------------------------------------------------------------

   122 // C3DAudioXMLParser::C3DAudioXMLParser

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

   124 // might leave.

   125 // -----------------------------------------------------------------------------

   126 //		

   127 C3DAudioXMLParser::C3DAudioXMLParser():

   128 	iParser( NULL ),

   129 	iParsedPattern( NULL )

   130 	{

   131 	}

   132 

   133 

   134 // -----------------------------------------------------------------------------

   135 // C3DAudioXMLParser::ConstructL

   136 // Symbian 2nd phase constructor can leave.

   137 // -----------------------------------------------------------------------------

   138 //

   139 void C3DAudioXMLParser::ConstructL()

   140     {

   141     _LIT8( KParserMimeType, "text/xml" );

   142     

   143 	iPatternId = KErrNotFound;

   144 	

   145 	iParser = Xml::CParser::NewL( KParserMimeType, *this );

   146 	

   147 	User::LeaveIfError( iFsSession.Connect() );

   148     }	

   149     

   150 

   151 // -----------------------------------------------------------------------------

   152 // C3DAudioXMLParser::Count

   153 //

   154 // -----------------------------------------------------------------------------

   155 //		

   156 TInt C3DAudioXMLParser::CountL()

   157     {

   158     User::LeaveIfNull( iParsedPattern );

   159     const RArray<T3DScriptUpdate>& script = iParsedPattern->Script();

   160     

   161     return script.Count();

   162     }

   163 

   164 

   165 // -----------------------------------------------------------------------------

   166 // C3DAudioXMLParser::PositionL

   167 //

   168 // -----------------------------------------------------------------------------

   169 //		

   170 const T3DPosition& C3DAudioXMLParser::PositionL( TInt aIndex )

   171     {

   172     User::LeaveIfNull( iParsedPattern );

   173     const RArray<T3DScriptUpdate>& script = iParsedPattern->Script();

   174     

   175     if ( aIndex < 0 || aIndex >= script.Count() )

   176         {

   177         User::Leave( KErrArgument );

   178         }

   179         

   180     return script[ aIndex ].iPosition;

   181     }

   182 

   183 

   184 // -----------------------------------------------------------------------------

   185 // C3DAudioXMLParser::VelocityL

   186 //

   187 // -----------------------------------------------------------------------------

   188 //		

   189 const T3DVelocity& C3DAudioXMLParser::VelocityL( TInt aIndex )

   190     {

   191     User::LeaveIfNull( iParsedPattern );

   192     const RArray<T3DScriptUpdate>& script = iParsedPattern->Script();

   193     

   194     if ( aIndex < 0 || aIndex >= script.Count() )

   195         {

   196         User::Leave( KErrArgument );

   197         }

   198         

   199     return script[ aIndex ].iVelocity;

   200     }

   201 

   202 

   203 // -----------------------------------------------------------------------------

   204 // C3DAudioXMLParser::TimeL

   205 //

   206 // -----------------------------------------------------------------------------

   207 //		

   208 const TInt& C3DAudioXMLParser::TimeL( TInt aIndex )

   209     {

   210     User::LeaveIfNull( iParsedPattern );    

   211     const RArray<T3DScriptUpdate>& script = iParsedPattern->Script();

   212     

   213     if ( aIndex < 0 || aIndex >= script.Count() )

   214         {

   215         User::Leave( KErrArgument );

   216         }

   217         

   218     return script[ aIndex ].iDTime;

   219     }

   220 

   221 

   222 // -----------------------------------------------------------------------------

   223 // C3DAudioXMLParser::Attribute

   224 //

   225 // -----------------------------------------------------------------------------

   226 //		

   227 TInt C3DAudioXMLParser::Attribute( TInt aKey )

   228     {

   229     TInt num = KErrNotFound;

   230     

   231     switch ( aKey )

   232         {

   233         case EKeyPatternId:

   234             {

   235             num = iPatternId;

   236             break;

   237             }

   238         case EKeyDopplerUsed:

   239             {

   240             num = iParsedPattern->DopplerAvailable();

   241             break;

   242             }

   243         case EKeyVelocity:

   244             {

   245             num = KMotionPatternDefaultVelocity;

   246             break;

   247             }

   248         default:

   249             {

   250             break;    

   251             }

   252         }

   253         

   254     return num;

   255     }

   256 

   257 

   258 // -----------------------------------------------------------------------------

   259 // C3DAudioXMLParser::ParseL

   260 //

   261 // -----------------------------------------------------------------------------

   262 //		

   263 void C3DAudioXMLParser::ParseL( TInt aPatternId )

   264 	{

   265 	FLOG( _L("C3DAudioXMLParser::ParseL START") );

   266 

   267 	if ( ReadFromPatternCacheL( aPatternId ) )

   268 	    {

   269 

   270 #ifdef _DEBUG

   271         // parsed pattern data found in cache (publish and subcribe)

   272         FlogPatternL( aPatternId );

   273 #endif

   274 

   275 	    }

   276 	else

   277 	    {

   278     	GetPatternFullPathL( iFullPath, aPatternId );

   279 	    ParseL( iFullPath );

   280 

   281 	    WriteToPatternCacheL( aPatternId );

   282 	    

   283 	    FLOG( _L("pattern '%S' parsed and written to cache"), &iFullPath );

   284 	    }

   285 	    

   286 	iPatternId = aPatternId;

   287 	

   288 #ifdef _DEBUG                         

   289     AssertParseDataL( aPatternId );

   290 #endif

   291 

   292 	

   293 	FLOG( _L("C3DAudioXMLParser::ParseL END") );

   294 	}

   295 

   296 

   297 // -----------------------------------------------------------------------------

   298 // C3DAudioXMLParser::ParseL

   299 //

   300 // -----------------------------------------------------------------------------

   301 //		

   302 void C3DAudioXMLParser::ParseL( const TDesC& aFileName )

   303 	{

   304 	delete iParsedPattern;

   305     iParsedPattern = NULL;

   306 	iParsedPattern = C3DAudioPattern::NewL();

   307 	

   308 	//

   309 	// read xml-format pattern file into descriptor

   310 	//

   311 	CBufFlat* buf = ReadPatternFileL( aFileName );

   312 	CleanupStack::PushL( buf );

   313 	

   314 	//

   315 	// parse xml-format pattern into C3DAudioPattern

   316 	//

   317 	TPtr8 ptr = buf->Ptr( 0 );

   318     iParser->ParseL( ptr );

   319     iParser->ParseEndL();

   320     

   321     RArray<T3DScriptUpdate> script = iParsedPattern->Script();

   322 	if ( script.Count() == 0 )

   323 	    {

   324         User::Leave( KErrNotFound );

   325 	    }

   326 

   327    	CleanupStack::PopAndDestroy( buf );

   328 	}

   329 

   330 

   331 // -----------------------------------------------------------------------------

   332 // C3DAudioXMLParser::ReadFromPatternCacheL

   333 //

   334 // -----------------------------------------------------------------------------

   335 //		

   336 TBool C3DAudioXMLParser::ReadFromPatternCacheL( TInt aPatternId )

   337 	{

   338    	C3DPatternPS* pubSub = C3DPatternPS::NewLC( KRingingTone3DAudioEComPluginUID );

   339     

   340     TInt patternId = pubSub->IntL( C3DPatternPS::EKeyPatternId );

   341     if ( patternId == aPatternId )

   342         {

   343         // buffer for 3D pattern data

   344         CBufFlat* buf = pubSub->DataLC();

   345                 

   346         // readstream to construct the pattern.

   347         RBufReadStream readstream( *buf );

   348         CleanupClosePushL( readstream );

   349                 

   350         // create C3DAudioPattern for accessing 3D ringing tone data 

   351         delete iParsedPattern;

   352         iParsedPattern = NULL;

   353         iParsedPattern = C3DAudioPattern::NewL( readstream );

   354     

   355 	    CleanupStack::PopAndDestroy( &readstream );

   356 	    CleanupStack::PopAndDestroy( buf );

   357         }

   358        

   359 	CleanupStack::PopAndDestroy( pubSub );

   360 	

   361 	if ( patternId == aPatternId )

   362 	    {

   363 	    return ETrue;

   364 	    }

   365 	return EFalse;

   366 	}

   367 

   368 

   369 // -----------------------------------------------------------------------------

   370 // C3DAudioXMLParser::WriteToPatternCacheL

   371 //

   372 // -----------------------------------------------------------------------------

   373 //		

   374 void C3DAudioXMLParser::WriteToPatternCacheL( TInt aPatternId )

   375 	{

   376     const TInt KGranularity = 1024;

   377 	

   378    	C3DPatternPS* pubSub = C3DPatternPS::NewLC( KRingingTone3DAudioEComPluginUID );

   379 

   380     //

   381     // write binary-format (parsed) pattern data into descriptor

   382     //

   383     CBufFlat* buf = CBufFlat::NewL( KGranularity );

   384     CleanupStack::PushL( buf );

   385     

   386     RBufWriteStream writestream( *buf );

   387     CleanupClosePushL( writestream );

   388     iParsedPattern->ExternalizeL( writestream );

   389    	writestream.CommitL();

   390 	CleanupStack::PopAndDestroy( &writestream );

   391 

   392 #ifdef _DEBUG

   393     TInt oldPatternId = pubSub->IntL( C3DPatternPS::EKeyPatternId );

   394     FlogPatternsL( oldPatternId, aPatternId );

   395 #endif    

   396     

   397     //

   398     // write pattern data and attributes into public and subscribe

   399     //

   400     pubSub->SetIntL( C3DPatternPS::EKeyPatternId, KErrNotFound );

   401 	pubSub->SetIntL( C3DPatternPS::EKeyDopplerUsed, iParsedPattern->DopplerAvailable() );

   402 	pubSub->SetIntL( C3DPatternPS::EKeyVelocity, KMotionPatternDefaultVelocity );

   403 	pubSub->SetDataL( buf->Ptr( 0 ) );

   404 	pubSub->SetIntL( C3DPatternPS::EKeyPatternId, aPatternId );

   405 	

   406 	CleanupStack::PopAndDestroy( buf );

   407 	

   408 	CleanupStack::PopAndDestroy( pubSub );

   409 	}

   410 

   411 

   412 

   413 // -----------------------------------------------------------------------------

   414 // C3DAudioXMLParser::OnStartDocumentL

   415 // Leave if error, otherwise nothing to do.

   416 // -----------------------------------------------------------------------------

   417 //	

   418 void C3DAudioXMLParser::OnStartDocumentL( 

   419 	const Xml::RDocumentParameters& /*aDocParam*/, 

   420 	TInt aErrorCode )

   421 	{

   422 	// Leave if error occurred.

   423 	User::LeaveIfError( aErrorCode );

   424 	}

   425 

   426 

   427 // -----------------------------------------------------------------------------

   428 // C3DAudioXMLParser::OnEndDocumentL

   429 // Leave if error, otherwise nothing to do.

   430 // -----------------------------------------------------------------------------

   431 //		

   432 void C3DAudioXMLParser::OnEndDocumentL( 

   433 	TInt aErrorCode )

   434 	{

   435 	// Leave if error occurred.

   436 	User::LeaveIfError( aErrorCode );

   437 	}

   438 

   439 

   440 // -----------------------------------------------------------------------------

   441 // C3DAudioXMLParser::OnStartElementL

   442 // Proceed depending on the element.

   443 // -----------------------------------------------------------------------------

   444 //		

   445 void C3DAudioXMLParser::OnStartElementL( 

   446 	const Xml::RTagInfo& aElement, 

   447 	const Xml::RAttributeArray& aAttributes, 

   448 	TInt aErrorCode )

   449 	{

   450 	// Leave if error occurred.

   451 	User::LeaveIfError( aErrorCode );

   452 	

   453 	CopyL( iElementName, aElement.LocalName().DesC() );

   454 	

   455 	// Proceed depending of the element.

   456 	if ( iElementName.CompareC( KUpdateElement ) == 0 )

   457 		{

   458 		ProcessUpdateAttributesL( aAttributes );

   459 		iLastTag = EUpdate;

   460 		}

   461 	else if ( iElementName.CompareC( KPositionElement ) == 0 )

   462 		{

   463 		// Do not take position in initialization in account.

   464 		if ( iLastTag == EUpdate )

   465 			{

   466 			ProcessPositionAttributesL( aAttributes );

   467 			}

   468 		}

   469 	else if ( iElementName.CompareC( KVelocityElement ) == 0 )

   470 		{

   471 		// Do not take velocity in initialization in account.

   472 		if ( iLastTag == EUpdate )

   473 			{

   474 			ProcessVelocityAttributesL( aAttributes );	

   475 			}

   476 		}

   477 	else if ( iElementName.CompareC( KInitElement ) == 0 )

   478 		{

   479 		// pasi

   480 		// Create new motion pattern and process the attributes of it.

   481 		delete iParsedPattern;

   482     	iParsedPattern = NULL;

   483 		iParsedPattern = C3DAudioPattern::NewL();

   484 		

   485 		ProcessInitAttributesL( aAttributes );

   486 		iLastTag = EInitialization;

   487 		}

   488 	else if ( iElementName.CompareC( KLoopElement ) == 0 )

   489 		{

   490 		ProcessLoopAttributesL( aAttributes );

   491 		}

   492 	}

   493 

   494 

   495 // -----------------------------------------------------------------------------

   496 // C3DAudioXMLParser::OnEndElementL

   497 // Proceed for elements that need processing.

   498 // -----------------------------------------------------------------------------

   499 //		

   500 void C3DAudioXMLParser::OnEndElementL( const Xml::RTagInfo& aElement, TInt aErrorCode )

   501 	{

   502 	// Leave if error occurred.

   503 	User::LeaveIfError( aErrorCode );

   504 	

   505 	CopyL( iElementName, aElement.LocalName().DesC() );

   506 	

   507 	if ( iElementName.CompareC( KUpdateElement ) == 0 )

   508 		{

   509 		// Update-element ended, add the update to script.

   510 		iParsedPattern->AddUpdateL( iCurrentUpdate );

   511 		}

   512 	else if ( iElementName.CompareC( KLoopElement ) == 0 )

   513 		{

   514 		// Loop-element ended, end the loop.

   515 		iParsedPattern->EndLoop();

   516 		}

   517 	}

   518 

   519 

   520 // -----------------------------------------------------------------------------

   521 // C3DAudioXMLParser::OnContentL

   522 // Leave if error, otherwise nothing to do.

   523 // -----------------------------------------------------------------------------

   524 //		

   525 void C3DAudioXMLParser::OnContentL( const TDesC8& /*aBytes*/, TInt aErrorCode )

   526 	{

   527 	// Leave if error occurred.

   528 	User::LeaveIfError( aErrorCode );

   529 	}

   530 

   531 

   532 // -----------------------------------------------------------------------------

   533 // C3DAudioXMLParser::OnStartPrefixMappingL

   534 // Leave if error, otherwise nothing to do.

   535 // -----------------------------------------------------------------------------

   536 //	

   537 void C3DAudioXMLParser::OnStartPrefixMappingL( const RString& /*aPrefix*/, 

   538 	                                           const RString& /*aUri*/, 

   539 	                                           TInt aErrorCode )

   540 	{

   541 	// Leave if error occurred.

   542 	User::LeaveIfError( aErrorCode );

   543 	}

   544 

   545 

   546 // -----------------------------------------------------------------------------

   547 // C3DAudioXMLParser::OnEndPrefixMappingL

   548 // Leave if error, otherwise nothing to do.

   549 // -----------------------------------------------------------------------------

   550 //		

   551 void C3DAudioXMLParser::OnEndPrefixMappingL( const RString& /*aPrefix*/, 

   552 	                                         TInt aErrorCode )

   553 	{

   554 	// Leave if error occurred.

   555 	User::LeaveIfError( aErrorCode );

   556 	}

   557 

   558 

   559 // -----------------------------------------------------------------------------

   560 // C3DAudioXMLParser::OnIgnorableWhiteSpaceL

   561 // Leave if error, otherwise nothing to do.

   562 // -----------------------------------------------------------------------------

   563 //		

   564 void C3DAudioXMLParser::OnIgnorableWhiteSpaceL(	const TDesC8& /*aBytes*/, 

   565 	                                            TInt aErrorCode )

   566 	{

   567 	// Leave if error occurred.

   568 	User::LeaveIfError( aErrorCode );

   569 	}

   570 

   571 

   572 // -----------------------------------------------------------------------------

   573 // C3DAudioXMLParser::OnSkippedEntityL

   574 // Leave if error, otherwise nothing to do.

   575 // -----------------------------------------------------------------------------

   576 //		

   577 void C3DAudioXMLParser::OnSkippedEntityL( const RString& /*aName*/, 

   578 	                                      TInt aErrorCode )

   579 	{

   580 	// Leave if error occurred.

   581 	User::LeaveIfError( aErrorCode );

   582 	}

   583 

   584 

   585 // -----------------------------------------------------------------------------

   586 // C3DAudioXMLParser::OnProcessingInstructionL

   587 // Leave if error, otherwise nothing to do.

   588 // -----------------------------------------------------------------------------

   589 //		

   590 void C3DAudioXMLParser::OnProcessingInstructionL( const TDesC8& /*aTarget*/, 

   591 	                                              const TDesC8& /*aData*/, 

   592 	                                              TInt aErrorCode )

   593 	{

   594 	// Leave if error occurred.

   595 	User::LeaveIfError( aErrorCode );

   596 	}

   597 

   598 

   599 // -----------------------------------------------------------------------------

   600 // C3DAudioXMLParser::OnError

   601 // Print error code to debug.

   602 // -----------------------------------------------------------------------------

   603 //		

   604 void C3DAudioXMLParser::OnError( TInt aErrorCode )

   605 	{

   606 	if ( aErrorCode != KErrNone )

   607 	    {

   608 	    FLOG( _L("### C3DAudioXMLParser::OnError (%d) ###"), aErrorCode );    

   609 	    }

   610 	}

   611 

   612 

   613 // -----------------------------------------------------------------------------

   614 // C3DAudioXMLParser::GetExtendedInterface

   615 // Not implemented

   616 // -----------------------------------------------------------------------------

   617 //

   618 TAny* C3DAudioXMLParser::GetExtendedInterface( const TInt32 /*aUid*/ )

   619 	{

   620 	return NULL;

   621 	}

   622 

   623 

   624 // -----------------------------------------------------------------------------

   625 // C3DAudioXMLParser::ProcessInitAttributesL

   626 // Process the initialization attributes.

   627 // -----------------------------------------------------------------------------

   628 //

   629 void C3DAudioXMLParser::ProcessInitAttributesL( const Xml::RAttributeArray& aAttributes )

   630 	{

   631 	// Check each attribute.	

   632 	for ( TUint i = 0; i < aAttributes.Count(); ++i )

   633 		{

   634 		CopyL( iAttributeName, aAttributes[i].Attribute().LocalName().DesC() );

   635 		CopyL( iAttributeValue, aAttributes[i].Value().DesC() );

   636 		

   637 		// Set the name of the pattern.

   638 		if ( iAttributeName.CompareC( KPatternName ) == 0 )

   639 			{

   640 			iParsedPattern->SetNameL( iAttributeValue );

   641 			}

   642 		else if ( iAttributeName.CompareC( KPatternReverb ) == 0 )

   643 			{

   644 			TUint selectedReverb = EReverbNotEnabled;

   645 

   646 			// Determine the reverberation.			

   647 			if ( iAttributeValue.CompareC( KReverbPresetOne ) == 0 )

   648 				{

   649 				selectedReverb = EReverbPresetOne;	

   650 				}

   651 			else if ( iAttributeValue.CompareC( KReverbPresetTwo ) == 0 )

   652 				{

   653 				selectedReverb = EReverbPresetTwo;

   654 				}

   655 			else if ( iAttributeValue.CompareC( KReverbPresetThree ) == 0 )

   656 				{

   657 				selectedReverb = EReverbPresetThree;

   658 				}

   659 			else if ( iAttributeValue.CompareC( KReverbPresetFour ) == 0 )

   660 				{

   661 				selectedReverb = EReverbPresetFour;

   662 				}

   663 			else if ( iAttributeValue.CompareC( KReverbPresetFive ) == 0 )

   664 				{

   665 				selectedReverb = EReverbPresetFive;

   666 				}

   667 			else if ( iAttributeValue.CompareC( KReverbPresetSix ) == 0 )

   668 				{

   669 				selectedReverb = EReverbPresetSix;

   670 				}

   671 				

   672 			// Set the reverberation to pattern.				

   673 			iParsedPattern->SetReverb( selectedReverb );

   674 			}

   675 		else if ( iAttributeName.CompareC( KPatternDoppler ) == 0)

   676 			{

   677 			// Set doppler.			

   678 			if ( iAttributeValue.CompareC( KBooleanTrue ) == 0 )

   679 				{

   680 				iParsedPattern->SetDoppler( ETrue );

   681 				}

   682 			}

   683 		}

   684 	}

   685 

   686 

   687 // -----------------------------------------------------------------------------

   688 // C3DAudioXMLParser::ProcessLoopAttributes

   689 // Process the loop-element attributes.

   690 // -----------------------------------------------------------------------------

   691 //

   692 void C3DAudioXMLParser::ProcessLoopAttributesL( const Xml::RAttributeArray& aAttributes )

   693 	{

   694 	TLex8 lex;

   695 			

   696 	for ( TUint i = 0; i < aAttributes.Count(); ++i )

   697 		{

   698 		CopyL( iAttributeName, aAttributes[i].Attribute().LocalName().DesC() );

   699 		CopyL( iAttributeValue, aAttributes[i].Value().DesC() );

   700 

   701 		lex.Assign( iAttributeValue );

   702 		

   703 		if ( iAttributeName.CompareC( KLoopCount ) == 0 )

   704 			{

   705 			TUint loopCount;

   706 			User::LeaveIfError ( lex.Val( loopCount ) );

   707 			

   708 			// Start the loop in pattern.

   709 			iParsedPattern->StartLoopL( loopCount );

   710 			}

   711 		}

   712 	}

   713 

   714 

   715 // -----------------------------------------------------------------------------

   716 // C3DAudioXMLParser::ProcessPositionAttributes

   717 // Process the position-element attributes.

   718 // -----------------------------------------------------------------------------

   719 //

   720 void C3DAudioXMLParser::ProcessPositionAttributesL( const Xml::RAttributeArray& aAttributes )

   721 	{

   722 	TLex8 lex;

   723 	T3DPosition position = T3DPosition();

   724 		

   725     TInt count = aAttributes.Count();

   726 	for ( TUint i = 0; i < count; ++i )

   727 		{

   728 		CopyL( iAttributeName, aAttributes[i].Attribute().LocalName().DesC() );

   729 		CopyL( iAttributeValue, aAttributes[i].Value().DesC() );

   730 

   731 		lex.Assign( iAttributeValue );

   732 		

   733 		if ( iAttributeName.CompareC( KXCoordinate ) == 0 )

   734 			{

   735 			User::LeaveIfError( lex.Val( position.iX ) );

   736 			}

   737 		else if ( iAttributeName.CompareC( KYCoordinate ) == 0 )

   738 			{

   739 			User::LeaveIfError( lex.Val( position.iY ) );

   740 			}

   741 		else if ( iAttributeName.CompareC( KZCoordinate ) == 0)

   742 			{

   743 			User::LeaveIfError( lex.Val( position.iZ ) );

   744 			}

   745 		}

   746 		

   747 	// Set position for current update.

   748 	iCurrentUpdate.iPosition = position;	

   749 	}

   750 

   751 

   752 // -----------------------------------------------------------------------------

   753 // C3DAudioXMLParser::ProcessUpdateAttributes

   754 // Process the update-element attributes.

   755 // -----------------------------------------------------------------------------

   756 //

   757 void C3DAudioXMLParser::ProcessUpdateAttributesL( const Xml::RAttributeArray& aAttributes )

   758 	{

   759 	TLex8 lex;

   760 	// New update-element.

   761 	iCurrentUpdate = T3DScriptUpdate();

   762 		

   763 	for ( TUint i = 0; i < aAttributes.Count(); ++i )

   764 		{

   765 		CopyL( iAttributeName, aAttributes[i].Attribute().LocalName().DesC() );

   766 		CopyL( iAttributeValue, aAttributes[i].Value().DesC() );

   767 

   768 		lex.Assign( iAttributeValue );

   769 		

   770 		if ( iAttributeName.CompareC( KDTime ) == 0 )

   771 			{

   772 			// Set the dTime for the update.			

   773 			User::LeaveIfError( lex.Val( iCurrentUpdate.iDTime ) );

   774 			}

   775 		}

   776 	}

   777 

   778 

   779 // -----------------------------------------------------------------------------

   780 // C3DAudioXMLParser::ProcessVelocityAttributes

   781 // Process the velocity-element attributes.

   782 // -----------------------------------------------------------------------------

   783 //

   784 void C3DAudioXMLParser::ProcessVelocityAttributesL( const Xml::RAttributeArray& aAttributes )

   785 	{

   786 	TLex8 lex;

   787 	T3DVelocity velocity = T3DVelocity();

   788 		

   789 	for ( TUint i = 0; i < aAttributes.Count(); ++i )

   790 		{

   791 		CopyL( iAttributeName, aAttributes[i].Attribute().LocalName().DesC() );

   792 		CopyL( iAttributeValue, aAttributes[i].Value().DesC() );

   793 

   794 		lex.Assign( iAttributeValue );

   795 		

   796 		if ( iAttributeName.CompareC( KScalarVelocity ) == 0 )

   797 			{

   798 			velocity.iScalar = ETrue;

   799 			User::LeaveIfError( lex.Val( velocity.iScalarVelocity ) );

   800 			velocity.iXVector = 0;

   801 			velocity.iYVector = 0;

   802 			velocity.iZVector = 0;

   803 			break;

   804 			}

   805 		else if ( iAttributeName.CompareC( KXCoordinate ) == 0 )

   806 			{

   807 			User::LeaveIfError( lex.Val( velocity.iXVector ) );

   808 			}

   809 		else if ( iAttributeName.CompareC( KYCoordinate ) == 0 )

   810 			{

   811 			User::LeaveIfError( lex.Val( velocity.iYVector ) );

   812 			}

   813 		else if ( iAttributeName.CompareC( KZCoordinate ) == 0)

   814 			{

   815 			User::LeaveIfError( lex.Val( velocity.iZVector ) );

   816 			}

   817 		}

   818 	// Set velocity for current update.	

   819 	iCurrentUpdate.iVelocity = velocity;

   820 	}

   821 

   822 

   823 // -----------------------------------------------------------------------------

   824 // C3DAudioXMLParser::CopyL

   825 // 

   826 // -----------------------------------------------------------------------------

   827 //

   828 void C3DAudioXMLParser::CopyL( TDes8& aTarget, const TDesC8& aSource )

   829 	{

   830 	if ( aSource.Length() > aTarget.MaxLength() )

   831 	    {

   832 

   833 #ifdef _DEBUG			                

   834         Panic( KErrArgument );

   835 #endif        

   836 

   837 	    User::Leave( KErrTooBig );

   838 	    }

   839 	    

   840 	aTarget.Copy( aSource );

   841 	}

   842 

   843 

   844 // -----------------------------------------------------------------------------

   845 // C3DAudioXMLParser::Panic()

   846 //

   847 // -----------------------------------------------------------------------------

   848 //    

   849 void C3DAudioXMLParser::Panic(TInt aReason)

   850     {

   851 	_LIT(KPanicCategory,"RingingTone3DAudioPlugin");

   852 	

   853 	User::Panic(KPanicCategory, aReason); 

   854     }

   855     

   856 

   857 // -------------------------------------------------------------------------------

   858 // C3DAudioXMLParser::ReadPatternFileL

   859 //

   860 // -------------------------------------------------------------------------------

   861 //

   862 CBufFlat* C3DAudioXMLParser::ReadPatternFileL( const TDesC& aFullName )

   863     {

   864     const TInt KGranularity = 1024;

   865     

   866     RFile file;

   867 	User::LeaveIfError( file.Open( iFsSession, aFullName, EFileRead ) );

   868 	CleanupClosePushL( file );

   869 

   870   	CBufFlat* buf = CBufFlat::NewL( KGranularity );

   871 	CleanupStack::PushL( buf );

   872 	

   873 	TInt size = 0;

   874 	file.Size( size );

   875 	buf->ResizeL( size );

   876 	

   877 	TPtr8 ptr = buf->Ptr( 0 );

   878 	User::LeaveIfError( file.Read( ptr ) );

   879 

   880 	CleanupStack::Pop( buf );

   881 	CleanupStack::PopAndDestroy( &file );

   882 	

   883 	return buf;

   884     }

   885     

   886     

   887 // -------------------------------------------------------------------------------

   888 // C3DAudioXMLParser::GetPatternFullPathL

   889 //

   890 // -------------------------------------------------------------------------------

   891 //

   892 void C3DAudioXMLParser::GetPatternFullPathL(TDes& aText, TInt aPatternId)

   893     {

   894     _LIT( KFormatString, "%S%S%S\\%S");

   895 

   896     TBuf<KBufSize32> pattern;

   897 

   898     // emulator dir  "\epoc32\release\winscw\udeb\Z\resource\3DTones"

   899     // hardware dir  "z:\data\Z\resource\3DTones"

   900 

   901     switch (aPatternId)

   902         {

   903         case EProfile3DEffectCircle:

   904             {

   905             pattern = KPatternCircle;

   906             break;

   907             }

   908         case EProfile3DEffectFlyby:

   909             {

   910             pattern = KPatternFlyBy;

   911             break;

   912             }

   913         case EProfile3DEffectZigZag:

   914             {

   915             pattern = KPatternZigZag;

   916             break;

   917             }

   918         case EProfile3DEffectRandomWalk:

   919             {

   920             pattern = KPatternRandomWalk;

   921             break;

   922             }

   923         case EProfile3DEffectChaos:

   924             {

   925             pattern = KPatternChaos;

   926             break;

   927             }

   928         default:

   929             {

   930             User::Leave( KErrNotSupported );

   931             break;

   932             }

   933         }

   934         

   935   	TDriveUnit drive( EDriveZ );

   936 	TDriveName driveName = drive.Name();

   937 	

   938 	aText.Format(KFormatString, &driveName, &KDC_RESOURCE_FILES_DIR, &K3DTonesDir, &pattern);

   939     }

   940     

   941 

   942 

   943 

   944 

   945 

   946 #ifdef _DEBUG

   947 

   948 // -----------------------------------------------------------------------------

   949 // C3DAudioXMLParser::AssertParseDataL

   950 //

   951 // -----------------------------------------------------------------------------

   952 //

   953 void C3DAudioXMLParser::AssertParseDataL( TInt aPatternId )

   954 	{

   955 	const TInt KGranularity = 1024;

   956 	

   957    	C3DPatternPS* ps = C3DPatternPS::NewLC( KRingingTone3DAudioEComPluginUID );

   958 	   	

   959     CBufFlat* buf = CBufFlat::NewL( KGranularity );

   960     CleanupStack::PushL( buf );

   961     

   962     RBufWriteStream writestream( *buf );

   963     CleanupClosePushL( writestream );

   964     iParsedPattern->ExternalizeL( writestream );

   965    	writestream.CommitL();

   966 	CleanupStack::PopAndDestroy( &writestream );

   967 	

   968 	CBufFlat* buf2 = ps->DataLC();

   969 

   970 

   971     TInt id = ps->IntL(C3DPatternPS::EKeyPatternId);

   972     if ( id != aPatternId )

   973         {

   974         Panic( KErrGeneral );

   975         }

   976     

   977     TPtr8 p1 = buf->Ptr( 0 );

   978     TPtr8 p2 = buf2->Ptr( 0 );

   979     

   980     TInt ret = p1.Compare( p2 );

   981     if ( ret != 0 )

   982         {

   983         Panic( KErrGeneral );

   984         }

   985     TInt doppler = ps->IntL( C3DPatternPS::EKeyDopplerUsed );

   986     if ( doppler != iParsedPattern->DopplerAvailable() )

   987         {

   988         Panic( KErrGeneral );

   989         }

   990     TInt velocity = ps->IntL( C3DPatternPS::EKeyVelocity );

   991     if (velocity != KMotionPatternDefaultVelocity)

   992         {

   993         Panic( KErrGeneral );

   994         }

   995     

   996     CleanupStack::PopAndDestroy( buf2 );

   997     CleanupStack::PopAndDestroy( buf );

   998     CleanupStack::PopAndDestroy( ps );

   999 	}

  1000 

  1001 

  1002 // -----------------------------------------------------------------------------

  1003 // C3DAudioXMLParser::FlogPatternsL()

  1004 //

  1005 // -----------------------------------------------------------------------------

  1006 //    

  1007 void C3DAudioXMLParser::FlogPatternsL(TInt aOldPattern, TInt aNewPattern)

  1008     {

  1009     TBuf<128> buf; TBuf<128> buf2;

  1010     

  1011     GetPatternString(buf, aOldPattern);

  1012     GetPatternString(buf2, aNewPattern);

  1013     FLOG( _L("pattern changed from '%S' to '%S'"), &buf, &buf2 );

  1014     }

  1015 

  1016 

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

  1018 // C3DAudioXMLParser::FlogPatternL()

  1019 //

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

  1021 //    

  1022 void C3DAudioXMLParser::FlogPatternL(TInt aPattern)

  1023     {

  1024     TBuf<128> buf;

  1025     

  1026     GetPatternString(buf, aPattern);

  1027     FLOG( _L("pattern '%S' found in cache"), &buf );

  1028     }

  1029 

  1030 

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

  1032 // C3DAudioXMLParser::GetPatternString()

  1033 //

  1034 // -----------------------------------------------------------------------------

  1035 //    

  1036 void C3DAudioXMLParser::GetPatternString(TDes& aText, TInt aPattern)

  1037     {

  1038 	switch (aPattern)

  1039 		{

  1040 		case EProfile3DEffectOff:

  1041 			aText = _L("EProfile3DEffectOff");

  1042 			break;

  1043 		case EProfile3DEffectCircle:

  1044 			aText = _L("EProfile3DEffectCircle");

  1045 			break;

  1046 		case EProfile3DEffectFlyby:

  1047 			aText = _L("EProfile3DEffectFlyby");

  1048 			break;

  1049 		case EProfile3DEffectZigZag:

  1050 			aText = _L("EProfile3DEffectZigZag");

  1051 			break;

  1052 		case EProfile3DEffectRandomWalk:

  1053 			aText = _L("EProfile3DEffectRandomWalk");

  1054 			break;

  1055 		case EProfile3DEffectChaos:

  1056 			aText = _L("EProfile3DEffectChaos");

  1057 			break;

  1058 		case EProfile3DEffectStereoWidening:

  1059 			aText = _L("EProfile3DEffectStereoWidening");

  1060 			break;

  1061 		case KErrNotFound:

  1062 			aText = _L("KErrNotFound");

  1063 			break;

  1064 

  1065 		default:

  1066 			aText = _L("### unknown pattern ###");

  1067 			break;

  1068 		}

  1069     }

  1070 

  1071 

  1072 // -----------------------------------------------------------------------------

  1073 // C3DAudioXMLParser::FlogPubSubL()

  1074 //

  1075 // -----------------------------------------------------------------------------

  1076 //    

  1077 void C3DAudioXMLParser::FlogPubSubL(TInt aEcho)

  1078     {

  1079     FLOG( _L("------ start pubsub data ------") );

  1080     

  1081     TInt num = 0;

  1082     TBuf<128> buf;

  1083     

  1084     C3DPatternPS* pubSub = C3DPatternPS::NewLC( KRingingTone3DAudioEComPluginUID );

  1085 	

  1086 	num = pubSub->IntL(C3DPatternPS::EKeyPatternId);

  1087     C3DAudioXMLParser::GetPatternString(buf, num);

  1088     FLOG( _L("pattern: %S (%d)"), &buf, num );

  1089     

  1090     GetEchoString(buf, aEcho);

  1091     FLOG( _L("echo: %S (%d)"), &buf, aEcho );

  1092  

  1093     num = pubSub->IntL(C3DPatternPS::EKeyVelocity);

  1094     FLOG( _L("velocity: %d"), num );

  1095     

  1096     num = pubSub->IntL(C3DPatternPS::EKeyDopplerUsed);

  1097     FLOG( _L("doppler: %d"), num );

  1098     

  1099     num = pubSub->IntL(C3DPatternPS::EKeyDataSize);

  1100     FLOG( _L("data size: %d"), num );

  1101     

  1102     CleanupStack::PopAndDestroy( pubSub );

  1103     

  1104     FLOG( _L("------ end pubsub data ------") );

  1105     }

  1106 

  1107 

  1108 // -----------------------------------------------------------------------------

  1109 // C3DAudioXMLParser::GetEchoString()

  1110 //

  1111 // -----------------------------------------------------------------------------

  1112 //    

  1113 void C3DAudioXMLParser::GetEchoString(TDes& aText, TInt aEcho)

  1114     {

  1115 	switch (aEcho)

  1116 		{

  1117 		case EProfile3DEchoOff:

  1118 			aText = _L("EProfile3DEchoOff");

  1119 			break;

  1120 		case EProfile3DEchoLivingRoom:

  1121 			aText = _L("EProfile3DEchoLivingRoom");

  1122 			break;

  1123 		case EProfile3DEchoCave:

  1124 			aText = _L("EProfile3DEchoCave");

  1125 			break;

  1126 		case EProfile3DEchoStoneCorridor:

  1127 			aText = _L("EProfile3DEchoStoneCorridor");

  1128 			break;

  1129 		case EProfile3DEchoForest:

  1130 			aText = _L("EProfile3DEchoForest");

  1131 			break;

  1132 		case EProfile3DEchoSewerPipe:

  1133 			aText = _L("EProfile3DEchoSewerPipe");

  1134 			break;

  1135 		case EProfile3DEchoUnderwater: