/*

* Copyright (c) 2007 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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:    Parses SDP file.*

*/

// INCLUDE FILES

#include <ipvideo/CDvrSdpParser.h>

#include <in_sock.h>

#include "videoserviceutilsLogger.h"

// CONSTANTS

_LIT8( KKeyIpv4Addr, "c=IN IP4 " );

_LIT8( KKeyIpv6Addr, "c=IN IP6 " );

_LIT8( KKeyAttribute, "a=" );

_LIT8( KKeyMedia, "m=" );

_LIT8( KKeyMediaAudio, "m=audio " );

_LIT8( KKeyMediaVideo, "m=video " );

_LIT8( KKeyMediaTitle, "m=title " );

_LIT8( KKeyDataStream, "m=data " );

_LIT8( KKeyClockRate, "a=rtpmap:" );

_LIT8( KKeyControl, "a=control:" ); 

//_LIT8( KKeyStreamId, "a=control:streamid=" );

_LIT8( KRealMediaIndicator, "/x-pn-real" ); 

_LIT8( KKeyBandWidth, "b=AS:" );

_LIT8( KCRSDPRtspUriBegin, "rtsp://" );

_LIT8( KSPStr, " ");

_LIT8( KCRStr, "\r");

_LIT8( KLFStr, "\n");

_LIT8( KCRLFStr, "\r\n");

_LIT8( KSLStr, "/" );

_LIT8( KSdpLiveStream, "a=LiveStream:integer;1");

_LIT8( KSdpRangeHeaderLiveStream, "a=range:npt=now-" );

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

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

// CDvrSdpParser::NewL

// Two-phased constructor.

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

//

EXPORT_C CDvrSdpParser* CDvrSdpParser::NewL()

    {

    CDvrSdpParser* self = CDvrSdpParser::NewLC();

    CleanupStack::Pop( self );

    return self;

    }

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

// CDvrSdpParser::NewLC

// Two-phased constructor.

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

//

