/*

#include <assert.h>

#include <string.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.

 */

    DEBUG_API("->XAAdaptationGst_Init");

            {

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

            free(pSelf);

            pSelf = NULL;

            }

        else

            {

            GError* gerror = 0;

            pSelf->busCb = XAAdaptationGst_GstBusCb;

            // VASU MOD BEGINS

            pSelf->cond_mutx_inited = XA_BOOLEAN_FALSE;

            // VASU MOD ENDS

                {

                }

            }

    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 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 .

 */

    DEBUG_API("->XAAdaptationGst_Free");

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

        }

        g_source_remove(ctx->asynctimer);

    sem_post(&(ctx->semAsyncWait));

    sem_destroy(&(ctx->semAsyncWait));

    XAAdaptationGst_StopGstListener(ctx);

        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)

 */

    GError *error;

    gchar *debug;

        case GST_MESSAGE_ERROR:

            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:

            break;

    }

XAresult XAAdaptationGst_InitGstListener(XAAdaptationGstCtx* ctx)

    int ret;

    DEBUG_API("->XAAdaptationGst_InitGstListener");

        DEBUG_ERR("could not get gst bus!")

        return XA_RESULT_INTERNAL_ERROR;

    // VASU MOD BEGINS

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

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

        return XA_RESULT_INTERNAL_ERROR;

    }

void * XAAdaptationGst_LaunchGstListener(void* 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

        DEBUG_API("<-XAAdaptationGst_LaunchGstListener");

        assert(0);

    else

        DEBUG_INFO("Start Glib main loop")

        g_main_loop_run(ctx->busloop);

        DEBUG_API("<-XAAdaptationGst_LaunchGstListener");

        pthread_exit(NULL);

    }

void XAAdaptationGst_StopGstListener(XAAdaptationGstCtx* ctx)

    DEBUG_API("->XAAdaptationGst_StopGstListener");

        g_main_loop_unref(ctx->busloop);

        gst_object_unref(ctx->bus);

        ctx->bus = NULL;

    }

/*

 * ASynchronous operation managing

 **/

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

 */

void XAAdaptationGst_PrepareAsyncWait(XAAdaptationGstCtx* ctx)

    DEBUG_API("->XAAdaptationGst_PrepareAsyncWait");

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

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

        sem_wait(&(ctx->semAsyncWait));

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

    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,

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

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

        sem_wait(&(ctx->semAsyncWait));

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

    else

        DEBUG_INFO("<> async completed already");

    /*cancel timer*/

        g_source_remove(ctx->asynctimer);

    ctx->waitingasyncop = XA_BOOLEAN_FALSE;

    DEBUG_API("<-XAAdaptationGst_StartAsyncWait");

/* async operation timeout callback*/

gboolean XAAdaptationGst_CancelAsyncWait(gpointer ctx)

    DEBUG_API("->XAAdaptationGst_CancelAsyncWait");

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

        bCtx->waitingasyncop = XA_BOOLEAN_FALSE;

        sem_post(&(bCtx->semAsyncWait));

    /* return false to remove timer */

    return FALSE;

void XAAdaptationGst_CompleteAsyncWait(XAAdaptationGstCtx* ctx)

    DEBUG_API("->XAAdaptationGst_CompleteAsyncWait");

        int i;

        ctx->waitingasyncop = XA_BOOLEAN_FALSE;

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

            sem_post(&(ctx->semAsyncWait));

    }

/**

 * 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

 */

    XAuint32 locType = 0;

    GstElement* gstSrc = NULL;

    XADataLocator_URI* uri = NULL;

    XADataLocator_IODevice* ioDevice = NULL;

    XACameraDeviceImpl* cameraDevice = NULL;

    XARadioDeviceImpl* radioDevice = NULL;

    DEBUG_API("->XAAdaptationGst_CreateGstSource");

        return NULL;

    *isobj = XA_BOOLEAN_FALSE;

        *isPCM = XA_BOOLEAN_TRUE;

        *isRawImage = XA_BOOLEAN_TRUE;

        case XA_DATALOCATOR_URI:

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

                    {

                    }

                else

                    {

                    }

                {

                DEBUG_ERR("No uri specified.");

                return NULL;

            break; /* XA_DATALOCATOR_URI */

        case XA_DATALOCATOR_IODEVICE:

                case XA_IODEVICE_AUDIOINPUT:

                    DEBUG_INFO("XA_IODEVICE_AUDIOINPUT");

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

                        {

                            break;

                        default: