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

**

** Copyright (C) 2009 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 <qmath.h>

#include <qpainter.h>

#include <qvariant.h>

#include <QtMultimedia/qvideosurfaceformat.h>

#if !defined(QT_NO_OPENGL) && !defined(QT_OPENGL_ES_1_CL) && !defined(QT_OPENGL_ES_1)

#include <qglshaderprogram.h>

#endif

#include <QtDebug>

QTM_BEGIN_NAMESPACE

class QVideoSurfacePainter

{

public:

    virtual ~QVideoSurfacePainter();

    virtual QList<QVideoFrame::PixelFormat> supportedPixelFormats(

            QAbstractVideoBuffer::HandleType handleType) const = 0;

    virtual bool isFormatSupported(

            const QVideoSurfaceFormat &format, QVideoSurfaceFormat *similar) const = 0;

    virtual QAbstractVideoSurface::Error start(const QVideoSurfaceFormat &format) = 0;

    virtual void stop() = 0;

    virtual QAbstractVideoSurface::Error setCurrentFrame(const QVideoFrame &frame) = 0;

    virtual QAbstractVideoSurface::Error paint(

            const QRectF &target, QPainter *painter, const QRectF &source) = 0;

    virtual void updateColors(int brightness, int contrast, int hue, int saturation) = 0;

};

QVideoSurfacePainter::~QVideoSurfacePainter()

{

}

class QVideoSurfaceRasterPainter : public QVideoSurfacePainter

{

public:

    QVideoSurfaceRasterPainter();

    QList<QVideoFrame::PixelFormat> supportedPixelFormats(

            QAbstractVideoBuffer::HandleType handleType) const;

    bool isFormatSupported(

            const QVideoSurfaceFormat &format, QVideoSurfaceFormat *similar) const;

    QAbstractVideoSurface::Error start(const QVideoSurfaceFormat &format);

    void stop();

    QAbstractVideoSurface::Error setCurrentFrame(const QVideoFrame &frame);

    QAbstractVideoSurface::Error paint(

            const QRectF &target, QPainter *painter, const QRectF &source);

    void updateColors(int brightness, int contrast, int hue, int saturation);

private:

    QList<QVideoFrame::PixelFormat> m_imagePixelFormats;

    QVideoFrame m_frame;

    QSize m_imageSize;

    QImage::Format m_imageFormat;

    QVideoSurfaceFormat::Direction m_scanLineDirection;

};

QVideoSurfaceRasterPainter::QVideoSurfaceRasterPainter()

    : m_imageFormat(QImage::Format_Invalid)

    , m_scanLineDirection(QVideoSurfaceFormat::TopToBottom)

{

    m_imagePixelFormats

        << QVideoFrame::Format_RGB32

#ifndef QT_OPENGL_ES // The raster formats should be a subset of the GL formats.

        << QVideoFrame::Format_RGB24

#endif

        << QVideoFrame::Format_ARGB32

        << QVideoFrame::Format_RGB565;

}

QList<QVideoFrame::PixelFormat> QVideoSurfaceRasterPainter::supportedPixelFormats(

        QAbstractVideoBuffer::HandleType handleType) const

{

    return handleType == QAbstractVideoBuffer::NoHandle

        ? m_imagePixelFormats

        : QList<QVideoFrame::PixelFormat>();

}

bool QVideoSurfaceRasterPainter::isFormatSupported(

        const QVideoSurfaceFormat &format, QVideoSurfaceFormat *) const

{

    return format.handleType() == QAbstractVideoBuffer::NoHandle

            && m_imagePixelFormats.contains(format.pixelFormat())

            && !format.frameSize().isEmpty();

}

QAbstractVideoSurface::Error QVideoSurfaceRasterPainter::start(const QVideoSurfaceFormat &format)

{

    m_frame = QVideoFrame();

    m_imageFormat = QVideoFrame::imageFormatFromPixelFormat(format.pixelFormat());

    m_imageSize = format.frameSize();

    m_scanLineDirection = format.scanLineDirection();

    return format.handleType() == QAbstractVideoBuffer::NoHandle

            && m_imageFormat != QImage::Format_Invalid

            && !m_imageSize.isEmpty()

            ? QAbstractVideoSurface::NoError

            : QAbstractVideoSurface::UnsupportedFormatError;

}

void QVideoSurfaceRasterPainter::stop()

{

    m_frame = QVideoFrame();

}

QAbstractVideoSurface::Error QVideoSurfaceRasterPainter::setCurrentFrame(const QVideoFrame &frame)

{

    m_frame = frame;

    return QAbstractVideoSurface::NoError;

}

QAbstractVideoSurface::Error QVideoSurfaceRasterPainter::paint(

            const QRectF &target, QPainter *painter, const QRectF &source)

