/*

* 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: 

*

*/

#include <assert.h>

#include <string.h>

#include "gst/gst.h"

#include "gst/gstbuffer.h"

#include "gst/app/gstappsrc.h"

#include "xaobjectitf.h"

#include "xacameradevice.h"

#include "xaradiodevice.h"

#include "xaoutputmix.h"

#include "xamediaplayeradaptctx.h"

#include "xacameraadaptctx.h"

#include <stdlib.h>

extern XAboolean cameraRealized;

extern XACameraAdaptationCtx_* cameraCtx;

/*

 * XAAdaptationGstCtx* XAAdaptationGst_Create()

 * 1st phase initialization function for Adaptation Base context structure.

 * Reserves memory for base context and initializes GStreamer FW.

 */

XAresult XAAdaptationGst_Init( XAAdaptationGstCtx* pSelf, XAuint32 ctxId )

{

    DEBUG_API("->XAAdaptationGst_Init");

    if ( pSelf )

    {

        if(XAAdaptationBase_Init(&(pSelf->baseObj), ctxId) != XA_RESULT_SUCCESS)

            {

            DEBUG_ERR("Failed to init base context!!!");

            free(pSelf);

            pSelf = NULL;

            }

        else

            {

            GError* gerror = 0;

    /*         Add default handler for Gst-bus messages */

            pSelf->busCb = XAAdaptationGst_GstBusCb;

            // VASU MOD BEGINS

            pSelf->cond_mutx_inited = XA_BOOLEAN_FALSE;

            // VASU MOD ENDS

            sem_init(&(pSelf->semAsyncWait),0,0);

            if ( !gst_init_check( NULL, NULL, &gerror ) )

                {

                    DEBUG_ERR("Gst Initalization failure.");

                    return XA_RESULT_INTERNAL_ERROR;

                }

            }

    }

    else

    {

        DEBUG_ERR("Invalid Gst Base Context.")

        return XA_RESULT_PARAMETER_INVALID;

    }

    DEBUG_API("<-XAAdaptationGst_Init");

    return XA_RESULT_SUCCESS;

}

/*

 * XAresult XAAdaptationGst_PostInit()

 * 2nd phase initialization for Adaptation Base.

 */

XAresult XAAdaptationGst_PostInit( XAAdaptationGstCtx* ctx )

{

    XAresult ret = XA_RESULT_SUCCESS;

    DEBUG_API("->XAAdaptationGst_PostInit");

    // VASU MOD BEGINS

    XAAdaptationBase_PostInit(&ctx->baseObj);

    ctx->thread_launched = XA_BOOLEAN_FALSE;

    pthread_mutex_init(&(ctx->ds_mutex), NULL);

    pthread_cond_init(&(ctx->ds_condition), NULL);

    ctx->cond_mutx_inited = XA_BOOLEAN_TRUE;

    // VASU MOD ENDS

    DEBUG_API("<-XAAdaptationGst_PostInit");

    return ret;

}

/*

 * void XAAdaptationGst_Free( XAAdaptationGstCtx* ctx )

 * Frees all Base context variables .

 */

void XAAdaptationGst_Free( XAAdaptationGstCtx* ctx )

