/*  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 "videoframe.h"

#include "quicktimevideoplayer.h"

#import <QuartzCore/CIFilter.h>

#import <QuartzCore/CIContext.h>

//#define CACHE_CV_TEXTURE

QT_BEGIN_NAMESPACE

namespace Phonon

{

namespace QT7

{

    VideoFrame::VideoFrame()

    {

        initMembers();

    }

    VideoFrame::VideoFrame(QuickTimeVideoPlayer *videoPlayer)

    {

        initMembers();

        m_videoPlayer = videoPlayer;

    }

    VideoFrame::VideoFrame(const VideoFrame& frame)

    {

        copyMembers(frame);

        retain();

    }

    void VideoFrame::operator=(const VideoFrame& frame)

    {

        if (this == &frame)

            return;

        release();

        copyMembers(frame);

        retain();

    }

    void VideoFrame::initMembers()

    {

        m_cachedCVTextureRef = 0;

		m_cachedCIImage = 0;

        m_cachedNSBitmap = 0;

        m_videoPlayer = 0;

        m_brightness = 0;

        m_contrast = 0;

        m_hue = 0;

        m_saturation = 0;

        m_opacity = 1;

        m_backgroundFrame = 0;

    }

    void VideoFrame::copyMembers(const VideoFrame& frame)

    {

#ifdef CACHE_CV_TEXTURE

        m_cachedCVTextureRef = frame.m_cachedCVTextureRef;

#endif

		m_cachedCIImage = frame.m_cachedCIImage;

		m_cachedQImage = frame.m_cachedQImage;

        m_cachedNSBitmap = frame.m_cachedNSBitmap;

        m_videoPlayer = frame.m_videoPlayer;

        m_brightness = frame.m_brightness;

        m_contrast = frame.m_contrast;

        m_hue = frame.m_hue;

        m_saturation = frame.m_saturation;

        m_opacity = frame.m_opacity;

        m_backgroundFrame = frame.m_backgroundFrame;

    }

    VideoFrame::~VideoFrame()

    {

        release();

    }

    QuickTimeVideoPlayer *VideoFrame::videoPlayer()

    {

        return m_videoPlayer;

    }

    void VideoFrame::setBackgroundFrame(const VideoFrame &frame)

    {

        m_backgroundFrame = new VideoFrame(frame);

    }

    QRect VideoFrame::frameRect() const

    {

        return m_videoPlayer->videoRect();

    }

    CVOpenGLTextureRef VideoFrame::cachedCVTexture() const

    {

#ifdef CACHE_CV_TEXTURE

        if (!m_cachedCVTextureRef && m_videoPlayer){

            m_videoPlayer->setColors(m_brightness, m_contrast, m_hue, m_saturation);

            (const_cast<VideoFrame *>(this))->m_cachedCVTextureRef = m_videoPlayer->currentFrameAsCVTexture();

            CVOpenGLTextureRetain((const_cast<VideoFrame *>(this))->m_cachedCVTextureRef);

        }

        return m_cachedCVTextureRef;

#else

        if (m_videoPlayer){

            m_videoPlayer->setColors(m_brightness, m_contrast, m_hue, m_saturation);

            return m_videoPlayer->currentFrameAsCVTexture();

        }

        return 0;

#endif

    }

    void *VideoFrame::cachedCIImage() const

    {

        if (!m_cachedCIImage && m_videoPlayer){

            m_videoPlayer->setColors(m_brightness, m_contrast, m_hue, m_saturation);

            (const_cast<VideoFrame *>(this))->m_cachedCIImage = m_videoPlayer->currentFrameAsCIImage();

        }

        return m_cachedCIImage;

    }

    GLuint VideoFrame::glTextureRef() const

    {

        return CVOpenGLTextureGetName(cachedCVTexture());

    }

    void VideoFrame::setColors(qreal brightness, qreal contrast, qreal hue, qreal saturation)

    {

        if (m_backgroundFrame)

            m_backgroundFrame->setColors(brightness, contrast, hue, saturation);

        if (m_brightness == brightness

            && m_contrast == contrast

            && m_hue == hue

            && m_saturation == saturation)

            return;

        m_brightness = brightness;

        m_contrast = contrast;

        m_hue = hue;

        m_saturation = saturation;

        invalidateImage();

    }

	CGRect VideoFrame::QRectToCGRect(const QRect & qrect)

	{

        CGRect cgrect;

        cgrect.origin.x = qrect.x();

        cgrect.origin.y = qrect.y() + qrect.height();

        cgrect.size.width = qrect.width();

        cgrect.size.height = -qrect.height();

		return cgrect;

	}

	bool VideoFrame::hasColorAdjustments()

	{

		return (m_brightness || m_contrast || m_saturation || m_hue);

	}

    void VideoFrame::setBaseOpacity(qreal opacity)

    {

        m_opacity = opacity;

    }

    void VideoFrame::drawQImage(QPainter *p, const QRect &rect) const

	{

        if (!m_videoPlayer)

            return;

#ifdef QUICKTIME_C_API_AVAILABLE

        if (m_cachedQImage.isNull()){

            m_videoPlayer->setColors(m_brightness, m_contrast, m_hue, m_saturation);

            (const_cast<VideoFrame *>(this))->m_cachedQImage = m_videoPlayer->currentFrameAsQImage();

        }

#else

        // Since cocoa-64 doesn't give us OpenGL textures directly, the process of converting

        // CIImges into QImages takes time. We could still call m_videoPlayer->currentFrameAsQImage(),

        // but because of bitmap memory management issues, and the fact that we need to swap red and

        // blue, we can optimize the process a bit here since we are going to draw immidiatly:

        CIImage *img = (CIImage*)cachedCIImage();

        if (!img)

            return;

        if (!m_cachedNSBitmap){

            (const_cast<VideoFrame *>(this))->m_cachedNSBitmap =

                [[NSBitmapImageRep alloc] initWithCIImage:img];

            CGRect bounds = [img extent];

            int w = bounds.size.width;

            int h = bounds.size.height;

            (const_cast<VideoFrame *>(this))->m_cachedQImage =

                QImage([m_cachedNSBitmap bitmapData], w, h, QImage::Format_ARGB32);

			// Swap red and blue (same as QImage::rgbSwapped, but without copy)

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

                uint *p = (uint*) m_cachedQImage.scanLine(i);

                uint *end = p + w;

                while (p < end) {

                    *p = ((*p << 16) & 0xff0000) | ((*p >> 16) & 0xff) | (*p & 0xff00ff00);

                    p++;

                }

            }

        }

#endif

        p->drawImage(rect, m_cachedQImage);

	}

    void VideoFrame::drawCIImage(const QRect &rect, float opacity) const

	{

		drawCIImage(QRectToCGRect(rect), opacity);

	}

    void VideoFrame::drawCIImage(const CGRect &rect, float opacity) const

	{

		Q_UNUSED(opacity);

		CIImage *img = (CIImage *) cachedCIImage();

		if (!img)

			return;

	    CIContext* ciContext = [[NSGraphicsContext currentContext] CIContext];

	    [ciContext drawImage:img inRect:rect fromRect:[img extent]];

	}

    void VideoFrame::drawCVTexture(const QRect &rect, float opacity) const

    {

        if (!m_videoPlayer)

            return;

        if (m_backgroundFrame)

            m_backgroundFrame->drawCVTexture(rect, opacity);

        CVOpenGLTextureRef texRef = cachedCVTexture();

        if (!texRef)

            return;

        glPushMatrix();

            glDisable(GL_CULL_FACE);

            GLenum target = CVOpenGLTextureGetTarget(texRef);

            glEnable(target);

            opacity *= m_opacity;

            if (opacity < 1){

                glEnable(GL_BLEND);

                glColor4f(1, 1, 1, opacity);

                glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

            } else {

                glColor3f(1, 1, 1);

                glDisable(GL_BLEND);

            }

            glBindTexture(target, CVOpenGLTextureGetName(texRef));

            glTexParameterf(target, GL_TEXTURE_MIN_FILTER, GL_LINEAR);

            glTexParameterf(target, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

            GLfloat lowerLeft[2], lowerRight[2], upperRight[2], upperLeft[2];

            CVOpenGLTextureGetCleanTexCoords(texRef, lowerLeft, lowerRight, upperRight, upperLeft);

            glBegin(GL_QUADS);

                glTexCoord2f(lowerLeft[0], lowerLeft[1]);

                glVertex2i(rect.topLeft().x(), rect.topLeft().y());

                glTexCoord2f(lowerRight[0], lowerRight[1]);

                glVertex2i(rect.topRight().x() + 1, rect.topRight().y());

                glTexCoord2f(upperRight[0], upperRight[1]);

                glVertex2i(rect.bottomRight().x() + 1, rect.bottomRight().y() + 1);

                glTexCoord2f(upperLeft[0], upperLeft[1]);

                glVertex2i(rect.bottomLeft().x(), rect.bottomLeft().y() + 1);

            glEnd();

        glPopMatrix();

    }

    void VideoFrame::drawGLTexture(const QRect &rect, float opacity) const

    {

        if (!m_videoPlayer)

            return;

        if (m_backgroundFrame)

            m_backgroundFrame->drawGLTexture(rect, opacity);

        GLuint texture = m_videoPlayer->currentFrameAsGLTexture();

        if (!texture)

            return;

        glPushMatrix();

            glDisable(GL_CULL_FACE);

            glEnable(GL_TEXTURE_RECTANGLE_EXT);

            opacity *= m_opacity;

            if (opacity < 1){

                glEnable(GL_BLEND);

                glColor4f(1, 1, 1, opacity);

                glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

            } else {

                glColor3f(1, 1, 1);

                glDisable(GL_BLEND);

            }

            glBindTexture(GL_TEXTURE_RECTANGLE_EXT, texture);

            glTexParameterf(GL_TEXTURE_RECTANGLE_EXT, GL_TEXTURE_MIN_FILTER, GL_LINEAR);

            glTexParameterf(GL_TEXTURE_RECTANGLE_EXT, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

            QRect videoRect = m_videoPlayer->videoRect();

            GLfloat lowerLeft[2], lowerRight[2], upperRight[2], upperLeft[2];

            lowerLeft[0] = 0;

            lowerLeft[1] = videoRect.height();

            lowerRight[0] = videoRect.width();

            lowerRight[1] = videoRect.height();

            upperRight[0] = videoRect.width();

            upperRight[1] = 0;

            upperLeft[0] = 0;

            upperLeft[1] = 0;

            glBegin(GL_QUADS);

                glTexCoord2f(lowerLeft[0], lowerLeft[1]);

                glVertex2i(rect.topLeft().x(), rect.topLeft().y());

                glTexCoord2f(lowerRight[0], lowerRight[1]);

                glVertex2i(rect.topRight().x() + 1, rect.topRight().y());

                glTexCoord2f(upperRight[0], upperRight[1]);

                glVertex2i(rect.bottomRight().x() + 1, rect.bottomRight().y() + 1);

                glTexCoord2f(upperLeft[0], upperLeft[1]);

                glVertex2i(rect.bottomLeft().x(), rect.bottomLeft().y() + 1);

            glEnd();

        glPopMatrix();

        // FOR NOW. FREE THE TEXTURE:

        glDeleteTextures(1, &texture);

    }

    bool VideoFrame::isEmpty()

    {

        return (m_videoPlayer == 0);

    }

    void VideoFrame::invalidateImage() const

    {

#ifdef CACHE_CV_TEXTURE

        if (m_cachedCVTextureRef){

            CVOpenGLTextureRelease(m_cachedCVTextureRef);

            (const_cast<VideoFrame *>(this))->m_cachedCVTextureRef = 0;

        }

#endif

        if (m_cachedCIImage){

			[(CIImage *) m_cachedCIImage release];

            (const_cast<VideoFrame *>(this))->m_cachedCIImage = 0;

        }

        if (m_cachedNSBitmap){

            [m_cachedNSBitmap release];

            (const_cast<VideoFrame *>(this))->m_cachedNSBitmap = 0;

        }

        (const_cast<VideoFrame *>(this))-> m_cachedQImage = QImage();

    }

    void VideoFrame::retain() const

    {

#ifdef CACHE_CV_TEXTURE

        if (m_cachedCVTextureRef)

            CVOpenGLTextureRetain(m_cachedCVTextureRef);

#endif

		if (m_cachedCIImage)

			[(CIImage *) m_cachedCIImage retain];

        if (m_backgroundFrame)

            m_backgroundFrame->retain();

        if (m_cachedNSBitmap)

            [m_cachedNSBitmap retain];

    }

    void VideoFrame::release() const

    {

#ifdef CACHE_CV_TEXTURE

        if (m_cachedCVTextureRef){

            CVOpenGLTextureRelease(m_cachedCVTextureRef);

            (const_cast<VideoFrame *>(this))->m_cachedCVTextureRef = 0;

        }

#endif

		if (m_cachedCIImage)

			[(CIImage *) m_cachedCIImage release];

        if (m_backgroundFrame)

            m_backgroundFrame->release();

        if (m_cachedNSBitmap)

            [m_cachedNSBitmap release];

        (const_cast<VideoFrame *>(this))->m_backgroundFrame = 0;

        (const_cast<VideoFrame *>(this))->m_cachedCIImage = 0;

        (const_cast<VideoFrame *>(this))->m_cachedNSBitmap = 0;

    }

}} //namespace Phonon::QT7

QT_END_NAMESPACE