MercurialSymaptic / file revision
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | raw | help
os/mm/mmhais/a3facl/src/audiocodec/logicalaudiocodec.cpp
author sl
Tue, 10 Jun 2014 14:32:02 +0200
changeset 1 260cb5ec6c19
permissions -rw-r--r--
Update contrib. 
     1 // Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 //

    15 

    16 

    17 

    18 #include "logicalaudiocodec.h"

    19 #include <a3f/audioprocessingunittypeuids.h>

    20 

    21 #include <ecom/implementationproxy.h> // For making it ECom plugin

    22 // Map the interface implementation UIDs to implementation factory functions

    23 const TImplementationProxy ImplementationTable[] =

    24 	{

    25 	IMPLEMENTATION_PROXY_ENTRY(KAudioDecoderUid,  CLogicalAudioCodec::NewL),

    26 	IMPLEMENTATION_PROXY_ENTRY(KAudioEncoderUid,  CLogicalAudioCodec::NewL),

    27 	};

    28 

    29 // Exported proxy for instantiation method resolution.

    30 EXPORT_C const TImplementationProxy* ImplementationGroupProxy(TInt& aTableCount)

    31 	{

    32 	aTableCount = sizeof(ImplementationTable) / sizeof(TImplementationProxy);

    33 	return ImplementationTable;

    34 	}

    35 

    36 // ---------------------------------------------------------------------------

    37 // Constructor

    38 // ---------------------------------------------------------------------------

    39 CLogicalAudioCodec* CLogicalAudioCodec::NewL(TAny* aParam)

    40 	{

    41 	DP_STATIC_CONTEXT(CLogicalAudioCodec::NewL *CD0*, CtxDevSound, DPLOCAL);

    42 	DP_IN();

    43 	CLogicalAudioCodec* self = new(ELeave)CLogicalAudioCodec(aParam);

    44 	CleanupStack::PushL(self);

    45 	self->ConstructL();

    46 	CleanupStack::Pop(self);

    47 	DP0_RET(self, "0x%x");

    48 	}

    49 

    50 // ---------------------------------------------------------------------------

    51 // Constructor

    52 // ---------------------------------------------------------------------------

    53 

    54 CLogicalAudioCodec::CLogicalAudioCodec(TAny* aParam) : CAudioProcessingUnit(aParam)

    55 	{

    56 	TRACE_CREATE();

    57 	DP_CONTEXT(CLogicalAudioCodec::CLogicalAudioCodec *CD1*, CtxDevSound, DPLOCAL);

    58 	DP_IN();

    59 	if(iSettingsObserver)

    60 		{

    61 		iSettingsObserver->ReceiveComponentSettingsChange(iType, ERegisterCodecObserver);

    62 		}

    63 	DP_OUT();

    64 	}

    65 

    66 // ---------------------------------------------------------------------------

    67 // Second phase constructor

    68 // ---------------------------------------------------------------------------

    69 void CLogicalAudioCodec::ConstructL()

    70 	{

    71 	DP_CONTEXT(CLogicalAudioCodec::ConstructL *CD1*, CtxDevSound, DPLOCAL);

    72 	DP_IN();

    73 	DP_OUT();

    74 	}

    75 

    76 // ---------------------------------------------------------------------------

    77 // Destructor

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

    79 CLogicalAudioCodec::~CLogicalAudioCodec()

    80 	{

    81 	DP_CONTEXT(CLogicalAudioCodec::~CLogicalAudioCodec *CD1*, CtxDevSound, DPLOCAL);

    82 	DP_IN();

    83 	iAudioCodecObserver.Close();

    84 	DP_OUT();

    85 	}

    86 

    87 // ---------------------------------------------------------------------------

    88 // from class MAudioCodec

    89 // CLogicalAudioCodec::SetFormat

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

    91 TInt CLogicalAudioCodec::SetFormat(TUid aFormat)

    92 	{

    93 	DP_CONTEXT(CLogicalAudioCodec::SetFormat *CD1*, CtxDevSound, DPLOCAL);

    94 	DP_IN();

    95 	iFormat = aFormat;

    96 	if(iSettingsObserver)

    97 		{

    98 		iSettingsObserver->ReceiveComponentSettingsChange(iType, EComponentAlterationCodec);

    99 		}

   100 	DP0_RET(KErrNone, "%d");

   101 	}

   102 

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

   104 // from class MAudioCodec

   105 // CLogicalAudioCodec::SetSampleRate

   106 // ---------------------------------------------------------------------------

   107 TInt CLogicalAudioCodec::SetSampleRate(TInt aSampleRate)

   108 	{

   109 	DP_CONTEXT(CLogicalAudioCodec::SetSampleRate *CD1*, CtxDevSound, DPLOCAL);

   110 	DP_IN();

   111 	iSampleRateConfig = aSampleRate;

   112 	if(iSettingsObserver)

   113 		{

   114 		iSettingsObserver->ReceiveComponentSettingsChange(iType, EComponentAlterationCodec);

   115 		}

   116 	DP0_RET(KErrNone, "%d");

   117 	}

   118 

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

   120 // from class MAudioCodec

   121 // CLogicalAudioCodec::SetMode

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

   123 TInt CLogicalAudioCodec::SetMode(TUid aMode)

   124 	{

   125 	DP_CONTEXT(CLogicalAudioCodec::SetMode *CD1*, CtxDevSound, DPLOCAL);

   126 	DP_IN();

   127 	iModeConfig = aMode;

   128 	if(iSettingsObserver)

   129 		{

   130 		iSettingsObserver->ReceiveComponentSettingsChange(iType, EComponentAlterationCodec);

   131 		}

   132 	DP0_RET(KErrNone, "%d");

   133 	}

   134 

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

   136 // from class MAudioCodec

   137 // CLogicalAudioCodec::GetSupportedSamplesRates

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

   139 TInt CLogicalAudioCodec::GetSupportedSamplesRates(RArray<TInt>& aSupportedRates)

   140 	{

   141 	DP_CONTEXT(CLogicalAudioCodec::GetSupportedSamplesRates *CD1*, CtxDevSound, DPLOCAL);

   142 	DP_IN();

   143 	TInt err(KErrNone);

   144 	if(iAdaptationStream)

   145 		{

   146 		err = iAdaptationStream->GetSupportedSampleRates(aSupportedRates);

   147 		}

   148 	else

   149 		{

   150 		err = KErrNotFound;

   151 		}

   152 	DP0_RET(err, "%d");

   153 	}

   154 

   155 // ---------------------------------------------------------------------------

   156 // from class MAudioCodec

   157 // CLogicalAudioCodec::GetSupportedMode

   158 // ---------------------------------------------------------------------------

   159 TInt CLogicalAudioCodec::GetSupportedModes(RArray<TUid>& aSupportedModes)

   160 	{

   161 	DP_CONTEXT(CLogicalAudioCodec::GetSupportedModes *CD1*, CtxDevSound, DPLOCAL);

   162 	DP_IN();

   163 	TInt err(KErrNone);

   164 	if(iAdaptationStream)

   165 		{

   166 		err = iAdaptationStream->GetSupportedModes(aSupportedModes);

   167 		}

   168 	else

   169 		{

   170 		err = KErrNotFound;

   171 		}

   172 	DP0_RET(err, "%d");

   173 	}

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

   175 // from class MAudioProcessingUnit

   176 // CLogicalAudioCodec::IsTypeOf

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

   178 TBool CLogicalAudioCodec::IsTypeOf(TUid aTypeId) const

   179 	{

   180 	DP_CONTEXT(CLogicalAudioCodec::IsTypeOf *CD1*, CtxDevSound, DPLOCAL);

   181 	DP_IN();

   182 	TBool result = EFalse;

   183 	if ( iType == aTypeId || aTypeId == KUidAudioCodec)

   184 		{

   185 		result = ETrue;

   186 		}

   187 	DP0_RET(result, "%d");

   188 	}

   189 

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

   191 // from class MAudioProcessingUnit

   192 // CLogicalAudioCodec::Interface

   193 // ---------------------------------------------------------------------------

   194 //

   195 TAny* CLogicalAudioCodec::Interface(TUid aType)

   196 	{

   197 	DP_CONTEXT(CLogicalAudioCodec::Interface *CD1*, CtxDevSound, DPLOCAL);

   198 	DP_IN();

   199 	

   200 	TAny* interface = NULL;

   201 	if (aType == KUidAudioCodec)

   202 		{

   203 		interface = static_cast<MAudioCodec*>(this);

   204 		}

   205 	else if (aType == KUidAudioCodecAdaptationObserver)

   206 		{

   207 		interface = static_cast<MAudioCodecAdaptationObserver*>(this);

   208 		}

   209 	DP0_RET(interface, "0x%08x");

   210 	}

   211 

   212 // ---------------------------------------------------------------------------

   213 // from class MAudioCodecAdaptationObserver

   214 // CLogicalAudioCodec::AllBuffersProcessed

   215 // ---------------------------------------------------------------------------

   216 void CLogicalAudioCodec::AllBuffersProcessed()

   217 	{

   218 	DP_CONTEXT(CLogicalAudioCodec::AllBuffersProcessed *CD1*, CtxDevSound, DPLOCAL);

   219 	DP_IN();

   220 	DP_OUT();

   221 	}

   222 

   223 // ---------------------------------------------------------------------------

   224 // from class MAudioCodecAdaptationObserver

   225 // CLogicalAudioCodec::GetSupportedConfigurationComplete

   226 // ---------------------------------------------------------------------------

   227 void CLogicalAudioCodec::GetSupportedAModesComplete(TInt aError)

   228 	{

   229 	DP_CONTEXT(CLogicalAudioCodec::GetSupportedModesComplete *CD1*, CtxDevSound, DPLOCAL);

   230 	DP_IN();

   231 	TUint count = iAudioCodecObserver.Count();

   232 	for ( TUint idx(0); idx < count; idx++ )

   233 		{

   234 		iAudioCodecObserver[idx]->GetSupportedModesComplete(aError);

   235 		}

   236 	DP_OUT();

   237 	}

   238 	

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

   240 // from class MAudioCodecAdaptationObserver

   241 // CLogicalAudioCodec::GetSupportedConfigurationComplete

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

   243 void CLogicalAudioCodec::GetSupportedARatesComplete(TInt aError)

   244 	{

   245 	DP_CONTEXT(CLogicalAudioCodec::GetSupportedRatesComplete *CD1*, CtxDevSound, DPLOCAL);

   246 	DP_IN();

   247 	TUint count = iAudioCodecObserver.Count();

   248 	for ( TUint idx(0); idx < count; idx++ )

   249 		{

   250 		iAudioCodecObserver[idx]->GetSupportedSampleRatesComplete(aError);

   251 		}

   252 	DP_OUT();

   253 	}

   254 

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

   256 // from class MAudioCodecAdaptationObserver

   257 // CLogicalAudioCodec::ProcessingUnitError

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

   259 void CLogicalAudioCodec::ProcessingUnitError(TInt aError)

   260 	{

   261 	DP_CONTEXT(CLogicalAudioCodec::ProcessingUnitError *CD1*, CtxDevSound, DPLOCAL);

   262 	DP_IN();

   263 

   264 	TUint count = iAudioProcessingUnitObservers.Count();

   265 	MAudioProcessingUnit* pUnit = static_cast<MAudioProcessingUnit*>(this);

   266 	for(TUint index=0; index < count; index++)

   267 		{

   268 		iAudioProcessingUnitObservers[index]->ProcessingUnitError(pUnit, aError);

   269 		}

   270 	DP_OUT();

   271 	}

   272 

   273 // ---------------------------------------------------------------------------

   274 // CLogicalAudioCodec::RegisterAudioCodecObserver

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

   276 TInt CLogicalAudioCodec::RegisterAudioCodecObserver(MAudioCodecObserver& aObserver)

   277 	{

   278 	DP_CONTEXT(CLogicalAudioCodec::RegisterAudioCodecObserver *CD1*, CtxDevSound, DPLOCAL);

   279 	DP_IN();

   280 	TInt err = iAudioCodecObserver.Find(&aObserver);

   281 	if(err == KErrNotFound)

   282 		{

   283 		err = iAudioCodecObserver.Append(&aObserver);

   284 		}

   285 	else

   286 		{

   287 		err = KErrAlreadyExists;

   288 		}

   289 	DP0_RET(err, "%d");

   290 	}

   291 

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

   293 // CLogicalAudioCodec::UnregisterAudioCodecObserver

   294 // ---------------------------------------------------------------------------

   295 void CLogicalAudioCodec::UnregisterAudioCodecObserver(MAudioCodecObserver& aObserver)

   296 	{

   297 	DP_CONTEXT(CLogicalAudioCodec::UnregisterAudioCodecObserver *CD1*, CtxDevSound, DPLOCAL);

   298 	DP_IN();

   299 	TInt idxOrErr = iAudioCodecObserver.Find(&aObserver);

   300 	if( idxOrErr != KErrNotFound )

   301 		{

   302 		iAudioCodecObserver.Remove(idxOrErr);

   303 		}

   304 	DP_OUT();

   305 	}

   306 

   307 // End of file
Symaptic