/****************************************************************************

**

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

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the Qt Mobility Components.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 2.1 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL included in the

** packaging of this file.  Please review the following information to

** ensure the GNU Lesser General Public License version 2.1 requirements

** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

#include <QtCore/qpointer.h>

#include <QtCore/qdatetime.h>

#include <QtCore/qbasictimer.h>

#include <QtCore/qcoreevent.h>

#include <QtGui/qgraphicsscene.h>

#include <QtGui/qgraphicsview.h>

#include <QtGui/qscrollbar.h>

#include <QtGui/qx11info_x11.h>

#include "qgraphicsvideoitem.h"

#include <qmediaobject.h>

#include <qmediaservice.h>

#include <qpaintervideosurface_p.h>

#include <qvideorenderercontrol.h>

#include <qvideosurfaceformat.h>

#include "qxvideosurface_maemo5_p.h"

QT_BEGIN_NAMESPACE

//update overlay geometry slightly later,

//to ensure color key is alredy replaced with static frame

#define GEOMETRY_UPDATE_DELAY 20

//this is necessary to prevent flickering, see maemo bug 8798

//on geometry changes, the color key is replaced with static image frame

//until the overlay is re-initialized

#define SOFTWARE_RENDERING_DURATION 150

#ifdef  __ARM_NEON__

/*

* ARM NEON optimized implementation of UYVY -> RGB16 convertor

*/

static void uyvy422_to_rgb16_line_neon (uint8_t * dst, const uint8_t * src, int n)

