/*

* 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 <stdlib.h>

#include "xamediaplayeradaptctx.h"

#include "xamediaplayeradaptctxmmf.h"

#include "xaadaptationgst.h"

#include "xaobjectitf.h"

#include "xacameradevice.h"

#include "xaoutputmix.h"

#include "xametadataadaptation.h"

/*#include "xangavideosink.h"*/

#include "xacameraadaptctx.h"

#include "xaoutputmixadaptctx.h"

/* forward declarations */

XAresult XAMediaPlayerAdapt_CreatePipeline( XAMediaPlayerAdaptationCtx* ctx );

void* ngaVideoSinkPtr = NULL;

extern XAboolean cameraRealized;

extern XACameraAdaptationCtx_* cameraCtx;

/*

 * static void XAMediaPlayerAdapt_NewPadCb (GstElement *element, GstPad *pad,  gpointer data)

 * Listen to codec bin dynamic pads

 */

static void XAMediaPlayerAdapt_NewPadCb (GstElement *element, GstPad *pad,  gpointer data)

{

  XAMediaPlayerAdaptationCtx* mCtx = (XAMediaPlayerAdaptationCtx*)data;

  gchar *name = gst_pad_get_name (pad);

  DEBUG_API_A1("->XAMediaPlayerAdapt_NewPadCb: A new pad %s was created", name);

  /*try first newly created pad to video pipe*/

  if( mCtx->videoppbin && !(gst_pad_is_linked(gst_element_get_static_pad(mCtx->videoppbin, "videopp_sink"))) )

  {

      if(gst_element_link_pads (mCtx->codecbin, name, mCtx->videoppbin, "videopp_sink"))

      {

          DEBUG_INFO_A1("Pads linked, codecbin:%s to videopp:sink", name);

          g_free (name);

          DEBUG_API("<-XAMediaPlayerAdapt_NewPadCb");

          return;

      }

  }

  /*..and then to audio pipe*/

  if( mCtx->audioppbin && !(gst_pad_is_linked(gst_element_get_static_pad(mCtx->audioppbin, "sink"))) )

  {

      if(gst_element_link_pads (mCtx->codecbin, name, mCtx->audioppbin, "sink"))

      {

          DEBUG_INFO_A1("Pads linked, codecbin:%s to audiopp:sink", name);

          g_free (name);

          DEBUG_API("<-XAMediaPlayerAdapt_NewPadCb");

          return;

      }

  }

  g_free (name);

  DEBUG_INFO("Warning: Could not find anything to link to new pad.");

  DEBUG_API("<-XAMediaPlayerAdapt_NewPadCb");

}

/*

 * void  push_data_for_prerolling (GstElement * pipeline, GstBuffer *buffer, XAMediaPlayerAdaptationCtx* ctx)

 * Called when "push-buffer" signal is emitted

 */

void  push_data_for_prerolling (GstElement * pipeline, GstBuffer *buffer, XAMediaPlayerAdaptationCtx* ctx)

{

	DEBUG_API("->push_data_for_prerolling");

	gst_app_src_push_buffer( GST_APP_SRC(ctx->source), GST_BUFFER(buffer) );

	/*GstPad* prerollPad = NULL;

	prerollPad = gst_element_get_static_pad(GST_ELEMENT(ctx->source),"src");

	gst_pad_push (prerollPad, buffer);

	gst_element_send_event(GST_ELEMENT(ctx->source),gst_event_new_flush_start());

	gst_element_send_event(GST_ELEMENT(ctx->source),gst_event_new_flush_stop());*/

	DEBUG_API("<-push_data_for_prerolling");

}

/*

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

 * MediaPlayer Gst-bus message handler (Callback)

 */

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

