qgst_debug.cpp - mozsearch

qt/qtmultimedia/src/plugins/multimedia/gstreamer/common/qgst_debug.cpp

Enable keyboard shortcuts

Revision control

++ // Copyright (C) 2024 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 "qgst_debug_p.h"

++ #include "qgstreamermessage_p.h"

++

++ #include <gst/gstclock.h>

++

++ QT_BEGIN_NAMESPACE

++

++ // NOLINTBEGIN(performance-unnecessary-value-param)

++

++ QDebug operator<<(QDebug dbg, const QGString &str)

++ {

++     return dbg << str.get();

++ }

++

++ QDebug operator<<(QDebug dbg, const QGstCaps &caps)

++ {

++     return dbg << caps.caps();

++ }

++

++ QDebug operator<<(QDebug dbg, const QGstStructureView &structure)

++ {

++     return dbg << structure.structure;

++ }

++

++ QDebug operator<<(QDebug dbg, const QUniqueGstStructureHandle &structure)

++ {

++     return dbg << QGstStructureView{structure};

++ }

++

++ QDebug operator<<(QDebug dbg, const QGValue &value)

++ {

++     return dbg << value.value;

++ }

++

++ QDebug operator<<(QDebug dbg, const QGstreamerMessage &msg)

++ {

++     return dbg << msg.message();

++ }

++

++ QDebug operator<<(QDebug dbg, const QUniqueGErrorHandle &handle)

++ {

++     return dbg << handle.get();

++ }

++

++ QDebug operator<<(QDebug dbg, const QUniqueGStringHandle &handle)

++ {

++     return dbg << handle.get();

++ }

++

++ QDebug operator<<(QDebug dbg, const QGstStreamCollectionHandle &handle)

++ {

++     return dbg << handle.get();

++ }

++

++ QDebug operator<<(QDebug dbg, const QGstStreamHandle &handle)

++ {

++     return dbg << handle.get();

++ }

++

++ QDebug operator<<(QDebug dbg, const QGstTagListHandle &handle)

++ {

++     return dbg << handle.get();

++ }

++

++ QDebug operator<<(QDebug dbg, const QGstElement &element)

++ {

++     return dbg << element.element();

++ }

++

++ QDebug operator<<(QDebug dbg, const QGstPad &pad)

++ {

++     return dbg << pad.pad();

++ }

++

++ QDebug operator<<(QDebug dbg, const GstCaps *caps)

++ {

++     if (caps)

++         return dbg << QGString(gst_caps_to_string(caps));

++     else

++         return dbg << "null";

++ }

++

++ QDebug operator<<(QDebug dbg, const GstVideoInfo *info)

++ {

++     return dbg << QGstCaps{

++         gst_video_info_to_caps(info),

++         QGstCaps::NeedsRef,

++     };

++ }

++

++ QDebug operator<<(QDebug dbg, const GstStructure *structure)

++ {

++     if (structure)

++         return dbg << QGString(gst_structure_to_string(structure));

++     else

++         return dbg << "null";

++ }

++

++ QDebug operator<<(QDebug dbg, const GstObject *object)

++ {

++     if (!object)

++         return dbg << "null";

++

++     dbg << QGString{gst_object_get_name(const_cast<GstObject*>(object))};

++

++     {

++         QDebugStateSaver saver(dbg);

++         dbg.nospace();

++

++         dbg << "{";

++

++         guint numProperties;

++         GParamSpec **properties = g_object_class_list_properties(G_OBJECT_GET_CLASS(object), &numProperties);

++

++         for (guint i = 0; i < numProperties; i++) {

++             GParamSpec *param = properties[i];

++

++             const gchar *name = g_param_spec_get_name(param);

++             constexpr bool trace_blurb = false;

++             if constexpr (trace_blurb) {

++                 const gchar *blurb = g_param_spec_get_blurb(param);

++                 dbg << name << " (" << blurb << "): ";

++             } else

++                 dbg << name << ": ";

++

++             bool readable = bool(param->flags & G_PARAM_READABLE);

++             if (!readable) {

++                 dbg << "(not readable)";

++             } else if (QLatin1StringView(name) == QLatin1StringView("parent")) {

++                 if (object->parent)

++                     dbg << QGString{ gst_object_get_name(object->parent) };

++                 else

++                     dbg << "(none)";

++             } else {

++                 GValue value = {};

++                 g_object_get_property(&const_cast<GstObject *>(object)->object, param->name,

++                                       &value);

++                 dbg << &value;

++             }

++             if (i != numProperties - 1)

++                 dbg << ", ";

++         }

++

++         dbg << "}";

++

++         g_free(properties);

++     }

++     return dbg;

++ }

