/*

* 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 "XAAdaptationContextBase.h"

#include "XAAdaptation.h"

#include "XAObjectItf.h"

#include "XACameraDevice.h"

#include "XARadioDevice.h"

#include "XAOutputMix.h"

#include "XAStaticCapsAdaptation.h"

#include "XAMediaPlayerAdaptCtx.h"

extern XAboolean cameraRealized;

extern XACameraAdaptationCtx_* cameraCtx;

/*

 * XAAdaptationBaseCtx* XAAdaptationBase_Create()

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

 * Reserves memory for base context and initializes GStreamer FW.

 */

XAresult XAAdaptationBase_Init( XAAdaptationBaseCtx* pSelf, XAuint32 ctxId )

{

    DEBUG_API("->XAAdaptationBase_Init");

    if ( pSelf )

    {

        GError* gerror = 0;

		pSelf->pipeSrcThr = NULL;

		pSelf->pipeSinkThr = NULL;

        /* Set context id */

        pSelf->ctxId = ctxId;

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

        pSelf->busCb = XAAdaptationBase_GstBusCb;

        // VASU MOD BEGINS

        pSelf->cond_mutx_inited = XA_BOOLEAN_FALSE;

        // VASU MOD ENDS

        pSelf->evtHdlrs = g_array_new (FALSE, FALSE, sizeof (XAAdaptEvtHdlr));

        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 Adaptation Base Context.")

        return XA_RESULT_PARAMETER_INVALID;

    }

    DEBUG_API("<-XAAdaptationBase_Init");

    return XA_RESULT_SUCCESS;

}

/*

 * XAresult XAAdaptationBase_PostInit()

 * 2nd phase initialization for Adaptation Base.

 */

XAresult XAAdaptationBase_PostInit( XAAdaptationBaseCtx* ctx )

{

    XAresult ret = XA_RESULT_SUCCESS;

    DEBUG_API("->XAAdaptationBase_PostInit");

    // VASU MOD BEGINS

    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("<-XAAdaptationBase_PostInit");

    return ret;

}

/*

 * void XAAdaptationBase_Free( XAAdaptationBaseCtx* ctx )

 * Frees all Base context variables .

 */

void XAAdaptationBase_Free( XAAdaptationBaseCtx* ctx )

