// Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).
/*
* Copyright (c) 2004 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:    
*
*/


// HEADERS
#include <connpref.h>
#include <es_sock.h>
#include <commdbconnpref.h>
#include "in_sock.h"
#include <e32cons.h>
#include <e32err.h>
#include <e32std.h>
#include <e32base.h>
#include <badesca.h>
#include <random.h>
#include "rtpheader.h"
#include "rtptestapp.h"

const TUint KIAPID = 1;
const TInt KLength = 20;
_LIT8(KHello, "RTP APIs...testing");
_LIT8(KNoCName, "");

CConsoleBase *gConsole;
CActiveScheduler *sched;

void MainL()
    {
    // Create a Console 
    gConsole = Console::NewL(_L("Test Console"), TSize(KConsFullScreen, KConsFullScreen));
    CleanupStack::PushL(gConsole);
    
    // Create an Active scheduler 
    sched = new (ELeave) CActiveScheduler;
    CActiveScheduler::Install(sched);
    
    //IAP(Internet Access Point) id to be chaged as per comms dat
    CRtpTestApp * iRtpTestApp = CRtpTestApp::NewL();   
    
    // Send RTP Packet with CSRC and Check RTP Stack 
    // Supports maximum 15 contributing sources
    iRtpTestApp->SendRtpPacketL();
    
    // Send RTP packet with zero length paylpoad
    iRtpTestApp->SendZeroLengthRtpPacketL();
    
    // Send RTP Packets and Modify packet in callback function
    iRtpTestApp->SendRtpPacketLoopbackL();
    
    
    User::After(5000000);
    delete iRtpTestApp;
    delete sched;
    CleanupStack::PopAndDestroy(gConsole);
    
    }

CRtpTestApp * CRtpTestApp::NewL()
{
    gConsole->Printf(_L("RtpTestApp::NewL\n"));
    CRtpTestApp* self = new( ELeave ) CRtpTestApp(); 
    CleanupStack::PushL( self );
    
    // To construct the objects in the second-phase of the construction
    self->ConstructL( );
    CleanupStack::Pop( self);
    return self;
}

CRtpTestApp::CRtpTestApp()
    {
    
    }


void CRtpTestApp::ErrorNotify( TInt /*aErrCode*/ )
    {
    
    }

void CRtpTestApp::SdesReceived( TRtpSSRC /*aSSRC*/,
                   const TRtpSdesParams& /*aParams*/ )
    {
    
    }

void CRtpTestApp::ByeReceived( TRtpId /*aStreamId*/, TRtpSSRC /*aSSRC*/,
                  const TDesC8& /*aReason*/ )
    {
    
    }

void CRtpTestApp::AppReceived( TRtpId /*aStreamId*/, TRtpSSRC /*aSSRC*/,
                  const TRtcpApp& /*aApp*/ )
    {
    
    }

void CRtpTestApp::SrReceived( TRtpId /*aStreamId*/, TRtpSSRC /*aSSRC*/,
                 const TTimeStamps& /*aTimeStamps*/ )
    {
    
    }

void CRtpTestApp::RrReceived( TRtpId /*aStreamId*/, TRtpSSRC /*aSSRC*/ )
    {
    
    }

void CRtpTestApp::RtpPacketReceived( TRtpId /*aStreamId*/, const TRtpRecvHeader& aHeaderInfo, const TDesC8& /*aPayloadData*/ )
    {
    gConsole->Printf(_L("RtpPacketReceived .. \n"));
    
    for(int i=0; i<aHeaderInfo.iCsrcCount; i++)
        {
        if ( (*iCsrclist)[i] == *(aHeaderInfo.iCsrcList+i) )
            {
            gConsole->Printf(_L("RtpPacketReceived, Successfully\n"));
            }
        else
            {
            gConsole->Printf(_L("Malformed RTP Packet Received\n"));
            gConsole->Printf(_L("Test Case Failed\n"));
            }
        }
    
    // Check for modified Padding, header extension, Marker bit values 1
    if( aHeaderInfo.iMarker == 0 )
        {
        gConsole->Printf(_L("Test Case Failed\n"));
        }
    }

void CRtpTestApp::ReadyToSendRtpPacket(  TRtpId /*aTranStreamId*/, TPtr8 &aPacket  )
    {
    gConsole->Printf(_L("ReadyToSendRtpPacket Callback..\n"));
    
    // Change Marker bit value from 0 to 1
    aPacket[1] = aPacket[1] | 0x80;
    
    TUint32* data32 = reinterpret_cast<TUint32*>(&(aPacket[8]));
    //Change SSRC Value from
    *data32 = ByteOrder::Swap32(0xDEADBEEF);
    }

void CrtpDataSender::RunL()
    {
    gConsole->Printf(_L("CrtpDataSender::RunL\n"));
    CActiveScheduler::Stop();
    }