++

++ QDebug operator<<(QDebug dbg, const GstElement *element)

++ {

++     return dbg << GST_OBJECT_CAST(element); // LATER: output other members?

++ }

++

++ QDebug operator<<(QDebug dbg, const GstPad *pad)

++ {

++     return dbg << GST_OBJECT_CAST(pad); // LATER: output other members?

++ }

++

++ QDebug operator<<(QDebug dbg, const GstDevice *device)

++ {

++     if (!device)

++         return dbg << "null";

++

++     GstDevice *d = const_cast<GstDevice *>(device);

++     QDebugStateSaver saver(dbg);

++     dbg.nospace();

++

++     dbg << gst_device_get_display_name(d) << "(" << gst_device_get_device_class(d) << ") ";

++     dbg << "Caps: " << QGstCaps{ gst_device_get_caps(d), QGstCaps::NeedsRef, } << ", ";

++     dbg << "Properties: " << QUniqueGstStructureHandle{ gst_device_get_properties(d) }.get();

++     return dbg;

++ }

++

++ namespace {

++

++ struct Timepoint

++ {

++     explicit Timepoint(guint64 us) : ts{ us } { }

++     guint64 ts;

++ };

++

++ QDebug operator<<(QDebug dbg, Timepoint ts)

++ {

++     char buffer[128];

++     snprintf(buffer, sizeof(buffer), "%" GST_TIME_FORMAT, GST_TIME_ARGS(ts.ts));

++     dbg << buffer;

++     return dbg;

++ }

++

++ } // namespace

++

++ QDebug operator<<(QDebug dbg, const GstMessage *msg)

