/*

* Copyright (c) 2009 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:  Implementation of UPnP transcode helper

*

*/

#include <bautils.h> //hack

#include <upnpitem.h>

#include <upnpstring.h>

#include <upnpdlnaprotocolinfo.h>

#include <upnpgstwrapper.h>

#include <upnprenderercfg.h>

#include <upnprenderercfgparser.h>

#include "upnpitemutility.h"

#include "upnpavdevice.h"

#include "upnptranscodehelper.h"

_LIT( KComponentLogfile, "upnptranscodehelper.txt");

#include "upnplog.h"

#define __FUNC_LOG __LOG8_1( "%s", __PRETTY_FUNCTION__ );

_LIT( KRendererCfgFile, "C:\\data\\UpnpCfgs.xml" );

_LIT( KTranscodedFlag, "?transcoded=true" );

_LIT8( KSymbianDirDelimiter, "\\" );

_LIT8( KLinuxDirDelimiter, "/" );

_LIT8( KProtocolInfo, "protocolInfo" );

_LIT8( KRes, "res" );

// These are for Transport Stream muxer checking (from pipeline)

_LIT8( KMpegTsMux, "mpegtsmux" );

_LIT8( KFFMuxMpegTs, "ffmux_mpegts" );

// These are for Transport Stream support checking

_LIT8( KTsProtocolInfoIdentifier, "_TS_" );

_LIT8( KAllMpegMimeTypes, "video/mpeg:*" );

// This is for MP4 support checking 

_LIT8( KMp4MimeType, "video/mp4" );

// The pipeline is currently hardcoded (except input file)

_LIT8( KDefaultPipelineFmt, 

"mpegtsmux output-buf-size=0x7FCCC name=mux ! appsink max-buffers=10 name=sinkbuffer filesrc \

location=%S ! qtdemux name=demux ! queue max-size-bytes=0xAAAA ! mux. demux. ! \

queue max-size-bytes=0xAAAA ! mux.");

const TInt KLocationFmtTagLen = 2;

CUpnpTranscodeHelper* CUpnpTranscodeHelper::NewL()

    {

    __FUNC_LOG;

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

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

CUpnpTranscodeHelper::~CUpnpTranscodeHelper()

    {

    __FUNC_LOG;

    iGstWrapper->RemoveObserver( *this );

    iGstWrapper->Close();

    iFs.Close();

    }

void CUpnpTranscodeHelper::PreDefinedCfgL( const CUpnpAVDevice& aRenderer, 

        CUpnpItem& aUpnpItem, HBufC8*& aPipeline,

        HBufC8*& aProtocolInfo )

    {

    __FUNC_LOG;

    //fetch mimetype and filename from original resource

    RUPnPElementsArray resources;

    CleanupClosePushL( resources );

    UPnPItemUtility::GetResElements( aUpnpItem, resources );

    TInt resourcesCount = resources.Count();

    if ( resourcesCount == 0 )

        {

        User::Leave( KErrNotFound );

        }         

    const CUpnpAttribute& originalProtocolInfoDesc = 

             UPnPItemUtility::FindAttributeByNameL( 

             *resources[0], KProtocolInfo ); 

    CUpnpDlnaProtocolInfo* originalProtocolInfo = 

            CUpnpDlnaProtocolInfo::NewL( originalProtocolInfoDesc.Value() );

    CleanupStack::PushL( originalProtocolInfo );            

    //create config for renderer

    CUpnpRendererCfg* config = CUpnpRendererCfg::NewLC( KRendererCfgFile, 

            aRenderer.ModelName(), originalProtocolInfo->ThirdField() );    

    CUpnpRendererCfgParser* parser = CUpnpRendererCfgParser::NewLC();   

    parser->ParseRendererCfgL( *config );

    HBufC8* srcFileName8 = PathToLinuxSyntaxL( resources[0]->FilePath() );

    CleanupStack::PushL( srcFileName8 );

    HBufC8* pipeline = HBufC8::NewLC( config->Pipeline().Length() + 

            srcFileName8->Length() - KLocationFmtTagLen );    

    pipeline->Des().AppendFormat( config->Pipeline(), srcFileName8 );

    HBufC8* protocolInfo = config->ProtocolInfo().AllocL();

    RFile file;

    User::LeaveIfError( file.Open(iFs,resources[0]->FilePath(),EFileRead) );

    CleanupClosePushL(file);

    TInt size(KErrNotFound);

    User::LeaveIfError( file.Size(size) );

    iGstWrapper->SetTranscodedFileSize( config->SizeMultiplier()*size );

    CleanupStack::PopAndDestroy(&file);

    CleanupStack::Pop( pipeline );

    CleanupStack::PopAndDestroy( srcFileName8 );

    CleanupStack::PopAndDestroy( parser );

    CleanupStack::PopAndDestroy( config );

    CleanupStack::PopAndDestroy( originalProtocolInfo );

    CleanupStack::PopAndDestroy( &resources );

    aPipeline = pipeline;

    aProtocolInfo = protocolInfo;

    }

HBufC8* CUpnpTranscodeHelper::PipelineL( CUpnpItem& aUpnpItem, 

        const CDesC8Array& aRendererProtocolInfos )

    {

    __FUNC_LOG;

    HBufC8* pipeline = NULL;

    TBool protocolMatch = EFalse;

    TContainerType srcContainerType = EUnknownContainer;

    TContainerType destContainerType = EUnknownContainer;

    //Get resources from the current upnp item

    RUPnPElementsArray resources;

    CleanupClosePushL( resources );

    UPnPItemUtility::GetResElements( aUpnpItem, resources );

    TInt resourcesCount = resources.Count();

    if ( resourcesCount == 0 )

        {

        User::Leave( KErrNotFound );

        }    

    //Check if suitable source container is found from 1st resource

    const CUpnpAttribute& originalProtocolInfo = 

            UPnPItemUtility::FindAttributeByNameL( 

            *resources[0], KProtocolInfo ); 

    if( originalProtocolInfo.Value().Find( KMp4MimeType ) )

        {

        srcContainerType = EMp4Container; 

        }

    else

        {

        User::Leave( KErrNotSupported );

        }        

    //Loop through all protocol infos from renderer and try to find suitable        

    TInt rendererProtocolInfoCount = aRendererProtocolInfos.Count(); 

    for( TInt i = 0; i < rendererProtocolInfoCount && !protocolMatch; i++ )

        {

        for( TInt j = 0; j < resourcesCount && !protocolMatch; j++ )

            {

            const TDesC8& protocolInfo = 

            UPnPItemUtility::FindAttributeByNameL( 

                    *resources[j], KProtocolInfo ).Value();        

            const TDesC8& rendererProtocolInfo = 

            aRendererProtocolInfos.MdcaPoint(i);

            if( rendererProtocolInfo.Find( protocolInfo ) != KErrNotFound )

                {                                

                protocolMatch = ETrue;

                //breaks both 'for' loops here    

                }

            //Check if protocol info is supported 

            if( destContainerType == EUnknownContainer &&

                ( rendererProtocolInfo.Find( 

                      KTsProtocolInfoIdentifier ) != KErrNotFound || 

                  rendererProtocolInfo.Find(

                      KAllMpegMimeTypes ) != KErrNotFound ) ) 

                {

                destContainerType = ETsContainer; 

                }

            //TODO: add here other supported containers (muxers) as well

            }        

        }

    if( !protocolMatch )

        {               

        HBufC8* filePath = PathToLinuxSyntaxL( resources[0]->FilePath() );     

        CleanupStack::PushL( filePath );            

        pipeline = GeneratePipelineL( *filePath, destContainerType );        

        CleanupStack::PopAndDestroy( filePath );                

        }

    CleanupStack::PopAndDestroy( &resources );

    return pipeline;

    }

void CUpnpTranscodeHelper::ReplaceResourceL( CUpnpItem& aUpnpItem, 

                                             const TDesC8& aProtocolInfo )

    {

    RUPnPElementsArray& elements = const_cast<RUPnPElementsArray&>(

                    aUpnpItem.GetElements());

    for( TInt resIndex(0); resIndex < elements.Count(); ++resIndex )

        {

        if( elements[resIndex]->Name() == KRes )

            {

            HBufC* tmp = HBufC::NewLC( 

                    elements[resIndex]->FilePath().Length() +

                    KTranscodedFlag().Length() );

            tmp->Des().Append( elements[resIndex]->FilePath() );

            tmp->Des().Append( KTranscodedFlag() );

            elements.Remove( resIndex );

            aUpnpItem.AddResourceL( *tmp, aProtocolInfo );

            CleanupStack::PopAndDestroy( tmp );

            break;

            }

        }

    }

void CUpnpTranscodeHelper::TranscodeL( const TDesC8& aPipeline )

    {

    __FUNC_LOG;

    //iGstWrapper->StartL( aPipeline ); 

    iGstWrapper->SetPipelineL( aPipeline );

    //should we wait here until we get pipeline playing state notification

    //or error ;)

    }

void CUpnpTranscodeHelper::AddValidResElementL( 

        CUpnpItem& aUpnpItem, const TDesC8& aPipeline, 

        const CDesC8Array& aRendererProtocolInfos )

    {

    __FUNC_LOG;

    TBool suitableFound = EFalse;

    const TDesC8* protocolInfoIdentifier = NULL;

    //TODO: Add also other supported containers (muxers)

    if( aPipeline.Find( KMpegTsMux ) != KErrNotFound || 

        aPipeline.Find( KFFMuxMpegTs ) != KErrNotFound )        

        {

        protocolInfoIdentifier = &KTsProtocolInfoIdentifier(); 

        }

    else

        {

        User::Leave( KErrNotSupported );

        }

    TInt rendererProtocolInfoCount = aRendererProtocolInfos.Count();

    if( rendererProtocolInfoCount == 0 )

        {

        User::Leave(KErrNotFound);

        }

    //Get resources from the current upnp item

    RUPnPElementsArray resources;

    CleanupClosePushL( resources );

    UPnPItemUtility::GetResElements( aUpnpItem, resources );

    TInt resourcesCount = resources.Count();

    if ( resourcesCount == 0 )

        {

        User::Leave( KErrNotFound );

        }  

    for( TInt i = 0; i < rendererProtocolInfoCount && !suitableFound; i++ )

        {           

        TPtrC8 rendererProtocolInfo = aRendererProtocolInfos.MdcaPoint(i);

        if( rendererProtocolInfo.Find( *protocolInfoIdentifier ) )

            {

            //TODO: Add only suitable ones -- now adds all protocol infos

            //      from renderer, which contains _TS_ sub-string

            const TDesC& originalFilePath = resources[0]->FilePath();

            HBufC* transcodedFilePath = HBufC::NewL( 

                    originalFilePath.Length() + KTranscodedFlag().Length() );

            CleanupStack::PushL( transcodedFilePath );

            transcodedFilePath->Des().Append( originalFilePath );

            transcodedFilePath->Des().Append( KTranscodedFlag );

            aUpnpItem.AddResourceL( *transcodedFilePath, 

                    rendererProtocolInfo );

            CleanupStack::PopAndDestroy( transcodedFilePath );

            suitableFound = ETrue;

            }                

        }

    CleanupStack::PopAndDestroy( &resources );

    if( !suitableFound )

        {

        User::Leave( KErrNotFound );

        }    

    else

        {

        // delete orig.

        RUPnPElementsArray& elements = const_cast<RUPnPElementsArray&>(

                aUpnpItem.GetElements());

        for( TInt resIndex(0); resIndex < elements.Count(); ++resIndex )

            {

            if( elements[resIndex]->Name() == KRes )

                {

                elements.Remove(resIndex);

                break;

                }

            }

        }

    }

CUpnpTranscodeHelper::CUpnpTranscodeHelper()

    {

    __FUNC_LOG;    

    }

void CUpnpTranscodeHelper::ConstructL()

    {

    __FUNC_LOG;    

    iGstWrapper = CUpnpGstWrapper::GetInstanceL();    

    iGstWrapper->SetObserverL( *this );

    User::LeaveIfError( iFs.Connect() );

    }

HBufC8* CUpnpTranscodeHelper::GeneratePipelineL( 

        const TDesC8& aOriginalFilePath, 

        TContainerType aDestContainerType )

    {    

    __FUNC_LOG;

    if( aDestContainerType == EUnknownContainer )

        {

        User::Leave( KErrNotSupported );

        }    

    HBufC8* pipeline = NULL;     

    switch( aDestContainerType )

        {

        case ETsContainer:

            {

            //TODO ??

            pipeline = HBufC8::NewL( KDefaultPipelineFmt().Length() - 

                    KLocationFmtTagLen + aOriginalFilePath.Length() );            

            pipeline->Des().AppendFormat( KDefaultPipelineFmt, 

                    &aOriginalFilePath );

            break;

            }

        default:

            {

            __ASSERT_ALWAYS( 0, User::Invariant() );

            }

        }

    return pipeline; 

    }

HBufC8* CUpnpTranscodeHelper::PathToLinuxSyntaxL( 

        const TDesC& aOriginalPath )

    {

    __FUNC_LOG;

    HBufC8* newFilePath = UpnpString::FromUnicodeL( aOriginalPath );

    TInt index = 0;

    while( index >= 0 )

        {

        index = newFilePath->Find( KSymbianDirDelimiter );

        if( index >= 0 )

            {

            newFilePath->Des().Replace( index, 

                    KSymbianDirDelimiter().Length(), KLinuxDirDelimiter );

            }

        }    

    return newFilePath;

    }

void CUpnpTranscodeHelper::HandleGstEvent( Gst::TEvent aEvent )

    {

    __FUNC_LOG;

    if( aEvent == Gst::EError )

        {

        __LOG1( "CUpnpTranscodeHelper::HandleGstEvent ErrorMsg: %S",

                iGstWrapper->ErrorMsg() );

        __ASSERT( EFalse, __FILE__, __LINE__ );

        }

    }

// end of file