/*

* 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 <QTime>

#include <fbs.h>

#include <QPixmap>

#include <coemain.h>

#include <QStringList>

#include <AudioPreference.h>

#include "cxevideocapturecontrolsymbian.h"

#include "cxevideorecorderutilitysymbian.h"

#include "cxecameradevicecontrolsymbian.h"

#include "cxefilenamegeneratorsymbian.h"

#include "cxeerrormappingsymbian.h"

#include "cxeviewfindercontrol.h"

#include "cxestillimagesymbian.h"

#include "cxecameradevice.h"

#include "cxutils.h"

#include "cxesysutil.h"

#include "cxestate.h"

#include "cxesettings.h"

#include "cxenamespace.h"

#include "OstTraceDefinitions.h"

#include "cxesoundplayersymbian.h"

#include "cxequalitypresetssymbian.h"

#include "cxeviewfindercontrolsymbian.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "cxevideocapturecontrolsymbianTraces.h"

#endif

// constants

const TInt64  KMinRequiredSpaceVideo       = 4000000;

const uint    KOneMillion                 = 1000000;

const qreal   KMetaDataCoeff              = 1.03;      // Coefficient to estimate metadata amount

const uint    KCamCMaxClipDurationInSecs  = 5400;      // Maximun video clip duration in seconds

const qreal   KCMRAvgVideoBitRateScaler   = 0.9;       // avg video bit rate scaler

/*!

* CxeVideoCaptureControlSymbian::CxeVideoCaptureControlSymbian

*/

CxeVideoCaptureControlSymbian::CxeVideoCaptureControlSymbian(CxeCameraDevice &cameraDevice,

                                                             CxeViewfinderControl &viewfinderControl,

                                                             CxeCameraDeviceControl &cameraDeviceControl,

                                                             CxeFilenameGenerator &nameGenerator,

                                                             CxeSettings &settings,

                                                             CxeQualityPresets &qualityPresets) :

    CxeStateMachine("CxeVideoCaptureControlSymbian"),

    mVideoRecorder(NULL),

    mCameraDevice(cameraDevice),

    mCameraDeviceControl(cameraDeviceControl),

    mViewfinderControl(viewfinderControl),

    mFilenameGenerator(nameGenerator),

    mSettings(settings),

    mQualityPresets(qualityPresets),

    mSnapshot(),

    mNewFileName(""),

    mCurrentFilename("")

{

    CX_DEBUG_ENTER_FUNCTION();

    qRegisterMetaType<CxeVideoCaptureControl::State> ();

    initializeStates();

    mVideoStopSoundPlayer = new

             CxeSoundPlayerSymbian(CxeSoundPlayerSymbian::VideoCaptureStop);

    mVideoStartSoundPlayer = new

             CxeSoundPlayerSymbian(CxeSoundPlayerSymbian::VideoCaptureStart);

    // 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()));

    // enabling setting change callbacks to videocapturecontrol

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

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

    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();

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

    if(state() == Idle) {

        // nothing to do

        return;

    }

    // first stop viewfinder

    mViewfinderControl.stop();

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

    stop();

    if (mCameraDevice.cameraSnapshot()) {

        mCameraDevice.cameraSnapshot()->StopSnapshot();

    }

    if (mVideoRecorder) {

        mVideoRecorder->Close();

    }

    // revert back the new filename to empty string so that we generate a new file name

    // when we init again

    mNewFileName = QString("");

    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();

    if (state() != Idle) {

        // not valid state to start "open" operation

        return;

    }

    if(!mVideoRecorder) {

        // if video recorder is not created, do it now.

        createVideoRecorder();

    }

    // update current video quality details from icm

    CxeError::Id err = getVideoQualityDetails(mCurrentVideoDetails);

    if (!err) {

        // read videofile mime type

        QByteArray videoFileData =

                    mCurrentVideoDetails.mVideoFileMimeType.toLatin1();

        TPtrC8 videoFileMimeType(reinterpret_cast<const TUint8*>

                           (videoFileData.constData()), videoFileData.size());

        // read preferred supplier

        TPtrC16 supplier(reinterpret_cast<const TUint16*>

                           (mCurrentVideoDetails.mPreferredSupplier.utf16()));

        err = findVideoController(videoFileMimeType, supplier);

        if (!err) {

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

            setState(Initialized);

            open();

        }

    } else {

        err = CxeErrorHandlingSymbian::map(KErrNotReady);

    }

    if (err) {

        // In case of error

        emit videoPrepareComplete(err);

        deinit();

    }

    CX_DEBUG_EXIT_FUNCTION();

}