++ {

++     QDebugStateSaver saver(dbg);

++     dbg.nospace();

++

++     dbg << GST_MESSAGE_TYPE_NAME(msg) << ", Source: " << GST_MESSAGE_SRC_NAME(msg);

++     if (GST_MESSAGE_TIMESTAMP(msg) != 0xFFFFFFFFFFFFFFFF)

++         dbg << ", Timestamp: " << GST_MESSAGE_TIMESTAMP(msg);

++

++     switch (msg->type) {

++     case GST_MESSAGE_ERROR: {

++         QUniqueGErrorHandle err;

++         QGString debug;

++         gst_message_parse_error(const_cast<GstMessage *>(msg), &err, &debug);

++

++         dbg << ", Error: " << err << " (" << debug << ")";

++         break;

++     }

++

++     case GST_MESSAGE_WARNING: {

++         QUniqueGErrorHandle err;

++         QGString debug;

++         gst_message_parse_warning(const_cast<GstMessage *>(msg), &err, &debug);

++

++         dbg << ", Warning: " << err << " (" << debug << ")";

++         break;

++     }

++

++     case GST_MESSAGE_INFO: {

++         QUniqueGErrorHandle err;

++         QGString debug;

++         gst_message_parse_info(const_cast<GstMessage *>(msg), &err, &debug);

++

++         dbg << ", Info: " << err << " (" << debug << ")";

++         break;

++     }

++

++     case GST_MESSAGE_TAG: {

++         QGstTagListHandle tagList;

++         gst_message_parse_tag(const_cast<GstMessage *>(msg), &tagList);

++

++         dbg << ", Tags: " << tagList;

++         break;

++     }

++

++     case GST_MESSAGE_QOS: {

++         gboolean live;

++         guint64 running_time;

++         guint64 stream_time;

++         guint64 timestamp;

++         guint64 duration;

++

++         gst_message_parse_qos(const_cast<GstMessage *>(msg), &live, &running_time, &stream_time,

++                               &timestamp, &duration);

++

++         dbg << ", Live: " << bool(live) << ", Running time: " << Timepoint{ running_time }

++             << ", Stream time: " << Timepoint{ stream_time }

++             << ", Timestamp: " << Timepoint{ timestamp } << ", Duration: " << Timepoint{ duration };

++         break;

++     }

++

++     case GST_MESSAGE_STATE_CHANGED: {

++         GstState oldState;

++         GstState newState;

++         GstState pending;

++

++         gst_message_parse_state_changed(const_cast<GstMessage *>(msg), &oldState, &newState,

++                                         &pending);

++

++         dbg << ", Transition: " << oldState << "->" << newState;

++

++         if (pending != GST_STATE_VOID_PENDING)

++             dbg << ", Pending State: " << pending;

++         break;

++     }

++

++     case GST_MESSAGE_STREAM_COLLECTION: {

++         QGstStreamCollectionHandle collection;

++         gst_message_parse_stream_collection(const_cast<GstMessage *>(msg), &collection);

++

++         dbg << ", " << collection;

++         break;

++     }

++

++     case GST_MESSAGE_STREAMS_SELECTED: {

++         QGstStreamCollectionHandle collection;

++         gst_message_parse_streams_selected(const_cast<GstMessage *>(msg), &collection);

++

++         dbg << ", " << collection;

++         break;

++     }

++

++     case GST_MESSAGE_STREAM_STATUS: {

++         GstStreamStatusType streamStatus;

++         gst_message_parse_stream_status(const_cast<GstMessage *>(msg), &streamStatus, nullptr);

++

++         dbg << ", Stream Status: " << streamStatus;

++         break;

++     }

++

++     case GST_MESSAGE_BUFFERING: {

++         int progress = 0;

++         gst_message_parse_buffering(const_cast<GstMessage *>(msg), &progress);

++

++         dbg << ", Buffering: " << progress << "%";

++         break;

++     }

++

++     case GST_MESSAGE_SEGMENT_START: {

++         gint64 pos;

++         GstFormat fmt{};

++         gst_message_parse_segment_start(const_cast<GstMessage *>(msg), &fmt, &pos);

++

++         switch (fmt) {

++         case GST_FORMAT_TIME: {

++             dbg << ", Position: " << std::chrono::nanoseconds{ pos };

++             break;

++         }

++         case GST_FORMAT_BYTES: {

++             dbg << ", Position: " << pos << "Bytes";

++             break;

++         }

++         default: {

++             dbg << ", Position: " << pos;

++             break;

++         }

++         }

++

++         break;

++     }

++

++     default:

++         break;

++     }

++     return dbg;

++ }

++

++ QDebug operator<<(QDebug dbg, const GstTagList *tagList)

++ {

++     if (tagList)

++         dbg << QGString{ gst_tag_list_to_string(tagList) };

++     else

++         dbg << "NULL";

++

++     return dbg;

++ }

++

++ QDebug operator<<(QDebug dbg, const GstQuery *query)

++ {

++     dbg << GST_QUERY_TYPE_NAME(query);

++     return dbg;

++ }

++

++ QDebug operator<<(QDebug dbg, const GstEvent *event)

++ {

++     dbg << GST_EVENT_TYPE_NAME(event);

++     return dbg;

++ }

++

++ QDebug operator<<(QDebug dbg, const GstPadTemplate *padTemplate)

++ {

++     QGstCaps caps = padTemplate

++             ? QGstCaps{ gst_pad_template_get_caps(const_cast<GstPadTemplate *>(padTemplate)), QGstCaps::HasRef, }

++             : QGstCaps{};

++

++     dbg << caps;

++     return dbg;

++ }

