slapin/qtmultimedia
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

QNX: Restructure plugins

Browse Source 
Now that the MmRenderer implementation is ported to plain QNX, rename
the directories and files accordingly:

"blackberry" becomes "qnx", replace the Bb prefix with MmRenderer for
classes concerned with mm-renderer. The legacy alsa support for plain qnx
is now "qnx-audio".

Change-Id: I6abd98ecdd713b2d5e554d42224dc30f13772f43
Reviewed-by: Thomas McGuire <thomas.mcguire@kdab.com>
This commit is contained in:
Frank Osterfeld
2013-11-05 14:28:08 +01:00
committed by The Qt Project
parent 66219c9a28
commit 99667804e1
88 changed files with 283 additions and 280 deletions
Download Patch File Download Diff File Expand all files Collapse all files

414
src/plugins/qnx/mediaplayer/mmrenderervideowindowcontrol.cpp Normal file
View File

@@ -0,0 +1,414 @@
/****************************************************************************
**
** Copyright (C) 2012 Research In Motion
** Contact: http://www.qt-project.org/legal
**
** This file is part of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and Digia. For licensing terms and
** conditions see http://qt.digia.com/licensing. For further information
** use the contact form at http://qt.digia.com/contact-us.
**
** 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, Digia gives you certain additional
** rights. These rights are described in the Digia Qt LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3.0 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU General Public License version 3.0 requirements will be
** met: http://www.gnu.org/copyleft/gpl.html.
**
**
** $QT_END_LICENSE$
**
****************************************************************************/
#include "mmrenderervideowindowcontrol.h"
#include "mmrendererutil.h"
#include <QtCore/qdebug.h>
#include <QtGui/qguiapplication.h>
#include <QtGui/qpa/qplatformnativeinterface.h>
#include <QtGui/qscreen.h>
#include <QtGui/qwindow.h>
#include <mm/renderer.h>
QT_BEGIN_NAMESPACE
static int winIdCounter = 0;
MmRendererVideoWindowControl::MmRendererVideoWindowControl(QObject *parent)
: QVideoWindowControl(parent),
m_videoId(-1),
m_winId(0),
m_context(0),
m_fullscreen(false),
m_aspectRatioMode(Qt::IgnoreAspectRatio),
m_window(0),
m_hue(0),
m_brightness(0),
m_contrast(0),
m_saturation(0)
{
}
MmRendererVideoWindowControl::~MmRendererVideoWindowControl()
{
}
WId MmRendererVideoWindowControl::winId() const
{
return m_winId;
}
void MmRendererVideoWindowControl::setWinId(WId id)
{
m_winId = id;
}
QRect MmRendererVideoWindowControl::displayRect() const
{
return m_displayRect ;
}
void MmRendererVideoWindowControl::setDisplayRect(const QRect &rect)
{
if (m_displayRect != rect) {
m_displayRect = rect;
updateVideoPosition();
}
}
bool MmRendererVideoWindowControl::isFullScreen() const
{
return m_fullscreen;
}
void MmRendererVideoWindowControl::setFullScreen(bool fullScreen)
{
if (m_fullscreen != fullScreen) {
m_fullscreen = fullScreen;
updateVideoPosition();
emit fullScreenChanged(m_fullscreen);
}
}
void MmRendererVideoWindowControl::repaint()
{
// Nothing we can or should do here
}
QSize MmRendererVideoWindowControl::nativeSize() const
{
return QSize(m_metaData.width(), m_metaData.height());
}
Qt::AspectRatioMode MmRendererVideoWindowControl::aspectRatioMode() const
{
return m_aspectRatioMode;
}
void MmRendererVideoWindowControl::setAspectRatioMode(Qt::AspectRatioMode mode)
{
m_aspectRatioMode = mode;
}
int MmRendererVideoWindowControl::brightness() const
{
return m_brightness;
}
void MmRendererVideoWindowControl::setBrightness(int brightness)
{
if (m_brightness != brightness) {
m_brightness = brightness;
updateBrightness();
emit brightnessChanged(m_brightness);
}
}
int MmRendererVideoWindowControl::contrast() const
{
return m_contrast;
}
void MmRendererVideoWindowControl::setContrast(int contrast)
{
if (m_contrast != contrast) {
m_contrast = contrast;
updateContrast();
emit contrastChanged(m_contrast);
}
}
int MmRendererVideoWindowControl::hue() const
{
return m_hue;
}
void MmRendererVideoWindowControl::setHue(int hue)
{
if (m_hue != hue) {
m_hue = hue;
updateHue();
emit hueChanged(m_hue);
}
}
int MmRendererVideoWindowControl::saturation() const
{
return m_saturation;
}
void MmRendererVideoWindowControl::setSaturation(int saturation)
{
if (m_saturation != saturation) {
m_saturation = saturation;
updateSaturation();
emit saturationChanged(m_saturation);
}
}
void MmRendererVideoWindowControl::attachDisplay(mmr_context_t *context)
{
if (m_videoId != -1) {
qDebug() << "MmRendererVideoWindowControl: Video output already attached!";
return;
}
if (!context) {
qDebug() << "MmRendererVideoWindowControl: No media player context!";
return;
}
QWindow *window = findWindow(m_winId);
if (!window) {
qDebug() << "MmRendererVideoWindowControl: No video window!";
return;
}
QPlatformNativeInterface * const nativeInterface = QGuiApplication::platformNativeInterface();
if (!nativeInterface) {
qDebug() << "MmRendererVideoWindowControl: Unable to get platform native interface";
return;
}
const char * const groupNameData = static_cast<const char *>(
nativeInterface->nativeResourceForWindow("windowGroup", window));
if (!groupNameData) {
qDebug() << "MmRendererVideoWindowControl: Unable to find window group for window" << window;
return;
}
const QString groupName = QString::fromLatin1(groupNameData);
m_windowName = QString("MmRendererVideoWindowControl_%1_%2").arg(winIdCounter++)
.arg(QCoreApplication::applicationPid());
nativeInterface->setWindowProperty(window->handle(),
QStringLiteral("mmRendererWindowName"), m_windowName);
// Start with an invisible window. If it would be visible right away, it would be at the wrong
// position, and we can only change the position once we get the window handle.
const QString videoDeviceUrl =
QString("screen:?winid=%1&wingrp=%2&initflags=invisible&nodstviewport=1").arg(m_windowName).arg(groupName);
m_videoId = mmr_output_attach(context, videoDeviceUrl.toLatin1(), "video");
if (m_videoId == -1) {
qDebug() << mmErrorMessage("mmr_output_attach() for video failed", context);
return;
}
m_context = context;
updateVideoPosition();
updateHue();
updateContrast();
updateBrightness();
updateSaturation();
}
void MmRendererVideoWindowControl::updateVideoPosition()
{
QWindow * const window = findWindow(m_winId);
if (m_context && m_videoId != -1 && window) {
QPoint topLeft = m_fullscreen ?
QPoint(0,0) :
window->mapToGlobal(m_displayRect.topLeft());
QScreen * const screen = window->screen();
int width = m_fullscreen ?
screen->size().width() :
m_displayRect.width();
int height = m_fullscreen ?
screen->size().height() :
m_displayRect.height();
if (m_metaData.hasVideo()) { // We need the source size to do aspect ratio scaling
const qreal sourceRatio = m_metaData.width() / static_cast<float>(m_metaData.height());
const qreal targetRatio = width / static_cast<float>(height);
if (m_aspectRatioMode == Qt::KeepAspectRatio) {
if (targetRatio < sourceRatio) {
// Need to make height smaller
const int newHeight = width / sourceRatio;
const int heightDiff = height - newHeight;
topLeft.ry() += heightDiff / 2;
height = newHeight;
} else {
// Need to make width smaller
const int newWidth = sourceRatio * height;
const int widthDiff = width - newWidth;
topLeft.rx() += widthDiff / 2;
width = newWidth;
}
} else if (m_aspectRatioMode == Qt::KeepAspectRatioByExpanding) {
if (targetRatio < sourceRatio) {
// Need to make width larger
const int newWidth = sourceRatio * height;
const int widthDiff = newWidth - width;
topLeft.rx() -= widthDiff / 2;
width = newWidth;
} else {
// Need to make height larger
const int newHeight = width / sourceRatio;
const int heightDiff = newHeight - height;
topLeft.ry() -= heightDiff / 2;
height = newHeight;
}
}
}
if (m_window != 0) {
const int position[2] = { topLeft.x(), topLeft.y() };
const int size[2] = { width, height };
const int visible = m_displayRect.isValid();
if (screen_set_window_property_iv(m_window, SCREEN_PROPERTY_POSITION, position) != 0)
perror("Setting video position failed");
if (screen_set_window_property_iv(m_window, SCREEN_PROPERTY_SIZE, size) != 0)
perror("Setting video size failed");
if (screen_set_window_property_iv(m_window, SCREEN_PROPERTY_VISIBLE, &visible) != 0)
perror("Setting video visibility failed");
}
}
}
void MmRendererVideoWindowControl::updateBrightness()
{
if (m_window != 0) {
const int backendValue = m_brightness * 2.55f;
if (screen_set_window_property_iv(m_window, SCREEN_PROPERTY_BRIGHTNESS, &backendValue) != 0)
perror("Setting brightness failed");
}
}
void MmRendererVideoWindowControl::updateContrast()
{
if (m_window != 0) {
const int backendValue = m_contrast * 1.27f;
if (screen_set_window_property_iv(m_window, SCREEN_PROPERTY_CONTRAST, &backendValue) != 0)
perror("Setting contrast failed");
}
}
void MmRendererVideoWindowControl::updateHue()
{
if (m_window != 0) {
const int backendValue = m_hue * 1.27f;
if (screen_set_window_property_iv(m_window, SCREEN_PROPERTY_HUE, &backendValue) != 0)
perror("Setting hue failed");
}
}
void MmRendererVideoWindowControl::updateSaturation()
{
if (m_window != 0) {
const int backendValue = m_saturation * 1.27f;
if (screen_set_window_property_iv(m_window, SCREEN_PROPERTY_SATURATION, &backendValue) != 0)
perror("Setting saturation failed");
}
}
void MmRendererVideoWindowControl::detachDisplay()
{
if (m_context && m_videoId != -1)
mmr_output_detach(m_context, m_videoId);
m_context = 0;
m_videoId = -1;
m_metaData.clear();
m_windowName.clear();
m_window = 0;
m_hue = 0;
m_brightness = 0;
m_contrast = 0;
m_saturation = 0;
}
void MmRendererVideoWindowControl::setMetaData(const MmRendererMetaData &metaData)
{
m_metaData = metaData;
emit nativeSizeChanged();
// To handle the updated source size data
updateVideoPosition();
}
void MmRendererVideoWindowControl::screenEventHandler(const screen_event_t &screen_event)
{
int eventType;
if (screen_get_event_property_iv(screen_event, SCREEN_PROPERTY_TYPE, &eventType) != 0) {
perror("MmRendererVideoWindowControl: Failed to query screen event type");
return;
}
if (eventType != SCREEN_EVENT_CREATE)
return;
screen_window_t window = 0;
if (screen_get_event_property_pv(screen_event, SCREEN_PROPERTY_WINDOW, (void**)&window) != 0) {
perror("MmRendererVideoWindowControl: Failed to query window property");
return;
}
const int maxIdStrLength = 128;
char idString[maxIdStrLength];
if (screen_get_window_property_cv(window, SCREEN_PROPERTY_ID_STRING, maxIdStrLength, idString) != 0) {
perror("MmRendererVideoWindowControl: Failed to query window ID string");
return;
}
if (m_windowName == idString) {
m_window = window;
updateVideoPosition();
const int visibleFlag = 1;
if (screen_set_window_property_iv(m_window, SCREEN_PROPERTY_VISIBLE, &visibleFlag) != 0) {
perror("MmRendererVideoWindowControl: Failed to make window visible");
return;
}
}
}
QWindow *MmRendererVideoWindowControl::findWindow(WId id) const
{
Q_FOREACH (QWindow *window, QGuiApplication::allWindows())
if (window->winId() == id)
return window;
return 0;
}
QT_END_NAMESPACE