MCL/sf/mw/mmmw: comparison mmmw_plat/telephony_multimedia_service_api/tsrc/TmsAudioServicesTestClass/src/TmsAudioServicesTestClassBlocks.cpp

equal deleted inserted replaced

-:f5c5c82a163e
+:3570217d8c21
 // Run specified method. Contains also table of test mothods and their names.
 // -----------------------------------------------------------------------------
 //
 TInt CTmsAudioServicesTestClass::RunMethodL(CStifItemParser& aItem)
 {
-static TStifFunctionInfo const
+static TStifFunctionInfo const KFunctions[] =
-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( "ReSetDownlinkFormat", CTmsAudioServicesTestClass::ReSetDownlinkFormat ),
 ENTRY( "ReSetUplinkFormat", CTmsAudioServicesTestClass::ReSetUplinkFormat ),
 ENTRY( "OpenDownlink", CTmsAudioServicesTestClass::OpenDownlink ),
 ENTRY( "OpenUplink", CTmsAudioServicesTestClass::OpenUplink ),
 ENTRY( "Gain", CTmsAudioServicesTestClass::Gain ),
-ENTRY( "AddGlobleGainEffectToStream", CTmsAudioServicesTestClass::AddGlobleGainEffectToStream),
+ENTRY( "AddGlobalGainEffectToStream", CTmsAudioServicesTestClass::AddGlobalGainEffectToStream),
-ENTRY( "RemoveGlobleGainEffectToStream", CTmsAudioServicesTestClass::RemoveGlobleGainEffectToStream),
+ENTRY( "RemoveGlobalGainEffectToStream", CTmsAudioServicesTestClass::RemoveGlobalGainEffectToStream),
 ENTRY( "Volume", CTmsAudioServicesTestClass::Volume ),
-ENTRY( "AddGlobleVolumeEffectToStream", CTmsAudioServicesTestClass::AddGlobleVolumeEffectToStream),
+ENTRY( "AddGlobalVolumeEffectToStream", CTmsAudioServicesTestClass::AddGlobalVolumeEffectToStream),
-ENTRY( "RemoveGlobleVolumeEffectToStream", CTmsAudioServicesTestClass::RemoveGlobleVolumeEffectToStream),
+ENTRY( "RemoveGlobalVolumeEffectToStream", CTmsAudioServicesTestClass::RemoveGlobalVolumeEffectToStream),
-ENTRY( "CreateGlobleGainEffect", CTmsAudioServicesTestClass::CreateGlobleGainEffect),
+ENTRY( "CreateGlobalGainEffect", CTmsAudioServicesTestClass::CreateGlobalGainEffect),
 ENTRY( "Close", CTmsAudioServicesTestClass::Close ),
 ENTRY( "Start", CTmsAudioServicesTestClass::Start ),
 ENTRY( "Pause", CTmsAudioServicesTestClass::Pause ),
 ENTRY( "Stop", CTmsAudioServicesTestClass::Stop ),
 ENTRY( "GetBitRateList", CTmsAudioServicesTestClass::GetBitRateList ),
 //      AddVolumeEffectToStream();
 }
 break;
 case TMS_EFFECT_GLOBAL_VOL:
 {
-error = CreateVolumeGlobleEffect();
+error = CreateVolumeGlobalEffect();
-//       AddGlobleVolumeEffectToStream();
+//       AddGlobalVolumeEffectToStream();
 }
 break;
 case TMS_EFFECT_GAIN:
 {
 error = CreateGainEffect();
 //        AddGainEffectToStream();
 }
 break;
 case TMS_EFFECT_GLOBAL_GAIN:
 {
-error = CreateGlobleGainEffect();
+error = CreateGlobalGainEffect();
-//        AddGlobleGainEffectToStream();
+//        AddGlobalGainEffectToStream();
 }
 break;
 default:
 error = KErrNotSupported;
 break;
 }
 return error;
 }
