/*

#include <stdio.h>

#include <stdlib.h>

#include <assert.h>

#include "xamediarecorder.h"

#include "xaaudioencoderitf.h"

#include "xaconfigextensionsitf.h"

#include "xadynintmgmtitf.h"

#include "xaequalizeritf.h"

#include "xaimagecontrolsitf.h"

#include "xaimageeffectsitf.h"

#include "xaimageencoderitf.h"

#include "xametadatainsertionitf.h"

#include "xarecorditf.h"

#include "xasnapshotitf.h"

#include "xavideoencoderitf.h"

#include "xavideopostprocessingitf.h"

#include "xavolumeitf.h"

#include "xametadataextractionitf.h"

#include "xametadatatraversalitf.h"

#include "xathreadsafety.h"

#include <string.h>

#include "xacapabilitiesmgr.h"

#include "xamediarecorderadaptctxmmf.h"

#include "xamediarecorderadaptctx.h"

/* Static mapping of enumeration XAMediaRecorderInterfaces to interface iids */

/* Global methods */

/* XAResult XAMediaRecorderImpl_Create

 * Create object

 */

XAresult XAMediaRecorderImpl_CreateMediaRecorder(FrameworkMap* mapper,

    XAMediaRecorderImpl* pImpl = NULL;

    XAObjectItfImpl* pBaseObj = NULL;

    FWMgrFwType fwType;

    XAuint8 itfIdx;

    XAMediaType mediaType = XA_MEDIATYPE_UNKNOWN;

    const char *uri = NULL;

    DEBUG_API("->XAMediaRecorderImpl_CreateMediaRecorder");

    XA_IMPL_THREAD_SAFETY_ENTRY( XATSMediaRecorder );

        /* invalid parameter */

        XA_IMPL_THREAD_SAFETY_EXIT( XATSMediaRecorder );

        DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

        DEBUG_API("<-XAMediaRecorderImpl_CreateMediaRecorder");

        return XA_RESULT_PARAMETER_INVALID;

    /* check sink&source parameters */

        XA_IMPL_THREAD_SAFETY_EXIT( XATSMediaRecorder );

        DEBUG_API("<-XAMediaRecorderImpl_CreateMediaRecorder");

        return ret;

    /* instantiate object implementation */

        /* memory allocation failed */

        XA_IMPL_THREAD_SAFETY_EXIT( XATSMediaRecorder );

        DEBUG_ERR("XA_RESULT_MEMORY_FAILURE");

        DEBUG_API("<-XAMediaRecorderImpl_CreateMediaRecorder");

        return XA_RESULT_MEMORY_FAILURE;

    pBaseObj = &pImpl->baseObj;

    /* Initialize base object default implementation */

    /* Mark interfaces that need to be exposed */

    /* Implicit and mandated interfaces */

    pBaseObj->interfaceMap[MR_RECORDITF].required = XA_BOOLEAN_TRUE;

        pBaseObj->interfaceMap[MR_AUDIOENCODERITF].required = XA_BOOLEAN_TRUE;

        pBaseObj->interfaceMap[MR_VIDEOENCODER].required = XA_BOOLEAN_TRUE;

        pBaseObj->interfaceMap[MR_IMAGEENCODERITF].required = XA_BOOLEAN_TRUE;

        pBaseObj->interfaceMap[MR_SNAPSHOTITF].required = XA_BOOLEAN_TRUE;

    pBaseObj->interfaceMap[MR_DIMITF].required = XA_BOOLEAN_TRUE;

    /* Explicit interfaces */

        {

            /* If mapEntry is null then required interface is not supported.*/

                {

                    /* required interface cannot be accommodated - fail creation */

                    DEBUG_ERR("Required interface not found - abort creation!");

                    ret = XA_RESULT_FEATURE_UNSUPPORTED;

                    break;

                else

                    DEBUG_INFO("Requested (not required) interface not found - continue creation");

                }

            else

                    entry->required = XA_BOOLEAN_FALSE;

                        DEBUG_ERR("Required interface not supported for given media - abort creation!");

                        ret = XA_RESULT_FEATURE_UNSUPPORTED;

                        break;

                    }

                else

                    entry->required = XA_BOOLEAN_TRUE;

                    DEBUG_ERR("SnapshotItf requested - support still mode");

                    pImpl->recModes |= XA_RECMODE_STILL;

                    DEBUG_ERR("RecordItf requested - support stream mode");

                    pImpl->recModes |= XA_RECMODE_STREAM;

                }

            }

        }

        DEBUG_ERR("Warning!!! No recording interfaces requested - unable to record!!");

    /*check sink and src parameters*/

        /*datasink ignored if only snapshotitf is used*/

            DEBUG_ERR("No datasink to record to!");

            ret = XA_RESULT_PARAMETER_INVALID;

            DEBUG_ERR("No data sources set!");

            ret = XA_RESULT_PARAMETER_INVALID;

        }

        XA_IMPL_THREAD_SAFETY_EXIT( XATSMediaRecorder );

        DEBUG_API("<-XAMediaRecorderImpl_CreateMediaRecorder");

        return ret;

    /* Mark interfaces that can be handled dynamically */

    /* Mandated dynamic itfs */

    pBaseObj->interfaceMap[MR_EQUALIZERITF].isDynamic = XA_BOOLEAN_TRUE;

    pBaseObj->interfaceMap[MR_IMAGEEFFECTSITF].isDynamic = XA_BOOLEAN_TRUE;

    /* Initialize XAMediaRecorderImpl variables */

    pImpl->audioSrc = pAudioSrc;

    pImpl->dataSnk = pDataSnk;

    pImpl->imageVideoSrc = pImageVideoSrc;

    /* Determine framework type that can handle recording */

    /**/

    if (pDataSnk->pLocator)

        if (dataLoc->locatorType == XA_DATALOCATOR_URI)

            {

            }

    if (fwType == FWMgrMOUnknown)

        {

        ret = XA_RESULT_CONTENT_UNSUPPORTED;

        XA_IMPL_THREAD_SAFETY_EXIT( XATSMediaRecorder );

        DEBUG_API("<-XAMediaRecorderImpl_CreateMediaRecorder");

        return ret;

        }

    /* Set ObjectItf to point to newly created object */

    else

        pImpl->adaptationCtx = XAMediaRecorderAdapt_Create(pImpl->audioSrc,

        {

        pImpl->adaptationCtx->capslist = capabilities;

        pImpl->adaptationCtx->fwtype = fwType;

        }

    else

        {

        ret = XA_RESULT_MEMORY_FAILURE;

        XA_IMPL_THREAD_SAFETY_EXIT( XATSMediaRecorder );

        DEBUG_API("<-XAMediaRecorderImpl_CreateMediaRecorder");

        return ret;

        }

    XA_IMPL_THREAD_SAFETY_EXIT( XATSMediaRecorder );

    DEBUG_API("<-XAMediaRecorderImpl_CreateMediaRecorder");

    return XA_RESULT_SUCCESS;

/* XAResult XAMediaRecorderImpl_QueryNumSupportedInterfaces

 * Statically query supported interfaces

 */

    DEBUG_API("->XAMediaRecorderImpl_QueryNumSupportedInterfaces");

        *pNumSupportedInterfaces = MR_ITFCOUNT;

        DEBUG_API("<-XAMediaRecorderImpl_QueryNumSupportedInterfaces");

        return XA_RESULT_SUCCESS;

    else

        DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

        return XA_RESULT_PARAMETER_INVALID;

    }

