/*
 * 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: Record Itf GST adaptation
 *
 */

#include <pthread.h>
#include <gst/gst.h>
#include "xamediarecorderadaptctx.h"
#include "xarecorditfadaptation.h"
#include "xaadaptationgst.h"
#include "xacameraadaptctx.h"

/*forward declaration of position updater callback*/
gboolean XARecordItfAdapt_PositionUpdate(gpointer ctx);

extern XAboolean cameraRealized;
extern XACameraAdaptationCtx_* cameraCtx;

/*
 * XAresult XARecordItfAdapt_SetRecordState(XAAdaptationGstCtx *ctx, XAuint32 state)
 * Sets record state to GStreamer.
 * @param XAAdaptationGstCtx *ctx - Adaptation context
 * XAuint32 state - Record state to be set
 * @return XAresult ret - Success value
 */
XAresult XARecordItfAdapt_SetRecordState(XAAdaptationGstCtx *bCtx,
        XAuint32 state)
    {
    XAresult ret = XA_RESULT_SUCCESS;
    XAboolean closeSink = XA_BOOLEAN_FALSE;
    XAboolean requestStateChange = XA_BOOLEAN_FALSE;
    GstStateChangeReturn gstRet = GST_STATE_CHANGE_SUCCESS;
    XAMediaRecorderAdaptationCtx* mCtx = NULL;
    XAboolean recording = XA_BOOLEAN_FALSE;
    DEBUG_API_A1("->XARecordItfAdapt_SetRecordState %s",RECORDSTATENAME(state));
    if (!bCtx || bCtx->baseObj.ctxId != XAMediaRecorderAdaptation)
        {
        DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
        DEBUG_API("<-XARecordItfAdapt_SetRecordState");
        return XA_RESULT_PARAMETER_INVALID;
        }

    mCtx = (XAMediaRecorderAdaptationCtx*) bCtx;

    mCtx->isRecord = XA_BOOLEAN_TRUE;

    switch (state)
        {
        case XA_RECORDSTATE_STOPPED:
            {
            // Audio sourse should be stopped 
            if (mCtx->audiosource)
                {
                if (gst_element_send_event(mCtx->audiosource,
                        gst_event_new_eos()) == TRUE)
                    {
                    DEBUG_INFO ("posted eos");
                    }
                else
                    {
                    DEBUG_ERR("FAIL : post eos");
                    }
                }

            if (cameraCtx && cameraRealized && mCtx->isobjvsrc
                    && mCtx->videosource)
                {
                cameraCtx->recording = XA_BOOLEAN_FALSE;

                if (!cameraCtx->playing && !cameraCtx->snapshotting)
                    {
                    /* Neither view finder or recorder is running -> pause camera */
                    if (GST_STATE( GST_ELEMENT(mCtx->videosource))
                            == GST_STATE_PLAYING)
                        {
                        GstStateChangeReturn gret;
                        DEBUG_INFO("Stop camera source");
                        gret = gst_element_set_state(
                                GST_ELEMENT(mCtx->videosource),
                                GST_STATE_PAUSED);
                        if (gret == GST_STATE_CHANGE_SUCCESS)
                            gret = gst_element_get_state(
                                    GST_ELEMENT(mCtx->videosource), NULL,
                                    NULL, XA_ADAPT_ASYNC_TIMEOUT_SHORT_NSEC);
                        }
                    }
                }

            bCtx->binWantedState = GST_STATE_PAUSED;
            closeSink = XA_BOOLEAN_TRUE;
            if (mCtx->runpositiontimer > 0)
                {
                g_source_remove(mCtx->runpositiontimer);
                mCtx->runpositiontimer = 0;
                }

            if (mCtx->recThrCtx.bufInsufficientSem)
                {
                DEBUG_INFO("No buffer-insufficient received, posting record thr semaphore.");
                if (XAImpl_PostSemaphore(mCtx->recThrCtx.bufInsufficientSem)
                        != XA_RESULT_SUCCESS)
                    {
                    DEBUG_ERR("Posting buffer-insufficient semaphore FAILED!");
                    }
                }

            break;
            }
        case XA_RECORDSTATE_PAUSED:
            {
            if (cameraCtx && cameraRealized && mCtx->isobjvsrc
                    && mCtx->videosource)
                {
                cameraCtx->recording = XA_BOOLEAN_FALSE;
                if (!cameraCtx->playing && !cameraCtx->snapshotting)
                    {
                    /* Neither view finder or recorder is running -> pause camera */
                    if (GST_STATE( GST_ELEMENT(mCtx->videosource))
                            == GST_STATE_PLAYING)
                        {
                        GstStateChangeReturn gret;
                        DEBUG_INFO("Stop camera source");
                        gret = gst_element_set_state(
                                GST_ELEMENT(mCtx->videosource),
                                GST_STATE_PAUSED);
                        if (gret == GST_STATE_CHANGE_SUCCESS)
                            gret = gst_element_get_state(
                                    GST_ELEMENT(mCtx->videosource), NULL,
                                    NULL, XA_ADAPT_ASYNC_TIMEOUT_SHORT_NSEC);
                        }
                    }
                }

            if (mCtx->xaRecordState == XA_RECORDSTATE_STOPPED
                    && mCtx->encodingchanged)
                {
                XAMediaRecorderAdapt_ChangeEncoders(mCtx);
                mCtx->encodingchanged = XA_BOOLEAN_FALSE;
                }
            bCtx->binWantedState = GST_STATE_PAUSED;
            if (mCtx->runpositiontimer > 0)
                {
                g_source_remove(mCtx->runpositiontimer);
                mCtx->runpositiontimer = 0;
                }
            break;
            }
        case XA_RECORDSTATE_RECORDING:
            {
            if (cameraCtx && mCtx->isobjvsrc)
                {
                cameraCtx->recording = XA_BOOLEAN_TRUE;
                }

            if (mCtx->xaRecordState == XA_RECORDSTATE_STOPPED
                    && (mCtx->encodingchanged))
                {
                XAMediaRecorderAdapt_ChangeEncoders(mCtx);
                mCtx->encodingchanged = XA_BOOLEAN_FALSE;
                }

            if (mCtx->recThrCtx.bufInsufficientSem)
                {
                /* Recording to address and recording thread semaphora is created */
                if (!XAImpl_StartThread(&(mCtx->recordingEventThr), NULL,
                        &XAMediaRecorderAdapt_RecordEventThr, (void*) mCtx))
                    {
                    DEBUG_ERR("Start thread Failed");
                    return XA_RESULT_INTERNAL_ERROR;
                    }
                }

            bCtx->binWantedState = GST_STATE_PLAYING;
            recording = XA_BOOLEAN_TRUE;
            break;
            }
        default:
            DEBUG_ERR("Unhandled state")
            ;
            ret = XA_RESULT_PARAMETER_INVALID;
            break;
        }

    if (ret == XA_RESULT_SUCCESS)
        {
        mCtx->xaRecordState = state;
        }

    /* launch Gstreamer state change only if necessary */
    if (GST_STATE_TARGET(bCtx->bin) == bCtx->binWantedState)
        {
        DEBUG_INFO("Gst already transitioning to wanted state!!");
        requestStateChange = XA_BOOLEAN_FALSE;
        }
    else
        {
        if ((GST_STATE(bCtx->bin) == bCtx->binWantedState)
                && (GST_STATE_PENDING(bCtx->bin) == GST_STATE_VOID_PENDING))
            {
            DEBUG_ERR_A3("WARNING : gststate %d == wanted %d != gsttarget %d and no statechange pending",
                    GST_STATE(bCtx->bin), bCtx->binWantedState, GST_STATE_TARGET(bCtx->bin));
            }
        requestStateChange = XA_BOOLEAN_TRUE;
        }

    if (requestStateChange)
        {
        XAAdaptationGst_PrepareAsyncWait(bCtx);
        DEBUG_INFO_A1("Sending change state request to state %d", bCtx->binWantedState);
        gstRet = gst_element_set_state(GST_ELEMENT(bCtx->bin),
                bCtx->binWantedState);
        switch (gstRet)
            {
            case GST_STATE_CHANGE_FAILURE:
                DEBUG_ERR_A1("FAILED to change state (target %d)",bCtx->binWantedState)
                ;
                bCtx->binWantedState = GST_STATE(bCtx->bin);
                ret = XA_RESULT_INTERNAL_ERROR;
                break;
            case GST_STATE_CHANGE_ASYNC:
                DEBUG_INFO_A1("Change state will happen asyncronously (target %d)",bCtx->binWantedState);
                XAAdaptationGst_StartAsyncWait(bCtx);
                ret = XA_RESULT_SUCCESS;
                break;
            case GST_STATE_CHANGE_NO_PREROLL:
                DEBUG_INFO("GST_STATE_CHANGE_NO_PREROLL")
                ;
                /* deliberate fall-through */
            case GST_STATE_CHANGE_SUCCESS:
                DEBUG_INFO_A1("Successfully changed state (target %d)",bCtx->binWantedState)
                ;
                ret = XA_RESULT_SUCCESS;
                break;
            default:
                DEBUG_ERR_A1("Unhandled error (%d)",gstRet)
                ;
                ret = XA_RESULT_UNKNOWN_ERROR;
                break;
            }
        bCtx->waitingasyncop = XA_BOOLEAN_FALSE;
        }
    if ((GST_STATE(bCtx->bin) > GST_STATE_READY) && closeSink)
        { /* close the sink*/
        gst_element_send_event(bCtx->bin, gst_event_new_flush_start());
        gst_element_send_event(bCtx->bin, gst_event_new_flush_stop());
        }

    if (recording && mCtx->isobjvsrc && mCtx->videosource)
        {
        GstPad *pad = gst_element_get_static_pad(
                GST_ELEMENT(mCtx->videosource), "MRObjSrc");
        if (pad && gst_pad_is_linked(pad))
            {
            DEBUG_INFO_A2("unblock element:%s pad:%s",
                    gst_element_get_name(mCtx->videosource),
                    gst_pad_get_name(pad));
            gst_pad_set_blocked_async(pad, FALSE, XAAdaptationGst_PadBlockCb,
                    NULL);
            }

        if (GST_STATE( GST_ELEMENT(mCtx->videosource)) != GST_STATE_PLAYING)
            {
            GstStateChangeReturn gret = GST_STATE_CHANGE_SUCCESS;
            DEBUG_INFO("Start camera source");
            gret = gst_element_set_state(GST_ELEMENT(mCtx->videosource),
                    GST_STATE_PLAYING);
            if (gret == GST_STATE_CHANGE_SUCCESS)
                gret = gst_element_get_state(GST_ELEMENT(mCtx->videosource),
                        NULL, NULL, XA_ADAPT_ASYNC_TIMEOUT_SHORT_NSEC);
            }
        }DEBUG_API("<-XARecordItfAdapt_SetRecordState");
    return ret;
    }

