1// Copyright (C) 2024 The Qt Company Ltd.
2// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
3
4#include "common/qgst_discoverer_p.h"
5
6#include <QtMultimedia/qmediaformat.h>
7
8#include <common/qglist_helper_p.h>
9#include <common/qgst_debug_p.h>
10#include <common/qgstreamermetadata_p.h>
11#include <common/qgstutils_p.h>
12#include <uri_handler/qgstreamer_qiodevice_handler_p.h>
13
14QT_BEGIN_NAMESPACE
15
16namespace QGst {
17
18namespace {
19
20template <typename StreamInfo>
21struct GstDiscovererStreamInfoList : QGstUtils::GListRangeAdaptor<StreamInfo *>
22{
23 using BaseType = QGstUtils::GListRangeAdaptor<StreamInfo *>;
24 using BaseType::BaseType;
25
26 ~GstDiscovererStreamInfoList() { gst_discoverer_stream_info_list_free(BaseType::head); }
27};
28
29QGstTagListHandle duplicateTagList(const GstTagList *tagList)
30{
31 if (!tagList)
32 return {};
33 return QGstTagListHandle{
34 gst_tag_list_copy(tagList),
35 QGstTagListHandle::HasRef,
36 };
37}
38
39QGstDiscovererStreamInfo parseGstDiscovererStreamInfo(GstDiscovererStreamInfo *info)
40{
41 QGstDiscovererStreamInfo result;
42
43 result.streamID = QString::fromUtf8(utf8: gst_discoverer_stream_info_get_stream_id(info));
44 result.tags = duplicateTagList(tagList: gst_discoverer_stream_info_get_tags(info));
45
46 result.streamNumber = gst_discoverer_stream_info_get_stream_number(info);
47
48 result.caps = QGstCaps{
49 gst_discoverer_stream_info_get_caps(info),
50 QGstCaps::HasRef,
51 };
52
53 return result;
54}
55
56template <typename T>
57constexpr bool isStreamInfo = std::is_same_v<std::decay_t<T>, GstDiscovererVideoInfo>
58 || std::is_same_v<std::decay_t<T>, GstDiscovererAudioInfo>
59 || std::is_same_v<std::decay_t<T>, GstDiscovererSubtitleInfo>
60 || std::is_same_v<std::decay_t<T>, GstDiscovererContainerInfo>;
61
62template <typename T>
63QGstDiscovererStreamInfo parseGstDiscovererStreamInfo(T *info)
64{
65 static_assert(isStreamInfo<T>);
66 return parseGstDiscovererStreamInfo(GST_DISCOVERER_STREAM_INFO(info));
67}
68
69QGstDiscovererVideoInfo parseGstDiscovererVideoInfo(GstDiscovererVideoInfo *info)
70{
71 QGstDiscovererVideoInfo result;
72 static_cast<QGstDiscovererStreamInfo &>(result) = parseGstDiscovererStreamInfo(info);
73
74 result.size = QSize{
75 int(gst_discoverer_video_info_get_width(info)),
76 int(gst_discoverer_video_info_get_height(info)),
77 };
78
79 result.bitDepth = gst_discoverer_video_info_get_depth(info);
80 result.framerate = Fraction{
81 .numerator: int(gst_discoverer_video_info_get_framerate_num(info)),
82 .denominator: int(gst_discoverer_video_info_get_framerate_denom(info)),
83 };
84
85 result.pixelAspectRatio = Fraction{
86 .numerator: int(gst_discoverer_video_info_get_par_num(info)),
87 .denominator: int(gst_discoverer_video_info_get_par_denom(info)),
88 };
89
90 result.isInterlaced = gst_discoverer_video_info_is_interlaced(info);
91 result.bitrate = int(gst_discoverer_video_info_get_bitrate(info));
92 result.maxBitrate = int(gst_discoverer_video_info_get_max_bitrate(info));
93 result.isImage = int(gst_discoverer_video_info_is_image(info));
94
95 return result;
96}
97
98QGstDiscovererAudioInfo parseGstDiscovererAudioInfo(GstDiscovererAudioInfo *info)
99{
100 QGstDiscovererAudioInfo result;
101 static_cast<QGstDiscovererStreamInfo &>(result) = parseGstDiscovererStreamInfo(info);
102
103 result.channels = int(gst_discoverer_audio_info_get_channels(info));
104 result.channelMask = gst_discoverer_audio_info_get_channel_mask(info);
105 result.sampleRate = gst_discoverer_audio_info_get_sample_rate(info);
106 result.bitsPerSample = gst_discoverer_audio_info_get_depth(info);
107
108 result.bitrate = int(gst_discoverer_audio_info_get_bitrate(info));
109 result.maxBitrate = int(gst_discoverer_audio_info_get_max_bitrate(info));
110 result.language = QGstUtils::codeToLanguage(gst_discoverer_audio_info_get_language(info));
111
112 return result;
113}
114
115QGstDiscovererSubtitleInfo parseGstDiscovererSubtitleInfo(GstDiscovererSubtitleInfo *info)
116{
117 QGstDiscovererSubtitleInfo result;
118 static_cast<QGstDiscovererStreamInfo &>(result) = parseGstDiscovererStreamInfo(info);
119 result.language = QGstUtils::codeToLanguage(gst_discoverer_subtitle_info_get_language(info));
120 return result;
121}
122
123QGstDiscovererContainerInfo parseGstDiscovererContainerInfo(GstDiscovererContainerInfo *info)
124{
125 QGstDiscovererContainerInfo result;
126 static_cast<QGstDiscovererStreamInfo &>(result) = parseGstDiscovererStreamInfo(info);
127
128 result.tags = duplicateTagList(tagList: gst_discoverer_container_info_get_tags(info));
129
130 return result;
131}
132
133QGstDiscovererInfo parseGstDiscovererInfo(GstDiscovererInfo *info)
134{
135 using namespace QGstUtils;
136
137 QGstDiscovererInfo result;
138 result.isLive = gst_discoverer_info_get_live(info);
139 result.isSeekable = gst_discoverer_info_get_seekable(info);
140
141 GstClockTime duration = gst_discoverer_info_get_duration(info);
142 if (duration != GST_CLOCK_TIME_NONE)
143 result.duration = std::chrono::nanoseconds{ duration };
144
145 QGstDiscovererStreamInfoHandle streamInfo{
146 gst_discoverer_info_get_stream_info(info),
147 QGstDiscovererStreamInfoHandle::HasRef,
148 };
149 if (streamInfo && GST_IS_DISCOVERER_CONTAINER_INFO(streamInfo.get()))
150 result.containerInfo =
151 parseGstDiscovererContainerInfo(GST_DISCOVERER_CONTAINER_INFO(streamInfo.get()));
152 result.tags = duplicateTagList(tagList: gst_discoverer_info_get_tags(info));
153
154 GstDiscovererStreamInfoList<GstDiscovererVideoInfo> videoStreams{
155 gst_discoverer_info_get_video_streams(info),
156 };
157 for (GstDiscovererVideoInfo *videoInfo : videoStreams)
158 result.videoStreams.emplace_back(args: parseGstDiscovererVideoInfo(info: videoInfo));
159
160 GstDiscovererStreamInfoList<GstDiscovererAudioInfo> audioStreams{
161 gst_discoverer_info_get_audio_streams(info),
162 };
163 for (GstDiscovererAudioInfo *audioInfo : audioStreams)
164 result.audioStreams.emplace_back(args: parseGstDiscovererAudioInfo(info: audioInfo));
165
166 GstDiscovererStreamInfoList<GstDiscovererSubtitleInfo> subtitleStreams{
167 gst_discoverer_info_get_subtitle_streams(info),
168 };
169 for (GstDiscovererSubtitleInfo *subtitleInfo : subtitleStreams)
170 result.subtitleStreams.emplace_back(args: parseGstDiscovererSubtitleInfo(info: subtitleInfo));
171
172 GstDiscovererStreamInfoList<GstDiscovererContainerInfo> containerStreams{
173 gst_discoverer_info_get_container_streams(info),
174 };
175 for (GstDiscovererContainerInfo *containerInfo : containerStreams)
176 result.containerStreams.emplace_back(args: parseGstDiscovererContainerInfo(info: containerInfo));
177
178 return result;
179}
180
181} // namespace
182
183//----------------------------------------------------------------------------------------------------------------------
184
185static constexpr std::chrono::nanoseconds discovererTimeout = std::chrono::seconds(10);
186
187QGstDiscoverer::QGstDiscoverer()
188 : m_instance{
189 gst_discoverer_new(timeout: discovererTimeout.count(), err: nullptr),
190 QGstDiscovererHandle::HasRef,
191 }
192{
193}
194
195QMaybe<QGstDiscovererInfo, QUniqueGErrorHandle> QGstDiscoverer::discover(const QString &uri)
196{
197 return discover(uri.toUtf8().constData());
198}
199
200QMaybe<QGstDiscovererInfo, QUniqueGErrorHandle> QGstDiscoverer::discover(const QUrl &url)
201{
202 return discover(url.toEncoded().constData());
203}
204
205QMaybe<QGstDiscovererInfo, QUniqueGErrorHandle> QGstDiscoverer::discover(QIODevice *device)
206{
207 return discover(url: qGstRegisterQIODevice(device));
208}
209
210QMaybe<QGstDiscovererInfo, QUniqueGErrorHandle> QGstDiscoverer::discover(const char *uri)
211{
212 QUniqueGErrorHandle error;
213 QGstDiscovererInfoHandle info{
214 gst_discoverer_discover_uri(discoverer: m_instance.get(), uri, err: &error),
215 QGstDiscovererInfoHandle::HasRef,
216 };
217
218 if (error)
219 return {
220 unexpect,
221 std::move(error),
222 };
223
224 QGstDiscovererInfo result = parseGstDiscovererInfo(info: info.get());
225 return result;
226}
227
228//----------------------------------------------------------------------------------------------------------------------
229
230QMediaMetaData toContainerMetadata(const QGstDiscovererInfo &info)
231{
232 QMediaMetaData metadata;
233 using Key = QMediaMetaData::Key;
234 using namespace std::chrono;
235
236 if (info.containerInfo)
237 extendMetaDataFromTagList(metadata, info.containerInfo->tags);
238 else
239 extendMetaDataFromTagList(metadata, info.tags);
240
241 auto updateMetadata = [&](Key key, auto value) {
242 QVariant currentValue = metadata.value(k: key);
243 if (!currentValue.isValid() || currentValue != value)
244 metadata.insert(k: key, value);
245 };
246
247 if (info.duration)
248 updateMetadata(Key::Duration,
249 QVariant::fromValue(value: round<milliseconds>(d: *info.duration).count()));
250
251 return metadata;
252}
253
254void addMissingKeysFromTaglist(QMediaMetaData &metadata, const QGstTagListHandle &tagList)
255{
256 QMediaMetaData tagMetaData = taglistToMetaData(tagList);
257 for (auto element : tagMetaData.asKeyValueRange()) {
258 if (metadata.keys().contains(t: element.first))
259 continue;
260
261 metadata.insert(k: element.first, value: element.second);
262 }
263}
264
265template <typename ValueType>
266static void updateMetadata(QMediaMetaData &metadata, QMediaMetaData::Key key, ValueType value)
267{
268 QVariant currentValue = metadata.value(k: key);
269 if (!currentValue.isValid() || currentValue != value)
270 metadata.insert(k: key, value);
271}
272
273QMediaMetaData toStreamMetadata(const QGstDiscovererVideoInfo &info)
274{
275 QMediaMetaData metadata;
276 using Key = QMediaMetaData::Key;
277
278 updateMetadata(metadata, key: Key::VideoBitRate, value: info.bitrate);
279
280 extendMetaDataFromCaps(metadata, info.caps);
281 addMissingKeysFromTaglist(metadata, tagList: info.tags);
282
283 return metadata;
284}
285
286QMediaMetaData toStreamMetadata(const QGstDiscovererAudioInfo &info)
287{
288 QMediaMetaData metadata;
289 using Key = QMediaMetaData::Key;
290
291 updateMetadata(metadata, key: Key::AudioBitRate, value: info.bitrate);
292 updateMetadata(metadata, key: Key::Language, value: info.language);
293
294 extendMetaDataFromCaps(metadata, info.caps);
295 addMissingKeysFromTaglist(metadata, tagList: info.tags);
296
297 return metadata;
298}
299
300QMediaMetaData toStreamMetadata(const QGstDiscovererSubtitleInfo &info)
301{
302 QMediaMetaData metadata;
303 using Key = QMediaMetaData::Key;
304
305 updateMetadata(metadata, key: Key::Language, value: info.language);
306
307 extendMetaDataFromCaps(metadata, info.caps);
308 addMissingKeysFromTaglist(metadata, tagList: info.tags);
309
310 return metadata;
311}
312
313} // namespace QGst
314
315QT_END_NAMESPACE
316

source code of qtmultimedia/src/plugins/multimedia/gstreamer/common/qgst_discoverer.cpp