{

     /* and this is the NEON code itself */

     static __attribute__ ((aligned (16))) uint16_t acc_r[8] = {

       22840, 22840, 22840, 22840, 22840, 22840, 22840, 22840,

     };

     static __attribute__ ((aligned (16))) uint16_t acc_g[8] = {

       17312, 17312, 17312, 17312, 17312, 17312, 17312, 17312,

     };

     static __attribute__ ((aligned (16))) uint16_t acc_b[8] = {

       28832, 28832, 28832, 28832, 28832, 28832, 28832, 28832,

     };

     /*

      * Registers:

      * q0, q1 : d0, d1, d2, d3  - are used for initial loading of YUV data

      * q2     : d4, d5          - are used for storing converted RGB data

      * q3     : d6, d7          - are used for temporary storage

      *

      * q6     : d12, d13        - are used for converting to RGB16

      * q7     : d14, d15        - are used for storing RGB16 data

      * q4-q5 - reserved

      *

      * q8, q9 : d16, d17, d18, d19  - are used for expanded Y data

      * q10    : d20, d21

      * q11    : d22, d23

      * q12    : d24, d25

      * q13    : d26, d27

      * q13, q14, q15            - various constants (#16, #149, #204, #50, #104, #154)

      */

     asm volatile (".macro convert_macroblock size\n"

         /* load up to 16 source pixels in UYVY format */

         ".if \\size == 16\n"

         "pld [%[src], #128]\n"

         "vld1.32 {d0, d1, d2, d3}, [%[src]]!\n"

         ".elseif \\size == 8\n"

         "vld1.32 {d0, d1}, [%[src]]!\n"

         ".elseif \\size == 4\n"

         "vld1.32 {d0}, [%[src]]!\n"

         ".elseif \\size == 2\n"

         "vld1.32 {d0[0]}, [%[src]]!\n"

         ".else\n" ".error \"unsupported macroblock size\"\n" ".endif\n"

         /* convert from 'packed' to 'planar' representation */

         "vuzp.8      d0, d1\n"    /* d1 - separated Y data (first 8 bytes) */

         "vuzp.8      d2, d3\n"    /* d3 - separated Y data (next 8 bytes) */

         "vuzp.8      d0, d2\n"    /* d0 - separated U data, d2 - separated V data */

         /* split even and odd Y color components */

         "vuzp.8      d1, d3\n"    /* d1 - evenY, d3 - oddY */

         /* clip upper and lower boundaries */

         "vqadd.u8    q0, q0, q4\n"

         "vqadd.u8    q1, q1, q4\n"

         "vqsub.u8    q0, q0, q5\n"

         "vqsub.u8    q1, q1, q5\n"

         "vshr.u8     d4, d2, #1\n"    /* d4 = V >> 1 */

         "vmull.u8    q8, d1, d27\n"       /* q8 = evenY * 149 */

         "vmull.u8    q9, d3, d27\n"       /* q9 = oddY * 149 */

         "vld1.16     {d20, d21}, [%[acc_r], :128]\n"      /* q10 - initialize accumulator for red */

         "vsubw.u8    q10, q10, d4\n"      /* red acc -= (V >> 1) */

         "vmlsl.u8    q10, d2, d28\n"      /* red acc -= V * 204 */

         "vld1.16     {d22, d23}, [%[acc_g], :128]\n"      /* q11 - initialize accumulator for green */

         "vmlsl.u8    q11, d2, d30\n"      /* green acc -= V * 104 */

         "vmlsl.u8    q11, d0, d29\n"      /* green acc -= U * 50 */

         "vld1.16     {d24, d25}, [%[acc_b], :128]\n"      /* q12 - initialize accumulator for blue */

         "vmlsl.u8    q12, d0, d30\n"      /* blue acc -= U * 104 */

         "vmlsl.u8    q12, d0, d31\n"      /* blue acc -= U * 154 */

         "vhsub.s16   q3, q8, q10\n"       /* calculate even red components */

         "vhsub.s16   q10, q9, q10\n"      /* calculate odd red components */

         "vqshrun.s16 d0, q3, #6\n"        /* right shift, narrow and saturate even red components */

         "vqshrun.s16 d3, q10, #6\n"       /* right shift, narrow and saturate odd red components */

         "vhadd.s16   q3, q8, q11\n"       /* calculate even green components */

         "vhadd.s16   q11, q9, q11\n"      /* calculate odd green components */

         "vqshrun.s16 d1, q3, #6\n"        /* right shift, narrow and saturate even green components */

         "vqshrun.s16 d4, q11, #6\n"       /* right shift, narrow and saturate odd green components */

         "vhsub.s16   q3, q8, q12\n"       /* calculate even blue components */

         "vhsub.s16   q12, q9, q12\n"      /* calculate odd blue components */

         "vqshrun.s16 d2, q3, #6\n"        /* right shift, narrow and saturate even blue components */

         "vqshrun.s16 d5, q12, #6\n"       /* right shift, narrow and saturate odd blue components */

         "vzip.8      d0, d3\n"    /* join even and odd red components */

         "vzip.8      d1, d4\n"    /* join even and odd green components */

         "vzip.8      d2, d5\n"    /* join even and odd blue components */

         "vshll.u8     q7, d0, #8\n" //red

         "vshll.u8     q6, d1, #8\n" //greed

         "vsri.u16   q7, q6, #5\n"

         "vshll.u8     q6, d2, #8\n" //blue

         "vsri.u16   q7, q6, #11\n" //now there is rgb16 in q7

         ".if \\size == 16\n"

         "vst1.16 {d14, d15}, [%[dst]]!\n"

         //"vst3.8  {d0, d1, d2}, [%[dst]]!\n"

         "vshll.u8     q7, d3, #8\n" //red

         "vshll.u8     q6, d4, #8\n" //greed

         "vsri.u16   q7, q6, #5\n"

         "vshll.u8     q6, d5, #8\n" //blue

         "vsri.u16   q7, q6, #11\n" //now there is rgb16 in q7

         //"vst3.8  {d3, d4, d5}, [%[dst]]!\n"

         "vst1.16 {d14, d15}, [%[dst]]!\n"

         ".elseif \\size == 8\n"

         "vst1.16 {d14, d15}, [%[dst]]!\n"

         //"vst3.8  {d0, d1, d2}, [%[dst]]!\n"

         ".elseif \\size == 4\n"

         "vst1.8 {d14}, [%[dst]]!\n"

         ".elseif \\size == 2\n"

         "vst1.8 {d14[0]}, [%[dst]]!\n"

         "vst1.8 {d14[1]}, [%[dst]]!\n"

         ".else\n"

         ".error \"unsupported macroblock size\"\n"

         ".endif\n"

         ".endm\n"

         "vmov.u8     d8, #15\n"  /* add this to U/V to saturate upper boundary */

         "vmov.u8     d9, #20\n"   /* add this to Y to saturate upper boundary */

         "vmov.u8     d10, #31\n"  /* sub this from U/V to saturate lower boundary */

         "vmov.u8     d11, #36\n"  /* sub this from Y to saturate lower boundary */

         "vmov.u8     d26, #16\n"

         "vmov.u8     d27, #149\n"

         "vmov.u8     d28, #204\n"

         "vmov.u8     d29, #50\n"

         "vmov.u8     d30, #104\n"

         "vmov.u8     d31, #154\n"

         "subs        %[n], %[n], #16\n"

         "blt         2f\n"

         "1:\n"

         "convert_macroblock 16\n"

         "subs        %[n], %[n], #16\n"

         "bge         1b\n"

         "2:\n"

         "tst         %[n], #8\n"

         "beq         3f\n"

         "convert_macroblock 8\n"

         "3:\n"

         "tst         %[n], #4\n"

         "beq         4f\n"

         "convert_macroblock 4\n"

         "4:\n"

         "tst         %[n], #2\n"

         "beq         5f\n"

         "convert_macroblock 2\n"

         "5:\n"

         ".purgem convert_macroblock\n":[src] "+&r" (src),[dst] "+&r" (dst),

         [n] "+&r" (n)

         :[acc_r] "r" (&acc_r[0]),[acc_g] "r" (&acc_g[0]),[acc_b] "r" (&acc_b[0])

         :"cc", "memory", "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7", "d8", "d9", "d10", "d11", "d12", "d13", "d14", "d15",

         "d16", "d17", "d18", "d19", "d20", "d21", "d22", "d23",

         "d24", "d25", "d26", "d27", "d28", "d29", "d30", "d31");

}

