/*  This file is part of the KDE project.

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

This library is free software: you can redistribute it and/or modify

it under the terms of the GNU Lesser General Public License as published by

the Free Software Foundation, either version 2.1 or 3 of the License.

This library is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License

along with this library.  If not, see <http://www.gnu.org/licenses/>.

*/

#include <coecntrl.h> // for CCoeControl

#include <QApplication>    // for QApplication::activeWindow

#include <QtCore/private/qcore_symbian_p.h> // for qt_TRect2QRect

#include "utils.h"

#include "videooutput_dsa.h"

#include "videoplayer_dsa.h"

QT_BEGIN_NAMESPACE

using namespace Phonon;

using namespace Phonon::MMF;

// Two-phase constructor idiom is used because construct() calls virtual

// functions and therefore cannot be called from the AbstractVideoPlayer

// C++ constructor.

DsaVideoPlayer* DsaVideoPlayer::create(MediaObject *parent,

                                       const AbstractPlayer *player)

{

    QScopedPointer<DsaVideoPlayer> self(new DsaVideoPlayer(parent, player));

    self->construct();

    return self.take();

}

DsaVideoPlayer::DsaVideoPlayer(MediaObject *parent, const AbstractPlayer *player)

    :   AbstractVideoPlayer(parent, player)

    ,   m_dsaActive(false)

    ,   m_dsaWasActive(false)

{

}

DsaVideoPlayer::~DsaVideoPlayer()

{

}

//-----------------------------------------------------------------------------

// Public functions

//-----------------------------------------------------------------------------

void MMF::DsaVideoPlayer::videoWindowScreenRectChanged()

{

    Q_ASSERT(m_videoOutput);

    QRect windowRect = static_cast<DsaVideoOutput *>(m_videoOutput)->videoWindowScreenRect();

    // Clip to physical window size

    // This is due to a defect in the layout when running on S60 3.2, which

    // results in the rectangle of the video widget extending outside the

    // screen in certain circumstances.  These include the initial startup

    // of the mediaplayer demo in portrait mode.  When this rectangle is

    // passed to the CVideoPlayerUtility, no video is rendered.

    const TSize screenSize = m_screenDevice.SizeInPixels();

    const QRect screenRect(0, 0, screenSize.iWidth, screenSize.iHeight);

    windowRect = windowRect.intersected(screenRect);

    // Recalculate scale factors.  Pass 'false' as second parameter in order to

    // suppress application of the change to the player - this is done at the end

    // of the function.

    updateScaleFactors(windowRect.size(), false);

    m_videoScreenRect = qt_QRect2TRect(windowRect);

    parametersChanged(WindowScreenRect | ScaleFactors);

}

void MMF::DsaVideoPlayer::suspendDirectScreenAccess()

{

    m_dsaWasActive = stopDirectScreenAccess();

}

void MMF::DsaVideoPlayer::resumeDirectScreenAccess()

{

    if (m_dsaWasActive) {

        startDirectScreenAccess();

        m_dsaWasActive = false;

    }

}

//-----------------------------------------------------------------------------

// Private functions

//-----------------------------------------------------------------------------

void MMF::DsaVideoPlayer::createPlayer()

{

    // A window handle must be provided in order to construct

    // CVideoPlayerUtility.  If no VideoOutput has yet been connected to this

    // player, we temporarily use the top-level application window handle.

    // No video ever gets rendered into this window; SetDisplayWindowL is

    // always called before rendering actually begins.

    if (!m_window)

        m_window = QApplication::activeWindow()->effectiveWinId()->DrawableWindow();

    const TInt priority = 0;

    const TMdaPriorityPreference preference = EMdaPriorityPreferenceNone;

    CVideoPlayerUtility *player = 0;

    QT_TRAP_THROWING(player = CVideoPlayerUtility::NewL(*this,

                                     priority, preference,

                                     m_wsSession, m_screenDevice,

                                     *m_window,

                                     m_videoScreenRect, m_videoScreenRect));

    m_player.reset(player);

    // CVideoPlayerUtility::NewL starts DSA

    m_dsaActive = true;

}

void MMF::DsaVideoPlayer::initVideoOutput()

{

    Q_ASSERT(m_videoOutput);

    bool connected = connect(

        m_videoOutput, SIGNAL(videoWindowScreenRectChanged()),

        this, SLOT(videoWindowScreenRectChanged())

    );

    Q_ASSERT(connected);

    connected = connect(

        m_videoOutput, SIGNAL(beginVideoWindowNativePaint()),

        this, SLOT(suspendDirectScreenAccess())

    );

    Q_ASSERT(connected);

    connected = connect(

        m_videoOutput, SIGNAL(endVideoWindowNativePaint()),

        this, SLOT(resumeDirectScreenAccess())

    );

    Q_ASSERT(connected);

    // Suppress warnings in release builds

    Q_UNUSED(connected);

    AbstractVideoPlayer::initVideoOutput();

}

