qvideosurfaceformat.cpp

Go to the documentation of this file.

/****************************************************************************
**
** Copyright (C) 2014 Digia Plc and/or its subsidiary(-ies).
** Contact: http://www.qt-project.org/legal
**
** This file is part of the QtMultimedia module 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 "qvideosurfaceformat.h"

#include <qdebug.h>
#include <qmetatype.h>
#include <qpair.h>
#include <qvariant.h>
#include <qvector.h>

QT_BEGIN_NAMESPACE

class QVideoSurfaceFormatPrivate : public QSharedData
{
public:
    QVideoSurfaceFormatPrivate()
        : pixelFormat(QVideoFrame::Format_Invalid)
        , handleType(QAbstractVideoBuffer::NoHandle)
        , scanLineDirection(QVideoSurfaceFormat::TopToBottom)
        , pixelAspectRatio(1, 1)
        , ycbcrColorSpace(QVideoSurfaceFormat::YCbCr_Undefined)
        , frameRate(0.0)
    {
    }

    QVideoSurfaceFormatPrivate(
            const QSize &size,
            QVideoFrame::PixelFormat format,
            QAbstractVideoBuffer::HandleType type)
        : pixelFormat(format)
        , handleType(type)
        , scanLineDirection(QVideoSurfaceFormat::TopToBottom)
        , frameSize(size)
        , pixelAspectRatio(1, 1)
        , ycbcrColorSpace(QVideoSurfaceFormat::YCbCr_Undefined)
        , viewport(QPoint(0, 0), size)
        , frameRate(0.0)
    {
    }

    QVideoSurfaceFormatPrivate(const QVideoSurfaceFormatPrivate &other)
        : QSharedData(other)
        , pixelFormat(other.pixelFormat)
        , handleType(other.handleType)
        , scanLineDirection(other.scanLineDirection)
        , frameSize(other.frameSize)
        , pixelAspectRatio(other.pixelAspectRatio)
        , ycbcrColorSpace(other.ycbcrColorSpace)
        , viewport(other.viewport)
        , frameRate(other.frameRate)
        , propertyNames(other.propertyNames)
        , propertyValues(other.propertyValues)
    {
    }

    bool operator ==(const QVideoSurfaceFormatPrivate &other) const
    {
        if (pixelFormat == other.pixelFormat
            && handleType == other.handleType
            && scanLineDirection == other.scanLineDirection
            && frameSize == other.frameSize
            && pixelAspectRatio == other.pixelAspectRatio
            && viewport == other.viewport
            && frameRatesEqual(frameRate, other.frameRate)
            && ycbcrColorSpace == other.ycbcrColorSpace
            && propertyNames.count() == other.propertyNames.count()) {
            for (int i = 0; i < propertyNames.count(); ++i) {
                int j = other.propertyNames.indexOf(propertyNames.at(i));

                if (j == -1 || propertyValues.at(i) != other.propertyValues.at(j))
                    return false;
            }
            return true;
        } else {
            return false;
        }
    }

    inline static bool frameRatesEqual(qreal r1, qreal r2)
    {
        return qAbs(r1 - r2) <= 0.00001 * qMin(qAbs(r1), qAbs(r2));
    }

    QVideoFrame::PixelFormat pixelFormat;
    QAbstractVideoBuffer::HandleType handleType;
    QVideoSurfaceFormat::Direction scanLineDirection;
    QSize frameSize;
    QSize pixelAspectRatio;
    QVideoSurfaceFormat::YCbCrColorSpace ycbcrColorSpace;
    QRect viewport;
    qreal frameRate;
    QList<QByteArray> propertyNames;
    QList<QVariant> propertyValues;
};

QVideoSurfaceFormat::QVideoSurfaceFormat()
    : d(new QVideoSurfaceFormatPrivate)
{
}

QVideoSurfaceFormat::QVideoSurfaceFormat(
        const QSize& size, QVideoFrame::PixelFormat format, QAbstractVideoBuffer::HandleType type)
    : d(new QVideoSurfaceFormatPrivate(size, format, type))
{
}

QVideoSurfaceFormat::QVideoSurfaceFormat(const QVideoSurfaceFormat &other)
    : d(other.d)
{
}

QVideoSurfaceFormat &QVideoSurfaceFormat::operator =(const QVideoSurfaceFormat &other)
{
    d = other.d;

    return *this;
}

QVideoSurfaceFormat::~QVideoSurfaceFormat()
{
}

bool QVideoSurfaceFormat::isValid() const
{
    return d->pixelFormat != QVideoFrame::Format_Invalid && d->frameSize.isValid();
}

bool QVideoSurfaceFormat::operator ==(const QVideoSurfaceFormat &other) const
{
    return d == other.d || *d == *other.d;
}

bool QVideoSurfaceFormat::operator !=(const QVideoSurfaceFormat &other) const
{
    return d != other.d && !(*d == *other.d);
}

QVideoFrame::PixelFormat QVideoSurfaceFormat::pixelFormat() const
{
    return d->pixelFormat;
}

QAbstractVideoBuffer::HandleType QVideoSurfaceFormat::handleType() const
{
    return d->handleType;
}

QSize QVideoSurfaceFormat::frameSize() const
{
    return d->frameSize;
}

int QVideoSurfaceFormat::frameWidth() const
{
    return d->frameSize.width();
}

int QVideoSurfaceFormat::frameHeight() const
{
    return d->frameSize.height();
}

void QVideoSurfaceFormat::setFrameSize(const QSize &size)
{
    d->frameSize = size;
    d->viewport = QRect(QPoint(0, 0), size);
}

void QVideoSurfaceFormat::setFrameSize(int width, int height)
{
    d->frameSize = QSize(width, height);
    d->viewport = QRect(0, 0, width, height);
}

QRect QVideoSurfaceFormat::viewport() const
{
    return d->viewport;
}

void QVideoSurfaceFormat::setViewport(const QRect &viewport)
{
    d->viewport = viewport;
}

QVideoSurfaceFormat::Direction QVideoSurfaceFormat::scanLineDirection() const
{
    return d->scanLineDirection;
}

void QVideoSurfaceFormat::setScanLineDirection(Direction direction)
{
    d->scanLineDirection = direction;
}

qreal QVideoSurfaceFormat::frameRate() const
{
    return d->frameRate;
}

void QVideoSurfaceFormat::setFrameRate(qreal rate)
{
    d->frameRate = rate;
}

QSize QVideoSurfaceFormat::pixelAspectRatio() const
{
    return d->pixelAspectRatio;
}

void QVideoSurfaceFormat::setPixelAspectRatio(const QSize &ratio)
{
    d->pixelAspectRatio = ratio;
}

void QVideoSurfaceFormat::setPixelAspectRatio(int horizontal, int vertical)
{
    d->pixelAspectRatio = QSize(horizontal, vertical);
}

QVideoSurfaceFormat::YCbCrColorSpace QVideoSurfaceFormat::yCbCrColorSpace() const
{
    return d->ycbcrColorSpace;
}

void QVideoSurfaceFormat::setYCbCrColorSpace(QVideoSurfaceFormat::YCbCrColorSpace space)
{
    d->ycbcrColorSpace = space;
}

QSize QVideoSurfaceFormat::sizeHint() const
{
    QSize size = d->viewport.size();

    if (d->pixelAspectRatio.height() != 0)
        size.setWidth(size.width() * d->pixelAspectRatio.width() / d->pixelAspectRatio.height());

    return size;
}

QList<QByteArray> QVideoSurfaceFormat::propertyNames() const
{
    return (QList<QByteArray>()
            << "handleType"
            << "pixelFormat"
            << "frameSize"
            << "frameWidth"
            << "viewport"
            << "scanLineDirection"
            << "frameRate"
            << "pixelAspectRatio"
            << "sizeHint"
            << "yCbCrColorSpace")
            + d->propertyNames;
}

QVariant QVideoSurfaceFormat::property(const char *name) const
{
    if (qstrcmp(name, "handleType") == 0) {
        return QVariant::fromValue(d->handleType);
    } else if (qstrcmp(name, "pixelFormat") == 0) {
        return QVariant::fromValue(d->pixelFormat);
    } else if (qstrcmp(name, "handleType") == 0) {
        return QVariant::fromValue(d->handleType);
    } else if (qstrcmp(name, "frameSize") == 0) {
        return d->frameSize;
    } else if (qstrcmp(name, "frameWidth") == 0) {
        return d->frameSize.width();
    } else if (qstrcmp(name, "frameHeight") == 0) {
        return d->frameSize.height();
    } else if (qstrcmp(name, "viewport") == 0) {
        return d->viewport;
    } else if (qstrcmp(name, "scanLineDirection") == 0) {
        return QVariant::fromValue(d->scanLineDirection);
    } else if (qstrcmp(name, "frameRate") == 0) {
        return QVariant::fromValue(d->frameRate);
    } else if (qstrcmp(name, "pixelAspectRatio") == 0) {
        return QVariant::fromValue(d->pixelAspectRatio);
    } else if (qstrcmp(name, "sizeHint") == 0) {
        return sizeHint();
    } else if (qstrcmp(name, "yCbCrColorSpace") == 0) {
        return QVariant::fromValue(d->ycbcrColorSpace);
    } else {
        int id = 0;
        for (; id < d->propertyNames.count() && d->propertyNames.at(id) != name; ++id) {}

        return id < d->propertyValues.count()
                ? d->propertyValues.at(id)
                : QVariant();
    }
}

void QVideoSurfaceFormat::setProperty(const char *name, const QVariant &value)
{
    if (qstrcmp(name, "handleType") == 0) {
        // read only.
    } else if (qstrcmp(name, "pixelFormat") == 0) {
        // read only.
    } else if (qstrcmp(name, "frameSize") == 0) {
        if (value.canConvert<QSize>()) {
            d->frameSize = qvariant_cast<QSize>(value);
            d->viewport = QRect(QPoint(0, 0), d->frameSize);
        }
    } else if (qstrcmp(name, "frameWidth") == 0) {
        // read only.
    } else if (qstrcmp(name, "frameHeight") == 0) {
        // read only.
    } else if (qstrcmp(name, "viewport") == 0) {
        if (value.canConvert<QRect>())
            d->viewport = qvariant_cast<QRect>(value);
    } else if (qstrcmp(name, "scanLineDirection") == 0) {
        if (value.canConvert<Direction>())
            d->scanLineDirection = qvariant_cast<Direction>(value);
    } else if (qstrcmp(name, "frameRate") == 0) {
        if (value.canConvert<qreal>())
            d->frameRate = qvariant_cast<qreal>(value);
    } else if (qstrcmp(name, "pixelAspectRatio") == 0) {
        if (value.canConvert<QSize>())
            d->pixelAspectRatio = qvariant_cast<QSize>(value);
    } else if (qstrcmp(name, "sizeHint") == 0) {
        // read only.
    } else if (qstrcmp(name, "yCbCrColorSpace") == 0) {
          if (value.canConvert<YCbCrColorSpace>())
              d->ycbcrColorSpace = qvariant_cast<YCbCrColorSpace>(value);
    } else {
        int id = 0;
        for (; id < d->propertyNames.count() && d->propertyNames.at(id) != name; ++id) {}

        if (id < d->propertyValues.count()) {
            if (value.isNull()) {
                d->propertyNames.removeAt(id);
                d->propertyValues.removeAt(id);
            } else {
                d->propertyValues[id] = value;
            }
        } else if (!value.isNull()) {
            d->propertyNames.append(QByteArray(name));
            d->propertyValues.append(value);
        }
    }
}


#ifndef QT_NO_DEBUG_STREAM
QDebug operator<<(QDebug dbg, const QVideoSurfaceFormat &f)
{
    QString typeName;
    switch (f.pixelFormat()) {
    case QVideoFrame::Format_Invalid:
        typeName = QLatin1String("Format_Invalid");
        break;
    case QVideoFrame::Format_ARGB32:
        typeName = QLatin1String("Format_ARGB32");
        break;
    case QVideoFrame::Format_ARGB32_Premultiplied:
        typeName = QLatin1String("Format_ARGB32_Premultiplied");
        break;
    case QVideoFrame::Format_RGB32:
        typeName = QLatin1String("Format_RGB32");
        break;
    case QVideoFrame::Format_RGB24:
        typeName = QLatin1String("Format_RGB24");
        break;
    case QVideoFrame::Format_RGB565:
        typeName = QLatin1String("Format_RGB565");
        break;
    case QVideoFrame::Format_RGB555:
        typeName = QLatin1String("Format_RGB555");
        break;
    case QVideoFrame::Format_ARGB8565_Premultiplied:
        typeName = QLatin1String("Format_ARGB8565_Premultiplied");
        break;
    case QVideoFrame::Format_BGRA32:
        typeName = QLatin1String("Format_BGRA32");
        break;
    case QVideoFrame::Format_BGRA32_Premultiplied:
        typeName = QLatin1String("Format_BGRA32_Premultiplied");
        break;
    case QVideoFrame::Format_BGR32:
        typeName = QLatin1String("Format_BGR32");
        break;
    case QVideoFrame::Format_BGR24:
        typeName = QLatin1String("Format_BGR24");
        break;
    case QVideoFrame::Format_BGR565:
        typeName = QLatin1String("Format_BGR565");
        break;
    case QVideoFrame::Format_BGR555:
        typeName = QLatin1String("Format_BGR555");
        break;
    case QVideoFrame::Format_BGRA5658_Premultiplied:
        typeName = QLatin1String("Format_BGRA5658_Premultiplied");
        break;
    case QVideoFrame::Format_AYUV444:
        typeName = QLatin1String("Format_AYUV444");
        break;
    case QVideoFrame::Format_AYUV444_Premultiplied:
        typeName = QLatin1String("Format_AYUV444_Premultiplied");
        break;
    case QVideoFrame::Format_YUV444:
        typeName = QLatin1String("Format_YUV444");
        break;
    case QVideoFrame::Format_YUV420P:
        typeName = QLatin1String("Format_YUV420P");
        break;
    case QVideoFrame::Format_YV12:
        typeName = QLatin1String("Format_YV12");
        break;
    case QVideoFrame::Format_UYVY:
        typeName = QLatin1String("Format_UYVY");
        break;
    case QVideoFrame::Format_YUYV:
        typeName = QLatin1String("Format_YUYV");
        break;
    case QVideoFrame::Format_NV12:
        typeName = QLatin1String("Format_NV12");
        break;
    case QVideoFrame::Format_NV21:
        typeName = QLatin1String("Format_NV21");
        break;
    case QVideoFrame::Format_IMC1:
        typeName = QLatin1String("Format_IMC1");
        break;
    case QVideoFrame::Format_IMC2:
        typeName = QLatin1String("Format_IMC2");
        break;
    case QVideoFrame::Format_IMC3:
        typeName = QLatin1String("Format_IMC3");
        break;
    case QVideoFrame::Format_IMC4:
        typeName = QLatin1String("Format_IMC4");
        break;
    case QVideoFrame::Format_Y8:
        typeName = QLatin1String("Format_Y8");
        break;
    case QVideoFrame::Format_Y16:
        typeName = QLatin1String("Format_Y16");
    default:
        typeName = QString(QLatin1String("UserType(%1)" )).arg(int(f.pixelFormat()));
    }

    dbg.nospace() << "QVideoSurfaceFormat(" << typeName;
    dbg.nospace() << ", " << f.frameSize();
    dbg.nospace() << ", viewport=" << f.viewport();
    dbg.nospace() << ", pixelAspectRatio=" << f.pixelAspectRatio();
    dbg.nospace() << ")";

    foreach(const QByteArray& propertyName, f.propertyNames())
        dbg << "\n    " << propertyName.data() << " = " << f.property(propertyName.data());

    return dbg.space();
}
#endif

QT_END_NAMESPACE