xref: /frameworks/base/media/jni/mediaeditor/VideoEditorMain.cpp

/*
 * Copyright (C) 2011 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
#define LOG_NDEBUG 1
#define LOG_TAG "VideoEditorMain"
#include <dlfcn.h>
#include <stdio.h>
#include <unistd.h>
#include <utils/Log.h>
#include <utils/threads.h>
#include <VideoEditorClasses.h>
#include <VideoEditorJava.h>
#include <VideoEditorOsal.h>
#include <VideoEditorLogging.h>
#include <marker.h>
#include <VideoEditorClasses.h>
#include <VideoEditorThumbnailMain.h>
#include <M4OSA_Debug.h>
#include <M4xVSS_Internal.h>
#include <gui/Surface.h>
#include "VideoEditorPreviewController.h"

#include "VideoEditorMain.h"

#include <android_runtime/android_view_Surface.h>

extern "C" {
#include <M4OSA_Clock.h>
#include <M4OSA_CharStar.h>
#include <M4OSA_Error.h>
#include <M4OSA_FileCommon.h>
#include <M4OSA_FileReader.h>
#include <M4OSA_FileWriter.h>
#include <M4OSA_Memory.h>
#include <M4OSA_Thread.h>
#include <M4xVSS_API.h>
#include <M4VSS3GPP_ErrorCodes.h>
#include <M4MCS_API.h>
#include <M4MCS_ErrorCodes.h>
#include <M4READER_Common.h>
#include <M4WRITER_common.h>
};


using namespace android;

#define THREAD_STACK_SIZE       (65536)

#define VIDEOEDITOR_VERSION_MAJOR     0
#define VIDEOEDITOR_VERSION_MINOR     0
#define VIDEOEDITOR_VERSION_REVISION  1


typedef enum
{
    ManualEditState_NOT_INITIALIZED,
    ManualEditState_INITIALIZED,
    ManualEditState_ANALYZING,
    ManualEditState_ANALYZING_ERROR,
    ManualEditState_OPENED,
    ManualEditState_SAVING,
    ManualEditState_SAVING_ERROR,
    ManualEditState_SAVED,
    ManualEditState_STOPPING
} ManualEditState;

typedef struct
{
    JavaVM*                        pVM;
    jobject                        engine;
    jmethodID                      onCompletionMethodId;
    jmethodID                      onErrorMethodId;
    jmethodID                      onWarningMethodId;
    jmethodID                      onProgressUpdateMethodId;
    jmethodID                      onPreviewProgressUpdateMethodId;
    jmethodID                      previewFrameEditInfoId;
    M4xVSS_InitParams              initParams;
    void*                          pTextRendererHandle;
    M4xVSS_getTextRgbBufferFct     pTextRendererFunction;
    M4OSA_Context                  engineContext;
    ManualEditState                state;
    M4VSS3GPP_EditSettings*        pEditSettings;
    M4OSA_Context                  threadContext;
    M4OSA_ERR                      threadResult;
    M4OSA_UInt8                    threadProgress;
    VideoEditorPreviewController   *mPreviewController;
    M4xVSS_AudioMixingSettings     *mAudioSettings;
    /* Audio Graph changes */
    M4OSA_Context                   pAudioGraphMCSCtx;
    M4OSA_Bool                      bSkipState;
    jmethodID                       onAudioGraphProgressUpdateMethodId;
    Mutex                           mLock;
    bool                            mIsUpdateOverlay;
    char                            *mOverlayFileName;
    int                             mOverlayRenderingMode;
    M4DECODER_VideoDecoders* decoders;
} ManualEditContext;

extern "C" M4OSA_ERR M4MCS_open_normalMode(
                M4MCS_Context                       pContext,
                M4OSA_Void*                         pFileIn,
                M4VIDEOEDITING_FileType             InputFileType,
                M4OSA_Void*                         pFileOut,
                M4OSA_Void*                         pTempFile);

static M4OSA_ERR videoEditor_toUTF8Fct(
                M4OSA_Void*                         pBufferIn,
                M4OSA_UInt8*                        pBufferOut,
                M4OSA_UInt32*                       bufferOutSize);

static M4OSA_ERR videoEditor_fromUTF8Fct(
                M4OSA_UInt8*                        pBufferIn,
                M4OSA_Void*                         pBufferOut,
                M4OSA_UInt32*                       bufferOutSize);

static M4OSA_ERR videoEditor_getTextRgbBufferFct(
                M4OSA_Void*                         pRenderingData,
                M4OSA_Void*                         pTextBuffer,
                M4OSA_UInt32                        textBufferSize,
                M4VIFI_ImagePlane**                 pOutputPlane);

static void videoEditor_callOnProgressUpdate(
                ManualEditContext*                  pContext,
                int                                 task,
                int                                 progress);

static void videoEditor_freeContext(
                JNIEnv*                             pEnv,
                ManualEditContext**                 ppContext);

static M4OSA_ERR videoEditor_threadProc(
                M4OSA_Void*                         param);

static jobject videoEditor_getVersion(
                JNIEnv*                             pEnv,
                jobject                             thiz);

static void videoEditor_init(
                JNIEnv*                             pEnv,
                jobject                             thiz,
                jstring                             tempPath,
                jstring                             textRendererPath);

static void videoEditor_loadSettings(
                JNIEnv*                             pEnv,
                jobject                             thiz,
                jobject                             settings);

static void videoEditor_unloadSettings(
                JNIEnv*                             pEnv,
                jobject                             thiz);


static void videoEditor_stopEncoding(
                JNIEnv*                             pEnv,
                jobject                             thiz);

static void videoEditor_release(
                JNIEnv*                             pEnv,
                jobject                             thiz);
static int videoEditor_getPixels(
                                 JNIEnv*                  env,
                                 jobject                  thiz,
                                 jstring                  path,
                                 jintArray                pixelArray,
                                 M4OSA_UInt32             width,
                                 M4OSA_UInt32             height,
                                 M4OSA_UInt32             timeMS);
static int videoEditor_getPixelsList(
                                     JNIEnv*                  env,
                                     jobject                  thiz,
                                     jstring                  path,
                                     jintArray                pixelArray,
                                     M4OSA_UInt32             width,
                                     M4OSA_UInt32             height,
                                     M4OSA_UInt32             noOfThumbnails,
                                     jlong                    startTime,
                                     jlong                    endTime,
                                     jintArray                indexArray,
                                     jobject                  callback);

static void
videoEditor_startPreview(
                JNIEnv*                 pEnv,
                jobject                 thiz,
                jobject                 mSurface,
                jlong                   fromMs,
                jlong                   toMs,
                jint                    callbackInterval,
                jboolean                loop);

static void
videoEditor_populateSettings(
                JNIEnv*                 pEnv,
                jobject                 thiz,
                jobject                 settings,
                jobject                 object,
                jobject                 audioSettingObject);

static int videoEditor_stopPreview(JNIEnv*  pEnv,
                              jobject  thiz);

static jobject
videoEditor_getProperties(
                JNIEnv*                             pEnv,
                jobject                             thiz,
                jstring                             file);

static int videoEditor_renderPreviewFrame(JNIEnv* pEnv,
                                    jobject thiz,
                                    jobject    mSurface,
                                    jlong fromMs,
                                    jint  surfaceWidth,
                                    jint  surfaceHeight);

static int videoEditor_registerManualEditMethods(
                JNIEnv*                             pEnv);

static void jniPreviewProgressCallback(void* cookie, M4OSA_UInt32 msgType,
                                        void *argc);

static int videoEditor_renderMediaItemPreviewFrame(JNIEnv* pEnv,
                                                    jobject thiz,
                                                    jobject mSurface,
                                                    jstring filePath,
                                                    jint frameWidth,
                                                    jint frameHeight,
                                                    jint surfaceWidth,
                                                    jint surfaceHeight,
                                                    jlong fromMs);

static int videoEditor_generateAudioWaveFormSync ( JNIEnv*     pEnv,
                                                  jobject     thiz,
                                                  jstring     pcmfilePath,
                                                  jstring     outGraphfilePath,
                                                  jint        frameDuration,
                                                  jint        channels,
                                                  jint        samplesCount);

static int videoEditor_generateAudioRawFile(JNIEnv* pEnv,
                                    jobject thiz,
                                    jstring infilePath,
                                    jstring pcmfilePath );

M4OSA_ERR videoEditor_generateAudio(JNIEnv* pEnv,ManualEditContext* pContext,
                                    M4OSA_Char* infilePath,
                                    M4OSA_Char* pcmfilePath );

static int
videoEditor_generateClip(
                JNIEnv*                             pEnv,
                jobject                             thiz,
                jobject                             settings);

static void videoEditor_clearSurface(JNIEnv* pEnv,
                                    jobject thiz,
                                    jobject surface);

static JNINativeMethod gManualEditMethods[] = {
    {"getVersion",               "()L"VERSION_CLASS_NAME";",
                                (void *)videoEditor_getVersion      },
    {"_init",                    "(Ljava/lang/String;Ljava/lang/String;)V",
                                (void *)videoEditor_init    },
    {"nativeStartPreview",       "(Landroid/view/Surface;JJIZ)V",
                                (void *)videoEditor_startPreview    },
    {"nativePopulateSettings",
            "(L"EDIT_SETTINGS_CLASS_NAME";L"PREVIEW_PROPERTIES_CLASS_NAME";L"
            AUDIO_SETTINGS_CLASS_NAME";)V",
                                (void *)videoEditor_populateSettings    },
    {"nativeRenderPreviewFrame", "(Landroid/view/Surface;JII)I",
                                (int *)videoEditor_renderPreviewFrame     },
    {"nativeRenderMediaItemPreviewFrame",
    "(Landroid/view/Surface;Ljava/lang/String;IIIIJ)I",
                        (int *)videoEditor_renderMediaItemPreviewFrame     },
    {"nativeStopPreview",       "()I",
                                (int *)videoEditor_stopPreview    },
    {"stopEncoding",            "()V",
                                (void *)videoEditor_stopEncoding         },
    {"release",                 "()V",
                                (void *)videoEditor_release            },
    {"nativeGetPixels",         "(Ljava/lang/String;[IIIJ)I",
                                (void*)videoEditor_getPixels               },
    {"nativeGetPixelsList",     "(Ljava/lang/String;[IIIIJJ[ILandroid/media/videoeditor/MediaArtistNativeHelper$NativeGetPixelsListCallback;)I",
                                (void*)videoEditor_getPixelsList           },
    {"getMediaProperties",
    "(Ljava/lang/String;)Landroid/media/videoeditor/MediaArtistNativeHelper$Properties;",
                                (void *)videoEditor_getProperties          },
    {"nativeGenerateAudioGraph","(Ljava/lang/String;Ljava/lang/String;III)I",
                                (int *)videoEditor_generateAudioWaveFormSync },
    {"nativeGenerateRawAudio",  "(Ljava/lang/String;Ljava/lang/String;)I",
                                (int *)videoEditor_generateAudioRawFile      },
    {"nativeGenerateClip",      "(L"EDIT_SETTINGS_CLASS_NAME";)I",
                                (void *)videoEditor_generateClip  },
    {"nativeClearSurface",       "(Landroid/view/Surface;)V",
                                (void *)videoEditor_clearSurface  },
};

// temp file name of VSS out file
#define TEMP_MCS_OUT_FILE_PATH "tmpOut.3gp"

void
getClipSetting(
                JNIEnv*                                       pEnv,
                jobject                                       object,
                M4VSS3GPP_ClipSettings*                       pSettings)
{

    jfieldID fid;
    int field = 0;
    bool needToBeLoaded = true;
    jclass clazz = pEnv->FindClass(PROPERTIES_CLASS_NAME);

    videoEditJava_checkAndThrowIllegalStateException(&needToBeLoaded, pEnv,
                                             (M4OSA_NULL == clazz),
                                             "not initialized");

    fid = pEnv->GetFieldID(clazz,"duration","I");
    pSettings->ClipProperties.uiClipDuration = pEnv->GetIntField(object,fid);
    M4OSA_TRACE1_1("duration = %d",pSettings->ClipProperties.uiClipDuration);

    fid = pEnv->GetFieldID(clazz,"videoFormat","I");
    pSettings->ClipProperties.VideoStreamType =
        (M4VIDEOEDITING_VideoFormat)pEnv->GetIntField(object,fid);
    M4OSA_TRACE1_1("videoFormat = %d",pSettings->ClipProperties.VideoStreamType);

    fid = pEnv->GetFieldID(clazz,"videoDuration","I");
    pSettings->ClipProperties.uiClipVideoDuration = pEnv->GetIntField(object,fid);
    M4OSA_TRACE1_1("videoDuration = %d",
                    pSettings->ClipProperties.uiClipVideoDuration);

    fid = pEnv->GetFieldID(clazz,"width","I");
    pSettings->ClipProperties.uiVideoWidth = pEnv->GetIntField(object,fid);
    M4OSA_TRACE1_1("width = %d",pSettings->ClipProperties.uiVideoWidth);

    fid = pEnv->GetFieldID(clazz,"height","I");
    pSettings->ClipProperties.uiVideoHeight = pEnv->GetIntField(object,fid);
    M4OSA_TRACE1_1("height = %d",pSettings->ClipProperties.uiVideoHeight);

    fid = pEnv->GetFieldID(clazz,"audioFormat","I");
    pSettings->ClipProperties.AudioStreamType =
        (M4VIDEOEDITING_AudioFormat)pEnv->GetIntField(object,fid);
    M4OSA_TRACE1_1("audioFormat = %d",pSettings->ClipProperties.AudioStreamType);

    fid = pEnv->GetFieldID(clazz,"audioDuration","I");
    pSettings->ClipProperties.uiClipAudioDuration = pEnv->GetIntField(object,fid);
    M4OSA_TRACE1_1("audioDuration = %d",
                    pSettings->ClipProperties.uiClipAudioDuration);

    fid = pEnv->GetFieldID(clazz,"audioBitrate","I");
    pSettings->ClipProperties.uiAudioBitrate = pEnv->GetIntField(object,fid);
    M4OSA_TRACE1_1("audioBitrate = %d",pSettings->ClipProperties.uiAudioBitrate);

    fid = pEnv->GetFieldID(clazz,"audioChannels","I");
    pSettings->ClipProperties.uiNbChannels = pEnv->GetIntField(object,fid);
    M4OSA_TRACE1_1("audioChannels = %d",pSettings->ClipProperties.uiNbChannels);

    fid = pEnv->GetFieldID(clazz,"audioSamplingFrequency","I");
    pSettings->ClipProperties.uiSamplingFrequency = pEnv->GetIntField(object,fid);
    M4OSA_TRACE1_1("audioSamplingFrequency = %d",
                    pSettings->ClipProperties.uiSamplingFrequency);

   fid = pEnv->GetFieldID(clazz,"audioVolumeValue","I");
   pSettings->ClipProperties.uiClipAudioVolumePercentage =
                    pEnv->GetIntField(object,fid);
   M4OSA_TRACE1_1("audioVolumeValue = %d",
                    pSettings->ClipProperties.uiClipAudioVolumePercentage);

   fid = pEnv->GetFieldID(clazz,"videoRotation","I");
   pSettings->ClipProperties.videoRotationDegrees =
                    pEnv->GetIntField(object,fid);
   M4OSA_TRACE1_1("videoRotation = %d",
                    pSettings->ClipProperties.videoRotationDegrees);

   // Free the local references to avoid memory leaks
   pEnv->DeleteLocalRef(clazz);
}

static void jniPreviewProgressCallback (void* cookie, M4OSA_UInt32 msgType,
                                        void *argc)
{
    ManualEditContext *pContext = (ManualEditContext *)cookie;
    JNIEnv*     pEnv = NULL;
    bool        isFinished = false;
    int         currentMs = 0;
    int         error = M4NO_ERROR;
    bool        isUpdateOverlay = false;
    int         overlayEffectIndex;
    char        *extPos;
    bool        isSendProgress = true;
    jstring     tmpFileName;
    VideoEditorCurretEditInfo *pCurrEditInfo;

    // Attach the current thread.
    pContext->pVM->AttachCurrentThread(&pEnv, NULL);
    switch(msgType)
    {
        case MSG_TYPE_PROGRESS_INDICATION:
            currentMs = *(int*)argc;
            break;
        case MSG_TYPE_PLAYER_ERROR:
            currentMs = -1;
            error = *(int*)argc;
            break;
        case MSG_TYPE_PREVIEW_END:
            isFinished = true;
            break;
        case MSG_TYPE_OVERLAY_UPDATE:
        {
            int overlayFileNameLen = 0;
            isSendProgress = false;
            pContext->mIsUpdateOverlay = true;
            pCurrEditInfo = (VideoEditorCurretEditInfo*)argc;
            overlayEffectIndex = pCurrEditInfo->overlaySettingsIndex;
            ALOGV("MSG_TYPE_OVERLAY_UPDATE");

            if (pContext->mOverlayFileName != NULL) {
                free(pContext->mOverlayFileName);
                pContext->mOverlayFileName = NULL;
            }

            overlayFileNameLen =
                strlen((const char*)pContext->pEditSettings->Effects[overlayEffectIndex].xVSS.pFramingFilePath);

            pContext->mOverlayFileName =
                (char*)M4OSA_32bitAlignedMalloc(overlayFileNameLen+1,
                                    M4VS, (M4OSA_Char*)"videoEdito JNI overlayFile");
            if (pContext->mOverlayFileName != NULL) {
                strncpy (pContext->mOverlayFileName,
                    (const char*)pContext->pEditSettings->\
                    Effects[overlayEffectIndex].xVSS.pFramingFilePath, overlayFileNameLen);
                //Change the name to png file
                extPos = strstr(pContext->mOverlayFileName, ".rgb");
                if (extPos != NULL) {
                    *extPos = '\0';
                } else {
                    ALOGE("ERROR the overlay file is incorrect");
                }

                strcat(pContext->mOverlayFileName, ".png");
                ALOGV("Conv string is %s", pContext->mOverlayFileName);
                ALOGV("Current Clip index = %d", pCurrEditInfo->clipIndex);

                pContext->mOverlayRenderingMode = pContext->pEditSettings->\
                         pClipList[pCurrEditInfo->clipIndex]->xVSS.MediaRendering;
                ALOGV("rendering mode %d ", pContext->mOverlayRenderingMode);

            }

            break;
        }

        case MSG_TYPE_OVERLAY_CLEAR:
            isSendProgress = false;
            if (pContext->mOverlayFileName != NULL) {
                free(pContext->mOverlayFileName);
                pContext->mOverlayFileName = NULL;
            }

            ALOGV("MSG_TYPE_OVERLAY_CLEAR");
            //argc is not used
            pContext->mIsUpdateOverlay = true;
            break;
        default:
            break;
    }

    if (isSendProgress) {
        tmpFileName  = pEnv->NewStringUTF(pContext->mOverlayFileName);
        pEnv->CallVoidMethod(pContext->engine,
                pContext->onPreviewProgressUpdateMethodId,
                currentMs,isFinished, pContext->mIsUpdateOverlay,
                tmpFileName, pContext->mOverlayRenderingMode, error);

        if (pContext->mIsUpdateOverlay) {
            pContext->mIsUpdateOverlay = false;
        }

        if (tmpFileName) {
            pEnv->DeleteLocalRef(tmpFileName);
        }
    }

    // Detach the current thread.
    pContext->pVM->DetachCurrentThread();

}
static M4OSA_ERR checkClipVideoProfileAndLevel(M4DECODER_VideoDecoders *pDecoders,
    M4OSA_Int32 format, M4OSA_UInt32 profile, M4OSA_UInt32 level){

    M4OSA_Int32 codec = 0;
    M4OSA_Bool foundCodec = M4OSA_FALSE;
    M4OSA_ERR  result = M4VSS3GPP_ERR_EDITING_UNSUPPORTED_VIDEO_PROFILE;
    M4OSA_Bool foundProfile = M4OSA_FALSE;
    ALOGV("checkClipVideoProfileAndLevel format %d profile;%d level:0x%x",
       format, profile, level);

    switch (format) {
        case M4VIDEOEDITING_kH263:
            codec = M4DA_StreamTypeVideoH263;
            break;
        case M4VIDEOEDITING_kH264:
             codec = M4DA_StreamTypeVideoMpeg4Avc;
            break;
        case M4VIDEOEDITING_kMPEG4:
             codec = M4DA_StreamTypeVideoMpeg4;
            break;
        case M4VIDEOEDITING_kNoneVideo:
        case M4VIDEOEDITING_kNullVideo:
        case M4VIDEOEDITING_kUnsupportedVideo:
             // For these case we do not check the profile and level
             return M4NO_ERROR;
        default :
            ALOGE("checkClipVideoProfileAndLevel unsupport Video format %ld", format);
            break;
    }

    if (pDecoders != M4OSA_NULL && pDecoders->decoderNumber > 0) {
        VideoDecoder *pVideoDecoder = pDecoders->decoder;
        for(size_t k =0; k < pDecoders->decoderNumber; k++) {
            if (pVideoDecoder != M4OSA_NULL) {
                if (pVideoDecoder->codec == codec) {
                    foundCodec = M4OSA_TRUE;
                    break;
                }
            }
            pVideoDecoder++;
        }

        if (foundCodec) {
            VideoComponentCapabilities* pComponent = pVideoDecoder->component;
            for (size_t i = 0; i < pVideoDecoder->componentNumber; i++) {
                if (pComponent != M4OSA_NULL) {
                    VideoProfileLevel *pProfileLevel = pComponent->profileLevel;
                    for (size_t j =0; j < pComponent->profileNumber; j++) {
                        // Check the profile and level
                        if (pProfileLevel != M4OSA_NULL) {
                            if (profile == pProfileLevel->mProfile) {
                                foundProfile = M4OSA_TRUE;

                                if (level <= pProfileLevel->mLevel) {
                                    return M4NO_ERROR;
                                }
                            } else {
                                foundProfile = M4OSA_FALSE;
                            }
                        }
                        pProfileLevel++;
                    }
                }
                pComponent++;
            }
        }
    }

    if (foundProfile) {
        result = M4VSS3GPP_ERR_EDITING_UNSUPPORTED_VIDEO_LEVEL;
    } else {
        result = M4VSS3GPP_ERR_EDITING_UNSUPPORTED_VIDEO_PROFILE;
    }

    return result;
}
static int videoEditor_stopPreview(JNIEnv*  pEnv,
                              jobject  thiz)
{
    ManualEditContext* pContext = M4OSA_NULL;
    bool needToBeLoaded = true;
    M4OSA_UInt32 lastProgressTimeMs = 0;

    // Get the context.
    pContext =
            (ManualEditContext*)videoEditClasses_getContext(&needToBeLoaded, pEnv, thiz);

    // Make sure that the context was set.
    videoEditJava_checkAndThrowIllegalStateException(&needToBeLoaded, pEnv,
                                             (M4OSA_NULL == pContext),
                                             "not initialized");
    lastProgressTimeMs = pContext->mPreviewController->stopPreview();

    if (pContext->mOverlayFileName != NULL) {
        free(pContext->mOverlayFileName);
        pContext->mOverlayFileName = NULL;
    }

    return lastProgressTimeMs;
}

