/*

* Copyright (c) 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 <QSize>

#include <QPixmap>

// Note: Keep atleast one Qt include before preprocessor flags

#ifdef Q_OS_SYMBIAN

#include <e32base.h>

#include <fbs.h>

#include <ecam.h>

#include <ecam/camerasnapshot.h>

#endif // Q_OS_SYMBIAN

#include "cxutils.h"

#include "cxeerror.h"

#include "cxeexception.h"

#include "cxeerrormappingsymbian.h"

#include "cxecameradevice.h"

#include "cxestate.h"

#include "cxesnapshotcontrol.h"

#include "cxesnapshotcontrolprivate.h"

namespace

{

    const int MAINTAIN_ASPECT = false;

#ifdef Q_OS_SYMBIAN

    /*!

    * Helper class for cleaning up MCameraBuffer instances.

    */

    class CxeCameraBufferCleanup

    {

    public:

        explicit CxeCameraBufferCleanup(MCameraBuffer *buffer)

            : mBuffer(buffer)

        {

        }

        ~CxeCameraBufferCleanup()

        {

            if (mBuffer) {

                CX_DEBUG(("CxeCameraBufferCleanup - releasing MCameraBuffer.."));

                mBuffer->Release();

                mBuffer = NULL;

            }

        }

    private:

        Q_DISABLE_COPY(CxeCameraBufferCleanup)

        MCameraBuffer *mBuffer;

    };

#endif // Q_OS_SYMBIAN

}

/*!

* Constructor.

* @param parent Public interface of Snapshot control.

* @param device Camera device interface, used for getting hold of adaptation snapshot API.

*/

CxeSnapshotControlPrivate::CxeSnapshotControlPrivate(CxeSnapshotControl *parent,

                                                     CxeCameraDevice& device)

    : CxeStateMachine("CxeSnapshotControlPrivate"),

      q(parent),

      mDevice(device)

{

    CX_DEBUG_ENTER_FUNCTION();

    CX_ASSERT_ALWAYS(q);

    initializeStates();

    CX_DEBUG_EXIT_FUNCTION();

}

/*!

* Destructor.

*/

CxeSnapshotControlPrivate::~CxeSnapshotControlPrivate()

{

    CX_DEBUG_ENTER_FUNCTION();

    stop();

    CX_DEBUG_EXIT_FUNCTION();

}

/*!

* Called when state changes.

* @param newStateId Id of the new state.

* @param error Error code or CxeError::None in successful case.

*/

void CxeSnapshotControlPrivate::handleStateChanged(int newStateId, CxeError::Id error)

{

    emit q->stateChanged(static_cast<CxeSnapshotControl::State>(newStateId), error);

}

/*!

* Get the state of Snapshot Control.

* @return The current state.

*/

CxeSnapshotControl::State CxeSnapshotControlPrivate::state() const

{

    return static_cast<CxeSnapshotControl::State> (stateId());

}

/*!

* Initialize Snapshot Control states

*/

void CxeSnapshotControlPrivate::initializeStates()

{

    CX_DEBUG_ENTER_FUNCTION();

    // addState( id, name, allowed next states )

    addState(new CxeState(CxeSnapshotControl::Idle, "Idle", CxeSnapshotControl::Active));

    addState(new CxeState(CxeSnapshotControl::Active, "Active", CxeSnapshotControl::Idle));

    setInitialState(CxeSnapshotControl::Idle);

    CX_DEBUG_EXIT_FUNCTION();

}

/*!

* Calculate snapshot size based on diplay size and image / video output resolution.

* @param displaySize Display size in pixels.

* @param outputResolution Resolution of the output image / video in pixels.

* @return Proposed best snapshot size.

*/

QSize CxeSnapshotControlPrivate::calculateSnapshotSize(const QSize &displaySize, const QSize &outputResolution) const

{

    CX_DEBUG_ENTER_FUNCTION();

    CX_DEBUG(("CxeSnapshotControlPrivate - output resolution (%d,%d)", outputResolution.width(), outputResolution.height()));

    CX_DEBUG(("CxeSnapshotControlPrivate - display size      (%d,%d)", displaySize.width(), displaySize.height()));

    // Take resolution as reference for aspect ratio.

    // Scale keeping aspect ratio to just fit display.

    QSize size(outputResolution);

    size.scale(displaySize, Qt::KeepAspectRatio);

    CX_DEBUG(("CxeSnapshotControlPrivate - calculated size, (%d,%d)", size.width(), size.height()));

    size.setHeight(displaySize.height());

    CX_DEBUG(("CxeSnapshotControlPrivate - adjusted final size, (%d,%d)", size.width(), size.height()));

    CX_DEBUG_EXIT_FUNCTION();

    return size;

}

/*!

* Start getting snapshots from camera.

* Throws CxeException with CxeError::Id if error encountered.

* @param size Size of the snapshot in pixels.

*/

void CxeSnapshotControlPrivate::start(const QSize &size)

