/*

* 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:

*

*

*/

#include <string.h>

#include <assert.h>

#include <gst/gst.h>

#include <gst/app/gstappsink.h>

#include "xacapabilitiesmgr.h"

#include "xamediarecorderadaptctx.h"

#include "xacameraadaptctx.h"

extern XAboolean cameraRealized;

extern XACameraAdaptationCtx_* cameraCtx;

/*forward declarations*/

GstElement* XAMediaRecorderAdapt_CreateEncodeBin(

        XAMediaRecorderAdaptationCtx* ctx);

XAresult XAMediaRecorderAdapt_CreatePipeline(

        XAMediaRecorderAdaptationCtx* ctx);

void XAMediaRecorderAdapt_BufferAvailable(GstElement* sink,

        gpointer user_data);

/** Creates the caps gst element */

static XAresult XAMediaRecorderAdapt_CreateCapsFilter( XAMediaRecorderAdaptationCtx* ctx );

/*

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

 * MediaPlayer Gst-bus message handler (Callback)

 */

gboolean XAMediaRecorderAdapt_GstBusCb(GstBus *bus, GstMessage *message,

        gpointer data)

    {

    XAAdaptationGstCtx* bCtx = (XAAdaptationGstCtx*) data;

    /* only listen to pipeline messages */

    if (GST_MESSAGE_SRC(message)==GST_OBJECT(bCtx->bin))

        {

        XAMediaRecorderAdaptationCtx* mCtx = NULL;

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

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

        mCtx = (XAMediaRecorderAdaptationCtx*)data;

        switch( GST_MESSAGE_TYPE(message))

        {

            case GST_MESSAGE_EOS:

            {

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

                {

                    XAAdaptEvent event = {XA_RECORDITFEVENTS, XA_RECORDEVENT_HEADATLIMIT, 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 %d -> new %d (-> pending %d -> gsttarget %d)",

                               oldstate, newstate, pendingstate, gsttargetstate);

                if(gsttargetstate!=bCtx->binWantedState)

                {

                    DEBUG_ERR_A1("WARNING: Gst target is not wanted target [%d]!!!", 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 %d, target %d)",

                                    newstate,bCtx->binWantedState);

                    }

                    else

                    {

                        DEBUG_INFO_A1("Gst in wanted target state (%d)",newstate);

                    }

                }

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

                {

                    XAAdaptEvent event = {XA_RECORDITFEVENTS, XA_RECORDEVENT_HEADMOVING, 0, NULL };

                    /* send needed events */

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

                    /* enable position tracking if needed */

                    if( mCtx->runpositiontimer==0 && mCtx->trackpositionenabled && mCtx->positionCb )

                    {

                        mCtx->runpositiontimer = g_timeout_add(XA_ADAPT_PU_INTERVAL, mCtx->positionCb, mCtx);

                    }

                }

                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_WARNING:

            {

                GError* error;

                gchar* debug;

                gst_message_parse_warning(message, &error, &debug);

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

                /* stop waiting any ongoing async operations */

                XAAdaptationGst_CompleteAsyncWait(bCtx);

                break;

            }

            default:

                break;

        }

    DEBUG_API("<-XAMediaRecorderAdapt_GstBusCb");

    }

    return TRUE;

    }

/*

 * XAAdaptationGstCtx* XAMediaRecorderAdapt_Create()

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

 * @param XADataSource *pAudioSrc - pointer to OMX-AL audio source

 * @param XADataSource *pImageVideoSrc - pointer image/video source

 * @param XADataSink *pDataSnk - pointer to OMX-AL sink

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

 */