#endif

class QGraphicsVideoItemPrivate

{

public:

    QGraphicsVideoItemPrivate()

        : q_ptr(0)

        , surface(0)

        , mediaObject(0)

        , service(0)

        , rendererControl(0)

        , savedViewportUpdateMode(QGraphicsView::FullViewportUpdate)

        , aspectRatioMode(Qt::KeepAspectRatio)

        , rect(0.0, 0.0, 320, 240)

        , softwareRenderingEnabled(false)

    {

    }

    QGraphicsVideoItem *q_ptr;

    QXVideoSurface *surface;

    QMediaObject *mediaObject;

    QMediaService *service;

    QVideoRendererControl *rendererControl;

    QPointer<QGraphicsView> currentView;

    QGraphicsView::ViewportUpdateMode savedViewportUpdateMode;

    Qt::AspectRatioMode aspectRatioMode;

    QRectF rect;

    QRectF boundingRect;

    QRectF sourceRect;

    QSizeF nativeSize;

    QPixmap lastFrame;

    QBasicTimer softwareRenderingTimer;

    QBasicTimer geometryUpdateTimer;

    bool softwareRenderingEnabled;

    QRect overlayRect;

    void clearService();

    void updateRects();

    void updateLastFrame();

    void _q_present();

    void _q_formatChanged(const QVideoSurfaceFormat &format);

    void _q_serviceDestroyed();

    void _q_mediaObjectDestroyed();

};

void QGraphicsVideoItemPrivate::clearService()

{

    if (rendererControl) {

        surface->stop();

        rendererControl->setSurface(0);

        service->releaseControl(rendererControl);

        rendererControl = 0;

    }

    if (service) {

        QObject::disconnect(service, SIGNAL(destroyed()), q_ptr, SLOT(_q_serviceDestroyed()));

        service = 0;

    }

}

void QGraphicsVideoItemPrivate::updateRects()

{

    q_ptr->prepareGeometryChange();

    if (nativeSize.isEmpty()) {

        boundingRect = QRectF();

    } else if (aspectRatioMode == Qt::IgnoreAspectRatio) {

        boundingRect = rect;

        sourceRect = QRectF(0, 0, 1, 1);

    } else if (aspectRatioMode == Qt::KeepAspectRatio) {

        QSizeF size = nativeSize;

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

        boundingRect = QRectF(0, 0, size.width(), size.height());

        boundingRect.moveCenter(rect.center());

        sourceRect = QRectF(0, 0, 1, 1);

    } else if (aspectRatioMode == Qt::KeepAspectRatioByExpanding) {

        boundingRect = rect;

        QSizeF size = rect.size();

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

        sourceRect = QRectF(

                0, 0, size.width() / nativeSize.width(), size.height() / nativeSize.height());

        sourceRect.moveCenter(QPointF(0.5, 0.5));

    }

}

void QGraphicsVideoItemPrivate::updateLastFrame()

{

    lastFrame = QPixmap();

    if (!softwareRenderingEnabled)

        return;

    QVideoFrame lastVideoFrame = surface->lastFrame();

    if (!lastVideoFrame.isValid())

        return;

    if (lastVideoFrame.map(QAbstractVideoBuffer::ReadOnly)) {

#ifdef  __ARM_NEON__

        if (lastVideoFrame.pixelFormat() == QVideoFrame::Format_UYVY) {

            QImage lastImage(lastVideoFrame.size(), QImage::Format_RGB16);

            const uchar *src = lastVideoFrame.bits();

            uchar *dst = lastImage.bits();

            const int srcLineStep = lastVideoFrame.bytesPerLine();

            const int dstLineStep = lastImage.bytesPerLine();

            const int h = lastVideoFrame.height();

            const int w = lastVideoFrame.width();

            for (int y=0; y<h; y++) {

                uyvy422_to_rgb16_line_neon(dst, src, w);

                src += srcLineStep;

                dst += dstLineStep;

            }

            lastFrame = QPixmap::fromImage(

                lastImage.scaled(boundingRect.size().toSize(), Qt::IgnoreAspectRatio, Qt::FastTransformation));

        } else

#endif

        {

            QImage::Format imgFormat = QVideoFrame::imageFormatFromPixelFormat(lastVideoFrame.pixelFormat());

            if (imgFormat != QImage::Format_Invalid) {

                QImage lastImage(lastVideoFrame.bits(),

                                 lastVideoFrame.width(),

                                 lastVideoFrame.height(),

                                 lastVideoFrame.bytesPerLine(),

                                 imgFormat);

                lastFrame = QPixmap::fromImage(

                        lastImage.scaled(boundingRect.size().toSize(), Qt::IgnoreAspectRatio, Qt::FastTransformation));

            }

        }

        lastVideoFrame.unmap();

    }

}

