Revision control
++ // Copyright (C) 2016 The Qt Company Ltd.
++ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
++
++ #include "qgstreamermetadata_p.h"
++ #include <QtMultimedia/qmediametadata.h>
++ #include <QtMultimedia/qtvideo.h>
++ #include <QtCore/qdebug.h>
++ #include <QtMultimedia/private/qmultimedia_ranges_p.h>
++ #include <QtCore/qdatetime.h>
++ #include <QtCore/qlocale.h>
++ #include <QtCore/qtimezone.h>
++ #include <QtGui/qimage.h>
++ #include <QtMultimedia/private/qmediametadata_p.h>
++
++ #include <gst/gstversion.h>
++ #include <common/qgst_handle_types_p.h>
++ #include <common/qgstutils_p.h>
++ #include <qgstreamerformatinfo_p.h>
++
++ QT_BEGIN_NAMESPACE
++
++ namespace ranges = QtMultimediaPrivate::ranges;
++ using namespace Qt::Literals;
++
++ RotationResult parseRotationTag(std::string_view tag)
++ {
++ using namespace std::string_view_literals;
++ Q_ASSERT(!tag.empty());
++
++ if (tag[0] == 'r') {
++ if (tag == "rotate-90"sv)
++ return { QtVideo::Rotation::Clockwise90, false };
++ if (tag == "rotate-180"sv)
++ return { QtVideo::Rotation::Clockwise180, false };
++ if (tag == "rotate-270"sv)
++ return { QtVideo::Rotation::Clockwise270, false };
++ if (tag == "rotate-0"sv)
++ return { QtVideo::Rotation::None, false };
++ }
++ if (tag[0] == 'f') {
++ // To flip by horizontal axis is the same as to mirror by vertical axis
++ // and rotate by 180 degrees.
++
++ if (tag == "flip-rotate-90"sv)
++ return { QtVideo::Rotation::Clockwise270, true };
++ if (tag == "flip-rotate-180"sv)
++ return { QtVideo::Rotation::None, true };
++ if (tag == "flip-rotate-270"sv)
++ return { QtVideo::Rotation::Clockwise90, true };
++ if (tag == "flip-rotate-0"sv)
++ return { QtVideo::Rotation::Clockwise180, true };
++ }
++
++ qCritical() << "cannot parse orientation: {}" << tag;
++ return { QtVideo::Rotation::None, false };
++ }
++
++ QImage parseImage(const GValue &val)
++ {
++ Q_ASSERT(G_VALUE_TYPE(&val) == GST_TYPE_SAMPLE);
++
++ GstSample *sample = (GstSample *)g_value_get_boxed(&val);
++ GstCaps *caps = gst_sample_get_caps(sample);
++ if (caps && !gst_caps_is_empty(caps)) {
++ GstStructure *structure = gst_caps_get_structure(caps, 0);
++ const gchar *name = gst_structure_get_name(structure);
++ if (QLatin1StringView(name).startsWith("image/"_L1)) {
++ GstBuffer *buffer = gst_sample_get_buffer(sample);
++ if (buffer) {
++ GstMapInfo info;
++ gst_buffer_map(buffer, &info, GST_MAP_READ);
++ QImage image = QImage::fromData(info.data, info.size, name);
++ gst_buffer_unmap(buffer, &info);
++ return image;
++ }
++ }
++ }
++
++ return {};
++ }
++
++ namespace {
++
++ namespace MetadataLookupImpl {
++
++ // note: libstdc++ 11 has incomplete support for ranges (missing owning_view, P2415)
++ #if defined(__cpp_lib_constexpr_algorithms) && defined(__cpp_lib_ranges) \
++ && (!defined(_GLIBCXX_RELEASE) || _GLIBCXX_RELEASE >= 12)
++ # define constexpr_lookup constexpr
++ #else
++ # define constexpr_lookup /*constexpr*/
++ #endif
++
++ struct MetadataKeyValuePair
++ {
++ const char *tag;
++ QMediaMetaData::Key key;
++ };
++
++ constexpr const char *toTag(const char *t)
++ {
++ return t;
++ }
++ constexpr const char *toTag(const MetadataKeyValuePair &kv)
++ {
++ return kv.tag;
++ }
++
++ constexpr QMediaMetaData::Key toKey(QMediaMetaData::Key k)
++ {
++ return k;
++ }
++ constexpr QMediaMetaData::Key toKey(const MetadataKeyValuePair &kv)
++ {
++ return kv.key;
++ }
++
++ constexpr auto compareByKey = [](const auto &lhs, const auto &rhs) {
++ return toKey(lhs) < toKey(rhs);
++ };
++
++ constexpr auto compareByTag = [](const auto &lhs, const auto &rhs) {
++ return std::strcmp(toTag(lhs), toTag(rhs)) < 0;
++ };
++
++ constexpr_lookup auto makeLookupTable()
++ {
++ std::array<MetadataKeyValuePair, 21> lookupTable{ {
++ { GST_TAG_TITLE, QMediaMetaData::Title },
++ { GST_TAG_COMMENT, QMediaMetaData::Comment },
++ { GST_TAG_DESCRIPTION, QMediaMetaData::Description },
++ { GST_TAG_GENRE, QMediaMetaData::Genre },
++ { GST_TAG_DATE_TIME, QMediaMetaData::Date },
++ { GST_TAG_DATE, QMediaMetaData::Date },
++
++ { GST_TAG_LANGUAGE_CODE, QMediaMetaData::Language },
++
++ { GST_TAG_ORGANIZATION, QMediaMetaData::Publisher },
++ { GST_TAG_COPYRIGHT, QMediaMetaData::Copyright },
++
++ // Media
++ { GST_TAG_DURATION, QMediaMetaData::Duration },
++
++ // Audio
++ { GST_TAG_BITRATE, QMediaMetaData::AudioBitRate },
++ { GST_TAG_AUDIO_CODEC, QMediaMetaData::AudioCodec },
++
++ // Music
++ { GST_TAG_ALBUM, QMediaMetaData::AlbumTitle },
++ { GST_TAG_ALBUM_ARTIST, QMediaMetaData::AlbumArtist },
++ { GST_TAG_ARTIST, QMediaMetaData::ContributingArtist },
++ { GST_TAG_TRACK_NUMBER, QMediaMetaData::TrackNumber },
++
++ { GST_TAG_IMAGE, QMediaMetaData::CoverArtImage },
++
++ // Image/Video
++ { "resolution", QMediaMetaData::Resolution },
++ { GST_TAG_IMAGE_ORIENTATION, QMediaMetaData::Orientation },
++
++ // Video
++ { GST_TAG_VIDEO_CODEC, QMediaMetaData::VideoCodec },
++
++ // Movie
++ { GST_TAG_PERFORMER, QMediaMetaData::LeadPerformer },
++ } };
++
++ ranges::sort(lookupTable, [](const MetadataKeyValuePair &lhs, const MetadataKeyValuePair &rhs) {
++ return std::string_view(lhs.tag) < std::string_view(rhs.tag);
++ });
++ return lookupTable;
++ }
++
++ constexpr_lookup auto gstTagToMetaDataKey = makeLookupTable();
++ constexpr_lookup auto metaDataKeyToGstTag = [] {
++ auto array = gstTagToMetaDataKey;
++ ranges::sort(array, compareByKey);
++ return array;
++ }();
++
++ } // namespace MetadataLookupImpl
++
++ QMediaMetaData::Key tagToKey(const char *tag)
++ {
++ if (tag == nullptr)
++ return QMediaMetaData::Key(-1);
++
++ using namespace MetadataLookupImpl;
++ auto foundIterator = ranges::lower_bound(gstTagToMetaDataKey, tag, compareByTag);
++ if (std::strcmp(foundIterator->tag, tag) == 0)
++ return foundIterator->key;
++
++ return QMediaMetaData::Key(-1);
++ }
++
++ const char *keyToTag(QMediaMetaData::Key key)
++ {
++ using namespace MetadataLookupImpl;
++ auto foundIterator = ranges::lower_bound(metaDataKeyToGstTag, key, compareByKey);
++ if (foundIterator->key == key)
++ return foundIterator->tag;
++
++ return nullptr;
++ }
++
++ #undef constexpr_lookup
++
++ QDateTime parseDate(const GDate *date)
++ {
++ if (!g_date_valid(date))
++ return {};
++
++ int year = g_date_get_year(date);
++ int month = g_date_get_month(date);
++ int day = g_date_get_day(date);
++ return QDateTime(QDate(year, month, day), QTime());
++ }
++
++ QDateTime parseDate(const GValue &val)
++ {
++ Q_ASSERT(G_VALUE_TYPE(&val) == G_TYPE_DATE);
++ const GDate *date = (const GDate *)g_value_get_boxed(&val);
++ return parseDate(date);
++ }
++
++ QDateTime parseDateTime(const GstDateTime *dateTime)
++ {
++ int year = gst_date_time_has_year(dateTime) ? gst_date_time_get_year(dateTime) : 0;
++ int month = gst_date_time_has_month(dateTime) ? gst_date_time_get_month(dateTime) : 0;
++ int day = gst_date_time_has_day(dateTime) ? gst_date_time_get_day(dateTime) : 0;
++ int hour = 0;
++ int minute = 0;
++ int second = 0;
++ float tz = 0;
++ if (gst_date_time_has_time(dateTime)) {
++ hour = gst_date_time_get_hour(dateTime);
++ minute = gst_date_time_get_minute(dateTime);
++ second = gst_date_time_get_second(dateTime);
++ tz = gst_date_time_get_time_zone_offset(dateTime);
++ }
++ return QDateTime{
++ QDate(year, month, day),
++ QTime(hour, minute, second),
++ QTimeZone(tz * 60 * 60),
++ };
++ }
++
++ QDateTime parseDateTime(const GValue &val)
++ {
++ Q_ASSERT(G_VALUE_TYPE(&val) == GST_TYPE_DATE_TIME);
++ const GstDateTime *dateTime = (const GstDateTime *)g_value_get_boxed(&val);
++ return parseDateTime(dateTime);
++ }
++
++ std::optional<double> parseFractionAsDouble(const GValue &val)
++ {
++ Q_ASSERT(G_VALUE_TYPE(&val) == GST_TYPE_FRACTION);
++
++ int nom = gst_value_get_fraction_numerator(&val);
++ int denom = gst_value_get_fraction_denominator(&val);
++ if (denom == 0)
++ return std::nullopt;
++ return double(nom) / double(denom);
++ }
++
++ constexpr std::string_view extendedComment{ GST_TAG_EXTENDED_COMMENT };
++
++ void addTagsFromExtendedComment(const GstTagList *list, const gchar *tag, QMediaMetaData &metadata)
++ {
++ using namespace Qt::Literals;
++ assert(tag == extendedComment);
++
++ int entryCount = gst_tag_list_get_tag_size(list, tag);
++ for (int i = 0; i != entryCount; ++i) {
++ const GValue *value = gst_tag_list_get_value_index(list, tag, i);
++
++ const QLatin1StringView strValue{ g_value_get_string(value) };
++
++ auto equalIndex = strValue.indexOf(QLatin1StringView("="));
++ if (equalIndex == -1) {
++ qDebug() << "Cannot parse GST_TAG_EXTENDED_COMMENT entry: " << value;
++ continue;
++ }
++
++ const QLatin1StringView key = strValue.first(equalIndex);
++ const QLatin1StringView valueString = strValue.last(strValue.size() - equalIndex - 1);
++
++ if (key == "DURATION"_L1) {
++ QGstDateTimeHandle duration{
++ gst_date_time_new_from_iso8601_string(valueString.data()),
++ QGstDateTimeHandle::HasRef,
++ };
++
++ if (duration) {
++ using namespace std::chrono;
++
++ auto chronoDuration = hours(gst_date_time_get_hour(duration.get()))
++ + minutes(gst_date_time_get_minute(duration.get()))
++ + seconds(gst_date_time_get_second(duration.get()))
++ + microseconds(gst_date_time_get_microsecond(duration.get()));
++
++ metadata.insert(QMediaMetaData::Duration,
++ QVariant::fromValue(round<milliseconds>(chronoDuration).count()));
++ }
++ }
++ }
++ }
++
++ void addTagToMetaData(const GstTagList *list, const gchar *tag, void *userdata)
++ {
++ QMediaMetaData &metadata = *reinterpret_cast<QMediaMetaData *>(userdata);
++
++ QMediaMetaData::Key key = tagToKey(tag);
++ if (key == QMediaMetaData::Key::Date)
++ return; // date/datetime are handled on a higher layer
++
++ if (key == QMediaMetaData::Key(-1)) {
++ if (tag == extendedComment)
++ addTagsFromExtendedComment(list, tag, metadata);
++
++ return;
++ }
++
++ GValue val{};
++ gst_tag_list_copy_value(&val, list, tag);
++
++ GType type = G_VALUE_TYPE(&val);
++
++ if (auto entryCount = gst_tag_list_get_tag_size(list, tag) != 0; entryCount != 1)
++ qWarning() << "addTagToMetaData: invaled entry count for" << tag << "-" << entryCount;
++
++ if (type == G_TYPE_STRING) {
++ const gchar *str_value = g_value_get_string(&val);
++
++ switch (key) {
++ case QMediaMetaData::Language: {
++ metadata.insert(key, QVariant::fromValue(QGstUtils::codeToLanguage(str_value)));
++ break;
++ }
++ case QMediaMetaData::Orientation: {
++ RotationResult result = parseRotationTag(str_value);
++ metadata.insert(key, QVariant::fromValue(result.rotation));
++ break;
++ }
++ default:
++ metadata.insert(key, QString::fromUtf8(str_value));
++ break;
++ };
++ } else if (type == G_TYPE_INT) {
++ metadata.insert(key, g_value_get_int(&val));
++ } else if (type == G_TYPE_UINT) {
++ metadata.insert(key, g_value_get_uint(&val));
++ } else if (type == G_TYPE_LONG) {
++ metadata.insert(key, qint64(g_value_get_long(&val)));
++ } else if (type == G_TYPE_BOOLEAN) {
++ metadata.insert(key, g_value_get_boolean(&val));
++ } else if (type == G_TYPE_CHAR) {
++ metadata.insert(key, g_value_get_schar(&val));
++ } else if (type == G_TYPE_DOUBLE) {
++ metadata.insert(key, g_value_get_double(&val));
++ } else if (type == G_TYPE_DATE) {
++ if (!metadata.keys().contains(key)) {
++ QDateTime date = parseDate(val);
++ if (date.isValid())
++ metadata.insert(key, date);
++ }
++ } else if (type == GST_TYPE_DATE_TIME) {
++ QDateTime date = parseDateTime(val);
++ if (date.isValid())
++ metadata.insert(key, parseDateTime(val));
++ } else if (type == GST_TYPE_SAMPLE) {
++ QImage image = parseImage(val);
++ Q_ASSERT(key == QMediaMetaData::CoverArtImage);
++ QtMultimediaPrivate::setCoverArtImage(metadata, image);
++ } else if (type == GST_TYPE_FRACTION) {
++ std::optional<double> fraction = parseFractionAsDouble(val);
++
++ if (fraction)
++ metadata.insert(key, *fraction);
++ }
++
++ g_value_unset(&val);
++ }
++
++ } // namespace
++
++ QMediaMetaData taglistToMetaData(const QGstTagListHandle &handle)
++ {
++ QMediaMetaData m;
++ extendMetaDataFromTagList(m, handle);
++ return m;
++ }
++
++ void extendMetaDataFromTagList(QMediaMetaData &metadata, const QGstTagListHandle &handle)
++ {
++ if (handle) {
++ // gstreamer has both GST_TAG_DATE_TIME and GST_TAG_DATE tags.
++ // if both are present, we use GST_TAG_DATE_TIME, else we fall back to GST_TAG_DATE
++
++ auto readDateTime = [&]() -> std::optional<QDateTime> {
++ GstDateTime *dateTimeHandle{};
++ gst_tag_list_get_date_time(handle.get(), GST_TAG_DATE_TIME, &dateTimeHandle);
++ if (dateTimeHandle) {
++ QDateTime ret = parseDateTime(dateTimeHandle);
++ gst_date_time_unref(dateTimeHandle);
++ if (ret.isValid())
++ return ret;
++ }
++ return std::nullopt;
++ };
++
++ auto readDate = [&]() -> std::optional<QDateTime> {
++ GDate *dateHandle{};
++ gst_tag_list_get_date(handle.get(), GST_TAG_DATE, &dateHandle);
++ if (dateHandle) {
++ QDateTime ret = parseDate(dateHandle);
++ g_date_free(dateHandle);
++ if (ret.isValid())
++ return ret;
++ }
++ return std::nullopt;
++ };
++
++ std::optional<QDateTime> date = readDateTime();
++ if (!date)
++ date = readDate();
++
++ if (date)
++ metadata.insert(QMediaMetaData::Key::Date, *date);
++
++ gst_tag_list_foreach(handle.get(), reinterpret_cast<GstTagForeachFunc>(&addTagToMetaData),
++ &metadata);
++ }
++ }
++
++ static void applyMetaDataToTagSetter(const QMediaMetaData &metadata, GstTagSetter *element)
++ {
++ gst_tag_setter_reset_tags(element);
++
++ for (QMediaMetaData::Key key : metadata.keys()) {
++ const char *tagName = keyToTag(key);
++ if (!tagName)
++ continue;
++ const QVariant &tagValue = metadata.value(key);
++
++ auto setTag = [&](const auto &value) {
++ gst_tag_setter_add_tags(element, GST_TAG_MERGE_REPLACE, tagName, value, nullptr);
++ };
++
++ switch (tagValue.typeId()) {
++ case QMetaType::QString:
++ setTag(tagValue.toString().toUtf8().constData());
++ break;
++ case QMetaType::Int:
++ case QMetaType::LongLong:
++ setTag(tagValue.toInt());
++ break;
++ case QMetaType::Double:
++ setTag(tagValue.toDouble());
++ break;
++
++ case QMetaType::QDateTime: {
++ // tagName does not properly disambiguate between GST_TAG_DATE_TIME and
++ // GST_TAG_DATE, as both map to QMediaMetaData::Key::Date. so we set it accordingly to
++ // the QVariant.
++
++ QDateTime date = tagValue.toDateTime();
++
++ QGstGstDateTimeHandle dateTime{
++ gst_date_time_new(date.offsetFromUtc() / 60. / 60., date.date().year(),
++ date.date().month(), date.date().day(), date.time().hour(),
++ date.time().minute(), date.time().second()),
++ QGstGstDateTimeHandle::HasRef,
++ };
++
++ gst_tag_setter_add_tags(element, GST_TAG_MERGE_REPLACE, GST_TAG_DATE_TIME,
++ dateTime.get(), nullptr);
++ break;
++ }
++ case QMetaType::QDate: {
++ QDate date = tagValue.toDate();
++
++ QUniqueGDateHandle dateHandle{
++ g_date_new_dmy(date.day(), GDateMonth(date.month()), date.year()),
++ };
++
++ gst_tag_setter_add_tags(element, GST_TAG_MERGE_REPLACE, GST_TAG_DATE, dateHandle.get(),
++ nullptr);
++ break;
++ }
++ default: {
++ if (tagValue.typeId() == qMetaTypeId<QLocale::Language>()) {
++ QByteArray language = QLocale::languageToCode(tagValue.value<QLocale::Language>(),
++ QLocale::ISO639Part2)
++ .toUtf8();
++ setTag(language.constData());
++ }
++
++ break;
++ }
++ }
++ }
++ }
++
++ void applyMetaDataToTagSetter(const QMediaMetaData &metadata, const QGstElement &element)
++ {
++ GstTagSetter *tagSetter = qGstSafeCast<GstTagSetter>(element.element());
++ if (tagSetter)
++ applyMetaDataToTagSetter(metadata, tagSetter);
++ else
++ qWarning() << "applyMetaDataToTagSetter failed: element not a GstTagSetter"
++ << element.name();
++ }
++
++ void applyMetaDataToTagSetter(const QMediaMetaData &metadata, const QGstBin &bin)
++ {
++ GstIterator *elements = gst_bin_iterate_all_by_interface(bin.bin(), GST_TYPE_TAG_SETTER);
++ GValue item = {};
++
++ while (gst_iterator_next(elements, &item) == GST_ITERATOR_OK) {
++ GstElement *element = static_cast<GstElement *>(g_value_get_object(&item));
++ if (!element)
++ continue;
++
++ GstTagSetter *tagSetter = qGstSafeCast<GstTagSetter>(element);
++
++ if (tagSetter)
++ applyMetaDataToTagSetter(metadata, tagSetter);
++ }
++
++ gst_iterator_free(elements);
++ }
++
++ void extendMetaDataFromCaps(QMediaMetaData &metadata, const QGstCaps &caps)
++ {
++ QGstStructureView structure = caps.at(0);
++
++ QMediaFormat::FileFormat fileFormat = QGstreamerFormatInfo::fileFormatForCaps(structure);
++ if (fileFormat != QMediaFormat::FileFormat::UnspecifiedFormat) {
++ // Container caps
++ metadata.insert(QMediaMetaData::FileFormat, fileFormat);
++ return;
++ }
++
++ QMediaFormat::AudioCodec audioCodec = QGstreamerFormatInfo::audioCodecForCaps(structure);
++ if (audioCodec != QMediaFormat::AudioCodec::Unspecified) {
++ // Audio stream caps
++ metadata.insert(QMediaMetaData::AudioCodec, QVariant::fromValue(audioCodec));
++ return;
++ }
++
++ QMediaFormat::VideoCodec videoCodec = QGstreamerFormatInfo::videoCodecForCaps(structure);
++ if (videoCodec != QMediaFormat::VideoCodec::Unspecified) {
++ // Video stream caps
++ metadata.insert(QMediaMetaData::VideoCodec, QVariant::fromValue(videoCodec));
++ std::optional<float> framerate = structure["framerate"].getFraction();
++ if (framerate)
++ metadata.insert(QMediaMetaData::VideoFrameRate, *framerate);
++
++ QSize resolution = structure.resolution();
++ if (resolution.isValid())
++ metadata.insert(QMediaMetaData::Resolution, resolution);
++ }
++ }
++
++ QMediaMetaData capsToMetaData(const QGstCaps &caps)
++ {
++ QMediaMetaData metadata;
++ extendMetaDataFromCaps(metadata, caps);
++ return metadata;
++ }
++
++ QT_END_NAMESPACE