/*

* Copyright (c) 2009-2010 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 <algorithm>

#include <exception>

#include <QTime>

#include <QPixmap>

#include <coemain.h>

#include <QStringList>

#include "cxeexception.h"

#include "cxevideocapturecontrolsymbian.h"

#include "cxevideorecorderutilitysymbian.h"

#include "cxecameradevicecontrolsymbian.h"

#include "cxefilenamegeneratorsymbian.h"

#include "cxeerrormappingsymbian.h"

#include "cxeviewfindercontrol.h"

#include "cxesnapshotcontrol.h"

#include "cxestillimagesymbian.h"

#include "cxecameradevice.h"

#include "cxutils.h"

#include "cxestate.h"

#include "cxesettings.h"

#include "cxenamespace.h"

#include "cxesoundplayersymbian.h"

#include "cxequalitypresetssymbian.h"

#include "cxeviewfindercontrolsymbian.h"

#include "cxediskmonitor.h"

#include "cxesettingsmappersymbian.h"

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "cxevideocapturecontrolsymbianTraces.h"

#endif

// constants

namespace

{

    // TMMFEvent UIDs for Async stop

    const TUid KCamCControllerCCVideoRecordStopped = {0x2000E546};

    const TUid KCamCControllerCCVideoFileComposed = {0x2000E547};

    const TInt64  KMinRequiredSpaceVideo      = 4000000;

}

/*!

* CxeVideoCaptureControlSymbian::CxeVideoCaptureControlSymbian

*/

CxeVideoCaptureControlSymbian::CxeVideoCaptureControlSymbian(

    CxeCameraDevice &cameraDevice,

    CxeViewfinderControl &viewfinderControl,

    CxeSnapshotControl &snapshotControl,

    CxeCameraDeviceControl &cameraDeviceControl,

    CxeFilenameGenerator &nameGenerator,

    CxeSettings &settings,

    CxeQualityPresets &qualityPresets,

    CxeDiskMonitor &diskMonitor)

    : CxeStateMachine("CxeVideoCaptureControlSymbian"),

      mVideoRecorder(NULL),

      mCameraDevice(cameraDevice),

      mCameraDeviceControl(cameraDeviceControl),

      mViewfinderControl(viewfinderControl),

      mSnapshotControl(snapshotControl),

      mFilenameGenerator(nameGenerator),

      mSettings(settings),

      mQualityPresets(qualityPresets),

      mDiskMonitor(diskMonitor),

      mSnapshot(),

      mVideoStartSoundPlayer(NULL),

      mVideoStopSoundPlayer(NULL),

      mCurrentFilename("")

{

    CX_DEBUG_ENTER_FUNCTION();

    OstTrace0(camerax_performance, CXEVIDEOCAPTURECONTROLSYMBIAN_CREATE_IN, "msg: e_CX_VIDEOCAPTURECONTROL_NEW 1");

    qRegisterMetaType<CxeVideoCaptureControl::State> ();

    initializeStates();

    mVideoStopSoundPlayer = new

             CxeSoundPlayerSymbian(CxeSoundPlayerSymbian::VideoCaptureStop,

                                   mSettings);

    mVideoStartSoundPlayer = new

             CxeSoundPlayerSymbian(CxeSoundPlayerSymbian::VideoCaptureStart,

                                   mSettings);

    // If camera is already allocated, call the slot ourselves.

    if (mCameraDevice.camera()) {

        handleCameraAllocated(CxeError::None);

    }

    OstTrace0(camerax_performance, CXEVIDEOCAPTURECONTROLSYMBIAN_CREATE_M1, "msg: e_CX_ENGINE_CONNECT_SIGNALS 1");

    // connect signals from cameraDevice, so we recieve events when camera reference changes

    connect(&cameraDevice, SIGNAL(prepareForCameraDelete()),

            this, SLOT(prepareForCameraDelete()));

    connect(&cameraDevice, SIGNAL(prepareForRelease()),

            this, SLOT(prepareForRelease()) );

    connect(&cameraDevice, SIGNAL(cameraAllocated(CxeError::Id)),

            this, SLOT(handleCameraAllocated(CxeError::Id)));

    // connect playing sound signals

    connect(mVideoStartSoundPlayer, SIGNAL(playComplete(int)),

            this, SLOT(handleSoundPlayed()));

    // connect snapshot ready signal

    connect(&mSnapshotControl, SIGNAL(snapshotReady(CxeError::Id, const QImage&)),

            this, SLOT(handleSnapshotReady(CxeError::Id, const QImage&)));

    // enabling setting change callbacks to videocapturecontrol

    connect(&mSettings, SIGNAL(settingValueChanged(const QString&,QVariant)),

            this, SLOT(handleSettingValueChanged(const QString&,QVariant)));

    mSettings.listenForSetting(CxeSettingIds::VIDEO_SCENE, this, SLOT(handleSceneChanged(const QVariant&)));

    OstTrace0(camerax_performance, CXEVIDEOCAPTURECONTROLSYMBIAN_CREATE_M2, "msg: e_CX_ENGINE_CONNECT_SIGNALS 0");

    OstTrace0(camerax_performance, CXEVIDEOCAPTURECONTROLSYMBIAN_CREATE_OUT, "msg: e_CX_VIDEOCAPTURECONTROL_NEW 0");

    CX_DEBUG_EXIT_FUNCTION();

}

