/* 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 "videorenderer_vmr9.h"
#ifndef QT_NO_PHONON_VIDEO
#include <QtGui/QWidget>
#include <QtGui/QPainter>
#include <QtCore/QTimerEvent>
#ifndef Q_OS_WINCE
#include <d3d9.h>
#include <vmr9.h>
#else
#include <uuids.h>
#endif
QT_BEGIN_NAMESPACE
namespace Phonon
{
namespace DS9
{
VideoRendererVMR9::~VideoRendererVMR9()
{
}
bool VideoRendererVMR9::isNative() const
{
return true;
}
#ifdef Q_OS_WINCE
VideoRendererVMR9::VideoRendererVMR9(QWidget *target) : m_target(target)
{
m_target->setAttribute(Qt::WA_PaintOnScreen, true);
m_filter = Filter(CLSID_VideoRenderer, IID_IBaseFilter);
}
QSize VideoRendererVMR9::videoSize() const
{
LONG w = 0,
h = 0;
ComPointer<IBasicVideo> basic(m_filter, IID_IBasicVideo);
if (basic) {
basic->GetVideoSize( &w, &h);
}
return QSize(w, h);
}
void VideoRendererVMR9::repaintCurrentFrame(QWidget * /*target*/, const QRect & /*rect*/)
{
//nothing to do here: the renderer paints everything
}
void VideoRendererVMR9::notifyResize(const QSize &size, Phonon::VideoWidget::AspectRatio aspectRatio,
Phonon::VideoWidget::ScaleMode scaleMode)
{
if (!isActive()) {
ComPointer<IBasicVideo> basic(m_filter, IID_IBasicVideo);
if (basic) {
basic->SetDestinationPosition(0, 0, 0, 0);
}
return;
}
ComPointer<IVideoWindow> video(m_filter, IID_IVideoWindow);
OAHWND owner;
HRESULT hr = video->get_Owner(&owner);
if (FAILED(hr)) {
return;
}
const OAHWND newOwner = reinterpret_cast<OAHWND>(m_target->winId());
if (owner != newOwner) {
video->put_Owner(newOwner);
video->put_MessageDrain(newOwner);
video->put_WindowStyle(WS_CHILD | WS_CLIPCHILDREN | WS_CLIPSIBLINGS);
}
//make sure the widget takes the whole size of the parent
video->SetWindowPosition(0, 0, size.width(), size.height());
const QSize vsize = videoSize();
internalNotifyResize(size, vsize, aspectRatio, scaleMode);
ComPointer<IBasicVideo> basic(m_filter, IID_IBasicVideo);
if (basic) {
basic->SetDestinationPosition(m_dstX, m_dstY, m_dstWidth, m_dstHeight);
}
}
void VideoRendererVMR9::applyMixerSettings(qreal /*brightness*/, qreal /*contrast*/, qreal /*m_hue*/, qreal /*saturation*/)
{
//this can't be supported for WinCE
}
QImage VideoRendererVMR9::snapshot() const
{
ComPointer<IBasicVideo> basic(m_filter, IID_IBasicVideo);
if (basic) {
LONG bufferSize = 0;
//1st we get the buffer size
basic->GetCurrentImage(&bufferSize, 0);
QByteArray buffer;
buffer.resize(bufferSize);
HRESULT hr = basic->GetCurrentImage(&bufferSize, reinterpret_cast<long*>(buffer.data()));
if (SUCCEEDED(hr)) {
const BITMAPINFOHEADER *bmi = reinterpret_cast<const BITMAPINFOHEADER*>(buffer.constData());
const int w = qAbs(bmi->biWidth),
h = qAbs(bmi->biHeight);
// Create image and copy data into image.
QImage ret(w, h, QImage::Format_RGB32);
if (!ret.isNull()) {
const char *data = buffer.constData() + bmi->biSize;
const int bytes_per_line = w * sizeof(QRgb);
for (int y = h - 1; y >= 0; --y) {
qMemCopy(ret.scanLine(y), //destination
data, //source
bytes_per_line);
data += bytes_per_line;
}
}
return ret;
}
}
return QImage();
}
#else
VideoRendererVMR9::VideoRendererVMR9(QWidget *target) : m_target(target)
{
m_filter = Filter(CLSID_VideoMixingRenderer9, IID_IBaseFilter);
if (!m_filter) {
qWarning("the video widget could not be initialized correctly");
return;
}
ComPointer<IVMRFilterConfig9> config(m_filter, IID_IVMRFilterConfig9);
Q_ASSERT(config);
HRESULT hr = config->SetRenderingMode(VMR9Mode_Windowless);
Q_ASSERT(SUCCEEDED(hr));
hr = config->SetNumberOfStreams(1); //for now we limit it to 1 input stream
Q_ASSERT(SUCCEEDED(hr));
ComPointer<IVMRWindowlessControl9> windowlessControl(m_filter, IID_IVMRWindowlessControl9);
windowlessControl->SetVideoClippingWindow(reinterpret_cast<HWND>(target->winId()));
windowlessControl->SetAspectRatioMode(VMR9ARMode_None); //we're in control of the size
}
QImage VideoRendererVMR9::snapshot() const
{
ComPointer<IVMRWindowlessControl9> windowlessControl(m_filter, IID_IVMRWindowlessControl9);
if (windowlessControl) {
BYTE *buffer = 0;
HRESULT hr = windowlessControl->GetCurrentImage(&buffer);
if (SUCCEEDED(hr)) {
const BITMAPINFOHEADER *bmi = reinterpret_cast<BITMAPINFOHEADER*>(buffer);
const int w = qAbs(bmi->biWidth),
h = qAbs(bmi->biHeight);
// Create image and copy data into image.
QImage ret(w, h, QImage::Format_RGB32);
if (!ret.isNull()) {
uchar *data = buffer + bmi->biSize;
const int bytes_per_line = w * sizeof(QRgb);
for (int y = h - 1; y >= 0; --y) {
qMemCopy(ret.scanLine(y), //destination
data, //source
bytes_per_line);
data += bytes_per_line;
}
}
::CoTaskMemFree(buffer);
return ret;
}
}
return QImage();
}
QSize VideoRendererVMR9::videoSize() const
{
LONG w = 0,
h = 0;
ComPointer<IVMRWindowlessControl9> windowlessControl(m_filter, IID_IVMRWindowlessControl9);
if (windowlessControl) {
windowlessControl->GetNativeVideoSize( &w, &h, 0, 0);
}
return QSize(w, h);
}
void VideoRendererVMR9::repaintCurrentFrame(QWidget *target, const QRect &rect)
{
HDC hDC = target->getDC();
// repaint the video
ComPointer<IVMRWindowlessControl9> windowlessControl(m_filter, IID_IVMRWindowlessControl9);
HRESULT hr = windowlessControl ? windowlessControl->RepaintVideo(target->winId(), hDC) : E_POINTER;
if (FAILED(hr) || m_dstY > 0 || m_dstX > 0) {
const QColor c = target->palette().color(target->backgroundRole());
COLORREF color = RGB(c.red(), c.green(), c.blue());
HPEN hPen = ::CreatePen(PS_SOLID, 1, color);
HBRUSH hBrush = ::CreateSolidBrush(color);
::SelectObject(hDC, hPen);
::SelectObject(hDC, hBrush);
// repaint the video
if (FAILED(hr)) {
//black background : we use the Win32 API to avoid the ghost effect of the backing store
::Rectangle(hDC, 0, 0, target->width(), target->height());
} else {
if (m_dstY > 0) {
::Rectangle(hDC, 0, 0, target->width(), m_dstY); //top
::Rectangle(hDC, 0, target->height() - m_dstY, target->width(), target->height()); //bottom
}
if (m_dstX > 0) {
::Rectangle(hDC, 0, m_dstY, m_dstX, m_dstHeight + m_dstY); //left
::Rectangle(hDC, m_dstWidth + m_dstX, m_dstY, target->width(), m_dstHeight + m_dstY); //right
}
}
::DeleteObject(hPen);
::DeleteObject(hBrush);
}
target->releaseDC(hDC);
}
void VideoRendererVMR9::notifyResize(const QSize &size, Phonon::VideoWidget::AspectRatio aspectRatio,
Phonon::VideoWidget::ScaleMode scaleMode)
{
if (!isActive()) {
RECT dummyRect = { 0, 0, 0, 0};
ComPointer<IVMRWindowlessControl9> windowlessControl(m_filter, IID_IVMRWindowlessControl9);
windowlessControl->SetVideoPosition(&dummyRect, &dummyRect);
return;
}
const QSize vsize = videoSize();
internalNotifyResize(size, vsize, aspectRatio, scaleMode);
RECT dstRectWin = { m_dstX, m_dstY, m_dstWidth + m_dstX, m_dstHeight + m_dstY};
RECT srcRectWin = { 0, 0, vsize.width(), vsize.height()};
ComPointer<IVMRWindowlessControl9> windowlessControl(m_filter, IID_IVMRWindowlessControl9);
if (windowlessControl) {
windowlessControl->SetVideoPosition(&srcRectWin, &dstRectWin);
}
}
void VideoRendererVMR9::applyMixerSettings(qreal brightness, qreal contrast, qreal hue, qreal saturation)
{
InputPin sink = BackendNode::pins(m_filter, PINDIR_INPUT).first();
OutputPin source;
if (FAILED(sink->ConnectedTo(source.pparam()))) {
return; //it must be connected to work
}
//get the mixer (used for brightness/contrast/saturation/hue)
ComPointer<IVMRMixerControl9> mixer(m_filter, IID_IVMRMixerControl9);
Q_ASSERT(mixer);
VMR9ProcAmpControl ctrl;
ctrl.dwSize = sizeof(ctrl);
ctrl.dwFlags = ProcAmpControl9_Contrast | ProcAmpControl9_Brightness | ProcAmpControl9_Saturation | ProcAmpControl9_Hue;
VMR9ProcAmpControlRange range;
range.dwSize = sizeof(range);
range.dwProperty = ProcAmpControl9_Contrast;
HRESULT hr = mixer->GetProcAmpControlRange(0, &range);
if (FAILED(hr)) {
return;
}
ctrl.Contrast = ((contrast < 0 ? range.MinValue : range.MaxValue) - range.DefaultValue) * qAbs(contrast) + range.DefaultValue;
//brightness
range.dwProperty = ProcAmpControl9_Brightness;
hr = mixer->GetProcAmpControlRange(0, &range);
if (FAILED(hr)) {
return;
}
ctrl.Brightness = ((brightness < 0 ? range.MinValue : range.MaxValue) - range.DefaultValue) * qAbs(brightness) + range.DefaultValue;
//saturation
range.dwProperty = ProcAmpControl9_Saturation;
hr = mixer->GetProcAmpControlRange(0, &range);
if (FAILED(hr)) {
return;
}
ctrl.Saturation = ((saturation < 0 ? range.MinValue : range.MaxValue) - range.DefaultValue) * qAbs(saturation) + range.DefaultValue;
//hue
range.dwProperty = ProcAmpControl9_Hue;
hr = mixer->GetProcAmpControlRange(0, &range);
if (FAILED(hr)) {
return;
}
ctrl.Hue = ((hue < 0 ? range.MinValue : range.MaxValue) - range.DefaultValue) * qAbs(hue) + range.DefaultValue;
//finally set the settings
mixer->SetProcAmpControl(0, &ctrl);
}
#endif
}
}
QT_END_NAMESPACE
#endif //QT_NO_PHONON_VIDEO