/*
 * XAresult XARecordItfAdapt_GetRecordState(XAAdaptationGstCtx *bCtx, XAuint32 *state)
 * Description: Return record state
 */
XAresult XARecordItfAdapt_GetRecordState(XAAdaptationGstCtx *bCtx,
        XAuint32 *state)
    {
    XAMediaRecorderAdaptationCtx* mCtx = NULL;
    DEBUG_API("->XARecordItfAdapt_GetRecordState");

    if (!bCtx || bCtx->baseObj.ctxId != XAMediaRecorderAdaptation)
        {
        DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
        DEBUG_API("<-XARecordItfAdapt_GetRecordState");
        return XA_RESULT_PARAMETER_INVALID;
        }

    mCtx = (XAMediaRecorderAdaptationCtx*) bCtx;

    *state = mCtx->xaRecordState;

    DEBUG_API("<-XARecordItfAdapt_GetRecordState");
    return XA_RESULT_SUCCESS;
    }

/*
 * XAresult XARecordItfAdapt_GetPosition(XAAdaptationGstCtx *ctx, AdaptationContextIDS ctxIDs, XAmillisecond *pMsec)
 * @param XAAdaptationGstCtx *ctx - Adaptation context, this will be casted to correct type regarding to contextID value given as 2nd parameter
 * XAmillisecond *pMsec - Pointer where to store current position in stream.
 * @return XAresult ret - Success value
 */
