****************************************************************************/
#include "audiodecoder.h"
-#include <iostream>
+#include <stdio.h>
AudioDecoder::AudioDecoder(bool isPlayback, bool isDelete)
: m_cout(stdout, QIODevice::WriteOnly)
#ifndef AUDIODECODER_H
#define AUDIODECODER_H
-#include <qaudiodecoder.h>
#include "wavefilewriter.h"
+
+#include <QAudioDecoder>
#include <QSoundEffect>
#include <QTextStream>
-QT_USE_NAMESPACE
-
class AudioDecoder : public QObject
{
Q_OBJECT
+
public:
AudioDecoder(bool isPlayback, bool isDelete);
~AudioDecoder() { }
void setTargetFilename(const QString &fileName);
-Q_SIGNALS:
+signals:
void done();
public slots:
**
****************************************************************************/
-#include <QtCore/QCoreApplication>
+#include "audiodecoder.h"
+
+#include <QCoreApplication>
+#include <QDir>
+#include <QFileInfo>
#include <QTextStream>
-#include <iostream>
-#include <qfileinfo.h>
-#include <qdir.h>
-#include "audiodecoder.h"
+#include <stdio.h>
int main(int argc, char *argv[])
{
decoder.start();
return app.exec();
-};
+}
return true;
}
-bool WaveFileWriter::write(const QAudioBuffer& buffer)
+bool WaveFileWriter::write(const QAudioBuffer &buffer)
{
if (buffer.format() != m_format)
return false; // buffer format has changed
- qint64 written = file.write((const char*)buffer.constData(), buffer.byteCount());
+ qint64 written = file.write((const char *)buffer.constData(), buffer.byteCount());
m_dataLength += written;
return written == buffer.byteCount();
}
return result;
}
-bool WaveFileWriter::writeHeader(const QAudioFormat& format)
+bool WaveFileWriter::writeHeader(const QAudioFormat &format)
{
// check if format is supported
if (format.byteOrder() == QAudioFormat::BigEndian || format.sampleType() != QAudioFormat::SignedInt)
#ifndef WAVEFILEWRITER_H
#define WAVEFILEWRITER_H
+#include <QAudioBuffer>
+#include <QFile>
#include <QObject>
-#include <qfile.h>
-#include <qaudiobuffer.h>
class WaveFileWriter : public QObject
{
Q_OBJECT
+
public:
explicit WaveFileWriter(QObject *parent = 0);
~WaveFileWriter();
- bool open(const QString& fileName, const QAudioFormat& format);
- bool write(const QAudioBuffer& buffer);
+ bool open(const QString &fileName, const QAudioFormat &format);
+ bool write(const QAudioBuffer &buffer);
bool close();
bool isOpen() const { return file.isOpen(); }
private:
- bool writeHeader(const QAudioFormat& format);
+ bool writeHeader(const QAudioFormat &format);
bool writeDataLength();
QFile file;
**
****************************************************************************/
-
-#include <qaudiodeviceinfo.h>
-
#include "audiodevices.h"
// Utility functions for converting QAudioFormat fields into text
-QString toString(QAudioFormat::SampleType sampleType)
+static QString toString(QAudioFormat::SampleType sampleType)
{
QString result("Unknown");
switch (sampleType) {
return result;
}
-QString toString(QAudioFormat::Endian endian)
+static QString toString(QAudioFormat::Endian endian)
{
QString result("Unknown");
switch (endian) {
}
-AudioDevicesBase::AudioDevicesBase(QWidget *parent, Qt::WindowFlags f)
- : QMainWindow(parent, f)
+AudioDevicesBase::AudioDevicesBase(QWidget *parent)
+ : QMainWindow(parent)
{
setupUi(this);
}
AudioDevicesBase::~AudioDevicesBase() {}
-AudioTest::AudioTest(QWidget *parent, Qt::WindowFlags f)
- : AudioDevicesBase(parent, f)
+AudioTest::AudioTest(QWidget *parent)
+ : AudioDevicesBase(parent)
{
mode = QAudio::AudioOutput;
settings.setChannelCount(chz.at(0));
codecsBox->clear();
- QStringList codecz = deviceInfo.supportedCodecs();
- for (int i = 0; i < codecz.size(); ++i)
- codecsBox->addItem(QString("%1").arg(codecz.at(i)));
- if (codecz.size())
- settings.setCodec(codecz.at(0));
+ QStringList codecs = deviceInfo.supportedCodecs();
+ for (int i = 0; i < codecs.size(); ++i)
+ codecsBox->addItem(QString("%1").arg(codecs.at(i)));
+ if (codecs.size())
+ settings.setCodec(codecs.at(0));
// Add false to create failed condition!
codecsBox->addItem("audio/test");
#ifndef AUDIODEVICES_H
#define AUDIODEVICES_H
-#include <QObject>
+#include <QAudioDeviceInfo>
#include <QMainWindow>
-#include <qaudiodeviceinfo.h>
+#include <QObject>
#include "ui_audiodevicesbase.h"
class AudioDevicesBase : public QMainWindow, public Ui::AudioDevicesBase
{
public:
- AudioDevicesBase(QWidget *parent = 0, Qt::WindowFlags f = 0);
+ AudioDevicesBase(QWidget *parent = 0);
virtual ~AudioDevicesBase();
};
class AudioTest : public AudioDevicesBase
{
Q_OBJECT
+
public:
- AudioTest(QWidget *parent = 0, Qt::WindowFlags f = 0);
+ AudioTest(QWidget *parent = 0);
virtual ~AudioTest();
QAudioDeviceInfo deviceInfo;
#include <math.h>
#include <QDateTime>
-
#include <QDebug>
#include <QPainter>
#include <QVBoxLayout>
-
-#include <qaudiodeviceinfo.h>
-#include <qaudioinput.h>
-
-#include <QtCore/qendian.h>
+#include <QAudioDeviceInfo>
+#include <QAudioInput>
+#include <qendian.h>
#include "audioinput.h"
void InputTest::readMore()
{
- if(!m_audioInput)
+ if (!m_audioInput)
return;
qint64 len = m_audioInput->bytesReady();
- if(len > BufferSize)
+ if (len > BufferSize)
len = BufferSize;
qint64 l = m_input->read(m_buffer.data(), len);
- if(l > 0) {
+ if (l > 0)
m_audioInfo->write(m_buffer.constData(), l);
- }
}
void InputTest::toggleMode()
void InputTest::toggleSuspend()
{
// toggle suspend/resume
- if(m_audioInput->state() == QAudio::SuspendedState) {
+ if (m_audioInput->state() == QAudio::SuspendedState) {
qWarning() << "status: Suspended, resume()";
m_audioInput->resume();
m_suspendResumeButton->setText(tr(SUSPEND_LABEL));
#ifndef AUDIOINPUT_H
#define AUDIOINPUT_H
-#include <QPixmap>
-#include <QWidget>
-#include <QObject>
+#include <QAudioInput>
+#include <QByteArray>
+#include <QComboBox>
#include <QMainWindow>
+#include <QObject>
+#include <QPixmap>
#include <QPushButton>
-#include <QComboBox>
-#include <QByteArray>
#include <QSlider>
-
-#include <qaudioinput.h>
+#include <QWidget>
class AudioInfo : public QIODevice
{
Q_OBJECT
+
public:
AudioInfo(const QAudioFormat &format, QObject *parent);
~AudioInfo();
QPixmap m_pixmap;
};
+
class InputTest : public QMainWindow
{
Q_OBJECT
+
public:
InputTest();
~InputTest();
QByteArray m_buffer;
};
-#endif
-
+#endif // AUDIOINPUT_H
TEMPLATE = app
TARGET = audioinput
-QT += multimedia
+QT += multimedia widgets
HEADERS = audioinput.h
sources.path = $$[QT_INSTALL_EXAMPLES]/qtmultimedia/audioinput
INSTALLS += target sources
-
-QT+=widgets
**
****************************************************************************/
+#include <QAudioDeviceInfo>
+#include <QAudioOutput>
#include <QDebug>
#include <QVBoxLayout>
+#include <qmath.h>
+#include <qendian.h>
-#include <qaudiooutput.h>
-#include <qaudiodeviceinfo.h>
-#include <QtCore/qmath.h>
-#include <QtCore/qendian.h>
#include "audiooutput.h"
#define PUSH_MODE_LABEL "Enable push mode"
#include <math.h>
-#include <QObject>
-#include <QMainWindow>
+#include <QAudioOutput>
+#include <QByteArray>
+#include <QComboBox>
+#include <QIODevice>
#include <QLabel>
+#include <QMainWindow>
+#include <QObject>
+#include <QPushButton>
#include <QSlider>
-#include <QIODevice>
#include <QTimer>
-#include <QPushButton>
-#include <QComboBox>
-#include <QByteArray>
-
-#include <qaudiooutput.h>
class Generator : public QIODevice
{
Q_OBJECT
+
public:
Generator(const QAudioFormat &format, qint64 durationUs, int sampleRate, QObject *parent);
~Generator();
class AudioTest : public QMainWindow
{
Q_OBJECT
+
public:
AudioTest();
~AudioTest();
void createAudioOutput();
private:
- QTimer* m_pullTimer;
+ QTimer *m_pullTimer;
// Owned by layout
- QPushButton* m_modeButton;
- QPushButton* m_suspendResumeButton;
- QComboBox* m_deviceBox;
- QLabel* m_volumeLabel;
- QSlider* m_volumeSlider;
+ QPushButton *m_modeButton;
+ QPushButton *m_suspendResumeButton;
+ QComboBox *m_deviceBox;
+ QLabel *m_volumeLabel;
+ QSlider *m_volumeSlider;
QAudioDeviceInfo m_device;
- Generator* m_generator;
- QAudioOutput* m_audioOutput;
- QIODevice* m_output; // not owned
- QAudioFormat m_format;
+ Generator *m_generator;
+ QAudioOutput *m_audioOutput;
+ QIODevice *m_output; // not owned
+ QAudioFormat m_format;
+
+ bool m_pullMode;
+ QByteArray m_buffer;
- bool m_pullMode;
- QByteArray m_buffer;
private slots:
void notified();
void pullTimerExpired();
void volumeChanged(int);
};
-#endif
-
+#endif // AUDIOOUTPUT_H
TEMPLATE = app
TARGET = audiooutput
-QT += multimedia
+QT += multimedia widgets
HEADERS = audiooutput.h
sources.path = $$[QT_INSTALL_EXAMPLES]/qtmultimedia/audiooutput
INSTALLS += target sources
-
-QT+=widgets
**
****************************************************************************/
-
-#include <QtWidgets>
+#include <QApplication>
#include "audiooutput.h"
-int main(int argv, char **args)
+int main(int argc, char *argv[])
{
- QApplication app(argv, args);
+ QApplication app(argc, argv);
app.setApplicationName("Audio Output Test");
AudioTest audio;
**
****************************************************************************/
-#include <QtCore/qdir.h>
-#include <QtWidgets/qfiledialog.h>
-
-#include <qaudiorecorder.h>
-#include <qmediarecorder.h>
-#include <qaudioprobe.h>
+#include <QAudioProbe>
+#include <QAudioRecorder>
+#include <QDir>
+#include <QFileDialog>
+#include <QMediaRecorder>
#include "audiorecorder.h"
#include "ui_audiorecorder.h"
#endif
-AudioRecorder::AudioRecorder(QWidget *parent)
- :
+static qreal getPeakValue(const QAudioFormat &format);
+static qreal getBufferLevel(const QAudioBuffer &buffer);
+
+template <class T>
+static qreal getBufferLevel(const T *buffer, int samples);
+
+AudioRecorder::AudioRecorder(QWidget *parent) :
QMainWindow(parent),
ui(new Ui::AudioRecorder),
outputLocationSet(false)
audioRecorder = new QAudioRecorder(this);
probe = new QAudioProbe;
- connect(probe, SIGNAL(audioBufferProbed(const QAudioBuffer&)), this, SLOT(processBuffer(QAudioBuffer)));
+ connect(probe, SIGNAL(audioBufferProbed(QAudioBuffer)), this, SLOT(processBuffer(QAudioBuffer)));
probe->setSource(audioRecorder);
//audio devices
int lastImage = 0;
int fileCount = 0;
- foreach(QString fileName, outputDir.entryList(QStringList() << "testclip_*")) {
+ foreach (const QString &fileName, outputDir.entryList(QStringList(QString("testclip_*")))) {
int imgNumber = fileName.mid(5, fileName.size() - 9).toInt();
lastImage = qMax(lastImage, imgNumber);
if (outputDir.exists(fileName))
fileCount += 1;
}
lastImage += fileCount;
- QUrl location(QDir::toNativeSeparators(outputDir.canonicalPath() + QString("/testclip_%1").arg(lastImage + 1, 4, 10, QLatin1Char('0'))));
+ QUrl location(QDir::toNativeSeparators(outputDir.canonicalPath()
+ + QString("/testclip_%1").arg(lastImage + 1, 4, 10, QLatin1Char('0'))));
return location;
}
// This function returns the maximum possible sample value for a given audio format
-qreal AudioRecorder::GetPeakValue(const QAudioFormat& format)
+qreal getPeakValue(const QAudioFormat& format)
{
// Note: Only the most common sample formats are supported
if (!format.isValid())
case QAudioFormat::SignedInt:
if (format.sampleSize() == 32)
return 2147483648.0;
- else if (format.sampleSize() == 16)
+ if (format.sampleSize() == 16)
return 32768.0;
- else if (format.sampleSize() == 8)
+ if (format.sampleSize() == 8)
return 128.0;
break;
case QAudioFormat::UnSignedInt:
return 0.0;
}
-qreal AudioRecorder::GetBufferLevel(const QAudioBuffer& buffer)
+qreal getBufferLevel(const QAudioBuffer& buffer)
{
if (!buffer.format().isValid() || buffer.format().byteOrder() != QAudioFormat::LittleEndian)
return 0.0;
if (buffer.format().codec() != "audio/pcm")
return 0.0;
- qreal peak_value = GetPeakValue(buffer.format());
+ qreal peak_value = getPeakValue(buffer.format());
if (qFuzzyCompare(peak_value, 0.0))
return 0.0;
break;
case QAudioFormat::Float:
if (buffer.format().sampleSize() == 32)
- return GetBufferLevel(buffer.constData<float>(), buffer.sampleCount()) / peak_value;
+ return getBufferLevel(buffer.constData<float>(), buffer.sampleCount()) / peak_value;
break;
case QAudioFormat::SignedInt:
if (buffer.format().sampleSize() == 32)
- return GetBufferLevel(buffer.constData<long int>(), buffer.sampleCount()) / peak_value;
- else if (buffer.format().sampleSize() == 16)
- return GetBufferLevel(buffer.constData<short int>(), buffer.sampleCount()) / peak_value;
- else if (buffer.format().sampleSize() == 8)
- return GetBufferLevel(buffer.constData<signed char>(), buffer.sampleCount()) / peak_value;
+ return getBufferLevel(buffer.constData<long int>(), buffer.sampleCount()) / peak_value;
+ if (buffer.format().sampleSize() == 16)
+ return getBufferLevel(buffer.constData<short int>(), buffer.sampleCount()) / peak_value;
+ if (buffer.format().sampleSize() == 8)
+ return getBufferLevel(buffer.constData<signed char>(), buffer.sampleCount()) / peak_value;
break;
}
}
template <class T>
-qreal AudioRecorder::GetBufferLevel(const T* buffer, int samples)
+qreal getBufferLevel(const T *buffer, int samples)
{
qreal max_value = 0.0;
- for (int i = 0; i < samples; i++) {
- qreal value = qAbs((qreal)buffer[i]);
+ for (int i = 0; i < samples; ++i) {
+ qreal value = qAbs(qreal(buffer[i]));
if (value > max_value)
max_value = value;
}
void AudioRecorder::processBuffer(const QAudioBuffer& buffer)
{
- qreal level = GetBufferLevel(buffer);
+ qreal level = getBufferLevel(buffer);
ui->audioLevel->setLevel(level);
}
#ifndef AUDIORECORDER_H
#define AUDIORECORDER_H
-#include <QtCore/qurl.h>
-#include <QtWidgets/qmainwindow.h>
-
-#include <qmediarecorder.h>
-
+#include <QMainWindow>
+#include <QMediaRecorder>
+#include <QUrl>
QT_BEGIN_NAMESPACE
-
-namespace Ui {
- class AudioRecorder;
-}
-
+namespace Ui { class AudioRecorder; }
class QAudioRecorder;
class QAudioProbe;
class QAudioBuffer;
QT_END_NAMESPACE
-QT_USE_NAMESPACE
-
class AudioRecorder : public QMainWindow
{
Q_OBJECT
+
public:
AudioRecorder(QWidget *parent = 0);
~AudioRecorder();
QUrl generateAudioFilePath();
private:
- static qreal GetPeakValue(const QAudioFormat& format);
- static qreal GetBufferLevel(const QAudioBuffer& buffer);
-
- template <class T>
- static qreal GetBufferLevel(const T* buffer, int samples);
-
Ui::AudioRecorder *ui;
- QAudioRecorder* audioRecorder;
- QAudioProbe* probe;
+ QAudioRecorder *audioRecorder;
+ QAudioProbe *probe;
bool outputLocationSet;
};
-#endif
+#endif // AUDIORECORDER_H
recorder.show();
return app.exec();
-};
+}
#include <QWidget>
-QT_USE_NAMESPACE
-
class QAudioLevel : public QWidget
{
Q_OBJECT
TEMPLATE = app
TARGET = customvideoitem
-QT += multimedia multimediawidgets
+QT += multimedia multimediawidgets widgets
contains(QT_CONFIG, opengl): QT += opengl
sources.path = $$[QT_INSTALL_EXAMPLES]/qtmultimedia/customvideoitem
INSTALLS += target sources
-
-QT+=widgets
#include "videoplayer.h"
-#include <QtWidgets/QApplication>
+#include <QApplication>
-int main(int argc, char **argv)
+int main(int argc, char *argv[])
{
QApplication app(argc, argv);
#include "videoitem.h"
-#include <QtWidgets>
-#include <qvideosurfaceformat.h>
+#include <QPainter>
+#include <QTransform>
+#include <QVideoSurfaceFormat>
VideoItem::VideoItem(QGraphicsItem *parent)
: QGraphicsItem(parent)
#ifndef VIDEOITEM_H
#define VIDEOITEM_H
-#include <qabstractvideosurface.h>
-#include <QtWidgets/QGraphicsItem>
+#include <QAbstractVideoSurface>
+#include <QGraphicsItem>
class VideoItem
: public QAbstractVideoSurface,
{
Q_OBJECT
Q_INTERFACES(QGraphicsItem)
+
public:
explicit VideoItem(QGraphicsItem *parentItem = 0);
~VideoItem();
QRectF boundingRect() const;
- void paint(
- QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = 0);
+ void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = 0);
//video surface
QList<QVideoFrame::PixelFormat> supportedPixelFormats(
bool framePainted;
};
-#endif
+#endif // VIDEOITEM_H
#include "videoitem.h"
#include <QtWidgets>
-#include <qvideosurfaceformat.h>
+#include <QVideoSurfaceFormat>
#if !defined(QT_NO_OPENGL)
-# include <QtOpenGL/QGLWidget>
+# include <QGLWidget>
#endif
-VideoPlayer::VideoPlayer(QWidget *parent, Qt::WindowFlags flags)
- : QWidget(parent, flags)
+VideoPlayer::VideoPlayer(QWidget *parent)
+ : QWidget(parent)
, mediaPlayer(0, QMediaPlayer::VideoSurface)
, videoItem(0)
, playButton(0)
#ifndef VIDEOPLAYER_H
#define VIDEOPLAYER_H
-#include <qmediaplayer.h>
-
-#include <QtGui/QMovie>
-#include <QtWidgets/QWidget>
+#include <QMediaPlayer>
+#include <QMovie>
+#include <QWidget>
QT_BEGIN_NAMESPACE
class QAbstractButton;
class QSlider;
QT_END_NAMESPACE
-
class VideoItem;
class VideoPlayer : public QWidget
{
Q_OBJECT
+
public:
- VideoPlayer(QWidget *parent = 0, Qt::WindowFlags flags = 0);
+ VideoPlayer(QWidget *parent = 0);
~VideoPlayer();
QSize sizeHint() const { return QSize(800, 600); }
QSlider *positionSlider;
};
-#endif
+#endif // VIDEOPLAYER_H
TEMPLATE = app
TARGET = customvideowidget
-QT += multimedia multimediawidgets
+QT += multimedia multimediawidgets widgets
HEADERS = \
videoplayer.h \
sources.path = $$[QT_INSTALL_EXAMPLES]/qtmultimedia/customvideowidget
INSTALLS += target sources
-
-QT+=widgets
#ifndef VIDEOPLAYER_H
#define VIDEOPLAYER_H
-#include <qmediaplayer.h>
-
-#include <QtGui/QMovie>
-#include <QtWidgets/QWidget>
+#include <QMediaPlayer>
+#include <QMovie>
+#include <QWidget>
QT_BEGIN_NAMESPACE
class QAbstractButton;
class VideoPlayer : public QWidget
{
Q_OBJECT
+
public:
VideoPlayer(QWidget *parent = 0);
~VideoPlayer();
QSlider *positionSlider;
};
-#endif
+#endif // VIDEOPLAYER_H
#include "videowidgetsurface.h"
-#include <QtWidgets/QWidget>
-
-QT_BEGIN_NAMESPACE
-class QAbstractVideoSurface;
-QT_END_NAMESPACE
-
-class VideoWidgetSurface;
+#include <QWidget>
//! [0]
class VideoWidget : public QWidget
{
Q_OBJECT
+
public:
VideoWidget(QWidget *parent = 0);
~VideoWidget();
};
//! [0]
-#endif
+#endif // VIDEOWIDGET_H
#ifndef VIDEOWIDGETSURFACE_H
#define VIDEOWIDGETSURFACE_H
-#include <QtCore/QRect>
-#include <QtGui/QImage>
-#include <qabstractvideosurface.h>
-#include <qvideoframe.h>
+#include <QAbstractVideoSurface>
+#include <QImage>
+#include <QRect>
+#include <QVideoFrame>
//! [0]
class VideoWidgetSurface : public QAbstractVideoSurface
{
Q_OBJECT
+
public:
VideoWidgetSurface(QWidget *widget, QObject *parent = 0);
#ifndef HISTOGRAMWIDGET_H
#define HISTOGRAMWIDGET_H
-#include <QWidget>
-#include <qvideoframe.h>
#include <QThread>
+#include <QVideoFrame>
+#include <QWidget>
-QT_USE_NAMESPACE
-
-class FrameProcessor: public QObject {
+class FrameProcessor: public QObject
+{
Q_OBJECT
public slots:
class HistogramWidget : public QWidget
{
Q_OBJECT
+
public:
explicit HistogramWidget(QWidget *parent = 0);
~HistogramWidget();
#include "player.h"
-#include <QtWidgets>
+#include <QApplication>
int main(int argc, char *argv[])
{
Player player;
#if defined(Q_WS_SIMULATOR)
-# if (QT_VERSION >= QT_VERSION_CHECK(4, 7, 2))
player.setAttribute(Qt::WA_LockLandscapeOrientation);
-# else
- // lock screen orientation
- CAknAppUi* appUi = dynamic_cast<CAknAppUi*>(CEikonEnv::Static()->AppUi());
- if(appUi){
- QT_TRAP_THROWING(appUi ->SetOrientationL(CAknAppUi::EAppUiOrientationLandscape));
- }
-# endif
player.showMaximized();
#else
player.show();
#endif
return app.exec();
-};
+}
#include "playlistmodel.h"
#include "histogramwidget.h"
-#include <qmediaservice.h>
-#include <qmediaplaylist.h>
-#include <qvideoprobe.h>
-
+#include <QMediaService>
+#include <QMediaPlaylist>
+#include <QVideoProbe>
#include <QtWidgets>
void Player::handleCursor(QMediaPlayer::MediaStatus status)
{
#ifndef QT_NO_CURSOR
- if( status == QMediaPlayer::LoadingMedia ||
+ if (status == QMediaPlayer::LoadingMedia ||
status == QMediaPlayer::BufferingMedia ||
status == QMediaPlayer::StalledMedia)
setCursor(QCursor(Qt::BusyCursor));
colorDialog->show();
}
#endif
-
#ifndef PLAYER_H
#define PLAYER_H
-#include <QtWidgets/QWidget>
-
-#include <qmediaplayer.h>
-#include <qmediaplaylist.h>
#include "videowidget.h"
+#include <QWidget>
+#include <QMediaPlayer>
+#include <QMediaPlaylist>
QT_BEGIN_NAMESPACE
class QAbstractItemView;
class QLabel;
+class QMediaPlayer;
class QModelIndex;
-class QSlider;
class QPushButton;
+class QSlider;
class QVideoProbe;
-
-class QMediaPlayer;
class QVideoWidget;
QT_END_NAMESPACE
-QT_USE_NAMESPACE
-
class PlaylistModel;
class HistogramWidget;
class Player : public QWidget
{
Q_OBJECT
+
public:
Player(QWidget *parent = 0);
~Player();
-Q_SIGNALS:
+signals:
void fullScreenChanged(bool fullScreen);
private slots:
#ifndef PLAYER_NO_COLOROPTIONS
void showColorDialog();
#endif
- void addToPlaylist(const QStringList& fileNames);
+ void addToPlaylist(const QStringList &fileNames);
private:
void setTrackInfo(const QString &info);
qint64 duration;
};
-#endif
+#endif // PLAYER_H
TEMPLATE = app
TARGET = player
-CONFIG += qt warn_on
-
QT += network \
xml \
multimedia \
- multimediawidgets
+ multimediawidgets \
+ widgets
HEADERS = \
player.h \
DEFINES += PLAYER_NO_COLOROPTIONS
}
-#install
target.path = $$[QT_INSTALL_EXAMPLES]/qtmultimedia/player
sources.files = $$SOURCES $HEADERS $$RESOURCES $$FORMS *.pro
sources.path = $$[QT_INSTALL_EXAMPLES]/qtmultimedia/player
INSTALLS += target sources
-
-QT+=widgets
#include "playercontrols.h"
-#include <QtWidgets/qboxlayout.h>
-#include <QtWidgets/qslider.h>
-#include <QtWidgets/qstyle.h>
-#include <QtWidgets/qtoolbutton.h>
-#include <QtWidgets/qcombobox.h>
+#include <QBoxLayout>
+#include <QSlider>
+#include <QStyle>
+#include <QToolButton>
+#include <QComboBox>
PlayerControls::PlayerControls(QWidget *parent)
: QWidget(parent)
connect(volumeSlider, SIGNAL(sliderMoved(int)), this, SIGNAL(changeVolume(int)));
-
rateBox = new QComboBox(this);
rateBox->addItem("0.5x", QVariant(0.5));
rateBox->addItem("1.0x", QVariant(1.0));
layout->addWidget(playButton);
layout->addWidget(nextButton);
layout->addWidget(muteButton);
- if (volumeSlider)
- layout->addWidget(volumeSlider);
-
- if (rateBox)
- layout->addWidget(rateBox);
+ layout->addWidget(volumeSlider);
+ layout->addWidget(rateBox);
setLayout(layout);
}
void PlayerControls::setPlaybackRate(float rate)
{
- for (int i=0; i<rateBox->count(); i++) {
+ for (int i = 0; i < rateBox->count(); ++i) {
if (qFuzzyCompare(rate, float(rateBox->itemData(i).toDouble()))) {
rateBox->setCurrentIndex(i);
return;
}
}
- rateBox->addItem( QString("%1x").arg(rate), QVariant(rate));
- rateBox->setCurrentIndex(rateBox->count()-1);
+ rateBox->addItem(QString("%1x").arg(rate), QVariant(rate));
+ rateBox->setCurrentIndex(rateBox->count() - 1);
}
void PlayerControls::updateRate()
#ifndef PLAYERCONTROLS_H
#define PLAYERCONTROLS_H
-#include <qmediaplayer.h>
-
-#include <QtWidgets/qwidget.h>
+#include <QMediaPlayer>
+#include <QWidget>
QT_BEGIN_NAMESPACE
class QAbstractButton;
class QComboBox;
QT_END_NAMESPACE
-QT_USE_NAMESPACE
-
class PlayerControls : public QWidget
{
Q_OBJECT
+
public:
PlayerControls(QWidget *parent = 0);
QMediaPlayer::State state() const;
-
int volume() const;
bool isMuted() const;
qreal playbackRate() const;
QComboBox *rateBox;
};
-#endif
+#endif // PLAYERCONTROLS_H
#include "playlistmodel.h"
-#include <QtCore/qfileinfo.h>
-#include <QtCore/qurl.h>
-
-#include <qmediaplaylist.h>
+#include <QFileInfo>
+#include <QUrl>
+#include <QMediaPlaylist>
PlaylistModel::PlaylistModel(QObject *parent)
: QAbstractItemModel(parent)
m_data.clear();
emit dataChanged(index(start,0), index(end,ColumnCount));
}
-
-
#ifndef PLAYLISTMODEL_H
#define PLAYLISTMODEL_H
-#include <qtmultimediadefs.h>
-#include <QtCore/qabstractitemmodel.h>
+#include <QAbstractItemModel>
QT_BEGIN_NAMESPACE
class QMediaPlaylist;
QT_END_NAMESPACE
-QT_USE_NAMESPACE
-
class PlaylistModel : public QAbstractItemModel
{
Q_OBJECT
+
public:
enum Column
{
QMap<QModelIndex, QVariant> m_data;
};
-#endif
+#endif // PLAYLISTMODEL_H
#include "videowidget.h"
-#include <QtWidgets>
+#include <QKeyEvent>
+#include <QMouseEvent>
VideoWidget::VideoWidget(QWidget *parent)
: QVideoWidget(parent)
{
if (event->key() == Qt::Key_Escape && isFullScreen()) {
setFullScreen(false);
-
event->accept();
} else if (event->key() == Qt::Key_Enter && event->modifiers() & Qt::Key_Alt) {
setFullScreen(!isFullScreen());
-
event->accept();
} else {
QVideoWidget::keyPressEvent(event);
void VideoWidget::mouseDoubleClickEvent(QMouseEvent *event)
{
setFullScreen(!isFullScreen());
-
event->accept();
}
** $QT_END_LICENSE$
**
****************************************************************************/
+
#ifndef VIDEOWIDGET_H
#define VIDEOWIDGET_H
-#include <qvideowidget.h>
-
-QT_USE_NAMESPACE
+#include <QVideoWidget>
class VideoWidget : public QVideoWidget
{
Q_OBJECT
+
public:
VideoWidget(QWidget *parent = 0);
void mousePressEvent(QMouseEvent *event);
};
-#endif
+#endif // VIDEOWIDGET_H
#include "radio.h"
-#include <QtWidgets>
-
Radio::Radio()
{
radio = new QRadioTuner;
connect(radio, SIGNAL(error(QRadioTuner::Error)), this, SLOT(error(QRadioTuner::Error)));
- if(radio->isBandSupported(QRadioTuner::FM))
+ if (radio->isBandSupported(QRadioTuner::FM))
radio->setBand(QRadioTuner::FM);
QWidget *window = new QWidget;
- QVBoxLayout* layout = new QVBoxLayout;
- QHBoxLayout* buttonBar = new QHBoxLayout;
- QHBoxLayout* topBar = new QHBoxLayout;
+ QVBoxLayout *layout = new QVBoxLayout;
+ QHBoxLayout *buttonBar = new QHBoxLayout;
+ QHBoxLayout *topBar = new QHBoxLayout;
layout->addLayout(topBar);
freq = new QLabel;
freq->setText(QString("%1 kHz").arg(radio->frequency()/1000));
topBar->addWidget(freq);
- connect(radio,SIGNAL(frequencyChanged(int)),this,SLOT(freqChanged(int)));
+ connect(radio, SIGNAL(frequencyChanged(int)), SLOT(freqChanged(int)));
signal = new QLabel;
if (radio->isAvailable())
else
signal->setText(tr("No radio found"));
topBar->addWidget(signal);
- connect(radio,SIGNAL(signalStrengthChanged(int)),this,SLOT(signalChanged(int)));
+ connect(radio, SIGNAL(signalStrengthChanged(int)), SLOT(signalChanged(int)));
volumeSlider = new QSlider(Qt::Vertical,this);
- volumeSlider->setRange(0,100);
+ volumeSlider->setRange(0, 100);
volumeSlider->setValue(50);
- connect(volumeSlider,SIGNAL(valueChanged(int)),this,SLOT(updateVolume(int)));
+ connect(volumeSlider, SIGNAL(valueChanged(int)), SLOT(updateVolume(int)));
topBar->addWidget(volumeSlider);
layout->addLayout(buttonBar);
searchLeft = new QPushButton;
searchLeft->setText(tr("scan Down"));
- connect(searchLeft,SIGNAL(clicked()),SLOT(searchDown()));
+ connect(searchLeft, SIGNAL(clicked()), SLOT(searchDown()));
buttonBar->addWidget(searchLeft);
left = new QPushButton;
left->setText(tr("Freq Down"));
- connect(left,SIGNAL(clicked()),SLOT(freqDown()));
+ connect(left, SIGNAL(clicked()), SLOT(freqDown()));
buttonBar->addWidget(left);
right = new QPushButton;
- connect(right,SIGNAL(clicked()),SLOT(freqUp()));
+ connect(right, SIGNAL(clicked()), SLOT(freqUp()));
right->setText(tr("Freq Up"));
buttonBar->addWidget(right);
searchRight = new QPushButton;
searchRight->setText(tr("scan Up"));
- connect(searchRight,SIGNAL(clicked()),SLOT(searchUp()));
+ connect(searchRight, SIGNAL(clicked()), SLOT(searchUp()));
buttonBar->addWidget(searchRight);
window->setLayout(layout);
void Radio::freqUp()
{
int f = radio->frequency();
- f = f + radio->frequencyStep(QRadioTuner::FM);
+ f += radio->frequencyStep(QRadioTuner::FM);
radio->setFrequency(f);
}
void Radio::freqDown()
{
int f = radio->frequency();
- f = f - radio->frequencyStep(QRadioTuner::FM);
+ f -= radio->frequencyStep(QRadioTuner::FM);
radio->setFrequency(f);
}
void Radio::error(QRadioTuner::Error error)
{
- const QMetaObject* metaObj = radio->metaObject();
+ const QMetaObject *metaObj = radio->metaObject();
QMetaEnum errorEnum = metaObj->enumerator(metaObj->indexOfEnumerator("Error"));
qWarning().nospace() << "Warning: Example application received error QRadioTuner::" << errorEnum.valueToKey(error);
}
#define RADIO_H
#include <QtWidgets>
-
-#include <qradiotuner.h>
-
-QT_BEGIN_NAMESPACE
-class QLabel;
-class QPushButton;
-class QSlider;
-QT_END_NAMESPACE
-
-QT_USE_NAMESPACE
+#include <QRadioTuner>
class Radio : public QMainWindow
{
void error(QRadioTuner::Error error);
private:
- QLabel* freq;
- QLabel* signal;
- QPushButton* left;
- QPushButton* right;
- QPushButton* searchLeft;
- QPushButton* searchRight;
- QSlider* volumeSlider;
- QRadioTuner* radio;
+ QLabel *freq;
+ QLabel *signal;
+ QPushButton *left;
+ QPushButton *right;
+ QPushButton *searchLeft;
+ QPushButton *searchRight;
+ QSlider *volumeSlider;
+ QRadioTuner *radio;
};
-#endif
+#endif // RADIO_H
TARGET = spectrum
-QT += multimedia
+QT += multimedia widgets
SOURCES += main.cpp \
engine.cpp \
QMAKE_LFLAGS += -Wl,--rpath=\\\$\$ORIGIN
}
}
-
-
-QT+=widgets
#include <math.h>
+#include <QAudioInput>
+#include <QAudioOutput>
#include <QCoreApplication>
+#include <QDebug>
+#include <QFile>
#include <QMetaObject>
#include <QSet>
-#include <QtMultimedia/QAudioInput>
-#include <QtMultimedia/QAudioOutput>
-#include <QDebug>
#include <QThread>
-#include <QFile>
//-----------------------------------------------------------------------------
// Constants
#include "spectrumanalyser.h"
#include "wavfile.h"
-#include <QObject>
-#include <QByteArray>
+#include <QAudioDeviceInfo>
+#include <QAudioFormat>
#include <QBuffer>
+#include <QByteArray>
+#include <QDir>
+#include <QObject>
#include <QVector>
-#include <QtMultimedia/QAudioDeviceInfo>
-#include <QtMultimedia/QAudioFormat>
#ifdef DUMP_CAPTURED_AUDIO
#define DUMP_DATA
#define DUMP_DATA
#endif
-#ifdef DUMP_DATA
-#include <QDir>
-#endif
-
class FrequencySpectrum;
-QT_FORWARD_DECLARE_CLASS(QAudioInput)
-QT_FORWARD_DECLARE_CLASS(QAudioOutput)
-QT_FORWARD_DECLARE_CLASS(QFile)
+QT_BEGIN_NAMESPACE
+class QAudioInput;
+class QAudioOutput;
+QT_END_NAMESPACE
/**
* This class interfaces with the QtMultimedia audio classes, and also with
* of audio data, meanwhile performing real-time analysis of the audio level
* and frequency spectrum.
*/
-class Engine : public QObject {
+class Engine : public QObject
+{
Q_OBJECT
+
public:
- Engine(QObject *parent = 0);
+ explicit Engine(QObject *parent = 0);
~Engine();
- const QList<QAudioDeviceInfo>& availableAudioInputDevices() const
+ const QList<QAudioDeviceInfo> &availableAudioInputDevices() const
{ return m_availableAudioInputDevices; }
- const QList<QAudioDeviceInfo>& availableAudioOutputDevices() const
+ const QList<QAudioDeviceInfo> &availableAudioOutputDevices() const
{ return m_availableAudioOutputDevices; }
- QAudio::Mode mode() const { return m_mode; }
- QAudio::State state() const { return m_state; }
+ QAudio::Mode mode() const { return m_mode; }
+ QAudio::State state() const { return m_state; }
/**
* \return Current audio format
* \note May be QAudioFormat() if engine is not initialized
*/
- const QAudioFormat& format() const { return m_format; }
+ const QAudioFormat& format() const { return m_format; }
/**
* Stop any ongoing recording or playback, and reset to ground state.
* Position of the audio input device.
* \return Position in bytes.
*/
- qint64 recordPosition() const { return m_recordPosition; }
+ qint64 recordPosition() const { return m_recordPosition; }
/**
* RMS level of the most recently processed set of audio samples.
* \return Level in range (0.0, 1.0)
*/
- qreal rmsLevel() const { return m_rmsLevel; }
+ qreal rmsLevel() const { return m_rmsLevel; }
/**
* Peak level of the most recently processed set of audio samples.
* \return Level in range (0.0, 1.0)
*/
- qreal peakLevel() const { return m_peakLevel; }
+ qreal peakLevel() const { return m_peakLevel; }
/**
* Position of the audio output device.
* \return Position in bytes.
*/
- qint64 playPosition() const { return m_playPosition; }
+ qint64 playPosition() const { return m_playPosition; }
/**
* Length of the internal engine buffer.
* Amount of data held in the buffer.
* \return Data length in bytes.
*/
- qint64 dataLength() const { return m_dataLength; }
+ qint64 dataLength() const { return m_dataLength; }
/**
* Set window function applied to audio data before spectral analysis.
return m_elements.count();
}
-FrequencySpectrum::Element& FrequencySpectrum::operator[](int index)
+FrequencySpectrum::Element &FrequencySpectrum::operator[](int index)
{
return m_elements[index];
}
-const FrequencySpectrum::Element& FrequencySpectrum::operator[](int index) const
+const FrequencySpectrum::Element &FrequencySpectrum::operator[](int index) const
{
return m_elements[index];
}
* RMS and peak levels of the window of audio samples most recently analyzed
* by the Engine.
*/
-class LevelMeter : public QWidget {
+class LevelMeter : public QWidget
+{
Q_OBJECT
+
public:
- LevelMeter(QWidget *parent = 0);
+ explicit LevelMeter(QWidget *parent = 0);
~LevelMeter();
void paintEvent(QPaintEvent *event);
**
****************************************************************************/
-#include <QtWidgets/QApplication>
#include "mainwidget.h"
+#include <QApplication>
-int main(int argc, char **argv)
+int main(int argc, char *argv[])
{
QApplication app(argc, argv);
app.setApplicationName("QtMultimedia spectrum analyzer");
- MainWidget w;
+ MainWidget w;
w.show();
return app.exec();
m_generateToneAction->setChecked(GenerateToneMode == m_mode);
m_recordAction->setChecked(RecordMode == m_mode);
}
-
#ifndef MAINWIDGET_H
#define MAINWIDGET_H
-#include <QWidget>
+#include <QAudio>
#include <QIcon>
-#include <QtMultimedia/qaudio.h>
+#include <QWidget>
class Engine;
class FrequencySpectrum;
-class ProgressBar;
-class Spectrograph;
-class Waveform;
class LevelMeter;
+class ProgressBar;
class SettingsDialog;
+class Spectrograph;
class ToneGeneratorDialog;
+class Waveform;
-QT_FORWARD_DECLARE_CLASS(QAudioFormat)
-QT_FORWARD_DECLARE_CLASS(QLabel)
-QT_FORWARD_DECLARE_CLASS(QPushButton)
-QT_FORWARD_DECLARE_CLASS(QMenu)
-QT_FORWARD_DECLARE_CLASS(QAction)
+QT_BEGIN_NAMESPACE
+class QAction;
+class QAudioFormat;
+class QLabel;
+class QMenu;
+class QPushButton;
+QT_END_NAMESPACE
/**
* Main application widget, responsible for connecting the various UI
* elements to the Engine.
*/
-class MainWidget : public QWidget {
+class MainWidget : public QWidget
+{
Q_OBJECT
+
public:
- MainWidget(QWidget *parent = 0);
+ explicit MainWidget(QWidget *parent = 0);
~MainWidget();
// QObject
QAction* m_loadFileAction;
QAction* m_generateToneAction;
QAction* m_recordAction;
-
};
#endif // MAINWIDGET_H
* Widget which displays a the current fill state of the Engine's internal
* buffer, and the current play/record position within that buffer.
*/
-class ProgressBar : public QWidget {
+class ProgressBar : public QWidget
+{
Q_OBJECT
+
public:
- ProgressBar(QWidget *parent = 0);
+ explicit ProgressBar(QWidget *parent = 0);
~ProgressBar();
void reset();
qint64 m_playPosition;
qint64 m_windowPosition;
qint64 m_windowLength;
-
};
#endif // PROGRESSBAR_H
****************************************************************************/
#include "settingsdialog.h"
+#include <QCheckBox>
#include <QComboBox>
#include <QDialogButtonBox>
#include <QLabel>
#include <QPushButton>
-#include <QVBoxLayout>
-#include <QCheckBox>
#include <QSlider>
#include <QSpinBox>
+#include <QVBoxLayout>
SettingsDialog::SettingsDialog(
const QList<QAudioDeviceInfo> &availableInputDevices,
#include "spectrum.h"
#include <QDialog>
-#include <QtMultimedia/QAudioDeviceInfo>
+#include <QAudioDeviceInfo>
-QT_FORWARD_DECLARE_CLASS(QComboBox)
-QT_FORWARD_DECLARE_CLASS(QCheckBox)
-QT_FORWARD_DECLARE_CLASS(QSlider)
-QT_FORWARD_DECLARE_CLASS(QSpinBox)
-QT_FORWARD_DECLARE_CLASS(QGridLayout)
+QT_BEGIN_NAMESPACE
+class QComboBox;
+class QCheckBox;
+class QSlider;
+class QSpinBox;
+class QGridLayout;
+QT_END_NAMESPACE
/**
* Dialog used to control settings such as the audio input / output device
* and the windowing function.
*/
-class SettingsDialog : public QDialog {
+class SettingsDialog : public QDialog
+{
Q_OBJECT
+
public:
SettingsDialog(const QList<QAudioDeviceInfo> &availableInputDevices,
const QList<QAudioDeviceInfo> &availableOutputDevices,
QWidget *parent = 0);
~SettingsDialog();
- WindowFunction windowFunction() const { return m_windowFunction; }
- const QAudioDeviceInfo& inputDevice() const { return m_inputDevice; }
- const QAudioDeviceInfo& outputDevice() const { return m_outputDevice; }
+ WindowFunction windowFunction() const { return m_windowFunction; }
+ const QAudioDeviceInfo &inputDevice() const { return m_inputDevice; }
+ const QAudioDeviceInfo &outputDevice() const { return m_outputDevice; }
private slots:
void windowFunctionChanged(int index);
QAudioDeviceInfo m_inputDevice;
QAudioDeviceInfo m_outputDevice;
- QComboBox* m_inputDeviceComboBox;
- QComboBox* m_outputDeviceComboBox;
-
- QComboBox* m_windowFunctionComboBox;
-
+ QComboBox *m_inputDeviceComboBox;
+ QComboBox *m_outputDeviceComboBox;
+ QComboBox *m_windowFunctionComboBox;
};
#endif // SETTINGSDIALOG_H
****************************************************************************/
#include "spectrograph.h"
-#include <QPainter>
-#include <QMouseEvent>
#include <QDebug>
+#include <QMouseEvent>
+#include <QPainter>
#include <QTimerEvent>
const int NullTimerId = -1;
#ifndef SPECTROGRAPH_H
#define SPECTROGRAPH_H
-#include <QWidget>
#include "frequencyspectrum.h"
-QT_FORWARD_DECLARE_CLASS(QMouseEvent)
+#include <QWidget>
/**
* Widget which displays a spectrograph showing the frequency spectrum
* of the window of audio samples most recently analyzed by the Engine.
*/
-class Spectrograph : public QWidget {
+class Spectrograph : public QWidget
+{
Q_OBJECT
+
public:
- Spectrograph(QWidget *parent = 0);
+ explicit Spectrograph(QWidget *parent = 0);
~Spectrograph();
void setParams(int numBars, qreal lowFreq, qreal highFreq);
qreal m_lowFreq;
qreal m_highFreq;
FrequencySpectrum m_spectrum;
-
-
};
#endif // SPECTROGRAPH_H
#ifndef SPECTRUM_H
#define SPECTRUM_H
-#include <QtCore/qglobal.h>
+#include <qglobal.h>
#include "utils.h"
#include "fftreal_wrapper.h" // For FFTLengthPowerOfTwo
const WindowFunction DefaultWindowFunction = HannWindow;
-struct Tone {
+struct Tone
+{
Tone(qreal freq = 0.0, qreal amp = 0.0)
: frequency(freq), amplitude(amp)
{ }
qreal amplitude;
};
-struct SweptTone {
+struct SweptTone
+{
SweptTone(qreal start = 0.0, qreal end = 0.0, qreal amp = 0.0)
: startFreq(start), endFreq(end), amplitude(amp)
{ Q_ASSERT(end >= start); }
#include "spectrumanalyser.h"
#include "utils.h"
+#include "fftreal_wrapper.h"
-#include <QtCore/qmath.h>
-#include <QtCore/qmetatype.h>
-#include <QtMultimedia/QAudioFormat>
+#include <qmath.h>
+#include <qmetatype.h>
+#include <QAudioFormat>
#include <QThread>
-#include "fftreal_wrapper.h"
-
SpectrumAnalyserThread::SpectrumAnalyserThread(QObject *parent)
: QObject(parent)
#ifndef DISABLE_FFT
emit spectrumChanged(spectrum);
m_state = Idle;
}
-
-
-
-
class SpectrumAnalyserThread : public QObject
{
Q_OBJECT
+
public:
SpectrumAnalyserThread(QObject *parent);
~SpectrumAnalyserThread();
class SpectrumAnalyser : public QObject
{
Q_OBJECT
+
public:
SpectrumAnalyser(QObject *parent = 0);
~SpectrumAnalyser();
#include "spectrum.h"
#include "utils.h"
#include <QByteArray>
-#include <QtMultimedia/QAudioFormat>
-#include <QtCore/qmath.h>
-#include <QtCore/qendian.h>
+#include <QAudioFormat>
+#include <qmath.h>
+#include <qendian.h>
void generateTone(const SweptTone &tone, const QAudioFormat &format, QByteArray &buffer)
{
phaseStep += phaseStepStep;
}
}
-
#ifndef TONEGENERATOR_H
#define TONEGENERATOR_H
-#include <QtCore/qglobal.h>
+#include <qglobal.h>
#include "spectrum.h"
-QT_FORWARD_DECLARE_CLASS(QAudioFormat)
-QT_FORWARD_DECLARE_CLASS(QByteArray)
+QT_BEGIN_NAMESPACE
+class QAudioFormat;
+class QByteArray;
+QT_END_NAMESPACE
/**
* Generate a sine wave
m_amplitudeSlider->setValue(ToneGeneratorAmplitudeDefault);
// Add widgets to layout
-
- QScopedPointer<QGridLayout> frequencyControlLayout(new QGridLayout);
+ QGridLayout *frequencyControlLayout = new QGridLayout;
QLabel *frequencyLabel = new QLabel(tr("Frequency (Hz)"), this);
frequencyControlLayout->addWidget(frequencyLabel, 0, 0, 2, 1);
frequencyControlLayout->addWidget(m_frequencySlider, 0, 1);
frequencyControlLayout->addWidget(m_frequencySpinBox, 1, 1);
- m_toneGeneratorFrequencyControl->setLayout(frequencyControlLayout.data());
- frequencyControlLayout.take(); // ownership transferred to m_toneGeneratorFrequencyControl
+ m_toneGeneratorFrequencyControl->setLayout(frequencyControlLayout);
m_toneGeneratorFrequencyControl->setEnabled(false);
- QScopedPointer<QGridLayout> toneGeneratorLayout(new QGridLayout);
+ QGridLayout *toneGeneratorLayout = new QGridLayout;
QLabel *amplitudeLabel = new QLabel(tr("Amplitude"), this);
toneGeneratorLayout->addWidget(m_toneGeneratorSweepCheckBox, 0, 1);
toneGeneratorLayout->addWidget(m_toneGeneratorFrequencyControl, 1, 0, 1, 2);
toneGeneratorLayout->addWidget(amplitudeLabel, 2, 0);
toneGeneratorLayout->addWidget(m_amplitudeSlider, 2, 1);
- m_toneGeneratorControl->setLayout(toneGeneratorLayout.data());
+ m_toneGeneratorControl->setLayout(toneGeneratorLayout);
m_toneGeneratorControl->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Fixed);
dialogLayout->addWidget(m_toneGeneratorControl);
- toneGeneratorLayout.take(); // ownership transferred
// Connect
CHECKED_CONNECT(m_toneGeneratorSweepCheckBox, SIGNAL(toggled(bool)),
#define TONEGENERATORDIALOG_H
#include "spectrum.h"
+#include <QAudioDeviceInfo>
#include <QDialog>
-#include <QtMultimedia/QAudioDeviceInfo>
-QT_FORWARD_DECLARE_CLASS(QCheckBox)
-QT_FORWARD_DECLARE_CLASS(QSlider)
-QT_FORWARD_DECLARE_CLASS(QSpinBox)
-QT_FORWARD_DECLARE_CLASS(QGridLayout)
+QT_BEGIN_NAMESPACE
+class QCheckBox;
+class QSlider;
+class QSpinBox;
+class QGridLayout;
+QT_END_NAMESPACE
/**
* Dialog which controls the parameters of the tone generator.
*/
-class ToneGeneratorDialog : public QDialog {
+class ToneGeneratorDialog : public QDialog
+{
Q_OBJECT
+
public:
- ToneGeneratorDialog(QWidget *parent = 0);
+ explicit ToneGeneratorDialog(QWidget *parent = 0);
~ToneGeneratorDialog();
bool isFrequencySweepEnabled() const;
void frequencySweepEnabled(bool enabled);
private:
- QCheckBox* m_toneGeneratorSweepCheckBox;
- bool m_frequencySweepEnabled;
- QWidget* m_toneGeneratorControl;
- QWidget* m_toneGeneratorFrequencyControl;
- QSlider* m_frequencySlider;
- QSpinBox* m_frequencySpinBox;
- qreal m_frequency;
- QSlider* m_amplitudeSlider;
-
+ QCheckBox *m_toneGeneratorSweepCheckBox;
+ bool m_frequencySweepEnabled;
+ QWidget *m_toneGeneratorControl;
+ QWidget *m_toneGeneratorFrequencyControl;
+ QSlider *m_frequencySlider;
+ QSpinBox *m_frequencySpinBox;
+ qreal m_frequency;
+ QSlider *m_amplitudeSlider;
};
#endif // TONEGENERATORDIALOG_H
**
****************************************************************************/
-#include <QtMultimedia/QAudioFormat>
+#include <QAudioFormat>
#include "utils.h"
qint64 audioDuration(const QAudioFormat &format, qint64 bytes)
bool isPCMS16LE(const QAudioFormat &format)
{
- return (isPCM(format) &&
- format.sampleType() == QAudioFormat::SignedInt &&
- format.sampleSize() == 16 &&
- format.byteOrder() == QAudioFormat::LittleEndian);
+ return isPCM(format) &&
+ format.sampleType() == QAudioFormat::SignedInt &&
+ format.sampleSize() == 16 &&
+ format.byteOrder() == QAudioFormat::LittleEndian;
}
const qint16 PCMS16MaxValue = 32767;
#ifndef WAVEFORM_H
#define WAVEFORM_H
-#include <QWidget>
-#include <QtMultimedia/QAudioFormat>
+#include <QAudioFormat>
#include <QPixmap>
#include <QScopedPointer>
-
-QT_FORWARD_DECLARE_CLASS(QByteArray)
+#include <QWidget>
/**
* Widget which displays a section of the audio waveform.
* outside the widget, it is moved to the right end of the tile array and
* painted with the next section of the waveform.
*/
-class Waveform : public QWidget {
+class Waveform : public QWidget
+{
Q_OBJECT
+
public:
- Waveform(QWidget *parent = 0);
+ explicit Waveform(QWidget *parent = 0);
~Waveform();
// QWidget
qint64 m_windowPosition;
qint64 m_windowLength;
-
};
#endif // WAVEFORM_H
**
****************************************************************************/
-#include <QtCore/qendian.h>
+#include <qendian.h>
#include <QVector>
#include <QDebug>
#include "utils.h"
**
****************************************************************************/
-
#ifndef WAVFILE_H
#define WAVFILE_H
-#include <QtCore/qobject.h>
-#include <QtCore/qfile.h>
-#include <QtMultimedia/qaudioformat.h>
+#include <QObject>
+#include <QFile>
+#include <QAudioFormat>
class WavFile : public QFile
{
private:
QAudioFormat m_fileFormat;
qint64 m_headerLength;
-
};
-#endif
-
+#endif // WAVFILE_H
# Ensure that library is built before application
CONFIG += ordered
+QT += widgets
-!contains(DEFINES, DISABLE_FFT) {
- SUBDIRS += 3rdparty/fftreal
-}
-
+!contains(DEFINES, DISABLE_FFT): SUBDIRS += 3rdparty/fftreal
SUBDIRS += app
TARGET = spectrum
sources.files = README.txt spectrum.pri spectrum.pro TODO.txt
sources.path = $$[QT_INSTALL_EXAMPLES]/qtmultimedia/spectrum
INSTALLS += sources
-
-QT+=widgets
#include "videoplayer.h"
-#include <QtWidgets/QApplication>
+#include <QApplication>
int main(int argc, char **argv)
{
#include "videoplayer.h"
#include <QtWidgets>
-#include <qvideosurfaceformat.h>
-#include <qgraphicsvideoitem.h>
+#include <QVideoSurfaceFormat>
+#include <QGraphicsVideoItem>
-VideoPlayer::VideoPlayer(QWidget *parent, Qt::WindowFlags flags)
- : QWidget(parent, flags)
+VideoPlayer::VideoPlayer(QWidget *parent)
+ : QWidget(parent)
, mediaPlayer(0, QMediaPlayer::VideoSurface)
, videoItem(0)
, playButton(0)
#ifndef VIDEOPLAYER_H
#define VIDEOPLAYER_H
-#include <qmediaplayer.h>
-
-#include <QtGui/QMovie>
-#include <QtWidgets/QWidget>
+#include <QMediaPlayer>
+#include <QMovie>
+#include <QWidget>
QT_BEGIN_NAMESPACE
class QAbstractButton;
class VideoPlayer : public QWidget
{
Q_OBJECT
+
public:
- VideoPlayer(QWidget *parent = 0, Qt::WindowFlags flags = 0);
+ VideoPlayer(QWidget *parent = 0);
~VideoPlayer();
QSize sizeHint() const { return QSize(800, 600); }
projects / platform / upstream / qtmultimedia.git / commitdiff