void CRtpTestApp::ConstructL()
    {
    iRtpApi = CRtpAPI::NewL(*this );

    TVersion  version = iRtpApi->Version();
    
    TInt result(KErrNone);
    
    iParams.iCName.Set(KNoCName());

    iRtpApi->OpenL( iParams, NULL, NULL, NULL );
    
    result = iRtpApi->StartConnection(KIAPID);
    gConsole->Printf(_L("Local Ip Address %d\n"),result);
    
    TBuf<50> addrStr;
    TInetAddr inetaddr = iRtpApi->GetLocalIPAddressL();
    inetaddr.Output(addrStr);
    
    gConsole->Printf(_L("Local Ip Address %s\n"),addrStr.PtrZ());
    
    iSessionParams.iPriority = TCreateSessionParams::EPriorityStandard;
    iSessionParams.iSocketBufSize = KSocketBufSize;
    
    
    iPort1 = 8000 ;
    iPort2 = 9000;

    iRtcpParams.iRtcpFraction = 10;
    iRtcpParams.iRtcpTimeOut = 5000000;
    iRtcpParams.iSessionBWidth = 300;
    
    iEnableRtcp = EFalse;
    
    //Creating New session
    iSessionId1  = KNullId;
    iSessionId2 = KNullId;
    iSessionId1 = iRtpApi->CreateSessionL(iSessionParams, iPort1, iEnableRtcp, &iRtcpParams);
    iSessionId2 = iRtpApi->CreateSessionL(iSessionParams,iPort2,EFalse,&iRtcpParams);
    
    TInetAddr remAddress = iRtpApi->GetLocalIPAddressL(); 
    remAddress.SetPort(iPort2); //Session 1 sends data to Session 2
    
    iRtpApi->SetRemoteAddress(iSessionId1, remAddress);
     
    iRtpApi->RegisterRtpObserver(iSessionId1, *this);
    iRtpApi->RegisterRtcpObserver(iSessionId1, *this);
    iRtpApi->RegisterRtpObserver(iSessionId2, *this);
    iRtpApi->RegisterRtcpObserver(iSessionId2, *this);
    iRtpApi->RegisterRtpPostProcessingObserver(iSessionId1, *this);
    
    TTranStreamParams streamParams;
    streamParams.iPayloadType = 98;
    TRtpSSRC locSSRC;
    
    iS1T1 = iRtpApi->CreateTransmitStreamL(iSessionId1,streamParams,locSSRC);
    
    TRcvStreamParams rcvParams;
    rcvParams.iPayloadType = 98;

    iS2R1 = iRtpApi->CreateReceiveStreamL(iSessionId2,rcvParams);
    
    
    /* Start both the sessions */
    TInt ret = iRtpApi->StartSession(iSessionId1);
    ret = iRtpApi->StartSession(iSessionId2);
    
    iRtpApi->SetSamplingRate(98,8000);
    }


void CRtpTestApp::SendRtpPacketL()
    {
    gConsole->Printf(_L("SendRtpPackets  TO Loopback address and Verify Header fields.. \n"));
    
    TRtpSendHeader headerinfo;
    headerinfo.iHeaderExtension = NULL;
    headerinfo.iMarker = 0;
    headerinfo.iPadding = 0;
    headerinfo.iPayloadType = 98;
    headerinfo.iTimestamp = 1000;
    
    HBufC8* data = HBufC8::NewLC(KLength);
    data->Des().Copy(KHello);

    
    TRtpSendPktParams *header = new(ELeave) TRtpSendPktParams(headerinfo);
    CleanupDeletePushL(header);
    header->iTranStreamId = iS1T1;
    header->iPayloadData.Set(data->Des()); 
    
    const TUint KArrayGranularity = 15;
    
    iCsrclist = new(ELeave) CArrayFixFlat<TUint32>(KArrayGranularity);
    
    // Send RTP Packets with CSRC list - 17 CSRC. Max Supported CSRC list is 15.
    iCsrclist->AppendL(100001);
    iCsrclist->AppendL(100002);
    iCsrclist->AppendL(100003);
    iCsrclist->AppendL(100004);
    iCsrclist->AppendL(100005);
    iCsrclist->AppendL(100006);
    iCsrclist->AppendL(100007);
    iCsrclist->AppendL(100008);
    iCsrclist->AppendL(100009);
    iCsrclist->AppendL(100010);
    iCsrclist->AppendL(100011);
    iCsrclist->AppendL(100012);
    iCsrclist->AppendL(100013);
    iCsrclist->AppendL(100014);
    iCsrclist->AppendL(100015);
    iCsrclist->AppendL(100016);
    iCsrclist->AppendL(100017);
    
    iRtpApi->SetSamplingRate(headerinfo.iPayloadType, 8000);
    TInt ret1 = iRtpApi->SendRtpPacket(*header, iCsrclist->Array());
    
    CrtpDataSender *datasend = CrtpDataSender::NewL(iRtpApi, iS1T1);
    CleanupStack::PushL(datasend);
    
    datasend->SendRtpData(*header, iCsrclist->Array());
    
    gConsole->Printf(_L("SendRtpPacket %d\n"),ret1);
    
    CActiveScheduler::Start();
    
    CleanupStack::PopAndDestroy(3);
    delete iCsrclist;
    iCsrclist = 0;
    }