static void videoEditor_clearSurface(JNIEnv* pEnv,
                                    jobject thiz,
                                    jobject surface)
{
    bool needToBeLoaded = true;
    M4OSA_ERR result = M4NO_ERROR;
    VideoEditor_renderPreviewFrameStr frameStr;
    const char* pMessage = NULL;
    // Let the size be QVGA
    int width = 320;
    int height = 240;
    ManualEditContext* pContext = M4OSA_NULL;

    // Get the context.
    pContext = (ManualEditContext*)videoEditClasses_getContext(&needToBeLoaded, pEnv, thiz);
    VIDEOEDIT_LOG_FUNCTION(ANDROID_LOG_INFO,
                                "VIDEO_EDITOR","pContext = 0x%x",pContext);

    // Make sure that the context was set.
    videoEditJava_checkAndThrowIllegalStateException(&needToBeLoaded, pEnv,
                                             (M4OSA_NULL == pContext),
                                             "not initialized");

    // Make sure that the context was set.
    videoEditJava_checkAndThrowIllegalStateException(&needToBeLoaded, pEnv,
                                 (M4OSA_NULL == pContext->mPreviewController),
                                 "not initialized");

    // Validate the surface parameter.
    videoEditJava_checkAndThrowIllegalArgumentException(&needToBeLoaded, pEnv,
                                                (NULL == surface),
                                                "surface is null");

    sp<Surface> previewSurface = android_view_Surface_getSurface(pEnv, surface);

    // Validate the mSurface's mNativeSurface field
    videoEditJava_checkAndThrowIllegalStateException(&needToBeLoaded, pEnv,
                                                (NULL == previewSurface.get()),
                                                "mNativeSurface is null");

    frameStr.pBuffer = M4OSA_NULL;
    frameStr.timeMs = 0;
    frameStr.uiSurfaceWidth = width;
    frameStr.uiSurfaceHeight = height;
    frameStr.uiFrameWidth = width;
    frameStr.uiFrameHeight = height;
    frameStr.bApplyEffect = M4OSA_FALSE;
    frameStr.clipBeginCutTime = 0;
    frameStr.clipEndCutTime = 0;

    result = pContext->mPreviewController->clearSurface(previewSurface,
                                                              &frameStr);
    videoEditJava_checkAndThrowRuntimeException(&needToBeLoaded, pEnv,
            (M4NO_ERROR != result), result);

  }

static int videoEditor_renderPreviewFrame(JNIEnv* pEnv,
                                    jobject thiz,
                                    jobject    mSurface,
                                    jlong fromMs,
                                    jint surfaceWidth,
                                    jint surfaceHeight )
{
    bool needToBeLoaded = true;
    M4OSA_ERR result = M4NO_ERROR;
    M4OSA_UInt32 timeMs = (M4OSA_UInt32)fromMs;
    M4OSA_UInt32 i=0,tnTimeMs = 0, framesizeYuv =0;
    M4VIFI_UInt8 *pixelArray = M4OSA_NULL;
    M4OSA_UInt32    iCurrentClipIndex = 0, uiNumberOfClipsInStoryBoard =0,
                    uiClipDuration = 0, uiTotalClipDuration = 0,
                    iIncrementedDuration = 0;
    VideoEditor_renderPreviewFrameStr frameStr;
    M4OSA_Context tnContext = M4OSA_NULL;
    const char* pMessage = NULL;
    M4VIFI_ImagePlane *yuvPlane = NULL;
    VideoEditorCurretEditInfo  currEditInfo;

    VIDEOEDIT_LOG_FUNCTION(ANDROID_LOG_INFO,
        "VIDEO_EDITOR", "surfaceWidth = %d",surfaceWidth);
    VIDEOEDIT_LOG_FUNCTION(ANDROID_LOG_INFO,
        "VIDEO_EDITOR", "surfaceHeight = %d",surfaceHeight);
    ManualEditContext* pContext = M4OSA_NULL;
    // Get the context.
    pContext =
            (ManualEditContext*)videoEditClasses_getContext(&needToBeLoaded, pEnv, thiz);
    VIDEOEDIT_LOG_FUNCTION(ANDROID_LOG_INFO,
                                "VIDEO_EDITOR","pContext = 0x%x",pContext);

    // Make sure that the context was set.
    videoEditJava_checkAndThrowIllegalStateException(&needToBeLoaded, pEnv,
                                             (M4OSA_NULL == pContext),
                                             "not initialized");

    // Make sure that the context was set.
    videoEditJava_checkAndThrowIllegalStateException(&needToBeLoaded, pEnv,
                                 (M4OSA_NULL == pContext->mPreviewController),
                                 "not initialized");

    // Validate the mSurface parameter.
    videoEditJava_checkAndThrowIllegalArgumentException(&needToBeLoaded, pEnv,
                                                (NULL == mSurface),
                                                "mSurface is null");

    sp<Surface> previewSurface = android_view_Surface_getSurface(pEnv, mSurface);

    // Validate the mSurface's mNativeSurface field
    videoEditJava_checkAndThrowIllegalStateException(&needToBeLoaded, pEnv,
                                                (NULL == previewSurface.get()),
                                                "mNativeSurface is null");

    /* Determine the total number of clips, total duration*/
    uiNumberOfClipsInStoryBoard = pContext->pEditSettings->uiClipNumber;

    for (i = 0; i < uiNumberOfClipsInStoryBoard; i++) {
        uiClipDuration = pContext->pEditSettings->pClipList[i]->uiEndCutTime -
            pContext->pEditSettings->pClipList[i]->uiBeginCutTime;
        uiTotalClipDuration += uiClipDuration;
    }

    /* determine the clip whose thumbnail needs to be rendered*/
    if (timeMs == 0) {
        iCurrentClipIndex = 0;
        i=0;
    } else {
        VIDEOEDIT_LOG_FUNCTION(ANDROID_LOG_INFO, "VIDEO_EDITOR",
            "videoEditor_renderPreviewFrame() timeMs=%d", timeMs);

        if (timeMs > uiTotalClipDuration) {
            VIDEOEDIT_LOG_FUNCTION(ANDROID_LOG_INFO, "VIDEO_EDITOR",
                "videoEditor_renderPreviewFrame() timeMs > uiTotalClipDuration");
            pMessage = videoEditJava_getErrorName(M4ERR_PARAMETER);
            jniThrowException(pEnv, "java/lang/IllegalArgumentException", pMessage);
            return -1;
        }

        for (i = 0; i < uiNumberOfClipsInStoryBoard; i++) {
            if (timeMs <= (iIncrementedDuration +
                          (pContext->pEditSettings->pClipList[i]->uiEndCutTime -
                           pContext->pEditSettings->pClipList[i]->uiBeginCutTime)))
            {
                iCurrentClipIndex = i;
                VIDEOEDIT_LOG_FUNCTION(ANDROID_LOG_INFO, "VIDEO_EDITOR",
                    "videoEditor_renderPreviewFrame() iCurrentClipIndex=%d for timeMs=%d",
                    iCurrentClipIndex, timeMs);
                break;
            }
            else {
                iIncrementedDuration = iIncrementedDuration +
                    (pContext->pEditSettings->pClipList[i]->uiEndCutTime -
                    pContext->pEditSettings->pClipList[i]->uiBeginCutTime);
            }
        }
    }
    /* If timestamp is beyond story board duration, return*/
    if (i >= uiNumberOfClipsInStoryBoard) {
        if (timeMs == iIncrementedDuration) {
            iCurrentClipIndex = i-1;
        } else {
           return -1;
        }
    }

    /*+ Handle the image files here */
      if (pContext->pEditSettings->pClipList[iCurrentClipIndex]->FileType ==
          /*M4VIDEOEDITING_kFileType_JPG*/ M4VIDEOEDITING_kFileType_ARGB8888 ) {
          VIDEOEDIT_LOG_FUNCTION(ANDROID_LOG_INFO, "VIDEO_EDITOR", " iCurrentClipIndex %d ", iCurrentClipIndex);
          VIDEOEDIT_LOG_FUNCTION(ANDROID_LOG_INFO, "VIDEO_EDITOR",
                "  Height = %d",
                pContext->pEditSettings->pClipList[iCurrentClipIndex]->ClipProperties.uiVideoHeight);

          VIDEOEDIT_LOG_FUNCTION(ANDROID_LOG_INFO, "VIDEO_EDITOR",
                "  Width = %d",
                pContext->pEditSettings->pClipList[iCurrentClipIndex]->ClipProperties.uiVideoWidth);

          LvGetImageThumbNail((const char *)pContext->pEditSettings->\
          pClipList[iCurrentClipIndex]->pFile,
            pContext->pEditSettings->pClipList[iCurrentClipIndex]->ClipProperties.uiVideoHeight,
            pContext->pEditSettings->pClipList[iCurrentClipIndex]->ClipProperties.uiVideoWidth,
            (M4OSA_Void **)&frameStr.pBuffer);
            tnTimeMs = (M4OSA_UInt32)timeMs;

          frameStr.videoRotationDegree = 0;
    } else {
        /* Handle 3gp/mp4 Clips here */
        /* get thumbnail*/
        result = ThumbnailOpen(&tnContext,
            (const M4OSA_Char*)pContext->pEditSettings->\
            pClipList[iCurrentClipIndex]->pFile, M4OSA_TRUE);
        if (result != M4NO_ERROR || tnContext  == M4OSA_NULL) {
            return -1;
        }

        /* timeMs is relative to storyboard; in this api it shud be relative to this clip */
        if ((i >= uiNumberOfClipsInStoryBoard) &&
            (timeMs == iIncrementedDuration)) {
            tnTimeMs = pContext->pEditSettings->\
            pClipList[iCurrentClipIndex]->uiEndCutTime;
        } else {
            tnTimeMs = pContext->pEditSettings->\
            pClipList[iCurrentClipIndex]->uiBeginCutTime
            + (timeMs - iIncrementedDuration);
        }

        VIDEOEDIT_LOG_API(ANDROID_LOG_INFO, "VIDEO_EDITOR",
            "video width = %d",pContext->pEditSettings->pClipList[iCurrentClipIndex]->\
            ClipProperties.uiVideoWidth);
        VIDEOEDIT_LOG_API(ANDROID_LOG_INFO, "VIDEO_EDITOR",
            "video height = %d",pContext->pEditSettings->pClipList[iCurrentClipIndex]->\
            ClipProperties.uiVideoHeight);
        VIDEOEDIT_LOG_API(ANDROID_LOG_INFO, "VIDEO_EDITOR",
            "current clip index = %d",iCurrentClipIndex);

        M4OSA_UInt32 width = pContext->pEditSettings->pClipList[iCurrentClipIndex]->\
            ClipProperties.uiVideoWidth;
        M4OSA_UInt32 height = pContext->pEditSettings->pClipList[iCurrentClipIndex]->\
            ClipProperties.uiVideoHeight;

        framesizeYuv = width * height * 1.5;

        pixelArray = (M4VIFI_UInt8 *)M4OSA_32bitAlignedMalloc(framesizeYuv, M4VS,
            (M4OSA_Char*)"videoEditor pixelArray");
        if (pixelArray == M4OSA_NULL) {
            VIDEOEDIT_LOG_FUNCTION(ANDROID_LOG_INFO, "VIDEO_EDITOR",
                "videoEditor_renderPreviewFrame() malloc error");
            ThumbnailClose(tnContext);
            pMessage = videoEditJava_getErrorName(M4ERR_ALLOC);
            jniThrowException(pEnv, "java/lang/RuntimeException", pMessage);
            return -1;
        }

        result = ThumbnailGetPixels16(tnContext, (M4OSA_Int16 *)pixelArray,
            pContext->pEditSettings->pClipList[iCurrentClipIndex]->\
            ClipProperties.uiVideoWidth,
            pContext->pEditSettings->pClipList[iCurrentClipIndex]->\
            ClipProperties.uiVideoHeight,
            &tnTimeMs, 0);
        if (result != M4NO_ERROR) {
            free(pixelArray);
            ThumbnailClose(tnContext);
            return -1;
        }

        ThumbnailClose(tnContext);
        tnContext = M4OSA_NULL;

#ifdef DUMPTOFILE
        {
            M4OSA_Context fileContext;
            M4OSA_Char* fileName = (M4OSA_Char*)"/mnt/sdcard/FirstRGB565.raw";
            remove((const char *)fileName);
            M4OSA_fileWriteOpen(&fileContext, (M4OSA_Void*) fileName,\
                M4OSA_kFileWrite|M4OSA_kFileCreate);
            M4OSA_fileWriteData(fileContext, (M4OSA_MemAddr8) pixelArray,
                framesizeYuv);
            M4OSA_fileWriteClose(fileContext);
        }
#endif

        /**
        * Allocate output YUV planes
        */
        yuvPlane = (M4VIFI_ImagePlane*)M4OSA_32bitAlignedMalloc(3*sizeof(M4VIFI_ImagePlane), M4VS,
            (M4OSA_Char*)"videoEditor_renderPreviewFrame Output plane YUV");
        if (yuvPlane == M4OSA_NULL) {
            VIDEOEDIT_LOG_FUNCTION(ANDROID_LOG_INFO, "VIDEO_EDITOR",
                "videoEditor_renderPreviewFrame() malloc error for yuv plane");
            free(pixelArray);
            pMessage = videoEditJava_getErrorName(M4ERR_ALLOC);
            jniThrowException(pEnv, "java/lang/RuntimeException", pMessage);
            return -1;
        }

        yuvPlane[0].u_width = width;
        yuvPlane[0].u_height = height;
        yuvPlane[0].u_topleft = 0;
        yuvPlane[0].u_stride = width;
        yuvPlane[0].pac_data = (M4VIFI_UInt8*)pixelArray;

        yuvPlane[1].u_width = width>>1;
        yuvPlane[1].u_height = height>>1;
        yuvPlane[1].u_topleft = 0;
        yuvPlane[1].u_stride = width>>1;
        yuvPlane[1].pac_data = yuvPlane[0].pac_data
                    + yuvPlane[0].u_width * yuvPlane[0].u_height;
        yuvPlane[2].u_width = (width)>>1;
        yuvPlane[2].u_height = (height)>>1;
        yuvPlane[2].u_topleft = 0;
        yuvPlane[2].u_stride = (width)>>1;
        yuvPlane[2].pac_data = yuvPlane[1].pac_data
                    + yuvPlane[1].u_width * yuvPlane[1].u_height;

#ifdef DUMPTOFILE
        {
            M4OSA_Context fileContext;
            M4OSA_Char* fileName = (M4OSA_Char*)"/mnt/sdcard/ConvertedYuv.yuv";
            remove((const char *)fileName);
            M4OSA_fileWriteOpen(&fileContext, (M4OSA_Void*) fileName,\
                M4OSA_kFileWrite|M4OSA_kFileCreate);
            M4OSA_fileWriteData(fileContext,
                (M4OSA_MemAddr8) yuvPlane[0].pac_data, framesizeYuv);
            M4OSA_fileWriteClose(fileContext);
        }
#endif

        /* Fill up the render structure*/
        frameStr.pBuffer = (M4OSA_Void*)yuvPlane[0].pac_data;

        frameStr.videoRotationDegree = pContext->pEditSettings->\
            pClipList[iCurrentClipIndex]->ClipProperties.videoRotationDegrees;
    }

    frameStr.timeMs = timeMs;    /* timestamp on storyboard*/
    frameStr.uiSurfaceWidth =
        pContext->pEditSettings->pClipList[iCurrentClipIndex]->\
        ClipProperties.uiVideoWidth;
    frameStr.uiSurfaceHeight =
        pContext->pEditSettings->pClipList[iCurrentClipIndex]->\
        ClipProperties.uiVideoHeight;
    frameStr.uiFrameWidth =
        pContext->pEditSettings->pClipList[iCurrentClipIndex]->\
        ClipProperties.uiVideoWidth;
    frameStr.uiFrameHeight =
        pContext->pEditSettings->pClipList[iCurrentClipIndex]->\
        ClipProperties.uiVideoHeight;
    if (pContext->pEditSettings->nbEffects > 0) {
        frameStr.bApplyEffect = M4OSA_TRUE;
    } else {
        frameStr.bApplyEffect = M4OSA_FALSE;
    }
    frameStr.clipBeginCutTime = iIncrementedDuration;
    frameStr.clipEndCutTime =
        iIncrementedDuration +
        (pContext->pEditSettings->pClipList[iCurrentClipIndex]->uiEndCutTime -\
        pContext->pEditSettings->pClipList[iCurrentClipIndex]->uiBeginCutTime);

    pContext->mPreviewController->setPreviewFrameRenderingMode(
        pContext->pEditSettings->\
        pClipList[iCurrentClipIndex]->xVSS.MediaRendering,
        pContext->pEditSettings->xVSS.outputVideoSize);
    result = pContext->mPreviewController->renderPreviewFrame(previewSurface,
                                                              &frameStr, &currEditInfo);

    if (currEditInfo.overlaySettingsIndex != -1) {
        char tmpOverlayFilename[100];
        char *extPos = NULL;
        jstring tmpOverlayString;
        int tmpRenderingMode = 0;

        strncpy (tmpOverlayFilename,
                (const char*)pContext->pEditSettings->Effects[currEditInfo.overlaySettingsIndex].xVSS.pFramingFilePath, 99);

        //Change the name to png file
        extPos = strstr(tmpOverlayFilename, ".rgb");
        if (extPos != NULL) {
            *extPos = '\0';
        } else {
            ALOGE("ERROR the overlay file is incorrect");
        }

        strcat(tmpOverlayFilename, ".png");

        tmpRenderingMode = pContext->pEditSettings->pClipList[iCurrentClipIndex]->xVSS.MediaRendering;
        tmpOverlayString = pEnv->NewStringUTF(tmpOverlayFilename);
        pEnv->CallVoidMethod(pContext->engine,
            pContext->previewFrameEditInfoId,
            tmpOverlayString, tmpRenderingMode);

    }

    videoEditJava_checkAndThrowRuntimeException(&needToBeLoaded, pEnv,
            (M4NO_ERROR != result), result);

    free(frameStr.pBuffer);
    if (pContext->pEditSettings->pClipList[iCurrentClipIndex]->FileType !=
            M4VIDEOEDITING_kFileType_ARGB8888) {
        free(yuvPlane);
    }

    return tnTimeMs;
}

