/*

* Copyright (c) 2010 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 GStreamer wrapper

*

*/

// INCLUDES

#include <bautils.h>

#include <gst/app/gstappsink.h>

#include <gst/app/gstappsink.h>

#include <gst/app/gstappbuffer.h>

#include <gst/gst.h>

#include <gst/gstinfo.h>

#include "upnpgstwrapper.h"

_LIT( KComponentLogfile, "upnpgstwrapper.txt");

#include "upnplog.h"

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

_LIT( KAlreadyInUseErrorMsg, "GST already in use (call Stop first)" );

_LIT( KUnknownErrorErrorMsg, "Unknown error" );

_LIT( KOutOfMemoryErrorMsg, "Out of memory" );

const char* const KMimeTypeVideo = "video/";

const char* const KMimeTypeAudio = "audio/";

const char* const KDemuxerName = "demux";

class CUpnpGstWrapperPimpl : CBase

    {

public: // construction / destruction

    /**

     * Static NewL

     *

     * @param none

     * @return instance to CUpnpGstWrapperPimpl

     */

    static CUpnpGstWrapperPimpl* NewL();    

    /**

     * Destructor

     */

    ~CUpnpGstWrapperPimpl();

private:

    /**

     * Constructor

     */

    CUpnpGstWrapperPimpl();

    /**

     * 2nd phrase Constructor

     */

    void ConstructL();

public:

    inline void SetPipeline( GstElement* aPipeline );

    inline GstElement* Pipeline(); 

    inline void SetDemuxer( GstElement* aDemuxer );

    inline GstElement* Demuxer();

    inline void InitAppSinkL();

    inline TBool PullBufferL( TPtr8& aPointer,TInt aMaxBytesLength, RBuf8* aBuf );

    inline TInt TranscodedBytes();

public: //callbacks

    /**

     * A function to receive any message occured within the pipeline

     * Note that the function will be called in the same thread context as

     * the posting object.

     * 

     * @param GstBus* a bus to create the watch for

     * @param GstMessage* a message created within the pipeline

     * @param gponter the user data that has been given, 

     *        when registering the handler

     * @return GstBusSyncReply indicates whether the message is also added

     *         into async queue (after this callback) or dropped

     */

    static GstBusSyncReply SyncBusCallback( GstBus* aBus, GstMessage* aMsg, 

            gpointer aData );

    /**

     * A function to receive callback from demuxer whenever source pad is

     * added into it

     * 

     * @param GstElement* an element (demuxer) where the source pad was added 

     * @param GstPad* a souce pad that was added

     * @param gponter the user data that has been given, 

     *        when registering the handler

     */

    static void DemuxPadAddedCallback( GstElement* aElement, GstPad* aPad,

            gpointer aData );

    /**

     * Internal log handler.

     * Implements GStreamer's log handler callback.

     * Ouputs GStreamer debug traces if DEBUG_ENABLE flag is enabled in

     * GStreamer.

     */    

    static void LogCallback( GstDebugCategory *category, GstDebugLevel level,

            const gchar *file, const gchar *function, gint line, 

            GObject *object, GstDebugMessage *message, gpointer data );

private:

    GstElement*                            iPipeline;

    GstElement*                            iDemuxer;        

    TInt                                   iBytesOffSet;

    GstElement*                            iAppsink;

    GstElement*                            iElement;

    GstBuffer*                             iGstBuffer;

    };

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

// CUpnpGstWrapperPimpl::NewL

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

CUpnpGstWrapperPimpl* CUpnpGstWrapperPimpl::NewL()

    {    

    __FUNC_LOG;

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

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );  

    return self;

    }

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

// CUpnpGstWrapperPimpl::~CUpnpGstWrapperPimpl

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

CUpnpGstWrapperPimpl::~CUpnpGstWrapperPimpl()

    {  

    __FUNC_LOG;

    }

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

// CUpnpGstWrapperPimpl::CUpnpGstWrapperPimpl

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

CUpnpGstWrapperPimpl::CUpnpGstWrapperPimpl()

    {    

    __FUNC_LOG;

    }

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

// CUpnpGstWrapperPimpl::ConstructL

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

void CUpnpGstWrapperPimpl::ConstructL()

    {    

    __FUNC_LOG;

    }

void CUpnpGstWrapperPimpl::SetPipeline( GstElement* aPipeline )

    {

    __FUNC_LOG;

    iPipeline = aPipeline;

    }

GstElement* CUpnpGstWrapperPimpl::Pipeline()

    {

    __FUNC_LOG;

    return iPipeline;

    }

void CUpnpGstWrapperPimpl::SetDemuxer( GstElement* aDemuxer )

    {    

    __FUNC_LOG;

    iDemuxer = aDemuxer;

    }

GstElement* CUpnpGstWrapperPimpl::Demuxer()

    {

    __FUNC_LOG;

    return iDemuxer;

    }

