Symaptic: os/mm/devsound/devsoundpluginsupport/src/CustomInterfaces/g711decoderconfigci.cpp@260cb5ec6c19

     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 //

    16 #include <ecom/implementationproxy.h>

    17 #include <ecom/implementationproxy.h>

    18 #include <ecom/ecom.h>

    19 #include <s32mem.h>

    21 #include "g711decoderconfigci.h"

    24 // MUX //

    26 TInt CMMFG711DecoderIntfcMux::OpenInterface(TUid /*aInterfaceId*/)

    27 	{

    28 	// attempt to open the interface link with the

    29 	// remote slave device

    30 	iRemoteHandle = -1;

    31 	TUid slaveId = {KMmfUidCustomInterfaceG711DecoderIntfcDeMux};

    33 	TInt handle = iUtility->OpenSlave(slaveId, KNullDesC8);

    34 	if (handle >= 0)

    35 		{

    36 		iRemoteHandle = handle;

    37 		}

    39 	return iRemoteHandle;

    40 	}

    43 void CMMFG711DecoderIntfcMux::Release()

    44 	{

    45 	// close the slave device if it exists

    46 	if (iRemoteHandle > 0)

    47 		{

    48 		// we assume the slave is closed correctly

    49 		iUtility->CloseSlave(iRemoteHandle);

    50 		}

    52 	TUid key = iKey;

    53 	delete this;

    55 	// tell ECom to destroy us

    56 	REComSession::DestroyedImplementation(key);

    57 	}

    60 void CMMFG711DecoderIntfcMux::PassDestructorKey(TUid aDestructorKey)

    61 	{

    62 	// store the destructor key

    63 	iKey = aDestructorKey;

    64 	}

    67 void CMMFG711DecoderIntfcMux::CompleteConstructL(MMMFDevSoundCustomInterfaceMuxUtility* aCustomUtility)

    68 	{

    69 	// store a pointer to the utility

    70 	iUtility = aCustomUtility;

    71 	}

    74 MMMFDevSoundCustomInterfaceMuxPlugin* CMMFG711DecoderIntfcMux::NewL()

    75 	{

    76 	CMMFG711DecoderIntfcMux* self = new (ELeave) CMMFG711DecoderIntfcMux;

    77 	return self;

    78 	}

    81 TAny* CMMFG711DecoderIntfcMux::CustomInterface(TUid /*aInterfaceId*/)

    82 	{

    83 	MG711DecoderIntfc* interface = this;

    84 	return interface;

    85 	}

    88 CMMFG711DecoderIntfcMux::CMMFG711DecoderIntfcMux() :

    89 iRemoteHandle(-1)

    90 	{

    91 	}

    94 CMMFG711DecoderIntfcMux::~CMMFG711DecoderIntfcMux()

    95 	{

    96 	}

    99 // from MG711DecoderIntfc

   100 TInt CMMFG711DecoderIntfcMux::SetDecoderMode(TDecodeMode aDecodeMode)

   101 	{

   102 	TInt result = KErrBadHandle;

   104 	if (iRemoteHandle > 0)

   105 		{

   106 		// send the decodeMode in the sync command

   107 		TPckgBuf<TDecodeMode> decodeMode(aDecodeMode);

   109 		// any return code other than zero is an error

   110 		result = iUtility->SendSlaveSyncCommand(iRemoteHandle,

   111 												EMMFDevSoundCIG711DecoderIntfcSetDecoderMode,

   112 												decodeMode);

   113 		}

   115 	return result;

   116 	}

   119 // from MG711DecoderIntfc

   120 TInt CMMFG711DecoderIntfcMux::GetDecoderMode(TDecodeMode& aDecodeMode)

   121 	{

   122 	TInt result = KErrBadHandle;

   124 	if (iRemoteHandle > 0)

   125 		{

   126 		// send the decodeMode in the sync command

   127 		TPckgBuf<TDecodeMode> retDecodeMode;

   129 		// any return code other than zero is an error

   130 		result = iUtility->SendSlaveSyncCommandResult(iRemoteHandle,

   131 													  EMMFDevSoundCIG711DecoderIntfcGetDecoderMode,

   132 													  KNullDesC8,

   133 													  retDecodeMode);

   135 		// assign return values to aDecodeMode. Do nothing if there is an error

   136 		if(result == KErrNone)

   137 			{

   138 			aDecodeMode = retDecodeMode();

   139 			}

   140 		}

   142 	return result;

   143 	}

   146 // from MG711DecoderIntfc

   147 TInt CMMFG711DecoderIntfcMux::SetComfortNoiseGeneration(TBool aCng)

   148 	{

   149 	TInt result = KErrBadHandle;

   151 	if (iRemoteHandle > 0)

   152 		{

   153 		// send the cng in the sync command

   154 		TPckgBuf<TBool> cng(aCng);

   156 		// any return code other than zero is an error

   157 		result = iUtility->SendSlaveSyncCommand(iRemoteHandle,

   158 												EMMFDevSoundCIG711DecoderIntfcSetComfortNoiseGeneration,

   159 												cng);

   160 		}

   162 	return result;

   163 	}

   166 // from MG711DecoderIntfc

   167 TInt CMMFG711DecoderIntfcMux::GetComfortNoiseGeneration(TBool& aCng)

   168 	{

   169 	TInt result = KErrBadHandle;

   171 	if (iRemoteHandle > 0)

   172 		{

   173 		// holds the returned value.

   174 		TPckgBuf<TBool> retCng;

   176 		// any return code other than zero is an error

   177 		result = iUtility->SendSlaveSyncCommandResult(iRemoteHandle,

   178 													  EMMFDevSoundCIG711DecoderIntfcGetComfortNoiseGeneration,

   179 													  KNullDesC8,

   180 													  retCng);

   182 		// assign return values to aCng. Do nothing if there is an error

   183 		if(result == KErrNone)

   184 			{

   185 			aCng = retCng();

   186 			}

   187 		}

   189 	return result;

   190 	}

   193 // from MG711DecoderIntfc

   194 TInt CMMFG711DecoderIntfcMux::SetPacketLossConcealment(TBool aPlc)

   195 	{

   196 	TInt result = KErrBadHandle;

   198 	if (iRemoteHandle > 0)

   199 		{

   200 		// send the plc in the sync command

   201 		TPckgBuf<TBool> plc(aPlc);

   203 		// any return code other than zero is an error

   204 		result = iUtility->SendSlaveSyncCommand(iRemoteHandle,

   205 												EMMFDevSoundCIG711DecoderIntfcSetPacketLossConcealment,

   206 												plc);

   207 		}

   209 	return result;

   210 	}

   213 // from MG711DecoderIntfc

   214 TInt CMMFG711DecoderIntfcMux::GetPacketLossConcealment(TBool& aPlc)

   215 	{

   216 	TInt result = KErrBadHandle;

   218 	if (iRemoteHandle > 0)

   219 		{

   220 		// send the plc in the sync command

   221 		TPckgBuf<TBool> retPlc;

   223 		// any return code other than zero is an error

   224 		result = iUtility->SendSlaveSyncCommandResult(iRemoteHandle,

   225 													  EMMFDevSoundCIG711DecoderIntfcGetPacketLossConcealment,

   226 													  KNullDesC8,

   227 													  retPlc);

   229 		// assign return values to aPlc. Do nothing if there is an error

   230 		if(result == KErrNone)

   231 			{

   232 			aPlc = retPlc();

   233 			}

   234 		}

   236 	return result;

   237 	}

   241 // DEMUX //

   243 TInt CMMFG711DecoderIntfcDeMux::OpenInterface(TUid /*aInterfaceId*/)

   244 	{

   245 	return KErrNone;

   246 	}

   249 void CMMFG711DecoderIntfcDeMux::Release()

   250 	{

   251 	TUid key = iKey;

   253 	delete this;

   255 	// tell ECom to destroy us

   256 	REComSession::DestroyedImplementation(key);

   257 	}

   260 void CMMFG711DecoderIntfcDeMux::PassDestructorKey(TUid aDestructorKey)

   261 	{

   262 	// store the destructor key

   263 	iKey = aDestructorKey;

   264 	}

   267 void CMMFG711DecoderIntfcDeMux::SetInterfaceTarget(MMMFDevSoundCustomInterfaceTarget* aTarget)

   268 	{

   269 	iTarget = aTarget;

   270 	}

   273 void CMMFG711DecoderIntfcDeMux::CompleteConstructL(MMMFDevSoundCustomInterfaceDeMuxUtility* aCustomUtility)

   274 	{

   275 	// store a pointer to the utility

   276 	iUtility = aCustomUtility;

   277 	}

   280 void CMMFG711DecoderIntfcDeMux::RefreshL()

   281 	{

   282 	// refetch the G711 decoder intfc custom interface if we already have a target

   283 	if (iTarget)

   284 		{

   285 		iInterfaceG711DecoderIntfc = static_cast <MG711DecoderIntfc*> (iTarget->CustomInterface(KUidG711DecoderIntfc));

   287 		if (!iInterfaceG711DecoderIntfc)

   288 			{

   289 			iInterfaceG711DecoderIntfc = NULL;

   290 			User::Leave(KErrNotSupported);

   291 			}

   292 		}

   293 	}

   296 MMMFDevSoundCustomInterfaceDeMuxPlugin* CMMFG711DecoderIntfcDeMux::NewL()

   297 	{

   298 	CMMFG711DecoderIntfcDeMux* self = new (ELeave) CMMFG711DecoderIntfcDeMux;

   299 	return self;

   300 	}

   303 CMMFG711DecoderIntfcDeMux::CMMFG711DecoderIntfcDeMux()

   304 	{

   305 	}

   308 CMMFG711DecoderIntfcDeMux::~CMMFG711DecoderIntfcDeMux()

   309 	{

   310 	}

   313 TInt CMMFG711DecoderIntfcDeMux::DoOpenSlaveL(TUid /*aInterface*/, const TDesC8& /*aPackageBuf*/)

   314 	{

   315 	// fetch the G711 decoder intfc Hw Device custom interface

   316 	iInterfaceG711DecoderIntfc = static_cast<MG711DecoderIntfc*> (iTarget->CustomInterface(KUidG711DecoderIntfc));

   318 	if (!iInterfaceG711DecoderIntfc)

   319 		{

   320 		iInterfaceG711DecoderIntfc = NULL;

   321 		User::Leave(KErrNotSupported);

   322 		}

   324 	return KErrNone;

   325 	}

   328 void CMMFG711DecoderIntfcDeMux::DoCloseSlaveL(TInt /*aHandle*/)

   329 	{

   330 	// nothing to do

   331 	}

   334 // original RMessage is supplied so that remote demux plugin can extract necessary details

   335 // using DeMux utility

   336 TInt CMMFG711DecoderIntfcDeMux::DoSendSlaveSyncCommandL(const RMmfIpcMessage& aMessage)

   337 	{

   338 	TMMFDevSoundCIMessageData data;

   339 	TInt result = KErrGeneral;

   341 	// decode message

   342 	iUtility->GetSyncMessageDataL(aMessage, data);

   344 	switch (data.iCommand)

   345 		{

   346 		case EMMFDevSoundCIG711DecoderIntfcSetDecoderMode:

   347 			{

   348 			TPckgBuf<MG711DecoderIntfc::TDecodeMode> decodeMode;

   349 			iUtility->ReadFromInputDesL(aMessage, &decodeMode);

   351 			result = DoSetDecoderModeL(decodeMode());

   353 			break;

   354 			}

   355 		case EMMFDevSoundCIG711DecoderIntfcSetComfortNoiseGeneration:

   356 			{

   357 			TPckgBuf<TBool> cng;

   358 			iUtility->ReadFromInputDesL(aMessage, &cng);

   360 			result = DoSetComfortNoiseGenerationL(cng());

   361 			break;

   362 			}

   363 		case EMMFDevSoundCIG711DecoderIntfcSetPacketLossConcealment:

   364 			{

   365 			TPckgBuf<TBool> plc;

   366 			iUtility->ReadFromInputDesL(aMessage, &plc);

   368 			result = DoSetPacketLossConcealmentL(plc());

   369 			break;

   370 			}

   371 		default:

   372 			{

   373 			User::Leave(KErrNotSupported);

   374 			}

   375 		}

   377 	return result;

   378 	}

   381 // original RMessage is supplied so that remote demux plugin can extract necessary details

   382 // using DeMux utility

   383 TInt CMMFG711DecoderIntfcDeMux::DoSendSlaveSyncCommandResultL(const RMmfIpcMessage& aMessage)

   384 	{

   385 	TMMFDevSoundCIMessageData data;

   386 	TInt result = KErrGeneral;

   388 	// decode message

   389 	iUtility->GetSyncMessageDataL(aMessage, data);

   391 	switch (data.iCommand)

   392 		{

   393 		case EMMFDevSoundCIG711DecoderIntfcGetDecoderMode:

   394 			{

   395 			TPckgBuf<MG711DecoderIntfc::TDecodeMode> decodeMode;

   396 			iUtility->ReadFromInputDesL(aMessage, &decodeMode);

   398 			result = DoGetDecoderModeL(decodeMode());

   400 			TPckgBuf<TBool> des(decodeMode());

   401 			iUtility->WriteToOutputDesL(aMessage, des);

   403 			break;

   404 			}

   405 		case EMMFDevSoundCIG711DecoderIntfcGetComfortNoiseGeneration:

   406 			{

   407 			TPckgBuf<TBool> cng;

   408 			iUtility->ReadFromInputDesL(aMessage, &cng);

   410 			result = DoGetComfortNoiseGenerationL(cng());

   412 			TPckgBuf<TBool> des(cng());

   413 			iUtility->WriteToOutputDesL(aMessage, des);

   415 			break;

   416 			}

   417 		case EMMFDevSoundCIG711DecoderIntfcGetPacketLossConcealment:

   418 			{

   419 			TPckgBuf<TBool> plc;

   420 			iUtility->ReadFromInputDesL(aMessage, &plc);

   422 			result = DoGetPacketLossConcealmentL(plc());

   424 			TPckgBuf<TBool> des(plc());

   425 			iUtility->WriteToOutputDesL(aMessage, des);

   427 			break;

   428 			}

   429 		default:

   430 			{

   431 			User::Leave(KErrNotSupported);

   432 			}

   433 		}

   435 	return result;

   436 	}

   439 void CMMFG711DecoderIntfcDeMux::DoSendSlaveAsyncCommandL(const RMmfIpcMessage& /*aMessage*/)

   440 	{

   441 	// not used in this interface

   442 	}

   445 void CMMFG711DecoderIntfcDeMux::DoSendSlaveAsyncCommandResultL(const RMmfIpcMessage& /*aMessage*/)

   446 	{

   447 	// not used in this interface

   448 	}

   451 // G711 decoder intfc custom interface implementation

   452 TInt CMMFG711DecoderIntfcDeMux::DoSetDecoderModeL(MG711DecoderIntfc::TDecodeMode aDecodeMode)

   453 	{

   454 	TInt result = KErrNotFound;

   456 	if (iInterfaceG711DecoderIntfc)

   457 		{

   458 		result = iInterfaceG711DecoderIntfc->SetDecoderMode(aDecodeMode);

   459 		}

   461 	return result;

   462 	}

   465 // G711 decoder intfc custom interface implementation

   466 TInt CMMFG711DecoderIntfcDeMux::DoGetDecoderModeL(MG711DecoderIntfc::TDecodeMode& aDecodeMode)

   467 	{

   468 	TInt result = KErrNotFound;

   470 	if (iInterfaceG711DecoderIntfc)

   471 		{

   472 		result = iInterfaceG711DecoderIntfc->GetDecoderMode(aDecodeMode);

   473 		}

   475 	return result;

   476 	}

   479 // G711 decoder intfc custom interface implementation

   480 TInt CMMFG711DecoderIntfcDeMux::DoSetComfortNoiseGenerationL(TBool aCng)

   481 	{

   482 	TInt result = KErrNotFound;

   484 	if (iInterfaceG711DecoderIntfc)

   485 		{

   486 		result = iInterfaceG711DecoderIntfc->SetComfortNoiseGeneration(aCng);

   487 		}

   489 	return result;

   490 	}

   493 // G711 decoder intfc custom interface implementation

   494 TInt CMMFG711DecoderIntfcDeMux::DoGetComfortNoiseGenerationL(TBool& aCng)

   495 	{

   496 	TInt result = KErrNotFound;

   498 	if (iInterfaceG711DecoderIntfc)

   499 		{

   500 		result = iInterfaceG711DecoderIntfc->GetComfortNoiseGeneration(aCng);

   501 		}

   503 	return result;

   504 	}

   507 // G711 decoder intfc custom interface implementation

   508 TInt CMMFG711DecoderIntfcDeMux::DoSetPacketLossConcealmentL(TBool aPlc)

   509 	{

   510 	TInt result = KErrNotFound;

   512 	if (iInterfaceG711DecoderIntfc)

   513 		{

   514 		result = iInterfaceG711DecoderIntfc->SetPacketLossConcealment(aPlc);

   515 		}

   517 	return result;

   518 	}

   521 // G711 decoder intfc custom interface implementation

   522 TInt CMMFG711DecoderIntfcDeMux::DoGetPacketLossConcealmentL(TBool& aPlc)

   523 	{

   524 	TInt result = KErrNotFound;

   526 	if (iInterfaceG711DecoderIntfc)

   527 		{

   528 		result = iInterfaceG711DecoderIntfc->GetPacketLossConcealment(aPlc);

   529 		}

   531 	return result;

   532 	}

   535 //

   536 // ImplementationTable

   537 //

   538 const TImplementationProxy ImplementationTable[] =

   539 	{

   540 	IMPLEMENTATION_PROXY_ENTRY(KMmfUidCustomInterfaceG711DecoderIntfcMux,	CMMFG711DecoderIntfcMux::NewL),

   541 	IMPLEMENTATION_PROXY_ENTRY(KMmfUidCustomInterfaceG711DecoderIntfcDeMux,	CMMFG711DecoderIntfcDeMux::NewL),

   542 	};

   544 //

   545 // ImplementationGroupProxy

   546 //

   547 EXPORT_C const TImplementationProxy* ImplementationGroupProxy(TInt& aTableCount)

   548 	{

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

   551 	return ImplementationTable;

   552 	}

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