static int videoEditor_renderMediaItemPreviewFrame(JNIEnv* pEnv,
                                                    jobject thiz,
                                                    jobject mSurface,
                                                    jstring filePath,
                                                    jint    frameWidth,
                                                    jint    frameHeight,
                                                    jint    surfaceWidth,
                                                    jint    surfaceHeight,
                                                    jlong   fromMs)
{
    bool needToBeLoaded = true;
    M4OSA_ERR result = M4NO_ERROR;
    M4OSA_UInt32 timeMs = (M4OSA_UInt32)fromMs;
    M4OSA_UInt32 framesizeYuv =0;
    M4VIFI_UInt8 *pixelArray = M4OSA_NULL;
    VideoEditor_renderPreviewFrameStr frameStr;
    M4OSA_Context tnContext = M4OSA_NULL;
    const char* pMessage = NULL;
    M4VIFI_ImagePlane yuvPlane[3], rgbPlane;

    ManualEditContext* pContext = M4OSA_NULL;
    // Get the context.
    pContext =
            (ManualEditContext*)videoEditClasses_getContext(&needToBeLoaded,
                                                      pEnv, thiz);

    // Make sure that the context was set.
    videoEditJava_checkAndThrowIllegalStateException(&needToBeLoaded, pEnv,
                                             (M4OSA_NULL == pContext),
                                             "not initialized");

    // Make sure that the context was set.
    videoEditJava_checkAndThrowIllegalStateException(&needToBeLoaded, pEnv,
                                 (M4OSA_NULL == pContext->mPreviewController),
                                 "not initialized");

    // Validate the mSurface parameter.
    videoEditJava_checkAndThrowIllegalArgumentException(&needToBeLoaded, pEnv,
                                                (NULL == mSurface),
                                                "mSurface is null");

    sp<Surface> previewSurface = android_view_Surface_getSurface(pEnv, mSurface);

    const char *pString = pEnv->GetStringUTFChars(filePath, NULL);
    if (pString == M4OSA_NULL) {
        if (pEnv != NULL) {
            jniThrowException(pEnv, "java/lang/RuntimeException", "Input string null");
        }
    }
    VIDEOEDIT_LOG_FUNCTION(ANDROID_LOG_INFO, "VIDEO_EDITOR",
        "videoEditor_renderMediaItemPreviewFrame() timeMs=%d", timeMs);
    /* get thumbnail*/
    result = ThumbnailOpen(&tnContext,(const M4OSA_Char*)pString, M4OSA_TRUE);
    if (result != M4NO_ERROR || tnContext  == M4OSA_NULL) {
        return timeMs;
    }

    framesizeYuv = ((frameWidth)*(frameHeight)*1.5);

    pixelArray = (M4VIFI_UInt8 *)M4OSA_32bitAlignedMalloc(framesizeYuv, M4VS,\
        (M4OSA_Char*)"videoEditor pixelArray");
    if (pixelArray == M4OSA_NULL) {
        VIDEOEDIT_LOG_FUNCTION(ANDROID_LOG_INFO, "VIDEO_EDITOR",
            "videoEditor_renderPreviewFrame() malloc error");
        ThumbnailClose(tnContext);
        pMessage = videoEditJava_getErrorName(M4ERR_ALLOC);
        jniThrowException(pEnv, "java/lang/RuntimeException", pMessage);
        return timeMs;
    }

    result = ThumbnailGetPixels16(tnContext, (M4OSA_Int16 *)pixelArray,
                                                frameWidth,
                                                frameHeight, &timeMs, 0);
    if (result != M4NO_ERROR) {
        free(pixelArray);
        ThumbnailClose(tnContext);
        return fromMs;
    }

#ifdef DUMPTOFILESYSTEM
    {
        M4OSA_Context fileContext;
        M4OSA_Char* fileName = (M4OSA_Char*)"/mnt/sdcard/FirstRGB565.rgb";
        M4OSA_fileWriteOpen(&fileContext, (M4OSA_Void*) fileName,\
            M4OSA_kFileWrite|M4OSA_kFileCreate);
        M4OSA_fileWriteData(fileContext, (M4OSA_MemAddr8) pixelArray,
                            framesizeRgb);
        M4OSA_fileWriteClose(fileContext);
    }
#endif

    yuvPlane[0].pac_data = (M4VIFI_UInt8*)pixelArray;
    yuvPlane[0].u_height = frameHeight;
    yuvPlane[0].u_width = frameWidth;
    yuvPlane[0].u_stride = yuvPlane[0].u_width;
    yuvPlane[0].u_topleft = 0;

    yuvPlane[1].u_height = frameHeight/2;
    yuvPlane[1].u_width = frameWidth/2;
    yuvPlane[1].u_stride = yuvPlane[1].u_width;
    yuvPlane[1].u_topleft = 0;
    yuvPlane[1].pac_data = yuvPlane[0].pac_data
                + yuvPlane[0].u_width*yuvPlane[0].u_height;

    yuvPlane[2].u_height = frameHeight/2;
    yuvPlane[2].u_width = frameWidth/2;
    yuvPlane[2].u_stride = yuvPlane[2].u_width;
    yuvPlane[2].u_topleft = 0;
    yuvPlane[2].pac_data = yuvPlane[0].pac_data
        + yuvPlane[0].u_width*yuvPlane[0].u_height + \
        (yuvPlane[0].u_width/2)*(yuvPlane[0].u_height/2);
#ifdef DUMPTOFILESYSTEM
    {
        M4OSA_Context fileContext;
        M4OSA_Char* fileName = (M4OSA_Char*)"/mnt/sdcard/ConvertedYuv.yuv";
        M4OSA_fileWriteOpen(&fileContext, (M4OSA_Void*) fileName,\
            M4OSA_kFileWrite|M4OSA_kFileCreate);
        M4OSA_fileWriteData(fileContext, (M4OSA_MemAddr8) yuvPlane[0].pac_data,
                            framesizeYuv);
        M4OSA_fileWriteClose(fileContext);
    }
#endif

    /* Fill up the render structure*/
    frameStr.pBuffer = (M4OSA_Void*)yuvPlane[0].pac_data;
    frameStr.timeMs = timeMs;    /* timestamp on storyboard*/
    frameStr.uiSurfaceWidth = frameWidth;
    frameStr.uiSurfaceHeight = frameHeight;
    frameStr.uiFrameWidth = frameWidth;
    frameStr.uiFrameHeight = frameHeight;
    frameStr.bApplyEffect = M4OSA_FALSE;
    // clip begin cuttime and end cuttime set to 0
    // as its only required when effect needs to be applied while rendering
    frameStr.clipBeginCutTime = 0;
    frameStr.clipEndCutTime = 0;

    /*  pContext->mPreviewController->setPreviewFrameRenderingMode(M4xVSS_kBlackBorders,
    (M4VIDEOEDITING_VideoFrameSize)(M4VIDEOEDITING_kHD960+1));*/
    result
    = pContext->mPreviewController->renderPreviewFrame(previewSurface,&frameStr, NULL);
    videoEditJava_checkAndThrowRuntimeException(&needToBeLoaded, pEnv,
                                                (M4NO_ERROR != result), result);

    /* free the pixelArray and yuvPlane[0].pac_data */
    free(yuvPlane[0].pac_data);

    ThumbnailClose(tnContext);

    if (pString != NULL) {
        pEnv->ReleaseStringUTFChars(filePath, pString);
    }

    return timeMs;
}

int videoEditor_generateAudioRawFile(   JNIEnv*     pEnv,
                                        jobject     thiz,
                                        jstring     infilePath,
                                        jstring     pcmfilePath)
{
    M4OSA_ERR result = M4NO_ERROR;
    bool               loaded   = true;
    ManualEditContext* pContext = M4OSA_NULL;



    const char *pInputFile = pEnv->GetStringUTFChars(infilePath, NULL);
    if (pInputFile == M4OSA_NULL) {
        if (pEnv != NULL) {
            jniThrowException(pEnv, "java/lang/RuntimeException", "Input string null");
        }
    }

    const char *pStringOutPCMFilePath = pEnv->GetStringUTFChars(pcmfilePath, NULL);
    if (pStringOutPCMFilePath == M4OSA_NULL) {
        if (pEnv != NULL) {
            jniThrowException(pEnv, "java/lang/RuntimeException", "Input string null");
        }
    }

    VIDEOEDIT_LOG_FUNCTION(ANDROID_LOG_INFO,
        "VIDEO_EDITOR", "videoEditor_generateAudioRawFile infilePath %s",
        pInputFile);
    VIDEOEDIT_LOG_FUNCTION(ANDROID_LOG_INFO,
        "VIDEO_EDITOR", "videoEditor_generateAudioRawFile pcmfilePath %s",
        pStringOutPCMFilePath);
    // Get the context.
    pContext = (ManualEditContext*)videoEditClasses_getContext(&loaded, pEnv, thiz);

    result = videoEditor_generateAudio( pEnv, pContext, (M4OSA_Char*)pInputFile,
        (M4OSA_Char*)pStringOutPCMFilePath);

    if (pInputFile != NULL) {
        pEnv->ReleaseStringUTFChars(infilePath, pInputFile);
    }
    if (pStringOutPCMFilePath != NULL) {
        pEnv->ReleaseStringUTFChars(pcmfilePath, pStringOutPCMFilePath);
    }

    return result;
}

M4OSA_ERR videoEditor_generateAudio(JNIEnv* pEnv,ManualEditContext* pContext,
                                    M4OSA_Char* infilePath,
                                    M4OSA_Char* pcmfilePath )
{
    bool                            needToBeLoaded = true;
    M4OSA_ERR                       result = M4NO_ERROR;
    M4MCS_Context                   mcsContext = M4OSA_NULL;
    M4OSA_Char*                     pInputFile = M4OSA_NULL;
    M4OSA_Char*                     pOutputFile = M4OSA_NULL;
    M4OSA_Char*                     pTempPath = M4OSA_NULL;
    M4MCS_OutputParams*             pOutputParams = M4OSA_NULL;
    M4MCS_EncodingParams*           pEncodingParams = M4OSA_NULL;
    M4OSA_Int32                     pInputFileType = 0;
    M4OSA_UInt8                     threadProgress = 0;
    M4OSA_Char*                     pTemp3gpFilePath = M4OSA_NULL;

    VIDEOEDIT_LOG_API(ANDROID_LOG_INFO, "VIDEO_EDITOR", "videoEditor_generateAudio()");

    videoEditJava_checkAndThrowIllegalArgumentException(&needToBeLoaded, pEnv,
        (NULL == pContext),
        "ManualEditContext is null");

    VIDEOEDIT_LOG_FUNCTION(ANDROID_LOG_INFO, "VIDEO_EDITOR", "M4MCS_init()");

    pOutputParams = (M4MCS_OutputParams *)M4OSA_32bitAlignedMalloc(
        sizeof(M4MCS_OutputParams),0x00,
        (M4OSA_Char *)"M4MCS_OutputParams");
    videoEditJava_checkAndThrowIllegalStateException(&needToBeLoaded, pEnv,
        (M4OSA_NULL == pOutputParams),
        "not initialized");
    if (needToBeLoaded == false) {
        return M4ERR_ALLOC;
    }

    pEncodingParams = (M4MCS_EncodingParams *)M4OSA_32bitAlignedMalloc(
        sizeof(M4MCS_EncodingParams),0x00,
        (M4OSA_Char *)"M4MCS_EncodingParams");
    videoEditJava_checkAndThrowIllegalStateException(&needToBeLoaded, pEnv,
        (M4OSA_NULL == pEncodingParams),
        "not initialized");
    if (needToBeLoaded == false) {
        free(pEncodingParams);
        pEncodingParams = M4OSA_NULL;
        return M4ERR_ALLOC;
    }

    // Initialize the MCS library.
    result = M4MCS_init(&mcsContext, pContext->initParams.pFileReadPtr,
        pContext->initParams.pFileWritePtr);
    videoEditJava_checkAndThrowRuntimeException(&needToBeLoaded, pEnv,\
        (M4NO_ERROR != result), result);
    videoEditJava_checkAndThrowIllegalStateException(&needToBeLoaded, pEnv,
        (M4OSA_NULL == mcsContext),
        "not initialized");
     if(needToBeLoaded == false) {
         free(pOutputParams);
         pOutputParams = M4OSA_NULL;
         free(pEncodingParams);
         pEncodingParams = M4OSA_NULL;
         return result;
     }

    // generate the path for temp 3gp output file
    pTemp3gpFilePath = (M4OSA_Char*) M4OSA_32bitAlignedMalloc (
        (strlen((const char*)pContext->initParams.pTempPath)
        + strlen((const char*)TEMP_MCS_OUT_FILE_PATH)) + 1 /* for null termination */ , 0x0,
        (M4OSA_Char*)"Malloc for temp 3gp file");
    if (pTemp3gpFilePath != M4OSA_NULL)
    {
        memset((void *)pTemp3gpFilePath  ,0,
            strlen((const char*)pContext->initParams.pTempPath)
            + strlen((const char*)TEMP_MCS_OUT_FILE_PATH) + 1);
        strncat((char *)pTemp3gpFilePath,
            (const char *)pContext->initParams.pTempPath  ,
            (size_t) ((M4OSA_Char*)pContext->initParams.pTempPath));
        strncat((char *)pTemp3gpFilePath , (const char *)TEMP_MCS_OUT_FILE_PATH,
            (size_t)strlen ((const char*)TEMP_MCS_OUT_FILE_PATH));
    }
    else {
         M4MCS_abort(mcsContext);
         free(pOutputParams);
         pOutputParams = M4OSA_NULL;
         free(pEncodingParams);
         pEncodingParams = M4OSA_NULL;
         return M4ERR_ALLOC;
    }

    pInputFile = (M4OSA_Char *) infilePath; //pContext->mAudioSettings->pFile;
    //Delete this file later
    pOutputFile = (M4OSA_Char *) pTemp3gpFilePath;
    // Temp folder path for VSS use = ProjectPath
    pTempPath = (M4OSA_Char *) pContext->initParams.pTempPath;
    pInputFileType = (M4VIDEOEDITING_FileType)pContext->mAudioSettings->fileType;

    VIDEOEDIT_LOG_API(ANDROID_LOG_INFO, "VIDEO_EDITOR", "TEMP_MCS_OUT_FILE_PATH len %d",
        strlen ((const char*)TEMP_MCS_OUT_FILE_PATH));
    VIDEOEDIT_LOG_API(ANDROID_LOG_INFO, "VIDEO_EDITOR", "pTemp3gpFilePath %s",
        pOutputFile);

    VIDEOEDIT_LOG_API(ANDROID_LOG_INFO, "VIDEO_EDITOR", "M4MCS_open()");

    result = M4MCS_open(mcsContext, pInputFile,
        (M4VIDEOEDITING_FileType)pInputFileType,
        pOutputFile, pTempPath);
    videoEditJava_checkAndThrowRuntimeException(&needToBeLoaded, pEnv,
        (M4NO_ERROR != result), result);
    if(needToBeLoaded == false) {
         free(pTemp3gpFilePath);
         pTemp3gpFilePath = M4OSA_NULL;
         M4MCS_abort(mcsContext);
         free(pOutputParams);
         pOutputParams = M4OSA_NULL;
         free(pEncodingParams);
         pEncodingParams = M4OSA_NULL;
         return result;
    }

    pOutputParams->OutputFileType
        = (M4VIDEOEDITING_FileType)M4VIDEOEDITING_kFileType_3GPP;
    // Set the video format.
    pOutputParams->OutputVideoFormat =
        (M4VIDEOEDITING_VideoFormat)M4VIDEOEDITING_kNoneVideo;//M4VIDEOEDITING_kNoneVideo;
    pOutputParams->outputVideoProfile = 1;
    pOutputParams->outputVideoLevel = 1;
    // Set the frame size.
    pOutputParams->OutputVideoFrameSize
        = (M4VIDEOEDITING_VideoFrameSize)M4VIDEOEDITING_kQCIF;
    // Set the frame rate.
    pOutputParams->OutputVideoFrameRate
        = (M4VIDEOEDITING_VideoFramerate)M4VIDEOEDITING_k5_FPS;

    // Set the audio format.
    pOutputParams->OutputAudioFormat
        = (M4VIDEOEDITING_AudioFormat)M4VIDEOEDITING_kAAC;
    // Set the audio sampling frequency.
    pOutputParams->OutputAudioSamplingFrequency =
        (M4VIDEOEDITING_AudioSamplingFrequency)M4VIDEOEDITING_k32000_ASF;
    // Set the audio mono.
    pOutputParams->bAudioMono = false;
    // Set the pcm file; null for now.
    pOutputParams->pOutputPCMfile = (M4OSA_Char *)pcmfilePath;
    //(M4OSA_Char *)"/sdcard/Output/AudioPcm.pcm";
    // Set the audio sampling frequency.
    pOutputParams->MediaRendering = (M4MCS_MediaRendering)M4MCS_kCropping;
    // new params after integrating MCS 2.0
    // Set the number of audio effects; 0 for now.
    pOutputParams->nbEffects = 0;
    // Set the audio effect; null for now.
    pOutputParams->pEffects = NULL;
    // Set the audio effect; null for now.
    pOutputParams->bDiscardExif = M4OSA_FALSE;
    // Set the audio effect; null for now.
    pOutputParams->bAdjustOrientation = M4OSA_FALSE;

    VIDEOEDIT_LOG_FUNCTION(ANDROID_LOG_INFO, "VIDEO_EDITOR", "M4MCS_setOutputParams()");
    result = M4MCS_setOutputParams(mcsContext, pOutputParams);
    videoEditJava_checkAndThrowRuntimeException(&needToBeLoaded, pEnv,
                                        (M4NO_ERROR != result), result);
    if (needToBeLoaded == false) {
         free(pTemp3gpFilePath);
         pTemp3gpFilePath = M4OSA_NULL;
         M4MCS_abort(mcsContext);
         free(pOutputParams);
         pOutputParams = M4OSA_NULL;
         free(pEncodingParams);
         pEncodingParams = M4OSA_NULL;
        return result;
    }
    // Set the video bitrate.
    pEncodingParams->OutputVideoBitrate =
    (M4VIDEOEDITING_Bitrate)M4VIDEOEDITING_kUndefinedBitrate;
    // Set the audio bitrate.
    pEncodingParams->OutputAudioBitrate
        = (M4VIDEOEDITING_Bitrate)M4VIDEOEDITING_k128_KBPS;
    // Set the end cut time in milliseconds.
    pEncodingParams->BeginCutTime = 0;
    // Set the end cut time in milliseconds.
    pEncodingParams->EndCutTime = 0;
    // Set the output file size in bytes.
    pEncodingParams->OutputFileSize = 0;
    // Set video time scale.
    pEncodingParams->OutputVideoTimescale = 0;

    VIDEOEDIT_LOG_FUNCTION(ANDROID_LOG_INFO, "VIDEO_EDITOR",
                            "M4MCS_setEncodingParams()");
    result = M4MCS_setEncodingParams(mcsContext, pEncodingParams);
    videoEditJava_checkAndThrowRuntimeException(&needToBeLoaded, pEnv,
        (M4NO_ERROR != result), result);
    if (needToBeLoaded == false) {
         free(pTemp3gpFilePath);
         pTemp3gpFilePath = M4OSA_NULL;
         M4MCS_abort(mcsContext);
         free(pOutputParams);
         pOutputParams = M4OSA_NULL;
         free(pEncodingParams);
         pEncodingParams = M4OSA_NULL;
         return result;
    }

    VIDEOEDIT_LOG_FUNCTION(ANDROID_LOG_INFO, "VIDEO_EDITOR",
                            "M4MCS_checkParamsAndStart()");
    result = M4MCS_checkParamsAndStart(mcsContext);
    videoEditJava_checkAndThrowRuntimeException(&needToBeLoaded, pEnv,
        (M4NO_ERROR != result), result);
    if (needToBeLoaded == false) {
         free(pTemp3gpFilePath);
         pTemp3gpFilePath = M4OSA_NULL;
         M4MCS_abort(mcsContext);
         free(pOutputParams);
         pOutputParams = M4OSA_NULL;
         free(pEncodingParams);
         pEncodingParams = M4OSA_NULL;
        return result;
    }

    VIDEOEDIT_LOG_FUNCTION(ANDROID_LOG_INFO, "VIDEO_EDITOR", "M4MCS_step()");

    /*+ PROGRESS CB */
    M4OSA_UInt8 curProgress = 0;
    int         lastProgress = 0;

    ALOGV("LVME_generateAudio Current progress is =%d", curProgress);
    pEnv->CallVoidMethod(pContext->engine,
            pContext->onProgressUpdateMethodId, 1/*task status*/,
            curProgress/*progress*/);
    do {
        result = M4MCS_step(mcsContext, &curProgress);

        if (result != M4NO_ERROR) {
            ALOGV("LVME_generateAudio M4MCS_step returned 0x%x",result);

            if (result == M4MCS_WAR_TRANSCODING_DONE) {
                ALOGV("LVME_generateAudio MCS process ended");

                // Send a progress notification.
                curProgress = 100;
                pEnv->CallVoidMethod(pContext->engine,
                    pContext->onProgressUpdateMethodId, 1/*task status*/,
                    curProgress);
                ALOGV("LVME_generateAudio Current progress is =%d", curProgress);
            }
        } else {
            // Send a progress notification if needed
            if (curProgress != lastProgress) {
                lastProgress = curProgress;
                pEnv->CallVoidMethod(pContext->engine,
                    pContext->onProgressUpdateMethodId, 0/*task status*/,
                    curProgress/*progress*/);
                ALOGV("LVME_generateAudio Current progress is =%d",curProgress);
            }
        }
    } while (result == M4NO_ERROR);
    /*- PROGRESS CB */

    videoEditJava_checkAndThrowRuntimeException(&needToBeLoaded, pEnv,
        (M4MCS_WAR_TRANSCODING_DONE != result), result);
    if (needToBeLoaded == false) {
         free(pTemp3gpFilePath);
         pTemp3gpFilePath = M4OSA_NULL;
         M4MCS_abort(mcsContext);
         free(pOutputParams);
         pOutputParams = M4OSA_NULL;
         free(pEncodingParams);
         pEncodingParams = M4OSA_NULL;
        return result;
    }

    VIDEOEDIT_LOG_FUNCTION(ANDROID_LOG_INFO, "VIDEO_EDITOR", "M4MCS_abort()");
    result = M4MCS_abort(mcsContext);
    videoEditJava_checkAndThrowRuntimeException(&needToBeLoaded, pEnv,
        (M4NO_ERROR != result), result);

    //pContext->mAudioSettings->pFile = pOutputParams->pOutputPCMfile;
    remove((const char *) pTemp3gpFilePath);
    VIDEOEDIT_LOG_FUNCTION(ANDROID_LOG_INFO, "VIDEO_EDITOR", "videoEditor_generateAudio() EXIT ");

    if (pTemp3gpFilePath != M4OSA_NULL) {
        free(pTemp3gpFilePath);
    }
    if (pOutputParams != M4OSA_NULL) {
       free(pOutputParams);
    }
    if(pEncodingParams != M4OSA_NULL) {
       free(pEncodingParams);
    }
    return result;
}

