GStreamerLoader.hpp

#pragma once
#include <score/tools/DynamicLibrary.hpp>
 
#include <ossia/detail/dylib_loader.hpp>
 
#include <cstddef>
#include <cstdint>
#include <initializer_list>
#include <optional>
#include <string>
#include <string_view>
#include <vector>
 
// Forward declarations of GStreamer types (all opaque)
extern "C"
{
typedef struct _GstElement GstElement;
typedef struct _GstBus GstBus;
typedef struct _GstMessage GstMessage;
typedef struct _GstCaps GstCaps;
typedef struct _GstStructure GstStructure;
typedef struct _GstSample GstSample;
typedef struct _GstBuffer GstBuffer;
typedef struct _GstPad GstPad;
typedef struct _GstIterator GstIterator;
 
// Enums that are passed by value
typedef enum
{
  GST_STATE_VOID_PENDING = 0,
  GST_STATE_NULL = 1,
  GST_STATE_READY = 2,
  GST_STATE_PAUSED = 3,
  GST_STATE_PLAYING = 4
} GstState;
 
typedef enum
{
  GST_STATE_CHANGE_FAILURE = 0,
  GST_STATE_CHANGE_SUCCESS = 1,
  GST_STATE_CHANGE_ASYNC = 2,
  GST_STATE_CHANGE_NO_PREROLL = 3
} GstStateChangeReturn;
 
typedef enum
{
  GST_MESSAGE_UNKNOWN = 0,
  GST_MESSAGE_EOS = (1 << 0),
  GST_MESSAGE_ERROR = (1 << 1),
  GST_MESSAGE_WARNING = (1 << 2),
  GST_MESSAGE_INFO = (1 << 3),
  GST_MESSAGE_STATE_CHANGED = (1 << 5),
} GstMessageType;
 
typedef enum
{
  GST_MAP_READ = (1 << 0),
  GST_MAP_WRITE = (1 << 1),
} GstMapFlags;
 
typedef enum
{
  GST_FORMAT_UNDEFINED = 0,
  GST_FORMAT_DEFAULT = 1,
  GST_FORMAT_BYTES = 2,
  GST_FORMAT_TIME = 3,
} GstFormat;
 
typedef enum
{
  GST_SEEK_FLAG_NONE = 0,
  GST_SEEK_FLAG_FLUSH = (1 << 0),
  GST_SEEK_FLAG_ACCURATE = (1 << 1),
  GST_SEEK_FLAG_KEY_UNIT = (1 << 2),
} GstSeekFlags;
 
typedef enum
{
  GST_FLOW_OK = 0,
  GST_FLOW_EOS = -3,
  GST_FLOW_ERROR = -5,
} GstFlowReturn;
 
// GstMapInfo must be fully defined since it's stack-allocated
typedef struct _GstMapInfo
{
  void* memory;
  GstMapFlags flags;
  uint8_t* data;
  size_t size;
  size_t maxsize;
  void* user_data[4];
  void* _gst_reserved[4];
} GstMapInfo;
 
// GstVideoMeta, from gst/video/gstvideometa.h. Read-only and only up to
// stride[]: the map/unmap callbacks and the GstVideoAlignment that follow are
// deliberately not declared, so nothing here depends on their layout.
// GST_VIDEO_MAX_PLANES has been 4 since the API was introduced.
#define GST_VIDEO_MAX_PLANES 4
typedef struct _GstVideoMeta
{
  // GstMeta meta;
  int meta_flags;
  const void* meta_info;
 
  struct _GstBuffer* buffer;
  int flags;  // GstVideoFrameFlags
  int format; // GstVideoFormat
  unsigned int id;
  unsigned int width;
  unsigned int height;
  unsigned int n_planes;
  size_t offset[GST_VIDEO_MAX_PLANES];
  int stride[GST_VIDEO_MAX_PLANES];
} GstVideoMeta;
 
// GError for error handling
typedef struct _GError
{
  uint32_t domain;
  int code;
  char* message;
} GError;
 
// gboolean is an int in GLib
typedef int gboolean;
typedef uint64_t GstClockTime;
#define GST_CLOCK_TIME_NONE ((GstClockTime)-1)
#define GST_SECOND ((GstClockTime)1000000000)
 
// GType is gsize, which is pointer-sized: eight bytes on the LP64 platforms
// and on Windows, where unsigned long is four. Getting this wrong shifts every
// field that follows a GType in the structures below.
typedef std::size_t GType;
 
// GLib type constants for gst_caps_new_simple varargs
// GLib/GObject fundamental type IDs
#define G_TYPE_BOOLEAN ((GType)5 << 2)
#define G_TYPE_INT ((GType)6 << 2)
#define G_TYPE_UINT ((GType)7 << 2)
#define G_TYPE_LONG ((GType)8 << 2)
#define G_TYPE_ULONG ((GType)9 << 2)
#define G_TYPE_INT64 ((GType)10 << 2)
#define G_TYPE_UINT64 ((GType)11 << 2)
#define G_TYPE_FLOAT ((GType)14 << 2)
#define G_TYPE_DOUBLE ((GType)15 << 2)
#define G_TYPE_STRING ((GType)16 << 2)
#define G_TYPE_ENUM ((GType)12 << 2)
#define G_TYPE_FLAGS ((GType)13 << 2)
 
// GParamSpec: property metadata
typedef struct _GParamSpec
{
  void* g_type_instance; // GTypeInstance
  const char* name;
  unsigned int flags; // GParamFlags
  GType value_type;
  GType owner_type;
  // Private fields follow — we only access name, flags, value_type
  char* _nick;
  char* _blurb;
  void* qdata;
  unsigned int ref_count;
  unsigned int param_id;
} GParamSpec;
 
// Typed GParamSpec subtypes for range access
typedef struct { GParamSpec parent; int minimum; int maximum; int default_value; } GParamSpecInt;
typedef struct { GParamSpec parent; unsigned int minimum; unsigned int maximum; unsigned int default_value; } GParamSpecUInt;
typedef struct { GParamSpec parent; long minimum; long maximum; long default_value; } GParamSpecLong;
typedef struct { GParamSpec parent; unsigned long minimum; unsigned long maximum; unsigned long default_value; } GParamSpecULong;
typedef struct { GParamSpec parent; int64_t minimum; int64_t maximum; int64_t default_value; } GParamSpecInt64;
typedef struct { GParamSpec parent; uint64_t minimum; uint64_t maximum; uint64_t default_value; } GParamSpecUInt64;
typedef struct { GParamSpec parent; float minimum; float maximum; float default_value; float epsilon; } GParamSpecFloat;
typedef struct { GParamSpec parent; double minimum; double maximum; double default_value; double epsilon; } GParamSpecDouble;
 
// GValue: generic value container (must match ABI — 24 bytes on 64-bit)
typedef struct _GValue
{
  GType g_type;
  union { int v_int; unsigned int v_uint; long v_long; unsigned long v_ulong;
          int64_t v_int64; uint64_t v_uint64; float v_float; double v_double;
          void* v_pointer; } data[2];
} GValue;
 
// GParamFlags
#define G_PARAM_READABLE (1 << 0)
#define G_PARAM_WRITABLE (1 << 1)
#define G_PARAM_READWRITE (G_PARAM_READABLE | G_PARAM_WRITABLE)
 
// Function signatures for dlsym
 
// Core
gboolean gst_init_check(int* argc, char*** argv, GError** error);
GstElement* gst_parse_launch(const char* pipeline_description, GError** error);
GstStateChangeReturn
gst_element_set_state(GstElement* element, GstState state);
GstStateChangeReturn gst_element_get_state(
    GstElement* element, GstState* state, GstState* pending,
    GstClockTime timeout);
GstBus* gst_element_get_bus(GstElement* element);
gboolean gst_element_seek_simple(
    GstElement* element, GstFormat format, GstSeekFlags seek_flags,
    int64_t seek_pos);
GstElement* gst_bin_get_by_name(GstElement* bin, const char* name);
GstPad* gst_element_get_static_pad(GstElement* element, const char* name);
char* gst_element_get_name(GstElement* element);
 
// Pads
GstPad* gst_pad_get_peer(GstPad* pad);
GstCaps* gst_pad_get_allowed_caps(GstPad* pad);
GstElement* gst_pad_get_parent_element(GstPad* pad);
 
// Caps
GstCaps* gst_pad_get_current_caps(GstPad* pad);
GstCaps* gst_caps_new_simple(const char* media_type, const char* fieldname, ...);
GstCaps* gst_caps_from_string(const char* string);
void gst_caps_unref(GstCaps* caps);
GstStructure* gst_caps_get_structure(const GstCaps* caps, unsigned int index);
const char* gst_structure_get_name(const GstStructure* structure);
gboolean gst_structure_get_int(
    const GstStructure* structure, const char* fieldname, int* value);
const char* gst_structure_get_string(
    const GstStructure* structure, const char* fieldname);
 
// Bus/messages
GstMessage* gst_bus_timed_pop_filtered(
    GstBus* bus, GstClockTime timeout, GstMessageType types);
 
// Lifecycle
void gst_object_unref(void* object);
void gst_message_unref(GstMessage* msg);
void gst_mini_object_unref(void* mini_object);
void g_free(void* mem);
void g_error_free(GError* error);
 
// AppSink (input)
GstSample* gst_app_sink_try_pull_sample(void* appsink, GstClockTime timeout);
gboolean gst_app_sink_is_eos(void* appsink);
 
// AppSrc (output)
GstFlowReturn gst_app_src_push_buffer(void* appsrc, GstBuffer* buffer);
GstFlowReturn gst_app_src_end_of_stream(void* appsrc);
void gst_app_src_set_caps(void* appsrc, const GstCaps* caps);
 
// Sample/Buffer
GstBuffer* gst_sample_get_buffer(GstSample* sample);
GstCaps* gst_sample_get_caps(GstSample* sample);
GstBuffer* gst_buffer_new_allocate(void* allocator, size_t size, void* params);
GstBuffer* gst_buffer_new_wrapped_full(
    int flags, void* data, size_t maxsize, size_t offset, size_t size,
    void* user_data, void (*notify)(void*));
gboolean gst_buffer_map(GstBuffer* buffer, GstMapInfo* info, GstMapFlags flags);
void gst_buffer_unmap(GstBuffer* buffer, GstMapInfo* info);
 
// Video meta (from libgstvideo-1.0): the stride and plane offsets an upstream
// element actually negotiated, when they are not the default for the caps.
GstVideoMeta* gst_buffer_get_video_meta(GstBuffer* buffer);
 
// GObject property introspection (from libgobject-2.0)
GParamSpec** g_object_class_list_properties(void* oclass, unsigned int* n_properties);
void* g_type_class_ref(GType type);
void g_type_class_unref(void* g_class);
gboolean g_type_is_a(GType type, GType is_a_type); // Check type inheritance
 
// GObject property access
void g_object_set(void* object, const char* first_property_name, ...);
void g_object_get(void* object, const char* first_property_name, ...);
 
// GValue operations
void g_value_init(GValue* value, GType g_type);
void g_value_unset(GValue* value);
void g_object_get_property(void* object, const char* property_name, GValue* value);
void g_object_set_property(void* object, const char* property_name, const GValue* value);
int g_value_get_int(const GValue* value);
unsigned int g_value_get_uint(const GValue* value);
float g_value_get_float(const GValue* value);
double g_value_get_double(const GValue* value);
gboolean g_value_get_boolean(const GValue* value);
const char* g_value_get_string(const GValue* value);
int64_t g_value_get_int64(const GValue* value);
uint64_t g_value_get_uint64(const GValue* value);
long g_value_get_long(const GValue* value);
unsigned long g_value_get_ulong(const GValue* value);
int g_value_get_enum(const GValue* value);
void g_value_set_int(GValue* value, int v_int);
void g_value_set_uint(GValue* value, unsigned int v_uint);
void g_value_set_float(GValue* value, float v_float);
void g_value_set_double(GValue* value, double v_double);
void g_value_set_boolean(GValue* value, gboolean v_boolean);
void g_value_set_string(GValue* value, const char* v_string);
void g_value_set_int64(GValue* value, int64_t v_int64);
void g_value_set_uint64(GValue* value, uint64_t v_uint64);
void g_value_set_long(GValue* value, long v_long);
void g_value_set_ulong(GValue* value, unsigned long v_ulong);
void g_value_set_enum(GValue* value, int v_enum);
}
 