++

++ QDebug operator<<(QDebug dbg, const GstStreamCollection *streamCollection)

++ {

++     QDebugStateSaver saver(dbg);

++     dbg.nospace();

++

++     GstStreamCollection *collection = const_cast<GstStreamCollection *>(streamCollection);

++     dbg << "Stream Collection: {";

++

++     qForeachStreamInCollection(collection, [&](GstStream *stream) {

++         dbg << stream << ", ";

++     });

++

++     dbg << "}";

++     return dbg;

++ }

++

++ QDebug operator<<(QDebug dbg, const GstStream *cstream)

++ {

++     GstStream *stream = const_cast<GstStream *>(cstream);

++

++     QDebugStateSaver saver(dbg);

++     dbg.nospace();

++

++     dbg << gst_stream_get_stream_id(stream) << " (" << gst_stream_get_stream_type(stream) << ")";

++

++     return dbg;

++ }

++

++ QDebug operator<<(QDebug dbg, GstState state)

++ {

++     return dbg << gst_element_state_get_name(state);

++ }

++

++ QDebug operator<<(QDebug dbg, GstStateChange transition)

++ {

++     return dbg << gst_state_change_get_name(transition);

++ }

++

++ QDebug operator<<(QDebug dbg, GstStateChangeReturn stateChangeReturn)

++ {

++     return dbg << gst_element_state_change_return_get_name(stateChangeReturn);

++ }

++

++ QDebug operator<<(QDebug dbg, GstMessageType type)

++ {

++     return dbg << gst_message_type_get_name(type);

++ }

++

++ #define ADD_ENUM_SWITCH(value) \

++     case value:                \

++         return dbg << #value;  \

++         static_assert(true, "enforce semicolon")

++

++ QDebug operator<<(QDebug dbg, GstPadDirection direction)

++ {

++     switch (direction) {

++         ADD_ENUM_SWITCH(GST_PAD_UNKNOWN);

++         ADD_ENUM_SWITCH(GST_PAD_SRC);

++         ADD_ENUM_SWITCH(GST_PAD_SINK);

++     default:

++         Q_UNREACHABLE_RETURN(dbg);

++     }

++ }

++

++ QDebug operator<<(QDebug dbg, GstStreamStatusType type)

++ {

++     switch (type) {

++         ADD_ENUM_SWITCH(GST_STREAM_STATUS_TYPE_CREATE);

++         ADD_ENUM_SWITCH(GST_STREAM_STATUS_TYPE_ENTER);

++         ADD_ENUM_SWITCH(GST_STREAM_STATUS_TYPE_LEAVE);

++         ADD_ENUM_SWITCH(GST_STREAM_STATUS_TYPE_DESTROY);

++         ADD_ENUM_SWITCH(GST_STREAM_STATUS_TYPE_START);

++         ADD_ENUM_SWITCH(GST_STREAM_STATUS_TYPE_PAUSE);

++         ADD_ENUM_SWITCH(GST_STREAM_STATUS_TYPE_STOP);

++     default:

++         Q_UNREACHABLE_RETURN(dbg);

++     }

++     return dbg;

++ }

++

++ #undef ADD_ENUM_SWITCH

++

++ QDebug operator<<(QDebug dbg, GstStreamType streamType)

++ {

++     dbg << gst_stream_type_get_name(streamType);

++     return dbg;

++ }

++

++ QDebug operator<<(QDebug dbg, const GValue *value)