{

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

        QImage image(

                m_frame.bits(),

                m_imageSize.width(),

                m_imageSize.height(),

                m_frame.bytesPerLine(),

                m_imageFormat);

        if (m_scanLineDirection == QVideoSurfaceFormat::BottomToTop) {

            const QTransform oldTransform = painter->transform();

            painter->scale(1, -1);

            painter->translate(0, -target.bottom());

            painter->drawImage(

                QRectF(target.x(), 0, target.width(), target.height()), image, source);

            painter->setTransform(oldTransform);

        } else {

            painter->drawImage(target, image, source);

        }

        m_frame.unmap();

    } else if (m_frame.isValid()) {

        return QAbstractVideoSurface::IncorrectFormatError;

    } else {

        painter->fillRect(target, Qt::black);

    }

    return QAbstractVideoSurface::NoError;

}

void QVideoSurfaceRasterPainter::updateColors(int, int, int, int)

{

}

#if !defined(QT_NO_OPENGL) && !defined(QT_OPENGL_ES_1_CL) && !defined(QT_OPENGL_ES_1)

#ifndef Q_WS_MAC

# ifndef APIENTRYP

#   ifdef APIENTRY

#     define APIENTRYP APIENTRY *

#   else

#     define APIENTRY

#     define APIENTRYP *

#   endif

# endif

#else

# define APIENTRY

# define APIENTRYP *

#endif

#ifndef GL_TEXTURE0

#  define GL_TEXTURE0    0x84C0

#  define GL_TEXTURE1    0x84C1

#  define GL_TEXTURE2    0x84C2

#endif

#ifndef GL_PROGRAM_ERROR_STRING_ARB

#  define GL_PROGRAM_ERROR_STRING_ARB       0x8874

#endif

#ifndef GL_UNSIGNED_SHORT_5_6_5

#  define GL_UNSIGNED_SHORT_5_6_5 33635

#endif

class QVideoSurfaceGLPainter : public QVideoSurfacePainter

{

public:

    QVideoSurfaceGLPainter(QGLContext *context);

    ~QVideoSurfaceGLPainter();

    QList<QVideoFrame::PixelFormat> supportedPixelFormats(

            QAbstractVideoBuffer::HandleType handleType) const;

    bool isFormatSupported(

            const QVideoSurfaceFormat &format, QVideoSurfaceFormat *similar) const;

    QAbstractVideoSurface::Error setCurrentFrame(const QVideoFrame &frame);

    void updateColors(int brightness, int contrast, int hue, int saturation);

protected:

    void initRgbTextureInfo(GLenum internalFormat, GLuint format, GLenum type, const QSize &size);

    void initYuv420PTextureInfo(const QSize &size);

    void initYv12TextureInfo(const QSize &size);

#ifndef QT_OPENGL_ES

    typedef void (APIENTRY *_glActiveTexture) (GLenum);

    _glActiveTexture glActiveTexture;

#endif

    QList<QVideoFrame::PixelFormat> m_imagePixelFormats;

    QList<QVideoFrame::PixelFormat> m_glPixelFormats;

    QMatrix4x4 m_colorMatrix;

    QVideoFrame m_frame;

    QGLContext *m_context;

    QAbstractVideoBuffer::HandleType m_handleType;

    QVideoSurfaceFormat::Direction m_scanLineDirection;

    GLenum m_textureFormat;

    GLuint m_textureInternalFormat;

    GLenum m_textureType;

    int m_textureCount;

    GLuint m_textureIds[3];

    int m_textureWidths[3];

    int m_textureHeights[3];

    int m_textureOffsets[3];

    bool m_yuv;

};

QVideoSurfaceGLPainter::QVideoSurfaceGLPainter(QGLContext *context)

    : m_context(context)

    , m_handleType(QAbstractVideoBuffer::NoHandle)

    , m_scanLineDirection(QVideoSurfaceFormat::TopToBottom)

    , m_textureFormat(0)

    , m_textureInternalFormat(0)

    , m_textureType(0)

    , m_textureCount(0)

    , m_yuv(false)

{

#ifndef QT_OPENGL_ES

    glActiveTexture = (_glActiveTexture)m_context->getProcAddress(QLatin1String("glActiveTexture"));

#endif

}

QVideoSurfaceGLPainter::~QVideoSurfaceGLPainter()

{

}

QList<QVideoFrame::PixelFormat> QVideoSurfaceGLPainter::supportedPixelFormats(

        QAbstractVideoBuffer::HandleType handleType) const

{

    switch (handleType) {

    case QAbstractVideoBuffer::NoHandle:

        return m_imagePixelFormats;

    case QAbstractVideoBuffer::GLTextureHandle:

        return m_glPixelFormats;

    default:

        return QList<QVideoFrame::PixelFormat>();

    }

}