static int removeAlphafromRGB8888 (
                        M4OSA_Char* pFramingFilePath,
                        M4xVSS_FramingStruct *pFramingCtx)
{
    M4OSA_UInt32 frameSize_argb = (pFramingCtx->width * pFramingCtx->height * 4); // aRGB data
    M4OSA_Context lImageFileFp  = M4OSA_NULL;
    M4OSA_ERR err = M4NO_ERROR;

    ALOGV("removeAlphafromRGB8888: width %d", pFramingCtx->width);

    M4OSA_UInt8 *pTmpData = (M4OSA_UInt8*) M4OSA_32bitAlignedMalloc(frameSize_argb, M4VS, (M4OSA_Char*)"Image argb data");
    if (pTmpData == M4OSA_NULL) {
        ALOGE("Failed to allocate memory for Image clip");
        return M4ERR_ALLOC;
    }

       /** Read the argb data from the passed file. */
    M4OSA_ERR lerr = M4OSA_fileReadOpen(&lImageFileFp, (M4OSA_Void *) pFramingFilePath, M4OSA_kFileRead);


    if ((lerr != M4NO_ERROR) || (lImageFileFp == M4OSA_NULL))
    {
        ALOGE("removeAlphafromRGB8888: Can not open the file ");
        free(pTmpData);
        return M4ERR_FILE_NOT_FOUND;
    }


    lerr = M4OSA_fileReadData(lImageFileFp, (M4OSA_MemAddr8)pTmpData, &frameSize_argb);
    if (lerr != M4NO_ERROR)
    {
        ALOGE("removeAlphafromRGB8888: can not read the data ");
        M4OSA_fileReadClose(lImageFileFp);
        free(pTmpData);
        return lerr;
    }
    M4OSA_fileReadClose(lImageFileFp);

    M4OSA_UInt32 frameSize = (pFramingCtx->width * pFramingCtx->height * 3); //Size of RGB 888 data.

    pFramingCtx->FramingRgb = (M4VIFI_ImagePlane*)M4OSA_32bitAlignedMalloc(
             sizeof(M4VIFI_ImagePlane), M4VS, (M4OSA_Char*)"Image clip RGB888 data");
    pFramingCtx->FramingRgb->pac_data = (M4VIFI_UInt8*)M4OSA_32bitAlignedMalloc(
             frameSize, M4VS, (M4OSA_Char*)"Image clip RGB888 data");

    if (pFramingCtx->FramingRgb == M4OSA_NULL)
    {
        ALOGE("Failed to allocate memory for Image clip");
        free(pTmpData);
        return M4ERR_ALLOC;
    }

    /** Remove the alpha channel */
    for (size_t i = 0, j = 0; i < frameSize_argb; i++) {
        if ((i % 4) == 0) continue;
        pFramingCtx->FramingRgb->pac_data[j] = pTmpData[i];
        j++;
    }
    free(pTmpData);
    return M4NO_ERROR;
}