void CUpnpGstWrapperPimpl::InitAppSinkL()

    {

    iAppsink = gst_bin_get_by_name (

            GST_BIN ( iPipeline ), "sinkbuffer");

    if( !iAppsink )

        User::Leave( KErrNotFound);

    g_object_set (

             G_OBJECT (iAppsink), "emit-signals", TRUE, "sync", FALSE, NULL);       

    gst_object_unref (iAppsink); 

    }

TBool CUpnpGstWrapperPimpl::PullBufferL( TPtr8& aPointer,TInt aMaxBytesLength, RBuf8* aBuf )

    {

    guint size;     

    if( iGstBuffer )

        {

        delete [] GST_BUFFER_DATA(iGstBuffer);

        GST_BUFFER_DATA(iGstBuffer) = NULL;

        }

    iGstBuffer = gst_app_sink_pull_buffer( GST_APP_SINK ( iAppsink  ));

    if( iGstBuffer )

        {

        size = GST_BUFFER_SIZE( iGstBuffer );

        iBytesOffSet += size;

        if( aBuf && ( size + aBuf->Length() ) > aBuf->MaxLength() )

            {

            HBufC8* tmp(NULL);

            TInt len(aBuf->Length());

            if( len > 0 )

                {

                tmp = aBuf->AllocLC();

                }

            aBuf->Close();

            aBuf->CreateL(size+len);

            if( tmp )

                {

                aBuf->Append(*tmp);

                CleanupStack::PopAndDestroy(tmp);

                }

            aBuf->Append( (TUint8*)GST_BUFFER_DATA(iGstBuffer),size );

            }

        else

            {                       

            __ASSERT( (aMaxBytesLength >= size), __FILE__, __LINE__ );

            aPointer.Set((TUint8*)GST_BUFFER_DATA(iGstBuffer),size,aMaxBytesLength);

            }

        }

    return ( iGstBuffer ) ? EFalse : ETrue;

    }

TInt CUpnpGstWrapperPimpl::TranscodedBytes()

    {

    return iBytesOffSet;

    }

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

// CUpnpGstWrapperPimpl::SyncBusCallback

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

GstBusSyncReply CUpnpGstWrapperPimpl::SyncBusCallback( GstBus* /*aBus*/, 

        GstMessage* aMsg, gpointer aData )

    {

    __FUNC_LOG;

    GstMessageType messageType = GST_MESSAGE_TYPE( aMsg );    

    if( messageType == GST_MESSAGE_EOS ||

        messageType == GST_MESSAGE_ERROR )

        {

        __ASSERT( aData, __FILE__, __LINE__ );      

        CUpnpGstWrapper* parent = static_cast<CUpnpGstWrapper*>( aData );

        Gst::TEvent event = Gst::EUnknown;

        parent->iMutex.Wait();

        switch( messageType ) 

            {

            case GST_MESSAGE_EOS:

                {        

                event = Gst::EEOS;  

                break;

                }

            case GST_MESSAGE_ERROR: 

                {

                GError* err = NULL;

                char* debug;

                gst_message_parse_error( aMsg, &err, &debug );

                g_free( debug );   

                if( err )

                    {

                    TRAP_IGNORE( parent->SetErrorMsg( 

                            parent->ConvertCharToDescL(

                            err->message ) ) );

                    g_error_free( err );

                    err = NULL;

                    }

                event = Gst::EError;        

                break;

                }

            default:

                {

                __ASSERT( EFalse, __FILE__, __LINE__ );

                }

            }

        parent->iEventQueue.Append( event );        

        __ASSERT( parent->IsActive(), __FILE__, __LINE__ );

        if( parent->iStatus == KRequestPending )

            {

            TRequestStatus* status = &parent->iStatus;

            RThread thread;

            TInt err = thread.Open( parent->iClientThreadId );

            __ASSERT( !err, __FILE__, __LINE__ );                        

            thread.RequestComplete( status, KErrNone );            

            thread.Close();

            }

        parent->iMutex.Signal();

        gst_message_unref( aMsg );

        }

    return GST_BUS_DROP; //do not add anything into async queue

    }

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

// CUpnpGstWrapperPimpl::DemuxPadAddedCallback

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

