/*

 * Copyright (c) 2007-2008 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: VoIP audio server session class implementation.

 *              Each session is created either for an uplink, downlink or

 *              ring tone player. Separate thread is created for uplink and

 *              downlink stream. Ring tone player runs in the main thread.

 *

 */

#include <AudioPreference.h>

#include <MProEngEngine.h>

#include <MProEngProfile.h>

#include <MProEngTones.h>

#include <ProEngFactory.h>

#include <voipaudiocommon.h>

#include "debugtracemacros.h"

#include "VoIPAudioSession.h"

#include "VoIPServerThread.h"

#include "VoIPSharedData.h"

#include "VoIPServerSession.h"

// These are the default tone length settings for the US

const TUint KDTMFToneLengthOn = 250000;

const TUint KDTMFToneLengthOff = 50000;

const TUint KDTMFToneLengthPause = 2500000;

const TUint KArrayExpandSize = 8;

// -----------------------------------------------------------------------------

// CVoIPAudioServerSession::NewL

// Symbian constructor.

// -----------------------------------------------------------------------------

//

CVoIPAudioServerSession* CVoIPAudioServerSession::NewL(

        CVoIPAudioServer &aServer)

    {

    CVoIPAudioServerSession* self = new (ELeave) CVoIPAudioServerSession(

            aServer);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

// -----------------------------------------------------------------------------

// CVoIPAudioServerSession::~CVoIPAudioServerSession

// The destructor

// -----------------------------------------------------------------------------

//

CVoIPAudioServerSession::~CVoIPAudioServerSession()

    {

    TRACE_PRN_FN_ENT;

    if (iAO)

        {

        iAO->Cancel();

        delete iAO;

        }

    delete iDevSound;

    delete iToneBuf;

    delete iRingTonePlayer;

    delete iDTMFTonePlayer;

    iCodecsUp.Reset();

    iCodecsUp.Close();

    iCodecsDn.Reset();

    iCodecsDn.Close();

    if (iThread.Handle() > 0)

        {

        iThread.Close(); // close thread handle

        }

    if (iMsgComQueueDtmf.Handle() > 0)

        {

        iMsgComQueueDtmf.Close();

        }

    if (iMsgComQueue.Handle() > 0)

        {

        iMsgComQueue.Close();

        }

    if (iITCMsgComQueue.Handle() > 0)

        {

        iITCMsgComQueue.Close();

        }

    iShared.iMutex.Close();

    iShared.iCodecSettings.iArrBitrates.Reset();

    iVoIPServer.DropSession(); // will start shutdown if no more sessions left

    // Release memory and close handles to unused plug-ins held by the DevSound

    REComSession::FinalClose();

    TRACE_PRN_FN_EXT;

    }

// -----------------------------------------------------------------------------

// CVoIPAudioServerSession::ConstructL

// 2-nd phase constructor.

// -----------------------------------------------------------------------------

//

void CVoIPAudioServerSession::ConstructL()

    {

    TRACE_PRN_FN_ENT;

    // Create semaphore for thread signaling when accessing shared data

    iShared.iMutex.CreateLocal();

    // Setup A/O for ITC to receive callbacks from the uplink/downlink threads

    // Note: Must replace with msg queue if multiple callbacks can be

    //       received at the same time.

    TThreadId tID = RThread().Id();

    iShared.iMutex.Wait();

    iShared.iMainThreadID = tID;

    iAO = new (ELeave) CVoIPServerAO(this, tID);

    iShared.iMnThreadStatus = &(this->iAO->iStatus);

    iShared.iCodecSettings.iG711FrameRate = TVoIPCodecSettings::E20MS;

    iShared.iMutex.Signal();

    iAO->Request();

    iSessionType = ENone;

    TRACE_PRN_FN_EXT;

    }

// -----------------------------------------------------------------------------

// CVoIPAudioServerSession::CVoIPAudioServerSession

// -----------------------------------------------------------------------------

//

CVoIPAudioServerSession::CVoIPAudioServerSession(CVoIPAudioServer &aServer) :

    iVoIPServer(aServer)

    {

    TRACE_PRN_FN_ENT;

    iVoIPServer.AddSession(); //add new session

    TRACE_PRN_FN_EXT;

    }

// -----------------------------------------------------------------------------

// CVoIPAudioServerSession::ServiceL

// Service request handler.

// -----------------------------------------------------------------------------

//

void CVoIPAudioServerSession::ServiceL(const RMessage2& aMessage)

    {

    TRAPD(err, DispatchMessageL(aMessage));

    if (!iMsgQueued)

        {

        aMessage.Complete(err);

        }

    }

// -----------------------------------------------------------------------------

// CVoIPAudioServerSession::DispatchMessageL

// Service request handler.

// -----------------------------------------------------------------------------

//

void CVoIPAudioServerSession::DispatchMessageL(const RMessage2& aMessage)

    {

    switch (aMessage.Function())

        {

        case EVoIPSetEncoderPriority:

        case EVoIPSetDecoderPriority:

            SetPriorityL(aMessage);

            break;

        case EVoIPGetSupportedEncodersCount:

            if (iSessionType == ENone)

                {

                iSessionType = EQueryEnc;

                }

            GetCodecsCountL(aMessage);

            break;

        case EVoIPGetSupportedDecodersCount:

            if (iSessionType == ENone)

                {

                iSessionType = EQueryDec;

                }

            GetCodecsCountL(aMessage);

            break;

        case EVoIPGetSupportedEncoders:

            if (iSessionType == ENone)

                {

                iSessionType = EQueryEnc;

                }

            GetSupportedCodecsL(aMessage);

            break;

        case EVoIPGetSupportedDecoders:

            GetSupportedCodecsL(aMessage);

            break;

        case EVoIPSetDecoder:

            if (iSessionType == ENone)

                {

                iSessionType = EQueryDec;

                }

            SetFormatL(aMessage);

            break;

        case EVoIPSetEncoder:

            if (iSessionType == ENone)

                {

                iSessionType = EQueryEnc;

                }

            SetFormatL(aMessage);

            break;

        case EVoIPOpenDownlink:

            OpenDownlinkL(aMessage);

            break;

        case EVoIPOpenUplink:

            OpenUplinkL(aMessage);

            break;

        case EVoIPStartDownlink:

            StartDownlink();

            break;

        case EVoIPStartUplink:

            StartUplink();

            break;

        case EVoIPStopDownlink:

            StopDownlink();

            break;

        case EVoIPStopUplink:

            StopUplink();

            break;

        case EVoIPCloseDownlink:

            CloseDownlink();

            break;

        case EVoIPCloseUplink:

            CloseUplink();

            break;

        case EVoIPGetMaxVolume:

            GetMaxVolumeL(aMessage);

            break;

        case EVoIPGetVolume:

            GetVolume(aMessage);

            break;

        case EVoIPSetVolume:

            SetVolume(aMessage);

            break;

        case EVoIPGetMaxGain:

            GetMaxGainL(aMessage);

            break;

        case EVoIPGetGain:

            GetGain(aMessage);

            break;

        case EVoIPSetGain:

            SetGain(aMessage);

            break;

        case EVoIPSetAudioDevice:

            SetAudioDeviceL(aMessage);

            break;

        case EVoIPGetAudioDevice:

            GetAudioDevice(aMessage);

            break;

        case EVoIPBufferFilled:

            BufferFilledL(aMessage);

            break;

        case EVoIPBufferEmptied:

            BufferEmptiedL(aMessage);

            break;

        case EVoIPSetIlbcCodecMode:

            SetIlbcCodecModeL(aMessage);

            break;

        case EVoIPGetIlbcCodecMode:

            GetIlbcCodecMode(aMessage);

            break;

        case EVoIPSetG711CodecMode:

            SetG711CodecModeL(aMessage);

            break;

        case EVoIPGetG711CodecMode:

            GetG711CodecMode(aMessage);

            break;

        case EVoIPGetSupportedBitratesCount:

            GetSupportedBitratesCount(aMessage);

            break;

        case EVoIPGetSupportedBitrates:

            GetSupportedBitratesL(aMessage);

            break;

        case EVoIPSetBitrate:

            SetBitrate(aMessage);

            break;

        case EVoIPGetBitrate:

            GetBitrate(aMessage);

            break;

        case EVoIPFrameModeRqrdForEC:

            FrameModeRqrdForEC(aMessage);

            break;

        case EVoIPSetFrameMode:

            SetFrameMode(aMessage);

            break;

        case EVoIPGetFrameMode:

            GetFrameMode(aMessage);

            break;

        case EVoIPConcealErrForNextBuf:

            ConcealErrorForNextBuffer();

            break;

        case EVoIPSetVad:

            SetVad(aMessage);

            break;

        case EVoIPGetVad:

            GetVad(aMessage);

            break;

        case EVoIPSetCng:

            SetCng(aMessage);

            break;

        case EVoIPGetCng:

            GetCng(aMessage);

            break;

        case EVoIPSetPlc:

            SetPlc(aMessage);

            break;

        case EVoIPGetPlc:

            GetPlc(aMessage);

            break;

        case EVoIPBadLsfNextBuffer:

            BadLsfNextBuffer();

            break;

        case EVoIPOpenDTMFTonePlayer:

            OpenDTMFTonePlayerL();

            break;

        case EVoIPPlayDTMFTone:

            PlayDTMFToneL(aMessage);

            break;

        case EVoIPStopDTMFTone:

            StopDTMFTonePlay();

            break;

        case EVoIPCloseDTMFTonePlayer:

            CloseDTMFTonePlayer();

            break;

        case EVoIPOpenRingTonePlayerFromFile:

            OpenRingTonePlayerFromFileL(aMessage);

            break;

        case EVoIPOpenRingTonePlayerFromRFile:

            OpenRingTonePlayerFromRFileL(aMessage);

            break;

        case EVoIPOpenRingTonePlayerFromProfile:

            OpenRingTonePlayerFromProfileL();

            break;

        case EVoIPOpenRingTonePlayerFromDes:

            OpenRingTonePlayerFromDesL(aMessage);

            break;

        case EVoIPPlayRingTone:

            PlayRingTone();

            break;

        case EVoIPPauseRingTone:

            PauseRingTone();

            break;

        case EVoIPResumeRingTone:

            ResumeRingTone();

            break;

        case EVoIPStopRingTone:

            StopRingTone();

            break;

        case EVoIPCloseRingTonePlayer:

            CloseRingTonePlayer();

            break;

        case EVoIPConfigJitterBuffer:

            ConfigureJitterBufferL(aMessage);

            break;

        case EVoIPResetJitterBuffer:

            ResetJitterBuffer(aMessage);

            break;

        case EVoIPJBDelayDown:

            JBDelayDown();

            break;

        case EVoIPJBDelayUp:

            JBDelayUp();

            break;

        case EVoIPSessionClose:

            break;

        default:

            User::Leave(KErrNotSupported);

            break;

        }

    }

// -----------------------------------------------------------------------------

// CVoIPAudioServerSession::SetDecoderPriority

//

// -----------------------------------------------------------------------------

//

void CVoIPAudioServerSession::SetPriorityL(const RMessage2& aMessage)

    {

    TMMFPrioritySettingsPckg pckg;

    aMessage.ReadL(0, pckg);

    iPriority = pckg();

    iShared.iMutex.Wait();

    iShared.iPreference = iPriority.iPref;

    iShared.iPriority = iPriority.iPriority;

    iShared.iMutex.Signal();

    }

// -----------------------------------------------------------------------------

// CVoIPAudioServerSession::GetCodecsCountL

//

// -----------------------------------------------------------------------------

//

void CVoIPAudioServerSession::GetCodecsCountL(const RMessage2& aMessage)

    {

    TRACE_PRN_FN_ENT;

    TVoIPMsgBufPckg p;

    p().iStatus = KErrNone;

    p().iInt = 0;

    // Is codecs info already available?

    if (iCodecsCountUp > 0 &&

       (iSessionType == EQueryEnc || iSessionType == EUplink))

        {

        p().iInt = iCodecsCountUp;

        iShared.iMutex.Wait();

        p().iUint = iShared.iCodecSettings.iG711FrameRate; //TODO:

        iShared.iMutex.Signal();

        }

    else if (iCodecsCountDn > 0 &&

            (iSessionType == EQueryDec || iSessionType == EDnlink))

        {

        p().iInt = iCodecsCountDn;

        iShared.iMutex.Wait();

        p().iUint = iShared.iCodecSettings.iG711FrameRate; //TODO:

        iShared.iMutex.Signal();

        }

    else

        {

        delete iDevSound;

        iDevSound = NULL;

        iDevSound = CMMFDevSound::NewL();

        if (iDevSound)

            {

            iCodecsUp.Reset();

            iCodecsCountUp = 0;

            iDevSound->GetSupportedInputDataTypesL(iCodecsUp, iPriority);

/*

#ifdef __WINSCW__

            // Support for adaptation stubs

            iCodecsUp.Append(KMccFourCCIdG711);

            iCodecsUp.Append(KMccFourCCIdG729);

            iCodecsUp.Append(KMccFourCCIdILBC);

            iCodecsUp.Append(KMccFourCCIdAMRNB);

#endif

*/

            iCodecsCountUp = iCodecsUp.Count();

            iCodecsDn.Reset();

            iCodecsCountDn = 0;

            iDevSound->GetSupportedOutputDataTypesL(iCodecsDn, iPriority);

/*

#ifdef __WINSCW__

            // Support for adaptation stubs

            iCodecsDn.Append(KMccFourCCIdG711);

            iCodecsDn.Append(KMccFourCCIdG729);

            iCodecsDn.Append(KMccFourCCIdILBC);

            iCodecsDn.Append(KMccFourCCIdAMRNB);

#endif

*/

            iCodecsCountDn = iCodecsDn.Count();

            }

        }

    delete iDevSound;

    iDevSound = NULL;

    if (iSessionType == EQueryEnc || iSessionType == EUplink)

        {

        p().iInt = iCodecsCountUp;

        }

    else if (iSessionType == EQueryDec || iSessionType == EDnlink)

        {

        p().iInt = iCodecsCountDn;

        }

    p().iUint = KVoIPG711FrameLen20ms; //good for 10ms and 20ms

    aMessage.WriteL(0, p);

    TRACE_PRN_FN_EXT;

    }

// -----------------------------------------------------------------------------

// CVoIPAudioServerSession::GetSupportedEncodersL

//

// -----------------------------------------------------------------------------

//

void CVoIPAudioServerSession::GetSupportedCodecsL(const RMessage2& aMessage)

    {

    TRACE_PRN_FN_ENT;

    CBufFlat* dataCopyBuffer = CBufFlat::NewL(KArrayExpandSize);

    CleanupStack::PushL(dataCopyBuffer);

    RBufWriteStream stream;

    stream.Open(*dataCopyBuffer);

    CleanupClosePushL(stream);

    if (iCodecsCountUp > 0 &&

       (iSessionType == EQueryEnc || iSessionType == EUplink))

        {

        for (TInt i = 0; i < iCodecsCountUp; i++)

            {

            stream.WriteUint32L(iCodecsUp[i].FourCC());

            TRACE_PRN_N2(_L("VoIP->CodecUP[%d]==[0x%x]"), i+1, iCodecsUp[i].FourCC());

            }

        }

    else if (iCodecsCountDn > 0 &&

            (iSessionType == EQueryDec || iSessionType == EDnlink))

        {

        for (TInt i = 0; i < iCodecsCountDn; i++)

            {

            stream.WriteUint32L(iCodecsDn[i].FourCC());

            TRACE_PRN_N2(_L("VoIP->CodecDN[%d]==[0x%x]"), i+1, iCodecsDn[i].FourCC());

            }

        }

    aMessage.WriteL(0, dataCopyBuffer->Ptr(0));

    CleanupStack::PopAndDestroy(&stream);

    CleanupStack::PopAndDestroy(dataCopyBuffer);

    TRACE_PRN_FN_EXT;

    }