MercurialSymaptic / file revision
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | raw | help
os/mm/devsoundextensions/effects/DistAtten/DistanceAttenuationEffect/Src/DistanceAttenuationBase.cpp
author sl@SLION-WIN7.fritz.box
Fri, 15 Jun 2012 03:10:57 +0200
changeset 0 bde4ae8d615e
permissions -rw-r--r--
First public contribution. 
     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 DistanceAttenuation effect class

    15 *

    16 */

    17 

    18 

    19 

    20 

    21 // INCLUDE FILES

    22 

    23 #ifdef _DEBUG

    24 #include <e32svr.h>

    25 #endif

    26 

    27 #include <DistanceAttenuationBase.h>

    28 #include <CustomInterfaceUtility.h>

    29 #include "DistanceAttenuationProxy.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>

    36 

    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

    44 

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

    46 

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

    48 // CDistanceAttenuation::CDistanceAttenuation

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

    50 // might leave.

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

    52 //

    53 EXPORT_C CDistanceAttenuation::CDistanceAttenuation()

    54     : 	iDistanceAttenuationData(0, 0, EFalse, 0,0),

    55     	iDataPckgTo(iDistanceAttenuationData)

    56     {

    57     }

    58 

    59 // Destructor

    60 EXPORT_C CDistanceAttenuation::~CDistanceAttenuation()

    61     {

    62     }

    63 

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

    65 // CDistanceAttenuation::NewL

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

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

    68 //

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

    70 	{

    71 	    

    72     DEBPRN0;

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

    74     CleanupStack::PushL(customInterface);

    75 

    76 	CDistanceAttenuationProxy* distanceAttenuationProxy = (CDistanceAttenuationProxy*)customInterface->CustomInterface(KUidDistanceAttenuationEffect);

    77 

    78 	if ( !distanceAttenuationProxy )

    79 		{

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

    81 		User::Leave(KErrNotSupported);

    82 		}

    83 

    84 	CleanupStack::Pop(customInterface);

    85 

    86     return distanceAttenuationProxy;

    87 	}

    88 

    89 // -----------------------------------------------------------------------------

    90 // CDistanceAttenuation::NewL

    91 // Static function for creating an instance of the DistanceAttenuation object.

    92 // -----------------------------------------------------------------------------

    93 //

    94 EXPORT_C CDistanceAttenuation* CDistanceAttenuation::NewL(

    95 	CMdaAudioInputStream& aUtility )

    96 	{

    97 	    

    98     DEBPRN0;

    99     CDistanceAttenuationProxy* distanceAttenuationProxy = (CDistanceAttenuationProxy*)aUtility.CustomInterface(KUidDistanceAttenuationEffect);

   100 	

   101 	if (distanceAttenuationProxy == NULL)

   102 		{

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

   104     	User::Leave(KErrNotSupported);

   105 		}

   106 	    

   107     return distanceAttenuationProxy;

   108 	}

   109 

   110 // -----------------------------------------------------------------------------

   111 // CDistanceAttenuation::NewL

   112 // Static function for creating an instance of the DistanceAttenuation object.

   113 // -----------------------------------------------------------------------------

   114 //

   115 EXPORT_C CDistanceAttenuation* CDistanceAttenuation::NewL(

   116 	CMdaAudioOutputStream& aUtility)

   117 	{

   118 	    

   119     DEBPRN0;

   120     CDistanceAttenuationProxy* distanceAttenuationProxy = (CDistanceAttenuationProxy*)aUtility.CustomInterface(KUidDistanceAttenuationEffect);

   121 	

   122 	if (distanceAttenuationProxy == NULL)

   123 		{

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

   125     	User::Leave(KErrNotSupported);

   126 		}

   127 	    

   128     return distanceAttenuationProxy;	

   129     }

   130 

   131 // -----------------------------------------------------------------------------

   132 // CDistanceAttenuation::NewL

   133 // Static function for creating an instance of the DistanceAttenuation object.

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

   135 //

   136 EXPORT_C CDistanceAttenuation* CDistanceAttenuation::NewL(

   137 	CMdaAudioPlayerUtility& aUtility )

   138 	{

   139 	    

   140     DEBPRN0;

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

   142     CleanupStack::PushL(customInterface);

   143 

   144 	CDistanceAttenuationProxy* distanceAttenuationProxy = (CDistanceAttenuationProxy*)customInterface->CustomInterface(KUidDistanceAttenuationEffect);

   145 

   146 	if ( !distanceAttenuationProxy )

   147 		{

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

   149 		User::Leave(KErrNotSupported);

   150 		}

   151 

   152 	CleanupStack::Pop(customInterface);

   153 

   154     return distanceAttenuationProxy;

   155 	}

   156 

   157 // -----------------------------------------------------------------------------

   158 // CDistanceAttenuation::NewL

   159 // Static function for creating an instance of the DistanceAttenuation object.

   160 // -----------------------------------------------------------------------------

   161 //

   162 EXPORT_C CDistanceAttenuation* CDistanceAttenuation::NewL(

   163 	CMdaAudioRecorderUtility& aUtility,	TBool aRecordStream)

   164 	{

   165 	    

   166     DEBPRN0;

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

   168     CleanupStack::PushL(customInterface);

   169 

   170 	CDistanceAttenuationProxy* distanceAttenuationProxy = (CDistanceAttenuationProxy*)customInterface->CustomInterface(KUidDistanceAttenuationEffect);

   171 

   172 	if ( !distanceAttenuationProxy )

   173 		{

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

   175 		User::Leave(KErrNotSupported);

   176 		}

   177 

   178 	CleanupStack::Pop(customInterface);

   179 

   180     return distanceAttenuationProxy;

   181 	}

   182 

   183 // -----------------------------------------------------------------------------

   184 // CDistanceAttenuation::NewL

   185 // Static function for creating an instance of the DistanceAttenuation object.

   186 // -----------------------------------------------------------------------------

   187 //

   188 EXPORT_C CDistanceAttenuation* CDistanceAttenuation::NewL(

   189 	CMdaAudioToneUtility& aUtility)

   190 	{

   191 	

   192 	DEBPRN0;

   193     CDistanceAttenuationProxy* distanceAttenuationProxy = (CDistanceAttenuationProxy*)aUtility.CustomInterface(KUidDistanceAttenuationEffect);

   194 	

   195 	if (distanceAttenuationProxy == NULL)

   196 		{

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

   198     	User::Leave(KErrNotSupported);

   199 		}

   200 	    

   201     return distanceAttenuationProxy;

   202 	}

   203 

   204 

   205 // -----------------------------------------------------------------------------

   206 // CDistanceAttenuation::NewL

   207 // Static function for creating an instance of the DistanceAttenuation object.

   208 // -----------------------------------------------------------------------------

   209 //

   210 EXPORT_C CDistanceAttenuation* CDistanceAttenuation::NewL(

   211 	CMMFDevSound& aDevSound )

   212 	{

   213 	

   214 	DEBPRN0;

   215     CDistanceAttenuationProxy* distanceAttenuationProxy = (CDistanceAttenuationProxy*)aDevSound.CustomInterface(KUidDistanceAttenuationEffect);

   216 	

   217 	if (distanceAttenuationProxy == NULL)

   218 		{

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

   220     	User::Leave(KErrNotSupported);

   221 		}

   222 	    

   223     return distanceAttenuationProxy;

   224 	}

   225 

   226 

   227 

   228 // -----------------------------------------------------------------------------

   229 // CDistanceAttenuation::NewL

   230 // Static function for creating an instance of the DistanceAttenuation object.

   231 // -----------------------------------------------------------------------------

   232 //

   233 EXPORT_C CDistanceAttenuation* CDistanceAttenuation::NewL(

   234 	CCustomCommandUtility* aUtility)

   235 	{

   236     

   237     DEBPRN0;

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

   239     CleanupStack::PushL(customInterface);

   240 

   241 	CDistanceAttenuationProxy* distanceAttenuationProxy = (CDistanceAttenuationProxy*)customInterface->CustomInterface(KUidDistanceAttenuationEffect);

   242 

   243 	if ( !distanceAttenuationProxy )

   244 		{

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

   246 		User::Leave(KErrNotSupported);

   247 		}

   248 

   249 	CleanupStack::Pop(customInterface);

   250 

   251     return distanceAttenuationProxy;

   252 	}

   253 

   254 // -----------------------------------------------------------------------------

   255 // CDistanceAttenuation::NewL

   256 // Static function for creating an instance of the DistanceAttenuation object.

   257 // -----------------------------------------------------------------------------

   258 //

   259 EXPORT_C CDistanceAttenuation* CDistanceAttenuation::NewL(

   260 	MCustomInterface& aCustomInterface )

   261 	{

   262 	    

   263     DEBPRN0;

   264 	CDistanceAttenuationProxy* distanceAttenuationProxy = (CDistanceAttenuationProxy*)aCustomInterface.CustomInterface(KUidDistanceAttenuationEffect);

   265 

   266 	if ( !distanceAttenuationProxy )

   267 		{

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

   269 		User::Leave(KErrNotSupported);

   270 		}

   271 

   272     return distanceAttenuationProxy;

   273 	}

   274 	

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

   276 // CDistanceAttenuation::NewL

   277 // Static function for creating an instance of the DistanceAttenuation object.

   278 // -----------------------------------------------------------------------------

   279 //

   280 EXPORT_C CDistanceAttenuation* CDistanceAttenuation::NewL( 

   281 	CMidiClientUtility& aUtility )

   282 	{

   283 	    

   284     DEBPRN0;

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

   286     CleanupStack::PushL(customInterface);

   287 

   288 	CDistanceAttenuationProxy* distanceAttenuationProxy = (CDistanceAttenuationProxy*)customInterface->CustomInterface(KUidDistanceAttenuationEffect);

   289 

   290 	if ( !distanceAttenuationProxy )

   291 		{

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

   293 		User::Leave(KErrNotSupported);

   294 		}

   295 

   296 	CleanupStack::Pop(customInterface);

   297 

   298     return distanceAttenuationProxy;

   299 	}

   300 

   301 // -----------------------------------------------------------------------------

   302 // CDistanceAttenuation::NewL

   303 // Static function for creating an instance of the DistanceAttenuation object.

   304 // -----------------------------------------------------------------------------

   305 //

   306 EXPORT_C CDistanceAttenuation* CDistanceAttenuation::NewL( 

   307 	CDrmPlayerUtility& aUtility )

   308 	{

   309 

   310     DEBPRN0;

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

   312     CleanupStack::PushL(customInterface);

   313 

   314 	CDistanceAttenuationProxy* distanceAttenuationProxy = (CDistanceAttenuationProxy*)customInterface->CustomInterface(KUidDistanceAttenuationEffect);

   315 

   316 	if ( !distanceAttenuationProxy )

   317 		{

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

   319 		User::Leave(KErrNotSupported);

   320 		}

   321 

   322 	CleanupStack::Pop(customInterface);

   323 

   324     return distanceAttenuationProxy;

   325 	}

   326 

   327 // -----------------------------------------------------------------------------

   328 // CDistanceAttenuation::NewL

   329 // Static function for creating an instance of the DistanceAttenuation object.

   330 // -----------------------------------------------------------------------------

   331 //

   332 EXPORT_C CDistanceAttenuation* CDistanceAttenuation::NewL( 

   333 	CVideoPlayerUtility& aUtility )

   334 	{

   335 

   336     DEBPRN0;

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

   338     CleanupStack::PushL(customInterface);

   339 

   340 	CDistanceAttenuationProxy* distanceAttenuationProxy = (CDistanceAttenuationProxy*)customInterface->CustomInterface(KUidDistanceAttenuationEffect);

   341 

   342 	if ( !distanceAttenuationProxy )

   343 		{

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

   345 		User::Leave(KErrNotSupported);

   346 		}

   347 

   348 	CleanupStack::Pop(customInterface);

   349 

   350     return distanceAttenuationProxy;

   351 	}

   352 

   353 // -----------------------------------------------------------------------------

   354 // CDistanceAttenuation::DistanceAttenuation

   355 // -----------------------------------------------------------------------------

   356 //

   357 

   358 EXPORT_C void CDistanceAttenuation::DistanceAttenuation(

   359 	TInt32& aRMin, TInt32& aRMax, TBool& aMuteAfterMax,

   360 	TUint32& aRollOffFactor, TUint32& aRoomRollOffFactor)

   361 	{

   362 

   363         DEBPRN0;

   364 		aRMin = iDistanceAttenuationData.iRMin;

   365 		aRMax = iDistanceAttenuationData.iRMax;

   366 		aMuteAfterMax = iDistanceAttenuationData.iMuteAfterMax;

   367 		aRollOffFactor = iDistanceAttenuationData.iRollOffFactor;

   368 		aRoomRollOffFactor = iDistanceAttenuationData.iRoomRollOffFactor;

   369 	}

   370 

   371 

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

   373 // CDistanceAttenuation::RollOffFactorMax

   374 // -----------------------------------------------------------------------------

   375 //

   376 EXPORT_C void CDistanceAttenuation::RollOffFactorMax(TUint32& aRollOfFactorMax)

   377 	{

   378 		aRollOfFactorMax = iDistanceAttenuationData.iRollOffFactorMax;

   379 	}

   380 

   381 // -----------------------------------------------------------------------------

   382 // CDistanceAttenuation::RoomRollOffFactorMax

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

   384 //

   385 EXPORT_C void CDistanceAttenuation::RoomRollOffFactorMax( TUint32& aRoomRollOfFactorMax )

   386 	{

   387 		aRoomRollOfFactorMax = iDistanceAttenuationData.iRoomRollOffFactorMax;

   388 	}

   389 

   390 

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

   392 // CDistanceAttenuation::SetDistanceAttenuationL

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

   394 //

   395 

   396 EXPORT_C void CDistanceAttenuation::SetDistanceAttenuationL(

   397 	TInt32 aRMin, TInt32 aRMax, TBool aMuteAfterMax,

   398 	TUint32 aRollOffFactor, TUint32 aRoomRollOffFactor )

   399 	{

   400 	    

   401         DEBPRN0;

   402 		iDistanceAttenuationData.iRMin = aRMin;

   403 		iDistanceAttenuationData.iRMax = aRMax;

   404 		iDistanceAttenuationData.iMuteAfterMax = aMuteAfterMax;

   405 

   406 		if(aRollOffFactor <= iDistanceAttenuationData.iRollOffFactorMax)

   407 			iDistanceAttenuationData.iRollOffFactor = aRollOffFactor;

   408 		else

   409 			User::Leave(KErrArgument);

   410 

   411 		if(aRoomRollOffFactor <= iDistanceAttenuationData.iRoomRollOffFactorMax)

   412 			iDistanceAttenuationData.iRoomRollOffFactor = aRoomRollOffFactor;

   413 		else

   414 			User::Leave(KErrArgument);

   415 

   416 	}

   417 

   418 

   419 // -----------------------------------------------------------------------------

   420 // CDistanceAttenuation::Uid

   421 // -----------------------------------------------------------------------------

   422 //

   423 EXPORT_C TUid CDistanceAttenuation::Uid() const

   424 	{

   425 	return KUidDistanceAttenuationEffect;

   426 	}

   427 

   428 

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

   430 // CDistanceAttenuation::DoEffectData

   431 // -----------------------------------------------------------------------------

   432 //

   433 EXPORT_C const TDesC8& CDistanceAttenuation::DoEffectData()

   434 	{

   435 	    

   436     DEBPRN0;

   437 	iDataPckgTo = iDistanceAttenuationData;

   438 	return iDataPckgTo;

   439 	}

   440 

   441 // -----------------------------------------------------------------------------

   442 // CDistanceAttenuation::SetEffectData

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

   444 //

   445 EXPORT_C void CDistanceAttenuation::SetEffectData(

   446 	const TDesC8& aEffectDataBuffer )

   447 	{

   448 	    

   449     DEBPRN0;

   450 	TEfDistanceAttenuationDataPckg dataPckg;

   451 	dataPckg.Copy(aEffectDataBuffer);

   452 	iDistanceAttenuationData = dataPckg();

   453 	iEnabled = iDistanceAttenuationData.iEnabled;

   454 	iEnforced = iDistanceAttenuationData.iEnforced;

   455 	iHaveUpdateRights = iDistanceAttenuationData.iHaveUpdateRights;

   456 	}

   457 

   458 

   459 // ========================== OTHER EXPORTED FUNCTIONS =========================

   460
Symaptic