static void
videoEditor_populateSettings(
                JNIEnv*                 pEnv,
                jobject                 thiz,
                jobject                 settings,
                jobject                 object,
                jobject                 audioSettingObject)
{
    VIDEOEDIT_LOG_FUNCTION(ANDROID_LOG_INFO, "VIDEO_EDITOR",
            "videoEditor_populateSettings()");

    bool                needToBeLoaded  = true;
    ManualEditContext*  pContext        = M4OSA_NULL;
    M4OSA_ERR           result          = M4NO_ERROR;
    jstring             strPath         = M4OSA_NULL;
    jstring             strPCMPath      = M4OSA_NULL;
    jobjectArray        propertiesClipsArray           = M4OSA_NULL;
    jobject             properties      = M4OSA_NULL;
    jint*               bitmapArray     =  M4OSA_NULL;
    jobjectArray        effectSettingsArray = M4OSA_NULL;
    jobject             effectSettings  = M4OSA_NULL;
    jintArray           pixelArray      = M4OSA_NULL;
    int width = 0;
    int height = 0;
    int nbOverlays = 0;
    int i,j = 0;
    int *pOverlayIndex = M4OSA_NULL;
    M4OSA_Char* pTempChar = M4OSA_NULL;

    // Add a code marker (the condition must always be true).
    ADD_CODE_MARKER_FUN(NULL != pEnv)

    // Validate the settings parameter.
    videoEditJava_checkAndThrowIllegalArgumentException(&needToBeLoaded, pEnv,
                                                (NULL == settings),
                                                "settings is null");
    // Get the context.
    pContext =
            (ManualEditContext*)videoEditClasses_getContext(&needToBeLoaded, pEnv, thiz);

    // Make sure that the context was set.
    videoEditJava_checkAndThrowIllegalStateException(&needToBeLoaded, pEnv,
                                             (M4OSA_NULL == pContext),
                                             "not initialized");
    // Make sure that the context was set.
    videoEditJava_checkAndThrowIllegalStateException(&needToBeLoaded, pEnv,
                                 (M4OSA_NULL == pContext->mPreviewController),
                                 "not initialized");
    jclass mPreviewClipPropClazz = pEnv->FindClass(PREVIEW_PROPERTIES_CLASS_NAME);
    videoEditJava_checkAndThrowIllegalStateException(&needToBeLoaded, pEnv,
                                     (M4OSA_NULL == mPreviewClipPropClazz),
                                     "not initialized");

    jfieldID fid = pEnv->GetFieldID(mPreviewClipPropClazz,"clipProperties",
            "[L"PROPERTIES_CLASS_NAME";"  );
    videoEditJava_checkAndThrowIllegalStateException(&needToBeLoaded, pEnv,
                                     (M4OSA_NULL == fid),
                                     "not initialized");

    propertiesClipsArray = (jobjectArray)pEnv->GetObjectField(object, fid);
    videoEditJava_checkAndThrowIllegalStateException(&needToBeLoaded, pEnv,
                                     (M4OSA_NULL == propertiesClipsArray),
                                     "not initialized");

    jclass engineClass = pEnv->FindClass(MANUAL_EDIT_ENGINE_CLASS_NAME);
    videoEditJava_checkAndThrowIllegalStateException(&needToBeLoaded, pEnv,
                                     (M4OSA_NULL == engineClass),
                                     "not initialized");

    pContext->onPreviewProgressUpdateMethodId = pEnv->GetMethodID(engineClass,
            "onPreviewProgressUpdate",     "(IZZLjava/lang/String;II)V");
    // Check if the context is valid (required because the context is dereferenced).
    if (needToBeLoaded) {
        // Make sure that we are in a correct state.
        videoEditJava_checkAndThrowIllegalStateException(&needToBeLoaded, pEnv,
                             (pContext->state != ManualEditState_INITIALIZED),
                             "settings already loaded");
        if (needToBeLoaded) {
            // Retrieve the edit settings.
            if (pContext->pEditSettings != M4OSA_NULL) {
                videoEditClasses_freeEditSettings(&pContext->pEditSettings);
                pContext->pEditSettings = M4OSA_NULL;
            }
            videoEditClasses_getEditSettings(&needToBeLoaded, pEnv,
                settings, &pContext->pEditSettings,false);
        }
    }

    if (needToBeLoaded == false) {
        j = 0;
        while (j < pContext->pEditSettings->nbEffects)
        {
            if (pContext->pEditSettings->Effects[j].xVSS.pFramingFilePath != M4OSA_NULL) {
                if (pContext->pEditSettings->Effects[j].xVSS.pFramingBuffer != M4OSA_NULL) {
                    free(pContext->pEditSettings->\
                    Effects[j].xVSS.pFramingBuffer);
                    pContext->pEditSettings->Effects[j].xVSS.pFramingBuffer = M4OSA_NULL;
                }
            }
          j++;
        }
        return;
    }

    M4OSA_TRACE1_0("videoEditorC_getEditSettings done");

    pContext->previewFrameEditInfoId = pEnv->GetMethodID(engineClass,
        "previewFrameEditInfo", "(Ljava/lang/String;I)V");

    if ( pContext->pEditSettings != NULL )
    {
        // Check if the edit settings could be retrieved.
        jclass mEditClazz = pEnv->FindClass(EDIT_SETTINGS_CLASS_NAME);
        if(mEditClazz == M4OSA_NULL)
        {
            M4OSA_TRACE1_0("cannot find object field for mEditClazz");
            goto videoEditor_populateSettings_cleanup;
        }
        jclass mEffectsClazz = pEnv->FindClass(EFFECT_SETTINGS_CLASS_NAME);
        if(mEffectsClazz == M4OSA_NULL)
        {
            M4OSA_TRACE1_0("cannot find object field for mEffectsClazz");
            goto videoEditor_populateSettings_cleanup;
        }
        fid = pEnv->GetFieldID(mEditClazz,"effectSettingsArray", "[L"EFFECT_SETTINGS_CLASS_NAME";"  );
        if(fid == M4OSA_NULL)
        {
            M4OSA_TRACE1_0("cannot find field for effectSettingsArray Array");
            goto videoEditor_populateSettings_cleanup;
        }
        effectSettingsArray = (jobjectArray)pEnv->GetObjectField(settings, fid);
        if(effectSettingsArray == M4OSA_NULL)
        {
            M4OSA_TRACE1_0("cannot find object field for effectSettingsArray");
            goto videoEditor_populateSettings_cleanup;
        }

        //int overlayIndex[pContext->pEditSettings->nbEffects];
        if (pContext->pEditSettings->nbEffects > 0)
        {
            pOverlayIndex
            = (int*) M4OSA_32bitAlignedMalloc(pContext->pEditSettings->nbEffects * sizeof(int), 0,
                (M4OSA_Char*)"pOverlayIndex");
            if (pOverlayIndex == M4OSA_NULL) {
                videoEditJava_checkAndThrowRuntimeException(&needToBeLoaded, pEnv,
                    M4OSA_TRUE, M4ERR_ALLOC);
                goto videoEditor_populateSettings_cleanup;
            }
        }

        i = 0;
        j = 0;
        M4OSA_TRACE1_1("no of effects = %d",pContext->pEditSettings->nbEffects);
        while (j < pContext->pEditSettings->nbEffects)
        {
            if (pContext->pEditSettings->Effects[j].xVSS.pFramingFilePath != M4OSA_NULL)
            {
                pOverlayIndex[nbOverlays] = j;

                M4xVSS_FramingStruct *aFramingCtx = M4OSA_NULL;
                aFramingCtx
                = (M4xVSS_FramingStruct*)M4OSA_32bitAlignedMalloc(sizeof(M4xVSS_FramingStruct), M4VS,
                  (M4OSA_Char*)"M4xVSS_internalDecodeGIF: Context of the framing effect");
                if (aFramingCtx == M4OSA_NULL)
                {
                    M4OSA_TRACE1_0("Allocation error in videoEditor_populateSettings");
                    videoEditJava_checkAndThrowRuntimeException(&needToBeLoaded, pEnv,
                        M4OSA_TRUE, M4ERR_ALLOC);
                    goto videoEditor_populateSettings_cleanup;
                }

                aFramingCtx->pCurrent = M4OSA_NULL; /* Only used by the first element of the chain */
                aFramingCtx->previousClipTime = -1;
                aFramingCtx->FramingYuv = M4OSA_NULL;
                aFramingCtx->FramingRgb = M4OSA_NULL;
                aFramingCtx->topleft_x
                    = pContext->pEditSettings->Effects[j].xVSS.topleft_x;
                aFramingCtx->topleft_y
                    = pContext->pEditSettings->Effects[j].xVSS.topleft_y;


                 VIDEOEDIT_LOG_FUNCTION(ANDROID_LOG_INFO, "VIDEO_EDITOR", "OF u_width %d",
                                        pContext->pEditSettings->Effects[j].xVSS.pFramingBuffer->u_width);
                 VIDEOEDIT_LOG_FUNCTION(ANDROID_LOG_INFO, "VIDEO_EDITOR", "OF u_height() %d",
                                        pContext->pEditSettings->Effects[j].xVSS.pFramingBuffer->u_height);
                 VIDEOEDIT_LOG_FUNCTION(ANDROID_LOG_INFO, "VIDEO_EDITOR", "OF rgbType() %d",
                                        pContext->pEditSettings->Effects[j].xVSS.rgbType);

                 aFramingCtx->width = pContext->pEditSettings->Effects[j].xVSS.pFramingBuffer->u_width;
                 aFramingCtx->height = pContext->pEditSettings->Effects[j].xVSS.pFramingBuffer->u_height;

                result = M4xVSS_internalConvertARGB888toYUV420_FrammingEffect(pContext->engineContext,
                    &(pContext->pEditSettings->Effects[j]),aFramingCtx,
                pContext->pEditSettings->Effects[j].xVSS.framingScaledSize);
                videoEditJava_checkAndThrowRuntimeException(&needToBeLoaded, pEnv,
                                            (M4NO_ERROR != result), result);
                if (needToBeLoaded == false) {
                    M4OSA_TRACE1_1("M4xVSS_internalConvertARGB888toYUV420_FrammingEffect returned 0x%x", result);
                    if (aFramingCtx != M4OSA_NULL) {
                        free(aFramingCtx);
                        aFramingCtx = M4OSA_NULL;
                    }
                    goto videoEditor_populateSettings_cleanup;
                }

                //framing buffers are resized to fit the output video resolution.
                pContext->pEditSettings->Effects[j].xVSS.pFramingBuffer->u_width =
                    aFramingCtx->FramingRgb->u_width;
                pContext->pEditSettings->Effects[j].xVSS.pFramingBuffer->u_height =
                    aFramingCtx->FramingRgb->u_height;

                VIDEOEDIT_LOG_FUNCTION(ANDROID_LOG_INFO, "VIDEO_EDITOR", "A framing Context aFramingCtx->width = %d",
                    aFramingCtx->FramingRgb->u_width);

                VIDEOEDIT_LOG_FUNCTION(ANDROID_LOG_INFO, "VIDEO_EDITOR", "A framing Context aFramingCtx->height = %d",
                    aFramingCtx->FramingRgb->u_height);


                width = pContext->pEditSettings->Effects[j].xVSS.pFramingBuffer->u_width;
                height = pContext->pEditSettings->Effects[j].xVSS.pFramingBuffer->u_height;

                //RGB 565
                pContext->pEditSettings->Effects[j].xVSS.pFramingBuffer->u_stride = width * 2;

                //for RGB565
                pContext->pEditSettings->Effects[j].xVSS.pFramingBuffer->u_topleft = 0;
                pContext->pEditSettings->Effects[j].xVSS.pFramingBuffer->pac_data =
                            (M4VIFI_UInt8 *)M4OSA_32bitAlignedMalloc(width*height*2,
                            0x00,(M4OSA_Char *)"pac_data buffer");

                if (pContext->pEditSettings->Effects[j].xVSS.pFramingBuffer->pac_data == M4OSA_NULL) {
                    M4OSA_TRACE1_0("Failed to allocate memory for framing buffer");
                    videoEditJava_checkAndThrowRuntimeException(&needToBeLoaded, pEnv,
                                            M4OSA_TRUE, M4ERR_ALLOC);
                    goto videoEditor_populateSettings_cleanup;
                }

                memcpy((void *)&pContext->pEditSettings->\
                    Effects[j].xVSS.pFramingBuffer->\
                    pac_data[0],(void *)&aFramingCtx->FramingRgb->pac_data[0],(width*height*2));

                //As of now rgb type is 565
                pContext->pEditSettings->Effects[j].xVSS.rgbType =
                    (M4VSS3GPP_RGBType) M4VSS3GPP_kRGB565;

                if (aFramingCtx->FramingYuv != M4OSA_NULL )
                {
                    if (aFramingCtx->FramingYuv[0].pac_data != M4OSA_NULL) {
                        free(aFramingCtx->FramingYuv[0].pac_data);
                        aFramingCtx->FramingYuv[0].pac_data = M4OSA_NULL;
                    }
                    if (aFramingCtx->FramingYuv[1].pac_data != M4OSA_NULL) {
                        free(aFramingCtx->FramingYuv[1].pac_data);
                        aFramingCtx->FramingYuv[1].pac_data = M4OSA_NULL;
                    }
                    if (aFramingCtx->FramingYuv[2].pac_data != M4OSA_NULL) {
                        free(aFramingCtx->FramingYuv[2].pac_data);
                        aFramingCtx->FramingYuv[2].pac_data = M4OSA_NULL;
                    }

                    free(aFramingCtx->FramingYuv);
                    aFramingCtx->FramingYuv = M4OSA_NULL;
                }
                if (aFramingCtx->FramingRgb->pac_data != M4OSA_NULL) {
                    free(aFramingCtx->FramingRgb->pac_data);
                    aFramingCtx->FramingRgb->pac_data = M4OSA_NULL;
                }
                if (aFramingCtx->FramingRgb != M4OSA_NULL) {
                    free(aFramingCtx->FramingRgb);
                    aFramingCtx->FramingRgb = M4OSA_NULL;
                }
                if (aFramingCtx != M4OSA_NULL) {
                    free(aFramingCtx);
                    aFramingCtx = M4OSA_NULL;
                }
                nbOverlays++;
            }
            j++;
        }

        // Check if the edit settings could be retrieved.
        M4OSA_TRACE1_1("total clips are = %d",pContext->pEditSettings->uiClipNumber);
        for (i = 0; i < pContext->pEditSettings->uiClipNumber; i++) {
            M4OSA_TRACE1_1("clip no = %d",i);
            properties = pEnv->GetObjectArrayElement(propertiesClipsArray, i);
            videoEditJava_checkAndThrowIllegalStateException(&needToBeLoaded, pEnv,
                (M4OSA_NULL == properties),
                "not initialized");
            if (needToBeLoaded) {
                getClipSetting(pEnv,properties, pContext->pEditSettings->pClipList[i]);
                pEnv->DeleteLocalRef(properties);
            } else {
                pEnv->DeleteLocalRef(properties);
                goto videoEditor_populateSettings_cleanup;
            }
        }

        if (needToBeLoaded) {
            // Log the edit settings.
            VIDEOEDIT_LOG_EDIT_SETTINGS(pContext->pEditSettings);
        }
    }
    /* free previous allocations , if any */
    if (pContext->mAudioSettings != M4OSA_NULL) {
        if (pContext->mAudioSettings->pFile != NULL) {
            free(pContext->mAudioSettings->pFile);
            pContext->mAudioSettings->pFile = M4OSA_NULL;
        }
        if (pContext->mAudioSettings->pPCMFilePath != NULL) {
            free(pContext->mAudioSettings->pPCMFilePath);
            pContext->mAudioSettings->pPCMFilePath = M4OSA_NULL;
        }
    }

    if (audioSettingObject != M4OSA_NULL) {
        jclass audioSettingClazz = pEnv->FindClass(AUDIO_SETTINGS_CLASS_NAME);
        videoEditJava_checkAndThrowIllegalStateException(&needToBeLoaded, pEnv,
                                         (M4OSA_NULL == audioSettingClazz),
                                         "not initialized");

        videoEditJava_checkAndThrowIllegalStateException(&needToBeLoaded, pEnv,
                                     (M4OSA_NULL == pContext->mAudioSettings),
                                     "not initialized");

        if (needToBeLoaded == false) {
            goto videoEditor_populateSettings_cleanup;
        }

        fid = pEnv->GetFieldID(audioSettingClazz,"bRemoveOriginal","Z");
        pContext->mAudioSettings->bRemoveOriginal =
            pEnv->GetBooleanField(audioSettingObject,fid);
        M4OSA_TRACE1_1("bRemoveOriginal = %d",pContext->mAudioSettings->bRemoveOriginal);

        fid = pEnv->GetFieldID(audioSettingClazz,"channels","I");
        pContext->mAudioSettings->uiNbChannels = pEnv->GetIntField(audioSettingObject,fid);
        M4OSA_TRACE1_1("uiNbChannels = %d",pContext->mAudioSettings->uiNbChannels);

        fid = pEnv->GetFieldID(audioSettingClazz,"Fs","I");
        pContext->mAudioSettings->uiSamplingFrequency = pEnv->GetIntField(audioSettingObject,fid);
        M4OSA_TRACE1_1("uiSamplingFrequency = %d",pContext->mAudioSettings->uiSamplingFrequency);

        fid = pEnv->GetFieldID(audioSettingClazz,"ExtendedFs","I");
        pContext->mAudioSettings->uiExtendedSamplingFrequency =
         pEnv->GetIntField(audioSettingObject,fid);
        M4OSA_TRACE1_1("uiExtendedSamplingFrequency = %d",
        pContext->mAudioSettings->uiExtendedSamplingFrequency);

        fid = pEnv->GetFieldID(audioSettingClazz,"startMs","J");
        pContext->mAudioSettings->uiAddCts
            = pEnv->GetLongField(audioSettingObject,fid);
        M4OSA_TRACE1_1("uiAddCts = %d",pContext->mAudioSettings->uiAddCts);

        fid = pEnv->GetFieldID(audioSettingClazz,"volume","I");
        pContext->mAudioSettings->uiAddVolume
            = pEnv->GetIntField(audioSettingObject,fid);
        M4OSA_TRACE1_1("uiAddVolume = %d",pContext->mAudioSettings->uiAddVolume);

        fid = pEnv->GetFieldID(audioSettingClazz,"loop","Z");
        pContext->mAudioSettings->bLoop
            = pEnv->GetBooleanField(audioSettingObject,fid);
        M4OSA_TRACE1_1("bLoop = %d",pContext->mAudioSettings->bLoop);

        fid = pEnv->GetFieldID(audioSettingClazz,"beginCutTime","J");
        pContext->mAudioSettings->beginCutMs
            = pEnv->GetLongField(audioSettingObject,fid);
        M4OSA_TRACE1_1("begin cut time = %d",pContext->mAudioSettings->beginCutMs);

        fid = pEnv->GetFieldID(audioSettingClazz,"endCutTime","J");
        pContext->mAudioSettings->endCutMs
            = pEnv->GetLongField(audioSettingObject,fid);
        M4OSA_TRACE1_1("end cut time = %d",pContext->mAudioSettings->endCutMs);

        fid = pEnv->GetFieldID(audioSettingClazz,"fileType","I");
        pContext->mAudioSettings->fileType
            = pEnv->GetIntField(audioSettingObject,fid);
        M4OSA_TRACE1_1("fileType = %d",pContext->mAudioSettings->fileType);

        fid = pEnv->GetFieldID(audioSettingClazz,"pFile","Ljava/lang/String;");
        strPath = (jstring)pEnv->GetObjectField(audioSettingObject,fid);
        pTempChar = (M4OSA_Char*)pEnv->GetStringUTFChars(strPath, M4OSA_NULL);
        if (pTempChar != NULL) {
            pContext->mAudioSettings->pFile = (M4OSA_Char*) M4OSA_32bitAlignedMalloc(
                (M4OSA_UInt32)(strlen((const char*)pTempChar))+1 /* +1 for NULL termination */, 0,
                (M4OSA_Char*)"strPath allocation " );
            if (pContext->mAudioSettings->pFile != M4OSA_NULL) {
                memcpy((void *)pContext->mAudioSettings->pFile ,
                    (void *)pTempChar , strlen((const char*)pTempChar));
                ((M4OSA_Int8 *)(pContext->mAudioSettings->pFile))[strlen((const char*)pTempChar)] = '\0';
                pEnv->ReleaseStringUTFChars(strPath,(const char *)pTempChar);
            } else {
                pEnv->ReleaseStringUTFChars(strPath,(const char *)pTempChar);
                VIDEOEDIT_LOG_ERROR(ANDROID_LOG_INFO, "VIDEO_EDITOR",
                    "regenerateAudio() Malloc failed for pContext->mAudioSettings->pFile ");
                videoEditJava_checkAndThrowRuntimeException(&needToBeLoaded, pEnv,
                    M4OSA_TRUE, M4ERR_ALLOC);
                goto videoEditor_populateSettings_cleanup;
            }
        }
        M4OSA_TRACE1_1("file name = %s",pContext->mAudioSettings->pFile);
        VIDEOEDIT_LOG_API(ANDROID_LOG_INFO, "VIDEOEDITOR", "regenerateAudio() file name = %s",\
        pContext->mAudioSettings->pFile);

        fid = pEnv->GetFieldID(audioSettingClazz,"pcmFilePath","Ljava/lang/String;");
        strPCMPath = (jstring)pEnv->GetObjectField(audioSettingObject,fid);
        pTempChar = (M4OSA_Char*)pEnv->GetStringUTFChars(strPCMPath, M4OSA_NULL);
        if (pTempChar != NULL) {
            pContext->mAudioSettings->pPCMFilePath = (M4OSA_Char*) M4OSA_32bitAlignedMalloc(
                (M4OSA_UInt32)(strlen((const char*)pTempChar))+1 /* +1 for NULL termination */, 0,
                (M4OSA_Char*)"strPCMPath allocation " );
            if (pContext->mAudioSettings->pPCMFilePath != M4OSA_NULL) {
                memcpy((void *)pContext->mAudioSettings->pPCMFilePath ,
                    (void *)pTempChar , strlen((const char*)pTempChar));
                ((M4OSA_Int8 *)(pContext->mAudioSettings->pPCMFilePath))[strlen((const char*)pTempChar)] = '\0';
                pEnv->ReleaseStringUTFChars(strPCMPath,(const char *)pTempChar);
            } else {
                pEnv->ReleaseStringUTFChars(strPCMPath,(const char *)pTempChar);
                VIDEOEDIT_LOG_ERROR(ANDROID_LOG_INFO, "VIDEO_EDITOR",
                    "regenerateAudio() Malloc failed for pContext->mAudioSettings->pPCMFilePath ");
                videoEditJava_checkAndThrowRuntimeException(&needToBeLoaded, pEnv,
                    M4OSA_TRUE, M4ERR_ALLOC);
                goto videoEditor_populateSettings_cleanup;
            }
        }
        VIDEOEDIT_LOG_API(ANDROID_LOG_INFO, "VIDEOEDITOR", "pPCMFilePath -- %s ",\
        pContext->mAudioSettings->pPCMFilePath);

        fid = pEnv->GetFieldID(engineClass,"mRegenerateAudio","Z");
        bool regenerateAudio = pEnv->GetBooleanField(thiz,fid);

        VIDEOEDIT_LOG_API(ANDROID_LOG_INFO, "VIDEOEDITOR", "regenerateAudio -- %d ",\
        regenerateAudio);

        if (regenerateAudio) {
            M4OSA_TRACE1_0("Calling Generate Audio now");
            result = videoEditor_generateAudio(pEnv,
                        pContext,
                        (M4OSA_Char*)pContext->mAudioSettings->pFile,
                        (M4OSA_Char*)pContext->mAudioSettings->pPCMFilePath);

            videoEditJava_checkAndThrowRuntimeException(&needToBeLoaded, pEnv,
                (M4NO_ERROR != result), result);
            if (needToBeLoaded == false) {
                goto videoEditor_populateSettings_cleanup;
            }

            regenerateAudio = false;
            pEnv->SetBooleanField(thiz,fid,regenerateAudio);
        }

        /* Audio mix and duck */
        fid = pEnv->GetFieldID(audioSettingClazz,"ducking_threshold","I");
        pContext->mAudioSettings->uiInDucking_threshold
            = pEnv->GetIntField(audioSettingObject,fid);

        M4OSA_TRACE1_1("ducking threshold = %d",
            pContext->mAudioSettings->uiInDucking_threshold);

        fid = pEnv->GetFieldID(audioSettingClazz,"ducking_lowVolume","I");
        pContext->mAudioSettings->uiInDucking_lowVolume
            = pEnv->GetIntField(audioSettingObject,fid);

        M4OSA_TRACE1_1("ducking lowVolume = %d",
            pContext->mAudioSettings->uiInDucking_lowVolume);

        fid = pEnv->GetFieldID(audioSettingClazz,"bInDucking_enable","Z");
        pContext->mAudioSettings->bInDucking_enable
            = pEnv->GetBooleanField(audioSettingObject,fid);
        M4OSA_TRACE1_1("ducking lowVolume = %d",
            pContext->mAudioSettings->bInDucking_enable);

    } else {
        if (pContext->mAudioSettings != M4OSA_NULL) {
            pContext->mAudioSettings->pFile = M4OSA_NULL;
            pContext->mAudioSettings->pPCMFilePath = M4OSA_NULL;
            pContext->mAudioSettings->bRemoveOriginal = 0;
            pContext->mAudioSettings->uiNbChannels = 0;
            pContext->mAudioSettings->uiSamplingFrequency = 0;
            pContext->mAudioSettings->uiExtendedSamplingFrequency = 0;
            pContext->mAudioSettings->uiAddCts = 0;
            pContext->mAudioSettings->uiAddVolume = 0;
            pContext->mAudioSettings->beginCutMs = 0;
            pContext->mAudioSettings->endCutMs = 0;
            pContext->mAudioSettings->fileType = 0;
            pContext->mAudioSettings->bLoop = 0;
            pContext->mAudioSettings->uiInDucking_lowVolume  = 0;
            pContext->mAudioSettings->bInDucking_enable  = 0;
            pContext->mAudioSettings->uiBTChannelCount  = 0;
            pContext->mAudioSettings->uiInDucking_threshold = 0;

            fid = pEnv->GetFieldID(engineClass,"mRegenerateAudio","Z");
            bool regenerateAudio = pEnv->GetBooleanField(thiz,fid);
            if (!regenerateAudio) {
                regenerateAudio = true;
                pEnv->SetBooleanField(thiz,fid,regenerateAudio);
            }
        }
    }

    if (pContext->pEditSettings != NULL)
    {
        result = pContext->mPreviewController->loadEditSettings(pContext->pEditSettings,
            pContext->mAudioSettings);
        videoEditJava_checkAndThrowRuntimeException(&needToBeLoaded, pEnv,
                                            (M4NO_ERROR != result), result);

        if (needToBeLoaded) {
            pContext->mPreviewController->setJniCallback((void*)pContext,
            (jni_progress_callback_fct)jniPreviewProgressCallback);
        }
    }

videoEditor_populateSettings_cleanup:
        j = 0;
        while (j < nbOverlays)
        {
            if (pContext->pEditSettings->Effects[pOverlayIndex[j]].xVSS.pFramingBuffer->pac_data != \
                M4OSA_NULL) {
                free(pContext->pEditSettings->\
                Effects[pOverlayIndex[j]].xVSS.pFramingBuffer->pac_data);
                pContext->pEditSettings->\
                Effects[pOverlayIndex[j]].xVSS.pFramingBuffer->pac_data = M4OSA_NULL;
            }
            j++;
        }

        j = 0;
        while (j < pContext->pEditSettings->nbEffects)
        {
            if (pContext->pEditSettings->Effects[j].xVSS.pFramingFilePath != M4OSA_NULL) {
                if (pContext->pEditSettings->Effects[j].xVSS.pFramingBuffer != M4OSA_NULL) {
                    free(pContext->pEditSettings->\
                    Effects[j].xVSS.pFramingBuffer);
                    pContext->pEditSettings->Effects[j].xVSS.pFramingBuffer = M4OSA_NULL;
                }
            }
          j++;
        }

    if (pOverlayIndex != M4OSA_NULL)
    {
        free(pOverlayIndex);
        pOverlayIndex = M4OSA_NULL;
    }
    return;
}

static void
videoEditor_startPreview(
                JNIEnv*                 pEnv,
                jobject                 thiz,
                jobject                 mSurface,
                jlong                   fromMs,
                jlong                   toMs,
                jint                    callbackInterval,
                jboolean                loop)
{
    bool needToBeLoaded = true;
    M4OSA_ERR result = M4NO_ERROR;
    VIDEOEDIT_LOG_FUNCTION(ANDROID_LOG_INFO, "VIDEO_EDITOR", "videoEditor_startPreview()");

    ManualEditContext* pContext = M4OSA_NULL;
    // Get the context.
    pContext = (ManualEditContext*)videoEditClasses_getContext(&needToBeLoaded, pEnv, thiz);

    // Make sure that the context was set.
    videoEditJava_checkAndThrowIllegalStateException(&needToBeLoaded, pEnv,
                                             (M4OSA_NULL == pContext),
                                             "not initialized");

    videoEditJava_checkAndThrowIllegalStateException(&needToBeLoaded, pEnv,
                                     (M4OSA_NULL == pContext->mAudioSettings),
                                     "not initialized");
    // Make sure that the context was set.
    videoEditJava_checkAndThrowIllegalStateException(&needToBeLoaded, pEnv,
                                 (M4OSA_NULL == pContext->mPreviewController),
                                 "not initialized");

    // Validate the mSurface parameter.
    videoEditJava_checkAndThrowIllegalArgumentException(&needToBeLoaded, pEnv,
                                                (NULL == mSurface),
                                                "mSurface is null");

    sp<Surface> previewSurface = android_view_Surface_getSurface(pEnv, mSurface);

    // Validate the mSurface's mNativeSurface field
    videoEditJava_checkAndThrowIllegalStateException(&needToBeLoaded, pEnv,
                                                (NULL == previewSurface.get()),
                                                "mNativeSurface is null");

    result =  pContext->mPreviewController->setSurface(previewSurface);
    videoEditJava_checkAndThrowRuntimeException(&needToBeLoaded, pEnv,
        (M4NO_ERROR != result), result);
    VIDEOEDIT_LOG_FUNCTION(ANDROID_LOG_INFO, "VIDEO_EDITOR", "fromMs=%ld, toMs=%ld",
        (M4OSA_UInt32)fromMs, (M4OSA_Int32)toMs);

    result = pContext->mPreviewController->startPreview((M4OSA_UInt32)fromMs,
                                                (M4OSA_Int32)toMs,
                                                (M4OSA_UInt16)callbackInterval,
                                                (M4OSA_Bool)loop);
    videoEditJava_checkAndThrowRuntimeException(&needToBeLoaded, pEnv, (M4NO_ERROR != result), result);
}