namespace Gfx::GStreamer
{
 
// Unified dynamic loader for libgstreamer-1.0, libgstapp-1.0, libglib-2.0
struct libgstreamer
{
  // Core functions
  decltype(&::gst_init_check) init_check{};
  decltype(&::gst_parse_launch) parse_launch{};
  decltype(&::gst_element_set_state) element_set_state{};
  decltype(&::gst_element_get_state) element_get_state{};
  decltype(&::gst_element_get_bus) element_get_bus{};
  decltype(&::gst_element_seek_simple) element_seek_simple{};
  decltype(&::gst_bin_get_by_name) bin_get_by_name{};
  decltype(&::gst_element_get_static_pad) element_get_static_pad{};
  decltype(&::gst_element_get_name) element_get_name{};
 
  // Pads
  decltype(&::gst_pad_get_peer) pad_get_peer{};
  decltype(&::gst_pad_get_allowed_caps) pad_get_allowed_caps{};
  decltype(&::gst_pad_get_parent_element) pad_get_parent_element{};
 
  // Caps
  decltype(&::gst_pad_get_current_caps) pad_get_current_caps{};
  decltype(&::gst_caps_new_simple) caps_new_simple{};
  decltype(&::gst_caps_from_string) caps_from_string{};
  decltype(&::gst_caps_unref) caps_unref{};
  decltype(&::gst_caps_get_structure) caps_get_structure{};
  decltype(&::gst_structure_get_name) structure_get_name{};
  decltype(&::gst_structure_get_int) structure_get_int{};
  decltype(&::gst_structure_get_string) structure_get_string{};
 
