/*

 * 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: Base GStreamer Adaptation Source

 *

 */

#include <assert.h>

#include <string.h>

#include <gst/gst.h>

#include <gst/gstbuffer.h>

#include "xaobjectitf.h"

#include "xaradiodevice.h"

#include <stdlib.h>

#include "xaadaptationgst.h"

/*

 * 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);

//cross check

            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;

#ifdef OMAX_CAMERABIN

    XACameraDeviceImpl* cameraDevice = NULL;

    XAObjectItfImpl* pObj = NULL;

#endif

    XARadioDeviceImpl* radioDevice = 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

							// no need to set num-buffers		

                            /*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;

                    }

#ifdef OMAX_CAMERABIN

                    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;