static jobject
videoEditor_getProperties(
                JNIEnv*                             pEnv,
                jobject                             thiz,
                jstring                             file)
{
    jobject object = M4OSA_NULL;
    jclass clazz = pEnv->FindClass(PROPERTIES_CLASS_NAME);
    jfieldID fid;
    bool needToBeLoaded = true;
    ManualEditContext* pContext = M4OSA_NULL;
    M4OSA_ERR          result   = M4NO_ERROR;
    int profile = 0;
    int level = 0;
    int videoFormat = 0;

    // Get the context.
    pContext = (ManualEditContext*)videoEditClasses_getContext(&needToBeLoaded, pEnv, thiz);

    videoEditJava_checkAndThrowIllegalStateException(&needToBeLoaded, pEnv,
                                             (M4OSA_NULL == clazz),
                                             "not initialized");

    object = videoEditProp_getProperties(pEnv,thiz,file);

    if (object != M4OSA_NULL) {
        fid = pEnv->GetFieldID(clazz,"profile","I");
        profile = pEnv->GetIntField(object,fid);
        fid = pEnv->GetFieldID(clazz,"level","I");
        level = pEnv->GetIntField(object,fid);
        fid = pEnv->GetFieldID(clazz,"videoFormat","I");
        videoFormat = pEnv->GetIntField(object,fid);

        result = checkClipVideoProfileAndLevel(pContext->decoders, videoFormat, profile, level);

        fid = pEnv->GetFieldID(clazz,"profileSupported","Z");
        if (M4VSS3GPP_ERR_EDITING_UNSUPPORTED_VIDEO_PROFILE == result) {
            pEnv->SetBooleanField(object,fid,false);
        }

        fid = pEnv->GetFieldID(clazz,"levelSupported","Z");
        if (M4VSS3GPP_ERR_EDITING_UNSUPPORTED_VIDEO_LEVEL == result) {
            pEnv->SetBooleanField(object,fid,false);
        }
    }
    return object;

}
static int videoEditor_getPixels(
                    JNIEnv*                     env,
                    jobject                     thiz,
                    jstring                     path,
                    jintArray                   pixelArray,
                    M4OSA_UInt32                width,
                    M4OSA_UInt32                height,
                    M4OSA_UInt32                timeMS)
{

    M4OSA_ERR       err = M4NO_ERROR;
    M4OSA_Context   mContext = M4OSA_NULL;
    jint*           m_dst32 = M4OSA_NULL;


    // Add a text marker (the condition must always be true).
    ADD_TEXT_MARKER_FUN(NULL != env)

    const char *pString = env->GetStringUTFChars(path, NULL);
    if (pString == M4OSA_NULL) {
        if (env != NULL) {
            jniThrowException(env, "java/lang/RuntimeException", "Input string null");
        }
        return M4ERR_ALLOC;
    }

    err = ThumbnailOpen(&mContext,(const M4OSA_Char*)pString, M4OSA_FALSE);
    if (err != M4NO_ERROR || mContext == M4OSA_NULL) {
        if (pString != NULL) {
            env->ReleaseStringUTFChars(path, pString);
        }
        if (env != NULL) {
            jniThrowException(env, "java/lang/RuntimeException", "ThumbnailOpen failed");
        }
    }

    m_dst32 = env->GetIntArrayElements(pixelArray, NULL);

    err = ThumbnailGetPixels32(mContext, (M4OSA_Int32 *)m_dst32, width,height,&timeMS,0);
    if (err != M4NO_ERROR ) {
        if (env != NULL) {
            jniThrowException(env, "java/lang/RuntimeException",\
                "ThumbnailGetPixels32 failed");
        }
    }
    env->ReleaseIntArrayElements(pixelArray, m_dst32, 0);

    ThumbnailClose(mContext);
    if (pString != NULL) {
        env->ReleaseStringUTFChars(path, pString);
    }

    return timeMS;
}

static int videoEditor_getPixelsList(
                JNIEnv*                 env,
                jobject                 thiz,
                jstring                 path,
                jintArray               pixelArray,
                M4OSA_UInt32            width,
                M4OSA_UInt32            height,
                M4OSA_UInt32            noOfThumbnails,
                jlong                   startTime,
                jlong                   endTime,
                jintArray               indexArray,
                jobject                 callback)
{

    M4OSA_ERR           err = M4NO_ERROR;
    M4OSA_Context       mContext = M4OSA_NULL;

    const char *pString = env->GetStringUTFChars(path, NULL);
    if (pString == M4OSA_NULL) {
        jniThrowException(env, "java/lang/RuntimeException", "Input string null");
        return M4ERR_ALLOC;
    }

    err = ThumbnailOpen(&mContext,(const M4OSA_Char*)pString, M4OSA_FALSE);
    if (err != M4NO_ERROR || mContext == M4OSA_NULL) {
        jniThrowException(env, "java/lang/RuntimeException", "ThumbnailOpen failed");
        if (pString != NULL) {
            env->ReleaseStringUTFChars(path, pString);
        }
        return err;
    }

    jlong duration = (endTime - startTime);
    M4OSA_UInt32 tolerance = duration / (2 * noOfThumbnails);
    jint* m_dst32 = env->GetIntArrayElements(pixelArray, NULL);
    jint* indices = env->GetIntArrayElements(indexArray, NULL);
    jsize len = env->GetArrayLength(indexArray);

    jclass cls = env->GetObjectClass(callback);
    jmethodID mid = env->GetMethodID(cls, "onThumbnail", "(I)V");

    for (int i = 0; i < len; i++) {
        int k = indices[i];
        M4OSA_UInt32 timeMS = startTime;
        timeMS += (2 * k + 1) * duration / (2 * noOfThumbnails);
        err = ThumbnailGetPixels32(mContext, ((M4OSA_Int32 *)m_dst32),
            width, height, &timeMS, tolerance);
        if (err != M4NO_ERROR) {
            break;
        }
        env->CallVoidMethod(callback, mid, (jint)k);
        if (env->ExceptionCheck()) {
            err = M4ERR_ALLOC;
            break;
        }
    }

    env->ReleaseIntArrayElements(pixelArray, m_dst32, 0);
    env->ReleaseIntArrayElements(indexArray, indices, 0);

    ThumbnailClose(mContext);
    if (pString != NULL) {
        env->ReleaseStringUTFChars(path, pString);
    }

    if (err != M4NO_ERROR && !env->ExceptionCheck()) {
        jniThrowException(env, "java/lang/RuntimeException",\
                "ThumbnailGetPixels32 failed");
    }

    return err;
}

static M4OSA_ERR
videoEditor_toUTF8Fct(
                M4OSA_Void*                         pBufferIn,
                M4OSA_UInt8*                        pBufferOut,
                M4OSA_UInt32*                       bufferOutSize)
{
    M4OSA_ERR    result = M4NO_ERROR;
    M4OSA_UInt32 length = 0;

    VIDEOEDIT_LOG_FUNCTION(ANDROID_LOG_INFO, "VIDEO_EDITOR", "videoEditor_toUTF8Fct()");

    // Determine the length of the input buffer.
    if (M4OSA_NULL != pBufferIn)
    {
        length = strlen((const char *)pBufferIn);
    }

    // Check if the output buffer is large enough to hold the input buffer.
    if ((*bufferOutSize) > length)
    {
        // Check if the input buffer is not M4OSA_NULL.
        if (M4OSA_NULL != pBufferIn)
        {
            // Copy the temp path, ignore the result.
            M4OSA_chrNCopy((M4OSA_Char *)pBufferOut, (M4OSA_Char *)pBufferIn, length);
        }
        else
        {
            // Set the output buffer to an empty string.
            (*(M4OSA_Char *)pBufferOut) = 0;
        }
    }
    else
    {
        // The buffer is too small.
        result = M4xVSSWAR_BUFFER_OUT_TOO_SMALL;
    }

    // Return the buffer output size.
    (*bufferOutSize) = length + 1;

    // Return the result.
    return(result);
}

static M4OSA_ERR
videoEditor_fromUTF8Fct(
                M4OSA_UInt8*                        pBufferIn,
                M4OSA_Void*                         pBufferOut,
                M4OSA_UInt32*                       bufferOutSize)
{
    M4OSA_ERR    result = M4NO_ERROR;
    M4OSA_UInt32 length = 0;

    VIDEOEDIT_LOG_FUNCTION(ANDROID_LOG_INFO, "VIDEO_EDITOR", "videoEditor_fromUTF8Fct()");

    // Determine the length of the input buffer.
    if (M4OSA_NULL != pBufferIn)
    {
        length = strlen((const char *)pBufferIn);
    }

    // Check if the output buffer is large enough to hold the input buffer.
    if ((*bufferOutSize) > length)
    {
        // Check if the input buffer is not M4OSA_NULL.
        if (M4OSA_NULL != pBufferIn)
        {
            // Copy the temp path, ignore the result.
            M4OSA_chrNCopy((M4OSA_Char *)pBufferOut, (M4OSA_Char *)pBufferIn, length);
        }
        else
        {
            // Set the output buffer to an empty string.
            (*(M4OSA_Char *)pBufferOut) = 0;
        }
    }
    else
    {
        // The buffer is too small.
        result = M4xVSSWAR_BUFFER_OUT_TOO_SMALL;
    }

    // Return the buffer output size.
    (*bufferOutSize) = length + 1;

    // Return the result.
    return(result);
}

static M4OSA_ERR
videoEditor_getTextRgbBufferFct(
                M4OSA_Void*                         pRenderingData,
                M4OSA_Void*                         pTextBuffer,
                M4OSA_UInt32                        textBufferSize,
                M4VIFI_ImagePlane**                 pOutputPlane)
{
    M4OSA_ERR result = M4NO_ERROR;

    VIDEOEDIT_LOG_FUNCTION(ANDROID_LOG_INFO, "VIDEO_EDITOR", "videoEditor_getTextRgbBufferFct()");

    // Return the result.
    return(result);
}

static void
videoEditor_callOnProgressUpdate(
                ManualEditContext*                  pContext,
                int                                 task,
                int                                 progress)
{
    JNIEnv* pEnv = NULL;


    // Attach the current thread.
    pContext->pVM->AttachCurrentThread(&pEnv, NULL);


    // Call the on completion callback.
    pEnv->CallVoidMethod(pContext->engine, pContext->onProgressUpdateMethodId,
     videoEditJava_getEngineCToJava(task), progress);


    // Detach the current thread.
    pContext->pVM->DetachCurrentThread();
}

static void
videoEditor_freeContext(
                JNIEnv*                             pEnv,
                ManualEditContext**                 ppContext)
{
    ManualEditContext* pContext = M4OSA_NULL;

    VIDEOEDIT_LOG_FUNCTION(ANDROID_LOG_INFO, "VIDEO_EDITOR", "videoEditor_freeContext");

    // Set the context pointer.
    pContext = (*ppContext);

    // Check if the context was set.
    if (M4OSA_NULL != pContext)
    {
        // Check if a global reference to the engine object was set.
        if (NULL != pContext->engine)
        {
            // Free the global reference.
            pEnv->DeleteGlobalRef(pContext->engine);
            pContext->engine = NULL;
        }

        // Check if the temp path was set.
        if (M4OSA_NULL != pContext->initParams.pTempPath)
        {
            // Free the memory allocated for the temp path.
            videoEditOsal_free(pContext->initParams.pTempPath);
            pContext->initParams.pTempPath = M4OSA_NULL;
        }

        // Check if the file writer was set.
        if (M4OSA_NULL != pContext->initParams.pFileWritePtr)
        {
            // Free the memory allocated for the file writer.
            videoEditOsal_free(pContext->initParams.pFileWritePtr);
            pContext->initParams.pFileWritePtr = M4OSA_NULL;
        }

        // Check if the file reader was set.
        if (M4OSA_NULL != pContext->initParams.pFileReadPtr)
        {
            // Free the memory allocated for the file reader.
            videoEditOsal_free(pContext->initParams.pFileReadPtr);
            pContext->initParams.pFileReadPtr = M4OSA_NULL;
        }

        // Free the memory allocated for the context.
        videoEditOsal_free(pContext);
        pContext = M4OSA_NULL;

        // Reset the context pointer.
        (*ppContext) = M4OSA_NULL;
    }
}

static jobject
videoEditor_getVersion(
                JNIEnv*                             pEnv,
                jobject                             thiz)
{
    bool           isSuccessful          = true;
    jobject        version         = NULL;
    M4_VersionInfo versionInfo     = {0, 0, 0, 0};
    M4OSA_ERR      result          = M4NO_ERROR;

    VIDEOEDIT_LOG_API(ANDROID_LOG_INFO, "VIDEO_EDITOR", "videoEditor_getVersion()");

    versionInfo.m_structSize = sizeof(versionInfo);
    versionInfo.m_major = VIDEOEDITOR_VERSION_MAJOR;
    versionInfo.m_minor = VIDEOEDITOR_VERSION_MINOR;
    versionInfo.m_revision = VIDEOEDITOR_VERSION_REVISION;

    VIDEOEDIT_LOG_API(ANDROID_LOG_INFO, "VIDEO_EDITOR", "videoEditor_getVersion() major %d,\
     minor %d, revision %d", versionInfo.m_major, versionInfo.m_minor, versionInfo.m_revision);

    // Create a version object.
    videoEditClasses_createVersion(&isSuccessful, pEnv, &versionInfo, &version);

    // Return the version object.
    return(version);
}

static void
videoEditor_init(
                JNIEnv*                             pEnv,
                jobject                             thiz,
                jstring                             tempPath,
                jstring                             libraryPath)
{
    bool                  initialized            = true;
    ManualEditContext*    pContext               = M4OSA_NULL;
    VideoEditJava_EngineMethodIds methodIds              = {NULL};
    M4OSA_Char*           pLibraryPath           = M4OSA_NULL;
    M4OSA_Char*           pTextRendererPath      = M4OSA_NULL;
    M4OSA_UInt32          textRendererPathLength = 0;
    M4OSA_ERR             result                 = M4NO_ERROR;

    VIDEOEDIT_LOG_API(ANDROID_LOG_INFO, "VIDEO_EDITOR", "videoEditor_init()");

    // Add a text marker (the condition must always be true).
    ADD_TEXT_MARKER_FUN(NULL != pEnv)

    // Get the context.
    pContext = (ManualEditContext*)videoEditClasses_getContext(&initialized, pEnv, thiz);

    // Get the engine method ids.
    videoEditJava_getEngineMethodIds(&initialized, pEnv, &methodIds);

    // Validate the tempPath parameter.
    videoEditJava_checkAndThrowIllegalArgumentException(&initialized, pEnv,
                                                (NULL == tempPath),
                                                "tempPath is null");

    // Make sure that the context was not set already.
    videoEditJava_checkAndThrowIllegalStateException(&initialized, pEnv,
                                             (M4OSA_NULL != pContext),
                                             "already initialized");

    // Check if the initialization succeeded (required because of dereferencing of psContext,
    // and freeing when initialization fails).
    if (initialized)
    {
        // Allocate a new context.
        pContext = new ManualEditContext;

        // Check if the initialization succeeded (required because of dereferencing of psContext).
        //if (initialized)
        if (pContext != NULL)
        {
            // Set the state to not initialized.
            pContext->state = ManualEditState_NOT_INITIALIZED;

            // Allocate a file read pointer structure.
            pContext->initParams.pFileReadPtr =
             (M4OSA_FileReadPointer*)videoEditOsal_alloc(&initialized, pEnv,
              sizeof(M4OSA_FileReadPointer), "FileReadPointer");

            // Allocate a file write pointer structure.
            pContext->initParams.pFileWritePtr =
             (M4OSA_FileWriterPointer*)videoEditOsal_alloc(&initialized, pEnv,
              sizeof(M4OSA_FileWriterPointer), "FileWriterPointer");

            // Get the temp path.
            M4OSA_Char* tmpString =
                (M4OSA_Char *)videoEditJava_getString(&initialized, pEnv, tempPath,
                NULL, M4OSA_NULL);
            M4OSA_UInt32 length = strlen((const char *)tmpString);
            // Malloc additional 2 bytes for beginning and tail separator.
            M4OSA_UInt32 pathLength = length + 2;

            pContext->initParams.pTempPath = (M4OSA_Char *)
                 M4OSA_32bitAlignedMalloc(pathLength, 0x0, (M4OSA_Char *)"tempPath");

            //initialize the first char. so that strcat works.
            M4OSA_Char *ptmpChar = (M4OSA_Char*)pContext->initParams.pTempPath;
            ptmpChar[0] = 0x00;
            strncat((char *)pContext->initParams.pTempPath, (const char *)tmpString,
                length);
            strncat((char *)pContext->initParams.pTempPath, (const char *)"/", (size_t)1);
            free(tmpString);
            tmpString = NULL;
            pContext->mIsUpdateOverlay = false;
            pContext->mOverlayFileName = NULL;
            pContext->decoders = NULL;
        }

        // Check if the initialization succeeded
        // (required because of dereferencing of pContext, pFileReadPtr and pFileWritePtr).
        if (initialized)
        {

            // Initialize the OSAL file system function pointers.
            videoEditOsal_getFilePointers(pContext->initParams.pFileReadPtr ,
                                          pContext->initParams.pFileWritePtr);

            // Set the UTF8 conversion functions.
            pContext->initParams.pConvToUTF8Fct   = videoEditor_toUTF8Fct;
            pContext->initParams.pConvFromUTF8Fct = videoEditor_fromUTF8Fct;

            // Set the callback method ids.
            pContext->onProgressUpdateMethodId = methodIds.onProgressUpdate;

            // Set the virtual machine.
            pEnv->GetJavaVM(&(pContext->pVM));

            // Create a global reference to the engine object.
            pContext->engine = pEnv->NewGlobalRef(thiz);

            // Check if the global reference could be created.
            videoEditJava_checkAndThrowRuntimeException(&initialized, pEnv,
             (NULL == pContext->engine), M4NO_ERROR);
        }

        // Check if the initialization succeeded (required because of dereferencing of pContext).
        if (initialized)
        {
            // Log the API call.
            VIDEOEDIT_LOG_API(ANDROID_LOG_INFO, "VIDEO_EDITOR", "M4xVSS_Init()");

            // Initialize the visual studio library.
            result = M4xVSS_Init(&pContext->engineContext, &pContext->initParams);

            // Log the result.
            VIDEOEDIT_LOG_RESULT(ANDROID_LOG_INFO, "VIDEO_EDITOR",
             videoEditOsal_getResultString(result));

            // Check if the library could be initialized.
            videoEditJava_checkAndThrowRuntimeException(&initialized, pEnv,
             (M4NO_ERROR != result), result);

            // Get platform video decoder capablities.
            result = M4xVSS_getVideoDecoderCapabilities(&pContext->decoders);

            videoEditJava_checkAndThrowRuntimeException(&initialized, pEnv,
             (M4NO_ERROR != result), result);
        }

        if(initialized)
        {
            pContext->mPreviewController = new VideoEditorPreviewController();
            videoEditJava_checkAndThrowIllegalStateException(&initialized, pEnv,
                                 (M4OSA_NULL == pContext->mPreviewController),
                                 "not initialized");
            pContext->mAudioSettings =
             (M4xVSS_AudioMixingSettings *)
             M4OSA_32bitAlignedMalloc(sizeof(M4xVSS_AudioMixingSettings),0x0,
             (M4OSA_Char *)"mAudioSettings");
            videoEditJava_checkAndThrowIllegalStateException(&initialized, pEnv,
                                     (M4OSA_NULL == pContext->mAudioSettings),
                                     "not initialized");
            pContext->mAudioSettings->pFile = M4OSA_NULL;
            pContext->mAudioSettings->pPCMFilePath = M4OSA_NULL;
            pContext->mAudioSettings->bRemoveOriginal = 0;
            pContext->mAudioSettings->uiNbChannels = 0;
            pContext->mAudioSettings->uiSamplingFrequency = 0;
            pContext->mAudioSettings->uiExtendedSamplingFrequency = 0;
            pContext->mAudioSettings->uiAddCts = 0;
            pContext->mAudioSettings->uiAddVolume = 0;
            pContext->mAudioSettings->beginCutMs = 0;
            pContext->mAudioSettings->endCutMs = 0;
            pContext->mAudioSettings->fileType = 0;
            pContext->mAudioSettings->bLoop = 0;
            pContext->mAudioSettings->uiInDucking_lowVolume  = 0;
            pContext->mAudioSettings->bInDucking_enable  = 0;
            pContext->mAudioSettings->uiBTChannelCount  = 0;
            pContext->mAudioSettings->uiInDucking_threshold = 0;
        }
        // Check if the library could be initialized.
        if (initialized)
        {
            // Set the state to initialized.
            pContext->state = ManualEditState_INITIALIZED;
        }

        // Set the context.
        videoEditClasses_setContext(&initialized, pEnv, thiz, (void* )pContext);
        pLibraryPath = M4OSA_NULL;

        pContext->pEditSettings = M4OSA_NULL;
        // Cleanup if anything went wrong during initialization.
        if (!initialized)
        {
            // Free the context.
            videoEditor_freeContext(pEnv, &pContext);
        }
    }
}