XAAdaptationBaseCtx* XAMediaRecorderAdapt_Create(XADataSource* pAudioSrc,

        XADataSource* pImageVideoSrc, XADataSink* pDataSnk, XAuint8 recModes)

    {

    XAMediaRecorderAdaptationCtx *pSelf = NULL;

    XAuint32 locType = 0;

    XADataLocator_IODevice *ioDevice;

    DEBUG_API("->XAMediaRecorderAdapt_Create");

    pSelf = (XAMediaRecorderAdaptationCtx*)calloc(1, sizeof(XAMediaRecorderAdaptationCtx));

    if (pSelf)

        {

        if (XAAdaptationGst_Init(&(pSelf->baseObj),

                XAMediaRecorderAdaptation) != XA_RESULT_SUCCESS)

            {

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

            free(pSelf);

            pSelf = NULL;

            DEBUG_API("<-XAMediaRecorderAdapt_Create");

            return NULL;

            }

        else

            {

            pSelf->baseObj.baseObj.fwtype = FWMgrFWGST;

            pSelf->xaAudioSource = pAudioSrc;

            pSelf->xaVideoSource = pImageVideoSrc;

            pSelf->xaSink = pDataSnk;

/*            pSelf->baseObj.pipeSinkThrCtx.state = CPStateNull;*/

            pSelf->xaRecordState = XA_RECORDSTATE_STOPPED;

            pSelf->curMirror = XA_VIDEOMIRROR_NONE;

            pSelf->curRotation = 0;

            pSelf->recModes = recModes;

            pSelf->isRecord = XA_BOOLEAN_FALSE;

            /* defaults from API spec */

            pSelf->imageEncSettings.width = 640;

            pSelf->imageEncSettings.height = 480;

            pSelf->imageEncSettings.compressionLevel = 0;

            pSelf->imageEncSettings.encoderId = XA_IMAGECODEC_JPEG;

            pSelf->imageEncSettings.colorFormat = XA_COLORFORMAT_UNUSED;

            /* no specified defaults for rest, determined later from container type */

            pSelf->videoEncSettings.encoderId = XA_ADAPTID_UNINITED;

            pSelf->videoEncSettings.width = 640;

            pSelf->videoEncSettings.height = 480;

            pSelf->videoEncSettings.frameRate = 15;

            pSelf->audioEncSettings.encoderId = XA_ADAPTID_UNINITED;

            pSelf->audioEncSettings.channelsIn = 2;

            pSelf->audioEncSettings.channelsOut = 2;

            pSelf->audioEncSettings.bitsPerSample = 8;

            pSelf->audioEncSettings.bitRate = 128;

            pSelf->audioEncSettings.sampleRate = 44100;

            }

        if (pImageVideoSrc)

            {

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

            if (locType == XA_DATALOCATOR_IODEVICE)

                {

                ioDevice

                        = (XADataLocator_IODevice*) (pImageVideoSrc->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("<-XAMediaRecorderAdapt_Create");

                    return NULL;

                    }

                }

            }

        }

    DEBUG_API("<-XAMediaRecorderAdapt_Create");

    return (XAAdaptationBaseCtx*) &pSelf->baseObj;

    }

/*

 * XAresult XAMediaRecorderAdapt_PostInit()

 * 2nd phase initialization of Media Recorder Adaptation Context

 * @param XAAdaptationGstCtx* ctx - pointer to Media Recorder adaptation context

 * @return XAresult - Success value

 */