  // Bus/messages
  decltype(&::gst_bus_timed_pop_filtered) bus_timed_pop_filtered{};
 
  // Lifecycle
  decltype(&::gst_object_unref) object_unref{};
  decltype(&::gst_message_unref) message_unref{};
  decltype(&::gst_mini_object_unref) mini_object_unref{};
  decltype(&::g_free) g_free{};
  decltype(&::g_error_free) g_error_free{};
 
  // AppSink (input)
  decltype(&::gst_app_sink_try_pull_sample) app_sink_try_pull_sample{};
  decltype(&::gst_app_sink_is_eos) app_sink_is_eos{};
 
  // AppSrc (output)
  decltype(&::gst_app_src_push_buffer) app_src_push_buffer{};
  decltype(&::gst_app_src_end_of_stream) app_src_end_of_stream{};
  decltype(&::gst_app_src_set_caps) app_src_set_caps{};
 
  // Sample/Buffer
  decltype(&::gst_sample_get_buffer) sample_get_buffer{};
  decltype(&::gst_sample_get_caps) sample_get_caps{};
  decltype(&::gst_buffer_new_allocate) buffer_new_allocate{};
  decltype(&::gst_buffer_new_wrapped_full) buffer_new_wrapped_full{};
  decltype(&::gst_buffer_map) buffer_map{};
  decltype(&::gst_buffer_unmap) buffer_unmap{};
 
