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

    const QSize ASPECT_RATIO_SIZE_4BY3  = QSize(4,3);
    const QSize ASPECT_RATIO_SIZE_16BY9 = QSize(16, 9);
    const QSize ASPECT_RATIO_SIZE_11BY9 = QSize(11, 9);

#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 Cxe::AspectRatio Aspect ratio of image/video resolution.
* @return Proposed best snapshot size.
*/

QSize CxeSnapshotControlPrivate::calculateSnapshotSize(const QSize& displaySize, Cxe::AspectRatio aspectRatio) const
{
    CX_DEBUG_ENTER_FUNCTION();
    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;
    
    if (aspectRatio == Cxe::AspectRatio4to3) {
        size = ASPECT_RATIO_SIZE_4BY3;
    } else if (aspectRatio == Cxe::AspectRatio16to9) {
        size = ASPECT_RATIO_SIZE_16BY9;
    } else if (aspectRatio == Cxe::AspectRatio11to9) {
        size = ASPECT_RATIO_SIZE_11BY9;
    }
    size.scale(displaySize, Qt::KeepAspectRatio);

    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 QImage containing the snapshot.
*/
QImage CxeSnapshotControlPrivate::snapshot()
{
    CX_DEBUG_ENTER_FUNCTION();
    QImage image;

    #ifdef Q_OS_SYMBIAN

        CFbsBitmap *snapshot = NULL;
        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));
            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 ));

            CX_DEBUG(("Creating QImage"));
            image = QImage(size.iWidth, size.iHeight, QImage::Format_RGB32);

            // Convert to QImage
            snapshot->LockHeap();
            const uchar *dataPtr = (const uchar*) snapshot->DataAddress();
            uchar *dst = image.bits();
            memcpy(dst, dataPtr, image.numBytes());
            snapshot->UnlockHeap();

        });
        // We throw error with the Symbian error code if there was problems.
        CxeException::throwIfError(status);


    #endif // Q_OS_SYMBIAN

        CX_DEBUG_EXIT_FUNCTION();
        return image;
}

/*!
* 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) {
            QImage 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