XAresult XAMediaRecorderAdapt_PostInit(XAAdaptationGstCtx* bCtx)

    {

    GstStateChangeReturn gret;

    XAresult ret = XA_RESULT_SUCCESS;

    XAMediaRecorderAdaptationCtx* ctx = NULL;

    DEBUG_API("->XAMediaRecorderAdapt_PostInit");

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

        {

        DEBUG_ERR("Invalid parameter!!");DEBUG_API("<-XAMediaRecorderAdapt_PostInit");

        return XA_RESULT_PARAMETER_INVALID;

        }

    ctx = (XAMediaRecorderAdaptationCtx*) bCtx;

    ret = XAAdaptationGst_PostInit(bCtx);

    if (ret != XA_RESULT_SUCCESS)

        {

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

        return ret;

        }

    /* top level bin for media recorder */

    bCtx->bin = gst_pipeline_new("media_recorder");

    /* Create Gst bus listener. */

    ret = XAAdaptationGst_InitGstListener(bCtx);

    if (ret != XA_RESULT_SUCCESS)

        {

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

        return ret;

        }

    /* Add Media Recorder specific handler */

    if (bCtx->bus)

        {

        bCtx->busCb = XAMediaRecorderAdapt_GstBusCb;

        gst_bus_add_signal_watch(bCtx->bus);

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

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

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

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

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

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

        }

    else

        {

        DEBUG_ERR("Failed to create message bus");

        return XA_RESULT_INTERNAL_ERROR;

        }

    XAMetadataAdapt_PreInit(bCtx);

    /* create pipeline */

    ret = XAMediaRecorderAdapt_CreatePipeline(ctx);

    if (ret != XA_RESULT_SUCCESS)

        {

        DEBUG_ERR("Failed to create recorder pipeline");

        return XA_RESULT_INTERNAL_ERROR;

        }

#ifdef XA_IMPL_MEASURE_GST_DELAY

    bCtx->startTime = clock();

#endif /* XA_IMPL_MEASURE_GST_DELAY */

    /* roll up bin */

    bCtx->binWantedState = GST_STATE_PAUSED;

    XAAdaptationGst_PrepareAsyncWait(bCtx);

    gret = gst_element_set_state(GST_ELEMENT(bCtx->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;*/

        }

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

    XAMetadataAdapt_PostInit(bCtx);

    bCtx->waitingasyncop = XA_BOOLEAN_FALSE;

    DEBUG_API("<-XAMediaRecorderAdapt_PostInit");

    return ret;

    }

/*

 * void XAMediaRecorderAdapt_Destroy( XAAdaptationGstCtx* bCtx )

 * Destroys Media Recorder Adaptation Context

 * @param ctx - Media Recorder Adaptation context to be destroyed

 */

void XAMediaRecorderAdapt_Destroy(XAAdaptationGstCtx* bCtx)

    {

    XAMediaRecorderAdaptationCtx* ctx = NULL;

    char* fname = NULL;

    DEBUG_API("->XAMediaRecorderAdapt_Destroy");

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

        {

        DEBUG_ERR("Invalid parameter!!");DEBUG_API("<-XAMediaRecorderAdapt_Destroy");

        return;

        }

    ctx = (XAMediaRecorderAdaptationCtx*) bCtx;

    if (ctx->isRecord == XA_BOOLEAN_FALSE)

        {

        DEBUG_INFO("Removing unnecessary file.");

        if (ctx->xaSink && *((XAuint32*) (ctx->xaSink->pLocator))

                == XA_DATALOCATOR_URI)

            {

            if (strncmp(

                    (char *) ((XADataLocator_URI*) (ctx->xaSink->pLocator))->URI,

                    "file:///", 8) == 0)

                {

                fname

                        = (char *) &(((XADataLocator_URI*) (ctx->xaSink->pLocator))->URI[8]);

                }

            else

                {

                fname

                        = (char *) ((XADataLocator_URI*) (ctx->xaSink->pLocator))->URI;

                }

            if (remove(fname) != 0)

                {

                DEBUG_ERR_A1("Cannot remove file %s", fname);

                }

            }

        }

    if (ctx->isobjvsrc && ctx->videosource)

        { /* external source, unlink now */

        gst_element_unlink(ctx->videosource, ctx->codecbin);

        GST_OBJECT_FLAG_SET(GST_OBJECT(ctx->videosource),GST_OBJECT_FLOATING);

        }

    if (bCtx->bus)

        {

        gst_bus_remove_signal_watch(bCtx->bus);

        }

    XAAdaptationGst_CancelAsyncWait(bCtx);

    if (ctx->runpositiontimer)

        {

        g_source_remove(ctx->runpositiontimer);

        }

    XAAdaptationGst_Free(bCtx);

    free(ctx);

    ctx = NULL;

    DEBUG_API("<-XAMediaRecorderAdapt_Destroy");

    }

/***************** INTERNAL FUNCTIONS *******************************/

    /*

     * void XAMediaRecorderAdapt_CreatePipeline( XAMediaRecorderAdaptationCtx* ctx );

     */

XAresult XAMediaRecorderAdapt_CreatePipeline(

        XAMediaRecorderAdaptationCtx* ctx)

    {

    XAresult ret = XA_RESULT_SUCCESS;

    DEBUG_API("->XAMediaRecorderAdapt_CreatePipeline");

    /* Create the audio src */

    if ( ctx->xaAudioSource )

        {

        /* create audio pipe source */

        ctx->audiosource = XAAdaptationGst_CreateGstSource( ctx->xaAudioSource, "audiosource",

                &(ctx->isobjasrc), NULL, NULL );

        if( ctx->audiosource )

            {

            if (gst_bin_add(GST_BIN(ctx->baseObj.bin), ctx->audiosource))

                {

                DEBUG_API("Added audiosource to bin");

                }

            else

                {

                DEBUG_API("Could not add audiosource to bin");

                return XA_RESULT_INTERNAL_ERROR;

                }

            }

        else

            {

            DEBUG_ERR("Could not create audio source!!!!");

            return XA_RESULT_INTERNAL_ERROR;

            }

        }

    /* create and add video pipeline */

    ctx->codecbin = XAMediaRecorderAdapt_CreateEncodeBin(ctx);

    if (ctx->codecbin)

        {

        if (gst_bin_add(GST_BIN(ctx->baseObj.bin), ctx->codecbin))

            {

            DEBUG_API("->XAMediaRecorderAdapt_CreatePipeline: gst_bin_add success");

            }

        else

            {

            DEBUG_ERR("Could not add codec bin");

            return XA_RESULT_INTERNAL_ERROR;

            }

        }

    else

        {

        DEBUG_ERR("Could not create encoding bin!!!");

        return XA_RESULT_INTERNAL_ERROR;

        }

    /* create and add video pipeline if video source available and codec supports video */

    if (ctx->xaVideoSource

            && gst_element_get_pad(ctx->codecbin, "v_sink"))

        {

        /* create video pipe source */

        ctx->videosource = XAAdaptationGst_CreateGstSource(

                ctx->xaVideoSource, "videosource", &(ctx->isobjvsrc),

                NULL, NULL );

        if (!ctx->videosource)

            {

            DEBUG_ERR("Could not create video source!!!!");

            return XA_RESULT_INTERNAL_ERROR;

            }

        if (!ctx->isobjvsrc)

            { /* Add other than camera sources to media recorder bin */

            gst_bin_add(GST_BIN(ctx->baseObj.bin), ctx->videosource);

            }

        else

            { /* Don't add camera source to media recorder bin */

            GstCaps * encSrcCaps;

            encSrcCaps = gst_caps_new_simple( "video/x-raw-yuv", 

            "format", GST_TYPE_FOURCC,GST_MAKE_FOURCC('I','4','2','0'),

            "framerate", GST_TYPE_FRACTION, ctx->videoEncSettings.frameRate, 1,

                    NULL);

            DEBUG_INFO_A1("new camera encoding filter: %s",gst_caps_to_string(encSrcCaps));

            g_object_set( G_OBJECT(ctx->videosource), "filter-caps",encSrcCaps,NULL);

            gst_caps_unref(encSrcCaps);

            }

        /* create video filter for video encoder settings */

        ctx->videofilter = gst_element_factory_make("capsfilter", "videofilter");

        if( ctx->videofilter )

            {

            GstCaps* encSrcCaps;

            gst_bin_add(GST_BIN(ctx->baseObj.bin), ctx->videofilter);

            encSrcCaps = gst_caps_new_simple("video/x-raw-yuv",

                    "width", G_TYPE_INT, ctx->videoEncSettings.width,

                    "height", G_TYPE_INT, ctx->videoEncSettings.height,

                    "framerate", GST_TYPE_FRACTION, ctx->videoEncSettings.frameRate, 1,

                    NULL);

            DEBUG_INFO_A1("video encoder config from settings: %s",gst_caps_to_string(encSrcCaps));

            g_object_set( G_OBJECT(ctx->videofilter), "caps",encSrcCaps,NULL);

            gst_caps_unref(encSrcCaps);

            if ( ! ctx->isobjvsrc )

                {

                if(!gst_element_link(ctx->videosource, ctx->videofilter))

                    {

                    DEBUG_ERR("Could not link videopp to videofilter!!");

                    return XA_RESULT_INTERNAL_ERROR;

                    }

                }

            else

                { /* For camera source used ghost-pads for linking, because elements are in different bins */

                GstStateChangeReturn gret;

                GstElement *camTee=NULL;

                GstPad *cameraBinGhostPad=NULL;

                GstPad *ghost=NULL;

                GstPad *mrGhostSink=NULL;

                DEBUG_INFO("Set ext-source PAUSED for pipeline manipulation");

                gret = gst_element_set_state( GST_ELEMENT(ctx->videosource), GST_STATE_READY);

                if(gret == GST_STATE_CHANGE_SUCCESS)

                    {

                    gret = gst_element_get_state( GST_ELEMENT(ctx->videosource), NULL,NULL,XA_ADAPT_ASYNC_TIMEOUT_SHORT_NSEC);

                    }

                /* Add new ghost-pad to external camera source */