  // Optional: absent when libgstvideo-1.0 is not installed. Every use falls
  // back to the default layout for the caps.
  decltype(&::gst_buffer_get_video_meta) buffer_get_video_meta{};
 
  // GObject property introspection (from libgobject-2.0)
  decltype(&::g_object_class_list_properties) object_class_list_properties{};
  decltype(&::g_type_class_ref) type_class_ref{};
  decltype(&::g_type_class_unref) type_class_unref{};
  decltype(&::g_type_is_a) type_is_a{};
  decltype(&::g_object_set_property) object_set_property{};
  decltype(&::g_object_get_property) object_get_property{};
  decltype(&::g_value_init) value_init{};
  decltype(&::g_value_unset) value_unset{};
  decltype(&::g_value_get_int) value_get_int{};
  decltype(&::g_value_get_uint) value_get_uint{};
  decltype(&::g_value_get_float) value_get_float{};
  decltype(&::g_value_get_double) value_get_double{};
  decltype(&::g_value_get_boolean) value_get_boolean{};
  decltype(&::g_value_get_string) value_get_string{};
  decltype(&::g_value_get_int64) value_get_int64{};
  decltype(&::g_value_get_uint64) value_get_uint64{};
  decltype(&::g_value_get_long) value_get_long{};
  decltype(&::g_value_get_ulong) value_get_ulong{};
  decltype(&::g_value_get_enum) value_get_enum{};
  decltype(&::g_value_set_int) value_set_int{};
  decltype(&::g_value_set_uint) value_set_uint{};
  decltype(&::g_value_set_float) value_set_float{};
  decltype(&::g_value_set_double) value_set_double{};
  decltype(&::g_value_set_boolean) value_set_boolean{};
  decltype(&::g_value_set_string) value_set_string{};
  decltype(&::g_value_set_int64) value_set_int64{};
  decltype(&::g_value_set_uint64) value_set_uint64{};
  decltype(&::g_value_set_long) value_set_long{};
  decltype(&::g_value_set_ulong) value_set_ulong{};
  decltype(&::g_value_set_enum) value_set_enum{};
 
  bool available{};
 
