--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/mmmw_plat/enhanced_media_client_api/tsrc/EnhanMediaTestClass/src/EnhanMediaTestClassBlocks.cpp Tue Feb 02 01:08:46 2010 +0200
@@ -0,0 +1,6254 @@
+/*
+* Copyright (c) 2002 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description: EMC - Test App
+*
+*/
+
+
+
+// INCLUDE FILES
+#include <e32svr.h>
+#include <StifParser.h>
+#include <Stiftestinterface.h>
+#include <DRMConfigIntfc.h>
+#include <DataBufferSource.h>
+
+#include <CommDbConnPref.h>
+#include <commdb.h>
+
+#include "EnhanMediaTestClass.h"
+#include "debug.h"
+
+using namespace multimedia;
+// EXTERNAL DATA STRUCTURES
+//extern ?external_data;
+
+// EXTERNAL FUNCTION PROTOTYPES
+//extern ?external_function( ?arg_type,?arg_type );
+
+// CONSTANTS
+//const ?type ?constant_var = ?constant;
+
+// MACROS
+//#define ?macro ?macro_def
+
+// LOCAL CONSTANTS AND MACROS
+//const ?type ?constant_var = ?constant;
+//#define ?macro_name ?macro_def
+
+// MODULE DATA STRUCTURES
+//enum ?declaration
+//typedef ?declaration
+
+// LOCAL FUNCTION PROTOTYPES
+//?type ?function_name( ?arg_type, ?arg_type );
+
+// FORWARD DECLARATIONS
+//class ?FORWARD_CLASSNAME;
+
+// ============================= LOCAL FUNCTIONS ===============================
+
+// -----------------------------------------------------------------------------
+// ?function_name ?description.
+// ?description
+// Returns: ?value_1: ?description
+// ?value_n: ?description_line1
+// ?description_line2
+// -----------------------------------------------------------------------------
+//
+/*
+?type ?function_name(
+ ?arg_type arg, // ?description
+ ?arg_type arg) // ?description
+ {
+
+ ?code // ?comment
+
+ // ?comment
+ ?code
+ }
+*/
+
+// ============================ MEMBER FUNCTIONS ===============================
+
+// -----------------------------------------------------------------------------
+// CEnhanMediaTestClass::Delete
+// Delete here all resources allocated and opened from test methods.
+// Called from destructor.
+// -----------------------------------------------------------------------------
+//
+void CEnhanMediaTestClass::Delete()
+ {
+ FTRACE(FPrint(_L("CEnhanMediaTestClass::Delete")));
+
+
+ iExpectedEvents.Reset();
+ iExpectedEvents.Close();
+ iFs.Close();
+ //iOcurredEvents.Close();
+ //iSupportedBitrates.Close();
+
+
+ iLog->Log(_L("Deleting test class CEnhanMediaTestClass..."));
+ iLog->Log(_L(""));
+ iLog->Log(_L(""));
+
+}
+
+// -----------------------------------------------------------------------------
+// CEnhanMediaTestClass::RunMethodL
+// Run specified method. Contains also table of test mothods and their names.
+// -----------------------------------------------------------------------------
+//
+TInt CEnhanMediaTestClass::RunMethodL(
+ CStifItemParser& aItem )
+ {
+
+ static TStifFunctionInfo const KFunctions[] =
+ {
+ // Copy this line for every implemented function.
+ // First string is the function name used in TestScripter script file.
+ // Second is the actual implementation member function.
+ ENTRY( "CreateFactory", CEnhanMediaTestClass::CreateFactory ),
+ ENTRY( "DeleteFactory", CEnhanMediaTestClass::DeleteFactory ),
+ ENTRY( "AddObserver", CEnhanMediaTestClass::AddObserver ),
+ ENTRY( "RemoveObserver", CEnhanMediaTestClass::RemoveObserver ),
+ ENTRY( "CreateSource", CEnhanMediaTestClass::CreateSourceControl ),
+ ENTRY( "StreamRemoveSource", CEnhanMediaTestClass::StreamRemoveSource ),
+ ENTRY( "CloseSource", CEnhanMediaTestClass::CloseSource ),
+ ENTRY( "DeleteSource", CEnhanMediaTestClass::DeleteSource ),
+ ENTRY( "StreamAddSource", CEnhanMediaTestClass::StreamAddSource ),
+ ENTRY( "CreateSink", CEnhanMediaTestClass::CreateSink),
+ ENTRY( "DeleteSink", CEnhanMediaTestClass::DeleteSink),
+ ENTRY( "StreamAddSink", CEnhanMediaTestClass::StreamAddSink),
+ ENTRY( "StreamRemoveSink", CEnhanMediaTestClass::StreamRemoveSink),
+ ENTRY( "CreateEffect", CEnhanMediaTestClass::CreateEffect ),
+ ENTRY( "DeleteEffect", CEnhanMediaTestClass::DeleteEffect ),
+ ENTRY( "RemoveEffect", CEnhanMediaTestClass::RemoveEffect ),
+ ENTRY( "StreamAddEffect", CEnhanMediaTestClass::StreamAddEffect ),
+ ENTRY( "CreateStream", CEnhanMediaTestClass::CreateStream ),
+ ENTRY( "DeleteStream", CEnhanMediaTestClass::DeleteStream ),
+ ENTRY( "FileSOpen", CEnhanMediaTestClass::FileSOpen ),
+ ENTRY( "FileGenOpen", CEnhanMediaTestClass::FileGenOpen ),
+ ENTRY( "DescSOpen", CEnhanMediaTestClass::DescSOpen ),
+ ENTRY( "DBSOpen", CEnhanMediaTestClass::DBSOpen ),
+ ENTRY( "DBSClose", CEnhanMediaTestClass::DBSClose ),
+ ENTRY( "StreamOpen", CEnhanMediaTestClass::StreamOpen ),
+ ENTRY( "StreamClose", CEnhanMediaTestClass::StreamClose ),
+ ENTRY( "StreamPrime", CEnhanMediaTestClass::StreamPrime ),
+ ENTRY( "EqualizerBandLevel", CEnhanMediaTestClass::EqualizerBandLevel ),
+ ENTRY( "EqualizerNumBands", CEnhanMediaTestClass::EqualizerNumBands ),
+ ENTRY( "EqualizerBandWidth", CEnhanMediaTestClass::EqualizerBandWidth ),
+ ENTRY( "EqualizerCenterFrequency", CEnhanMediaTestClass::EqualizerCenterFrequency ),
+ ENTRY( "EqualizerCrossoverFrequency", CEnhanMediaTestClass::EqualizerCrossoverFrequency ),
+ ENTRY( "EqualizerDbLevelLimits", CEnhanMediaTestClass::EqualizerDbLevelLimits ),
+ ENTRY( "EqualizerSetBandLevel", CEnhanMediaTestClass::EqualizerSetBandLevel ),
+ ENTRY( "StreamStart", CEnhanMediaTestClass::StreamStart ),
+ ENTRY( "StreamPause", CEnhanMediaTestClass::StreamPause ),
+ ENTRY( "StreamStop", CEnhanMediaTestClass::StreamStop ),
+ ENTRY( "StreamCustomInterface", CEnhanMediaTestClass::StreamCustomInterface ),
+ ENTRY( "DescSGetBitRate", CEnhanMediaTestClass::DescSGetBitRate ),
+ ENTRY( "CreateDataBuffer", CEnhanMediaTestClass::CreateDataBuffer ),
+ ENTRY( "DBSSetSize", CEnhanMediaTestClass::DBSSetSize ),
+ ENTRY( "DBSGetSize", CEnhanMediaTestClass::DBSGetSize ),
+ ENTRY( "DBSMinBufSize", CEnhanMediaTestClass::DBSMinBufSize ),
+ ENTRY( "WriteLoop", CEnhanMediaTestClass::WriteLoop ),
+ ENTRY( "GetBuffConfig", CEnhanMediaTestClass::GetBuffConfig ),
+ ENTRY( "DBSSetBuffConfig", CEnhanMediaTestClass::DBSSetBuffConfig ),
+ ENTRY( "DBSGetBuffType", CEnhanMediaTestClass::DBSGetBuffType ),
+ ENTRY( "DBSGetInterface", CEnhanMediaTestClass::DBSGetInterface ),
+ ENTRY( "DBSGetBitRate", CEnhanMediaTestClass::DBSGetBitRate ),
+ ENTRY( "DeleteDataBuffer", CEnhanMediaTestClass::DeleteDataBuffer ),
+
+ ENTRY( "VolGetMinVolume", CEnhanMediaTestClass::VolGetMinVolume ),
+ ENTRY( "VolGetMaxVolume", CEnhanMediaTestClass::VolGetMaxVolume ),
+ ENTRY( "VolSetVolume", CEnhanMediaTestClass::VolSetVolume ),
+ ENTRY( "VolGetVolume", CEnhanMediaTestClass::VolGetVolume ),
+ ENTRY( "VolGetDefaultVolume", CEnhanMediaTestClass::VolGetDefaultVolume ),
+ ENTRY( "BalGetBalance", CEnhanMediaTestClass::BalGetBalance ),
+ ENTRY( "BalSetBalance", CEnhanMediaTestClass::BalSetBalance ),
+ ENTRY( "EffectApply", CEnhanMediaTestClass::EffectApply ),
+ ENTRY( "VolSetVolumeRamp", CEnhanMediaTestClass::VolSetVolumeRamp ),
+ ENTRY( "FileSGetBitRate", CEnhanMediaTestClass::FileSGetBitRate ),
+ ENTRY( "FileSGetSize", CEnhanMediaTestClass::FileSGetSize ),
+ ENTRY( "Source_GetMimeType", CEnhanMediaTestClass::Source_GetMimeType ),
+ ENTRY( "Source_GetSize", CEnhanMediaTestClass::Source_GetSize ),
+ ENTRY( "Stream_GetDuration", CEnhanMediaTestClass::Stream_GetDuration ),
+ ENTRY( "Stream_SetPriority", CEnhanMediaTestClass::Stream_SetPriority ),
+ ENTRY( "StreamGetSSL", CEnhanMediaTestClass::StreamGetSSL ),
+ ENTRY( "StreamGetRSSL", CEnhanMediaTestClass::StreamGetRSSL ),
+ ENTRY( "StreamGetStateL", CEnhanMediaTestClass::StreamGetStateL ),
+ ENTRY( "StreamGetCIL", CEnhanMediaTestClass::StreamGetCIL ),
+ ENTRY( "StreamGetPositionL", CEnhanMediaTestClass::StreamGetPositionL ),
+ ENTRY( "StreamSetPositionL", CEnhanMediaTestClass::StreamSetPositionL ),
+ ENTRY( "ControlTypeL", CEnhanMediaTestClass::ControlTypeL ),
+ ENTRY( "ControlControlTypeL", CEnhanMediaTestClass::ControlControlTypeL ),
+
+ ENTRY( "DRMSetType", CEnhanMediaTestClass::DRMSetType ),
+ ENTRY( "DRMGetType", CEnhanMediaTestClass::DRMGetType ),
+ ENTRY( "DRMCommit", CEnhanMediaTestClass::DRMCommit ),
+ ENTRY( "DRMGetAllowedODCount", CEnhanMediaTestClass::DRMGetAllowedOutputDeviceCount ),
+ ENTRY( "DRMGetAllowedOutputDevice", CEnhanMediaTestClass::DRMGetAllowedOutputDevice ),
+ ENTRY( "DRMAppendAllowedOutputDevice", CEnhanMediaTestClass::DRMAppendAllowedOutputDevice ),
+ ENTRY( "DRMRemoveAllowedOutputDevice", CEnhanMediaTestClass::DRMRemoveAllowedOutputDevice ),
+ ENTRY( "DRMReset", CEnhanMediaTestClass::DRMReset ),
+
+ ENTRY( "DSGetSize", CEnhanMediaTestClass::DSGetSize ),
+
+ ENTRY( "DSGetSize", CEnhanMediaTestClass::GeneralGen_StartProgDLL ),
+
+ ENTRY( "Gen_StartProgDL",CEnhanMediaTestClass::GeneralGen_StartProgDLL ),
+ ENTRY( "PDLSOpenL",CEnhanMediaTestClass::PDLSOpenL ),
+ ENTRY( "PDLSGetCurFileSizeL",CEnhanMediaTestClass::PDLSGetCurFileSizeL ),
+ ENTRY( "PDLSGetExpFileSizeL",CEnhanMediaTestClass::PDLSGetExpFileSizeL ),
+ ENTRY( "PDLSGetDLStatusL",CEnhanMediaTestClass::PDLSGetDLStatusL ),
+ ENTRY( "PDLSIsDLCompleteL",CEnhanMediaTestClass::PDLSIsDLCompleteL ),
+ ENTRY( "PDLSGetPerDownloadedL",CEnhanMediaTestClass::PDLSGetPerDownloadedL ),
+ ENTRY( "PDLSGetPerBufferedL",CEnhanMediaTestClass::PDLSGetPerBufferedL ),
+ ENTRY( "PDLSGetDLRateL",CEnhanMediaTestClass::PDLSGetDLRateL ),
+ ENTRY( "PDLSGetBitRateL",CEnhanMediaTestClass::PDLSGetBitRateL ),
+ ENTRY( "PDLSResumeDownloadL",CEnhanMediaTestClass::PDLSResumeDownloadL ),
+ ENTRY( "PDLSMoveFileL",CEnhanMediaTestClass::PDLSMoveFileL ),
+ ENTRY( "PDLSCancelDownloadL",CEnhanMediaTestClass::PDLSCancelDownloadL ),
+ ENTRY( "PDLSGetSize",CEnhanMediaTestClass::PDLSGetSize ),
+
+ ENTRY( "AudioEffect_IsEnabled",CEnhanMediaTestClass::AudioEffectIsEnabled ),
+ ENTRY( "AudioEffect_IsEnforced",CEnhanMediaTestClass::AudioEffectIsEnforced ),
+ ENTRY( "AudioEffect_Uid",CEnhanMediaTestClass::AudioEffectUid ),
+ ENTRY( "AudioEffect_HaveUpdateRights",CEnhanMediaTestClass::AudioEffectHaveUpdateRights ),
+ ENTRY( "AudioEffect_Enforce",CEnhanMediaTestClass::AudioEffectEnforce ),
+
+ ENTRY( "AudioEffect_Enable",CEnhanMediaTestClass::HandleAudioEffectEnableL ),
+ ENTRY( "AudioEffect_Disable",CEnhanMediaTestClass::HandleAudioEffectDisableL ),
+
+ ENTRY( "ER_DecayHFRatio",CEnhanMediaTestClass::HandleReverbDecayHFRatioL ),
+ ENTRY( "ER_DecayHFRatioRange",CEnhanMediaTestClass::HandleReverbDecayHFRatioRangeL ),
+ ENTRY( "ER_DecayTime",CEnhanMediaTestClass::HandleReverbDecayTimeL ),
+ ENTRY( "ER_DecayTimeRange",CEnhanMediaTestClass::HandleReverbDecayTimeRangeL ),
+ ENTRY( "ER_Density",CEnhanMediaTestClass::HandleReverbDensityL ),
+ ENTRY( "ER_Diffusion",CEnhanMediaTestClass::HandleReverbDiffusionL ),
+ ENTRY( "ER_ReflectionsDelay",CEnhanMediaTestClass::HandleReverbReflectionsDelayL ),
+ ENTRY( "ER_ReflectionsDelayMax",CEnhanMediaTestClass::HandleReverbReflectionsDelayMaxL ),
+ ENTRY( "ER_ReflectionsLevel",CEnhanMediaTestClass::HandleReverbReflectionsLevelL ),
+ ENTRY( "ER_ReflectionLevelRange",CEnhanMediaTestClass::HandleReverbReflectionLevelRangeL ),
+ ENTRY( "ER_ReverbDelay",CEnhanMediaTestClass::HandleReverbReverbDelayL ),
+ ENTRY( "ER_ReverbDelayMax",CEnhanMediaTestClass::HandleReverbReverbDelayMaxL ),
+ ENTRY( "ER_ReverbLevel",CEnhanMediaTestClass::HandleReverbReverbLevelL),
+ ENTRY( "ER_ReverbLevelRange",CEnhanMediaTestClass::HandleReverbReverbLevelRangeL ),
+ ENTRY( "ER_RoomHFLevel",CEnhanMediaTestClass::HandleReverbRoomHFLevelL ),
+ ENTRY( "ER_RoomHFLevelRange",CEnhanMediaTestClass::HandleReverbRoomHFLevelRangeL ),
+ ENTRY( "ER_RoomLevel",CEnhanMediaTestClass::HandleReverbRoomLevelL ),
+ ENTRY( "ER_RoomLevelRange",CEnhanMediaTestClass::HandleReverbRoomLevelRangeL ),
+ ENTRY( "ER_SetDecayHFRatio",CEnhanMediaTestClass::HandleReverbSetDecayHFRatioL ),
+ ENTRY( "ER_SetDecayTime",CEnhanMediaTestClass::HandleReverbSetDecayTimeL ),
+ ENTRY( "ER_SetDensity",CEnhanMediaTestClass::HandleReverbSetDensityL ),
+ ENTRY( "ER_SetDiffusion",CEnhanMediaTestClass::HandleReverbSetDiffusionL ),
+ ENTRY( "ER_SetReflectionsDelay",CEnhanMediaTestClass::HandleReverbSetReflectionsDelayL ),
+ ENTRY( "ER_SetReflectionsLevel",CEnhanMediaTestClass::HandleReverbSetReflectionsLevelL ),
+ ENTRY( "ER_SetReverbDelay",CEnhanMediaTestClass::HandleReverbSetReverbDelayL ),
+ ENTRY( "ER_SetReverbLevel",CEnhanMediaTestClass::HandleReverbSetReverbLevelL ),
+ ENTRY( "ER_SetRoomHFLevel",CEnhanMediaTestClass::HandleReverbSetRoomHFLevelL ),
+ ENTRY( "ER_SetRoomLevel",CEnhanMediaTestClass::HandleReverbSetRoomLevelL ),
+ ENTRY( "ER_DelayMax",CEnhanMediaTestClass::HandleReverbDelayMaxL ),
+
+ ENTRY( "SW_IsContinuousLevelSupportedL",CEnhanMediaTestClass::HandleSWIsContinuousLevelSupportedL ),
+ ENTRY( "SW_SetStereoWideningLevelL",CEnhanMediaTestClass::HandleSWSetStereoWideningLevelL ),
+ ENTRY( "SW_StereoWideningLevelL",CEnhanMediaTestClass::HandleSWStereoWideningLevelL ),
+
+ ENTRY( "RL_LevelRangeL",CEnhanMediaTestClass::HandleRLLevelRangeL ),
+ ENTRY( "RL_SetRoomLevelL",CEnhanMediaTestClass::HandleRLSetRoomLevelL ),
+ ENTRY( "RL_LevelL",CEnhanMediaTestClass::HandleRLLevelL ),
+
+ ENTRY( "DA_DistanceAttenuationL",CEnhanMediaTestClass::HandleDADistanceAttenuationL ),
+ ENTRY( "DA_RollOffFactorMaxL",CEnhanMediaTestClass::HandleDARollOffFactorMaxL ),
+ ENTRY( "DA_RoomRollOffFactorMaxL",CEnhanMediaTestClass::HandleDARoomRollOffFactorMaxL ),
+
+
+ ENTRY( "SL_LocationCartesianL",CEnhanMediaTestClass::HandleSLLocationCartesianL ),
+ ENTRY( "SL_LocationSphericalL",CEnhanMediaTestClass::HandleSLLocationSphericalL ),
+ ENTRY( "SL_SetLocationCartesianL",CEnhanMediaTestClass::HandleSLSetLocationCartesianL ),
+ ENTRY( "SL_SetLocationSphericalL",CEnhanMediaTestClass::HandleSLSetLocationSphericalL ),
+ ENTRY( "LO_OrientationL",CEnhanMediaTestClass::LO_OrientationL ),
+ ENTRY( "LO_OrientationVectorsL",CEnhanMediaTestClass::LO_OrientationVectorsL ),
+
+
+ ENTRY( "Control_Type",CEnhanMediaTestClass::HandleControlTypeL ),
+ ENTRY( "Control_ControlType",CEnhanMediaTestClass::HandleControlControlTypeL ),
+
+ ENTRY( "SD_SetFactorL",CEnhanMediaTestClass::HandleSDSetFactorL ),
+ ENTRY( "SD_SetSphericalVelocityL",CEnhanMediaTestClass::HandleSDSetSphericalVelocityL ),
+ ENTRY( "SD_SphericalVelocityL",CEnhanMediaTestClass::HandleSDSphericalVelocityL ),
+ ENTRY( "SD_CartesianVelocityL",CEnhanMediaTestClass::HandleSDCartesianVelocityL ),
+ ENTRY( "SD_FactorL",CEnhanMediaTestClass::HandleSDFactorL ),
+ ENTRY( "SD_FactorMaxL",CEnhanMediaTestClass::HandleSDFactorMaxL ),
+ ENTRY( "SD_SetCartesianVelocityL",CEnhanMediaTestClass::HandleSDSetCartesianVelocityL ),
+
+ ENTRY( "AttachReverb",CEnhanMediaTestClass::AttachReverb ),
+ ENTRY( "DetachReverb",CEnhanMediaTestClass::DetachReverb ),
+
+
+ };
+
+ const TInt count = sizeof( KFunctions ) /
+ sizeof( TStifFunctionInfo );
+
+ return RunInternalL( KFunctions, count, aItem );
+
+ }
+
+
+// -----------------------------------------------------------------------------
+// CEnhanMediaTestClass::EventName
+// Return descriptor with the notification description
+// -----------------------------------------------------------------------------
+TPtrC CEnhanMediaTestClass::EventName( TInt aKey )
+{
+ static TText* const badKeyword = (TText*)L"BadKeyword";
+ static TText* const keywords[] =
+ {
+ (TText*)L"EEDBSOpen",
+ (TText*)L"EEStreamPause",
+ (TText*)L"EEDeleteBuffer",
+ (TText*)L"EEWriteToStream",
+ (TText*)L"EEDataBuffer",
+ (TText*)L"EEStreamClose",
+ (TText*)L"EEStreamAddEffect",
+ (TText*)L"EEStreamOpen",
+ (TText*)L"EEStreamPrime",
+ (TText*)L"EEStreamStart",
+ (TText*)L"EEPDLSOpen",
+
+ };
+ if( (TUint)aKey >= (sizeof( keywords )/sizeof(TText*)) )
+ {
+ iLog->Log(_L("Keyword out of bounds"));
+ TPtrC keyword( badKeyword );
+ return keyword;
+ }
+ else
+ {
+ TPtrC keyword( keywords[aKey] );
+ return keyword;
+ }
+}
+
+// -----------------------------------------------------------------------------
+// CEnhanMediaTestClass::AddExpectedEvent
+// Add an event to the expected events' list
+// -----------------------------------------------------------------------------
+void CEnhanMediaTestClass::AddExpectedEvent(TAEnhsExpectedEvent event, TInt ms)
+{
+ FTRACE(FPrint(_L("CEnhanMediaTestClass::AddExpectedEvent")));
+ iExpectedEvents.Append(event);
+ TPtrC eventName = EventName(event);
+ iLog->Log(_L("Adding expected event:(0x%02x)%S Total=%d"), event, &eventName, iExpectedEvents.Count() );
+
+ if ( iTimeoutController && !iTimeoutController->IsActive() )
+ {
+ if (ms > 0)
+ {
+ iTimeoutController->Start( TTimeIntervalMicroSeconds(ms * 1000) );
+ }
+ else
+ {
+ iLog->Log(_L("Timeout with default value (1s)"));
+ iTimeoutController->Start( TTimeIntervalMicroSeconds(1000000) );
+ }
+ }
+}
+
+// -----------------------------------------------------------------------------
+// CEnhanMediaTestClass::RemoveExpectedEvent
+// Remove the indicated event from the expected events' list
+// -----------------------------------------------------------------------------
+TBool CEnhanMediaTestClass::RemoveExpectedEvent(TAEnhsExpectedEvent aEvent)
+{
+ FTRACE(FPrint(_L("CEnhanMediaTestClass::RemoveExpectedEvent")));
+ TBool match = EFalse;
+ for (TUint i=0; i < iExpectedEvents.Count() ; i++)
+ {
+ if (iExpectedEvents[i] == aEvent)
+ {
+ iExpectedEvents.Remove(i);
+ match = ETrue;
+ break;
+ }
+ }
+
+ return match;
+}
+
+
+// -----------------------------------------------------------------------------
+// CEnhanMediaTestClass::RemoveAllExpectedEvents
+// Remove the indicated event from the expected events' list
+// -----------------------------------------------------------------------------
+void CEnhanMediaTestClass::RemoveAllExpectedEvents()
+{
+ FTRACE(FPrint(_L("CEnhanMediaTestClass::RemoveAllExpectedEvents")));
+ iLog->Log(_L("Removing all expected events"));
+
+ iExpectedEvents.Reset();
+ //iOcurredEvents.Reset();
+}
+
+
+// -----------------------------------------------------------------------------
+// CEnhanMediaTestClass::ProcessEvent
+// -----------------------------------------------------------------------------
+void CEnhanMediaTestClass::ProcessEvent(TAEnhsExpectedEvent aEvent, TInt aError)
+{
+ FTRACE(FPrint(_L("CEnhanMediaTestClass::ProcessExpectedEvent")));
+ TPtrC nameEvent = EventName(aEvent);
+
+ // Check for error
+ if (aError == KErrNone)
+ {
+ // Remove the event
+ if (RemoveExpectedEvent(aEvent))
+ {
+ iLog->Log(_L("Expected Event: (0x%02x)%S has ocurred Total=%d"), aEvent, &nameEvent,iExpectedEvents.Count());
+ }
+ else
+ {
+ iLog->Log(_L("Event: (0x%02x)%S has ocurred"), aEvent, &nameEvent);
+ return;
+ }
+ // All expected events have ocurred
+ if (iExpectedEvents.Count() == 0 )
+ {
+ Signal();
+ iTimeoutController->Cancel();
+ }
+ }
+ else
+ {
+ iLog->Log(_L("[Error] Event: (0x%02x)%S return with error code=%d"), aEvent, &nameEvent, aError);
+ if (iExpectedEvents.Count() != 0 )
+ {
+ RemoveExpectedEvent(aEvent);
+ }
+ iTimeoutController->Cancel();
+ Signal(KErrCallbackErrorCode);
+ }
+}
+
+// -----------------------------------------------------------------------------
+// CEnhanMediaTestClass::HandleTimeout
+// Review if all the expected events have ocurred once the time is over
+// -----------------------------------------------------------------------------
+
+void CEnhanMediaTestClass::HandleTimeout(TInt aError)
+{
+ FTRACE(FPrint(_L("CEnhanMediaTestClass::HandleTimeout")));
+ // All expected events have ocurred
+ if (aError != KErrNone)
+ {
+ if (iExpectedEvents.Count() == 0 )
+ {
+ iLog->Log(_L("Timing out but events have ocurred"));
+ Signal();
+ }
+ else
+ {
+ RemoveAllExpectedEvents();
+ iLog->Log(_L("Timing out and events still pending"));
+ Signal(KErrEventPending);
+ }
+ }
+ else
+ {
+ iLog->Log(_L("Timing out return a error %d"), aError);
+ Signal(aError);
+ }
+}
+
+// -----------------------------------------------------------------------------
+// CEnhanMediaTestClass::SetTimeout
+// Create a timer and set a timeout
+// When the timeout is reached the test case is marked as failed
+// It's used rather than the "timeout" keyword in the configuration file
+// because in this way the log continues
+// -----------------------------------------------------------------------------
+TInt CEnhanMediaTestClass::SetTimeout( CStifItemParser& aItem )
+{
+ FTRACE(FPrint(_L("CEnhanMediaTestClass::SetTimeout")));
+ TInt timeout=0;
+ TInt error = aItem.GetNextInt(timeout) ;
+ if ( iTimeoutController )
+ {
+ if ( timeout > 0 )
+ {
+ iTimeoutController->Start( TTimeIntervalMicroSeconds(timeout*1000) );
+ }
+ else
+ {
+ iTimeoutController->Start( TTimeIntervalMicroSeconds(1000000) );
+ }
+ }
+ else
+ {
+ iLog->Log(_L("Timeout Controller doesn't exist"));
+ error = KErrTimeoutController;
+ }
+ return error;
+}
+
+
+// -----------------------------------------------------------------------------
+// Uses the TestModuleBase API to allow a panic as exit reason for a test case
+// -----------------------------------------------------------------------------
+TInt CEnhanMediaTestClass::SetAllowedPanic( CStifItemParser& aItem )
+{
+ FTRACE(FPrint(_L("CEnhanMediaTestClass::SetAllowedPanic")));
+ TInt error = KErrNone;
+ TInt panicCode;
+ TPtrC panicType;
+ if ( ( KErrNone == aItem.GetNextString(panicType) ) &&
+ ( KErrNone == aItem.GetNextInt(panicCode) ) )
+ {
+ iLog->Log(_L("Allowing panic: %S %d"), &panicType, panicCode);
+ iTestModuleIf.SetExitReason( CTestModuleIf::EPanic, panicCode );
+ iNormalExitReason = EFalse;
+ }
+ else
+ {
+ iLog->Log(KMsgBadTestParameters);
+ error = KErrBadTestParameter;
+ }
+ return error;
+}
+
+// -----------------------------------------------------------------------------
+// CEnhanMediaTestClass::SetExpectedEvents()
+// -----------------------------------------------------------------------------
+TInt CEnhanMediaTestClass::SetExpectedEvents( CStifItemParser& aItem )
+{
+ FTRACE(FPrint(_L("CEnhanMediaTestClass::SetExpectedEvents")));
+ TInt error = KErrNone;
+ TInt event=0;
+ while ( KErrNone == aItem.GetNextInt(event))
+ {
+ AddExpectedEvent(static_cast<TAEnhsExpectedEvent>(event), 0); // Default timeout value
+ }
+ return error;
+}
+
+
+// -----------------------------------------------------------------------------
+// CEnhanMediaTestClass::ExampleL
+// Example test method function.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+TInt CEnhanMediaTestClass::ExampleL( CStifItemParser& aItem )
+ {
+
+ // Print to UI
+ _LIT( KEnhanMediaTestClass, "EnhanMediaTestClass" );
+ _LIT( KExample, "In Example" );
+ TestModuleIf().Printf( 0, KEnhanMediaTestClass, KExample );
+ // Print to log file
+ iLog->Log( KExample );
+
+ TInt i = 0;
+ TPtrC string;
+ _LIT( KParam, "Param[%i]: %S" );
+ while ( aItem.GetNextString ( string ) == KErrNone )
+ {
+ TestModuleIf().Printf( i, KEnhanMediaTestClass,
+ KParam, i, &string );
+ i++;
+ }
+
+ return KErrNone;
+
+ }
+
+// -----------------------------------------------------------------------------
+// CEnhanMediaTestClass::CreateRestrictedAO
+// Create RestrictedAO
+// -----------------------------------------------------------------------------
+//
+TInt CEnhanMediaTestClass::CreateFactory( CStifItemParser& /*aItem*/ )
+ {
+ //AddExpectedEvent(EECreateFactory,KShortTimeout);
+ TInt error = KErrNone;
+ TInt err = CMultimediaFactory::CreateFactory(iFactory);
+ if(error == KErrNone)
+ {
+ iLog->Log(_L("CreateFactory OK"));
+ }
+ else
+ {
+ iLog->Log(_L("CreateFactory [%d]"),error);
+ }
+ //ProcessEvent(EECreateFactory, error);
+ return error;
+ }
+
+TInt CEnhanMediaTestClass::DeleteFactory( CStifItemParser& /*aItem*/ )
+ {
+ TInt error = KErrNone;
+ if(iMimeType)
+ {
+ delete iMimeType;
+ iMimeType = NULL;
+ }
+
+ if(iFileName)
+ {
+ delete iFileName;
+ iFileName = NULL;
+ }
+
+ if(iDescData)
+ {
+ delete iDescData;
+ iDescData = NULL;
+ }
+
+ if (iDRMConfigIntfc)
+ {
+ delete iDRMConfigIntfc;
+ iDRMConfigIntfc = NULL;
+ }
+ if(iUrlName)
+ {
+ delete iUrlName;
+ }
+
+ if(iAccessPtName)
+ {
+ delete iAccessPtName;
+ }
+ // ProcessEvent(EECreateFactory, error);
+/* for (TUint i =0; i < iExpectedEvents.Count() ; i++)
+ {
+ ProcessEvent(TAEnhsExpectedEvent(i),0);
+ }*/
+ delete iFactory;
+ iLog->Log(_L("Delete Factory OK"));
+ return error;
+ }
+
+TInt CEnhanMediaTestClass::CreateSourceControl( CStifItemParser& aItem )
+ {
+ //AddExpectedEvent(EECreateSource,KShortTimeout);
+
+ TInt object;
+ TInt status = KErrNone;
+ aItem.GetNextInt(object);
+ switch(object)
+ {
+ case EFILESOURCE:
+ {
+ status = iFactory->CreateSourceControl( KFileSourceControl, iSourceControl );
+ if(status == KErrNone)
+ {
+ iMFileSource = static_cast<MFileSource*>(iSourceControl);
+ }
+ break;
+ }
+ case EDATABUFFERSOURCE:
+ {
+ status = iFactory->CreateSourceControl( KDataBufferSourceControl, iSourceControl );
+ if(status == KErrNone)
+ {
+ iMDataBufferSource = static_cast<MDataBufferSource*>(iSourceControl);
+ }
+ break;
+ }
+ case EDESCRIPTORSOURCE:
+ {
+ status = iFactory->CreateSourceControl( KDescriptorSourceControl, iSourceControl );
+ if(status == KErrNone)
+ {
+ iMDescriptorSource = static_cast<MDescriptorSource*>(iSourceControl);
+ }
+ break;
+ }
+ case EPDLSOURCE:
+ {
+ status = iFactory->CreateSourceControl( KProgDLSourceControl, iSourceControl );
+ if(status == KErrNone)
+ {
+ iMProgDLSource = static_cast<MProgDLSource*>(iSourceControl);
+ }
+ break;
+ }
+ default:
+ {
+ status = KErrNotSupported;
+ break;
+ }
+ };
+ if(status == KErrNone)
+ {
+ // iMFileSource = static_cast<MFileSource*>(iSourceControl);
+ iLog->Log(_L("CreateSourceControl OK"));
+
+ }
+ else
+ {
+ iLog->Log(_L("CreateSourceControl [%d]"),status);
+ }
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::DeleteSource(CStifItemParser& /*aItem*/)
+ {
+ iLog->Log(_L("DeleteSourceControl"));
+ TInt status = KErrNone;
+ if(iMDataBufferSource)
+ {
+ MSourceControl* objPtr = iMDataBufferSource;
+ iFactory->DeleteSourceControl(objPtr);
+ iMDataBufferSource = NULL;
+ }
+
+ if(iMDescriptorSource)
+ {
+ MSourceControl* objPtr = iMDescriptorSource;
+ iFactory->DeleteSourceControl(objPtr);
+ iMDescriptorSource = NULL;
+ }
+
+ if(iMFileSource)
+ {
+ MSourceControl* objPtr = iMFileSource;
+ iFactory->DeleteSourceControl(objPtr);
+ iMFileSource = NULL;
+ }
+ if(iMProgDLSource)
+ {
+ MSourceControl* objPtr = iMProgDLSource;
+ iFactory->DeleteSourceControl(objPtr);
+ iMProgDLSource = NULL;
+ }
+ iLog->Log(_L("DeleteSourceControl OK"));
+ //ProcessEvent(EECreateSource, status);
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::CloseSource(CStifItemParser& /*aItem*/)
+ {
+ TInt status = KErrNone;
+ status = iSourceControl->Close();
+ if (status == KErrNone)
+ {
+ iLog->Log(_L("CloseSource OK"));
+ }
+ else
+ {
+ iLog->Log(_L("CloseSource FAILED [%d]"),status);
+ }
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::CreateSink(CStifItemParser& /*aItem*/)
+ {
+ //AddExpectedEvent(EECreateSink,KShortTimeout);
+ TInt status(KErrNone);
+ if ( iMAudioSink )
+ {
+ status = KErrAlreadyExists;
+ }
+ else
+ {
+ status = iFactory->CreateSinkControl( KMMFAudioOutputSinkControl, iMAudioSink );
+ }
+ if (status == KErrNone)
+ {
+ iLog->Log(_L("CreateSinkL OK"));
+ }
+ else
+ {
+ iLog->Log(_L("CreateSinkL FAILED [%d]"),status);
+ }
+
+ //ProcessEvent(ECreateSink, status);
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::DeleteSink(CStifItemParser& /*aItem*/)
+ {
+ TInt status(KErrNone);
+ if ( iMAudioSink )
+ {
+ status = iFactory->DeleteSinkControl(iMAudioSink);
+ iMAudioSink = NULL;
+ }
+ if (status == KErrNone)
+ {
+ iLog->Log(_L("DeleteSink OK"));
+ }
+ else
+ {
+ iLog->Log(_L("DeleteSink FAILED [%d]"),status);
+ }
+
+ //ProcessEvent(EECreateSink, status);
+
+ return status;
+ }
+TInt CEnhanMediaTestClass::CreateStream(CStifItemParser& /*aItem*/)
+ {
+ //AddExpectedEvent(EECreateStream,KShortTimeout);
+ TInt status(KErrNone);
+ if ( iMStreamControl )
+ {
+ status = KErrAlreadyExists;
+ }
+ else
+ {
+ status = iFactory->CreateStreamControl( KStreamControl, iMStreamControl );
+ }
+ //ProcessEvent(ECreateStream, status);
+ if (status == KErrNone)
+ {
+ iLog->Log(_L("CreateStream OK"));
+ }
+ else
+ {
+ iLog->Log(_L("CreateStream FAILED [%d]"),status);
+ }
+ //AddExpectedEvent(EECreateStream,KShortTimeout);
+
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::DeleteStream(CStifItemParser& /*aItem*/)
+ {
+ TInt status(KErrNone);
+
+ if ( iMStreamControl )
+ {
+ status = iFactory->DeleteStreamControl(iMStreamControl);
+ iMStreamControl = NULL;
+ }
+ if (status == KErrNone)
+ {
+ iLog->Log(_L("DeleteStream OK"));
+ }
+ else
+ {
+ iLog->Log(_L("DeleteStream FAILED [%d]"),status);
+ }
+ //ProcessEvent(EECreateStream, status);
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::RemoveEffect(CStifItemParser& aItem)
+ {
+
+ TInt object;
+ TInt status(KErrNone);
+ aItem.GetNextInt(object);
+ iLog->Log(_L("RemoveEffect INIT [%d]"),object);
+ switch(object)
+ {
+ case EVOLUMECONTROL:
+ {
+ iEffectControl = iMVolumeControl;
+ }
+ break;
+ case EBALANCECONTROL:
+ {
+ iEffectControl = iMBalanceControl;
+ }
+ break;
+ case EEQUALIZERCONTROL:
+ {
+ iEffectControl = iMEqualizerControl;
+ }
+ break;
+ case EREVERBCONTROL:
+ {
+ iEffectControl = iMReverbControl;
+ }
+ break;
+ case EBASSBOOSTCONTROL:
+ {
+ iEffectControl = iMBassBoostControl;
+ }
+ break;
+ case ESTEREOWIDCONTROL:
+ {
+ iEffectControl = iMStereoWideningControl;
+ }
+ break;
+
+
+ case ELOUDNESSCONTROL:
+ {
+ iEffectControl = iMLoudnessControl;
+ }
+ break;
+
+
+ case EROOMLEVELCONTROL:
+ {
+ iEffectControl = iMRoomLevelControl;
+ }
+ break;
+
+
+ case EDISTATTCONTROL:
+ {
+ iEffectControl = iMDistanceAttenuationControl;
+ }
+ break;
+
+
+ case ELISTDOPPCONTROL:
+ {
+ iEffectControl = iMListenerDopplerControl;
+ }
+ break;
+
+
+ case ESOURDOPPCONTROL:
+ {
+ iEffectControl = iMSourceDopplerControl;
+ }
+ break;
+
+
+ case ELISTLOCCONTROL:
+ {
+ iEffectControl = iMListenerLocationControl;
+ }
+ break;
+
+
+ case ESOURLOCCONTROL:
+ {
+ iEffectControl = iMSourceLocationControl;
+ }
+ break;
+
+
+ case ELISTORIENTCONTROL:
+ {
+ iEffectControl = iMListenerOrientationControl;
+ }
+ break;
+
+
+ case ESOURORIENTCONTROL:
+ {
+ iEffectControl = iMSourceOrientationControl;
+ }
+ break;
+
+ }
+ status = iMStreamControl->RemoveEffect(*iEffectControl);
+ if (status == KErrNone)
+ {
+ iLog->Log(_L("RemoveEffect OK"));
+ }
+ else
+ {
+ iLog->Log(_L("RemoveEffect FAILED [%d]"),status);
+ }
+ ProcessEvent(EEStreamAddEffect, status);
+ iLog->Log(_L("RemoveEffect END [%d]"),object);
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::DeleteEffect(CStifItemParser& aItem)
+ {
+
+ TInt object;
+ TInt status(KErrNone);
+ MEffectControl* tempCtrl;
+ aItem.GetNextInt(object);
+ iLog->Log(_L("DeleteEffect INIT [%d]"),object);
+ switch(object)
+ {
+ case EVOLUMECONTROL:
+ {
+ if ( iMVolumeControl )
+ {
+ tempCtrl = iMVolumeControl;
+ status = iFactory->DeleteEffectControl(tempCtrl);
+ iMVolumeControl = NULL;
+ }
+ break;
+ }
+ case EBALANCECONTROL:
+ {
+ if ( iMBalanceControl )
+ {
+ tempCtrl = iMBalanceControl;
+ status = iFactory->DeleteEffectControl(tempCtrl);
+ iMBalanceControl = NULL;
+ }
+ break;
+ }
+ case EEQUALIZERCONTROL:
+ {
+ if ( iMEqualizerControl )
+ {
+ tempCtrl = iMEqualizerControl;
+ status = iFactory->DeleteEffectControl(tempCtrl);
+ iMEqualizerControl = NULL;
+ }
+ break;
+ }
+ case EREVERBCONTROL:
+ {
+ if ( iMReverbControl )
+ {
+ tempCtrl = iMReverbControl;
+ status = iFactory->DeleteEffectControl(tempCtrl);
+ iMReverbControl = NULL;
+ }
+ break;
+ }
+
+ case EBASSBOOSTCONTROL:
+ {
+ if ( iMBassBoostControl )
+ {
+ tempCtrl = iMBassBoostControl;
+ status = iFactory->DeleteEffectControl(tempCtrl);
+ iMBassBoostControl = NULL;
+ }
+ break;
+ }
+
+ case ESTEREOWIDCONTROL:
+ {
+ if ( iMStereoWideningControl )
+ {
+ tempCtrl = iMStereoWideningControl;
+ status = iFactory->DeleteEffectControl(tempCtrl);
+ iMStereoWideningControl = NULL;
+ }
+ break;
+ }
+ case ELOUDNESSCONTROL:
+ {
+ if ( iMLoudnessControl )
+ {
+ tempCtrl = iMLoudnessControl;
+ status = iFactory->DeleteEffectControl(tempCtrl);
+ iMLoudnessControl = NULL;
+ }
+ break;
+ }
+ case EROOMLEVELCONTROL:
+ {
+ if ( iMRoomLevelControl )
+ {
+ tempCtrl = iMRoomLevelControl;
+ status = iFactory->DeleteEffectControl(tempCtrl);
+ iMRoomLevelControl = NULL;
+ }
+ break;
+ }
+ case EDISTATTCONTROL:
+ {
+ if ( iMDistanceAttenuationControl )
+ {
+ tempCtrl = iMDistanceAttenuationControl;
+ status = iFactory->DeleteEffectControl(tempCtrl);
+ iMDistanceAttenuationControl = NULL;
+ }
+ break;
+ }
+ case ELISTDOPPCONTROL:
+ {
+ if ( iMListenerDopplerControl )
+ {
+ tempCtrl = iMListenerDopplerControl;
+ status = iFactory->DeleteEffectControl(tempCtrl);
+ iMListenerDopplerControl = NULL;
+ }
+ break;
+ }
+ case ESOURDOPPCONTROL:
+ {
+ if ( iMSourceDopplerControl )
+ {
+ tempCtrl = iMSourceDopplerControl;
+ status = iFactory->DeleteEffectControl(tempCtrl);
+ iMSourceDopplerControl = NULL;
+ }
+ break;
+ }
+ case ELISTLOCCONTROL:
+ {
+ if ( iMListenerLocationControl )
+ {
+ tempCtrl = iMListenerLocationControl;
+ status = iFactory->DeleteEffectControl(tempCtrl);
+ iMListenerLocationControl = NULL;
+ }
+ break;
+ }
+ case ESOURLOCCONTROL:
+ {
+ if ( iMSourceLocationControl )
+ {
+ tempCtrl = iMSourceLocationControl;
+ status = iFactory->DeleteEffectControl(tempCtrl);
+ iMSourceLocationControl = NULL;
+ }
+ break;
+ }
+ case ELISTORIENTCONTROL:
+ {
+ if ( iMListenerOrientationControl )
+ {
+ tempCtrl = iMListenerOrientationControl;
+ status = iFactory->DeleteEffectControl(tempCtrl);
+ iMListenerOrientationControl = NULL;
+ }
+ break;
+ }
+ case ESOURORIENTCONTROL:
+ {
+ if ( iMSourceOrientationControl )
+ {
+ tempCtrl = iMSourceOrientationControl;
+ status = iFactory->DeleteEffectControl(tempCtrl);
+ iMSourceOrientationControl = NULL;
+ }
+ break;
+ }
+ }
+ if (status == KErrNone)
+ {
+ iLog->Log(_L("DeleteEffectControl OK"));
+ }
+ else
+ {
+ iLog->Log(_L("DeleteEffectControl FAILED [%d]"),status);
+ }
+ iLog->Log(_L("DeleteEffect END[%d]"),object);
+
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::CreateEffect(CStifItemParser& aItem)
+ {
+ //AddExpectedEvent(EECreateEffect,KShortTimeout);
+ TInt object;
+ TInt status = KErrNone;
+ MEffectControl* tempCtrl;
+ aItem.GetNextInt(object);
+ iLog->Log(_L("CreateEffect INIT[%d]"),object);
+
+ switch(object)
+ {
+ case EVOLUMECONTROL:
+ {
+ status = iFactory->CreateEffectControl( KVolumeEffectControl, tempCtrl );
+ if(status == KErrNone)
+ {
+ iMVolumeControl = static_cast<MVolumeControl*> (tempCtrl);
+ }
+ break;
+ }
+ case EBALANCECONTROL:
+ {
+ status = iFactory->CreateEffectControl( KBalanceEffectControl, tempCtrl );
+ if(status == KErrNone)
+ {
+ iMBalanceControl = static_cast<MBalanceControl*> (tempCtrl);
+ }
+ break;
+ }
+ case EEQUALIZERCONTROL:
+ {
+ status = iFactory->CreateEffectControl( KEqualizerEffectControl, tempCtrl );
+ if(status == KErrNone)
+ {
+ iMEqualizerControl = static_cast<MEqualizerControl*> (tempCtrl);
+ }
+ break;
+ }
+ case EREVERBCONTROL:
+ {
+ status = iFactory->CreateEffectControl( KReverbEffectControl, tempCtrl );
+ if(status == KErrNone)
+ {
+ iMReverbControl = static_cast<MReverbControl*> (tempCtrl);
+ }
+ break;
+ }
+
+ case EBASSBOOSTCONTROL:
+ {
+ status = iFactory->CreateEffectControl( KBassBoostEffectControl, tempCtrl );
+ if(status == KErrNone)
+ {
+ iMBassBoostControl = static_cast<MBassBoostControl*> (tempCtrl);
+ }
+ break;
+ }
+
+ case ESTEREOWIDCONTROL:
+ {
+ status = iFactory->CreateEffectControl( KStereoWideningEffectControl, tempCtrl );
+ if(status == KErrNone)
+ {
+ iMStereoWideningControl = static_cast<MStereoWideningControl*> (tempCtrl);
+ }
+ break;
+ }
+
+
+ case ELOUDNESSCONTROL:
+ {
+ status = iFactory->CreateEffectControl( KLoudnessEffectControl, tempCtrl );
+ if(status == KErrNone)
+ {
+ iMLoudnessControl = static_cast<MLoudnessControl*> (tempCtrl);
+ }
+ break;
+ }
+
+
+ case EROOMLEVELCONTROL:
+ {
+ status = iFactory->CreateEffectControl( KRoomLevelEffectControl, tempCtrl );
+ if(status == KErrNone)
+ {
+ iMRoomLevelControl = static_cast<MRoomLevelControl*> (tempCtrl);
+ }
+ break;
+ }
+
+
+ case EDISTATTCONTROL:
+ {
+ status = iFactory->CreateEffectControl( KDistanceAttenuationEffectControl, tempCtrl );
+ if(status == KErrNone)
+ {
+ iMDistanceAttenuationControl = static_cast<MDistanceAttenuationControl*> (tempCtrl);
+ }
+ break;
+ }
+
+ case ELISTDOPPCONTROL:
+ {
+ status = iFactory->CreateEffectControl( KListenerDopplerEffectControl, tempCtrl );
+ if(status == KErrNone)
+ {
+ iMListenerDopplerControl = static_cast<MListenerDopplerControl*> (tempCtrl);
+ }
+ break;
+ }
+
+
+ case ESOURDOPPCONTROL:
+ {
+ status = iFactory->CreateEffectControl( KSourceDopplerEffectControl, tempCtrl );
+ if(status == KErrNone)
+ {
+ iMSourceDopplerControl = static_cast<MSourceDopplerControl*> (tempCtrl);
+ }
+ break;
+ }
+
+
+ case ELISTLOCCONTROL:
+ {
+ status = iFactory->CreateEffectControl( KListenerLocationEffectControl, tempCtrl );
+ if(status == KErrNone)
+ {
+ iMListenerLocationControl = static_cast<MListenerLocationControl*> (tempCtrl);
+ }
+ break;
+ }
+
+ case ESOURLOCCONTROL:
+ {
+ status = iFactory->CreateEffectControl( KSourceLocationEffectControl, tempCtrl );
+ if(status == KErrNone)
+ {
+ iMSourceLocationControl = static_cast<MSourceLocationControl*> (tempCtrl);
+ }
+ break;
+ }
+
+
+ case ELISTORIENTCONTROL:
+ {
+ status = iFactory->CreateEffectControl( KListenerOrientationEffectControl, tempCtrl );
+ if(status == KErrNone)
+ {
+ iMListenerOrientationControl = static_cast<MListenerOrientationControl*> (tempCtrl);
+ }
+ break;
+ }
+
+
+ case ESOURORIENTCONTROL:
+ {
+ status = iFactory->CreateEffectControl( KSourceOrientationEffectControl, tempCtrl );
+ if(status == KErrNone)
+ {
+ iMSourceOrientationControl = static_cast<MSourceOrientationControl*> (tempCtrl);
+ }
+ break;
+ }
+ default:
+ break;
+ };
+ if (status == KErrNone)
+ {
+ iLog->Log(_L("CreateEffect OK"));
+ }
+ else
+ {
+ iLog->Log(_L("CreateEffect FAILED [%d]"),status);
+ }
+
+ //ProcessEvent(ECreateEffect, error);
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::StreamAddEffect(CStifItemParser& aItem)
+ {
+ AddExpectedEvent(EEStreamAddEffect,KShortTimeout);
+ TInt status(KErrNotReady);
+ TInt object;
+ aItem.GetNextInt(object);
+ iLog->Log(_L("StreamAddEffect INIT [%d]"),object);
+
+ switch(object)
+ {
+ case EVOLUMECONTROL:
+ {
+ iEffectControl = iMVolumeControl;
+ }
+ break;
+ case EBALANCECONTROL:
+ {
+ iEffectControl = iMBalanceControl;
+ }
+ break;
+ case EEQUALIZERCONTROL:
+ {
+ iEffectControl = iMEqualizerControl;
+ }
+ break;
+ case EREVERBCONTROL:
+ {
+ iEffectControl = iMReverbControl;
+ }
+ break;
+
+ case EBASSBOOSTCONTROL:
+ {
+ iEffectControl = iMBassBoostControl;
+ }
+ break;
+
+
+ case ESTEREOWIDCONTROL:
+ {
+ iEffectControl = iMStereoWideningControl;
+ }
+ break;
+
+
+ case ELOUDNESSCONTROL:
+ {
+ iEffectControl = iMLoudnessControl;
+ }
+ break;
+
+
+ case EROOMLEVELCONTROL:
+ {
+ iEffectControl = iMRoomLevelControl;
+ }
+ break;
+
+
+ case EDISTATTCONTROL:
+ {
+ iEffectControl = iMDistanceAttenuationControl;
+ }
+ break;
+
+
+ case ELISTDOPPCONTROL:
+ {
+ iEffectControl = iMListenerDopplerControl;
+ }
+ break;
+
+
+ case ESOURDOPPCONTROL:
+ {
+ iEffectControl = iMSourceDopplerControl;
+ }
+ break;
+
+
+ case ELISTLOCCONTROL:
+ {
+ iEffectControl = iMListenerLocationControl;
+ }
+ break;
+
+
+ case ESOURLOCCONTROL:
+ {
+ iEffectControl = iMSourceLocationControl;
+ }
+ break;
+
+
+ case ELISTORIENTCONTROL:
+ {
+ iEffectControl = iMListenerOrientationControl;
+ }
+ break;
+
+
+ case ESOURORIENTCONTROL:
+ {
+ iEffectControl = iMSourceOrientationControl;
+ }
+ break;
+
+ }
+ status = iMStreamControl->AddEffect(*iEffectControl);
+ if (status == KErrNone)
+ {
+ iLog->Log(_L("AddEffect OK"));
+ }
+ else
+ {
+ iLog->Log(_L("AddEffect FAILED [%d]"),status);
+ }
+ iLog->Log(_L("StreamAddEffect END [%d]"),object);
+
+ //ProcessEvent(EEStreamAddEffect, status);
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::AttachReverb (CStifItemParser& /*aItem*/)
+{
+ iLog->Log(_L("CEnhanMediaTestClass::AttachReverb BEGIN"));
+ TInt status(KErrNotReady);
+
+ if (iMReverbControl && iMRoomLevelControl)
+ {
+ status = iMRoomLevelControl->AttachReverb ( *iMReverbControl );
+ }
+
+ if (status == KErrNone)
+ {
+ iLog->Log(_L("CEnhanMediaTestClass::AttachReverb OK"));
+ }
+ else
+ {
+ iLog->Log(_L("CEnhanMediaTestClass::AttachReverb FAILED [%d]"),status);
+ }
+
+ iLog->Log(_L("CEnhanMediaTestClass::AttachReverb END"));
+ return status;
+}
+
+TInt CEnhanMediaTestClass::DetachReverb(CStifItemParser& /*aItem*/)
+{
+ iLog->Log(_L("CEnhanMediaTestClass::DetachReverb BEGIN"));
+ TInt status(KErrNotReady);
+
+ if (iMReverbControl && iMRoomLevelControl)
+ {
+ status = iMRoomLevelControl->DetachReverb( *iMReverbControl );
+ }
+
+ if (status == KErrNone)
+ {
+ iLog->Log(_L("CEnhanMediaTestClass::DetachReverb OK"));
+ }
+ else
+ {
+ iLog->Log(_L("CEnhanMediaTestClass::DetachReverb FAILED [%d]"),status);
+ }
+
+ iLog->Log(_L("CEnhanMediaTestClass::DetachReverb END "));
+ return status;
+}
+
+TInt CEnhanMediaTestClass::AddObserver(CStifItemParser& aItem)
+ {
+ //AddExpectedEvent(EEObserver,KMediumTimeout);
+ TInt object;
+ TInt status = KErrNone;
+ aItem.GetNextInt(object);
+ iLog->Log(_L(" AddObserver = [%d]"),object);
+ switch(object)
+ {
+ case EFILESOURCE:
+ {
+ if(iMFileSource)
+ {
+ iMFileSource->AddObserver(*this);
+ }
+ else
+ {
+ status = KErrNotFound;
+ }
+ break;
+ }
+ case EDATABUFFERSOURCE:
+ {
+ if(iMDataBufferSource)
+ {
+ iMDataBufferSource->AddObserver(*this);
+ }
+ else
+ {
+ status = KErrNotFound;
+ }
+ break;
+ }
+ case EDESCRIPTORSOURCE:
+ {
+ if(iMDescriptorSource)
+ {
+ iMDescriptorSource->AddObserver(*this);
+ }
+ else
+ {
+ status = KErrNotFound;
+ }
+ break;
+ }
+ case ESTREAMCONTROL:
+ {
+ if(iMStreamControl)
+ {
+ iMStreamControl->AddObserver(*this);
+ }
+ else
+ {
+ status = KErrNotFound;
+ }
+ break;
+ }
+ case EMMFAUDIOOUTPUTSINKCONTROL:
+ {
+ if(iMAudioSink)
+ {
+ iMAudioSink->AddObserver(*this);
+ }
+ else
+ {
+ status = KErrNotFound;
+ }
+ break;
+ }
+ case EPDLSOURCE:
+ {
+ if(iMProgDLSource)
+ {
+ iMProgDLSource->AddObserver(*this);
+ }
+ else
+ {
+ status = KErrNotFound;
+ }
+ break;
+ }
+ case EVOLUMECONTROL:
+ {
+ if(iMVolumeControl)
+ {
+ iMVolumeControl->AddObserver(*this);
+ }
+ else
+ {
+ status = KErrNotFound;
+ }
+ break;
+ }
+ case EBALANCECONTROL:
+ {
+ if(iMBalanceControl)
+ {
+ iMBalanceControl->AddObserver(*this);
+ }
+ else
+ {
+ status = KErrNotFound;
+ }
+ break;
+ }
+ case EEQUALIZERCONTROL:
+ {
+ if(iMEqualizerControl)
+ {
+ iMEqualizerControl->AddObserver(*this);
+ }
+ else
+ {
+ status = KErrNotFound;
+ }
+ break;
+ }
+
+ case EREVERBCONTROL:
+ {
+ if(iMReverbControl)
+ {
+ iMReverbControl->AddObserver(*this);
+ }
+ else
+ {
+ status = KErrNotFound;
+ }
+ break;
+ }
+
+ case EBASSBOOSTCONTROL:
+ {
+ if(iMBassBoostControl)
+ {
+ iMBassBoostControl->AddObserver(*this);
+ }
+ else
+ {
+ status = KErrNotFound;
+ }
+ break;
+ }
+
+ case ESTEREOWIDCONTROL:
+ {
+ if(iMStereoWideningControl)
+ {
+ iMStereoWideningControl->AddObserver(*this);
+ }
+ else
+ {
+ status = KErrNotFound;
+ }
+ break;
+ }
+
+ case ELOUDNESSCONTROL:
+ {
+ if(iMLoudnessControl)
+ {
+ iMLoudnessControl->AddObserver(*this);
+ }
+ else
+ {
+ status = KErrNotFound;
+ }
+ break;
+ }
+
+ case EROOMLEVELCONTROL:
+ {
+ if(iMRoomLevelControl)
+ {
+ iMRoomLevelControl->AddObserver(*this);
+ }
+ else
+ {
+ status = KErrNotFound;
+ }
+ break;
+ }
+
+ case EDISTATTCONTROL:
+ {
+ if(iMDistanceAttenuationControl)
+ {
+ iMDistanceAttenuationControl->AddObserver(*this);
+ }
+ else
+ {
+ status = KErrNotFound;
+ }
+ break;
+ }
+
+ case ELISTDOPPCONTROL:
+ {
+ if(iMListenerDopplerControl)
+ {
+ iMListenerDopplerControl->AddObserver(*this);
+ }
+ else
+ {
+ status = KErrNotFound;
+ }
+ break;
+ }
+
+ case ESOURDOPPCONTROL:
+ {
+ if(iMSourceDopplerControl)
+ {
+ iMSourceDopplerControl->AddObserver(*this);
+ }
+ else
+ {
+ status = KErrNotFound;
+ }
+ break;
+ }
+ case ELISTLOCCONTROL:
+ {
+ if(iMListenerLocationControl)
+ {
+ iMListenerLocationControl->AddObserver(*this);
+ }
+ else
+ {
+ status = KErrNotFound;
+ }
+ break;
+ }
+
+ case ESOURLOCCONTROL:
+ {
+ if(iMSourceLocationControl)
+ {
+ iMSourceLocationControl->AddObserver(*this);
+ }
+ else
+ {
+ status = KErrNotFound;
+ }
+ break;
+ }
+
+ case ELISTORIENTCONTROL:
+ {
+ if(iMListenerOrientationControl)
+ {
+ iMListenerOrientationControl->AddObserver(*this);
+ }
+ else
+ {
+ status = KErrNotFound;
+ }
+ break;
+ }
+ case ESOURORIENTCONTROL:
+ {
+ if(iMSourceOrientationControl)
+ {
+ iMSourceOrientationControl->AddObserver(*this);
+ }
+ else
+ {
+ status = KErrNotFound;
+ }
+ break;
+ }
+ default:
+ break;
+ };
+
+ iLog->Log(_L("AddObserver OK [%d]"),status);
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::FileGenOpen(CStifItemParser& /*aItem*/)
+ {
+ //AddExpectedEvent(EEFileSOpen,KMediumTimeout);
+ TInt status(KErrNotReady);
+ TFileName fileName;
+ fileName.Copy(KTagFileTest);
+ if(iFileName)
+ {
+ delete iFileName;
+ iFileName = NULL;
+ }
+ iFileName = HBufC::NewL(fileName.Length());
+ iFileName->Des().Copy(fileName);
+
+
+ iFs.Connect();
+ iIsEOFReached = EFalse;
+ status = iFile.Open(iFs,*iFileName,EFileShareReadersOnly);
+ if (status == KErrNone)
+ {
+ iLog->Log(_L("CEnhanMediaTestClass::FileGenOpen = %d"), status);
+ }
+ else
+ {
+ iLog->Log(_L("CEnhanMediaTestClass::FileGenOpen ERROR = [%d]"), status);
+ }
+ //ProcessEvent(EEFileSOpen, status);
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::DBSMinBufSize(CStifItemParser& /*aItem*/)
+ {
+ TInt status(KErrNotReady);
+ TUint bufferSize =0;
+ if(!iMDataBufferSource)
+ {
+ status = KErrNotReady;
+ }
+ else
+ {
+ status = iMDataBufferSource->GetMinimumBufferSize(bufferSize);
+ }
+ if (status == KErrNone)
+ {
+ iLog->Log(_L("iMDataBufferSource->GetMinimumBufferSize = [%d]"), bufferSize);
+ }
+ else
+ {
+ iLog->Log(_L("iMDataBufferSource->GetMinimumBufferSize ERROR = [%d]"), status);
+ }
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::CreateDataBuffer(CStifItemParser& aItem)
+ {
+ AddExpectedEvent(EEDataBuffer,KMediumTimeout);
+
+ TInt status(KErrNone);
+ TInt bufferSize = 0;
+ TInt numBuffers = 0;
+
+ status = aItem.GetNextInt(bufferSize);
+ if ( status != KErrNone )
+ {
+ iLog->Log(_L("CreateDataBuffer Missing Argument Buffer Size in config file "));
+ return status;
+ }
+ status = aItem.GetNextInt(numBuffers);
+
+ if ( status != KErrNone )
+ {
+ iLog->Log(_L("CreateDataBuffer Missing Argument NumberOfBuffers in config file "));
+ return status;
+ }
+
+ MDataBuffer* buffer;
+ iBuffers.ResetAndDestroy();
+ iAvailable.Reset();
+
+ for (int i = 0; i < numBuffers; i++ )
+ {
+ status = iFactory->CreateDataBuffer(KDataBufferSourceControl,bufferSize,buffer);
+ if(status == KErrNone)
+ {
+ status = iBuffers.Append(buffer);
+ buffer = NULL;
+ iAvailable.AppendL(ETrue);
+ }
+ else
+ {
+ break;
+ }
+ }
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::FileSOpen(CStifItemParser& /*aItem*/)
+ {
+ //AddExpectedEvent(EEFileSOpen,KMediumTimeout);
+ TInt status(KErrNotReady);
+ TFileName fileName;
+ TBuf8<256> mimeType;
+
+ fileName.Copy(KTagFileTest);
+ mimeType.Copy(KTagMimeType);
+
+ if(!iMFileSource)
+ {
+ return KErrNotReady;
+ }
+ if(iFileName)
+ {
+ delete iFileName;
+ iFileName = NULL;
+ }
+ iFileName = HBufC::NewL(fileName.Length());
+ iFileName->Des().Copy(fileName);
+ iMimeType = HBufC8::NewL(mimeType.Length());
+ iMimeType->Des().Copy(mimeType);
+ status = iMFileSource->Open(*iFileName,*iMimeType);
+ if (status == KErrNone)
+ {
+ iLog->Log(_L("CEnhanMediaTestClass::FileSOpen = %d"), status);
+ }
+ else
+ {
+ iLog->Log(_L("CEnhanMediaTestClass::FileSOpen ERROR = [%d]"), status);
+ }
+ //ProcessEvent(EEFileSOpen, status);
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::DescSOpen(CStifItemParser& /*aItem*/)
+ {
+ //AddExpectedEvent(EEFileSOpen,KMediumTimeout);
+ TInt status(KErrNotReady);
+ TBuf8<256> mimeType;
+ mimeType.Copy(KTagMimeType);
+ if(!iMDescriptorSource)
+ {
+ status = KErrNotReady;
+ return status;
+ }
+
+ if(iMimeType)
+ {
+ delete iMimeType;
+ iMimeType = NULL;
+ }
+
+ iMimeType = HBufC8::NewL(mimeType.Length());
+ iMimeType->Des().Copy(mimeType);
+
+ TInt size = 0;
+ iFile.Size(size);
+ if(iDescData)
+ {
+ delete iDescData;
+ iDescData = NULL;
+ }
+
+ iDescData = HBufC8::NewLC(size);
+ TPtr8 des = iDescData->Des();
+ iFile.Read(des);
+
+ status = iMDescriptorSource->Open(*iMimeType,*iDescData);
+ CleanupStack::Pop(iDescData);
+
+ if (status == KErrNone)
+ {
+ iLog->Log(_L("CEnhanMediaTestClass::FileSOpenL = %d"), status);
+ }
+ else
+ {
+ iLog->Log(_L("CEnhanMediaTestClass::FileSOpenL ERROR = [%d]"), status);
+ }
+ //ProcessEvent(EEFileSOpen, status);
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::DBSSetSize(CStifItemParser& aItem)
+ {
+ TInt status(KErrNone);
+ TInt size = 0;
+ status = aItem.GetNextInt(size);
+ if(!iMDataBufferSource)
+ {
+ status = KErrNotReady;
+ }
+ else
+ {
+ status = iMDataBufferSource->SetSize(size);
+ }
+ if (status == KErrNone)
+ {
+ iLog->Log(_L("DBSSetSize = %d"), status);
+ }
+ else
+ {
+ iLog->Log(_L("DBSSetSize ERROR = [%d]"), status);
+ }
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::DBSOpen(CStifItemParser& aItem)
+ {
+ iLog->Log(_L(" CEnhanMediaTestClass::DBSOpen("));
+ AddExpectedEvent(EEDBSOpen,KMediumTimeout);
+ TInt status(KErrNotReady);
+ TBuf8<256> mimeType;
+ TPtrC string;
+ //mimeType.Copy(KTagMimeType);
+
+
+ aItem.SetParsingType( CStifItemParser::EQuoteStyleParsing );
+ status = aItem.GetNextString ( string );
+ if ( status != KErrNone )
+ {
+ iLog->Log(_L("CHelixSTIFClient:: MimeType missing in config file "));
+ return status;
+ }
+ else
+ {
+ mimeType.Copy(string);
+ }
+
+
+ if(!iMDataBufferSource)
+ {
+ return status = KErrNotReady;
+ }
+
+
+ if(iMimeType)
+ {
+ delete iMimeType;
+ iMimeType = NULL;
+ }
+
+ iMimeType = HBufC8::NewL(mimeType.Length());
+ iMimeType->Des().Copy(mimeType);
+
+ MDataBuffer* headerData(NULL);
+ status = iMDataBufferSource->Open(*iMimeType,*headerData);
+
+ if (status == KErrNone)
+ {
+ iLog->Log(_L("CEnhanMediaTestClass::FileSOpenL = %d"), status);
+ }
+ else
+ {
+ iLog->Log(_L("CEnhanMediaTestClass::FileSOpenL ERROR = [%d]"), status);
+ }
+ //ProcessEvent(EEFileSOpen, status);
+ iLog->Log(_L(" CEnhanMediaTestClass::DBSOpen END"));
+ return status;
+ }
+TInt CEnhanMediaTestClass::StreamRemoveSource(CStifItemParser& aItem)
+ {
+ //AddExpectedEvent(EEAddSource,KShortTimeout);
+ TInt status(KErrNone);
+ TInt controlType;
+ aItem.GetNextInt(controlType);
+ iLog->Log(_L(" CEnhanMediaTestClass::StreamRemoveSource INIT [%d]"),controlType);
+ switch(controlType)
+ {
+ case EFILESOURCE:
+ {
+ iSourceControl = iMFileSource;
+ }
+ break;
+ case EDATABUFFERSOURCE:
+ {
+ iSourceControl = iMDataBufferSource;
+ }
+ break;
+ case EDESCRIPTORSOURCE:
+ {
+ iSourceControl = iMDescriptorSource;
+ }
+ break;
+ case EPDLSOURCE:
+ {
+ iSourceControl = iMProgDLSource;
+ }
+ break;
+ }
+
+ status = iMStreamControl->RemoveSource(*iSourceControl);
+ if (status == KErrNone)
+ {
+ iLog->Log(_L("RemoveSource = %d"), status);
+ }
+ else
+ {
+ iLog->Log(_L("StreamRemoveSource ERROR = [%d]"), status);
+ }
+ //ProcessEvent(EStreamAddSource, status);
+ iLog->Log(_L(" CEnhanMediaTestClass::StreamRemoveSource END [%d]"),controlType);
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::StreamAddSource(CStifItemParser& aItem)
+ {
+ //AddExpectedEvent(EEAddSource,KShortTimeout);
+ TInt status(KErrNone);
+ TInt controlType;
+ aItem.GetNextInt(controlType);
+ iLog->Log(_L(" CEnhanMediaTestClass::StreamAddSource INIT [%d]"),controlType);
+ switch(controlType)
+ {
+ case EFILESOURCE:
+ {
+ iSourceControl = iMFileSource;
+ }
+ break;
+ case EDATABUFFERSOURCE:
+ {
+ iSourceControl = iMDataBufferSource;
+ }
+ break;
+ case EDESCRIPTORSOURCE:
+ {
+ iSourceControl = iMDescriptorSource;
+ }
+ break;
+ case EPDLSOURCE:
+ {
+ iSourceControl = iMProgDLSource;
+ }
+ break;
+ }
+ status = iMStreamControl->AddSource(*iSourceControl);
+ if (status == KErrNone)
+ {
+ iLog->Log(_L("AddSource = %d"), status);
+ }
+ else
+ {
+ iLog->Log(_L("AddSource ERROR = [%d]"), status);
+ }
+ //ProcessEvent(EStreamAddSource, status);
+ iLog->Log(_L(" CEnhanMediaTestClass::StreamAddSource END [%d]"),controlType);
+ return status;
+ }
+TInt CEnhanMediaTestClass::StreamAddSink(CStifItemParser& /*aItem*/)
+ {
+ //AddExpectedEvent(EEStreamAddSink,KShortTimeout);
+ iLog->Log(_L(" CEnhanMediaTestClass::StreamAddSink INIT"));
+ TInt status(KErrNone);
+ status = iMStreamControl->AddSink(*iMAudioSink);
+ if (status == KErrNone)
+ {
+ iLog->Log(_L("AddSink = %d"), status);
+ }
+ else
+ {
+ iLog->Log(_L("AddSink ERROR = [%d]"), status);
+ }
+ //ProcessEvent(EStreamAddSink, status);
+ iLog->Log(_L(" CEnhanMediaTestClass::StreamAddSink END"));
+
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::StreamRemoveSink(CStifItemParser& /*aItem*/)
+ {
+ iLog->Log(_L(" CEnhanMediaTestClass::StreamRemoveSink INIT"));
+ TInt status(KErrNone);
+ status = iMStreamControl->RemoveSink(*iMAudioSink);
+ if (status == KErrNone)
+ {
+ iLog->Log(_L("RemoveSink = %d"), status);
+ }
+ else
+ {
+ iLog->Log(_L("RemoveSink ERROR = [%d]"), status);
+ }
+ //ProcessEvent(EStreamAddSink, status);
+ iLog->Log(_L(" CEnhanMediaTestClass::StreamRemoveSink END"));
+
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::StreamOpen(CStifItemParser& /*aItem*/)
+ {
+
+ //RemoveAllExpectedEvents();
+ TInt status(KErrNone);
+ AddExpectedEvent(EEStreamOpen,KMediumTimeout);
+ if ( !iMStreamControl )
+ {
+ status = KErrNotReady;
+ iLog->Log(_L("CEnhanMediaTestClass::StreamOpenL = %d"), status);
+ }
+
+ status = iMStreamControl->Open();
+ if (status == KErrNone)
+ {
+ iLog->Log(_L("iMStreamControl->Open() = %d"), status);
+ }
+ else
+ {
+ iLog->Log(_L("iMStreamControl->Open() ERROR = [%d]"), status);
+ }
+ //ProcessEvent(EEStreamOpen, aEventType);
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::StreamClose(CStifItemParser& /*aItem*/)
+ {
+ TInt status(KErrNotReady);
+ TInt state;
+ state=iMStreamControl->GetState();
+ AddExpectedEvent(EEStreamClose,KMediumTimeout);
+ if ( !iMStreamControl )
+ {
+ status = KErrNotReady;
+ }
+ else
+ {
+ iLog->Log(_L("iMStreamControl->GetState() = %d"), state);
+ if (iMProgDLSource)
+ {
+ status = iMProgDLSource->Close();
+ }
+ status = iMStreamControl->Close();
+ iLog->Log(_L("iMStreamControl->GetState() = %d"), iMStreamControl->GetState());
+
+ }
+ if (status == KErrNone)
+ {
+ iLog->Log(_L("iMStreamControl->Close = %d"), status);
+ }
+ else
+ {
+ iLog->Log(_L("iMStreamControl->Close ERROR = [%d]"), status);
+ }
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::RemoveObserver(CStifItemParser& aItem)
+ {
+ TInt status(KErrNone);
+ TInt controlType;
+ aItem.GetNextInt(controlType);
+ iLog->Log(_L("RemoveObserver = [%d]"), controlType);
+ switch(controlType)
+ {
+ case EFILESOURCE:
+ {
+ if(iMFileSource)
+ {
+ iMFileSource->RemoveObserver(*this);
+ }
+ else
+ {
+ status = KErrNotFound;
+ }
+ break;
+ }
+ case EDATABUFFERSOURCE:
+ {
+ if(iMDataBufferSource)
+ {
+ iMDataBufferSource->RemoveObserver(*this);
+ }
+ else
+ {
+ status = KErrNotFound;
+ }
+ break;
+ }
+ case EDESCRIPTORSOURCE:
+ {
+ if(iMDescriptorSource)
+ {
+ iMDescriptorSource->RemoveObserver(*this);
+ }
+ else
+ {
+ status = KErrNotFound;
+ }
+ break;
+ }
+ case ESTREAMCONTROL:
+ {
+ if(iMStreamControl)
+ {
+ iMStreamControl->RemoveObserver(*this);
+ }
+ else
+ {
+ status = KErrNotFound;
+ }
+ break;
+ }
+ case EMMFAUDIOOUTPUTSINKCONTROL:
+ {
+ if(iMAudioSink)
+ {
+ iMAudioSink->RemoveObserver(*this);
+ }
+ else
+ {
+ status = KErrNotFound;
+ }
+ break;
+ }
+ case EPDLSOURCE:
+ {
+ if(iMProgDLSource)
+ {
+ iMProgDLSource->RemoveObserver(*this);
+ }
+ else
+ {
+ status = KErrNotFound;
+ }
+ break;
+ }
+ case EVOLUMECONTROL:
+ {
+ if(iMVolumeControl)
+ {
+ iMVolumeControl->RemoveObserver(*this);
+ }
+ else
+ {
+ status = KErrNotFound;
+ }
+ break;
+ }
+ case EBALANCECONTROL:
+ {
+ if(iMBalanceControl)
+ {
+ iMBalanceControl->RemoveObserver(*this);
+ }
+ else
+ {
+ status = KErrNotFound;
+ }
+ break;
+ }
+ case EEQUALIZERCONTROL:
+ {
+ if(iMEqualizerControl)
+ {
+ iMEqualizerControl->RemoveObserver(*this);
+ }
+ else
+ {
+ status = KErrNotFound;
+ }
+ break;
+ }
+ case EREVERBCONTROL:
+ {
+ if(iMReverbControl)
+ {
+ iMReverbControl->RemoveObserver(*this);
+ }
+ else
+ {
+ status = KErrNotFound;
+ }
+ break;
+ }
+
+ case EBASSBOOSTCONTROL:
+ {
+ if(iMBassBoostControl)
+ {
+ iMBassBoostControl->RemoveObserver(*this);
+ }
+ else
+ {
+ status = KErrNotFound;
+ }
+ break;
+ }
+
+ case ESTEREOWIDCONTROL:
+ {
+ if(iMStereoWideningControl)
+ {
+ iMStereoWideningControl->RemoveObserver(*this);
+ }
+ else
+ {
+ status = KErrNotFound;
+ }
+ break;
+ }
+
+ case ELOUDNESSCONTROL:
+ {
+ if(iMLoudnessControl)
+ {
+ iMLoudnessControl->RemoveObserver(*this);
+ }
+ else
+ {
+ status = KErrNotFound;
+ }
+ break;
+ }
+
+ case EROOMLEVELCONTROL:
+ {
+ if(iMRoomLevelControl)
+ {
+ iMRoomLevelControl->RemoveObserver(*this);
+ }
+ else
+ {
+ status = KErrNotFound;
+ }
+ break;
+ }
+
+ case EDISTATTCONTROL:
+ {
+ if(iMDistanceAttenuationControl)
+ {
+ iMDistanceAttenuationControl->RemoveObserver(*this);
+ }
+ else
+ {
+ status = KErrNotFound;
+ }
+ break;
+ }
+
+ case ELISTDOPPCONTROL:
+ {
+ if(iMListenerDopplerControl)
+ {
+ iMListenerDopplerControl->RemoveObserver(*this);
+ }
+ else
+ {
+ status = KErrNotFound;
+ }
+ break;
+ }
+
+ case ESOURDOPPCONTROL:
+ {
+ if(iMSourceDopplerControl)
+ {
+ iMSourceDopplerControl->RemoveObserver(*this);
+ }
+ else
+ {
+ status = KErrNotFound;
+ }
+ break;
+ }
+
+ case ELISTLOCCONTROL:
+ {
+ if(iMListenerLocationControl)
+ {
+ iMListenerLocationControl->RemoveObserver(*this);
+ }
+ else
+ {
+ status = KErrNotFound;
+ }
+ break;
+ }
+
+ case ESOURLOCCONTROL:
+ {
+ if(iMSourceLocationControl)
+ {
+ iMSourceLocationControl->RemoveObserver(*this);
+ }
+ else
+ {
+ status = KErrNotFound;
+ }
+ break;
+ }
+
+
+ case ELISTORIENTCONTROL:
+ {
+ if(iMListenerOrientationControl)
+ {
+ iMListenerOrientationControl->RemoveObserver(*this);
+ }
+ else
+ {
+ status = KErrNotFound;
+ }
+ break;
+ }
+
+ case ESOURORIENTCONTROL:
+ {
+ break;
+ }
+
+ };
+ if (status == KErrNone)
+ {
+ iLog->Log(_L("RemoveObserver = %d"), status);
+ }
+ else
+ {
+ iLog->Log(_L("RemoveObserver ERROR = [%d]"), status);
+ }
+ //ProcessEvent(EEObserver, status);
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::StreamPrime(CStifItemParser& /*aItem*/)
+ {
+ TInt status(KErrNone);
+ AddExpectedEvent(EEStreamPrime,KMediumTimeout);
+ if ( !iMStreamControl )
+ {
+ status = KErrNotReady;
+ iLog->Log(_L("CEnhanMediaTestClass::StreamOpenL = %d"), status);
+ }
+ status = iMStreamControl->Prime();
+ if (status == KErrNone)
+ {
+ iLog->Log(_L("StreamPrime = %d"), status);
+ }
+ else
+ {
+ iLog->Log(_L("StreamPrime ERROR = [%d]"), status);
+ }
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::StreamStart(CStifItemParser& /*aItem*/)
+ {
+ TInt status(KErrNone);
+ iLog->Log(_L("StreamStart "));
+ AddExpectedEvent(EEStreamStart,KMediumTimeout);
+ if ( !iMStreamControl )
+ {
+ status = KErrNotReady;
+ iLog->Log(_L("StreamStart = %d"), status);
+ }
+ status = iMStreamControl->Start();
+ if (status == KErrNone)
+ {
+ iLog->Log(_L("StreamStart = %d"), status);
+ }
+ else
+ {
+ iLog->Log(_L("StreamStart ERROR = [%d]"), status);
+ }
+ iLog->Log(_L("StreamStart END"));
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::StreamPause(CStifItemParser& /*aItem*/)
+ {
+ TInt status(KErrNone);
+ iLog->Log(_L("StreamPause *-*-*-*-*-*"));
+ AddExpectedEvent(EEStreamPause,KMediumTimeout);
+ if ( !iMStreamControl )
+ {
+ status = KErrNotReady;
+ iLog->Log(_L("StreamPause = %d"), status);
+ }
+ status = iMStreamControl->Pause();
+ if (status == KErrNone)
+ {
+ iLog->Log(_L("StreamPause = %d"), status);
+ }
+ else
+ {
+ iLog->Log(_L("StreamPause ERROR = [%d]"), status);
+ }
+ iLog->Log(_L("StreamPause END"));
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::StreamStop(CStifItemParser& /*aItem*/)
+ {
+ TInt status(KErrNone);
+ //AddExpectedEvent(EEStreamPause,KMediumTimeout);
+ iLog->Log(_L("StreamStop "));
+ if ( !iMStreamControl )
+ {
+ status = KErrNotReady;
+ iLog->Log(_L("StreamStart = %d"), status);
+ }
+ status = iMStreamControl->Stop();
+ if (status == KErrNone)
+ {
+ iLog->Log(_L("StreamStop = %d"), status);
+ }
+ else
+ {
+ iLog->Log(_L("StreamStop ERROR = [%d]"), status);
+ }
+ iLog->Log(_L("StreamStop END "));
+ return status;
+ }
+
+
+TInt CEnhanMediaTestClass::EqualizerBandLevel(CStifItemParser& aItem)
+ {
+ TInt status(KErrNone);
+ TInt band;
+ TInt bandlevel;
+
+ status = aItem.GetNextInt(band);
+ if (status != KErrNone)
+ {
+ iLog->Log(_L("EqualizerBandLevel ERROR = [%d]"), status);
+ return status;
+ }
+ if(!iEffectControl)
+ {
+ status = KErrNotReady;
+ }
+ status = static_cast<MEqualizerControl*>(iEffectControl)->BandLevel(band,bandlevel);
+ if (status == KErrNone)
+ {
+ iLog->Log(_L("EqualizerBandLevel status = %d"), status);
+ }
+ else
+ {
+ iLog->Log(_L("EqualizerBandLevel ERROR = [%d]"), status);
+ }
+ return status;
+ }
+TInt CEnhanMediaTestClass::EqualizerNumBands (CStifItemParser& /*aItem*/)
+ {
+ TInt status(KErrNone);
+ TInt bands;
+
+ if(!iEffectControl)
+ {
+ status = KErrNotReady;
+ }
+
+ status = static_cast<MEqualizerControl*>(iEffectControl)->NumberOfBands(bands);
+
+ if (status == KErrNone)
+ {
+ iLog->Log(_L("EqualizerNumBands status = %d"), status);
+ }
+ else
+ {
+ iLog->Log(_L("EqualizerNumBands ERROR = [%d]"), status);
+ }
+
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::EqualizerBandWidth (CStifItemParser& aItem)
+ {
+ TInt status(KErrNone);
+ TInt band;
+ TInt bandwidth;
+
+ status = aItem.GetNextInt(band);
+ if (status != KErrNone)
+ {
+ iLog->Log(_L("EqualizerBandWidth ERROR = [%d]"), status);
+ return status;
+ }
+
+ if(!iEffectControl)
+ {
+ status = KErrNotReady;
+ }
+
+ status = static_cast<MEqualizerControl*>(iEffectControl)->BandWidth(band,bandwidth);
+
+ if (status == KErrNone)
+ {
+ iLog->Log(_L("EqualizerBandWidth status = %d"), status);
+ }
+ else
+ {
+ iLog->Log(_L("EqualizerBandWidth ERROR = [%d]"), status);
+ }
+
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::EqualizerCenterFrequency (CStifItemParser& aItem)
+ {
+ TInt status(KErrNone);
+ TInt band;
+ TInt freq;
+
+ status = aItem.GetNextInt(band);
+ if (status != KErrNone)
+ {
+ iLog->Log(_L("EqualizerCenterFrequency ERROR = [%d]"), status);
+ return status;
+ }
+
+ if(!iEffectControl)
+ {
+ status = KErrNotReady;
+ }
+
+ status = static_cast<MEqualizerControl*>(iEffectControl)->CenterFrequency(band,freq);
+
+ if (status == KErrNone)
+ {
+ iLog->Log(_L("EqualizerCenterFrequency status = %d"), status);
+ }
+ else
+ {
+ iLog->Log(_L("EqualizerCenterFrequency ERROR = [%d]"), status);
+ }
+
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::EqualizerCrossoverFrequency (CStifItemParser& aItem)
+ {
+ TInt status(KErrNone);
+ TInt band;
+ TInt freq;
+
+ status = aItem.GetNextInt(band);
+ if (status != KErrNone)
+ {
+ iLog->Log(_L("EqualizerCrossoverFrequency ERROR = [%d]"), status);
+ return status;
+ }
+
+ if(!iEffectControl)
+ {
+ status = KErrNotReady;
+ }
+
+ status = static_cast<MEqualizerControl*>(iEffectControl)->CrossoverFrequency(band,freq);
+
+ if (status == KErrNone)
+ {
+ iLog->Log(_L("EqualizerCrossoverFrequency status = %d"), status);
+ }
+ else
+ {
+ iLog->Log(_L("EqualizerCrossoverFrequency ERROR = [%d]"), status);
+ }
+
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::EqualizerDbLevelLimits (CStifItemParser& /*aItem*/)
+ {
+ TInt status(KErrNone);
+ TInt min, max;
+
+ if(!iEffectControl)
+ {
+ status = KErrNotReady;
+ }
+
+ status = static_cast<MEqualizerControl*>(iEffectControl)->DbLevelLimits(min,max);
+
+ if (status == KErrNone)
+ {
+ iLog->Log(_L("EqualizerDbLevelLimits status = %d"), status);
+ }
+ else
+ {
+ iLog->Log(_L("EqualizerDbLevelLimits ERROR = [%d]"), status);
+ }
+
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::EqualizerSetBandLevel (CStifItemParser& aItem)
+ {
+ TInt status(KErrNone);
+ TInt band, bandlevel;
+
+ status = aItem.GetNextInt(band);
+ if (status != KErrNone)
+ {
+ iLog->Log(_L("EqualizerSetBandLevel on band variable, ERROR = [%d]"), status);
+ return status;
+ }
+
+ status = aItem.GetNextInt(bandlevel);
+ if (status != KErrNone)
+ {
+ iLog->Log(_L("EqualizerSetBandLevel on bandlevel variable, ERROR = [%d]"), status);
+ return status;
+ }
+
+ if(!iEffectControl)
+ {
+ status = KErrNotReady;
+ }
+
+ status = static_cast<MEqualizerControl*>(iEffectControl)->SetBandLevel(band, bandlevel);
+
+ if (status == KErrNone)
+ {
+ iLog->Log(_L("EqualizerSetBandLevel status = %d"), status);
+ }
+ else
+ {
+ iLog->Log(_L("EqualizerSetBandLevel ERROR = [%d]"), status);
+ }
+
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::DescSGetBitRate(CStifItemParser& /*aItem*/)
+ {
+ TInt status(KErrNone);
+ TUint bitrate = 0;
+
+ if(!iMDescriptorSource)
+ {
+ return status = KErrNotReady;
+ }
+ status = iMDescriptorSource->GetBitRate(bitrate);
+ if (status == KErrNone)
+ {
+ iLog->Log(_L("iMDescriptorSource->GetBitRate() = [%d]"), bitrate);
+ }
+ else
+ {
+ iLog->Log(_L("iMDescriptorSource->GetBitRate ERROR = [%d]"), status);
+ }
+ return status;
+ }
+
+void CEnhanMediaTestClass::WriteLoop(CStifItemParser& aItem)
+ {
+ AddExpectedEvent(EEWriteToStream,KMediumTimeout);
+ iLog->Log(_L("WriteLoop INIT"));
+ aItem.GetNextInt(iAutoWriteBuffer);
+ TInt index = iAvailable.Find(ETrue);
+ while ( (index != KErrNotFound ) && (!iIsEOFReached))
+ {
+ User::LeaveIfError( ReadFromFileAndWriteToStream( index ) );
+ // Exit the loop if file EOF.
+ if ( !iIsEOFReached )
+ {
+ // Get the next free buffer
+ index = iAvailable.Find(ETrue);
+ }
+ }
+ iLog->Log(_L("WriteLoop END"));
+ }
+
+TInt CEnhanMediaTestClass::ReadFromFileAndWriteToStream(TInt aIndex)
+ {
+ iLog->Log(_L("ReadFromFileAndWriteToStream INIT"));
+ MDataBuffer* buffer = iBuffers[aIndex];
+ // Read data into CAudioBuffer
+ iFile.Read( buffer->GetBufferPtr() );
+ iBytesReadFromFile += buffer->GetBufferPtr().Length();
+
+ if ( buffer->GetBufferPtr().Length() < buffer->GetBufferPtr().MaxLength() )
+ {
+ // Last buffer is reached, set the flag
+ buffer->SetLastBuffer( ETrue );
+ iIsEOFReached = ETrue;
+ }
+ else
+ {
+ buffer->SetLastBuffer(EFalse);
+ }
+
+ // Write data into iMDataBufferSource
+ #ifdef _DEBUG
+ RDebug::Print(_L("CEnhanMediaTestClass::ReadFromFileAndWriteToStream\
+ [AudioBuffer[0x%x]FileSize[%d]BytesRead[%d]]") , buffer, iFileSizeInBytes, iBytesReadFromFile );
+ #endif
+ TInt err(KErrNone);
+ err = iMDataBufferSource->WriteData( *buffer );
+
+ if (err == KErrNone)
+ {
+ iAvailable[aIndex] = EFalse;
+ }
+ else if ( err == KErrOverflow )
+ {
+ // There isn't enough memory in the player to buffer the data.
+ // reset the file pos
+ TInt size = -(buffer->GetBufferPtr().Length());
+ iFile.Seek( ESeekCurrent, size );
+ iBytesReadFromFile -= size;
+ }
+ iLog->Log(_L("ReadFromFileAndWriteToStream END"));
+
+ return err;
+ // iAutoWriteBuffer
+ }
+
+TInt CEnhanMediaTestClass::GetBuffConfig(CStifItemParser& /*aItem*/)
+ {
+ iLog->Log(_L("GetBuffConfig INIT"));
+ TInt status(KErrNone);
+ TInt buffer=0;
+ TPckgBuf<TBufferingConfig> pckg;
+ TIpcArgs args(&pckg);
+
+ if(!iMDataBufferSource)
+ {
+ status = KErrNotReady;
+ }
+ else
+ {
+ status = iMDataBufferSource->GetBufferingConfig(pckg());
+ }
+ if (status == KErrNone)
+ {
+ iLog->Log(_L("iMDataBufferSource->GetBufferingConfig = [%d]"), buffer);
+ }
+ else
+ {
+ iLog->Log(_L("iMDataBufferSource->GetBufferingConfig ERROR = [%d]"), status);
+ }
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::DBSSetBuffConfig(CStifItemParser& aItem)
+ {
+ iLog->Log(_L("DBSSetBuffConfig "));
+ TInt status(KErrNone);
+ TIpcArgs args;
+ TInt type=0;
+ TInt amount=0;
+ TPckgBuf<TBufferingConfig> pckg;
+ status = aItem.GetNextInt(type);
+
+ if ( status != KErrNone )
+ {
+ iLog->Log(_L("DBSSetBufConfig Missing Argument Type in config file "));
+ return status;
+ }
+ else
+ {
+ pckg().iType = TBufferingConfig::TBufferingType(type);
+ }
+
+ status = aItem.GetNextInt(amount);
+ if ( status != KErrNone )
+ {
+ iLog->Log(_L("DBSSetBufConfigL Missing Argument Amount in config file "));
+ return status;
+ }
+ else
+ {
+ pckg().iAmount = amount;
+ }
+
+ if(!iMDataBufferSource)
+ {
+ status = KErrNotReady;
+ }
+ else
+ {
+ status = iMDataBufferSource->SetBufferingConfig(pckg());
+ }
+ iLog->Log(_L("DBSSetBuffConfig END"));
+
+ return status;
+ }
+TInt CEnhanMediaTestClass::DBSGetBuffType(CStifItemParser& /*aItem*/)
+ {
+ iLog->Log(_L("CEnhanMediaTestClass::DBSGetBuffType "));
+ TInt status(KErrNone);
+ RArray<TBufferingConfig::TBufferingType> aArray;
+ TArray<TBufferingConfig::TBufferingType> array = aArray.Array();
+
+ if(!iMDataBufferSource)
+ {
+ return status = KErrNotReady;
+ }
+
+ status = iMDataBufferSource->GetBufferingTypesSupported(array);
+ aArray.Reset();
+ aArray.Close();
+ iLog->Log(_L("CEnhanMediaTestClass::DBSGetBuffType END [%d]"),status);
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::DBSGetInterface(CStifItemParser& /*aItem*/)
+ {
+ TInt status(KErrNone);
+ iLog->Log(_L("CEnhanMediaTestClass::DBSGetInterface "));
+ // For descriptor source set DRM Type and allowed output
+ if (iMDataBufferSource)
+ {
+ if (iDRMConfigIntfc)
+ {
+ delete iDRMConfigIntfc;
+ iDRMConfigIntfc = NULL;
+ }
+ TAny* intfc(NULL);
+ TVersion ver(KDRMConfigIntfcMajorVer1, KDRMConfigIntfcMinorVer1, KDRMConfigIntfcBuildVer1);
+ TInt status = iMDataBufferSource->GetInterface(KDRMConfigIntfc,
+ ver,
+ intfc);
+ if (status == KErrNone)
+ {
+ iDRMConfigIntfc = (CDRMConfigIntfc*)intfc;
+ }
+ }
+ AddExpectedEvent(EEDBSGetInterface,KShortTimeout);
+ iLog->Log(_L("CEnhanMediaTestClass::DBSGetInterface END"));
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::DBSGetBitRate(CStifItemParser& /*aItem*/)
+ {
+
+ iLog->Log(_L("CEnhanMediaTestClass::DBSGetBitRate "));
+ TInt status(KErrNone);
+ TUint bitrate = 0;
+ if(!iMDataBufferSource)
+ {
+ status = KErrNotReady;
+ }
+ else
+ {
+ status = iMDataBufferSource->GetBitRate(bitrate);
+ }
+ iLog->Log(_L("CEnhanMediaTestClass::DBSGetBitRate "));
+
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::DBSGetSize(CStifItemParser& /*aItem*/)
+ {
+
+ iLog->Log(_L("CEnhanMediaTestClass::DBSGetSize "));
+ TInt status(KErrNone);
+ TUint sizes = 0;
+ if(!iMDataBufferSource)
+ {
+ status = KErrNotReady;
+ }
+ else
+ {
+ status = iMDataBufferSource->GetSize(sizes);
+ }
+ iLog->Log(_L("CEnhanMediaTestClass::DBSGetSize [%d]"), status);
+
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::DBSClose(CStifItemParser& /*aItem*/)
+ {
+
+ iLog->Log(_L("CEnhanMediaTestClass::DBSClose "));
+ TInt status(KErrNone);
+ if(!iMDataBufferSource)
+ {
+ status = KErrNotReady;
+ }
+ else
+ {
+ iMDataBufferSource->EmptyBuffers();
+ status = iMDataBufferSource->Close();
+ }
+ iLog->Log(_L("CEnhanMediaTestClass::DBSClose [%d]"), status);
+
+ return status;
+ }
+
+
+TInt CEnhanMediaTestClass::DSGetSize(CStifItemParser& /*aItem*/)
+ {
+
+ iLog->Log(_L("CEnhanMediaTestClass::DSGetSize "));
+ TInt status(KErrNone);
+ TUint sizes = 0;
+ if(!iMDescriptorSource)
+ {
+ status = KErrNotReady;
+ }
+ else
+ {
+ status = iMDescriptorSource->GetSize(sizes);
+ }
+ iLog->Log(_L("CEnhanMediaTestClass::DSGetSize [%d]"), status);
+
+ return status;
+ }
+TInt CEnhanMediaTestClass::DeleteDataBuffer(CStifItemParser& /*aItem*/)
+ {
+
+ iLog->Log(_L("CEnhanMediaTestClass::DeleteDataBuffer "));
+ AddExpectedEvent(EEDeleteBuffer,KMediumTimeout);
+ TInt status(KErrNone);
+ MDataBuffer* temp ;
+ while(iBuffers.Count())
+ {
+ temp = iBuffers[0];
+ iBuffers.Remove(0);
+ status = iFactory->DeleteDataBuffer(temp);
+ }
+ iAvailable.Reset();
+ iBuffers.ResetAndDestroy();
+ iLog->Log(_L("CEnhanMediaTestClass::DeleteDataBuffer "));
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::VolGetMinVolume(CStifItemParser& /*aItem*/)
+ {
+
+ iLog->Log(_L("CEnhanMediaTestClass::VolGetMinVolume "));
+ TInt status(KErrNone);
+
+ TInt volume=0;
+ if(!iMVolumeControl)
+ {
+ return status = KErrNotReady;
+ }
+ status = iMVolumeControl->GetMinVolume(volume);
+ iLog->Log(_L("CEnhanMediaTestClass::VolGetMinVolume [%d]"),volume);
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::VolGetMaxVolume(CStifItemParser& /*aItem*/)
+ {
+
+ iLog->Log(_L("CEnhanMediaTestClass::VolGetMaxVolume "));
+ TInt status(KErrNone);
+ TInt volume=0;
+ if(!iMVolumeControl)
+ {
+ return status = KErrNotReady;
+ }
+ status = iMVolumeControl->GetMaxVolume(volume);
+ iLog->Log(_L("CEnhanMediaTestClass::VolGetMaxVolume [%d]"),volume);
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::VolGetVolume(CStifItemParser& /*aItem*/)
+ {
+
+ iLog->Log(_L("CEnhanMediaTestClass::VolGetVolume "));
+ TInt status(KErrNone);
+ TInt volume=0;
+ if(!iMVolumeControl)
+ {
+ return status = KErrNotReady;
+ }
+ status = iMVolumeControl->GetVolume(volume);
+ iLog->Log(_L("CEnhanMediaTestClass::VolGetVolume [%d]"),volume);
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::VolGetDefaultVolume(CStifItemParser& /*aItem*/)
+ {
+
+ iLog->Log(_L("CEnhanMediaTestClass::VolGetDefaultVolume "));
+ TInt status(KErrNone);
+ TInt volume=0;
+ if(!iMVolumeControl)
+ {
+ return status = KErrNotReady;
+ }
+ status = iMVolumeControl->GetDefaultVolume(volume);
+ iLog->Log(_L("CEnhanMediaTestClass::VolGetDefaultVolume [%d]"),volume);
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::VolSetVolume(CStifItemParser& aItem)
+ {
+ TInt volume;
+ TInt status(KErrNone);
+ iLog->Log(_L("VolSetVolume INIT"));
+ aItem.GetNextInt(volume);
+ status = iMVolumeControl->SetVolume(volume);
+ if (status!=KErrNone)
+ {
+ iLog->Log(_L("VolSetVolume FAILED"));
+ }
+ else
+ {
+ iLog->Log(_L("VolSetVolume OK"));
+ }
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::BalGetBalance(CStifItemParser& /*aItem*/)
+ {
+
+ iLog->Log(_L("CEnhanMediaTestClass::BalGetBalance "));
+ TInt status(KErrNone);
+ TInt balance=0;
+ if(!iMBalanceControl)
+ {
+ return status = KErrNotReady;
+ }
+ status = iMBalanceControl->GetBalance(balance);
+ iLog->Log(_L("CEnhanMediaTestClass::BalGetBalance [%d]"),balance);
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::BalSetBalance(CStifItemParser& aItem)
+ {
+ TInt balance;
+ TInt status(KErrNone);
+ iLog->Log(_L("BalSetBalance INIT"));
+ aItem.GetNextInt(balance);
+ status = iMBalanceControl->SetBalance(balance);
+ if (status!=KErrNone)
+ {
+ iLog->Log(_L("BalSetBalance FAILED"));
+ }
+ else
+ {
+ iLog->Log(_L("BalSetBalance OK"));
+ }
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::EffectApply(CStifItemParser& aItem)
+ {
+ TInt control;
+ TInt status(KErrNone);
+ iLog->Log(_L("EffectApply INIT"));
+ aItem.GetNextInt(control);
+
+ switch(TControl(control))
+ {
+ case EVOLUMECONTROL:
+ {
+ iEffectControl = iMVolumeControl;
+ }
+ break;
+ case EBALANCECONTROL:
+ {
+ iEffectControl = iMBalanceControl;
+ }
+ break;
+ case EEQUALIZERCONTROL:
+ {
+ iEffectControl = iMEqualizerControl;
+ }
+ break;
+ case EREVERBCONTROL:
+ {
+ iEffectControl = iMReverbControl;
+ }
+ break;
+ case EBASSBOOSTCONTROL:
+ {
+ iEffectControl = iMBassBoostControl;
+ }
+ break;
+
+ case ESTEREOWIDCONTROL:
+ {
+ iEffectControl = iMStereoWideningControl;
+ }
+ break;
+
+
+ case ELOUDNESSCONTROL:
+ {
+ iEffectControl = iMLoudnessControl;
+ }
+ break;
+
+
+ case EROOMLEVELCONTROL:
+ {
+ iEffectControl = iMRoomLevelControl;
+ }
+ break;
+
+
+ case EDISTATTCONTROL:
+ {
+ iEffectControl = iMDistanceAttenuationControl;
+ }
+ break;
+
+
+ case ELISTDOPPCONTROL:
+ {
+ iEffectControl = iMListenerDopplerControl;
+ }
+ break;
+
+
+ case ESOURDOPPCONTROL:
+ {
+ iEffectControl = iMSourceDopplerControl;
+ }
+ break;
+
+
+ case ELISTLOCCONTROL:
+ {
+ iEffectControl = iMListenerLocationControl;
+ }
+ break;
+
+
+ case ESOURLOCCONTROL:
+ {
+ iEffectControl = iMSourceLocationControl;
+ }
+ break;
+
+
+ case ELISTORIENTCONTROL:
+ {
+ iEffectControl = iMListenerOrientationControl;
+ }
+ break;
+
+
+ case ESOURORIENTCONTROL:
+ {
+ iEffectControl = iMSourceOrientationControl;
+ }
+ break;
+ }
+ status = iEffectControl->Apply();
+ if (status!=KErrNone)
+ {
+ iLog->Log(_L("EffectApply FAILED"));
+ }
+ else
+ {
+ iLog->Log(_L("EffectApply OK"));
+ }
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::VolSetVolumeRamp(CStifItemParser& aItem)
+ {
+ TInt status(KErrNone);
+ TInt initialvolume;
+ TInt finalvolume;
+ TInt rampmodevolume;
+ TInt rampduration_par;
+ iLog->Log(_L("VolSetVolume INIT"));
+
+ if(!iMVolumeControl)
+ {
+ status = KErrNotReady;
+ }
+ else
+ {
+ aItem.GetNextInt(initialvolume);
+ aItem.GetNextInt(finalvolume);
+ aItem.GetNextInt(rampduration_par);
+ TPckgBuf<TUint64> pckg;
+ pckg = rampduration_par;
+ aItem.GetNextInt(rampmodevolume);
+ TUint64 rampduration = pckg();
+ MVolumeControl::TVolumeRampMode rampmode = MVolumeControl::TVolumeRampMode(rampmodevolume);
+ status = iMVolumeControl->SetVolumeRamp(initialvolume,finalvolume,rampduration,rampmode);
+
+ if (status!=KErrNone)
+ {
+ iLog->Log(_L("VolSetVolume FAILED"));
+ }
+ else
+ {
+ iLog->Log(_L("VolSetVolume OK"));
+ }
+ }
+ return status;
+ }
+
+
+TInt CEnhanMediaTestClass::FileSGetBitRate(CStifItemParser& /*aItem*/)
+ {
+
+ iLog->Log(_L("CEnhanMediaTestClass::FileSGetBitRate "));
+ TInt status(KErrNone);
+ TUint bitrate = 0;
+ if(!iMFileSource)
+ {
+ status = KErrNotReady;
+ }
+ else
+ {
+ status = iMFileSource->GetBitRate(bitrate);
+ }
+ iLog->Log(_L("CEnhanMediaTestClass::FileSGetBitRate [%d]"),bitrate);
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::FileSGetSize(CStifItemParser& /*aItem*/)
+ {
+
+ iLog->Log(_L("CEnhanMediaTestClass::FileSGetSize "));
+ TInt status(KErrNone);
+ TUint sizes = 0;
+ if(!iMFileSource)
+ {
+ status = KErrNotReady;
+ }
+ else
+ {
+ status = iMFileSource->GetSize(sizes);
+ }
+ iLog->Log(_L("CEnhanMediaTestClass::FileSGetSize [%d]"),sizes);
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::Source_GetMimeType(CStifItemParser& /*aItem*/)
+ {
+ iLog->Log(_L("CEnhanMediaTestClass::FileSGetBitRate "));
+ TInt status(KErrNone);
+ TBuf8<256> mimeType;
+ mimeType.Copy(KTagMimeType);
+
+ TInt mimeTypeSize = mimeType.Size();
+
+ if(iMimeType)
+ {
+ delete iMimeType;
+ iMimeType = NULL;
+ }
+
+ iMimeType = HBufC8::NewL(mimeType.Size());
+ TPtr8 des = iMimeType->Des();
+ status = iSourceControl->GetMimeType(des);
+ if (status == KErrNone)
+ {
+ iLog->Log(_L("CEnhanMediaTestClass::Source_GetMimeType = %d"), status);
+ }
+ else
+ {
+ iLog->Log(_L("CEnhanMediaTestClass::Source_GetMimeType ERROR = [%d]"), status);
+ }
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::Source_GetSize(CStifItemParser& /*aItem*/)
+ {
+
+ iLog->Log(_L("CEnhanMediaTestClass::Source_GetSize "));
+ TInt status(KErrNone);
+ TUint size = 0;
+ status = iSourceControl->GetSize(size);
+ iLog->Log(_L("CEnhanMediaTestClass::Source_GetSize [%d]"),size);
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::Stream_GetDuration(CStifItemParser& /*aItem*/)
+ {
+ iLog->Log(_L("CEnhanMediaTestClass::Stream_GetDuration "));
+ TInt status(KErrNone);
+ TInt64 dur=0;
+ status = iMStreamControl->GetDuration(dur);
+ iLog->Log(_L("CEnhanMediaTestClass::Stream_GetDuration [%d]"),dur);
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::Stream_SetPriority(CStifItemParser& aItem)
+ {
+ iLog->Log(_L("CEnhanMediaTestClass::Stream_SetPriority "));
+ TInt status(KErrNone);
+ if ( !iMStreamControl )
+ {
+ status = KErrNotReady;
+ }
+ else
+ {
+ TInt priority;
+ TInt mdaprioritypref;
+ aItem.GetNextInt(priority);
+ aItem.GetNextInt(mdaprioritypref);
+ TMdaPriorityPreference pref = TMdaPriorityPreference(mdaprioritypref);
+ status = iMStreamControl->SetPriority(priority, pref );
+ }
+ if (status == KErrNone)
+ {
+ iLog->Log(_L("CEnhanMediaTestClass::Stream_SetPriority = %d"), status);
+ }
+ else
+ {
+ iLog->Log(_L("CEnhanMediaTestClass::Stream_SetPriority ERROR = [%d]"), status);
+ }
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::StreamGetSSL(CStifItemParser& /*aItem*/)
+ {
+ iLog->Log(_L("CEnhanMediaTestClass::StreamGetSSL "));
+ TInt status(KErrNone);
+ TBool seekingSupported(EFalse);
+ status = iMStreamControl->GetSeekingSupport(seekingSupported);
+ iLog->Log(_L("CEnhanMediaTestClass::StreamGetSSL [%d]"),status);
+ status = KErrNone;
+ return status;
+
+ }
+TInt CEnhanMediaTestClass::StreamGetRSSL(CStifItemParser& /*aItem*/)
+ {
+ iLog->Log(_L("CEnhanMediaTestClass::StreamGetRSSL "));
+ TInt status(KErrNone);
+ TBool seekingSupported(EFalse);
+ status = iMStreamControl->GetRandomSeekingSupport(seekingSupported);
+ iLog->Log(_L("CEnhanMediaTestClass::StreamGetRSSL [%d]"),status);
+ status = KErrNone;
+ return status;
+ }
+TInt CEnhanMediaTestClass::StreamGetStateL(CStifItemParser& /*aItem*/)
+ {
+ iLog->Log(_L("CEnhanMediaTestClass::StreamGetStateL "));
+ TInt status(KErrNone);
+ MStreamControl::TStreamState state = iMStreamControl->GetState();
+ iLog->Log(_L("CEnhanMediaTestClass::StreamGetStateL [%d]"),status);
+ return status;
+ }
+TInt CEnhanMediaTestClass::StreamGetCIL(CStifItemParser& /*aItem*/)
+ {
+ iLog->Log(_L("CEnhanMediaTestClass::StreamGetCIL "));
+ TInt status(KErrNone);
+
+ iLog->Log(_L("CEnhanMediaTestClass::StreamGetCIL [%d]"),status);
+ return status;
+ }
+TInt CEnhanMediaTestClass::StreamGetPositionL(CStifItemParser& /*aItem*/)
+ {
+ iLog->Log(_L("CEnhanMediaTestClass::StreamGetStateL "));
+ TInt status(KErrNone);
+ TInt64 pos=0;
+ status = iMStreamControl->GetPosition(pos);
+ iLog->Log(_L("CEnhanMediaTestClass::StreamGetStateL [%d]"),status);
+ return status;
+ }
+TInt CEnhanMediaTestClass::StreamSetPositionL(CStifItemParser& aItem)
+ {
+ iLog->Log(_L("CEnhanMediaTestClass::StreamSetPositionL"));
+ TInt status(KErrNone);
+ if ( !iMStreamControl )
+ {
+ status = KErrNotReady;
+ }
+ TInt data;
+ aItem.GetNextInt(data);
+ TPckgBuf<TInt64> pckg;
+ pckg = data;
+ status = iMStreamControl->SetPosition(pckg());
+ iLog->Log(_L("CEnhanMediaTestClass::StreamSetPositionL [%d]"),status);
+ return status;
+ }
+TInt CEnhanMediaTestClass::ControlTypeL(CStifItemParser& aItem)
+ {
+ iLog->Log(_L("CEnhanMediaTestClass::ControlTypeL INIT"));
+ TInt status(KErrNone);
+ TInt control;
+ aItem.GetNextInt(control);
+ TUid controlUid(TUid::Uid(0));
+
+ switch(TControl(control))
+ {
+ case EFILESOURCE:
+ {
+ if(iMFileSource)
+ {
+ controlUid = iMFileSource->Type();
+ }
+ else
+ {
+ status = KErrNotFound;
+ }
+ break;
+ }
+ case EDATABUFFERSOURCE:
+ {
+ if(iMDataBufferSource)
+ {
+ controlUid = iMDataBufferSource->Type();
+ }
+ else
+ {
+ status = KErrNotFound;
+ }
+ break;
+ }
+ case EDESCRIPTORSOURCE:
+ {
+ if(iMDescriptorSource)
+ {
+ controlUid = iMDescriptorSource->Type();
+ }
+ else
+ {
+ status = KErrNotFound;
+ }
+ break;
+ }
+ case ESTREAMCONTROL:
+ {
+ if(iMStreamControl)
+ {
+ controlUid = iMStreamControl->Type();
+ }
+ else
+ {
+ status = KErrNotFound;
+ }
+ break;
+ }
+ case EMMFAUDIOOUTPUTSINKCONTROL:
+ {
+ if(iMAudioSink)
+ {
+ controlUid = iMAudioSink->Type();
+ }
+ else
+ {
+ status = KErrNotFound;
+ }
+ break;
+ }
+ case EVOLUMECONTROL:
+ {
+ if(iMVolumeControl)
+ {
+ controlUid = iMVolumeControl->Type();
+ }
+ else
+ {
+ status = KErrNotFound;
+ }
+ break;
+ }
+ case EBALANCECONTROL:
+ {
+ if(iMBalanceControl)
+ {
+ controlUid = iMBalanceControl->Type();
+ }
+ else
+ {
+ status = KErrNotFound;
+ }
+ break;
+ }
+ case EPDLSOURCE:
+ {
+ if(iMProgDLSource)
+ {
+ controlUid = iMProgDLSource->Type();
+ }
+ else
+ {
+ status = KErrNotFound;
+ }
+ break;
+ }
+ }
+ iLog->Log(_L("CEnhanMediaTestClass::ControlTypeL = [%d]"),control);
+ return status;
+ }
+TInt CEnhanMediaTestClass::ControlControlTypeL(CStifItemParser& aItem)
+ {
+ iLog->Log(_L("CEnhanMediaTestClass::ControlControlTypeL INIT"));
+ TInt status(KErrNone);
+ TInt control;
+ aItem.GetNextInt(control);
+ TControlType controlType(TControlType(0));
+ switch(TControl(control))
+ {
+ case EFILESOURCE:
+ {
+ if(iMFileSource)
+ {
+ controlType = iMFileSource->ControlType();
+ }
+ else
+ {
+ status = KErrNotFound;
+ }
+ break;
+ }
+ case EDATABUFFERSOURCE:
+ {
+ if(iMDataBufferSource)
+ {
+ controlType = iMDataBufferSource->ControlType();
+ }
+ else
+ {
+ status = KErrNotFound;
+ }
+ break;
+ }
+ case EDESCRIPTORSOURCE:
+ {
+ if(iMDescriptorSource)
+ {
+ controlType = iMDescriptorSource->ControlType();
+ }
+ else
+ {
+ status = KErrNotFound;
+ }
+ break;
+ }
+ case ESTREAMCONTROL:
+ {
+ if(iMStreamControl)
+ {
+ controlType = iMStreamControl->ControlType();
+ }
+ else
+ {
+ status = KErrNotFound;
+ }
+ break;
+ }
+ case EMMFAUDIOOUTPUTSINKCONTROL:
+ {
+ if(iMAudioSink)
+ {
+ controlType = iMAudioSink->ControlType();
+ }
+ else
+ {
+ status = KErrNotFound;
+ }
+ break;
+ }
+ case EVOLUMECONTROL:
+ {
+ if(iMVolumeControl)
+ {
+ controlType = iMVolumeControl->ControlType();
+ }
+ else
+ {
+ status = KErrNotFound;
+ }
+ break;
+ }
+ case EBALANCECONTROL:
+ {
+ if(iMBalanceControl)
+ {
+ controlType = iMBalanceControl->ControlType();
+ }
+ else
+ {
+ status = KErrNotFound;
+ }
+ break;
+ }
+ case EPDLSOURCE:
+ {
+ if(iMProgDLSource)
+ {
+ controlType = iMProgDLSource->ControlType();
+ }
+ else
+ {
+ status = KErrNotFound;
+ }
+ break;
+ }
+ }
+ iLog->Log(_L("CEnhanMediaTestClass::ControlControlTypeL = [%d]"),control);
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::DRMSetType(CStifItemParser& aItem)
+ {
+ TInt typedrm;
+ TInt status(KErrNone);
+ iLog->Log(_L("DRMSetType INIT"));
+ if (!iDRMConfigIntfc)
+ {
+ iLog->Log(_L("iDRMConfigIntfc Not ready"));
+ status = KErrNotReady;
+ }
+ else
+ {
+ status = aItem.GetNextInt(typedrm);
+ if (status != KErrNone)
+ {
+ iLog->Log(_L("Parameter was not set into config to set DRM type"));
+ status = KErrNotReady;
+ }
+ else
+ {
+ status = iDRMConfigIntfc->SetDRMType(TDRMType(typedrm));
+ if (status!=KErrNone)
+ {
+ iLog->Log(_L("DRMSetType FAILED"));
+ }
+ else
+ {
+ iLog->Log(_L("DRMSetType OK"));
+ }
+ }
+ }
+ return status;
+ }
+TInt CEnhanMediaTestClass::DRMGetType(CStifItemParser& /*aItem*/)
+ {
+ TInt status(KErrNone);
+ TDRMType typedrm;
+ iLog->Log(_L("DRMGetType INIT"));
+ if (!iDRMConfigIntfc)
+ {
+ iLog->Log(_L("iDRMConfigIntfc Not ready"));
+ status = KErrNotReady;
+ }
+ else
+ {
+ status = iDRMConfigIntfc->GetDRMType(typedrm);
+ if (status!=KErrNone)
+ {
+ iLog->Log(_L("DRMGetType FAILED"));
+ }
+ else
+ {
+ iLog->Log(_L("DRMGetType OK [%d]"),typedrm);
+ }
+ }
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::DRMCommit(CStifItemParser& /*aItem*/)
+ {
+ TInt status(KErrNone);
+ iLog->Log(_L("DRMCommit INIT"));
+ if (!iDRMConfigIntfc)
+ {
+ iLog->Log(_L("iDRMConfigIntfc Not ready"));
+ status = KErrNotReady;
+ }
+ else
+ {
+ status = iDRMConfigIntfc->Commit();
+ if (status!=KErrNone)
+ {
+ iLog->Log(_L("DRMCommit FAILED"));
+ }
+ else
+ {
+ iLog->Log(_L("DRMCommit OK"));
+ }
+ }
+ return status;
+ }
+TInt CEnhanMediaTestClass::DRMGetAllowedOutputDeviceCount( CStifItemParser& /*aItem */)
+ {
+ TInt status(KErrNone);
+ iLog->Log(_L("DRMGetAllowedOutputDeviceCount INIT"));
+ if (!iDRMConfigIntfc)
+ {
+ iLog->Log(_L("iDRMConfigIntfc Not ready"));
+ status = KErrNotReady;
+ }
+ else
+ {
+ status = iDRMConfigIntfc->GetAllowedOutputDeviceCount(iAllowedDevice);
+ if (status!=KErrNone)
+ {
+ iLog->Log(_L("DRMGetAllowedOutputDeviceCount FAILED"));
+ }
+ else
+ {
+ iLog->Log(_L("DRMGetAllowedOutputDeviceCount = [%d]"),iAllowedDevice);
+ }
+ }
+ return status;
+
+ }
+TInt CEnhanMediaTestClass::DRMGetAllowedOutputDevice(CStifItemParser& aItem )
+ {
+ TInt status(KErrNone);
+ TDRMAllowedOutputDevice output;
+ TInt index;
+ iLog->Log(_L("DRMGetAllowedOutputDevice INIT"));
+ if (!iDRMConfigIntfc)
+ {
+ iLog->Log(_L("iDRMConfigIntfc Not ready"));
+ status = KErrNotReady;
+ }
+ else
+ {
+ aItem.GetNextInt(index);
+ status = iDRMConfigIntfc->GetAllowedOutputDevice(index, output);
+ if (status!=KErrNone)
+ {
+ iLog->Log(_L("DRMGetAllowedOutputDevice FAILED [%d]"),status);
+ }
+ else
+ {
+ iLog->Log(_L("DRMGetAllowedOutputDevice = [%d]"),output);
+ }
+ }
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::DRMAppendAllowedOutputDevice(CStifItemParser& aItem )
+ {
+ TInt status(KErrNone);
+ TDRMAllowedOutputDevice output;
+ TInt index;
+ iLog->Log(_L("DRMAppendAllowedOutputDevice INIT"));
+ if (!iDRMConfigIntfc)
+ {
+ iLog->Log(_L("iDRMConfigIntfc Not ready"));
+ status = KErrNotReady;
+ }
+ else
+ {
+ aItem.GetNextInt(index);
+ output = TDRMAllowedOutputDevice(index);
+ status = iDRMConfigIntfc->AppendAllowedOutputDevice(output);
+ if (status!=KErrNone)
+ {
+ iLog->Log(_L("DRMAppendAllowedOutputDevice FAILED [%d]"),status);
+ }
+ else
+ {
+ iLog->Log(_L("DRMAppendAllowedOutputDevice = [%d]"),output);
+ }
+ }
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::DRMRemoveAllowedOutputDevice(CStifItemParser& aItem )
+ {
+ TInt status(KErrNone);
+ TDRMAllowedOutputDevice output;
+ TInt index;
+ iLog->Log(_L("DRMRemoveAllowedOutputDevice INIT"));
+ if (!iDRMConfigIntfc)
+ {
+ iLog->Log(_L("iDRMConfigIntfc Not ready"));
+ status = KErrNotReady;
+ }
+ else
+ {
+ aItem.GetNextInt(index);
+ output = TDRMAllowedOutputDevice(index);
+ status = iDRMConfigIntfc->RemoveAllowedOutputDevice(output);
+ if (status != KErrNone)
+ {
+ iLog->Log(_L("DRMRemoveAllowedOutputDevice ERROR = [%d]"),status);
+ }
+ else
+ {
+ iLog->Log(_L("DRMRemoveAllowedOutputDevice = [%d]"),output);
+ }
+ }
+ status = KErrNone; //remove after fixed
+ return status;
+ }
+TInt CEnhanMediaTestClass::DRMReset()
+ {
+ TInt status(KErrNone);
+ iLog->Log(_L("DRMReset INIT"));
+ if (!iDRMConfigIntfc)
+ {
+ iLog->Log(_L("iDRMConfigIntfc Not ready"));
+ status = KErrNotReady;
+ }
+ else
+ {
+ status = iDRMConfigIntfc->Reset();
+ if (status!=KErrNone)
+ {
+ iLog->Log(_L("DRMReset FAILED "));
+ }
+ else
+ {
+ iLog->Log(_L("DRMReset OK"));
+ }
+ }
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::CreateSeekableData(CStifItemParser& /*aItem*/)
+ {
+ TInt status(KErrNone);
+ iLog->Log(_L("CreateSeekableData INIT"));
+ if (!iMDataBufferSource)
+ {
+ status = KErrNotReady;
+ }
+ else
+ {
+ //iDataSourceConfigIntfcImpl = CDataSourceConfigIntfcImpl::NewL();
+ if(status == KErrNone)
+ {
+// iSourceControl = CCacheSource::NewL(*iSourceControl,iDataSourceConfigIntfcImpl);
+
+ }
+
+ }
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::GeneralGen_StartProgDLL(CStifItemParser& aItem)
+ {
+ TInt status = KErrNone;
+ TPtrC string;
+ //AddExpectedEvent(EEStartDownload,KMediumTimeout);
+ aItem.SetParsingType( CStifItemParser::EQuoteStyleParsing );
+
+ status = aItem.GetNextString ( string );
+
+ if ( status != KErrNone )
+ {
+ iLog->Log(_L("CHelixSTIFClient:: File name missing in config file "));
+ return status;
+ }
+ else
+ {
+ if(iUrlName)
+ {
+ delete iUrlName;
+ iUrlName = NULL;
+ }
+ iUrlName = HBufC8::NewL(string.Length());
+ TPtr8 des = iUrlName->Des();
+ des.Copy(string);
+ }
+
+ status = aItem.GetNextString ( string );
+
+ if ( status != KErrNone )
+ {
+ iLog->Log(_L("CHelixSTIFClient:: File name missing in config file "));
+ return status;
+ }
+ else
+ {
+ if(iAccessPtName)
+ {
+ delete iAccessPtName;
+ iAccessPtName = NULL;
+ }
+ iAccessPtName = HBufC::NewL(string.Length());
+ TPtr des = iAccessPtName->Des();
+ des.Copy(string);
+ }
+
+ status = aItem.GetNextString ( string );
+
+ if ( status != KErrNone )
+ {
+ iLog->Log(_L("CHelixSTIFClient:: File name missing in config file "));
+ return status;
+ }
+ else
+ {
+ if(iFileName)
+ {
+ delete iFileName;
+ iFileName = NULL;
+ }
+ iFileName = HBufC::NewL(string.Length());
+ TPtr des = iFileName->Des();
+ des.Copy(string);
+ }
+
+ if ( !iDMgrConnected )
+ {
+ TRAP(status,iDownloadMgr.ConnectL( TUid::Uid(1), *this, EFalse ));
+ if(!status)
+ {
+ iDMgrConnected = ETrue;
+ }
+ else
+ {
+ iLog->Log(_L("CHelixSTIFClient::GeneralGen_StartProgDLL Connection failed to DlMgr "));
+ return status;
+ }
+ }
+
+ // Get IAP names and ids from the database
+ TInt res;
+ TBuf<40> name;
+ TUint32 id;
+
+ CCommsDatabase* TheDb = CCommsDatabase::NewL(EDatabaseTypeIAP);
+ CleanupStack::PushL(TheDb);
+
+ TheDb->ShowHiddenRecords();
+
+ CCommsDbTableView* view = TheDb->OpenTableLC(TPtrC(IAP));
+ res = view->GotoFirstRecord();
+
+ while(res == KErrNone)
+ {
+ view->ReadTextL(TPtrC(COMMDB_NAME), name);
+ view->ReadUintL(TPtrC(COMMDB_ID), id);
+
+ iLog->Log(_L("CHelixSTIFClient::GeneralGen_StartProgDLL Name[%s] ID[%d] "),&name,id);
+ if(!iAccessPtName->Des().Compare(name))
+ {
+ break;
+ }
+
+ res = view->GotoNextRecord();
+ RDebug::Print(_L("IAP name, id: %S, %d"), &name, id);
+ }
+
+ CleanupStack::PopAndDestroy(); // view
+ CleanupStack::PopAndDestroy(); // TheDb
+
+ status = iDownloadMgr.SetIntAttribute( EDlMgrIap,id );
+ if(status != KErrNone)
+ {
+ return status;
+ }
+
+ status = iDownloadMgr.SetDefaultStringAttribute( EDlAttrDestFilename, *iFileName ) ;
+
+
+ TRAP(status,iDownload = &(iDownloadMgr.CreateDownloadL(*iUrlName)));
+ if(status != KErrNone)
+ {
+ return status;
+ }
+
+ status = iDownload->Start();
+ if(status != KErrNone)
+ {
+ iLog->Log(_L("CHelixSTIFClient::GeneralGen_StartProgDLL Download Start Failed "));
+ return status;
+ }
+ status = iDownload->GetIntAttribute(EDlAttrId, iDownloadId);
+ if(status != KErrNone)
+ {
+ iLog->Log(_L("CHelixSTIFClient::GeneralGen_StartProgDLL Getting DLId failed "));
+ return status;
+ }
+
+ if(iActive)
+ {
+ delete iActive;
+ iActive = NULL;
+ }
+
+ iActive = new CActiveSchedulerWait;
+ RDebug::Print(_L("Before"));
+ iLog->Log(_L("Before = %d"), status);
+ iActive->Start();
+ iLog->Log(_L("After = %d"), status);
+ RDebug::Print(_L("AFter"));
+ iLog->Log(_L("CEnhanMediaTestClass::GeneralGen_StartProgDLL = %d"), status);
+ return status;
+ }
+
+
+TInt CEnhanMediaTestClass::PDLSOpenL(CStifItemParser& /*aItem*/)
+ {
+ AddExpectedEvent(EEPDLSOpen,KMediumTimeout);
+ TInt status(KErrNone);
+ //TBool stateDL;
+ //TUint percent;
+ if(!iMProgDLSource)
+ {
+ return status = KErrNotReady;
+ }
+ status = iMProgDLSource->Open(*iFileName,iDownloadId);
+// iMProgDLSource->GetPercentageDownloaded(percent);
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::PDLSGetCurFileSizeL(CStifItemParser& /*aItem*/)
+ {
+ TInt status(KErrNone);
+ TUint fileSize;
+ if(!iMProgDLSource)
+ {
+ return status = KErrNotReady;
+ }
+ status = iMProgDLSource->GetCurrentFileSize(fileSize);
+ iLog->Log(_L("PDLSGetCurFileSizeL = %d"), fileSize);
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::PDLSGetExpFileSizeL(CStifItemParser& /*aItem*/)
+ {
+ TInt status(KErrNone);
+ TUint fileSize;
+ if(!iMProgDLSource)
+ {
+ return status = KErrNotReady;
+ }
+ status = iMProgDLSource->GetExpectedFileSize(fileSize);
+ iLog->Log(_L("PDLSGetExpFileSizeL = %d"), fileSize);
+
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::PDLSGetDLStatusL(CStifItemParser& /*aItem*/)
+ {
+ TInt status(KErrNone);
+ MProgDLSource::TDownloadStatus dlStatus;
+ if(!iMProgDLSource)
+ {
+ return status = KErrNotReady;
+ }
+
+ dlStatus = iMProgDLSource->GetDownloadStatus();
+ iLog->Log(_L("PDLSGetDLStatusL = %d"), dlStatus);
+
+ return status;
+ }
+
+
+TInt CEnhanMediaTestClass::PDLSIsDLCompleteL(CStifItemParser& /*aItem*/)
+ {
+ TInt status(KErrNone);
+ TBool dlComplete;
+ if(!iMProgDLSource)
+ {
+ return status = KErrNotReady;
+ }
+
+ status = iMProgDLSource->IsDownloadComplete(dlComplete);
+ iLog->Log(_L("PDLSIsDLCompleteL = %d"), dlComplete);
+
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::PDLSGetPerDownloadedL(CStifItemParser& /*aItem*/)
+ {
+ TInt status(KErrNone);
+ TUint perDl;
+ if(!iMProgDLSource)
+ {
+ return status = KErrNotReady;
+ }
+
+ status = iMProgDLSource->GetPercentageDownloaded(perDl);
+ iLog->Log(_L("PDLSGetPerDownloadedL = %d"), perDl);
+
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::PDLSGetPerBufferedL(CStifItemParser& /*aItem*/)
+ {
+ TInt status(KErrNone);
+ TUint perBuf;
+ if(!iMProgDLSource)
+ {
+ return status = KErrNotReady;
+ }
+
+ status = iMProgDLSource->GetPercentageBuffered(perBuf);
+ iLog->Log(_L("PDLSGetPerBufferedL = %d"), perBuf);
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::PDLSGetDLRateL(CStifItemParser& /*aItem*/)
+ {
+ TInt status(KErrNone);
+ TUint dlRate;
+ if(!iMProgDLSource)
+ {
+ return status = KErrNotReady;
+ }
+
+ status = iMProgDLSource->GetDownloadingRate(dlRate);
+ iLog->Log(_L("PDLSGetDLRateL = %d"), dlRate);
+
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::PDLSGetBitRateL(CStifItemParser& /*aItem*/)
+ {
+ TInt status(KErrNone);
+ TUint bitRate;
+ if(!iMProgDLSource)
+ {
+ return status = KErrNotReady;
+ }
+
+ status = iMProgDLSource->GetBitRate(bitRate);
+ iLog->Log(_L("PDLSGetBitRateL = %d"), bitRate);
+
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::PDLSResumeDownloadL(CStifItemParser& /*aItem*/)
+ {
+ TInt status(KErrNone);
+ if(!iMProgDLSource)
+ {
+ return status = KErrNotReady;
+ }
+
+ status = iMProgDLSource->ResumeDownload();
+ iLog->Log(_L("PDLSResumeDownloadL = %d"), status);
+
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::PDLSMoveFileL(CStifItemParser& aItem)
+ {
+ TInt status(KErrNone);
+ TPtrC string;
+ TFileName fileName;
+ if(!iMProgDLSource)
+ {
+ return status = KErrNotReady;
+ }
+ status = aItem.GetNextString(string);
+ if ( status != KErrNone )
+ {
+ iLog->Log(_L("CEnhanMediaTestClass:: File name missing in config file "));
+ return status;
+ }
+ else
+ {
+ fileName.Copy(string);
+ }
+ if(iFileName)
+ {
+ delete iFileName;
+ iFileName = NULL;
+ }
+ iFileName = HBufC::NewL(fileName.Length());
+ iFileName->Des().Copy(fileName);
+
+
+ status = iMProgDLSource->MoveFile(*iFileName);
+ iLog->Log(_L("PDLSMoveFileL = %d"), status);
+
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::PDLSGetSize(CStifItemParser& /*aItem*/)
+ {
+
+ iLog->Log(_L("CEnhanMediaTestClass::PDLSGetSize "));
+ TInt status(KErrNone);
+ TUint sizes = 0;
+ if(!iMProgDLSource)
+ {
+ status = KErrNotReady;
+ }
+ else
+ {
+ status = iMProgDLSource->GetSize(sizes);
+ }
+ iLog->Log(_L("CEnhanMediaTestClass::PDLSGetSize [%d]"), status);
+
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::PDLSCancelDownloadL(CStifItemParser& /*aItem*/)
+ {
+ TMediaId mediaId;
+ TFourCC dataType;
+ iLog->Log(_L("CEnhanMediaTestClass::PDLSCancelDownloadL "));
+ TInt status(KErrNone);
+ if(!iMProgDLSource)
+ {
+ status = KErrNotReady;
+ }
+ else
+ {
+ status = iMProgDLSource->CancelDownload();
+ }
+ iLog->Log(_L("CEnhanMediaTestClass::PDLSCancelDownloadL [%d]"), status);
+
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::StreamCustomInterface(CStifItemParser& /*aItem*/)
+ {
+ iLog->Log(_L("CEnhanMediaTestClass::StreamCustomInterface "));
+ TInt status(KErrNone);
+ if(!iMStreamControl)
+ {
+ status = KErrNotReady;
+ }
+ else
+ {
+ TUid controlUid(TUid::Uid(0x101F7D8D));
+ iMStreamControl->CustomInterface(controlUid);
+ controlUid = TUid::Uid(0x10207BA8);
+ iMStreamControl->CustomInterface(controlUid);
+ controlUid = TUid::Uid(0x10207BA9);
+ iMStreamControl->CustomInterface(controlUid);
+ }
+ iLog->Log(_L("CEnhanMediaTestClass::StreamCustomInterface"));
+
+ return status;
+ }
+TInt CEnhanMediaTestClass::AudioEffectIsEnabled (CStifItemParser& /*aItem*/)
+ {
+ TInt status(KErrNone);
+ TBool enabled;
+
+ if(!iEffectControl)
+ {
+ status = KErrNotReady;
+ }
+
+ status = static_cast<MAudioEffectControl*>(iEffectControl)->IsEnabled(enabled);
+
+ if (status == KErrNone)
+ {
+ iLog->Log(_L("AudioEffectIsEnabled status = %d"), status);
+ }
+ else
+ {
+ iLog->Log(_L("AudioEffectIsEnabled ERROR = [%d]"), status);
+ }
+
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::AudioEffectIsEnforced (CStifItemParser& /*aItem*/)
+ {
+ TInt status(KErrNone);
+ TBool enforced;
+
+ if(!iEffectControl)
+ {
+ status = KErrNotReady;
+ }
+
+ status = static_cast<MAudioEffectControl*>(iEffectControl)->IsEnforced(enforced);
+
+ if (status == KErrNone)
+ {
+ iLog->Log(_L("AudioEffectIsEnforced status = %d"), status);
+ }
+ else
+ {
+ iLog->Log(_L("AudioEffectIsEnforced ERROR = [%d]"), status);
+ }
+
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::AudioEffectUid (CStifItemParser& /*aItem*/)
+ {
+ TInt status(KErrNone);
+ TUid effectUid;
+
+ if(!iEffectControl)
+ {
+ status = KErrNotReady;
+ }
+
+ status = static_cast<MAudioEffectControl*>(iEffectControl)->Uid(effectUid);
+
+ if (status == KErrNone)
+ {
+ iLog->Log(_L("AudioEffectUid status = %d"), status);
+ }
+ else
+ {
+ iLog->Log(_L("AudioEffectUid ERROR = [%d]"), status);
+ }
+
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::AudioEffectHaveUpdateRights (CStifItemParser& /*aItem*/)
+ {
+ TInt status(KErrNone);
+ TBool rights;
+
+ if(!iEffectControl)
+ {
+ status = KErrNotReady;
+ }
+
+ status = static_cast<MAudioEffectControl*>(iEffectControl)->HaveUpdateRights(rights);
+
+ if (status == KErrNone)
+ {
+ iLog->Log(_L("AudioEffectHaveUpdateRights status = %d"), status);
+ }
+ else
+ {
+ iLog->Log(_L("AudioEffectHaveUpdateRights ERROR = [%d]"), status);
+ }
+
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::AudioEffectEnforce (CStifItemParser& aItem)
+ {
+ TInt status(KErrNone);
+ TBool enforce;
+
+ status = aItem.GetNextInt(enforce);
+ if (status != KErrNone)
+ {
+ iLog->Log(_L("AudioEffectEnforce ERROR = [%d]"), status);
+ return status;
+ }
+
+ if(!iEffectControl)
+ {
+ status = KErrNotReady;
+ }
+
+ status = static_cast<MAudioEffectControl*>(iEffectControl)->Enforce(enforce);
+
+ if (status == KErrNone)
+ {
+ iLog->Log(_L("AudioEffectEnforce status = %d"), status);
+ }
+ else
+ {
+ iLog->Log(_L("AudioEffectEnforce ERROR = [%d]"), status);
+ }
+
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::HandleAudioEffectEnableL(CStifItemParser& aItem)
+ {
+ iLog->Log(_L("CEnhanMediaTestClass::HandleAudioEffectEnableL"));
+ TInt status(KErrNone);
+ TInt control;
+ status = aItem.GetNextInt(control);
+ if (status != KErrNone)
+ {
+ iLog->Log(_L("AudioEffectEnable ERROR = [%d]"), status);
+ return status;
+ }
+
+ TControl controlType = TControl(control);
+
+ switch(controlType)
+ {
+ case EVOLUMECONTROL:
+ {
+ iEffectControl = iMVolumeControl;
+ }
+ break;
+ case EBALANCECONTROL:
+ {
+ iEffectControl = iMBalanceControl;
+ }
+ break;
+ case EEQUALIZERCONTROL:
+ {
+ iEffectControl = iMEqualizerControl;
+ }
+ break;
+ case EREVERBCONTROL:
+ {
+ iEffectControl = iMReverbControl;
+ }
+ break;
+ case EBASSBOOSTCONTROL:
+ {
+ iEffectControl = iMBassBoostControl;
+ }
+ break;
+
+ case ESTEREOWIDCONTROL:
+ {
+ iEffectControl = iMStereoWideningControl;
+ }
+ break;
+
+
+ case ELOUDNESSCONTROL:
+ {
+ iEffectControl = iMLoudnessControl;
+ }
+ break;
+
+
+ case EROOMLEVELCONTROL:
+ {
+ iEffectControl = iMRoomLevelControl;
+ }
+ break;
+
+
+ case EDISTATTCONTROL:
+ {
+ iEffectControl = iMDistanceAttenuationControl;
+ }
+ break;
+
+
+ case ELISTDOPPCONTROL:
+ {
+ iEffectControl = iMListenerDopplerControl;
+ }
+ break;
+
+
+ case ESOURDOPPCONTROL:
+ {
+ iEffectControl = iMSourceDopplerControl;
+ }
+ break;
+
+
+ case ELISTLOCCONTROL:
+ {
+ iEffectControl = iMListenerLocationControl;
+ }
+ break;
+
+
+ case ESOURLOCCONTROL:
+ {
+ iEffectControl = iMSourceLocationControl;
+ }
+ break;
+
+
+ case ELISTORIENTCONTROL:
+ {
+ iEffectControl = iMListenerOrientationControl;
+ }
+ break;
+
+
+ case ESOURORIENTCONTROL:
+ {
+ iEffectControl = iMSourceOrientationControl;
+ }
+ break;
+
+ }
+ status = static_cast<MAudioEffectControl*>(iEffectControl)->Enable();
+ iLog->Log(_L("CEnhanMediaTestClass::HandleAudioEffectEnableL END"));
+ if (status == KErrNone)
+ {
+ iLog->Log(_L("AudioEffectEnable status = %d"), status);
+ }
+ else
+ {
+ iLog->Log(_L("AudioEffectEnable ERROR = [%d]"), status);
+ }
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::HandleAudioEffectDisableL(CStifItemParser& aItem)
+ {
+ iLog->Log(_L("CEnhanMediaTestClass::HandleAudioEffectDisableL"));
+ TInt status(KErrNone);
+ TInt controltype = 0;
+ status = aItem.GetNextInt(controltype);
+ if (status != KErrNone)
+ {
+ iLog->Log(_L("AudioEffectDisable ERROR = [%d]"), status);
+ return status;
+ }
+
+ switch(TControl(controltype))
+ {
+ case EVOLUMECONTROL:
+ {
+ iEffectControl = iMVolumeControl;
+ }
+ break;
+ case EBALANCECONTROL:
+ {
+ iEffectControl = iMBalanceControl;
+ }
+ break;
+ case EEQUALIZERCONTROL:
+ {
+ iEffectControl = iMEqualizerControl;
+ }
+ break;
+ case EREVERBCONTROL:
+ {
+ iEffectControl = iMReverbControl;
+ }
+ break;
+ case EBASSBOOSTCONTROL:
+ {
+ iEffectControl = iMBassBoostControl;
+ }
+ break;
+
+ case ESTEREOWIDCONTROL:
+ {
+ iEffectControl = iMStereoWideningControl;
+ }
+ break;
+
+
+ case ELOUDNESSCONTROL:
+ {
+ iEffectControl = iMLoudnessControl;
+ }
+ break;
+
+
+ case EROOMLEVELCONTROL:
+ {
+ iEffectControl = iMRoomLevelControl;
+ }
+ break;
+
+
+ case EDISTATTCONTROL:
+ {
+ iEffectControl = iMDistanceAttenuationControl;
+ }
+ break;
+
+
+ case ELISTDOPPCONTROL:
+ {
+ iEffectControl = iMListenerDopplerControl;
+ }
+ break;
+
+
+ case ESOURDOPPCONTROL:
+ {
+ iEffectControl = iMSourceDopplerControl;
+ }
+ break;
+
+
+ case ELISTLOCCONTROL:
+ {
+ iEffectControl = iMListenerLocationControl;
+ }
+ break;
+
+
+ case ESOURLOCCONTROL:
+ {
+ iEffectControl = iMSourceLocationControl;
+ }
+ break;
+
+
+ case ELISTORIENTCONTROL:
+ {
+ iEffectControl = iMListenerOrientationControl;
+ }
+ break;
+
+
+ case ESOURORIENTCONTROL:
+ {
+ iEffectControl = iMSourceOrientationControl;
+ }
+ break;
+
+ }
+ status = static_cast<MAudioEffectControl*>(iEffectControl)->Disable();
+ if (status == KErrNone)
+ {
+ iLog->Log(_L("AudioEffectDisable status = %d"), status);
+ }
+ else
+ {
+ iLog->Log(_L("AudioEffectDisable ERROR = [%d]"), status);
+ }
+ iLog->Log(_L("CEnhanMediaTestClass::HandleAudioEffectDisableL END"));
+ return status;
+ }
+
+
+TInt CEnhanMediaTestClass::HandleReverbDecayHFRatioL(CStifItemParser& /*aItem*/)
+ {
+ TInt status(KErrNone);
+ TUint ratio;
+ iLog->Log(_L("CEnhanMediaTestClass::HandleReverbDecayHFRatioL"));
+ if(!iEffectControl)
+ {
+ return status = KErrNotReady;
+ }
+ status = static_cast<MReverbControl*>(iEffectControl)->DecayHFRatio(ratio);
+ iLog->Log(_L("CEnhanMediaTestClass::HandleReverbDecayHFRatioL END"));
+
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::HandleReverbDecayHFRatioRangeL(CStifItemParser& /*aItem*/)
+ {
+
+ iLog->Log(_L("CEnhanMediaTestClass::HandleReverbDecayHFRatioRangeL"));
+ TInt status(KErrNone);
+ //status = aItem.GetNextInt(controltype);
+ TUint min,max;
+ if(!iEffectControl)
+ {
+ return status = KErrNotReady;
+ }
+ status = static_cast<MReverbControl*>(iEffectControl)->DecayHFRatioRange(min,max);
+ iLog->Log(_L("CEnhanMediaTestClass::HandleReverbDecayHFRatioRangeL min [%d] - max [%d]"),min,max);
+ return status;
+ }
+
+
+TInt CEnhanMediaTestClass::HandleReverbDecayTimeL(CStifItemParser& /*aItem*/)
+ {
+
+ iLog->Log(_L("CEnhanMediaTestClass::HandleReverbDecayTimeL"));
+ TInt status(KErrNone);
+ //status = aItem.GetNextInt(controltype);
+ TUint value;
+ if(!iEffectControl)
+ {
+ return status = KErrNotReady;
+ }
+ status = static_cast<MReverbControl*>(iEffectControl)->DecayTime(value);
+ iLog->Log(_L("CEnhanMediaTestClass::HandleReverbDecayTimeL [%d]"),value);
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::HandleReverbDecayTimeRangeL(CStifItemParser& /*aItem*/)
+ {
+
+ iLog->Log(_L("CEnhanMediaTestClass::HandleReverbDecayTimeL"));
+ TInt status(KErrNone);
+ //status = aItem.GetNextInt(controltype);
+ TUint max, min;
+ if(!iEffectControl)
+ {
+ return status = KErrNotReady;
+ }
+ status = static_cast<MReverbControl*>(iEffectControl)->DecayTimeRange(min,max);
+ iLog->Log(_L("CEnhanMediaTestClass::HandleReverbDecayTimeL min[%d] - max[%d]"),min,max);
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::HandleReverbDensityL(CStifItemParser& /*aItem*/)
+ {
+
+ iLog->Log(_L("CEnhanMediaTestClass::HandleReverbDecayTimeL"));
+ TInt status(KErrNone);
+ //status = aItem.GetNextInt(controltype);
+ TUint value;
+ if(!iEffectControl)
+ {
+ return status = KErrNotReady;
+ }
+ status = static_cast<MReverbControl*>(iEffectControl)->Density(value);
+ iLog->Log(_L("CEnhanMediaTestClass::HandleReverbDecayTimeL [%d]"),value);
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::HandleReverbDiffusionL(CStifItemParser& /*aItem*/)
+ {
+
+ iLog->Log(_L("CEnhanMediaTestClass::HandleReverbDecayTimeL"));
+ TInt status(KErrNone);
+ //status = aItem.GetNextInt(controltype);
+ TUint value;
+ if(!iEffectControl)
+ {
+ return status = KErrNotReady;
+ }
+ status = static_cast<MReverbControl*>(iEffectControl)->Diffusion(value);
+ iLog->Log(_L("CEnhanMediaTestClass::HandleReverbDecayTimeL value = [%d]"),value);
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::HandleReverbReflectionsDelayL(CStifItemParser& /*aItem*/)
+ {
+
+ iLog->Log(_L("CEnhanMediaTestClass::HandleReverbReflectionsDelayL"));
+ TInt status(KErrNone);
+ //status = aItem.GetNextInt(controltype);
+ TUint value;
+ if(!iEffectControl)
+ {
+ return status = KErrNotReady;
+ }
+ status = static_cast<MReverbControl*>(iEffectControl)->ReflectionsDelay(value);
+ iLog->Log(_L("CEnhanMediaTestClass::HandleReverbReflectionsDelayL value = [%d]"),value);
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::HandleReverbReflectionsDelayMaxL(CStifItemParser& /*aItem*/)
+ {
+
+ iLog->Log(_L("CEnhanMediaTestClass::HandleReverbReflectionsDelayMaxL"));
+ TInt status(KErrNone);
+ //status = aItem.GetNextInt(controltype);
+ TUint value;
+ if(!iEffectControl)
+ {
+ return status = KErrNotReady;
+ }
+ status = static_cast<MReverbControl*>(iEffectControl)->ReflectionsDelayMax(value);
+ iLog->Log(_L("CEnhanMediaTestClass::HandleReverbReflectionsDelayMaxL value = [%d]"),value);
+ return status;
+ }
+
+
+TInt CEnhanMediaTestClass::HandleReverbReflectionsLevelL(CStifItemParser& /*aItem*/)
+ {
+
+ iLog->Log(_L("CEnhanMediaTestClass::HandleReverbReflectionsLevelL"));
+ TInt status(KErrNone);
+ //status = aItem.GetNextInt(controltype);
+ TInt value;
+ if(!iEffectControl)
+ {
+ return status = KErrNotReady;
+ }
+ status = static_cast<MReverbControl*>(iEffectControl)->ReflectionsLevel(value);
+ iLog->Log(_L("CEnhanMediaTestClass::HandleReverbReflectionsLevelL value = [%d]"),value);
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::HandleReverbReflectionLevelRangeL(CStifItemParser& /*aItem*/)
+ {
+
+ iLog->Log(_L("CEnhanMediaTestClass::HandleReverbReflectionLevelRangeL"));
+ TInt status(KErrNone);
+ //status = aItem.GetNextInt(controltype);
+ TInt min,max;
+ if(!iEffectControl)
+ {
+ return status = KErrNotReady;
+ }
+ status = static_cast<MReverbControl*>(iEffectControl)->ReflectionLevelRange(min,max);
+ iLog->Log(_L("CEnhanMediaTestClass::HandleReverbReflectionLevelRangeL min = [%d]- max = [%d]"),min,max);
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::HandleReverbReverbDelayL(CStifItemParser& /*aItem*/)
+ {
+
+ iLog->Log(_L("CEnhanMediaTestClass::HandleReverbReverbDelayL"));
+ TInt status(KErrNone);
+ //status = aItem.GetNextInt(controltype);
+ TUint value;
+ if(!iEffectControl)
+ {
+ return status = KErrNotReady;
+ }
+ status = static_cast<MReverbControl*>(iEffectControl)->ReverbDelay(value);
+ iLog->Log(_L("CEnhanMediaTestClass::HandleReverbReverbDelayL value = [%d]"),value);
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::HandleReverbReverbDelayMaxL(CStifItemParser& /*aItem*/)
+ {
+
+ iLog->Log(_L("CEnhanMediaTestClass::HandleReverbReverbDelayMaxL"));
+ TInt status(KErrNone);
+ //status = aItem.GetNextInt(controltype);
+ TUint value;
+ if(!iEffectControl)
+ {
+ return status = KErrNotReady;
+ }
+ status = static_cast<MReverbControl*>(iEffectControl)->ReverbDelayMax(value);
+ iLog->Log(_L("CEnhanMediaTestClass::HandleReverbReverbDelayMaxL value = [%d]"),value);
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::HandleReverbReverbLevelL(CStifItemParser& /*aItem*/)
+ {
+ iLog->Log(_L("CEnhanMediaTestClass::HandleReverbReverbLevelL"));
+ TInt status(KErrNone);
+ //status = aItem.GetNextInt(controltype);
+ TInt value;
+ if(!iEffectControl)
+ {
+ return status = KErrNotReady;
+ }
+ status = static_cast<MReverbControl*>(iEffectControl)->ReverbLevel(value);
+ iLog->Log(_L("CEnhanMediaTestClass::HandleReverbReverbLevelL value = [%d]"),value);
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::HandleReverbReverbLevelRangeL(CStifItemParser& /*aItem*/)
+ {
+ iLog->Log(_L("CEnhanMediaTestClass::HandleReverbReverbLevelRangeL"));
+ TInt status(KErrNone);
+ //status = aItem.GetNextInt(controltype);
+ TInt min,max;
+ if(!iEffectControl)
+ {
+ return status = KErrNotReady;
+ }
+ status = static_cast<MReverbControl*>(iEffectControl)->ReverbLevelRange(min,max);
+ iLog->Log(_L("CEnhanMediaTestClass::HandleReverbReverbLevelRangeL min = [%d] - max = [%d]"),min,max);
+ return status;
+ }
+
+
+
+
+
+TInt CEnhanMediaTestClass::HandleReverbRoomHFLevelL(CStifItemParser& /*aItem*/)
+ {
+ iLog->Log(_L("CEnhanMediaTestClass::HandleReverbRoomHFLevelL"));
+ TInt status(KErrNone);
+ //status = aItem.GetNextInt(controltype);
+ TInt value;
+ if(!iEffectControl)
+ {
+ return status = KErrNotReady;
+ }
+ status = static_cast<MReverbControl*>(iEffectControl)->RoomHFLevel(value);
+ iLog->Log(_L("CEnhanMediaTestClass::HandleReverbRoomHFLevelL value = [%d]"),value);
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::HandleReverbRoomHFLevelRangeL(CStifItemParser& /*aItem*/)
+ {
+ iLog->Log(_L("CEnhanMediaTestClass::HandleReverbRoomHFLevelRangeL"));
+ TInt status(KErrNone);
+ //status = aItem.GetNextInt(controltype);
+ TInt min,max;
+ if(!iEffectControl)
+ {
+ return status = KErrNotReady;
+ }
+ status = static_cast<MReverbControl*>(iEffectControl)->RoomHFLevelRange(min,max);
+ iLog->Log(_L("CEnhanMediaTestClass::HandleReverbRoomHFLevelRangeL min = [%d] - max = [%d]"),min,max);
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::HandleReverbRoomLevelL(CStifItemParser& /*aItem*/)
+ {
+ iLog->Log(_L("CEnhanMediaTestClass::HandleReverbRoomLevelL"));
+ TInt status(KErrNone);
+ TInt value;
+ if(!iEffectControl)
+ {
+ return status = KErrNotReady;
+ }
+ status = static_cast<MReverbControl*>(iEffectControl)->RoomLevel(value);
+ iLog->Log(_L("CEnhanMediaTestClass::HandleReverbRoomLevelL value = [%d]"),value);
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::HandleReverbRoomLevelRangeL(CStifItemParser& /*aItem*/)
+ {
+ iLog->Log(_L("CEnhanMediaTestClass::HandleReverbRoomLevelRangeL"));
+ TInt status(KErrNone);
+ //status = aItem.GetNextInt(controltype);
+ TInt min,max;
+ if(!iEffectControl)
+ {
+ return status = KErrNotReady;
+ }
+ status = static_cast<MReverbControl*>(iEffectControl)->RoomLevelRange(min,max);
+ iLog->Log(_L("CEnhanMediaTestClass::HandleReverbRoomLevelRangeL min = [%d] - max = [%d]"),min,max);
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::HandleReverbSetDecayHFRatioL(CStifItemParser& aItem)
+ {
+ iLog->Log(_L("CEnhanMediaTestClass::HandleReverbSetDecayHFRatioL"));
+ TInt status(KErrNone);
+ TInt value;
+ status = aItem.GetNextInt(value);
+ if(!iEffectControl)
+ {
+ return status = KErrNotReady;
+ }
+ status = static_cast<MReverbControl*>(iEffectControl)->SetDecayHFRatio(value);
+ iLog->Log(_L("CEnhanMediaTestClass::HandleReverbSetDecayHFRatioL value = [%d]"),value);
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::HandleReverbSetDecayTimeL(CStifItemParser& aItem)
+ {
+ iLog->Log(_L("CEnhanMediaTestClass::HandleReverbSetDecayTimeL"));
+ TInt status(KErrNone);
+ TInt value;
+ status = aItem.GetNextInt(value);
+ if(!iEffectControl)
+ {
+ return status = KErrNotReady;
+ }
+ status = static_cast<MReverbControl*>(iEffectControl)->SetDecayTime(value);
+ iLog->Log(_L("CEnhanMediaTestClass::HandleReverbSetDecayTimeL value = [%d]"),value);
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::HandleReverbSetDensityL(CStifItemParser& aItem)
+ {
+ iLog->Log(_L("CEnhanMediaTestClass::HandleReverbSetDensityL"));
+ TInt status(KErrNone);
+ TInt value;
+ status = aItem.GetNextInt(value);
+ if(!iEffectControl)
+ {
+ return status = KErrNotReady;
+ }
+ status = static_cast<MReverbControl*>(iEffectControl)->SetDensity(value);
+ iLog->Log(_L("CEnhanMediaTestClass::HandleReverbSetDensityL value = [%d]"),value);
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::HandleReverbSetDiffusionL(CStifItemParser& aItem)
+ {
+ iLog->Log(_L("CEnhanMediaTestClass::HandleReverbSetDiffusionL"));
+ TInt status(KErrNone);
+ TInt value;
+ status = aItem.GetNextInt(value);
+ if(!iEffectControl)
+ {
+ return status = KErrNotReady;
+ }
+ status = static_cast<MReverbControl*>(iEffectControl)->SetDiffusion(value);
+ iLog->Log(_L("CEnhanMediaTestClass::HandleReverbSetDiffusionL value = [%d]"),value);
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::HandleReverbSetReflectionsDelayL(CStifItemParser& aItem)
+ {
+ iLog->Log(_L("CEnhanMediaTestClass::HandleReverbSetReflectionsDelayL"));
+ TInt status(KErrNone);
+ TInt value;
+ status = aItem.GetNextInt(value);
+ if(!iEffectControl)
+ {
+ return status = KErrNotReady;
+ }
+ status = static_cast<MReverbControl*>(iEffectControl)->SetReflectionsDelay(value);
+ iLog->Log(_L("CEnhanMediaTestClass::HandleReverbSetReflectionsDelayL value = [%d]"),value);
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::HandleReverbSetReflectionsLevelL(CStifItemParser& aItem)
+ {
+ iLog->Log(_L("CEnhanMediaTestClass::HandleReverbSetReflectionsLevelL"));
+ TInt status(KErrNone);
+ TInt value;
+ status = aItem.GetNextInt(value);
+ if(!iEffectControl)
+ {
+ return status = KErrNotReady;
+ }
+ status = static_cast<MReverbControl*>(iEffectControl)->SetReflectionsLevel(value);
+ iLog->Log(_L("CEnhanMediaTestClass::HandleReverbSetReflectionsLevelL value = [%d]"),value);
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::HandleReverbSetReverbDelayL(CStifItemParser& aItem)
+ {
+ iLog->Log(_L("CEnhanMediaTestClass::HandleReverbSetReverbDelayL"));
+ TInt status(KErrNone);
+ TInt value;
+ status = aItem.GetNextInt(value);
+ if(!iEffectControl)
+ {
+ return status = KErrNotReady;
+ }
+ status = static_cast<MReverbControl*>(iEffectControl)->SetReverbDelay(value);
+ iLog->Log(_L("CEnhanMediaTestClass::HandleReverbSetReverbDelayL value = [%d]"),value);
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::HandleReverbSetReverbLevelL(CStifItemParser& aItem)
+ {
+ iLog->Log(_L("CEnhanMediaTestClass::HandleReverbSetReverbLevelL"));
+ TInt status(KErrNone);
+ TInt value;
+ status = aItem.GetNextInt(value);
+ if(!iEffectControl)
+ {
+ return status = KErrNotReady;
+ }
+ status = static_cast<MReverbControl*>(iEffectControl)->SetReverbLevel(value);
+ iLog->Log(_L("CEnhanMediaTestClass::HandleReverbSetReverbLevelL value = [%d]"),value);
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::HandleReverbSetRoomHFLevelL(CStifItemParser& aItem)
+ {
+ iLog->Log(_L("CEnhanMediaTestClass::HandleReverbSetRoomHFLevelL"));
+ TInt status(KErrNone);
+ TInt value;
+ status = aItem.GetNextInt(value);
+ if(!iEffectControl)
+ {
+ return status = KErrNotReady;
+ }
+ status = static_cast<MReverbControl*>(iEffectControl)->SetRoomHFLevel(value);
+ iLog->Log(_L("CEnhanMediaTestClass::HandleReverbSetRoomHFLevelL value = [%d]"),value);
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::HandleReverbSetRoomLevelL(CStifItemParser& aItem)
+ {
+ iLog->Log(_L("CEnhanMediaTestClass::HandleReverbSetRoomLevelL"));
+ TInt status(KErrNone);
+ TInt value;
+ status = aItem.GetNextInt(value);
+ if(!iEffectControl)
+ {
+ return status = KErrNotReady;
+ }
+ status = static_cast<MReverbControl*>(iEffectControl)->SetRoomLevel(value);
+ iLog->Log(_L("CEnhanMediaTestClass::HandleReverbSetRoomLevelL value = [%d]"),value);
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::HandleReverbDelayMaxL(CStifItemParser& /*aItem*/)
+ {
+ iLog->Log(_L("CEnhanMediaTestClass::HandleReverbDelayMaxL"));
+ TInt status(KErrNone);
+ //status = aItem.GetNextInt(controltype);
+ TUint value;
+ if(!iEffectControl)
+ {
+ return status = KErrNotReady;
+ }
+ status = static_cast<MReverbControl*>(iEffectControl)->ReverbDelayMax(value);
+ iLog->Log(_L("CEnhanMediaTestClass::HandleReverbDelayMaxL value = [%d]"),value);
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::HandleSWIsContinuousLevelSupportedL(CStifItemParser& /*aItem*/)
+ {
+ iLog->Log(_L("CEnhanMediaTestClass::HandleReverbDelayMaxL"));
+ TInt status(KErrNone);
+ //status = aItem.GetNextInt(controltype);
+ TInt value;
+ if(!iEffectControl)
+ {
+ return status = KErrNotReady;
+ }
+ status = static_cast<MStereoWideningControl*>(iEffectControl)->IsContinuousLevelSupported(value);
+ iLog->Log(_L("CEnhanMediaTestClass::HandleReverbDelayMaxL value = [%d]"),value);
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::HandleSWSetStereoWideningLevelL(CStifItemParser& aItem)
+ {
+ iLog->Log(_L("CEnhanMediaTestClass::HandleSWSetStereoWideningLevelL"));
+ TInt status(KErrNone);
+ TUint value;
+ status = aItem.GetNextInt(value);
+ if(!iEffectControl)
+ {
+ return status = KErrNotReady;
+ }
+ status = static_cast<MStereoWideningControl*>(iEffectControl)->SetStereoWideningLevel(value);
+ iLog->Log(_L("CEnhanMediaTestClass::HandleSWSetStereoWideningLevelL value = [%d]"),value);
+ return status;
+ }
+TInt CEnhanMediaTestClass::HandleSWStereoWideningLevelL(CStifItemParser& /*aItem*/)
+ {
+ iLog->Log(_L("CEnhanMediaTestClass::HandleSWStereoWideningLevelL"));
+ TInt status(KErrNone);
+ //status = aItem.GetNextInt(controltype);
+ TInt value;
+ if(!iEffectControl)
+ {
+ return status = KErrNotReady;
+ }
+ status = static_cast<MStereoWideningControl*>(iEffectControl)->StereoWideningLevel(value);
+ iLog->Log(_L("CEnhanMediaTestClass::HandleSWStereoWideningLevelL value = [%d]"),value);
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::LO_OrientationL (CStifItemParser& aItem)
+ {
+ TInt status(KErrNone);
+
+ if(!iEffectControl)
+ {
+ status = KErrNotReady;
+ return status;
+ }
+
+ TInt a,b,c;
+
+
+ TInt control = 0;
+ status = aItem.GetNextInt(control);
+
+ if (TControl(control) == ELISTORIENTCONTROL)
+ {
+ status = static_cast<MListenerOrientationControl*>(iEffectControl)->Orientation(a,b,c);
+ }
+ else if (TControl(control) == ESOURORIENTCONTROL)
+ {
+ status = static_cast<MSourceOrientationControl*>(iEffectControl)->Orientation(a,b,c);
+ }
+
+ if (status == KErrNone)
+ {
+ iLog->Log(_L("LO_OrientationL status = %d"), status);
+ }
+ else
+ {
+ iLog->Log(_L("LO_OrientationL ERROR = [%d]"), status);
+ }
+
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::LO_OrientationVectorsL (CStifItemParser& aItem)
+ {
+ TInt status(KErrNone);
+
+ if(!iEffectControl)
+ {
+ status = KErrNotReady;
+ return status;
+ }
+
+ TInt a,b,c,d,e,f;
+ TInt control = 0;
+ status = aItem.GetNextInt(control);
+ if (TControl(control) == ELISTORIENTCONTROL)
+ {
+ status = static_cast<MListenerOrientationControl*>(iEffectControl)->OrientationVectors(a,b,c,d,e,f);
+ }
+ else if (TControl(control) == ESOURORIENTCONTROL)
+ {
+ status = static_cast<MSourceOrientationControl*>(iEffectControl)->OrientationVectors(a,b,c,d,e,f);
+ }
+
+
+ if (status == KErrNone)
+ {
+ iLog->Log(_L("LO_OrientationVectorsL status = %d"), status);
+ }
+ else
+ {
+ iLog->Log(_L("LO_OrientationVectorsL ERROR = [%d]"), status);
+ }
+
+ return status;
+ }
+
+
+
+TInt CEnhanMediaTestClass::HandleRLLevelRangeL(CStifItemParser& /*aItem*/)
+ {
+ iLog->Log(_L("CEnhanMediaTestClass::HandleRLLevelRangeL"));
+ TInt status(KErrNone);
+ //status = aItem.GetNextInt(controltype);
+ TInt value1,value2;
+ if(!iEffectControl)
+ {
+ return status = KErrNotReady;
+ }
+ status = static_cast<MRoomLevelControl*>(iEffectControl)->LevelRange(value1,value2);
+ iLog->Log(_L("CEnhanMediaTestClass::HandleRLLevelRangeL value = [%d] - [%d]"),value1,value2);
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::HandleRLSetRoomLevelL(CStifItemParser& aItem)
+ {
+ iLog->Log(_L("CEnhanMediaTestClass::HandleRLSetRoomLevelL"));
+ TInt status(KErrNone);
+ TInt value;
+ status = aItem.GetNextInt(value);
+ if(!iEffectControl)
+ {
+ return status = KErrNotReady;
+ }
+ status = static_cast<MRoomLevelControl*>(iEffectControl)->SetRoomLevel(value);
+ iLog->Log(_L("CEnhanMediaTestClass::HandleRLSetRoomLevelL value = [%d]"),value);
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::HandleRLLevelL(CStifItemParser& /*aItem*/)
+ {
+ iLog->Log(_L("CEnhanMediaTestClass::HandleRLLevelL"));
+ TInt status(KErrNone);
+ //status = aItem.GetNextInt(controltype);
+ TInt value;
+ if(!iEffectControl)
+ {
+ return status = KErrNotReady;
+ }
+ status = static_cast<MRoomLevelControl*>(iEffectControl)->Level(value);
+ iLog->Log(_L("CEnhanMediaTestClass::HandleRLLevelL value = [%d]"),value);
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::HandleDADistanceAttenuationL(CStifItemParser& /*aItem*/)
+ {
+ iLog->Log(_L("CEnhanMediaTestClass::HandleDADistanceAttenuationL"));
+ TInt status(KErrNone);
+ if(!iEffectControl)
+ {
+ return status = KErrNotReady;
+ }
+ TInt a,b,c;
+ TUint d,e;
+ status = static_cast<MDistanceAttenuationControl*>(iEffectControl)->DistanceAttenuation(a,b,c,d,e);
+ iLog->Log(_L("CEnhanMediaTestClass::HandleDADistanceAttenuationL a = [%d] - b = [%d] - c = [%d] - d = [%d]- e = [%d]"),a,b,c,d,e);
+ return status;
+ }
+TInt CEnhanMediaTestClass::HandleDARollOffFactorMaxL(CStifItemParser& /*aItem*/)
+ {
+ iLog->Log(_L("CEnhanMediaTestClass::HandleDARollOffFactorMaxL"));
+ TInt status(KErrNone);
+ if(!iEffectControl)
+ {
+ return status = KErrNotReady;
+ }
+ TUint value;
+ status = static_cast<MDistanceAttenuationControl*>(iEffectControl)->RollOffFactorMax(value);
+ iLog->Log(_L("CEnhanMediaTestClass::HandleDARollOffFactorMaxL value = [%d]"),value);
+ return status;
+ }
+TInt CEnhanMediaTestClass::HandleDARoomRollOffFactorMaxL(CStifItemParser& /*aItem*/)
+ {
+ iLog->Log(_L("CEnhanMediaTestClass::HandleDARoomRollOffFactorMaxL"));
+ TInt status(KErrNone);
+ if(!iEffectControl)
+ {
+ return status = KErrNotReady;
+ }
+ TUint value;
+ status = static_cast<MDistanceAttenuationControl*>(iEffectControl)->RoomRollOffFactorMax(value);
+ iLog->Log(_L("CEnhanMediaTestClass::HandleDARoomRollOffFactorMaxL value = [%d]"),value);
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::HandleSLLocationCartesianL(CStifItemParser& aItem)
+ {
+ iLog->Log(_L("CEnhanMediaTestClass::HandleSLLocationCartesianL"));
+ TInt status(KErrNone);
+ if(!iEffectControl)
+ {
+ return status = KErrNotReady;
+ }
+ TInt a,b,c;
+ TInt control = 0;
+ status = aItem.GetNextInt(control);
+
+ if (TControl(control) == ESOURLOCCONTROL)
+ {
+ status = static_cast<MSourceLocationControl*>(iEffectControl)->LocationCartesian(a,b,c);
+ }
+ else if (TControl(control) == ELISTLOCCONTROL)
+ {
+ status = static_cast<MSourceLocationControl*>(iEffectControl)->LocationCartesian(a,b,c);
+ }
+ iLog->Log(_L("CEnhanMediaTestClass::HandleSLLocationCartesianL status = [%d]"),status);
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::HandleSLLocationSphericalL(CStifItemParser& aItem)
+ {
+ iLog->Log(_L("CEnhanMediaTestClass::HandleSLLocationSphericalL"));
+ TInt status(KErrNone);
+ if(!iEffectControl)
+ {
+ return status = KErrNotReady;
+ }
+ TInt a,b,c;
+ TInt control = 0;
+ status = aItem.GetNextInt(control);
+
+ if (TControl(control) == ESOURLOCCONTROL)
+ {
+ status = static_cast<MSourceLocationControl*>(iEffectControl)->LocationSpherical(a,b,c);
+ }
+ else if (TControl(control) == ELISTLOCCONTROL)
+ {
+ status = static_cast<MListenerLocationControl*>(iEffectControl)->LocationSpherical(a,b,c);
+ }
+ iLog->Log(_L("CEnhanMediaTestClass::HandleSLLocationSphericalL status = [%d]"),status);
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::HandleSLSetLocationCartesianL(CStifItemParser& aItem)
+ {
+ iLog->Log(_L("CEnhanMediaTestClass::HandleSLSetLocationCartesianL"));
+ TInt status(KErrNone);
+ if(!iEffectControl)
+ {
+ return status = KErrNotReady;
+ }
+ TInt control = 0;
+ status = aItem.GetNextInt(control);
+ TInt a,b,c;
+ status = aItem.GetNextInt(a);
+ status = aItem.GetNextInt(b);
+ status = aItem.GetNextInt(c);
+
+ if (TControl(control) == ESOURLOCCONTROL)
+ {
+ status = static_cast<MSourceLocationControl*>(iEffectControl)->SetLocationCartesian(a,b,c);
+ }
+ else if (TControl(control) == ELISTLOCCONTROL)
+ {
+ status = static_cast<MListenerLocationControl*>(iEffectControl)->SetLocationCartesian(a,b,c);
+ }
+ iLog->Log(_L("CEnhanMediaTestClass::HandleSLSetLocationCartesianL status = [%d]"),status);
+ return status;
+ }
+TInt CEnhanMediaTestClass::HandleSLSetLocationSphericalL(CStifItemParser& aItem)
+ {
+ iLog->Log(_L("CEnhanMediaTestClass::HandleSLSetLocationSphericalL"));
+ TInt status(KErrNone);
+ if(!iEffectControl)
+ {
+ return status = KErrNotReady;
+ }
+ TInt control = 0;
+ status = aItem.GetNextInt(control);
+ TInt a,b,c;
+ status = aItem.GetNextInt(a);
+ status = aItem.GetNextInt(b);
+ status = aItem.GetNextInt(c);
+ if (TControl(control) == ESOURLOCCONTROL)
+ {
+ status = static_cast<MSourceLocationControl*>(iEffectControl)->SetLocationSpherical(a,b,c);
+ }
+ else if (TControl(control) == ELISTLOCCONTROL)
+ {
+ status = static_cast<MListenerLocationControl*>(iEffectControl)->SetLocationSpherical(a,b,c);
+ }
+
+ iLog->Log(_L("CEnhanMediaTestClass::HandleSLSetLocationSphericalL status = [%d]"),status);
+ return status;
+ }
+
+
+TInt CEnhanMediaTestClass::HandleControlTypeL(CStifItemParser& aItem)
+ {
+ iLog->Log(_L("CEnhanMediaTestClass::HandleControlTypeL"));
+ TInt status(KErrNone);
+ TInt control = 0;
+ status = aItem.GetNextInt(control);
+ TUid controlUid(TUid::Uid(0));
+ switch(TControl(control))
+ {
+ case EFILESOURCE:
+ {
+ if(iMFileSource)
+ {
+ controlUid = iMFileSource->Type();
+ }
+ else
+ {
+ status = KErrNotFound;
+ }
+ break;
+ }
+ case EDATABUFFERSOURCE:
+ {
+ if(iMDataBufferSource)
+ {
+ controlUid = iMDataBufferSource->Type();
+ }
+ else
+ {
+ status = KErrNotFound;
+ }
+ break;
+ }
+ case EDESCRIPTORSOURCE:
+ {
+ if(iMDescriptorSource)
+ {
+ controlUid = iMDescriptorSource->Type();
+ }
+ else
+ {
+ status = KErrNotFound;
+ }
+ break;
+ }
+ case ESTREAMCONTROL:
+ {
+ if(iMStreamControl)
+ {
+ controlUid = iMStreamControl->Type();
+ }
+ else
+ {
+ status = KErrNotFound;
+ }
+ break;
+ }
+ case EMMFAUDIOOUTPUTSINKCONTROL:
+ {
+ if(iMAudioSink)
+ {
+ controlUid = iMAudioSink->Type();
+ }
+ else
+ {
+ status = KErrNotFound;
+ }
+ break;
+ }
+ case EPDLSOURCE:
+ {
+ if(iMProgDLSource)
+ {
+ controlUid = iMProgDLSource->Type();
+ }
+ else
+ {
+ status = KErrNotFound;
+ }
+ break;
+ }
+
+ case EVOLUMECONTROL:
+ {
+ if(iMVolumeControl)
+ {
+ controlUid = iMVolumeControl->Type();
+ }
+ else
+ {
+ status = KErrNotFound;
+ }
+ break;
+ }
+ case EBALANCECONTROL:
+ {
+ if(iMBalanceControl)
+ {
+ controlUid = iMBalanceControl->Type();
+ }
+ else
+ {
+ status = KErrNotFound;
+ }
+ break;
+ }
+ case EEQUALIZERCONTROL:
+ {
+ if(iMEqualizerControl)
+ {
+ controlUid = iMEqualizerControl->Type();
+ }
+ else
+ {
+ status = KErrNotFound;
+ }
+ break;
+ }
+ case EREVERBCONTROL:
+ {
+ if(iMReverbControl)
+ {
+ controlUid = iMReverbControl->Type();
+ }
+ else
+ {
+ status = KErrNotFound;
+ }
+ break;
+ }
+
+ case EBASSBOOSTCONTROL:
+ {
+ if(iMBassBoostControl)
+ {
+ controlUid = iMBassBoostControl->Type();
+ }
+ else
+ {
+ status = KErrNotFound;
+ }
+ break;
+ }
+
+ case ESTEREOWIDCONTROL:
+ {
+ if(iMStereoWideningControl)
+ {
+ controlUid = iMStereoWideningControl->Type();
+ }
+ else
+ {
+ status = KErrNotFound;
+ }
+ break;
+ }
+
+ case ELOUDNESSCONTROL:
+ {
+ if(iMLoudnessControl)
+ {
+ controlUid = iMLoudnessControl->Type();
+ }
+ else
+ {
+ status = KErrNotFound;
+ }
+ break;
+ }
+
+ case EROOMLEVELCONTROL:
+ {
+ if(iMRoomLevelControl)
+ {
+ controlUid = iMRoomLevelControl->Type();
+ }
+ else
+ {
+ status = KErrNotFound;
+ }
+ break;
+ }
+
+ case EDISTATTCONTROL:
+ {
+ if(iMDistanceAttenuationControl)
+ {
+ controlUid = iMDistanceAttenuationControl->Type();
+ }
+ else
+ {
+ status = KErrNotFound;
+ }
+ break;
+ }
+
+ case ELISTDOPPCONTROL:
+ {
+ if(iMListenerDopplerControl)
+ {
+ controlUid = iMListenerDopplerControl->Type();
+ }
+ else
+ {
+ status = KErrNotFound;
+ }
+ break;
+ }
+
+ case ESOURDOPPCONTROL:
+ {
+ if(iMSourceDopplerControl)
+ {
+ controlUid = iMSourceDopplerControl->Type();
+ }
+ else
+ {
+ status = KErrNotFound;
+ }
+ break;
+ }
+
+ case ELISTLOCCONTROL:
+ {
+ if(iMListenerLocationControl)
+ {
+ controlUid = iMListenerLocationControl->Type();
+ }
+ else
+ {
+ status = KErrNotFound;
+ }
+ break;
+ }
+
+ case ESOURLOCCONTROL:
+ {
+ if(iMSourceLocationControl)
+ {
+ controlUid = iMSourceLocationControl->Type();
+ }
+ else
+ {
+ status = KErrNotFound;
+ }
+ break;
+ }
+
+
+ case ELISTORIENTCONTROL:
+ {
+ if(iMListenerOrientationControl)
+ {
+ controlUid = iMListenerOrientationControl->Type();
+ }
+ else
+ {
+ status = KErrNotFound;
+ }
+ break;
+ }
+
+ case ESOURORIENTCONTROL:
+ {
+ if(iMSourceOrientationControl)
+ {
+ controlUid = iMSourceOrientationControl->Type();
+ }
+ else
+ {
+ status = KErrNotFound;
+ }
+ break;
+ }
+ }
+
+ iLog->Log(_L("CEnhanMediaTestClass::HandleControlTypeL status = [%d]"),status);
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::HandleControlControlTypeL(CStifItemParser& aItem)
+ {
+ iLog->Log(_L("CEnhanMediaTestClass::HandleControlControlTypeL"));
+ TInt status(KErrNone);
+
+ TInt control = 0;
+ status = aItem.GetNextInt(control);
+ TControlType controlType(TControlType(0));
+ switch(TControl(control))
+ {
+ case EFILESOURCE:
+ {
+ if(iMFileSource)
+ {
+ controlType = iMFileSource->ControlType();
+ }
+ else
+ {
+ status = KErrNotFound;
+ }
+ break;
+ }
+ case EDATABUFFERSOURCE:
+ {
+ if(iMDataBufferSource)
+ {
+ controlType = iMDataBufferSource->ControlType();
+ }
+ else
+ {
+ status = KErrNotFound;
+ }
+ break;
+ }
+ case EDESCRIPTORSOURCE:
+ {
+ if(iMDescriptorSource)
+ {
+ controlType = iMDescriptorSource->ControlType();
+ }
+ else
+ {
+ status = KErrNotFound;
+ }
+ break;
+ }
+ case ESTREAMCONTROL:
+ {
+ if(iMStreamControl)
+ {
+ controlType = iMStreamControl->ControlType();
+ }
+ else
+ {
+ status = KErrNotFound;
+ }
+ break;
+ }
+ case EMMFAUDIOOUTPUTSINKCONTROL:
+ {
+ if(iMAudioSink)
+ {
+ controlType = iMAudioSink->ControlType();
+ }
+ else
+ {
+ status = KErrNotFound;
+ }
+ break;
+ }
+ case EPDLSOURCE:
+ {
+ if(iMProgDLSource)
+ {
+ controlType = iMProgDLSource->ControlType();
+ }
+ else
+ {
+ status = KErrNotFound;
+ }
+ break;
+ }
+
+ case EVOLUMECONTROL:
+ {
+ if(iMVolumeControl)
+ {
+ controlType = iMVolumeControl->ControlType();
+ }
+ else
+ {
+ status = KErrNotFound;
+ }
+ break;
+ }
+ case EBALANCECONTROL:
+ {
+ if(iMBalanceControl)
+ {
+ controlType = iMBalanceControl->ControlType();
+ }
+ else
+ {
+ status = KErrNotFound;
+ }
+ break;
+ }
+ case EEQUALIZERCONTROL:
+ {
+ if(iMEqualizerControl)
+ {
+ controlType = iMEqualizerControl->ControlType();
+ }
+ else
+ {
+ status = KErrNotFound;
+ }
+ break;
+ }
+ case EREVERBCONTROL:
+ {
+ if(iMReverbControl)
+ {
+ controlType = iMReverbControl->ControlType();
+ }
+ else
+ {
+ status = KErrNotFound;
+ }
+ break;
+ }
+
+ case EBASSBOOSTCONTROL:
+ {
+ if(iMBassBoostControl)
+ {
+ controlType = iMBassBoostControl->ControlType();
+ }
+ else
+ {
+ status = KErrNotFound;
+ }
+ break;
+ }
+
+ case ESTEREOWIDCONTROL:
+ {
+ if(iMStereoWideningControl)
+ {
+ controlType = iMStereoWideningControl->ControlType();
+ }
+ else
+ {
+ status = KErrNotFound;
+ }
+ break;
+ }
+
+ case ELOUDNESSCONTROL:
+ {
+ if(iMLoudnessControl)
+ {
+ controlType = iMLoudnessControl->ControlType();
+ }
+ else
+ {
+ status = KErrNotFound;
+ }
+ break;
+ }
+
+ case EROOMLEVELCONTROL:
+ {
+ if(iMRoomLevelControl)
+ {
+ controlType = iMRoomLevelControl->ControlType();
+ }
+ else
+ {
+ status = KErrNotFound;
+ }
+ break;
+ }
+
+ case EDISTATTCONTROL:
+ {
+ if(iMDistanceAttenuationControl)
+ {
+ controlType = iMDistanceAttenuationControl->ControlType();
+ }
+ else
+ {
+ status = KErrNotFound;
+ }
+ break;
+ }
+
+ case ELISTDOPPCONTROL:
+ {
+ if(iMListenerDopplerControl)
+ {
+ controlType = iMListenerDopplerControl->ControlType();
+ }
+ else
+ {
+ status = KErrNotFound;
+ }
+ break;
+ }
+
+ case ESOURDOPPCONTROL:
+ {
+ if(iMSourceDopplerControl)
+ {
+ controlType = iMSourceDopplerControl->ControlType();
+ }
+ else
+ {
+ status = KErrNotFound;
+ }
+ break;
+ }
+
+ case ELISTLOCCONTROL:
+ {
+ if(iMListenerLocationControl)
+ {
+ controlType = iMListenerLocationControl->ControlType();
+ }
+ else
+ {
+ status = KErrNotFound;
+ }
+ break;
+ }
+
+ case ESOURLOCCONTROL:
+ {
+ if(iMSourceLocationControl)
+ {
+ controlType = iMSourceLocationControl->ControlType();
+ }
+ else
+ {
+ status = KErrNotFound;
+ }
+ break;
+ }
+
+
+ case ELISTORIENTCONTROL:
+ {
+ if(iMListenerOrientationControl)
+ {
+ controlType = iMListenerOrientationControl->ControlType();
+ }
+ else
+ {
+ status = KErrNotFound;
+ }
+ break;
+ }
+
+ case ESOURORIENTCONTROL:
+ {
+ if(iMSourceOrientationControl)
+ {
+ controlType = iMSourceOrientationControl->ControlType();
+ }
+ else
+ {
+ status = KErrNotFound;
+ }
+ break;
+ }
+
+
+ }
+
+ iLog->Log(_L("CEnhanMediaTestClass::HandleControlControlTypeL status = [%d]"),status);
+ return status;
+ }
+
+
+
+
+
+
+TInt CEnhanMediaTestClass::HandleSDSetFactorL(CStifItemParser& aItem)
+ {
+ iLog->Log(_L("CEnhanMediaTestClass::HandleLDSetFactorL"));
+ TInt status(KErrNone);
+ if(!iEffectControl)
+ {
+ return KErrNotReady;
+ }
+ TInt control = 0;
+ status = aItem.GetNextInt(control);
+ TUint value = 0;
+ aItem.GetNextInt(value);
+
+ if (TControl(control) == ELISTDOPPCONTROL)
+ {
+ status = static_cast<MListenerDopplerControl*>(iEffectControl)->SetFactor(value);
+ }
+ if (TControl(control) == ESOURDOPPCONTROL)
+ {
+ status = static_cast<MSourceDopplerControl*>(iEffectControl)->SetFactor(value);
+ }
+ iLog->Log(_L("CEnhanMediaTestClass::HandleLDSetFactorL END"));
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::HandleSDSetSphericalVelocityL(CStifItemParser& aItem)
+ {
+ iLog->Log(_L("CEnhanMediaTestClass::HandleSDSetSphericalVelocityL"));
+ TInt status(KErrNone);
+ if(!iEffectControl)
+ {
+ return status = KErrNotReady;
+ }
+ TInt control = 0;
+ status = aItem.GetNextInt(control);
+ TInt a,b,c;
+ status = aItem.GetNextInt(a);
+ status = aItem.GetNextInt(b);
+ status = aItem.GetNextInt(c);
+
+ if (TControl(control) == ELISTDOPPCONTROL)
+ {
+ status = static_cast<MListenerDopplerControl*>(iEffectControl)->SetCartesianVelocity(a,b,c);
+ }
+ if (TControl(control) == ESOURDOPPCONTROL)
+ {
+ status = static_cast<MSourceDopplerControl*>(iEffectControl)->SetCartesianVelocity(a,b,c);
+ }
+ iLog->Log(_L("CEnhanMediaTestClass::HandleSDSetSphericalVelocityL END"));
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::HandleSDSphericalVelocityL(CStifItemParser& aItem)
+ {
+ iLog->Log(_L("CEnhanMediaTestClass::HandleSDSphericalVelocityL"));
+ TInt status(KErrNone);
+ if(!iEffectControl)
+ {
+ return status = KErrNotReady;
+ }
+ TInt control = 0;
+ status = aItem.GetNextInt(control);
+ TInt a,b,c;
+
+ if (TControl(control) == ELISTDOPPCONTROL)
+ {
+ status = static_cast<MListenerDopplerControl*>(iEffectControl)->SphericalVelocity(a,b,c);
+ }
+ if (TControl(control) == ESOURDOPPCONTROL)
+ {
+ status = static_cast<MSourceDopplerControl*>(iEffectControl)->SphericalVelocity(a,b,c);
+ }
+ iLog->Log(_L("CEnhanMediaTestClass::HandleSDSphericalVelocityL END"));
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::HandleSDCartesianVelocityL(CStifItemParser& aItem)
+ {
+ TInt status(KErrNone);
+ iLog->Log(_L("CEnhanMediaTestClass::HandleSDCartesianVelocityL"));
+ if(!iEffectControl)
+ {
+ return status = KErrNotReady;
+ }
+ TInt control = 0;
+ status = aItem.GetNextInt(control);
+ TInt a,b,c;
+
+ if (TControl(control) == ELISTDOPPCONTROL)
+ {
+ status = static_cast<MListenerDopplerControl*>(iEffectControl)->CartesianVelocity(a,b,c);
+ }
+ if (TControl(control) == ESOURDOPPCONTROL)
+ {
+ status = static_cast<MSourceDopplerControl*>(iEffectControl)->CartesianVelocity(a,b,c);
+ }
+ iLog->Log(_L("CEnhanMediaTestClass::HandleSDCartesianVelocityL END"));
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::HandleSDFactorL(CStifItemParser& aItem)
+ {
+ TInt status(KErrNone);
+ iLog->Log(_L("CEnhanMediaTestClass::HandleSDFactorL"));
+ if(!iEffectControl)
+ {
+ return status = KErrNotReady;
+ }
+ TInt control = 0;
+ status = aItem.GetNextInt(control);
+ TUint value;
+
+ if (TControl(control) == ELISTDOPPCONTROL)
+ {
+ status = static_cast<MListenerDopplerControl*>(iEffectControl)->Factor(value);
+ }
+ if (TControl(control) == ESOURDOPPCONTROL)
+ {
+ status = static_cast<MSourceDopplerControl*>(iEffectControl)->Factor(value);
+ }
+ iLog->Log(_L("CEnhanMediaTestClass::HandleSDFactorL END"));
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::HandleSDFactorMaxL(CStifItemParser& aItem)
+ {
+ iLog->Log(_L("CEnhanMediaTestClass::HandleLDSetFactorL"));
+ TInt status(KErrNone);
+ if(!iEffectControl)
+ {
+ return KErrNotReady;
+ }
+ TInt control = 0;
+ status = aItem.GetNextInt(control);
+ TUint value;
+
+ if (TControl(control) == ELISTDOPPCONTROL)
+ {
+ status = static_cast<MListenerDopplerControl*>(iEffectControl)->FactorMax(value);
+ }
+ if (TControl(control) == ESOURDOPPCONTROL)
+ {
+ status = static_cast<MSourceDopplerControl*>(iEffectControl)->FactorMax(value);
+ }
+ iLog->Log(_L("CEnhanMediaTestClass::HandleLDSetFactorL END"));
+ return status;
+ }
+
+TInt CEnhanMediaTestClass::HandleSDSetCartesianVelocityL(CStifItemParser& aItem)
+ {
+ TInt status(KErrNone);
+ iLog->Log(_L("CEnhanMediaTestClass::HandleSDSetCartesianVelocityL"));
+ if(!iEffectControl)
+ {
+ return status = KErrNotReady;
+ }
+ TInt control = 0;
+ status = aItem.GetNextInt(control);
+ TInt a,b,c;
+ status = aItem.GetNextInt(a);
+ status = aItem.GetNextInt(b);
+ status = aItem.GetNextInt(c);
+
+ if (TControl(control) == ELISTDOPPCONTROL)
+ {
+ status = static_cast<MListenerDopplerControl*>(iEffectControl)->SetCartesianVelocity(a,b,c);
+ }
+ if (TControl(control) == ESOURDOPPCONTROL)
+ {
+ status = static_cast<MSourceDopplerControl*>(iEffectControl)->SetCartesianVelocity(a,b,c);
+ }
+ iLog->Log(_L("CEnhanMediaTestClass::HandleSDSetCartesianVelocityL END"));
+ return status;
+ }
+
+// End of File