void MMF::DsaVideoPlayer::prepareCompleted()

{

    if (m_videoOutput)

        videoWindowScreenRectChanged();

}

void MMF::DsaVideoPlayer::handleVideoWindowChanged()

{

    if (!m_window) {

        if (QWidget *window = QApplication::activeWindow())

            m_window = window->effectiveWinId()->DrawableWindow();

        else

            m_window = 0;

        m_videoScreenRect = TRect();

    }

    parametersChanged(WindowHandle | WindowScreenRect);

}

#ifndef QT_NO_DEBUG

// The following code is for debugging problems related to video visibility.  It allows

// the VideoPlayer instance to query the window server in order to determine the

// DSA drawing region for the video window.

class CDummyAO : public CActive

{

public:

    CDummyAO() : CActive(CActive::EPriorityStandard) { CActiveScheduler::Add(this); }

    void RunL() { }

    void DoCancel() { }

    TRequestStatus& Status() { return iStatus; }

    void SetActive() { CActive::SetActive(); }

};

void getDsaRegion(RWsSession &session, const RWindowBase &window)

{

    // Dump complete window tree

    session.LogCommand(RWsSession::ELoggingStatusDump);

    RDirectScreenAccess dsa(session);

    TInt err = dsa.Construct();

    CDummyAO ao;

    RRegion* region;

    err = dsa.Request(region, ao.Status(), window);

    ao.SetActive();

    dsa.Close();

    ao.Cancel();

    if (region) {

        qDebug() << "Phonon::MMF::getDsaRegion count" << region->Count();

        for (int i=0; i<region->Count(); ++i) {

            const TRect& rect = region->RectangleList()[i];

            qDebug() << "Phonon::MMF::getDsaRegion rect"

                << rect.iTl.iX << rect.iTl.iY << rect.iBr.iX << rect.iBr.iY;

        }

        region->Close();

    }

}

#endif // QT_NO_DEBUG

void MMF::DsaVideoPlayer::handleParametersChanged(VideoParameters parameters)

{

    TRACE_CONTEXT(DsaVideoPlayer::handleParametersChanged, EVideoInternal);

    TRACE_ENTRY("parameters 0x%x", parameters.operator int());

    if (!m_window)

        return;

#ifndef QT_NO_DEBUG

    getDsaRegion(m_wsSession, *m_window);

#endif

    if (m_player) {

        static const TBool antialias = ETrue;

        int err = KErrNone;

        if (parameters & ScaleFactors) {

            TRAP(err, m_player->SetScaleFactorL(m_scaleWidth, m_scaleHeight,

                                                antialias));

            if(KErrNone != err) {

                TRACE("SetScaleFactorL (1) err %d", err);

                setError(tr("Video display error"), err);

            }

        }

        if (KErrNone == err) {

            if (parameters & WindowHandle || parameters & WindowScreenRect) {

                TRAP(err,

                    m_player->SetDisplayWindowL(m_wsSession, m_screenDevice,

                                                *m_window,

                                                m_videoScreenRect,

                                                m_videoScreenRect));

            }

            if (KErrNone != err) {

                TRACE("SetDisplayWindowL err %d", err);

                setError(tr("Video display error"), err);

            } else {

                m_dsaActive = true;

                if (parameters & ScaleFactors) {

                    TRAP(err, m_player->SetScaleFactorL(m_scaleWidth, m_scaleHeight,

                                                        antialias));

                    if (KErrNone != err) {

                        TRACE("SetScaleFactorL (2) err %d", err);

                        setError(tr("Video display error"), err);

                    }

                }

            }

        }

    }

    TRACE_EXIT_0();

}

void MMF::DsaVideoPlayer::startDirectScreenAccess()

{

    TRACE_CONTEXT(DsaVideoPlayer::startDirectScreenAccess, EVideoInternal);

    TRACE_ENTRY("dsaActive %d", m_dsaActive);

    int err = KErrNone;

    if (!m_dsaActive) {

        TRAP(err, m_player->StartDirectScreenAccessL());

        if (KErrNone == err)

            m_dsaActive = true;

        else

            setError(tr("Video display error"), err);

    }

    if (m_videoOutput)

        m_videoOutput->dump();

    TRACE_EXIT("error %d", err);

}

bool MMF::DsaVideoPlayer::stopDirectScreenAccess()

{

    TRACE_CONTEXT(DsaVideoPlayer::stopDirectScreenAccess, EVideoInternal);

    TRACE_ENTRY("dsaActive %d", m_dsaActive);

    int err = KErrNone;

    const bool dsaWasActive = m_dsaActive;

    if (m_dsaActive) {

        TRAP(err, m_player->StopDirectScreenAccessL());

        if (KErrNone == err)

            m_dsaActive = false;

        else

            setError(tr("Video display error"), err);

    }

    TRACE_EXIT("error %d", err);

    return dsaWasActive;

}

QT_END_NAMESPACE