{

	GstElement* fakesink = NULL;

    DEBUG_API("->XAAdaptationBase_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));

    XAAdaptationBase_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

    DEBUG_API("<-XAAdaptationBase_Free");

}

/*

 * XAresult XAAdaptationBase_AddEventHandler

 * Adds event handler for certain event types.

 */

XAresult XAAdaptationBase_AddEventHandler( XAAdaptationBaseCtx* ctx, xaAdaptEventHandler evtHandler,

                                    XAuint32 evtTypes, void *pHandlerCtx )

{

    XAuint32 i;

    XAAdaptEvtHdlr tmp;

    DEBUG_API("->XAAdaptationBase_AddEventHandler");

    if(!ctx)

    {

        DEBUG_ERR("no context");

        return XA_RESULT_PARAMETER_INVALID;

    }

    for(i=0; i<ctx->evtHdlrs->len; i++)

    {

        if( (g_array_index(ctx->evtHdlrs, XAAdaptEvtHdlr, i)).handlerfunc == evtHandler )

        {

            return XA_RESULT_PARAMETER_INVALID;

        }

    }

    tmp.handlerfunc = evtHandler;

    tmp.handlercontext = pHandlerCtx;

    tmp.eventtypes = evtTypes;

    g_array_append_val(ctx->evtHdlrs, tmp);

    DEBUG_API("<-XAAdaptationBase_AddEventHandler");

    return XA_RESULT_SUCCESS;

}

/*

 * XAresult XAAdaptationBase_RemoveEventHandler

 * Removes event handler for certain event types.

 */

XAresult XAAdaptationBase_RemoveEventHandler( XAAdaptationBaseCtx* ctx, xaAdaptEventHandler evtHandler)

{

    XAuint32 i;

    DEBUG_API("->XAAdaptationBase_RemoveEventHandler");

    if(!ctx)

    {

        DEBUG_ERR("no context");

        return XA_RESULT_PARAMETER_INVALID;

    }

    for(i=0; i<ctx->evtHdlrs->len; i++)

    {

        if( (g_array_index(ctx->evtHdlrs, XAAdaptEvtHdlr, i)).handlerfunc == evtHandler )

        {

            g_array_remove_index(ctx->evtHdlrs, i);

            return XA_RESULT_SUCCESS;

        }

    }

    DEBUG_API("<-XAAdaptationBase_RemoveEventHandler");

    /*did not find, return error*/

    return XA_RESULT_PARAMETER_INVALID;

}

/*

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

 * Default Gst-bus message handler (Callback)

 */

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

{

    GError *error;

    gchar *debug;

    DEBUG_API("->XAAdaptationBase_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("<-XAAdaptationBase_GstBusCb");

    return TRUE;

}

XAresult XAAdaptationBase_InitGstListener(XAAdaptationBaseCtx* ctx)

{

    int ret;

    DEBUG_API("->XAAdaptationBase_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, (XAAdaptationBase_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("<-XAAdaptationBase_InitGstListener");

    return XA_RESULT_SUCCESS;

}

void * XAAdaptationBase_LaunchGstListener(void* args)

{

    XAAdaptationBaseCtx* ctx = (XAAdaptationBaseCtx*)args;

    DEBUG_API("->XAAdaptationBase_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("<-XAAdaptationBase_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("<-XAAdaptationBase_LaunchGstListener");

        pthread_exit(NULL);

    }

}

void XAAdaptationBase_StopGstListener(XAAdaptationBaseCtx* ctx)

{

    DEBUG_API("->XAAdaptationBase_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("<-XAAdaptationBase_StopGstListener");

}

void XAAdaptationBase_SendAdaptEvents(XAAdaptationBaseCtx* ctx, XAAdaptEvent* event)

{

    XAuint32 i;

    XAAdaptEvtHdlr* tmp;

    for(i=0; i<ctx->evtHdlrs->len; i++)

    {

        tmp = &g_array_index(ctx->evtHdlrs, XAAdaptEvtHdlr, i);

        if( tmp->eventtypes & event->eventtype )

        {

            (tmp->handlerfunc)(tmp->handlercontext, event);

        }

    }

}

/*

 * ASynchronous operation managing

 **/

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

 */

void XAAdaptationBase_PrepareAsyncWait(XAAdaptationBaseCtx* ctx)

{

    DEBUG_API("->XAAdaptationBase_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("<-XAAdaptationBase_PrepareAsyncWait");

}

void XAAdaptationBase_StartAsyncWait(XAAdaptationBaseCtx* ctx)

{

    DEBUG_API("->XAAdaptationBase_StartAsyncWait");

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

    ctx->asynctimer = g_timeout_add(XA_ADAPT_ASYNC_TIMEOUT,

                                    XAAdaptationBase_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("<-XAAdaptationBase_StartAsyncWait");

}

/* async operation timeout callback*/

gboolean XAAdaptationBase_CancelAsyncWait(gpointer ctx)

{

    XAAdaptationBaseCtx* bCtx = (XAAdaptationBaseCtx*)ctx;

    DEBUG_API("->XAAdaptationBase_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("<-XAAdaptationBase_CancelAsyncWait");

    /* return false to remove timer */

    return FALSE;

}

void XAAdaptationBase_CompleteAsyncWait(XAAdaptationBaseCtx* ctx)

{

    DEBUG_API("->XAAdaptationBase_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("<-XAAdaptationBase_CompleteAsyncWait");

}

XAresult XAAdaptationBase_SetCPConfiguration(XAAdaptationBaseCtx* ctx, XAConfigExtensionCpKey configValue)

{

    XAresult res = XA_RESULT_SUCCESS;

    DEBUG_API("-> XAAdaptationBase_SetConfiguration");

    if( ctx )

    {

		if ( configValue == XA_READ )

		{

			ctx->pipeSrcThrCtx.cpConfig = configValue;

			res = XA_RESULT_SUCCESS;

		}

		else if ( configValue == XA_READBUFFER )

		{

		    ctx->pipeSrcThrCtx.cpConfig = configValue;

			res = XA_RESULT_SUCCESS;

		}

		else if ( configValue == XA_WRITE )

        {

            ctx->pipeSinkThrCtx.cpConfig = configValue;

            res = XA_RESULT_SUCCESS;

        }

		else if ( configValue == XA_WRITEBUFFER )

        {

            ctx->pipeSinkThrCtx.cpConfig = configValue;

            res = XA_RESULT_SUCCESS;

        }

    }

    else

    {

        res = XA_RESULT_PARAMETER_INVALID;

    }

    DEBUG_API("-> XAAdaptationBase_SetConfiguration");

    return res;

}

/**

 * GstElement* XAAdaptationBase_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* XAAdaptationBase_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("->XAAdaptationBase_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));