bool QVideoSurfaceGLPainter::isFormatSupported(

        const QVideoSurfaceFormat &format, QVideoSurfaceFormat *) const

{

    if (format.frameSize().isEmpty()) {

        return false;

    } else {

        switch (format.handleType()) {

        case QAbstractVideoBuffer::NoHandle:

            return m_imagePixelFormats.contains(format.pixelFormat());

        case QAbstractVideoBuffer::GLTextureHandle:

            return m_glPixelFormats.contains(format.pixelFormat());

        default:

            return false;

        }

    }

}

QAbstractVideoSurface::Error QVideoSurfaceGLPainter::setCurrentFrame(const QVideoFrame &frame)

{

    m_frame = frame;

    if (m_handleType == QAbstractVideoBuffer::GLTextureHandle) {

        m_textureIds[0] = frame.handle().toInt();

    } else if (m_frame.map(QAbstractVideoBuffer::ReadOnly)) {

        m_context->makeCurrent();

        for (int i = 0; i < m_textureCount; ++i) {

            glBindTexture(GL_TEXTURE_2D, m_textureIds[i]);

            glTexImage2D(

                    GL_TEXTURE_2D,

                    0,

                    m_textureInternalFormat,

                    m_textureWidths[i],

                    m_textureHeights[i],

                    0,

                    m_textureFormat,

                    m_textureType,

                    m_frame.bits() + m_textureOffsets[i]);

            glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

            glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);

            glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);

            glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);

        }

        m_frame.unmap();

    } else if (m_frame.isValid()) {

        return QAbstractVideoSurface::IncorrectFormatError;

    }

    return QAbstractVideoSurface::NoError;

}

void QVideoSurfaceGLPainter::updateColors(int brightness, int contrast, int hue, int saturation)

{

    const qreal b = brightness / 200.0;

    const qreal c = contrast / 100.0 + 1.0;

    const qreal s = saturation / 100.0 + 1.0;

    const qreal cosH = qCos(M_PI * h);

    const qreal sinH = qSin(M_PI * h);

    const qreal sr = (1.0 - s) * 0.3086;

    const qreal sg = (1.0 - s) * 0.6094;

    const qreal sb = (1.0 - s) * 0.0820;

    const qreal sr_s = sr + s;

    const qreal sg_s = sg + s;

    const qreal sb_s = sr + s;

    const float m4 = (s + sr + sg + sb) * (0.5 - 0.5 * c + b);

    m_colorMatrix(0, 0) = c * (sr_s * h11 + sg * h21 + sb * h31);

    m_colorMatrix(0, 1) = c * (sr_s * h12 + sg * h22 + sb * h32);

    m_colorMatrix(0, 2) = c * (sr_s * h13 + sg * h23 + sb * h33);

    m_colorMatrix(0, 3) = m4;

    m_colorMatrix(1, 0) = c * (sr * h11 + sg_s * h21 + sb * h31);

    m_colorMatrix(1, 1) = c * (sr * h12 + sg_s * h22 + sb * h32);

    m_colorMatrix(1, 2) = c * (sr * h13 + sg_s * h23 + sb * h33);

    m_colorMatrix(1, 3) = m4;

    m_colorMatrix(2, 0) = c * (sr * h11 + sg * h21 + sb_s * h31);

    m_colorMatrix(2, 1) = c * (sr * h12 + sg * h22 + sb_s * h32);

    m_colorMatrix(2, 2) = c * (sr * h13 + sg * h23 + sb_s * h33);

    m_colorMatrix(2, 3) = m4;

    m_colorMatrix(3, 0) = 0.0;

    m_colorMatrix(3, 1) = 0.0;

    m_colorMatrix(3, 2) = 0.0;

    m_colorMatrix(3, 3) = 1.0;

    if (m_yuv) {

        m_colorMatrix = m_colorMatrix * QMatrix4x4(

                1.0,  0.000,  1.140, -0.5700,

                1.0, -0.394, -0.581,  0.4875,

                1.0,  2.028,  0.000, -1.0140,

                0.0,  0.000,  0.000,  1.0000);

    }

}

void QVideoSurfaceGLPainter::initRgbTextureInfo(

        GLenum internalFormat, GLuint format, GLenum type, const QSize &size)

{

    m_yuv = false;

    m_textureInternalFormat = internalFormat;

    m_textureFormat = format;

    m_textureType = type;

    m_textureCount = 1;

    m_textureWidths[0] = size.width();

    m_textureHeights[0] = size.height();

    m_textureOffsets[0] = 0;

}

void QVideoSurfaceGLPainter::initYuv420PTextureInfo(const QSize &size)