XAresult XARecordItfAdapt_GetPosition(XAAdaptationGstCtx *bCtx,
        XAmillisecond *pMsec)
    {
    XAresult ret = XA_RESULT_SUCCESS;

    gint64 position = 0;
    GstFormat format = GST_FORMAT_TIME;
    DEBUG_API("->XARecordItfAdapt_GetPosition");

    if (!bCtx || bCtx->baseObj.ctxId != XAMediaRecorderAdaptation)
        {
        DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
        DEBUG_API("<-XARecordItfAdapt_GetPosition");
        /* invalid parameter */
        return XA_RESULT_PARAMETER_INVALID;
        }
    if (gst_element_query_position(GST_ELEMENT(bCtx->bin), &format, &position))
        {
        ret = XA_RESULT_SUCCESS;
        *pMsec = GST_TIME_AS_MSECONDS(position); /*Warning ok due to used API specification*/
        DEBUG_INFO_A1("Gst: Position in microseconds : %u", *pMsec );
        }
    else
        {
        DEBUG_ERR("WARNING: Gst: could not get position");
        /* probably not fully prerolled - safe assumption for position = 0 */
        *pMsec = 0;
        ret = XA_RESULT_SUCCESS;
        }

    DEBUG_API("<-XARecordItfAdapt_GetPosition");
    return ret;
    }