{

    XAAdaptationGstCtx* bCtx = (XAAdaptationGstCtx*)data;

    /* only listen to bin messages */

    if(GST_MESSAGE_SRC(message)==(GstObject*)(bCtx->bin))

    {

        XAMediaPlayerAdaptationCtx* mCtx = (XAMediaPlayerAdaptationCtx*)data;

        DEBUG_API_A2("->XAMediaPlayerAdapt_GstBusCb:\"%s\" from object \"%s\"",

                        GST_MESSAGE_TYPE_NAME(message), GST_OBJECT_NAME(GST_MESSAGE_SRC(message)));

        switch( GST_MESSAGE_TYPE(message))

        {

            case GST_MESSAGE_EOS:

            {

                if( mCtx && mCtx->loopingenabled && mCtx->loopend == GST_CLOCK_TIME_NONE)

                {

                    DEBUG_INFO_A2("Restart loop from %"GST_TIME_FORMAT" to %"GST_TIME_FORMAT,

                                  GST_TIME_ARGS(mCtx->loopstart), GST_TIME_ARGS(mCtx->loopend));

                    gst_element_seek( bCtx->bin, mCtx->playrate, GST_FORMAT_TIME, (GstSeekFlags)(GST_SEEK_FLAG_FLUSH|GST_SEEK_FLAG_ACCURATE),

                                      GST_SEEK_TYPE_SET, mCtx->loopstart,

                                      GST_SEEK_TYPE_NONE, (gint64)GST_CLOCK_TIME_NONE );

                    gst_element_get_state(bCtx->bin,NULL,NULL,XA_ADAPT_ASYNC_TIMEOUT_SHORT_NSEC);

                    mCtx->lastpos = mCtx->loopstart;

                    if( mCtx && mCtx->trackpositionenabled )

                    {

                        XAmillisecond posMsec = GST_TIME_AS_MSECONDS(mCtx->lastpos);/*Warning ok due to used API specification*/

                        XAAdaptEvent event = {XA_PLAYITFEVENTS, XA_ADAPT_POSITION_UPDATE_EVT, 1, NULL};

                        event.data = &posMsec;

                        XAAdaptationBase_SendAdaptEvents(&bCtx->baseObj, &event );

                    }

                }

                else

                {

                /* stop position tracking */

                if(mCtx->runpositiontimer > 0)

                {

                    g_source_remove(mCtx->runpositiontimer);

                    mCtx->runpositiontimer=0;

                }

                /* complete any ongoing client async operations */

                XAAdaptationGst_CompleteAsyncWait(bCtx);

                /* send needed events */

                {

					XAMediaType mediatype;

/*

					if( mCtx->baseObj.pipeSrcThrCtx.pipe )

					{

						XACommon_CheckDataSource((XADataSource*)mCtx->xaAudioSink, &mediatype);

					}

					else

*/

					{

						XACommon_CheckDataSource(mCtx->xaSource, &mediatype);

					}

					if(mediatype!=XA_MEDIATYPE_IMAGE)

					{

						XAAdaptEvent event = { XA_PLAYITFEVENTS, XA_PLAYEVENT_HEADATEND, 0, NULL };

						XAAdaptationBase_SendAdaptEvents(&bCtx->baseObj, &event );

					}

                }

                if(mCtx->positionCb)

                {

                    mCtx->positionCb(bCtx);

                }

                bCtx->binWantedState = GST_STATE_PAUSED;

                }

                break;

            }

            case GST_MESSAGE_STATE_CHANGED:

            {

                GstState oldstate, newstate, pendingstate, gsttargetstate;

                gst_message_parse_state_changed(message, &oldstate, &newstate, &pendingstate);

                gsttargetstate = GST_STATE_TARGET(bCtx->bin);

                DEBUG_INFO_A4("old %s -> new %s ( pending %s, gsttarget %s )",

                               gst_element_state_get_name(oldstate),

                               gst_element_state_get_name(newstate),

                               gst_element_state_get_name(pendingstate),

                               gst_element_state_get_name(gsttargetstate) );

                if(gsttargetstate!=bCtx->binWantedState)

                {

                    DEBUG_ERR_A1("WARNING: Gst target is not wanted target [%s]!!!",

                                    gst_element_state_get_name(bCtx->binWantedState));

                }

                /* print out some more info */

                if( pendingstate == GST_STATE_VOID_PENDING )

                {

                    if( newstate != bCtx->binWantedState )

                    {

                        DEBUG_INFO_A2("Gst in intermediate state transition (curr %s, target %s)",

                                        gst_element_state_get_name(newstate),

                                        gst_element_state_get_name(bCtx->binWantedState));

                       break; // TL: add to avoid extra event sent below in this case...                

                    }

                    else

                    {

                        DEBUG_INFO_A1("Gst in wanted target state (%s)",

                                        gst_element_state_get_name(newstate));

                    }

                }

                if( oldstate!=GST_STATE_PLAYING && newstate==GST_STATE_PLAYING )

                {

                    /* send needed events */

                    XAAdaptEvent event = {XA_PLAYITFEVENTS, XA_PLAYEVENT_HEADMOVING, 0, NULL };

                    XAAdaptationBase_SendAdaptEvents(&bCtx->baseObj, &event );

                    /* enable position tracking if needed */

                    XAMediaPlayerAdapt_UpdatePositionCbTimer(mCtx);

                }

                if ( oldstate== GST_STATE_READY && newstate==GST_STATE_PAUSED)

                {

/*                    if ( mCtx->baseObj.pipeSinkThrCtx.dataHandle )

                    {

                        mCtx->baseObj.pipeSrcThrCtx.state = CPStateInitialized;

                    }*/

                }

                break;

            }

            case GST_MESSAGE_ASYNC_DONE:

            {

                /* some async sequence ended */

                XAAdaptationGst_CompleteAsyncWait(bCtx);

                break;

            }

            case GST_MESSAGE_ERROR:

            {

                GError* error;

                gchar* debug;

                gst_message_parse_error(message, &error, &debug);

                DEBUG_ERR_A1("Gst reports error \"%s\"", debug);

                /* stop waiting any ongoing async operations */

                XAAdaptationGst_CompleteAsyncWait(bCtx);

                break;

            }

            case GST_MESSAGE_BUFFERING:

            {

                gint percent;

                gst_message_parse_buffering(message, &percent);

                DEBUG_INFO_A1("Gst message buffering %d", percent);

                mCtx->buffering = percent;

                {

                    XAAdaptEvent event = {XA_PREFETCHITFEVENTS, XA_ADAPT_BUFFERING, 1, NULL };

                    event.data = &mCtx->buffering;

                XAAdaptationBase_SendAdaptEvents(&bCtx->baseObj, &event );

                }

                break;

            }

            case GST_MESSAGE_ELEMENT:

            {

                DEBUG_INFO("GST_MESSAGE_ELEMENT");

                if ((gst_structure_has_name(message->structure, "graphics-surface-created")) || 

                    (gst_structure_has_name(message->structure, "graphics-surface-updated")))

                {

                     DEBUG_INFO("graphics-surface-created message recived");

                }

                break;

            }

            default:

                break;

        }

    }

    else //if (GST_MESSAGE_SRC(message)==(GstObject*)(bCtx->videosink))

    {

        switch( GST_MESSAGE_TYPE(message))

        {

            case GST_MESSAGE_ELEMENT:

            {

                DEBUG_INFO("GST_MESSAGE_ELEMENT");

                if ((gst_structure_has_name(message->structure, "graphics-surface-created")) || 

                    (gst_structure_has_name(message->structure, "graphics-surface-updated")))

                {

                     guint32 surfaceid0, surfaceid1, surfaceid2, surfaceid3;

                     gint crop_rect_tl_x, crop_rect_tl_y, crop_rect_br_x, crop_rect_br_y;

                     gint aspect_ratio_num, aspect_ratio_denom;

                     GstObject *sink= GST_MESSAGE_SRC(message);

                     g_object_get(sink, "surfaceid0", &surfaceid0, NULL);

                     g_object_get(sink, "surfaceid1", &surfaceid1,NULL);

                     g_object_get(sink, "surfaceid2", &surfaceid2,NULL);

                     g_object_get(sink, "surfaceid3", &surfaceid3,NULL);

                     g_object_get(sink, "croprect_tl_x", &crop_rect_tl_x, NULL);

                     g_object_get(sink, "croprect_tl_y", &crop_rect_tl_y, NULL);

                     g_object_get(sink, "croprect_br_x", &crop_rect_br_x, NULL);

                     g_object_get(sink, "croprect_br_y", &crop_rect_br_y, NULL);                

                     g_object_get(sink, "aspectratio_num", &aspect_ratio_num, NULL);

                     g_object_get(sink, "aspectratio_denom", &aspect_ratio_denom, NULL);                     

/*

                     surface_created(ngaVideoSinkPtr, surfaceid0,surfaceid1,surfaceid2,surfaceid3,crop_rect_tl_x,

                     									crop_rect_tl_y,crop_rect_br_x,crop_rect_br_y,aspect_ratio_num,aspect_ratio_denom);                     

*/

                }

                break;

            }

            default:

                break;

        }   

    }

    DEBUG_API("<-XAMediaPlayerAdapt_GstBusCb");    

    return TRUE;

}