/*!

* Opens file for video recording.

*/

void CxeVideoCaptureControlSymbian::open()

{

    CX_DEBUG_ENTER_FUNCTION();

    if (state() != Initialized) {

        // not valid state to start "open" operation

        return;

    }

    CxeError::Id err = CxeError::None;

    // generate video file name, if necessary

    if (mNewFileName.isEmpty()) {

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

        QString fileExt(".");

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

            fileExt = fileExt + list[1];

        }

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

        err = mFilenameGenerator.generateFilename(mNewFileName, fileExt);

        if (err == CxeError::None) {

            mCurrentFilename = mNewFileName;

        } else {

            // file name is not valid, re-initialize the value of current string

            // back to empty string

            mCurrentFilename = QString("");

        }

    }

    if (!err &&

        mVideoRecorder &&

        !mCurrentFilename.isEmpty()) {

        TPtrC16 fName(reinterpret_cast<const TUint16*>(mCurrentFilename.utf16()));

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

        // read video codec mime type

        QByteArray videoCodecData =

                    mCurrentVideoDetails.mVideoCodecMimeType.toLatin1();

        TPtrC8 videoCodecMimeType(reinterpret_cast<const TUint8*>

                           (videoCodecData.constData()), videoCodecData.size());

        setState(CxeVideoCaptureControl::Preparing);

        TRAPD(openErr, mVideoRecorder->OpenFileL(fName,

                       mCameraDevice.camera()->Handle(),

                       mVideoControllerUid,

                       mVideoFormatUid,

                       videoCodecMimeType,

                       audioType(mCurrentVideoDetails.mAudioType)));

        err = CxeErrorHandlingSymbian::map(openErr);

    }

    if (err) {

        // error occured.

        deinit();

        emit videoPrepareComplete(err);

    }

    CX_DEBUG_EXIT_FUNCTION();

}

/*!

* Prepare Video Recorder with necessary settings for video capture.

*/

TFourCC CxeVideoCaptureControlSymbian::audioType(const QString& str)

{

    CX_DEBUG_ENTER_FUNCTION();

    QByteArray audioType = str.toAscii();

    quint8 char1(' ');

    quint8 char2(' ');

    quint8 char3(' ');

    quint8 char4(' ');

    if (audioType.count() > 3) {

        char1 = audioType[0];

        char2 = audioType[1];

        char3 = audioType[2];

        if (audioType.count() == 4) {

            char4 = audioType[3];

        }

    }

    return TFourCC(char1, char2, char3, char4);

}

/*!

* 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;

    }

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

                                           mCurrentVideoDetails.mHeight));

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

    CX_DEBUG(("Video frame rate = %f)", mCurrentVideoDetails.mVideoFrameRate));

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

    TSize frameSize;

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

    int muteSetting = 0; // audio enabled

    mSettings.get(CxeSettingIds::VIDEO_MUTE_SETTING, muteSetting);

    TRAPD(err,

              {

              mVideoRecorder->SetVideoFrameSizeL(frameSize);

              mVideoRecorder->SetVideoFrameRateL(mCurrentVideoDetails.mVideoFrameRate);

              mVideoRecorder->SetVideoBitRateL(mCurrentVideoDetails.mVideoBitRate);

              mVideoRecorder->SetAudioEnabledL(muteSetting == 0);

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

              mVideoRecorder->SetMaxClipSizeL(mCurrentVideoDetails.mMaximumSizeInBytes);

              }

         );

    if (!err) {

        // settings have been applied successfully, start to prepare

        mVideoRecorder->Prepare();

        // prepare snapshot

        err = prepareVideoSnapshot();

    }

    if (!err) {

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

        emit prepareZoomForVideo();

    }

    // emit video prepare status

    emit videoPrepareComplete(CxeErrorHandlingSymbian::map(err));

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

    CX_DEBUG_EXIT_FUNCTION();

}

/*!

Fetches video qualites details based on video quality setting.

Returns CxeError codes if any.

*/

CxeError::Id

CxeVideoCaptureControlSymbian::getVideoQualityDetails(CxeVideoDetails &videoInfo)

