/*

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

#include <gst.h>

#include <gstappsrc.h>

#include <gstappsink.h>

#include "XAAdaptation.h"

#include "XASnapShotItfAdaptation.h"

#include "XAMediaRecorderAdaptCtx.h"

#include "XAMetadataAdaptation.h"

#include "XAStaticCapsAdaptation.h"

#define SSMAXPIC 30

#define SSMAXFPS 30 /*technically, same as FPS of video stream*/

#define SSMINFPS 1

extern XAboolean cameraRealized;

extern XACameraAdaptationCtx_* cameraCtx;

/* Forward declarations for internal methods */

XAresult XASnapshotItfAdaptation_CreateSnapshotPipeline(XAAdaptationBaseCtx* bCtx);

XAresult XASnapshotItfAdaptation_FreeSnapshot();

const char* XASnapshotItfAdaptation_GetFileSuffix(XADataFormat_MIME* format);

void XASnapshotItfAdaptation_AllocNextFilename(char** fname, const char* template);

void XASnapshotItfAdaptation_StopSnapshotting(XAAdaptationBaseCtx* bCtx);

/* callbacks */

gboolean XASnapshotItfAdaptation_SnapshotBusCb( GstBus *bus, GstMessage *message, gpointer data );

void XASnapshotItfAdaptation_BufferHandoffCb( GstElement *extract, GstBuffer *buffer, gpointer data);

/*********************************

 * SnapshotItf adaptation methods

 *********************************/

/*

 * XAresult XASnapshotItfAdaptation_InitiateSnapshot(XAAdaptationBaseCtx* bCtx,

 *                                                 XAuint32 numberOfPictures,

 *                                                 XAuint32 fps,

 *                                                 XAboolean freezeViewFinder,

 *                                                 XADataSink* sink)

 */

XAresult XASnapshotItfAdaptation_InitiateSnapshot(XAAdaptationBaseCtx* bCtx,

                                                  XAuint32 numberOfPictures,

                                                  XAuint32 fps,

                                                  XAboolean freezeViewFinder,

                                                  XADataSink* sink)

{

    XAMediaRecorderAdaptationCtx* mCtx = (XAMediaRecorderAdaptationCtx*)bCtx;

    XADataLocator_URI* uri=NULL;

    DEBUG_API("->XASnapshotItfAdaptation_InitiateSnapshot");

    /* Store initialization variables */

    mCtx->snapshotVars.numpics = numberOfPictures;

    mCtx->snapshotVars.fps = fps;

    mCtx->snapshotVars.freeze =freezeViewFinder;

    mCtx->snapshotVars.parsenegotiated = FALSE;

    mCtx->snapshotVars.snapshotbuffer = NULL;

    if( sink )

    {   /* parse file sink name*/

        if( sink->pLocator && *((XAuint32*)(sink->pLocator)) == XA_DATALOCATOR_URI )

        {

            uri = (XADataLocator_URI*)sink->pLocator;

            if ( uri->URI != NULL )

            {

                /* parse filename template: <prefix><nnnn><suffix> */

                mCtx->snapshotVars.fnametemplate = calloc(1,strlen((char*)uri->URI)+10);

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

                if(strncmp((char*)uri->URI, "file://", 7) == 0)

                {

                    strcat(mCtx->snapshotVars.fnametemplate, (char*)&((uri->URI)[7]));

                }

                else

                {

                    strcat(mCtx->snapshotVars.fnametemplate, (char*)uri->URI);

                }

                strcat(mCtx->snapshotVars.fnametemplate, "%04d.");

                strcat(mCtx->snapshotVars.fnametemplate,

                        XASnapshotItfAdaptation_GetFileSuffix(sink->pFormat));

                DEBUG_INFO_A1("->template name %s", mCtx->snapshotVars.fnametemplate);

            }

            else

            {

                DEBUG_ERR("No uri specified.");

                return XA_RESULT_PARAMETER_INVALID;

            }

        }

        else

        { /* take snapshot to memory buffer */

            if( mCtx->snapshotVars.fnametemplate )

            {

                free( mCtx->snapshotVars.fnametemplate );

            }

            mCtx->snapshotVars.fnametemplate = NULL;

        }

        if( sink->pFormat && *((XAuint32*)(sink->pFormat)) == XA_DATAFORMAT_RAWIMAGE )

        {

            XADataFormat_RawImage* img = ((XADataFormat_RawImage*)sink->pFormat);

            /*set needed image settings from the sink structure*/

            mCtx->imageEncSettings.encoderId = XA_IMAGECODEC_RAW;

            mCtx->imageEncSettings.width = img->width;

            mCtx->imageEncSettings.height = img->height;

            mCtx->imageEncSettings.colorFormat = img->colorFormat;

        }

    }

    else

    {

        DEBUG_ERR("XASnapshotItfAdaptation_InitiateSnapshot, invalid data sink!");

        DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

        DEBUG_API("<-XASnapshotItfAdaptation_InitiateSnapshot");

        return XA_RESULT_PARAMETER_INVALID;

    }

    if( mCtx->snapshotVars.sspipeline )

    {

        XASnapshotItfAdaptation_FreeSnapshot(bCtx);

    }

    if( XASnapshotItfAdaptation_CreateSnapshotPipeline(bCtx) != XA_RESULT_SUCCESS )

    {

        DEBUG_ERR("Failed to create pipeline!!");

        DEBUG_ERR("XA_RESULT_INTERNAL_ERROR");

        DEBUG_API("<-XASnapshotItfAdaptation_InitiateSnapshot");

        return XA_RESULT_INTERNAL_ERROR;

    }

    DEBUG_API("<-XASnapshotItfAdaptation_InitiateSnapshot");

    return XA_RESULT_SUCCESS;

}

