/*

* Copyright (c) 2006-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:    Contains functionality for DTMF digit encoding and sending.

*

*/

// INCLUDES

#include <hal.h>

#include "mmccnetworksettings.h"

#include "dtmfpayloadformatwrite.h"

#include "dtmfpayloadencoder.h"

#include "dtmfeventpayloadinfo.h"

#include "dtmftonepayloadinfo.h"

#include "mccrtpdatasink.h"

#include "mccinternaldef.h"

#include "rtpdatasink.h"

#include "mccrtpmediaclock.h"

#include "mccinternalevents.h"

#include "dtmfhighresolutiontimer.h"

// CONSTANTS

const TUint8 KValidDTMFDigits[] = { '0', '1', '2', '3', '4', '5', '6', '7', 

    '8', '9', 'a', 'b', 'c', 'd', 'A', 'B', 'C', 'D', '*', '#', 'p', 'w'  };

const TInt  KSignalInbandDtmf = 1;

const TInt  KSignalOutbandDtmf = 2;

const TInt  KDurationNotApplicable = 1000000000;

// Pause in DTMF string sending when next digit to handle is 'p' char

const TUint KDTMFPauseLengthInUs    = 2500000;

const TInt  KNumOfFinalPackets      = 3;

const TReal KUsToSecFactor          = 0.000001;

const TReal KMsToSecFactor          = 0.001;

const TUint KDtmfDefSampleRate      = 8000;

const TUint KFactor1000             = 1000;

const TInt  KDefaultTickPeriodInMs  = 1;

// ======== MEMBER FUNCTIONS ========

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

// CDTMFPayloadFormatWrite::CDTMFPayloadFormatWrite

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CDTMFPayloadFormatWrite::CDTMFPayloadFormatWrite()

    :

    iSampleRate( KDtmfDefSampleRate ), 

    iTickPeriod( KDefaultTickPeriodInMs )

    {

    DP_DTMF_WRITE( _L("CDTMFPayloadFormatWrite::CDTMFPayloadFormatWrite") );

    }

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

// CDTMFPayloadFormatWrite::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CDTMFPayloadFormatWrite::ConstructL( MDataSink* aSink )

    {

    DP_DTMF_WRITE( _L("CDTMFPayloadFormatWrite::ConstructL") );

    iFourCC = TFourCC( KMccFourCCIdDTMF );

    // Set data sink

    CMccRtpDataSink* tmp = static_cast<CMccRtpDataSink*>( aSink );

    iRtpDataSink = static_cast<MMccRtpDataSink*>( tmp );

    iClip = aSink;

    // Allocate buffer for payload encoder

    iSinkBuffer = CMMFDataBuffer::NewL( KDTMFDefaultPayloadSize );

    iPayloadEncoder = CDTMFPayloadEncoder::NewL();

    // Initialize state machine

    iStateMachine = CDtmfEncStateMachine::NewL( *this );

    TUint validDigitCount = sizeof ( KValidDTMFDigits ) / sizeof ( TUint8 );

    for ( TUint i = 0; i < validDigitCount; i++ )

        {

        iValidDigits.Append( KValidDTMFDigits[ i ] );

        }

    TInt err = HAL::Get( HAL::ENanoTickPeriod, iTickPeriod );

    if ( KErrNone != err )

        {

        DP_DTMF_WRITE2( _L("CDTMFPayloadFormatWrite::ConstructL HAL ERR: %d"),

            err );

        }

    iTickPeriod = TInt( iTickPeriod * KMsToSecFactor );

    iSendTimer = CDtmfHighResTimer::NewL( CActive::EPriorityHigh );

    }

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

// CDTMFPayloadFormatWrite::NewL

// Two-phased constructor.

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

//

CDTMFPayloadFormatWrite* CDTMFPayloadFormatWrite::NewL( MDataSink* aSink )

    {

    DP_DTMF_WRITE( _L("CDTMFPayloadFormatWrite::NewL") );

    if ( !aSink ) 

        {

        User::Leave ( KErrArgument );

        }

    if ( KMccRtpSinkUid != aSink->DataSinkType() )

        {

        User::Leave ( KErrNotSupported );

        }

    CDTMFPayloadFormatWrite* self = new( ELeave ) CDTMFPayloadFormatWrite;

    CleanupStack::PushL( self );

    self->ConstructL( aSink );

    CleanupStack::Pop( self );

    return self;

    }

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

