/*

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

#include <gst.h>

#include "XAMediaPlayerAdaptCtx.h"

#include "XAMediaPlayerAdaptCtxMMF.h"

#include "XAAdaptation.h"

#include "XAObjectItf.h"

#include "XACameraDevice.h"

#include "XAOutputMix.h"

#include "XAMetadataAdaptation.h"

#include "XANGAVideoSink.h"

static void need_data_for_prerolling (GstElement * pipeline, guint size, XAMediaPlayerAdaptationCtx* ctx );

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

static void  enough_data_for_prerolling (GstElement * pipeline, XAMediaPlayerAdaptationCtx* ctx);

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

}

/*

 * void  enough_data_for_prerolling (GstElement * pipeline, XAMediaPlayerAdaptationCtx* ctx)

 * Called when appsrc has enough data

 */

void  enough_data_for_prerolling (GstElement * pipeline, XAMediaPlayerAdaptationCtx* ctx)

{

	DEBUG_API("->enough_data_for_prerolling");

	/*No any functionality yet*/

	DEBUG_API("<-enough_data_for_prerolling");

}

/*

 * void need_data_for_prerolling (GstElement * pipeline, guint size, XAMediaPlayerAdaptationCtx* ctx )

 * Called when the appsrc needs more data during prerolling

 */

void need_data_for_prerolling (GstElement * pipeline, guint size, XAMediaPlayerAdaptationCtx* ctx )

{

    CPresult cpRet;

    XAuint32 requestedBytes = size;

    guint readedBytes = 0;

    CP_CHECKBYTESRESULTTYPE eResult;

    DEBUG_API("->need_data_for_prerolling");

    /*Start prerolling to contentpipe data*/

	ctx->baseObj.pipeSrcThrCtx.state = CPStatePrerolling;

	do

	{

		gpointer cpBuffer = NULL;

		GstBuffer  *buffer = NULL;

		cpRet = ctx->baseObj.pipeSrcThrCtx.pipe->pContentPipe->CheckAvailableBytes(&(ctx->baseObj.pipeSrcThrCtx.dataHandle), requestedBytes, &eResult);

		if ( cpRet != EXIT_SUCCESS )

		{

			DEBUG_API("ERROR");

			ctx->baseObj.pipeSrcThrCtx.state = CPStateError;

		}

		if ( eResult == CP_CheckBytesOk )

		{

			cpBuffer = g_malloc0(requestedBytes );

			readedBytes =+ requestedBytes;

			cpRet = ctx->baseObj.pipeSrcThrCtx.pipe->pContentPipe->Read( &(ctx->baseObj.pipeSrcThrCtx.dataHandle), (CPbyte*)cpBuffer, requestedBytes );

			if ( cpRet != EXIT_SUCCESS )

			{

				DEBUG_ERR("Could not read data from content pipe!");

				ctx->baseObj.pipeSrcThrCtx.state = CPStateError;

			}

			else

			{

				DEBUG_INFO_A1("Readed %u bytes", requestedBytes );

				/* Create gstBuffer, GStreamer frees data  */

				buffer = gst_app_buffer_new( (void*)cpBuffer, requestedBytes, g_free, cpBuffer );

				if ( !buffer )

				{

					DEBUG_ERR("Could not allocate buffer for content pipe source!");

					ctx->baseObj.pipeSrcThrCtx.state = CPStateError;

				}

			}

			if ( cpRet == EXIT_SUCCESS  )

			{

				if( buffer )

				{

					DEBUG_INFO("Pushing preroll buffer");

					/*CP code: causes some delay for appsrc but we use push-buffer signal at this point

                    GstFlowReturn ret;

					g_signal_emit_by_name (ctx->source, "push-buffer", GST_BUFFER(buffer), &ret);

					if( ret != GST_FLOW_OK )

					{

						DEBUG_ERR("Some problem during preroll");

						DEBUG_API("<-need_data_for_prerolling");

					}*/

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

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

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

					break;

				}

			}

		}

		else if( eResult == CP_CheckBytesAtEndOfStream )

		{

			ctx->baseObj.pipeSrcThrCtx.state = CPStateEOS;

			break;

		}

		else if( eResult == CP_CheckBytesInsufficientBytes )

		{

			ctx->baseObj.pipeSrcThrCtx.state = CPStateWaitForData;

		}

		else if( eResult == CP_CheckBytesVendorStartUnused )

		{

			/*We use this enumeration when client is started caching from the beginning again*/

			DEBUG_API( "CP_CheckBytesVendorStartUnused from implementation");

		}

	}while ( ctx->baseObj.pipeSrcThrCtx.state == CPStatePrerolling || ctx->baseObj.pipeSrcThrCtx.state == CPStateWaitForData );

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

{

    XAAdaptationBaseCtx* bCtx = (XAAdaptationBaseCtx*)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, GST_SEEK_FLAG_FLUSH|GST_SEEK_FLAG_ACCURATE,

                                      GST_SEEK_TYPE_SET, mCtx->loopstart,

                                      GST_SEEK_TYPE_NONE, 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, &event );

                    }

                }

                else

                {

                /* stop position tracking */

                if(mCtx->runpositiontimer > 0)

                {

                    g_source_remove(mCtx->runpositiontimer);

                    mCtx->runpositiontimer=0;

                }

                /* complete any ongoing client async operations */

                XAAdaptationBase_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, &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, &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 */

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

                XAAdaptationBase_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, &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;

    XAresult res = XA_RESULT_INTERNAL_ERROR;

    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),XAMediaPlayerAdaptation)

            != XA_RESULT_SUCCESS )

        {

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

            free(pSelf);

            pSelf = 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 = GST_CLOCK_TIME_NONE;

            pSelf->playrate = 1.0;

            pSelf->baseObj.pipeSrcThrCtx.state = CPStateNull;

            pSelf->baseObj.pipeSinkThrCtx.dataHandle = NULL;

            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;

            /*pSelf->waitData = XA_BOOLEAN_FALSE;*/

            if(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);

					free(pSelf);

					pSelf = NULL;

				}

			}

		}

    }

    DEBUG_API("<-XAMediaPlayerAdapt_Create");

    return (XAAdaptationBaseCtx*)pSelf;

}

/*

 * 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( XAAdaptationBaseCtx* bCtx )

{

    XAresult ret = XA_RESULT_SUCCESS;

    GstStateChangeReturn gret;

	XAuint32 locType = 0;

	XAMediaPlayerAdaptationCtx* ctx = NULL;

	GstElement *videotest=NULL;

    DEBUG_API("->XAMediaPlayerAdapt_PostInit");

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

    {

        DEBUG_ERR("Invalid parameter!!");

        DEBUG_API("<-XAMediaPlayerAdapt_PostInit");

        return XA_RESULT_PARAMETER_INVALID;

    }

    ctx = (XAMediaPlayerAdaptationCtx*)bCtx;

    assert(ctx);

    ret = XAAdaptationBase_PostInit( bCtx );

    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 = XAAdaptationBase_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 );