/* XAResult XAMediaRecorderImpl_QuerySupportedInterfaces

 * Statically query supported interfaces

 */

XAresult XAMediaRecorderImpl_QuerySupportedInterfaces(XAuint32 index,

    DEBUG_API("->XAMediaRecorderImpl_QuerySupportedInterfaces");

        DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

        return XA_RESULT_PARAMETER_INVALID;

    else

        *pInterfaceId = *(xaMediaRecorderItfIIDs[index]);

        DEBUG_API("<-XAMediaRecorderImpl_QuerySupportedInterfaces");

        return XA_RESULT_SUCCESS;

    }

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

 * base object XAObjectItfImpl methods

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

/* XAresult XAMediaRecorderImpl_DoRealize( XAObjectItf self )

 * Description: Realize all implicit and explicitly wanted interfaces.

 * Create and initialize implementation-specific variables.

 * Called from base object XAObjectItfImpl

 */

    XAuint8 itfIdx;

    XAresult ret = XA_RESULT_SUCCESS;

    DEBUG_API("->XAMediaRecorderImpl_DoRealize");

    XA_IMPL_THREAD_SAFETY_ENTRY( XATSMediaRecorder );

    /* check casting from correct pointer type */

        DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

        /* invalid parameter */

        XA_IMPL_THREAD_SAFETY_EXIT( XATSMediaRecorder );

        return XA_RESULT_PARAMETER_INVALID;

    /* init adaptation */

    else

        XA_IMPL_THREAD_SAFETY_EXIT( XATSMediaRecorder );

        return ret;

    /* Realize all implicit and explicitly wanted interfaces */

        {

            void *pItf = NULL;

                case MR_DIMITF:

                    pItf = XADIMItfImpl_Create();

                        XADIMItfImpl_Init(pItf, self,

                                XAMediaRecorderImpl_DoAddItf,

                                XAMediaRecorderImpl_DoResumeItf,

                                XAMediaRecorderImpl_DoRemoveItf);

                    break;

                case MR_RECORDITF:

                    break;

                case MR_AUDIOENCODERITF:

                    pItf = XAAudioEncoderItfImpl_Create(pObjImpl);

                    break;

#ifdef OMAX_CAMERABIN

                    pItf = XASnapshotItfImpl_Create(pObjImpl);

                    break;

                    pItf = XAVideoEncoderItfImpl_Create(pObjImpl);

                    pItf = XAImageEncoderItfImpl_Create(pObjImpl);

#endif

                case MR_METADATAINSERTIONITF:

                    pItf = XAMetadataInsertionItfImpl_Create(pObjImpl);

                    pItf = XAConfigExtensionsItfImpl_Create();

                    break;

                case MR_EQUALIZERITF:

                    break;

#ifdef OMAX_CAMERABIN

                    pItf = XAImageControlsItfImpl_Create( pObjImpl->adaptationCtx );

                    break;

                    pItf = XAImageEffectsItfImpl_Create( pObjImpl->adaptationCtx );

                    break;

                    pItf = XAVideoPostProcessingItfImpl_Create( pObjImpl->adaptationCtx );

                    break;

#endif

                case MR_VOLUMEITF:

                    break;

                case MR_METADATAEXTRACTIONITF:

                    break;

                case MR_METADATATRAVERSALITF:

                    break;

                default:

                    break;

                DEBUG_ERR("XA_RESULT_MEMORY_FAILURE");

                /* memory allocation failed */

                XA_IMPL_THREAD_SAFETY_EXIT( XATSMediaRecorder );

                return XA_RESULT_MEMORY_FAILURE;

            else

                pObj->interfaceMap[itfIdx].pItf = pItf;

            }

        }

    pObj->state = XA_OBJECT_STATE_REALIZED;

    DEBUG_API("<-XAMediaRecorderImpl_DoRealize");

    XA_IMPL_THREAD_SAFETY_EXIT( XATSMediaRecorder );

    return XA_RESULT_SUCCESS;

/* XAresult XAMediaRecorderImpl_DoResume

 * Description: Resume object from suspended state

 */

XAresult XAMediaRecorderImpl_DoResume(XAObjectItf self)

    DEBUG_API("->XAMediaRecorderImpl_DoResume");

    DEBUG_API("<-XAMediaRecorderImpl_DoResume");

    /* This implementation does not support suspended state */

    return XA_RESULT_PRECONDITIONS_VIOLATED;

/* void XAMediaRecorderImpl_FreeResources

 * Description: Free all resources reserved at XAMediaRecorderImpl_DoRealize()

 */