// CDTMFPayloadFormatWrite::~CDTMFPayloadFormatWrite

// Destructor.

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

//

CDTMFPayloadFormatWrite::~CDTMFPayloadFormatWrite()

    {

    DP_DTMF_WRITE( _L("CDTMFPayloadFormatWrite::~CDTMFPayloadFormatWrite") );

    delete iSinkBuffer;

    delete iPayloadEncoder;

    delete iSendTimer;

    delete iStateMachine;

    iEventHandler = NULL;

    iRtpDataSink = NULL;

    // Media clock is not owned

    if ( iRtpMediaClock )

        {

        iRtpMediaClock->UnregisterMediaFormat( iKey );

        iRtpMediaClock = NULL;

        }

    iSendBuffer.Close();

    iValidDigits.Close();

    }

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

// CDTMFPayloadFormatWrite::HandleTimerEventL

// STATIC METHOD. Passes timer events to the class instance interested

// about them.

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

//

TInt CDTMFPayloadFormatWrite::HandleTimerEventL( TAny* aObjectPtr )

    {

    if ( aObjectPtr )

        {

        return static_cast<CDTMFPayloadFormatWrite*>( aObjectPtr )->

                                                        DoHandleTimerEventL();

        }

    else

        {

        return KErrArgument;

        }

    }

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

// CDTMFPayloadFormatWrite::SinkThreadLogon

// Passes the logon command to the sink clip.

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

//

TInt CDTMFPayloadFormatWrite::SinkThreadLogon( 

    MAsyncEventHandler& aEventHandler )

    {

    DP_DTMF_WRITE( _L("CDTMFPayloadFormatWrite::SinkThreadLogon") );

    iEventHandler = &aEventHandler;

    return iClip->SinkThreadLogon( aEventHandler );

    }

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

// CDTMFPayloadFormatWrite::SinkThreadLogoff

// Passes the logoff command to the sink clip.

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

//

void CDTMFPayloadFormatWrite::SinkThreadLogoff()

    {

    DP_DTMF_WRITE( _L("CDTMFPayloadFormatWrite::SinkThreadLogoff") );

    iClip->SinkThreadLogoff();

    }

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

// CDTMFPayloadFormatWrite::CanCreateSinkBuffer

// EmptyBufferL() is not used.

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

//

TBool CDTMFPayloadFormatWrite::CanCreateSinkBuffer()

    {

    return EFalse;

    }

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

// CDTMFPayloadFormatWrite::CreateSinkBufferL

// Create a sink buffer.

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

//

CMMFBuffer* CDTMFPayloadFormatWrite::CreateSinkBufferL( 

    TMediaId /*aMediaId*/,

    TBool& /*aReference*/ )

    {

    DP_DTMF_WRITE( _L("CDTMFPayloadFormatWrite::CreateSinkBufferL") );

    User::Leave( KErrNotSupported );

    // PC_LINT #527, for compiler warning

    return NULL;

    }

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

// CDTMFPayloadFormatWrite::SetSinkDataTypeCode

// Set the sink data type to the given FourCC code for the given media.

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

//

TInt CDTMFPayloadFormatWrite::SetSinkDataTypeCode( TFourCC aSinkFourCC, 

                                                   TMediaId aMediaId )

    {

    DP_DTMF_WRITE( _L("CDTMFPayloadFormatWrite::SetSinkDataTypeCode") );

    if ( KUidMediaTypeAudio != aMediaId.iMediaType )

        {

        return KErrNotSupported;

        }

    iFourCC = aSinkFourCC;

    return KErrNone;

    }

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

// CDTMFPayloadFormatWrite::SinkDataTypeCode

// Return the sink data type (four CC code) for the given media.

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

//

TFourCC CDTMFPayloadFormatWrite::SinkDataTypeCode( TMediaId aMediaId )

    {

    DP_DTMF_WRITE( _L("CDTMFPayloadFormatWrite::SinkDataTypeCode") );

    if ( KUidMediaTypeAudio == aMediaId.iMediaType )

        {

        return iFourCC;

        }

    else

        {

        // Defaults to 'NULL' fourCC

        return TFourCC();

        }

    }

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