/*

 * XAresult XASnapshotItfAdaptation_TakeSnapshot(XAAdaptationBaseCtx* bCtx)

 */

XAresult XASnapshotItfAdaptation_TakeSnapshot(XAAdaptationBaseCtx* bCtx)

{

    XAMediaRecorderAdaptationCtx* mCtx = NULL;

    DEBUG_API("->XASnapshotItfAdaptation_TakeSnapshot");

    if(!bCtx || bCtx->ctxId != XAMediaRecorderAdaptation )

    {

        DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

        DEBUG_API("<-XASnapshotItfAdaptation_TakeSnapshot");

        /* invalid parameter */

        return XA_RESULT_PARAMETER_INVALID;

    }

    mCtx = (XAMediaRecorderAdaptationCtx*)bCtx;

    /*to get buffer, base pipeline must be playing...*/

    if( GST_STATE(mCtx->baseObj.bin) != GST_STATE_PLAYING )

    {

        DEBUG_INFO_A1("Parent bin in state %d, set to PLAYING", GST_STATE(mCtx->baseObj.bin));

        gst_element_set_state( GST_ELEMENT(mCtx->baseObj.bin), GST_STATE_PLAYING );

        gst_element_get_state( GST_ELEMENT(mCtx->baseObj.bin), NULL,NULL, XA_ADAPT_ASYNC_TIMEOUT_SHORT_NSEC);

    }

    if ( mCtx->isobjvsrc && mCtx->videosource && cameraCtx && cameraRealized )

    {

    	GstPad *pad=NULL;

    	GstPad *pad1=NULL;

    	cameraCtx->snapshotting = XA_BOOLEAN_TRUE;

    	pad = gst_element_get_static_pad( GST_ELEMENT(cameraCtx->baseObj.bin), "MRObjSrc");

		if( pad && gst_pad_is_linked(pad) )

		{

			DEBUG_INFO_A2("unblock element:%s pad:%s",

					gst_element_get_name(cameraCtx->baseObj.bin),

					gst_pad_get_name(pad));

			gst_pad_set_blocked_async(pad, FALSE, XAAdaptationBase_PadBlockCb, NULL);

		}

    	pad1 = gst_element_get_static_pad( GST_ELEMENT(cameraCtx->baseObj.bin), "MPObjSrc");

		if( pad1 && gst_pad_is_linked(pad1) )

		{

			DEBUG_INFO_A2("unblock element:%s pad:%s",

					gst_element_get_name(cameraCtx->baseObj.bin),

					gst_pad_get_name(pad1));

			gst_pad_set_blocked_async(pad, FALSE, XAAdaptationBase_PadBlockCb, NULL);

		}

    	DEBUG_INFO_A1("Using camera from global pointer %x", cameraCtx);

    	if ( GST_STATE( GST_ELEMENT(cameraCtx->baseObj.bin)) != GST_STATE_PLAYING )

		{

			cameraCtx->baseObj.binWantedState = GST_STATE(cameraCtx->baseObj.bin);

			DEBUG_INFO_A1("Camerabin state %d, set to PLAYING", GST_STATE(GST_ELEMENT(cameraCtx->baseObj.bin)));

			gst_element_set_state( GST_ELEMENT(cameraCtx->baseObj.bin), GST_STATE_PLAYING );

			gst_element_get_state( GST_ELEMENT(cameraCtx->baseObj.bin), NULL,NULL, XA_ADAPT_ASYNC_TIMEOUT_SHORT_NSEC);

		}

	}

    /* Connect signal for getting current buffer from video pipeline*/

    mCtx->snapshotVars.numpicstaken = 0;

    mCtx->snapshotVars.waitforbuffer = TRUE;

    if(mCtx->videoextract)

    {

        mCtx->snapshotVars.sighandler = g_signal_connect(mCtx->videoextract, "handoff",

                                G_CALLBACK (XASnapshotItfAdaptation_BufferHandoffCb),mCtx);

    }

    if( mCtx->snapshotVars.sighandler==0 )

    {

        DEBUG_ERR("XA_RESULT_INTERNAL_ERROR");

        DEBUG_API("<-XASnapshotItfAdaptation_TakeSnapshot");

        return XA_RESULT_INTERNAL_ERROR;

    }

    DEBUG_API("<-XASnapshotItfAdaptation_TakeSnapshot");

    return XA_RESULT_SUCCESS;

}