/*!

* CxeVideoCaptureControlSymbian::~CxeVideoCaptureControlSymbian()

*/

CxeVideoCaptureControlSymbian::~CxeVideoCaptureControlSymbian()

{

    CX_DEBUG_ENTER_FUNCTION();

    releaseResources();

    mIcmSupportedVideoResolutions.clear();

    delete mVideoStartSoundPlayer;

    delete mVideoStopSoundPlayer;

    CX_DEBUG_EXIT_FUNCTION();

}

/*!

* Initializes resources for video recording.

*/

void CxeVideoCaptureControlSymbian::init()

{

    CX_DEBUG_ENTER_FUNCTION();

    OstTrace0( camerax_performance, CXEVIDEOCAPTURECONTROLSYMBIAN_INIT, "msg: e_CX_VIDEO_CAPCONT_INIT 1" );

    if (state() == Idle) {

        // start initializing resources for video capture

        initVideoRecorder();

    } else if (state() == Initialized) {

        // video recorder already initalized. Continue to prepare video reocording.

        open();

    }

    OstTrace0( camerax_performance, DUP1_CXEVIDEOCAPTURECONTROLSYMBIAN_INIT, "msg: e_CX_VIDEO_CAPCONT_INIT 0" );

    CX_DEBUG_EXIT_FUNCTION();

}

/*!

* Releases all resources

*/

void CxeVideoCaptureControlSymbian::deinit()

{

    CX_DEBUG_ENTER_FUNCTION();

    // Nothing to do if already idle.

    if(state() != Idle) {

        OstTrace0( camerax_performance, CXEVIDEOCAPTURECONTROLSYMBIAN_DEINIT, "msg: e_CX_VIDEO_CAPCONT_DEINIT 1" );

        // first stop viewfinder

        mViewfinderControl.stop();

        // stop video-recording in-case if its ongoing.

        stop();

        // Check if state is stopping, in which case we have to inform the

        // file harvester that a file is to be completed. We would not

        // call harvestFile otherwise in this case.

        // Otherwise the video will not be found from videos app.

        if (state() == Stopping) {

            emit videoComposed(CxeError::None, mCurrentFilename);

        }

        mSnapshotControl.stop();

        if (mVideoRecorder) {

            mVideoRecorder->close();

        }

        setState(Idle);

        OstTrace0( camerax_performance, DUP1_CXEVIDEOCAPTURECONTROLSYMBIAN_DEINIT, "msg: e_CX_VIDEO_CAPCONT_DEINIT 0" );

    }

    CX_DEBUG_EXIT_FUNCTION();

}

/*!

* Intializes VideoRecorder for recording.

*/

void CxeVideoCaptureControlSymbian::initVideoRecorder()

{

    CX_DEBUG_ENTER_FUNCTION();

    // Init needed only in Idle state

    if (state() == Idle) {

        try {

            // If video recorder is not yet created, do it now.

            createVideoRecorder();

            // Update current video quality details from ICM.

            // Throws an error if unable to get the quality.

            updateVideoCaptureParameters();

            // Video recorder is ready to open video file for recording.

            setState(Initialized);

            open();

        } catch (const std::exception &e) {

            // Handle error

            handlePrepareFailed();

        }

    }

    CX_DEBUG_EXIT_FUNCTION();

}

/*!

* Opens file for video recording.

*/

void CxeVideoCaptureControlSymbian::open()