++ {

++     if (!value)

++         return dbg << "null";

++

++     switch (G_VALUE_TYPE(value)) {

++     case G_TYPE_STRING:

++         return dbg << g_value_get_string(value);

++     case G_TYPE_BOOLEAN:

++         return dbg << g_value_get_boolean(value);

++     case G_TYPE_ULONG:

++         return dbg << g_value_get_ulong(value);

++     case G_TYPE_LONG:

++         return dbg << g_value_get_long(value);

++     case G_TYPE_UINT:

++         return dbg << g_value_get_uint(value);

++     case G_TYPE_INT:

++         return dbg << g_value_get_int(value);

++     case G_TYPE_UINT64:

++         return dbg << g_value_get_uint64(value);

++     case G_TYPE_INT64:

++         return dbg << g_value_get_int64(value);

++     case G_TYPE_FLOAT:

++         return dbg << g_value_get_float(value);

++     case G_TYPE_DOUBLE:

++         return dbg << g_value_get_double(value);

++     default:

++         break;

++     }

++

++     if (GST_VALUE_HOLDS_BITMASK(value)) {

++         QDebugStateSaver saver(dbg);

++         return dbg << Qt::hex << gst_value_get_bitmask(value);

++     }

++

++     if (GST_VALUE_HOLDS_FRACTION(value))

++         return dbg << gst_value_get_fraction_numerator(value) << "/"

++                    << gst_value_get_fraction_denominator(value);

++

++     if (GST_VALUE_HOLDS_CAPS(value))

++         return dbg << gst_value_get_caps(value);

++

++     if (GST_VALUE_HOLDS_STRUCTURE(value))

++         return dbg << gst_value_get_structure(value);

++

++     if (GST_VALUE_HOLDS_ARRAY(value)) {

++         const guint size = gst_value_array_get_size(value);

++         const guint last = size - 1;

++         dbg << "[";

++         for (guint index = 0; index != size; ++index) {

++             dbg << gst_value_array_get_value(value, index);

++             if (index != last)

++                 dbg << ", ";

++         }

++         dbg << "}";

++         return dbg;

++     }

++

++     if (G_VALUE_TYPE(value) == GST_TYPE_PAD_DIRECTION) {

++         GstPadDirection direction = static_cast<GstPadDirection>(g_value_get_enum(value));

++         return dbg << direction;

++     }

++

++     if (G_VALUE_TYPE(value) == GST_TYPE_PAD_TEMPLATE) {

++         GstPadTemplate *padTemplate = static_cast<GstPadTemplate *>(g_value_get_object(value));

++         return dbg << padTemplate;

++     }

++

++     dbg << "(not implemented: " << G_VALUE_TYPE_NAME(value) << ")";

++

++     return dbg;

++ }

++

++ QDebug operator<<(QDebug dbg, const GError *error)

++ {

++     return dbg << error->message;

++ }

++

++ QCompactGstMessageAdaptor::QCompactGstMessageAdaptor(const QGstreamerMessage &m)

++     : QCompactGstMessageAdaptor{

++           m.message(),

++       }

++ {

++ }

++

++ QCompactGstMessageAdaptor::QCompactGstMessageAdaptor(GstMessage *m)

++     : msg{

++           m,

++       }

++ {

++ }

++

++ QDebug operator<<(QDebug dbg, const QCompactGstMessageAdaptor &m)

++ {

++     std::optional<QDebugStateSaver> saver(dbg);

++     dbg.nospace();

++

++     switch (GST_MESSAGE_TYPE(m.msg)) {

++     case GST_MESSAGE_ERROR: {

++         QUniqueGErrorHandle err;

++         QGString debug;

++         gst_message_parse_error(m.msg, &err, &debug);

++         dbg << err << " (" << debug << ")";

++         return dbg;

++     }

++

++     case GST_MESSAGE_WARNING: {

++         QUniqueGErrorHandle err;

++         QGString debug;

++         gst_message_parse_warning(m.msg, &err, &debug);

++         dbg << err << " (" << debug << ")";

++         return dbg;

++     }

++

++     case GST_MESSAGE_INFO: {

++         QUniqueGErrorHandle err;

++         QGString debug;

++         gst_message_parse_info(m.msg, &err, &debug);

++

++         dbg << err << " (" << debug << ")";

++         return dbg;

++     }

++

++     case GST_MESSAGE_STATE_CHANGED: {

++         GstState oldState;

++         GstState newState;

++         GstState pending;

++

++         gst_message_parse_state_changed(m.msg, &oldState, &newState, &pending);

++

++         dbg << oldState << " -> " << newState;

++         if (pending != GST_STATE_VOID_PENDING)

++             dbg << " (pending: " << pending << ")";

++         return dbg;

++     }

++

++     default: {

++         saver.reset();

++         return dbg << m.msg;

++     }

++     }

++ }

