Symaptic: os/mm/devsoundextensions/effectspresets/StereoWideningUtility/src/StereoWideningUtility.cpp@260cb5ec6c19

     1 /*

     2 * Copyright (c) 2006 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:   Utility to Access the StereoWidening Effect

    15 *

    16 */

    20 // INCLUDE FILES

    21 #include <e32std.h>

    22 #include <StereoWideningUtility.h>

    23 #include <DrmAudioSamplePlayer.h>

    24 //#include <midiclientutility.h>

    25 #include "TempStereoWidening.h"

    26 #include "StereoWideningInternalCRKeys.h"

    27 #include <videoplayer.h>

    29 // ============================ MEMBER FUNCTIONS ===============================

    31 // -----------------------------------------------------------------------------

    32 // CStereoWideningUtility::CStereoWideningUtility

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

    34 // might leave.

    35 // -----------------------------------------------------------------------------

    36 //

    37 CStereoWideningUtility::CStereoWideningUtility()

    38 	: iStereoWidening(NULL),

    39 	  iPresetRepository(NULL)

    40 	{

    41     }

    44 // Destructor

    45 CStereoWideningUtility::~CStereoWideningUtility()

    46     {

    47 		iPresetArray.Close();

    48 		iFullPresetArray.Close();

    49 		delete iPresetRepository;

    50 		delete iTransStereoWidening;

    51 		delete iStereoWidening;

    52     }

    55 // -----------------------------------------------------------------------------

    56 // CStereoWideningUtility::ConstructL

    57 // Symbian 2nd phase constructor can leave.

    58 // -----------------------------------------------------------------------------

    59 //

    60 void CStereoWideningUtility::ConstructL(CMMFDevSound& aDevSound)

    61     {

    62 #ifdef _DEBUG

    63 		    RDebug::Print(_L("CStereoWideningUtility::ConstructL"));

    64 #endif

    65 		iStereoWidening = CStereoWidening::NewL(aDevSound);

    66 		TInt level = iStereoWidening->StereoWideningLevel();

    68 		iTransStereoWidening = CTempStereoWidening::NewL(level,iStereoWidening);

    70 		iPresetRepository = CRepository::NewL(KCRUidStereoWideningPresets);

    73 		UpdateFullPresetArrayFromCenRep(iFullPresetArray);

    74 		UpdatePresetArray(iPresetArray,iFullPresetArray);

    75     }

    78 // -----------------------------------------------------------------------------

    79 // CStereoWideningUtility::ConstructL

    80 // Symbian 2nd phase constructor can leave.

    81 // -----------------------------------------------------------------------------

    82 //

    83 void CStereoWideningUtility::ConstructL(CMdaAudioConvertUtility& aUtility)

    84     {

    85 #ifdef _DEBUG

    86 		    RDebug::Print(_L("CStereoWideningUtility::ConstructL"));

    87 #endif

    88 		iStereoWidening = CStereoWidening::NewL(aUtility);

    89 		TInt level = iStereoWidening->StereoWideningLevel();

    91 		iTransStereoWidening = CTempStereoWidening::NewL(level,iStereoWidening);

    93 		iPresetRepository = CRepository::NewL(KCRUidStereoWideningPresets);

    96 		UpdateFullPresetArrayFromCenRep(iFullPresetArray);

    97 		UpdatePresetArray(iPresetArray,iFullPresetArray);

    98     }

   100 // -----------------------------------------------------------------------------

   101 // CStereoWideningUtility::ConstructL

   102 // Symbian 2nd phase constructor can leave.

   103 // -----------------------------------------------------------------------------

   104 //

   105 void CStereoWideningUtility::ConstructL(CMdaAudioInputStream& aUtility)

   106     {

   107 #ifdef _DEBUG

   108 		    RDebug::Print(_L("CStereoWideningUtility::ConstructL"));

   109 #endif

   110 		iStereoWidening = CStereoWidening::NewL(aUtility);

   111 		TInt level = iStereoWidening->StereoWideningLevel();

   113 		iTransStereoWidening = CTempStereoWidening::NewL(level,iStereoWidening);

   115 		iPresetRepository = CRepository::NewL(KCRUidStereoWideningPresets);

   118 		UpdateFullPresetArrayFromCenRep(iFullPresetArray);

   119 		UpdatePresetArray(iPresetArray,iFullPresetArray);

   120     }

   122 // -----------------------------------------------------------------------------

   123 // CStereoWideningUtility::ConstructL

   124 // Symbian 2nd phase constructor can leave.

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

   126 //

   127 void CStereoWideningUtility::ConstructL(CMdaAudioOutputStream& aUtility)

   128     {

   129 #ifdef _DEBUG

   130 		    RDebug::Print(_L("CStereoWideningUtility::ConstructL"));

   131 #endif

   132 		iStereoWidening = CStereoWidening::NewL(aUtility);

   133 		TInt level = iStereoWidening->StereoWideningLevel();

   135 		iTransStereoWidening = CTempStereoWidening::NewL(level,iStereoWidening);

   137 		iPresetRepository = CRepository::NewL(KCRUidStereoWideningPresets);

   140 		UpdateFullPresetArrayFromCenRep(iFullPresetArray);

   141 		UpdatePresetArray(iPresetArray,iFullPresetArray);

   142     }

   144 // -----------------------------------------------------------------------------

   145 // CStereoWideningUtility::ConstructL

   146 // Symbian 2nd phase constructor can leave.

   147 // -----------------------------------------------------------------------------

   148 //

   149 void CStereoWideningUtility::ConstructL(CMdaAudioPlayerUtility& aUtility)

   150     {

   151 #ifdef _DEBUG

   152 		    RDebug::Print(_L("CStereoWideningUtility::ConstructL"));

   153 #endif

   154 		iStereoWidening = CStereoWidening::NewL(aUtility);

   155 		TInt level = iStereoWidening->StereoWideningLevel();

   157 		iTransStereoWidening = CTempStereoWidening::NewL(level,iStereoWidening);

   159 		iPresetRepository = CRepository::NewL(KCRUidStereoWideningPresets);

   162 		UpdateFullPresetArrayFromCenRep(iFullPresetArray);

   163 		UpdatePresetArray(iPresetArray,iFullPresetArray);

   164 	}

   166 // -----------------------------------------------------------------------------

   167 // CStereoWideningUtility::ConstructL

   168 // Symbian 2nd phase constructor can leave.

   169 // -----------------------------------------------------------------------------

   170 //

   171 void CStereoWideningUtility::ConstructL(CMdaAudioRecorderUtility& aUtility )

   172     {

   173 #ifdef _DEBUG

   174 		    RDebug::Print(_L("CStereoWideningUtility::ConstructL"));

   175 #endif

   176 		iStereoWidening = CStereoWidening::NewL(aUtility,ETrue,EFalse,0);

   177 		TInt level = iStereoWidening->StereoWideningLevel();

   179 		iTransStereoWidening = CTempStereoWidening::NewL(level,iStereoWidening);

   181 		iPresetRepository = CRepository::NewL(KCRUidStereoWideningPresets);

   184 		UpdateFullPresetArrayFromCenRep(iFullPresetArray);

   185 		UpdatePresetArray(iPresetArray,iFullPresetArray);

   186    }

   188 // -----------------------------------------------------------------------------

   189 // CStereoWideningUtility::ConstructL

   190 // Symbian 2nd phase constructor can leave.

   191 // -----------------------------------------------------------------------------

   192 //

   193 void CStereoWideningUtility::ConstructL(CMdaAudioToneUtility& aUtility)

   194     {

   195 #ifdef _DEBUG

   196 		    RDebug::Print(_L("CStereoWideningUtility::ConstructL"));

   197 #endif

   198 		iStereoWidening = CStereoWidening::NewL(aUtility);

   199 		TInt level = iStereoWidening->StereoWideningLevel();

   201 		iTransStereoWidening = CTempStereoWidening::NewL(level,iStereoWidening);

   203 		iPresetRepository = CRepository::NewL(KCRUidStereoWideningPresets);

   206 		UpdateFullPresetArrayFromCenRep(iFullPresetArray);

   207 		UpdatePresetArray(iPresetArray,iFullPresetArray);

   208     }

   210 // -----------------------------------------------------------------------------

   211 // CStereoWideningUtility::ConstructL

   212 // Symbian 2nd phase constructor can leave.

   213 // -----------------------------------------------------------------------------

   214 //

   215 void CStereoWideningUtility::ConstructL(CCustomCommandUtility* aUtility)

   216     {

   217 #ifdef _DEBUG

   218 		    RDebug::Print(_L("CStereoWideningUtility::ConstructL"));

   219 #endif

   220 		iStereoWidening = CStereoWidening::NewL(aUtility);

   221 		TInt level = iStereoWidening->StereoWideningLevel();

   223 		iTransStereoWidening = CTempStereoWidening::NewL(level,iStereoWidening);

   225 		iPresetRepository = CRepository::NewL(KCRUidStereoWideningPresets);

   228 		UpdateFullPresetArrayFromCenRep(iFullPresetArray);

   229 		UpdatePresetArray(iPresetArray,iFullPresetArray);

   230     }

   232 // -----------------------------------------------------------------------------

   233 // CStereoWideningUtility::ConstructL

   234 // Symbian 2nd phase constructor can leave.

   235 // -----------------------------------------------------------------------------

   236 //

   237 void CStereoWideningUtility::ConstructL(MCustomInterface& aCustomInterface)

   238     {

   239 #ifdef _DEBUG

   240 		    RDebug::Print(_L("CStereoWideningUtility::ConstructL"));

   241 #endif

   242 		iStereoWidening = CStereoWidening::NewL(aCustomInterface);

   243 		TInt level = iStereoWidening->StereoWideningLevel();

   245 		iTransStereoWidening = CTempStereoWidening::NewL(level,iStereoWidening);

   247 		iPresetRepository = CRepository::NewL(KCRUidStereoWideningPresets);

   250 		UpdateFullPresetArrayFromCenRep(iFullPresetArray);

   251 		UpdatePresetArray(iPresetArray,iFullPresetArray);

   253     }

   255 // -----------------------------------------------------------------------------

   256 // CStereoWideningUtility::ConstructL

   257 // Symbian 2nd phase constructor can leave.

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

   259 //

   260 void CStereoWideningUtility::ConstructL(CMidiClientUtility& aUtility)

   261     {

   262 #ifdef _DEBUG

   263 		    RDebug::Print(_L("CStereoWideningUtility::ConstructL"));

   264 #endif

   265 		iStereoWidening = CStereoWidening::NewL(aUtility);

   266 		TInt level = iStereoWidening->StereoWideningLevel();

   268 		iTransStereoWidening = CTempStereoWidening::NewL(level,iStereoWidening);

   270 		iPresetRepository = CRepository::NewL(KCRUidStereoWideningPresets);

   273 		UpdateFullPresetArrayFromCenRep(iFullPresetArray);

   274 		UpdatePresetArray(iPresetArray,iFullPresetArray);

   275 	}

   277 // -----------------------------------------------------------------------------

   278 // CStereoWideningUtility::ConstructL

   279 // Symbian 2nd phase constructor can leave.

   280 // -----------------------------------------------------------------------------

   281 //

   282 void CStereoWideningUtility::ConstructL(CDrmPlayerUtility& aUtility)

   283     {

   284 #ifdef _DEBUG

   285 		    RDebug::Print(_L("CStereoWideningUtility::ConstructL"));

   286 #endif

   287 		iStereoWidening = CStereoWidening::NewL(aUtility);

   288 		TInt level = iStereoWidening->StereoWideningLevel();

   290 		iTransStereoWidening = CTempStereoWidening::NewL(level,iStereoWidening);

   292 		iPresetRepository = CRepository::NewL(KCRUidStereoWideningPresets);

   295 		UpdateFullPresetArrayFromCenRep(iFullPresetArray);

   296 		UpdatePresetArray(iPresetArray,iFullPresetArray);

   297 	}

   299 // -----------------------------------------------------------------------------

   300 // CStereoWideningUtility::ConstructL

   301 // Symbian 2nd phase constructor can leave.

   302 // -----------------------------------------------------------------------------

   303 //

   304 void CStereoWideningUtility::ConstructL(CVideoPlayerUtility& aUtility)

   305     {

   306 #ifdef _DEBUG

   307 		    RDebug::Print(_L("CStereoWideningUtility::ConstructL"));

   308 #endif

   309 		iStereoWidening = CStereoWidening::NewL(aUtility);

   310 		TInt level = iStereoWidening->StereoWideningLevel();

   312 		iTransStereoWidening = CTempStereoWidening::NewL(level,iStereoWidening);

   314 		iPresetRepository = CRepository::NewL(KCRUidStereoWideningPresets);

   317 		UpdateFullPresetArrayFromCenRep(iFullPresetArray);

   318 		UpdatePresetArray(iPresetArray,iFullPresetArray);

   319 	}

   321 // -----------------------------------------------------------------------------

   322 // CStereoWideningUtility::NewL

   323 // Two-phased constructor.

   324 // -----------------------------------------------------------------------------

   325 //

   326 EXPORT_C CStereoWideningUtility* CStereoWideningUtility::NewL(CMMFDevSound& aDevSound)

   327     {

   328 #ifdef _DEBUG

   329 		    RDebug::Print(_L("CStereoWideningUtility::NewL"));

   330 #endif

   331 		CStereoWideningUtility* self = new( ELeave ) CStereoWideningUtility;

   332 		CleanupStack::PushL( self );

   333 		self->ConstructL(aDevSound);

   334 		CleanupStack::Pop(self);

   335 		return self;

   336     }

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

   340 // CStereoWideningUtility::NewL

   341 // Two-phased constructor.

   342 // -----------------------------------------------------------------------------

   343 //

   344 EXPORT_C CStereoWideningUtility* CStereoWideningUtility::NewL(CMdaAudioConvertUtility& aUtility)

   345     {

   346 #ifdef _DEBUG

   347 		    RDebug::Print(_L("CStereoWideningUtility::NewL"));

   348 #endif

   349 		CStereoWideningUtility* self = new( ELeave ) CStereoWideningUtility;

   350 		CleanupStack::PushL( self );

   351 		self->ConstructL(aUtility);

   352 		CleanupStack::Pop(self);

   353 		return self;

   354     }

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

   358 // CStereoWideningUtility::NewL

   359 // Two-phased constructor.

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

   361 //

   362 EXPORT_C CStereoWideningUtility* CStereoWideningUtility::NewL(CMdaAudioInputStream& aUtility)

   363     {

   364 #ifdef _DEBUG

   365 		    RDebug::Print(_L("CStereoWideningUtility::NewL"));

   366 #endif

   367 		CStereoWideningUtility* self = new( ELeave ) CStereoWideningUtility;

   368 		CleanupStack::PushL( self );

   369 		self->ConstructL(aUtility);

   370 		CleanupStack::Pop(self);

   371 		return self;

   372     }

   375 // -----------------------------------------------------------------------------

   376 // CStereoWideningUtility::NewL

   377 // Two-phased constructor.

   378 // -----------------------------------------------------------------------------

   379 //

   380 EXPORT_C CStereoWideningUtility* CStereoWideningUtility::NewL(CMdaAudioOutputStream& aUtility)

   381     {

   382 #ifdef _DEBUG

   383 		    RDebug::Print(_L("CStereoWideningUtility::NewL"));

   384 #endif

   385 		CStereoWideningUtility* self = new( ELeave ) CStereoWideningUtility;

   386 		CleanupStack::PushL( self );

   387 		self->ConstructL(aUtility);

   388 		CleanupStack::Pop(self);

   389 		return self;

   390     }

   393 // -----------------------------------------------------------------------------

   394 // CStereoWideningUtility::NewL

   395 // Two-phased constructor.

   396 // -----------------------------------------------------------------------------

   397 //

   398 EXPORT_C CStereoWideningUtility* CStereoWideningUtility::NewL(CMdaAudioPlayerUtility& aUtility)

   399     {

   400 #ifdef _DEBUG

   401 		    RDebug::Print(_L("CStereoWideningUtility::NewL"));

   402 #endif

   403 		CStereoWideningUtility* self = new( ELeave ) CStereoWideningUtility;

   404 		CleanupStack::PushL( self );

   405 		self->ConstructL(aUtility);

   406 		CleanupStack::Pop(self);

   407 		return self;

   408     }

   411 // -----------------------------------------------------------------------------

   412 // CStereoWideningUtility::NewL

   413 // Two-phased constructor.

   414 // -----------------------------------------------------------------------------

   415 //

   416 EXPORT_C CStereoWideningUtility* CStereoWideningUtility::NewL(CMdaAudioRecorderUtility& aUtility)

   417     {

   418 #ifdef _DEBUG

   419 		    RDebug::Print(_L("CStereoWideningUtility::NewL"));

   420 #endif

   421 		CStereoWideningUtility* self = new( ELeave ) CStereoWideningUtility;

   422 		CleanupStack::PushL( self );

   423 		self->ConstructL(aUtility);

   424 		CleanupStack::Pop(self);

   425 		return self;

   426     }

   429 // -----------------------------------------------------------------------------

   430 // CStereoWideningUtility::NewL

   431 // Two-phased constructor.

   432 // -----------------------------------------------------------------------------

   433 //

   434 EXPORT_C CStereoWideningUtility* CStereoWideningUtility::NewL(CMdaAudioToneUtility& aUtility)

   435     {

   436 #ifdef _DEBUG

   437 		    RDebug::Print(_L("CStereoWideningUtility::NewL"));

   438 #endif

   439 		CStereoWideningUtility* self = new( ELeave ) CStereoWideningUtility;

   440 		CleanupStack::PushL( self );

   441 		self->ConstructL(aUtility);

   442 		CleanupStack::Pop(self);

   443 		return self;

   444     }

   447 // -----------------------------------------------------------------------------

   448 // CStereoWideningUtility::NewL

   449 // Two-phased constructor.

   450 // -----------------------------------------------------------------------------

   451 //

   452 EXPORT_C CStereoWideningUtility* CStereoWideningUtility::NewL(CCustomCommandUtility* aUtility)

   453     {

   454 #ifdef _DEBUG

   455 		    RDebug::Print(_L("CStereoWideningUtility::NewL"));

   456 #endif

   457 		CStereoWideningUtility* self = new( ELeave ) CStereoWideningUtility;

   458 		CleanupStack::PushL( self );

   459 		self->ConstructL(aUtility);

   460 		CleanupStack::Pop(self);

   461 		return self;

   462     }

   465 // -----------------------------------------------------------------------------

   466 // CStereoWideningUtility::NewL

   467 // Two-phased constructor.

   468 // -----------------------------------------------------------------------------

   469 //

   470 EXPORT_C CStereoWideningUtility* CStereoWideningUtility::NewL(MCustomInterface& aCustomInterface)

   471     {

   472 #ifdef _DEBUG

   473 		    RDebug::Print(_L("CStereoWideningUtility::NewL"));

   474 #endif

   475 		CStereoWideningUtility* self = new( ELeave ) CStereoWideningUtility;

   476 		CleanupStack::PushL( self );

   477 		self->ConstructL(aCustomInterface);

   478 		CleanupStack::Pop(self);

   479 		return self;

   480     }

   482 // -----------------------------------------------------------------------------

   483 // CStereoWideningUtility::NewL

   484 // Two-phased constructor.

   485 // -----------------------------------------------------------------------------

   486 //

   487 EXPORT_C  CStereoWideningUtility* CStereoWideningUtility::NewL(CMidiClientUtility& aUtility)

   488 {

   490 	#ifdef _DEBUG

   491 		    RDebug::Print(_L("CStereoWideningUtility::NewL"));

   492 #endif

   493 		CStereoWideningUtility* self = new( ELeave ) CStereoWideningUtility;

   494 		CleanupStack::PushL( self );

   495 		self->ConstructL(aUtility);

   496 		CleanupStack::Pop(self);

   497 		return self;

   498 }

   500 // -----------------------------------------------------------------------------

   501 // CStereoWideningUtility::NewL

   502 // Two-phased constructor.

   503 // -----------------------------------------------------------------------------

   504 //

   505 EXPORT_C  CStereoWideningUtility* CStereoWideningUtility::NewL(CDrmPlayerUtility& aUtility)

   506 {

   508 	#ifdef _DEBUG

   509 		    RDebug::Print(_L("CStereoWideningUtility::NewL"));

   510 #endif

   511 		CStereoWideningUtility* self = new( ELeave ) CStereoWideningUtility;

   512 		CleanupStack::PushL( self );

   513 		self->ConstructL(aUtility);

   514 		CleanupStack::Pop(self);

   515 		return self;

   516 }

   518 // -----------------------------------------------------------------------------

   519 // CStereoWideningUtility::NewL

   520 // Two-phased constructor.

   521 // -----------------------------------------------------------------------------

   522 //

   523 EXPORT_C  CStereoWideningUtility* CStereoWideningUtility::NewL(CVideoPlayerUtility& aUtility)

   524 {

   526 	#ifdef _DEBUG

   527 		    RDebug::Print(_L("CStereoWideningUtility::NewL"));

   528 #endif

   529 		CStereoWideningUtility* self = new( ELeave ) CStereoWideningUtility;

   530 		CleanupStack::PushL( self );

   531 		self->ConstructL(aUtility);

   532 		CleanupStack::Pop(self);

   533 		return self;

   534 }

   536 // -----------------------------------------------------------------------------

   537 // CStereoWideningUtility::ApplyPresetL()

   538 // Applies the Preset to the StereoWidening Object

   539 // (other items were commented in a header).

   540 // -----------------------------------------------------------------------------

   541 //

   542 EXPORT_C void CStereoWideningUtility::ApplyPresetL(

   543     TInt aPresetIndex)

   544     {

   545 #ifdef _DEBUG

   546 		    RDebug::Print(_L("CStereoWideningUtility::ApplyPresetL"));

   547 #endif

   548 		// Get the Preset from the Central Repository

   549 		// and Apply it to the StereoWidening Object

   550 		// using SetBandData method. After that Just Enable() the Effect

   552 		TInt level;

   554 		if(aPresetIndex > (iPresetArray.Count() - 1))

   555 			User::Leave(KErrArgument);

   557 		// Write the StereoWidening Data in the first available NULL Space

   558 		for( TInt j = 0; j < iFullPresetArray.Count();j++)

   559 			{

   560 				if( iFullPresetArray[j].iPresetNameKey == iPresetArray[aPresetIndex].iPresetNameKey)

   561 					{

   562 						iPresetRepository->Get(iFullPresetArray[j].iPresetDescriptionKey,level);

   563 						iStereoWidening->SetStereoWideningLevelL(level);

   564 						// Applying the Settings to the Audio StereoWidening

   565 					//	iStereoWidening->ApplyL();

   567                                                 iStereoWidening->EnableL();

   568 						break;

   569 					}

   570 			}

   571     }

   573 // -----------------------------------------------------------------------------

   574 // CStereoWideningUtility::CreatePresetL(TDesC& aName,CStereoWidening& aStereoWidening)

   575 // Applies the Preset to the StereoWidening Object

   576 // (other items were commented in a header).

   577 // -----------------------------------------------------------------------------

   578 //

   580 EXPORT_C void CStereoWideningUtility:: CreatePresetL(

   581     TDesC& aName,

   582     CStereoWidening& aStereoWideningUI)

   583     {

   584 #ifdef _DEBUG

   585 		    RDebug::Print(_L("CStereoWideningUtility::CreatePresetL"));

   586 #endif

   587 		// Get the Preset from the UI and create a DesC using

   588 		// DoBandData() method and then store it to the

   589 		// Central Repository

   591 		 __ASSERT_ALWAYS(aName.Length() > 0,User::Leave(KErrArgument));

   592 		UpdateFullPresetArrayFromCenRep(iFullPresetArray);

   594 		iTransStereoWidening = &aStereoWideningUI;

   596 				//Create New Keys at the End of the Repository

   597 		TInt currentNumber = 0;

   598 				// Get the number of User Defined Presets in the Repository

   599 		iPresetRepository->Get(KStereoWideningNumberOfUserDefinedPresets,currentNumber);

   601 		TUint8 level = iTransStereoWidening->StereoWideningLevel();

   603 				// Calculate and Create the StereoWidening Data for the New Preset

   604 		iPresetRepository->Create(currentNumber*2+KStereoWideningUserDefinedPresetStart,level);

   605 				// Calculate and create the New Preset Name in the End

   606 		iPresetRepository->Create(currentNumber*2+KStereoWideningUserDefinedPresetStartName,aName);

   607 				// Update the Number of UserDefined Presets in the End

   608 				// Since we created new Keys for the Name and the Descriptor

   609 		currentNumber += 1;

   610 		iPresetRepository->Set(KStereoWideningNumberOfUserDefinedPresets,currentNumber);

   611 		iPresetRepository->Get(KStereoWideningPresetsCounter,currentNumber);

   612 		iPresetRepository->Set(KStereoWideningPresetsCounter,currentNumber + 1);

   614 		// Refresh the iFullPresetArray

   615 		UpdateFullPresetArrayFromCenRep(iFullPresetArray);

   617     }

   619 // -----------------------------------------------------------------------------

   620 // CStereoWideningUtility::DeletePresetL()

   621 // Deletes the Preset from the Central Repository

   622 // (other items were commented in a header).

   623 // -----------------------------------------------------------------------------

   624 //

   625 EXPORT_C const TDesC& CStereoWideningUtility::GetPresetL(

   626     TInt aPresetIndex)

   627     {

   628 #ifdef _DEBUG

   629 		    RDebug::Print(_L("CStereoWideningUtility::GetPresetL"));

   630 #endif

   631 		// Get the Preset from the Central Repository

   632 		// and Apply it to the StereoWidening Object

   633 		// using SetBandData method. After that Just Enable() the Effect

   636 		if(aPresetIndex > (iPresetArray.Count() - 1))

   637 			User::Leave(KErrArgument);

   639 		TBool presetFound = EFalse;

   640 		TInt level;

   642 		// Write the StereoWidening Data in the first available NULL Space

   643 		for(TInt j = 0; j < iFullPresetArray.Count();j++)

   644 			{

   645 				if( iFullPresetArray[j].iPresetNameKey == iPresetArray[aPresetIndex].iPresetNameKey)

   646 					{

   647 						iPresetRepository->Get(iFullPresetArray[j].iPresetDescriptionKey,level);

   648 						iTransStereoWidening->SetStereoWideningLevelL(level);

   649 						presetFound = ETrue;

   650 						return iFullPresetArray[j].iPresetName;

   651 					}

   652 			}

   653 		if(!presetFound)

   654 			User::Leave(KErrNotFound);

   656 		return KNullDesC;

   657     }

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

   661 // CStereoWideningUtility::DeletePresetL()

   662 // Deletes the Preset from the Central Repository

   663 // (other items were commented in a header).

   664 // -----------------------------------------------------------------------------

   665 //

   666 EXPORT_C void CStereoWideningUtility::DeletePresetL(

   667     TInt aPresetIndex)

   668     {

   669 #ifdef _DEBUG

   670 		    RDebug::Print(_L("CStereoWideningUtility::DeletePresetL"));

   671 #endif

   672 		// Get the Name from the PresetIndex

   673 		// This Preset Index is from the Array returned to the UI

   675 		TInt err(KErrNone);

   676 		TBool presetFound = EFalse;

   678         // Leave if it deletes a predefined preset

   679 		TInt currentNumberOfPredefinedPresets = 0;

   681 	    // Get the number of User Defined Presets in the Repository

   682 		iPresetRepository->Get(KStereoWideningNumberOfPreDefinedPresets,currentNumberOfPredefinedPresets);

   684         if (aPresetIndex < currentNumberOfPredefinedPresets)  //it is a predefined preset,

   685         {

   686 			User::Leave(KErrArgument);

   687         }

   689 		if(aPresetIndex > (iPresetArray.Count() - 1))

   690 			User::Leave(KErrArgument);

   692 		UpdateFullPresetArrayFromCenRep(iFullPresetArray);

   693 		UpdatePresetArray(iPresetArray,iFullPresetArray);

   694 #ifdef _DEBUG

   695 		RDebug::RawPrint(iPresetArray[aPresetIndex].iPresetName);

   696 #endif

   698 		// Deletes the Preset from the iFullPresetArray and then

   699 		// rewrite it to the Central Repository

   700 		for(TInt j = 0; j < iFullPresetArray.Count();j++)

   701 			{

   703 				if( (iFullPresetArray[j].iPresetNameKey == iPresetArray[aPresetIndex].iPresetNameKey) &&

   704 						(iFullPresetArray[j].iPresetName.Length()))

   705 					{

   707 						presetFound = ETrue;

   708 						TRAP(err,iPresetRepository->Set(iFullPresetArray[j].iPresetNameKey,KNullDesC));

   709 						TRAP(err,iPresetRepository->Set(iFullPresetArray[j].iPresetDescriptionKey,KNullDesC));

   710 						if(err != KErrNone)

   711 							{

   712 								break;

   713 							}

   714 						else

   715 							{

   716 								iFullPresetArray[j].iPresetName.FillZ(0);

   717 								iFullPresetArray[j].iPresetNameKey = 0;

   718 								iFullPresetArray[j].iPresetDescriptionKey = 0;

   719 							    break;

   720 							}

   721 					}

   722 #ifdef _DEBUG

   723 				RDebug::RawPrint(iFullPresetArray[j].iPresetName);

   724 #endif

   725 			}

   727 		if(!presetFound)

   728 			User::Leave(KErrNotFound);

   729 		// After This Update the iPresetArray for the UI

   730 		UpdatePresetArray(iPresetArray,iFullPresetArray);

   731     }

   733 // -----------------------------------------------------------------------------

   734 // CStereoWideningUtility::DisablePresetL()

   735 // Disable the Preset

   736 // (other items were commented in a header).

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

   738 //

   740 EXPORT_C void CStereoWideningUtility::DisableStereoWideningL()

   741 {

   742 #ifdef _DEBUG

   743 		    RDebug::Print(_L("CStereoWideningUtility::DisableStereoWideningL"));

   744 #endif

   746 	if(iStereoWidening)

   747 	{

   748 		iStereoWidening->DisableL();

   749 	}

   750 }

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

   753 // CStereoWideningUtility::StereoWidening()

   754 // Applies the Preset to the StereoWidening Object

   755 // (other items were commented in a header).

   756 // -----------------------------------------------------------------------------

   757 //

   758 EXPORT_C CStereoWidening& CStereoWideningUtility::StereoWidening()

   759     {

   760 #ifdef _DEBUG

   761 		    RDebug::Print(_L("CStereoWideningUtility::StereoWidening()"));

   762 #endif

   764 		return *iTransStereoWidening;

   765     }

   768 // -----------------------------------------------------------------------------

   769 // CStereoWideningUtility::ModifyPresetL()

   770 // Applies the Preset to the StereoWidening Object

   771 // (other items were commented in a header).

   772 // -----------------------------------------------------------------------------

   773 //

   774 EXPORT_C void CStereoWideningUtility::ModifyPresetL(

   775     TInt aPresetIndex,

   776     TDesC& aName,

   777     CStereoWidening& aStereoWideningUI)

   778     {

   779 #ifdef _DEBUG

   780 		    RDebug::Print(_L("CStereoWideningUtility::ModifyPresetL"));

   781 #endif

   783 		 __ASSERT_ALWAYS(aName.Length() > 0,User::Leave(KErrArgument));

   784 		// Modifies the Preset Data in the Central Repository

   785 		// with the updated Name and StereoWidening Settings for the

   786 		// given PresetIndex

   788 		if(aPresetIndex > (iPresetArray.Count() - 1))

   789 			User::Leave(KErrArgument);

   791 		TUint8 level;

   792 		TBuf<32> presetName;

   793 		presetName = iPresetArray[aPresetIndex].iPresetName;

   795 		iTransStereoWidening = &aStereoWideningUI;

   797 		// Write the StereoWidening Data in the first available NULL Space

   798 		for( TInt j = 0; j < iFullPresetArray.Count();j++)

   799 			{

   800 				if( iFullPresetArray[j].iPresetName == presetName)

   801 					{

   802 						iPresetRepository->Set(iFullPresetArray[j].iPresetNameKey,aName);

   803 						level = iTransStereoWidening->StereoWideningLevel();

   804 						iPresetRepository->Set(iFullPresetArray[j].iPresetDescriptionKey,level);

   805 						break;

   806 					}

   807 			}

   808 		UpdateFullPresetArrayFromCenRep(iFullPresetArray);

   809     }

   812 // -----------------------------------------------------------------------------

   813 // CStereoWideningUtility::NumberOfPreDefinedPresets()

   814 // Applies the Preset to the StereoWidening Object

   815 // (other items were commented in a header).

   816 // -----------------------------------------------------------------------------

   817 //

   820 EXPORT_C TUint32 CStereoWideningUtility::NumberOfPreDefinedPresets() const

   821     {

   822 #ifdef _DEBUG

   823 		    RDebug::Print(_L("CStereoWideningUtility::NumberOfPreDefinedPresets"));

   824 #endif

   826 		TInt numberOfPresets;

   827 		iPresetRepository->Get(KStereoWideningNumberOfPreDefinedPresets,numberOfPresets);

   828 		return numberOfPresets;

   829     }

   832 // -----------------------------------------------------------------------------

   833 // CStereoWideningUtility::Presets()

   834 // Applies the Preset to the StereoWidening Object

   835 // (other items were commented in a header).

   836 // -----------------------------------------------------------------------------

   837 //

   838 EXPORT_C TArray<TEfStereoWideningUtilityPreset> CStereoWideningUtility::Presets()

   839     {

   840 #ifdef _DEBUG

   841 		    RDebug::Print(_L("CStereoWideningUtility::Presets"));

   842 #endif

   844 		// returns all the Presets from the System Defined and

   845 		// User Defined Preset Array in the Central Repository

   846 		UpdatePresetArray(iPresetArray,iFullPresetArray);

   847 		return iPresetArray.Array();

   848     }

   851 // -----------------------------------------------------------------------------

   852 // CStereoWideningUtility::ResetPresetL(TInt aPresetIndex)

   853 // Applies the Preset to the StereoWidening Object

   854 // (other items were commented in a header).

   855 // -----------------------------------------------------------------------------

   856 //

   857 EXPORT_C void CStereoWideningUtility::ResetPresetL(TInt aPresetIndex)

   858     {

   859 #ifdef _DEBUG

   860 		    RDebug::Print(_L("CStereoWideningUtility::ResetPresetL"));

   861 #endif

   863 		if(aPresetIndex > (iPresetArray.Count() - 1))

   864 			User::Leave(KErrArgument);

   866 		TBuf<32> aName;

   867 		aName = iPresetArray[aPresetIndex].iPresetName;

   869 		TInt currentNumber = 0;

   870 		// Get the number of System Defined Presets in the Repository

   871 		iPresetRepository->Get(KStereoWideningNumberOfPreDefinedPresets,currentNumber);

   873 		if(aPresetIndex >= currentNumber)

   874 			User::Leave(KErrNotSupported);

   877 		for( TInt j = 0; j < currentNumber;j++)

   878 				{

   879 					if( iFullPresetArray[j].iPresetName == aName)

   880 						{

   881 							iPresetRepository->Reset(iFullPresetArray[j].iPresetDescriptionKey);

   882 							iPresetRepository->Reset(iFullPresetArray[j].iPresetNameKey);

   883 						}

   884 				}

   886 		UpdatePresetArray(iPresetArray,iFullPresetArray);

   887 	}

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

   891 // CStereoWideningUtility::UpdatePresetArrayFromCenRep(RArray<TEfStereoWideningUtilityPreset> &aFullPresetArray)

   892 // Updates the Array with the Values in Central Repository

   893 // (other items were commented in a header).

   894 // -----------------------------------------------------------------------------

   895 //

   897 void CStereoWideningUtility::UpdateFullPresetArrayFromCenRep(RArray<TEfStereoWideningUtilityPreset>& aFullPresetArray)

   898 	{

   900 		aFullPresetArray.Reset();

   901  		TEfStereoWideningUtilityPreset tempPreset;

   904 		TInt numberOfUserDefinedPresets = 0;

   905 		TInt numberOfPreDefinedPresets = 0;

   907 		iPresetRepository->Get(KStereoWideningNumberOfUserDefinedPresets,numberOfUserDefinedPresets);

   908 		iPresetRepository->Get(KStereoWideningNumberOfPreDefinedPresets,numberOfPreDefinedPresets);

   910 		for( TInt j = 0; j < (numberOfPreDefinedPresets); j++)

   911 				{

   912 					tempPreset.iPresetDescriptionKey = KStereoWideningPreDefinedPresetStart + (2 * j);

   913 					tempPreset.iPresetNameKey = KStereoWideningPreDefinedPresetStartName + (2 * j);

   914 					iPresetRepository->Get((KStereoWideningPreDefinedPresetStartName + (2 * j)) ,tempPreset.iPresetName);

   915 #ifdef _DEBUG

   916 					RDebug::RawPrint(tempPreset.iPresetName);

   917 #endif

   918 					aFullPresetArray.Append(tempPreset);

   920 				}

   922 			for( TInt j = 0; j < (numberOfUserDefinedPresets); j++)

   923 				{

   924 					tempPreset.iPresetDescriptionKey = KStereoWideningUserDefinedPresetStart + (2 * j);

   925 					tempPreset.iPresetNameKey = KStereoWideningUserDefinedPresetStartName + (2 * j);

   926 					iPresetRepository->Get((KStereoWideningUserDefinedPresetStartName + (2 * j)) ,tempPreset.iPresetName);

   927 #ifdef _DEBUG

   928 					RDebug::RawPrint(tempPreset.iPresetName);

   929 #endif

   930 					aFullPresetArray.Append(tempPreset);

   932 				}

   934 	}

   936 // -----------------------------------------------------------------------------

   937 // CStereoWideningUtility::UpdatePresetArray(RArray<TDesC>& aPresetArray,const RArray<TEfStereoWideningUtilityPreset> &aFullPresetArray)

   938 // Creates the Descriptor Array of Names of the Presets Stored in Central Repository

   939 // (other items were commented in a header).

   940 // -----------------------------------------------------------------------------

   941 //

   942 void CStereoWideningUtility::UpdatePresetArray(RArray<TEfStereoWideningUtilityPreset>& aPresetArray,const RArray<TEfStereoWideningUtilityPreset>& aFullPresetArray)

   943 	{

   945 		aPresetArray.Reset();

   946 		TEfStereoWideningUtilityPreset	tempClientArray;

   948 		// Write the StereoWidening Data in the first available NULL Space

   949 		for( TInt j = 0; j < aFullPresetArray.Count();j++)

   950 			{

   951 				if( aFullPresetArray[j].iPresetName.Length() != 0)

   952 					{

   954 						tempClientArray.iPresetName = aFullPresetArray[j].iPresetName;

   955 						tempClientArray.iPresetNameKey = aFullPresetArray[j].iPresetNameKey;

   956 						tempClientArray.iPresetDescriptionKey = aFullPresetArray[j].iPresetDescriptionKey;

   957 						aPresetArray.Append(tempClientArray);

   958 					}

   959 				RDebug::Print(_L("Name Length %d "),aFullPresetArray[j].iPresetName.Length());

   960 				RDebug::RawPrint(aFullPresetArray[j].iPresetName);

   961 			}

   963 	}

   966 // ========================== OTHER EXPORTED FUNCTIONS =========================

   970 //  End of File

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