{

    CX_DEBUG_ENTER_FUNCTION();

    // Check valid state to start "open" operation

    if (state() == Initialized) {

        try {

            // generate video file name, if necessary

            generateFilename();

            CX_DEBUG(( "Next video file path: %s", mCurrentFilename.toAscii().constData() ));

            // Start preparing..

            setState(CxeVideoCaptureControl::Preparing);

            // Exception thrown if open fails.

            mVideoRecorder->open(mCameraDevice.camera()->Handle(),

                                 mCurrentFilename,

                                 mCurrentVideoDetails.mVideoFileMimeType,

                                 mCurrentVideoDetails.mPreferredSupplier,

                                 mCurrentVideoDetails.mVideoCodecMimeType,

                                 mCurrentVideoDetails.mAudioType);

        } catch (const std::exception &e) {

            handlePrepareFailed();

        }

    }

    CX_DEBUG_EXIT_FUNCTION();

}

/*!

* Helper method for generating filename.

* Throws exception, if file type mime is formatted wrong or

* filename generation fails.

*/

void CxeVideoCaptureControlSymbian::generateFilename()

{

    CX_DEBUG_ENTER_FUNCTION();

    mCurrentFilename = QString("");

    QStringList list = mCurrentVideoDetails.mVideoFileMimeType.split("/");

    // Throw exception if mime string is formatted wrong.

    if (list.count() != 2) {

        throw new CxeException(CxeError::General);

    }

    QString fileExt = "." + list[1];

    // Generate new filename and open the file for writing video data

    CxeException::throwIfError(mFilenameGenerator.generateFilename(mCurrentFilename, fileExt));

    CX_DEBUG_EXIT_FUNCTION();

}

/*!

* Prepare Video Recorder with necessary settings for video capture.

*/

void CxeVideoCaptureControlSymbian::prepare()

{

    CX_DEBUG_ENTER_FUNCTION();

    if (state() != Preparing) {

        // not valid state to continue prepare.

        return;

    }

    OstTrace0(camerax_performance, CXEVIDEOCAPTURECONTROL_PREPARE_1, "msg: e_CX_VIDCAPCONT_PREPARE 1");

    QSize frameSize(mCurrentVideoDetails.mWidth, mCurrentVideoDetails.mHeight);

    bool muteSetting = mSettings.get<bool>(CxeSettingIds::VIDEO_MUTE_SETTING, false);

    // Check if scene defines frame rate.

    // Use generic frame rate defined in video details, if no value is set in scene.

    int frameRate = mSettings.get<int>(CxeSettingIds::FRAME_RATE, 0);

    if (frameRate <= 0) {

        frameRate = mCurrentVideoDetails.mVideoFrameRate;

    }

    CX_DEBUG(("Video resolution (%d,%d)", mCurrentVideoDetails.mWidth,

                                           mCurrentVideoDetails.mHeight));

    CX_DEBUG(("Video bitrate = %d)", mCurrentVideoDetails.mVideoBitRate));

    CX_DEBUG(("Video frame rate = %d)", frameRate));

    try {

        mVideoRecorder->setVideoFrameSize(frameSize);

        mVideoRecorder->setVideoFrameRate(frameRate);

        mVideoRecorder->setVideoBitRate(mCurrentVideoDetails.mVideoBitRate);

        mVideoRecorder->setAudioEnabled(!muteSetting);

        // "No limit" value is handled in video recorder wrapper.

        mVideoRecorder->setVideoMaxSize(mCurrentVideoDetails.mMaximumSizeInBytes);

        // Settings have been applied successfully, start to prepare.

        mVideoRecorder->prepare();

        // Prepare zoom only when there are no errors during prepare.

        emit prepareZoomForVideo();

        emit videoPrepareComplete(CxeError::None);

    } catch (const std::exception &e) {

        // Handle error.

        handlePrepareFailed();

    }

    OstTrace0(camerax_performance, CXEVIDEOCAPTURECONTROL_PREPARE_2, "msg: e_CX_VIDCAPCONT_PREPARE 0");

    CX_DEBUG_EXIT_FUNCTION();

}

/*!

* Prepare video snapshot.

* Throws exception on error.

*/

void CxeVideoCaptureControlSymbian::prepareSnapshot()

{

    CX_DEBUG_ENTER_FUNCTION();

    OstTrace0( camerax_performance, CXEVIDEOCAPTURECONTROL_PREPARESNAP_1, "msg: e_CX_PREPARE_SNAPSHOT 1" );

    // Prepare snapshot. Snapshot control throws error if problems.

    QSize snapshotSize = mSnapshotControl.calculateSnapshotSize(

                            mViewfinderControl.deviceDisplayResolution(),

                            mCurrentVideoDetails.mAspectRatio);

    mSnapshotControl.start(snapshotSize);

    OstTrace0( camerax_performance, CXEVIDEOCAPTURECONTROL_PREPARESNAP_2, "msg: e_CX_PREPARE_SNAPSHOT 0" );

    CX_DEBUG_EXIT_FUNCTION();

}