{

	GstElement* fakesink = NULL;

    DEBUG_API("->XAAdaptationGst_Free");

    if ( ctx->bin )

    {

    	fakesink = gst_bin_get_by_name(GST_BIN(ctx->bin), "fakesink");

		if ( fakesink )

		{

			gst_element_set_state( GST_ELEMENT(fakesink), GST_STATE_NULL);

			gst_object_unref(fakesink);

		}

        if ( gst_element_set_state(GST_ELEMENT(ctx->bin), GST_STATE_NULL )!=GST_STATE_CHANGE_SUCCESS )

        {   /*not much we can do*/

            DEBUG_ERR("WARNING: Failed to change to NULL state before deletion!!")

        }

    }

    if(ctx->asynctimer)

    {   /*cancel timer*/

        g_source_remove(ctx->asynctimer);

    }

    sem_post(&(ctx->semAsyncWait));

    sem_destroy(&(ctx->semAsyncWait));

    XAAdaptationGst_StopGstListener(ctx);

    if ( ctx->bin )

    {

        gst_object_unref(ctx->bin);

    }

    //g_array_free(ctx->evtHdlrs, TRUE);

    // VASU MOD BEGINS

    if (ctx->cond_mutx_inited == XA_BOOLEAN_TRUE)

        {

        ctx->thread_launched = XA_BOOLEAN_FALSE;

        pthread_mutex_destroy(&(ctx->ds_mutex));

        pthread_cond_destroy(&(ctx->ds_condition));

        ctx->cond_mutx_inited = XA_BOOLEAN_FALSE;

        }

    // VASU MOD ENDS

    XAAdaptationBase_Free(&ctx->baseObj);

    DEBUG_API("<-XAAdaptationGst_Free");

}

/*

 * gboolean XAAdaptationBase_GstBusCb( GstBus *bus, GstMessage *message, gpointer data )

 * Default Gst-bus message handler (Callback)

 */

gboolean XAAdaptationGst_GstBusCb( GstBus *bus, GstMessage *message, gpointer data )

{

    GError *error;

    gchar *debug;

    DEBUG_API("->XAAdaptationGst_GstBusCb");

    DEBUG_INFO_A2("Received Gst callback \"%s\" from \"%s\"",

                    GST_MESSAGE_TYPE_NAME(message),

                    GST_OBJECT_NAME(GST_MESSAGE_SRC(message)));

    switch( GST_MESSAGE_TYPE(message))

    {

        case GST_MESSAGE_ERROR:

            gst_message_parse_error( message, &error, &debug );

            DEBUG_INFO_A1("%s", debug);

            break;

        case GST_MESSAGE_EOS:

            break;

        case GST_MESSAGE_UNKNOWN:

            break;

        case GST_MESSAGE_WARNING:

            break;

        case GST_MESSAGE_INFO:

            break;

        case GST_MESSAGE_TAG:

            break;

        case GST_MESSAGE_BUFFERING:

            break;

        case GST_MESSAGE_STATE_CHANGED:

            break;

        case GST_MESSAGE_STATE_DIRTY:

            break;

        case GST_MESSAGE_STEP_DONE:

            break;

        case GST_MESSAGE_CLOCK_PROVIDE:

            break;

        case GST_MESSAGE_CLOCK_LOST:

            break;

        case GST_MESSAGE_NEW_CLOCK:

            break;

        case GST_MESSAGE_STRUCTURE_CHANGE:

            break;

        case GST_MESSAGE_STREAM_STATUS:

            break;

        case GST_MESSAGE_APPLICATION:

            break;

        case GST_MESSAGE_ELEMENT:

            break;

        case GST_MESSAGE_SEGMENT_START:

            break;

        case GST_MESSAGE_SEGMENT_DONE:

            break;

        case GST_MESSAGE_DURATION:

            break;

        case GST_MESSAGE_LATENCY:

            break;

        case GST_MESSAGE_ASYNC_START:

            break;

        case GST_MESSAGE_ASYNC_DONE:

            break;

        case GST_MESSAGE_ANY:

            break;

        default:

            DEBUG_INFO("Unhandled Gst-Bus message");

            break;

    }

    DEBUG_API("<-XAAdaptationGst_GstBusCb");

    return TRUE;

}

XAresult XAAdaptationGst_InitGstListener(XAAdaptationGstCtx* ctx)

