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