/*

 * XAMediaPlayerAdaptationCtx* XAMediaPlayerAdapt_Create()

 * Allocates memory for Media Player Adaptation Context and makes 1st phase initialization

 * @param XADataSource *pDataSrc - pointer to OMX-AL data source

 * @param XADataSource *pBankSrc - pointer to instrument bank structure in Mobile DLS, if NULL default will be used.

 * @param XADataSink *pAudioSnk - pointer to OMX-AL audio sink definition

 * @param XADataSink *pImageVideoSnk - pointer to OMX-AL image and video sink definition

 * @returns XAMediaPlayerAdaptationCtx* - Pointer to created context, NULL if error occurs.

 */

XAAdaptationBaseCtx* XAMediaPlayerAdapt_Create(XADataSource *pDataSrc, XADataSource *pBankSrc,

                                                      XADataSink *pAudioSnk, XADataSink *pImageVideoSnk,

                                                      XADataSink *pVibra, XADataSink *pLEDArray)

{

    XAMediaPlayerAdaptationCtx *pSelf = NULL;

    XAuint32 locType = 0;

    XADataLocator_IODevice *ioDevice;

    DEBUG_API("->XAMediaPlayerAdapt_Create");

    //Create NGA Video Sink class

/*    if(pImageVideoSnk)

    {

       ngaVideoSinkPtr = nga_video_sink_init();

    }*/

    pSelf = calloc(1, sizeof(XAMediaPlayerAdaptationCtx));

    if ( pSelf)

    {

        if( XAAdaptationBase_Init(&(pSelf->baseObj.baseObj),XAMediaPlayerAdaptation)

            != XA_RESULT_SUCCESS )

        {

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

            free(pSelf);

            pSelf = NULL;

            return NULL;

        }

        else

        {

            pSelf->xaSource = pDataSrc;

            pSelf->xaBankSrc = pBankSrc;

            pSelf->xaAudioSink = pAudioSnk;

            pSelf->xaVideoSink = pImageVideoSnk;

            pSelf->xaLEDArray = pLEDArray;

            pSelf->xaVibra = pVibra;

            pSelf->loopstart = 0;

            pSelf->loopend = (gint64)GST_CLOCK_TIME_NONE;

            pSelf->playrate = 1.0;

            pSelf->rateprops = (XA_RATEPROP_SMOOTHVIDEO | XA_RATEPROP_SILENTAUDIO);

            pSelf->curMirror = XA_VIDEOMIRROR_NONE;

            pSelf->curRotation = 0;

            pSelf->isobjsrc = XA_BOOLEAN_FALSE;

            pSelf->cameraSinkSynced = XA_BOOLEAN_FALSE;

/*            if(pImageVideoSnk && ngaVideoSinkPtr)

            {

               setup_native_display(ngaVideoSinkPtr, pImageVideoSnk);

            }*/

        }

        if ( pDataSrc )

		{

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

			if ( locType == XA_DATALOCATOR_IODEVICE  )

			{

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

				if ( ioDevice->deviceType == XA_IODEVICE_CAMERA && !cameraRealized )

				{

					DEBUG_ERR("Preconditions violated - Camera object not realized");

					XAAdaptationBase_Free(&pSelf->baseObj.baseObj);

					free(pSelf);

					pSelf = NULL;

				}

			}

		}

    }

    DEBUG_API("<-XAMediaPlayerAdapt_Create");

    return (XAAdaptationBaseCtx*)(&pSelf->baseObj);

}