{

    int ret;

    DEBUG_API("->XAAdaptationGst_InitGstListener");

    if ( ctx->bin )

    {

        ctx->bus = gst_pipeline_get_bus( GST_PIPELINE( ctx->bin ));

    }

    if( !ctx->bus )

    {

        DEBUG_ERR("could not get gst bus!")

        return XA_RESULT_INTERNAL_ERROR;

    }

    ret = pthread_create(&(ctx->busloopThr), NULL, (XAAdaptationGst_LaunchGstListener),(void*)ctx);

    // VASU MOD BEGINS

    if ( ctx->thread_launched == XA_BOOLEAN_FALSE )

    {

        // Wait until the thread is created

        pthread_mutex_lock(&(ctx->ds_mutex));

        pthread_cond_wait(&(ctx->ds_condition), &(ctx->ds_mutex));

        pthread_mutex_unlock(&(ctx->ds_mutex));

        // VASU MOD ENDS

    }

    if(ret)

    {

        DEBUG_ERR_A1("could not create thread!! (%d)",ret)

        return XA_RESULT_INTERNAL_ERROR;

    }

    DEBUG_API("<-XAAdaptationGst_InitGstListener");

    return XA_RESULT_SUCCESS;

}

void * XAAdaptationGst_LaunchGstListener(void* args)

{

    XAAdaptationGstCtx* ctx = (XAAdaptationGstCtx*)args;

    DEBUG_API("->XAAdaptationGst_LaunchGstListener");

    // VASU MOD BEGINS

    // Signal calling thread that this thread creation is completed

    ctx->thread_launched = XA_BOOLEAN_TRUE;

    pthread_mutex_lock(&(ctx->ds_mutex));

    pthread_cond_signal(&(ctx->ds_condition));

    pthread_mutex_unlock(&(ctx->ds_mutex));

    // VASU MOD ENDS

    ctx->busloop = g_main_loop_new( NULL, FALSE );

    if ( !ctx->busloop )

    {

        DEBUG_ERR("Glib main loop failure.")

        DEBUG_API("<-XAAdaptationGst_LaunchGstListener");

        assert(0);

    }

    else

    {

        DEBUG_INFO("Start Glib main loop")

        g_main_loop_run(ctx->busloop);

        DEBUG_INFO("Glib main loop stopped - exiting thread")

        DEBUG_API("<-XAAdaptationGst_LaunchGstListener");

        pthread_exit(NULL);

    }

   return NULL;

}

void XAAdaptationGst_StopGstListener(XAAdaptationGstCtx* ctx)

{

    DEBUG_API("->XAAdaptationGst_StopGstListener");

    if(ctx->busloop)

    {

        g_main_loop_quit (ctx->busloop);

        g_main_loop_unref(ctx->busloop);

    }

    if(ctx->bus)

    {

        gst_object_unref(ctx->bus);

        ctx->bus = NULL;

    }

    DEBUG_API("<-XAAdaptationGst_StopGstListener");

}

/*

 * ASynchronous operation managing

 **/

/* NOTE: This should NOT be called from gst callbacks - danger of deadlock!!

 */

void XAAdaptationGst_PrepareAsyncWait(XAAdaptationGstCtx* ctx)

{

    DEBUG_API("->XAAdaptationGst_PrepareAsyncWait");

    if( ctx->waitingasyncop )

    {   /*wait previous async op*/

        DEBUG_INFO("::WARNING:: previous asynch still ongoing!!!");

        DEBUG_INFO(">>>>  WAIT PREVIOUS");

        sem_wait(&(ctx->semAsyncWait));

        DEBUG_INFO("<<<<  PREVIOUS COMPLETED");

    }

    sem_init(&(ctx->semAsyncWait),0,0);

    ctx->waitingasyncop = XA_BOOLEAN_TRUE;

    DEBUG_API("<-XAAdaptationGst_PrepareAsyncWait");

}

void XAAdaptationGst_StartAsyncWait(XAAdaptationGstCtx* ctx)

{

    DEBUG_API("->XAAdaptationGst_StartAsyncWait");

    /* timeout to try to avoid gst freeze in rollup */

    ctx->asynctimer = g_timeout_add(XA_ADAPT_ASYNC_TIMEOUT,

                                    XAAdaptationGst_CancelAsyncWait, ctx);

    /* check flag once again if callback already happened before wait */

    if(ctx->waitingasyncop)

    {

        DEBUG_INFO(">>>>  ASYNC STARTS");

        sem_wait(&(ctx->semAsyncWait));

        DEBUG_INFO("<<<<  ASYNC COMPLETED");

    }

    else

    {

        DEBUG_INFO("<> async completed already");

    }

    /*cancel timer*/

    if(ctx->asynctimer)

    {

        g_source_remove(ctx->asynctimer);

    }

    ctx->waitingasyncop = XA_BOOLEAN_FALSE;

    DEBUG_API("<-XAAdaptationGst_StartAsyncWait");

}

/* async operation timeout callback*/

gboolean XAAdaptationGst_CancelAsyncWait(gpointer ctx)

{

    XAAdaptationGstCtx* bCtx = (XAAdaptationGstCtx*)ctx;

    DEBUG_API("->XAAdaptationGst_CancelAsyncWait");

    if( bCtx->waitingasyncop )

    {

        DEBUG_ERR_A3("ASYNC TIMED OUT : current %d, gsttarget %d, wanted %d",

                      GST_STATE(bCtx->bin), GST_STATE_TARGET(bCtx->bin), bCtx->binWantedState);

        bCtx->waitingasyncop = XA_BOOLEAN_FALSE;

        sem_post(&(bCtx->semAsyncWait));

    }

    DEBUG_API("<-XAAdaptationGst_CancelAsyncWait");

    /* return false to remove timer */

    return FALSE;

}

void XAAdaptationGst_CompleteAsyncWait(XAAdaptationGstCtx* ctx)

{

    DEBUG_API("->XAAdaptationGst_CompleteAsyncWait");

    if( ctx->waitingasyncop )

    {

        int i;

        ctx->waitingasyncop = XA_BOOLEAN_FALSE;

        sem_getvalue(&(ctx->semAsyncWait),&i);

        DEBUG_INFO_A1("Asynch operation succeeded, sem value %d",i);

        if(i<=0)

        {   /* only post if locked */

            sem_post(&(ctx->semAsyncWait));

        }

        else if(i>0)

        {   /* should not be, reset semaphore */

            sem_init(&(ctx->semAsyncWait),0,0);

        }

    }

    DEBUG_API("<-XAAdaptationGst_CompleteAsyncWait");

}

/**

 * GstElement* XAAdaptationGst_CreateGstSource( XADataSource* xaSrc, const XAchar *name )

 * @param XADataSource* xaSnk - XADataSource defining gst source to create

 * @param const XAchar *name - string for naming the gst element

 * @param XAboolean *isobj - (out param) is source another XA object?

 * @return GstElement* - return newly created gst source element

 * Description: Create gst source element corresponding to XA source structure

 */

GstElement* XAAdaptationGst_CreateGstSource( XADataSource* xaSrc, const char *name, XAboolean *isobj, XAboolean *isPCM, XAboolean *isRawImage  )