void CRtpTestApp::SendRtpPacketLoopbackL()
    {
    gConsole->Printf(_L("SendRtpPackets  TO Loopback address and Verify Header fields.. \n"));

    TRtpSendHeader header; 
    header.iHeaderExtension = NULL;
    header.iMarker = 0;
    header.iPadding = 0;
    header.iPayloadType = 98;
    header.iTimestamp = 1000;
    
    HBufC8* data = HBufC8::NewLC(KLength);
    data->Des().Copy(KHello);

    TRtpSendPktParams *headerinfo = new(ELeave) TRtpSendPktParams(header);
    CleanupDeletePushL(headerinfo);
    headerinfo->iTranStreamId = iS1T1;
    headerinfo->iPayloadData.Set(data->Des()); 
    
    const TUint KArrayGranularity = 15;
    
    // Create CSRC list and Append CSRC identifiers
    iCsrclist = new(ELeave) CArrayFixFlat<TUint32>(KArrayGranularity);
    
    iCsrclist->AppendL(123456);
    iCsrclist->AppendL(999999);
     
    TInt error2( KErrNone );
    // Try sending synchronously with Csrc
    error2 = iRtpApi->SendRtpPacket(*headerinfo, iCsrclist->Array());
    gConsole->Printf(_L("SendRtpPacket.. %d\n"), error2);
    
    // Try sending asynchronously with CSRC
    CrtpDataSender *datasend = CrtpDataSender::NewL(iRtpApi, iS1T1);
    CleanupStack::PushL(datasend);
    datasend->SendRtpData(*headerinfo, iCsrclist->Array());
    gConsole->Printf(_L("SendRtpPacket.. %d\n"), error2);
    
    CActiveScheduler::Start();
    
    CleanupStack::PopAndDestroy(3);
    delete iCsrclist;
    iCsrclist = 0;
    }

void CRtpTestApp::SendZeroLengthRtpPacketL()
    {
    // Start Session on Session id
    iRtpApi->StartSession(iSessionId1);
    
    TInetAddr remAddress = iRtpApi->GetLocalIPAddressL();
    remAddress.SetPort(9000); //Session 1 sends data to Session 2
    
    iRtpApi->SetRemoteAddress(iSessionId1, remAddress);
    
    iRtpApi->RegisterRtpObserver(iSessionId1, *this);
    iRtpApi->RegisterRtcpObserver(iSessionId1, *this);
    iRtpApi->RegisterRtpPostProcessingObserver(iSessionId1, *this);
    
    //iRtpApi->SetNonRTPDataObserver(iSessionId1, *this);
    
    TTranStreamParams tranStreamParams;
    tranStreamParams.iPayloadType = 96;
    TRtpSSRC ssrc = 4567890;
    
    TRtpId streamId = iRtpApi->CreateTransmitStreamL(iSessionId1, tranStreamParams, ssrc);

    
    TRtpSendHeader headerinfo;
    headerinfo.iHeaderExtension = 0;
    headerinfo.iPayloadType = 96;
    headerinfo.iTimestamp = 12345678;
    
    TRtpSendPktParams *header = new(ELeave) TRtpSendPktParams(headerinfo);
    CleanupDeletePushL(header);
    header->iTranStreamId = streamId;
    
    const TUint KArrayGranularity = 15;
    
    iCsrclist = new(ELeave) CArrayFixFlat<TUint32>(KArrayGranularity);
    
    // Send RTP Packets with CSRC list
    iCsrclist->AppendL(100001);
    iCsrclist->AppendL(100002);
    
    iRtpApi->SetSamplingRate(headerinfo.iPayloadType, 8000);
    
    TInt ret1 = iRtpApi->SendRtpPacket(*header, iCsrclist->Array());
    
    CrtpDataSender *datasend = CrtpDataSender::NewL(iRtpApi, streamId);
    CleanupStack::PushL(datasend);
    datasend->SendRtpData(*header, iCsrclist->Array());
    
    CActiveScheduler::Start();
    
    CleanupStack::PopAndDestroy(2);
    delete iCsrclist;
    iCsrclist = 0;
    }

CRtpTestApp::~CRtpTestApp()
    {
    delete iRtpApi;
    }

GLDEF_C TInt E32Main()
/**
 * @return - Standard Epoc error code on exit
 */
    {
    __UHEAP_MARK;
    CTrapCleanup* cleanup = CTrapCleanup::New();
    if(!cleanup)
        {
        return KErrNoMemory;
        }
    TInt err = 0;
    TRAP(err,MainL());
    delete cleanup;
    __UHEAP_MARKEND;
    return err;
    }