{

    m_yuv = true;

    m_textureInternalFormat = GL_LUMINANCE;

    m_textureFormat = GL_LUMINANCE;

    m_textureType = GL_UNSIGNED_BYTE;

    m_textureCount = 3;

    m_textureWidths[0] = size.width();

    m_textureHeights[0] = size.height();

    m_textureOffsets[0] = 0;

    m_textureWidths[1] = size.width() / 2;

    m_textureHeights[1] = size.height() / 2;

    m_textureOffsets[1] = size.width() * size.height();

    m_textureWidths[2] = size.width() / 2;

    m_textureHeights[2] = size.height() / 2;

    m_textureOffsets[2] = size.width() * size.height() * 5 / 4;

}

void QVideoSurfaceGLPainter::initYv12TextureInfo(const QSize &size)

{

    m_yuv = true;

    m_textureInternalFormat = GL_LUMINANCE;

    m_textureFormat = GL_LUMINANCE;

    m_textureType = GL_UNSIGNED_BYTE;

    m_textureCount = 3;

    m_textureWidths[0] = size.width();

    m_textureHeights[0] = size.height();

    m_textureOffsets[0] = 0;

    m_textureWidths[1] = size.width() / 2;

    m_textureHeights[1] = size.height() / 2;

    m_textureOffsets[1] = size.width() * size.height() * 5 / 4;

    m_textureWidths[2] = size.width() / 2;

    m_textureHeights[2] = size.height() / 2;

    m_textureOffsets[2] = size.width() * size.height();

}

#ifndef QT_OPENGL_ES

# ifndef GL_FRAGMENT_PROGRAM_ARB

#  define GL_FRAGMENT_PROGRAM_ARB           0x8804

#  define GL_PROGRAM_FORMAT_ASCII_ARB       0x8875

# endif

// Paints an RGB32 frame

static const char *qt_arbfp_xrgbShaderProgram =

    "!!ARBfp1.0\n"

    "PARAM matrix[4] = { program.local[0..2],"

    "{ 0.0, 0.0, 0.0, 1.0 } };\n"

    "TEMP xrgb;\n"

    "TEX xrgb.xyz, fragment.texcoord[0], texture[0], 2D;\n"

    "MOV xrgb.w, matrix[3].w;\n"

    "DP4 result.color.x, xrgb.zyxw, matrix[0];\n"

    "DP4 result.color.y, xrgb.zyxw, matrix[1];\n"

    "DP4 result.color.z, xrgb.zyxw, matrix[2];\n"

    "END";

// Paints an ARGB frame.

static const char *qt_arbfp_argbShaderProgram =

    "!!ARBfp1.0\n"

    "PARAM matrix[4] = { program.local[0..2],"

    "{ 0.0, 0.0, 0.0, 1.0 } };\n"

    "TEMP argb;\n"

    "TEX argb, fragment.texcoord[0], texture[0], 2D;\n"

    "MOV argb.w, matrix[3].w;\n"

    "DP4 result.color.x, argb.zyxw, matrix[0];\n"

    "DP4 result.color.y, argb.zyxw, matrix[1];\n"

    "DP4 result.color.z, argb.zyxw, matrix[2];\n"

    "TEX result.color.w, fragment.texcoord[0], texture, 2D;\n"

    "END";

// Paints an RGB(A) frame.

static const char *qt_arbfp_rgbShaderProgram =

    "!!ARBfp1.0\n"

    "PARAM matrix[4] = { program.local[0..2],"

    "{ 0.0, 0.0, 0.0, 1.0 } };\n"

    "TEMP rgb;\n"

    "TEX rgb, fragment.texcoord[0], texture[0], 2D;\n"

    "MOV rgb.w, matrix[3].w;\n"

    "DP4 result.color.x, rgb, matrix[0];\n"

    "DP4 result.color.y, rgb, matrix[1];\n"

    "DP4 result.color.z, rgb, matrix[2];\n"

    "TEX result.color.w, fragment.texcoord[0], texture, 2D;\n"

    "END";

// Paints a YUV420P or YV12 frame.

static const char *qt_arbfp_yuvPlanarShaderProgram =

    "!!ARBfp1.0\n"

    "PARAM matrix[4] = { program.local[0..2],"

    "{ 0.0, 0.0, 0.0, 1.0 } };\n"

    "TEMP yuv;\n"

    "TEX yuv.x, fragment.texcoord[0], texture[0], 2D;\n"

    "TEX yuv.y, fragment.texcoord[0], texture[1], 2D;\n"

    "TEX yuv.z, fragment.texcoord[0], texture[2], 2D;\n"

    "MOV yuv.w, matrix[3].w;\n"

    "DP4 result.color.x, yuv, matrix[0];\n"