{

    XAuint32 locType = 0;

    GstElement* gstSrc = NULL;

    char* fname=NULL;

    XADataLocator_URI* uri = NULL;

    XADataLocator_IODevice* ioDevice = NULL;

    XACameraDeviceImpl* cameraDevice = NULL;

    XARadioDeviceImpl* radioDevice = NULL;

    XAObjectItfImpl* pObj = NULL;

    DEBUG_API("->XAAdaptationGst_CreateGstSource");

    if( !xaSrc || !xaSrc->pLocator || !isobj )

    {

        return NULL;

    }

    *isobj = XA_BOOLEAN_FALSE;

    if( xaSrc && xaSrc->pFormat && *((XAuint32*)(xaSrc->pFormat))==XA_DATAFORMAT_PCM && isPCM )

    {

        *isPCM = XA_BOOLEAN_TRUE;

    }

    if( xaSrc && xaSrc->pFormat && *((XAuint32*)(xaSrc->pFormat))==XA_DATAFORMAT_RAWIMAGE && isRawImage )

    {

        *isRawImage = XA_BOOLEAN_TRUE;

    }

    locType = *((XAuint32*)(xaSrc->pLocator));

    switch ( locType )

    {

        case XA_DATALOCATOR_URI:

            DEBUG_INFO("XA_DATALOCATOR_URI");

            uri = (XADataLocator_URI*)xaSrc->pLocator;

            gstSrc = gst_element_factory_make("filesrc",name);

            if ( uri->URI != NULL )

            {

                DEBUG_INFO_A1("URI: %s", uri->URI);

                if(strncmp((char *)uri->URI, "file:///", 8) == 0)

                    {

                    fname = (char *)&((uri->URI)[8]);

                    }

                else

                    {

                    fname = (char *)uri->URI;

                    }

                DEBUG_INFO_A1("->filesystem path %s", fname);

                g_object_set( G_OBJECT(gstSrc), "location", fname, NULL );

                /*check for pcm - decodebin does not know how to handle raw PCM files */

                if( isPCM && strstr(fname, ".pcm") )

                {

                    DEBUG_INFO("PCM file detected");

                    *isPCM=XA_BOOLEAN_TRUE;

                }

            }

            else

            {

                DEBUG_ERR("No uri specified.");

                return NULL;

            }

            break; /* XA_DATALOCATOR_URI */

        case XA_DATALOCATOR_IODEVICE:

            DEBUG_INFO("XA_DATALOCATOR_IODEVICE");

            ioDevice = (XADataLocator_IODevice*)(xaSrc->pLocator);

            switch ( ioDevice->deviceType )

            {

                case XA_IODEVICE_AUDIOINPUT:

                {

                    DEBUG_INFO("XA_IODEVICE_AUDIOINPUT");

                    DEBUG_INFO_A1("ioDevice->deviceID: %x", ioDevice->deviceID);

                    switch (ioDevice->deviceID )

                    {

                    //case XA_ADAPTID_ALSASRC: //Krishna

                    case XA_ADAPTID_DEVSOUNDSRC:

                        //DEBUG_INFO("alsasrc"); //Krishna

                        DEBUG_INFO("devsoundsrc");

                        gstSrc = gst_element_factory_make("devsoundsrc",name); //Krishna - changed to devsoundsrc

                        g_object_set (G_OBJECT (gstSrc), "num-buffers", 80, NULL);

                        break;

                    case XA_ADAPTID_AUDIOTESTSRC:

                        /*fall through*/

                    default:

                        DEBUG_INFO("audiotestsrc");

                        gstSrc = gst_element_factory_make("audiotestsrc",name);

                        break;

                    }

                    break;

                }

                case XA_IODEVICE_CAMERA:

                {

                    DEBUG_INFO("XA_IODEVICE_CAMERA");

                    if ( ioDevice->device )

                    {   /*source is camera object*/

                        DEBUG_INFO("Use camerabin as source.");

                        /* Get camerabin from source object */

                        pObj = (XAObjectItfImpl*)(*ioDevice->device);

                        cameraDevice = (XACameraDeviceImpl*)(pObj);

                        /*TODO we had to remove this line below since adaptationCtx

                         * was  not a member of structure*/

                        gstSrc = GST_ELEMENT(((XAAdaptationGstCtx*)(cameraDevice->adaptationCtx))->bin);

                        /* refcount increase is needed to keep this not being deleted after use */

                        gst_object_ref(GST_OBJECT(gstSrc));

                        *isobj = XA_BOOLEAN_TRUE;

                    }

                    else

                    {

                        DEBUG_INFO_A1("ioDevice->deviceID: %x", ioDevice->deviceID);

                        switch (ioDevice->deviceID )

                        {

                        case XA_ADAPTID_V4L2SRC:

                            DEBUG_INFO("Camera deviceID: v4l2src ");

                            break;

                        case XA_ADAPTID_VIDEOTESTSRC:

                            DEBUG_INFO("Camera deviceID: videotestsrc");

                            break;

                        default:

                        case XA_DEFAULTDEVICEID_CAMERA:

                            DEBUG_INFO("Camera deviceID:Default");

                            break;

                        }

                        if ( cameraCtx )