Recently I've discovered, that connecting to signals in gstreamermm can be really inconvenient. The problem doesn't exist in the other mm libraries, because most of the classes and their signals are wrapped.
But GStreamer allows to create user-defined elements, so it's actually impossible to wrap everything in gstreamermm (for now library supports wrappers for gstreamer plugins core and base).
Currently, if you want to connect to a signal in gstreamermm, you have two options:
Moreover, I'm going to remove plugin API in the next release [1], so user won't be able to use gstreamermm API even for the base and core plugins. I was wondering, if it would be possible to write generic wrapper for the GObject signals. So... there you are! The solution is not perfect yet, and I haven't tested it so much, but so far it works fine with few plugins and signals.
As you see, you still have to know the type of the callback, but at least you can use gstreamermm C++ classes.
There is couple of things to do in this code, like getting last parameter from the list in more efficient way than through the tuple, etc.
I don't feel it is stable enough to integrate it with gstreamermm, but probably in the future I'll do that. Also, we could even internally use it in the glibmm to reduce amount of generated code.
Links
[1] https://bugzilla.gnome.org/show_bug.cgi?id=755395
[2] https://gist.github.com/loganek/7833089caff73ff2e8b1f076c8f7910e
But GStreamer allows to create user-defined elements, so it's actually impossible to wrap everything in gstreamermm (for now library supports wrappers for gstreamer plugins core and base).
Currently, if you want to connect to a signal in gstreamermm, you have two options:
- Using pure C API:
- Using gstreamermm API As I mentioned, gstreamermm provide wrappers for core and base plugins, so some of the elements (and their signals) are already wrapped in the library:
auto typefind = Gst::ElementFactory::create_element("typefind");
g_signal_connect (typefind->gobj(),
"have-type",
G_CALLBACK(cb_typefind_havetype),
(gpointer *)typefind->gobj());
static void cb_typefind_havetype (GstTypeFindElement *typefind,
guint probability,
GstCaps *caps,
gpointer user_data)
{
// callback implementation
}
Well, it's not very bad. But... you have to use C structures in the callback instead of C++ wrappers.
auto typefind = Gst::TypeFindElement::create();
typefind->signal_have_type().connect(
[] (guint probability, const Glib::RefPtr& caps)
{
// callback implementation
});
Moreover, I'm going to remove plugin API in the next release [1], so user won't be able to use gstreamermm API even for the base and core plugins. I was wondering, if it would be possible to write generic wrapper for the GObject signals. So... there you are! The solution is not perfect yet, and I haven't tested it so much, but so far it works fine with few plugins and signals.
namespace Glib
{
template <typename T>
static constexpr T wrap (T v, bool=true)
{
return v;
}
template <typename T>
static constexpr T unwrap (T v, bool=true)
{
return v;
}
template<typename T>
using unwrapped_t = decltype(unwrap(*((typename std::remove_reference<T>::type*)nullptr)));
template<typename T>
constexpr T return_helper()
{
typedef unwrapped_t<T> Ret;
return Ret();
}
template<>
constexpr void return_helper()
{
return void();
}
}
template<typename>
class signal_callback;
template<typename Ret, typename ...T>
class signal_callback<Ret(T...)>
{
template<typename ...Args>
static auto callback(void* self, Args ...v)
{
using Glib::wrap;
typedef sigc::slot< void, decltype(wrap(v))... > SlotType;
void* data = std::get<sizeof...(Args)-1>(std::tuple<Args...>(v...));
// Do not try to call a signal on a disassociated wrapper.
if(dynamic_cast<Glib::Object*>(Glib::ObjectBase::_get_current_wrapper((GObject*) self)))
{
try
{
if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
{
(*static_cast<SlotType*>(slot))(wrap(std::forward<Args>(v), true)...);
}
}
catch(...)
{
Glib::exception_handlers_invoke();
}
}
return Glib::return_helper<Ret>();
}
public:
auto operator()(const std::string& signal_name, const Glib::RefPtr<Glib::Object>& obj)
{
using Glib::unwrap;
static std::map<std::pair<GType, std::string>, Glib::SignalProxyInfo> signal_infos;
auto key = std::make_pair(G_TYPE_FROM_INSTANCE (obj->gobj()), signal_name);
if (signal_infos.find(key) == signal_infos.end())
{
signal_infos[key] = {
signal_name.c_str(),
(GCallback) &callback<Glib::unwrapped_t<T>..., void*>,
(GCallback) &callback<Glib::unwrapped_t<T>..., void*>
};
}
return Glib::SignalProxy<Ret, T... >(obj.operator->(), &signal_infos[key]);
}
};
auto typefind = Gst::ElementFactory::create_element("typefind"),
signal_callback<void(guint, const Glib::RefPtr<Gst::Caps>&)> signal_wrapper;
signal_wrapper("have-type", typefind).connect(
[&ready, &cv] (guint probability, const Glib::RefPtr<Gst::Caps>& caps) {
std::cout << "have-type: probability=" << probability << std::endl;
Gst::Structure structure = caps->get_structure(0);
const Glib::ustring mime_type = structure.get_name();
std::cout << "have-type: mime_type=" << mime_type << std::endl;
structure.foreach([] (const Glib::QueryQuark& id, const Glib::ValueBase& value) {
const Glib::ustring str_id = id;
gchar* str_value = g_strdup_value_contents(value.gobj());
std::cout << "Structure field: id=" << str_id << ", value=" << str_value << std::endl;
g_free(str_value);
return true;
});
});
Full source of the code can be found on the github [2].As you see, you still have to know the type of the callback, but at least you can use gstreamermm C++ classes.
There is couple of things to do in this code, like getting last parameter from the list in more efficient way than through the tuple, etc.
I don't feel it is stable enough to integrate it with gstreamermm, but probably in the future I'll do that. Also, we could even internally use it in the glibmm to reduce amount of generated code.
Links
[1] https://bugzilla.gnome.org/show_bug.cgi?id=755395
[2] https://gist.github.com/loganek/7833089caff73ff2e8b1f076c8f7910e