++

++ QDebug operator<<(QDebug dbg, GstPlayMessage type)

++ {

++     return dbg << gst_play_message_get_name(type);

++ }

++

++ QDebug operator<<(QDebug dbg, GstPlayState state)

++ {

++     return dbg << gst_play_state_get_name(state);

++ }

++

++ QGstPlayMessageAdaptor::QGstPlayMessageAdaptor(const QGstreamerMessage &m)

++     : QGstPlayMessageAdaptor{

++           m.message(),

++       }

++ {

++ }

++

++ QGstPlayMessageAdaptor::QGstPlayMessageAdaptor(GstMessage *m)

++     : msg{

++           m,

++       }

++ {

++ }

++

++ QDebug operator<<(QDebug dbg, const QGstPlayMessageAdaptor &m)

++ {

++     using namespace std::chrono;

++     Q_ASSERT(gst_play_is_play_message(m.msg));

++

++     std::optional<QDebugStateSaver> saver(dbg);

++

++     GstPlayMessage type;

++     gst_play_message_parse_type(m.msg, &type);

++

++     switch (type) {

++     case GST_PLAY_MESSAGE_URI_LOADED:

++     case GST_PLAY_MESSAGE_END_OF_STREAM:

++     case GST_PLAY_MESSAGE_MEDIA_INFO_UPDATED:

++     case GST_PLAY_MESSAGE_VOLUME_CHANGED:

++     case GST_PLAY_MESSAGE_MUTE_CHANGED:

++     case GST_PLAY_MESSAGE_SEEK_DONE:

++         return dbg << type;

++

++     case GST_PLAY_MESSAGE_POSITION_UPDATED: {

++         GstClockTime position;

++         gst_play_message_parse_position_updated(m.msg, &position);

++         return dbg << type << nanoseconds(position);

++     }

++     case GST_PLAY_MESSAGE_DURATION_CHANGED: {

++         GstClockTime duration;

++         gst_play_message_parse_duration_updated(m.msg, &duration);

++         return dbg << type << nanoseconds(duration);

++     }

++

++     case GST_PLAY_MESSAGE_STATE_CHANGED: {

++         GstPlayState state;

++         gst_play_message_parse_state_changed(m.msg, &state);

++         return dbg << type << state;

++     }

++     case GST_PLAY_MESSAGE_BUFFERING: {

++         guint percent;

++         gst_play_message_parse_buffering_percent(m.msg, &percent);

++         return dbg << type << percent;

++     }

++     case GST_PLAY_MESSAGE_ERROR: {

++         QUniqueGErrorHandle err;

++         QUniqueGstStructureHandle details;

++         gst_play_message_parse_error(m.msg, &err, &details);

++         return dbg << type << err << details.get();

++     }

++     case GST_PLAY_MESSAGE_WARNING: {

++         QUniqueGErrorHandle err;

++         QUniqueGstStructureHandle details;

++         gst_play_message_parse_warning(m.msg, &err, &details);

++         return dbg << type << err << details.get();

++     };

++

++     case GST_PLAY_MESSAGE_VIDEO_DIMENSIONS_CHANGED: {

++         guint width, height;

++         gst_play_message_parse_video_dimensions_changed(m.msg, &width, &height);

++         return dbg << type << QSize(width, height);

++     }

++     default:

++         Q_UNREACHABLE_RETURN(dbg);

++     }

++ }

++

++ QT_END_NAMESPACE