Symaptic: os/mm/devsoundextensions/effects/Loudness/LoudnessEffect/Src/LoudnessBase.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:   Implementation of the Loudness effect class

    15 *

    16 */

    21 // INCLUDE FILES

    23 #ifdef _DEBUG

    24 #include <e32svr.h>

    25 #endif

    27 #include <LoudnessBase.h>

    28 #include <CustomInterfaceUtility.h>

    29 #include "LoudnessProxy.h"

    30 #include <DrmAudioSamplePlayer.h>

    31 #include <mdaaudioinputstream.h>

    32 #include <mdaaudiooutputstream.h>

    33 #include <mdaaudiotoneplayer.h>

    34 #include <mmf/server/sounddevice.h>

    35 #include <videoplayer.h>

    37 #ifdef _DEBUG

    38 #define DEBPRN0         RDebug::Printf( "%s", __PRETTY_FUNCTION__);

    39 #define DEBPRN1(str)    RDebug::Printf( "%s %s", __PRETTY_FUNCTION__, str );

    40 #else

    41 #define DEBPRN0

    42 #define DEBPRN1(str)

    43 #endif

    45 // ============================ MEMBER FUNCTIONS ===============================

    47 // -----------------------------------------------------------------------------

    48 // CLoudness::CLoudness

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

    50 // might leave.

    51 // -----------------------------------------------------------------------------

    52 //

    53 EXPORT_C CLoudness::CLoudness()

    54     : 	iLoudnessData(),

    55     	iDataPckgTo(iLoudnessData)

    56     {

    57     }

    59 // Destructor

    60 EXPORT_C CLoudness::~CLoudness()

    61     {

    62     }

    64 // -----------------------------------------------------------------------------

    65 // CLoudness::NewL

    66 // Static function for creating an instance of the Loudness object.

    67 // -----------------------------------------------------------------------------

    68 //

    69 EXPORT_C CLoudness* CLoudness::NewL(CMdaAudioConvertUtility& aUtility)

    70 	{

    72     DEBPRN0;

    73    	CCustomInterfaceUtility* customInterface = CCustomInterfaceUtility::NewL(aUtility);

    74     CleanupStack::PushL(customInterface);

    76 	CLoudnessProxy* loudnessProxy = (CLoudnessProxy*)customInterface->CustomInterface(KUidLoudnessEffect);

    78 	if ( !loudnessProxy )

    79 		{

    80 		DEBPRN1("No Adaptation Support - leaving");

    81 		CleanupStack::Pop(customInterface);

    82 		User::Leave(KErrNotSupported);

    83 		}

    85 	CleanupStack::Pop(customInterface);

    87     return loudnessProxy;

    88 	}

    90 // -----------------------------------------------------------------------------

    91 // CLoudness::NewL

    92 // Static function for creating an instance of the Loudness object.

    93 // -----------------------------------------------------------------------------

    94 //

    95 EXPORT_C CLoudness* CLoudness::NewL(

    96 	CMdaAudioInputStream& aUtility , TBool aEnable )

    97 	{

    99     DEBPRN0;

   100     CLoudnessProxy* loudnessProxy = (CLoudnessProxy*)aUtility.CustomInterface(KUidLoudnessEffect);

   102 	if (loudnessProxy == NULL)

   103 		{

   104         DEBPRN1("No Adaptation Support - leaving");

   105     	User::Leave(KErrNotSupported);

   106 		}

   108 	if(aEnable)

   109 	    {

   110 		loudnessProxy->EnableL();

   111 	    }

   113     return loudnessProxy;

   114 	}

   116 // -----------------------------------------------------------------------------

   117 // CLoudness::NewL

   118 // Static function for creating an instance of the Loudness object.

   119 // -----------------------------------------------------------------------------

   120 //

   121 EXPORT_C CLoudness* CLoudness::NewL(

   122 	CMdaAudioOutputStream& aUtility, TBool aEnable )

   123 	{

   125     DEBPRN0;

   126     CLoudnessProxy* loudnessProxy = (CLoudnessProxy*)aUtility.CustomInterface(KUidLoudnessEffect);

   128 	if (loudnessProxy == NULL)

   129 		{

   130         DEBPRN1("No Adaptation Support - leaving");

   131     	User::Leave(KErrNotSupported);

   132 		}

   134 	if(aEnable)

   135 	    {

   136 		loudnessProxy->EnableL();

   137 	    }

   139     return loudnessProxy;

   140 	}

   142 // -----------------------------------------------------------------------------

   143 // CLoudness::NewL

   144 // Static function for creating an instance of the Loudness object.

   145 // -----------------------------------------------------------------------------

   146 //

   147 EXPORT_C CLoudness* CLoudness::NewL(

   148 	CMdaAudioPlayerUtility& aUtility , TBool aEnable)

   149 	{

   151     DEBPRN0;

   152    	CCustomInterfaceUtility* customInterface = CCustomInterfaceUtility::NewL(aUtility);

   153     CleanupStack::PushL(customInterface);

   155 	CLoudnessProxy* loudnessProxy = (CLoudnessProxy*)customInterface->CustomInterface(KUidLoudnessEffect);

   157 	if ( !loudnessProxy )

   158 		{

   159 		DEBPRN1("No Adaptation Support - leaving");

   160 		CleanupStack::Pop(customInterface);

   161 		User::Leave(KErrNotSupported);

   162 		}

   164 	CleanupStack::Pop(customInterface);

   166 	if(aEnable)

   167         {

   168 		loudnessProxy->EnableL();

   169 	    }

   171     return loudnessProxy;

   172 	}

   174 // -----------------------------------------------------------------------------

   175 // CLoudness::NewL

   176 // Static function for creating an instance of the Loudness object.

   177 // -----------------------------------------------------------------------------

   178 //

   179 EXPORT_C CLoudness* CLoudness::NewL(

   180 	CMdaAudioRecorderUtility& aUtility,	TBool aRecordStream, TBool aEnable)

   181 	{

   183     DEBPRN0;

   184    	CCustomInterfaceUtility* customInterface = CCustomInterfaceUtility::NewL(aUtility, aRecordStream);

   185     CleanupStack::PushL(customInterface);

   187 	CLoudnessProxy* loudnessProxy = (CLoudnessProxy*)customInterface->CustomInterface(KUidLoudnessEffect);

   189 	if ( !loudnessProxy )

   190 		{

   191 		DEBPRN1("No Adaptation Support - leaving");

   192 		CleanupStack::Pop(customInterface);

   193 		User::Leave(KErrNotSupported);

   194 		}

   196 	CleanupStack::Pop(customInterface);

   198 	if(aEnable)

   199 	{

   200 		loudnessProxy->EnableL();

   201 	}

   203     return loudnessProxy;

   204 	}

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

   207 // CLoudness::NewL

   208 // Static function for creating an instance of the Loudness object.

   209 // -----------------------------------------------------------------------------

   210 //

   211 EXPORT_C CLoudness* CLoudness::NewL(

   212 	CMdaAudioToneUtility& aUtility, TBool aEnable )

   213 	{

   215 	DEBPRN0;

   216     CLoudnessProxy* loudnessProxy = (CLoudnessProxy*)aUtility.CustomInterface(KUidLoudnessEffect);

   218 	if (loudnessProxy == NULL)

   219 		{

   220         DEBPRN1("No Adaptation Support - leaving");

   221     	User::Leave(KErrNotSupported);

   222 		}

   224 	if(aEnable)

   225 	    {

   226 		loudnessProxy->EnableL();

   227 	    }

   229     return loudnessProxy;

   230 	}

   233 // -----------------------------------------------------------------------------

   234 // CLoudness::NewL

   235 // Static function for creating an instance of the Loudness object.

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

   237 //

   238 EXPORT_C CLoudness* CLoudness::NewL(

   239 	CMMFDevSound& aDevSound , TBool aEnable )

   240 	{

   242 	DEBPRN0;

   243     CLoudnessProxy* loudnessProxy = (CLoudnessProxy*)aDevSound.CustomInterface(KUidLoudnessEffect);

   245 	if (loudnessProxy == NULL)

   246 		{

   247         DEBPRN1("No Adaptation Support - leaving");

   248     	User::Leave(KErrNotSupported);

   249 		}

   251 	if(aEnable)

   252 	    {

   253 		loudnessProxy->EnableL();

   254 	    }

   256     return loudnessProxy;

   257 	}

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

   262 // CLoudness::NewL

   263 // Static function for creating an instance of the Loudness object.

   264 // -----------------------------------------------------------------------------

   265 //

   266 EXPORT_C CLoudness* CLoudness::NewL(

   267 	CCustomCommandUtility* aUtility , TBool aEnable)

   268 	{

   270     DEBPRN0;

   271    	CCustomInterfaceUtility* customInterface = CCustomInterfaceUtility::NewL(aUtility);

   272     CleanupStack::PushL(customInterface);

   274 	CLoudnessProxy* loudnessProxy = (CLoudnessProxy*)customInterface->CustomInterface(KUidLoudnessEffect);

   276 	if ( !loudnessProxy )

   277 		{

   278 		DEBPRN1("No Adaptation Support - leaving");

   279 		CleanupStack::Pop(customInterface);

   280 		User::Leave(KErrNotSupported);

   281 		}

   283 	CleanupStack::Pop(customInterface);

   285 	if(aEnable)

   286 	    {

   287 		loudnessProxy->EnableL();

   288 	    }

   290     return loudnessProxy;

   291 	}

   293 // -----------------------------------------------------------------------------

   294 // CLoudness::NewL

   295 // Static function for creating an instance of the Loudness object.

   296 // -----------------------------------------------------------------------------

   297 //

   298 EXPORT_C CLoudness* CLoudness::NewL(

   299 	MCustomInterface& aCustomInterface , TBool aEnable)

   300 	{

   302     DEBPRN0;

   303 	CLoudnessProxy* loudnessProxy = (CLoudnessProxy*)aCustomInterface.CustomInterface(KUidLoudnessEffect);

   305 	if ( !loudnessProxy )

   306 		{

   307 		DEBPRN1("No Adaptation Support - leaving");

   308 		User::Leave(KErrNotSupported);

   309 		}

   311 	if(aEnable)

   312 	    {

   313 		loudnessProxy->EnableL();

   314 	    }

   316     return loudnessProxy;

   317 	}

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

   320 // CLoudness::NewL

   321 // Static function for creating an instance of the Loudness object.

   322 // -----------------------------------------------------------------------------

   323 //

   324 EXPORT_C CLoudness* CLoudness::NewL(

   325     CMidiClientUtility& aUtility , TBool aEnable)

   326 	{

   328     DEBPRN0;

   329    	CCustomInterfaceUtility* customInterface = CCustomInterfaceUtility::NewL(aUtility);

   330     CleanupStack::PushL(customInterface);

   332 	CLoudnessProxy* loudnessProxy = (CLoudnessProxy*)customInterface->CustomInterface(KUidLoudnessEffect);

   334 	if ( !loudnessProxy )

   335 		{

   336 		DEBPRN1("No Adaptation Support - leaving");

   337 		CleanupStack::Pop(customInterface);

   338 		User::Leave(KErrNotSupported);

   339 		}

   341 	CleanupStack::Pop(customInterface);

   343 	if(aEnable)

   344     	{

   345 		loudnessProxy->EnableL();

   346 	    }

   348     return loudnessProxy;

   349 	}

   351 // -----------------------------------------------------------------------------

   352 // CLoudness::NewL

   353 // Static function for creating an instance of the Loudness object.

   354 // -----------------------------------------------------------------------------

   355 //

   356 EXPORT_C CLoudness* CLoudness::NewL(

   357     CDrmPlayerUtility& aUtility, TBool aEnable)

   358 	{

   360     DEBPRN0;

   361    	CCustomInterfaceUtility* customInterface = CCustomInterfaceUtility::NewL(aUtility);

   362     CleanupStack::PushL(customInterface);

   364 	CLoudnessProxy* loudnessProxy = (CLoudnessProxy*)customInterface->CustomInterface(KUidLoudnessEffect);

   366 	if ( !loudnessProxy )

   367 		{

   368 		DEBPRN1("No Adaptation Support - leaving");

   369 		CleanupStack::Pop(customInterface);

   370 		User::Leave(KErrNotSupported);

   371 		}

   373 	CleanupStack::Pop(customInterface);

   375 	if(aEnable)

   376 	    {

   377 		loudnessProxy->EnableL();

   378 	    }

   380     return loudnessProxy;

   381 	}

   383 // -----------------------------------------------------------------------------

   384 // CLoudness::NewL

   385 // Static function for creating an instance of the Loudness object.

   386 // -----------------------------------------------------------------------------

   387 //

   388 EXPORT_C CLoudness* CLoudness::NewL(

   389     CVideoPlayerUtility& aUtility, TBool aEnable)

   390 	{

   392     DEBPRN0;

   393    	CCustomInterfaceUtility* customInterface = CCustomInterfaceUtility::NewL(aUtility);

   394     CleanupStack::PushL(customInterface);

   396 	CLoudnessProxy* loudnessProxy = (CLoudnessProxy*)customInterface->CustomInterface(KUidLoudnessEffect);

   398 	if ( !loudnessProxy )

   399 		{

   400 		DEBPRN1("No Adaptation Support - leaving");

   401 		CleanupStack::Pop(customInterface);

   402 		User::Leave(KErrNotSupported);

   403 		}

   405 	CleanupStack::Pop(customInterface);

   407 	if(aEnable)

   408 	    {

   409 		loudnessProxy->EnableL();

   410 	    }

   412     return loudnessProxy;

   413 	}

   415 // -----------------------------------------------------------------------------

   416 // CLoudness::Uid

   417 // -----------------------------------------------------------------------------

   418 //

   419 EXPORT_C TUid CLoudness::Uid() const

   420 	{

   421 	return KUidLoudnessEffect;

   422 	}

   425 // -----------------------------------------------------------------------------

   426 // CLoudness::DoEffectData

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

   428 //

   429 EXPORT_C const TDesC8& CLoudness::DoEffectData()

   430 	{

   431     DEBPRN0;

   432 	iDataPckgTo = iLoudnessData;

   433 	return iDataPckgTo;

   434 	}

   436 // -----------------------------------------------------------------------------

   437 // CLoudness::SetEffectData

   438 // -----------------------------------------------------------------------------

   439 //

   440 EXPORT_C void CLoudness::SetEffectData(

   441 	const TDesC8& aEffectDataBuffer )

   442 	{

   443     DEBPRN0;

   444 	TEfLoudnessDataPckg dataPckg;

   445 	dataPckg.Copy(aEffectDataBuffer);

   446 	iLoudnessData = dataPckg();

   447 	iEnabled = iLoudnessData.iEnabled;

   448 	iEnforced = iLoudnessData.iEnforced;

   449 	iHaveUpdateRights = iLoudnessData.iHaveUpdateRights;

   451 	}

   454 // ========================== OTHER EXPORTED FUNCTIONS =========================

   456 // End of File

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