/*+ PROGRESS CB */
static
M4OSA_ERR videoEditor_processClip(
                            JNIEnv*  pEnv,
                            jobject  thiz,
                            int      unuseditemID) {

    bool               loaded           = true;
    ManualEditContext* pContext         = NULL;
    M4OSA_UInt8        progress         = 0;
    M4OSA_UInt8        progressBase     = 0;
    M4OSA_UInt8        lastProgress     = 0;
    M4OSA_ERR          result           = M4NO_ERROR;

    // Get the context.
    pContext = (ManualEditContext*)videoEditClasses_getContext(&loaded, pEnv, thiz);

    // Make sure that the context was set.
    videoEditJava_checkAndThrowIllegalStateException(&loaded, pEnv,
                                             (M4OSA_NULL == pContext),
                                             "not initialized");

    // We start in Analyzing state
    pContext->state = ManualEditState_INITIALIZED;
    M4OSA_ERR          completionResult = M4VSS3GPP_WAR_ANALYZING_DONE;
    ManualEditState    completionState  = ManualEditState_OPENED;
    ManualEditState    errorState       = ManualEditState_ANALYZING_ERROR;

    // While analyzing progress goes from 0 to 10 (except Kenburn clip
    // generation, which goes from 0 to 50)
    progressBase     = 0;

    // Set the text rendering function.
    if (M4OSA_NULL != pContext->pTextRendererFunction)
    {
        // Use the text renderer function in the library.
        pContext->pEditSettings->xVSS.pTextRenderingFct = pContext->pTextRendererFunction;
    }
    else
    {
        // Use the internal text renderer function.
        pContext->pEditSettings->xVSS.pTextRenderingFct = videoEditor_getTextRgbBufferFct;
    }

    // Send the command.
    ALOGV("videoEditor_processClip ITEM %d Calling M4xVSS_SendCommand()", unuseditemID);
    result = M4xVSS_SendCommand(pContext->engineContext, pContext->pEditSettings);
    ALOGV("videoEditor_processClip ITEM %d M4xVSS_SendCommand() returned 0x%x",
        unuseditemID, (unsigned int) result);

    // Remove warnings indications (we only care about errors here)
    if ((result == M4VSS3GPP_WAR_TRANSCODING_NECESSARY)
        || (result == M4VSS3GPP_WAR_OUTPUTFILESIZE_EXCEED)) {
        result = M4NO_ERROR;
    }

    // Send the first progress indication (=0)
    ALOGV("VERY FIRST PROGRESS videoEditor_processClip ITEM %d Progress indication %d",
        unuseditemID, progress);
    pEnv->CallVoidMethod(pContext->engine, pContext->onProgressUpdateMethodId,
        unuseditemID, progress);

    // Check if a task is being performed.
    // ??? ADD STOPPING MECHANISM
    ALOGV("videoEditor_processClip Entering processing loop");
    M4OSA_UInt8 prevReportedProgress = 0;
    while((result == M4NO_ERROR)
        &&(pContext->state!=ManualEditState_SAVED)
        &&(pContext->state!=ManualEditState_STOPPING)) {

            // Perform the next processing step.
            //ALOGV("LVME_processClip Entering M4xVSS_Step()");
            result = M4xVSS_Step(pContext->engineContext, &progress);

            if (progress != prevReportedProgress) {
                prevReportedProgress = progress;
                // Log the 1 % .. 100 % progress after processing.
                if (M4OSA_TRUE ==
                    pContext->pEditSettings->pClipList[0]->xVSS.isPanZoom) {
                    // For KenBurn clip generation, return 0 to 50
                    // for Analysis phase and 50 to 100 for Saving phase
                    progress = progressBase + progress/2;
                } else {
                    // For export/transition clips, 0 to 10 for Analysis phase
                    // and 10 to 100 for Saving phase
                    if (ManualEditState_INITIALIZED == pContext->state) {
                        progress = 0.1*progress;
                    } else {
                        progress = progressBase + 0.9*progress;
                    }
                }

                if (progress > lastProgress)
                {
                    // Send a progress notification.
                    ALOGV("videoEditor_processClip ITEM %d Progress indication %d",
                        unuseditemID, progress);
                    pEnv->CallVoidMethod(pContext->engine,
                        pContext->onProgressUpdateMethodId,
                        unuseditemID, progress);
                    lastProgress = progress;
                }
            }

            // Check if processing has been completed.
            if (result == completionResult)
            {
                // Set the state to the completions state.
                pContext->state = completionState;
                ALOGV("videoEditor_processClip ITEM %d STATE changed to %d",
                    unuseditemID, pContext->state);

                // Reset progress indication, as we switch to next state
                lastProgress = 0;

                // Reset error code, as we start a new round of processing
                result = M4NO_ERROR;

                // Check if we are analyzing input
                if (pContext->state == ManualEditState_OPENED) {
                    // File is opened, we must start saving it
                    ALOGV("videoEditor_processClip Calling M4xVSS_SaveStart()");
                    result = M4xVSS_SaveStart(pContext->engineContext,
                        (M4OSA_Char*)pContext->pEditSettings->pOutputFile,
                        (M4OSA_UInt32)pContext->pEditSettings->uiOutputPathSize);
                    ALOGV("videoEditor_processClip ITEM %d SaveStart() returned 0x%x",
                        unuseditemID, (unsigned int) result);

                    // Set the state to saving.
                    pContext->state  = ManualEditState_SAVING;
                    completionState  = ManualEditState_SAVED;
                    completionResult = M4VSS3GPP_WAR_SAVING_DONE;
                    errorState       = ManualEditState_SAVING_ERROR;

                    // While saving, progress goes from 10 to 100
                    // except for Kenburn clip which goes from 50 to 100
                    if (M4OSA_TRUE ==
                            pContext->pEditSettings->pClipList[0]->xVSS.isPanZoom) {
                        progressBase = 50;
                    } else {
                        progressBase     = 10;
                    }
                }
                // Check if we encoding is ongoing
                else if (pContext->state == ManualEditState_SAVED) {

                    // Send a progress notification.
                    progress = 100;
                    ALOGV("videoEditor_processClip ITEM %d Last progress indication %d",
                        unuseditemID, progress);
                    pEnv->CallVoidMethod(pContext->engine,
                        pContext->onProgressUpdateMethodId,
                        unuseditemID, progress);


                    // Stop the encoding.
                    ALOGV("videoEditor_processClip Calling M4xVSS_SaveStop()");
                    result = M4xVSS_SaveStop(pContext->engineContext);
                    ALOGV("videoEditor_processClip M4xVSS_SaveStop() returned 0x%x", result);
                }
                // Other states are unexpected
                else {
                    result = M4ERR_STATE;
                    ALOGE("videoEditor_processClip ITEM %d State ERROR 0x%x",
                        unuseditemID, (unsigned int) result);
                }
            }

            // Check if an error occurred.
            if (result != M4NO_ERROR)
            {
                // Set the state to the error state.
                pContext->state = errorState;

                // Log the result.
                ALOGE("videoEditor_processClip ITEM %d Processing ERROR 0x%x",
                    unuseditemID, (unsigned int) result);
            }
    }

    // Return the error result
    ALOGE("videoEditor_processClip ITEM %d END 0x%x", unuseditemID, (unsigned int) result);
    return result;
}
/*+ PROGRESS CB */

static int
videoEditor_generateClip(
                JNIEnv*                             pEnv,
                jobject                             thiz,
                jobject                             settings) {
    bool               loaded   = true;
    ManualEditContext* pContext = M4OSA_NULL;
    M4OSA_ERR          result   = M4NO_ERROR;

    ALOGV("videoEditor_generateClip START");

    // Get the context.
    pContext = (ManualEditContext*)videoEditClasses_getContext(&loaded, pEnv, thiz);

    Mutex::Autolock autoLock(pContext->mLock);

    // Validate the settings parameter.
    videoEditJava_checkAndThrowIllegalArgumentException(&loaded, pEnv,
                                                (NULL == settings),
                                                "settings is null");

    // Make sure that the context was set.
    videoEditJava_checkAndThrowIllegalStateException(&loaded, pEnv,
                                             (M4OSA_NULL == pContext),
                                             "not initialized");

    // Load the clip settings
    ALOGV("videoEditor_generateClip Calling videoEditor_loadSettings");
    videoEditor_loadSettings(pEnv, thiz, settings);
    ALOGV("videoEditor_generateClip videoEditor_loadSettings returned");

    // Generate the clip
    ALOGV("videoEditor_generateClip Calling LVME_processClip");
    result = videoEditor_processClip(pEnv, thiz, 0 /*item id is unused*/);
    ALOGV("videoEditor_generateClip videoEditor_processClip returned 0x%x", result);

    if (pContext->state != ManualEditState_INITIALIZED) {
        // Free up memory (whatever the result)
        videoEditor_unloadSettings(pEnv, thiz);
    }

    ALOGV("videoEditor_generateClip END 0x%x", (unsigned int) result);
    return result;
}

static void
videoEditor_loadSettings(
                JNIEnv*                             pEnv,
                jobject                             thiz,
                jobject                             settings)
{
    bool               needToBeLoaded   = true;
    ManualEditContext* pContext = M4OSA_NULL;

    VIDEOEDIT_LOG_API(ANDROID_LOG_INFO, "VIDEO_EDITOR", "videoEditor_loadSettings()");

    // Add a code marker (the condition must always be true).
    ADD_CODE_MARKER_FUN(NULL != pEnv)

    // Get the context.
    pContext = (ManualEditContext*)videoEditClasses_getContext(&needToBeLoaded,
                                                                pEnv, thiz);

    // Validate the settings parameter.
    videoEditJava_checkAndThrowIllegalArgumentException(&needToBeLoaded, pEnv,
                                                (NULL == settings),
                                                "settings is null");

    // Make sure that the context was set.
    videoEditJava_checkAndThrowIllegalStateException(&needToBeLoaded, pEnv,
                                             (M4OSA_NULL == pContext),
                                             "not initialized");

    // Check if the context is valid (required because the context is dereferenced).
    if (needToBeLoaded)
    {
        // Make sure that we are in a correct state.
        videoEditJava_checkAndThrowIllegalStateException(&needToBeLoaded, pEnv,
                             (pContext->state != ManualEditState_INITIALIZED),
                             "settings already loaded");

        // Retrieve the edit settings.
        if(pContext->pEditSettings != M4OSA_NULL) {
            videoEditClasses_freeEditSettings(&pContext->pEditSettings);
            pContext->pEditSettings = M4OSA_NULL;
        }
        videoEditClasses_getEditSettings(&needToBeLoaded, pEnv, settings,
            &pContext->pEditSettings,true);
    }

    // Check if the edit settings could be retrieved.
    if (needToBeLoaded)
    {
        // Log the edit settings.
        VIDEOEDIT_LOG_API(ANDROID_LOG_INFO, "VIDEO_EDITOR", "inside load settings");
        VIDEOEDIT_LOG_EDIT_SETTINGS(pContext->pEditSettings);
    }
    ALOGV("videoEditor_loadSettings END");
}



static void
videoEditor_unloadSettings(
                JNIEnv*                             pEnv,
                jobject                             thiz)
{
    bool               needToBeUnLoaded = true;
    ManualEditContext* pContext = M4OSA_NULL;
    M4OSA_ERR          result   = M4NO_ERROR;

    VIDEOEDIT_LOG_API(ANDROID_LOG_INFO, "VIDEO_EDITOR", "videoEditor_unloadSettings()");

    // Get the context.
    pContext = (ManualEditContext*)videoEditClasses_getContext(&needToBeUnLoaded, pEnv, thiz);

    // Make sure that the context was set.
    videoEditJava_checkAndThrowIllegalStateException(&needToBeUnLoaded, pEnv,
                                             (M4OSA_NULL == pContext),
                                             "not initialized");

    // Check if the context is valid (required because the context is dereferenced).
    if (needToBeUnLoaded)
    {
        ALOGV("videoEditor_unloadSettings state %d", pContext->state);
        // Make sure that we are in a correct state.
        videoEditJava_checkAndThrowIllegalStateException(&needToBeUnLoaded, pEnv,
                     ((pContext->state != ManualEditState_ANALYZING      ) &&
                      (pContext->state != ManualEditState_ANALYZING_ERROR) &&
                      (pContext->state != ManualEditState_OPENED         ) &&
                      (pContext->state != ManualEditState_SAVING_ERROR   ) &&
                      (pContext->state != ManualEditState_SAVED          ) &&
                      (pContext->state != ManualEditState_STOPPING       ) ),
                     "videoEditor_unloadSettings no load settings in progress");
    }

    // Check if we are in a correct state.
    if (needToBeUnLoaded)
    {
        // Check if the thread could be stopped.
        if (needToBeUnLoaded)
        {
            // Close the command.
            ALOGV("videoEditor_unloadSettings Calling M4xVSS_CloseCommand()");
            result = M4xVSS_CloseCommand(pContext->engineContext);
            ALOGV("videoEditor_unloadSettings M4xVSS_CloseCommand() returned 0x%x",
                (unsigned int)result);

            // Check if the command could be closed.
            videoEditJava_checkAndThrowRuntimeException(&needToBeUnLoaded, pEnv,
             (M4NO_ERROR != result), result);
        }

        // Check if the command could be closed.
        if (needToBeUnLoaded)
        {
            // Free the edit settings.
            //videoEditClasses_freeEditSettings(&pContext->pEditSettings);

            // Reset the thread result.
            pContext->threadResult = M4NO_ERROR;

            // Reset the thread progress.
            pContext->threadProgress = 0;

            // Set the state to initialized.
            pContext->state = ManualEditState_INITIALIZED;
        }
    }
}

static void
videoEditor_stopEncoding(
                JNIEnv*                             pEnv,
                jobject                             thiz)
{
    bool               stopped  = true;
    ManualEditContext* pContext = M4OSA_NULL;
    M4OSA_ERR          result   = M4NO_ERROR;

    ALOGV("videoEditor_stopEncoding START");

    // Get the context.
    pContext = (ManualEditContext*)videoEditClasses_getContext(&stopped, pEnv, thiz);

    // Change state and get Lock
    // This will ensure the generateClip function exits
    pContext->state = ManualEditState_STOPPING;
    Mutex::Autolock autoLock(pContext->mLock);

    // Make sure that the context was set.
    videoEditJava_checkAndThrowIllegalStateException(&stopped, pEnv,
                                             (M4OSA_NULL == pContext),
                                             "not initialized");

    if (stopped) {

        // Check if the command should be closed.
        if (pContext->state != ManualEditState_INITIALIZED)
        {
            // Close the command.
            ALOGV("videoEditor_stopEncoding Calling M4xVSS_CloseCommand()");
            result = M4xVSS_CloseCommand(pContext->engineContext);
            ALOGV("videoEditor_stopEncoding M4xVSS_CloseCommand() returned 0x%x",
                (unsigned int)result);
        }

        // Check if the command could be closed.
        videoEditJava_checkAndThrowRuntimeException(&stopped, pEnv,
            (M4NO_ERROR != result), result);

        // Free the edit settings.
        videoEditClasses_freeEditSettings(&pContext->pEditSettings);

        // Set the state to initialized.
        pContext->state = ManualEditState_INITIALIZED;
    }

}

static void
videoEditor_release(
                JNIEnv*                             pEnv,
                jobject                             thiz)
{
    bool               released = true;
    ManualEditContext* pContext = M4OSA_NULL;
    M4OSA_ERR          result   = M4NO_ERROR;

    VIDEOEDIT_LOG_API(ANDROID_LOG_INFO, "VIDEO_EDITOR", "videoEditor_release()");

    // Add a text marker (the condition must always be true).
    ADD_TEXT_MARKER_FUN(NULL != pEnv)

    // Get the context.
    pContext = (ManualEditContext*)videoEditClasses_getContext(&released, pEnv, thiz);

    // If context is not set, return (we consider release already happened)
    if (pContext == NULL) {
        ALOGV("videoEditor_release Nothing to do, context is aleady NULL");
        return;
    }


    // Check if the context is valid (required because the context is dereferenced).
    if (released)
    {
        if (pContext->state != ManualEditState_INITIALIZED)
        {
            // Change state and get Lock
            // This will ensure the generateClip function exits if it is running
            pContext->state = ManualEditState_STOPPING;
            Mutex::Autolock autoLock(pContext->mLock);
        }

        // Reset the context.
        videoEditClasses_setContext(&released, pEnv, thiz, (void *)M4OSA_NULL);

        // Check if the command should be closed.
        if (pContext->state != ManualEditState_INITIALIZED)
        {
            // Close the command.
            ALOGV("videoEditor_release Calling M4xVSS_CloseCommand() state =%d",
                pContext->state);
            result = M4xVSS_CloseCommand(pContext->engineContext);
            ALOGV("videoEditor_release M4xVSS_CloseCommand() returned 0x%x",
                (unsigned int)result);

            // Check if the command could be closed.
            videoEditJava_checkAndThrowRuntimeException(&released, pEnv,
                (M4NO_ERROR != result), result);
        }

        // Cleanup the engine.
        ALOGV("videoEditor_release Calling M4xVSS_CleanUp()");
        result = M4xVSS_CleanUp(pContext->engineContext);
        ALOGV("videoEditor_release M4xVSS_CleanUp() returned 0x%x", (unsigned int)result);

        // Check if the cleanup succeeded.
        videoEditJava_checkAndThrowRuntimeException(&released, pEnv,
            (M4NO_ERROR != result), result);

        // Free the edit settings.
        videoEditClasses_freeEditSettings(&pContext->pEditSettings);
        pContext->pEditSettings = M4OSA_NULL;


        if(pContext->mPreviewController != M4OSA_NULL)
        {
            delete pContext->mPreviewController;
            pContext->mPreviewController = M4OSA_NULL;
        }

        // Free the mAudioSettings context.
        if(pContext->mAudioSettings != M4OSA_NULL)
        {
            if (pContext->mAudioSettings->pFile != NULL) {
                free(pContext->mAudioSettings->pFile);
                pContext->mAudioSettings->pFile = M4OSA_NULL;
            }
            if (pContext->mAudioSettings->pPCMFilePath != NULL) {
                free(pContext->mAudioSettings->pPCMFilePath);
                pContext->mAudioSettings->pPCMFilePath = M4OSA_NULL;
            }

            free(pContext->mAudioSettings);
            pContext->mAudioSettings = M4OSA_NULL;
        }
        // Free video Decoders capabilities
        if (pContext->decoders != M4OSA_NULL) {
            VideoDecoder *pDecoder = NULL;
            VideoComponentCapabilities *pComponents = NULL;
            int32_t decoderNumber = pContext->decoders->decoderNumber;
            if (pContext->decoders->decoder != NULL &&
                decoderNumber > 0) {
                pDecoder = pContext->decoders->decoder;
                for (int32_t k = 0; k < decoderNumber; k++) {
                    // free each component
                    ALOGV("decoder index :%d",k);
                    if (pDecoder != NULL &&
                        pDecoder->component != NULL &&
                        pDecoder->componentNumber > 0) {
                        ALOGV("component number %d",pDecoder->componentNumber);
                        int32_t componentNumber =
                           pDecoder->componentNumber;

                        pComponents = pDecoder->component;
                        for (int32_t i = 0; i< componentNumber; i++) {
                            ALOGV("component index :%d",i);
                            if (pComponents != NULL &&
                                pComponents->profileLevel != NULL) {
                                free(pComponents->profileLevel);
                                pComponents->profileLevel = NULL;
                            }
                            pComponents++;
                        }
                        free(pDecoder->component);
                        pDecoder->component = NULL;
                    }

                    pDecoder++;
                }
                free(pContext->decoders->decoder);
                pContext->decoders->decoder = NULL;
            }
            free(pContext->decoders);
            pContext->decoders = NULL;
        }

        videoEditor_freeContext(pEnv, &pContext);
    }
}