// CDTMFPayloadFormatWrite::FrameTimeInterval

// Gets audio frame size in milliseconds.

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

//

TTimeIntervalMicroSeconds CDTMFPayloadFormatWrite::FrameTimeInterval( 

    TMediaId aMediaType ) const

    {

    DP_DTMF_WRITE( _L("CDTMFPayloadFormatWrite::FrameTimeInterval") );

    if ( KUidMediaTypeAudio == aMediaType.iMediaType )

        {

        return TTimeIntervalMicroSeconds( TInt64( 0 ) );

        }

    else

        {

        return TTimeIntervalMicroSeconds( TInt64( 0 ) );

        }

    }

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

// CDTMFPayloadFormatWrite::Duration

// Gets the duration of the sink clip for the specified media ID.

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

//

TTimeIntervalMicroSeconds CDTMFPayloadFormatWrite::Duration( 

    TMediaId /*aMediaType*/ ) const

    {

    DP_DTMF_WRITE( _L("CDTMFPayloadFormatWrite::Duration") );

    return TTimeIntervalMicroSeconds( TInt64( KDurationNotApplicable ) );

    }

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

// CDTMFPayloadFormatWrite::BufferEmptiedL

// Called by RTP data sink. Indicates that DTMF data is sent to the network.

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

//

void CDTMFPayloadFormatWrite::BufferEmptiedL( CMMFBuffer* /*aBuffer*/ )

    {

    DP_DTMF_WRITE( _L("CDTMFPayloadFormatWrite::BufferEmptiedL") );

    // Nothing to do

    }

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

// CDTMFPayloadFormatWrite::SinkPrimeL

// Passes prime transition to the RTP data sink.

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

//

void CDTMFPayloadFormatWrite::SinkPrimeL()

    {

    DP_DTMF_WRITE( _L("CDTMFPayloadFormatWrite::SinkPrimeL") );

    iClip->SinkPrimeL();

    // If the possible state machine in clip does not leave, let dtmf payload

    // formatter also allow re-priming from any state.

    CancelDTMFStringSending();

    }

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

// CDTMFPayloadFormatWrite::SinkPlayL

// Passes play transition to the RTP data sink and resets state variables.

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

//

void CDTMFPayloadFormatWrite::SinkPlayL()

    {

    DP_DTMF_WRITE( _L("CDTMFPayloadFormatWrite::SinkPlayL") );

    iClip->SinkPlayL();

    }

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

// CDTMFPayloadFormatWrite::SinkPauseL

// Passes pause transition to the RTP data sink.

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

//

void CDTMFPayloadFormatWrite::SinkPauseL()

    {

    DP_DTMF_WRITE( _L("CDTMFPayloadFormatWrite::SinkPauseL") );

    CancelDTMFStringSending();

    iClip->SinkPauseL();

    }

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

// CDTMFPayloadFormatWrite::SinkStopL

// Passes stop transition to the RTP data sink.

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

//  

void CDTMFPayloadFormatWrite::SinkStopL()

    {

    DP_DTMF_WRITE( _L("CDTMFPayloadFormatWrite::SinkStopL") );

    CancelDTMFStringSending();

    iClip->SinkStopL();

    }

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

// CDTMFPayloadFormatWrite::EmptyBufferL

// Not used because DTMF payload formatter generates DTMF independently.

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

//

void CDTMFPayloadFormatWrite::EmptyBufferL( CMMFBuffer* /*aBuffer*/, 

                                            MDataSource* /*aSupplier*/, 

                                            TMediaId /*aMediaId*/ )

    {

    DP_DTMF_WRITE( _L("CDTMFPayloadFormatWrite::EmptyBufferL") );

    User::Leave( KErrNotSupported );

    }

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

// CDTMFPayloadFormatWrite::PayloadFormat

// Returns payload format used in DTMF encoding.

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

//

TDTMFPayloadFormat CDTMFPayloadFormatWrite::PayloadFormat() const

    {

    DP_DTMF_WRITE( _L("CDTMFPayloadFormatWrite::PayloadFormat") );

    return iPayloadFormat;

    }

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

// CDTMFPayloadFormatWrite::SetPayloadFormat

// Sets payload format used in DTMF encoding.

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

//