/*

 * XAresult XASnapshotItfAdaptation_CancelSnapshot(XAAdaptationBaseCtx* bCtx)

 */

XAresult XASnapshotItfAdaptation_CancelSnapshot(XAAdaptationBaseCtx* bCtx)

{

    DEBUG_API("->XASnapshotItfAdaptation_CancelSnapshot");

    if(!bCtx || bCtx->ctxId != XAMediaRecorderAdaptation )

    {

        DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

        DEBUG_API("<-XASnapshotItfAdaptation_CancelSnapshot");

        /* invalid parameter */

        return XA_RESULT_PARAMETER_INVALID;

    }

    XASnapshotItfAdaptation_FreeSnapshot(bCtx);

    DEBUG_API("<-XASnapshotItfAdaptation_CancelSnapshot");

    return XA_RESULT_SUCCESS;

}

/*

 * XAresult XASnapshotItfAdaptation_GetMaxPicsPerBurst(XAAdaptationBaseCtx* bCtx,

 *                                              XAuint32 *maxNumberOfPictures)

 */

XAresult XASnapshotItfAdaptation_GetMaxPicsPerBurst(XAAdaptationBaseCtx* bCtx,

                                              XAuint32 *maxNumberOfPictures)

{

    DEBUG_API("->XASnapshotItfAdaptation_GetMaxPicsPerBurst");

    if(!bCtx || bCtx->ctxId != XAMediaRecorderAdaptation )

    {

        DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

        DEBUG_API("<-XASnapshotItfAdaptation_GetMaxPicsPerBurst");

        return XA_RESULT_PARAMETER_INVALID;

    }

    *maxNumberOfPictures = SSMAXPIC;

    DEBUG_API("<-XASnapshotItfAdaptation_GetMaxPicsPerBurst");

    return XA_RESULT_SUCCESS;

}

/*

 * XAresult XASnapshotItfAdaptation_GetBurstFPSRange(XAAdaptationBaseCtx* bCtx,

 *                                            XAuint32 *minFPS,

 *                                           XAuint32 *maxFPS)

 */

XAresult XASnapshotItfAdaptation_GetBurstFPSRange(XAAdaptationBaseCtx* bCtx,

                                            XAuint32 *minFPS,

                                            XAuint32 *maxFPS)

{

    DEBUG_API("->XASnapshotItfAdaptation_GetBurstFPSRange");

    if(!bCtx || bCtx->ctxId != XAMediaRecorderAdaptation )

        {

            DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

            DEBUG_API("<-XASnapshotItfAdaptation_GetBurstFPSRange");

            return XA_RESULT_PARAMETER_INVALID;

        }

    *minFPS = SSMINFPS;

    *maxFPS = SSMAXFPS;

    DEBUG_API("<-XASnapshotItfAdaptation_GetBurstFPSRange");

    return XA_RESULT_SUCCESS;

}

/*

 * XAresult XASnapshotItfAdaptation_SetShutterFeedback(XAAdaptationBaseCtx* bCtx,

 *                                              XAboolean enabled)

 */