void QGraphicsVideoItemPrivate::_q_present()

{

    q_ptr->update(boundingRect);

}

void QGraphicsVideoItemPrivate::_q_formatChanged(const QVideoSurfaceFormat &format)

{

    nativeSize = format.sizeHint();

    lastFrame = QPixmap();

    updateRects();

    emit q_ptr->nativeSizeChanged(nativeSize);

}

void QGraphicsVideoItemPrivate::_q_serviceDestroyed()

{

    rendererControl = 0;

    service = 0;

    surface->stop();

}

void QGraphicsVideoItemPrivate::_q_mediaObjectDestroyed()

{

    mediaObject = 0;

    clearService();

}

QGraphicsVideoItem::QGraphicsVideoItem(QGraphicsItem *parent)

    : QGraphicsObject(parent)

    , d_ptr(new QGraphicsVideoItemPrivate)

{

    d_ptr->q_ptr = this;

    d_ptr->surface = new QXVideoSurface;

    setCacheMode(NoCache);

    setFlag(QGraphicsItem::ItemIgnoresParentOpacity);

    setFlag(QGraphicsItem::ItemSendsGeometryChanges);

    setFlag(QGraphicsItem::ItemSendsScenePositionChanges);

    connect(d_ptr->surface, SIGNAL(surfaceFormatChanged(QVideoSurfaceFormat)),

            this, SLOT(_q_formatChanged(QVideoSurfaceFormat)));

    connect(d_ptr->surface, SIGNAL(activeChanged(bool)), this, SLOT(_q_present()));

}

QGraphicsVideoItem::~QGraphicsVideoItem()

{

    if (d_ptr->rendererControl) {

        d_ptr->rendererControl->setSurface(0);

        d_ptr->service->releaseControl(d_ptr->rendererControl);

    }

    if (d_ptr->currentView)

        d_ptr->currentView->setViewportUpdateMode(d_ptr->savedViewportUpdateMode);

    delete d_ptr->surface;

    delete d_ptr;

}

QMediaObject *QGraphicsVideoItem::mediaObject() const

{

    return d_func()->mediaObject;

}

bool QGraphicsVideoItem::setMediaObject(QMediaObject *object)

{

    Q_D(QGraphicsVideoItem);

    if (object == d->mediaObject)

        return true;

    d->clearService();

    d->mediaObject = object;

    if (d->mediaObject) {

        d->service = d->mediaObject->service();

        if (d->service) {

            d->rendererControl = qobject_cast<QVideoRendererControl *>(

                    d->service->requestControl(QVideoRendererControl_iid));

            if (d->rendererControl != 0) {

                connect(d->service, SIGNAL(destroyed()), this, SLOT(_q_serviceDestroyed()));

                d->rendererControl->setSurface(d->surface);

                return true;

            }

        }

    }

    return false;

}

Qt::AspectRatioMode QGraphicsVideoItem::aspectRatioMode() const

{

    return d_func()->aspectRatioMode;

}

void QGraphicsVideoItem::setAspectRatioMode(Qt::AspectRatioMode mode)

{

    Q_D(QGraphicsVideoItem);

    d->aspectRatioMode = mode;

    d->updateRects();

}

QPointF QGraphicsVideoItem::offset() const

{

    return d_func()->rect.topLeft();

}

void QGraphicsVideoItem::setOffset(const QPointF &offset)

{

    Q_D(QGraphicsVideoItem);

    d->rect.moveTo(offset);

    d->updateRects();

}

QSizeF QGraphicsVideoItem::size() const

{

    return d_func()->rect.size();

}

void QGraphicsVideoItem::setSize(const QSizeF &size)

{

    Q_D(QGraphicsVideoItem);

    d->rect.setSize(size.isValid() ? size : QSizeF(0, 0));

    d->updateRects();

}

QSizeF QGraphicsVideoItem::nativeSize() const

{

    return d_func()->nativeSize;

}

QRectF QGraphicsVideoItem::boundingRect() const

{

    return d_func()->boundingRect;

}

void QGraphicsVideoItem::paint(

        QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)

{

    qDebug() << "QGraphicsVideoItem::paint";

    Q_UNUSED(option);

    Q_D(QGraphicsVideoItem);

    QGraphicsView *view = 0;

    if (scene() && !scene()->views().isEmpty())

        view = scene()->views().first();