-TInt CTmsAudioServicesTestClass::CreateDownlinkStream(CStifItemParser& /*aItem*/)
+TInt CTmsAudioServicesTestClass::CreateDownlinkStream(
+CStifItemParser& /*aItem*/)
 {
 FTRACE(FPrint(_L("CTmsAudioServicesTestClass::CreateDownlinkStream")));
 iLog->Log(_L("CTmsAudioServicesTestClass::CreateDownlinkStream"));
 TInt error = KErrNone;
 error = iTmsDnlink->SetFormat(iTmsFormat);
 }
 if (error != KErrNone)
 {
-iLog->Log(_L("CTmsAudioServicesTestClass::SetDownlinkFormat - failed, return error = %d" ),
+iLog->Log(_L("CTmsAudioServicesTestClass::SetDownlinkFormat - failed, return error = %d" ), error);
-error);
 return error;
 }
 }
 else
 {
 if (iTmsDnlink && iTmsFormatDn)
 {
 error = iTmsDnlink->ResetFormat(iTmsFormatDn);
 if (error != KErrNone)
 {
-iLog->Log(_L("CTmsAudioServicesTestClass::ReSetDownlinkFormat - failed, return error = %d" ),
+iLog->Log(_L("CTmsAudioServicesTestClass::ReSetDownlinkFormat - failed, return error = %d" ), error);
-error);
 return error;
 }
 }
 else
 {
 if (iTmsUplink)
 {
 if (iTmsFormatUp)
 {
-iLog->Log(
+iLog->Log(_L("CTmsAudioServicesTestClass::SetUplinkFormat - iTmsFormatUp"));
-_L("CTmsAudioServicesTestClass::SetUplinkFormat - iTmsFormatUp"));
 error = iTmsUplink->SetFormat(iTmsFormatUp);
 }
 else
 {
 iLog->Log(_L("CTmsAudioServicesTestClass::SetUplinkFormat - iTmsFormat"));
 error = iTmsUplink->SetFormat(iTmsFormat);
 }
 if (error != KErrNone)
 {
-iLog->Log(_L("CTmsAudioServicesTestClass::SetUplinkFormat - failed, return error = %d" ),
+iLog->Log(_L("CTmsAudioServicesTestClass::SetUplinkFormat - failed, return error = %d" ), error);
-error);
 return error;
 }
 }
 else
 {
 {
 //iRecBufPtr.Set(NULL, 0, 0);
 iRecBufReady = EFalse;
 //iUpLinkCodec = ENULL;
 iTmsUplink->Deinit();
+iTmsUplink->RemoveObserver(*this);
 iUpLinkStatus = UNINITIALIZED;
 iLog->Log(_L("Close Uplink"));
 AddExpectedEvent(EUplinkClosed, KMediumTimeout);
 }
 else if (closeType == KTagDnlink)
 {
 //iPlayBufPtr.Set(NULL, 0, 0);
 iTmsDnlink->Deinit();
+iTmsDnlink->RemoveObserver(*this);
 iDnLinkStatus = UNINITIALIZED;
 iPlayBufReady = EFalse;
 // iDnLinkCodec = ENULL;
 iLog->Log(_L("Close Dnlink"));
 AddExpectedEvent(EDownlinkClosed, KMediumTimeout);
 aItem.GetNextInt(effecttype);
 if (effecttype == TMS_EFFECT_GAIN)
 {
 RDebug::Printf("[TMS STIF] GAIN, GetMaxLevel");
-ret = static_cast<TMSGainEffect*>(iTmsUplinkEffect)->GetMaxLevel(
+ret = static_cast<TMSGainEffect*> (iTmsUplinkEffect)->GetMaxLevel(
 iMaxGain);
 RDebug::Printf("[TMS STIF] GAIN, GetMaxLevel Level [%d] Ret Err [%d]", iMaxGain, ret);
 RDebug::Printf("[TMS STIF] GAIN, SetLevel to [%d]", iMaxGain);
 ret = static_cast<TMSGainEffect*>(iTmsUplinkEffect)->SetLevel(iMaxGain);
 RDebug::Printf("[TMS STIF] GAIN, SetLevel ret [%d]", ret);
 iLog->Log(_L("SetMaxGain: %d"), iMaxGain);
 RDebug::Printf("[TMS STIF] GAIN, GetLevel");
-ret = static_cast<TMSGainEffect*>(iTmsUplinkEffect)->GetLevel(iGain);
+ret = static_cast<TMSGainEffect*> (iTmsUplinkEffect)->GetLevel(iGain);
 RDebug::Printf("[TMS STIF] GAIN, Exp Level [%d] Ret Level [%d] Ret Err [%d]", iMaxGain, iGain, ret);
 if (iGain != iMaxGain)
 {
 iLog->Log(_L("GetGain doesn't return expected MaxGain!!! returned Gain = %d"), iGain);
 return KErrUnexpectedValue;
 }
-static_cast<TMSGainEffect*>(iTmsUplinkEffect)->SetLevel(0);
+static_cast<TMSGainEffect*> (iTmsUplinkEffect)->SetLevel(0);
 iLog->Log(_L("MuteMic"));
-static_cast<TMSGainEffect*>(iTmsUplinkEffect)->GetLevel(iGain);
+static_cast<TMSGainEffect*> (iTmsUplinkEffect)->GetLevel(iGain);
 if (iGain != 0)
 {
 iLog->Log(_L("GetGain does not return expected Mute value!!! returned Gain = %d"), iGain);
 return KErrUnexpectedValue;
 }
 }
 else if (effecttype == TMS_EFFECT_GLOBAL_GAIN)
 {
 RDebug::Printf("[TMS STIF] GLOBAL GAIN, GetMaxLevel");
-ret = static_cast<TMSGlobalGainEffect*>(iGlobalGain)->GetMaxLevel(
+ret = static_cast<TMSGlobalGainEffect*> (iGlobalGain)->GetMaxLevel(
 iMaxGain);
 RDebug::Printf("[TMS STIF] GLOBAL GAIN, GetMaxLevel Level [%d] Ret Err [%d]", iMaxGain, ret);
 RDebug::Printf("[TMS STIF] GLOBAL GAIN, SetLevel to [%d]", iMaxGain);
-ret = static_cast<TMSGlobalGainEffect*>(iGlobalGain)->SetLevel(
+ret = static_cast<TMSGlobalGainEffect*> (iGlobalGain)->SetLevel(
 iMaxGain);
 RDebug::Printf("[TMS STIF] GLOBAL GAIN, SetLevel ret [%d]", ret);
-iLog->Log(_L("SetGlobleMaxGain: %d"), iMaxGain);
+iLog->Log(_L("SetGlobalMaxGain: %d"), iMaxGain);
 RDebug::Printf("[TMS STIF] GLOBAL GAIN, GetLevel");
 ret = static_cast<TMSGlobalGainEffect*>(iGlobalGain)->GetLevel(iGain);
 RDebug::Printf("[TMS STIF] GLOBAL GAIN, Exp Level [%d] Ret Level [%d] Ret Err [%d]", iMaxGain, iGain, ret);
 if (iGain != iMaxGain)
 {
-iLog->Log(_L("GetGain doesn't return expected Globle MaxGain!!! returned Gain = %d"), iGain);
+iLog->Log(_L("GetGain doesn't return expected Global MaxGain!!! returned Gain = %d"), iGain);
 return KErrUnexpectedValue;
 }
-static_cast<TMSGlobalGainEffect*>(iGlobalGain)->SetLevel(0);
+static_cast<TMSGlobalGainEffect*> (iGlobalGain)->SetLevel(0);
 iLog->Log(_L("MuteMic"));
-static_cast<TMSGlobalGainEffect*>(iGlobalGain)->GetLevel(iGain);
+static_cast<TMSGlobalGainEffect*> (iGlobalGain)->GetLevel(iGain);
 if (iGain != 0)
 {
 iLog->Log(_L("GetGain does not return expected loble Mute value!!! returned Gain = %d"), iGain);
 return KErrUnexpectedValue;
 aItem.GetNextInt(effecttype);
 if (effecttype == TMS_EFFECT_VOLUME)
 {
 RDebug::Printf("[TMS STIF] Volume, GetMaxLevel");
-ret = static_cast<TMSVolumeEffect*>(iTmsDnlinkEffect)->GetMaxLevel(
+ret = static_cast<TMSVolumeEffect*> (iTmsDnlinkEffect)->GetMaxLevel(
 iMaxVolume);
 RDebug::Printf("[TMS STIF] MaxLevel [%d] Ret Error [%d]", iMaxVolume, ret);
 RDebug::Printf("[TMS STIF] Volume, SetLevel to MaxLevel [%d]", iMaxVolume);
-ret = static_cast<TMSVolumeEffect*>(iTmsDnlinkEffect)->SetLevel(
+ret = static_cast<TMSVolumeEffect*> (iTmsDnlinkEffect)->SetLevel(
 iMaxVolume);
 RDebug::Printf("[TMS STIF] SetLevel Ret Error [%d]", ret);
 iLog->Log(_L("SetMaxVolume: %d"), iMaxVolume);
 RDebug::Printf("[TMS STIF] GetLevel");
-ret = static_cast<TMSVolumeEffect*>(iTmsDnlinkEffect)->GetLevel(
+ret = static_cast<TMSVolumeEffect*> (iTmsDnlinkEffect)->GetLevel(
 iVolume);
 RDebug::Printf("[TMS STIF] Level [%d] Ret Error [%d]", iVolume, ret);
 if (iVolume != iMaxVolume)
 {
 iLog->Log(_L("GetVolume doesn't return expected MaxVolume!!! returned Volume = %d"), iVolume);
 return KErrUnexpectedValue;
 }
 RDebug::Printf("[TMS STIF] Volume, SetLevel to 0 ");
-ret = static_cast<TMSVolumeEffect*>(iTmsDnlinkEffect)->SetLevel(0);
+ret = static_cast<TMSVolumeEffect*> (iTmsDnlinkEffect)->SetLevel(0);
 RDebug::Printf("[TMS STIF] SetLevel Ret Error [%d]", ret);
 iLog->Log(_L("Mute Volume"));
-ret = static_cast<TMSVolumeEffect*>(iTmsDnlinkEffect)->GetLevel(
+ret = static_cast<TMSVolumeEffect*> (iTmsDnlinkEffect)->GetLevel(
 iVolume);
 RDebug::Printf("[TMS STIF] Level [%d] Ret Error [%d]", iVolume, ret);
 if (iVolume != 0)
 {
 iLog->Log(_L("GetVolume does not return expected Mute value!!! returned Volume = %d"), iVolume);
 }
 }
 else if (effecttype == TMS_EFFECT_GLOBAL_VOL)
 {
 RDebug::Printf("[TMS STIF] GLOBAL_VOL, Get Current Level");
-ret = static_cast<TMSGlobalVolEffect*>(iGlobalVol)->GetLevel(iVolume);
+ret = static_cast<TMSGlobalVolEffect*> (iGlobalVol)->GetLevel(iVolume);
 RDebug::Printf("[TMS STIF] Current Vol Level [%d] Ret Error [%d]", iVolume, ret);
 RDebug::Printf("[TMS STIF] GLOBAL_VOL, GetMaxLevel");
-ret = static_cast<TMSGlobalVolEffect*>(iGlobalVol)->GetMaxLevel(
+ret = static_cast<TMSGlobalVolEffect*> (iGlobalVol)->GetMaxLevel(
 iMaxVolume);
 RDebug::Printf("[TMS STIF] MaxLevel [%d] Ret Error [%d]", iMaxVolume, ret);
 RDebug::Printf("[TMS STIF] GLOBAL_VOL, SetLevel to [%d]", iMaxVolume);
-ret = static_cast<TMSGlobalVolEffect*>(iGlobalVol)->SetLevel(
+ret = static_cast<TMSGlobalVolEffect*> (iGlobalVol)->SetLevel(
 iMaxVolume);
 RDebug::Printf("[TMS STIF] SetLevel Ret Error [%d]", ret);
-iLog->Log(_L("SetMaxGlobleVolume: %d"), iMaxVolume);
+iLog->Log(_L("SetMaxGlobalVolume: %d"), iMaxVolume);
 RDebug::Printf("[TMS STIF] GLOBAL_VOL,GetLevel");
-ret = static_cast<TMSGlobalVolEffect*>(iGlobalVol)->GetLevel(iVolume);
+ret = static_cast<TMSGlobalVolEffect*> (iGlobalVol)->GetLevel(iVolume);
 RDebug::Printf("[TMS STIF] Expected Level [%d] Ret Level [%d] Ret Error [%d]", iMaxVolume, iVolume, ret);
-iLog->Log(_L("GetMaxGlobleVolume: %d"), iVolume);
+iLog->Log(_L("GetMaxGlobalVolume: %d"), iVolume);
 if (iVolume != iMaxVolume)
 {
-iLog->Log(_L("GetGlobleVolume doesn't return expected MaxVolume!!! returned Volume = %d"), iVolume);
+iLog->Log(_L("GetGlobalVolume doesn't return expected MaxVolume!!! returned Volume = %d"), iVolume);
 return KErrUnexpectedValue;
 }
-static_cast<TMSGlobalVolEffect*>(iGlobalVol)->SetLevel(0);
+static_cast<TMSGlobalVolEffect*> (iGlobalVol)->SetLevel(0);
-iLog->Log(_L("Mute Globle Volume"));
+iLog->Log(_L("Mute Global Volume"));
-static_cast<TMSGlobalVolEffect*>(iGlobalVol)->GetLevel(iVolume);
+static_cast<TMSGlobalVolEffect*> (iGlobalVol)->GetLevel(iVolume);
 if (iVolume != 0)
 {
-iLog->Log(_L("GetGlobleVolume does not return expected Mute value!!! returned Volume = %d"), iVolume);
+iLog->Log(_L("GetGlobalVolume does not return expected Mute value!!! returned Volume = %d"), iVolume);
 return KErrUnexpectedValue;
 }
 }
 else
 {
 }
 }
 return error;
 }
-TInt CTmsAudioServicesTestClass::AddGlobalRoutingObserver(CStifItemParser& /*aItem */)
+TInt CTmsAudioServicesTestClass::AddGlobalRoutingObserver(
+CStifItemParser& /*aItem */)
 {
 iLog->Log(_L("CTmsAudioServicesTestClass::AddGlobalRoutingObserver"));
 TInt error = KErrNone;
 if (iTmsGlobalRouting)
 iLog->Log(_L("CTmsAudioServicesTestClass::AddGlobalRoutingObserver failed error [%d]"), error);
 }
 return error;
 }
-TInt CTmsAudioServicesTestClass::DeleteGlobalRoutingObserver(CStifItemParser& /*aItem*/)
+TInt CTmsAudioServicesTestClass::DeleteGlobalRoutingObserver(
+CStifItemParser& /*aItem*/)
 {
 iLog->Log(_L("CTmsAu dioServicesTestClass::DeleteGlobalRoutingObserver"));
 TInt error = KErrNone;
 if (iTmsGlobalRouting)
 iLog-> Log(KMsgBadTestParameters);
 error = KErrBadTestParameter;
 return error;
 }
-AddExpectedEvent(ESetOutputComplete, KLongTimeout);
+AddExpectedEvent(ESetOutputComplete, KShortTimeout);
 }
 return error;
 }
 {
 if (bitRate == KTagMin)
 {
 if (iBitratesVector.size() > 0)
 {
-std::vector<guint>::iterator iBitrate =
+std::vector<guint>::iterator iBitrate = iBitratesVector.begin();
-iBitratesVector.begin();
 error = iTmsFormatUp -> SetBitRate(*iBitrate);
 iLog->Log(_L("BR set %d"), *iBitrate);
 }
 }
 else if (bitRate == KTagMax)
 TBool aVad;
 switch (iUpLinkCodec)
 {
 case TMS_FORMAT_G711:
-error = static_cast<TMSG711Format*>(iTmsFormatUp)->GetVADMode(aVad);
+error = static_cast<TMSG711Format*> (iTmsFormatUp)->GetVADMode(
+aVad);
 break;
 case TMS_FORMAT_G729:
-error = static_cast<TMSG729Format*>(iTmsFormatUp)->GetVADMode(aVad);
+error = static_cast<TMSG729Format*> (iTmsFormatUp)->GetVADMode(
+aVad);
 break;
 case TMS_FORMAT_ILBC:
-error = static_cast<TMSILBCFormat*>(iTmsFormatUp)->GetVADMode(aVad);
+error = static_cast<TMSILBCFormat*> (iTmsFormatUp)->GetVADMode(
+aVad);
 break;
 default:
 break;
 }
 iVad = (iVad) ? EFalse : ETrue;
 switch (iUpLinkCodec)
 {
 case TMS_FORMAT_G711:
-error = static_cast<TMSG711Format*>(iTmsFormatUp)->SetVADMode(iVad);
+error = static_cast<TMSG711Format*> (iTmsFormatUp)->SetVADMode(
+iVad);
 break;
 case TMS_FORMAT_G729:
-error = static_cast<TMSG729Format*>(iTmsFormatUp)->SetVADMode(iVad);
+error = static_cast<TMSG729Format*> (iTmsFormatUp)->SetVADMode(
+iVad);
 break;
 case TMS_FORMAT_ILBC:
-error = static_cast<TMSILBCFormat*>(iTmsFormatUp)->SetVADMode(iVad);
+error = static_cast<TMSILBCFormat*> (iTmsFormatUp)->SetVADMode(
+iVad);
 break;
 default:
 break;
 }
 iLog->Log(_L("VAD set: %d"), iVad);
 if (error == KErrNone)
 {
 if ((linkType == KTagUplink) && (iUpLinkCodec == TMS_FORMAT_G711))
 {
 TMSG711CodecMode aMode;
-static_cast<TMSG711Format*>(iTmsFormatUp)->GetMode(aMode);
+static_cast<TMSG711Format*> (iTmsFormatUp)->GetMode(aMode);
 if (aMode == TMS_G711_CODEC_MODE_ALAW)
 {
 iLog->Log(_L("UPL Mode: aLaw"));
 }
 }
 else if ((linkType == KTagUplink)
 && (iUpLinkCodec == TMS_FORMAT_ILBC))
 {
 TMSILBCCodecMode aMode;
-static_cast<TMSILBCFormat*>(iTmsFormatUp)->GetMode(aMode);
+static_cast<TMSILBCFormat*> (iTmsFormatUp)->GetMode(aMode);
 if (aMode == TMS_ILBC_CODEC_MODE_20MS_FRAME)
 {
 iLog->Log(_L("UPL Mode: 20ms frame"));
 }
 }
 else if ((linkType == KTagDnlink)
 && (iDnLinkCodec == TMS_FORMAT_G711))
 {
 TMSG711CodecMode aMode;
-static_cast<TMSG711Format*>(iTmsFormatDn)->GetMode(aMode);
+static_cast<TMSG711Format*> (iTmsFormatDn)->GetMode(aMode);
 if (aMode == TMS_G711_CODEC_MODE_ALAW)
 {
 iLog->Log(_L("DNL Mode: aLaw"));
 }
 }
 else if ((linkType == KTagDnlink)
 && (iDnLinkCodec == TMS_FORMAT_ILBC))
 {
 TMSILBCCodecMode aMode;
-static_cast<TMSILBCFormat*>(iTmsFormatDn)->GetMode(aMode);
+static_cast<TMSILBCFormat*> (iTmsFormatDn)->GetMode(aMode);
 if (aMode == TMS_ILBC_CODEC_MODE_20MS_FRAME)
 {
 iLog->Log(_L("DNL Mode: 20ms frame"));
 }
 {
 if ((linkType == KTagUplink) && (iUpLinkCodec == TMS_FORMAT_G711)
 && (mode == KTagALaw))
 {
 iLog->Log(_L("UPL Mode Set: aLaw"));
-static_cast<TMSG711Format*>(iTmsFormatUp)->SetMode(
+static_cast<TMSG711Format*> (iTmsFormatUp)->SetMode(
 TMS_G711_CODEC_MODE_ALAW);
 }
 else if ((linkType == KTagUplink)
 && (iUpLinkCodec == TMS_FORMAT_G711) && (mode == KTagULaw))
 {
 iLog->Log(_L("UPL Mode Set: uLaw"));
-static_cast<TMSG711Format*>(iTmsFormatUp)->SetMode(
+static_cast<TMSG711Format*> (iTmsFormatUp)->SetMode(
 TMS_G711_CODEC_MODE_MULAW);
 }
 else if ((linkType == KTagUplink)
 && (iUpLinkCodec == TMS_FORMAT_ILBC) && (mode == KTag20ms))
 {
 iLog->Log(_L("UPL Mode Set: 20ms frame"));
-static_cast<TMSILBCFormat*>(iTmsFormatUp)->SetMode(
+static_cast<TMSILBCFormat*> (iTmsFormatUp)->SetMode(
 TMS_ILBC_CODEC_MODE_20MS_FRAME);
 }
 else if ((linkType == KTagUplink)
 && (iUpLinkCodec == TMS_FORMAT_ILBC) && (mode == KTag30ms))
 {
 iLog->Log(_L("UPL Mode Set: 30ms frame"));
-static_cast<TMSILBCFormat*>(iTmsFormatUp)->SetMode(
+static_cast<TMSILBCFormat*> (iTmsFormatUp)->SetMode(
 TMS_ILBC_CODEC_MODE_30MS_FRAME);
 }
 else if ((linkType == KTagDnlink)
 && (iDnLinkCodec == TMS_FORMAT_G711) && (mode == KTagALaw))
 {
 iLog->Log(_L("DNL Mode Set: aLaw"));
-static_cast<TMSG711Format*>(iTmsFormatDn)->SetMode(
+static_cast<TMSG711Format*> (iTmsFormatDn)->SetMode(
 TMS_G711_CODEC_MODE_ALAW);
 }
 else if ((linkType == KTagDnlink)
 && (iDnLinkCodec == TMS_FORMAT_G711) && (mode == KTagULaw))
 {
 iLog->Log(_L("DNL Mode Set: uLaw"));
-static_cast<TMSG711Format*>(iTmsFormatDn)->SetMode(
+static_cast<TMSG711Format*> (iTmsFormatDn)->SetMode(
 TMS_G711_CODEC_MODE_MULAW);
 }
 else if ((linkType == KTagDnlink)
 && (iDnLinkCodec == TMS_FORMAT_ILBC) && (mode == KTag20ms))
 {
 iLog->Log(_L("DNL Mode Set: 20ms frame"));
-static_cast<TMSILBCFormat*>(iTmsFormatDn)->SetMode(
+static_cast<TMSILBCFormat*> (iTmsFormatDn)->SetMode(
 TMS_ILBC_CODEC_MODE_20MS_FRAME);
 }
 else if ((linkType == KTagDnlink)
 && (iDnLinkCodec == TMS_FORMAT_ILBC) && (mode == KTag30ms))
 {
 iLog->Log(_L("DNL Mode Set: 30ms frame"));
-static_cast<TMSILBCFormat*>(iTmsFormatDn)->SetMode(
+static_cast<TMSILBCFormat*> (iTmsFormatDn)->SetMode(
 TMS_ILBC_CODEC_MODE_30MS_FRAME);
 }
 else
 {
 iLog->Log(KMsgBadTestParameters);
 TInt error = KErrNone;
 TBool aCng = EFalse;
 switch (iDnLinkCodec)
 {
 case TMS_FORMAT_G711:
-error = static_cast<TMSG711Format*>(iTmsFormatDn)->GetCNG(aCng);
+error = static_cast<TMSG711Format*> (iTmsFormatDn)->GetCNG(aCng);
 iLog->Log(_L("CNG: %d"), aCng);
 break;
 case TMS_FORMAT_ILBC:
-error = static_cast<TMSILBCFormat*>(iTmsFormatDn)->GetCNG(aCng);
+error = static_cast<TMSILBCFormat*> (iTmsFormatDn)->GetCNG(aCng);
 iLog->Log(_L("CNG: %d"), aCng);
 break;
 default:
 break;
 }
 return error;
 }
 TInt CTmsAudioServicesTestClass::ToggleCNG(CStifItemParser & /*aItem*/)
 {
 iLog ->Log(_L("CTmsAudioServicesTestClass::ToggleCNG"));
 TInt error = KErrNone;
 iCng = (iCng) ? EFalse : ETrue;
 switch (iDnLinkCodec)
 {
 case TMS_FORMAT_G711:
-static_cast<TMSG711Format*>(iTmsFormatDn)->SetCNG(iCng);
+static_cast<TMSG711Format*> (iTmsFormatDn)->SetCNG(iCng);
 iLog->Log(_L("CNG set: %d"), iCng);
 break;
 case TMS_FORMAT_ILBC:
-static_cast<TMSILBCFormat*>(iTmsFormatDn)->SetCNG(iCng);
+static_cast<TMSILBCFormat*> (iTmsFormatDn)->SetCNG(iCng);
 iLog->Log(_L("CNG set: %d"), iCng);
 break;
 default:
 break;
 }
 iLog->Log(_L("CTmsAudioServicesTestClass::GetPLC"));
 TInt error = KErrNone;
 TBool aPlc = EFalse;
 if (iDnLinkCodec == TMS_FORMAT_G711)
 {
-static_cast<TMSG711Format*>(iTmsFormatDn)->GetPlc(aPlc);
+static_cast<TMSG711Format*> (iTmsFormatDn)->GetPlc(aPlc);
 iLog->Log(_L("PLC: %d"), aPlc);
 }
 if (aPlc != iPlc)
 {
 iLog ->Log(_L("CTmsAudioServicesTestClass::TogglePLC"));
 TInt error = KErrNone;
 iPlc = (iPlc) ? EFalse : ETrue;
 if (iDnLinkCodec == TMS_FORMAT_G711)
 {
-error = static_cast<TMSG711Format*>(iTmsFormatDn)->SetPlc(iPlc);
+error = static_cast<TMSG711Format*> (iTmsFormatDn)->SetPlc(iPlc);
 iLog->Log(_L("PLC set: %d"), iPlc);
 }
 return error;
 }
 TInt error = KErrNone;
 if (iTmsDnlink && iTmsClientSource)
 {
 error = iTmsDnlink->AddSource(iTmsClientSource);
 }
-iLog->Log(
+iLog->Log(_L("CTmsAudioServicesTestClass::AddClientSrcToDnlStream Error [%d]"), error);
-_L("CTmsAudioServicesTestClass::AddClientSrcToDnlStream Error [%d]"),
-error);
 return error;
 }
 // NOTE: CS and IP
 TInt CTmsAudioServicesTestClass::AddMicSrcToUplStream(CStifItemParser& /*aItem*/)
 {
 iLog->Log(_L("CTmsAudioServicesTestClass::AddSourceObserver"));
 TInt error = KErrNone;
 if (iTmsClientSource)
 {
-error = static_cast<TMSClientSource*>(iTmsClientSource)->AddObserver(
+error = static_cast<TMSClientSource*> (iTmsClientSource)->AddObserver(
 *this, NULL);
 }
 return error;
 }
 {
 iLog->Log(_L("CTmsAudioServicesTestClass::RemoveSourceObserver"));
 TInt error = KErrNone;
 if (iTmsClientSource)
 {
-error = static_cast<TMSClientSource*>(iTmsClientSource)->RemoveObserver(
+error = static_cast<TMSClientSource*> (iTmsClientSource)->RemoveObserver(*this);
-*this);
 }
 return error;
 }
 TInt CTmsAudioServicesTestClass::AddClientSinkToUplStream(
 {
 iLog ->Log(_L("CTmsAudioServicesTestClass::AddSinkObserver"));
 TInt error = KErrNone;
 if (iTmsUplink && iTmsClientSink)
 {
-error = static_cast<TMSClientSink*>(iTmsClientSink)->AddObserver(*this,
+error = static_cast<TMSClientSink*> (iTmsClientSink)->AddObserver(
-NULL);
+*this, NULL);
 }
 return error;
 }
 TInt CTmsAudioServicesTestClass::RemoveSinkObserver(CStifItemParser& /*aItem*/)
 {
 iLog->Log(_L("CTmsAudioServicesTestClass::RemoveSinkObserver"));
 TInt error = KErrNone;
 if (iTmsUplink && iTmsClientSink)
 {
-error = static_cast<TMSClientSink*>(iTmsClientSink)->RemoveObserver(
+error = static_cast<TMSClientSink*> (iTmsClientSink)->RemoveObserver(
 *this);
 }
 return error;
 }
 if (iFactory && iTmsDnlink && !iTmsDnlinkEffect)
 {
 status = iFactory->CreateEffect(TMS_EFFECT_VOLUME, iTmsDnlinkEffect);
 if (status == KErrNone)
 {
-static_cast<TMSVolumeEffect*>(iTmsDnlinkEffect)->AddObserver(*this,
+static_cast<TMSVolumeEffect*> (iTmsDnlinkEffect)->AddObserver(
-NULL);
+*this, NULL);
 }
 }
 RDebug::Printf("[TMS STIF] CreateVolumeEffect Return [%d]", status);
 return status;
 }
-gint CTmsAudioServicesTestClass::CreateVolumeGlobleEffect()
+gint CTmsAudioServicesTestClass::CreateVolumeGlobalEffect()
 {
-iLog->Log(_L("CTmsAudioServicesTestClass::CreateVolumeGlobleEffect"));
+iLog->Log(_L("CTmsAudioServicesTestClass::CreateVolumeGlobalEffect"));
 gint status(KErrNone);
 if (iFactory && !iGlobalVol)
 {
 status = iFactory->CreateEffect(TMS_EFFECT_GLOBAL_VOL, iGlobalVol);
 if (status == KErrNone)
 {
-static_cast<TMSGlobalVolEffect*>(iGlobalVol)->AddObserver(*this,
+static_cast<TMSGlobalVolEffect*> (iGlobalVol)->AddObserver(*this,
 NULL);
-iLog->Log(_L("CTmsAudioServicesTestClass::CreateVolumeGlobleEffect - AddObserver"));
+iLog->Log(_L("CTmsAudioServicesTestClass::CreateVolumeGlobalEffect - AddObserver"));
 }
 }
-RDebug::Printf("[TMS STIF] CreateVolumeGlobleEffect Return [%d]", status);
+RDebug::Printf("[TMS STIF] CreateVolumeGlobalEffect Return [%d]", status);
 return status;
 }
 TInt CTmsAudioServicesTestClass::AddVolumeEffectToStream(
 CStifItemParser& /*aItem*/)
 error = iTmsDnlink->AddEffect(iTmsDnlinkEffect);
 }
 return error;
 }
-TInt CTmsAudioServicesTestClass::AddGlobleVolumeEffectToStream(
+TInt CTmsAudioServicesTestClass::AddGlobalVolumeEffectToStream(
 CStifItemParser& /*aItem*/)
 {
-iLog->Log(_L("CTmsAudioServicesTestClass::AddGlobleVolumeEffectToStream"));
+iLog->Log(_L("CTmsAudioServicesTestClass::AddGlobalVolumeEffectToStream"));
 TInt error = KErrNone;
 if (iTmsDnlink && iGlobalVol)
 {
 error = iTmsDnlink->AddEffect(iGlobalVol);
 }
 return error;
 }
-TInt CTmsAudioServicesTestClass::RemoveGlobleVolumeEffectToStream(
+TInt CTmsAudioServicesTestClass::RemoveGlobalVolumeEffectToStream(
 CStifItemParser& /*aItem*/)
 {
-iLog->Log(_L("CTmsAudioServicesTestClass::RemoveGlobleVolumeEffectToStream"));
+iLog->Log(_L("CTmsAudioServicesTestClass::RemoveGlobalVolumeEffectToStream"));
 TInt error = KErrNone;
 if (iTmsDnlink && iGlobalVol)
 {
 error = iTmsDnlink->RemoveEffect(iGlobalVol);
 }
 if (iFactory && iTmsUplink && !iTmsUplinkEffect)
 {
 status = iFactory->CreateEffect(TMS_EFFECT_GAIN, iTmsUplinkEffect);
 if (status == KErrNone)
 {
-static_cast<TMSGainEffect*>(iTmsUplinkEffect)->AddObserver(*this,
+static_cast<TMSGainEffect*> (iTmsUplinkEffect)->AddObserver(
-NULL);
+*this, NULL);
 }
 }
 RDebug::Printf("[TMS STIF] CreateGainEffect Return [%d]", status);
 return status;
 }
-gint CTmsAudioServicesTestClass::CreateGlobleGainEffect()
+gint CTmsAudioServicesTestClass::CreateGlobalGainEffect()
 {
-iLog->Log(_L("CTmsAudioServicesTestClass::CreateGlobleGainEffect"));
+iLog->Log(_L("CTmsAudioServicesTestClass::CreateGlobalGainEffect"));
 gint status(KErrNone);
 if (iFactory && !iGlobalGain)
 {
 status = iFactory->CreateEffect(TMS_EFFECT_GLOBAL_GAIN, iGlobalGain);
 if (status == KErrNone)
 {
-static_cast<TMSGlobalGainEffect*>(iGlobalGain)->AddObserver(*this,
+static_cast<TMSGlobalGainEffect*> (iGlobalGain)->AddObserver(
-NULL);
+*this, NULL);
 }
 }
-RDebug::Printf("[TMS STIF] CreateGlobleGainEffect Return [%d]", status);
+RDebug::Printf("[TMS STIF] CreateGlobalGainEffect Return [%d]", status);
 return status;
 }
 TInt CTmsAudioServicesTestClass::AddGainEffectToStream(
 CStifItemParser& /*aItem*/)
 error = iTmsUplink->AddEffect(iTmsUplinkEffect);
 }
 return error;
 }
-TInt CTmsAudioServicesTestClass::AddGlobleGainEffectToStream(
+TInt CTmsAudioServicesTestClass::AddGlobalGainEffectToStream(
 CStifItemParser& /*aItem*/)
 {
-iLog->Log(_L("CTmsAudioServicesTestClass::AddGlobleGainEffectToStream"));
+iLog->Log(_L("CTmsAudioServicesTestClass::AddGlobalGainEffectToStream"));
 TInt error = KErrNone;
 if (iTmsUplink && iGlobalGain)
 {
 error = iTmsUplink->AddEffect(iGlobalGain);
 }
 return error;
 }
-TInt CTmsAudioServicesTestClass::RemoveGlobleGainEffectToStream(
+TInt CTmsAudioServicesTestClass::RemoveGlobalGainEffectToStream(
 CStifItemParser& /*aItem*/)
 {
-iLog->Log(_L("CTmsAudioServicesTestClass::RemoveGlobleGainEffectToStream"));
+iLog->Log(_L("CTmsAudioServicesTestClass::RemoveGlobalGainEffectToStream"));
 TInt error = KErrNone;
 if (iTmsUplink && iGlobalGain)
 {
 error = iTmsUplink->RemoveEffect(iGlobalGain);
 }
 iRecBuf->GetDataPtr(srcptr);
 iRecBuf->GetDataSize(srcsize);
 Mem::Copy(desptr, srcptr, srcsize);
-static_cast<TMSClientSource*>(iTmsClientSource)->BufferFilled(
+static_cast<TMSClientSource*> (iTmsClientSource)->BufferFilled(
 *iPlayBuf);
-static_cast<TMSClientSink*>(iTmsClientSink)->BufferProcessed(iRecBuf);
+static_cast<TMSClientSink*> (iTmsClientSink)->BufferProcessed(iRecBuf);
 iPlayBufReady = EFalse; // buf filled, ready for FillBuffer
-iRecBufReady = EFalse; // buf consumed, ready for EmptyBuffer
+iRecBufReady = EFalse;  // buf consumed, ready for EmptyBuffer
 }
 iLog->Log(_L("CTmsAudioServicesTestClass::DoLoopback END"));
 }

branch	RCL_3
changeset 11	3570217d8c21
parent 9	f5c5c82a163e
child 19	095bea5f582e