/*

 * XAresult XAMediaPlayerAdapt_PostInit()

 * 2nd phase initialization of Media Player Adaptation Context

 * @param XAMediaPlayerAdaptationCtx* ctx - pointer to Media Player adaptation context

 * @return XAresult - Success value

 */

XAresult XAMediaPlayerAdapt_PostInit( XAAdaptationGstCtx* bCtx )

{

    XAresult ret = XA_RESULT_SUCCESS;

    GstStateChangeReturn gret;

	XAMediaPlayerAdaptationCtx* ctx = NULL;

	GstElement *videotest=NULL;

    DEBUG_API("->XAMediaPlayerAdapt_PostInit");

    if(bCtx == NULL || bCtx->baseObj.ctxId != XAMediaPlayerAdaptation )

    {

        DEBUG_ERR("Invalid parameter!!");

        DEBUG_API("<-XAMediaPlayerAdapt_PostInit");

        return XA_RESULT_PARAMETER_INVALID;

    }

    ctx = (XAMediaPlayerAdaptationCtx*)bCtx;

    assert(ctx);

    ret = XAAdaptationBase_PostInit( &bCtx->baseObj );

    if( ret!=XA_RESULT_SUCCESS )

    {

        DEBUG_ERR("Base context postinit failed!!");

        return ret;

    }

    /* top level bin for media player */

    ctx->baseObj.bin = gst_pipeline_new("media_player");

    /* Create Gst bus listener. */

    ret = XAAdaptationGst_InitGstListener(bCtx);

    if( ret!=XA_RESULT_SUCCESS )

    {

        DEBUG_ERR("Bus listener creation failed!!");

        return ret;

    }

    /* Add Media Player specific handler */

    if(ctx->baseObj.bus)

    {

        ctx->baseObj.busCb = XAMediaPlayerAdapt_GstBusCb;

        gst_bus_add_signal_watch( ctx->baseObj.bus );

        gst_bus_enable_sync_message_emission( ctx->baseObj.bus );

        g_signal_connect(ctx->baseObj.bus, "message::eos", G_CALLBACK(bCtx->busCb), ctx );

        g_signal_connect(ctx->baseObj.bus, "message::error", G_CALLBACK(bCtx->busCb), ctx );

        g_signal_connect(ctx->baseObj.bus, "message::warning", G_CALLBACK(bCtx->busCb), ctx );

        g_signal_connect(ctx->baseObj.bus, "message::state-changed", G_CALLBACK(bCtx->busCb), ctx );

        g_signal_connect(ctx->baseObj.bus, "message::segment-done", G_CALLBACK(bCtx->busCb), ctx );

        g_signal_connect(ctx->baseObj.bus, "message::async-done", G_CALLBACK(bCtx->busCb), ctx );

        g_signal_connect(ctx->baseObj.bus, "message::element", G_CALLBACK(bCtx->busCb), ctx );

    }

    else

    {

        DEBUG_ERR("Failed to create message bus");

        return XA_RESULT_INTERNAL_ERROR;

    }

    XAMetadataAdapt_PreInit(bCtx);

    /* create pipeline */

    ret = XAMediaPlayerAdapt_CreatePipeline(ctx);

    if ( ret != XA_RESULT_SUCCESS )

    {

        DEBUG_ERR("Failed to create Media Player pipeline");

        return ret;

    }

#ifdef XA_IMPL_MEASURE_GST_DELAY

    ctx->baseObj.startTime = clock();

#endif /* XA_IMPL_MEASURE_GST_DELAY */

    /* roll up bin */

    ctx->baseObj.binWantedState = GST_STATE_PAUSED;

    XAAdaptationGst_PrepareAsyncWait(bCtx);

    gret = gst_element_set_state( GST_ELEMENT(ctx->baseObj.bin), bCtx->binWantedState);

    if( gret == GST_STATE_CHANGE_ASYNC )

    {

        DEBUG_INFO("Wait for preroll");

        XAAdaptationGst_StartAsyncWait(bCtx);

        DEBUG_INFO("Preroll ready");

    }

    else if( gret == GST_STATE_CHANGE_FAILURE )

    {

        DEBUG_ERR("Preroll FAILED");

        ret = XA_RESULT_INTERNAL_ERROR;

    }

    bCtx->waitingasyncop = XA_BOOLEAN_FALSE;

    gret = gst_element_get_state( GST_ELEMENT(bCtx->bin), NULL, NULL, XA_ADAPT_ASYNC_TIMEOUT_SHORT_NSEC);

    if(GST_STATE(bCtx->bin)<GST_STATE_PAUSED)

    {

        DEBUG_INFO("Warning! Preroll not ready");

        if( ctx->audioppbin && !(gst_pad_is_linked(gst_element_get_static_pad(ctx->audioppbin, "sink"))) )

        {/*could not find suitable pad for audiopipeline - remove it*/

            DEBUG_INFO("Warning! No suitable decodebin pad for audio pipeline!");

            gst_element_set_state( GST_ELEMENT(ctx->audioppbin), GST_STATE_NULL);

            gst_bin_remove(GST_BIN(bCtx->bin), ctx->audioppbin);

            gst_element_set_state( GST_ELEMENT(ctx->audiosink), GST_STATE_NULL);

            gst_bin_remove(GST_BIN(bCtx->bin), ctx->audiosink);

        }

        else if( ctx->videoppbin && !(gst_pad_is_linked(gst_element_get_static_pad(ctx->videoppbin, "videopp_sink"))) )

        {/*could not find suitable pad for videopipeline - remove it*/

            DEBUG_INFO("Warning! No suitable decodebin pad for video pipeline!");

            gst_element_set_state( GST_ELEMENT(ctx->videoppbin), GST_STATE_NULL);

            gst_bin_remove(GST_BIN(bCtx->bin), ctx->videoppbin);

            gst_element_set_state( GST_ELEMENT(ctx->videosink), GST_STATE_NULL);

            gst_bin_remove(GST_BIN(bCtx->bin), ctx->videosink);

        }

		gst_element_set_state( GST_ELEMENT(bCtx->bin), bCtx->binWantedState);

		gst_element_get_state( GST_ELEMENT(bCtx->bin), NULL, NULL, XA_ADAPT_ASYNC_TIMEOUT_SHORT_NSEC);

		if(GST_STATE(bCtx->bin)==GST_STATE_PAUSED)

		{

			DEBUG_INFO("Retry preroll successful!")

			ret = XA_RESULT_SUCCESS;

		}

    }

    else

    {

        DEBUG_INFO("Preroll ready");

    }

#ifdef XA_IMPL_MEASURE_GST_DELAY

    bCtx->endTime = clock();

    double diff = bCtx->endTime - bCtx->startTime ;

    diff = diff / CLOCKS_PER_SEC;

    DEBUG_API_A1( "Starting up bin took %.4lf secs",diff);

#endif /* XA_IMPL_MEASURE_GST_DELAY */

    videotest = gst_bin_get_by_name(GST_BIN(bCtx->bin), "videotest");

    if ( videotest && !ctx->isobjsrc )

    {

    	gst_element_set_state( GST_ELEMENT(videotest),GST_STATE_PLAYING);

    }

    XAMetadataAdapt_PostInit(bCtx);

    if ( videotest )

    {

        gst_object_unref(videotest);

    }