static int
videoEditor_registerManualEditMethods(
                JNIEnv*                             pEnv)
{
    int result = -1;

    VIDEOEDIT_LOG_FUNCTION(ANDROID_LOG_INFO, "VIDEO_EDITOR",
     "videoEditor_registerManualEditMethods()");

    // Look up the engine class
    jclass engineClazz = pEnv->FindClass(MANUAL_EDIT_ENGINE_CLASS_NAME);

    // Clear any resulting exceptions.
    pEnv->ExceptionClear();

    // Check if the engine class was found.
    if (NULL != engineClazz)
    {
        // Register all the methods.
        if (pEnv->RegisterNatives(engineClazz, gManualEditMethods,
                sizeof(gManualEditMethods) / sizeof(gManualEditMethods[0])) == JNI_OK)
        {
            // Success.
            result = 0;
        }
    }

    // Return the result.
    return(result);
}

/*******Audio Graph*******/

static M4OSA_UInt32 getDecibelSound(M4OSA_UInt32 value)
{
    int dbSound = 1;

    if (value == 0) return 0;

    if (value > 0x4000 && value <= 0x8000) // 32768
        dbSound = 90;
    else if (value > 0x2000 && value <= 0x4000) // 16384
        dbSound = 84;
    else if (value > 0x1000 && value <= 0x2000) // 8192
        dbSound = 78;
    else if (value > 0x0800 && value <= 0x1000) // 4028
        dbSound = 72;
    else if (value > 0x0400 && value <= 0x0800) // 2048
        dbSound = 66;
    else if (value > 0x0200 && value <= 0x0400) // 1024
        dbSound = 60;
    else if (value > 0x0100 && value <= 0x0200) // 512
        dbSound = 54;
    else if (value > 0x0080 && value <= 0x0100) // 256
        dbSound = 48;
    else if (value > 0x0040 && value <= 0x0080) // 128
        dbSound = 42;
    else if (value > 0x0020 && value <= 0x0040) // 64
        dbSound = 36;
    else if (value > 0x0010 && value <= 0x0020) // 32
        dbSound = 30;
    else if (value > 0x0008 && value <= 0x0010) //16
        dbSound = 24;
    else if (value > 0x0007 && value <= 0x0008) //8
        dbSound = 24;
    else if (value > 0x0003 && value <= 0x0007) // 4
        dbSound = 18;
    else if (value > 0x0001 && value <= 0x0003) //2
        dbSound = 12;
    else if (value > 0x000 && value == 0x0001) // 1
        dbSound = 6;
    else
        dbSound = 0;

    return dbSound;
}

typedef struct
{
    M4OSA_UInt8      *m_dataAddress;
    M4OSA_UInt32    m_bufferSize;
} M4AM_Buffer;


M4OSA_UInt8 logLookUp[256] = {
0,120,137,146,154,159,163,167,171,173,176,178,181,182,184,186,188,189,190,192,193,
194,195,196,198,199,199,200,201,202,203,204,205,205,206,207,207,208,209,209,210,
211,211,212,212,213,213,214,215,215,216,216,216,217,217,218,218,219,219,220,220,
220,221,221,222,222,222,223,223,223,224,224,224,225,225,225,226,226,226,227,227,
227,228,228,228,229,229,229,229,230,230,230,230,231,231,231,232,232,232,232,233,
233,233,233,233,234,234,234,234,235,235,235,235,236,236,236,236,236,237,237,237,
237,237,238,238,238,238,238,239,239,239,239,239,240,240,240,240,240,240,241,241,
241,241,241,241,242,242,242,242,242,242,243,243,243,243,243,243,244,244,244,244,
244,244,245,245,245,245,245,245,245,246,246,246,246,246,246,246,247,247,247,247,
247,247,247,247,248,248,248,248,248,248,248,249,249,249,249,249,249,249,249,250,
250,250,250,250,250,250,250,250,251,251,251,251,251,251,251,251,252,252,252,252,
252,252,252,252,252,253,253,253,253,253,253,253,253,253,253,254,254,254,254,254,
254,254,254,254,255,255,255,255,255,255,255,255,255,255,255};

M4OSA_ERR M4MA_generateAudioGraphFile(JNIEnv* pEnv, M4OSA_Char* pInputFileURL,
                     M4OSA_Char* pOutFileURL,
                     M4OSA_UInt32 samplesPerValue,
                     M4OSA_UInt32 channels,
                     M4OSA_UInt32 frameDuration,
                     ManualEditContext* pContext)
{
    M4OSA_ERR           err;
    M4OSA_Context       outFileHandle = M4OSA_NULL;
    M4OSA_Context       inputFileHandle = M4OSA_NULL;
    M4AM_Buffer         bufferIn = {0, 0};
    M4OSA_UInt32        peakVolumeDbValue = 0;
    M4OSA_UInt32        samplesCountInBytes= 0 , numBytesToRead = 0, index = 0;
    M4OSA_UInt32        writeCount = 0, samplesCountBigEndian = 0, volumeValuesCount = 0;
    M4OSA_Int32         seekPos = 0;
    M4OSA_UInt32        fileSize = 0;
    M4OSA_UInt32        totalBytesRead = 0;
    M4OSA_UInt32        prevProgress = 0;
    bool                threadStarted = true;

    int dbValue = 0;
    M4OSA_Int16 *ptr16 ;

    jclass engineClass = pEnv->FindClass(MANUAL_EDIT_ENGINE_CLASS_NAME);
    videoEditJava_checkAndThrowIllegalStateException(&threadStarted, pEnv,
                                             (M4OSA_NULL == engineClass),
                                             "not initialized");

    /* register the call back function pointer */
    pContext->onAudioGraphProgressUpdateMethodId =
            pEnv->GetMethodID(engineClass, "onAudioGraphExtractProgressUpdate", "(IZ)V");


    /* ENTER */
    VIDEOEDIT_LOG_API(ANDROID_LOG_INFO, "VIDEO_EDITOR", "ENTER - M4MA_generateAudioGraphFile");
    VIDEOEDIT_LOG_API(ANDROID_LOG_INFO, "VIDEO_EDITOR",
            "Audio Graph samplesPerValue %d channels %d", samplesPerValue, channels);

    /******************************************************************************
        OPEN INPUT AND OUTPUT FILES
    *******************************************************************************/
    err = M4OSA_fileReadOpen (&inputFileHandle, pInputFileURL, M4OSA_kFileRead);
    if (inputFileHandle == M4OSA_NULL) {
        VIDEOEDIT_LOG_ERROR(ANDROID_LOG_INFO, "VIDEO_EDITOR",
            "M4MA_generateAudioGraphFile: Cannot open input file 0x%lx", err);
        return err;
    }

    /* get the file size for progress */
    err = M4OSA_fileReadGetOption(inputFileHandle, M4OSA_kFileReadGetFileSize,
                                (M4OSA_Void**)&fileSize);
    if ( err != M4NO_ERROR) {
        //LVMEL_LOG_ERROR("M4MA_generateAudioGraphFile : File write failed \n");
        jniThrowException(pEnv, "java/lang/IOException", "file size get option failed");
        //return -1;
    }

    err = M4OSA_fileWriteOpen (&outFileHandle,(M4OSA_Char*) pOutFileURL,
        M4OSA_kFileCreate | M4OSA_kFileWrite);
    if (outFileHandle == M4OSA_NULL) {
        if (inputFileHandle != NULL)
        {
            M4OSA_fileReadClose(inputFileHandle);
        }
        return err;
    }

    /******************************************************************************
        PROCESS THE SAMPLES
    *******************************************************************************/
    samplesCountInBytes = (samplesPerValue * sizeof(M4OSA_UInt16) * channels);

    bufferIn.m_dataAddress = (M4OSA_UInt8*)M4OSA_32bitAlignedMalloc(samplesCountInBytes*sizeof(M4OSA_UInt16), 0,
    (M4OSA_Char*)"AudioGraph" );
    if ( bufferIn.m_dataAddress != M4OSA_NULL) {
        bufferIn.m_bufferSize = samplesCountInBytes*sizeof(M4OSA_UInt16);
    } else {
        VIDEOEDIT_LOG_ERROR(ANDROID_LOG_INFO, "VIDEO_EDITOR",
            "M4MA_generateAudioGraphFile: Malloc failed for bufferIn.m_dataAddress 0x%lx",
            M4ERR_ALLOC);
        return M4ERR_ALLOC;
    }
    /* sample to be converted to BIG endian ; store the frame duration */
    samplesCountBigEndian = ((frameDuration>>24)&0xff) | // move byte 3 to byte 0
                    ((frameDuration<<8)&0xff0000) | // move byte 1 to byte 2
                    ((frameDuration>>8)&0xff00) | // move byte 2 to byte 1
                    ((frameDuration<<24)&0xff000000); // byte 0 to byte 3

    /* write the samples per value supplied to out file */
    err = M4OSA_fileWriteData (outFileHandle, (M4OSA_MemAddr8)&samplesCountBigEndian,
        sizeof(M4OSA_UInt32) );
    if (err != M4NO_ERROR) {
        jniThrowException(pEnv, "java/lang/IOException", "file write failed");
    }


    /* write UIn32 value 0 for no of values as place holder */
    samplesCountBigEndian = 0; /* reusing local var */
    err = M4OSA_fileWriteData (outFileHandle, (M4OSA_MemAddr8)&samplesCountBigEndian,
        sizeof(M4OSA_UInt32) );
    if (err != M4NO_ERROR) {
        jniThrowException(pEnv, "java/lang/IOException", "file write failed");
    }

    /* loop until EOF */
    do
    {
        memset((void *)bufferIn.m_dataAddress,0,bufferIn.m_bufferSize);

        numBytesToRead = samplesCountInBytes;

        err =  M4OSA_fileReadData(  inputFileHandle,
                                    (M4OSA_MemAddr8)bufferIn.m_dataAddress,
                                    &numBytesToRead );

        if (err != M4NO_ERROR) {
            // if out value of bytes-read is 0, break
            if ( numBytesToRead == 0) {
                VIDEOEDIT_LOG_ERROR(ANDROID_LOG_INFO, "VIDEO_EDITOR", "numBytesToRead 0x%lx",
                numBytesToRead);
                break; /* stop if file is empty or EOF */
            }
        }

        ptr16 = (M4OSA_Int16*)bufferIn.m_dataAddress;

        peakVolumeDbValue = 0;
        index = 0;

        // loop through half the lenght frame bytes read 'cause its 16 bits samples
        while (index < (numBytesToRead / 2)) {
            /* absolute values of 16 bit sample */
            if (ptr16[index] < 0) {
                ptr16[index] = -(ptr16[index]);
            }
            peakVolumeDbValue = (peakVolumeDbValue > (M4OSA_UInt32)ptr16[index] ?\
             peakVolumeDbValue : (M4OSA_UInt32)ptr16[index]);
            index++;
        }

        // move 7 bits , ignore sign bit
        dbValue = (peakVolumeDbValue >> 7);
        dbValue = logLookUp[(M4OSA_UInt8)dbValue];

        err = M4OSA_fileWriteData (outFileHandle, (M4OSA_MemAddr8)&dbValue, sizeof(M4OSA_UInt8) );
        if (err != M4NO_ERROR) {
            VIDEOEDIT_LOG_ERROR(ANDROID_LOG_INFO, "VIDEO_EDITOR",
             "M4MA_generateAudioGraphFile : File write failed");
            break;
        }

        volumeValuesCount ++;
        totalBytesRead += numBytesToRead;

        if ((((totalBytesRead*100)/fileSize)) != prevProgress) {
            if ( (pContext->threadProgress != prevProgress) && (prevProgress != 0 )) {
                //pContext->threadProgress = prevProgress;
                //onWveformProgressUpdateMethodId(prevProgress, 0);
                //LVME_callAudioGraphOnProgressUpdate(pContext, 0, prevProgress);
            pEnv->CallVoidMethod(pContext->engine,
                                 pContext->onAudioGraphProgressUpdateMethodId,
                                 prevProgress, 0);
            VIDEOEDIT_LOG_API(ANDROID_LOG_INFO, "VIDEO_EDITOR", "pContext->threadProgress %d",
                             prevProgress);
            }
        }
        prevProgress = (((totalBytesRead*100)/fileSize));

    } while (numBytesToRead != 0);

    VIDEOEDIT_LOG_ERROR(ANDROID_LOG_INFO, "VIDEO_EDITOR", "loop 0x%lx", volumeValuesCount);

    /* if some error occured in fwrite */
    if (numBytesToRead != 0) {
        //err = -1;
        jniThrowException(pEnv, "java/lang/IOException", "numBytesToRead != 0 ; file write failed");
    }

    /* write the count in place holder after seek */
    seekPos = sizeof(M4OSA_UInt32);
    err = M4OSA_fileWriteSeek(outFileHandle, M4OSA_kFileSeekBeginning,
            &seekPos /* after samples per value */);
    if ( err != M4NO_ERROR) {
        jniThrowException(pEnv, "java/lang/IOException", "file seek failed");
    } else {
        volumeValuesCount = ((volumeValuesCount>>24)&0xff) | // move byte 3 to byte 0
                    ((volumeValuesCount<<8)&0xff0000) | // move byte 1 to byte 2
                    ((volumeValuesCount>>8)&0xff00) |  // move byte 2 to byte 1
                    ((volumeValuesCount<<24)&0xff000000); // byte 0 to byte 3

        err = M4OSA_fileWriteData (outFileHandle, (M4OSA_MemAddr8)&volumeValuesCount,
                                    sizeof(M4OSA_UInt32) );
        if ( err != M4NO_ERROR) {
            jniThrowException(pEnv, "java/lang/IOException", "file write failed");
        }
    }

    /******************************************************************************
    CLOSE AND FREE ALLOCATIONS
    *******************************************************************************/
    free(bufferIn.m_dataAddress);
    M4OSA_fileReadClose(inputFileHandle);
    M4OSA_fileWriteClose(outFileHandle);
    /* final finish callback */
    pEnv->CallVoidMethod(pContext->engine, pContext->onAudioGraphProgressUpdateMethodId, 100, 0);

    /* EXIT */
    VIDEOEDIT_LOG_API(ANDROID_LOG_INFO, "VIDEO_EDITOR", "EXIT - M4MA_generateAudioGraphFile");

    return err;
}

static int videoEditor_generateAudioWaveFormSync (JNIEnv*  pEnv, jobject thiz,
                                                  jstring pcmfilePath,
                                                  jstring outGraphfilePath,
                                                  jint frameDuration, jint channels,
                                                  jint samplesCount)
{
    M4OSA_ERR result = M4NO_ERROR;
    ManualEditContext* pContext = M4OSA_NULL;
    bool needToBeLoaded = true;
    const char *pPCMFilePath, *pStringOutAudioGraphFile;

    VIDEOEDIT_LOG_API(ANDROID_LOG_INFO, "VIDEO_EDITOR",
        "videoEditor_generateAudioWaveFormSync() ");

    /* Get the context. */
    pContext = (ManualEditContext*)videoEditClasses_getContext(&needToBeLoaded, pEnv, thiz);
    if (pContext == M4OSA_NULL) {
        VIDEOEDIT_LOG_API(ANDROID_LOG_INFO, "VIDEO_EDITOR",
            "videoEditor_generateAudioWaveFormSync() - pContext is NULL ");
    }

    VIDEOEDIT_LOG_API(ANDROID_LOG_INFO, "VIDEO_EDITOR",
        "videoEditor_generateAudioWaveFormSync Retrieving pStringOutAudioGraphFile");

    pPCMFilePath = pEnv->GetStringUTFChars(pcmfilePath, NULL);
    if (pPCMFilePath == M4OSA_NULL) {
        jniThrowException(pEnv, "java/lang/RuntimeException",
            "Input string PCMFilePath is null");
        result = M4ERR_PARAMETER;
        goto out;
    }

    pStringOutAudioGraphFile = pEnv->GetStringUTFChars(outGraphfilePath, NULL);
    if (pStringOutAudioGraphFile == M4OSA_NULL) {
        jniThrowException(pEnv, "java/lang/RuntimeException",
            "Input string outGraphfilePath is null");
        result = M4ERR_PARAMETER;
        goto out2;
    }

    VIDEOEDIT_LOG_API(ANDROID_LOG_INFO, "VIDEO_EDITOR",
        "videoEditor_generateAudioWaveFormSync Generate the waveform data %s %d %d %d",
        pStringOutAudioGraphFile, frameDuration, channels, samplesCount);

    /* Generate the waveform */
    result = M4MA_generateAudioGraphFile(pEnv, (M4OSA_Char*) pPCMFilePath,
        (M4OSA_Char*) pStringOutAudioGraphFile,
        (M4OSA_UInt32) samplesCount,
        (M4OSA_UInt32) channels,
        (M4OSA_UInt32)frameDuration,
        pContext);

    pEnv->ReleaseStringUTFChars(outGraphfilePath, pStringOutAudioGraphFile);

out2:
    if (pPCMFilePath != NULL) {
        pEnv->ReleaseStringUTFChars(pcmfilePath, pPCMFilePath);
    }

out:
    VIDEOEDIT_LOG_FUNCTION(ANDROID_LOG_INFO, "VIDEO_EDITOR",
        "videoEditor_generateAudioWaveFormSync pContext->bSkipState ");

    return result;
}

/******** End Audio Graph *******/
jint JNI_OnLoad(
                JavaVM*                             pVm,
                void*                               pReserved)
{
    void* pEnv         = NULL;
    bool  needToBeInitialized = true;
    jint  result      = -1;

    VIDEOEDIT_LOG_FUNCTION(ANDROID_LOG_INFO, "VIDEO_EDITOR", "JNI_OnLoad()");

    // Add a text marker (the condition must always be true).
    ADD_TEXT_MARKER_FUN(NULL != pVm)

    // Check the JNI version.
    if (pVm->GetEnv(&pEnv, JNI_VERSION_1_4) == JNI_OK)
    {
        // Add a code marker (the condition must always be true).
        ADD_CODE_MARKER_FUN(NULL != pEnv)

        // Register the manual edit JNI methods.
        if (videoEditor_registerManualEditMethods((JNIEnv*)pEnv) == 0)
        {
            // Initialize the classes.
            videoEditClasses_init(&needToBeInitialized, (JNIEnv*)pEnv);
            if (needToBeInitialized)
            {
                // Success, return valid version number.
                result = JNI_VERSION_1_4;
            }
        }
    }

    // Return the result.
    return(result);
}