XAresult XASnapshotItfAdaptation_SetShutterFeedback(XAAdaptationBaseCtx* bCtx,

                                              XAboolean enabled)

{

    DEBUG_API("->XASnapshotItfAdaptation_SetShutterFeedback");

    if(!bCtx || bCtx->ctxId != XAMediaRecorderAdaptation )

    {

        DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

        DEBUG_API("<-XASnapshotItfAdaptation_SetShutterFeedback");

        /* invalid parameter */

        return XA_RESULT_PARAMETER_INVALID;

    }

    /* stubbed, no implementation */

    DEBUG_API("<-XASnapshotItfAdaptation_SetShutterFeedback");

    return XA_RESULT_SUCCESS;

}

/********************

 * Internal methods

 ********************/

/*

 * void XASnapshotItfAdaptation_StopSnapshotting(XAAdaptationBaseCtx* bCtx)

 */

void XASnapshotItfAdaptation_StopSnapshotting(XAAdaptationBaseCtx* bCtx)

{

    XAMediaRecorderAdaptationCtx* mCtx = (XAMediaRecorderAdaptationCtx*) bCtx;

    DEBUG_API("->XASnapshotItfAdaptation_StopSnapshotting");

    mCtx->snapshotVars.waitforbuffer = FALSE;

    mCtx->snapshotVars.snapshotbuffer = NULL;

    if(mCtx->snapshotVars.sighandler)

    {

        if(mCtx->videoextract)

        {

            g_signal_handler_disconnect(mCtx->videoextract,mCtx->snapshotVars.sighandler);

        }

        mCtx->snapshotVars.sighandler = 0;

    }

    /* did we change the state of parent pipeline?*/

    if( mCtx->baseObj.bin && (GST_STATE(mCtx->baseObj.bin) != mCtx->baseObj.binWantedState) )

    {

        gst_element_set_state( GST_ELEMENT(mCtx->baseObj.bin), mCtx->baseObj.binWantedState );

    }

    if ( cameraCtx && (GST_STATE(cameraCtx->baseObj.bin) != cameraCtx->baseObj.binWantedState) )

	{

    	cameraCtx->snapshotting = XA_BOOLEAN_FALSE;

		DEBUG_INFO_A2("Camerabin state %d, restored to %d", GST_STATE(cameraCtx->baseObj.bin), cameraCtx->baseObj.binWantedState );

		gst_element_set_state( GST_ELEMENT(cameraCtx->baseObj.bin), cameraCtx->baseObj.binWantedState );

		gst_element_get_state( GST_ELEMENT(cameraCtx->baseObj.bin), NULL,NULL, XA_ADAPT_ASYNC_TIMEOUT_SHORT_NSEC);

	}

    DEBUG_API("<-XASnapshotItfAdaptation_StopSnapshotting");

}

/*

 * XAresult XASnapshotItfAdaptation_FreeSnapshot(XAAdaptationBaseCtx* bCtx)

 */

XAresult XASnapshotItfAdaptation_FreeSnapshot(XAAdaptationBaseCtx* bCtx)

{

    XAMediaRecorderAdaptationCtx* mCtx = NULL;

    DEBUG_API("->XASnapshotItfAdaptation_FreeSnapshot");

    if(!bCtx || bCtx->ctxId != XAMediaRecorderAdaptation)

    {

        DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

        DEBUG_API("<-XASnapshotItfAdaptation_FreeSnapshot");

        return XA_RESULT_PARAMETER_INVALID;

    }

    mCtx = (XAMediaRecorderAdaptationCtx*) bCtx;

    XASnapshotItfAdaptation_StopSnapshotting(bCtx);

    /* Clean up pipeline and set current pipeline state to null*/

    if( mCtx->snapshotVars.sspipeline )

    {

        gst_element_set_state( GST_ELEMENT(mCtx->snapshotVars.sspipeline), GST_STATE_NULL );

        gst_object_unref( GST_OBJECT(mCtx->snapshotVars.sspipeline) );

        mCtx->snapshotVars.sspipeline = NULL;

    }

    if( mCtx->snapshotVars.ssbus )

    {

        gst_object_unref( GST_OBJECT(mCtx->snapshotVars.ssbus) );

        mCtx->snapshotVars.ssbus = NULL;

    }

    if( mCtx->snapshotVars.fnametemplate )

    {

        free(mCtx->snapshotVars.fnametemplate);

        mCtx->snapshotVars.fnametemplate=NULL;

    }

    DEBUG_API("<-XASnapshotItfAdaptation_FreeSnapshot");

    return XA_RESULT_SUCCESS;

}