  static const libgstreamer& instance() noexcept
  {
    static const libgstreamer self;
    return self;
  }
 
private:
#if defined(__APPLE__)
  // dlopen searches DYLD_FALLBACK_LIBRARY_PATH, which covers neither the
  // Homebrew nor the MacPorts prefix, so the install roots are named outright.
  static std::optional<ossia::dylib_loader>
  load_apple_library(std::initializer_list<std::string_view> sonames)
  {
    static constexpr std::string_view prefixes[]{
        "", "/opt/homebrew/lib/", "/usr/local/lib/", "/opt/local/lib/",
        "/Library/Frameworks/GStreamer.framework/Versions/1.0/lib/"};
 
    std::vector<std::string> owned;
    owned.reserve(sonames.size() * std::size(prefixes));
    for(auto prefix : prefixes)
      for(auto soname : sonames)
        owned.emplace_back(std::string(prefix) + std::string(soname));
 
    std::vector<std::string_view> names;
    names.reserve(owned.size());
    for(auto& candidate : owned)
      names.emplace_back(candidate);
    return score::try_load_library(std::move(names));
  }
#endif
 
  static std::optional<ossia::dylib_loader> load_core_library()
  {
#if defined(_WIN32)
    return score::try_load_library({"gstreamer-1.0-0.dll", "libgstreamer-1.0-0.dll"});
#elif defined(__APPLE__)
    return load_apple_library({"libgstreamer-1.0.0.dylib", "libgstreamer-1.0.dylib"});
#else
    return score::try_load_library({
        "libgstreamer-1.0.so.0", "libgstreamer-1.0.so"});
#endif
  }
 
  static std::optional<ossia::dylib_loader> load_app_library()
  {
#if defined(_WIN32)
    return score::try_load_library({"gstapp-1.0-0.dll", "libgstapp-1.0-0.dll"});
#elif defined(__APPLE__)
    return load_apple_library({"libgstapp-1.0.0.dylib", "libgstapp-1.0.dylib"});
#else
    return score::try_load_library({
        "libgstapp-1.0.so.0", "libgstapp-1.0.so"});
#endif
  }
 
  static std::optional<ossia::dylib_loader> load_video_library()
  {
#if defined(_WIN32)
    return score::try_load_library({"gstvideo-1.0-0.dll", "libgstvideo-1.0-0.dll"});
#elif defined(__APPLE__)
    return load_apple_library({"libgstvideo-1.0.0.dylib", "libgstvideo-1.0.dylib"});
#else
    return score::try_load_library({
        "libgstvideo-1.0.so.0", "libgstvideo-1.0.so"});
#endif
  }
 
  static std::optional<ossia::dylib_loader> load_gobject_library()
  {
#if defined(_WIN32)
    return score::try_load_library({"gobject-2.0-0.dll", "libgobject-2.0-0.dll"});
#elif defined(__APPLE__)
    return load_apple_library({"libgobject-2.0.0.dylib", "libgobject-2.0.dylib"});
#else
    return score::try_load_library({
        "libgobject-2.0.so.0", "libgobject-2.0.so"});
#endif
  }
 