/*
 * gboolean XARecordItfAdapt_PositionUpdate(gpointer ctx)
 * callback.
 * If position tracking enabled, periodic timer calls this method every XA_ADAPT_PU_INTERVAL msecs
 * @return false to stop periodic calls
 */
gboolean XARecordItfAdapt_PositionUpdate(gpointer ctx)
    {
    XAAdaptationGstCtx *bCtx = (XAAdaptationGstCtx*) ctx;
    XAMediaRecorderAdaptationCtx* mCtx = (XAMediaRecorderAdaptationCtx*) ctx;
    DEBUG_API("->XARecordItfAdapt_PositionUpdate");

    if (mCtx && mCtx->trackpositionenabled)
        {
        GstFormat format = GST_FORMAT_TIME;
        gint64 position = 0;
        if (gst_element_query_position(GST_ELEMENT(bCtx->bin), &format,
                &position))
            {
            XAuint32 posMsec = GST_TIME_AS_MSECONDS(position);
            /*Warning ok due to used API specification*/
            XAAdaptEvent event =
                {
                XA_RECORDITFEVENTS, XA_ADAPT_POSITION_UPDATE_EVT, 1, NULL
                };
            event.data = &posMsec;
            DEBUG_API_A1("XARecordItfAdapt_PositionUpdate: pos %lu ms", posMsec);
            /* send needed events */
            XAAdaptationBase_SendAdaptEvents(&bCtx->baseObj, &event);
            }
        else
            {
            DEBUG_ERR("Gst: Failed to get position");
            }
        DEBUG_API_A1("<-XARecordItfAdapt_PositionUpdate: %d", mCtx->runpositiontimer);
        /* return false to stop timer */
        return (mCtx->runpositiontimer);
        }
    return FALSE;
    }

/*
 * XAresult XARecordItfAdapt_EnablePositionTracking
 * Enable/disable periodic position tracking callbacks
 */
XAresult XARecordItfAdapt_EnablePositionTracking(XAAdaptationGstCtx *bCtx,
        XAboolean enable)
    {
    XAMediaRecorderAdaptationCtx* mCtx = (XAMediaRecorderAdaptationCtx*) bCtx;
    DEBUG_API_A1("->XARecordItfAdapt_EnablePositionTracking (enable: %lu)", enable);

    if (!bCtx || bCtx->baseObj.ctxId != XAMediaRecorderAdaptation)
        {
        DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
        DEBUG_API("<-XARecordItfAdapt_EnablePositionTracking");
        /* invalid parameter */
        return XA_RESULT_PARAMETER_INVALID;
        }

    /* create a timer to track position of playback */
    if (enable && !(mCtx->trackpositionenabled))
        {
        mCtx->trackpositionenabled = XA_BOOLEAN_TRUE;
        mCtx->positionCb = &XARecordItfAdapt_PositionUpdate;
        /* if recording is already on, create a timer to track position of recording */
        if (GST_STATE(bCtx->bin) == GST_STATE_PLAYING)
            {
            mCtx->runpositiontimer = g_timeout_add(XA_ADAPT_PU_INTERVAL,
                    mCtx->positionCb, mCtx);
            }
        }
    else if (!enable && (mCtx->trackpositionenabled))
        {
        mCtx->trackpositionenabled = XA_BOOLEAN_FALSE;
        if (mCtx->runpositiontimer > 0)
            {
            g_source_remove(mCtx->runpositiontimer);
            mCtx->runpositiontimer = 0;
            }
        }

    DEBUG_API("<-XARecordItfAdapt_EnablePositionTracking");
    return XA_RESULT_SUCCESS;
    }