QStringList args = app.arguments();
PerformanceMonitor::State performanceMonitorState;
bool sourceIsUrl = false;
- for (int i=1; i<args.count(); ++i) {
- const QString &arg = args.at(i);
+ for (int i = 1; i < args.size(); ++i) {
+ const QByteArray arg = args.at(i).toUtf8();
if (arg.startsWith('-')) {
if ("-volume" == arg) {
if (i+1 < args.count())
qtTrace() << "Option \"-volume\" takes a value";
}
#ifdef PERFORMANCEMONITOR_SUPPORT
- else if (PerformanceMonitor::parseArgument(arg, performanceMonitorState)) {
+ else if (performanceMonitorState.parseArgument(arg)) {
// Do nothing
}
#endif
#include "filereader.h"
#include "trace.h"
-#include <QtCore/QCoreApplication>
-#include <QtCore/QDir>
-#include <QtCore/QFile>
-#include <QtCore/QFileInfo>
-#include <QtCore/QTextStream>
-QString adjustPath(const QString &path)
-{
-#ifdef Q_OS_UNIX
-#ifdef Q_OS_MAC
- if (!QDir::isAbsolutePath(path))
- return QCoreApplication::applicationDirPath()
- + QLatin1String("/../Resources/") + path;
-#else
- QString pathInInstallDir;
- const QString applicationDirPath = QCoreApplication::applicationDirPath();
- pathInInstallDir = QString::fromLatin1("%1/../%2").arg(applicationDirPath, path);
-
- if (QFileInfo(pathInInstallDir).exists())
- return pathInInstallDir;
-#endif
-#endif
- return path;
-}
+#include <QCoreApplication>
+#include <QDir>
+#include <QFile>
+#include <QFileInfo>
+#include <QTextStream>
QString FileReader::readFile(const QString &fileName)
{
qtTrace() << "FileReader::readFile" << "fileName" << fileName;
QString content;
- QFile file(adjustPath(fileName));
+ QFile file(fileName);
if (file.open(QIODevice::ReadOnly)) {
QTextStream stream(&file);
content = stream.readAll();
**
****************************************************************************/
-#include <QtCore/QObject>
+#include <QObject>
class FileReader : public QObject
{
#ifdef PERFORMANCEMONITOR_SUPPORT
PerformanceMonitor::State performanceMonitorState;
#endif
- for (int i=1; i<args.count(); ++i) {
- const QString &arg = args.at(i);
+ for (int i = 1; i < args.size(); ++i) {
+ const QByteArray arg = args.at(i).toUtf8();
if (arg.startsWith('-')) {
if ("-volume" == arg) {
- if (i+1 < args.count())
+ if (i + 1 < args.size())
volume = 0.01 * args.at(++i).toInt();
else
qtTrace() << "Option \"-volume\" takes a value";
}
#ifdef PERFORMANCEMONITOR_SUPPORT
- else if (PerformanceMonitor::parseArgument(arg, performanceMonitorState)) {
+ else if (performanceMonitorState.parseArgument(arg)) {
// Do nothing
}
#endif
// rather than being inline in the QML file
onFragmentShaderFilenameChanged:
- fragmentShader = d.fragmentShaderCommon + fileReader.readFile(fragmentShaderFilename)
+ fragmentShader = d.fragmentShaderCommon + fileReader.readFile(":shaders/" + fragmentShaderFilename)
onVertexShaderFilenameChanged:
vertexShader = fileReader.readFile(vertexShaderFilename)
}
property real step_x: 0.0015625
property real step_y: targetHeight ? (step_x * targetWidth / targetHeight) : 0.0
- fragmentShaderFilename: "shaders/billboard.fsh"
+ fragmentShaderFilename: "billboard.fsh"
}
// Transform slider values, and bind result to shader uniforms
property real threshold: parameters.get(0).value
- fragmentShaderFilename: "shaders/blackandwhite.fsh"
+ fragmentShaderFilename: "blackandwhite.fsh"
}
import QtQuick 2.0
Effect {
- fragmentShaderFilename: "shaders/emboss.fsh"
+ fragmentShaderFilename: "emboss.fsh"
}
anchors.fill: parent
dividerValue: parent.dividerValue
property real blurSize: 4.0 * parent.parameters.get(0).value / targetHeight
- fragmentShaderFilename: "shaders/gaussianblur_v.fsh"
+ fragmentShaderFilename: "gaussianblur_v.fsh"
}
Effect {
anchors.fill: parent
dividerValue: parent.dividerValue
property real blurSize: 4.0 * parent.parameters.get(0).value / parent.targetWidth
- fragmentShaderFilename: "shaders/gaussianblur_h.fsh"
+ fragmentShaderFilename: "gaussianblur_h.fsh"
source: horizontalShaderSource
ShaderEffectSource {
import QtQuick 2.0
Effect {
- fragmentShaderFilename: "shaders/glow.fsh"
+ fragmentShaderFilename: "glow.fsh"
}
property real targetHue: parameters.get(0).value * 360
property real windowWidth: parameters.get(1).value * 60
- fragmentShaderFilename: "shaders/isolate.fsh"
+ fragmentShaderFilename: "isolate.fsh"
}
d.oldTargetHeight = targetHeight
}
- fragmentShaderFilename: "shaders/magnify.fsh"
+ fragmentShaderFilename: "magnify.fsh"
MouseArea {
anchors.fill: parent
// Transform slider values, and bind result to shader uniforms
property real curlExtent: 1.0 - parameters.get(0).value
- fragmentShaderFilename: "shaders/pagecurl.fsh"
+ fragmentShaderFilename: "pagecurl.fsh"
}
// Transform slider values, and bind result to shader uniforms
property real granularity: parameters.get(0).value * 20
- fragmentShaderFilename: "shaders/pixelate.fsh"
+ fragmentShaderFilename: "pixelate.fsh"
}
property real numColors: 8.0
- fragmentShaderFilename: "shaders/posterize.fsh"
+ fragmentShaderFilename: "posterize.fsh"
}
property real time: 0
NumberAnimation on time { loops: Animation.Infinite; from: 0; to: Math.PI * 2; duration: 600 }
- fragmentShaderFilename: "shaders/ripple.fsh"
+ fragmentShaderFilename: "ripple.fsh"
}
import QtQuick 2.0
Effect {
- fragmentShaderFilename: "shaders/sepia.fsh"
+ fragmentShaderFilename: "sepia.fsh"
}
// Transform slider values, and bind result to shader uniforms
property real amount: parameters.get(0).value * 18
- fragmentShaderFilename: "shaders/sharpen.fsh"
+ fragmentShaderFilename: "sharpen.fsh"
}
}
}
- fragmentShaderFilename: "shaders/shockwave.fsh"
+ fragmentShaderFilename: "shockwave.fsh"
}
property real resS: targetSize
property real resT: targetSize
- fragmentShaderFilename: "shaders/sobeledgedetection1.fsh"
+ fragmentShaderFilename: "sobeledgedetection1.fsh"
}
// Transform slider values, and bind result to shader uniforms
property real weight: parameters.get(0).value
- fragmentShaderFilename: "shaders/sobeledgedetection2.fsh"
+ fragmentShaderFilename: "sobeledgedetection2.fsh"
}
import QtQuick 2.0
Effect {
- fragmentShaderFilename: "shaders/tiltshift.fsh"
+ fragmentShaderFilename: "tiltshift.fsh"
}
property real magTol: 0.3
property real quantize: 8.0
- fragmentShaderFilename: "shaders/toon.fsh"
+ fragmentShaderFilename: "toon.fsh"
}
import QtQuick 2.0
Effect {
- fragmentShaderFilename: "shaders/vignette.fsh"
+ fragmentShaderFilename: "vignette.fsh"
}
import QtQuick 2.0
Effect {
- fragmentShaderFilename: "shaders/warhol.fsh"
+ fragmentShaderFilename: "warhol.fsh"
}
NumberAnimation on time { loops: Animation.Infinite; from: 0; to: Math.PI * 2; duration: 600 }
- fragmentShaderFilename: "shaders/wobble.fsh"
+ fragmentShaderFilename: "wobble.fsh"
}
QT += quick
-LOCAL_SOURCES = filereader.cpp main.cpp
-LOCAL_HEADERS = filereader.h trace.h
-
-SOURCES += $$LOCAL_SOURCES
-HEADERS += $$LOCAL_HEADERS
+SOURCES += filereader.cpp main.cpp
+HEADERS += filereader.h trace.h
RESOURCES += qmlvideofx.qrc
-SNIPPETS_PATH = ../snippets
-include($$SNIPPETS_PATH/performancemonitor/performancemonitordeclarative.pri)
+include($$PWD/../snippets/performancemonitor/performancemonitordeclarative.pri)
maemo6: {
DEFINES += SMALL_SCREEN_LAYOUT
<file>qml/qmlvideofx/main-smallscreen.qml</file>
<file>qml/qmlvideofx/ParameterPanel.qml</file>
<file>qml/qmlvideofx/Slider.qml</file>
+ <file>shaders/billboard.fsh</file>
+ <file>shaders/blackandwhite.fsh</file>
+ <file>shaders/emboss.fsh</file>
+ <file>shaders/gaussianblur_h.fsh</file>
+ <file>shaders/gaussianblur_v.fsh</file>
+ <file>shaders/glow.fsh</file>
+ <file>shaders/isolate.fsh</file>
+ <file>shaders/magnify.fsh</file>
+ <file>shaders/pagecurl.fsh</file>
+ <file>shaders/pixelate.fsh</file>
+ <file>shaders/posterize.fsh</file>
+ <file>shaders/ripple.fsh</file>
+ <file>shaders/selectionpanel.fsh</file>
+ <file>shaders/sepia.fsh</file>
+ <file>shaders/sharpen.fsh</file>
+ <file>shaders/shockwave.fsh</file>
+ <file>shaders/sobeledgedetection1.fsh</file>
+ <file>shaders/sobeledgedetection2.fsh</file>
+ <file>shaders/tiltshift.fsh</file>
+ <file>shaders/toon.fsh</file>
+ <file>shaders/vignette.fsh</file>
+ <file>shaders/warhol.fsh</file>
+ <file>shaders/wobble.fsh</file>
</qresource>
</RCC>
#ifndef TRACE_H
#define TRACE_H
-#include <QtCore/QDebug>
+#include <QDebug>
#define ENABLE_TRACE
//#define VERBOSE_TRACE
{
public:
template <typename T>
- NullDebug& operator<<(const T&) { return *this; }
+ NullDebug &operator<<(const T &) { return *this; }
};
inline NullDebug nullDebug() { return NullDebug(); }
} // namespace Trace
template <typename T>
-inline QDebug& operator<<(QDebug &debug, const Trace::PtrWrapper<T> &wrapper)
+inline QDebug &operator<<(QDebug &debug, const Trace::PtrWrapper<T> &wrapper)
{
debug.nospace() << "[" << (void*)wrapper.m_ptr << "]";
return debug.space();
}
-template<typename T>
-inline const void *qtVoidPtr(const T *ptr)
-{ return static_cast<const void *>(ptr); }
-
-#define qtThisPtr() qtVoidPtr(this)
-
#ifdef ENABLE_TRACE
inline QDebug qtTrace() { return qDebug() << "[qmlvideofx]"; }
# ifdef VERBOSE_TRACE
****************************************************************************/
#include "frequencymonitor.h"
-#include <QtCore/QDebug>
-#include <QtCore/QElapsedTimer>
-#include <QtCore/QString>
-#include <QtCore/QTime>
-#include <QtCore/QTimer>
+#include <QDebug>
+#include <QElapsedTimer>
+#include <QString>
+#include <QTime>
+#include <QTimer>
//#define VERBOSE_TRACE
class FrequencyMonitorPrivate : public QObject
{
Q_OBJECT
+
public:
FrequencyMonitorPrivate(FrequencyMonitor *parent);
void calculateInstantaneousFrequency();
m_stalledTimer->start(3 * ms);
if (m_instantaneousFrequency)
q_ptr->setActive(true);
- q_ptr->emit instantaneousFrequencyChanged(m_instantaneousFrequency);
- q_ptr->emit frequencyChanged();
+ emit q_ptr->instantaneousFrequencyChanged(m_instantaneousFrequency);
+ emit q_ptr->frequencyChanged();
}
void FrequencyMonitorPrivate::calculateAverageFrequency()
{
const qint64 ms = m_averageElapsed.restart();
m_averageFrequency = qreal(m_count * 1000) / ms;
- q_ptr->emit averageFrequencyChanged(m_averageFrequency);
- q_ptr->emit frequencyChanged();
+ emit q_ptr->averageFrequencyChanged(m_averageFrequency);
+ emit q_ptr->frequencyChanged();
m_count = 0;
}
if (m_instantaneousFrequency) {
qtVerboseTrace() << "FrequencyMonitor::stalled";
m_instantaneousFrequency = 0;
- q_ptr->emit instantaneousFrequencyChanged(m_instantaneousFrequency);
- q_ptr->emit frequencyChanged();
+ emit q_ptr->instantaneousFrequencyChanged(m_instantaneousFrequency);
+ emit q_ptr->frequencyChanged();
}
}
FrequencyMonitor::FrequencyMonitor(QObject *parent)
: QObject(parent)
-, d_ptr(0)
{
d_ptr = new FrequencyMonitorPrivate(this);
qtTrace() << "FrequencyMonitor::FrequencyMonitor";
}
-const QString &FrequencyMonitor::label() const
+QString FrequencyMonitor::label() const
{
return d_func()->m_label;
}
#ifndef FREQUENCYMONITOR_H
#define FREQUENCYMONITOR_H
-#include <QtCore/QObject>
-#include <QtCore/QTimer>
+#include <QObject>
+#include <QTimer>
class FrequencyMonitorPrivate;
Q_PROPERTY(int traceInterval READ traceInterval WRITE setTraceInterval NOTIFY traceIntervalChanged)
Q_PROPERTY(qreal instantaneousFrequency READ instantaneousFrequency NOTIFY instantaneousFrequencyChanged)
Q_PROPERTY(qreal averageFrequency READ averageFrequency NOTIFY averageFrequencyChanged)
+
public:
FrequencyMonitor(QObject *parent = 0);
~FrequencyMonitor();
static void qmlRegisterType();
- const QString &label() const;
+ QString label() const;
bool active() const;
int samplingInterval() const;
int traceInterval() const;
namespace PerformanceMonitor {
- bool parseArgument(const QString &arg, State &state)
- {
- bool result = false;
- if ("-log-perf" == arg) {
- state.logging = true;
- state.valid = true;
- result = true;
- } else if ("-no-log-perf" == arg) {
- state.logging = false;
- state.valid = true;
- result = true;
- } else if ("-show-perf" == arg) {
- state.visible = true;
- state.valid = true;
- result = true;
- } else if ("-hide-perf" == arg) {
- state.visible = false;
- state.valid = true;
- result = true;
- }
- return result;
+bool State::parseArgument(const QByteArray &arg)
+{
+ bool result = false;
+ if (arg == "-log-perf") {
+ logging = true;
+ valid = true;
+ result = true;
+ } else if (arg == "-no-log-perf") {
+ logging = false;
+ valid = true;
+ result = true;
+ } else if (arg == "-show-perf") {
+ visible = true;
+ valid = true;
+ result = true;
+ } else if (arg == "-hide-perf") {
+ visible = false;
+ valid = true;
+ result = true;
}
-
+ return result;
}
+
+} // namespace PerformanceMonitor
#ifndef PERFORMANCEMONITOR_H
#define PERFORMANCEMONITOR_H
-#include <QtCore/QString>
+#include <QByteArray>
namespace PerformanceMonitor {
- struct State {
- bool valid;
- bool logging;
- bool visible;
- State() : valid(true), logging(false), visible(true) { }
- State(bool l, bool v) : valid(true), logging(l), visible(v) { }
- bool operator==(const State &other) const
- { return logging == other.logging && visible == other.visible; }
- bool operator!=(const State &other) const
- { return logging != other.logging || visible != other.visible; }
- };
+struct State
+{
+ State() : valid(true), logging(false), visible(true) { }
+ State(bool l, bool v) : valid(true), logging(l), visible(v) { }
+ bool operator==(const State &other) const
+ { return logging == other.logging && visible == other.visible; }
+ bool operator!=(const State &other) const
+ { return logging != other.logging || visible != other.visible; }
- bool parseArgument(const QString &arg, State &state);
-}
+ bool parseArgument(const QByteArray &arg);
+
+ bool valid;
+ bool logging;
+ bool visible;
+};
+
+} // namespace PerformanceMonitor
#endif // PERFORMANCEMONITOR_H
projects / platform / upstream / qtmultimedia.git / commitdiff