summaryrefslogtreecommitdiffstats
path: root/tests/auto/qvideosurfaceformat/tst_qvideosurfaceformat.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'tests/auto/qvideosurfaceformat/tst_qvideosurfaceformat.cpp')
-rw-r--r--tests/auto/qvideosurfaceformat/tst_qvideosurfaceformat.cpp745
1 files changed, 745 insertions, 0 deletions
diff --git a/tests/auto/qvideosurfaceformat/tst_qvideosurfaceformat.cpp b/tests/auto/qvideosurfaceformat/tst_qvideosurfaceformat.cpp
new file mode 100644
index 0000000..1bab37b
--- /dev/null
+++ b/tests/auto/qvideosurfaceformat/tst_qvideosurfaceformat.cpp
@@ -0,0 +1,745 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the test suite of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** 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, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, 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.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at http://qt.nokia.com/contact.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <QtTest/QtTest>
+
+#include <QtMultimedia/QVideoSurfaceFormat>
+
+class tst_QVideoSurfaceFormat : public QObject
+{
+ Q_OBJECT
+public:
+ tst_QVideoSurfaceFormat();
+ ~tst_QVideoSurfaceFormat();
+
+public slots:
+ void initTestCase();
+ void cleanupTestCase();
+ void init();
+ void cleanup();
+
+private slots:
+ void constructNull();
+ void construct_data();
+ void construct();
+ void frameSize_data();
+ void frameSize();
+ void viewport_data();
+ void viewport();
+ void scanLineDirection_data();
+ void scanLineDirection();
+ void frameRate_data();
+ void frameRate();
+ void yuvColorSpace_data();
+ void yuvColorSpace();
+ void pixelAspectRatio_data();
+ void pixelAspectRatio();
+ void sizeHint_data();
+ void sizeHint();
+ void staticPropertyNames();
+ void dynamicProperty();
+ void compare();
+ void copy();
+ void assign();
+};
+
+Q_DECLARE_METATYPE(QVideoSurfaceFormat::ViewportMode)
+
+
+tst_QVideoSurfaceFormat::tst_QVideoSurfaceFormat()
+{
+}
+
+tst_QVideoSurfaceFormat::~tst_QVideoSurfaceFormat()
+{
+}
+
+void tst_QVideoSurfaceFormat::initTestCase()
+{
+}
+
+void tst_QVideoSurfaceFormat::cleanupTestCase()
+{
+}
+
+void tst_QVideoSurfaceFormat::init()
+{
+}
+
+void tst_QVideoSurfaceFormat::cleanup()
+{
+}
+
+void tst_QVideoSurfaceFormat::constructNull()
+{
+ QVideoSurfaceFormat format;
+
+ QVERIFY(!format.isValid());
+ QCOMPARE(format.handleType(), QAbstractVideoBuffer::NoHandle);
+ QCOMPARE(format.pixelFormat(), QVideoFrame::Format_Invalid);
+ QCOMPARE(format.frameSize(), QSize());
+ QCOMPARE(format.frameWidth(), -1);
+ QCOMPARE(format.frameHeight(), -1);
+ QCOMPARE(format.viewport(), QRect());
+ QCOMPARE(format.scanLineDirection(), QVideoSurfaceFormat::TopToBottom);
+ QCOMPARE(format.frameRate(), QVideoSurfaceFormat::FrameRate());
+ QCOMPARE(format.pixelAspectRatio(), QSize(1, 1));
+ QCOMPARE(format.yuvColorSpace(), QVideoSurfaceFormat::YCbCr_Undefined);
+}
+
+void tst_QVideoSurfaceFormat::construct_data()
+{
+ QTest::addColumn<QSize>("frameSize");
+ QTest::addColumn<QVideoFrame::PixelFormat>("pixelFormat");
+ QTest::addColumn<QAbstractVideoBuffer::HandleType>("handleType");
+
+ QTest::newRow("32x32 rgb32 no handle")
+ << QSize(32, 32)
+ << QVideoFrame::Format_RGB32
+ << QAbstractVideoBuffer::NoHandle;
+
+ QTest::newRow("1024x768 YUV444 GL texture")
+ << QSize(32, 32)
+ << QVideoFrame::Format_YUV444
+ << QAbstractVideoBuffer::GLTextureHandle;
+}
+
+void tst_QVideoSurfaceFormat::construct()
+{
+ QFETCH(QSize, frameSize);
+ QFETCH(QVideoFrame::PixelFormat, pixelFormat);
+ QFETCH(QAbstractVideoBuffer::HandleType, handleType);
+
+ QRect viewport(QPoint(0, 0), frameSize);
+
+ QVideoSurfaceFormat format(frameSize, pixelFormat, handleType);
+
+ QCOMPARE(format.handleType(), handleType);
+ QCOMPARE(format.pixelFormat(), pixelFormat);
+ QCOMPARE(format.frameSize(), frameSize);
+ QCOMPARE(format.frameWidth(), frameSize.width());
+ QCOMPARE(format.frameHeight(), frameSize.height());
+ QCOMPARE(format.viewport(), viewport);
+ QCOMPARE(format.scanLineDirection(), QVideoSurfaceFormat::TopToBottom);
+ QCOMPARE(format.frameRate(), QVideoSurfaceFormat::FrameRate());
+ QCOMPARE(format.pixelAspectRatio(), QSize(1, 1));
+ QCOMPARE(format.yuvColorSpace(), QVideoSurfaceFormat::YCbCr_Undefined);
+}
+
+void tst_QVideoSurfaceFormat::frameSize_data()
+{
+ QTest::addColumn<QSize>("initialSize");
+ QTest::addColumn<QSize>("newSize");
+
+ QTest::newRow("grow")
+ << QSize(64, 64)
+ << QSize(1024, 1024);
+ QTest::newRow("shrink")
+ << QSize(1024, 1024)
+ << QSize(64, 64);
+ QTest::newRow("unchanged")
+ << QSize(512, 512)
+ << QSize(512, 512);
+}
+
+void tst_QVideoSurfaceFormat::frameSize()
+{
+ QFETCH(QSize, initialSize);
+ QFETCH(QSize, newSize);
+
+ QVideoSurfaceFormat format(initialSize, QVideoFrame::Format_RGB32);
+
+ format.setFrameSize(newSize);
+
+ QCOMPARE(format.frameSize(), newSize);
+ QCOMPARE(format.property("frameSize").toSize(), newSize);
+ QCOMPARE(format.frameWidth(), newSize.width());
+ QCOMPARE(format.property("frameWidth").toInt(), newSize.width());
+ QCOMPARE(format.frameHeight(), newSize.height());
+ QCOMPARE(format.property("frameHeight").toInt(), newSize.height());
+}
+
+void tst_QVideoSurfaceFormat::viewport_data()
+{
+ QTest::addColumn<QSize>("initialSize");
+ QTest::addColumn<QRect>("viewport");
+ QTest::addColumn<QSize>("newSize");
+ QTest::addColumn<QVideoSurfaceFormat::ViewportMode>("viewportMode");
+ QTest::addColumn<QRect>("expectedViewport");
+
+ QTest::newRow("grow reset")
+ << QSize(64, 64)
+ << QRect(8, 8, 48, 48)
+ << QSize(1024, 1024)
+ << QVideoSurfaceFormat::ResetViewport
+ << QRect(0, 0, 1024, 1024);
+ QTest::newRow("grow keep")
+ << QSize(64, 64)
+ << QRect(8, 8, 48, 48)
+ << QSize(1024, 1024)
+ << QVideoSurfaceFormat::KeepViewport
+ << QRect(8, 8, 48, 48);
+ QTest::newRow("shrink reset")
+ << QSize(1024, 1024)
+ << QRect(8, 8, 1008, 1008)
+ << QSize(64, 64)
+ << QVideoSurfaceFormat::ResetViewport
+ << QRect(0, 0, 64, 64);
+ QTest::newRow("shrink keep")
+ << QSize(1024, 1024)
+ << QRect(8, 8, 1008, 1008)
+ << QSize(64, 64)
+ << QVideoSurfaceFormat::KeepViewport
+ << QRect(8, 8, 56, 56);
+ QTest::newRow("unchanged reset")
+ << QSize(512, 512)
+ << QRect(8, 8, 496, 496)
+ << QSize(512, 512)
+ << QVideoSurfaceFormat::ResetViewport
+ << QRect(0, 0, 512, 512);
+ QTest::newRow("unchanged keep")
+ << QSize(512, 512)
+ << QRect(8, 8, 496, 496)
+ << QSize(512, 512)
+ << QVideoSurfaceFormat::KeepViewport
+ << QRect(8, 8, 496, 496);
+}
+
+void tst_QVideoSurfaceFormat::viewport()
+{
+ QFETCH(QSize, initialSize);
+ QFETCH(QRect, viewport);
+ QFETCH(QSize, newSize);
+ QFETCH(QVideoSurfaceFormat::ViewportMode, viewportMode);
+ QFETCH(QRect, expectedViewport);
+
+ {
+ QRect initialViewport(QPoint(0, 0), initialSize);
+
+ QVideoSurfaceFormat format(initialSize, QVideoFrame::Format_RGB32);
+
+ format.setViewport(viewport);
+
+ QCOMPARE(format.viewport(), viewport);
+ QCOMPARE(format.property("viewport").toRect(), viewport);
+
+ format.setFrameSize(newSize, viewportMode);
+
+ QCOMPARE(format.viewport(), expectedViewport);
+ QCOMPARE(format.property("viewport").toRect(), expectedViewport);
+ }
+ {
+ QVideoSurfaceFormat format(initialSize, QVideoFrame::Format_RGB32);
+
+ format.setProperty("viewport", viewport);
+
+ QCOMPARE(format.viewport(), viewport);
+ QCOMPARE(format.property("viewport").toRect(), viewport);
+ }
+}
+
+void tst_QVideoSurfaceFormat::scanLineDirection_data()
+{
+ QTest::addColumn<QVideoSurfaceFormat::Direction>("direction");
+
+ QTest::newRow("top to bottom")
+ << QVideoSurfaceFormat::TopToBottom;
+
+ QTest::newRow("bottom to top")
+ << QVideoSurfaceFormat::BottomToTop;
+}
+
+void tst_QVideoSurfaceFormat::scanLineDirection()
+{
+ QFETCH(QVideoSurfaceFormat::Direction, direction);
+
+ {
+ QVideoSurfaceFormat format(QSize(16, 16), QVideoFrame::Format_RGB32);
+
+ format.setScanLineDirection(direction);
+
+ QCOMPARE(format.scanLineDirection(), direction);
+ QCOMPARE(
+ qvariant_cast<QVideoSurfaceFormat::Direction>(format.property("scanLineDirection")),
+ direction);
+ }
+ {
+ QVideoSurfaceFormat format(QSize(16, 16), QVideoFrame::Format_RGB32);
+
+ format.setProperty("scanLineDirection", qVariantFromValue(direction));
+
+ QCOMPARE(format.scanLineDirection(), direction);
+ QCOMPARE(
+ qvariant_cast<QVideoSurfaceFormat::Direction>(format.property("scanLineDirection")),
+ direction);
+ }
+}
+
+void tst_QVideoSurfaceFormat::frameRate_data()
+{
+ QTest::addColumn<QVideoSurfaceFormat::FrameRate>("frameRate");
+
+ QTest::newRow("null")
+ << QVideoSurfaceFormat::FrameRate(0, 0);
+ QTest::newRow("1/1")
+ << QVideoSurfaceFormat::FrameRate(1, 1);
+ QTest::newRow("24/1")
+ << QVideoSurfaceFormat::FrameRate(24, 1);
+ QTest::newRow("15/2")
+ << QVideoSurfaceFormat::FrameRate(15, 2);
+}
+
+void tst_QVideoSurfaceFormat::frameRate()
+{
+ QFETCH(QVideoSurfaceFormat::FrameRate, frameRate);
+
+ {
+ QVideoSurfaceFormat format(QSize(64, 64), QVideoFrame::Format_RGB32);
+
+ format.setFrameRate(frameRate);
+
+ QCOMPARE(format.frameRate(), frameRate);
+ QCOMPARE(qvariant_cast<QVideoSurfaceFormat::FrameRate>(format.property("frameRate")),
+ frameRate);
+ }
+ {
+ QVideoSurfaceFormat format(QSize(64, 64), QVideoFrame::Format_RGB32);
+
+ format.setFrameRate(frameRate.first, frameRate.second);
+
+ QCOMPARE(format.frameRate(), frameRate);
+ QCOMPARE(
+ qvariant_cast<QVideoSurfaceFormat::FrameRate>(format.property("frameRate")),
+ frameRate);
+ }
+ {
+ QVideoSurfaceFormat format(QSize(64, 64), QVideoFrame::Format_RGB32);
+
+ format.setFrameRate(frameRate);
+ format.setProperty(
+ "frameRate", qVariantFromValue<QVideoSurfaceFormat::FrameRate>(frameRate));
+
+ QCOMPARE(format.frameRate(), frameRate);
+ QCOMPARE(qvariant_cast<QVideoSurfaceFormat::FrameRate>(format.property("frameRate")),
+ frameRate);
+ }
+}
+
+void tst_QVideoSurfaceFormat::yuvColorSpace_data()
+{
+ QTest::addColumn<QVideoSurfaceFormat::YuvColorSpace>("colorspace");
+
+ QTest::newRow("undefined")
+ << QVideoSurfaceFormat::YCbCr_Undefined;
+ QTest::newRow("bt709")
+ << QVideoSurfaceFormat::YCbCr_BT709;
+ QTest::newRow("xvYCC601")
+ << QVideoSurfaceFormat::YCbCr_xvYCC601;
+ QTest::newRow("JPEG")
+ << QVideoSurfaceFormat::YCbCr_JPEG;
+}
+
+void tst_QVideoSurfaceFormat::yuvColorSpace()
+{
+ QFETCH(QVideoSurfaceFormat::YuvColorSpace, colorspace);
+
+ {
+ QVideoSurfaceFormat format(QSize(64, 64), QVideoFrame::Format_RGB32);
+ format.setYuvColorSpace(colorspace);
+
+ QCOMPARE(format.yuvColorSpace(), colorspace);
+ QCOMPARE(qvariant_cast<QVideoSurfaceFormat::YuvColorSpace>(format.property("yuvColorSpace")),
+ colorspace);
+ }
+ {
+ QVideoSurfaceFormat format(QSize(64, 64), QVideoFrame::Format_RGB32);
+ format.setProperty("yuvColorSpace", qVariantFromValue(colorspace));
+
+ QCOMPARE(format.yuvColorSpace(), colorspace);
+ QCOMPARE(qvariant_cast<QVideoSurfaceFormat::YuvColorSpace>(format.property("yuvColorSpace")),
+ colorspace);
+ }
+}
+
+void tst_QVideoSurfaceFormat::pixelAspectRatio_data()
+{
+ QTest::addColumn<QSize>("aspectRatio");
+
+ QTest::newRow("1:1")
+ << QSize(1, 1);
+ QTest::newRow("4:3")
+ << QSize(4, 3);
+ QTest::newRow("16:9")
+ << QSize(16, 9);
+}
+
+void tst_QVideoSurfaceFormat::pixelAspectRatio()
+{
+ QFETCH(QSize, aspectRatio);
+
+ {
+ QVideoSurfaceFormat format(QSize(64, 64), QVideoFrame::Format_RGB32);
+ format.setPixelAspectRatio(aspectRatio);
+
+ QCOMPARE(format.pixelAspectRatio(), aspectRatio);
+ QCOMPARE(format.property("pixelAspectRatio").toSize(), aspectRatio);
+ }
+ {
+ QVideoSurfaceFormat format(QSize(64, 64), QVideoFrame::Format_RGB32);
+ format.setPixelAspectRatio(aspectRatio.width(), aspectRatio.height());
+
+ QCOMPARE(format.pixelAspectRatio(), aspectRatio);
+ QCOMPARE(format.property("pixelAspectRatio").toSize(), aspectRatio);
+ }
+ {
+ QVideoSurfaceFormat format(QSize(64, 64), QVideoFrame::Format_RGB32);
+ format.setProperty("pixelAspectRatio", aspectRatio);
+
+ QCOMPARE(format.pixelAspectRatio(), aspectRatio);
+ QCOMPARE(format.property("pixelAspectRatio").toSize(), aspectRatio);
+ }
+}
+
+void tst_QVideoSurfaceFormat::sizeHint_data()
+{
+ QTest::addColumn<QSize>("frameSize");
+ QTest::addColumn<QRect>("viewport");
+ QTest::addColumn<QSize>("aspectRatio");
+ QTest::addColumn<QSize>("sizeHint");
+
+ QTest::newRow("(0, 0, 1024x768), 1:1")
+ << QSize(1024, 768)
+ << QRect(0, 0, 1024, 768)
+ << QSize(1, 1)
+ << QSize(1024, 768);
+ QTest::newRow("0, 0, 1024x768), 4:3")
+ << QSize(1024, 768)
+ << QRect(0, 0, 1024, 768)
+ << QSize(4, 3)
+ << QSize(1365, 768);
+ QTest::newRow("(168, 84, 800x600), 1:1")
+ << QSize(1024, 768)
+ << QRect(168, 84, 800, 600)
+ << QSize(1, 1)
+ << QSize(800, 600);
+ QTest::newRow("(168, 84, 800x600), 4:3")
+ << QSize(1024, 768)
+ << QRect(168, 84, 800, 600)
+ << QSize(4, 3)
+ << QSize(1066, 600);
+}
+
+void tst_QVideoSurfaceFormat::sizeHint()
+{
+ QFETCH(QSize, frameSize);
+ QFETCH(QRect, viewport);
+ QFETCH(QSize, aspectRatio);
+ QFETCH(QSize, sizeHint);
+
+ QVideoSurfaceFormat format(frameSize, QVideoFrame::Format_RGB32);
+ format.setViewport(viewport);
+ format.setPixelAspectRatio(aspectRatio);
+
+ QCOMPARE(format.sizeHint(), sizeHint);
+ QCOMPARE(format.property("sizeHint").toSize(), sizeHint);
+}
+
+void tst_QVideoSurfaceFormat::staticPropertyNames()
+{
+ QVideoSurfaceFormat format(QSize(64, 64), QVideoFrame::Format_RGB32);
+
+ QList<QByteArray> propertyNames = format.propertyNames();
+
+ QVERIFY(propertyNames.contains("handleType"));
+ QVERIFY(propertyNames.contains("pixelFormat"));
+ QVERIFY(propertyNames.contains("frameSize"));
+ QVERIFY(propertyNames.contains("frameWidth"));
+ QVERIFY(propertyNames.contains("viewport"));
+ QVERIFY(propertyNames.contains("scanLineDirection"));
+ QVERIFY(propertyNames.contains("frameRate"));
+ QVERIFY(propertyNames.contains("pixelAspectRatio"));
+ QVERIFY(propertyNames.contains("yuvColorSpace"));
+ QVERIFY(propertyNames.contains("sizeHint"));
+ QCOMPARE(propertyNames.count(), 10);
+}
+
+void tst_QVideoSurfaceFormat::dynamicProperty()
+{
+ QVideoSurfaceFormat format(QSize(64, 64), QVideoFrame::Format_RGB32);
+
+ QCOMPARE(format.property("integer"), QVariant());
+ QCOMPARE(format.property("size"), QVariant());
+ QCOMPARE(format.property("string"), QVariant());
+ QCOMPARE(format.property("null"), QVariant());
+
+ QList<QByteArray> propertyNames = format.propertyNames();
+
+ QCOMPARE(propertyNames.count(QByteArray("integer")), 0);
+ QCOMPARE(propertyNames.count(QByteArray("string")), 0);
+ QCOMPARE(propertyNames.count(QByteArray("size")), 0);
+ QCOMPARE(propertyNames.count(QByteArray("null")), 0);
+
+ format.setProperty("string", QString::fromLatin1("Hello"));
+ format.setProperty("integer", 198);
+ format.setProperty("size", QSize(43, 65));
+
+ QCOMPARE(format.property("integer").toInt(), 198);
+ QCOMPARE(format.property("size").toSize(), QSize(43, 65));
+ QCOMPARE(format.property("string").toString(), QString::fromLatin1("Hello"));
+
+ propertyNames = format.propertyNames();
+
+ QCOMPARE(propertyNames.count(QByteArray("integer")), 1);
+ QCOMPARE(propertyNames.count(QByteArray("string")), 1);
+ QCOMPARE(propertyNames.count(QByteArray("size")), 1);
+
+ format.setProperty("integer", 125423);
+ format.setProperty("size", QSize(1, 986));
+
+ QCOMPARE(format.property("integer").toInt(), 125423);
+ QCOMPARE(format.property("size").toSize(), QSize(1, 986));
+ QCOMPARE(format.property("string").toString(), QString::fromLatin1("Hello"));
+
+ propertyNames = format.propertyNames();
+
+ QCOMPARE(propertyNames.count(QByteArray("integer")), 1);
+ QCOMPARE(propertyNames.count(QByteArray("string")), 1);
+ QCOMPARE(propertyNames.count(QByteArray("size")), 1);
+
+ format.setProperty("string", QVariant());
+ format.setProperty("size", QVariant());
+ format.setProperty("null", QVariant());
+
+ QCOMPARE(format.property("integer").toInt(), 125423);
+ QCOMPARE(format.property("size"), QVariant());
+ QCOMPARE(format.property("string"), QVariant());
+ QCOMPARE(format.property("null"), QVariant());
+
+ propertyNames = format.propertyNames();
+
+ QCOMPARE(propertyNames.count(QByteArray("integer")), 1);
+ QCOMPARE(propertyNames.count(QByteArray("string")), 0);
+ QCOMPARE(propertyNames.count(QByteArray("size")), 0);
+ QCOMPARE(propertyNames.count(QByteArray("null")), 0);
+}
+
+void tst_QVideoSurfaceFormat::compare()
+{
+ QVideoSurfaceFormat format1(
+ QSize(16, 16), QVideoFrame::Format_RGB32, QAbstractVideoBuffer::GLTextureHandle);
+ QVideoSurfaceFormat format2(
+ QSize(16, 16), QVideoFrame::Format_RGB32, QAbstractVideoBuffer::GLTextureHandle);
+ QVideoSurfaceFormat format3(
+ QSize(32, 32), QVideoFrame::Format_YUV444, QAbstractVideoBuffer::GLTextureHandle);
+ QVideoSurfaceFormat format4(
+ QSize(16, 16), QVideoFrame::Format_RGB32, QAbstractVideoBuffer::UserHandle);
+
+ QCOMPARE(format1 == format2, true);
+ QCOMPARE(format1 != format2, false);
+ QCOMPARE(format1 == format3, false);
+ QCOMPARE(format1 != format3, true);
+ QCOMPARE(format1 == format4, false);
+ QCOMPARE(format1 != format4, true);
+
+ format2.setFrameSize(1024, 768, QVideoSurfaceFormat::ResetViewport);
+
+ // Not equal, frame size differs.
+ QCOMPARE(format1 == format2, false);
+ QCOMPARE(format1 != format2, true);
+
+ format1.setFrameSize(1024, 768, QVideoSurfaceFormat::KeepViewport);
+
+ // Not equal, viewport differs.
+ QCOMPARE(format1 == format2, false);
+ QCOMPARE(format1 != format2, true);
+
+ format1.setViewport(QRect(0, 0, 1024, 768));
+
+ // Equal.
+ QCOMPARE(format1 == format2, true);
+ QCOMPARE(format1 != format2, false);
+
+ format2.setScanLineDirection(QVideoSurfaceFormat::BottomToTop);
+
+ // Not equal scan line direction differs.
+ QCOMPARE(format1 == format2, false);
+ QCOMPARE(format1 != format2, true);
+
+ format1.setScanLineDirection(QVideoSurfaceFormat::BottomToTop);
+
+ // Equal.
+ QCOMPARE(format1 == format2, true);
+ QCOMPARE(format1 != format2, false);
+
+ format1.setFrameRate(QVideoSurfaceFormat::FrameRate(15, 2));
+
+ // Not equal frame rate differs.
+ QCOMPARE(format1 == format2, false);
+ QCOMPARE(format1 != format2, true);
+
+ format2.setFrameRate(15, 2);
+
+ // Equal.
+ QCOMPARE(format1 == format2, true);
+ QCOMPARE(format1 != format2, false);
+
+ format2.setPixelAspectRatio(4, 3);
+
+ // Not equal pixel aspect ratio differs.
+ QCOMPARE(format1 == format2, false);
+ QCOMPARE(format1 != format2, true);
+
+ format1.setPixelAspectRatio(QSize(4, 3));
+
+ // Equal.
+ QCOMPARE(format1 == format2, true);
+ QCOMPARE(format1 != format2, false);
+
+ format2.setYuvColorSpace(QVideoSurfaceFormat::YCbCr_xvYCC601);
+
+ // Not equal yuv color space differs.
+ QCOMPARE(format1 == format2, false);
+ QCOMPARE(format1 != format2, true);
+
+ format1.setYuvColorSpace(QVideoSurfaceFormat::YCbCr_xvYCC601);
+
+ // Equal.
+ QCOMPARE(format1 == format2, true);
+ QCOMPARE(format1 != format2, false);
+
+ format1.setProperty("integer", 12);
+
+ // Not equal, property mismatch.
+ QCOMPARE(format1 == format2, false);
+ QCOMPARE(format1 != format2, true);
+
+ format2.setProperty("integer", 45);
+
+ // Not equal, integer differs.
+ QCOMPARE(format1 == format2, false);
+ QCOMPARE(format1 != format2, true);
+
+ format2.setProperty("integer", 12);
+
+ // Equal.
+ QCOMPARE(format1 == format2, true);
+ QCOMPARE(format1 != format2, false);
+
+ format1.setProperty("string", QString::fromLatin1("Hello"));
+ format2.setProperty("size", QSize(12, 54));
+
+ // Not equal, property mismatch.
+ QCOMPARE(format1 == format2, false);
+ QCOMPARE(format1 != format2, true);
+
+ format2.setProperty("string", QString::fromLatin1("Hello"));
+ format1.setProperty("size", QSize(12, 54));
+
+ // Equal.
+ QCOMPARE(format1 == format2, true);
+ QCOMPARE(format1 != format2, false);
+
+ format1.setProperty("string", QVariant());
+
+ // Not equal, property mismatch.
+ QCOMPARE(format1 == format2, false);
+ QCOMPARE(format1 != format2, true);
+}
+
+
+void tst_QVideoSurfaceFormat::copy()
+{
+ QVideoSurfaceFormat original(
+ QSize(1024, 768), QVideoFrame::Format_ARGB32, QAbstractVideoBuffer::GLTextureHandle);
+ original.setScanLineDirection(QVideoSurfaceFormat::BottomToTop);
+
+ QVideoSurfaceFormat copy(original);
+
+ QCOMPARE(copy.handleType(), QAbstractVideoBuffer::GLTextureHandle);
+ QCOMPARE(copy.pixelFormat(), QVideoFrame::Format_ARGB32);
+ QCOMPARE(copy.frameSize(), QSize(1024, 768));
+ QCOMPARE(copy.scanLineDirection(), QVideoSurfaceFormat::BottomToTop);
+
+ QCOMPARE(original == copy, true);
+ QCOMPARE(original != copy, false);
+
+ copy.setScanLineDirection(QVideoSurfaceFormat::TopToBottom);
+
+ QCOMPARE(copy.scanLineDirection(), QVideoSurfaceFormat::TopToBottom);
+
+ QCOMPARE(original.scanLineDirection(), QVideoSurfaceFormat::BottomToTop);
+
+ QCOMPARE(original == copy, false);
+ QCOMPARE(original != copy, true);
+}
+
+void tst_QVideoSurfaceFormat::assign()
+{
+ QVideoSurfaceFormat copy(
+ QSize(64, 64), QVideoFrame::Format_AYUV444, QAbstractVideoBuffer::UserHandle);
+
+ QVideoSurfaceFormat original(
+ QSize(1024, 768), QVideoFrame::Format_ARGB32, QAbstractVideoBuffer::GLTextureHandle);
+ original.setScanLineDirection(QVideoSurfaceFormat::BottomToTop);
+
+ copy = original;
+
+ QCOMPARE(copy.handleType(), QAbstractVideoBuffer::GLTextureHandle);
+ QCOMPARE(copy.pixelFormat(), QVideoFrame::Format_ARGB32);
+ QCOMPARE(copy.frameSize(), QSize(1024, 768));
+ QCOMPARE(copy.scanLineDirection(), QVideoSurfaceFormat::BottomToTop);
+
+ QCOMPARE(original == copy, true);
+ QCOMPARE(original != copy, false);
+
+ copy.setScanLineDirection(QVideoSurfaceFormat::TopToBottom);
+
+ QCOMPARE(copy.scanLineDirection(), QVideoSurfaceFormat::TopToBottom);
+
+ QCOMPARE(original.scanLineDirection(), QVideoSurfaceFormat::BottomToTop);
+
+ QCOMPARE(original == copy, false);
+ QCOMPARE(original != copy, true);
+}
+
+QTEST_MAIN(tst_QVideoSurfaceFormat)
+
+#include "tst_qvideosurfaceformat.moc"