void CUpnpGstWrapperPimpl::DemuxPadAddedCallback( GstElement* /*aElement*/, 

        GstPad* aPad, gpointer aData )

    {

    __FUNC_LOG;    

    __ASSERT( aData, __FILE__, __LINE__ );       

    CUpnpGstWrapper* parent = static_cast<CUpnpGstWrapper*>( aData );

    GstCaps* caps = gst_pad_get_caps( aPad );

    char* str = gst_caps_to_string( caps );  

    Gst::TEvent event = Gst::EUnknown;

    parent->iMutex.Wait();

    if( g_str_has_prefix( str, KMimeTypeVideo ) )

        {

        delete parent->iVideoInfo; parent->iVideoInfo = NULL;

        TRAPD( err, parent->iVideoInfo = parent->ConvertCharToDescL( str ) );

        if( !err )

            {

            event = Gst::EVideoStreamInfoAvailable;

            }

        else

            {            

            event = Gst::EError;

            TRAP_IGNORE( parent->SetErrorMsgL( KOutOfMemoryErrorMsg ) );

            }

        }

    else if( g_str_has_prefix( str, KMimeTypeAudio ) )

        {

        delete parent->iAudioInfo; parent->iAudioInfo = NULL;

        TRAPD( err, parent->iAudioInfo = parent->ConvertCharToDescL( str ) );

        if( !err )

            {

            event = Gst::EAudioStreamInfoAvailable;

            }

        else

            {            

            event = Gst::EError;

            TRAP_IGNORE( parent->SetErrorMsgL( KOutOfMemoryErrorMsg ) );

            }        

        }

    else

        {

        __ASSERT( EFalse, __FILE__, __LINE__ );

        }

    parent->iEventQueue.Append( event );        

    __ASSERT( parent->IsActive(), __FILE__, __LINE__ );

    if( parent->iStatus == KRequestPending )

        {

        TRequestStatus* status = &parent->iStatus;

        RThread thread;

        TInt err = thread.Open( parent->iClientThreadId );

        __ASSERT( !err, __FILE__, __LINE__ );                        

        thread.RequestComplete( status, KErrNone );            

        thread.Close();

        }

    parent->iMutex.Signal();

    g_free(str);

    }

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

// CUpnpGstWrapperPimpl::LogCallback

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

void CUpnpGstWrapperPimpl::LogCallback( GstDebugCategory* category, 

        GstDebugLevel level, const char* file, const char* function, 

        gint line, GObject* /*object*/, GstDebugMessage* message, 

        gpointer /*data*/ )

    {  

    if (level > gst_debug_category_get_threshold (category))

        {

        return;    

        }    

#ifndef __UPNP_LOG_FILE    

    const char* const KGstLogFmt = "%s %20s %s:%d:%s %s\n";

    RDebug::Printf( KGstLogFmt,

            gst_debug_level_get_name (level),

            gst_debug_category_get_name (category), file, line, function,

            gst_debug_message_get (message) );

#else

    _LIT8( KGstLogFmtDesc, "%s %20s %s:%d:%s %s\n" );

    RFileLogger::WriteFormat( KLogDir, KComponentLogfile,

            EFileLoggingModeAppend, KGstLogFmtDesc, 

            gst_debug_level_get_name (level),

            gst_debug_category_get_name (category), file, line, function,

            gst_debug_message_get (message) );

#endif    

    }

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

// CUpnpGstWrapper::GetInstanceL

// See upnpgstwrapper.h

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

EXPORT_C CUpnpGstWrapper* CUpnpGstWrapper::GetInstanceL()

    {

    CUpnpGstWrapper* singleton = static_cast<CUpnpGstWrapper*>( Dll::Tls() );

    if ( singleton == 0 )

        {

        // singleton must be created first

        singleton = new ( ELeave ) CUpnpGstWrapper();

        CleanupStack::PushL( singleton );

        singleton->ConstructL();

        User::LeaveIfError( Dll::SetTls( singleton ) );

        CleanupStack::Pop( singleton );

        }    

    singleton->iSingletonRefCount++;

    return singleton;

    }

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

// CUpnpGstWrapper::Close

// See upnpgstwrapper.h

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

EXPORT_C void CUpnpGstWrapper::Close()

    {

    if(--iSingletonRefCount == 0)

        {

        Dll::FreeTls();

        delete this;

        }

    }

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

// CUpnpGstWrapper::~CUpnpGstWrapper

// See upnpgstwrapper.h

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

EXPORT_C CUpnpGstWrapper::~CUpnpGstWrapper()

    {    

    __FUNC_LOG;

    Stop();

    Cancel();

    gst_deinit();

    delete iErrorMsg;

    delete iVideoInfo;

    delete iAudioInfo;

    iEventQueue.Close();    

    iMutex.Close();

    iObservers.Close();

    delete iPimpl;

    delete iPipeline;

    }

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

// CUpnpGstWrapper::CUpnpGstWrapper

// See upnpgstwrapper.h

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

CUpnpGstWrapper::CUpnpGstWrapper()

    : CActive( EPriorityStandard )

    , iDuration( KErrNotFound )

    {    

    __FUNC_LOG;    

    CActiveScheduler::Add( this );

    }

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

// CUpnpGstWrapper::ConstructL

// See upnpgstwrapper.h

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

void CUpnpGstWrapper::ConstructL()

    {

    __FUNC_LOG;      

    iPimpl = CUpnpGstWrapperPimpl::NewL();

    iMutex.CreateLocal();

    RThread thread;