{

    CX_DEBUG_ENTER_FUNCTION();

#ifdef Q_OS_SYMBIAN

    CCamera::CCameraSnapshot *ss = mDevice.cameraSnapshot();

    CX_ASSERT_ALWAYS(ss);

    if (ss->IsSnapshotActive()) {

        CX_DEBUG(("Stop currently active snapshot.."));

        ss->StopSnapshot();

    }

    // Prepare snapshot

    CCamera::TFormat snapFormat = CCamera::EFormatFbsBitmapColor16MU;

    TSize snapSize = TSize(size.width(), size.height());

    CX_DEBUG(("Prepare snapshot, size (%d x %d)..", size.width(), size.height()));

    TRAPD(status, ss->PrepareSnapshotL(snapFormat, snapSize, MAINTAIN_ASPECT));

    CxeException::throwIfError(CxeErrorHandlingSymbian::map(status));

    CX_DEBUG(("After prepare ECAM modified size to (%d x %d)..", size.width(), size.height()));

    CX_DEBUG(("Start snapshot.."));

    ss->StartSnapshot();

#else

    Q_UNUSED(size);

#endif // Q_OS_SYMBIAN

    setState(CxeSnapshotControl::Active);

    CX_DEBUG_EXIT_FUNCTION();

}

/*!

* Stop getting snapshots from camera.

*/

void CxeSnapshotControlPrivate::stop()

{

    CX_DEBUG_ENTER_FUNCTION();

#ifdef Q_OS_SYMBIAN

    if (mDevice.cameraSnapshot()) {

        mDevice.cameraSnapshot()->StopSnapshot();

    }

#endif // Q_OS_SYMBIAN

    setState(CxeSnapshotControl::Idle);

    CX_DEBUG_EXIT_FUNCTION();

}

/*!

* Helper method for getting the snapshot.

* Throws exception if fetching the snapshot fails.

* @return QPixmap containing the snapshot.

*/

QPixmap CxeSnapshotControlPrivate::snapshot()

{

    CX_DEBUG_ENTER_FUNCTION();

    QPixmap pixmap;

#ifdef Q_OS_SYMBIAN

    TRAPD(status, {

        RArray<TInt> frameIndex;

        CleanupClosePushL(frameIndex);

        MCameraBuffer &buffer(mDevice.cameraSnapshot()->SnapshotDataL(frameIndex));

        // Make sure buffer is released on leave / exception.

        // Buffer is released once the cleanup item goes out of scope.

        CxeCameraBufferCleanup cleaner(&buffer);

        TInt firstImageIndex(frameIndex.Find(0));

        CFbsBitmap &snapshot(buffer.BitmapL(firstImageIndex));

        CleanupStack::PopAndDestroy(); // frameIndex

        TSize size = snapshot.SizeInPixels();

        TInt sizeInWords = size.iHeight * CFbsBitmap::ScanLineLength(size.iWidth, EColor16MU) / sizeof(TUint32);

        CX_DEBUG(("size %d x %d, sizeInWords = %d", size.iWidth, size.iHeight, sizeInWords ));

        TUint32 *pixelData = new (ELeave) TUint32[ sizeInWords ];

        // Convert to QImage

        snapshot.LockHeap();

        TUint32 *dataPtr = snapshot.DataAddress();

        memcpy(pixelData, dataPtr, sizeof(TUint32)*sizeInWords);

        snapshot.UnlockHeap();

        CX_DEBUG(("Creating QImage"));

        QImage *snapImage = new QImage((uchar*)pixelData, size.iWidth, size.iHeight,

                                       CFbsBitmap::ScanLineLength(size.iWidth, EColor16MU),

                                       QImage::Format_RGB32);

        pixmap = QPixmap::fromImage(*snapImage);

        delete [] pixelData;

        delete snapImage;

    });

    // We throw error with the Symbian error code if there was problems.

    CxeException::throwIfError(status);

#endif // Q_OS_SYMBIAN

    CX_DEBUG_EXIT_FUNCTION();

    return pixmap;

}

/*!

* Handle camera snapshot events.

* @param id Event uid.

* @param error Status code of the event.

*/

void CxeSnapshotControlPrivate::handleCameraEvent(int id, int error)

{

    CX_DEBUG_ENTER_FUNCTION();

    // Ignoring all events if not active.

    if (state() == CxeSnapshotControl::Active) {

#ifdef Q_OS_SYMBIAN

        if (id == KUidECamEventSnapshotUidValue) {

            QPixmap ss;

            if (!error) {

                try {

                    ss = snapshot();

                } catch (const CxeException& e) {

                    // Note: Normally CxeException carries CxeError::Id,

                    // but we intentionally use Symbian code in getSnapshot

                    // as it's easier to handle here.

                    error = e.error();

                } catch (...) {

                    error = KErrGeneral;

                }

            }

            // Emit snapshot ready signal through the public interface.

            emit q->snapshotReady(CxeErrorHandlingSymbian::map(error), ss);

        }

#else

        Q_UNUSED(id)

        Q_UNUSED(error)

#endif // Q_OS_SYMBIAN

    }

    CX_DEBUG_EXIT_FUNCTION();

}

// end of file