EXPORT_C CDvrSdpParser* CDvrSdpParser::NewLC()

    {

    CDvrSdpParser* self = new( ELeave ) CDvrSdpParser();

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// CDvrSdpParser::CDvrSdpParser

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

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

//

CDvrSdpParser::CDvrSdpParser()

  : iAudioPort( KErrNotFound ),

    iVideoPort( KErrNotFound ),

    iTitlePort( KErrNotFound ),

    iAudioBitrate( KErrNotFound ),

    iVideoBitrate( KErrNotFound ),

    iAudioStreamId( KErrNotFound ),

    iVideoStreamId( KErrNotFound ),

    iVideoTimerGranularity( KMaxTUint32 ),

    iAudioTimerGranularity( KMaxTUint32 )

    {

    // None

    }

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

// CDvrSdpParser::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CDvrSdpParser::ConstructL()

    {

    LOG( "CDvrSdpParser::ConstructL()" );

    }

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

// CDvrSdpParser::~CDvrSdpParser

// Destructor.

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

//

EXPORT_C CDvrSdpParser::~CDvrSdpParser()

    {

    LOG( "CDvrSdpParser::~CDvrSdpParser()" );

    delete iBaseUrl; iBaseUrl = NULL; 

    DeleteVariables();

    }

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

// CDvrSdpParser::TryParseL

// 

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

//

EXPORT_C void CDvrSdpParser::TryParseL( const TDesC8& aSdp, const TDesC8& aBaseUrl ) 

    {

#if defined( LIVE_TV_RDEBUG_TRACE ) || defined( LIVE_TV_FILE_TRACE )

    HBufC* baseLog = HBufC::NewLC( aBaseUrl.Length() );

    TPtr ptr = baseLog->Des();

    ptr.Copy( aBaseUrl );

    LOG2( "CDvrSdpParser::TryParseL(), aSdp length: %d, aBaseUrl: %S",

                                       aSdp.Length(), &ptr );

    CleanupStack::PopAndDestroy( baseLog );

#endif

    if ( aBaseUrl.Length() ) 

        {

        delete iBaseUrl; iBaseUrl = NULL; 

        iBaseUrl = aBaseUrl.AllocL(); 

        }

    TryParseL( aSdp ); 

    }

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

// CDvrSdpParser::TryParseL

//

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

//

EXPORT_C void CDvrSdpParser::TryParseL( const TDesC8& aSdp )

    {

    LOG1( "CDvrSdpParser::TryParseL(), aSdp length: %d", aSdp.Length() );

    // Find medias

    FindMediasL( aSdp );

    // Append found medias to the array

    for ( TInt i( 0 ); i < iMediaBuf.Count(); i++ )

        {

        TInt port( KErrNotFound );

        TPtrC8 ptr( iMediaBuf[i] );

        // Audio media info found ?

        port = GetIntL( ptr, KKeyMediaAudio );    

        if ( port != KErrNotFound )

            {

            iAudioPort = port;

            LOG1( "CDvrSdpParser::TryParseL(), iAudioPort: %d", iAudioPort );

            UpdateMediaInfoL( ptr, iAudioIpAddr );

            // Stream id (Helix takes medias in appearance order)

            iAudioStreamId = i;

            // Audio clock rate

            iAudioTimerGranularity = GetClockRateL( ptr );

            iAudioBitrate = GetIntL( ptr, KKeyBandWidth ); 

            // Audio attributes

            FindAttributesL( ptr, iAudioAttributes ); 

            // Audio control

            GetControlL( ptr, iAudioControlAddr );

            // Find media id 97 from a=rtpmap:97 MP4A-LATM/32000/2

            iMediaIdentifierAudio = GetIntL( ptr, KKeyClockRate ); 

            }

        else

            {

            // Video media info found ?

            port = GetIntL( ptr, KKeyMediaVideo );

            if ( port != KErrNotFound )

                {

                iVideoPort = port;

                LOG1( "CDvrSdpParser::TryParseL(), iVideoPort: %d", iVideoPort );

                UpdateMediaInfoL( ptr, iVideoIpAddr );

                // Stream id (Helix takes medias in appearance order)

                iVideoStreamId = i; 

                // Video clock rate

                iVideoTimerGranularity = GetClockRateL( ptr );

                iVideoBitrate = GetIntL( ptr, KKeyBandWidth ); 

                // Video attributes

                FindAttributesL( ptr, iVideoAttributes );

                // Video control

                GetControlL( ptr, iVideoControlAddr );

                // Find media id 96 from a=rtpmap:96 H264/90000 line

	            iMediaIdentifierVideo = GetIntL( ptr, KKeyClockRate );

                }

            else

                {

                port = GetIntL( ptr, KKeyMediaTitle );

                if ( port != KErrNotFound )

                    {

                    iTitlePort = port;

                    LOG1( "CDvrSdpParser::TryParseL(), iTitlePort: %d", iTitlePort );

                    }

                }

            }

        }

    iMediaBuf.Reset();

    delete iBaseUrl; iBaseUrl = NULL; 

    delete iCommonIp; iCommonIp = NULL;

    }

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

// CDvrSdpParser::NewLineL

// 

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

//

EXPORT_C void CDvrSdpParser::NewLineL(

    const TInt aStreamId,

    const TDesC8& aLine ) 

    {

    User::LeaveIfNull( iSdp );

    const TInt newLen( iSdp->Length() + aLine.Length() + KCRLFStr().Length() );

    LOG2( "CDvrSdpParser::NewLineL(), aStreamId: %d, New sdp length: %d",

                                      aStreamId, newLen );

    switch( aStreamId )

        {

        case KErrNotFound: // Common

            {

            // Alloc more room

            iSdp = iSdp->ReAllocL( newLen );

            TPtr8 ptr( iSdp->Des() );

            // Find first attribute for new line point

            const TInt insertPoint( ptr.Find( KKeyAttribute ) );

            User::LeaveIfError( insertPoint );

            ptr.Insert( insertPoint, KCRLFStr );

            ptr.Insert( insertPoint, aLine );

            }

            break;

        case 0: // Audio (usually)

        case 1: // Video (usually)

            {

            iSdp = iSdp->ReAllocL( newLen );

            InserNewLineL( aStreamId, aLine );

            }

            break;

        default:

            User::Leave( KErrCompletion );

        }

    }

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

// CDvrSdpParser::GetSdp

// 

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

//

EXPORT_C TInt CDvrSdpParser::GetSdp( TPtrC8& aSdp ) 

    {

    if ( iSdp )

        {

        aSdp.Set( iSdp->Des() );

        return KErrNone;

        }

    return KErrNotFound;

    }

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

// CDvrSdpParser::SupportedContent

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

//

EXPORT_C CDvrSdpParser::TDvrPacketProvidings CDvrSdpParser::SupportedContent( void )

    {

    TDvrPacketProvidings retval( EDvrNoProgramAtAll );

    if ( iAudioPort > KErrNotFound && iVideoPort > KErrNotFound )

        {

        retval = EDvrBothAudioAndVideo;

        }

    else if ( iAudioPort > KErrNotFound && iVideoPort <= KErrNotFound )

        {

        retval = EDvrAudioOnly;

        }

    else if ( iVideoPort > KErrNotFound && iAudioPort <= KErrNotFound )

        {

        retval = EDvrVideoOnly;

        }

    else

        {

        LOG( "CDvrSdpParser::SupportedContent(), No media !" );

        }

    return retval;

    }

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

// CDvrSdpParser::SessionAttributes

// 

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

//

EXPORT_C RArray<TPtrC8>& CDvrSdpParser::SessionAttributes( void ) 

    {

    return iSessionAttributes; 

    }

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

// CDvrSdpParser::AudioAttributes

// 

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

//

EXPORT_C RArray<TPtrC8>& CDvrSdpParser::AudioAttributes( void ) 

    {

    return iAudioAttributes; 

    }

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

// CDvrSdpParser::VideoAttributes

// 

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

//

EXPORT_C RArray<TPtrC8>& CDvrSdpParser::VideoAttributes( void ) 

    {

    return iVideoAttributes; 

    }

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

// CDvrSdpParser::DataStreams

// 

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

//

EXPORT_C RArray<TPtrC8>& CDvrSdpParser::DataStreams( void ) 

    {

    return iDataStreams; 

    }

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

// CDvrSdpParser::IsIpv4Sdp

// Checks if Ipv4 address in use.

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

//

EXPORT_C TBool CDvrSdpParser::IsIpv4Sdp( void ) 

    {

    return iIsIpv4;

    }   

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

// CDvrSdpParser::IsMultiCastSdp

// Checks if c= line did specify a multicast addr

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

//

EXPORT_C TBool CDvrSdpParser::IsMultiCastSdp( void ) 

    {

    return iIsMulticast;

    }   

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

// CDvrSdpParser::AudioControlAddr

// 

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

//

EXPORT_C TPtrC8 CDvrSdpParser::AudioControlAddr( void ) 

    {

    return ( iAudioControlAddr )? TPtrC8( *iAudioControlAddr ): 

                                  TPtrC8( KNullDesC8 );     

    }

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

// CDvrSdpParser::VideoControlAddr

// 

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

//

EXPORT_C TPtrC8 CDvrSdpParser::VideoControlAddr( void ) 

    {

    return ( iVideoControlAddr )? TPtrC8( *iVideoControlAddr ):

                                  TPtrC8( KNullDesC8 );     

    }   

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

// CDvrSdpParser::AudioIpAddr

// 

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

//

EXPORT_C TPtrC8 CDvrSdpParser::AudioIpAddr( void ) 

    {

    return ( iAudioIpAddr )? TPtrC8( *iAudioIpAddr ): TPtrC8( KNullDesC8 );     

    }   

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

// CDvrSdpParser::VideoIpAddr

// 

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

//

EXPORT_C TPtrC8 CDvrSdpParser::VideoIpAddr( void ) 

    {

    return ( iVideoIpAddr )? TPtrC8( *iVideoIpAddr ): TPtrC8( KNullDesC8 );     

    }

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

// CDvrSdpParser::AudioPort

// 

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

//

EXPORT_C TInt CDvrSdpParser::AudioPort( void ) 

    {

    return iAudioPort;

    }

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

// CDvrSdpParser::VideoPort

// 

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

//

EXPORT_C TInt CDvrSdpParser::VideoPort( void ) 

    {

    return iVideoPort;

    }

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

// CDvrSdpParser::AudioBitrate

// 

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

//

EXPORT_C TInt CDvrSdpParser::AudioBitrate( void ) 

    {

    return iAudioBitrate;

    }

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

// CDvrSdpParser::VideoBitrate

// 

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

//

EXPORT_C TInt CDvrSdpParser::VideoBitrate( void ) 

    {

    return iVideoBitrate;   

    }

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

// CDvrSdpParser::AudioStreamId

// 

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

//

EXPORT_C TInt CDvrSdpParser::AudioStreamId( void ) 

    {

    return iAudioStreamId;

    }

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

// CDvrSdpParser::VideoStreamId

// 

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

//

EXPORT_C TInt CDvrSdpParser::VideoStreamId( void ) 

    {

    return iVideoStreamId;

    }

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

// CDvrSdpParser::VideoTimerGranularity

// 

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

//

EXPORT_C TUint32 CDvrSdpParser::VideoTimerGranularity( void )  

    {

    return iVideoTimerGranularity; 

    }       

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

// CDvrSdpParser::AudioTimerGranularity

// 

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

//

EXPORT_C TUint32 CDvrSdpParser::AudioTimerGranularity( void ) 

    {

    return iAudioTimerGranularity; 

    }       

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

// CDvrSdpParser::IsRealMediaContent

// Check for realmedia content.

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

//

EXPORT_C TBool CDvrSdpParser::IsRealMediaContent( void ) 

    {

    if ( iSdp && iSdp->Des().Find( KRealMediaIndicator ) != KErrNotFound )

        {

        LOG( "CDvrSdpParser::IsRealMediaContent(), Yes" );

        return ETrue;

        }   

    return EFalse;

    }

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

// CDvrSdpParser::MediaIdentifierAudio

// 

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

//

EXPORT_C TInt CDvrSdpParser::MediaIdentifierAudio( void )

	{

	return iMediaIdentifierAudio ;

	}

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

// CDvrSdpParser::MediaIdentifierVideo

// 

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

//

EXPORT_C TInt CDvrSdpParser::MediaIdentifierVideo( void )

	{

	return iMediaIdentifierVideo ;

	}

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

// CDvrSdpParser::IsLiveStream

// 

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

//

EXPORT_C TBool CDvrSdpParser::IsLiveStream( void ) 

    {

    TBool isLiveStream = EFalse;

    if ( iSdp &&