Symaptic: os/mm/devsoundextensions/effectspresets/AudioEqualizerUtility/src/AudioEqualizerutility.cpp@bde4ae8d615e

     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 Equalizer Effect

    15 *

    16 */

    20 // INCLUDE FILES

    21 #include <e32std.h>

    22 #include <AudioEqualizerUtility.h>

    23 #include <DrmAudioSamplePlayer.h>

    24 #include "TempAudioEqualizer.h"

    25 #include "AudioEqUtilityInternalCRKeys.h"

    26 #include <videoplayer.h>

    28 // ============================ MEMBER FUNCTIONS ===============================

    30 // -----------------------------------------------------------------------------

    31 // CAudioEqualizerUtility::CAudioEqualizerUtility

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

    33 // might leave.

    34 // -----------------------------------------------------------------------------

    35 //

    36 CAudioEqualizerUtility::CAudioEqualizerUtility()

    37 	: iAudioEqualizer(NULL),

    38 	  iBassBoost(NULL),

    39 	  iPresetRepository(NULL)

    40 	{

    41     }

    44 // Destructor

    45 CAudioEqualizerUtility::~CAudioEqualizerUtility()

    46     {

    47 		iPresetArray.Close();

    48 		iFullPresetArray.Close();

    49 		delete iPresetRepository;

    50 		delete iTransAudioEqualizer;

    51 		delete iAudioEqualizer;

    52 		//delete iBassBoost;

    53     }

    56 // -----------------------------------------------------------------------------

    57 // CAudioEqualizerUtility::ConstructL

    58 // Symbian 2nd phase constructor can leave.

    59 // -----------------------------------------------------------------------------

    60 //

    61 void CAudioEqualizerUtility::ConstructL(CMMFDevSound& aDevSound)

    62     {

    63 #ifdef _DEBUG

    64 		RDebug::Print(_L("CAudioEqualizerUtility::ConstructL"));

    65 #endif

    66 		iAudioEqualizer = CAudioEqualizer::NewL(aDevSound);

    67 		TInt numberBands = iAudioEqualizer->NumberOfBands();

    69 		iTransAudioEqualizer = CTempAudioEqualizer::NewL(numberBands,iAudioEqualizer);

    71 		//iBassBoost = CBassBoost::NewL(aDevSound,EFalse);

    72 		iPresetRepository = CRepository::NewL(KCRUidAudioEqUtilityPresets);

    75 		UpdateFullPresetArrayFromCenRep(iFullPresetArray);

    76 		UpdatePresetArray(iPresetArray,iFullPresetArray);

    78 		iTransAudioEqualizer->SetBandDataL(2,iAudioEqualizer->DoBandDataL(1,ETrue));

    79 		iTransAudioEqualizer->SetEffectData(iAudioEqualizer->DoEffectData());

    80     }

    83 // -----------------------------------------------------------------------------

    84 // CAudioEqualizerUtility::ConstructL

    85 // Symbian 2nd phase constructor can leave.

    86 // -----------------------------------------------------------------------------

    87 //

    88 void CAudioEqualizerUtility::ConstructL(CMdaAudioConvertUtility& aUtility)

    89     {

    90 #ifdef _DEBUG

    91 		RDebug::Print(_L("CAudioEqualizerUtility::ConstructL"));

    92 #endif

    93 		iAudioEqualizer = CAudioEqualizer::NewL(aUtility);

    94 		TInt numberBands = iAudioEqualizer->NumberOfBands();

    96 		iTransAudioEqualizer = CTempAudioEqualizer::NewL(numberBands,iAudioEqualizer);

    98 		//iBassBoost = CBassBoost::NewL(aUtility,EFalse);

    99 		iPresetRepository = CRepository::NewL(KCRUidAudioEqUtilityPresets);

   102 		UpdateFullPresetArrayFromCenRep(iFullPresetArray);

   103 		UpdatePresetArray(iPresetArray,iFullPresetArray);

   105 		iTransAudioEqualizer->SetBandDataL(2,iAudioEqualizer->DoBandDataL(1,ETrue));

   106 		iTransAudioEqualizer->SetEffectData(iAudioEqualizer->DoEffectData());

   107     }

   109 // -----------------------------------------------------------------------------

   110 // CAudioEqualizerUtility::ConstructL

   111 // Symbian 2nd phase constructor can leave.

   112 // -----------------------------------------------------------------------------

   113 //

   114 void CAudioEqualizerUtility::ConstructL(CMdaAudioInputStream& aUtility)

   115     {

   116 #ifdef _DEBUG

   117 		RDebug::Print(_L("CAudioEqualizerUtility::ConstructL"));

   118 #endif

   119 		iAudioEqualizer = CAudioEqualizer::NewL(aUtility);

   120 		TInt numberBands = iAudioEqualizer->NumberOfBands();

   122 		iTransAudioEqualizer = CTempAudioEqualizer::NewL(numberBands,iAudioEqualizer);

   124 		//iBassBoost = CBassBoost::NewL(aUtility,EFalse);

   125 		iPresetRepository = CRepository::NewL(KCRUidAudioEqUtilityPresets);

   128 		UpdateFullPresetArrayFromCenRep(iFullPresetArray);

   129 		UpdatePresetArray(iPresetArray,iFullPresetArray);

   131 		iTransAudioEqualizer->SetBandDataL(2,iAudioEqualizer->DoBandDataL(1,ETrue));

   132 		iTransAudioEqualizer->SetEffectData(iAudioEqualizer->DoEffectData());

   133     }

   135 // -----------------------------------------------------------------------------

   136 // CAudioEqualizerUtility::ConstructL

   137 // Symbian 2nd phase constructor can leave.

   138 // -----------------------------------------------------------------------------

   139 //

   140 void CAudioEqualizerUtility::ConstructL(CMdaAudioOutputStream& aUtility)

   141     {

   142 #ifdef _DEBUG

   143 		RDebug::Print(_L("CAudioEqualizerUtility::ConstructL"));

   144 #endif

   145 		iAudioEqualizer = CAudioEqualizer::NewL(aUtility);

   146 		TInt numberBands = iAudioEqualizer->NumberOfBands();

   148 		iTransAudioEqualizer = CTempAudioEqualizer::NewL(numberBands,iAudioEqualizer);

   150 		//iBassBoost = CBassBoost::NewL(aUtility,EFalse);

   151 		iPresetRepository = CRepository::NewL(KCRUidAudioEqUtilityPresets);

   154 		UpdateFullPresetArrayFromCenRep(iFullPresetArray);

   155 		UpdatePresetArray(iPresetArray,iFullPresetArray);

   157 		iTransAudioEqualizer->SetBandDataL(2,iAudioEqualizer->DoBandDataL(1,ETrue));

   158 		iTransAudioEqualizer->SetEffectData(iAudioEqualizer->DoEffectData());

   159     }

   161 // -----------------------------------------------------------------------------

   162 // CAudioEqualizerUtility::ConstructL

   163 // Symbian 2nd phase constructor can leave.

   164 // -----------------------------------------------------------------------------

   165 //

   166 void CAudioEqualizerUtility::ConstructL(CMdaAudioPlayerUtility& aUtility)

   167     {

   168 #ifdef _DEBUG

   169 	    RDebug::Print(_L("CAudioEqualizerUtility::ConstructL"));

   170 #endif

   171 		iAudioEqualizer = CAudioEqualizer::NewL(aUtility);

   172 		TInt numberBands = iAudioEqualizer->NumberOfBands();

   174 		iTransAudioEqualizer = CTempAudioEqualizer::NewL(numberBands,iAudioEqualizer);

   176 		//iBassBoost = CBassBoost::NewL(aUtility,EFalse);

   177 		iPresetRepository = CRepository::NewL(KCRUidAudioEqUtilityPresets);

   180 		UpdateFullPresetArrayFromCenRep(iFullPresetArray);

   181 		UpdatePresetArray(iPresetArray,iFullPresetArray);

   183 		iTransAudioEqualizer->SetBandDataL(2,iAudioEqualizer->DoBandDataL(1,ETrue));

   184 		iTransAudioEqualizer->SetEffectData(iAudioEqualizer->DoEffectData());

   185 	}

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

   188 // CAudioEqualizerUtility::ConstructL

   189 // Symbian 2nd phase constructor can leave.

   190 // -----------------------------------------------------------------------------

   191 //

   192 void CAudioEqualizerUtility::ConstructL(CMdaAudioRecorderUtility& aUtility )

   193     {

   194 #ifdef _DEBUG

   195 		RDebug::Print(_L("CAudioEqualizerUtility::ConstructL"));

   196 #endif

   197 		iAudioEqualizer = CAudioEqualizer::NewL(aUtility,ETrue);

   198 		TInt numberBands = iAudioEqualizer->NumberOfBands();

   200 		iTransAudioEqualizer = CTempAudioEqualizer::NewL(numberBands,iAudioEqualizer);

   202 		//iBassBoost = CBassBoost::NewL(aUtility,EFalse);

   203 		iPresetRepository = CRepository::NewL(KCRUidAudioEqUtilityPresets);

   206 		UpdateFullPresetArrayFromCenRep(iFullPresetArray);

   207 		UpdatePresetArray(iPresetArray,iFullPresetArray);

   209 		iTransAudioEqualizer->SetBandDataL(2,iAudioEqualizer->DoBandDataL(1,ETrue));

   210 		iTransAudioEqualizer->SetEffectData(iAudioEqualizer->DoEffectData());

   211    }

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

   214 // CAudioEqualizerUtility::ConstructL

   215 // Symbian 2nd phase constructor can leave.

   216 // -----------------------------------------------------------------------------

   217 //

   218 void CAudioEqualizerUtility::ConstructL(CMdaAudioToneUtility& aUtility)

   219     {

   220 #ifdef _DEBUG

   221 		RDebug::Print(_L("CAudioEqualizerUtility::ConstructL"));

   222 #endif

   223 		iAudioEqualizer = CAudioEqualizer::NewL(aUtility);

   224 		TInt numberBands = iAudioEqualizer->NumberOfBands();

   226 		iTransAudioEqualizer = CTempAudioEqualizer::NewL(numberBands,iAudioEqualizer);

   228 		//iBassBoost = CBassBoost::NewL(aUtility,EFalse);

   229 		iPresetRepository = CRepository::NewL(KCRUidAudioEqUtilityPresets);

   232 		UpdateFullPresetArrayFromCenRep(iFullPresetArray);

   233 		UpdatePresetArray(iPresetArray,iFullPresetArray);

   235 		iTransAudioEqualizer->SetBandDataL(2,iAudioEqualizer->DoBandDataL(1,ETrue));

   236 		iTransAudioEqualizer->SetEffectData(iAudioEqualizer->DoEffectData());

   237     }

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

   240 // CAudioEqualizerUtility::ConstructL

   241 // Symbian 2nd phase constructor can leave.

   242 // -----------------------------------------------------------------------------

   243 //

   244 void CAudioEqualizerUtility::ConstructL(CCustomCommandUtility* aUtility)

   245     {

   246 #ifdef _DEBUG

   247 		RDebug::Print(_L("CAudioEqualizerUtility::ConstructL"));

   248 #endif

   249 		iAudioEqualizer = CAudioEqualizer::NewL(aUtility);

   250 		TInt numberBands = iAudioEqualizer->NumberOfBands();

   252 		iTransAudioEqualizer = CTempAudioEqualizer::NewL(numberBands,iAudioEqualizer);

   254 		//iBassBoost = CBassBoost::NewL(aUtility,EFalse);

   255 		iPresetRepository = CRepository::NewL(KCRUidAudioEqUtilityPresets);

   258 		UpdateFullPresetArrayFromCenRep(iFullPresetArray);

   259 		UpdatePresetArray(iPresetArray,iFullPresetArray);

   261 		iTransAudioEqualizer->SetBandDataL(2,iAudioEqualizer->DoBandDataL(1,ETrue));

   262 		iTransAudioEqualizer->SetEffectData(iAudioEqualizer->DoEffectData());

   263     }

   265 // -----------------------------------------------------------------------------

   266 // CAudioEqualizerUtility::ConstructL

   267 // Symbian 2nd phase constructor can leave.

   268 // -----------------------------------------------------------------------------

   269 //

   270 void CAudioEqualizerUtility::ConstructL(MCustomInterface& aCustomInterface)

   271     {

   272 #ifdef _DEBUG

   273 		RDebug::Print(_L("CAudioEqualizerUtility::ConstructL"));

   274 #endif

   275 		iAudioEqualizer = CAudioEqualizer::NewL(aCustomInterface);

   276 		TInt numberBands = iAudioEqualizer->NumberOfBands();

   278 		iTransAudioEqualizer = CTempAudioEqualizer::NewL(numberBands,iAudioEqualizer);

   280 		//iBassBoost = CBassBoost::NewL(aCustomInterface,EFalse);

   281 		iPresetRepository = CRepository::NewL(KCRUidAudioEqUtilityPresets);

   284 		UpdateFullPresetArrayFromCenRep(iFullPresetArray);

   285 		UpdatePresetArray(iPresetArray,iFullPresetArray);

   287 		iTransAudioEqualizer->SetBandDataL(2,iAudioEqualizer->DoBandDataL(1,ETrue));

   288 		iTransAudioEqualizer->SetEffectData(iAudioEqualizer->DoEffectData());

   290     }

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

   293 // CAudioEqualizerUtility::ConstructL

   294 // Symbian 2nd phase constructor can leave.

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

   296 //

   297 void CAudioEqualizerUtility::ConstructL(CMidiClientUtility& aUtility)

   298     {

   299 #ifdef _DEBUG

   300 		RDebug::Print(_L("CAudioEqualizerUtility::ConstructL"));

   301 #endif

   302 		iAudioEqualizer = CAudioEqualizer::NewL(aUtility);

   303 		TInt numberBands = iAudioEqualizer->NumberOfBands();

   305 		iTransAudioEqualizer = CTempAudioEqualizer::NewL(numberBands,iAudioEqualizer);

   307 		//iBassBoost = CBassBoost::NewL(aUtility,EFalse);

   308 		iPresetRepository = CRepository::NewL(KCRUidAudioEqUtilityPresets);

   311 		UpdateFullPresetArrayFromCenRep(iFullPresetArray);

   312 		UpdatePresetArray(iPresetArray,iFullPresetArray);

   314 		iTransAudioEqualizer->SetBandDataL(2,iAudioEqualizer->DoBandDataL(1,ETrue));

   315 		iTransAudioEqualizer->SetEffectData(iAudioEqualizer->DoEffectData());

   316 	}

   318 // -----------------------------------------------------------------------------

   319 // CAudioEqualizerUtility::ConstructL

   320 // Symbian 2nd phase constructor can leave.

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

   322 //

   323 void CAudioEqualizerUtility::ConstructL(CDrmPlayerUtility& aUtility)

   324     {

   325 #ifdef _DEBUG

   326 		RDebug::Print(_L("CAudioEqualizerUtility::ConstructL"));

   327 #endif

   328 		iAudioEqualizer = CAudioEqualizer::NewL(aUtility);

   329 		TInt numberBands = iAudioEqualizer->NumberOfBands();

   331 		iTransAudioEqualizer = CTempAudioEqualizer::NewL(numberBands,iAudioEqualizer);

   333 		//iBassBoost = CBassBoost::NewL(aUtility,EFalse);

   334 		iPresetRepository = CRepository::NewL(KCRUidAudioEqUtilityPresets);

   337 		UpdateFullPresetArrayFromCenRep(iFullPresetArray);

   338 		UpdatePresetArray(iPresetArray,iFullPresetArray);

   340 		iTransAudioEqualizer->SetBandDataL(2,iAudioEqualizer->DoBandDataL(1,ETrue));

   341 		iTransAudioEqualizer->SetEffectData(iAudioEqualizer->DoEffectData());

   342 	}

   344 // -----------------------------------------------------------------------------

   345 // CAudioEqualizerUtility::ConstructL

   346 // Symbian 2nd phase constructor can leave.

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

   348 //

   349 void CAudioEqualizerUtility::ConstructL(CVideoPlayerUtility& aUtility)

   350     {

   351 #ifdef _DEBUG

   352 		RDebug::Print(_L("CAudioEqualizerUtility::ConstructL"));

   353 #endif

   354 		iAudioEqualizer = CAudioEqualizer::NewL(aUtility);

   355 		TInt numberBands = iAudioEqualizer->NumberOfBands();

   357 		iTransAudioEqualizer = CTempAudioEqualizer::NewL(numberBands,iAudioEqualizer);

   359 		//iBassBoost = CBassBoost::NewL(aUtility,EFalse);

   360 		iPresetRepository = CRepository::NewL(KCRUidAudioEqUtilityPresets);

   363 		UpdateFullPresetArrayFromCenRep(iFullPresetArray);

   364 		UpdatePresetArray(iPresetArray,iFullPresetArray);

   366 		iTransAudioEqualizer->SetBandDataL(2,iAudioEqualizer->DoBandDataL(1,ETrue));

   367 		iTransAudioEqualizer->SetEffectData(iAudioEqualizer->DoEffectData());

   368 	}

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

   371 // CAudioEqualizerUtility::NewL

   372 // Two-phased constructor.

   373 // -----------------------------------------------------------------------------

   374 //

   375 EXPORT_C CAudioEqualizerUtility* CAudioEqualizerUtility::NewL(CMMFDevSound& aDevSound)

   376     {

   377 #ifdef _DEBUG

   378 		RDebug::Print(_L("CAudioEqualizerUtility::NewL"));

   379 #endif

   380 		CAudioEqualizerUtility* self = new( ELeave ) CAudioEqualizerUtility;

   381 		CleanupStack::PushL( self );

   382 		self->ConstructL(aDevSound);

   383 		CleanupStack::Pop(self);

   384 		return self;

   385     }

   388 // -----------------------------------------------------------------------------

   389 // CAudioEqualizerUtility::NewL

   390 // Two-phased constructor.

   391 // -----------------------------------------------------------------------------

   392 //

   393 EXPORT_C CAudioEqualizerUtility* CAudioEqualizerUtility::NewL(CMdaAudioConvertUtility& aUtility)

   394     {

   395 #ifdef _DEBUG

   396 		RDebug::Print(_L("CAudioEqualizerUtility::NewL"));

   397 #endif

   398 		CAudioEqualizerUtility* self = new( ELeave ) CAudioEqualizerUtility;

   399 		CleanupStack::PushL( self );

   400 		self->ConstructL(aUtility);

   401 		CleanupStack::Pop(self);

   402 		return self;

   403     }

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

   407 // CAudioEqualizerUtility::NewL

   408 // Two-phased constructor.

   409 // -----------------------------------------------------------------------------

   410 //

   411 EXPORT_C CAudioEqualizerUtility* CAudioEqualizerUtility::NewL(CMdaAudioInputStream& aUtility)

   412     {

   413 #ifdef _DEBUG

   414 		RDebug::Print(_L("CAudioEqualizerUtility::NewL"));

   415 #endif

   416 		CAudioEqualizerUtility* self = new( ELeave ) CAudioEqualizerUtility;

   417 		CleanupStack::PushL( self );

   418 		self->ConstructL(aUtility);

   419 		CleanupStack::Pop(self);

   420 		return self;

   421     }

   424 // -----------------------------------------------------------------------------

   425 // CAudioEqualizerUtility::NewL

   426 // Two-phased constructor.

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

   428 //

   429 EXPORT_C CAudioEqualizerUtility* CAudioEqualizerUtility::NewL(CMdaAudioOutputStream& aUtility)

   430     {

   431 #ifdef _DEBUG

   432 		RDebug::Print(_L("CAudioEqualizerUtility::NewL"));

   433 #endif

   434 		CAudioEqualizerUtility* self = new( ELeave ) CAudioEqualizerUtility;

   435 		CleanupStack::PushL( self );

   436 		self->ConstructL(aUtility);

   437 		CleanupStack::Pop(self);

   438 		return self;

   439     }

   442 // -----------------------------------------------------------------------------

   443 // CAudioEqualizerUtility::NewL

   444 // Two-phased constructor.

   445 // -----------------------------------------------------------------------------

   446 //

   447 EXPORT_C CAudioEqualizerUtility* CAudioEqualizerUtility::NewL(CMdaAudioPlayerUtility& aUtility)

   448     {

   449 #ifdef _DEBUG

   450 		RDebug::Print(_L("CAudioEqualizerUtility::NewL"));

   451 #endif

   452 		CAudioEqualizerUtility* self = new( ELeave ) CAudioEqualizerUtility;

   453 		CleanupStack::PushL( self );

   454 		self->ConstructL(aUtility);

   455 		CleanupStack::Pop(self);

   456 		return self;

   457     }

   460 // -----------------------------------------------------------------------------

   461 // CAudioEqualizerUtility::NewL

   462 // Two-phased constructor.

   463 // -----------------------------------------------------------------------------

   464 //

   465 EXPORT_C CAudioEqualizerUtility* CAudioEqualizerUtility::NewL(CMdaAudioRecorderUtility& aUtility)

   466     {

   467 #ifdef _DEBUG

   468 	    RDebug::Print(_L("CAudioEqualizerUtility::NewL"));

   469 #endif

   470 		CAudioEqualizerUtility* self = new( ELeave ) CAudioEqualizerUtility;

   471 		CleanupStack::PushL( self );

   472 		self->ConstructL(aUtility);

   473 		CleanupStack::Pop(self);

   474 		return self;

   475     }

   478 // -----------------------------------------------------------------------------

   479 // CAudioEqualizerUtility::NewL

   480 // Two-phased constructor.

   481 // -----------------------------------------------------------------------------

   482 //

   483 EXPORT_C CAudioEqualizerUtility* CAudioEqualizerUtility::NewL(CMdaAudioToneUtility& aUtility)

   484     {

   485 #ifdef _DEBUG

   486 		RDebug::Print(_L("CAudioEqualizerUtility::NewL"));

   487 #endif

   488 		CAudioEqualizerUtility* self = new( ELeave ) CAudioEqualizerUtility;

   489 		CleanupStack::PushL( self );

   490 		self->ConstructL(aUtility);

   491 		CleanupStack::Pop(self);

   492 		return self;

   493     }

   496 // -----------------------------------------------------------------------------

   497 // CAudioEqualizerUtility::NewL

   498 // Two-phased constructor.

   499 // -----------------------------------------------------------------------------

   500 //

   501 EXPORT_C CAudioEqualizerUtility* CAudioEqualizerUtility::NewL(CCustomCommandUtility* aUtility)

   502     {

   503 #ifdef _DEBUG

   504 		    RDebug::Print(_L("CAudioEqualizerUtility::NewL"));

   505 #endif

   506 		CAudioEqualizerUtility* self = new( ELeave ) CAudioEqualizerUtility;

   507 		CleanupStack::PushL( self );

   508 		self->ConstructL(aUtility);

   509 		CleanupStack::Pop(self);

   510 		return self;

   511     }

   514 // -----------------------------------------------------------------------------

   515 // CAudioEqualizerUtility::NewL

   516 // Two-phased constructor.

   517 // -----------------------------------------------------------------------------

   518 //

   519 EXPORT_C CAudioEqualizerUtility* CAudioEqualizerUtility::NewL(MCustomInterface& aCustomInterface)

   520     {

   521 #ifdef _DEBUG

   522 		RDebug::Print(_L("CAudioEqualizerUtility::NewL"));

   523 #endif

   524 		CAudioEqualizerUtility* self = new( ELeave ) CAudioEqualizerUtility;

   525 		CleanupStack::PushL( self );

   526 		self->ConstructL(aCustomInterface);

   527 		CleanupStack::Pop(self);

   528 		return self;

   529     }

   531 // -----------------------------------------------------------------------------

   532 // CAudioEqualizerUtility::NewL

   533 // Two-phased constructor.

   534 // -----------------------------------------------------------------------------

   535 //

   536 EXPORT_C CAudioEqualizerUtility* CAudioEqualizerUtility::NewL(CMidiClientUtility& aUtility)

   537     {

   538 #ifdef _DEBUG

   539 		RDebug::Print(_L("CAudioEqualizerUtility::NewL"));

   540 #endif

   541 		CAudioEqualizerUtility* self = new( ELeave ) CAudioEqualizerUtility;

   542 		CleanupStack::PushL( self );

   543 		self->ConstructL(aUtility);

   544 		CleanupStack::Pop(self);

   545 		return self;

   546     }

   548 // -----------------------------------------------------------------------------

   549 // CAudioEqualizerUtility::NewL

   550 // Two-phased constructor.

   551 // -----------------------------------------------------------------------------

   552 //

   553 EXPORT_C CAudioEqualizerUtility* CAudioEqualizerUtility::NewL(CDrmPlayerUtility& aUtility)

   554     {

   555 #ifdef _DEBUG

   556 		RDebug::Print(_L("CAudioEqualizerUtility::NewL"));

   557 #endif

   558 		CAudioEqualizerUtility* self = new( ELeave ) CAudioEqualizerUtility;

   559 		CleanupStack::PushL( self );

   560 		self->ConstructL(aUtility);

   561 		CleanupStack::Pop(self);

   562 		return self;

   563     }

   565 // -----------------------------------------------------------------------------

   566 // CAudioEqualizerUtility::NewL

   567 // Two-phased constructor.

   568 // -----------------------------------------------------------------------------

   569 //

   570 EXPORT_C CAudioEqualizerUtility* CAudioEqualizerUtility::NewL(CVideoPlayerUtility& aUtility)

   571     {

   572 #ifdef _DEBUG

   573 		RDebug::Print(_L("CAudioEqualizerUtility::NewL"));

   574 #endif

   575 		CAudioEqualizerUtility* self = new( ELeave ) CAudioEqualizerUtility;

   576 		CleanupStack::PushL( self );

   577 		self->ConstructL(aUtility);

   578 		CleanupStack::Pop(self);

   579 		return self;

   580     }

   582 // -----------------------------------------------------------------------------

   583 // CAudioEqualizerUtility::ApplyPresetL()

   584 // Applies the Preset to the Equalizer Object

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

   586 // -----------------------------------------------------------------------------

   587 //

   588 EXPORT_C void CAudioEqualizerUtility::ApplyPresetL(

   589     TInt aPresetIndex)

   590     {

   591 #ifdef _DEBUG

   592 		    RDebug::Print(_L("CAudioEqualizerUtility::ApplyPresetL"));

   593 #endif

   594 		// Get the Preset from the Central Repository

   595 		// and Apply it to the Equalizer Object

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

   598 		TBuf8<256> aDescription;

   599 		TBufC8<256> aDes;

   600 		TBool presetFound = EFalse;

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

   603 			User::Leave(KErrArgument);

   605 		UpdateFullPresetArrayFromCenRep(iFullPresetArray);

   607 		// Write the Equalizer Data in the first available NULL Space

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

   609 			{

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

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

   612 					{

   613 						iPresetRepository->Get(iFullPresetArray[j].iPresetDescriptionKey,aDescription);

   614 						aDes = aDescription;

   615 						iAudioEqualizer->SetBandDataL(2,aDes);

   617 						// Applying the Settings to the Audio Equalizer

   618 						iAudioEqualizer->EnableL();

   619 					//	iAudioEqualizer->ApplyL();

   620 						presetFound =  ETrue;

   621 						break;

   622 					}

   623 			}

   625 		if(!presetFound)

   626 			User::Leave(KErrNotFound);

   627     }

   629 // -----------------------------------------------------------------------------

   630 // CAudioEqualizerUtility::CreatePresetL(TDesC& aName,CAudioEqualizer& aAudioEqualizer)

   631 // Applies the Preset to the Equalizer Object

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

   633 // -----------------------------------------------------------------------------

   634 //

   636 EXPORT_C void CAudioEqualizerUtility:: CreatePresetL(

   637     TDesC& aName,

   638     CAudioEqualizer& /*aAudioEqualizerUI*/)

   639     {

   640 #ifdef _DEBUG

   641 		    RDebug::Print(_L("CAudioEqualizerUtility::CreatePresetL"));

   642 #endif

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

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

   645 		// Central Repository

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

   650 		UpdateFullPresetArrayFromCenRep(iFullPresetArray);

   652 	//	iTransAudioEqualizer = &aAudioEqualizerUI;

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

   655 		TInt currentNumber = 0;

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

   657 		iPresetRepository->Get(KAudioEqUtilityNumberOfUserDefinedPresets,currentNumber);

   659 		HBufC8* presetHeap = HBufC8::NewL(iAudioEqualizer->NumberOfBands() * sizeof(TEfAudioEqualizerBand));

   660 		TPtr8 des = presetHeap->Des();

   661 		des.SetLength(presetHeap->Size());

   662 		des.Append(iTransAudioEqualizer->DoBandDataL(2,ETrue));

   664 				// Calculate and Create the Equalizer Data for the New Preset

   665 		iPresetRepository->Create(currentNumber*2+KAudioEqUtilityUserDefinedPresetStart,des);

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

   667 		iPresetRepository->Create(currentNumber*2+KAudioEqUtilityUserDefinedPresetStartName,aName);

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

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

   670 		currentNumber += 1;

   671 		iPresetRepository->Set(KAudioEqUtilityNumberOfUserDefinedPresets,currentNumber);

   672 		iPresetRepository->Get(KAudioEqUtilityPresetsCounter,currentNumber);

   673 		iPresetRepository->Set(KAudioEqUtilityPresetsCounter,currentNumber + 1);

   675 		// Refresh the iFullPresetArray

   676 		UpdateFullPresetArrayFromCenRep(iFullPresetArray);

   677 		delete presetHeap;

   678 		presetHeap = NULL;

   680     }

   682 // -----------------------------------------------------------------------------

   683 // CAudioEqualizerUtility::GetPresetL()

   684 // Gets the Preset from the Central Repository

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

   686 // -----------------------------------------------------------------------------

   687 //

   688 EXPORT_C const TDesC& CAudioEqualizerUtility::GetPresetL(

   689     TInt aPresetIndex)

   690     {

   691 #ifdef _DEBUG

   692 		    RDebug::Print(_L("CAudioEqualizerUtility::GetPresetL"));

   693 #endif

   694 		// Get the Preset from the Central Repository

   695 		// and Apply it to the Equalizer Object

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

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

   700 			User::Leave(KErrArgument);

   702 		TBuf8<256> aDescription;

   703 		TBufC8<256> aDes;

   704 		TBool presetFound = EFalse;

   706 		UpdateFullPresetArrayFromCenRep(iFullPresetArray);

   708 		// Write the Equalizer Data in the first available NULL Space

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

   710 			{

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

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

   713 					{

   714 						iPresetRepository->Get(iFullPresetArray[j].iPresetDescriptionKey,aDescription);

   715 						aDes = aDescription;

   717 						iTransAudioEqualizer->SetBandDataL(2,aDes); // The First Argument should be > 1 for getting all bands

   718 						presetFound = ETrue;

   719 						return iFullPresetArray[j].iPresetName;

   720 					}

   721 			}

   723 		if(!presetFound)

   724 			User::Leave(KErrNotFound);

   726 		return KNullDesC;

   728     }

   731 // -----------------------------------------------------------------------------

   732 // CAudioEqualizerUtility::DeletePresetL()

   733 // Deletes the Preset from the Central Repository

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

   735 // -----------------------------------------------------------------------------

   736 //

   737 EXPORT_C void CAudioEqualizerUtility::DeletePresetL(

   738     TInt aPresetIndex)

   739     {

   740 #ifdef _DEBUG

   741 		    RDebug::Print(_L("CAudioEqualizerUtility::DeletePresetL"));

   742 #endif

   743 		// Get the Name from the PresetIndex

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

   746 		TInt err(KErrNone);

   747 		TBool presetFound = EFalse;

   750         // Leave if it deletes a predefined preset

   751 		TInt currentNumberOfPredefinedPresets = 0;

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

   754 		iPresetRepository->Get(KAudioEqUtilityNumberOfPreDefinedPresets,currentNumberOfPredefinedPresets);

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

   757         {

   758 			User::Leave(KErrArgument);

   759         }

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

   762 			User::Leave(KErrArgument);

   764 		UpdateFullPresetArrayFromCenRep(iFullPresetArray);

   765 		UpdatePresetArray(iPresetArray,iFullPresetArray);

   767 #ifdef _DEBUG

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

   769 #endif

   771 		// Deletes the Preset from the iFullPresetArray and then

   772 		// rewrite it to the Central Repository

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

   774 			{

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

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

   778 					{

   779 						presetFound = ETrue;

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

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

   782 						if(err != KErrNone)

   783 							{

   784 								break;

   785 							}

   786 						else

   787 							{

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

   789 								iFullPresetArray[j].iPresetNameKey = 0;

   790 								iFullPresetArray[j].iPresetDescriptionKey = 0;

   791                                 break;

   793 							}

   795 					}

   796 #ifdef _DEBUG

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

   798 #endif

   799 			}

   801         // update the KAudioEqUtilityNumberOfUserDefinedPresets in CR

   802 		if(!presetFound)

   803 			User::Leave(KErrNotFound);

   805 		// After This Update the iPresetArray for the UI

   806 		UpdatePresetArray(iPresetArray,iFullPresetArray);

   807     }

   809 // -----------------------------------------------------------------------------

   810 // CAudioEqualizerUtility::DisablePresetL()

   811 // Disable the Preset

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

   813 // -----------------------------------------------------------------------------

   814 //

   816 EXPORT_C void CAudioEqualizerUtility::DisableEqualizerL()

   817 {

   818 #ifdef _DEBUG

   819 		    RDebug::Print(_L("CAudioEqualizerUtility::DisableEqualizerL"));

   820 #endif

   822 	if(iAudioEqualizer)

   823 	{

   824 		iAudioEqualizer->DisableL();

   825 	}

   826 }

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

   829 // CAudioEqualizerUtility::Equalizer()

   830 // Applies the Preset to the Equalizer Object

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

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

   833 //

   834 EXPORT_C CAudioEqualizer& CAudioEqualizerUtility::Equalizer()

   835     {

   836 #ifdef _DEBUG

   837 		    RDebug::Print(_L("CAudioEqualizerUtility::Equalizer()"));

   838 #endif

   840 		return *iTransAudioEqualizer;

   841     }

   843 // -----------------------------------------------------------------------------

   844 // CAudioEqualizerUtility::BassBoost()

   845 // Applies the Preset to the Equalizer Object

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

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

   848 //

   849 EXPORT_C CBassBoost& CAudioEqualizerUtility::BassBoost()

   850     {

   851 #ifdef _DEBUG

   852 		    RDebug::Print(_L("CAudioEqualizerUtility::BassBoost()"));

   853 #endif

   854 		return *iBassBoost;

   855     }

   858 // -----------------------------------------------------------------------------

   859 // CAudioEqualizerUtility::ModifyPresetL()

   860 // Applies the Preset to the Equalizer Object

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

   862 // -----------------------------------------------------------------------------

   863 //

   864 EXPORT_C void CAudioEqualizerUtility::ModifyPresetL(

   865     TInt aPresetIndex,

   866     TDesC& aName,

   867     CAudioEqualizer& aAudioEqualizerUI)

   868     {

   869 #ifdef _DEBUG

   870 		    RDebug::Print(_L("CAudioEqualizerUtility::ModifyPresetL"));

   871 #endif

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

   875 		// Modifies the Preset Data in the Central Repository

   876 		// with the updated Name and Equalizer Settings for the

   877 		// given PresetIndex

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

   880 			User::Leave(KErrArgument);

   882 		iTransAudioEqualizer = &aAudioEqualizerUI;

   884 		// Write the Equalizer Data in the first available NULL Space

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

   886 			{

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

   888 					{

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

   891 						HBufC8* presetHeap = HBufC8::NewL(iAudioEqualizer->NumberOfBands() * sizeof(TEfAudioEqualizerBand));

   892 						TPtr8 des = presetHeap->Des();

   893 						des.SetLength(presetHeap->Size());

   894 						des.Append(iTransAudioEqualizer->DoBandDataL(2,ETrue));

   896 						iPresetRepository->Set(iFullPresetArray[j].iPresetDescriptionKey,des);

   897 						delete presetHeap;

   898 						presetHeap = NULL;

   899 						break;

   900 					}

   901 			}

   902 		UpdateFullPresetArrayFromCenRep(iFullPresetArray);

   903     }

   906 // -----------------------------------------------------------------------------

   907 // CAudioEqualizerUtility::NumberOfPreDefinedPresets()

   908 // Applies the Preset to the Equalizer Object

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

   910 // -----------------------------------------------------------------------------

   911 //

   914 EXPORT_C TUint32 CAudioEqualizerUtility::NumberOfPreDefinedPresets() const

   915     {

   916 #ifdef _DEBUG

   917 		    RDebug::Print(_L("CAudioEqualizerUtility::NumberOfPreDefinedPresets"));

   918 #endif

   920 		TInt numberOfPresets;

   921 		iPresetRepository->Get(KAudioEqUtilityNumberOfPreDefinedPresets,numberOfPresets);

   922 		return numberOfPresets;

   923     }

   926 // -----------------------------------------------------------------------------

   927 // CAudioEqualizerUtility::Presets()

   928 // Applies the Preset to the Equalizer Object

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

   930 // -----------------------------------------------------------------------------

   931 //

   932 EXPORT_C TArray<TEfAudioEqualizerUtilityPreset> CAudioEqualizerUtility::Presets()

   933     {

   934 #ifdef _DEBUG

   935 		    RDebug::Print(_L("CAudioEqualizerUtility::Presets"));

   936 #endif

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

   939 		// User Defined Preset Array in the Central Repository

   940 		UpdateFullPresetArrayFromCenRep(iFullPresetArray);

   941 		UpdatePresetArray(iPresetArray,iFullPresetArray);

   942 		return iPresetArray.Array();

   943     }

   946 // -----------------------------------------------------------------------------

   947 // CAudioEqualizerUtility::ResetPresetL(TInt aPresetIndex)

   948 // Applies the Preset to the Equalizer Object

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

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

   951 //

   952 EXPORT_C void CAudioEqualizerUtility::ResetPresetL(TInt aPresetIndex)

   953     {

   954 #ifdef _DEBUG

   955 		    RDebug::Print(_L("CAudioEqualizerUtility::ResetPresetL"));

   956 #endif

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

   959 			User::Leave(KErrArgument);

   961 		TInt currentNumber = 0;

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

   963 		iPresetRepository->Get(KAudioEqUtilityNumberOfPreDefinedPresets,currentNumber);

   965 		if(aPresetIndex >= currentNumber)

   966 			User::Leave(KErrNotSupported);

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

   970 				{

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

   972 						{

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

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

   975 						}

   976 				}

   977 		UpdateFullPresetArrayFromCenRep(iFullPresetArray);

   978 		UpdatePresetArray(iPresetArray,iFullPresetArray);

   979 	}

   982 // -----------------------------------------------------------------------------

   983 // CAudioEqualizerUtility::UpdatePresetArrayFromCenRep(RArray<TEfAudioEqualizerUtilityPreset> &aFullPresetArray)

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

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

   986 // -----------------------------------------------------------------------------

   987 //

   989 void CAudioEqualizerUtility::UpdateFullPresetArrayFromCenRep(RArray<TEfAudioEqualizerUtilityPreset>& aFullPresetArray)

   990 	{

   992 		aFullPresetArray.Reset();

   993  		TEfAudioEqualizerUtilityPreset tempPreset;

   996 		TInt numberOfUserDefinedPresets = 0;

   997 		TInt numberOfPreDefinedPresets = 0;

   999 		iPresetRepository->Get(KAudioEqUtilityNumberOfUserDefinedPresets,numberOfUserDefinedPresets);

  1000 		iPresetRepository->Get(KAudioEqUtilityNumberOfPreDefinedPresets,numberOfPreDefinedPresets);

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

  1003 				{

  1004 					tempPreset.iPresetDescriptionKey = KAudioEqUtilityPreDefinedPresetStart + (2 * j);

  1005 					tempPreset.iPresetNameKey = KAudioEqUtilityPreDefinedPresetStartName + (2 * j);

  1006 					iPresetRepository->Get((KAudioEqUtilityPreDefinedPresetStartName + (2 * j)) ,tempPreset.iPresetName);

  1007 #ifdef _DEBUG

  1008 					RDebug::RawPrint(tempPreset.iPresetName);

  1009 #endif

  1010 					aFullPresetArray.Append(tempPreset);

  1012 				}

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

  1015 				{

  1016 					tempPreset.iPresetDescriptionKey = KAudioEqUtilityUserDefinedPresetStart + (2 * j);

  1017 					tempPreset.iPresetNameKey = KAudioEqUtilityUserDefinedPresetStartName + (2 * j);

  1018 					iPresetRepository->Get((KAudioEqUtilityUserDefinedPresetStartName + (2 * j)) ,tempPreset.iPresetName);

  1019 #ifdef _DEBUG

  1020 					RDebug::RawPrint(tempPreset.iPresetName);

  1021 #endif

  1022 					aFullPresetArray.Append(tempPreset);

  1024 				}

  1026 	}

  1028 // -----------------------------------------------------------------------------

  1029 // CAudioEqualizerUtility::UpdatePresetArray(RArray<TDesC>& aPresetArray,const RArray<TEfAudioEqualizerUtilityPreset> &aFullPresetArray)

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

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

  1032 // -----------------------------------------------------------------------------

  1033 //

  1034 void CAudioEqualizerUtility::UpdatePresetArray(RArray<TEfAudioEqualizerUtilityPreset>& aPresetArray,const RArray<TEfAudioEqualizerUtilityPreset>& aFullPresetArray)

  1035 	{

  1037 		aPresetArray.Reset();

  1038 		TEfAudioEqualizerUtilityPreset	tempClientArray;

  1040 		// Write the Equalizer Data in the first available NULL Space

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

  1042 			{

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

  1044 					{

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

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

  1049 						aPresetArray.Append(tempClientArray);

  1050 					}

  1051 #ifdef _DEBUG

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

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

  1054 #endif

  1055 			}

  1057 	}

  1060 // ========================== OTHER EXPORTED FUNCTIONS =========================

  1064 //  End of File

author	sl@SLION-WIN7.fritz.box
	Fri, 15 Jun 2012 03:10:57 +0200
changeset 0	bde4ae8d615e
permissions	-rw-r--r--