/*

 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

 * All rights reserved.

 * This component and the accompanying materials are made available

 * under the terms of "Eclipse Public License v1.0"

 * which accompanies this distribution, and is available

 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

 *

 * Initial Contributors:

 * Nokia Corporation - initial contribution.

 *

 * Contributors:

 *

 * Description:

 *

 */

#include <string.h>

#include <ctype.h>

#include <uri8.h>

#include <uri16.h>

#include "cmmfbackendengine.h"

#include "markerpositiontimer.h"

#include "positionupdatetimer.h"

#include "profileutilmacro.h"

#include <mmf/common/mmfvideoenums.h>

extern "C"

    {

#include "xaadaptationmmf.h"

    }

#define RET_IF_ERR(res, val) if (res != KErrNone) return val

const XAuint32 XA_PLAYSTATE_PLAYERUNINITIALIZED = 0;

CMMFBackendEngine* CMMFBackendEngine::NewL()

    {

    CMMFBackendEngine* self = new (ELeave) CMMFBackendEngine();

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

CMMFBackendEngine::~CMMFBackendEngine()

    {

    Close();

    Destroy();

    }

CMMFBackendEngine::CMMFBackendEngine() :

    iPositionUpdatePeriod(1000), /* default is 1000 millisec */

    iUriPtr(NULL, 0)

    {

    iRecordState = ERecorderNotReady;

    iPositionUpdateTimer = NULL;

    iMediaPlayerState = XA_PLAYSTATE_PLAYERUNINITIALIZED;

    iMMFPlayerState = EPlayerClosed;

    }

void CMMFBackendEngine::ConstructL()

    {

    iAPIBeingUsed = ENoUtility;

    iActiveSchedulerWait = new (ELeave) CActiveSchedulerWait;

    }

void CMMFBackendEngine::InitAudioRecorderUtilityL()

    {

    if (!iAudioRecorder)

        {

        iBaseAudioRecorder = CMdaAudioRecorderUtility::NewL(*this);

        iAudioRecorder = (CMdaAudioRecorderUtility*) iBaseAudioRecorder;

        }

    }

void CMMFBackendEngine::InitAudioPlayerUtilityL()

    {

    if (!iAudioPlayer)

        {

        iBaseAudioPlayer = CMdaAudioPlayerUtility::NewL(*this);

        iAudioPlayer = (CMdaAudioPlayerUtility*) iBaseAudioPlayer;

        }

    InitPlayerTimersL();

    }

void CMMFBackendEngine::InitVideoPlayerUtilityL()

    {

    if (!iVideoPlayer)

        {

        iBaseVideoPlayer = CVideoPlayerUtility2::NewL(*this,

                EMdaPriorityNormal, EMdaPriorityPreferenceTimeAndQuality);

        iVideoPlayer = (CVideoPlayerUtility2*) iBaseVideoPlayer;

        iVideoPlayer->RegisterForVideoLoadingNotification(*this);

        }

    InitPlayerTimersL();

    }

void CMMFBackendEngine::InitPlayerTimersL()

    {

    if (!iMarkerPositionTimer)

        {

        iMarkerPositionTimer = CMarkerPositionTimer::NewL(iAudioPlayer,

                iVideoPlayer);

        iMarkerPositionTimer->SetContext(iAdaptContext);

        }

    if (!iPlayItfPositionUpdateTimer)

        {

        iPlayItfPositionUpdateTimer = CPositionUpdateTimer::NewL(

                iAudioPlayer, iVideoPlayer);

        iPlayItfPositionUpdateTimer->SetContext(iAdaptContext);

        }

    iMarkerPositionTimer->Stop();

    iPlayItfPositionUpdateTimer->Stop();

    }

TInt CMMFBackendEngine::SetFileName(char* uri, XAuint32 format,

        TFuncInUse func)

    {

    TInt err(KErrNone);

    _LIT8(KFileSlash,"file:///");

    TInt fileslashlen = KFileSlash().Length();

    if (func == ERecord)

        {

        if (iRecordState == ERecorderNotReady)

            {

            iFileFormat = format;

            iAPIBeingUsed = DetermineAPIToUse(uri, ERecord);

            err = XA_RESULT_INTERNAL_ERROR;

            if (iAPIBeingUsed == EAudioRecorderUtility)

                {

                /* Initialize URI as needed by MMF utilities */

                err = InitializeURIForMMFUtil(uri);

                RET_IF_ERR(err, XA_RESULT_INTERNAL_ERROR);

                /* Initalize Recorder related objects */

                TRAP(err, InitAudioRecorderUtilityL());

                RET_IF_ERR(err, XA_RESULT_INTERNAL_ERROR);

                TRAP(err, iAudioRecorder->OpenFileL(iUriPtr));

                RET_IF_ERR(err, XA_RESULT_INTERNAL_ERROR);

                /* Wait until we receive moscostatechanged callback */

                if (iActiveSchedulerWait && !iActiveSchedulerWait->IsStarted())

                    {

                    iActiveSchedulerWait->Start();

                    }

                RET_IF_ERR(iErrorCode, XA_RESULT_INTERNAL_ERROR);

                }

            }

        }

    else

        {

        /* The second one is needed for dynamic source interface */

        if ((iMediaPlayerState == XA_PLAYSTATE_PLAYERUNINITIALIZED)

                || (iMediaPlayerState == XA_PLAYSTATE_STOPPED))

            {

            iFileFormat = format;

            iAPIBeingUsed = DetermineAPIToUse(uri, EPlay);

            err = XA_RESULT_INTERNAL_ERROR;

            if (iAPIBeingUsed == EAudioPlayerUtility)

                {

                /* Initialize URI as needed by MMF utilities */

                err = InitializeURIForMMFUtil(uri);

                RET_IF_ERR(err, XA_RESULT_INTERNAL_ERROR);

                /* Initalize Player related objects */

                TRAP(err, InitAudioPlayerUtilityL());

                RET_IF_ERR(err, XA_RESULT_INTERNAL_ERROR);

                TAG_TIME_PROFILING_BEGIN;

                TRAP(err, iAudioPlayer->OpenFileL(iUriPtr));

                RET_IF_ERR(err, XA_RESULT_INTERNAL_ERROR); 

                TAG_TIME_PROFILING_END; 

                PRINT_TO_CONSOLE_TIME_DIFF;

                /* Wait until we receive mapc init complete */

                PRINT_TO_CONSOLE_HOME_TIME;

                if (iActiveSchedulerWait && !iActiveSchedulerWait->IsStarted())

                    {

                    iActiveSchedulerWait->Start();

                    }

                RET_IF_ERR(iErrorCode, XA_RESULT_INTERNAL_ERROR);

                }

            else if (iAPIBeingUsed == EVideoPlayerUtility)

                {

                /* Initialize URI as needed by MMF utilities */

                err = InitializeURIForMMFUtil(uri);

                RET_IF_ERR(err, XA_RESULT_INTERNAL_ERROR);

                /* Initalize Player related objects */

                TRAP(err, InitVideoPlayerUtilityL());

                RET_IF_ERR(err, XA_RESULT_INTERNAL_ERROR);

                if (iUriType == ELocal)

                    {

                    /* Open file */

                    TAG_TIME_PROFILING_BEGIN;

                    TRAP(err, iVideoPlayer->OpenFileL(iUriPtr));

                    RET_IF_ERR(err, XA_RESULT_INTERNAL_ERROR); 

                    TAG_TIME_PROFILING_END; 

                    PRINT_TO_CONSOLE_TIME_DIFF;

                    }

                else

                    {

                    /* Open URL */

                    TAG_TIME_PROFILING_BEGIN;

                    TRAP(err, iVideoPlayer->OpenUrlL(iUriPtr));

                    RET_IF_ERR(err, XA_RESULT_INTERNAL_ERROR); 

                    TAG_TIME_PROFILING_END; 

                    PRINT_TO_CONSOLE_TIME_DIFF;

                    }

                /* Wait until we receive  MvpuoOpenComplete */

                PRINT_TO_CONSOLE_HOME_TIME;

                if (iActiveSchedulerWait && !iActiveSchedulerWait->IsStarted())

                    {

                    iActiveSchedulerWait->Start();

                    }

                RET_IF_ERR(iErrorCode, XA_RESULT_INTERNAL_ERROR);

                /* Prepare utility */

                iVideoPlayer->Prepare();

                PRINT_TO_CONSOLE_TIME_DIFF;

                /* Wait until we receive  MvpuoPrepareComplete */

                PRINT_TO_CONSOLE_HOME_TIME_NO_VAR_DEF;

                if (iActiveSchedulerWait && !iActiveSchedulerWait->IsStarted())

                    {

                    iActiveSchedulerWait->Start();

                    }

                RET_IF_ERR(iErrorCode, XA_RESULT_INTERNAL_ERROR);

                }

            }

        }

    if (err != KErrNone)

        {

        err = XA_RESULT_INTERNAL_ERROR;

        }

    return err;

    }

TInt CMMFBackendEngine::DetermineAPIToUse(char* uri, TFuncInUse aFunc)

    {

    char* dotPtr = NULL;

    char ext[MAX_EXTENSION_SIZE] =

        {

        0

        };

    int extLen;

    int colpos;

    char urischeme[MAX_EXTENSION_SIZE] =

        {

        0

        };

    int urischemeLen;

    dotPtr = strrchr(uri, (int) '.');

    if (!dotPtr)

        {

        return KErrNotFound;

        }

    strncpy(ext, dotPtr, strlen(dotPtr));

    /*Null terminate the string*/

    ext[strlen(dotPtr)] = '\0';

    extLen = sizeof(ext);

    for (unsigned int i = 0; i < extLen; i++)

        {

        ext[i] = tolower(ext[i]);

        }

    colpos = strcspn(uri, ":");

    strncpy(urischeme, uri, colpos + 1);

    /*Null terminate the string*/

    urischeme[colpos + 1] = '\0';

    urischemeLen = sizeof(urischeme);

    for (unsigned int i = 0; i < urischemeLen; i++)

        {

        urischeme[i] = tolower(urischeme[i]);

        }

    if (aFunc == ERecord)

        {

        return EAudioRecorderUtility;

        }

    else

        {

        if (!strcmp(urischeme, "file:"))

            {

            if (!strcmp(ext, ".mp3") || !strcmp(ext, ".amr")

                    || !strcmp(ext, ".aac") || !strcmp(ext, ".mid")

                    || !strcmp(ext, ".wav") || !strcmp(ext, ".awb"))

                {

                return EAudioPlayerUtility;

                }

            else

                {

                return EVideoPlayerUtility;

                }

            }

        else

            {

            return EVideoPlayerUtility;

            }

        }

    }

//From MVidePlayerUtilityObserver

void CMMFBackendEngine::MvpuoOpenComplete(TInt aError)

    {

    PRINT_TO_CONSOLE_HOME_TIME;

    iErrorCode = aError;

    if (iErrorCode == KErrNone)

        {

        iMMFPlayerState = EPlayerOpened;

        }

    if (iActiveSchedulerWait && iActiveSchedulerWait->IsStarted())

        {

        iActiveSchedulerWait->AsyncStop();

        }

    }

void CMMFBackendEngine::MvpuoPrepareComplete(TInt aError)

    {

    PRINT_TO_CONSOLE_HOME_TIME;

    TAutoScaleType autoScale = EAutoScaleBestFit;

    iErrorCode = aError;

    iMediaPlayerState = XA_PLAYSTATE_PLAYERUNINITIALIZED;

    iMediaDuration = 0;

    iMarkerPositionTimer->ResetPlayer();

    iPlayItfPositionUpdateTimer->ResetPlayer();

    if (iErrorCode == KErrNone)

        {

        iMMFPlayerState = EPlayerPrepared;

        TAG_TIME_PROFILING_BEGIN;

        TRAP(iErrorCode, iMediaDuration = iVideoPlayer->DurationL()); 

        TAG_TIME_PROFILING_END; 

        PRINT_TO_CONSOLE_TIME_DIFF;

        if (iErrorCode == KErrNone)

            {

            iPlaybackHead = 0;

            iMediaPlayerState = XA_PLAYSTATE_STOPPED;

            iMarkerPositionTimer->UseVideoPlayer();

            iPlayItfPositionUpdateTimer->UseVideoPlayer();

            if (m_pWs && m_pScr && m_pWindow)

                {

                TRect videoExtent = TRect(m_pWindow->Size());

                TRect clipRect = TRect(m_pWindow->Size());

                TAG_TIME_PROFILING_BEGIN;

                TRAP_IGNORE(iVideoPlayer->AddDisplayWindowL(*m_pWs, *m_pScr, *m_pWindow, videoExtent, clipRect));

                TRAP_IGNORE(iVideoPlayer->SetAutoScaleL(*m_pWindow, autoScale)); 

                TAG_TIME_PROFILING_END; 

                PRINT_TO_CONSOLE_TIME_DIFF;

                }

            }

        }

    if (iActiveSchedulerWait && iActiveSchedulerWait->IsStarted())

        {

        iActiveSchedulerWait->AsyncStop();

        }

    }

void CMMFBackendEngine::MvpuoFrameReady(CFbsBitmap& /*aFrame*/, TInt /*aError*/)

    {

    }

void CMMFBackendEngine::MvpuoPlayComplete(TInt aError)

    {

    iErrorCode = aError;

    if (iErrorCode == KErrNone)

        {

        iPlaybackHead = iMediaDuration;

        /* Per OpenMAX AL Spec, when playback is completed, media player stays in

         * paused state with playhead at the end of the media clip */

        iMediaPlayerState = XA_PLAYSTATE_PAUSED;

        DoPostEvent(XA_PLAYEVENT_HEADATEND);

        }

    else

        {

        iPlaybackHead = 0;

        iMediaPlayerState = XA_PLAYSTATE_STOPPED;

        XAAdaptEvent event =

            {

            XA_PLAYITFEVENTS, XA_OBJECT_EVENT_RESOURCES_LOST, 0, NULL

            };

        XAAdaptationBase_SendAdaptEvents(

                (XAAdaptationBaseCtx*) iAdaptContext, &event);

        }

    iMMFPlayerState = EPlayerPrepared;

    iMarkerPositionTimer->Stop();

    iPlayItfPositionUpdateTimer->Stop();

    }

void CMMFBackendEngine::MvpuoEvent(class TMMFEvent const & event)

    {

    //RDebug::Print(_L("CMMFBackendEngine::MvpuoEvent (0x%x %d)"), event.iEventType, event.iErrorCode);

    if (event.iEventType == KMMFEventCategoryVideoPlayerGeneralError

            && event.iErrorCode == KErrHardwareNotAvailable)

        {

        //RDebug::Print(_L("CMMFBackendEngine::MvpuoEvent: Hardware Not Available"));

        }

    else if (event.iEventType == KMMFEventCategoryVideoPlayerGeneralError

            && event.iErrorCode == KErrMMPartialPlayback)

        {

        //RDebug::Print(_L("CMMFBackendEngine::MvpuoEvent: Partial playback"));

        }

    if (event.iEventType == KMMFEventCategoryVideoPlayerGeneralError

            && event.iErrorCode == -12014)

        {

        //RDebug::Print(_L("CMMFBackendEngine::MvpuoEvent: Audio Device taken"));

        PausePlayback();

            {

            XA_PLAYITFEVENTS, XA_OBJECT_EVENT_RESOURCES_LOST, 0, NULL

            };

        XAAdaptationBase_SendAdaptEvents(

        }

    else if (event.iEventType == KMMFRefreshMetaData)

        {

        //RDebug::Print(_L("CMMFBackendEngine::MvpuoEvent: EventType == KMMFRefreshMetaData"));

        }

    else

        {

        //RDebug::Print(_L("CMMFBackendEngine::MvpuoEvent: Unhandled event"));

        }

    }

// From MRebufferCallback

void CMMFBackendEngine::MvloLoadingStarted()

    {

    }

void CMMFBackendEngine::MvloLoadingComplete()

    {

    }

//MMdaAudioPlayerCallback

void CMMFBackendEngine::MapcInitComplete(TInt aError,

        const TTimeIntervalMicroSeconds& aDuration)

    {