/*

 * XAresult XASnapshotItfAdaptation_CreateSnapshotPipeline(XAAdaptationBaseCtx* bCtx)

 */

XAresult XASnapshotItfAdaptation_CreateSnapshotPipeline(XAAdaptationBaseCtx* bCtx)

{

    XAMediaRecorderAdaptationCtx* mCtx = NULL;

    GstStateChangeReturn gstRet = GST_STATE_CHANGE_SUCCESS;

    XAStaticCapsData temp;

    GstCaps *imageCaps=NULL;

    DEBUG_API("->XASnapshotItfAdaptation_CreateSnapshotPipeline");

    if(!bCtx || bCtx->ctxId != XAMediaRecorderAdaptation)

    {

        DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

        return XA_RESULT_PARAMETER_INVALID;

    }

    mCtx = (XAMediaRecorderAdaptationCtx*) bCtx;

    /*Create snapshotpipeline*/

    mCtx->snapshotVars.sspipeline = gst_pipeline_new ("sspipeline");

    if( mCtx->snapshotVars.sspipeline  )

    {

        /*add listener*/

        mCtx->snapshotVars.ssbus = gst_pipeline_get_bus(GST_PIPELINE( mCtx->snapshotVars.sspipeline ) );

        if( ! mCtx->snapshotVars.ssbus )

        {

            DEBUG_API("Cannot create snapshotbus");

            DEBUG_API("<-XASnapshotItfAdaptation_CreateSnapshotPipeline - XA_RESULT_INTERNAL_ERROR");

            return XA_RESULT_INTERNAL_ERROR;

        }

        gst_bus_add_signal_watch( mCtx->snapshotVars.ssbus );

        g_signal_connect(mCtx->snapshotVars.ssbus, "message::eos",

                G_CALLBACK(XASnapshotItfAdaptation_SnapshotBusCb), bCtx );

        g_signal_connect(mCtx->snapshotVars.ssbus, "message::state-changed",

                G_CALLBACK(XASnapshotItfAdaptation_SnapshotBusCb), bCtx );

        g_signal_connect(mCtx->snapshotVars.ssbus, "message::async-done",

                G_CALLBACK(XASnapshotItfAdaptation_SnapshotBusCb), bCtx );

        /*Create snapshotsource element*/

        mCtx->snapshotVars.ssbuffersrc = gst_element_factory_make("appsrc", "ssbuffersrc");

        if( !mCtx->snapshotVars.ssbuffersrc )

        {

            DEBUG_ERR("Cannot create ssbuffersrc!");

            DEBUG_API("<-XASnapshotItfAdaptation_CreateSnapshotPipeline - XA_RESULT_INTERNAL_ERROR");

            return XA_RESULT_INTERNAL_ERROR;

        }

        /*Frame parser*/

        mCtx->snapshotVars.ssparser =

            gst_element_factory_make("videoparse","ssparser");

        if( !mCtx->snapshotVars.ssparser )

        {

            DEBUG_ERR("Could not create snapshotparse");

            DEBUG_API("<-XASnapshotItfAdaptation_CreateSnapshotPipeline - XA_RESULT_INTERNAL_ERROR");

            return XA_RESULT_INTERNAL_ERROR;

        }

        /*Scaler and filter for XAImageSettings width&height*/

        mCtx->snapshotVars.ssscaler =

            gst_element_factory_make("videoscale","ssscaler");

        if( !mCtx->snapshotVars.ssscaler )

        {

            DEBUG_ERR("Could not create ssscaler");

            DEBUG_API("<-XASnapshotItfAdaptation_CreateSnapshotPipeline - XA_RESULT_INTERNAL_ERROR");

            return XA_RESULT_INTERNAL_ERROR;

        }

        mCtx->snapshotVars.ssfilter =

            gst_element_factory_make("capsfilter","ssfilter");

        if( !mCtx->snapshotVars.ssfilter )

        {

            DEBUG_ERR("Could not create ssfilter");

            DEBUG_API("<-XASnapshotItfAdaptation_CreateSnapshotPipeline - XA_RESULT_INTERNAL_ERROR");

            return XA_RESULT_INTERNAL_ERROR;

        }

        /*Create imageencoder */

        if(XAStaticCapsAdapt_GetCapsById(XACAP_ENCODER|XACAP_IMAGE, mCtx->imageEncSettings.encoderId, &temp) == XA_RESULT_SUCCESS)

        {

            if(temp.adaptId!=NULL)

            {

                mCtx->snapshotVars.ssencoder = gst_element_factory_make((char*)temp.adaptId, "ssencoder");

            }

            else if(mCtx->imageEncSettings.encoderId == XA_IMAGECODEC_RAW)

            {

                /* raw frames are internal format, so no codec needed. just insert identity for linking*/

               mCtx->snapshotVars.ssencoder = gst_element_factory_make("identity", "ssencoder");

            }

        }

        if( !mCtx->snapshotVars.ssencoder )

        {

            DEBUG_API("Cannot create image encoder");

            DEBUG_API("<-XASnapshotItfAdaptation_CreateSnapshotPipeline - XA_RESULT_INTERNAL_ERROR");

            return XA_RESULT_INTERNAL_ERROR;

        }

        /* Create also tag setter for JPG */

        if(mCtx->imageEncSettings.encoderId == XA_IMAGECODEC_JPEG)

        {

            mCtx->snapshotVars.sstagger = gst_element_factory_make("metadatamux", "sstagger");

            if( !mCtx->snapshotVars.sstagger || !gst_bin_add(GST_BIN(mCtx->snapshotVars.sspipeline),mCtx->snapshotVars.sstagger))

            {

                DEBUG_API("Cannot create metadatamux");

                DEBUG_API("<-XASnapshotItfAdaptation_CreateSnapshotPipeline - XA_RESULT_INTERNAL_ERROR");

            }

            g_object_set( G_OBJECT(mCtx->snapshotVars.sstagger), "xmp", TRUE, "exif", TRUE, "iptc", TRUE, NULL );

        }

        /*Create sink*/

        if(mCtx->snapshotVars.fnametemplate)

        {

            DEBUG_INFO("RECORD SNAPSHOT TO FILE");

            mCtx->snapshotVars.sssink = gst_element_factory_make("filesink","ssfilesink");

            g_object_set( G_OBJECT(mCtx->snapshotVars.sssink), "location", "temp",

                                                                "async", FALSE,

                                                                "qos", FALSE,

                                                                "max-lateness", (gint64)(-1),

                                                                "buffer-mode", 2,

                                                                NULL );

        }

        else

        {

            DEBUG_INFO("RECORD SNAPSHOT TO MEMORY");

            mCtx->snapshotVars.sssink = gst_element_factory_make("appsink","ssbuffersink");

        }

        if( !mCtx->snapshotVars.sssink )

        {

            DEBUG_ERR("Could not create sssink!!");

            DEBUG_API("<-XASnapshotItfAdaptation_CreateSnapshotPipeline - XA_RESULT_INTERNAL_ERROR");

            return XA_RESULT_INTERNAL_ERROR;

        }

        g_object_set( G_OBJECT(mCtx->snapshotVars.sssink), "async", FALSE, NULL );

        /*Add elements to bin*/

        gst_bin_add_many (GST_BIN (mCtx->snapshotVars.sspipeline),

                mCtx->snapshotVars.ssbuffersrc,

                mCtx->snapshotVars.ssparser,

                mCtx->snapshotVars.ssscaler,

                mCtx->snapshotVars.ssfilter,

                mCtx->snapshotVars.ssencoder,

                mCtx->snapshotVars.sssink,

                NULL);

        /* set needed XAImageSettings properties*/

        /* set caps from imagesettings */

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

                                        "width", G_TYPE_INT, mCtx->imageEncSettings.width,

                                        "height", G_TYPE_INT, mCtx->imageEncSettings.height, NULL);

        g_object_set( G_OBJECT(mCtx->snapshotVars.ssfilter), "caps", imageCaps, NULL );

        DEBUG_INFO_A1("new caps: %s",gst_caps_to_string(imageCaps));

        gst_caps_unref(imageCaps);

        /* set compression level */

        if(mCtx->imageEncSettings.encoderId == XA_IMAGECODEC_JPEG)

        {

            g_object_set( G_OBJECT(mCtx->snapshotVars.ssencoder), "quality", (gint)(1000 - mCtx->imageEncSettings.compressionLevel)/10, NULL );

        }