TInt CDTMFPayloadFormatWrite::SetPayloadFormat( 

    TDTMFPayloadFormat aPayloadFormat )

    {

    DP_DTMF_WRITE2( _L("CDTMFPayloadFormatWrite::SetPayloadFormat - Format: %d"), aPayloadFormat );

    TInt err = iPayloadEncoder->SetPayloadFormat( aPayloadFormat );

    if ( KErrNone == err )

        {

        iPayloadFormat = aPayloadFormat;

        }

    return err;

    }

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

// CDTMFPayloadFormatWrite::StartDTMFToneL

// Starts a timer which sends specified DTMF digit periodically until 

// StopDTMFTone() is called.

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

//

void CDTMFPayloadFormatWrite::StartDTMFToneL( const TChar aTone )

    {

    TUint32 tickCount( User::NTickCount() );

    DP_DTMF_WRITE3(  _L("CDTMFPayloadFormatWrite::StartDTMFToneL aTone = %c, tick = %u"),

        static_cast<TUint>( aTone ), tickCount );

    DP_DTMF_WRITE2( _L("CDTMFPayloadFormatWrite::StartDTMFToneL enc state %d"),

        iStateMachine->State() );

    __ASSERT_ALWAYS( IsValidDigit( aTone ), User::Leave( KErrArgument ) );

    iSendingMode = EModeManual;

    TSendBufferElement element( aTone, tickCount );

    iSendBuffer.AppendL( element );

    if ( EStateSendingIdle == iStateMachine->State() )

        {

        if ( KSignalOutbandDtmf == iGenerationMode )

            {

            iSinkBuffer->Data().FillZ( KDTMFDefaultPayloadSize );

            }

        iStateMachine->ChangeStateTo( EStateEncodeNextDigit );

        }

    else

        {

        DP_DTMF_WRITE( 

            _L("CDTMFPayloadFormatWrite::StartDTMFToneL - REQ BUFFERED") );

        }

    }

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

// CDTMFPayloadFormatWrite::StopDTMFToneL

// Stops the timer for DTMF digit update packet sending. Starts a timer for 

// sending Final Packet three times according to RFC 2833, section 2.5.1.4.

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

//

void CDTMFPayloadFormatWrite::StopDTMFToneL()

    {

    TUint32 tickCount( User::NTickCount() );

    DP_DTMF_WRITE2( _L("CDTMFPayloadFormatWrite::StopDTMFTone, tick = %u"),

        tickCount );

    // set stop time to the first unupdated element

    TBool elementFound( EFalse );

    TInt index( 0 );

    while ( !elementFound && index < iSendBuffer.Count() )

        {

        if ( iSendBuffer[index].StopTime() == 0 )

            {

            iSendBuffer[index].SetStopTime( tickCount );

            if ( iSendBuffer[index].StopTime() == 0 )

                {

                // mark stop time as updated to prevent update of the same 

                // element in future

                iSendBuffer[index].SetStopTime( 1 );

                }

            elementFound = ETrue;

            }

        index++;

        }

    if ( EStateToneOn == iStateMachine->State() )

        {

        if ( KSignalOutbandDtmf == iGenerationMode )

            {

            if ( EDTMFPayloadFormatEvent == iPayloadFormat

                || EDTMFPayloadFormatRedEvents == iPayloadFormat )

                {

                // Send final packet with "E" bit set. According to 

                // RFC 2833 2.5.1.4 final packet SHOULD be sent three times.

                iPayloadEncoder

                    ->UpdateEventPayload( ETrue, iToneDuration, iSinkBuffer );

                iStateMachine->ChangeStateTo( EStateToneOff );

                }

            else if ( EDTMFPayloadFormatTone == iPayloadFormat )

                {

                // Tone Payload Format doesn't have final packet redundancy

                iPayloadEncoder->UpdateTonePayload( iToneDuration, 

                                                                iSinkBuffer );

                }

            else

                {

                // Not acceptable payload format

                }

            }

        else

            {

            iStateMachine->ChangeStateTo( EStateToneOff );

            }

        }

    else

        {

        DP_DTMF_WRITE( _L("CDTMFPayloadFormatWrite::StopDTMFTone OUT-OF-SYNC") );

        }

    }

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

// CDTMFPayloadFormatWrite::SendDTMFTonesL

// Starts to send DTMF string incrementally until the string is sent.