/*!

  Fetch video quality details based on current video quality setting.

*/

void CxeVideoCaptureControlSymbian::updateVideoCaptureParameters()

{

    CX_DEBUG_ENTER_FUNCTION();

    OstTrace0(camerax_performance, CXEVIDEOCAPTURECONTROL_UPDATEVIDEOCAPTUREPARAMETERS_1, "msg: e_CX_UPDATE_VIDEO_CAPTURE_PARAMETERS 1");

    int quality = 0;

    // Get quality index for primary camera. Only one quality for secondary camera.

    if (mCameraDeviceControl.cameraIndex() == Cxe::PrimaryCameraIndex) {

        quality = mSettings.get<int>(CxeSettingIds::VIDEO_QUALITY);

    }

    if (quality < 0 || quality >= mIcmSupportedVideoResolutions.count()) {

       throw new CxeException(CxeError::NotFound);

    }

    // Get video quality details

    mCurrentVideoDetails = mIcmSupportedVideoResolutions.at(quality);

    OstTrace0(camerax_performance, CXEVIDEOCAPTURECONTROL_UPDATEVIDEOCAPTUREPARAMETERS_2, "msg: e_CX_UPDATE_VIDEO_CAPTURE_PARAMETERS 0");

    CX_DEBUG_EXIT_FUNCTION();

}

/*!

* Resets the video snapshot and current video filename

*/

void CxeVideoCaptureControlSymbian::reset()

{

    CX_DEBUG_ENTER_FUNCTION();

    // Snapshot will consume considerably memory.

    // Replace it with null pixmap to have it freed.

    mSnapshot = QPixmap();

    // reset the current file name.

    mCurrentFilename = QString("");

    CX_DEBUG_EXIT_FUNCTION();

}

/*!

* Returns current video filename

*/

QString CxeVideoCaptureControlSymbian::filename() const

{

    // Simply return the current contents of mCurrentFilename.

    // If video recording was started then it returns proper filename

    // otherwise an empty string is returned.

    return mCurrentFilename;

}

/*!

* Returns current video snapshot

*/

QPixmap CxeVideoCaptureControlSymbian::snapshot() const

{

    return mSnapshot;

}

/*!

* Starts video recording if we are in appropriate state.

*/

void CxeVideoCaptureControlSymbian::record()

{

    CX_DEBUG_ENTER_FUNCTION();

    if (state() == Ready || state() == Paused) {

        // ask the player to play the sound

        // recording will start once start sound is played

        setState(CxeVideoCaptureControl::PlayingStartSound);

        mVideoStartSoundPlayer->play();

    }

    CX_DEBUG_EXIT_FUNCTION();

}

/*!

* Pauses video recording.

*/

void CxeVideoCaptureControlSymbian::pause()

{

    CX_DEBUG_ENTER_FUNCTION();

    try {

        mVideoRecorder->pause();

        setState(CxeVideoCaptureControl::Paused);

        // play the sound, but not changing the state

        mVideoStopSoundPlayer->play();

    } catch (const std::exception &e) {

        handleComposeFailed(qt_symbian_exception2Error(e));

    }

    CX_DEBUG_EXIT_FUNCTION();

}

/*!

* Stops video recording.

*/

void CxeVideoCaptureControlSymbian::stop()

{

    CX_DEBUG_ENTER_FUNCTION();

    if (state() == Recording || state() == Paused) {

        // first stop viewfinder

        mViewfinderControl.stop();

        try {

            // Try asynchronous stopping first.

            mVideoRecorder->stop(true);

            // No error from asynchronous stop -> wait for stop event

        } catch (const std::exception &e) {

            CX_DEBUG(("CxeVideoCaptureControlSymbian - async stop failed, try sync.."));

            try {

                mVideoRecorder->stop(false);

                // stopping went ok

                emulateNormalStopping();

            } catch (const std::exception &e) {

                // Even synchronous stopping failed -> release resources.

                CX_DEBUG(("CxeVideoCaptureControlSymbian - sync stop failed, too!"));

                handleComposeFailed(qt_symbian_exception2Error(e));

            }

        }

    }

    CX_DEBUG_EXIT_FUNCTION();

}

/*!

* Callback when "Open" operation is complete.

*/

void CxeVideoCaptureControlSymbian::MvruoOpenComplete(TInt aError)

{

    CX_DEBUG_ENTER_FUNCTION();

    CX_DEBUG(("CxeVideoCaptureControlSymbian::MvruoOpenComplete, err=%d", aError));

    if (state() == Preparing) {

        if (!aError) {

            prepare();

        } else {