  static std::optional<ossia::dylib_loader> load_glib_library()
  {
#if defined(_WIN32)
    return score::try_load_library({"glib-2.0-0.dll", "libglib-2.0-0.dll"});
#elif defined(__APPLE__)
    return load_apple_library({"libglib-2.0.0.dylib", "libglib-2.0.dylib"});
#else
    return score::try_load_library({
        "libglib-2.0.so.0", "libglib-2.0.so"});
#endif
  }
 
#define GST_LOAD(lib, name) \
  name = lib->symbol<decltype(&::gst_##name)>("gst_" #name)
 
  libgstreamer()
  {
    m_core = load_core_library();
    m_app = load_app_library();
    m_gobject = load_gobject_library();
    m_glib = load_glib_library();
    m_video = load_video_library();
 
    // Not installed: available stays false and every entry point bails out
    if(!m_core || !m_app || !m_gobject || !m_glib)
      return;
 
    // Core
    GST_LOAD(m_core, init_check);
    GST_LOAD(m_core, parse_launch);
    GST_LOAD(m_core, element_set_state);
    GST_LOAD(m_core, element_get_state);
    GST_LOAD(m_core, element_get_bus);
    GST_LOAD(m_core, element_seek_simple);
    GST_LOAD(m_core, bin_get_by_name);
    GST_LOAD(m_core, element_get_static_pad);
    GST_LOAD(m_core, element_get_name);
 
    // Pads
    GST_LOAD(m_core, pad_get_peer);
    GST_LOAD(m_core, pad_get_allowed_caps);
    GST_LOAD(m_core, pad_get_parent_element);
 
    // Caps
    GST_LOAD(m_core, pad_get_current_caps);
    GST_LOAD(m_core, caps_new_simple);
    GST_LOAD(m_core, caps_from_string);
    GST_LOAD(m_core, caps_unref);
    GST_LOAD(m_core, caps_get_structure);
    GST_LOAD(m_core, structure_get_name);
    GST_LOAD(m_core, structure_get_int);
    GST_LOAD(m_core, structure_get_string);
 
    // Bus
    GST_LOAD(m_core, bus_timed_pop_filtered);
 
    // Lifecycle
    GST_LOAD(m_core, object_unref);
    GST_LOAD(m_core, message_unref);
    GST_LOAD(m_core, mini_object_unref);
    g_free = m_glib->symbol<decltype(&::g_free)>("g_free");
    g_error_free = m_glib->symbol<decltype(&::g_error_free)>("g_error_free");
 
    // AppSink
    GST_LOAD(m_app, app_sink_try_pull_sample);
    GST_LOAD(m_app, app_sink_is_eos);
 
    // AppSrc
    GST_LOAD(m_app, app_src_push_buffer);
    GST_LOAD(m_app, app_src_end_of_stream);
    GST_LOAD(m_app, app_src_set_caps);
 
    // Sample/Buffer
    GST_LOAD(m_core, sample_get_buffer);
    GST_LOAD(m_core, sample_get_caps);
    GST_LOAD(m_core, buffer_new_allocate);
    GST_LOAD(m_core, buffer_new_wrapped_full);
    GST_LOAD(m_core, buffer_map);
    GST_LOAD(m_core, buffer_unmap);
 
    if(m_video)
      GST_LOAD(m_video, buffer_get_video_meta);
 
    // GObject property introspection
#define GOBJ_LOAD(name) \
  name = m_gobject->symbol<decltype(&::g_##name)>("g_" #name)
 
    GOBJ_LOAD(object_class_list_properties);
    GOBJ_LOAD(type_class_ref);
    GOBJ_LOAD(type_class_unref);
    GOBJ_LOAD(type_is_a);
    GOBJ_LOAD(object_set_property);
    GOBJ_LOAD(object_get_property);
    GOBJ_LOAD(value_init);
    GOBJ_LOAD(value_unset);
    GOBJ_LOAD(value_get_int);
    GOBJ_LOAD(value_get_uint);
    GOBJ_LOAD(value_get_float);
    GOBJ_LOAD(value_get_double);
    GOBJ_LOAD(value_get_boolean);
    GOBJ_LOAD(value_get_string);
    GOBJ_LOAD(value_get_int64);
    GOBJ_LOAD(value_get_uint64);
    GOBJ_LOAD(value_get_long);
    GOBJ_LOAD(value_get_ulong);
    GOBJ_LOAD(value_get_enum);
    GOBJ_LOAD(value_set_int);
    GOBJ_LOAD(value_set_uint);
    GOBJ_LOAD(value_set_float);
    GOBJ_LOAD(value_set_double);
    GOBJ_LOAD(value_set_boolean);
    GOBJ_LOAD(value_set_string);
    GOBJ_LOAD(value_set_int64);
    GOBJ_LOAD(value_set_uint64);
    GOBJ_LOAD(value_set_long);
    GOBJ_LOAD(value_set_ulong);
    GOBJ_LOAD(value_set_enum);
 
#undef GOBJ_LOAD
 
    // Verify critical symbols
    available = init_check && parse_launch && element_set_state && element_get_state
                && bin_get_by_name && object_unref && buffer_map && buffer_unmap;
  }
 
#undef GST_LOAD
 
  std::optional<ossia::dylib_loader> m_core;
  std::optional<ossia::dylib_loader> m_app;
  std::optional<ossia::dylib_loader> m_gobject;
  std::optional<ossia::dylib_loader> m_glib;
  std::optional<ossia::dylib_loader> m_video;
};
 
// Call once from any code that needs GStreamer
inline bool gstreamer_init()
{
  static bool initialized = [] {
    auto& g = libgstreamer::instance();
    if(!g.available || !g.init_check)
      return false;
    GError* err = nullptr;
    gboolean ok = g.init_check(nullptr, nullptr, &err);
    if(err)
    {
      if(g.g_error_free)
        g.g_error_free(err);
    }
    return ok != 0;
  }();
  return initialized;
}
 
}