{

    CX_DEBUG_ENTER_FUNCTION();

    int videoQuality = 0;

    CxeError::Id err = CxeError::None;

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

        err = mSettings.get(CxeSettingIds::VIDEO_QUALITY, videoQuality);

        bool validQuality = (videoQuality >= 0 &&

                             videoQuality < mIcmSupportedVideoResolutions.count());

        if (err == CxeError::None && validQuality) {

            // get video quality details

            videoInfo = mIcmSupportedVideoResolutions.at(videoQuality);

        } else {

            // not valid video quality

            err = CxeError::NotFound;

        }

    } else {

        // get secondary camera video quality index

        if (mIcmSupportedVideoResolutions.count() > 0) {

            videoInfo = mIcmSupportedVideoResolutions.at(videoQuality);

        } else {

            // not valid video quality

            err = CxeError::NotFound;

        }

    }

    CX_DEBUG_EXIT_FUNCTION();

    return err;

}

/**!

 Prepare snapshot

 Returns symbian error code.

 */

int CxeVideoCaptureControlSymbian::prepareVideoSnapshot()

{

    CX_DEBUG_ENTER_FUNCTION();

    CCamera::CCameraSnapshot *cameraSnapshot = mCameraDevice.cameraSnapshot();

    CX_ASSERT_ALWAYS(cameraSnapshot);

    int err = KErrNone;

    // Whether or not we have postcapture on, we need the snapshot for Thumbnail Manager.

    if (cameraSnapshot) {

        // Cancel active snapshot

        cameraSnapshot->StopSnapshot();

        // Prepare snapshot

        CCamera::TFormat snapFormat = CCamera::EFormatFbsBitmapColor16MU;

        TRAP(err, cameraSnapshot->PrepareSnapshotL(snapFormat,

                                                   getSnapshotSize(),

                                                   KMaintainAspectRatio));

        CX_DEBUG(("PrepareSnapshotL done, err=%d", err));

        // Start snapshot if no errors encountered.

        if (err == KErrNone) {

            CX_DEBUG(("Start video snapshot"));

            cameraSnapshot->StartSnapshot();

        }

    } else {

        // No snapshot interface available. Report error.

        // Assert above takes care of this, but keeping this as an option.

        err = KErrNotReady;

    }

    CX_DEBUG_EXIT_FUNCTION();

    return err;

}

/*!

* Returns snapshot size. Snapshot size is calculated based on the

* display resolution and current video aspect ratio.

*/

TSize CxeVideoCaptureControlSymbian::getSnapshotSize() const

{

    CX_DEBUG_ENTER_FUNCTION();

    TSize snapshotSize;

    QSize deviceResolution = mViewfinderControl.deviceDisplayResolution();

    QSize size = QSize(mCurrentVideoDetails.mWidth, mCurrentVideoDetails.mHeight);

    // scale according to aspect ratio.

    size.scale(deviceResolution.width(),

               deviceResolution.height(),

               Qt::KeepAspectRatio);

    CX_DEBUG(("Video Snapshot size, (%d,%d)", size.width(), size.height()));

    snapshotSize.SetSize(size.width(), deviceResolution.height());

    CX_DEBUG_EXIT_FUNCTION();

    return snapshotSize;

}

/**!

* Camera events coming from ecam.

*/

void CxeVideoCaptureControlSymbian::handleCameraEvent(int eventUid, int error)

{

    CX_DEBUG_ENTER_FUNCTION();

    if (eventUid == KUidECamEventSnapshotUidValue) {

        handleSnapshotEvent(CxeErrorHandlingSymbian::map(error));

    }

    CX_DEBUG_EXIT_FUNCTION();

}

/*!

* Handle Snapshot event from ecam

*/

void CxeVideoCaptureControlSymbian::handleSnapshotEvent(CxeError::Id error)

{

    CX_DEBUG_ENTER_FUNCTION();

    if (state() == Idle) {

        // we ignore this event, when we are not in active state(s)

        CX_DEBUG(( "wrong state, ignoring snapshot" ));

        CX_DEBUG_EXIT_FUNCTION();

        return;

    }

    if (error) {

        mSnapshot = QPixmap();

        emit snapshotReady(error, mSnapshot, filename());

        return;

    }

    RArray<TInt> snapList;

    MCameraBuffer* buffer(NULL);

    // Note: Cleanup not required in this function

    CFbsBitmap *snapshot = NULL;

    TRAPD(snapErr,

          buffer = &mCameraDevice.cameraSnapshot()->SnapshotDataL(snapList));