From 2c6d87b1f3141cd60e0ab717dff204e4a44f6825 Mon Sep 17 00:00:00 2001 From: RSWilli Date: Tue, 16 Sep 2025 22:36:07 +0200 Subject: [PATCH] regenerate --- pkg/gst/gst.gen.go | 3733 ++++++++++++++++------- pkg/gst/gst_export.gen.go | 350 +++ pkg/gstallocators/gstallocators.gen.go | 244 +- pkg/gstapp/gstapp.gen.go | 384 ++- pkg/gstapp/gstapp_export.gen.go | 78 + pkg/gstaudio/gstaudio.gen.go | 2007 +++++++++--- pkg/gstaudio/gstaudio_export.gen.go | 350 +++ pkg/gstbase/gstbase.gen.go | 2387 +++++++++++++-- pkg/gstbase/gstbase_export.gen.go | 490 +++ pkg/gstcheck/gstcheck.gen.go | 117 +- pkg/gstcontroller/gstcontroller.gen.go | 408 ++- pkg/gstgl/gstgl.gen.go | 2007 +++++++----- pkg/gstgl/gstgl_export.gen.go | 195 ++ pkg/gstmpegts/gstmpegts.gen.go | 355 ++- pkg/gstnet/gstnet.gen.go | 247 +- pkg/gstpbutils/gstpbutils.gen.go | 553 ++-- pkg/gstpbutils/gstpbutils_export.gen.go | 40 + pkg/gstplay/gstplay.gen.go | 481 ++- pkg/gstplayer/gstplayer.gen.go | 492 ++- pkg/gstrtp/gstrtp.gen.go | 665 +++- pkg/gstrtp/gstrtp_export.gen.go | 103 + pkg/gstrtsp/gstrtsp.gen.go | 270 +- pkg/gstrtsp/gstrtsp_export.gen.go | 45 + pkg/gstsdp/gstsdp.gen.go | 154 +- pkg/gsttag/gsttag.gen.go | 206 +- pkg/gsttag/gsttag_export.gen.go | 28 + pkg/gstvideo/gstvideo.gen.go | 2130 ++++++++++--- pkg/gstvideo/gstvideo_export.gen.go | 365 +++ pkg/gstwebrtc/gstwebrtc.gen.go | 790 +++-- pkg/gstwebrtc/gstwebrtc_export.gen.go | 110 + 30 files changed, 14670 insertions(+), 5114 deletions(-) create mode 100644 pkg/gstapp/gstapp_export.gen.go create mode 100644 pkg/gstrtp/gstrtp_export.gen.go create mode 100644 pkg/gsttag/gsttag_export.gen.go diff --git a/pkg/gst/gst.gen.go b/pkg/gst/gst.gen.go index 373c39a..7d27acf 100644 --- a/pkg/gst/gst.gen.go +++ b/pkg/gst/gst.gen.go @@ -42,6 +42,286 @@ import ( // extern void _gotk4_gst1_TaskFunction(gpointer); // extern void _gotk4_gst1_TypeFindFunction(GstTypeFind*, gpointer); // extern void destroyUserdata(gpointer); +// extern void _gotk4_gst1_ChildProxy_child_added(GstChildProxy*, GObject*, gchar*); +// extern void _gotk4_gst1_ChildProxy_child_removed(GstChildProxy*, GObject*, gchar*); +// extern GObject* _gotk4_gst1_ChildProxy_get_child_by_index(GstChildProxy*, guint); +// extern GObject* _gotk4_gst1_ChildProxy_get_child_by_name(GstChildProxy*, gchar*); +// extern guint _gotk4_gst1_ChildProxy_get_children_count(GstChildProxy*); +// void _gotk4_gst1_ChildProxy_virtual_child_added(void* fnptr, GstChildProxy* carg0, GObject* carg1, gchar* carg2) { +// return ((void (*) (GstChildProxy*, GObject*, gchar*))(fnptr))(carg0, carg1, carg2); +// } +// void _gotk4_gst1_ChildProxy_virtual_child_removed(void* fnptr, GstChildProxy* carg0, GObject* carg1, gchar* carg2) { +// return ((void (*) (GstChildProxy*, GObject*, gchar*))(fnptr))(carg0, carg1, carg2); +// } +// GObject* _gotk4_gst1_ChildProxy_virtual_get_child_by_index(void* fnptr, GstChildProxy* carg0, guint carg1) { +// return ((GObject* (*) (GstChildProxy*, guint))(fnptr))(carg0, carg1); +// } +// GObject* _gotk4_gst1_ChildProxy_virtual_get_child_by_name(void* fnptr, GstChildProxy* carg0, gchar* carg1) { +// return ((GObject* (*) (GstChildProxy*, gchar*))(fnptr))(carg0, carg1); +// } +// guint _gotk4_gst1_ChildProxy_virtual_get_children_count(void* fnptr, GstChildProxy* carg0) { +// return ((guint (*) (GstChildProxy*))(fnptr))(carg0); +// } +// extern gboolean _gotk4_gst1_Preset_delete_preset(GstPreset*, gchar*); +// extern gboolean _gotk4_gst1_Preset_get_meta(GstPreset*, gchar*, gchar*, gchar*); +// extern gchar** _gotk4_gst1_Preset_get_preset_names(GstPreset*); +// extern gchar** _gotk4_gst1_Preset_get_property_names(GstPreset*); +// extern gboolean _gotk4_gst1_Preset_load_preset(GstPreset*, gchar*); +// extern gboolean _gotk4_gst1_Preset_rename_preset(GstPreset*, gchar*, gchar*); +// extern gboolean _gotk4_gst1_Preset_save_preset(GstPreset*, gchar*); +// extern gboolean _gotk4_gst1_Preset_set_meta(GstPreset*, gchar*, gchar*, gchar*); +// gboolean _gotk4_gst1_Preset_virtual_delete_preset(void* fnptr, GstPreset* carg0, gchar* carg1) { +// return ((gboolean (*) (GstPreset*, gchar*))(fnptr))(carg0, carg1); +// } +// gboolean _gotk4_gst1_Preset_virtual_get_meta(void* fnptr, GstPreset* carg0, gchar* carg1, gchar* carg2, gchar** carg3) { +// return ((gboolean (*) (GstPreset*, gchar*, gchar*, gchar**))(fnptr))(carg0, carg1, carg2, carg3); +// } +// gchar** _gotk4_gst1_Preset_virtual_get_preset_names(void* fnptr, GstPreset* carg0) { +// return ((gchar** (*) (GstPreset*))(fnptr))(carg0); +// } +// gchar** _gotk4_gst1_Preset_virtual_get_property_names(void* fnptr, GstPreset* carg0) { +// return ((gchar** (*) (GstPreset*))(fnptr))(carg0); +// } +// gboolean _gotk4_gst1_Preset_virtual_load_preset(void* fnptr, GstPreset* carg0, gchar* carg1) { +// return ((gboolean (*) (GstPreset*, gchar*))(fnptr))(carg0, carg1); +// } +// gboolean _gotk4_gst1_Preset_virtual_rename_preset(void* fnptr, GstPreset* carg0, gchar* carg1, gchar* carg2) { +// return ((gboolean (*) (GstPreset*, gchar*, gchar*))(fnptr))(carg0, carg1, carg2); +// } +// gboolean _gotk4_gst1_Preset_virtual_save_preset(void* fnptr, GstPreset* carg0, gchar* carg1) { +// return ((gboolean (*) (GstPreset*, gchar*))(fnptr))(carg0, carg1); +// } +// gboolean _gotk4_gst1_Preset_virtual_set_meta(void* fnptr, GstPreset* carg0, gchar* carg1, gchar* carg2, gchar* carg3) { +// return ((gboolean (*) (GstPreset*, gchar*, gchar*, gchar*))(fnptr))(carg0, carg1, carg2, carg3); +// } +// extern gchar* _gotk4_gst1_URIHandler_get_uri(GstURIHandler*); +// extern gboolean _gotk4_gst1_URIHandler_set_uri(GstURIHandler*, gchar*, GError*); +// gchar* _gotk4_gst1_URIHandler_virtual_get_uri(void* fnptr, GstURIHandler* carg0) { +// return ((gchar* (*) (GstURIHandler*))(fnptr))(carg0); +// } +// gboolean _gotk4_gst1_URIHandler_virtual_set_uri(void* fnptr, GstURIHandler* carg0, gchar* carg1, GError** _cerr) { +// return ((gboolean (*) (GstURIHandler*, gchar*, GError**))(fnptr))(carg0, carg1, _cerr); +// } +// extern void _gotk4_gst1_Pad_linked(GstPad*, GstPad*); +// extern void _gotk4_gst1_Pad_unlinked(GstPad*, GstPad*); +// void _gotk4_gst1_Pad_virtual_linked(void* fnptr, GstPad* carg0, GstPad* carg1) { +// return ((void (*) (GstPad*, GstPad*))(fnptr))(carg0, carg1); +// } +// void _gotk4_gst1_Pad_virtual_unlinked(void* fnptr, GstPad* carg0, GstPad* carg1) { +// return ((void (*) (GstPad*, GstPad*))(fnptr))(carg0, carg1); +// } +// extern void _gotk4_gst1_PadTemplate_pad_created(GstPadTemplate*, GstPad*); +// void _gotk4_gst1_PadTemplate_virtual_pad_created(void* fnptr, GstPadTemplate* carg0, GstPad* carg1) { +// return ((void (*) (GstPadTemplate*, GstPad*))(fnptr))(carg0, carg1); +// } +// extern void _gotk4_gst1_TaskPool_cleanup(GstTaskPool*); +// extern void _gotk4_gst1_TaskPool_prepare(GstTaskPool*, GError*); +// void _gotk4_gst1_TaskPool_virtual_cleanup(void* fnptr, GstTaskPool* carg0) { +// return ((void (*) (GstTaskPool*))(fnptr))(carg0); +// } +// void _gotk4_gst1_TaskPool_virtual_prepare(void* fnptr, GstTaskPool* carg0, GError** _cerr) { +// return ((void (*) (GstTaskPool*, GError**))(fnptr))(carg0, _cerr); +// } +// extern GstMemory* _gotk4_gst1_Allocator_alloc(GstAllocator*, gsize, GstAllocationParams*); +// extern void _gotk4_gst1_Allocator_free(GstAllocator*, GstMemory*); +// GstMemory* _gotk4_gst1_Allocator_virtual_alloc(void* fnptr, GstAllocator* carg0, gsize carg1, GstAllocationParams* carg2) { +// return ((GstMemory* (*) (GstAllocator*, gsize, GstAllocationParams*))(fnptr))(carg0, carg1, carg2); +// } +// void _gotk4_gst1_Allocator_virtual_free(void* fnptr, GstAllocator* carg0, GstMemory* carg1) { +// return ((void (*) (GstAllocator*, GstMemory*))(fnptr))(carg0, carg1); +// } +// extern GstFlowReturn _gotk4_gst1_BufferPool_acquire_buffer(GstBufferPool*, GstBuffer*, GstBufferPoolAcquireParams*); +// extern GstFlowReturn _gotk4_gst1_BufferPool_alloc_buffer(GstBufferPool*, GstBuffer*, GstBufferPoolAcquireParams*); +// extern void _gotk4_gst1_BufferPool_flush_start(GstBufferPool*); +// extern void _gotk4_gst1_BufferPool_flush_stop(GstBufferPool*); +// extern void _gotk4_gst1_BufferPool_free_buffer(GstBufferPool*, GstBuffer*); +// extern const gchar** _gotk4_gst1_BufferPool_get_options(GstBufferPool*); +// extern void _gotk4_gst1_BufferPool_release_buffer(GstBufferPool*, GstBuffer*); +// extern void _gotk4_gst1_BufferPool_reset_buffer(GstBufferPool*, GstBuffer*); +// extern gboolean _gotk4_gst1_BufferPool_set_config(GstBufferPool*, GstStructure*); +// extern gboolean _gotk4_gst1_BufferPool_start(GstBufferPool*); +// extern gboolean _gotk4_gst1_BufferPool_stop(GstBufferPool*); +// GstFlowReturn _gotk4_gst1_BufferPool_virtual_acquire_buffer(void* fnptr, GstBufferPool* carg0, GstBuffer** carg1, GstBufferPoolAcquireParams* carg2) { +// return ((GstFlowReturn (*) (GstBufferPool*, GstBuffer**, GstBufferPoolAcquireParams*))(fnptr))(carg0, carg1, carg2); +// } +// GstFlowReturn _gotk4_gst1_BufferPool_virtual_alloc_buffer(void* fnptr, GstBufferPool* carg0, GstBuffer** carg1, GstBufferPoolAcquireParams* carg2) { +// return ((GstFlowReturn (*) (GstBufferPool*, GstBuffer**, GstBufferPoolAcquireParams*))(fnptr))(carg0, carg1, carg2); +// } +// void _gotk4_gst1_BufferPool_virtual_flush_start(void* fnptr, GstBufferPool* carg0) { +// return ((void (*) (GstBufferPool*))(fnptr))(carg0); +// } +// void _gotk4_gst1_BufferPool_virtual_flush_stop(void* fnptr, GstBufferPool* carg0) { +// return ((void (*) (GstBufferPool*))(fnptr))(carg0); +// } +// void _gotk4_gst1_BufferPool_virtual_free_buffer(void* fnptr, GstBufferPool* carg0, GstBuffer* carg1) { +// return ((void (*) (GstBufferPool*, GstBuffer*))(fnptr))(carg0, carg1); +// } +// const gchar** _gotk4_gst1_BufferPool_virtual_get_options(void* fnptr, GstBufferPool* carg0) { +// return ((const gchar** (*) (GstBufferPool*))(fnptr))(carg0); +// } +// void _gotk4_gst1_BufferPool_virtual_release_buffer(void* fnptr, GstBufferPool* carg0, GstBuffer* carg1) { +// return ((void (*) (GstBufferPool*, GstBuffer*))(fnptr))(carg0, carg1); +// } +// void _gotk4_gst1_BufferPool_virtual_reset_buffer(void* fnptr, GstBufferPool* carg0, GstBuffer* carg1) { +// return ((void (*) (GstBufferPool*, GstBuffer*))(fnptr))(carg0, carg1); +// } +// gboolean _gotk4_gst1_BufferPool_virtual_set_config(void* fnptr, GstBufferPool* carg0, GstStructure* carg1) { +// return ((gboolean (*) (GstBufferPool*, GstStructure*))(fnptr))(carg0, carg1); +// } +// gboolean _gotk4_gst1_BufferPool_virtual_start(void* fnptr, GstBufferPool* carg0) { +// return ((gboolean (*) (GstBufferPool*))(fnptr))(carg0); +// } +// gboolean _gotk4_gst1_BufferPool_virtual_stop(void* fnptr, GstBufferPool* carg0) { +// return ((gboolean (*) (GstBufferPool*))(fnptr))(carg0); +// } +// extern void _gotk4_gst1_Bus_message(GstBus*, GstMessage*); +// extern void _gotk4_gst1_Bus_sync_message(GstBus*, GstMessage*); +// void _gotk4_gst1_Bus_virtual_message(void* fnptr, GstBus* carg0, GstMessage* carg1) { +// return ((void (*) (GstBus*, GstMessage*))(fnptr))(carg0, carg1); +// } +// void _gotk4_gst1_Bus_virtual_sync_message(void* fnptr, GstBus* carg0, GstMessage* carg1) { +// return ((void (*) (GstBus*, GstMessage*))(fnptr))(carg0, carg1); +// } +// extern GstClockTime _gotk4_gst1_Clock_change_resolution(GstClock*, GstClockTime, GstClockTime); +// extern GstClockTime _gotk4_gst1_Clock_get_internal_time(GstClock*); +// extern GstClockTime _gotk4_gst1_Clock_get_resolution(GstClock*); +// extern void _gotk4_gst1_Clock_unschedule(GstClock*, GstClockEntry*); +// extern GstClockReturn _gotk4_gst1_Clock_wait(GstClock*, GstClockEntry*, GstClockTimeDiff); +// extern GstClockReturn _gotk4_gst1_Clock_wait_async(GstClock*, GstClockEntry*); +// GstClockTime _gotk4_gst1_Clock_virtual_change_resolution(void* fnptr, GstClock* carg0, GstClockTime carg1, GstClockTime carg2) { +// return ((GstClockTime (*) (GstClock*, GstClockTime, GstClockTime))(fnptr))(carg0, carg1, carg2); +// } +// GstClockTime _gotk4_gst1_Clock_virtual_get_internal_time(void* fnptr, GstClock* carg0) { +// return ((GstClockTime (*) (GstClock*))(fnptr))(carg0); +// } +// GstClockTime _gotk4_gst1_Clock_virtual_get_resolution(void* fnptr, GstClock* carg0) { +// return ((GstClockTime (*) (GstClock*))(fnptr))(carg0); +// } +// void _gotk4_gst1_Clock_virtual_unschedule(void* fnptr, GstClock* carg0, GstClockEntry* carg1) { +// return ((void (*) (GstClock*, GstClockEntry*))(fnptr))(carg0, carg1); +// } +// GstClockReturn _gotk4_gst1_Clock_virtual_wait(void* fnptr, GstClock* carg0, GstClockEntry* carg1, GstClockTimeDiff* carg2) { +// return ((GstClockReturn (*) (GstClock*, GstClockEntry*, GstClockTimeDiff*))(fnptr))(carg0, carg1, carg2); +// } +// GstClockReturn _gotk4_gst1_Clock_virtual_wait_async(void* fnptr, GstClock* carg0, GstClockEntry* carg1) { +// return ((GstClockReturn (*) (GstClock*, GstClockEntry*))(fnptr))(carg0, carg1); +// } +// extern gboolean _gotk4_gst1_ControlBinding_sync_values(GstControlBinding*, GstObject*, GstClockTime, GstClockTime); +// gboolean _gotk4_gst1_ControlBinding_virtual_sync_values(void* fnptr, GstControlBinding* carg0, GstObject* carg1, GstClockTime carg2, GstClockTime carg3) { +// return ((gboolean (*) (GstControlBinding*, GstObject*, GstClockTime, GstClockTime))(fnptr))(carg0, carg1, carg2, carg3); +// } +// extern GstElement* _gotk4_gst1_Device_create_element(GstDevice*, gchar*); +// extern gboolean _gotk4_gst1_Device_reconfigure_element(GstDevice*, GstElement*); +// GstElement* _gotk4_gst1_Device_virtual_create_element(void* fnptr, GstDevice* carg0, gchar* carg1) { +// return ((GstElement* (*) (GstDevice*, gchar*))(fnptr))(carg0, carg1); +// } +// gboolean _gotk4_gst1_Device_virtual_reconfigure_element(void* fnptr, GstDevice* carg0, GstElement* carg1) { +// return ((gboolean (*) (GstDevice*, GstElement*))(fnptr))(carg0, carg1); +// } +// extern gboolean _gotk4_gst1_DeviceProvider_start(GstDeviceProvider*); +// extern void _gotk4_gst1_DeviceProvider_stop(GstDeviceProvider*); +// gboolean _gotk4_gst1_DeviceProvider_virtual_start(void* fnptr, GstDeviceProvider* carg0) { +// return ((gboolean (*) (GstDeviceProvider*))(fnptr))(carg0); +// } +// void _gotk4_gst1_DeviceProvider_virtual_stop(void* fnptr, GstDeviceProvider* carg0) { +// return ((void (*) (GstDeviceProvider*))(fnptr))(carg0); +// } +// extern GstStateChangeReturn _gotk4_gst1_Element_change_state(GstElement*, GstStateChange); +// extern GstStateChangeReturn _gotk4_gst1_Element_get_state(GstElement*, GstState, GstState, GstClockTime); +// extern void _gotk4_gst1_Element_no_more_pads(GstElement*); +// extern void _gotk4_gst1_Element_pad_added(GstElement*, GstPad*); +// extern void _gotk4_gst1_Element_pad_removed(GstElement*, GstPad*); +// extern gboolean _gotk4_gst1_Element_post_message(GstElement*, GstMessage*); +// extern GstClock* _gotk4_gst1_Element_provide_clock(GstElement*); +// extern gboolean _gotk4_gst1_Element_query(GstElement*, GstQuery*); +// extern void _gotk4_gst1_Element_release_pad(GstElement*, GstPad*); +// extern GstPad* _gotk4_gst1_Element_request_new_pad(GstElement*, GstPadTemplate*, gchar*, GstCaps*); +// extern gboolean _gotk4_gst1_Element_send_event(GstElement*, GstEvent*); +// extern void _gotk4_gst1_Element_set_bus(GstElement*, GstBus*); +// extern gboolean _gotk4_gst1_Element_set_clock(GstElement*, GstClock*); +// extern void _gotk4_gst1_Element_set_context(GstElement*, GstContext*); +// extern GstStateChangeReturn _gotk4_gst1_Element_set_state(GstElement*, GstState); +// extern void _gotk4_gst1_Element_state_changed(GstElement*, GstState, GstState, GstState); +// GstStateChangeReturn _gotk4_gst1_Element_virtual_change_state(void* fnptr, GstElement* carg0, GstStateChange carg1) { +// return ((GstStateChangeReturn (*) (GstElement*, GstStateChange))(fnptr))(carg0, carg1); +// } +// GstStateChangeReturn _gotk4_gst1_Element_virtual_get_state(void* fnptr, GstElement* carg0, GstState* carg1, GstState* carg2, GstClockTime carg3) { +// return ((GstStateChangeReturn (*) (GstElement*, GstState*, GstState*, GstClockTime))(fnptr))(carg0, carg1, carg2, carg3); +// } +// void _gotk4_gst1_Element_virtual_no_more_pads(void* fnptr, GstElement* carg0) { +// return ((void (*) (GstElement*))(fnptr))(carg0); +// } +// void _gotk4_gst1_Element_virtual_pad_added(void* fnptr, GstElement* carg0, GstPad* carg1) { +// return ((void (*) (GstElement*, GstPad*))(fnptr))(carg0, carg1); +// } +// void _gotk4_gst1_Element_virtual_pad_removed(void* fnptr, GstElement* carg0, GstPad* carg1) { +// return ((void (*) (GstElement*, GstPad*))(fnptr))(carg0, carg1); +// } +// gboolean _gotk4_gst1_Element_virtual_post_message(void* fnptr, GstElement* carg0, GstMessage* carg1) { +// return ((gboolean (*) (GstElement*, GstMessage*))(fnptr))(carg0, carg1); +// } +// GstClock* _gotk4_gst1_Element_virtual_provide_clock(void* fnptr, GstElement* carg0) { +// return ((GstClock* (*) (GstElement*))(fnptr))(carg0); +// } +// gboolean _gotk4_gst1_Element_virtual_query(void* fnptr, GstElement* carg0, GstQuery* carg1) { +// return ((gboolean (*) (GstElement*, GstQuery*))(fnptr))(carg0, carg1); +// } +// void _gotk4_gst1_Element_virtual_release_pad(void* fnptr, GstElement* carg0, GstPad* carg1) { +// return ((void (*) (GstElement*, GstPad*))(fnptr))(carg0, carg1); +// } +// GstPad* _gotk4_gst1_Element_virtual_request_new_pad(void* fnptr, GstElement* carg0, GstPadTemplate* carg1, gchar* carg2, GstCaps* carg3) { +// return ((GstPad* (*) (GstElement*, GstPadTemplate*, gchar*, GstCaps*))(fnptr))(carg0, carg1, carg2, carg3); +// } +// gboolean _gotk4_gst1_Element_virtual_send_event(void* fnptr, GstElement* carg0, GstEvent* carg1) { +// return ((gboolean (*) (GstElement*, GstEvent*))(fnptr))(carg0, carg1); +// } +// void _gotk4_gst1_Element_virtual_set_bus(void* fnptr, GstElement* carg0, GstBus* carg1) { +// return ((void (*) (GstElement*, GstBus*))(fnptr))(carg0, carg1); +// } +// gboolean _gotk4_gst1_Element_virtual_set_clock(void* fnptr, GstElement* carg0, GstClock* carg1) { +// return ((gboolean (*) (GstElement*, GstClock*))(fnptr))(carg0, carg1); +// } +// void _gotk4_gst1_Element_virtual_set_context(void* fnptr, GstElement* carg0, GstContext* carg1) { +// return ((void (*) (GstElement*, GstContext*))(fnptr))(carg0, carg1); +// } +// GstStateChangeReturn _gotk4_gst1_Element_virtual_set_state(void* fnptr, GstElement* carg0, GstState carg1) { +// return ((GstStateChangeReturn (*) (GstElement*, GstState))(fnptr))(carg0, carg1); +// } +// void _gotk4_gst1_Element_virtual_state_changed(void* fnptr, GstElement* carg0, GstState carg1, GstState carg2, GstState carg3) { +// return ((void (*) (GstElement*, GstState, GstState, GstState))(fnptr))(carg0, carg1, carg2, carg3); +// } +// extern gboolean _gotk4_gst1_Bin_add_element(GstBin*, GstElement*); +// extern void _gotk4_gst1_Bin_deep_element_added(GstBin*, GstBin*, GstElement*); +// extern void _gotk4_gst1_Bin_deep_element_removed(GstBin*, GstBin*, GstElement*); +// extern gboolean _gotk4_gst1_Bin_do_latency(GstBin*); +// extern void _gotk4_gst1_Bin_element_added(GstBin*, GstElement*); +// extern void _gotk4_gst1_Bin_element_removed(GstBin*, GstElement*); +// extern void _gotk4_gst1_Bin_handle_message(GstBin*, GstMessage*); +// extern gboolean _gotk4_gst1_Bin_remove_element(GstBin*, GstElement*); +// gboolean _gotk4_gst1_Bin_virtual_add_element(void* fnptr, GstBin* carg0, GstElement* carg1) { +// return ((gboolean (*) (GstBin*, GstElement*))(fnptr))(carg0, carg1); +// } +// void _gotk4_gst1_Bin_virtual_deep_element_added(void* fnptr, GstBin* carg0, GstBin* carg1, GstElement* carg2) { +// return ((void (*) (GstBin*, GstBin*, GstElement*))(fnptr))(carg0, carg1, carg2); +// } +// void _gotk4_gst1_Bin_virtual_deep_element_removed(void* fnptr, GstBin* carg0, GstBin* carg1, GstElement* carg2) { +// return ((void (*) (GstBin*, GstBin*, GstElement*))(fnptr))(carg0, carg1, carg2); +// } +// gboolean _gotk4_gst1_Bin_virtual_do_latency(void* fnptr, GstBin* carg0) { +// return ((gboolean (*) (GstBin*))(fnptr))(carg0); +// } +// void _gotk4_gst1_Bin_virtual_element_added(void* fnptr, GstBin* carg0, GstElement* carg1) { +// return ((void (*) (GstBin*, GstElement*))(fnptr))(carg0, carg1); +// } +// void _gotk4_gst1_Bin_virtual_element_removed(void* fnptr, GstBin* carg0, GstElement* carg1) { +// return ((void (*) (GstBin*, GstElement*))(fnptr))(carg0, carg1); +// } +// void _gotk4_gst1_Bin_virtual_handle_message(void* fnptr, GstBin* carg0, GstMessage* carg1) { +// return ((void (*) (GstBin*, GstMessage*))(fnptr))(carg0, carg1); +// } +// gboolean _gotk4_gst1_Bin_virtual_remove_element(void* fnptr, GstBin* carg0, GstElement* carg1) { +// return ((gboolean (*) (GstBin*, GstElement*))(fnptr))(carg0, carg1); +// } import "C" // GType values. @@ -887,6 +1167,7 @@ func (e CoreError) String() string { } // CoreErrorQuark wraps gst_core_error_quark +// // The function returns the following values: // // - goret glib.Quark @@ -1649,6 +1930,7 @@ func FormatGetName(format Format) string { } // FormatIterateDefinitions wraps gst_format_iterate_definitions +// // The function returns the following values: // // - goret *Iterator @@ -1877,6 +2159,7 @@ func (e LibraryError) String() string { } // LibraryErrorQuark wraps gst_library_error_quark +// // The function returns the following values: // // - goret glib.Quark @@ -2237,6 +2520,7 @@ func (e ParseError) String() string { } // ParseErrorQuark wraps gst_parse_error_quark +// // The function returns the following values: // // - goret glib.Quark @@ -2295,6 +2579,7 @@ func (e PluginError) String() string { } // PluginErrorQuark wraps gst_plugin_error_quark +// // The function returns the following values: // // - goret glib.Quark @@ -2835,6 +3120,7 @@ func (e ResourceError) String() string { } // ResourceErrorQuark wraps gst_resource_error_quark +// // The function returns the following values: // // - goret glib.Quark @@ -3296,6 +3582,7 @@ func (e StreamError) String() string { } // StreamErrorQuark wraps gst_stream_error_quark +// // The function returns the following values: // // - goret glib.Quark @@ -3942,6 +4229,7 @@ func (e URIError) String() string { } // URIErrorQuark wraps gst_uri_error_quark +// // The function returns the following values: // // - goret glib.Quark @@ -7725,6 +8013,7 @@ func DebugConstructWinColor(colorinfo uint) int { } // DebugGetAllCategories wraps gst_debug_get_all_categories +// // The function returns the following values: // // - goret []*DebugCategory @@ -7752,6 +8041,7 @@ func DebugGetAllCategories() []*DebugCategory { } // DebugGetColorMode wraps gst_debug_get_color_mode +// // The function returns the following values: // // - goret DebugColorMode @@ -7770,6 +8060,7 @@ func DebugGetColorMode() DebugColorMode { } // DebugGetDefaultThreshold wraps gst_debug_get_default_threshold +// // The function returns the following values: // // - goret DebugLevel @@ -7817,6 +8108,7 @@ func DebugGetStackTrace(flags StackTraceFlags) string { } // DebugIsActive wraps gst_debug_is_active +// // The function returns the following values: // // - goret bool @@ -7837,6 +8129,7 @@ func DebugIsActive() bool { } // DebugIsColored wraps gst_debug_is_colored +// // The function returns the following values: // // - goret bool @@ -8029,6 +8322,7 @@ func DebugRemoveRingBufferLogger() { } // DebugRingBufferLoggerGetLogs wraps gst_debug_ring_buffer_logger_get_logs +// // The function returns the following values: // // - goret []string @@ -8430,6 +8724,7 @@ func FormatsContains(formats []Format, format Format) bool { } // GetMainExecutablePath wraps gst_get_main_executable_path +// // The function returns the following values: // // - goret string (nullable) @@ -8487,6 +8782,7 @@ func IsCapsFeatures(obj unsafe.Pointer) bool { } // IsInitialized wraps gst_is_initialized +// // The function returns the following values: // // - goret bool @@ -8508,6 +8804,7 @@ func IsInitialized() bool { } // ParentBufferMetaApiGetType wraps gst_parent_buffer_meta_api_get_type +// // The function returns the following values: // // - goret gobject.Type @@ -8758,6 +9055,7 @@ func ProtectionFilterSystemsByAvailableDecryptors(systemIdentifiers []string) [] } // ProtectionMetaApiGetType wraps gst_protection_meta_api_get_type +// // The function returns the following values: // // - goret gobject.Type @@ -8809,6 +9107,7 @@ func ProtectionSelectSystem(systemIdentifiers []string) string { } // ReferenceTimestampMetaApiGetType wraps gst_reference_timestamp_meta_api_get_type +// // The function returns the following values: // // - goret gobject.Type @@ -8825,6 +9124,7 @@ func ReferenceTimestampMetaApiGetType() gobject.Type { } // SegtrapIsEnabled wraps gst_segtrap_is_enabled +// // The function returns the following values: // // - goret bool @@ -9106,6 +9406,7 @@ func TagMergeUseFirst(src *gobject.Value) gobject.Value { } // TracingGetActiveTracers wraps gst_tracing_get_active_tracers +// // The function returns the following values: // // - goret []Tracer @@ -9195,6 +9496,7 @@ func TypeMarkAsPluginApi(typ gobject.Type, flags PluginAPIFlags) { } // UpdateRegistry wraps gst_update_registry +// // The function returns the following values: // // - goret bool @@ -9554,6 +9856,7 @@ func UtilGdoubleToGuint64(value float64) uint64 { } // UtilGetTimestamp wraps gst_util_get_timestamp +// // The function returns the following values: // // - goret ClockTime @@ -9637,6 +9940,7 @@ func UtilGreatestCommonDivisorInt64(a int64, b int64) int64 { } // UtilGroupIDNext wraps gst_util_group_id_next +// // The function returns the following values: // // - goret uint @@ -9718,6 +10022,7 @@ func UtilSeqnumCompare(s1 uint32, s2 uint32) int32 { } // UtilSeqnumNext wraps gst_util_seqnum_next +// // The function returns the following values: // // - goret uint32 @@ -11447,6 +11752,7 @@ func ValueUnion(value1 *gobject.Value, value2 *gobject.Value) (gobject.Value, bo } // Version wraps gst_version +// // The function returns the following values: // // - major uint: pointer to a guint to store the major version number @@ -11477,6 +11783,7 @@ func Version() (uint, uint, uint, uint) { } // VersionString wraps gst_version_string +// // The function returns the following values: // // - goret string @@ -11589,6 +11896,7 @@ type ChildProxy interface { // element names only and should not contain any property names. GetChildByNameRecurse(string) gobject.Object // GetChildrenCount wraps gst_child_proxy_get_children_count + // // The function returns the following values: // // - goret uint @@ -11801,6 +12109,7 @@ func (childProxy *ChildProxyInstance) GetChildByNameRecurse(name string) gobject } // GetChildrenCount wraps gst_child_proxy_get_children_count +// // The function returns the following values: // // - goret uint @@ -11828,12 +12137,80 @@ func (parent *ChildProxyInstance) GetChildrenCount() uint { func (o *ChildProxyInstance) ConnectChildAdded(fn func(ChildProxy, gobject.Object, string)) gobject.SignalHandle { return o.Instance.Connect("child-added", fn) } + // ConnectChildRemoved connects the provided callback to the "child-removed" signal // // Will be emitted after the @object was removed from the @child_proxy. func (o *ChildProxyInstance) ConnectChildRemoved(fn func(ChildProxy, gobject.Object, string)) gobject.SignalHandle { return o.Instance.Connect("child-removed", fn) } + +// ChildProxyOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type ChildProxyOverrides[Instance ChildProxy] struct { + // ChildAdded allows you to override the implementation of the virtual method child_added. + // The function takes the following parameters: + // + // - child gobject.Object: the newly added child + // - name string: the name of the new child + ChildAdded func(Instance, gobject.Object, string) + // ChildRemoved allows you to override the implementation of the virtual method child_removed. + // The function takes the following parameters: + // + // - child gobject.Object: the removed child + // - name string: the name of the old child + ChildRemoved func(Instance, gobject.Object, string) + // GetChildByIndex allows you to override the implementation of the virtual method get_child_by_index. + // The function takes the following parameters: + // + // - index uint: the child's position in the child list + // + // The function returns the following values: + // + // - goret gobject.Object (nullable) + GetChildByIndex func(Instance, uint) gobject.Object + // GetChildByName allows you to override the implementation of the virtual method get_child_by_name. + // The function takes the following parameters: + // + // - name string: the child's name + // + // The function returns the following values: + // + // - goret gobject.Object (nullable) + GetChildByName func(Instance, string) gobject.Object + // GetChildrenCount allows you to override the implementation of the virtual method get_children_count. + // The function returns the following values: + // + // - goret uint + GetChildrenCount func(Instance) uint +} + +// UnsafeApplyChildProxyOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyChildProxyOverrides[Instance ChildProxy](gclass unsafe.Pointer, overrides ChildProxyOverrides[Instance]) { + pclass := (*C.GstChildProxyInterface)(gclass) + + if overrides.ChildAdded != nil { + pclass.child_added = (*[0]byte)(C._gotk4_gst1_ChildProxy_child_added) + } + + if overrides.ChildRemoved != nil { + pclass.child_removed = (*[0]byte)(C._gotk4_gst1_ChildProxy_child_removed) + } + + if overrides.GetChildByIndex != nil { + pclass.get_child_by_index = (*[0]byte)(C._gotk4_gst1_ChildProxy_get_child_by_index) + } + + if overrides.GetChildByName != nil { + pclass.get_child_by_name = (*[0]byte)(C._gotk4_gst1_ChildProxy_get_child_by_name) + } + + if overrides.GetChildrenCount != nil { + pclass.get_children_count = (*[0]byte)(C._gotk4_gst1_ChildProxy_get_children_count) + } +} + // PresetInstance is the instance type used by all types implementing GstPreset. It is used internally by the bindings. Users should use the interface [Preset] instead. type PresetInstance struct { _ [0]func() // equal guard @@ -11898,6 +12275,7 @@ type Preset interface { // something like e.g. "comment". Returned values need to be released when done. GetMeta(string, string) (string, bool) // GetPresetNames wraps gst_preset_get_preset_names + // // The function returns the following values: // // - goret []string @@ -11905,6 +12283,7 @@ type Preset interface { // Get a copy of preset names as a %NULL terminated string array. GetPresetNames() []string // GetPropertyNames wraps gst_preset_get_property_names + // // The function returns the following values: // // - goret []string @@ -11912,6 +12291,7 @@ type Preset interface { // Get a the names of the GObject properties that can be used for presets. GetPropertyNames() []string // IsEditable wraps gst_preset_is_editable + // // The function returns the following values: // // - goret bool @@ -12014,6 +12394,7 @@ func UnsafePresetToGlibFull(c Preset) unsafe.Pointer { } // PresetGetAppDir wraps gst_preset_get_app_dir +// // The function returns the following values: // // - goret string (nullable) @@ -12144,6 +12525,7 @@ func (preset *PresetInstance) GetMeta(name string, tag string) (string, bool) { } // GetPresetNames wraps gst_preset_get_preset_names +// // The function returns the following values: // // - goret []string @@ -12168,6 +12550,7 @@ func (preset *PresetInstance) GetPresetNames() []string { } // GetPropertyNames wraps gst_preset_get_property_names +// // The function returns the following values: // // - goret []string @@ -12192,6 +12575,7 @@ func (preset *PresetInstance) GetPropertyNames() []string { } // IsEditable wraps gst_preset_is_editable +// // The function returns the following values: // // - goret bool @@ -12368,6 +12752,118 @@ func (preset *PresetInstance) SetMeta(name string, tag string, value string) boo return goret } +// PresetOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type PresetOverrides[Instance Preset] struct { + // DeletePreset allows you to override the implementation of the virtual method delete_preset. + // The function takes the following parameters: + // + // - name string: preset name to remove + // + // The function returns the following values: + // + // - goret bool + DeletePreset func(Instance, string) bool + // GetMeta allows you to override the implementation of the virtual method get_meta. + // The function takes the following parameters: + // + // - name string: preset name + // - tag string: meta data item name + // + // The function returns the following values: + // + // - value string: value + // - goret bool + GetMeta func(Instance, string, string) (string, bool) + // GetPresetNames allows you to override the implementation of the virtual method get_preset_names. + // The function returns the following values: + // + // - goret []string + GetPresetNames func(Instance) []string + // GetPropertyNames allows you to override the implementation of the virtual method get_property_names. + // The function returns the following values: + // + // - goret []string + GetPropertyNames func(Instance) []string + // LoadPreset allows you to override the implementation of the virtual method load_preset. + // The function takes the following parameters: + // + // - name string: preset name to load + // + // The function returns the following values: + // + // - goret bool + LoadPreset func(Instance, string) bool + // RenamePreset allows you to override the implementation of the virtual method rename_preset. + // The function takes the following parameters: + // + // - oldName string: current preset name + // - newName string: new preset name + // + // The function returns the following values: + // + // - goret bool + RenamePreset func(Instance, string, string) bool + // SavePreset allows you to override the implementation of the virtual method save_preset. + // The function takes the following parameters: + // + // - name string: preset name to save + // + // The function returns the following values: + // + // - goret bool + SavePreset func(Instance, string) bool + // SetMeta allows you to override the implementation of the virtual method set_meta. + // The function takes the following parameters: + // + // - name string: preset name + // - tag string: meta data item name + // - value string (nullable): new value + // + // The function returns the following values: + // + // - goret bool + SetMeta func(Instance, string, string, string) bool +} + +// UnsafeApplyPresetOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyPresetOverrides[Instance Preset](gclass unsafe.Pointer, overrides PresetOverrides[Instance]) { + pclass := (*C.GstPresetInterface)(gclass) + + if overrides.DeletePreset != nil { + pclass.delete_preset = (*[0]byte)(C._gotk4_gst1_Preset_delete_preset) + } + + if overrides.GetMeta != nil { + pclass.get_meta = (*[0]byte)(C._gotk4_gst1_Preset_get_meta) + } + + if overrides.GetPresetNames != nil { + pclass.get_preset_names = (*[0]byte)(C._gotk4_gst1_Preset_get_preset_names) + } + + if overrides.GetPropertyNames != nil { + pclass.get_property_names = (*[0]byte)(C._gotk4_gst1_Preset_get_property_names) + } + + if overrides.LoadPreset != nil { + pclass.load_preset = (*[0]byte)(C._gotk4_gst1_Preset_load_preset) + } + + if overrides.RenamePreset != nil { + pclass.rename_preset = (*[0]byte)(C._gotk4_gst1_Preset_rename_preset) + } + + if overrides.SavePreset != nil { + pclass.save_preset = (*[0]byte)(C._gotk4_gst1_Preset_save_preset) + } + + if overrides.SetMeta != nil { + pclass.set_meta = (*[0]byte)(C._gotk4_gst1_Preset_set_meta) + } +} + // URIHandlerInstance is the instance type used by all types implementing GstURIHandler. It is used internally by the bindings. Users should use the interface [URIHandler] instead. type URIHandlerInstance struct { _ [0]func() // equal guard @@ -12390,6 +12886,7 @@ type URIHandler interface { upcastToGstURIHandler() *URIHandlerInstance // GetProtocols wraps gst_uri_handler_get_protocols + // // The function returns the following values: // // - goret []string (nullable) @@ -12398,6 +12895,7 @@ type URIHandler interface { // modified. GetProtocols() []string // GetURI wraps gst_uri_handler_get_uri + // // The function returns the following values: // // - goret string (nullable) @@ -12405,6 +12903,7 @@ type URIHandler interface { // Gets the currently handled URI. GetURI() string // GetURIType wraps gst_uri_handler_get_uri_type + // // The function returns the following values: // // - goret URIType @@ -12465,6 +12964,7 @@ func UnsafeURIHandlerToGlibFull(c URIHandler) unsafe.Pointer { } // GetProtocols wraps gst_uri_handler_get_protocols +// // The function returns the following values: // // - goret []string (nullable) @@ -12490,6 +12990,7 @@ func (handler *URIHandlerInstance) GetProtocols() []string { } // GetURI wraps gst_uri_handler_get_uri +// // The function returns the following values: // // - goret string (nullable) @@ -12515,6 +13016,7 @@ func (handler *URIHandlerInstance) GetURI() string { } // GetURIType wraps gst_uri_handler_get_uri_type +// // The function returns the following values: // // - goret URIType @@ -12575,6 +13077,40 @@ func (handler *URIHandlerInstance) SetURI(uri string) (bool, error) { return goret, _goerr } +// URIHandlerOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type URIHandlerOverrides[Instance URIHandler] struct { + // GetURI allows you to override the implementation of the virtual method get_uri. + // The function returns the following values: + // + // - goret string (nullable) + GetURI func(Instance) string + // SetURI allows you to override the implementation of the virtual method set_uri. + // The function takes the following parameters: + // + // - uri string: URI to set + // + // The function returns the following values: + // + // - goret bool + // - _goerr error (nullable): an error + SetURI func(Instance, string) (bool, error) +} + +// UnsafeApplyURIHandlerOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyURIHandlerOverrides[Instance URIHandler](gclass unsafe.Pointer, overrides URIHandlerOverrides[Instance]) { + pclass := (*C.GstURIHandlerInterface)(gclass) + + if overrides.GetURI != nil { + pclass.get_uri = (*[0]byte)(C._gotk4_gst1_URIHandler_get_uri) + } + + if overrides.SetURI != nil { + pclass.set_uri = (*[0]byte)(C._gotk4_gst1_URIHandler_set_uri) + } +} + // TagSetterInstance is the instance type used by all types implementing GstTagSetter. It is used internally by the bindings. Users should use the interface [TagSetter] instead. type TagSetterInstance struct { _ [0]func() // equal guard @@ -12630,6 +13166,7 @@ type TagSetter interface { upcastToGstTagSetter() *TagSetterInstance // GetTagList wraps gst_tag_setter_get_tag_list + // // The function returns the following values: // // - goret *TagList (nullable) @@ -12640,6 +13177,7 @@ type TagSetter interface { // This function is not thread-safe. GetTagList() *TagList // GetTagMergeMode wraps gst_tag_setter_get_tag_merge_mode + // // The function returns the following values: // // - goret TagMergeMode @@ -12712,6 +13250,7 @@ func UnsafeTagSetterToGlibFull(c TagSetter) unsafe.Pointer { } // GetTagList wraps gst_tag_setter_get_tag_list +// // The function returns the following values: // // - goret *TagList (nullable) @@ -12739,6 +13278,7 @@ func (setter *TagSetterInstance) GetTagList() *TagList { } // GetTagMergeMode wraps gst_tag_setter_get_tag_merge_mode +// // The function returns the following values: // // - goret TagMergeMode @@ -12818,6 +13358,16 @@ func (setter *TagSetterInstance) SetTagMergeMode(mode TagMergeMode) { runtime.KeepAlive(mode) } +// TagSetterOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type TagSetterOverrides[Instance TagSetter] struct { +} + +// UnsafeApplyTagSetterOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyTagSetterOverrides[Instance TagSetter](gclass unsafe.Pointer, overrides TagSetterOverrides[Instance]) { +} + // TocSetterInstance is the instance type used by all types implementing GstTocSetter. It is used internally by the bindings. Users should use the interface [TocSetter] instead. type TocSetterInstance struct { _ [0]func() // equal guard @@ -12846,6 +13396,7 @@ type TocSetter interface { upcastToGstTocSetter() *TocSetterInstance // GetToc wraps gst_toc_setter_get_toc + // // The function returns the following values: // // - goret *Toc (nullable) @@ -12908,6 +13459,7 @@ func UnsafeTocSetterToGlibFull(c TocSetter) unsafe.Pointer { } // GetToc wraps gst_toc_setter_get_toc +// // The function returns the following values: // // - goret *Toc (nullable) @@ -12967,6 +13519,16 @@ func (setter *TocSetterInstance) SetToc(toc *Toc) { runtime.KeepAlive(toc) } +// TocSetterOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type TocSetterOverrides[Instance TocSetter] struct { +} + +// UnsafeApplyTocSetterOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyTocSetterOverrides[Instance TocSetter](gclass unsafe.Pointer, overrides TocSetterOverrides[Instance]) { +} + // ObjectInstance is the instance type used by all types extending GstObject. It is used internally by the bindings. Users should use the interface [Object] instead. type ObjectInstance struct { _ [0]func() // equal guard @@ -13073,6 +13635,7 @@ type Object interface { // unreferenced again after use. CurrentControlBinding(string) ControlBinding // GetControlRate wraps gst_object_get_control_rate + // // The function returns the following values: // // - goret ClockTime @@ -13089,6 +13652,7 @@ type Object interface { // %GST_STATE_PAUSED or %GST_STATE_PLAYING. GetControlRate() ClockTime // GetName wraps gst_object_get_name + // // The function returns the following values: // // - goret string (nullable) @@ -13101,6 +13665,7 @@ type Object interface { // Free-function: g_free GetName() string // GetParent wraps gst_object_get_parent + // // The function returns the following values: // // - goret Object (nullable) @@ -13109,6 +13674,7 @@ type Object interface { // of the parent object so you should gst_object_unref() it after usage. GetParent() Object // GetPathString wraps gst_object_get_path_string + // // The function returns the following values: // // - goret string @@ -13119,6 +13685,7 @@ type Object interface { // Free-function: g_free GetPathString() string // HasActiveControlBindings wraps gst_object_has_active_control_bindings + // // The function returns the following values: // // - goret bool @@ -13246,6 +13813,7 @@ type Object interface { // be incremented, and any floating reference will be removed (see gst_object_ref_sink()). SetParent(Object) bool // SuggestNextSync wraps gst_object_suggest_next_sync + // // The function returns the following values: // // - goret ClockTime @@ -13414,6 +13982,7 @@ func (object *ObjectInstance) CurrentControlBinding(propertyName string) Control } // GetControlRate wraps gst_object_get_control_rate +// // The function returns the following values: // // - goret ClockTime @@ -13445,6 +14014,7 @@ func (object *ObjectInstance) GetControlRate() ClockTime { } // GetName wraps gst_object_get_name +// // The function returns the following values: // // - goret string (nullable) @@ -13475,6 +14045,7 @@ func (object *ObjectInstance) GetName() string { } // GetParent wraps gst_object_get_parent +// // The function returns the following values: // // - goret Object (nullable) @@ -13500,6 +14071,7 @@ func (object *ObjectInstance) GetParent() Object { } // GetPathString wraps gst_object_get_path_string +// // The function returns the following values: // // - goret string @@ -13526,6 +14098,7 @@ func (object *ObjectInstance) GetPathString() string { } // HasActiveControlBindings wraps gst_object_has_active_control_bindings +// // The function returns the following values: // // - goret bool @@ -13834,6 +14407,7 @@ func (object *ObjectInstance) SetParent(parent Object) bool { } // SuggestNextSync wraps gst_object_suggest_next_sync +// // The function returns the following values: // // - goret ClockTime @@ -13907,6 +14481,20 @@ func (object *ObjectInstance) Unparent() { runtime.KeepAlive(object) } +// ObjectOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type ObjectOverrides[Instance Object] struct { + // gobject.InitiallyUnownedOverrides allows you to override virtual methods from the parent class gobject.InitiallyUnowned + gobject.InitiallyUnownedOverrides[Instance] + +} + +// UnsafeApplyObjectOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyObjectOverrides[Instance Object](gclass unsafe.Pointer, overrides ObjectOverrides[Instance]) { + gobject.UnsafeApplyInitiallyUnownedOverrides(gclass, overrides.InitiallyUnownedOverrides) +} + // PadInstance is the instance type used by all types extending GstPad. It is used internally by the bindings. Users should use the interface [Pad] instead. type PadInstance struct { _ [0]func() // equal guard @@ -14087,6 +14675,7 @@ type Pad interface { // MT safe. ChainList(*BufferList) FlowReturn // CheckReconfigure wraps gst_pad_check_reconfigure + // // The function returns the following values: // // - goret bool @@ -14159,6 +14748,7 @@ type Pad interface { // When @forward returns %TRUE, no further pads will be processed. Forward(PadForwardFunction) bool // GetAllowedCaps wraps gst_pad_get_allowed_caps + // // The function returns the following values: // // - goret *Caps (nullable) @@ -14171,6 +14761,7 @@ type Pad interface { // on the resulting caps. GetAllowedCaps() *Caps // GetCurrentCaps wraps gst_pad_get_current_caps + // // The function returns the following values: // // - goret *Caps (nullable) @@ -14179,6 +14770,7 @@ type Pad interface { // #GST_EVENT_CAPS event. GetCurrentCaps() *Caps // GetDirection wraps gst_pad_get_direction + // // The function returns the following values: // // - goret PadDirection @@ -14188,6 +14780,7 @@ type Pad interface { // the LOCK. GetDirection() PadDirection // GetLastFlowReturn wraps gst_pad_get_last_flow_return + // // The function returns the following values: // // - goret FlowReturn @@ -14195,6 +14788,7 @@ type Pad interface { // Gets the #GstFlowReturn return from the last data passed by this pad. GetLastFlowReturn() FlowReturn // GetOffset wraps gst_pad_get_offset + // // The function returns the following values: // // - goret int64 @@ -14203,6 +14797,7 @@ type Pad interface { // pad. GetOffset() int64 // GetPadTemplate wraps gst_pad_get_pad_template + // // The function returns the following values: // // - goret PadTemplate (nullable) @@ -14210,6 +14805,7 @@ type Pad interface { // Gets the template for @pad. GetPadTemplate() PadTemplate // GetPadTemplateCaps wraps gst_pad_get_pad_template_caps + // // The function returns the following values: // // - goret *Caps @@ -14217,6 +14813,7 @@ type Pad interface { // Gets the capabilities for @pad's template. GetPadTemplateCaps() *Caps // GetParentElement wraps gst_pad_get_parent_element + // // The function returns the following values: // // - goret Element (nullable) @@ -14225,6 +14822,7 @@ type Pad interface { // its parent is not an element, return %NULL. GetParentElement() Element // GetPeer wraps gst_pad_get_peer + // // The function returns the following values: // // - goret Pad (nullable) @@ -14273,6 +14871,7 @@ type Pad interface { // This is a lowlevel function. Usually gst_pad_pull_range() is used. GetRange(uint64, uint) (*Buffer, FlowReturn) // GetSingleInternalLink wraps gst_pad_get_single_internal_link + // // The function returns the following values: // // - goret Pad (nullable) @@ -14295,6 +14894,7 @@ type Pad interface { // from the event. GetStickyEvent(EventType, uint) *Event // GetStream wraps gst_pad_get_stream + // // The function returns the following values: // // - goret Stream (nullable) @@ -14306,6 +14906,7 @@ type Pad interface { // gst_event_parse_stream(). GetStream() Stream // GetStreamID wraps gst_pad_get_stream_id + // // The function returns the following values: // // - goret string (nullable) @@ -14320,6 +14921,7 @@ type Pad interface { // contents should not be interpreted. GetStreamID() string // GetTaskState wraps gst_pad_get_task_state + // // The function returns the following values: // // - goret TaskState @@ -14328,6 +14930,7 @@ type Pad interface { // set, #GST_TASK_STOPPED is returned. GetTaskState() TaskState // HasCurrentCaps wraps gst_pad_has_current_caps + // // The function returns the following values: // // - goret bool @@ -14335,6 +14938,7 @@ type Pad interface { // Check if @pad has caps set on it with a #GST_EVENT_CAPS event. HasCurrentCaps() bool // IsActive wraps gst_pad_is_active + // // The function returns the following values: // // - goret bool @@ -14342,6 +14946,7 @@ type Pad interface { // Query if a pad is active IsActive() bool // IsBlocked wraps gst_pad_is_blocked + // // The function returns the following values: // // - goret bool @@ -14351,6 +14956,7 @@ type Pad interface { // is actually blocking at this point (see gst_pad_is_blocking()). IsBlocked() bool // IsBlocking wraps gst_pad_is_blocking + // // The function returns the following values: // // - goret bool @@ -14359,6 +14965,7 @@ type Pad interface { // of whether the pad is actually blocking on a #GstBuffer or a #GstEvent. IsBlocking() bool // IsLinked wraps gst_pad_is_linked + // // The function returns the following values: // // - goret bool @@ -14366,6 +14973,7 @@ type Pad interface { // Checks if a @pad is linked to another pad or not. IsLinked() bool // IterateInternalLinks wraps gst_pad_iterate_internal_links + // // The function returns the following values: // // - goret *Iterator (nullable) @@ -14475,6 +15083,7 @@ type Pad interface { // gst_pad_check_reconfigure() will return %TRUE after this call. MarkReconfigure() // NeedsReconfigure wraps gst_pad_needs_reconfigure + // // The function returns the following values: // // - goret bool @@ -14483,6 +15092,7 @@ type Pad interface { // if the flag was set. NeedsReconfigure() bool // PauseTask wraps gst_pad_pause_task + // // The function returns the following values: // // - goret bool @@ -14923,6 +15533,7 @@ type Pad interface { // before @func is called. StartTask(TaskFunction) bool // StopTask wraps gst_pad_stop_task + // // The function returns the following values: // // - goret bool @@ -15369,6 +15980,7 @@ func (pad *PadInstance) ChainList(list *BufferList) FlowReturn { } // CheckReconfigure wraps gst_pad_check_reconfigure +// // The function returns the following values: // // - goret bool @@ -15531,6 +16143,7 @@ func (pad *PadInstance) Forward(forward PadForwardFunction) bool { } // GetAllowedCaps wraps gst_pad_get_allowed_caps +// // The function returns the following values: // // - goret *Caps (nullable) @@ -15560,6 +16173,7 @@ func (pad *PadInstance) GetAllowedCaps() *Caps { } // GetCurrentCaps wraps gst_pad_get_current_caps +// // The function returns the following values: // // - goret *Caps (nullable) @@ -15585,6 +16199,7 @@ func (pad *PadInstance) GetCurrentCaps() *Caps { } // GetDirection wraps gst_pad_get_direction +// // The function returns the following values: // // - goret PadDirection @@ -15609,6 +16224,7 @@ func (pad *PadInstance) GetDirection() PadDirection { } // GetLastFlowReturn wraps gst_pad_get_last_flow_return +// // The function returns the following values: // // - goret FlowReturn @@ -15631,6 +16247,7 @@ func (pad *PadInstance) GetLastFlowReturn() FlowReturn { } // GetOffset wraps gst_pad_get_offset +// // The function returns the following values: // // - goret int64 @@ -15654,6 +16271,7 @@ func (pad *PadInstance) GetOffset() int64 { } // GetPadTemplate wraps gst_pad_get_pad_template +// // The function returns the following values: // // - goret PadTemplate (nullable) @@ -15678,6 +16296,7 @@ func (pad *PadInstance) GetPadTemplate() PadTemplate { } // GetPadTemplateCaps wraps gst_pad_get_pad_template_caps +// // The function returns the following values: // // - goret *Caps @@ -15700,6 +16319,7 @@ func (pad *PadInstance) GetPadTemplateCaps() *Caps { } // GetParentElement wraps gst_pad_get_parent_element +// // The function returns the following values: // // - goret Element (nullable) @@ -15725,6 +16345,7 @@ func (pad *PadInstance) GetParentElement() Element { } // GetPeer wraps gst_pad_get_peer +// // The function returns the following values: // // - goret Pad (nullable) @@ -15814,6 +16435,7 @@ func (pad *PadInstance) GetRange(offset uint64, size uint) (*Buffer, FlowReturn) } // GetSingleInternalLink wraps gst_pad_get_single_internal_link +// // The function returns the following values: // // - goret Pad (nullable) @@ -15876,6 +16498,7 @@ func (pad *PadInstance) GetStickyEvent(eventType EventType, idx uint) *Event { } // GetStream wraps gst_pad_get_stream +// // The function returns the following values: // // - goret Stream (nullable) @@ -15904,6 +16527,7 @@ func (pad *PadInstance) GetStream() Stream { } // GetStreamID wraps gst_pad_get_stream_id +// // The function returns the following values: // // - goret string (nullable) @@ -15936,6 +16560,7 @@ func (pad *PadInstance) GetStreamID() string { } // GetTaskState wraps gst_pad_get_task_state +// // The function returns the following values: // // - goret TaskState @@ -15959,6 +16584,7 @@ func (pad *PadInstance) GetTaskState() TaskState { } // HasCurrentCaps wraps gst_pad_has_current_caps +// // The function returns the following values: // // - goret bool @@ -15983,6 +16609,7 @@ func (pad *PadInstance) HasCurrentCaps() bool { } // IsActive wraps gst_pad_is_active +// // The function returns the following values: // // - goret bool @@ -16007,6 +16634,7 @@ func (pad *PadInstance) IsActive() bool { } // IsBlocked wraps gst_pad_is_blocked +// // The function returns the following values: // // - goret bool @@ -16033,6 +16661,7 @@ func (pad *PadInstance) IsBlocked() bool { } // IsBlocking wraps gst_pad_is_blocking +// // The function returns the following values: // // - goret bool @@ -16058,6 +16687,7 @@ func (pad *PadInstance) IsBlocking() bool { } // IsLinked wraps gst_pad_is_linked +// // The function returns the following values: // // - goret bool @@ -16082,6 +16712,7 @@ func (pad *PadInstance) IsLinked() bool { } // IterateInternalLinks wraps gst_pad_iterate_internal_links +// // The function returns the following values: // // - goret *Iterator (nullable) @@ -16320,6 +16951,7 @@ func (pad *PadInstance) MarkReconfigure() { } // NeedsReconfigure wraps gst_pad_needs_reconfigure +// // The function returns the following values: // // - goret bool @@ -16345,6 +16977,7 @@ func (pad *PadInstance) NeedsReconfigure() bool { } // PauseTask wraps gst_pad_pause_task +// // The function returns the following values: // // - goret bool @@ -17305,6 +17938,7 @@ func (pad *PadInstance) StartTask(fn TaskFunction) bool { } // StopTask wraps gst_pad_stop_task +// // The function returns the following values: // // - goret bool @@ -17423,12 +18057,48 @@ func (pad *PadInstance) UseFixedCaps() { func (o *PadInstance) ConnectLinked(fn func(Pad, Pad)) gobject.SignalHandle { return o.Connect("linked", fn) } + // ConnectUnlinked connects the provided callback to the "unlinked" signal // // Signals that a pad has been unlinked from the peer pad. func (o *PadInstance) ConnectUnlinked(fn func(Pad, Pad)) gobject.SignalHandle { return o.Connect("unlinked", fn) } + +// PadOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type PadOverrides[Instance Pad] struct { + // ObjectOverrides allows you to override virtual methods from the parent class Object + ObjectOverrides[Instance] + + // Linked allows you to override the implementation of the virtual method linked. + // The function takes the following parameters: + // + // - peer Pad + Linked func(Instance, Pad) + // Unlinked allows you to override the implementation of the virtual method unlinked. + // The function takes the following parameters: + // + // - peer Pad + Unlinked func(Instance, Pad) +} + +// UnsafeApplyPadOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyPadOverrides[Instance Pad](gclass unsafe.Pointer, overrides PadOverrides[Instance]) { + UnsafeApplyObjectOverrides(gclass, overrides.ObjectOverrides) + + pclass := (*C.GstPadClass)(gclass) + + if overrides.Linked != nil { + pclass.linked = (*[0]byte)(C._gotk4_gst1_Pad_linked) + } + + if overrides.Unlinked != nil { + pclass.unlinked = (*[0]byte)(C._gotk4_gst1_Pad_unlinked) + } +} + // PadTemplateInstance is the instance type used by all types extending GstPadTemplate. It is used internally by the bindings. Users should use the interface [PadTemplate] instead. type PadTemplateInstance struct { _ [0]func() // equal guard @@ -17504,6 +18174,7 @@ type PadTemplate interface { upcastToGstPadTemplate() *PadTemplateInstance // GetCaps wraps gst_pad_template_get_caps + // // The function returns the following values: // // - goret *Caps @@ -17511,6 +18182,7 @@ type PadTemplate interface { // Gets the capabilities of the pad template. GetCaps() *Caps // GetDocumentationCaps wraps gst_pad_template_get_documentation_caps + // // The function returns the following values: // // - goret *Caps @@ -17704,6 +18376,7 @@ func NewPadTemplateWithGType(nameTemplate string, direction PadDirection, presen } // GetCaps wraps gst_pad_template_get_caps +// // The function returns the following values: // // - goret *Caps @@ -17726,6 +18399,7 @@ func (templ *PadTemplateInstance) GetCaps() *Caps { } // GetDocumentationCaps wraps gst_pad_template_get_documentation_caps +// // The function returns the following values: // // - goret *Caps @@ -17794,6 +18468,32 @@ func (templ *PadTemplateInstance) SetDocumentationCaps(caps *Caps) { func (o *PadTemplateInstance) ConnectPadCreated(fn func(PadTemplate, Pad)) gobject.SignalHandle { return o.Connect("pad-created", fn) } + +// PadTemplateOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type PadTemplateOverrides[Instance PadTemplate] struct { + // ObjectOverrides allows you to override virtual methods from the parent class Object + ObjectOverrides[Instance] + + // PadCreated allows you to override the implementation of the virtual method pad_created. + // The function takes the following parameters: + // + // - pad Pad: the #GstPad that created it + PadCreated func(Instance, Pad) +} + +// UnsafeApplyPadTemplateOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyPadTemplateOverrides[Instance PadTemplate](gclass unsafe.Pointer, overrides PadTemplateOverrides[Instance]) { + UnsafeApplyObjectOverrides(gclass, overrides.ObjectOverrides) + + pclass := (*C.GstPadTemplateClass)(gclass) + + if overrides.PadCreated != nil { + pclass.pad_created = (*[0]byte)(C._gotk4_gst1_PadTemplate_pad_created) + } +} + // PluginInstance is the instance type used by all types extending GstPlugin. It is used internally by the bindings. Users should use the interface [Plugin] instead. type PluginInstance struct { _ [0]func() // equal guard @@ -17902,6 +18602,7 @@ type Plugin interface { // - message string: the status warning message AddStatusWarning(string) // GetCacheData wraps gst_plugin_get_cache_data + // // The function returns the following values: // // - goret *Structure (nullable) @@ -17910,6 +18611,7 @@ type Plugin interface { // stored. This is the case when the registry is getting rebuilt. GetCacheData() *Structure // GetDescription wraps gst_plugin_get_description + // // The function returns the following values: // // - goret string @@ -17917,6 +18619,7 @@ type Plugin interface { // Get the long descriptive name of the plugin GetDescription() string // GetFilename wraps gst_plugin_get_filename + // // The function returns the following values: // // - goret string (nullable) @@ -17924,6 +18627,7 @@ type Plugin interface { // get the filename of the plugin GetFilename() string // GetLicense wraps gst_plugin_get_license + // // The function returns the following values: // // - goret string @@ -17931,6 +18635,7 @@ type Plugin interface { // get the license of the plugin GetLicense() string // GetName wraps gst_plugin_get_name + // // The function returns the following values: // // - goret string @@ -17938,6 +18643,7 @@ type Plugin interface { // Get the short name of the plugin GetName() string // GetOrigin wraps gst_plugin_get_origin + // // The function returns the following values: // // - goret string @@ -17945,6 +18651,7 @@ type Plugin interface { // get the URL where the plugin comes from GetOrigin() string // GetPackage wraps gst_plugin_get_package + // // The function returns the following values: // // - goret string @@ -17952,6 +18659,7 @@ type Plugin interface { // get the package the plugin belongs to. GetPackage() string // GetReleaseDateString wraps gst_plugin_get_release_date_string + // // The function returns the following values: // // - goret string (nullable) @@ -17966,6 +18674,7 @@ type Plugin interface { // There may be plugins that do not have a valid release date set on them. GetReleaseDateString() string // GetSource wraps gst_plugin_get_source + // // The function returns the following values: // // - goret string @@ -17973,21 +18682,25 @@ type Plugin interface { // get the source module the plugin belongs to. GetSource() string // GetStatusErrors wraps gst_plugin_get_status_errors + // // The function returns the following values: // // - goret []string (nullable) GetStatusErrors() []string // GetStatusInfos wraps gst_plugin_get_status_infos + // // The function returns the following values: // // - goret []string (nullable) GetStatusInfos() []string // GetStatusWarnings wraps gst_plugin_get_status_warnings + // // The function returns the following values: // // - goret []string (nullable) GetStatusWarnings() []string // GetVersion wraps gst_plugin_get_version + // // The function returns the following values: // // - goret string @@ -17995,6 +18708,7 @@ type Plugin interface { // get the version of the plugin GetVersion() string // IsLoaded wraps gst_plugin_is_loaded + // // The function returns the following values: // // - goret bool @@ -18002,6 +18716,7 @@ type Plugin interface { // queries if the plugin is loaded into memory IsLoaded() bool // Load wraps gst_plugin_load + // // The function returns the following values: // // - goret Plugin (nullable) @@ -18386,6 +19101,7 @@ func (plugin *PluginInstance) AddStatusWarning(message string) { } // GetCacheData wraps gst_plugin_get_cache_data +// // The function returns the following values: // // - goret *Structure (nullable) @@ -18411,6 +19127,7 @@ func (plugin *PluginInstance) GetCacheData() *Structure { } // GetDescription wraps gst_plugin_get_description +// // The function returns the following values: // // - goret string @@ -18433,6 +19150,7 @@ func (plugin *PluginInstance) GetDescription() string { } // GetFilename wraps gst_plugin_get_filename +// // The function returns the following values: // // - goret string (nullable) @@ -18457,6 +19175,7 @@ func (plugin *PluginInstance) GetFilename() string { } // GetLicense wraps gst_plugin_get_license +// // The function returns the following values: // // - goret string @@ -18479,6 +19198,7 @@ func (plugin *PluginInstance) GetLicense() string { } // GetName wraps gst_plugin_get_name +// // The function returns the following values: // // - goret string @@ -18501,6 +19221,7 @@ func (plugin *PluginInstance) GetName() string { } // GetOrigin wraps gst_plugin_get_origin +// // The function returns the following values: // // - goret string @@ -18523,6 +19244,7 @@ func (plugin *PluginInstance) GetOrigin() string { } // GetPackage wraps gst_plugin_get_package +// // The function returns the following values: // // - goret string @@ -18545,6 +19267,7 @@ func (plugin *PluginInstance) GetPackage() string { } // GetReleaseDateString wraps gst_plugin_get_release_date_string +// // The function returns the following values: // // - goret string (nullable) @@ -18576,6 +19299,7 @@ func (plugin *PluginInstance) GetReleaseDateString() string { } // GetSource wraps gst_plugin_get_source +// // The function returns the following values: // // - goret string @@ -18598,6 +19322,7 @@ func (plugin *PluginInstance) GetSource() string { } // GetStatusErrors wraps gst_plugin_get_status_errors +// // The function returns the following values: // // - goret []string (nullable) @@ -18620,6 +19345,7 @@ func (plugin *PluginInstance) GetStatusErrors() []string { } // GetStatusInfos wraps gst_plugin_get_status_infos +// // The function returns the following values: // // - goret []string (nullable) @@ -18642,6 +19368,7 @@ func (plugin *PluginInstance) GetStatusInfos() []string { } // GetStatusWarnings wraps gst_plugin_get_status_warnings +// // The function returns the following values: // // - goret []string (nullable) @@ -18664,6 +19391,7 @@ func (plugin *PluginInstance) GetStatusWarnings() []string { } // GetVersion wraps gst_plugin_get_version +// // The function returns the following values: // // - goret string @@ -18686,6 +19414,7 @@ func (plugin *PluginInstance) GetVersion() string { } // IsLoaded wraps gst_plugin_is_loaded +// // The function returns the following values: // // - goret bool @@ -18710,6 +19439,7 @@ func (plugin *PluginInstance) IsLoaded() bool { } // Load wraps gst_plugin_load +// // The function returns the following values: // // - goret Plugin (nullable) @@ -18800,6 +19530,7 @@ type PluginFeature interface { // the nano version from the string and do this check that way if needed. CheckVersion(uint, uint, uint) bool // GetPlugin wraps gst_plugin_feature_get_plugin + // // The function returns the following values: // // - goret Plugin (nullable) @@ -18807,6 +19538,7 @@ type PluginFeature interface { // Get the plugin that provides this feature. GetPlugin() Plugin // GetPluginName wraps gst_plugin_feature_get_plugin_name + // // The function returns the following values: // // - goret string (nullable) @@ -18814,6 +19546,7 @@ type PluginFeature interface { // Get the name of the plugin that provides this feature. GetPluginName() string // GetRank wraps gst_plugin_feature_get_rank + // // The function returns the following values: // // - goret uint @@ -18821,6 +19554,7 @@ type PluginFeature interface { // Gets the rank of a plugin feature. GetRank() uint // Load wraps gst_plugin_feature_load + // // The function returns the following values: // // - goret PluginFeature (nullable) @@ -18970,6 +19704,7 @@ func (feature *PluginFeatureInstance) CheckVersion(minMajor uint, minMinor uint, } // GetPlugin wraps gst_plugin_feature_get_plugin +// // The function returns the following values: // // - goret Plugin (nullable) @@ -18994,6 +19729,7 @@ func (feature *PluginFeatureInstance) GetPlugin() Plugin { } // GetPluginName wraps gst_plugin_feature_get_plugin_name +// // The function returns the following values: // // - goret string (nullable) @@ -19018,6 +19754,7 @@ func (feature *PluginFeatureInstance) GetPluginName() string { } // GetRank wraps gst_plugin_feature_get_rank +// // The function returns the following values: // // - goret uint @@ -19040,6 +19777,7 @@ func (feature *PluginFeatureInstance) GetRank() uint { } // Load wraps gst_plugin_feature_load +// // The function returns the following values: // // - goret PluginFeature (nullable) @@ -19108,6 +19846,7 @@ type ProxyPad interface { upcastToGstProxyPad() *ProxyPadInstance // GetInternal wraps gst_proxy_pad_get_internal + // // The function returns the following values: // // - goret ProxyPad (nullable) @@ -19315,6 +20054,7 @@ func ProxyPadIterateInternalLinksDefault(pad Pad, parent Object) *Iterator { } // GetInternal wraps gst_proxy_pad_get_internal +// // The function returns the following values: // // - goret ProxyPad (nullable) @@ -19341,6 +20081,20 @@ func (pad *ProxyPadInstance) GetInternal() ProxyPad { return goret } +// ProxyPadOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type ProxyPadOverrides[Instance ProxyPad] struct { + // PadOverrides allows you to override virtual methods from the parent class Pad + PadOverrides[Instance] + +} + +// UnsafeApplyProxyPadOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyProxyPadOverrides[Instance ProxyPad](gclass unsafe.Pointer, overrides ProxyPadOverrides[Instance]) { + UnsafeApplyPadOverrides(gclass, overrides.PadOverrides) +} + // RegistryInstance is the instance type used by all types extending GstRegistry. It is used internally by the bindings. Users should use the interface [Registry] instead. type RegistryInstance struct { _ [0]func() // equal guard @@ -19527,6 +20281,7 @@ type Registry interface { // Retrieves a #GList of features of the plugin with name @name. GetFeatureListByPlugin(string) []PluginFeature // GetFeatureListCookie wraps gst_registry_get_feature_list_cookie + // // The function returns the following values: // // - goret uint32 @@ -19535,6 +20290,7 @@ type Registry interface { // every time a feature is added or removed from the registry. GetFeatureListCookie() uint32 // GetPluginList wraps gst_registry_get_plugin_list + // // The function returns the following values: // // - goret []Plugin @@ -19668,6 +20424,7 @@ func UnsafeRegistryToGlibFull(c Registry) unsafe.Pointer { } // RegistryForkIsEnabled wraps gst_registry_fork_is_enabled +// // The function returns the following values: // // - goret bool @@ -19713,6 +20470,7 @@ func RegistryForkSetEnabled(enabled bool) { } // RegistryGet wraps gst_registry_get +// // The function returns the following values: // // - goret Registry @@ -20045,6 +20803,7 @@ func (registry *RegistryInstance) GetFeatureListByPlugin(name string) []PluginFe } // GetFeatureListCookie wraps gst_registry_get_feature_list_cookie +// // The function returns the following values: // // - goret uint32 @@ -20068,6 +20827,7 @@ func (registry *RegistryInstance) GetFeatureListCookie() uint32 { } // GetPluginList wraps gst_registry_get_plugin_list +// // The function returns the following values: // // - goret []Plugin @@ -20297,6 +21057,7 @@ func (registry *RegistryInstance) ScanPath(path string) bool { func (o *RegistryInstance) ConnectFeatureAdded(fn func(Registry, PluginFeature)) gobject.SignalHandle { return o.Connect("feature-added", fn) } + // ConnectPluginAdded connects the provided callback to the "plugin-added" signal // // Signals that a plugin has been added to the registry (possibly @@ -20304,6 +21065,21 @@ func (o *RegistryInstance) ConnectFeatureAdded(fn func(Registry, PluginFeature)) func (o *RegistryInstance) ConnectPluginAdded(fn func(Registry, Plugin)) gobject.SignalHandle { return o.Connect("plugin-added", fn) } + +// RegistryOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type RegistryOverrides[Instance Registry] struct { + // ObjectOverrides allows you to override virtual methods from the parent class Object + ObjectOverrides[Instance] + +} + +// UnsafeApplyRegistryOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyRegistryOverrides[Instance Registry](gclass unsafe.Pointer, overrides RegistryOverrides[Instance]) { + UnsafeApplyObjectOverrides(gclass, overrides.ObjectOverrides) +} + // StreamInstance is the instance type used by all types extending GstStream. It is used internally by the bindings. Users should use the interface [Stream] instead. type StreamInstance struct { _ [0]func() // equal guard @@ -20331,6 +21107,7 @@ type Stream interface { upcastToGstStream() *StreamInstance // GetCaps wraps gst_stream_get_caps + // // The function returns the following values: // // - goret *Caps (nullable) @@ -20338,6 +21115,7 @@ type Stream interface { // Retrieve the caps for @stream, if any GetCaps() *Caps // GetStreamFlags wraps gst_stream_get_stream_flags + // // The function returns the following values: // // - goret StreamFlags @@ -20345,6 +21123,7 @@ type Stream interface { // Retrieve the current stream flags for @stream GetStreamFlags() StreamFlags // GetStreamID wraps gst_stream_get_stream_id + // // The function returns the following values: // // - goret string (nullable) @@ -20352,6 +21131,7 @@ type Stream interface { // Returns the stream ID of @stream. GetStreamID() string // GetStreamType wraps gst_stream_get_stream_type + // // The function returns the following values: // // - goret StreamType @@ -20359,6 +21139,7 @@ type Stream interface { // Retrieve the stream type for @stream GetStreamType() StreamType // GetTags wraps gst_stream_get_tags + // // The function returns the following values: // // - goret *TagList (nullable) @@ -20484,6 +21265,7 @@ func NewStream(streamId string, caps *Caps, typ StreamType, flags StreamFlags) S } // GetCaps wraps gst_stream_get_caps +// // The function returns the following values: // // - goret *Caps (nullable) @@ -20508,6 +21290,7 @@ func (stream *StreamInstance) GetCaps() *Caps { } // GetStreamFlags wraps gst_stream_get_stream_flags +// // The function returns the following values: // // - goret StreamFlags @@ -20530,6 +21313,7 @@ func (stream *StreamInstance) GetStreamFlags() StreamFlags { } // GetStreamID wraps gst_stream_get_stream_id +// // The function returns the following values: // // - goret string (nullable) @@ -20554,6 +21338,7 @@ func (stream *StreamInstance) GetStreamID() string { } // GetStreamType wraps gst_stream_get_stream_type +// // The function returns the following values: // // - goret StreamType @@ -20576,6 +21361,7 @@ func (stream *StreamInstance) GetStreamType() StreamType { } // GetTags wraps gst_stream_get_tags +// // The function returns the following values: // // - goret *TagList (nullable) @@ -20679,6 +21465,20 @@ func (stream *StreamInstance) SetTags(tags *TagList) { runtime.KeepAlive(tags) } +// StreamOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type StreamOverrides[Instance Stream] struct { + // ObjectOverrides allows you to override virtual methods from the parent class Object + ObjectOverrides[Instance] + +} + +// UnsafeApplyStreamOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyStreamOverrides[Instance Stream](gclass unsafe.Pointer, overrides StreamOverrides[Instance]) { + UnsafeApplyObjectOverrides(gclass, overrides.ObjectOverrides) +} + // StreamCollectionInstance is the instance type used by all types extending GstStreamCollection. It is used internally by the bindings. Users should use the interface [StreamCollection] instead. type StreamCollectionInstance struct { _ [0]func() // equal guard @@ -20722,6 +21522,7 @@ type StreamCollection interface { // Add the given @stream to the @collection. AddStream(Stream) bool // GetSize wraps gst_stream_collection_get_size + // // The function returns the following values: // // - goret uint @@ -20743,6 +21544,7 @@ type StreamCollection interface { // The caller should not modify the returned #GstStream GetStream(uint) Stream // GetUpstreamID wraps gst_stream_collection_get_upstream_id + // // The function returns the following values: // // - goret string (nullable) @@ -20852,6 +21654,7 @@ func (collection *StreamCollectionInstance) AddStream(stream Stream) bool { } // GetSize wraps gst_stream_collection_get_size +// // The function returns the following values: // // - goret uint @@ -20908,6 +21711,7 @@ func (collection *StreamCollectionInstance) GetStream(index uint) Stream { } // GetUpstreamID wraps gst_stream_collection_get_upstream_id +// // The function returns the following values: // // - goret string (nullable) @@ -20931,6 +21735,20 @@ func (collection *StreamCollectionInstance) GetUpstreamID() string { return goret } +// StreamCollectionOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type StreamCollectionOverrides[Instance StreamCollection] struct { + // ObjectOverrides allows you to override virtual methods from the parent class Object + ObjectOverrides[Instance] + +} + +// UnsafeApplyStreamCollectionOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyStreamCollectionOverrides[Instance StreamCollection](gclass unsafe.Pointer, overrides StreamCollectionOverrides[Instance]) { + UnsafeApplyObjectOverrides(gclass, overrides.ObjectOverrides) +} + // TaskInstance is the instance type used by all types extending GstTask. It is used internally by the bindings. Users should use the interface [Task] instead. type TaskInstance struct { _ [0]func() // equal guard @@ -20985,6 +21803,7 @@ type Task interface { upcastToGstTask() *TaskInstance // GetPool wraps gst_task_get_pool + // // The function returns the following values: // // - goret TaskPool @@ -20995,6 +21814,7 @@ type Task interface { // MT safe. GetPool() TaskPool // GetState wraps gst_task_get_state + // // The function returns the following values: // // - goret TaskState @@ -21002,6 +21822,7 @@ type Task interface { // Get the current state of the task. GetState() TaskState // Join wraps gst_task_join + // // The function returns the following values: // // - goret bool @@ -21016,6 +21837,7 @@ type Task interface { // g_warning. Join() bool // Pause wraps gst_task_pause + // // The function returns the following values: // // - goret bool @@ -21026,6 +21848,7 @@ type Task interface { // the paused state. Pause() bool // Resume wraps gst_task_resume + // // The function returns the following values: // // - goret bool @@ -21063,6 +21886,7 @@ type Task interface { // MT safe. SetState(TaskState) bool // Start wraps gst_task_start + // // The function returns the following values: // // - goret bool @@ -21071,6 +21895,7 @@ type Task interface { // gst_task_set_lock() or this function will return %FALSE. Start() bool // Stop wraps gst_task_stop + // // The function returns the following values: // // - goret bool @@ -21174,6 +21999,7 @@ func TaskCleanupAll() { } // GetPool wraps gst_task_get_pool +// // The function returns the following values: // // - goret TaskPool @@ -21199,6 +22025,7 @@ func (task *TaskInstance) GetPool() TaskPool { } // GetState wraps gst_task_get_state +// // The function returns the following values: // // - goret TaskState @@ -21221,6 +22048,7 @@ func (task *TaskInstance) GetState() TaskState { } // Join wraps gst_task_join +// // The function returns the following values: // // - goret bool @@ -21252,6 +22080,7 @@ func (task *TaskInstance) Join() bool { } // Pause wraps gst_task_pause +// // The function returns the following values: // // - goret bool @@ -21279,6 +22108,7 @@ func (task *TaskInstance) Pause() bool { } // Resume wraps gst_task_resume +// // The function returns the following values: // // - goret bool @@ -21364,6 +22194,7 @@ func (task *TaskInstance) SetState(state TaskState) bool { } // Start wraps gst_task_start +// // The function returns the following values: // // - goret bool @@ -21389,6 +22220,7 @@ func (task *TaskInstance) Start() bool { } // Stop wraps gst_task_stop +// // The function returns the following values: // // - goret bool @@ -21414,6 +22246,20 @@ func (task *TaskInstance) Stop() bool { return goret } +// TaskOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type TaskOverrides[Instance Task] struct { + // ObjectOverrides allows you to override virtual methods from the parent class Object + ObjectOverrides[Instance] + +} + +// UnsafeApplyTaskOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyTaskOverrides[Instance Task](gclass unsafe.Pointer, overrides TaskOverrides[Instance]) { + UnsafeApplyObjectOverrides(gclass, overrides.ObjectOverrides) +} + // TaskPoolInstance is the instance type used by all types extending GstTaskPool. It is used internally by the bindings. Users should use the interface [TaskPool] instead. type TaskPoolInstance struct { _ [0]func() // equal guard @@ -21440,6 +22286,7 @@ type TaskPool interface { // MT safe. Cleanup() // Prepare wraps gst_task_pool_prepare + // // The function returns the following values: // // - _goerr error (nullable): an error @@ -21489,6 +22336,7 @@ func UnsafeTaskPoolToGlibFull(c TaskPool) unsafe.Pointer { } // NewTaskPool wraps gst_task_pool_new +// // The function returns the following values: // // - goret TaskPool @@ -21523,6 +22371,7 @@ func (pool *TaskPoolInstance) Cleanup() { } // Prepare wraps gst_task_pool_prepare +// // The function returns the following values: // // - _goerr error (nullable): an error @@ -21548,6 +22397,37 @@ func (pool *TaskPoolInstance) Prepare() error { return _goerr } +// TaskPoolOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type TaskPoolOverrides[Instance TaskPool] struct { + // ObjectOverrides allows you to override virtual methods from the parent class Object + ObjectOverrides[Instance] + + // Cleanup allows you to override the implementation of the virtual method cleanup. + Cleanup func(Instance) + // Prepare allows you to override the implementation of the virtual method prepare. + // The function returns the following values: + // + // - _goerr error (nullable): an error + Prepare func(Instance) error +} + +// UnsafeApplyTaskPoolOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyTaskPoolOverrides[Instance TaskPool](gclass unsafe.Pointer, overrides TaskPoolOverrides[Instance]) { + UnsafeApplyObjectOverrides(gclass, overrides.ObjectOverrides) + + pclass := (*C.GstTaskPoolClass)(gclass) + + if overrides.Cleanup != nil { + pclass.cleanup = (*[0]byte)(C._gotk4_gst1_TaskPool_cleanup) + } + + if overrides.Prepare != nil { + pclass.prepare = (*[0]byte)(C._gotk4_gst1_TaskPool_prepare) + } +} + // TracerInstance is the instance type used by all types extending GstTracer. It is used internally by the bindings. Users should use the interface [Tracer] instead. type TracerInstance struct { _ [0]func() // equal guard @@ -21646,6 +22526,20 @@ func TracerRegister(plugin Plugin, name string, typ gobject.Type) bool { return goret } +// TracerOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type TracerOverrides[Instance Tracer] struct { + // ObjectOverrides allows you to override virtual methods from the parent class Object + ObjectOverrides[Instance] + +} + +// UnsafeApplyTracerOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyTracerOverrides[Instance Tracer](gclass unsafe.Pointer, overrides TracerOverrides[Instance]) { + UnsafeApplyObjectOverrides(gclass, overrides.ObjectOverrides) +} + // TracerFactoryInstance is the instance type used by all types extending GstTracerFactory. It is used internally by the bindings. Users should use the interface [TracerFactory] instead. type TracerFactoryInstance struct { _ [0]func() // equal guard @@ -21663,6 +22557,7 @@ type TracerFactory interface { upcastToGstTracerFactory() *TracerFactoryInstance // GetTracerType wraps gst_tracer_factory_get_tracer_type + // // The function returns the following values: // // - goret gobject.Type @@ -21714,6 +22609,7 @@ func UnsafeTracerFactoryToGlibFull(c TracerFactory) unsafe.Pointer { } // TracerFactoryGetList wraps gst_tracer_factory_get_list +// // The function returns the following values: // // - goret []TracerFactory @@ -21744,6 +22640,7 @@ func TracerFactoryGetList() []TracerFactory { } // GetTracerType wraps gst_tracer_factory_get_tracer_type +// // The function returns the following values: // // - goret gobject.Type @@ -21895,6 +22792,7 @@ type TypeFindFactory interface { // Calls the #GstTypeFindFunction associated with this factory. CallFunction(*TypeFind) // GetCaps wraps gst_type_find_factory_get_caps + // // The function returns the following values: // // - goret *Caps (nullable) @@ -21902,6 +22800,7 @@ type TypeFindFactory interface { // Gets the #GstCaps associated with a typefind factory. GetCaps() *Caps // GetExtensions wraps gst_type_find_factory_get_extensions + // // The function returns the following values: // // - goret []string (nullable) @@ -21912,6 +22811,7 @@ type TypeFindFactory interface { // a 0-length list. GetExtensions() []string // HasFunction wraps gst_type_find_factory_has_function + // // The function returns the following values: // // - goret bool @@ -21963,6 +22863,7 @@ func UnsafeTypeFindFactoryToGlibFull(c TypeFindFactory) unsafe.Pointer { } // TypeFindFactoryGetList wraps gst_type_find_factory_get_list +// // The function returns the following values: // // - goret []TypeFindFactory @@ -22014,6 +22915,7 @@ func (factory *TypeFindFactoryInstance) CallFunction(find *TypeFind) { } // GetCaps wraps gst_type_find_factory_get_caps +// // The function returns the following values: // // - goret *Caps (nullable) @@ -22038,6 +22940,7 @@ func (factory *TypeFindFactoryInstance) GetCaps() *Caps { } // GetExtensions wraps gst_type_find_factory_get_extensions +// // The function returns the following values: // // - goret []string (nullable) @@ -22065,6 +22968,7 @@ func (factory *TypeFindFactoryInstance) GetExtensions() []string { } // HasFunction wraps gst_type_find_factory_has_function +// // The function returns the following values: // // - goret bool @@ -22331,6 +23235,45 @@ func (allocator *AllocatorInstance) SetDefault() { runtime.KeepAlive(allocator) } +// AllocatorOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type AllocatorOverrides[Instance Allocator] struct { + // ObjectOverrides allows you to override virtual methods from the parent class Object + ObjectOverrides[Instance] + + // Alloc allows you to override the implementation of the virtual method alloc. + // The function takes the following parameters: + // + // - size uint: size of the visible memory area + // - params *AllocationParams (nullable): optional parameters + // + // The function returns the following values: + // + // - goret *Memory (nullable) + Alloc func(Instance, uint, *AllocationParams) *Memory + // Free allows you to override the implementation of the virtual method free. + // The function takes the following parameters: + // + // - memory *Memory: the memory to free + Free func(Instance, *Memory) +} + +// UnsafeApplyAllocatorOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyAllocatorOverrides[Instance Allocator](gclass unsafe.Pointer, overrides AllocatorOverrides[Instance]) { + UnsafeApplyObjectOverrides(gclass, overrides.ObjectOverrides) + + pclass := (*C.GstAllocatorClass)(gclass) + + if overrides.Alloc != nil { + pclass.alloc = (*[0]byte)(C._gotk4_gst1_Allocator_alloc) + } + + if overrides.Free != nil { + pclass.free = (*[0]byte)(C._gotk4_gst1_Allocator_free) + } +} + // BufferPoolInstance is the instance type used by all types extending GstBufferPool. It is used internally by the bindings. Users should use the interface [BufferPool] instead. type BufferPoolInstance struct { _ [0]func() // equal guard @@ -22398,6 +23341,7 @@ type BufferPool interface { // @params can contain optional parameters to influence the allocation. AcquireBuffer(*BufferPoolAcquireParams) (*Buffer, FlowReturn) // GetConfig wraps gst_buffer_pool_get_config + // // The function returns the following values: // // - goret *Structure @@ -22406,6 +23350,7 @@ type BufferPool interface { // can be modified and used for the gst_buffer_pool_set_config() call. GetConfig() *Structure // GetOptions wraps gst_buffer_pool_get_options + // // The function returns the following values: // // - goret []string @@ -22427,6 +23372,7 @@ type BufferPool interface { // Checks if the bufferpool supports @option. HasOption(string) bool // IsActive wraps gst_buffer_pool_is_active + // // The function returns the following values: // // - goret bool @@ -22543,6 +23489,7 @@ func UnsafeBufferPoolToGlibFull(c BufferPool) unsafe.Pointer { } // NewBufferPool wraps gst_buffer_pool_new +// // The function returns the following values: // // - goret BufferPool @@ -22939,6 +23886,7 @@ func (pool *BufferPoolInstance) AcquireBuffer(params *BufferPoolAcquireParams) ( } // GetConfig wraps gst_buffer_pool_get_config +// // The function returns the following values: // // - goret *Structure @@ -22962,6 +23910,7 @@ func (pool *BufferPoolInstance) GetConfig() *Structure { } // GetOptions wraps gst_buffer_pool_get_options +// // The function returns the following values: // // - goret []string @@ -23021,6 +23970,7 @@ func (pool *BufferPoolInstance) HasOption(option string) bool { } // IsActive wraps gst_buffer_pool_is_active +// // The function returns the following values: // // - goret bool @@ -23179,6 +24129,129 @@ func (pool *BufferPoolInstance) SetFlushing(flushing bool) { runtime.KeepAlive(flushing) } +// BufferPoolOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type BufferPoolOverrides[Instance BufferPool] struct { + // ObjectOverrides allows you to override virtual methods from the parent class Object + ObjectOverrides[Instance] + + // AcquireBuffer allows you to override the implementation of the virtual method acquire_buffer. + // The function takes the following parameters: + // + // - params *BufferPoolAcquireParams (nullable): parameters. + // + // The function returns the following values: + // + // - buffer *Buffer (nullable): a location for a #GstBuffer + // - goret FlowReturn + AcquireBuffer func(Instance, *BufferPoolAcquireParams) (*Buffer, FlowReturn) + // AllocBuffer allows you to override the implementation of the virtual method alloc_buffer. + // The function takes the following parameters: + // + // - params *BufferPoolAcquireParams (nullable): parameters. + // + // The function returns the following values: + // + // - buffer *Buffer (nullable): a location for a #GstBuffer + // - goret FlowReturn + AllocBuffer func(Instance, *BufferPoolAcquireParams) (*Buffer, FlowReturn) + // FlushStart allows you to override the implementation of the virtual method flush_start. + FlushStart func(Instance) + // FlushStop allows you to override the implementation of the virtual method flush_stop. + FlushStop func(Instance) + // FreeBuffer allows you to override the implementation of the virtual method free_buffer. + // The function takes the following parameters: + // + // - buffer *Buffer: the #GstBuffer to free + FreeBuffer func(Instance, *Buffer) + // GetOptions allows you to override the implementation of the virtual method get_options. + // The function returns the following values: + // + // - goret []string + GetOptions func(Instance) []string + // ReleaseBuffer allows you to override the implementation of the virtual method release_buffer. + // The function takes the following parameters: + // + // - buffer *Buffer: a #GstBuffer + ReleaseBuffer func(Instance, *Buffer) + // ResetBuffer allows you to override the implementation of the virtual method reset_buffer. + // The function takes the following parameters: + // + // - buffer *Buffer: the #GstBuffer to reset + ResetBuffer func(Instance, *Buffer) + // SetConfig allows you to override the implementation of the virtual method set_config. + // The function takes the following parameters: + // + // - config *Structure: a #GstStructure + // + // The function returns the following values: + // + // - goret bool + SetConfig func(Instance, *Structure) bool + // Start allows you to override the implementation of the virtual method start. + // The function returns the following values: + // + // - goret bool + Start func(Instance) bool + // Stop allows you to override the implementation of the virtual method stop. + // The function returns the following values: + // + // - goret bool + Stop func(Instance) bool +} + +// UnsafeApplyBufferPoolOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyBufferPoolOverrides[Instance BufferPool](gclass unsafe.Pointer, overrides BufferPoolOverrides[Instance]) { + UnsafeApplyObjectOverrides(gclass, overrides.ObjectOverrides) + + pclass := (*C.GstBufferPoolClass)(gclass) + + if overrides.AcquireBuffer != nil { + pclass.acquire_buffer = (*[0]byte)(C._gotk4_gst1_BufferPool_acquire_buffer) + } + + if overrides.AllocBuffer != nil { + pclass.alloc_buffer = (*[0]byte)(C._gotk4_gst1_BufferPool_alloc_buffer) + } + + if overrides.FlushStart != nil { + pclass.flush_start = (*[0]byte)(C._gotk4_gst1_BufferPool_flush_start) + } + + if overrides.FlushStop != nil { + pclass.flush_stop = (*[0]byte)(C._gotk4_gst1_BufferPool_flush_stop) + } + + if overrides.FreeBuffer != nil { + pclass.free_buffer = (*[0]byte)(C._gotk4_gst1_BufferPool_free_buffer) + } + + if overrides.GetOptions != nil { + pclass.get_options = (*[0]byte)(C._gotk4_gst1_BufferPool_get_options) + } + + if overrides.ReleaseBuffer != nil { + pclass.release_buffer = (*[0]byte)(C._gotk4_gst1_BufferPool_release_buffer) + } + + if overrides.ResetBuffer != nil { + pclass.reset_buffer = (*[0]byte)(C._gotk4_gst1_BufferPool_reset_buffer) + } + + if overrides.SetConfig != nil { + pclass.set_config = (*[0]byte)(C._gotk4_gst1_BufferPool_set_config) + } + + if overrides.Start != nil { + pclass.start = (*[0]byte)(C._gotk4_gst1_BufferPool_start) + } + + if overrides.Stop != nil { + pclass.stop = (*[0]byte)(C._gotk4_gst1_BufferPool_stop) + } +} + // BusInstance is the instance type used by all types extending GstBus. It is used internally by the bindings. Users should use the interface [Bus] instead. type BusInstance struct { _ [0]func() // equal guard @@ -23304,6 +24377,7 @@ type Bus interface { // @bus using gst_object_unref() after setting the bus watch. AddWatchFull(int, BusFunc) uint // CreateWatch wraps gst_bus_create_watch + // // The function returns the following values: // // - goret *glib.Source (nullable) @@ -23346,6 +24420,7 @@ type Bus interface { // signal is marshalled to the main thread via the #GMainLoop. EnableSyncMessageEmission() // GetPollfd wraps gst_bus_get_pollfd + // // The function returns the following values: // // - fd glib.PollFD: A GPollFD to fill @@ -23360,6 +24435,7 @@ type Bus interface { // GstBus API, e.g. gst_bus_pop(). GetPollfd() glib.PollFD // HavePending wraps gst_bus_have_pending + // // The function returns the following values: // // - goret bool @@ -23368,6 +24444,7 @@ type Bus interface { // should be handled. HavePending() bool // Peek wraps gst_bus_peek + // // The function returns the following values: // // - goret *Message (nullable) @@ -23423,6 +24500,7 @@ type Bus interface { // from there. Poll(MessageType, ClockTime) *Message // Pop wraps gst_bus_pop + // // The function returns the following values: // // - goret *Message (nullable) @@ -23463,6 +24541,7 @@ type Bus interface { // Removes a signal watch previously added with gst_bus_add_signal_watch(). RemoveSignalWatch() // RemoveWatch wraps gst_bus_remove_watch + // // The function returns the following values: // // - goret bool @@ -23585,6 +24664,7 @@ func UnsafeBusToGlibFull(c Bus) unsafe.Pointer { } // NewBus wraps gst_bus_new +// // The function returns the following values: // // - goret Bus @@ -23717,6 +24797,7 @@ func (bus *BusInstance) AddWatchFull(priority int, fn BusFunc) uint { } // CreateWatch wraps gst_bus_create_watch +// // The function returns the following values: // // - goret *glib.Source (nullable) @@ -23792,6 +24873,7 @@ func (bus *BusInstance) EnableSyncMessageEmission() { } // GetPollfd wraps gst_bus_get_pollfd +// // The function returns the following values: // // - fd glib.PollFD: A GPollFD to fill @@ -23823,6 +24905,7 @@ func (bus *BusInstance) GetPollfd() glib.PollFD { } // HavePending wraps gst_bus_have_pending +// // The function returns the following values: // // - goret bool @@ -23848,6 +24931,7 @@ func (bus *BusInstance) HavePending() bool { } // Peek wraps gst_bus_peek +// // The function returns the following values: // // - goret *Message (nullable) @@ -23943,6 +25027,7 @@ func (bus *BusInstance) Poll(events MessageType, timeout ClockTime) *Message { } // Pop wraps gst_bus_pop +// // The function returns the following values: // // - goret *Message (nullable) @@ -24048,6 +25133,7 @@ func (bus *BusInstance) RemoveSignalWatch() { } // RemoveWatch wraps gst_bus_remove_watch +// // The function returns the following values: // // - goret bool @@ -24213,6 +25299,7 @@ func (bus *BusInstance) TimedPopFiltered(timeout ClockTime, types MessageType) * func (o *BusInstance) ConnectMessage(fn func(Bus, Message)) gobject.SignalHandle { return o.Connect("message", fn) } + // ConnectSyncMessage connects the provided callback to the "sync-message" signal // // A message has been posted on the bus. This signal is emitted from the @@ -24223,6 +25310,41 @@ func (o *BusInstance) ConnectMessage(fn func(Bus, Message)) gobject.SignalHandle func (o *BusInstance) ConnectSyncMessage(fn func(Bus, Message)) gobject.SignalHandle { return o.Connect("sync-message", fn) } + +// BusOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type BusOverrides[Instance Bus] struct { + // ObjectOverrides allows you to override virtual methods from the parent class Object + ObjectOverrides[Instance] + + // Message allows you to override the implementation of the virtual method message. + // The function takes the following parameters: + // + // - message *Message: the message that has been posted asynchronously + Message func(Instance, *Message) + // SyncMessage allows you to override the implementation of the virtual method sync_message. + // The function takes the following parameters: + // + // - message *Message: the message that has been posted synchronously + SyncMessage func(Instance, *Message) +} + +// UnsafeApplyBusOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyBusOverrides[Instance Bus](gclass unsafe.Pointer, overrides BusOverrides[Instance]) { + UnsafeApplyObjectOverrides(gclass, overrides.ObjectOverrides) + + pclass := (*C.GstBusClass)(gclass) + + if overrides.Message != nil { + pclass.message = (*[0]byte)(C._gotk4_gst1_Bus_message) + } + + if overrides.SyncMessage != nil { + pclass.sync_message = (*[0]byte)(C._gotk4_gst1_Bus_sync_message) + } +} + // ClockInstance is the instance type used by all types extending GstClock. It is used internally by the bindings. Users should use the interface [Clock] instead. type ClockInstance struct { _ [0]func() // equal guard @@ -24396,6 +25518,7 @@ type Clock interface { // Note: The @clock parameter is unused and can be NULL AdjustWithCalibration(ClockTime, ClockTime, ClockTime, ClockTime, ClockTime) ClockTime // GetCalibration wraps gst_clock_get_calibration + // // The function returns the following values: // // - internal ClockTime: a location to store the internal time @@ -24410,6 +25533,7 @@ type Clock interface { // caller is not interested in the values. GetCalibration() (ClockTime, ClockTime, ClockTime, ClockTime) // GetInternalTime wraps gst_clock_get_internal_time + // // The function returns the following values: // // - goret ClockTime @@ -24418,6 +25542,7 @@ type Clock interface { // unadjusted for the offset and the rate. GetInternalTime() ClockTime // GetMaster wraps gst_clock_get_master + // // The function returns the following values: // // - goret Clock (nullable) @@ -24426,6 +25551,7 @@ type Clock interface { // not slaved to any master clock. GetMaster() Clock // GetResolution wraps gst_clock_get_resolution + // // The function returns the following values: // // - goret ClockTime @@ -24434,6 +25560,7 @@ type Clock interface { // of the values returned by gst_clock_get_time(). GetResolution() ClockTime // GetTime wraps gst_clock_get_time + // // The function returns the following values: // // - goret ClockTime @@ -24443,6 +25570,7 @@ type Clock interface { // offset and rate. GetTime() ClockTime // GetTimeout wraps gst_clock_get_timeout + // // The function returns the following values: // // - goret ClockTime @@ -24450,6 +25578,7 @@ type Clock interface { // Gets the amount of time that master and slave clocks are sampled. GetTimeout() ClockTime // IsSynced wraps gst_clock_is_synced + // // The function returns the following values: // // - goret bool @@ -25187,6 +26316,7 @@ func (clock *ClockInstance) AdjustWithCalibration(internalTarget ClockTime, cint } // GetCalibration wraps gst_clock_get_calibration +// // The function returns the following values: // // - internal ClockTime: a location to store the internal time @@ -25225,6 +26355,7 @@ func (clock *ClockInstance) GetCalibration() (ClockTime, ClockTime, ClockTime, C } // GetInternalTime wraps gst_clock_get_internal_time +// // The function returns the following values: // // - goret ClockTime @@ -25248,6 +26379,7 @@ func (clock *ClockInstance) GetInternalTime() ClockTime { } // GetMaster wraps gst_clock_get_master +// // The function returns the following values: // // - goret Clock (nullable) @@ -25273,6 +26405,7 @@ func (clock *ClockInstance) GetMaster() Clock { } // GetResolution wraps gst_clock_get_resolution +// // The function returns the following values: // // - goret ClockTime @@ -25296,6 +26429,7 @@ func (clock *ClockInstance) GetResolution() ClockTime { } // GetTime wraps gst_clock_get_time +// // The function returns the following values: // // - goret ClockTime @@ -25320,6 +26454,7 @@ func (clock *ClockInstance) GetTime() ClockTime { } // GetTimeout wraps gst_clock_get_timeout +// // The function returns the following values: // // - goret ClockTime @@ -25342,6 +26477,7 @@ func (clock *ClockInstance) GetTimeout() ClockTime { } // IsSynced wraps gst_clock_is_synced +// // The function returns the following values: // // - goret bool @@ -25822,6 +26958,91 @@ func (clock *ClockInstance) WaitForSync(timeout ClockTime) bool { func (o *ClockInstance) ConnectSynced(fn func(Clock, bool)) gobject.SignalHandle { return o.Connect("synced", fn) } + +// ClockOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type ClockOverrides[Instance Clock] struct { + // ObjectOverrides allows you to override virtual methods from the parent class Object + ObjectOverrides[Instance] + + // ChangeResolution allows you to override the implementation of the virtual method change_resolution. + // The function takes the following parameters: + // + // - oldResolution ClockTime: the previous resolution + // - newResolution ClockTime: the new resolution + // + // The function returns the following values: + // + // - goret ClockTime + ChangeResolution func(Instance, ClockTime, ClockTime) ClockTime + // GetInternalTime allows you to override the implementation of the virtual method get_internal_time. + // The function returns the following values: + // + // - goret ClockTime + GetInternalTime func(Instance) ClockTime + // GetResolution allows you to override the implementation of the virtual method get_resolution. + // The function returns the following values: + // + // - goret ClockTime + GetResolution func(Instance) ClockTime + // Unschedule allows you to override the implementation of the virtual method unschedule. + // The function takes the following parameters: + // + // - entry *ClockEntry: the entry to unschedule + Unschedule func(Instance, *ClockEntry) + // Wait allows you to override the implementation of the virtual method wait. + // The function takes the following parameters: + // + // - entry *ClockEntry: the entry to wait on + // + // The function returns the following values: + // + // - jitter ClockTimeDiff: a pointer that will contain the jitter + // - goret ClockReturn + Wait func(Instance, *ClockEntry) (ClockTimeDiff, ClockReturn) + // WaitAsync allows you to override the implementation of the virtual method wait_async. + // The function takes the following parameters: + // + // - entry *ClockEntry: the entry to wait on + // + // The function returns the following values: + // + // - goret ClockReturn + WaitAsync func(Instance, *ClockEntry) ClockReturn +} + +// UnsafeApplyClockOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyClockOverrides[Instance Clock](gclass unsafe.Pointer, overrides ClockOverrides[Instance]) { + UnsafeApplyObjectOverrides(gclass, overrides.ObjectOverrides) + + pclass := (*C.GstClockClass)(gclass) + + if overrides.ChangeResolution != nil { + pclass.change_resolution = (*[0]byte)(C._gotk4_gst1_Clock_change_resolution) + } + + if overrides.GetInternalTime != nil { + pclass.get_internal_time = (*[0]byte)(C._gotk4_gst1_Clock_get_internal_time) + } + + if overrides.GetResolution != nil { + pclass.get_resolution = (*[0]byte)(C._gotk4_gst1_Clock_get_resolution) + } + + if overrides.Unschedule != nil { + pclass.unschedule = (*[0]byte)(C._gotk4_gst1_Clock_unschedule) + } + + if overrides.Wait != nil { + pclass.wait = (*[0]byte)(C._gotk4_gst1_Clock_wait) + } + + if overrides.WaitAsync != nil { + pclass.wait_async = (*[0]byte)(C._gotk4_gst1_Clock_wait_async) + } +} + // ControlBindingInstance is the instance type used by all types extending GstControlBinding. It is used internally by the bindings. Users should use the interface [ControlBinding] instead. type ControlBindingInstance struct { _ [0]func() // equal guard @@ -25841,6 +27062,7 @@ type ControlBinding interface { upcastToGstControlBinding() *ControlBindingInstance // IsDisabled wraps gst_control_binding_is_disabled + // // The function returns the following values: // // - goret bool @@ -25916,6 +27138,7 @@ func UnsafeControlBindingToGlibFull(c ControlBinding) unsafe.Pointer { } // IsDisabled wraps gst_control_binding_is_disabled +// // The function returns the following values: // // - goret bool @@ -26006,6 +27229,37 @@ func (binding *ControlBindingInstance) SyncControlBindingValues(object Object, t return goret } +// ControlBindingOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type ControlBindingOverrides[Instance ControlBinding] struct { + // ObjectOverrides allows you to override virtual methods from the parent class Object + ObjectOverrides[Instance] + + // SyncValues allows you to override the implementation of the virtual method sync_values. + // The function takes the following parameters: + // + // - object Object: the object that has controlled properties + // - timestamp ClockTime: the time that should be processed + // - lastSync ClockTime: the last time this was called + // + // The function returns the following values: + // + // - goret bool + SyncValues func(Instance, Object, ClockTime, ClockTime) bool +} + +// UnsafeApplyControlBindingOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyControlBindingOverrides[Instance ControlBinding](gclass unsafe.Pointer, overrides ControlBindingOverrides[Instance]) { + UnsafeApplyObjectOverrides(gclass, overrides.ObjectOverrides) + + pclass := (*C.GstControlBindingClass)(gclass) + + if overrides.SyncValues != nil { + pclass.sync_values = (*[0]byte)(C._gotk4_gst1_ControlBinding_sync_values) + } +} + // ControlSourceInstance is the instance type used by all types extending GstControlSource. It is used internally by the bindings. Users should use the interface [ControlSource] instead. type ControlSourceInstance struct { _ [0]func() // equal guard @@ -26182,6 +27436,20 @@ func (self *ControlSourceInstance) ControlSourceGetValueArray(timestamp ClockTim return goret } +// ControlSourceOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type ControlSourceOverrides[Instance ControlSource] struct { + // ObjectOverrides allows you to override virtual methods from the parent class Object + ObjectOverrides[Instance] + +} + +// UnsafeApplyControlSourceOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyControlSourceOverrides[Instance ControlSource](gclass unsafe.Pointer, overrides ControlSourceOverrides[Instance]) { + UnsafeApplyObjectOverrides(gclass, overrides.ObjectOverrides) +} + // DeviceInstance is the instance type used by all types extending GstDevice. It is used internally by the bindings. Users should use the interface [Device] instead. type DeviceInstance struct { _ [0]func() // equal guard @@ -26217,6 +27485,7 @@ type Device interface { // this device. CreateElement(string) Element // GetCaps wraps gst_device_get_caps + // // The function returns the following values: // // - goret *Caps (nullable) @@ -26224,6 +27493,7 @@ type Device interface { // Getter for the #GstCaps that this device supports. GetCaps() *Caps // GetDeviceClass wraps gst_device_get_device_class + // // The function returns the following values: // // - goret string @@ -26233,6 +27503,7 @@ type Device interface { // classes of the #GstDeviceProvider that produced this device. GetDeviceClass() string // GetDisplayName wraps gst_device_get_display_name + // // The function returns the following values: // // - goret string @@ -26240,6 +27511,7 @@ type Device interface { // Gets the user-friendly name of the device. GetDisplayName() string // GetProperties wraps gst_device_get_properties + // // The function returns the following values: // // - goret *Structure (nullable) @@ -26369,6 +27641,7 @@ func (device *DeviceInstance) CreateElement(name string) Element { } // GetCaps wraps gst_device_get_caps +// // The function returns the following values: // // - goret *Caps (nullable) @@ -26393,6 +27666,7 @@ func (device *DeviceInstance) GetCaps() *Caps { } // GetDeviceClass wraps gst_device_get_device_class +// // The function returns the following values: // // - goret string @@ -26418,6 +27692,7 @@ func (device *DeviceInstance) GetDeviceClass() string { } // GetDisplayName wraps gst_device_get_display_name +// // The function returns the following values: // // - goret string @@ -26441,6 +27716,7 @@ func (device *DeviceInstance) GetDisplayName() string { } // GetProperties wraps gst_device_get_properties +// // The function returns the following values: // // - goret *Structure (nullable) @@ -26574,6 +27850,50 @@ func (device *DeviceInstance) ReconfigureElement(element Element) bool { func (o *DeviceInstance) ConnectRemoved(fn func(Device)) gobject.SignalHandle { return o.Connect("removed", fn) } + +// DeviceOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type DeviceOverrides[Instance Device] struct { + // ObjectOverrides allows you to override virtual methods from the parent class Object + ObjectOverrides[Instance] + + // CreateElement allows you to override the implementation of the virtual method create_element. + // The function takes the following parameters: + // + // - name string (nullable): name of new element, or %NULL to automatically + // create a unique name. + // + // The function returns the following values: + // + // - goret Element (nullable) + CreateElement func(Instance, string) Element + // ReconfigureElement allows you to override the implementation of the virtual method reconfigure_element. + // The function takes the following parameters: + // + // - element Element: a #GstElement + // + // The function returns the following values: + // + // - goret bool + ReconfigureElement func(Instance, Element) bool +} + +// UnsafeApplyDeviceOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyDeviceOverrides[Instance Device](gclass unsafe.Pointer, overrides DeviceOverrides[Instance]) { + UnsafeApplyObjectOverrides(gclass, overrides.ObjectOverrides) + + pclass := (*C.GstDeviceClass)(gclass) + + if overrides.CreateElement != nil { + pclass.create_element = (*[0]byte)(C._gotk4_gst1_Device_create_element) + } + + if overrides.ReconfigureElement != nil { + pclass.reconfigure_element = (*[0]byte)(C._gotk4_gst1_Device_reconfigure_element) + } +} + // DeviceMonitorInstance is the instance type used by all types extending GstDeviceMonitor. It is used internally by the bindings. Users should use the interface [DeviceMonitor] instead. type DeviceMonitorInstance struct { _ [0]func() // equal guard @@ -26673,6 +27993,7 @@ type DeviceMonitor interface { // Filters must be added before the #GstDeviceMonitor is started. AddFilter(string, *Caps) uint // GetBus wraps gst_device_monitor_get_bus + // // The function returns the following values: // // - goret Bus @@ -26680,6 +28001,7 @@ type DeviceMonitor interface { // Gets the #GstBus of this #GstDeviceMonitor GetBus() Bus // GetDevices wraps gst_device_monitor_get_devices + // // The function returns the following values: // // - goret []Device (nullable) @@ -26688,6 +28010,7 @@ type DeviceMonitor interface { // probe the hardware if the monitor is not currently started. GetDevices() []Device // GetProviders wraps gst_device_monitor_get_providers + // // The function returns the following values: // // - goret []string @@ -26697,6 +28020,7 @@ type DeviceMonitor interface { // This GetProviders() []string // GetShowAllDevices wraps gst_device_monitor_get_show_all_devices + // // The function returns the following values: // // - goret bool @@ -26727,6 +28051,7 @@ type DeviceMonitor interface { // providers. Setting @show_all to true might show some devices multiple times. SetShowAllDevices(bool) // Start wraps gst_device_monitor_start + // // The function returns the following values: // // - goret bool @@ -26780,6 +28105,7 @@ func UnsafeDeviceMonitorToGlibFull(c DeviceMonitor) unsafe.Pointer { } // NewDeviceMonitor wraps gst_device_monitor_new +// // The function returns the following values: // // - goret DeviceMonitor @@ -26847,6 +28173,7 @@ func (monitor *DeviceMonitorInstance) AddFilter(classes string, caps *Caps) uint } // GetBus wraps gst_device_monitor_get_bus +// // The function returns the following values: // // - goret Bus @@ -26869,6 +28196,7 @@ func (monitor *DeviceMonitorInstance) GetBus() Bus { } // GetDevices wraps gst_device_monitor_get_devices +// // The function returns the following values: // // - goret []Device (nullable) @@ -26899,6 +28227,7 @@ func (monitor *DeviceMonitorInstance) GetDevices() []Device { } // GetProviders wraps gst_device_monitor_get_providers +// // The function returns the following values: // // - goret []string @@ -26925,6 +28254,7 @@ func (monitor *DeviceMonitorInstance) GetProviders() []string { } // GetShowAllDevices wraps gst_device_monitor_get_show_all_devices +// // The function returns the following values: // // - goret bool @@ -27005,6 +28335,7 @@ func (monitor *DeviceMonitorInstance) SetShowAllDevices(showAll bool) { } // Start wraps gst_device_monitor_start +// // The function returns the following values: // // - goret bool @@ -27042,6 +28373,20 @@ func (monitor *DeviceMonitorInstance) Stop() { runtime.KeepAlive(monitor) } +// DeviceMonitorOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type DeviceMonitorOverrides[Instance DeviceMonitor] struct { + // ObjectOverrides allows you to override virtual methods from the parent class Object + ObjectOverrides[Instance] + +} + +// UnsafeApplyDeviceMonitorOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyDeviceMonitorOverrides[Instance DeviceMonitor](gclass unsafe.Pointer, overrides DeviceMonitorOverrides[Instance]) { + UnsafeApplyObjectOverrides(gclass, overrides.ObjectOverrides) +} + // DeviceProviderInstance is the instance type used by all types extending GstDeviceProvider. It is used internally by the bindings. Users should use the interface [DeviceProvider] instead. type DeviceProviderInstance struct { _ [0]func() // equal guard @@ -27066,6 +28411,7 @@ type DeviceProvider interface { upcastToGstDeviceProvider() *DeviceProviderInstance // CanMonitor wraps gst_device_provider_can_monitor + // // The function returns the following values: // // - goret bool @@ -27109,6 +28455,7 @@ type DeviceProvider interface { // This is for use by subclasses. DeviceRemove(Device) // GetBus wraps gst_device_provider_get_bus + // // The function returns the following values: // // - goret Bus @@ -27116,6 +28463,7 @@ type DeviceProvider interface { // Gets the #GstBus of this #GstDeviceProvider GetBus() Bus // GetDevices wraps gst_device_provider_get_devices + // // The function returns the following values: // // - goret []Device @@ -27127,6 +28475,7 @@ type DeviceProvider interface { // objedcts that have been returned by the #GST_MESSAGE_DEVICE_ADDED messages. GetDevices() []Device // GetFactory wraps gst_device_provider_get_factory + // // The function returns the following values: // // - goret DeviceProviderFactory (nullable) @@ -27134,6 +28483,7 @@ type DeviceProvider interface { // Retrieves the factory that was used to create this device provider. GetFactory() DeviceProviderFactory // GetHiddenProviders wraps gst_device_provider_get_hidden_providers + // // The function returns the following values: // // - goret []string @@ -27166,6 +28516,7 @@ type DeviceProvider interface { // device provider with @name to avoid duplicate devices. HideProvider(string) // IsStarted wraps gst_device_provider_is_started + // // The function returns the following values: // // - goret bool @@ -27173,6 +28524,7 @@ type DeviceProvider interface { // This function can be used to know if the @provider was successfully started. IsStarted() bool // Start wraps gst_device_provider_start + // // The function returns the following values: // // - goret bool @@ -27300,6 +28652,7 @@ func DeviceProviderRegister(plugin Plugin, name string, rank uint, typ gobject.T } // CanMonitor wraps gst_device_provider_can_monitor +// // The function returns the following values: // // - goret bool @@ -27396,6 +28749,7 @@ func (provider *DeviceProviderInstance) DeviceRemove(device Device) { } // GetBus wraps gst_device_provider_get_bus +// // The function returns the following values: // // - goret Bus @@ -27418,6 +28772,7 @@ func (provider *DeviceProviderInstance) GetBus() Bus { } // GetDevices wraps gst_device_provider_get_devices +// // The function returns the following values: // // - goret []Device @@ -27451,6 +28806,7 @@ func (provider *DeviceProviderInstance) GetDevices() []Device { } // GetFactory wraps gst_device_provider_get_factory +// // The function returns the following values: // // - goret DeviceProviderFactory (nullable) @@ -27475,6 +28831,7 @@ func (provider *DeviceProviderInstance) GetFactory() DeviceProviderFactory { } // GetHiddenProviders wraps gst_device_provider_get_hidden_providers +// // The function returns the following values: // // - goret []string @@ -27555,6 +28912,7 @@ func (provider *DeviceProviderInstance) HideProvider(name string) { } // IsStarted wraps gst_device_provider_is_started +// // The function returns the following values: // // - goret bool @@ -27579,6 +28937,7 @@ func (provider *DeviceProviderInstance) IsStarted() bool { } // Start wraps gst_device_provider_start +// // The function returns the following values: // // - goret bool @@ -27656,10 +29015,43 @@ func (provider *DeviceProviderInstance) UnhideProvider(name string) { func (o *DeviceProviderInstance) ConnectProviderHidden(fn func(DeviceProvider, string)) gobject.SignalHandle { return o.Connect("provider-hidden", fn) } + // ConnectProviderUnhidden connects the provided callback to the "provider-unhidden" signal func (o *DeviceProviderInstance) ConnectProviderUnhidden(fn func(DeviceProvider, string)) gobject.SignalHandle { return o.Connect("provider-unhidden", fn) } + +// DeviceProviderOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type DeviceProviderOverrides[Instance DeviceProvider] struct { + // ObjectOverrides allows you to override virtual methods from the parent class Object + ObjectOverrides[Instance] + + // Start allows you to override the implementation of the virtual method start. + // The function returns the following values: + // + // - goret bool + Start func(Instance) bool + // Stop allows you to override the implementation of the virtual method stop. + Stop func(Instance) +} + +// UnsafeApplyDeviceProviderOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyDeviceProviderOverrides[Instance DeviceProvider](gclass unsafe.Pointer, overrides DeviceProviderOverrides[Instance]) { + UnsafeApplyObjectOverrides(gclass, overrides.ObjectOverrides) + + pclass := (*C.GstDeviceProviderClass)(gclass) + + if overrides.Start != nil { + pclass.start = (*[0]byte)(C._gotk4_gst1_DeviceProvider_start) + } + + if overrides.Stop != nil { + pclass.stop = (*[0]byte)(C._gotk4_gst1_DeviceProvider_stop) + } +} + // DeviceProviderFactoryInstance is the instance type used by all types extending GstDeviceProviderFactory. It is used internally by the bindings. Users should use the interface [DeviceProviderFactory] instead. type DeviceProviderFactoryInstance struct { _ [0]func() // equal guard @@ -27683,6 +29075,7 @@ type DeviceProviderFactory interface { upcastToGstDeviceProviderFactory() *DeviceProviderFactoryInstance // Get wraps gst_device_provider_factory_get + // // The function returns the following values: // // - goret DeviceProvider (nullable) @@ -27691,6 +29084,7 @@ type DeviceProviderFactory interface { // providerfactory. Get() DeviceProvider // GetDeviceProviderType wraps gst_device_provider_factory_get_device_provider_type + // // The function returns the following values: // // - goret gobject.Type @@ -27712,6 +29106,7 @@ type DeviceProviderFactory interface { // Get the metadata on @factory with @key. GetMetadata(string) string // GetMetadataKeys wraps gst_device_provider_factory_get_metadata_keys + // // The function returns the following values: // // - goret []string (nullable) @@ -27884,6 +29279,7 @@ func DeviceProviderFactoryListGetDeviceProviders(minrank Rank) []DeviceProviderF } // Get wraps gst_device_provider_factory_get +// // The function returns the following values: // // - goret DeviceProvider (nullable) @@ -27909,6 +29305,7 @@ func (factory *DeviceProviderFactoryInstance) Get() DeviceProvider { } // GetDeviceProviderType wraps gst_device_provider_factory_get_device_provider_type +// // The function returns the following values: // // - goret gobject.Type @@ -27966,6 +29363,7 @@ func (factory *DeviceProviderFactoryInstance) GetMetadata(key string) string { } // GetMetadataKeys wraps gst_device_provider_factory_get_metadata_keys +// // The function returns the following values: // // - goret []string (nullable) @@ -28416,6 +29814,7 @@ type Element interface { // into account until next time this function is used. ForEachSrcPad(ElementForEachPadFunc) bool // GetBaseTime wraps gst_element_get_base_time + // // The function returns the following values: // // - goret ClockTime @@ -28426,6 +29825,7 @@ type Element interface { // the running time of the element. GetBaseTime() ClockTime // GetBus wraps gst_element_get_bus + // // The function returns the following values: // // - goret Bus (nullable) @@ -28434,6 +29834,7 @@ type Element interface { // bus for the application. GetBus() Bus // GetClock wraps gst_element_get_clock + // // The function returns the following values: // // - goret Clock (nullable) @@ -28504,6 +29905,7 @@ type Element interface { // Gets the context with @context_type set on the element or NULL. GetContextUnlocked(string) *Context // GetContexts wraps gst_element_get_contexts + // // The function returns the following values: // // - goret []*Context @@ -28513,6 +29915,7 @@ type Element interface { // MT safe. GetContexts() []*Context // GetCurrentClockTime wraps gst_element_get_current_clock_time + // // The function returns the following values: // // - goret ClockTime @@ -28521,6 +29924,7 @@ type Element interface { // element's clock, or GST_CLOCK_TIME_NONE if there is no clock. GetCurrentClockTime() ClockTime // GetCurrentRunningTime wraps gst_element_get_current_running_time + // // The function returns the following values: // // - goret ClockTime @@ -28530,6 +29934,7 @@ type Element interface { // if the element has no clock, or if its base time has not been set. GetCurrentRunningTime() ClockTime // GetFactory wraps gst_element_get_factory + // // The function returns the following values: // // - goret ElementFactory (nullable) @@ -28561,6 +29966,7 @@ type Element interface { // Retrieves a padtemplate from @element with the given name. GetPadTemplate(string) PadTemplate // GetPadTemplateList wraps gst_element_get_pad_template_list + // // The function returns the following values: // // - goret []PadTemplate @@ -28586,6 +29992,7 @@ type Element interface { // provides the exact same functionality. GetRequestPad(string) Pad // GetStartTime wraps gst_element_get_start_time + // // The function returns the following values: // // - goret ClockTime @@ -28648,6 +30055,7 @@ type Element interface { // already-existing (i.e. 'static') pads. GetStaticPad(string) Pad // IsLockedState wraps gst_element_is_locked_state + // // The function returns the following values: // // - goret bool @@ -28661,6 +30069,7 @@ type Element interface { // MT safe. IsLockedState() bool // IteratePads wraps gst_element_iterate_pads + // // The function returns the following values: // // - goret *Iterator @@ -28673,6 +30082,7 @@ type Element interface { // the pads were added to the element. IteratePads() *Iterator // IterateSinkPads wraps gst_element_iterate_sink_pads + // // The function returns the following values: // // - goret *Iterator @@ -28683,6 +30093,7 @@ type Element interface { // the pads were added to the element. IterateSinkPads() *Iterator // IterateSrcPads wraps gst_element_iterate_src_pads + // // The function returns the following values: // // - goret *Iterator @@ -28891,6 +30302,7 @@ type Element interface { // additional reference before calling. PostMessage(*Message) bool // ProvidedClock wraps gst_element_provide_clock + // // The function returns the following values: // // - goret Clock (nullable) @@ -29245,6 +30657,7 @@ type Element interface { // #GST_STATE_CHANGE_ASYNC. SetState(State) StateChangeReturn // SyncStateWithParent wraps gst_element_sync_state_with_parent + // // The function returns the following values: // // - goret bool @@ -29931,6 +31344,7 @@ func (element *ElementInstance) ForEachSrcPad(fn ElementForEachPadFunc) bool { } // GetBaseTime wraps gst_element_get_base_time +// // The function returns the following values: // // - goret ClockTime @@ -29956,6 +31370,7 @@ func (element *ElementInstance) GetBaseTime() ClockTime { } // GetBus wraps gst_element_get_bus +// // The function returns the following values: // // - goret Bus (nullable) @@ -29981,6 +31396,7 @@ func (element *ElementInstance) GetBus() Bus { } // GetClock wraps gst_element_get_clock +// // The function returns the following values: // // - goret Clock (nullable) @@ -30155,6 +31571,7 @@ func (element *ElementInstance) GetContextUnlocked(contextType string) *Context } // GetContexts wraps gst_element_get_contexts +// // The function returns the following values: // // - goret []*Context @@ -30186,6 +31603,7 @@ func (element *ElementInstance) GetContexts() []*Context { } // GetCurrentClockTime wraps gst_element_get_current_clock_time +// // The function returns the following values: // // - goret ClockTime @@ -30209,6 +31627,7 @@ func (element *ElementInstance) GetCurrentClockTime() ClockTime { } // GetCurrentRunningTime wraps gst_element_get_current_running_time +// // The function returns the following values: // // - goret ClockTime @@ -30233,6 +31652,7 @@ func (element *ElementInstance) GetCurrentRunningTime() ClockTime { } // GetFactory wraps gst_element_get_factory +// // The function returns the following values: // // - goret ElementFactory (nullable) @@ -30321,6 +31741,7 @@ func (element *ElementInstance) GetPadTemplate(name string) PadTemplate { } // GetPadTemplateList wraps gst_element_get_pad_template_list +// // The function returns the following values: // // - goret []PadTemplate @@ -30389,6 +31810,7 @@ func (element *ElementInstance) GetRequestPad(name string) Pad { } // GetStartTime wraps gst_element_get_start_time +// // The function returns the following values: // // - goret ClockTime @@ -30511,6 +31933,7 @@ func (element *ElementInstance) GetStaticPad(name string) Pad { } // IsLockedState wraps gst_element_is_locked_state +// // The function returns the following values: // // - goret bool @@ -30541,6 +31964,7 @@ func (element *ElementInstance) IsLockedState() bool { } // IteratePads wraps gst_element_iterate_pads +// // The function returns the following values: // // - goret *Iterator @@ -30568,6 +31992,7 @@ func (element *ElementInstance) IteratePads() *Iterator { } // IterateSinkPads wraps gst_element_iterate_sink_pads +// // The function returns the following values: // // - goret *Iterator @@ -30593,6 +32018,7 @@ func (element *ElementInstance) IterateSinkPads() *Iterator { } // IterateSrcPads wraps gst_element_iterate_src_pads +// // The function returns the following values: // // - goret *Iterator @@ -31080,6 +32506,7 @@ func (element *ElementInstance) PostMessage(message *Message) bool { } // ProvidedClock wraps gst_element_provide_clock +// // The function returns the following values: // // - goret Clock (nullable) @@ -31832,6 +33259,7 @@ func (element *ElementInstance) SetState(state State) StateChangeReturn { } // SyncStateWithParent wraps gst_element_sync_state_with_parent +// // The function returns the following values: // // - goret bool @@ -31918,6 +33346,7 @@ func (src *ElementInstance) UnlinkPads(srcpadname string, dest Element, destpadn func (o *ElementInstance) ConnectNoMorePads(fn func(Element)) gobject.SignalHandle { return o.Connect("no-more-pads", fn) } + // ConnectPadAdded connects the provided callback to the "pad-added" signal // // a new #GstPad has been added to the element. Note that this signal will @@ -31928,12 +33357,214 @@ func (o *ElementInstance) ConnectNoMorePads(fn func(Element)) gobject.SignalHand func (o *ElementInstance) ConnectPadAdded(fn func(Element, Pad)) gobject.SignalHandle { return o.Connect("pad-added", fn) } + // ConnectPadRemoved connects the provided callback to the "pad-removed" signal // // a #GstPad has been removed from the element func (o *ElementInstance) ConnectPadRemoved(fn func(Element, Pad)) gobject.SignalHandle { return o.Connect("pad-removed", fn) } + +// ElementOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type ElementOverrides[Instance Element] struct { + // ObjectOverrides allows you to override virtual methods from the parent class Object + ObjectOverrides[Instance] + + // ChangeState allows you to override the implementation of the virtual method change_state. + // The function takes the following parameters: + // + // - transition StateChange: the requested transition + // + // The function returns the following values: + // + // - goret StateChangeReturn + ChangeState func(Instance, StateChange) StateChangeReturn + // GetState allows you to override the implementation of the virtual method get_state. + // The function takes the following parameters: + // + // - timeout ClockTime: a #GstClockTime to specify the timeout for an async + // state change or %GST_CLOCK_TIME_NONE for infinite timeout. + // + // The function returns the following values: + // + // - state State: a pointer to #GstState to hold the state. + // Can be %NULL. + // - pending State: a pointer to #GstState to hold the pending + // state. Can be %NULL. + // - goret StateChangeReturn + GetState func(Instance, ClockTime) (State, State, StateChangeReturn) + // NoMorePads allows you to override the implementation of the virtual method no_more_pads. + NoMorePads func(Instance) + // PadAdded allows you to override the implementation of the virtual method pad_added. + // The function takes the following parameters: + // + // - pad Pad + PadAdded func(Instance, Pad) + // PadRemoved allows you to override the implementation of the virtual method pad_removed. + // The function takes the following parameters: + // + // - pad Pad + PadRemoved func(Instance, Pad) + // PostMessage allows you to override the implementation of the virtual method post_message. + // The function takes the following parameters: + // + // - message *Message: a #GstMessage to post + // + // The function returns the following values: + // + // - goret bool + PostMessage func(Instance, *Message) bool + // ProvideClock allows you to override the implementation of the virtual method provide_clock. + // The function returns the following values: + // + // - goret Clock (nullable) + ProvideClock func(Instance) Clock + // Query allows you to override the implementation of the virtual method query. + // The function takes the following parameters: + // + // - query *Query: the #GstQuery. + // + // The function returns the following values: + // + // - goret bool + Query func(Instance, *Query) bool + // ReleasePad allows you to override the implementation of the virtual method release_pad. + // The function takes the following parameters: + // + // - pad Pad + ReleasePad func(Instance, Pad) + // RequestNewPad allows you to override the implementation of the virtual method request_new_pad. + // The function takes the following parameters: + // + // - templ PadTemplate: a #GstPadTemplate of which we want a pad of. + // - name string (nullable): the name of the request #GstPad + // to retrieve. Can be %NULL. + // - caps *Caps (nullable): the caps of the pad we want to + // request. Can be %NULL. + // + // The function returns the following values: + // + // - goret Pad (nullable) + RequestNewPad func(Instance, PadTemplate, string, *Caps) Pad + // SendEvent allows you to override the implementation of the virtual method send_event. + // The function takes the following parameters: + // + // - event *Event: the #GstEvent to send to the element. + // + // The function returns the following values: + // + // - goret bool + SendEvent func(Instance, *Event) bool + // SetBus allows you to override the implementation of the virtual method set_bus. + // The function takes the following parameters: + // + // - bus Bus (nullable): the #GstBus to set. + SetBus func(Instance, Bus) + // SetClock allows you to override the implementation of the virtual method set_clock. + // The function takes the following parameters: + // + // - clock Clock (nullable): the #GstClock to set for the element. + // + // The function returns the following values: + // + // - goret bool + SetClock func(Instance, Clock) bool + // SetContext allows you to override the implementation of the virtual method set_context. + // The function takes the following parameters: + // + // - _context *Context: the #GstContext to set. + SetContext func(Instance, *Context) + // SetState allows you to override the implementation of the virtual method set_state. + // The function takes the following parameters: + // + // - state State: the element's new #GstState. + // + // The function returns the following values: + // + // - goret StateChangeReturn + SetState func(Instance, State) StateChangeReturn + // StateChanged allows you to override the implementation of the virtual method state_changed. + // The function takes the following parameters: + // + // - oldstate State + // - newstate State + // - pending State + StateChanged func(Instance, State, State, State) +} + +// UnsafeApplyElementOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyElementOverrides[Instance Element](gclass unsafe.Pointer, overrides ElementOverrides[Instance]) { + UnsafeApplyObjectOverrides(gclass, overrides.ObjectOverrides) + + pclass := (*C.GstElementClass)(gclass) + + if overrides.ChangeState != nil { + pclass.change_state = (*[0]byte)(C._gotk4_gst1_Element_change_state) + } + + if overrides.GetState != nil { + pclass.get_state = (*[0]byte)(C._gotk4_gst1_Element_get_state) + } + + if overrides.NoMorePads != nil { + pclass.no_more_pads = (*[0]byte)(C._gotk4_gst1_Element_no_more_pads) + } + + if overrides.PadAdded != nil { + pclass.pad_added = (*[0]byte)(C._gotk4_gst1_Element_pad_added) + } + + if overrides.PadRemoved != nil { + pclass.pad_removed = (*[0]byte)(C._gotk4_gst1_Element_pad_removed) + } + + if overrides.PostMessage != nil { + pclass.post_message = (*[0]byte)(C._gotk4_gst1_Element_post_message) + } + + if overrides.ProvideClock != nil { + pclass.provide_clock = (*[0]byte)(C._gotk4_gst1_Element_provide_clock) + } + + if overrides.Query != nil { + pclass.query = (*[0]byte)(C._gotk4_gst1_Element_query) + } + + if overrides.ReleasePad != nil { + pclass.release_pad = (*[0]byte)(C._gotk4_gst1_Element_release_pad) + } + + if overrides.RequestNewPad != nil { + pclass.request_new_pad = (*[0]byte)(C._gotk4_gst1_Element_request_new_pad) + } + + if overrides.SendEvent != nil { + pclass.send_event = (*[0]byte)(C._gotk4_gst1_Element_send_event) + } + + if overrides.SetBus != nil { + pclass.set_bus = (*[0]byte)(C._gotk4_gst1_Element_set_bus) + } + + if overrides.SetClock != nil { + pclass.set_clock = (*[0]byte)(C._gotk4_gst1_Element_set_clock) + } + + if overrides.SetContext != nil { + pclass.set_context = (*[0]byte)(C._gotk4_gst1_Element_set_context) + } + + if overrides.SetState != nil { + pclass.set_state = (*[0]byte)(C._gotk4_gst1_Element_set_state) + } + + if overrides.StateChanged != nil { + pclass.state_changed = (*[0]byte)(C._gotk4_gst1_Element_state_changed) + } +} + // ElementFactoryInstance is the instance type used by all types extending GstElementFactory. It is used internally by the bindings. Users should use the interface [ElementFactory] instead. type ElementFactoryInstance struct { _ [0]func() // equal guard @@ -32051,6 +33682,7 @@ type ElementFactory interface { // The supplied list of properties, will be passed at object construction. CreateWithProperties([]string, []gobject.Value) Element // GetElementType wraps gst_element_factory_get_element_type + // // The function returns the following values: // // - goret gobject.Type @@ -32072,6 +33704,7 @@ type ElementFactory interface { // Get the metadata on @factory with @key. GetMetadata(string) string // GetMetadataKeys wraps gst_element_factory_get_metadata_keys + // // The function returns the following values: // // - goret []string (nullable) @@ -32079,6 +33712,7 @@ type ElementFactory interface { // Get the available keys for the metadata on @factory. GetMetadataKeys() []string // GetNumPadTemplates wraps gst_element_factory_get_num_pad_templates + // // The function returns the following values: // // - goret uint @@ -32086,6 +33720,7 @@ type ElementFactory interface { // Gets the number of pad_templates in this factory. GetNumPadTemplates() uint // GetSkipDocumentation wraps gst_element_factory_get_skip_documentation + // // The function returns the following values: // // - goret bool @@ -32094,6 +33729,7 @@ type ElementFactory interface { // be excluded from documentation system or not. GetSkipDocumentation() bool // GetStaticPadTemplates wraps gst_element_factory_get_static_pad_templates + // // The function returns the following values: // // - goret []*StaticPadTemplate @@ -32101,6 +33737,7 @@ type ElementFactory interface { // Gets the #GList of #GstStaticPadTemplate for this factory. GetStaticPadTemplates() []*StaticPadTemplate // GetURIProtocols wraps gst_element_factory_get_uri_protocols + // // The function returns the following values: // // - goret []string @@ -32111,6 +33748,7 @@ type ElementFactory interface { // make a copy of the protocol string array if you need to. GetURIProtocols() []string // GetURIType wraps gst_element_factory_get_uri_type + // // The function returns the following values: // // - goret URIType @@ -32506,6 +34144,7 @@ func (factory *ElementFactoryInstance) CreateWithProperties(names []string, valu } // GetElementType wraps gst_element_factory_get_element_type +// // The function returns the following values: // // - goret gobject.Type @@ -32563,6 +34202,7 @@ func (factory *ElementFactoryInstance) GetMetadata(key string) string { } // GetMetadataKeys wraps gst_element_factory_get_metadata_keys +// // The function returns the following values: // // - goret []string (nullable) @@ -32587,6 +34227,7 @@ func (factory *ElementFactoryInstance) GetMetadataKeys() []string { } // GetNumPadTemplates wraps gst_element_factory_get_num_pad_templates +// // The function returns the following values: // // - goret uint @@ -32609,6 +34250,7 @@ func (factory *ElementFactoryInstance) GetNumPadTemplates() uint { } // GetSkipDocumentation wraps gst_element_factory_get_skip_documentation +// // The function returns the following values: // // - goret bool @@ -32634,6 +34276,7 @@ func (factory *ElementFactoryInstance) GetSkipDocumentation() bool { } // GetStaticPadTemplates wraps gst_element_factory_get_static_pad_templates +// // The function returns the following values: // // - goret []*StaticPadTemplate @@ -32663,6 +34306,7 @@ func (factory *ElementFactoryInstance) GetStaticPadTemplates() []*StaticPadTempl } // GetURIProtocols wraps gst_element_factory_get_uri_protocols +// // The function returns the following values: // // - goret []string @@ -32690,6 +34334,7 @@ func (factory *ElementFactoryInstance) GetURIProtocols() []string { } // GetURIType wraps gst_element_factory_get_uri_type +// // The function returns the following values: // // - goret URIType @@ -32804,6 +34449,7 @@ type GhostPad interface { upcastToGstGhostPad() *GhostPadInstance // Construct wraps gst_ghost_pad_construct + // // The function returns the following values: // // - goret bool @@ -32819,6 +34465,7 @@ type GhostPad interface { // anymore. Construct() bool // GetTarget wraps gst_ghost_pad_get_target + // // The function returns the following values: // // - goret Pad (nullable) @@ -33134,6 +34781,7 @@ func GhostPadInternalActivateModeDefault(pad Pad, parent Object, mode PadMode, a } // Construct wraps gst_ghost_pad_construct +// // The function returns the following values: // // - goret bool @@ -33166,6 +34814,7 @@ func (gpad *GhostPadInstance) Construct() bool { } // GetTarget wraps gst_ghost_pad_get_target +// // The function returns the following values: // // - goret Pad (nullable) @@ -33225,6 +34874,20 @@ func (gpad *GhostPadInstance) SetTarget(newtarget Pad) bool { return goret } +// GhostPadOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type GhostPadOverrides[Instance GhostPad] struct { + // ProxyPadOverrides allows you to override virtual methods from the parent class ProxyPad + ProxyPadOverrides[Instance] + +} + +// UnsafeApplyGhostPadOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyGhostPadOverrides[Instance GhostPad](gclass unsafe.Pointer, overrides GhostPadOverrides[Instance]) { + UnsafeApplyProxyPadOverrides(gclass, overrides.ProxyPadOverrides) +} + // SharedTaskPoolInstance is the instance type used by all types extending GstSharedTaskPool. It is used internally by the bindings. Users should use the interface [SharedTaskPool] instead. type SharedTaskPoolInstance struct { _ [0]func() // equal guard @@ -33241,6 +34904,7 @@ type SharedTaskPool interface { upcastToGstSharedTaskPool() *SharedTaskPoolInstance // GetMaxThreads wraps gst_shared_task_pool_get_max_threads + // // The function returns the following values: // // - goret uint @@ -33300,6 +34964,7 @@ func UnsafeSharedTaskPoolToGlibFull(c SharedTaskPool) unsafe.Pointer { } // NewSharedTaskPool wraps gst_shared_task_pool_new +// // The function returns the following values: // // - goret TaskPool @@ -33323,6 +34988,7 @@ func NewSharedTaskPool() TaskPool { } // GetMaxThreads wraps gst_shared_task_pool_get_max_threads +// // The function returns the following values: // // - goret uint @@ -33365,6 +35031,20 @@ func (pool *SharedTaskPoolInstance) SetMaxThreads(maxThreads uint) { runtime.KeepAlive(maxThreads) } +// SharedTaskPoolOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type SharedTaskPoolOverrides[Instance SharedTaskPool] struct { + // TaskPoolOverrides allows you to override virtual methods from the parent class TaskPool + TaskPoolOverrides[Instance] + +} + +// UnsafeApplySharedTaskPoolOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplySharedTaskPoolOverrides[Instance SharedTaskPool](gclass unsafe.Pointer, overrides SharedTaskPoolOverrides[Instance]) { + UnsafeApplyTaskPoolOverrides(gclass, overrides.TaskPoolOverrides) +} + // SystemClockInstance is the instance type used by all types extending GstSystemClock. It is used internally by the bindings. Users should use the interface [SystemClock] instead. type SystemClockInstance struct { _ [0]func() // equal guard @@ -33430,6 +35110,7 @@ func UnsafeSystemClockToGlibFull(c SystemClock) unsafe.Pointer { } // SystemClockObtain wraps gst_system_clock_obtain +// // The function returns the following values: // // - goret Clock @@ -33474,6 +35155,20 @@ func SystemClockSetDefault(newClock Clock) { runtime.KeepAlive(newClock) } +// SystemClockOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type SystemClockOverrides[Instance SystemClock] struct { + // ClockOverrides allows you to override virtual methods from the parent class Clock + ClockOverrides[Instance] + +} + +// UnsafeApplySystemClockOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplySystemClockOverrides[Instance SystemClock](gclass unsafe.Pointer, overrides SystemClockOverrides[Instance]) { + UnsafeApplyClockOverrides(gclass, overrides.ClockOverrides) +} + // BinInstance is the instance type used by all types extending GstBin. It is used internally by the bindings. Users should use the interface [Bin] instead. type BinInstance struct { _ [0]func() // equal guard @@ -33677,6 +35372,7 @@ type Bin interface { // element is not found, a recursion is performed on the parent bin. GetByNameRecurseUp(string) Element // GetSuppressedFlags wraps gst_bin_get_suppressed_flags + // // The function returns the following values: // // - goret ElementFlags @@ -33711,6 +35407,7 @@ type Bin interface { // of #GstElement. IterateAllByInterface(gobject.Type) *Iterator // IterateElements wraps gst_bin_iterate_elements + // // The function returns the following values: // // - goret *Iterator (nullable) @@ -33718,6 +35415,7 @@ type Bin interface { // Gets an iterator for the elements in this bin. IterateElements() *Iterator // IterateRecurse wraps gst_bin_iterate_recurse + // // The function returns the following values: // // - goret *Iterator (nullable) @@ -33726,6 +35424,7 @@ type Bin interface { // This iterator recurses into GstBin children. IterateRecurse() *Iterator // IterateSinks wraps gst_bin_iterate_sinks + // // The function returns the following values: // // - goret *Iterator (nullable) @@ -33734,6 +35433,7 @@ type Bin interface { // #GST_ELEMENT_FLAG_SINK flag set. IterateSinks() *Iterator // IterateSorted wraps gst_bin_iterate_sorted + // // The function returns the following values: // // - goret *Iterator (nullable) @@ -33746,6 +35446,7 @@ type Bin interface { // of the bin elements and for clock selection. IterateSorted() *Iterator // IterateSources wraps gst_bin_iterate_sources + // // The function returns the following values: // // - goret *Iterator (nullable) @@ -33754,6 +35455,7 @@ type Bin interface { // #GST_ELEMENT_FLAG_SOURCE flag set. IterateSources() *Iterator // RecalculateLatency wraps gst_bin_recalculate_latency + // // The function returns the following values: // // - goret bool @@ -33799,6 +35501,7 @@ type Bin interface { // not be propagated to the bin. SetSuppressedFlags(ElementFlags) // SyncChildrenStates wraps gst_bin_sync_children_states + // // The function returns the following values: // // - goret bool @@ -34094,6 +35797,7 @@ func (bin *BinInstance) GetByNameRecurseUp(name string) Element { } // GetSuppressedFlags wraps gst_bin_get_suppressed_flags +// // The function returns the following values: // // - goret ElementFlags @@ -34184,6 +35888,7 @@ func (bin *BinInstance) IterateAllByInterface(iface gobject.Type) *Iterator { } // IterateElements wraps gst_bin_iterate_elements +// // The function returns the following values: // // - goret *Iterator (nullable) @@ -34208,6 +35913,7 @@ func (bin *BinInstance) IterateElements() *Iterator { } // IterateRecurse wraps gst_bin_iterate_recurse +// // The function returns the following values: // // - goret *Iterator (nullable) @@ -34233,6 +35939,7 @@ func (bin *BinInstance) IterateRecurse() *Iterator { } // IterateSinks wraps gst_bin_iterate_sinks +// // The function returns the following values: // // - goret *Iterator (nullable) @@ -34258,6 +35965,7 @@ func (bin *BinInstance) IterateSinks() *Iterator { } // IterateSorted wraps gst_bin_iterate_sorted +// // The function returns the following values: // // - goret *Iterator (nullable) @@ -34287,6 +35995,7 @@ func (bin *BinInstance) IterateSorted() *Iterator { } // IterateSources wraps gst_bin_iterate_sources +// // The function returns the following values: // // - goret *Iterator (nullable) @@ -34312,6 +36021,7 @@ func (bin *BinInstance) IterateSources() *Iterator { } // RecalculateLatency wraps gst_bin_recalculate_latency +// // The function returns the following values: // // - goret bool @@ -34405,6 +36115,7 @@ func (bin *BinInstance) SetSuppressedFlags(flags ElementFlags) { } // SyncChildrenStates wraps gst_bin_sync_children_states +// // The function returns the following values: // // - goret bool @@ -34435,12 +36146,14 @@ func (bin *BinInstance) SyncChildrenStates() bool { func (o *BinInstance) ConnectDeepElementAdded(fn func(Bin, Bin, Element)) gobject.SignalHandle { return o.Connect("deep-element-added", fn) } + // ConnectDeepElementRemoved connects the provided callback to the "deep-element-removed" signal // // Will be emitted after the element was removed from @sub_bin. func (o *BinInstance) ConnectDeepElementRemoved(fn func(Bin, Bin, Element)) gobject.SignalHandle { return o.Connect("deep-element-removed", fn) } + // ConnectDoLatency connects the provided callback to the "do-latency" signal // // Will be emitted when the bin needs to perform latency calculations. This @@ -34457,18 +36170,119 @@ func (o *BinInstance) ConnectDeepElementRemoved(fn func(Bin, Bin, Element)) gobj func (o *BinInstance) ConnectDoLatency(fn func(Bin) bool) gobject.SignalHandle { return o.Connect("do-latency", fn) } + // ConnectElementAdded connects the provided callback to the "element-added" signal // // Will be emitted after the element was added to the bin. func (o *BinInstance) ConnectElementAdded(fn func(Bin, Element)) gobject.SignalHandle { return o.Connect("element-added", fn) } + // ConnectElementRemoved connects the provided callback to the "element-removed" signal // // Will be emitted after the element was removed from the bin. func (o *BinInstance) ConnectElementRemoved(fn func(Bin, Element)) gobject.SignalHandle { return o.Connect("element-removed", fn) } + +// BinOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type BinOverrides[Instance Bin] struct { + // ElementOverrides allows you to override virtual methods from the parent class Element + ElementOverrides[Instance] + + // AddElement allows you to override the implementation of the virtual method add_element. + // The function takes the following parameters: + // + // - element Element: the element to be added + // + // The function returns the following values: + // + // - goret bool + AddElement func(Instance, Element) bool + // DeepElementAdded allows you to override the implementation of the virtual method deep_element_added. + // The function takes the following parameters: + // + // - subBin Bin: the #GstBin to which the element was added + // - child Element: the element that was added + DeepElementAdded func(Instance, Bin, Element) + // DeepElementRemoved allows you to override the implementation of the virtual method deep_element_removed. + // The function takes the following parameters: + // + // - subBin Bin: the #GstBin from which the element was removed + // - child Element: the element that was removed + DeepElementRemoved func(Instance, Bin, Element) + // DoLatency allows you to override the implementation of the virtual method do_latency. + // The function returns the following values: + // + // - goret bool + DoLatency func(Instance) bool + // ElementAdded allows you to override the implementation of the virtual method element_added. + // The function takes the following parameters: + // + // - child Element: the element that was added + ElementAdded func(Instance, Element) + // ElementRemoved allows you to override the implementation of the virtual method element_removed. + // The function takes the following parameters: + // + // - child Element: the element that was removed + ElementRemoved func(Instance, Element) + // HandleMessage allows you to override the implementation of the virtual method handle_message. + // The function takes the following parameters: + // + // - message *Message: the message to be handled + HandleMessage func(Instance, *Message) + // RemoveElement allows you to override the implementation of the virtual method remove_element. + // The function takes the following parameters: + // + // - element Element: the element to be removed + // + // The function returns the following values: + // + // - goret bool + RemoveElement func(Instance, Element) bool +} + +// UnsafeApplyBinOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyBinOverrides[Instance Bin](gclass unsafe.Pointer, overrides BinOverrides[Instance]) { + UnsafeApplyElementOverrides(gclass, overrides.ElementOverrides) + + pclass := (*C.GstBinClass)(gclass) + + if overrides.AddElement != nil { + pclass.add_element = (*[0]byte)(C._gotk4_gst1_Bin_add_element) + } + + if overrides.DeepElementAdded != nil { + pclass.deep_element_added = (*[0]byte)(C._gotk4_gst1_Bin_deep_element_added) + } + + if overrides.DeepElementRemoved != nil { + pclass.deep_element_removed = (*[0]byte)(C._gotk4_gst1_Bin_deep_element_removed) + } + + if overrides.DoLatency != nil { + pclass.do_latency = (*[0]byte)(C._gotk4_gst1_Bin_do_latency) + } + + if overrides.ElementAdded != nil { + pclass.element_added = (*[0]byte)(C._gotk4_gst1_Bin_element_added) + } + + if overrides.ElementRemoved != nil { + pclass.element_removed = (*[0]byte)(C._gotk4_gst1_Bin_element_removed) + } + + if overrides.HandleMessage != nil { + pclass.handle_message = (*[0]byte)(C._gotk4_gst1_Bin_handle_message) + } + + if overrides.RemoveElement != nil { + pclass.remove_element = (*[0]byte)(C._gotk4_gst1_Bin_remove_element) + } +} + // PipelineInstance is the instance type used by all types extending GstPipeline. It is used internally by the bindings. Users should use the interface [Pipeline] instead. type PipelineInstance struct { _ [0]func() // equal guard @@ -34544,6 +36358,7 @@ type Pipeline interface { // MT safe. AutoClock() // GetAutoFlushBus wraps gst_pipeline_get_auto_flush_bus + // // The function returns the following values: // // - goret bool @@ -34552,6 +36367,7 @@ type Pipeline interface { // the NULL state. GetAutoFlushBus() bool // GetBus wraps gst_pipeline_get_bus + // // The function returns the following values: // // - goret Bus @@ -34560,6 +36376,7 @@ type Pipeline interface { // #GstMessage packets. GetBus() Bus // GetConfiguredLatency wraps gst_pipeline_get_configured_latency + // // The function returns the following values: // // - goret ClockTime @@ -34567,6 +36384,7 @@ type Pipeline interface { // Return the configured latency on @pipeline. GetConfiguredLatency() ClockTime // GetDelay wraps gst_pipeline_get_delay + // // The function returns the following values: // // - goret ClockTime @@ -34574,6 +36392,7 @@ type Pipeline interface { // Get the configured delay (see gst_pipeline_set_delay()). GetDelay() ClockTime // GetLatency wraps gst_pipeline_get_latency + // // The function returns the following values: // // - goret ClockTime @@ -34582,6 +36401,7 @@ type Pipeline interface { // gst_pipeline_set_latency(). GetLatency() ClockTime // GetPipelineClock wraps gst_pipeline_get_pipeline_clock + // // The function returns the following values: // // - goret Clock @@ -34592,6 +36412,7 @@ type Pipeline interface { // clock, even if the pipeline is not in the PLAYING state. GetPipelineClock() Clock // IsLive wraps gst_pipeline_is_live + // // The function returns the following values: // // - goret bool @@ -34763,6 +36584,7 @@ func (pipeline *PipelineInstance) AutoClock() { } // GetAutoFlushBus wraps gst_pipeline_get_auto_flush_bus +// // The function returns the following values: // // - goret bool @@ -34788,6 +36610,7 @@ func (pipeline *PipelineInstance) GetAutoFlushBus() bool { } // GetBus wraps gst_pipeline_get_bus +// // The function returns the following values: // // - goret Bus @@ -34811,6 +36634,7 @@ func (pipeline *PipelineInstance) GetBus() Bus { } // GetConfiguredLatency wraps gst_pipeline_get_configured_latency +// // The function returns the following values: // // - goret ClockTime @@ -34833,6 +36657,7 @@ func (pipeline *PipelineInstance) GetConfiguredLatency() ClockTime { } // GetDelay wraps gst_pipeline_get_delay +// // The function returns the following values: // // - goret ClockTime @@ -34855,6 +36680,7 @@ func (pipeline *PipelineInstance) GetDelay() ClockTime { } // GetLatency wraps gst_pipeline_get_latency +// // The function returns the following values: // // - goret ClockTime @@ -34878,6 +36704,7 @@ func (pipeline *PipelineInstance) GetLatency() ClockTime { } // GetPipelineClock wraps gst_pipeline_get_pipeline_clock +// // The function returns the following values: // // - goret Clock @@ -34903,6 +36730,7 @@ func (pipeline *PipelineInstance) GetPipelineClock() Clock { } // IsLive wraps gst_pipeline_is_live +// // The function returns the following values: // // - goret bool @@ -35042,6 +36870,20 @@ func (pipeline *PipelineInstance) UseClock(clock Clock) { runtime.KeepAlive(clock) } +// PipelineOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type PipelineOverrides[Instance Pipeline] struct { + // BinOverrides allows you to override virtual methods from the parent class Bin + BinOverrides[Instance] + +} + +// UnsafeApplyPipelineOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyPipelineOverrides[Instance Pipeline](gclass unsafe.Pointer, overrides PipelineOverrides[Instance]) { + UnsafeApplyBinOverrides(gclass, overrides.BinOverrides) +} + // AllocationParams wraps GstAllocationParams // // Parameters to control the allocation of memory @@ -35071,7 +36913,7 @@ func UnsafeAllocationParamsFromGlibBorrow(p unsafe.Pointer) *AllocationParams { return &AllocationParams{&allocationParams{(*C.GstAllocationParams)(p)}} } -// UnsafeAllocationParamsFromGlibNone is used to convert raw C.GstAllocationParams pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeAllocationParamsFromGlibNone is used to convert raw C.GstAllocationParams pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeAllocationParamsFromGlibNone(p unsafe.Pointer) *AllocationParams { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeAllocationParamsFromGlibBorrow(p) @@ -35084,7 +36926,7 @@ func UnsafeAllocationParamsFromGlibNone(p unsafe.Pointer) *AllocationParams { return wrapped } -// UnsafeAllocationParamsFromGlibFull is used to convert raw C.GstAllocationParams pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeAllocationParamsFromGlibFull is used to convert raw C.GstAllocationParams pointers to go while taking ownership. This is used by the bindings internally. func UnsafeAllocationParamsFromGlibFull(p unsafe.Pointer) *AllocationParams { wrapped := UnsafeAllocationParamsFromGlibBorrow(p) runtime.SetFinalizer( @@ -35116,7 +36958,9 @@ func UnsafeAllocationParamsToGlibFull(a *AllocationParams) unsafe.Pointer { a.native = nil // AllocationParams is invalid from here on return _p } + // NewAllocationParams wraps gst_allocation_params_new +// // The function returns the following values: // // - goret *AllocationParams @@ -35141,6 +36985,7 @@ func NewAllocationParams() *AllocationParams { } // Copy wraps gst_allocation_params_copy +// // The function returns the following values: // // - goret *AllocationParams (nullable) @@ -35179,6 +37024,8 @@ func (params *AllocationParams) Init() { // AllocatorClass wraps GstAllocatorClass // // The #GstAllocator is used to create new memory. +// +// AllocatorClass is the type struct for [Allocator] type AllocatorClass struct { *allocatorClass } @@ -35193,31 +37040,6 @@ func UnsafeAllocatorClassFromGlibBorrow(p unsafe.Pointer) *AllocatorClass { return &AllocatorClass{&allocatorClass{(*C.GstAllocatorClass)(p)}} } -// UnsafeAllocatorClassFromGlibNone is used to convert raw C.GstAllocatorClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeAllocatorClassFromGlibNone(p unsafe.Pointer) *AllocatorClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeAllocatorClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.allocatorClass, - func (intern *allocatorClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeAllocatorClassFromGlibFull is used to convert raw C.GstAllocatorClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeAllocatorClassFromGlibFull(p unsafe.Pointer) *AllocatorClass { - wrapped := UnsafeAllocatorClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.allocatorClass, - func (intern *allocatorClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeAllocatorClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [AllocatorClass] is expected to work anymore. @@ -35230,14 +37052,15 @@ func UnsafeAllocatorClassToGlibNone(a *AllocatorClass) unsafe.Pointer { return unsafe.Pointer(a.native) } -// UnsafeAllocatorClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeAllocatorClassToGlibFull(a *AllocatorClass) unsafe.Pointer { - runtime.SetFinalizer(a.allocatorClass, nil) - _p := unsafe.Pointer(a.native) - a.native = nil // AllocatorClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (a *AllocatorClass) ParentClass() *ObjectClass { + parent := UnsafeObjectClassFromGlibBorrow(UnsafeAllocatorClassToGlibNone(a)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *AllocatorClass) {}, a) + return parent } + // AtomicQueue wraps GstAtomicQueue // // The #GstAtomicQueue object implements a queue that can be used from multiple @@ -35268,7 +37091,7 @@ func UnsafeAtomicQueueFromGlibBorrow(p unsafe.Pointer) *AtomicQueue { return &AtomicQueue{&atomicQueue{(*C.GstAtomicQueue)(p)}} } -// UnsafeAtomicQueueFromGlibNone is used to convert raw C.GstAtomicQueue pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeAtomicQueueFromGlibNone is used to convert raw C.GstAtomicQueue pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeAtomicQueueFromGlibNone(p unsafe.Pointer) *AtomicQueue { C.gst_atomic_queue_ref((*C.GstAtomicQueue)(p)) wrapped := UnsafeAtomicQueueFromGlibBorrow(p) @@ -35281,7 +37104,7 @@ func UnsafeAtomicQueueFromGlibNone(p unsafe.Pointer) *AtomicQueue { return wrapped } -// UnsafeAtomicQueueFromGlibFull is used to convert raw C.GstAtomicQueue pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeAtomicQueueFromGlibFull is used to convert raw C.GstAtomicQueue pointers to go while taking ownership. This is used by the bindings internally. func UnsafeAtomicQueueFromGlibFull(p unsafe.Pointer) *AtomicQueue { wrapped := UnsafeAtomicQueueFromGlibBorrow(p) runtime.SetFinalizer( @@ -35320,6 +37143,7 @@ func UnsafeAtomicQueueToGlibFull(a *AtomicQueue) unsafe.Pointer { a.native = nil // AtomicQueue is invalid from here on return _p } + // NewAtomicQueue wraps gst_atomic_queue_new // // The function takes the following parameters: @@ -35349,6 +37173,7 @@ func NewAtomicQueue(initialSize uint) *AtomicQueue { } // Length wraps gst_atomic_queue_length +// // The function returns the following values: // // - goret uint @@ -35383,6 +37208,8 @@ func (queue *AtomicQueue) Length() uint { // was added to a sub-bin of this bin. #GstBin implementations that override // this message should chain up to the parent class implementation so the // #GstBin::deep-element-added signal is emitted on all parents. +// +// BinClass is the type struct for [Bin] type BinClass struct { *binClass } @@ -35397,31 +37224,6 @@ func UnsafeBinClassFromGlibBorrow(p unsafe.Pointer) *BinClass { return &BinClass{&binClass{(*C.GstBinClass)(p)}} } -// UnsafeBinClassFromGlibNone is used to convert raw C.GstBinClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeBinClassFromGlibNone(p unsafe.Pointer) *BinClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeBinClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.binClass, - func (intern *binClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeBinClassFromGlibFull is used to convert raw C.GstBinClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeBinClassFromGlibFull(p unsafe.Pointer) *BinClass { - wrapped := UnsafeBinClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.binClass, - func (intern *binClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeBinClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [BinClass] is expected to work anymore. @@ -35434,14 +37236,15 @@ func UnsafeBinClassToGlibNone(b *BinClass) unsafe.Pointer { return unsafe.Pointer(b.native) } -// UnsafeBinClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeBinClassToGlibFull(b *BinClass) unsafe.Pointer { - runtime.SetFinalizer(b.binClass, nil) - _p := unsafe.Pointer(b.native) - b.native = nil // BinClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (b *BinClass) ParentClass() *ElementClass { + parent := UnsafeElementClassFromGlibBorrow(UnsafeBinClassToGlibNone(b)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *BinClass) {}, b) + return parent } + // Buffer wraps GstBuffer // // Buffers are the basic unit of data transfer in GStreamer. They contain the @@ -35559,7 +37362,7 @@ func UnsafeBufferFromGlibBorrow(p unsafe.Pointer) *Buffer { return &Buffer{&buffer{(*C.GstBuffer)(p)}} } -// UnsafeBufferFromGlibNone is used to convert raw C.GstBuffer pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeBufferFromGlibNone is used to convert raw C.GstBuffer pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeBufferFromGlibNone(p unsafe.Pointer) *Buffer { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeBufferFromGlibBorrow(p) @@ -35572,7 +37375,7 @@ func UnsafeBufferFromGlibNone(p unsafe.Pointer) *Buffer { return wrapped } -// UnsafeBufferFromGlibFull is used to convert raw C.GstBuffer pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeBufferFromGlibFull is used to convert raw C.GstBuffer pointers to go while taking ownership. This is used by the bindings internally. func UnsafeBufferFromGlibFull(p unsafe.Pointer) *Buffer { wrapped := UnsafeBufferFromGlibBorrow(p) runtime.SetFinalizer( @@ -35604,7 +37407,9 @@ func UnsafeBufferToGlibFull(b *Buffer) unsafe.Pointer { b.native = nil // Buffer is invalid from here on return _p } + // NewBuffer wraps gst_buffer_new +// // The function returns the following values: // // - goret *Buffer @@ -35699,6 +37504,7 @@ func NewBufferWrappedBytes(bytes *glib.Bytes) *Buffer { } // BufferGetMaxMemory wraps gst_buffer_get_max_memory +// // The function returns the following values: // // - goret uint @@ -35956,6 +37762,7 @@ func (buf1 *Buffer) AppendRegion(buf2 *Buffer, offset int, size int) *Buffer { } // CopyDeep wraps gst_buffer_copy_deep +// // The function returns the following values: // // - goret *Buffer (nullable) @@ -36175,6 +37982,7 @@ func (buffer *Buffer) ForEachMeta(fn BufferForEachMetaFunc) bool { } // GetAllMemory wraps gst_buffer_get_all_memory +// // The function returns the following values: // // - goret *Memory (nullable) @@ -36233,6 +38041,7 @@ func (buffer *Buffer) GetCustomMeta(name string) *CustomMeta { } // GetFlags wraps gst_buffer_get_flags +// // The function returns the following values: // // - goret BufferFlags @@ -36428,6 +38237,7 @@ func (buffer *Buffer) GetReferenceTimestampMeta(reference *Caps) *ReferenceTimes } // GetSize wraps gst_buffer_get_size +// // The function returns the following values: // // - goret uint @@ -36450,6 +38260,7 @@ func (buffer *Buffer) GetSize() uint { } // GetSizes wraps gst_buffer_get_sizes +// // The function returns the following values: // // - offset uint: a pointer to the offset @@ -36595,6 +38406,7 @@ func (buffer *Buffer) InsertMemory(idx int, mem *Memory) { } // IsAllMemoryWritable wraps gst_buffer_is_all_memory_writable +// // The function returns the following values: // // - goret bool @@ -36701,6 +38513,7 @@ func (buffer *Buffer) Memset(offset uint, val uint8, size uint) uint { } // NMemory wraps gst_buffer_n_memory +// // The function returns the following values: // // - goret uint @@ -37130,7 +38943,7 @@ func UnsafeBufferListFromGlibBorrow(p unsafe.Pointer) *BufferList { return &BufferList{&bufferList{(*C.GstBufferList)(p)}} } -// UnsafeBufferListFromGlibNone is used to convert raw C.GstBufferList pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeBufferListFromGlibNone is used to convert raw C.GstBufferList pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeBufferListFromGlibNone(p unsafe.Pointer) *BufferList { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeBufferListFromGlibBorrow(p) @@ -37143,7 +38956,7 @@ func UnsafeBufferListFromGlibNone(p unsafe.Pointer) *BufferList { return wrapped } -// UnsafeBufferListFromGlibFull is used to convert raw C.GstBufferList pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeBufferListFromGlibFull is used to convert raw C.GstBufferList pointers to go while taking ownership. This is used by the bindings internally. func UnsafeBufferListFromGlibFull(p unsafe.Pointer) *BufferList { wrapped := UnsafeBufferListFromGlibBorrow(p) runtime.SetFinalizer( @@ -37175,7 +38988,9 @@ func UnsafeBufferListToGlibFull(b *BufferList) unsafe.Pointer { b.native = nil // BufferList is invalid from here on return _p } + // NewBufferList wraps gst_buffer_list_new +// // The function returns the following values: // // - goret *BufferList @@ -37222,6 +39037,7 @@ func NewBufferListSized(size uint) *BufferList { } // CalculateSize wraps gst_buffer_list_calculate_size +// // The function returns the following values: // // - goret uint @@ -37245,6 +39061,7 @@ func (list *BufferList) CalculateSize() uint { } // CopyDeep wraps gst_buffer_list_copy_deep +// // The function returns the following values: // // - goret *BufferList @@ -37405,6 +39222,7 @@ func (list *BufferList) Insert(idx int, buffer *Buffer) { } // Length wraps gst_buffer_list_length +// // The function returns the following values: // // - goret uint @@ -37472,7 +39290,7 @@ func UnsafeBufferPoolAcquireParamsFromGlibBorrow(p unsafe.Pointer) *BufferPoolAc return &BufferPoolAcquireParams{&bufferPoolAcquireParams{(*C.GstBufferPoolAcquireParams)(p)}} } -// UnsafeBufferPoolAcquireParamsFromGlibNone is used to convert raw C.GstBufferPoolAcquireParams pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeBufferPoolAcquireParamsFromGlibNone is used to convert raw C.GstBufferPoolAcquireParams pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeBufferPoolAcquireParamsFromGlibNone(p unsafe.Pointer) *BufferPoolAcquireParams { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeBufferPoolAcquireParamsFromGlibBorrow(p) @@ -37485,7 +39303,7 @@ func UnsafeBufferPoolAcquireParamsFromGlibNone(p unsafe.Pointer) *BufferPoolAcqu return wrapped } -// UnsafeBufferPoolAcquireParamsFromGlibFull is used to convert raw C.GstBufferPoolAcquireParams pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeBufferPoolAcquireParamsFromGlibFull is used to convert raw C.GstBufferPoolAcquireParams pointers to go while taking ownership. This is used by the bindings internally. func UnsafeBufferPoolAcquireParamsFromGlibFull(p unsafe.Pointer) *BufferPoolAcquireParams { wrapped := UnsafeBufferPoolAcquireParamsFromGlibBorrow(p) runtime.SetFinalizer( @@ -37517,9 +39335,12 @@ func UnsafeBufferPoolAcquireParamsToGlibFull(b *BufferPoolAcquireParams) unsafe. b.native = nil // BufferPoolAcquireParams is invalid from here on return _p } + // BufferPoolClass wraps GstBufferPoolClass // // The #GstBufferPool class. +// +// BufferPoolClass is the type struct for [BufferPool] type BufferPoolClass struct { *bufferPoolClass } @@ -37534,31 +39355,6 @@ func UnsafeBufferPoolClassFromGlibBorrow(p unsafe.Pointer) *BufferPoolClass { return &BufferPoolClass{&bufferPoolClass{(*C.GstBufferPoolClass)(p)}} } -// UnsafeBufferPoolClassFromGlibNone is used to convert raw C.GstBufferPoolClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeBufferPoolClassFromGlibNone(p unsafe.Pointer) *BufferPoolClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeBufferPoolClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.bufferPoolClass, - func (intern *bufferPoolClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeBufferPoolClassFromGlibFull is used to convert raw C.GstBufferPoolClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeBufferPoolClassFromGlibFull(p unsafe.Pointer) *BufferPoolClass { - wrapped := UnsafeBufferPoolClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.bufferPoolClass, - func (intern *bufferPoolClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeBufferPoolClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [BufferPoolClass] is expected to work anymore. @@ -37571,17 +39367,20 @@ func UnsafeBufferPoolClassToGlibNone(b *BufferPoolClass) unsafe.Pointer { return unsafe.Pointer(b.native) } -// UnsafeBufferPoolClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeBufferPoolClassToGlibFull(b *BufferPoolClass) unsafe.Pointer { - runtime.SetFinalizer(b.bufferPoolClass, nil) - _p := unsafe.Pointer(b.native) - b.native = nil // BufferPoolClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (b *BufferPoolClass) ParentClass() *ObjectClass { + parent := UnsafeObjectClassFromGlibBorrow(UnsafeBufferPoolClassToGlibNone(b)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *BufferPoolClass) {}, b) + return parent } + // BusClass wraps GstBusClass // // GStreamer bus class. +// +// BusClass is the type struct for [Bus] type BusClass struct { *busClass } @@ -37596,31 +39395,6 @@ func UnsafeBusClassFromGlibBorrow(p unsafe.Pointer) *BusClass { return &BusClass{&busClass{(*C.GstBusClass)(p)}} } -// UnsafeBusClassFromGlibNone is used to convert raw C.GstBusClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeBusClassFromGlibNone(p unsafe.Pointer) *BusClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeBusClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.busClass, - func (intern *busClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeBusClassFromGlibFull is used to convert raw C.GstBusClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeBusClassFromGlibFull(p unsafe.Pointer) *BusClass { - wrapped := UnsafeBusClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.busClass, - func (intern *busClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeBusClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [BusClass] is expected to work anymore. @@ -37633,14 +39407,15 @@ func UnsafeBusClassToGlibNone(b *BusClass) unsafe.Pointer { return unsafe.Pointer(b.native) } -// UnsafeBusClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeBusClassToGlibFull(b *BusClass) unsafe.Pointer { - runtime.SetFinalizer(b.busClass, nil) - _p := unsafe.Pointer(b.native) - b.native = nil // BusClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (b *BusClass) ParentClass() *ObjectClass { + parent := UnsafeObjectClassFromGlibBorrow(UnsafeBusClassToGlibNone(b)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *BusClass) {}, b) + return parent } + // ByteArrayInterface wraps GstByteArrayInterface // // Interface for an array of bytes. It is expected to be subclassed to implement @@ -37664,7 +39439,7 @@ func UnsafeByteArrayInterfaceFromGlibBorrow(p unsafe.Pointer) *ByteArrayInterfac return &ByteArrayInterface{&byteArrayInterface{(*C.GstByteArrayInterface)(p)}} } -// UnsafeByteArrayInterfaceFromGlibNone is used to convert raw C.GstByteArrayInterface pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeByteArrayInterfaceFromGlibNone is used to convert raw C.GstByteArrayInterface pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeByteArrayInterfaceFromGlibNone(p unsafe.Pointer) *ByteArrayInterface { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeByteArrayInterfaceFromGlibBorrow(p) @@ -37677,7 +39452,7 @@ func UnsafeByteArrayInterfaceFromGlibNone(p unsafe.Pointer) *ByteArrayInterface return wrapped } -// UnsafeByteArrayInterfaceFromGlibFull is used to convert raw C.GstByteArrayInterface pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeByteArrayInterfaceFromGlibFull is used to convert raw C.GstByteArrayInterface pointers to go while taking ownership. This is used by the bindings internally. func UnsafeByteArrayInterfaceFromGlibFull(p unsafe.Pointer) *ByteArrayInterface { wrapped := UnsafeByteArrayInterfaceFromGlibBorrow(p) runtime.SetFinalizer( @@ -37709,6 +39484,7 @@ func UnsafeByteArrayInterfaceToGlibFull(b *ByteArrayInterface) unsafe.Pointer { b.native = nil // ByteArrayInterface is invalid from here on return _p } + // Caps wraps GstCaps // // Caps (capabilities) are lightweight refcounted objects describing media types. @@ -37772,7 +39548,7 @@ func UnsafeCapsFromGlibBorrow(p unsafe.Pointer) *Caps { return &Caps{&caps{(*C.GstCaps)(p)}} } -// UnsafeCapsFromGlibNone is used to convert raw C.GstCaps pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeCapsFromGlibNone is used to convert raw C.GstCaps pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeCapsFromGlibNone(p unsafe.Pointer) *Caps { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeCapsFromGlibBorrow(p) @@ -37785,7 +39561,7 @@ func UnsafeCapsFromGlibNone(p unsafe.Pointer) *Caps { return wrapped } -// UnsafeCapsFromGlibFull is used to convert raw C.GstCaps pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeCapsFromGlibFull is used to convert raw C.GstCaps pointers to go while taking ownership. This is used by the bindings internally. func UnsafeCapsFromGlibFull(p unsafe.Pointer) *Caps { wrapped := UnsafeCapsFromGlibBorrow(p) runtime.SetFinalizer( @@ -37817,7 +39593,9 @@ func UnsafeCapsToGlibFull(c *Caps) unsafe.Pointer { c.native = nil // Caps is invalid from here on return _p } + // NewCapsAny wraps gst_caps_new_any +// // The function returns the following values: // // - goret *Caps @@ -37837,6 +39615,7 @@ func NewCapsAny() *Caps { } // NewCapsEmpty wraps gst_caps_new_empty +// // The function returns the following values: // // - goret *Caps @@ -38019,6 +39798,7 @@ func (caps1 *Caps) CanIntersect(caps2 *Caps) bool { } // Copy wraps gst_caps_copy +// // The function returns the following values: // // - goret *Caps @@ -38103,6 +39883,7 @@ func (caps *Caps) FilterAndMapInPlace(fn CapsFilterMapFunc) { } // Fixate wraps gst_caps_fixate +// // The function returns the following values: // // - goret *Caps @@ -38215,6 +39996,7 @@ func (caps *Caps) GetFeatures(index uint) *CapsFeatures { } // GetSize wraps gst_caps_get_size +// // The function returns the following values: // // - goret uint @@ -38378,6 +40160,7 @@ func (caps1 *Caps) IsAlwaysCompatible(caps2 *Caps) bool { } // IsAny wraps gst_caps_is_any +// // The function returns the following values: // // - goret bool @@ -38402,6 +40185,7 @@ func (caps *Caps) IsAny() bool { } // IsEmpty wraps gst_caps_is_empty +// // The function returns the following values: // // - goret bool @@ -38491,6 +40275,7 @@ func (caps1 *Caps) IsEqualFixed(caps2 *Caps) bool { } // IsFixed wraps gst_caps_is_fixed +// // The function returns the following values: // // - goret bool @@ -38789,6 +40574,7 @@ func (caps *Caps) MergeStructureFull(structure *Structure, features *CapsFeature } // Normalize wraps gst_caps_normalize +// // The function returns the following values: // // - goret *Caps @@ -38948,6 +40734,7 @@ func (caps *Caps) SetValue(field string, value *gobject.Value) { } // Simplify wraps gst_caps_simplify +// // The function returns the following values: // // - goret *Caps @@ -39044,6 +40831,7 @@ func (minuend *Caps) Subtract(subtrahend *Caps) *Caps { } // ToString wraps gst_caps_to_string +// // The function returns the following values: // // - goret string @@ -39079,6 +40867,7 @@ func (caps *Caps) ToString() string { } // Truncate wraps gst_caps_truncate +// // The function returns the following values: // // - goret *Caps @@ -39155,7 +40944,7 @@ func UnsafeCapsFeaturesFromGlibBorrow(p unsafe.Pointer) *CapsFeatures { return &CapsFeatures{&capsFeatures{(*C.GstCapsFeatures)(p)}} } -// UnsafeCapsFeaturesFromGlibNone is used to convert raw C.GstCapsFeatures pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeCapsFeaturesFromGlibNone is used to convert raw C.GstCapsFeatures pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeCapsFeaturesFromGlibNone(p unsafe.Pointer) *CapsFeatures { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeCapsFeaturesFromGlibBorrow(p) @@ -39168,7 +40957,7 @@ func UnsafeCapsFeaturesFromGlibNone(p unsafe.Pointer) *CapsFeatures { return wrapped } -// UnsafeCapsFeaturesFromGlibFull is used to convert raw C.GstCapsFeatures pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeCapsFeaturesFromGlibFull is used to convert raw C.GstCapsFeatures pointers to go while taking ownership. This is used by the bindings internally. func UnsafeCapsFeaturesFromGlibFull(p unsafe.Pointer) *CapsFeatures { wrapped := UnsafeCapsFeaturesFromGlibBorrow(p) runtime.SetFinalizer( @@ -39200,7 +40989,9 @@ func UnsafeCapsFeaturesToGlibFull(c *CapsFeatures) unsafe.Pointer { c.native = nil // CapsFeatures is invalid from here on return _p } + // NewCapsFeaturesAny wraps gst_caps_features_new_any +// // The function returns the following values: // // - goret *CapsFeatures @@ -39221,6 +41012,7 @@ func NewCapsFeaturesAny() *CapsFeatures { } // NewCapsFeaturesEmpty wraps gst_caps_features_new_empty +// // The function returns the following values: // // - goret *CapsFeatures @@ -39401,6 +41193,7 @@ func (features *CapsFeatures) ContainsID(feature glib.Quark) bool { } // Copy wraps gst_caps_features_copy +// // The function returns the following values: // // - goret *CapsFeatures @@ -39485,6 +41278,7 @@ func (features *CapsFeatures) GetNthID(i uint) glib.Quark { } // GetSize wraps gst_caps_features_get_size +// // The function returns the following values: // // - goret uint @@ -39507,6 +41301,7 @@ func (features *CapsFeatures) GetSize() uint { } // IsAny wraps gst_caps_features_is_any +// // The function returns the following values: // // - goret bool @@ -39639,6 +41434,7 @@ func (features *CapsFeatures) SetParentRefcount(refcount *int) bool { } // ToString wraps gst_caps_features_to_string +// // The function returns the following values: // // - goret string @@ -39686,7 +41482,7 @@ func UnsafeChildProxyInterfaceFromGlibBorrow(p unsafe.Pointer) *ChildProxyInterf return &ChildProxyInterface{&childProxyInterface{(*C.GstChildProxyInterface)(p)}} } -// UnsafeChildProxyInterfaceFromGlibNone is used to convert raw C.GstChildProxyInterface pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeChildProxyInterfaceFromGlibNone is used to convert raw C.GstChildProxyInterface pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeChildProxyInterfaceFromGlibNone(p unsafe.Pointer) *ChildProxyInterface { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeChildProxyInterfaceFromGlibBorrow(p) @@ -39699,7 +41495,7 @@ func UnsafeChildProxyInterfaceFromGlibNone(p unsafe.Pointer) *ChildProxyInterfac return wrapped } -// UnsafeChildProxyInterfaceFromGlibFull is used to convert raw C.GstChildProxyInterface pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeChildProxyInterfaceFromGlibFull is used to convert raw C.GstChildProxyInterface pointers to go while taking ownership. This is used by the bindings internally. func UnsafeChildProxyInterfaceFromGlibFull(p unsafe.Pointer) *ChildProxyInterface { wrapped := UnsafeChildProxyInterfaceFromGlibBorrow(p) runtime.SetFinalizer( @@ -39731,10 +41527,13 @@ func UnsafeChildProxyInterfaceToGlibFull(c *ChildProxyInterface) unsafe.Pointer c.native = nil // ChildProxyInterface is invalid from here on return _p } + // ClockClass wraps GstClockClass // // GStreamer clock class. Override the vmethods to implement the clock // functionality. +// +// ClockClass is the type struct for [Clock] type ClockClass struct { *clockClass } @@ -39749,31 +41548,6 @@ func UnsafeClockClassFromGlibBorrow(p unsafe.Pointer) *ClockClass { return &ClockClass{&clockClass{(*C.GstClockClass)(p)}} } -// UnsafeClockClassFromGlibNone is used to convert raw C.GstClockClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeClockClassFromGlibNone(p unsafe.Pointer) *ClockClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeClockClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.clockClass, - func (intern *clockClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeClockClassFromGlibFull is used to convert raw C.GstClockClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeClockClassFromGlibFull(p unsafe.Pointer) *ClockClass { - wrapped := UnsafeClockClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.clockClass, - func (intern *clockClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeClockClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [ClockClass] is expected to work anymore. @@ -39786,14 +41560,15 @@ func UnsafeClockClassToGlibNone(c *ClockClass) unsafe.Pointer { return unsafe.Pointer(c.native) } -// UnsafeClockClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeClockClassToGlibFull(c *ClockClass) unsafe.Pointer { - runtime.SetFinalizer(c.clockClass, nil) - _p := unsafe.Pointer(c.native) - c.native = nil // ClockClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (c *ClockClass) ParentClass() *ObjectClass { + parent := UnsafeObjectClassFromGlibBorrow(UnsafeClockClassToGlibNone(c)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *ClockClass) {}, c) + return parent } + // ClockEntry wraps GstClockEntry // // All pending timeouts or periodic notifies are converted into @@ -39814,7 +41589,7 @@ func UnsafeClockEntryFromGlibBorrow(p unsafe.Pointer) *ClockEntry { return &ClockEntry{&clockEntry{(*C.GstClockEntry)(p)}} } -// UnsafeClockEntryFromGlibNone is used to convert raw C.GstClockEntry pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeClockEntryFromGlibNone is used to convert raw C.GstClockEntry pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeClockEntryFromGlibNone(p unsafe.Pointer) *ClockEntry { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeClockEntryFromGlibBorrow(p) @@ -39827,7 +41602,7 @@ func UnsafeClockEntryFromGlibNone(p unsafe.Pointer) *ClockEntry { return wrapped } -// UnsafeClockEntryFromGlibFull is used to convert raw C.GstClockEntry pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeClockEntryFromGlibFull is used to convert raw C.GstClockEntry pointers to go while taking ownership. This is used by the bindings internally. func UnsafeClockEntryFromGlibFull(p unsafe.Pointer) *ClockEntry { wrapped := UnsafeClockEntryFromGlibBorrow(p) runtime.SetFinalizer( @@ -39859,6 +41634,7 @@ func UnsafeClockEntryToGlibFull(c *ClockEntry) unsafe.Pointer { c.native = nil // ClockEntry is invalid from here on return _p } + // Context wraps GstContext // // #GstContext is a container object used to store contexts like a device @@ -39916,7 +41692,7 @@ func UnsafeContextFromGlibBorrow(p unsafe.Pointer) *Context { return &Context{&_context{(*C.GstContext)(p)}} } -// UnsafeContextFromGlibNone is used to convert raw C.GstContext pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeContextFromGlibNone is used to convert raw C.GstContext pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeContextFromGlibNone(p unsafe.Pointer) *Context { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeContextFromGlibBorrow(p) @@ -39929,7 +41705,7 @@ func UnsafeContextFromGlibNone(p unsafe.Pointer) *Context { return wrapped } -// UnsafeContextFromGlibFull is used to convert raw C.GstContext pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeContextFromGlibFull is used to convert raw C.GstContext pointers to go while taking ownership. This is used by the bindings internally. func UnsafeContextFromGlibFull(p unsafe.Pointer) *Context { wrapped := UnsafeContextFromGlibBorrow(p) runtime.SetFinalizer( @@ -39961,6 +41737,7 @@ func UnsafeContextToGlibFull(c *Context) unsafe.Pointer { c.native = nil // Context is invalid from here on return _p } + // NewContext wraps gst_context_new // // The function takes the following parameters: @@ -39996,6 +41773,7 @@ func NewContext(contextType string, persistent bool) *Context { } // GetContextType wraps gst_context_get_context_type +// // The function returns the following values: // // - goret string @@ -40018,6 +41796,7 @@ func (_context *Context) GetContextType() string { } // GetStructure wraps gst_context_get_structure +// // The function returns the following values: // // - goret *Structure @@ -40073,6 +41852,7 @@ func (_context *Context) HasContextType(contextType string) bool { } // IsPersistent wraps gst_context_is_persistent +// // The function returns the following values: // // - goret bool @@ -40097,6 +41877,7 @@ func (_context *Context) IsPersistent() bool { } // WritableStructure wraps gst_context_writable_structure +// // The function returns the following values: // // - goret *Structure @@ -40121,6 +41902,8 @@ func (_context *Context) WritableStructure() *Structure { // ControlBindingClass wraps GstControlBindingClass // // The class structure of #GstControlBinding. +// +// ControlBindingClass is the type struct for [ControlBinding] type ControlBindingClass struct { *controlBindingClass } @@ -40135,31 +41918,6 @@ func UnsafeControlBindingClassFromGlibBorrow(p unsafe.Pointer) *ControlBindingCl return &ControlBindingClass{&controlBindingClass{(*C.GstControlBindingClass)(p)}} } -// UnsafeControlBindingClassFromGlibNone is used to convert raw C.GstControlBindingClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeControlBindingClassFromGlibNone(p unsafe.Pointer) *ControlBindingClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeControlBindingClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.controlBindingClass, - func (intern *controlBindingClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeControlBindingClassFromGlibFull is used to convert raw C.GstControlBindingClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeControlBindingClassFromGlibFull(p unsafe.Pointer) *ControlBindingClass { - wrapped := UnsafeControlBindingClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.controlBindingClass, - func (intern *controlBindingClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeControlBindingClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [ControlBindingClass] is expected to work anymore. @@ -40172,17 +41930,20 @@ func UnsafeControlBindingClassToGlibNone(c *ControlBindingClass) unsafe.Pointer return unsafe.Pointer(c.native) } -// UnsafeControlBindingClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeControlBindingClassToGlibFull(c *ControlBindingClass) unsafe.Pointer { - runtime.SetFinalizer(c.controlBindingClass, nil) - _p := unsafe.Pointer(c.native) - c.native = nil // ControlBindingClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (c *ControlBindingClass) ParentClass() *ObjectClass { + parent := UnsafeObjectClassFromGlibBorrow(UnsafeControlBindingClassToGlibNone(c)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *ControlBindingClass) {}, c) + return parent } + // ControlSourceClass wraps GstControlSourceClass // // The class structure of #GstControlSource. +// +// ControlSourceClass is the type struct for [ControlSource] type ControlSourceClass struct { *controlSourceClass } @@ -40197,31 +41958,6 @@ func UnsafeControlSourceClassFromGlibBorrow(p unsafe.Pointer) *ControlSourceClas return &ControlSourceClass{&controlSourceClass{(*C.GstControlSourceClass)(p)}} } -// UnsafeControlSourceClassFromGlibNone is used to convert raw C.GstControlSourceClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeControlSourceClassFromGlibNone(p unsafe.Pointer) *ControlSourceClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeControlSourceClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.controlSourceClass, - func (intern *controlSourceClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeControlSourceClassFromGlibFull is used to convert raw C.GstControlSourceClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeControlSourceClassFromGlibFull(p unsafe.Pointer) *ControlSourceClass { - wrapped := UnsafeControlSourceClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.controlSourceClass, - func (intern *controlSourceClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeControlSourceClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [ControlSourceClass] is expected to work anymore. @@ -40234,14 +41970,15 @@ func UnsafeControlSourceClassToGlibNone(c *ControlSourceClass) unsafe.Pointer { return unsafe.Pointer(c.native) } -// UnsafeControlSourceClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeControlSourceClassToGlibFull(c *ControlSourceClass) unsafe.Pointer { - runtime.SetFinalizer(c.controlSourceClass, nil) - _p := unsafe.Pointer(c.native) - c.native = nil // ControlSourceClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (c *ControlSourceClass) ParentClass() *ObjectClass { + parent := UnsafeObjectClassFromGlibBorrow(UnsafeControlSourceClassToGlibNone(c)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *ControlSourceClass) {}, c) + return parent } + // CustomMeta wraps GstCustomMeta // // Extra custom metadata. The @structure field is the same as returned by @@ -40264,7 +42001,7 @@ func UnsafeCustomMetaFromGlibBorrow(p unsafe.Pointer) *CustomMeta { return &CustomMeta{&customMeta{(*C.GstCustomMeta)(p)}} } -// UnsafeCustomMetaFromGlibNone is used to convert raw C.GstCustomMeta pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeCustomMetaFromGlibNone is used to convert raw C.GstCustomMeta pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeCustomMetaFromGlibNone(p unsafe.Pointer) *CustomMeta { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeCustomMetaFromGlibBorrow(p) @@ -40277,7 +42014,7 @@ func UnsafeCustomMetaFromGlibNone(p unsafe.Pointer) *CustomMeta { return wrapped } -// UnsafeCustomMetaFromGlibFull is used to convert raw C.GstCustomMeta pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeCustomMetaFromGlibFull is used to convert raw C.GstCustomMeta pointers to go while taking ownership. This is used by the bindings internally. func UnsafeCustomMetaFromGlibFull(p unsafe.Pointer) *CustomMeta { wrapped := UnsafeCustomMetaFromGlibBorrow(p) runtime.SetFinalizer( @@ -40309,7 +42046,9 @@ func UnsafeCustomMetaToGlibFull(c *CustomMeta) unsafe.Pointer { c.native = nil // CustomMeta is invalid from here on return _p } + // GetStructure wraps gst_custom_meta_get_structure +// // The function returns the following values: // // - goret *Structure @@ -40401,7 +42140,7 @@ func UnsafeDateTimeFromGlibBorrow(p unsafe.Pointer) *DateTime { return &DateTime{&dateTime{(*C.GstDateTime)(p)}} } -// UnsafeDateTimeFromGlibNone is used to convert raw C.GstDateTime pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeDateTimeFromGlibNone is used to convert raw C.GstDateTime pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeDateTimeFromGlibNone(p unsafe.Pointer) *DateTime { C.gst_date_time_ref((*C.GstDateTime)(p)) wrapped := UnsafeDateTimeFromGlibBorrow(p) @@ -40414,7 +42153,7 @@ func UnsafeDateTimeFromGlibNone(p unsafe.Pointer) *DateTime { return wrapped } -// UnsafeDateTimeFromGlibFull is used to convert raw C.GstDateTime pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeDateTimeFromGlibFull is used to convert raw C.GstDateTime pointers to go while taking ownership. This is used by the bindings internally. func UnsafeDateTimeFromGlibFull(p unsafe.Pointer) *DateTime { wrapped := UnsafeDateTimeFromGlibBorrow(p) runtime.SetFinalizer( @@ -40453,6 +42192,7 @@ func UnsafeDateTimeToGlibFull(d *DateTime) unsafe.Pointer { d.native = nil // DateTime is invalid from here on return _p } + // NewDateTime wraps gst_date_time_new // // The function takes the following parameters: @@ -40771,6 +42511,7 @@ func NewDateTimeLocalTime(year int, month int, day int, hour int, minute int, se } // NewDateTimeNowLocalTime wraps gst_date_time_new_now_local_time +// // The function returns the following values: // // - goret *DateTime (nullable) @@ -40791,6 +42532,7 @@ func NewDateTimeNowLocalTime() *DateTime { } // NewDateTimeNowUTC wraps gst_date_time_new_now_utc +// // The function returns the following values: // // - goret *DateTime (nullable) @@ -40929,6 +42671,7 @@ func NewDateTimeYmd(year int, month int, day int) *DateTime { } // GetDay wraps gst_date_time_get_day +// // The function returns the following values: // // - goret int @@ -40951,6 +42694,7 @@ func (datetime *DateTime) GetDay() int { } // GetHour wraps gst_date_time_get_hour +// // The function returns the following values: // // - goret int @@ -40974,6 +42718,7 @@ func (datetime *DateTime) GetHour() int { } // GetMicrosecond wraps gst_date_time_get_microsecond +// // The function returns the following values: // // - goret int @@ -40997,6 +42742,7 @@ func (datetime *DateTime) GetMicrosecond() int { } // GetMinute wraps gst_date_time_get_minute +// // The function returns the following values: // // - goret int @@ -41020,6 +42766,7 @@ func (datetime *DateTime) GetMinute() int { } // GetMonth wraps gst_date_time_get_month +// // The function returns the following values: // // - goret int @@ -41042,6 +42789,7 @@ func (datetime *DateTime) GetMonth() int { } // GetSecond wraps gst_date_time_get_second +// // The function returns the following values: // // - goret int @@ -41065,6 +42813,7 @@ func (datetime *DateTime) GetSecond() int { } // GetTimeZoneOffset wraps gst_date_time_get_time_zone_offset +// // The function returns the following values: // // - goret float32 @@ -41090,6 +42839,7 @@ func (datetime *DateTime) GetTimeZoneOffset() float32 { } // GetYear wraps gst_date_time_get_year +// // The function returns the following values: // // - goret int @@ -41113,6 +42863,7 @@ func (datetime *DateTime) GetYear() int { } // HasDay wraps gst_date_time_has_day +// // The function returns the following values: // // - goret bool @@ -41135,6 +42886,7 @@ func (datetime *DateTime) HasDay() bool { } // HasMonth wraps gst_date_time_has_month +// // The function returns the following values: // // - goret bool @@ -41157,6 +42909,7 @@ func (datetime *DateTime) HasMonth() bool { } // HasSecond wraps gst_date_time_has_second +// // The function returns the following values: // // - goret bool @@ -41179,6 +42932,7 @@ func (datetime *DateTime) HasSecond() bool { } // HasTime wraps gst_date_time_has_time +// // The function returns the following values: // // - goret bool @@ -41201,6 +42955,7 @@ func (datetime *DateTime) HasTime() bool { } // HasYear wraps gst_date_time_has_year +// // The function returns the following values: // // - goret bool @@ -41223,6 +42978,7 @@ func (datetime *DateTime) HasYear() bool { } // ToGDateTime wraps gst_date_time_to_g_date_time +// // The function returns the following values: // // - goret *glib.DateTime (nullable) @@ -41247,6 +43003,7 @@ func (datetime *DateTime) ToGDateTime() *glib.DateTime { } // ToISO8601String wraps gst_date_time_to_iso8601_string +// // The function returns the following values: // // - goret string (nullable) @@ -41291,7 +43048,7 @@ func UnsafeDebugCategoryFromGlibBorrow(p unsafe.Pointer) *DebugCategory { return &DebugCategory{&debugCategory{(*C.GstDebugCategory)(p)}} } -// UnsafeDebugCategoryFromGlibNone is used to convert raw C.GstDebugCategory pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeDebugCategoryFromGlibNone is used to convert raw C.GstDebugCategory pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeDebugCategoryFromGlibNone(p unsafe.Pointer) *DebugCategory { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeDebugCategoryFromGlibBorrow(p) @@ -41304,7 +43061,7 @@ func UnsafeDebugCategoryFromGlibNone(p unsafe.Pointer) *DebugCategory { return wrapped } -// UnsafeDebugCategoryFromGlibFull is used to convert raw C.GstDebugCategory pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeDebugCategoryFromGlibFull is used to convert raw C.GstDebugCategory pointers to go while taking ownership. This is used by the bindings internally. func UnsafeDebugCategoryFromGlibFull(p unsafe.Pointer) *DebugCategory { wrapped := UnsafeDebugCategoryFromGlibBorrow(p) runtime.SetFinalizer( @@ -41336,7 +43093,9 @@ func UnsafeDebugCategoryToGlibFull(d *DebugCategory) unsafe.Pointer { d.native = nil // DebugCategory is invalid from here on return _p } + // GetColor wraps gst_debug_category_get_color +// // The function returns the following values: // // - goret uint @@ -41360,6 +43119,7 @@ func (category *DebugCategory) GetColor() uint { } // GetDescription wraps gst_debug_category_get_description +// // The function returns the following values: // // - goret string @@ -41382,6 +43142,7 @@ func (category *DebugCategory) GetDescription() string { } // GetName wraps gst_debug_category_get_name +// // The function returns the following values: // // - goret string @@ -41404,6 +43165,7 @@ func (category *DebugCategory) GetName() string { } // GetThreshold wraps gst_debug_category_get_threshold +// // The function returns the following values: // // - goret DebugLevel @@ -41480,7 +43242,7 @@ func UnsafeDebugMessageFromGlibBorrow(p unsafe.Pointer) *DebugMessage { return &DebugMessage{&debugMessage{(*C.GstDebugMessage)(p)}} } -// UnsafeDebugMessageFromGlibNone is used to convert raw C.GstDebugMessage pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeDebugMessageFromGlibNone is used to convert raw C.GstDebugMessage pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeDebugMessageFromGlibNone(p unsafe.Pointer) *DebugMessage { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeDebugMessageFromGlibBorrow(p) @@ -41493,7 +43255,7 @@ func UnsafeDebugMessageFromGlibNone(p unsafe.Pointer) *DebugMessage { return wrapped } -// UnsafeDebugMessageFromGlibFull is used to convert raw C.GstDebugMessage pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeDebugMessageFromGlibFull is used to convert raw C.GstDebugMessage pointers to go while taking ownership. This is used by the bindings internally. func UnsafeDebugMessageFromGlibFull(p unsafe.Pointer) *DebugMessage { wrapped := UnsafeDebugMessageFromGlibBorrow(p) runtime.SetFinalizer( @@ -41525,7 +43287,9 @@ func UnsafeDebugMessageToGlibFull(d *DebugMessage) unsafe.Pointer { d.native = nil // DebugMessage is invalid from here on return _p } + // Get wraps gst_debug_message_get +// // The function returns the following values: // // - goret string (nullable) @@ -41551,6 +43315,7 @@ func (message *DebugMessage) Get() string { } // GetID wraps gst_debug_message_get_id +// // The function returns the following values: // // - goret string (nullable) @@ -41578,6 +43343,8 @@ func (message *DebugMessage) GetID() string { // DeviceClass wraps GstDeviceClass // // The class structure for a #GstDevice object. +// +// DeviceClass is the type struct for [Device] type DeviceClass struct { *deviceClass } @@ -41592,31 +43359,6 @@ func UnsafeDeviceClassFromGlibBorrow(p unsafe.Pointer) *DeviceClass { return &DeviceClass{&deviceClass{(*C.GstDeviceClass)(p)}} } -// UnsafeDeviceClassFromGlibNone is used to convert raw C.GstDeviceClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeDeviceClassFromGlibNone(p unsafe.Pointer) *DeviceClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeDeviceClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.deviceClass, - func (intern *deviceClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeDeviceClassFromGlibFull is used to convert raw C.GstDeviceClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeDeviceClassFromGlibFull(p unsafe.Pointer) *DeviceClass { - wrapped := UnsafeDeviceClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.deviceClass, - func (intern *deviceClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeDeviceClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [DeviceClass] is expected to work anymore. @@ -41629,17 +43371,20 @@ func UnsafeDeviceClassToGlibNone(d *DeviceClass) unsafe.Pointer { return unsafe.Pointer(d.native) } -// UnsafeDeviceClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeDeviceClassToGlibFull(d *DeviceClass) unsafe.Pointer { - runtime.SetFinalizer(d.deviceClass, nil) - _p := unsafe.Pointer(d.native) - d.native = nil // DeviceClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (d *DeviceClass) ParentClass() *ObjectClass { + parent := UnsafeObjectClassFromGlibBorrow(UnsafeDeviceClassToGlibNone(d)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *DeviceClass) {}, d) + return parent } + // DeviceMonitorClass wraps GstDeviceMonitorClass // // Opaque device monitor class structure. +// +// DeviceMonitorClass is the type struct for [DeviceMonitor] type DeviceMonitorClass struct { *deviceMonitorClass } @@ -41654,31 +43399,6 @@ func UnsafeDeviceMonitorClassFromGlibBorrow(p unsafe.Pointer) *DeviceMonitorClas return &DeviceMonitorClass{&deviceMonitorClass{(*C.GstDeviceMonitorClass)(p)}} } -// UnsafeDeviceMonitorClassFromGlibNone is used to convert raw C.GstDeviceMonitorClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeDeviceMonitorClassFromGlibNone(p unsafe.Pointer) *DeviceMonitorClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeDeviceMonitorClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.deviceMonitorClass, - func (intern *deviceMonitorClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeDeviceMonitorClassFromGlibFull is used to convert raw C.GstDeviceMonitorClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeDeviceMonitorClassFromGlibFull(p unsafe.Pointer) *DeviceMonitorClass { - wrapped := UnsafeDeviceMonitorClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.deviceMonitorClass, - func (intern *deviceMonitorClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeDeviceMonitorClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [DeviceMonitorClass] is expected to work anymore. @@ -41691,17 +43411,20 @@ func UnsafeDeviceMonitorClassToGlibNone(d *DeviceMonitorClass) unsafe.Pointer { return unsafe.Pointer(d.native) } -// UnsafeDeviceMonitorClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeDeviceMonitorClassToGlibFull(d *DeviceMonitorClass) unsafe.Pointer { - runtime.SetFinalizer(d.deviceMonitorClass, nil) - _p := unsafe.Pointer(d.native) - d.native = nil // DeviceMonitorClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (d *DeviceMonitorClass) ParentClass() *ObjectClass { + parent := UnsafeObjectClassFromGlibBorrow(UnsafeDeviceMonitorClassToGlibNone(d)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *DeviceMonitorClass) {}, d) + return parent } + // DeviceProviderClass wraps GstDeviceProviderClass // // The structure of the base #GstDeviceProviderClass +// +// DeviceProviderClass is the type struct for [DeviceProvider] type DeviceProviderClass struct { *deviceProviderClass } @@ -41716,31 +43439,6 @@ func UnsafeDeviceProviderClassFromGlibBorrow(p unsafe.Pointer) *DeviceProviderCl return &DeviceProviderClass{&deviceProviderClass{(*C.GstDeviceProviderClass)(p)}} } -// UnsafeDeviceProviderClassFromGlibNone is used to convert raw C.GstDeviceProviderClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeDeviceProviderClassFromGlibNone(p unsafe.Pointer) *DeviceProviderClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeDeviceProviderClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.deviceProviderClass, - func (intern *deviceProviderClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeDeviceProviderClassFromGlibFull is used to convert raw C.GstDeviceProviderClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeDeviceProviderClassFromGlibFull(p unsafe.Pointer) *DeviceProviderClass { - wrapped := UnsafeDeviceProviderClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.deviceProviderClass, - func (intern *deviceProviderClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeDeviceProviderClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [DeviceProviderClass] is expected to work anymore. @@ -41753,14 +43451,15 @@ func UnsafeDeviceProviderClassToGlibNone(d *DeviceProviderClass) unsafe.Pointer return unsafe.Pointer(d.native) } -// UnsafeDeviceProviderClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeDeviceProviderClassToGlibFull(d *DeviceProviderClass) unsafe.Pointer { - runtime.SetFinalizer(d.deviceProviderClass, nil) - _p := unsafe.Pointer(d.native) - d.native = nil // DeviceProviderClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (d *DeviceProviderClass) ParentClass() *ObjectClass { + parent := UnsafeObjectClassFromGlibBorrow(UnsafeDeviceProviderClassToGlibNone(d)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *DeviceProviderClass) {}, d) + return parent } + // AddMetadata wraps gst_device_provider_class_add_metadata // // The function takes the following parameters: @@ -41936,6 +43635,8 @@ func (klass *DeviceProviderClass) SetStaticMetadata(longname string, classificat // DeviceProviderFactoryClass wraps GstDeviceProviderFactoryClass // // The opaque #GstDeviceProviderFactoryClass data structure. +// +// DeviceProviderFactoryClass is the type struct for [DeviceProviderFactory] type DeviceProviderFactoryClass struct { *deviceProviderFactoryClass } @@ -41950,31 +43651,6 @@ func UnsafeDeviceProviderFactoryClassFromGlibBorrow(p unsafe.Pointer) *DevicePro return &DeviceProviderFactoryClass{&deviceProviderFactoryClass{(*C.GstDeviceProviderFactoryClass)(p)}} } -// UnsafeDeviceProviderFactoryClassFromGlibNone is used to convert raw C.GstDeviceProviderFactoryClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeDeviceProviderFactoryClassFromGlibNone(p unsafe.Pointer) *DeviceProviderFactoryClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeDeviceProviderFactoryClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.deviceProviderFactoryClass, - func (intern *deviceProviderFactoryClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeDeviceProviderFactoryClassFromGlibFull is used to convert raw C.GstDeviceProviderFactoryClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeDeviceProviderFactoryClassFromGlibFull(p unsafe.Pointer) *DeviceProviderFactoryClass { - wrapped := UnsafeDeviceProviderFactoryClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.deviceProviderFactoryClass, - func (intern *deviceProviderFactoryClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeDeviceProviderFactoryClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [DeviceProviderFactoryClass] is expected to work anymore. @@ -41987,15 +43663,18 @@ func UnsafeDeviceProviderFactoryClassToGlibNone(d *DeviceProviderFactoryClass) u return unsafe.Pointer(d.native) } -// UnsafeDeviceProviderFactoryClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeDeviceProviderFactoryClassToGlibFull(d *DeviceProviderFactoryClass) unsafe.Pointer { - runtime.SetFinalizer(d.deviceProviderFactoryClass, nil) - _p := unsafe.Pointer(d.native) - d.native = nil // DeviceProviderFactoryClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (d *DeviceProviderFactoryClass) ParentClass() *PluginFeatureClass { + parent := UnsafePluginFeatureClassFromGlibBorrow(UnsafeDeviceProviderFactoryClassToGlibNone(d)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *DeviceProviderFactoryClass) {}, d) + return parent } + // DynamicTypeFactoryClass wraps GstDynamicTypeFactoryClass +// +// DynamicTypeFactoryClass is the type struct for [DynamicTypeFactory] type DynamicTypeFactoryClass struct { *dynamicTypeFactoryClass } @@ -42010,31 +43689,6 @@ func UnsafeDynamicTypeFactoryClassFromGlibBorrow(p unsafe.Pointer) *DynamicTypeF return &DynamicTypeFactoryClass{&dynamicTypeFactoryClass{(*C.GstDynamicTypeFactoryClass)(p)}} } -// UnsafeDynamicTypeFactoryClassFromGlibNone is used to convert raw C.GstDynamicTypeFactoryClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeDynamicTypeFactoryClassFromGlibNone(p unsafe.Pointer) *DynamicTypeFactoryClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeDynamicTypeFactoryClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.dynamicTypeFactoryClass, - func (intern *dynamicTypeFactoryClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeDynamicTypeFactoryClassFromGlibFull is used to convert raw C.GstDynamicTypeFactoryClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeDynamicTypeFactoryClassFromGlibFull(p unsafe.Pointer) *DynamicTypeFactoryClass { - wrapped := UnsafeDynamicTypeFactoryClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.dynamicTypeFactoryClass, - func (intern *dynamicTypeFactoryClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeDynamicTypeFactoryClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [DynamicTypeFactoryClass] is expected to work anymore. @@ -42047,18 +43701,21 @@ func UnsafeDynamicTypeFactoryClassToGlibNone(d *DynamicTypeFactoryClass) unsafe. return unsafe.Pointer(d.native) } -// UnsafeDynamicTypeFactoryClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeDynamicTypeFactoryClassToGlibFull(d *DynamicTypeFactoryClass) unsafe.Pointer { - runtime.SetFinalizer(d.dynamicTypeFactoryClass, nil) - _p := unsafe.Pointer(d.native) - d.native = nil // DynamicTypeFactoryClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (d *DynamicTypeFactoryClass) ParentClass() *PluginFeatureClass { + parent := UnsafePluginFeatureClassFromGlibBorrow(UnsafeDynamicTypeFactoryClassToGlibNone(d)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *DynamicTypeFactoryClass) {}, d) + return parent } + // ElementClass wraps GstElementClass // // GStreamer element class. Override the vmethods to implement the element // functionality. +// +// ElementClass is the type struct for [Element] type ElementClass struct { *elementClass } @@ -42073,31 +43730,6 @@ func UnsafeElementClassFromGlibBorrow(p unsafe.Pointer) *ElementClass { return &ElementClass{&elementClass{(*C.GstElementClass)(p)}} } -// UnsafeElementClassFromGlibNone is used to convert raw C.GstElementClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeElementClassFromGlibNone(p unsafe.Pointer) *ElementClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeElementClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.elementClass, - func (intern *elementClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeElementClassFromGlibFull is used to convert raw C.GstElementClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeElementClassFromGlibFull(p unsafe.Pointer) *ElementClass { - wrapped := UnsafeElementClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.elementClass, - func (intern *elementClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeElementClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [ElementClass] is expected to work anymore. @@ -42110,14 +43742,15 @@ func UnsafeElementClassToGlibNone(e *ElementClass) unsafe.Pointer { return unsafe.Pointer(e.native) } -// UnsafeElementClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeElementClassToGlibFull(e *ElementClass) unsafe.Pointer { - runtime.SetFinalizer(e.elementClass, nil) - _p := unsafe.Pointer(e.native) - e.native = nil // ElementClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (e *ElementClass) ParentClass() *ObjectClass { + parent := UnsafeObjectClassFromGlibBorrow(UnsafeElementClassToGlibNone(e)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *ElementClass) {}, e) + return parent } + // AddMetadata wraps gst_element_class_add_metadata // // The function takes the following parameters: @@ -42313,6 +43946,7 @@ func (elementClass *ElementClass) GetPadTemplate(name string) PadTemplate { } // GetPadTemplateList wraps gst_element_class_get_pad_template_list +// // The function returns the following values: // // - goret []PadTemplate @@ -42432,6 +44066,8 @@ func (klass *ElementClass) SetStaticMetadata(longname string, classification str } // ElementFactoryClass wraps GstElementFactoryClass +// +// ElementFactoryClass is the type struct for [ElementFactory] type ElementFactoryClass struct { *elementFactoryClass } @@ -42446,31 +44082,6 @@ func UnsafeElementFactoryClassFromGlibBorrow(p unsafe.Pointer) *ElementFactoryCl return &ElementFactoryClass{&elementFactoryClass{(*C.GstElementFactoryClass)(p)}} } -// UnsafeElementFactoryClassFromGlibNone is used to convert raw C.GstElementFactoryClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeElementFactoryClassFromGlibNone(p unsafe.Pointer) *ElementFactoryClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeElementFactoryClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.elementFactoryClass, - func (intern *elementFactoryClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeElementFactoryClassFromGlibFull is used to convert raw C.GstElementFactoryClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeElementFactoryClassFromGlibFull(p unsafe.Pointer) *ElementFactoryClass { - wrapped := UnsafeElementFactoryClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.elementFactoryClass, - func (intern *elementFactoryClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeElementFactoryClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [ElementFactoryClass] is expected to work anymore. @@ -42483,14 +44094,15 @@ func UnsafeElementFactoryClassToGlibNone(e *ElementFactoryClass) unsafe.Pointer return unsafe.Pointer(e.native) } -// UnsafeElementFactoryClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeElementFactoryClassToGlibFull(e *ElementFactoryClass) unsafe.Pointer { - runtime.SetFinalizer(e.elementFactoryClass, nil) - _p := unsafe.Pointer(e.native) - e.native = nil // ElementFactoryClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (e *ElementFactoryClass) ParentClass() *PluginFeatureClass { + parent := UnsafePluginFeatureClassFromGlibBorrow(UnsafeElementFactoryClassToGlibNone(e)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *ElementFactoryClass) {}, e) + return parent } + // Event wraps GstEvent // // The event class provides factory methods to construct events for sending @@ -42560,7 +44172,7 @@ func UnsafeEventFromGlibBorrow(p unsafe.Pointer) *Event { return &Event{&event{(*C.GstEvent)(p)}} } -// UnsafeEventFromGlibNone is used to convert raw C.GstEvent pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeEventFromGlibNone is used to convert raw C.GstEvent pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeEventFromGlibNone(p unsafe.Pointer) *Event { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeEventFromGlibBorrow(p) @@ -42573,7 +44185,7 @@ func UnsafeEventFromGlibNone(p unsafe.Pointer) *Event { return wrapped } -// UnsafeEventFromGlibFull is used to convert raw C.GstEvent pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeEventFromGlibFull is used to convert raw C.GstEvent pointers to go while taking ownership. This is used by the bindings internally. func UnsafeEventFromGlibFull(p unsafe.Pointer) *Event { wrapped := UnsafeEventFromGlibBorrow(p) runtime.SetFinalizer( @@ -42605,6 +44217,7 @@ func UnsafeEventToGlibFull(e *Event) unsafe.Pointer { e.native = nil // Event is invalid from here on return _p } + // NewEventBufferSize wraps gst_event_new_buffer_size // // The function takes the following parameters: @@ -42720,6 +44333,7 @@ func NewEventCustom(typ EventType, structure *Structure) *Event { } // NewEventEos wraps gst_event_new_eos +// // The function returns the following values: // // - goret *Event @@ -42750,6 +44364,7 @@ func NewEventEos() *Event { } // NewEventFlushStart wraps gst_event_new_flush_start +// // The function returns the following values: // // - goret *Event @@ -43150,6 +44765,7 @@ func NewEventQos(typ QOSType, proportion float64, diff ClockTimeDiff, timestamp } // NewEventReconfigure wraps gst_event_new_reconfigure +// // The function returns the following values: // // - goret *Event @@ -43671,6 +45287,7 @@ func (event *Event) CopySegment(segment *Segment) { } // GetRunningTimeOffset wraps gst_event_get_running_time_offset +// // The function returns the following values: // // - goret int64 @@ -43701,6 +45318,7 @@ func (event *Event) GetRunningTimeOffset() int64 { } // GetSeqnum wraps gst_event_get_seqnum +// // The function returns the following values: // // - goret uint32 @@ -43734,6 +45352,7 @@ func (event *Event) GetSeqnum() uint32 { } // GetStructure wraps gst_event_get_structure +// // The function returns the following values: // // - goret *Structure (nullable) @@ -43825,6 +45444,7 @@ func (event *Event) HasNameID(name glib.Quark) bool { } // ParseBufferSize wraps gst_event_parse_buffer_size +// // The function returns the following values: // // - format Format: A pointer to store the format in @@ -43861,6 +45481,7 @@ func (event *Event) ParseBufferSize() (Format, int64, int64, bool) { } // ParseCaps wraps gst_event_parse_caps +// // The function returns the following values: // // - caps *Caps: A pointer to the caps @@ -43884,6 +45505,7 @@ func (event *Event) ParseCaps() *Caps { } // ParseFlushStop wraps gst_event_parse_flush_stop +// // The function returns the following values: // // - resetTime bool: if time should be reset @@ -43908,6 +45530,7 @@ func (event *Event) ParseFlushStop() bool { } // ParseGap wraps gst_event_parse_gap +// // The function returns the following values: // // - timestamp ClockTime: location where to store the @@ -43936,6 +45559,7 @@ func (event *Event) ParseGap() (ClockTime, ClockTime) { } // ParseGapFlags wraps gst_event_parse_gap_flags +// // The function returns the following values: // // - flags GapFlags: a #GstGapFlags or %NULL @@ -43959,6 +45583,7 @@ func (event *Event) ParseGapFlags() GapFlags { } // ParseGroupID wraps gst_event_parse_group_id +// // The function returns the following values: // // - groupId uint: address of variable where to store the group id @@ -43985,6 +45610,7 @@ func (event *Event) ParseGroupID() (uint, bool) { } // ParseInstantRateChange wraps gst_event_parse_instant_rate_change +// // The function returns the following values: // // - rateMultiplier float64: location in which to store the rate @@ -44013,6 +45639,7 @@ func (event *Event) ParseInstantRateChange() (float64, SegmentFlags) { } // ParseInstantRateSyncTime wraps gst_event_parse_instant_rate_sync_time +// // The function returns the following values: // // - rateMultiplier float64: location where to store the rate of @@ -44046,6 +45673,7 @@ func (event *Event) ParseInstantRateSyncTime() (float64, ClockTime, ClockTime) { } // ParseLatency wraps gst_event_parse_latency +// // The function returns the following values: // // - latency ClockTime: A pointer to store the latency in. @@ -44068,6 +45696,7 @@ func (event *Event) ParseLatency() ClockTime { } // ParseProtection wraps gst_event_parse_protection +// // The function returns the following values: // // - systemId string: pointer to store the UUID @@ -44104,6 +45733,7 @@ func (event *Event) ParseProtection() (string, *Buffer, string) { } // ParseQos wraps gst_event_parse_qos +// // The function returns the following values: // // - typ QOSType: A pointer to store the QoS type in @@ -44141,6 +45771,7 @@ func (event *Event) ParseQos() (QOSType, float64, ClockTimeDiff, ClockTime) { } // ParseSeek wraps gst_event_parse_seek +// // The function returns the following values: // // - rate float64: result location for the rate @@ -44187,6 +45818,7 @@ func (event *Event) ParseSeek() (float64, Format, SeekFlags, SeekType, int64, Se } // ParseSeekTrickmodeInterval wraps gst_event_parse_seek_trickmode_interval +// // The function returns the following values: // // - interval ClockTime: interval @@ -44210,6 +45842,7 @@ func (event *Event) ParseSeekTrickmodeInterval() ClockTime { } // ParseSegment wraps gst_event_parse_segment +// // The function returns the following values: // // - segment *Segment: a pointer to a #GstSegment @@ -44234,6 +45867,7 @@ func (event *Event) ParseSegment() *Segment { } // ParseSegmentDone wraps gst_event_parse_segment_done +// // The function returns the following values: // // - format Format: Result location for the format, or %NULL @@ -44260,6 +45894,7 @@ func (event *Event) ParseSegmentDone() (Format, int64) { } // ParseSinkMessage wraps gst_event_parse_sink_message +// // The function returns the following values: // // - msg *Message: a pointer to store the #GstMessage in. @@ -44282,6 +45917,7 @@ func (event *Event) ParseSinkMessage() *Message { } // ParseStep wraps gst_event_parse_step +// // The function returns the following values: // // - format Format: a pointer to store the format in @@ -44325,6 +45961,7 @@ func (event *Event) ParseStep() (Format, uint64, float64, bool, bool) { } // ParseStream wraps gst_event_parse_stream +// // The function returns the following values: // // - stream Stream: address of variable to store the stream @@ -44347,6 +45984,7 @@ func (event *Event) ParseStream() Stream { } // ParseStreamCollection wraps gst_event_parse_stream_collection +// // The function returns the following values: // // - collection StreamCollection: pointer to store the collection. @@ -44369,6 +46007,7 @@ func (event *Event) ParseStreamCollection() StreamCollection { } // ParseStreamFlags wraps gst_event_parse_stream_flags +// // The function returns the following values: // // - flags StreamFlags: address of variable where to store the stream flags @@ -44389,6 +46028,7 @@ func (event *Event) ParseStreamFlags() StreamFlags { } // ParseStreamGroupDone wraps gst_event_parse_stream_group_done +// // The function returns the following values: // // - groupId uint: address of variable to store the group id into @@ -44412,6 +46052,7 @@ func (event *Event) ParseStreamGroupDone() uint { } // ParseStreamStart wraps gst_event_parse_stream_start +// // The function returns the following values: // // - streamId string: pointer to store the stream-id @@ -44437,6 +46078,7 @@ func (event *Event) ParseStreamStart() string { } // ParseTag wraps gst_event_parse_tag +// // The function returns the following values: // // - taglist *TagList: pointer to metadata list @@ -44462,6 +46104,7 @@ func (event *Event) ParseTag() *TagList { } // ParseToc wraps gst_event_parse_toc +// // The function returns the following values: // // - toc *Toc: pointer to #GstToc structure. @@ -44490,6 +46133,7 @@ func (event *Event) ParseToc() (*Toc, bool) { } // ParseTocSelect wraps gst_event_parse_toc_select +// // The function returns the following values: // // - uid string: storage for the selection UID. @@ -44662,6 +46306,7 @@ func (event *Event) SetStreamFlags(flags StreamFlags) { } // WritableStructure wraps gst_event_writable_structure +// // The function returns the following values: // // - goret *Structure @@ -44700,7 +46345,7 @@ func UnsafeFormatDefinitionFromGlibBorrow(p unsafe.Pointer) *FormatDefinition { return &FormatDefinition{&formatDefinition{(*C.GstFormatDefinition)(p)}} } -// UnsafeFormatDefinitionFromGlibNone is used to convert raw C.GstFormatDefinition pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeFormatDefinitionFromGlibNone is used to convert raw C.GstFormatDefinition pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeFormatDefinitionFromGlibNone(p unsafe.Pointer) *FormatDefinition { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeFormatDefinitionFromGlibBorrow(p) @@ -44713,7 +46358,7 @@ func UnsafeFormatDefinitionFromGlibNone(p unsafe.Pointer) *FormatDefinition { return wrapped } -// UnsafeFormatDefinitionFromGlibFull is used to convert raw C.GstFormatDefinition pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeFormatDefinitionFromGlibFull is used to convert raw C.GstFormatDefinition pointers to go while taking ownership. This is used by the bindings internally. func UnsafeFormatDefinitionFromGlibFull(p unsafe.Pointer) *FormatDefinition { wrapped := UnsafeFormatDefinitionFromGlibBorrow(p) runtime.SetFinalizer( @@ -44745,7 +46390,10 @@ func UnsafeFormatDefinitionToGlibFull(f *FormatDefinition) unsafe.Pointer { f.native = nil // FormatDefinition is invalid from here on return _p } + // GhostPadClass wraps GstGhostPadClass +// +// GhostPadClass is the type struct for [GhostPad] type GhostPadClass struct { *ghostPadClass } @@ -44760,31 +46408,6 @@ func UnsafeGhostPadClassFromGlibBorrow(p unsafe.Pointer) *GhostPadClass { return &GhostPadClass{&ghostPadClass{(*C.GstGhostPadClass)(p)}} } -// UnsafeGhostPadClassFromGlibNone is used to convert raw C.GstGhostPadClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeGhostPadClassFromGlibNone(p unsafe.Pointer) *GhostPadClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeGhostPadClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.ghostPadClass, - func (intern *ghostPadClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeGhostPadClassFromGlibFull is used to convert raw C.GstGhostPadClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeGhostPadClassFromGlibFull(p unsafe.Pointer) *GhostPadClass { - wrapped := UnsafeGhostPadClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.ghostPadClass, - func (intern *ghostPadClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeGhostPadClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [GhostPadClass] is expected to work anymore. @@ -44797,14 +46420,15 @@ func UnsafeGhostPadClassToGlibNone(g *GhostPadClass) unsafe.Pointer { return unsafe.Pointer(g.native) } -// UnsafeGhostPadClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeGhostPadClassToGlibFull(g *GhostPadClass) unsafe.Pointer { - runtime.SetFinalizer(g.ghostPadClass, nil) - _p := unsafe.Pointer(g.native) - g.native = nil // GhostPadClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (g *GhostPadClass) ParentClass() *ProxyPadClass { + parent := UnsafeProxyPadClassFromGlibBorrow(UnsafeGhostPadClassToGlibNone(g)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *GhostPadClass) {}, g) + return parent } + // Iterator wraps GstIterator // // A GstIterator is used to retrieve multiple objects from another object in @@ -44871,7 +46495,7 @@ func UnsafeIteratorFromGlibBorrow(p unsafe.Pointer) *Iterator { return &Iterator{&iterator{(*C.GstIterator)(p)}} } -// UnsafeIteratorFromGlibNone is used to convert raw C.GstIterator pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeIteratorFromGlibNone is used to convert raw C.GstIterator pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeIteratorFromGlibNone(p unsafe.Pointer) *Iterator { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeIteratorFromGlibBorrow(p) @@ -44884,7 +46508,7 @@ func UnsafeIteratorFromGlibNone(p unsafe.Pointer) *Iterator { return wrapped } -// UnsafeIteratorFromGlibFull is used to convert raw C.GstIterator pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeIteratorFromGlibFull is used to convert raw C.GstIterator pointers to go while taking ownership. This is used by the bindings internally. func UnsafeIteratorFromGlibFull(p unsafe.Pointer) *Iterator { wrapped := UnsafeIteratorFromGlibBorrow(p) runtime.SetFinalizer( @@ -44916,6 +46540,7 @@ func UnsafeIteratorToGlibFull(i *Iterator) unsafe.Pointer { i.native = nil // Iterator is invalid from here on return _p } + // NewIteratorSingle wraps gst_iterator_new_single // // The function takes the following parameters: @@ -44951,6 +46576,7 @@ func NewIteratorSingle(typ gobject.Type, object *gobject.Value) *Iterator { } // Copy wraps gst_iterator_copy +// // The function returns the following values: // // - goret *Iterator @@ -45168,7 +46794,7 @@ func UnsafeMemoryFromGlibBorrow(p unsafe.Pointer) *Memory { return &Memory{&memory{(*C.GstMemory)(p)}} } -// UnsafeMemoryFromGlibNone is used to convert raw C.GstMemory pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeMemoryFromGlibNone is used to convert raw C.GstMemory pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeMemoryFromGlibNone(p unsafe.Pointer) *Memory { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeMemoryFromGlibBorrow(p) @@ -45181,7 +46807,7 @@ func UnsafeMemoryFromGlibNone(p unsafe.Pointer) *Memory { return wrapped } -// UnsafeMemoryFromGlibFull is used to convert raw C.GstMemory pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeMemoryFromGlibFull is used to convert raw C.GstMemory pointers to go while taking ownership. This is used by the bindings internally. func UnsafeMemoryFromGlibFull(p unsafe.Pointer) *Memory { wrapped := UnsafeMemoryFromGlibBorrow(p) runtime.SetFinalizer( @@ -45213,6 +46839,7 @@ func UnsafeMemoryToGlibFull(m *Memory) unsafe.Pointer { m.native = nil // Memory is invalid from here on return _p } + // Copy wraps gst_memory_copy // // The function takes the following parameters: @@ -45252,6 +46879,7 @@ func (mem *Memory) Copy(offset int, size int) *Memory { } // GetSizes wraps gst_memory_get_sizes +// // The function returns the following values: // // - offset uint: pointer to offset @@ -45462,7 +47090,7 @@ func UnsafeMessageFromGlibBorrow(p unsafe.Pointer) *Message { return &Message{&message{(*C.GstMessage)(p)}} } -// UnsafeMessageFromGlibNone is used to convert raw C.GstMessage pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeMessageFromGlibNone is used to convert raw C.GstMessage pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeMessageFromGlibNone(p unsafe.Pointer) *Message { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeMessageFromGlibBorrow(p) @@ -45475,7 +47103,7 @@ func UnsafeMessageFromGlibNone(p unsafe.Pointer) *Message { return wrapped } -// UnsafeMessageFromGlibFull is used to convert raw C.GstMessage pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeMessageFromGlibFull is used to convert raw C.GstMessage pointers to go while taking ownership. This is used by the bindings internally. func UnsafeMessageFromGlibFull(p unsafe.Pointer) *Message { wrapped := UnsafeMessageFromGlibBorrow(p) runtime.SetFinalizer( @@ -45507,6 +47135,7 @@ func UnsafeMessageToGlibFull(m *Message) unsafe.Pointer { m.native = nil // Message is invalid from here on return _p } + // NewMessageApplication wraps gst_message_new_application // // The function takes the following parameters: @@ -47250,6 +48879,7 @@ func (message *Message) AddRedirectEntry(location string, tagList *TagList, entr } // Copy wraps gst_message_copy +// // The function returns the following values: // // - goret *Message @@ -47272,6 +48902,7 @@ func (msg *Message) Copy() *Message { } // GetNumRedirectEntries wraps gst_message_get_num_redirect_entries +// // The function returns the following values: // // - goret uint @@ -47292,6 +48923,7 @@ func (message *Message) GetNumRedirectEntries() uint { } // GetSeqnum wraps gst_message_get_seqnum +// // The function returns the following values: // // - goret uint32 @@ -47325,6 +48957,7 @@ func (message *Message) GetSeqnum() uint32 { } // GetStructure wraps gst_message_get_structure +// // The function returns the following values: // // - goret *Structure (nullable) @@ -47384,6 +49017,7 @@ func (message *Message) HasName(name string) bool { } // ParseAsyncDone wraps gst_message_parse_async_done +// // The function returns the following values: // // - runningTime ClockTime: Result location for the running_time or %NULL @@ -47408,6 +49042,7 @@ func (message *Message) ParseAsyncDone() ClockTime { } // ParseBuffering wraps gst_message_parse_buffering +// // The function returns the following values: // // - percent int: Return location for the percent. @@ -47433,6 +49068,7 @@ func (message *Message) ParseBuffering() int { } // ParseBufferingStats wraps gst_message_parse_buffering_stats +// // The function returns the following values: // // - mode BufferingMode: a buffering mode, or %NULL @@ -47468,6 +49104,7 @@ func (message *Message) ParseBufferingStats() (BufferingMode, int, int, int64) { } // ParseClockLost wraps gst_message_parse_clock_lost +// // The function returns the following values: // // - clock Clock: a pointer to hold the lost clock @@ -47493,6 +49130,7 @@ func (message *Message) ParseClockLost() Clock { } // ParseClockProvide wraps gst_message_parse_clock_provide +// // The function returns the following values: // // - clock Clock: a pointer to hold a clock @@ -47525,6 +49163,7 @@ func (message *Message) ParseClockProvide() (Clock, bool) { } // ParseContextType wraps gst_message_parse_context_type +// // The function returns the following values: // // - contextType string: the context type, or %NULL @@ -47553,6 +49192,7 @@ func (message *Message) ParseContextType() (string, bool) { } // ParseDeviceAdded wraps gst_message_parse_device_added +// // The function returns the following values: // // - device Device: A location where to store a @@ -47578,6 +49218,7 @@ func (message *Message) ParseDeviceAdded() Device { } // ParseDeviceChanged wraps gst_message_parse_device_changed +// // The function returns the following values: // // - device Device: A location where to store a @@ -47609,6 +49250,7 @@ func (message *Message) ParseDeviceChanged() (Device, Device) { } // ParseDeviceRemoved wraps gst_message_parse_device_removed +// // The function returns the following values: // // - device Device: A location where to store a @@ -47634,6 +49276,7 @@ func (message *Message) ParseDeviceRemoved() Device { } // ParseError wraps gst_message_parse_error +// // The function returns the following values: // // - debug string (nullable): location for the debug message, @@ -47688,6 +49331,7 @@ func (message *Message) ParseError() (string, error) { } // ParseErrorDetails wraps gst_message_parse_error_details +// // The function returns the following values: // // - structure *Structure (nullable): A pointer to the returned details @@ -47713,6 +49357,7 @@ func (message *Message) ParseErrorDetails() *Structure { } // ParseGroupID wraps gst_message_parse_group_id +// // The function returns the following values: // // - groupId uint: Result location for the group id or @@ -47742,6 +49387,7 @@ func (message *Message) ParseGroupID() (uint, bool) { } // ParseHaveContext wraps gst_message_parse_have_context +// // The function returns the following values: // // - _context *Context: Result location for the @@ -47767,6 +49413,7 @@ func (message *Message) ParseHaveContext() *Context { } // ParseInfo wraps gst_message_parse_info +// // The function returns the following values: // // - debug string (nullable): location for the debug message, @@ -47800,6 +49447,7 @@ func (message *Message) ParseInfo() (string, error) { } // ParseInfoDetails wraps gst_message_parse_info_details +// // The function returns the following values: // // - structure *Structure (nullable): A pointer to the returned details @@ -47825,6 +49473,7 @@ func (message *Message) ParseInfoDetails() *Structure { } // ParseInstantRateRequest wraps gst_message_parse_instant_rate_request +// // The function returns the following values: // // - rateMultiplier float64: return location for the rate, or %NULL @@ -47847,6 +49496,7 @@ func (message *Message) ParseInstantRateRequest() float64 { } // ParseNewClock wraps gst_message_parse_new_clock +// // The function returns the following values: // // - clock Clock: a pointer to hold the selected @@ -47873,6 +49523,7 @@ func (message *Message) ParseNewClock() Clock { } // ParseProgress wraps gst_message_parse_progress +// // The function returns the following values: // // - typ ProgressType: location for the type @@ -47905,6 +49556,7 @@ func (message *Message) ParseProgress() (ProgressType, string, string) { } // ParseQos wraps gst_message_parse_qos +// // The function returns the following values: // // - live bool: if the message was generated by a live element @@ -47955,6 +49607,7 @@ func (message *Message) ParseQos() (bool, uint64, uint64, uint64, uint64) { } // ParseQosStats wraps gst_message_parse_qos_stats +// // The function returns the following values: // // - format Format: Units of the 'processed' and 'dropped' fields. @@ -47996,6 +49649,7 @@ func (message *Message) ParseQosStats() (Format, uint64, uint64) { } // ParseQosValues wraps gst_message_parse_qos_values +// // The function returns the following values: // // - jitter int64: The difference of the running-time against @@ -48079,6 +49733,7 @@ func (message *Message) ParseRedirectEntry(entryIndex uint) (string, *TagList, * } // ParseRequestState wraps gst_message_parse_request_state +// // The function returns the following values: // // - state State: Result location for the requested state or %NULL @@ -48103,6 +49758,7 @@ func (message *Message) ParseRequestState() State { } // ParseResetTime wraps gst_message_parse_reset_time +// // The function returns the following values: // // - runningTime ClockTime: Result location for the running_time or @@ -48128,6 +49784,7 @@ func (message *Message) ParseResetTime() ClockTime { } // ParseSegmentDone wraps gst_message_parse_segment_done +// // The function returns the following values: // // - format Format: Result location for the format, or %NULL @@ -48156,6 +49813,7 @@ func (message *Message) ParseSegmentDone() (Format, int64) { } // ParseSegmentStart wraps gst_message_parse_segment_start +// // The function returns the following values: // // - format Format: Result location for the format, or %NULL @@ -48184,6 +49842,7 @@ func (message *Message) ParseSegmentStart() (Format, int64) { } // ParseStateChanged wraps gst_message_parse_state_changed +// // The function returns the following values: // // - oldstate State: the previous state, or %NULL @@ -48235,6 +49894,7 @@ func (message *Message) ParseStateChanged() (State, State, State) { } // ParseStepDone wraps gst_message_parse_step_done +// // The function returns the following values: // // - format Format: result location for the format @@ -48289,6 +49949,7 @@ func (message *Message) ParseStepDone() (Format, uint64, float64, bool, bool, ui } // ParseStepStart wraps gst_message_parse_step_start +// // The function returns the following values: // // - active bool: result location for the active flag @@ -48339,6 +50000,7 @@ func (message *Message) ParseStepStart() (bool, Format, uint64, float64, bool, b } // ParseStreamCollection wraps gst_message_parse_stream_collection +// // The function returns the following values: // // - collection StreamCollection: A location where to store a @@ -48362,6 +50024,7 @@ func (message *Message) ParseStreamCollection() StreamCollection { } // ParseStreamStatus wraps gst_message_parse_stream_status +// // The function returns the following values: // // - typ StreamStatusType: A pointer to hold the status type @@ -48392,6 +50055,7 @@ func (message *Message) ParseStreamStatus() (StreamStatusType, Element) { } // ParseStreamsSelected wraps gst_message_parse_streams_selected +// // The function returns the following values: // // - collection StreamCollection: A location where to store a @@ -48415,6 +50079,7 @@ func (message *Message) ParseStreamsSelected() StreamCollection { } // ParseStructureChange wraps gst_message_parse_structure_change +// // The function returns the following values: // // - typ StructureChangeType: A pointer to hold the change type @@ -48451,6 +50116,7 @@ func (message *Message) ParseStructureChange() (StructureChangeType, Element, bo } // ParseTag wraps gst_message_parse_tag +// // The function returns the following values: // // - tagList *TagList: return location for the tag-list. @@ -48494,6 +50160,7 @@ func (message *Message) ParseTag() *TagList { } // ParseToc wraps gst_message_parse_toc +// // The function returns the following values: // // - toc *Toc: return location for the TOC. @@ -48526,6 +50193,7 @@ func (message *Message) ParseToc() (*Toc, bool) { } // ParseWarning wraps gst_message_parse_warning +// // The function returns the following values: // // - debug string (nullable): location for the debug message, @@ -48559,6 +50227,7 @@ func (message *Message) ParseWarning() (string, error) { } // ParseWarningDetails wraps gst_message_parse_warning_details +// // The function returns the following values: // // - structure *Structure (nullable): A pointer to the returned details @@ -48774,6 +50443,7 @@ func (message *Message) StreamsSelectedAdd(stream Stream) { } // StreamsSelectedGetSize wraps gst_message_streams_selected_get_size +// // The function returns the following values: // // - goret uint @@ -48828,6 +50498,7 @@ func (message *Message) StreamsSelectedGetStream(idx uint) Stream { } // WritableStructure wraps gst_message_writable_structure +// // The function returns the following values: // // - goret *Structure @@ -48885,7 +50556,7 @@ func UnsafeMetaFromGlibBorrow(p unsafe.Pointer) *Meta { return &Meta{&meta{(*C.GstMeta)(p)}} } -// UnsafeMetaFromGlibNone is used to convert raw C.GstMeta pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeMetaFromGlibNone is used to convert raw C.GstMeta pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeMetaFromGlibNone(p unsafe.Pointer) *Meta { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeMetaFromGlibBorrow(p) @@ -48898,7 +50569,7 @@ func UnsafeMetaFromGlibNone(p unsafe.Pointer) *Meta { return wrapped } -// UnsafeMetaFromGlibFull is used to convert raw C.GstMeta pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeMetaFromGlibFull is used to convert raw C.GstMeta pointers to go while taking ownership. This is used by the bindings internally. func UnsafeMetaFromGlibFull(p unsafe.Pointer) *Meta { wrapped := UnsafeMetaFromGlibBorrow(p) runtime.SetFinalizer( @@ -48930,6 +50601,7 @@ func UnsafeMetaToGlibFull(m *Meta) unsafe.Pointer { m.native = nil // Meta is invalid from here on return _p } + // MetaApiTypeGetTags wraps gst_meta_api_type_get_tags // // The function takes the following parameters: @@ -49168,6 +50840,7 @@ func (meta1 *Meta) CompareSeqnum(meta2 *Meta) int { } // GetSeqnum wraps gst_meta_get_seqnum +// // The function returns the following values: // // - goret uint64 @@ -49250,7 +50923,7 @@ func UnsafeMetaInfoFromGlibBorrow(p unsafe.Pointer) *MetaInfo { return &MetaInfo{&metaInfo{(*C.GstMetaInfo)(p)}} } -// UnsafeMetaInfoFromGlibNone is used to convert raw C.GstMetaInfo pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeMetaInfoFromGlibNone is used to convert raw C.GstMetaInfo pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeMetaInfoFromGlibNone(p unsafe.Pointer) *MetaInfo { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeMetaInfoFromGlibBorrow(p) @@ -49263,7 +50936,7 @@ func UnsafeMetaInfoFromGlibNone(p unsafe.Pointer) *MetaInfo { return wrapped } -// UnsafeMetaInfoFromGlibFull is used to convert raw C.GstMetaInfo pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeMetaInfoFromGlibFull is used to convert raw C.GstMetaInfo pointers to go while taking ownership. This is used by the bindings internally. func UnsafeMetaInfoFromGlibFull(p unsafe.Pointer) *MetaInfo { wrapped := UnsafeMetaInfoFromGlibBorrow(p) runtime.SetFinalizer( @@ -49295,7 +50968,9 @@ func UnsafeMetaInfoToGlibFull(m *MetaInfo) unsafe.Pointer { m.native = nil // MetaInfo is invalid from here on return _p } + // IsCustom wraps gst_meta_info_is_custom +// // The function returns the following values: // // - goret bool @@ -49318,6 +50993,7 @@ func (info *MetaInfo) IsCustom() bool { } // Register wraps gst_meta_info_register +// // The function returns the following values: // // - goret *MetaInfo @@ -49360,7 +51036,7 @@ func UnsafeMetaTransformCopyFromGlibBorrow(p unsafe.Pointer) *MetaTransformCopy return &MetaTransformCopy{&metaTransformCopy{(*C.GstMetaTransformCopy)(p)}} } -// UnsafeMetaTransformCopyFromGlibNone is used to convert raw C.GstMetaTransformCopy pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeMetaTransformCopyFromGlibNone is used to convert raw C.GstMetaTransformCopy pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeMetaTransformCopyFromGlibNone(p unsafe.Pointer) *MetaTransformCopy { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeMetaTransformCopyFromGlibBorrow(p) @@ -49373,7 +51049,7 @@ func UnsafeMetaTransformCopyFromGlibNone(p unsafe.Pointer) *MetaTransformCopy { return wrapped } -// UnsafeMetaTransformCopyFromGlibFull is used to convert raw C.GstMetaTransformCopy pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeMetaTransformCopyFromGlibFull is used to convert raw C.GstMetaTransformCopy pointers to go while taking ownership. This is used by the bindings internally. func UnsafeMetaTransformCopyFromGlibFull(p unsafe.Pointer) *MetaTransformCopy { wrapped := UnsafeMetaTransformCopyFromGlibBorrow(p) runtime.SetFinalizer( @@ -49405,6 +51081,7 @@ func UnsafeMetaTransformCopyToGlibFull(m *MetaTransformCopy) unsafe.Pointer { m.native = nil // MetaTransformCopy is invalid from here on return _p } + // MiniObject wraps GstMiniObject // // #GstMiniObject is a simple structure that can be used to implement refcounted @@ -49459,7 +51136,7 @@ func UnsafeMiniObjectFromGlibBorrow(p unsafe.Pointer) *MiniObject { return &MiniObject{&miniObject{(*C.GstMiniObject)(p)}} } -// UnsafeMiniObjectFromGlibNone is used to convert raw C.GstMiniObject pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeMiniObjectFromGlibNone is used to convert raw C.GstMiniObject pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeMiniObjectFromGlibNone(p unsafe.Pointer) *MiniObject { C.gst_mini_object_ref((*C.GstMiniObject)(p)) wrapped := UnsafeMiniObjectFromGlibBorrow(p) @@ -49472,7 +51149,7 @@ func UnsafeMiniObjectFromGlibNone(p unsafe.Pointer) *MiniObject { return wrapped } -// UnsafeMiniObjectFromGlibFull is used to convert raw C.GstMiniObject pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeMiniObjectFromGlibFull is used to convert raw C.GstMiniObject pointers to go while taking ownership. This is used by the bindings internally. func UnsafeMiniObjectFromGlibFull(p unsafe.Pointer) *MiniObject { wrapped := UnsafeMiniObjectFromGlibBorrow(p) runtime.SetFinalizer( @@ -49511,6 +51188,7 @@ func UnsafeMiniObjectToGlibFull(m *MiniObject) unsafe.Pointer { m.native = nil // MiniObject is invalid from here on return _p } + // AddParent wraps gst_mini_object_add_parent // // The function takes the following parameters: @@ -49538,6 +51216,7 @@ func (object *MiniObject) AddParent(parent *MiniObject) { } // IsWritable wraps gst_mini_object_is_writable +// // The function returns the following values: // // - goret bool @@ -49644,6 +51323,8 @@ func (object *MiniObject) Unlock(flags LockFlags) { // ObjectClass wraps GstObjectClass // // GStreamer base object class. +// +// ObjectClass is the type struct for [Object] type ObjectClass struct { *objectClass } @@ -49658,31 +51339,6 @@ func UnsafeObjectClassFromGlibBorrow(p unsafe.Pointer) *ObjectClass { return &ObjectClass{&objectClass{(*C.GstObjectClass)(p)}} } -// UnsafeObjectClassFromGlibNone is used to convert raw C.GstObjectClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeObjectClassFromGlibNone(p unsafe.Pointer) *ObjectClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeObjectClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.objectClass, - func (intern *objectClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeObjectClassFromGlibFull is used to convert raw C.GstObjectClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeObjectClassFromGlibFull(p unsafe.Pointer) *ObjectClass { - wrapped := UnsafeObjectClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.objectClass, - func (intern *objectClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeObjectClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [ObjectClass] is expected to work anymore. @@ -49695,15 +51351,18 @@ func UnsafeObjectClassToGlibNone(o *ObjectClass) unsafe.Pointer { return unsafe.Pointer(o.native) } -// UnsafeObjectClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeObjectClassToGlibFull(o *ObjectClass) unsafe.Pointer { - runtime.SetFinalizer(o.objectClass, nil) - _p := unsafe.Pointer(o.native) - o.native = nil // ObjectClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (o *ObjectClass) ParentClass() *gobject.InitiallyUnownedClass { + parent := gobject.UnsafeInitiallyUnownedClassFromGlibBorrow(UnsafeObjectClassToGlibNone(o)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *ObjectClass) {}, o) + return parent } + // PadClass wraps GstPadClass +// +// PadClass is the type struct for [Pad] type PadClass struct { *padClass } @@ -49718,31 +51377,6 @@ func UnsafePadClassFromGlibBorrow(p unsafe.Pointer) *PadClass { return &PadClass{&padClass{(*C.GstPadClass)(p)}} } -// UnsafePadClassFromGlibNone is used to convert raw C.GstPadClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafePadClassFromGlibNone(p unsafe.Pointer) *PadClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafePadClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.padClass, - func (intern *padClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafePadClassFromGlibFull is used to convert raw C.GstPadClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafePadClassFromGlibFull(p unsafe.Pointer) *PadClass { - wrapped := UnsafePadClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.padClass, - func (intern *padClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafePadClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [PadClass] is expected to work anymore. @@ -49755,14 +51389,15 @@ func UnsafePadClassToGlibNone(p *PadClass) unsafe.Pointer { return unsafe.Pointer(p.native) } -// UnsafePadClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafePadClassToGlibFull(p *PadClass) unsafe.Pointer { - runtime.SetFinalizer(p.padClass, nil) - _p := unsafe.Pointer(p.native) - p.native = nil // PadClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (p *PadClass) ParentClass() *ObjectClass { + parent := UnsafeObjectClassFromGlibBorrow(UnsafePadClassToGlibNone(p)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *PadClass) {}, p) + return parent } + // PadProbeInfo wraps GstPadProbeInfo // // Info passed in the #GstPadProbeCallback. @@ -49780,7 +51415,7 @@ func UnsafePadProbeInfoFromGlibBorrow(p unsafe.Pointer) *PadProbeInfo { return &PadProbeInfo{&padProbeInfo{(*C.GstPadProbeInfo)(p)}} } -// UnsafePadProbeInfoFromGlibNone is used to convert raw C.GstPadProbeInfo pointers to go while taking a reference. This is used by the bindings internally. +// UnsafePadProbeInfoFromGlibNone is used to convert raw C.GstPadProbeInfo pointers to go without transferring ownership. This is used by the bindings internally. func UnsafePadProbeInfoFromGlibNone(p unsafe.Pointer) *PadProbeInfo { // FIXME: this has no ref function, what should we do here? wrapped := UnsafePadProbeInfoFromGlibBorrow(p) @@ -49793,7 +51428,7 @@ func UnsafePadProbeInfoFromGlibNone(p unsafe.Pointer) *PadProbeInfo { return wrapped } -// UnsafePadProbeInfoFromGlibFull is used to convert raw C.GstPadProbeInfo pointers to go while taking a reference. This is used by the bindings internally. +// UnsafePadProbeInfoFromGlibFull is used to convert raw C.GstPadProbeInfo pointers to go while taking ownership. This is used by the bindings internally. func UnsafePadProbeInfoFromGlibFull(p unsafe.Pointer) *PadProbeInfo { wrapped := UnsafePadProbeInfoFromGlibBorrow(p) runtime.SetFinalizer( @@ -49825,7 +51460,9 @@ func UnsafePadProbeInfoToGlibFull(p *PadProbeInfo) unsafe.Pointer { p.native = nil // PadProbeInfo is invalid from here on return _p } + // GetBuffer wraps gst_pad_probe_info_get_buffer +// // The function returns the following values: // // - goret *Buffer (nullable) @@ -49848,6 +51485,7 @@ func (info *PadProbeInfo) GetBuffer() *Buffer { } // GetBufferList wraps gst_pad_probe_info_get_buffer_list +// // The function returns the following values: // // - goret *BufferList (nullable) @@ -49870,6 +51508,7 @@ func (info *PadProbeInfo) GetBufferList() *BufferList { } // GetEvent wraps gst_pad_probe_info_get_event +// // The function returns the following values: // // - goret *Event (nullable) @@ -49892,6 +51531,7 @@ func (info *PadProbeInfo) GetEvent() *Event { } // GetQuery wraps gst_pad_probe_info_get_query +// // The function returns the following values: // // - goret *Query (nullable) @@ -49914,6 +51554,8 @@ func (info *PadProbeInfo) GetQuery() *Query { } // PadTemplateClass wraps GstPadTemplateClass +// +// PadTemplateClass is the type struct for [PadTemplate] type PadTemplateClass struct { *padTemplateClass } @@ -49928,31 +51570,6 @@ func UnsafePadTemplateClassFromGlibBorrow(p unsafe.Pointer) *PadTemplateClass { return &PadTemplateClass{&padTemplateClass{(*C.GstPadTemplateClass)(p)}} } -// UnsafePadTemplateClassFromGlibNone is used to convert raw C.GstPadTemplateClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafePadTemplateClassFromGlibNone(p unsafe.Pointer) *PadTemplateClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafePadTemplateClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.padTemplateClass, - func (intern *padTemplateClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafePadTemplateClassFromGlibFull is used to convert raw C.GstPadTemplateClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafePadTemplateClassFromGlibFull(p unsafe.Pointer) *PadTemplateClass { - wrapped := UnsafePadTemplateClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.padTemplateClass, - func (intern *padTemplateClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafePadTemplateClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [PadTemplateClass] is expected to work anymore. @@ -49965,14 +51582,15 @@ func UnsafePadTemplateClassToGlibNone(p *PadTemplateClass) unsafe.Pointer { return unsafe.Pointer(p.native) } -// UnsafePadTemplateClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafePadTemplateClassToGlibFull(p *PadTemplateClass) unsafe.Pointer { - runtime.SetFinalizer(p.padTemplateClass, nil) - _p := unsafe.Pointer(p.native) - p.native = nil // PadTemplateClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (p *PadTemplateClass) ParentClass() *ObjectClass { + parent := UnsafeObjectClassFromGlibBorrow(UnsafePadTemplateClassToGlibNone(p)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *PadTemplateClass) {}, p) + return parent } + // ParamSpecArray wraps GstParamSpecArray // // A GParamSpec derived structure for arrays of values. @@ -49990,7 +51608,7 @@ func UnsafeParamSpecArrayFromGlibBorrow(p unsafe.Pointer) *ParamSpecArray { return &ParamSpecArray{¶mSpecArray{(*C.GstParamSpecArray)(p)}} } -// UnsafeParamSpecArrayFromGlibNone is used to convert raw C.GstParamSpecArray pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeParamSpecArrayFromGlibNone is used to convert raw C.GstParamSpecArray pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeParamSpecArrayFromGlibNone(p unsafe.Pointer) *ParamSpecArray { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeParamSpecArrayFromGlibBorrow(p) @@ -50003,7 +51621,7 @@ func UnsafeParamSpecArrayFromGlibNone(p unsafe.Pointer) *ParamSpecArray { return wrapped } -// UnsafeParamSpecArrayFromGlibFull is used to convert raw C.GstParamSpecArray pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeParamSpecArrayFromGlibFull is used to convert raw C.GstParamSpecArray pointers to go while taking ownership. This is used by the bindings internally. func UnsafeParamSpecArrayFromGlibFull(p unsafe.Pointer) *ParamSpecArray { wrapped := UnsafeParamSpecArrayFromGlibBorrow(p) runtime.SetFinalizer( @@ -50035,6 +51653,7 @@ func UnsafeParamSpecArrayToGlibFull(p *ParamSpecArray) unsafe.Pointer { p.native = nil // ParamSpecArray is invalid from here on return _p } + // ParamSpecFraction wraps GstParamSpecFraction // // A GParamSpec derived structure that contains the meta data for fractional @@ -50053,7 +51672,7 @@ func UnsafeParamSpecFractionFromGlibBorrow(p unsafe.Pointer) *ParamSpecFraction return &ParamSpecFraction{¶mSpecFraction{(*C.GstParamSpecFraction)(p)}} } -// UnsafeParamSpecFractionFromGlibNone is used to convert raw C.GstParamSpecFraction pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeParamSpecFractionFromGlibNone is used to convert raw C.GstParamSpecFraction pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeParamSpecFractionFromGlibNone(p unsafe.Pointer) *ParamSpecFraction { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeParamSpecFractionFromGlibBorrow(p) @@ -50066,7 +51685,7 @@ func UnsafeParamSpecFractionFromGlibNone(p unsafe.Pointer) *ParamSpecFraction { return wrapped } -// UnsafeParamSpecFractionFromGlibFull is used to convert raw C.GstParamSpecFraction pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeParamSpecFractionFromGlibFull is used to convert raw C.GstParamSpecFraction pointers to go while taking ownership. This is used by the bindings internally. func UnsafeParamSpecFractionFromGlibFull(p unsafe.Pointer) *ParamSpecFraction { wrapped := UnsafeParamSpecFractionFromGlibBorrow(p) runtime.SetFinalizer( @@ -50098,6 +51717,7 @@ func UnsafeParamSpecFractionToGlibFull(p *ParamSpecFraction) unsafe.Pointer { p.native = nil // ParamSpecFraction is invalid from here on return _p } + // ParentBufferMeta wraps GstParentBufferMeta // // The #GstParentBufferMeta is a #GstMeta which can be attached to a #GstBuffer @@ -50122,7 +51742,7 @@ func UnsafeParentBufferMetaFromGlibBorrow(p unsafe.Pointer) *ParentBufferMeta { return &ParentBufferMeta{&parentBufferMeta{(*C.GstParentBufferMeta)(p)}} } -// UnsafeParentBufferMetaFromGlibNone is used to convert raw C.GstParentBufferMeta pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeParentBufferMetaFromGlibNone is used to convert raw C.GstParentBufferMeta pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeParentBufferMetaFromGlibNone(p unsafe.Pointer) *ParentBufferMeta { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeParentBufferMetaFromGlibBorrow(p) @@ -50135,7 +51755,7 @@ func UnsafeParentBufferMetaFromGlibNone(p unsafe.Pointer) *ParentBufferMeta { return wrapped } -// UnsafeParentBufferMetaFromGlibFull is used to convert raw C.GstParentBufferMeta pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeParentBufferMetaFromGlibFull is used to convert raw C.GstParentBufferMeta pointers to go while taking ownership. This is used by the bindings internally. func UnsafeParentBufferMetaFromGlibFull(p unsafe.Pointer) *ParentBufferMeta { wrapped := UnsafeParentBufferMetaFromGlibBorrow(p) runtime.SetFinalizer( @@ -50167,7 +51787,9 @@ func UnsafeParentBufferMetaToGlibFull(p *ParentBufferMeta) unsafe.Pointer { p.native = nil // ParentBufferMeta is invalid from here on return _p } + // ParentBufferMetaGetInfo wraps gst_parent_buffer_meta_get_info +// // The function returns the following values: // // - goret *MetaInfo @@ -50214,7 +51836,7 @@ func UnsafeParseContextFromGlibBorrow(p unsafe.Pointer) *ParseContext { return &ParseContext{&parseContext{(*C.GstParseContext)(p)}} } -// UnsafeParseContextFromGlibNone is used to convert raw C.GstParseContext pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeParseContextFromGlibNone is used to convert raw C.GstParseContext pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeParseContextFromGlibNone(p unsafe.Pointer) *ParseContext { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeParseContextFromGlibBorrow(p) @@ -50227,7 +51849,7 @@ func UnsafeParseContextFromGlibNone(p unsafe.Pointer) *ParseContext { return wrapped } -// UnsafeParseContextFromGlibFull is used to convert raw C.GstParseContext pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeParseContextFromGlibFull is used to convert raw C.GstParseContext pointers to go while taking ownership. This is used by the bindings internally. func UnsafeParseContextFromGlibFull(p unsafe.Pointer) *ParseContext { wrapped := UnsafeParseContextFromGlibBorrow(p) runtime.SetFinalizer( @@ -50259,7 +51881,9 @@ func UnsafeParseContextToGlibFull(p *ParseContext) unsafe.Pointer { p.native = nil // ParseContext is invalid from here on return _p } + // NewParseContext wraps gst_parse_context_new +// // The function returns the following values: // // - goret *ParseContext (nullable) @@ -50283,6 +51907,7 @@ func NewParseContext() *ParseContext { } // Copy wraps gst_parse_context_copy +// // The function returns the following values: // // - goret *ParseContext (nullable) @@ -50307,6 +51932,7 @@ func (_context *ParseContext) Copy() *ParseContext { } // GetMissingElements wraps gst_parse_context_get_missing_elements +// // The function returns the following values: // // - goret []string (nullable) @@ -50333,6 +51959,8 @@ func (_context *ParseContext) GetMissingElements() []string { } // PipelineClass wraps GstPipelineClass +// +// PipelineClass is the type struct for [Pipeline] type PipelineClass struct { *pipelineClass } @@ -50347,31 +51975,6 @@ func UnsafePipelineClassFromGlibBorrow(p unsafe.Pointer) *PipelineClass { return &PipelineClass{&pipelineClass{(*C.GstPipelineClass)(p)}} } -// UnsafePipelineClassFromGlibNone is used to convert raw C.GstPipelineClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafePipelineClassFromGlibNone(p unsafe.Pointer) *PipelineClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafePipelineClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.pipelineClass, - func (intern *pipelineClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafePipelineClassFromGlibFull is used to convert raw C.GstPipelineClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafePipelineClassFromGlibFull(p unsafe.Pointer) *PipelineClass { - wrapped := UnsafePipelineClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.pipelineClass, - func (intern *pipelineClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafePipelineClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [PipelineClass] is expected to work anymore. @@ -50384,15 +51987,18 @@ func UnsafePipelineClassToGlibNone(p *PipelineClass) unsafe.Pointer { return unsafe.Pointer(p.native) } -// UnsafePipelineClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafePipelineClassToGlibFull(p *PipelineClass) unsafe.Pointer { - runtime.SetFinalizer(p.pipelineClass, nil) - _p := unsafe.Pointer(p.native) - p.native = nil // PipelineClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (p *PipelineClass) ParentClass() *BinClass { + parent := UnsafeBinClassFromGlibBorrow(UnsafePipelineClassToGlibNone(p)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *PipelineClass) {}, p) + return parent } + // PluginClass wraps GstPluginClass +// +// PluginClass is the type struct for [Plugin] type PluginClass struct { *pluginClass } @@ -50407,31 +52013,6 @@ func UnsafePluginClassFromGlibBorrow(p unsafe.Pointer) *PluginClass { return &PluginClass{&pluginClass{(*C.GstPluginClass)(p)}} } -// UnsafePluginClassFromGlibNone is used to convert raw C.GstPluginClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafePluginClassFromGlibNone(p unsafe.Pointer) *PluginClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafePluginClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.pluginClass, - func (intern *pluginClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafePluginClassFromGlibFull is used to convert raw C.GstPluginClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafePluginClassFromGlibFull(p unsafe.Pointer) *PluginClass { - wrapped := UnsafePluginClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.pluginClass, - func (intern *pluginClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafePluginClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [PluginClass] is expected to work anymore. @@ -50444,14 +52025,15 @@ func UnsafePluginClassToGlibNone(p *PluginClass) unsafe.Pointer { return unsafe.Pointer(p.native) } -// UnsafePluginClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafePluginClassToGlibFull(p *PluginClass) unsafe.Pointer { - runtime.SetFinalizer(p.pluginClass, nil) - _p := unsafe.Pointer(p.native) - p.native = nil // PluginClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (p *PluginClass) ParentClass() *ObjectClass { + parent := UnsafeObjectClassFromGlibBorrow(UnsafePluginClassToGlibNone(p)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *PluginClass) {}, p) + return parent } + // PluginDesc wraps GstPluginDesc // // A plugin should export a variable of this type called plugin_desc. The plugin @@ -50473,7 +52055,7 @@ func UnsafePluginDescFromGlibBorrow(p unsafe.Pointer) *PluginDesc { return &PluginDesc{&pluginDesc{(*C.GstPluginDesc)(p)}} } -// UnsafePluginDescFromGlibNone is used to convert raw C.GstPluginDesc pointers to go while taking a reference. This is used by the bindings internally. +// UnsafePluginDescFromGlibNone is used to convert raw C.GstPluginDesc pointers to go without transferring ownership. This is used by the bindings internally. func UnsafePluginDescFromGlibNone(p unsafe.Pointer) *PluginDesc { // FIXME: this has no ref function, what should we do here? wrapped := UnsafePluginDescFromGlibBorrow(p) @@ -50486,7 +52068,7 @@ func UnsafePluginDescFromGlibNone(p unsafe.Pointer) *PluginDesc { return wrapped } -// UnsafePluginDescFromGlibFull is used to convert raw C.GstPluginDesc pointers to go while taking a reference. This is used by the bindings internally. +// UnsafePluginDescFromGlibFull is used to convert raw C.GstPluginDesc pointers to go while taking ownership. This is used by the bindings internally. func UnsafePluginDescFromGlibFull(p unsafe.Pointer) *PluginDesc { wrapped := UnsafePluginDescFromGlibBorrow(p) runtime.SetFinalizer( @@ -50518,7 +52100,10 @@ func UnsafePluginDescToGlibFull(p *PluginDesc) unsafe.Pointer { p.native = nil // PluginDesc is invalid from here on return _p } + // PluginFeatureClass wraps GstPluginFeatureClass +// +// PluginFeatureClass is the type struct for [PluginFeature] type PluginFeatureClass struct { *pluginFeatureClass } @@ -50533,31 +52118,6 @@ func UnsafePluginFeatureClassFromGlibBorrow(p unsafe.Pointer) *PluginFeatureClas return &PluginFeatureClass{&pluginFeatureClass{(*C.GstPluginFeatureClass)(p)}} } -// UnsafePluginFeatureClassFromGlibNone is used to convert raw C.GstPluginFeatureClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafePluginFeatureClassFromGlibNone(p unsafe.Pointer) *PluginFeatureClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafePluginFeatureClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.pluginFeatureClass, - func (intern *pluginFeatureClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafePluginFeatureClassFromGlibFull is used to convert raw C.GstPluginFeatureClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafePluginFeatureClassFromGlibFull(p unsafe.Pointer) *PluginFeatureClass { - wrapped := UnsafePluginFeatureClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.pluginFeatureClass, - func (intern *pluginFeatureClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafePluginFeatureClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [PluginFeatureClass] is expected to work anymore. @@ -50570,14 +52130,15 @@ func UnsafePluginFeatureClassToGlibNone(p *PluginFeatureClass) unsafe.Pointer { return unsafe.Pointer(p.native) } -// UnsafePluginFeatureClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafePluginFeatureClassToGlibFull(p *PluginFeatureClass) unsafe.Pointer { - runtime.SetFinalizer(p.pluginFeatureClass, nil) - _p := unsafe.Pointer(p.native) - p.native = nil // PluginFeatureClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (p *PluginFeatureClass) ParentClass() *ObjectClass { + parent := UnsafeObjectClassFromGlibBorrow(UnsafePluginFeatureClassToGlibNone(p)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *PluginFeatureClass) {}, p) + return parent } + // Poll wraps GstPoll // // A #GstPoll keeps track of file descriptors much like fd_set (used with @@ -50617,7 +52178,7 @@ func UnsafePollFromGlibBorrow(p unsafe.Pointer) *Poll { return &Poll{&poll{(*C.GstPoll)(p)}} } -// UnsafePollFromGlibNone is used to convert raw C.GstPoll pointers to go while taking a reference. This is used by the bindings internally. +// UnsafePollFromGlibNone is used to convert raw C.GstPoll pointers to go without transferring ownership. This is used by the bindings internally. func UnsafePollFromGlibNone(p unsafe.Pointer) *Poll { // FIXME: this has no ref function, what should we do here? wrapped := UnsafePollFromGlibBorrow(p) @@ -50630,7 +52191,7 @@ func UnsafePollFromGlibNone(p unsafe.Pointer) *Poll { return wrapped } -// UnsafePollFromGlibFull is used to convert raw C.GstPoll pointers to go while taking a reference. This is used by the bindings internally. +// UnsafePollFromGlibFull is used to convert raw C.GstPoll pointers to go while taking ownership. This is used by the bindings internally. func UnsafePollFromGlibFull(p unsafe.Pointer) *Poll { wrapped := UnsafePollFromGlibBorrow(p) runtime.SetFinalizer( @@ -50662,6 +52223,7 @@ func UnsafePollToGlibFull(p *Poll) unsafe.Pointer { p.native = nil // Poll is invalid from here on return _p } + // AddFd wraps gst_poll_add_fd // // The function takes the following parameters: @@ -51022,6 +52584,7 @@ func (set *Poll) GetReadGpollfd(fd *glib.PollFD) { } // ReadControl wraps gst_poll_read_control +// // The function returns the following values: // // - goret bool @@ -51204,6 +52767,7 @@ func (set *Poll) Wait(timeout ClockTime) int { } // WriteControl wraps gst_poll_write_control +// // The function returns the following values: // // - goret bool @@ -51254,7 +52818,7 @@ func UnsafePollFDFromGlibBorrow(p unsafe.Pointer) *PollFD { return &PollFD{&pollFD{(*C.GstPollFD)(p)}} } -// UnsafePollFDFromGlibNone is used to convert raw C.GstPollFD pointers to go while taking a reference. This is used by the bindings internally. +// UnsafePollFDFromGlibNone is used to convert raw C.GstPollFD pointers to go without transferring ownership. This is used by the bindings internally. func UnsafePollFDFromGlibNone(p unsafe.Pointer) *PollFD { // FIXME: this has no ref function, what should we do here? wrapped := UnsafePollFDFromGlibBorrow(p) @@ -51267,7 +52831,7 @@ func UnsafePollFDFromGlibNone(p unsafe.Pointer) *PollFD { return wrapped } -// UnsafePollFDFromGlibFull is used to convert raw C.GstPollFD pointers to go while taking a reference. This is used by the bindings internally. +// UnsafePollFDFromGlibFull is used to convert raw C.GstPollFD pointers to go while taking ownership. This is used by the bindings internally. func UnsafePollFDFromGlibFull(p unsafe.Pointer) *PollFD { wrapped := UnsafePollFDFromGlibBorrow(p) runtime.SetFinalizer( @@ -51299,6 +52863,7 @@ func UnsafePollFDToGlibFull(p *PollFD) unsafe.Pointer { p.native = nil // PollFD is invalid from here on return _p } + // Init wraps gst_poll_fd_init // // Initializes @fd. Alternatively you can initialize it with @@ -51329,7 +52894,7 @@ func UnsafePresetInterfaceFromGlibBorrow(p unsafe.Pointer) *PresetInterface { return &PresetInterface{&presetInterface{(*C.GstPresetInterface)(p)}} } -// UnsafePresetInterfaceFromGlibNone is used to convert raw C.GstPresetInterface pointers to go while taking a reference. This is used by the bindings internally. +// UnsafePresetInterfaceFromGlibNone is used to convert raw C.GstPresetInterface pointers to go without transferring ownership. This is used by the bindings internally. func UnsafePresetInterfaceFromGlibNone(p unsafe.Pointer) *PresetInterface { // FIXME: this has no ref function, what should we do here? wrapped := UnsafePresetInterfaceFromGlibBorrow(p) @@ -51342,7 +52907,7 @@ func UnsafePresetInterfaceFromGlibNone(p unsafe.Pointer) *PresetInterface { return wrapped } -// UnsafePresetInterfaceFromGlibFull is used to convert raw C.GstPresetInterface pointers to go while taking a reference. This is used by the bindings internally. +// UnsafePresetInterfaceFromGlibFull is used to convert raw C.GstPresetInterface pointers to go while taking ownership. This is used by the bindings internally. func UnsafePresetInterfaceFromGlibFull(p unsafe.Pointer) *PresetInterface { wrapped := UnsafePresetInterfaceFromGlibBorrow(p) runtime.SetFinalizer( @@ -51374,6 +52939,7 @@ func UnsafePresetInterfaceToGlibFull(p *PresetInterface) unsafe.Pointer { p.native = nil // PresetInterface is invalid from here on return _p } + // Promise wraps GstPromise // // The #GstPromise object implements the container for values that may @@ -51455,7 +53021,7 @@ func UnsafePromiseFromGlibBorrow(p unsafe.Pointer) *Promise { return &Promise{&promise{(*C.GstPromise)(p)}} } -// UnsafePromiseFromGlibNone is used to convert raw C.GstPromise pointers to go while taking a reference. This is used by the bindings internally. +// UnsafePromiseFromGlibNone is used to convert raw C.GstPromise pointers to go without transferring ownership. This is used by the bindings internally. func UnsafePromiseFromGlibNone(p unsafe.Pointer) *Promise { // FIXME: this has no ref function, what should we do here? wrapped := UnsafePromiseFromGlibBorrow(p) @@ -51468,7 +53034,7 @@ func UnsafePromiseFromGlibNone(p unsafe.Pointer) *Promise { return wrapped } -// UnsafePromiseFromGlibFull is used to convert raw C.GstPromise pointers to go while taking a reference. This is used by the bindings internally. +// UnsafePromiseFromGlibFull is used to convert raw C.GstPromise pointers to go while taking ownership. This is used by the bindings internally. func UnsafePromiseFromGlibFull(p unsafe.Pointer) *Promise { wrapped := UnsafePromiseFromGlibBorrow(p) runtime.SetFinalizer( @@ -51500,7 +53066,9 @@ func UnsafePromiseToGlibFull(p *Promise) unsafe.Pointer { p.native = nil // Promise is invalid from here on return _p } + // NewPromise wraps gst_promise_new +// // The function returns the following values: // // - goret *Promise @@ -51564,6 +53132,7 @@ func (promise *Promise) Expire() { } // GetReply wraps gst_promise_get_reply +// // The function returns the following values: // // - goret *Structure (nullable) @@ -51629,6 +53198,7 @@ func (promise *Promise) Reply(s *Structure) { } // Wait wraps gst_promise_wait +// // The function returns the following values: // // - goret PromiseResult @@ -51670,7 +53240,7 @@ func UnsafeProtectionMetaFromGlibBorrow(p unsafe.Pointer) *ProtectionMeta { return &ProtectionMeta{&protectionMeta{(*C.GstProtectionMeta)(p)}} } -// UnsafeProtectionMetaFromGlibNone is used to convert raw C.GstProtectionMeta pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeProtectionMetaFromGlibNone is used to convert raw C.GstProtectionMeta pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeProtectionMetaFromGlibNone(p unsafe.Pointer) *ProtectionMeta { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeProtectionMetaFromGlibBorrow(p) @@ -51683,7 +53253,7 @@ func UnsafeProtectionMetaFromGlibNone(p unsafe.Pointer) *ProtectionMeta { return wrapped } -// UnsafeProtectionMetaFromGlibFull is used to convert raw C.GstProtectionMeta pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeProtectionMetaFromGlibFull is used to convert raw C.GstProtectionMeta pointers to go while taking ownership. This is used by the bindings internally. func UnsafeProtectionMetaFromGlibFull(p unsafe.Pointer) *ProtectionMeta { wrapped := UnsafeProtectionMetaFromGlibBorrow(p) runtime.SetFinalizer( @@ -51715,7 +53285,9 @@ func UnsafeProtectionMetaToGlibFull(p *ProtectionMeta) unsafe.Pointer { p.native = nil // ProtectionMeta is invalid from here on return _p } + // ProtectionMetaGetInfo wraps gst_protection_meta_get_info +// // The function returns the following values: // // - goret *MetaInfo @@ -51732,6 +53304,8 @@ func ProtectionMetaGetInfo() *MetaInfo { } // ProxyPadClass wraps GstProxyPadClass +// +// ProxyPadClass is the type struct for [ProxyPad] type ProxyPadClass struct { *proxyPadClass } @@ -51746,31 +53320,6 @@ func UnsafeProxyPadClassFromGlibBorrow(p unsafe.Pointer) *ProxyPadClass { return &ProxyPadClass{&proxyPadClass{(*C.GstProxyPadClass)(p)}} } -// UnsafeProxyPadClassFromGlibNone is used to convert raw C.GstProxyPadClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeProxyPadClassFromGlibNone(p unsafe.Pointer) *ProxyPadClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeProxyPadClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.proxyPadClass, - func (intern *proxyPadClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeProxyPadClassFromGlibFull is used to convert raw C.GstProxyPadClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeProxyPadClassFromGlibFull(p unsafe.Pointer) *ProxyPadClass { - wrapped := UnsafeProxyPadClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.proxyPadClass, - func (intern *proxyPadClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeProxyPadClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [ProxyPadClass] is expected to work anymore. @@ -51783,14 +53332,15 @@ func UnsafeProxyPadClassToGlibNone(p *ProxyPadClass) unsafe.Pointer { return unsafe.Pointer(p.native) } -// UnsafeProxyPadClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeProxyPadClassToGlibFull(p *ProxyPadClass) unsafe.Pointer { - runtime.SetFinalizer(p.proxyPadClass, nil) - _p := unsafe.Pointer(p.native) - p.native = nil // ProxyPadClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (p *ProxyPadClass) ParentClass() *PadClass { + parent := UnsafePadClassFromGlibBorrow(UnsafeProxyPadClassToGlibNone(p)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *ProxyPadClass) {}, p) + return parent } + // Query wraps GstQuery // // Queries can be performed on pads (gst_pad_query()) and elements @@ -51842,7 +53392,7 @@ func UnsafeQueryFromGlibBorrow(p unsafe.Pointer) *Query { return &Query{&query{(*C.GstQuery)(p)}} } -// UnsafeQueryFromGlibNone is used to convert raw C.GstQuery pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeQueryFromGlibNone is used to convert raw C.GstQuery pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeQueryFromGlibNone(p unsafe.Pointer) *Query { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeQueryFromGlibBorrow(p) @@ -51855,7 +53405,7 @@ func UnsafeQueryFromGlibNone(p unsafe.Pointer) *Query { return wrapped } -// UnsafeQueryFromGlibFull is used to convert raw C.GstQuery pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeQueryFromGlibFull is used to convert raw C.GstQuery pointers to go while taking ownership. This is used by the bindings internally. func UnsafeQueryFromGlibFull(p unsafe.Pointer) *Query { wrapped := UnsafeQueryFromGlibBorrow(p) runtime.SetFinalizer( @@ -51887,6 +53437,7 @@ func UnsafeQueryToGlibFull(q *Query) unsafe.Pointer { q.native = nil // Query is invalid from here on return _p } + // NewQueryAcceptCaps wraps gst_query_new_accept_caps // // The function takes the following parameters: @@ -51954,6 +53505,7 @@ func NewQueryAllocation(caps *Caps, needPool bool) *Query { } // NewQueryBitrate wraps gst_query_new_bitrate +// // The function returns the following values: // // - goret *Query @@ -52155,6 +53707,7 @@ func NewQueryCustom(typ QueryType, structure *Structure) *Query { } // NewQueryDrain wraps gst_query_new_drain +// // The function returns the following values: // // - goret *Query @@ -52206,6 +53759,7 @@ func NewQueryDuration(format Format) *Query { } // NewQueryFormats wraps gst_query_new_formats +// // The function returns the following values: // // - goret *Query @@ -52227,6 +53781,7 @@ func NewQueryFormats() *Query { } // NewQueryLatency wraps gst_query_new_latency +// // The function returns the following values: // // - goret *Query @@ -52281,6 +53836,7 @@ func NewQueryPosition(format Format) *Query { } // NewQueryScheduling wraps gst_query_new_scheduling +// // The function returns the following values: // // - goret *Query @@ -52362,6 +53918,7 @@ func NewQuerySegment(format Format) *Query { } // NewQuerySelectable wraps gst_query_new_selectable +// // The function returns the following values: // // - goret *Query @@ -52382,6 +53939,7 @@ func NewQuerySelectable() *Query { } // NewQueryURI wraps gst_query_new_uri +// // The function returns the following values: // // - goret *Query @@ -52583,6 +54141,7 @@ func (query *Query) FindAllocationMeta(api gobject.Type) (uint, bool) { } // GetNAllocationMetas wraps gst_query_get_n_allocation_metas +// // The function returns the following values: // // - goret uint @@ -52606,6 +54165,7 @@ func (query *Query) GetNAllocationMetas() uint { } // GetNAllocationParams wraps gst_query_get_n_allocation_params +// // The function returns the following values: // // - goret uint @@ -52634,6 +54194,7 @@ func (query *Query) GetNAllocationParams() uint { } // GetNAllocationPools wraps gst_query_get_n_allocation_pools +// // The function returns the following values: // // - goret uint @@ -52657,6 +54218,7 @@ func (query *Query) GetNAllocationPools() uint { } // GetNBufferingRanges wraps gst_query_get_n_buffering_ranges +// // The function returns the following values: // // - goret uint @@ -52680,6 +54242,7 @@ func (query *Query) GetNBufferingRanges() uint { } // GetNSchedulingModes wraps gst_query_get_n_scheduling_modes +// // The function returns the following values: // // - goret uint @@ -52703,6 +54266,7 @@ func (query *Query) GetNSchedulingModes() uint { } // GetStructure wraps gst_query_get_structure +// // The function returns the following values: // // - goret *Structure (nullable) @@ -52803,6 +54367,7 @@ func (query *Query) HasSchedulingModeWithFlags(mode PadMode, flags SchedulingFla } // ParseAcceptCaps wraps gst_query_parse_accept_caps +// // The function returns the following values: // // - caps *Caps: A pointer to the caps @@ -52826,6 +54391,7 @@ func (query *Query) ParseAcceptCaps() *Caps { } // ParseAcceptCapsResult wraps gst_query_parse_accept_caps_result +// // The function returns the following values: // // - result bool: location for the result @@ -52850,6 +54416,7 @@ func (query *Query) ParseAcceptCapsResult() bool { } // ParseAllocation wraps gst_query_parse_allocation +// // The function returns the following values: // // - caps *Caps (nullable): The #GstCaps @@ -52885,6 +54452,7 @@ func (query *Query) ParseAllocation() (*Caps, bool) { } // ParseBitrate wraps gst_query_parse_bitrate +// // The function returns the following values: // // - nominalBitrate uint: The resulting bitrate in bits per second @@ -52907,6 +54475,7 @@ func (query *Query) ParseBitrate() uint { } // ParseBufferingPercent wraps gst_query_parse_buffering_percent +// // The function returns the following values: // // - busy bool: if buffering is busy, or %NULL @@ -52936,6 +54505,7 @@ func (query *Query) ParseBufferingPercent() (bool, int) { } // ParseBufferingRange wraps gst_query_parse_buffering_range +// // The function returns the following values: // // - format Format: the format to set for the @segment_start @@ -52974,6 +54544,7 @@ func (query *Query) ParseBufferingRange() (Format, int64, int64, int64) { } // ParseBufferingStats wraps gst_query_parse_buffering_stats +// // The function returns the following values: // // - mode BufferingMode: a buffering mode, or %NULL @@ -53009,6 +54580,7 @@ func (query *Query) ParseBufferingStats() (BufferingMode, int, int, int64) { } // ParseCaps wraps gst_query_parse_caps +// // The function returns the following values: // // - filter *Caps: A pointer to the caps filter @@ -53032,6 +54604,7 @@ func (query *Query) ParseCaps() *Caps { } // ParseCapsResult wraps gst_query_parse_caps_result +// // The function returns the following values: // // - caps *Caps (nullable): A pointer to the caps @@ -53057,6 +54630,7 @@ func (query *Query) ParseCapsResult() *Caps { } // ParseContext wraps gst_query_parse_context +// // The function returns the following values: // // - _context *Context (nullable): A pointer to store the #GstContext @@ -53082,6 +54656,7 @@ func (query *Query) ParseContext() *Context { } // ParseContextType wraps gst_query_parse_context_type +// // The function returns the following values: // // - contextType string: the context type, or %NULL @@ -53110,6 +54685,7 @@ func (query *Query) ParseContextType() (string, bool) { } // ParseConvert wraps gst_query_parse_convert +// // The function returns the following values: // // - srcFormat Format: the storage for the #GstFormat of the @@ -53148,6 +54724,7 @@ func (query *Query) ParseConvert() (Format, int64, Format, int64) { } // ParseDuration wraps gst_query_parse_duration +// // The function returns the following values: // // - format Format: the storage for the #GstFormat of the duration @@ -53176,6 +54753,7 @@ func (query *Query) ParseDuration() (Format, int64) { } // ParseLatency wraps gst_query_parse_latency +// // The function returns the following values: // // - live bool: storage for live or %NULL @@ -53208,6 +54786,7 @@ func (query *Query) ParseLatency() (bool, ClockTime, ClockTime) { } // ParseNFormats wraps gst_query_parse_n_formats +// // The function returns the following values: // // - nFormats uint: the number of formats in this query. @@ -53454,6 +55033,7 @@ func (query *Query) ParseNthSchedulingMode(index uint) PadMode { } // ParsePosition wraps gst_query_parse_position +// // The function returns the following values: // // - format Format: the storage for the #GstFormat of the @@ -53482,6 +55062,7 @@ func (query *Query) ParsePosition() (Format, int64) { } // ParseScheduling wraps gst_query_parse_scheduling +// // The function returns the following values: // // - flags SchedulingFlags: #GstSchedulingFlags @@ -53516,6 +55097,7 @@ func (query *Query) ParseScheduling() (SchedulingFlags, int, int, int) { } // ParseSeeking wraps gst_query_parse_seeking +// // The function returns the following values: // // - format Format: the format to set for the @segment_start @@ -53555,6 +55137,7 @@ func (query *Query) ParseSeeking() (Format, bool, int64, int64) { } // ParseSegment wraps gst_query_parse_segment +// // The function returns the following values: // // - rate float64: the storage for the rate of the segment, or %NULL @@ -53593,6 +55176,7 @@ func (query *Query) ParseSegment() (float64, Format, int64, int64) { } // ParseSelectable wraps gst_query_parse_selectable +// // The function returns the following values: // // - selectable bool: The resulting stream selection capability @@ -53617,6 +55201,7 @@ func (query *Query) ParseSelectable() bool { } // ParseURI wraps gst_query_parse_uri +// // The function returns the following values: // // - uri string (nullable): the storage for the current URI @@ -53645,6 +55230,7 @@ func (query *Query) ParseURI() string { } // ParseURIRedirection wraps gst_query_parse_uri_redirection +// // The function returns the following values: // // - uri string (nullable): the storage for the redirect URI @@ -53673,6 +55259,7 @@ func (query *Query) ParseURIRedirection() string { } // ParseURIRedirectionPermanent wraps gst_query_parse_uri_redirection_permanent +// // The function returns the following values: // // - permanent bool: if the URI redirection is permanent @@ -54324,6 +55911,7 @@ func (query *Query) SetURIRedirectionPermanent(permanent bool) { } // WritableStructure wraps gst_query_writable_structure +// // The function returns the following values: // // - goret *Structure @@ -54384,7 +55972,7 @@ func UnsafeReferenceTimestampMetaFromGlibBorrow(p unsafe.Pointer) *ReferenceTime return &ReferenceTimestampMeta{&referenceTimestampMeta{(*C.GstReferenceTimestampMeta)(p)}} } -// UnsafeReferenceTimestampMetaFromGlibNone is used to convert raw C.GstReferenceTimestampMeta pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeReferenceTimestampMetaFromGlibNone is used to convert raw C.GstReferenceTimestampMeta pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeReferenceTimestampMetaFromGlibNone(p unsafe.Pointer) *ReferenceTimestampMeta { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeReferenceTimestampMetaFromGlibBorrow(p) @@ -54397,7 +55985,7 @@ func UnsafeReferenceTimestampMetaFromGlibNone(p unsafe.Pointer) *ReferenceTimest return wrapped } -// UnsafeReferenceTimestampMetaFromGlibFull is used to convert raw C.GstReferenceTimestampMeta pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeReferenceTimestampMetaFromGlibFull is used to convert raw C.GstReferenceTimestampMeta pointers to go while taking ownership. This is used by the bindings internally. func UnsafeReferenceTimestampMetaFromGlibFull(p unsafe.Pointer) *ReferenceTimestampMeta { wrapped := UnsafeReferenceTimestampMetaFromGlibBorrow(p) runtime.SetFinalizer( @@ -54429,7 +56017,9 @@ func UnsafeReferenceTimestampMetaToGlibFull(r *ReferenceTimestampMeta) unsafe.Po r.native = nil // ReferenceTimestampMeta is invalid from here on return _p } + // ReferenceTimestampMetaGetInfo wraps gst_reference_timestamp_meta_get_info +// // The function returns the following values: // // - goret *MetaInfo @@ -54448,6 +56038,8 @@ func ReferenceTimestampMetaGetInfo() *MetaInfo { } // RegistryClass wraps GstRegistryClass +// +// RegistryClass is the type struct for [Registry] type RegistryClass struct { *registryClass } @@ -54462,31 +56054,6 @@ func UnsafeRegistryClassFromGlibBorrow(p unsafe.Pointer) *RegistryClass { return &RegistryClass{®istryClass{(*C.GstRegistryClass)(p)}} } -// UnsafeRegistryClassFromGlibNone is used to convert raw C.GstRegistryClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeRegistryClassFromGlibNone(p unsafe.Pointer) *RegistryClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeRegistryClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.registryClass, - func (intern *registryClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeRegistryClassFromGlibFull is used to convert raw C.GstRegistryClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeRegistryClassFromGlibFull(p unsafe.Pointer) *RegistryClass { - wrapped := UnsafeRegistryClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.registryClass, - func (intern *registryClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeRegistryClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [RegistryClass] is expected to work anymore. @@ -54499,14 +56066,15 @@ func UnsafeRegistryClassToGlibNone(r *RegistryClass) unsafe.Pointer { return unsafe.Pointer(r.native) } -// UnsafeRegistryClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeRegistryClassToGlibFull(r *RegistryClass) unsafe.Pointer { - runtime.SetFinalizer(r.registryClass, nil) - _p := unsafe.Pointer(r.native) - r.native = nil // RegistryClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (r *RegistryClass) ParentClass() *ObjectClass { + parent := UnsafeObjectClassFromGlibBorrow(UnsafeRegistryClassToGlibNone(r)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *RegistryClass) {}, r) + return parent } + // Sample wraps GstSample // // A #GstSample is a small object containing data, a type, timing and @@ -54537,7 +56105,7 @@ func UnsafeSampleFromGlibBorrow(p unsafe.Pointer) *Sample { return &Sample{&sample{(*C.GstSample)(p)}} } -// UnsafeSampleFromGlibNone is used to convert raw C.GstSample pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeSampleFromGlibNone is used to convert raw C.GstSample pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeSampleFromGlibNone(p unsafe.Pointer) *Sample { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeSampleFromGlibBorrow(p) @@ -54550,7 +56118,7 @@ func UnsafeSampleFromGlibNone(p unsafe.Pointer) *Sample { return wrapped } -// UnsafeSampleFromGlibFull is used to convert raw C.GstSample pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeSampleFromGlibFull is used to convert raw C.GstSample pointers to go while taking ownership. This is used by the bindings internally. func UnsafeSampleFromGlibFull(p unsafe.Pointer) *Sample { wrapped := UnsafeSampleFromGlibBorrow(p) runtime.SetFinalizer( @@ -54582,6 +56150,7 @@ func UnsafeSampleToGlibFull(s *Sample) unsafe.Pointer { s.native = nil // Sample is invalid from here on return _p } + // NewSample wraps gst_sample_new // // The function takes the following parameters: @@ -54632,6 +56201,7 @@ func NewSample(buffer *Buffer, caps *Caps, segment *Segment, info *Structure) *S } // GetBuffer wraps gst_sample_get_buffer +// // The function returns the following values: // // - goret *Buffer (nullable) @@ -54657,6 +56227,7 @@ func (sample *Sample) GetBuffer() *Buffer { } // GetBufferList wraps gst_sample_get_buffer_list +// // The function returns the following values: // // - goret *BufferList (nullable) @@ -54682,6 +56253,7 @@ func (sample *Sample) GetBufferList() *BufferList { } // GetCaps wraps gst_sample_get_caps +// // The function returns the following values: // // - goret *Caps (nullable) @@ -54707,6 +56279,7 @@ func (sample *Sample) GetCaps() *Caps { } // GetInfo wraps gst_sample_get_info +// // The function returns the following values: // // - goret *Structure (nullable) @@ -54732,6 +56305,7 @@ func (sample *Sample) GetInfo() *Structure { } // GetSegment wraps gst_sample_get_segment +// // The function returns the following values: // // - goret *Segment @@ -54936,7 +56510,7 @@ func UnsafeSegmentFromGlibBorrow(p unsafe.Pointer) *Segment { return &Segment{&segment{(*C.GstSegment)(p)}} } -// UnsafeSegmentFromGlibNone is used to convert raw C.GstSegment pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeSegmentFromGlibNone is used to convert raw C.GstSegment pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeSegmentFromGlibNone(p unsafe.Pointer) *Segment { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeSegmentFromGlibBorrow(p) @@ -54949,7 +56523,7 @@ func UnsafeSegmentFromGlibNone(p unsafe.Pointer) *Segment { return wrapped } -// UnsafeSegmentFromGlibFull is used to convert raw C.GstSegment pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeSegmentFromGlibFull is used to convert raw C.GstSegment pointers to go while taking ownership. This is used by the bindings internally. func UnsafeSegmentFromGlibFull(p unsafe.Pointer) *Segment { wrapped := UnsafeSegmentFromGlibBorrow(p) runtime.SetFinalizer( @@ -54981,7 +56555,9 @@ func UnsafeSegmentToGlibFull(s *Segment) unsafe.Pointer { s.native = nil // Segment is invalid from here on return _p } + // NewSegment wraps gst_segment_new +// // The function returns the following values: // // - goret *Segment @@ -55063,6 +56639,7 @@ func (segment *Segment) Clip(format Format, start uint64, stop uint64) (uint64, } // Copy wraps gst_segment_copy +// // The function returns the following values: // // - goret *Segment @@ -55727,6 +57304,8 @@ func (segment *Segment) ToStreamTimeFull(format Format, position uint64) (uint64 // SharedTaskPoolClass wraps GstSharedTaskPoolClass // // The #GstSharedTaskPoolClass object. +// +// SharedTaskPoolClass is the type struct for [SharedTaskPool] type SharedTaskPoolClass struct { *sharedTaskPoolClass } @@ -55741,31 +57320,6 @@ func UnsafeSharedTaskPoolClassFromGlibBorrow(p unsafe.Pointer) *SharedTaskPoolCl return &SharedTaskPoolClass{&sharedTaskPoolClass{(*C.GstSharedTaskPoolClass)(p)}} } -// UnsafeSharedTaskPoolClassFromGlibNone is used to convert raw C.GstSharedTaskPoolClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeSharedTaskPoolClassFromGlibNone(p unsafe.Pointer) *SharedTaskPoolClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeSharedTaskPoolClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.sharedTaskPoolClass, - func (intern *sharedTaskPoolClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeSharedTaskPoolClassFromGlibFull is used to convert raw C.GstSharedTaskPoolClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeSharedTaskPoolClassFromGlibFull(p unsafe.Pointer) *SharedTaskPoolClass { - wrapped := UnsafeSharedTaskPoolClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.sharedTaskPoolClass, - func (intern *sharedTaskPoolClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeSharedTaskPoolClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [SharedTaskPoolClass] is expected to work anymore. @@ -55778,14 +57332,15 @@ func UnsafeSharedTaskPoolClassToGlibNone(s *SharedTaskPoolClass) unsafe.Pointer return unsafe.Pointer(s.native) } -// UnsafeSharedTaskPoolClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeSharedTaskPoolClassToGlibFull(s *SharedTaskPoolClass) unsafe.Pointer { - runtime.SetFinalizer(s.sharedTaskPoolClass, nil) - _p := unsafe.Pointer(s.native) - s.native = nil // SharedTaskPoolClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (s *SharedTaskPoolClass) ParentClass() *TaskPoolClass { + parent := UnsafeTaskPoolClassFromGlibBorrow(UnsafeSharedTaskPoolClassToGlibNone(s)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *SharedTaskPoolClass) {}, s) + return parent } + // StaticCaps wraps GstStaticCaps // // Data structure to initialize #GstCaps from a string description usually @@ -55817,7 +57372,7 @@ func UnsafeStaticCapsFromGlibBorrow(p unsafe.Pointer) *StaticCaps { return &StaticCaps{&staticCaps{(*C.GstStaticCaps)(p)}} } -// UnsafeStaticCapsFromGlibNone is used to convert raw C.GstStaticCaps pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeStaticCapsFromGlibNone is used to convert raw C.GstStaticCaps pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeStaticCapsFromGlibNone(p unsafe.Pointer) *StaticCaps { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeStaticCapsFromGlibBorrow(p) @@ -55830,7 +57385,7 @@ func UnsafeStaticCapsFromGlibNone(p unsafe.Pointer) *StaticCaps { return wrapped } -// UnsafeStaticCapsFromGlibFull is used to convert raw C.GstStaticCaps pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeStaticCapsFromGlibFull is used to convert raw C.GstStaticCaps pointers to go while taking ownership. This is used by the bindings internally. func UnsafeStaticCapsFromGlibFull(p unsafe.Pointer) *StaticCaps { wrapped := UnsafeStaticCapsFromGlibBorrow(p) runtime.SetFinalizer( @@ -55862,6 +57417,7 @@ func UnsafeStaticCapsToGlibFull(s *StaticCaps) unsafe.Pointer { s.native = nil // StaticCaps is invalid from here on return _p } + // Cleanup wraps gst_static_caps_cleanup // // Cleans up the cached caps contained in @static_caps. @@ -55875,6 +57431,7 @@ func (staticCaps *StaticCaps) Cleanup() { } // Get wraps gst_static_caps_get +// // The function returns the following values: // // - goret *Caps (nullable) @@ -55927,7 +57484,7 @@ func UnsafeStaticPadTemplateFromGlibBorrow(p unsafe.Pointer) *StaticPadTemplate return &StaticPadTemplate{&staticPadTemplate{(*C.GstStaticPadTemplate)(p)}} } -// UnsafeStaticPadTemplateFromGlibNone is used to convert raw C.GstStaticPadTemplate pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeStaticPadTemplateFromGlibNone is used to convert raw C.GstStaticPadTemplate pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeStaticPadTemplateFromGlibNone(p unsafe.Pointer) *StaticPadTemplate { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeStaticPadTemplateFromGlibBorrow(p) @@ -55940,7 +57497,7 @@ func UnsafeStaticPadTemplateFromGlibNone(p unsafe.Pointer) *StaticPadTemplate { return wrapped } -// UnsafeStaticPadTemplateFromGlibFull is used to convert raw C.GstStaticPadTemplate pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeStaticPadTemplateFromGlibFull is used to convert raw C.GstStaticPadTemplate pointers to go while taking ownership. This is used by the bindings internally. func UnsafeStaticPadTemplateFromGlibFull(p unsafe.Pointer) *StaticPadTemplate { wrapped := UnsafeStaticPadTemplateFromGlibBorrow(p) runtime.SetFinalizer( @@ -55972,7 +57529,9 @@ func UnsafeStaticPadTemplateToGlibFull(s *StaticPadTemplate) unsafe.Pointer { s.native = nil // StaticPadTemplate is invalid from here on return _p } + // Get wraps gst_static_pad_template_get +// // The function returns the following values: // // - goret PadTemplate (nullable) @@ -55997,6 +57556,7 @@ func (padTemplate *StaticPadTemplate) Get() PadTemplate { } // GetCaps wraps gst_static_pad_template_get_caps +// // The function returns the following values: // // - goret *Caps @@ -56021,6 +57581,8 @@ func (templ *StaticPadTemplate) GetCaps() *Caps { // StreamClass wraps GstStreamClass // // GstStream class structure +// +// StreamClass is the type struct for [Stream] type StreamClass struct { *streamClass } @@ -56035,31 +57597,6 @@ func UnsafeStreamClassFromGlibBorrow(p unsafe.Pointer) *StreamClass { return &StreamClass{&streamClass{(*C.GstStreamClass)(p)}} } -// UnsafeStreamClassFromGlibNone is used to convert raw C.GstStreamClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeStreamClassFromGlibNone(p unsafe.Pointer) *StreamClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeStreamClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.streamClass, - func (intern *streamClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeStreamClassFromGlibFull is used to convert raw C.GstStreamClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeStreamClassFromGlibFull(p unsafe.Pointer) *StreamClass { - wrapped := UnsafeStreamClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.streamClass, - func (intern *streamClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeStreamClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [StreamClass] is expected to work anymore. @@ -56072,17 +57609,20 @@ func UnsafeStreamClassToGlibNone(s *StreamClass) unsafe.Pointer { return unsafe.Pointer(s.native) } -// UnsafeStreamClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeStreamClassToGlibFull(s *StreamClass) unsafe.Pointer { - runtime.SetFinalizer(s.streamClass, nil) - _p := unsafe.Pointer(s.native) - s.native = nil // StreamClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (s *StreamClass) ParentClass() *ObjectClass { + parent := UnsafeObjectClassFromGlibBorrow(UnsafeStreamClassToGlibNone(s)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *StreamClass) {}, s) + return parent } + // StreamCollectionClass wraps GstStreamCollectionClass // // GstStreamCollection class structure +// +// StreamCollectionClass is the type struct for [StreamCollection] type StreamCollectionClass struct { *streamCollectionClass } @@ -56097,31 +57637,6 @@ func UnsafeStreamCollectionClassFromGlibBorrow(p unsafe.Pointer) *StreamCollecti return &StreamCollectionClass{&streamCollectionClass{(*C.GstStreamCollectionClass)(p)}} } -// UnsafeStreamCollectionClassFromGlibNone is used to convert raw C.GstStreamCollectionClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeStreamCollectionClassFromGlibNone(p unsafe.Pointer) *StreamCollectionClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeStreamCollectionClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.streamCollectionClass, - func (intern *streamCollectionClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeStreamCollectionClassFromGlibFull is used to convert raw C.GstStreamCollectionClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeStreamCollectionClassFromGlibFull(p unsafe.Pointer) *StreamCollectionClass { - wrapped := UnsafeStreamCollectionClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.streamCollectionClass, - func (intern *streamCollectionClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeStreamCollectionClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [StreamCollectionClass] is expected to work anymore. @@ -56134,14 +57649,15 @@ func UnsafeStreamCollectionClassToGlibNone(s *StreamCollectionClass) unsafe.Poin return unsafe.Pointer(s.native) } -// UnsafeStreamCollectionClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeStreamCollectionClassToGlibFull(s *StreamCollectionClass) unsafe.Pointer { - runtime.SetFinalizer(s.streamCollectionClass, nil) - _p := unsafe.Pointer(s.native) - s.native = nil // StreamCollectionClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (s *StreamCollectionClass) ParentClass() *ObjectClass { + parent := UnsafeObjectClassFromGlibBorrow(UnsafeStreamCollectionClassToGlibNone(s)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *StreamCollectionClass) {}, s) + return parent } + // Structure wraps GstStructure // // A #GstStructure is a collection of key/value pairs. The keys are expressed as @@ -56274,7 +57790,7 @@ func UnsafeStructureFromGlibBorrow(p unsafe.Pointer) *Structure { return &Structure{&structure{(*C.GstStructure)(p)}} } -// UnsafeStructureFromGlibNone is used to convert raw C.GstStructure pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeStructureFromGlibNone is used to convert raw C.GstStructure pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeStructureFromGlibNone(p unsafe.Pointer) *Structure { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeStructureFromGlibBorrow(p) @@ -56287,7 +57803,7 @@ func UnsafeStructureFromGlibNone(p unsafe.Pointer) *Structure { return wrapped } -// UnsafeStructureFromGlibFull is used to convert raw C.GstStructure pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeStructureFromGlibFull is used to convert raw C.GstStructure pointers to go while taking ownership. This is used by the bindings internally. func UnsafeStructureFromGlibFull(p unsafe.Pointer) *Structure { wrapped := UnsafeStructureFromGlibBorrow(p) runtime.SetFinalizer( @@ -56319,6 +57835,7 @@ func UnsafeStructureToGlibFull(s *Structure) unsafe.Pointer { s.native = nil // Structure is invalid from here on return _p } + // StructureFromString wraps gst_structure_from_string // // The function takes the following parameters: @@ -56488,6 +58005,7 @@ func (struct1 *Structure) CanIntersect(struct2 *Structure) bool { } // Copy wraps gst_structure_copy +// // The function returns the following values: // // - goret *Structure @@ -57264,6 +58782,7 @@ func (structure *Structure) GetInt64(fieldname string) (int64, bool) { } // GetName wraps gst_structure_get_name +// // The function returns the following values: // // - goret string @@ -57286,6 +58805,7 @@ func (structure *Structure) GetName() string { } // GetNameID wraps gst_structure_get_name_id +// // The function returns the following values: // // - goret glib.Quark @@ -57755,6 +59275,7 @@ func (structure *Structure) MapInPlace(fn StructureMapFunc) bool { } // NFields wraps gst_structure_n_fields +// // The function returns the following values: // // - goret int @@ -57977,6 +59498,7 @@ func (structure *Structure) SetParentRefcount(refcount *int) bool { } // ToString wraps gst_structure_to_string +// // The function returns the following values: // // - goret string @@ -58011,6 +59533,8 @@ func (structure *Structure) ToString() string { } // SystemClockClass wraps GstSystemClockClass +// +// SystemClockClass is the type struct for [SystemClock] type SystemClockClass struct { *systemClockClass } @@ -58025,31 +59549,6 @@ func UnsafeSystemClockClassFromGlibBorrow(p unsafe.Pointer) *SystemClockClass { return &SystemClockClass{&systemClockClass{(*C.GstSystemClockClass)(p)}} } -// UnsafeSystemClockClassFromGlibNone is used to convert raw C.GstSystemClockClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeSystemClockClassFromGlibNone(p unsafe.Pointer) *SystemClockClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeSystemClockClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.systemClockClass, - func (intern *systemClockClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeSystemClockClassFromGlibFull is used to convert raw C.GstSystemClockClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeSystemClockClassFromGlibFull(p unsafe.Pointer) *SystemClockClass { - wrapped := UnsafeSystemClockClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.systemClockClass, - func (intern *systemClockClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeSystemClockClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [SystemClockClass] is expected to work anymore. @@ -58062,14 +59561,15 @@ func UnsafeSystemClockClassToGlibNone(s *SystemClockClass) unsafe.Pointer { return unsafe.Pointer(s.native) } -// UnsafeSystemClockClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeSystemClockClassToGlibFull(s *SystemClockClass) unsafe.Pointer { - runtime.SetFinalizer(s.systemClockClass, nil) - _p := unsafe.Pointer(s.native) - s.native = nil // SystemClockClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (s *SystemClockClass) ParentClass() *ClockClass { + parent := UnsafeClockClassFromGlibBorrow(UnsafeSystemClockClassToGlibNone(s)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *SystemClockClass) {}, s) + return parent } + // TagList wraps GstTagList // // List of tags and values used to describe media metadata. @@ -58102,7 +59602,7 @@ func UnsafeTagListFromGlibBorrow(p unsafe.Pointer) *TagList { return &TagList{&tagList{(*C.GstTagList)(p)}} } -// UnsafeTagListFromGlibNone is used to convert raw C.GstTagList pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeTagListFromGlibNone is used to convert raw C.GstTagList pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeTagListFromGlibNone(p unsafe.Pointer) *TagList { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeTagListFromGlibBorrow(p) @@ -58115,7 +59615,7 @@ func UnsafeTagListFromGlibNone(p unsafe.Pointer) *TagList { return wrapped } -// UnsafeTagListFromGlibFull is used to convert raw C.GstTagList pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeTagListFromGlibFull is used to convert raw C.GstTagList pointers to go while taking ownership. This is used by the bindings internally. func UnsafeTagListFromGlibFull(p unsafe.Pointer) *TagList { wrapped := UnsafeTagListFromGlibBorrow(p) runtime.SetFinalizer( @@ -58147,7 +59647,9 @@ func UnsafeTagListToGlibFull(t *TagList) unsafe.Pointer { t.native = nil // TagList is invalid from here on return _p } + // NewTagListEmpty wraps gst_tag_list_new_empty +// // The function returns the following values: // // - goret *TagList @@ -58269,6 +59771,7 @@ func (list *TagList) AddValue(mode TagMergeMode, tag string, value *gobject.Valu } // Copy wraps gst_tag_list_copy +// // The function returns the following values: // // - goret *TagList @@ -58905,6 +60408,7 @@ func (list *TagList) GetSampleIndex(tag string, index uint) (*Sample, bool) { } // GetScope wraps gst_tag_list_get_scope +// // The function returns the following values: // // - goret TagScope @@ -59238,6 +60742,7 @@ func (into *TagList) Insert(from *TagList, mode TagMergeMode) { } // IsEmpty wraps gst_tag_list_is_empty +// // The function returns the following values: // // - goret bool @@ -59335,6 +60840,7 @@ func (list1 *TagList) Merge(list2 *TagList, mode TagMergeMode) *TagList { } // NTags wraps gst_tag_list_n_tags +// // The function returns the following values: // // - goret int @@ -59473,6 +60979,7 @@ func (list *TagList) SetScope(scope TagScope) { } // ToString wraps gst_tag_list_to_string +// // The function returns the following values: // // - goret string @@ -59512,7 +61019,7 @@ func UnsafeTagSetterInterfaceFromGlibBorrow(p unsafe.Pointer) *TagSetterInterfac return &TagSetterInterface{&tagSetterInterface{(*C.GstTagSetterInterface)(p)}} } -// UnsafeTagSetterInterfaceFromGlibNone is used to convert raw C.GstTagSetterInterface pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeTagSetterInterfaceFromGlibNone is used to convert raw C.GstTagSetterInterface pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeTagSetterInterfaceFromGlibNone(p unsafe.Pointer) *TagSetterInterface { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeTagSetterInterfaceFromGlibBorrow(p) @@ -59525,7 +61032,7 @@ func UnsafeTagSetterInterfaceFromGlibNone(p unsafe.Pointer) *TagSetterInterface return wrapped } -// UnsafeTagSetterInterfaceFromGlibFull is used to convert raw C.GstTagSetterInterface pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeTagSetterInterfaceFromGlibFull is used to convert raw C.GstTagSetterInterface pointers to go while taking ownership. This is used by the bindings internally. func UnsafeTagSetterInterfaceFromGlibFull(p unsafe.Pointer) *TagSetterInterface { wrapped := UnsafeTagSetterInterfaceFromGlibBorrow(p) runtime.SetFinalizer( @@ -59557,7 +61064,10 @@ func UnsafeTagSetterInterfaceToGlibFull(t *TagSetterInterface) unsafe.Pointer { t.native = nil // TagSetterInterface is invalid from here on return _p } + // TaskClass wraps GstTaskClass +// +// TaskClass is the type struct for [Task] type TaskClass struct { *taskClass } @@ -59572,31 +61082,6 @@ func UnsafeTaskClassFromGlibBorrow(p unsafe.Pointer) *TaskClass { return &TaskClass{&taskClass{(*C.GstTaskClass)(p)}} } -// UnsafeTaskClassFromGlibNone is used to convert raw C.GstTaskClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeTaskClassFromGlibNone(p unsafe.Pointer) *TaskClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeTaskClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.taskClass, - func (intern *taskClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeTaskClassFromGlibFull is used to convert raw C.GstTaskClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeTaskClassFromGlibFull(p unsafe.Pointer) *TaskClass { - wrapped := UnsafeTaskClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.taskClass, - func (intern *taskClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeTaskClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [TaskClass] is expected to work anymore. @@ -59609,17 +61094,20 @@ func UnsafeTaskClassToGlibNone(t *TaskClass) unsafe.Pointer { return unsafe.Pointer(t.native) } -// UnsafeTaskClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeTaskClassToGlibFull(t *TaskClass) unsafe.Pointer { - runtime.SetFinalizer(t.taskClass, nil) - _p := unsafe.Pointer(t.native) - t.native = nil // TaskClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (t *TaskClass) ParentClass() *ObjectClass { + parent := UnsafeObjectClassFromGlibBorrow(UnsafeTaskClassToGlibNone(t)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *TaskClass) {}, t) + return parent } + // TaskPoolClass wraps GstTaskPoolClass // // The #GstTaskPoolClass object. +// +// TaskPoolClass is the type struct for [TaskPool] type TaskPoolClass struct { *taskPoolClass } @@ -59634,31 +61122,6 @@ func UnsafeTaskPoolClassFromGlibBorrow(p unsafe.Pointer) *TaskPoolClass { return &TaskPoolClass{&taskPoolClass{(*C.GstTaskPoolClass)(p)}} } -// UnsafeTaskPoolClassFromGlibNone is used to convert raw C.GstTaskPoolClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeTaskPoolClassFromGlibNone(p unsafe.Pointer) *TaskPoolClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeTaskPoolClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.taskPoolClass, - func (intern *taskPoolClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeTaskPoolClassFromGlibFull is used to convert raw C.GstTaskPoolClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeTaskPoolClassFromGlibFull(p unsafe.Pointer) *TaskPoolClass { - wrapped := UnsafeTaskPoolClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.taskPoolClass, - func (intern *taskPoolClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeTaskPoolClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [TaskPoolClass] is expected to work anymore. @@ -59671,14 +61134,15 @@ func UnsafeTaskPoolClassToGlibNone(t *TaskPoolClass) unsafe.Pointer { return unsafe.Pointer(t.native) } -// UnsafeTaskPoolClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeTaskPoolClassToGlibFull(t *TaskPoolClass) unsafe.Pointer { - runtime.SetFinalizer(t.taskPoolClass, nil) - _p := unsafe.Pointer(t.native) - t.native = nil // TaskPoolClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (t *TaskPoolClass) ParentClass() *ObjectClass { + parent := UnsafeObjectClassFromGlibBorrow(UnsafeTaskPoolClassToGlibNone(t)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *TaskPoolClass) {}, t) + return parent } + // TimedValue wraps GstTimedValue // // Structure for storing a timestamp and a value. @@ -59696,7 +61160,7 @@ func UnsafeTimedValueFromGlibBorrow(p unsafe.Pointer) *TimedValue { return &TimedValue{&timedValue{(*C.GstTimedValue)(p)}} } -// UnsafeTimedValueFromGlibNone is used to convert raw C.GstTimedValue pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeTimedValueFromGlibNone is used to convert raw C.GstTimedValue pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeTimedValueFromGlibNone(p unsafe.Pointer) *TimedValue { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeTimedValueFromGlibBorrow(p) @@ -59709,7 +61173,7 @@ func UnsafeTimedValueFromGlibNone(p unsafe.Pointer) *TimedValue { return wrapped } -// UnsafeTimedValueFromGlibFull is used to convert raw C.GstTimedValue pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeTimedValueFromGlibFull is used to convert raw C.GstTimedValue pointers to go while taking ownership. This is used by the bindings internally. func UnsafeTimedValueFromGlibFull(p unsafe.Pointer) *TimedValue { wrapped := UnsafeTimedValueFromGlibBorrow(p) runtime.SetFinalizer( @@ -59741,6 +61205,7 @@ func UnsafeTimedValueToGlibFull(t *TimedValue) unsafe.Pointer { t.native = nil // TimedValue is invalid from here on return _p } + // Toc wraps GstToc // // #GstToc functions are used to create/free #GstToc and #GstTocEntry structures. @@ -59814,7 +61279,7 @@ func UnsafeTocFromGlibBorrow(p unsafe.Pointer) *Toc { return &Toc{&toc{(*C.GstToc)(p)}} } -// UnsafeTocFromGlibNone is used to convert raw C.GstToc pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeTocFromGlibNone is used to convert raw C.GstToc pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeTocFromGlibNone(p unsafe.Pointer) *Toc { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeTocFromGlibBorrow(p) @@ -59827,7 +61292,7 @@ func UnsafeTocFromGlibNone(p unsafe.Pointer) *Toc { return wrapped } -// UnsafeTocFromGlibFull is used to convert raw C.GstToc pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeTocFromGlibFull is used to convert raw C.GstToc pointers to go while taking ownership. This is used by the bindings internally. func UnsafeTocFromGlibFull(p unsafe.Pointer) *Toc { wrapped := UnsafeTocFromGlibBorrow(p) runtime.SetFinalizer( @@ -59859,6 +61324,7 @@ func UnsafeTocToGlibFull(t *Toc) unsafe.Pointer { t.native = nil // Toc is invalid from here on return _p } + // NewToc wraps gst_toc_new // // The function takes the following parameters: @@ -59949,6 +61415,7 @@ func (toc *Toc) FindEntry(uid string) *TocEntry { } // GetEntries wraps gst_toc_get_entries +// // The function returns the following values: // // - goret []*TocEntry @@ -59978,6 +61445,7 @@ func (toc *Toc) GetEntries() []*TocEntry { } // GetScope wraps gst_toc_get_scope +// // The function returns the following values: // // - goret TocScope @@ -59998,6 +61466,7 @@ func (toc *Toc) GetScope() TocScope { } // GetTags wraps gst_toc_get_tags +// // The function returns the following values: // // - goret *TagList (nullable) @@ -60094,7 +61563,7 @@ func UnsafeTocEntryFromGlibBorrow(p unsafe.Pointer) *TocEntry { return &TocEntry{&tocEntry{(*C.GstTocEntry)(p)}} } -// UnsafeTocEntryFromGlibNone is used to convert raw C.GstTocEntry pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeTocEntryFromGlibNone is used to convert raw C.GstTocEntry pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeTocEntryFromGlibNone(p unsafe.Pointer) *TocEntry { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeTocEntryFromGlibBorrow(p) @@ -60107,7 +61576,7 @@ func UnsafeTocEntryFromGlibNone(p unsafe.Pointer) *TocEntry { return wrapped } -// UnsafeTocEntryFromGlibFull is used to convert raw C.GstTocEntry pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeTocEntryFromGlibFull is used to convert raw C.GstTocEntry pointers to go while taking ownership. This is used by the bindings internally. func UnsafeTocEntryFromGlibFull(p unsafe.Pointer) *TocEntry { wrapped := UnsafeTocEntryFromGlibBorrow(p) runtime.SetFinalizer( @@ -60139,6 +61608,7 @@ func UnsafeTocEntryToGlibFull(t *TocEntry) unsafe.Pointer { t.native = nil // TocEntry is invalid from here on return _p } + // NewTocEntry wraps gst_toc_entry_new // // The function takes the following parameters: @@ -60191,6 +61661,7 @@ func (entry *TocEntry) AppendSubEntry(subentry *TocEntry) { } // GetEntryType wraps gst_toc_entry_get_entry_type +// // The function returns the following values: // // - goret TocEntryType @@ -60211,6 +61682,7 @@ func (entry *TocEntry) GetEntryType() TocEntryType { } // GetLoop wraps gst_toc_entry_get_loop +// // The function returns the following values: // // - loopType TocLoopType: the storage for the loop_type @@ -60248,6 +61720,7 @@ func (entry *TocEntry) GetLoop() (TocLoopType, int, bool) { } // GetParent wraps gst_toc_entry_get_parent +// // The function returns the following values: // // - goret *TocEntry (nullable) @@ -60272,6 +61745,7 @@ func (entry *TocEntry) GetParent() *TocEntry { } // GetStartStopTimes wraps gst_toc_entry_get_start_stop_times +// // The function returns the following values: // // - start int64: the storage for the start value, leave @@ -60307,6 +61781,7 @@ func (entry *TocEntry) GetStartStopTimes() (int64, int64, bool) { } // GetSubEntries wraps gst_toc_entry_get_sub_entries +// // The function returns the following values: // // - goret []*TocEntry @@ -60336,6 +61811,7 @@ func (entry *TocEntry) GetSubEntries() []*TocEntry { } // GetTags wraps gst_toc_entry_get_tags +// // The function returns the following values: // // - goret *TagList (nullable) @@ -60360,6 +61836,7 @@ func (entry *TocEntry) GetTags() *TagList { } // GetToc wraps gst_toc_entry_get_toc +// // The function returns the following values: // // - goret *Toc (nullable) @@ -60384,6 +61861,7 @@ func (entry *TocEntry) GetToc() *Toc { } // GetUid wraps gst_toc_entry_get_uid +// // The function returns the following values: // // - goret string @@ -60406,6 +61884,7 @@ func (entry *TocEntry) GetUid() string { } // IsAlternative wraps gst_toc_entry_is_alternative +// // The function returns the following values: // // - goret bool @@ -60428,6 +61907,7 @@ func (entry *TocEntry) IsAlternative() bool { } // IsSequence wraps gst_toc_entry_is_sequence +// // The function returns the following values: // // - goret bool @@ -60558,7 +62038,7 @@ func UnsafeTocSetterInterfaceFromGlibBorrow(p unsafe.Pointer) *TocSetterInterfac return &TocSetterInterface{&tocSetterInterface{(*C.GstTocSetterInterface)(p)}} } -// UnsafeTocSetterInterfaceFromGlibNone is used to convert raw C.GstTocSetterInterface pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeTocSetterInterfaceFromGlibNone is used to convert raw C.GstTocSetterInterface pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeTocSetterInterfaceFromGlibNone(p unsafe.Pointer) *TocSetterInterface { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeTocSetterInterfaceFromGlibBorrow(p) @@ -60571,7 +62051,7 @@ func UnsafeTocSetterInterfaceFromGlibNone(p unsafe.Pointer) *TocSetterInterface return wrapped } -// UnsafeTocSetterInterfaceFromGlibFull is used to convert raw C.GstTocSetterInterface pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeTocSetterInterfaceFromGlibFull is used to convert raw C.GstTocSetterInterface pointers to go while taking ownership. This is used by the bindings internally. func UnsafeTocSetterInterfaceFromGlibFull(p unsafe.Pointer) *TocSetterInterface { wrapped := UnsafeTocSetterInterfaceFromGlibBorrow(p) runtime.SetFinalizer( @@ -60603,7 +62083,10 @@ func UnsafeTocSetterInterfaceToGlibFull(t *TocSetterInterface) unsafe.Pointer { t.native = nil // TocSetterInterface is invalid from here on return _p } + // TracerClass wraps GstTracerClass +// +// TracerClass is the type struct for [Tracer] type TracerClass struct { *tracerClass } @@ -60618,31 +62101,6 @@ func UnsafeTracerClassFromGlibBorrow(p unsafe.Pointer) *TracerClass { return &TracerClass{&tracerClass{(*C.GstTracerClass)(p)}} } -// UnsafeTracerClassFromGlibNone is used to convert raw C.GstTracerClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeTracerClassFromGlibNone(p unsafe.Pointer) *TracerClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeTracerClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.tracerClass, - func (intern *tracerClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeTracerClassFromGlibFull is used to convert raw C.GstTracerClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeTracerClassFromGlibFull(p unsafe.Pointer) *TracerClass { - wrapped := UnsafeTracerClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.tracerClass, - func (intern *tracerClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeTracerClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [TracerClass] is expected to work anymore. @@ -60655,15 +62113,18 @@ func UnsafeTracerClassToGlibNone(t *TracerClass) unsafe.Pointer { return unsafe.Pointer(t.native) } -// UnsafeTracerClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeTracerClassToGlibFull(t *TracerClass) unsafe.Pointer { - runtime.SetFinalizer(t.tracerClass, nil) - _p := unsafe.Pointer(t.native) - t.native = nil // TracerClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (t *TracerClass) ParentClass() *ObjectClass { + parent := UnsafeObjectClassFromGlibBorrow(UnsafeTracerClassToGlibNone(t)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *TracerClass) {}, t) + return parent } + // TracerFactoryClass wraps GstTracerFactoryClass +// +// TracerFactoryClass is the type struct for [TracerFactory] type TracerFactoryClass struct { *tracerFactoryClass } @@ -60678,31 +62139,6 @@ func UnsafeTracerFactoryClassFromGlibBorrow(p unsafe.Pointer) *TracerFactoryClas return &TracerFactoryClass{&tracerFactoryClass{(*C.GstTracerFactoryClass)(p)}} } -// UnsafeTracerFactoryClassFromGlibNone is used to convert raw C.GstTracerFactoryClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeTracerFactoryClassFromGlibNone(p unsafe.Pointer) *TracerFactoryClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeTracerFactoryClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.tracerFactoryClass, - func (intern *tracerFactoryClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeTracerFactoryClassFromGlibFull is used to convert raw C.GstTracerFactoryClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeTracerFactoryClassFromGlibFull(p unsafe.Pointer) *TracerFactoryClass { - wrapped := UnsafeTracerFactoryClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.tracerFactoryClass, - func (intern *tracerFactoryClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeTracerFactoryClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [TracerFactoryClass] is expected to work anymore. @@ -60715,15 +62151,18 @@ func UnsafeTracerFactoryClassToGlibNone(t *TracerFactoryClass) unsafe.Pointer { return unsafe.Pointer(t.native) } -// UnsafeTracerFactoryClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeTracerFactoryClassToGlibFull(t *TracerFactoryClass) unsafe.Pointer { - runtime.SetFinalizer(t.tracerFactoryClass, nil) - _p := unsafe.Pointer(t.native) - t.native = nil // TracerFactoryClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (t *TracerFactoryClass) ParentClass() *PluginFeatureClass { + parent := UnsafePluginFeatureClassFromGlibBorrow(UnsafeTracerFactoryClassToGlibNone(t)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *TracerFactoryClass) {}, t) + return parent } + // TracerRecordClass wraps GstTracerRecordClass +// +// TracerRecordClass is the type struct for [TracerRecord] type TracerRecordClass struct { *tracerRecordClass } @@ -60738,31 +62177,6 @@ func UnsafeTracerRecordClassFromGlibBorrow(p unsafe.Pointer) *TracerRecordClass return &TracerRecordClass{&tracerRecordClass{(*C.GstTracerRecordClass)(p)}} } -// UnsafeTracerRecordClassFromGlibNone is used to convert raw C.GstTracerRecordClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeTracerRecordClassFromGlibNone(p unsafe.Pointer) *TracerRecordClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeTracerRecordClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.tracerRecordClass, - func (intern *tracerRecordClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeTracerRecordClassFromGlibFull is used to convert raw C.GstTracerRecordClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeTracerRecordClassFromGlibFull(p unsafe.Pointer) *TracerRecordClass { - wrapped := UnsafeTracerRecordClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.tracerRecordClass, - func (intern *tracerRecordClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeTracerRecordClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [TracerRecordClass] is expected to work anymore. @@ -60775,14 +62189,15 @@ func UnsafeTracerRecordClassToGlibNone(t *TracerRecordClass) unsafe.Pointer { return unsafe.Pointer(t.native) } -// UnsafeTracerRecordClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeTracerRecordClassToGlibFull(t *TracerRecordClass) unsafe.Pointer { - runtime.SetFinalizer(t.tracerRecordClass, nil) - _p := unsafe.Pointer(t.native) - t.native = nil // TracerRecordClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (t *TracerRecordClass) ParentClass() *ObjectClass { + parent := UnsafeObjectClassFromGlibBorrow(UnsafeTracerRecordClassToGlibNone(t)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *TracerRecordClass) {}, t) + return parent } + // TypeFind wraps GstTypeFind // // The following functions allow you to detect the media type of an unknown @@ -60813,7 +62228,7 @@ func UnsafeTypeFindFromGlibBorrow(p unsafe.Pointer) *TypeFind { return &TypeFind{&typeFind{(*C.GstTypeFind)(p)}} } -// UnsafeTypeFindFromGlibNone is used to convert raw C.GstTypeFind pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeTypeFindFromGlibNone is used to convert raw C.GstTypeFind pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeTypeFindFromGlibNone(p unsafe.Pointer) *TypeFind { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeTypeFindFromGlibBorrow(p) @@ -60826,7 +62241,7 @@ func UnsafeTypeFindFromGlibNone(p unsafe.Pointer) *TypeFind { return wrapped } -// UnsafeTypeFindFromGlibFull is used to convert raw C.GstTypeFind pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeTypeFindFromGlibFull is used to convert raw C.GstTypeFind pointers to go while taking ownership. This is used by the bindings internally. func UnsafeTypeFindFromGlibFull(p unsafe.Pointer) *TypeFind { wrapped := UnsafeTypeFindFromGlibBorrow(p) runtime.SetFinalizer( @@ -60858,6 +62273,7 @@ func UnsafeTypeFindToGlibFull(t *TypeFind) unsafe.Pointer { t.native = nil // TypeFind is invalid from here on return _p } + // TypeFindRegister wraps gst_type_find_register // // The function takes the following parameters: @@ -60924,6 +62340,7 @@ func TypeFindRegister(plugin Plugin, name string, rank uint, fn TypeFindFunction } // GetLength wraps gst_type_find_get_length +// // The function returns the following values: // // - goret uint64 @@ -61042,6 +62459,8 @@ func (find *TypeFind) SuggestEmptySimple(probability uint, mediaType string) { } // TypeFindFactoryClass wraps GstTypeFindFactoryClass +// +// TypeFindFactoryClass is the type struct for [TypeFindFactory] type TypeFindFactoryClass struct { *typeFindFactoryClass } @@ -61056,31 +62475,6 @@ func UnsafeTypeFindFactoryClassFromGlibBorrow(p unsafe.Pointer) *TypeFindFactory return &TypeFindFactoryClass{&typeFindFactoryClass{(*C.GstTypeFindFactoryClass)(p)}} } -// UnsafeTypeFindFactoryClassFromGlibNone is used to convert raw C.GstTypeFindFactoryClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeTypeFindFactoryClassFromGlibNone(p unsafe.Pointer) *TypeFindFactoryClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeTypeFindFactoryClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.typeFindFactoryClass, - func (intern *typeFindFactoryClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeTypeFindFactoryClassFromGlibFull is used to convert raw C.GstTypeFindFactoryClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeTypeFindFactoryClassFromGlibFull(p unsafe.Pointer) *TypeFindFactoryClass { - wrapped := UnsafeTypeFindFactoryClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.typeFindFactoryClass, - func (intern *typeFindFactoryClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeTypeFindFactoryClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [TypeFindFactoryClass] is expected to work anymore. @@ -61093,14 +62487,15 @@ func UnsafeTypeFindFactoryClassToGlibNone(t *TypeFindFactoryClass) unsafe.Pointe return unsafe.Pointer(t.native) } -// UnsafeTypeFindFactoryClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeTypeFindFactoryClassToGlibFull(t *TypeFindFactoryClass) unsafe.Pointer { - runtime.SetFinalizer(t.typeFindFactoryClass, nil) - _p := unsafe.Pointer(t.native) - t.native = nil // TypeFindFactoryClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (t *TypeFindFactoryClass) ParentClass() *PluginFeatureClass { + parent := UnsafePluginFeatureClassFromGlibBorrow(UnsafeTypeFindFactoryClassToGlibNone(t)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *TypeFindFactoryClass) {}, t) + return parent } + // URIHandlerInterface wraps GstURIHandlerInterface // // Any #GstElement using this interface should implement these methods. @@ -61118,7 +62513,7 @@ func UnsafeURIHandlerInterfaceFromGlibBorrow(p unsafe.Pointer) *URIHandlerInterf return &URIHandlerInterface{&uriHandlerInterface{(*C.GstURIHandlerInterface)(p)}} } -// UnsafeURIHandlerInterfaceFromGlibNone is used to convert raw C.GstURIHandlerInterface pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeURIHandlerInterfaceFromGlibNone is used to convert raw C.GstURIHandlerInterface pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeURIHandlerInterfaceFromGlibNone(p unsafe.Pointer) *URIHandlerInterface { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeURIHandlerInterfaceFromGlibBorrow(p) @@ -61131,7 +62526,7 @@ func UnsafeURIHandlerInterfaceFromGlibNone(p unsafe.Pointer) *URIHandlerInterfac return wrapped } -// UnsafeURIHandlerInterfaceFromGlibFull is used to convert raw C.GstURIHandlerInterface pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeURIHandlerInterfaceFromGlibFull is used to convert raw C.GstURIHandlerInterface pointers to go while taking ownership. This is used by the bindings internally. func UnsafeURIHandlerInterfaceFromGlibFull(p unsafe.Pointer) *URIHandlerInterface { wrapped := UnsafeURIHandlerInterfaceFromGlibBorrow(p) runtime.SetFinalizer( @@ -61163,6 +62558,7 @@ func UnsafeURIHandlerInterfaceToGlibFull(u *URIHandlerInterface) unsafe.Pointer u.native = nil // URIHandlerInterface is invalid from here on return _p } + // Uri wraps GstUri // // A #GstUri object can be used to parse and split a URI string into its @@ -61194,7 +62590,7 @@ func UnsafeUriFromGlibBorrow(p unsafe.Pointer) *Uri { return &Uri{&uri{(*C.GstUri)(p)}} } -// UnsafeUriFromGlibNone is used to convert raw C.GstUri pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeUriFromGlibNone is used to convert raw C.GstUri pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeUriFromGlibNone(p unsafe.Pointer) *Uri { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeUriFromGlibBorrow(p) @@ -61207,7 +62603,7 @@ func UnsafeUriFromGlibNone(p unsafe.Pointer) *Uri { return wrapped } -// UnsafeUriFromGlibFull is used to convert raw C.GstUri pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeUriFromGlibFull is used to convert raw C.GstUri pointers to go while taking ownership. This is used by the bindings internally. func UnsafeUriFromGlibFull(p unsafe.Pointer) *Uri { wrapped := UnsafeUriFromGlibBorrow(p) runtime.SetFinalizer( @@ -61239,6 +62635,7 @@ func UnsafeUriToGlibFull(u *Uri) unsafe.Pointer { u.native = nil // Uri is invalid from here on return _p } + // NewUri wraps gst_uri_new // // The function takes the following parameters: @@ -61801,6 +63198,7 @@ func (base *Uri) FromStringWithBase(uri string) *Uri { } // GetFragment wraps gst_uri_get_fragment +// // The function returns the following values: // // - goret string (nullable) @@ -61826,6 +63224,7 @@ func (uri *Uri) GetFragment() string { } // GetHost wraps gst_uri_get_host +// // The function returns the following values: // // - goret string (nullable) @@ -61851,6 +63250,7 @@ func (uri *Uri) GetHost() string { } // GetPath wraps gst_uri_get_path +// // The function returns the following values: // // - goret string (nullable) @@ -61876,6 +63276,7 @@ func (uri *Uri) GetPath() string { } // GetPathSegments wraps gst_uri_get_path_segments +// // The function returns the following values: // // - goret []string @@ -61906,6 +63307,7 @@ func (uri *Uri) GetPathSegments() []string { } // GetPathString wraps gst_uri_get_path_string +// // The function returns the following values: // // - goret string (nullable) @@ -61931,6 +63333,7 @@ func (uri *Uri) GetPathString() string { } // GetPort wraps gst_uri_get_port +// // The function returns the following values: // // - goret uint @@ -61954,6 +63357,7 @@ func (uri *Uri) GetPort() uint { } // GetQueryKeys wraps gst_uri_get_query_keys +// // The function returns the following values: // // - goret []string @@ -61983,6 +63387,7 @@ func (uri *Uri) GetQueryKeys() []string { } // GetQueryString wraps gst_uri_get_query_string +// // The function returns the following values: // // - goret string (nullable) @@ -62045,6 +63450,7 @@ func (uri *Uri) GetQueryValue(queryKey string) string { } // GetScheme wraps gst_uri_get_scheme +// // The function returns the following values: // // - goret string (nullable) @@ -62070,6 +63476,7 @@ func (uri *Uri) GetScheme() string { } // GetUserinfo wraps gst_uri_get_userinfo +// // The function returns the following values: // // - goret string (nullable) @@ -62095,6 +63502,7 @@ func (uri *Uri) GetUserinfo() string { } // IsNormalized wraps gst_uri_is_normalized +// // The function returns the following values: // // - goret bool @@ -62120,6 +63528,7 @@ func (uri *Uri) IsNormalized() bool { } // IsWritable wraps gst_uri_is_writable +// // The function returns the following values: // // - goret bool @@ -62187,6 +63596,7 @@ func (baseUri *Uri) Join(refUri *Uri) *Uri { } // MakeWritable wraps gst_uri_make_writable +// // The function returns the following values: // // - goret *Uri @@ -62289,6 +63699,7 @@ func (base *Uri) NewWithBase(scheme string, userinfo string, host string, port u } // Normalize wraps gst_uri_normalize +// // The function returns the following values: // // - goret bool @@ -62699,6 +64110,7 @@ func (uri *Uri) SetUserinfo(userinfo string) bool { } // ToString wraps gst_uri_to_string +// // The function returns the following values: // // - goret string @@ -62742,7 +64154,7 @@ func UnsafeValueTableFromGlibBorrow(p unsafe.Pointer) *ValueTable { return &ValueTable{&valueTable{(*C.GstValueTable)(p)}} } -// UnsafeValueTableFromGlibNone is used to convert raw C.GstValueTable pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeValueTableFromGlibNone is used to convert raw C.GstValueTable pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeValueTableFromGlibNone(p unsafe.Pointer) *ValueTable { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeValueTableFromGlibBorrow(p) @@ -62755,7 +64167,7 @@ func UnsafeValueTableFromGlibNone(p unsafe.Pointer) *ValueTable { return wrapped } -// UnsafeValueTableFromGlibFull is used to convert raw C.GstValueTable pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeValueTableFromGlibFull is used to convert raw C.GstValueTable pointers to go while taking ownership. This is used by the bindings internally. func UnsafeValueTableFromGlibFull(p unsafe.Pointer) *ValueTable { wrapped := UnsafeValueTableFromGlibBorrow(p) runtime.SetFinalizer( @@ -62787,3 +64199,4 @@ func UnsafeValueTableToGlibFull(v *ValueTable) unsafe.Pointer { v.native = nil // ValueTable is invalid from here on return _p } + diff --git a/pkg/gst/gst_export.gen.go b/pkg/gst/gst_export.gen.go index 61e73f2..7af03ff 100644 --- a/pkg/gst/gst_export.gen.go +++ b/pkg/gst/gst_export.gen.go @@ -657,3 +657,353 @@ func _gotk4_gst1_ElementForEachPadFunc(carg1 *C.GstElement, carg2 *C.GstPad, car return cret } +//export _gotk4_gst1_ChildProxy_child_added +func _gotk4_gst1_ChildProxy_child_added(carg0 *C.GstChildProxy, carg1 *C.GObject, carg2 *C.gchar) { + panic("unimplemented") +} + +//export _gotk4_gst1_ChildProxy_child_removed +func _gotk4_gst1_ChildProxy_child_removed(carg0 *C.GstChildProxy, carg1 *C.GObject, carg2 *C.gchar) { + panic("unimplemented") +} + +//export _gotk4_gst1_ChildProxy_get_child_by_index +func _gotk4_gst1_ChildProxy_get_child_by_index(carg0 *C.GstChildProxy, carg1 C.guint) (cret *C.GObject) { + panic("unimplemented") +} + +//export _gotk4_gst1_ChildProxy_get_child_by_name +func _gotk4_gst1_ChildProxy_get_child_by_name(carg0 *C.GstChildProxy, carg1 *C.gchar) (cret *C.GObject) { + panic("unimplemented") +} + +//export _gotk4_gst1_ChildProxy_get_children_count +func _gotk4_gst1_ChildProxy_get_children_count(carg0 *C.GstChildProxy) (cret C.guint) { + panic("unimplemented") +} + +//export _gotk4_gst1_Preset_delete_preset +func _gotk4_gst1_Preset_delete_preset(carg0 *C.GstPreset, carg1 *C.gchar) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gst1_Preset_get_meta +func _gotk4_gst1_Preset_get_meta(carg0 *C.GstPreset, carg1 *C.gchar, carg2 *C.gchar, carg3 **C.gchar) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gst1_Preset_get_preset_names +func _gotk4_gst1_Preset_get_preset_names(carg0 *C.GstPreset) (cret **C.gchar) { + panic("unimplemented") +} + +//export _gotk4_gst1_Preset_get_property_names +func _gotk4_gst1_Preset_get_property_names(carg0 *C.GstPreset) (cret **C.gchar) { + panic("unimplemented") +} + +//export _gotk4_gst1_Preset_load_preset +func _gotk4_gst1_Preset_load_preset(carg0 *C.GstPreset, carg1 *C.gchar) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gst1_Preset_rename_preset +func _gotk4_gst1_Preset_rename_preset(carg0 *C.GstPreset, carg1 *C.gchar, carg2 *C.gchar) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gst1_Preset_save_preset +func _gotk4_gst1_Preset_save_preset(carg0 *C.GstPreset, carg1 *C.gchar) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gst1_Preset_set_meta +func _gotk4_gst1_Preset_set_meta(carg0 *C.GstPreset, carg1 *C.gchar, carg2 *C.gchar, carg3 *C.gchar) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gst1_URIHandler_get_uri +func _gotk4_gst1_URIHandler_get_uri(carg0 *C.GstURIHandler) (cret *C.gchar) { + panic("unimplemented") +} + +//export _gotk4_gst1_URIHandler_set_uri +func _gotk4_gst1_URIHandler_set_uri(carg0 *C.GstURIHandler, carg1 *C.gchar, _cerr **C.GError) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gst1_Pad_linked +func _gotk4_gst1_Pad_linked(carg0 *C.GstPad, carg1 *C.GstPad) { + panic("unimplemented") +} + +//export _gotk4_gst1_Pad_unlinked +func _gotk4_gst1_Pad_unlinked(carg0 *C.GstPad, carg1 *C.GstPad) { + panic("unimplemented") +} + +//export _gotk4_gst1_PadTemplate_pad_created +func _gotk4_gst1_PadTemplate_pad_created(carg0 *C.GstPadTemplate, carg1 *C.GstPad) { + panic("unimplemented") +} + +//export _gotk4_gst1_TaskPool_cleanup +func _gotk4_gst1_TaskPool_cleanup(carg0 *C.GstTaskPool) { + panic("unimplemented") +} + +//export _gotk4_gst1_TaskPool_prepare +func _gotk4_gst1_TaskPool_prepare(carg0 *C.GstTaskPool, _cerr **C.GError) { + panic("unimplemented") +} + +//export _gotk4_gst1_Allocator_alloc +func _gotk4_gst1_Allocator_alloc(carg0 *C.GstAllocator, carg1 C.gsize, carg2 *C.GstAllocationParams) (cret *C.GstMemory) { + panic("unimplemented") +} + +//export _gotk4_gst1_Allocator_free +func _gotk4_gst1_Allocator_free(carg0 *C.GstAllocator, carg1 *C.GstMemory) { + panic("unimplemented") +} + +//export _gotk4_gst1_BufferPool_acquire_buffer +func _gotk4_gst1_BufferPool_acquire_buffer(carg0 *C.GstBufferPool, carg1 **C.GstBuffer, carg2 *C.GstBufferPoolAcquireParams) (cret C.GstFlowReturn) { + panic("unimplemented") +} + +//export _gotk4_gst1_BufferPool_alloc_buffer +func _gotk4_gst1_BufferPool_alloc_buffer(carg0 *C.GstBufferPool, carg1 **C.GstBuffer, carg2 *C.GstBufferPoolAcquireParams) (cret C.GstFlowReturn) { + panic("unimplemented") +} + +//export _gotk4_gst1_BufferPool_flush_start +func _gotk4_gst1_BufferPool_flush_start(carg0 *C.GstBufferPool) { + panic("unimplemented") +} + +//export _gotk4_gst1_BufferPool_flush_stop +func _gotk4_gst1_BufferPool_flush_stop(carg0 *C.GstBufferPool) { + panic("unimplemented") +} + +//export _gotk4_gst1_BufferPool_free_buffer +func _gotk4_gst1_BufferPool_free_buffer(carg0 *C.GstBufferPool, carg1 *C.GstBuffer) { + panic("unimplemented") +} + +//export _gotk4_gst1_BufferPool_get_options +func _gotk4_gst1_BufferPool_get_options(carg0 *C.GstBufferPool) (cret **C.gchar) { + panic("unimplemented") +} + +//export _gotk4_gst1_BufferPool_release_buffer +func _gotk4_gst1_BufferPool_release_buffer(carg0 *C.GstBufferPool, carg1 *C.GstBuffer) { + panic("unimplemented") +} + +//export _gotk4_gst1_BufferPool_reset_buffer +func _gotk4_gst1_BufferPool_reset_buffer(carg0 *C.GstBufferPool, carg1 *C.GstBuffer) { + panic("unimplemented") +} + +//export _gotk4_gst1_BufferPool_set_config +func _gotk4_gst1_BufferPool_set_config(carg0 *C.GstBufferPool, carg1 *C.GstStructure) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gst1_BufferPool_start +func _gotk4_gst1_BufferPool_start(carg0 *C.GstBufferPool) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gst1_BufferPool_stop +func _gotk4_gst1_BufferPool_stop(carg0 *C.GstBufferPool) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gst1_Bus_message +func _gotk4_gst1_Bus_message(carg0 *C.GstBus, carg1 *C.GstMessage) { + panic("unimplemented") +} + +//export _gotk4_gst1_Bus_sync_message +func _gotk4_gst1_Bus_sync_message(carg0 *C.GstBus, carg1 *C.GstMessage) { + panic("unimplemented") +} + +//export _gotk4_gst1_Clock_change_resolution +func _gotk4_gst1_Clock_change_resolution(carg0 *C.GstClock, carg1 C.GstClockTime, carg2 C.GstClockTime) (cret C.GstClockTime) { + panic("unimplemented") +} + +//export _gotk4_gst1_Clock_get_internal_time +func _gotk4_gst1_Clock_get_internal_time(carg0 *C.GstClock) (cret C.GstClockTime) { + panic("unimplemented") +} + +//export _gotk4_gst1_Clock_get_resolution +func _gotk4_gst1_Clock_get_resolution(carg0 *C.GstClock) (cret C.GstClockTime) { + panic("unimplemented") +} + +//export _gotk4_gst1_Clock_unschedule +func _gotk4_gst1_Clock_unschedule(carg0 *C.GstClock, carg1 *C.GstClockEntry) { + panic("unimplemented") +} + +//export _gotk4_gst1_Clock_wait +func _gotk4_gst1_Clock_wait(carg0 *C.GstClock, carg1 *C.GstClockEntry, carg2 *C.GstClockTimeDiff) (cret C.GstClockReturn) { + panic("unimplemented") +} + +//export _gotk4_gst1_Clock_wait_async +func _gotk4_gst1_Clock_wait_async(carg0 *C.GstClock, carg1 *C.GstClockEntry) (cret C.GstClockReturn) { + panic("unimplemented") +} + +//export _gotk4_gst1_ControlBinding_sync_values +func _gotk4_gst1_ControlBinding_sync_values(carg0 *C.GstControlBinding, carg1 *C.GstObject, carg2 C.GstClockTime, carg3 C.GstClockTime) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gst1_Device_create_element +func _gotk4_gst1_Device_create_element(carg0 *C.GstDevice, carg1 *C.gchar) (cret *C.GstElement) { + panic("unimplemented") +} + +//export _gotk4_gst1_Device_reconfigure_element +func _gotk4_gst1_Device_reconfigure_element(carg0 *C.GstDevice, carg1 *C.GstElement) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gst1_DeviceProvider_start +func _gotk4_gst1_DeviceProvider_start(carg0 *C.GstDeviceProvider) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gst1_DeviceProvider_stop +func _gotk4_gst1_DeviceProvider_stop(carg0 *C.GstDeviceProvider) { + panic("unimplemented") +} + +//export _gotk4_gst1_Element_change_state +func _gotk4_gst1_Element_change_state(carg0 *C.GstElement, carg1 C.GstStateChange) (cret C.GstStateChangeReturn) { + panic("unimplemented") +} + +//export _gotk4_gst1_Element_get_state +func _gotk4_gst1_Element_get_state(carg0 *C.GstElement, carg1 *C.GstState, carg2 *C.GstState, carg3 C.GstClockTime) (cret C.GstStateChangeReturn) { + panic("unimplemented") +} + +//export _gotk4_gst1_Element_no_more_pads +func _gotk4_gst1_Element_no_more_pads(carg0 *C.GstElement) { + panic("unimplemented") +} + +//export _gotk4_gst1_Element_pad_added +func _gotk4_gst1_Element_pad_added(carg0 *C.GstElement, carg1 *C.GstPad) { + panic("unimplemented") +} + +//export _gotk4_gst1_Element_pad_removed +func _gotk4_gst1_Element_pad_removed(carg0 *C.GstElement, carg1 *C.GstPad) { + panic("unimplemented") +} + +//export _gotk4_gst1_Element_post_message +func _gotk4_gst1_Element_post_message(carg0 *C.GstElement, carg1 *C.GstMessage) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gst1_Element_provide_clock +func _gotk4_gst1_Element_provide_clock(carg0 *C.GstElement) (cret *C.GstClock) { + panic("unimplemented") +} + +//export _gotk4_gst1_Element_query +func _gotk4_gst1_Element_query(carg0 *C.GstElement, carg1 *C.GstQuery) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gst1_Element_release_pad +func _gotk4_gst1_Element_release_pad(carg0 *C.GstElement, carg1 *C.GstPad) { + panic("unimplemented") +} + +//export _gotk4_gst1_Element_request_new_pad +func _gotk4_gst1_Element_request_new_pad(carg0 *C.GstElement, carg1 *C.GstPadTemplate, carg2 *C.gchar, carg3 *C.GstCaps) (cret *C.GstPad) { + panic("unimplemented") +} + +//export _gotk4_gst1_Element_send_event +func _gotk4_gst1_Element_send_event(carg0 *C.GstElement, carg1 *C.GstEvent) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gst1_Element_set_bus +func _gotk4_gst1_Element_set_bus(carg0 *C.GstElement, carg1 *C.GstBus) { + panic("unimplemented") +} + +//export _gotk4_gst1_Element_set_clock +func _gotk4_gst1_Element_set_clock(carg0 *C.GstElement, carg1 *C.GstClock) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gst1_Element_set_context +func _gotk4_gst1_Element_set_context(carg0 *C.GstElement, carg1 *C.GstContext) { + panic("unimplemented") +} + +//export _gotk4_gst1_Element_set_state +func _gotk4_gst1_Element_set_state(carg0 *C.GstElement, carg1 C.GstState) (cret C.GstStateChangeReturn) { + panic("unimplemented") +} + +//export _gotk4_gst1_Element_state_changed +func _gotk4_gst1_Element_state_changed(carg0 *C.GstElement, carg1 C.GstState, carg2 C.GstState, carg3 C.GstState) { + panic("unimplemented") +} + +//export _gotk4_gst1_Bin_add_element +func _gotk4_gst1_Bin_add_element(carg0 *C.GstBin, carg1 *C.GstElement) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gst1_Bin_deep_element_added +func _gotk4_gst1_Bin_deep_element_added(carg0 *C.GstBin, carg1 *C.GstBin, carg2 *C.GstElement) { + panic("unimplemented") +} + +//export _gotk4_gst1_Bin_deep_element_removed +func _gotk4_gst1_Bin_deep_element_removed(carg0 *C.GstBin, carg1 *C.GstBin, carg2 *C.GstElement) { + panic("unimplemented") +} + +//export _gotk4_gst1_Bin_do_latency +func _gotk4_gst1_Bin_do_latency(carg0 *C.GstBin) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gst1_Bin_element_added +func _gotk4_gst1_Bin_element_added(carg0 *C.GstBin, carg1 *C.GstElement) { + panic("unimplemented") +} + +//export _gotk4_gst1_Bin_element_removed +func _gotk4_gst1_Bin_element_removed(carg0 *C.GstBin, carg1 *C.GstElement) { + panic("unimplemented") +} + +//export _gotk4_gst1_Bin_handle_message +func _gotk4_gst1_Bin_handle_message(carg0 *C.GstBin, carg1 *C.GstMessage) { + panic("unimplemented") +} + +//export _gotk4_gst1_Bin_remove_element +func _gotk4_gst1_Bin_remove_element(carg0 *C.GstBin, carg1 *C.GstElement) (cret C.gboolean) { + panic("unimplemented") +} + diff --git a/pkg/gstallocators/gstallocators.gen.go b/pkg/gstallocators/gstallocators.gen.go index 0d07f5f..b02e92e 100644 --- a/pkg/gstallocators/gstallocators.gen.go +++ b/pkg/gstallocators/gstallocators.gen.go @@ -361,6 +361,16 @@ func UnsafePhysMemoryAllocatorToGlibFull(c PhysMemoryAllocator) unsafe.Pointer { return gobject.UnsafeObjectToGlibFull(&i.Instance) } +// PhysMemoryAllocatorOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type PhysMemoryAllocatorOverrides[Instance PhysMemoryAllocator] struct { +} + +// UnsafeApplyPhysMemoryAllocatorOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyPhysMemoryAllocatorOverrides[Instance PhysMemoryAllocator](gclass unsafe.Pointer, overrides PhysMemoryAllocatorOverrides[Instance]) { +} + // DRMDumbAllocatorInstance is the instance type used by all types extending GstDRMDumbAllocator. It is used internally by the bindings. Users should use the interface [DRMDumbAllocator] instead. type DRMDumbAllocatorInstance struct { _ [0]func() // equal guard @@ -395,6 +405,7 @@ type DRMDumbAllocator interface { // number and the height is scaled according to the sub-sampling. DRMAlloc(uint32, uint32, uint32) (uint32, *gst.Memory) // HasPrimeExport wraps gst_drm_dumb_allocator_has_prime_export + // // The function returns the following values: // // - goret bool @@ -552,6 +563,7 @@ func (allocator *DRMDumbAllocatorInstance) DRMAlloc(drmFourcc uint32, width uint } // HasPrimeExport wraps gst_drm_dumb_allocator_has_prime_export +// // The function returns the following values: // // - goret bool @@ -575,6 +587,20 @@ func (allocator *DRMDumbAllocatorInstance) HasPrimeExport() bool { return goret } +// DRMDumbAllocatorOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type DRMDumbAllocatorOverrides[Instance DRMDumbAllocator] struct { + // gst.AllocatorOverrides allows you to override virtual methods from the parent class gst.Allocator + gst.AllocatorOverrides[Instance] + +} + +// UnsafeApplyDRMDumbAllocatorOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyDRMDumbAllocatorOverrides[Instance DRMDumbAllocator](gclass unsafe.Pointer, overrides DRMDumbAllocatorOverrides[Instance]) { + gst.UnsafeApplyAllocatorOverrides(gclass, overrides.AllocatorOverrides) +} + // FdAllocatorInstance is the instance type used by all types extending GstFdAllocator. It is used internally by the bindings. Users should use the interface [FdAllocator] instead. type FdAllocatorInstance struct { _ [0]func() // equal guard @@ -632,6 +658,7 @@ func UnsafeFdAllocatorToGlibFull(c FdAllocator) unsafe.Pointer { } // NewFdAllocator wraps gst_fd_allocator_new +// // The function returns the following values: // // - goret gst.Allocator @@ -690,6 +717,20 @@ func FdAllocatorAlloc(allocator gst.Allocator, fd int, size uint, flags FdMemory return goret } +// FdAllocatorOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type FdAllocatorOverrides[Instance FdAllocator] struct { + // gst.AllocatorOverrides allows you to override virtual methods from the parent class gst.Allocator + gst.AllocatorOverrides[Instance] + +} + +// UnsafeApplyFdAllocatorOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyFdAllocatorOverrides[Instance FdAllocator](gclass unsafe.Pointer, overrides FdAllocatorOverrides[Instance]) { + gst.UnsafeApplyAllocatorOverrides(gclass, overrides.AllocatorOverrides) +} + // ShmAllocatorInstance is the instance type used by all types extending GstShmAllocator. It is used internally by the bindings. Users should use the interface [ShmAllocator] instead. type ShmAllocatorInstance struct { _ [0]func() // equal guard @@ -757,6 +798,7 @@ func UnsafeShmAllocatorToGlibFull(c ShmAllocator) unsafe.Pointer { } // ShmAllocatorGet wraps gst_shm_allocator_get +// // The function returns the following values: // // - goret gst.Allocator (nullable) @@ -786,6 +828,20 @@ func ShmAllocatorInitOnce() { C.gst_shm_allocator_init_once() } +// ShmAllocatorOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type ShmAllocatorOverrides[Instance ShmAllocator] struct { + // FdAllocatorOverrides allows you to override virtual methods from the parent class FdAllocator + FdAllocatorOverrides[Instance] + +} + +// UnsafeApplyShmAllocatorOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyShmAllocatorOverrides[Instance ShmAllocator](gclass unsafe.Pointer, overrides ShmAllocatorOverrides[Instance]) { + UnsafeApplyFdAllocatorOverrides(gclass, overrides.FdAllocatorOverrides) +} + // DmaBufAllocatorInstance is the instance type used by all types extending GstDmaBufAllocator. It is used internally by the bindings. Users should use the interface [DmaBufAllocator] instead. type DmaBufAllocatorInstance struct { _ [0]func() // equal guard @@ -845,6 +901,7 @@ func UnsafeDmaBufAllocatorToGlibFull(c DmaBufAllocator) unsafe.Pointer { } // NewDmaBufAllocator wraps gst_dmabuf_allocator_new +// // The function returns the following values: // // - goret gst.Allocator @@ -940,7 +997,23 @@ func DmaBufAllocatorAllocWithFlags(allocator gst.Allocator, fd int, size uint, f return goret } +// DmaBufAllocatorOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type DmaBufAllocatorOverrides[Instance DmaBufAllocator] struct { + // FdAllocatorOverrides allows you to override virtual methods from the parent class FdAllocator + FdAllocatorOverrides[Instance] + +} + +// UnsafeApplyDmaBufAllocatorOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyDmaBufAllocatorOverrides[Instance DmaBufAllocator](gclass unsafe.Pointer, overrides DmaBufAllocatorOverrides[Instance]) { + UnsafeApplyFdAllocatorOverrides(gclass, overrides.FdAllocatorOverrides) +} + // DRMDumbAllocatorClass wraps GstDRMDumbAllocatorClass +// +// DRMDumbAllocatorClass is the type struct for [DRMDumbAllocator] type DRMDumbAllocatorClass struct { *drmDumbAllocatorClass } @@ -955,31 +1028,6 @@ func UnsafeDRMDumbAllocatorClassFromGlibBorrow(p unsafe.Pointer) *DRMDumbAllocat return &DRMDumbAllocatorClass{&drmDumbAllocatorClass{(*C.GstDRMDumbAllocatorClass)(p)}} } -// UnsafeDRMDumbAllocatorClassFromGlibNone is used to convert raw C.GstDRMDumbAllocatorClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeDRMDumbAllocatorClassFromGlibNone(p unsafe.Pointer) *DRMDumbAllocatorClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeDRMDumbAllocatorClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.drmDumbAllocatorClass, - func (intern *drmDumbAllocatorClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeDRMDumbAllocatorClassFromGlibFull is used to convert raw C.GstDRMDumbAllocatorClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeDRMDumbAllocatorClassFromGlibFull(p unsafe.Pointer) *DRMDumbAllocatorClass { - wrapped := UnsafeDRMDumbAllocatorClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.drmDumbAllocatorClass, - func (intern *drmDumbAllocatorClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeDRMDumbAllocatorClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [DRMDumbAllocatorClass] is expected to work anymore. @@ -992,15 +1040,18 @@ func UnsafeDRMDumbAllocatorClassToGlibNone(d *DRMDumbAllocatorClass) unsafe.Poin return unsafe.Pointer(d.native) } -// UnsafeDRMDumbAllocatorClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeDRMDumbAllocatorClassToGlibFull(d *DRMDumbAllocatorClass) unsafe.Pointer { - runtime.SetFinalizer(d.drmDumbAllocatorClass, nil) - _p := unsafe.Pointer(d.native) - d.native = nil // DRMDumbAllocatorClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (d *DRMDumbAllocatorClass) ParentClass() *gst.AllocatorClass { + parent := gst.UnsafeAllocatorClassFromGlibBorrow(UnsafeDRMDumbAllocatorClassToGlibNone(d)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *DRMDumbAllocatorClass) {}, d) + return parent } + // DmaBufAllocatorClass wraps GstDmaBufAllocatorClass +// +// DmaBufAllocatorClass is the type struct for [DmaBufAllocator] type DmaBufAllocatorClass struct { *dmaBufAllocatorClass } @@ -1015,31 +1066,6 @@ func UnsafeDmaBufAllocatorClassFromGlibBorrow(p unsafe.Pointer) *DmaBufAllocator return &DmaBufAllocatorClass{&dmaBufAllocatorClass{(*C.GstDmaBufAllocatorClass)(p)}} } -// UnsafeDmaBufAllocatorClassFromGlibNone is used to convert raw C.GstDmaBufAllocatorClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeDmaBufAllocatorClassFromGlibNone(p unsafe.Pointer) *DmaBufAllocatorClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeDmaBufAllocatorClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.dmaBufAllocatorClass, - func (intern *dmaBufAllocatorClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeDmaBufAllocatorClassFromGlibFull is used to convert raw C.GstDmaBufAllocatorClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeDmaBufAllocatorClassFromGlibFull(p unsafe.Pointer) *DmaBufAllocatorClass { - wrapped := UnsafeDmaBufAllocatorClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.dmaBufAllocatorClass, - func (intern *dmaBufAllocatorClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeDmaBufAllocatorClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [DmaBufAllocatorClass] is expected to work anymore. @@ -1052,15 +1078,18 @@ func UnsafeDmaBufAllocatorClassToGlibNone(d *DmaBufAllocatorClass) unsafe.Pointe return unsafe.Pointer(d.native) } -// UnsafeDmaBufAllocatorClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeDmaBufAllocatorClassToGlibFull(d *DmaBufAllocatorClass) unsafe.Pointer { - runtime.SetFinalizer(d.dmaBufAllocatorClass, nil) - _p := unsafe.Pointer(d.native) - d.native = nil // DmaBufAllocatorClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (d *DmaBufAllocatorClass) ParentClass() *FdAllocatorClass { + parent := UnsafeFdAllocatorClassFromGlibBorrow(UnsafeDmaBufAllocatorClassToGlibNone(d)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *DmaBufAllocatorClass) {}, d) + return parent } + // FdAllocatorClass wraps GstFdAllocatorClass +// +// FdAllocatorClass is the type struct for [FdAllocator] type FdAllocatorClass struct { *fdAllocatorClass } @@ -1075,31 +1104,6 @@ func UnsafeFdAllocatorClassFromGlibBorrow(p unsafe.Pointer) *FdAllocatorClass { return &FdAllocatorClass{&fdAllocatorClass{(*C.GstFdAllocatorClass)(p)}} } -// UnsafeFdAllocatorClassFromGlibNone is used to convert raw C.GstFdAllocatorClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeFdAllocatorClassFromGlibNone(p unsafe.Pointer) *FdAllocatorClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeFdAllocatorClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.fdAllocatorClass, - func (intern *fdAllocatorClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeFdAllocatorClassFromGlibFull is used to convert raw C.GstFdAllocatorClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeFdAllocatorClassFromGlibFull(p unsafe.Pointer) *FdAllocatorClass { - wrapped := UnsafeFdAllocatorClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.fdAllocatorClass, - func (intern *fdAllocatorClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeFdAllocatorClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [FdAllocatorClass] is expected to work anymore. @@ -1112,14 +1116,15 @@ func UnsafeFdAllocatorClassToGlibNone(f *FdAllocatorClass) unsafe.Pointer { return unsafe.Pointer(f.native) } -// UnsafeFdAllocatorClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeFdAllocatorClassToGlibFull(f *FdAllocatorClass) unsafe.Pointer { - runtime.SetFinalizer(f.fdAllocatorClass, nil) - _p := unsafe.Pointer(f.native) - f.native = nil // FdAllocatorClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (f *FdAllocatorClass) ParentClass() *gst.AllocatorClass { + parent := gst.UnsafeAllocatorClassFromGlibBorrow(UnsafeFdAllocatorClassToGlibNone(f)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *FdAllocatorClass) {}, f) + return parent } + // PhysMemoryAllocatorInterface wraps GstPhysMemoryAllocatorInterface // // Marker interface for allocators with physical address backed memory @@ -1137,7 +1142,7 @@ func UnsafePhysMemoryAllocatorInterfaceFromGlibBorrow(p unsafe.Pointer) *PhysMem return &PhysMemoryAllocatorInterface{&physMemoryAllocatorInterface{(*C.GstPhysMemoryAllocatorInterface)(p)}} } -// UnsafePhysMemoryAllocatorInterfaceFromGlibNone is used to convert raw C.GstPhysMemoryAllocatorInterface pointers to go while taking a reference. This is used by the bindings internally. +// UnsafePhysMemoryAllocatorInterfaceFromGlibNone is used to convert raw C.GstPhysMemoryAllocatorInterface pointers to go without transferring ownership. This is used by the bindings internally. func UnsafePhysMemoryAllocatorInterfaceFromGlibNone(p unsafe.Pointer) *PhysMemoryAllocatorInterface { // FIXME: this has no ref function, what should we do here? wrapped := UnsafePhysMemoryAllocatorInterfaceFromGlibBorrow(p) @@ -1150,7 +1155,7 @@ func UnsafePhysMemoryAllocatorInterfaceFromGlibNone(p unsafe.Pointer) *PhysMemor return wrapped } -// UnsafePhysMemoryAllocatorInterfaceFromGlibFull is used to convert raw C.GstPhysMemoryAllocatorInterface pointers to go while taking a reference. This is used by the bindings internally. +// UnsafePhysMemoryAllocatorInterfaceFromGlibFull is used to convert raw C.GstPhysMemoryAllocatorInterface pointers to go while taking ownership. This is used by the bindings internally. func UnsafePhysMemoryAllocatorInterfaceFromGlibFull(p unsafe.Pointer) *PhysMemoryAllocatorInterface { wrapped := UnsafePhysMemoryAllocatorInterfaceFromGlibBorrow(p) runtime.SetFinalizer( @@ -1182,7 +1187,10 @@ func UnsafePhysMemoryAllocatorInterfaceToGlibFull(p *PhysMemoryAllocatorInterfac p.native = nil // PhysMemoryAllocatorInterface is invalid from here on return _p } + // ShmAllocatorClass wraps GstShmAllocatorClass +// +// ShmAllocatorClass is the type struct for [ShmAllocator] type ShmAllocatorClass struct { *shmAllocatorClass } @@ -1197,31 +1205,6 @@ func UnsafeShmAllocatorClassFromGlibBorrow(p unsafe.Pointer) *ShmAllocatorClass return &ShmAllocatorClass{&shmAllocatorClass{(*C.GstShmAllocatorClass)(p)}} } -// UnsafeShmAllocatorClassFromGlibNone is used to convert raw C.GstShmAllocatorClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeShmAllocatorClassFromGlibNone(p unsafe.Pointer) *ShmAllocatorClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeShmAllocatorClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.shmAllocatorClass, - func (intern *shmAllocatorClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeShmAllocatorClassFromGlibFull is used to convert raw C.GstShmAllocatorClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeShmAllocatorClassFromGlibFull(p unsafe.Pointer) *ShmAllocatorClass { - wrapped := UnsafeShmAllocatorClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.shmAllocatorClass, - func (intern *shmAllocatorClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeShmAllocatorClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [ShmAllocatorClass] is expected to work anymore. @@ -1234,11 +1217,12 @@ func UnsafeShmAllocatorClassToGlibNone(s *ShmAllocatorClass) unsafe.Pointer { return unsafe.Pointer(s.native) } -// UnsafeShmAllocatorClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeShmAllocatorClassToGlibFull(s *ShmAllocatorClass) unsafe.Pointer { - runtime.SetFinalizer(s.shmAllocatorClass, nil) - _p := unsafe.Pointer(s.native) - s.native = nil // ShmAllocatorClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (s *ShmAllocatorClass) ParentClass() *FdAllocatorClass { + parent := UnsafeFdAllocatorClassFromGlibBorrow(UnsafeShmAllocatorClassToGlibNone(s)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *ShmAllocatorClass) {}, s) + return parent } + diff --git a/pkg/gstapp/gstapp.gen.go b/pkg/gstapp/gstapp.gen.go index 278f0aa..5cf4d35 100644 --- a/pkg/gstapp/gstapp.gen.go +++ b/pkg/gstapp/gstapp.gen.go @@ -15,6 +15,62 @@ import ( // #cgo pkg-config: gstreamer-app-1.0 // #cgo CFLAGS: -Wno-deprecated-declarations // #include +// extern void _gotk4_gstapp1_AppSink_eos(GstAppSink*); +// extern GstFlowReturn _gotk4_gstapp1_AppSink_new_preroll(GstAppSink*); +// extern GstFlowReturn _gotk4_gstapp1_AppSink_new_sample(GstAppSink*); +// extern GstSample* _gotk4_gstapp1_AppSink_pull_preroll(GstAppSink*); +// extern GstSample* _gotk4_gstapp1_AppSink_pull_sample(GstAppSink*); +// extern GstSample* _gotk4_gstapp1_AppSink_try_pull_preroll(GstAppSink*, GstClockTime); +// extern GstSample* _gotk4_gstapp1_AppSink_try_pull_sample(GstAppSink*, GstClockTime); +// void _gotk4_gstapp1_AppSink_virtual_eos(void* fnptr, GstAppSink* carg0) { +// return ((void (*) (GstAppSink*))(fnptr))(carg0); +// } +// GstFlowReturn _gotk4_gstapp1_AppSink_virtual_new_preroll(void* fnptr, GstAppSink* carg0) { +// return ((GstFlowReturn (*) (GstAppSink*))(fnptr))(carg0); +// } +// GstFlowReturn _gotk4_gstapp1_AppSink_virtual_new_sample(void* fnptr, GstAppSink* carg0) { +// return ((GstFlowReturn (*) (GstAppSink*))(fnptr))(carg0); +// } +// GstSample* _gotk4_gstapp1_AppSink_virtual_pull_preroll(void* fnptr, GstAppSink* carg0) { +// return ((GstSample* (*) (GstAppSink*))(fnptr))(carg0); +// } +// GstSample* _gotk4_gstapp1_AppSink_virtual_pull_sample(void* fnptr, GstAppSink* carg0) { +// return ((GstSample* (*) (GstAppSink*))(fnptr))(carg0); +// } +// GstSample* _gotk4_gstapp1_AppSink_virtual_try_pull_preroll(void* fnptr, GstAppSink* carg0, GstClockTime carg1) { +// return ((GstSample* (*) (GstAppSink*, GstClockTime))(fnptr))(carg0, carg1); +// } +// GstSample* _gotk4_gstapp1_AppSink_virtual_try_pull_sample(void* fnptr, GstAppSink* carg0, GstClockTime carg1) { +// return ((GstSample* (*) (GstAppSink*, GstClockTime))(fnptr))(carg0, carg1); +// } +// extern GstFlowReturn _gotk4_gstapp1_AppSrc_end_of_stream(GstAppSrc*); +// extern void _gotk4_gstapp1_AppSrc_enough_data(GstAppSrc*); +// extern void _gotk4_gstapp1_AppSrc_need_data(GstAppSrc*, guint); +// extern GstFlowReturn _gotk4_gstapp1_AppSrc_push_buffer(GstAppSrc*, GstBuffer*); +// extern GstFlowReturn _gotk4_gstapp1_AppSrc_push_buffer_list(GstAppSrc*, GstBufferList*); +// extern GstFlowReturn _gotk4_gstapp1_AppSrc_push_sample(GstAppSrc*, GstSample*); +// extern gboolean _gotk4_gstapp1_AppSrc_seek_data(GstAppSrc*, guint64); +// GstFlowReturn _gotk4_gstapp1_AppSrc_virtual_end_of_stream(void* fnptr, GstAppSrc* carg0) { +// return ((GstFlowReturn (*) (GstAppSrc*))(fnptr))(carg0); +// } +// void _gotk4_gstapp1_AppSrc_virtual_enough_data(void* fnptr, GstAppSrc* carg0) { +// return ((void (*) (GstAppSrc*))(fnptr))(carg0); +// } +// void _gotk4_gstapp1_AppSrc_virtual_need_data(void* fnptr, GstAppSrc* carg0, guint carg1) { +// return ((void (*) (GstAppSrc*, guint))(fnptr))(carg0, carg1); +// } +// GstFlowReturn _gotk4_gstapp1_AppSrc_virtual_push_buffer(void* fnptr, GstAppSrc* carg0, GstBuffer* carg1) { +// return ((GstFlowReturn (*) (GstAppSrc*, GstBuffer*))(fnptr))(carg0, carg1); +// } +// GstFlowReturn _gotk4_gstapp1_AppSrc_virtual_push_buffer_list(void* fnptr, GstAppSrc* carg0, GstBufferList* carg1) { +// return ((GstFlowReturn (*) (GstAppSrc*, GstBufferList*))(fnptr))(carg0, carg1); +// } +// GstFlowReturn _gotk4_gstapp1_AppSrc_virtual_push_sample(void* fnptr, GstAppSrc* carg0, GstSample* carg1) { +// return ((GstFlowReturn (*) (GstAppSrc*, GstSample*))(fnptr))(carg0, carg1); +// } +// gboolean _gotk4_gstapp1_AppSrc_virtual_seek_data(void* fnptr, GstAppSrc* carg0, guint64 carg1) { +// return ((gboolean (*) (GstAppSrc*, guint64))(fnptr))(carg0, carg1); +// } import "C" // GType values. @@ -172,6 +228,7 @@ type AppSink interface { upcastToGstAppSink() *AppSinkInstance // GetBufferListSupport wraps gst_app_sink_get_buffer_list_support + // // The function returns the following values: // // - goret bool @@ -179,6 +236,7 @@ type AppSink interface { // Check if @appsink supports buffer lists. GetBufferListSupport() bool // GetCaps wraps gst_app_sink_get_caps + // // The function returns the following values: // // - goret *gst.Caps (nullable) @@ -186,6 +244,7 @@ type AppSink interface { // Get the configured caps on @appsink. GetCaps() *gst.Caps // GetDrop wraps gst_app_sink_get_drop + // // The function returns the following values: // // - goret bool @@ -194,6 +253,7 @@ type AppSink interface { // data is reached (meaning max buffers, time or bytes limit, whichever is hit first). GetDrop() bool // GetEmitSignals wraps gst_app_sink_get_emit_signals + // // The function returns the following values: // // - goret bool @@ -201,6 +261,7 @@ type AppSink interface { // Check if appsink will emit the "new-preroll" and "new-sample" signals. GetEmitSignals() bool // GetMaxBuffers wraps gst_app_sink_get_max_buffers + // // The function returns the following values: // // - goret uint @@ -208,6 +269,7 @@ type AppSink interface { // Get the maximum amount of buffers that can be queued in @appsink. GetMaxBuffers() uint // GetMaxBytes wraps gst_app_sink_get_max_bytes + // // The function returns the following values: // // - goret uint64 @@ -215,6 +277,7 @@ type AppSink interface { // Get the maximum total size, in bytes, that can be queued in @appsink. GetMaxBytes() uint64 // GetMaxTime wraps gst_app_sink_get_max_time + // // The function returns the following values: // // - goret gst.ClockTime @@ -222,6 +285,7 @@ type AppSink interface { // Get the maximum total duration that can be queued in @appsink. GetMaxTime() gst.ClockTime // GetWaitOnEos wraps gst_app_sink_get_wait_on_eos + // // The function returns the following values: // // - goret bool @@ -230,6 +294,7 @@ type AppSink interface { // received. GetWaitOnEos() bool // IsEos wraps gst_app_sink_is_eos + // // The function returns the following values: // // - goret bool @@ -241,6 +306,7 @@ type AppSink interface { // PLAYING state. IsEos() bool // PullPreroll wraps gst_app_sink_pull_preroll + // // The function returns the following values: // // - goret *gst.Sample (nullable) @@ -265,6 +331,7 @@ type AppSink interface { // element is set to the READY/NULL state. PullPreroll() *gst.Sample // PullSample wraps gst_app_sink_pull_sample + // // The function returns the following values: // // - goret *gst.Sample (nullable) @@ -627,6 +694,7 @@ func UnsafeAppSinkToGlibFull(c AppSink) unsafe.Pointer { } // GetBufferListSupport wraps gst_app_sink_get_buffer_list_support +// // The function returns the following values: // // - goret bool @@ -651,6 +719,7 @@ func (appsink *AppSinkInstance) GetBufferListSupport() bool { } // GetCaps wraps gst_app_sink_get_caps +// // The function returns the following values: // // - goret *gst.Caps (nullable) @@ -675,6 +744,7 @@ func (appsink *AppSinkInstance) GetCaps() *gst.Caps { } // GetDrop wraps gst_app_sink_get_drop +// // The function returns the following values: // // - goret bool @@ -700,6 +770,7 @@ func (appsink *AppSinkInstance) GetDrop() bool { } // GetEmitSignals wraps gst_app_sink_get_emit_signals +// // The function returns the following values: // // - goret bool @@ -724,6 +795,7 @@ func (appsink *AppSinkInstance) GetEmitSignals() bool { } // GetMaxBuffers wraps gst_app_sink_get_max_buffers +// // The function returns the following values: // // - goret uint @@ -746,6 +818,7 @@ func (appsink *AppSinkInstance) GetMaxBuffers() uint { } // GetMaxBytes wraps gst_app_sink_get_max_bytes +// // The function returns the following values: // // - goret uint64 @@ -768,6 +841,7 @@ func (appsink *AppSinkInstance) GetMaxBytes() uint64 { } // GetMaxTime wraps gst_app_sink_get_max_time +// // The function returns the following values: // // - goret gst.ClockTime @@ -790,6 +864,7 @@ func (appsink *AppSinkInstance) GetMaxTime() gst.ClockTime { } // GetWaitOnEos wraps gst_app_sink_get_wait_on_eos +// // The function returns the following values: // // - goret bool @@ -815,6 +890,7 @@ func (appsink *AppSinkInstance) GetWaitOnEos() bool { } // IsEos wraps gst_app_sink_is_eos +// // The function returns the following values: // // - goret bool @@ -843,6 +919,7 @@ func (appsink *AppSinkInstance) IsEos() bool { } // PullPreroll wraps gst_app_sink_pull_preroll +// // The function returns the following values: // // - goret *gst.Sample (nullable) @@ -884,6 +961,7 @@ func (appsink *AppSinkInstance) PullPreroll() *gst.Sample { } // PullSample wraps gst_app_sink_pull_sample +// // The function returns the following values: // // - goret *gst.Sample (nullable) @@ -1197,6 +1275,7 @@ func (appsink *AppSinkInstance) TryPullSample(timeout gst.ClockTime) *gst.Sample func (o *AppSinkInstance) ConnectEos(fn func(AppSink)) gobject.SignalHandle { return o.Connect("eos", fn) } + // ConnectNewPreroll connects the provided callback to the "new-preroll" signal // // Signal that a new preroll sample is available. @@ -1213,6 +1292,7 @@ func (o *AppSinkInstance) ConnectEos(fn func(AppSink)) gobject.SignalHandle { func (o *AppSinkInstance) ConnectNewPreroll(fn func(AppSink) gst.FlowReturn) gobject.SignalHandle { return o.Connect("new-preroll", fn) } + // ConnectNewSample connects the provided callback to the "new-sample" signal // // Signal that a new sample is available. @@ -1229,6 +1309,7 @@ func (o *AppSinkInstance) ConnectNewPreroll(fn func(AppSink) gst.FlowReturn) gob func (o *AppSinkInstance) ConnectNewSample(fn func(AppSink) gst.FlowReturn) gobject.SignalHandle { return o.Connect("new-sample", fn) } + // ConnectNewSerializedEvent connects the provided callback to the "new-serialized-event" signal // // Signal that a new downstream serialized event is available. @@ -1251,6 +1332,7 @@ func (o *AppSinkInstance) ConnectNewSample(fn func(AppSink) gst.FlowReturn) gobj func (o *AppSinkInstance) ConnectNewSerializedEvent(fn func(AppSink) bool) gobject.SignalHandle { return o.Connect("new-serialized-event", fn) } + // ConnectProposeAllocation connects the provided callback to the "propose-allocation" signal // // Signal that a new propose_allocation query is available. @@ -1260,6 +1342,7 @@ func (o *AppSinkInstance) ConnectNewSerializedEvent(fn func(AppSink) bool) gobje func (o *AppSinkInstance) ConnectProposeAllocation(fn func(AppSink, gst.Query) bool) gobject.SignalHandle { return o.Connect("propose-allocation", fn) } + // EmitPullPreroll emits the "pull-preroll" signal // // Get the last preroll sample in @appsink. This was the sample that caused the @@ -1283,6 +1366,7 @@ func (o *AppSinkInstance) ConnectProposeAllocation(fn func(AppSink, gst.Query) b func (o *AppSinkInstance) EmitPullPreroll() gst.Sample { return o.Emit("pull-preroll").(gst.Sample) } + // EmitPullSample emits the "pull-sample" signal // // This function blocks until a sample or EOS becomes available or the appsink @@ -1302,6 +1386,7 @@ func (o *AppSinkInstance) EmitPullPreroll() gst.Sample { func (o *AppSinkInstance) EmitPullSample() gst.Sample { return o.Emit("pull-sample").(gst.Sample) } + // EmitTryPullObject emits the "try-pull-object" signal // // This function blocks until a sample or an event becomes available or the appsink @@ -1329,6 +1414,7 @@ func (o *AppSinkInstance) EmitPullSample() gst.Sample { func (o *AppSinkInstance) EmitTryPullObject(arg0 uint64) gst.MiniObject { return o.Emit("try-pull-object", arg0).(gst.MiniObject) } + // EmitTryPullPreroll emits the "try-pull-preroll" signal // // Get the last preroll sample in @appsink. This was the sample that caused the @@ -1353,6 +1439,7 @@ func (o *AppSinkInstance) EmitTryPullObject(arg0 uint64) gst.MiniObject { func (o *AppSinkInstance) EmitTryPullPreroll(arg0 uint64) gst.Sample { return o.Emit("try-pull-preroll", arg0).(gst.Sample) } + // EmitTryPullSample emits the "try-pull-sample" signal // // This function blocks until a sample or EOS becomes available or the appsink @@ -1373,6 +1460,91 @@ func (o *AppSinkInstance) EmitTryPullPreroll(arg0 uint64) gst.Sample { func (o *AppSinkInstance) EmitTryPullSample(arg0 uint64) gst.Sample { return o.Emit("try-pull-sample", arg0).(gst.Sample) } + +// AppSinkOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type AppSinkOverrides[Instance AppSink] struct { + // gstbase.BaseSinkOverrides allows you to override virtual methods from the parent class gstbase.BaseSink + gstbase.BaseSinkOverrides[Instance] + + // Eos allows you to override the implementation of the virtual method eos. + Eos func(Instance) + // NewPreroll allows you to override the implementation of the virtual method new_preroll. + // The function returns the following values: + // + // - goret gst.FlowReturn + NewPreroll func(Instance) gst.FlowReturn + // NewSample allows you to override the implementation of the virtual method new_sample. + // The function returns the following values: + // + // - goret gst.FlowReturn + NewSample func(Instance) gst.FlowReturn + // PullPreroll allows you to override the implementation of the virtual method pull_preroll. + // The function returns the following values: + // + // - goret *gst.Sample (nullable) + PullPreroll func(Instance) *gst.Sample + // PullSample allows you to override the implementation of the virtual method pull_sample. + // The function returns the following values: + // + // - goret *gst.Sample (nullable) + PullSample func(Instance) *gst.Sample + // TryPullPreroll allows you to override the implementation of the virtual method try_pull_preroll. + // The function takes the following parameters: + // + // - timeout gst.ClockTime: the maximum amount of time to wait for the preroll sample + // + // The function returns the following values: + // + // - goret *gst.Sample (nullable) + TryPullPreroll func(Instance, gst.ClockTime) *gst.Sample + // TryPullSample allows you to override the implementation of the virtual method try_pull_sample. + // The function takes the following parameters: + // + // - timeout gst.ClockTime: the maximum amount of time to wait for a sample + // + // The function returns the following values: + // + // - goret *gst.Sample (nullable) + TryPullSample func(Instance, gst.ClockTime) *gst.Sample +} + +// UnsafeApplyAppSinkOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyAppSinkOverrides[Instance AppSink](gclass unsafe.Pointer, overrides AppSinkOverrides[Instance]) { + gstbase.UnsafeApplyBaseSinkOverrides(gclass, overrides.BaseSinkOverrides) + + pclass := (*C.GstAppSinkClass)(gclass) + + if overrides.Eos != nil { + pclass.eos = (*[0]byte)(C._gotk4_gstapp1_AppSink_eos) + } + + if overrides.NewPreroll != nil { + pclass.new_preroll = (*[0]byte)(C._gotk4_gstapp1_AppSink_new_preroll) + } + + if overrides.NewSample != nil { + pclass.new_sample = (*[0]byte)(C._gotk4_gstapp1_AppSink_new_sample) + } + + if overrides.PullPreroll != nil { + pclass.pull_preroll = (*[0]byte)(C._gotk4_gstapp1_AppSink_pull_preroll) + } + + if overrides.PullSample != nil { + pclass.pull_sample = (*[0]byte)(C._gotk4_gstapp1_AppSink_pull_sample) + } + + if overrides.TryPullPreroll != nil { + pclass.try_pull_preroll = (*[0]byte)(C._gotk4_gstapp1_AppSink_try_pull_preroll) + } + + if overrides.TryPullSample != nil { + pclass.try_pull_sample = (*[0]byte)(C._gotk4_gstapp1_AppSink_try_pull_sample) + } +} + // AppSrcInstance is the instance type used by all types extending GstAppSrc. It is used internally by the bindings. Users should use the interface [AppSrc] instead. type AppSrcInstance struct { _ [0]func() // equal guard @@ -1456,6 +1628,7 @@ type AppSrc interface { upcastToGstAppSrc() *AppSrcInstance // EndOfStream wraps gst_app_src_end_of_stream + // // The function returns the following values: // // - goret gst.FlowReturn @@ -1464,6 +1637,7 @@ type AppSrc interface { // element is the last buffer of the stream. EndOfStream() gst.FlowReturn // GetCaps wraps gst_app_src_get_caps + // // The function returns the following values: // // - goret *gst.Caps (nullable) @@ -1471,6 +1645,7 @@ type AppSrc interface { // Get the configured caps on @appsrc. GetCaps() *gst.Caps // GetCurrentLevelBuffers wraps gst_app_src_get_current_level_buffers + // // The function returns the following values: // // - goret uint64 @@ -1478,6 +1653,7 @@ type AppSrc interface { // Get the number of currently queued buffers inside @appsrc. GetCurrentLevelBuffers() uint64 // GetCurrentLevelBytes wraps gst_app_src_get_current_level_bytes + // // The function returns the following values: // // - goret uint64 @@ -1485,6 +1661,7 @@ type AppSrc interface { // Get the number of currently queued bytes inside @appsrc. GetCurrentLevelBytes() uint64 // GetCurrentLevelTime wraps gst_app_src_get_current_level_time + // // The function returns the following values: // // - goret gst.ClockTime @@ -1492,6 +1669,7 @@ type AppSrc interface { // Get the amount of currently queued time inside @appsrc. GetCurrentLevelTime() gst.ClockTime // GetDuration wraps gst_app_src_get_duration + // // The function returns the following values: // // - goret gst.ClockTime @@ -1500,6 +1678,7 @@ type AppSrc interface { // not known. GetDuration() gst.ClockTime // GetEmitSignals wraps gst_app_src_get_emit_signals + // // The function returns the following values: // // - goret bool @@ -1507,6 +1686,7 @@ type AppSrc interface { // Check if appsrc will emit the "new-preroll" and "new-buffer" signals. GetEmitSignals() bool // GetLatency wraps gst_app_src_get_latency + // // The function returns the following values: // // - min uint64: the min latency @@ -1515,6 +1695,7 @@ type AppSrc interface { // Retrieve the min and max latencies in @min and @max respectively. GetLatency() (uint64, uint64) // GetLeakyType wraps gst_app_src_get_leaky_type + // // The function returns the following values: // // - goret AppLeakyType @@ -1523,6 +1704,7 @@ type AppSrc interface { // for more details. GetLeakyType() AppLeakyType // GetMaxBuffers wraps gst_app_src_get_max_buffers + // // The function returns the following values: // // - goret uint64 @@ -1530,6 +1712,7 @@ type AppSrc interface { // Get the maximum amount of buffers that can be queued in @appsrc. GetMaxBuffers() uint64 // GetMaxBytes wraps gst_app_src_get_max_bytes + // // The function returns the following values: // // - goret uint64 @@ -1537,6 +1720,7 @@ type AppSrc interface { // Get the maximum amount of bytes that can be queued in @appsrc. GetMaxBytes() uint64 // GetMaxTime wraps gst_app_src_get_max_time + // // The function returns the following values: // // - goret gst.ClockTime @@ -1544,6 +1728,7 @@ type AppSrc interface { // Get the maximum amount of time that can be queued in @appsrc. GetMaxTime() gst.ClockTime // GetSize wraps gst_app_src_get_size + // // The function returns the following values: // // - goret int64 @@ -1552,6 +1737,7 @@ type AppSrc interface { // not known. GetSize() int64 // GetStreamType wraps gst_app_src_get_stream_type + // // The function returns the following values: // // - goret AppStreamType @@ -1830,6 +2016,7 @@ func UnsafeAppSrcToGlibFull(c AppSrc) unsafe.Pointer { } // EndOfStream wraps gst_app_src_end_of_stream +// // The function returns the following values: // // - goret gst.FlowReturn @@ -1853,6 +2040,7 @@ func (appsrc *AppSrcInstance) EndOfStream() gst.FlowReturn { } // GetCaps wraps gst_app_src_get_caps +// // The function returns the following values: // // - goret *gst.Caps (nullable) @@ -1877,6 +2065,7 @@ func (appsrc *AppSrcInstance) GetCaps() *gst.Caps { } // GetCurrentLevelBuffers wraps gst_app_src_get_current_level_buffers +// // The function returns the following values: // // - goret uint64 @@ -1899,6 +2088,7 @@ func (appsrc *AppSrcInstance) GetCurrentLevelBuffers() uint64 { } // GetCurrentLevelBytes wraps gst_app_src_get_current_level_bytes +// // The function returns the following values: // // - goret uint64 @@ -1921,6 +2111,7 @@ func (appsrc *AppSrcInstance) GetCurrentLevelBytes() uint64 { } // GetCurrentLevelTime wraps gst_app_src_get_current_level_time +// // The function returns the following values: // // - goret gst.ClockTime @@ -1943,6 +2134,7 @@ func (appsrc *AppSrcInstance) GetCurrentLevelTime() gst.ClockTime { } // GetDuration wraps gst_app_src_get_duration +// // The function returns the following values: // // - goret gst.ClockTime @@ -1966,6 +2158,7 @@ func (appsrc *AppSrcInstance) GetDuration() gst.ClockTime { } // GetEmitSignals wraps gst_app_src_get_emit_signals +// // The function returns the following values: // // - goret bool @@ -1990,6 +2183,7 @@ func (appsrc *AppSrcInstance) GetEmitSignals() bool { } // GetLatency wraps gst_app_src_get_latency +// // The function returns the following values: // // - min uint64: the min latency @@ -2016,6 +2210,7 @@ func (appsrc *AppSrcInstance) GetLatency() (uint64, uint64) { } // GetLeakyType wraps gst_app_src_get_leaky_type +// // The function returns the following values: // // - goret AppLeakyType @@ -2039,6 +2234,7 @@ func (appsrc *AppSrcInstance) GetLeakyType() AppLeakyType { } // GetMaxBuffers wraps gst_app_src_get_max_buffers +// // The function returns the following values: // // - goret uint64 @@ -2061,6 +2257,7 @@ func (appsrc *AppSrcInstance) GetMaxBuffers() uint64 { } // GetMaxBytes wraps gst_app_src_get_max_bytes +// // The function returns the following values: // // - goret uint64 @@ -2083,6 +2280,7 @@ func (appsrc *AppSrcInstance) GetMaxBytes() uint64 { } // GetMaxTime wraps gst_app_src_get_max_time +// // The function returns the following values: // // - goret gst.ClockTime @@ -2105,6 +2303,7 @@ func (appsrc *AppSrcInstance) GetMaxTime() gst.ClockTime { } // GetSize wraps gst_app_src_get_size +// // The function returns the following values: // // - goret int64 @@ -2128,6 +2327,7 @@ func (appsrc *AppSrcInstance) GetSize() int64 { } // GetStreamType wraps gst_app_src_get_stream_type +// // The function returns the following values: // // - goret AppStreamType @@ -2483,6 +2683,7 @@ func (appsrc *AppSrcInstance) SetStreamType(typ AppStreamType) { func (o *AppSrcInstance) EmitEndOfStream() gst.FlowReturn { return o.Emit("end-of-stream").(gst.FlowReturn) } + // ConnectEnoughData connects the provided callback to the "enough-data" signal // // Signal that the source has enough data. It is recommended that the @@ -2491,6 +2692,7 @@ func (o *AppSrcInstance) EmitEndOfStream() gst.FlowReturn { func (o *AppSrcInstance) ConnectEnoughData(fn func(AppSrc)) gobject.SignalHandle { return o.Connect("enough-data", fn) } + // ConnectNeedData connects the provided callback to the "need-data" signal // // Signal that the source needs more data. In the callback or from another @@ -2504,6 +2706,7 @@ func (o *AppSrcInstance) ConnectEnoughData(fn func(AppSrc)) gobject.SignalHandle func (o *AppSrcInstance) ConnectNeedData(fn func(AppSrc, uint)) gobject.SignalHandle { return o.Connect("need-data", fn) } + // EmitPushBuffer emits the "push-buffer" signal // // Adds a buffer to the queue of buffers that the appsrc element will @@ -2518,6 +2721,7 @@ func (o *AppSrcInstance) ConnectNeedData(fn func(AppSrc, uint)) gobject.SignalHa func (o *AppSrcInstance) EmitPushBuffer(arg0 gst.Buffer) gst.FlowReturn { return o.Emit("push-buffer", arg0).(gst.FlowReturn) } + // EmitPushBufferList emits the "push-buffer-list" signal // // Adds a buffer list to the queue of buffers and buffer lists that the @@ -2532,6 +2736,7 @@ func (o *AppSrcInstance) EmitPushBuffer(arg0 gst.Buffer) gst.FlowReturn { func (o *AppSrcInstance) EmitPushBufferList(arg0 gst.BufferList) gst.FlowReturn { return o.Emit("push-buffer-list", arg0).(gst.FlowReturn) } + // EmitPushSample emits the "push-sample" signal // // Extract a buffer from the provided sample and adds the extracted buffer @@ -2550,6 +2755,7 @@ func (o *AppSrcInstance) EmitPushBufferList(arg0 gst.BufferList) gst.FlowReturn func (o *AppSrcInstance) EmitPushSample(arg0 gst.Sample) gst.FlowReturn { return o.Emit("push-sample", arg0).(gst.FlowReturn) } + // ConnectSeekData connects the provided callback to the "seek-data" signal // // Seek to the given offset. The next push-buffer should produce buffers from @@ -2558,7 +2764,103 @@ func (o *AppSrcInstance) EmitPushSample(arg0 gst.Sample) gst.FlowReturn { func (o *AppSrcInstance) ConnectSeekData(fn func(AppSrc, uint64) bool) gobject.SignalHandle { return o.Connect("seek-data", fn) } + +// AppSrcOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type AppSrcOverrides[Instance AppSrc] struct { + // gstbase.BaseSrcOverrides allows you to override virtual methods from the parent class gstbase.BaseSrc + gstbase.BaseSrcOverrides[Instance] + + // EndOfStream allows you to override the implementation of the virtual method end_of_stream. + // The function returns the following values: + // + // - goret gst.FlowReturn + EndOfStream func(Instance) gst.FlowReturn + // EnoughData allows you to override the implementation of the virtual method enough_data. + EnoughData func(Instance) + // NeedData allows you to override the implementation of the virtual method need_data. + // The function takes the following parameters: + // + // - length uint + NeedData func(Instance, uint) + // PushBuffer allows you to override the implementation of the virtual method push_buffer. + // The function takes the following parameters: + // + // - buffer *gst.Buffer: a #GstBuffer to push + // + // The function returns the following values: + // + // - goret gst.FlowReturn + PushBuffer func(Instance, *gst.Buffer) gst.FlowReturn + // PushBufferList allows you to override the implementation of the virtual method push_buffer_list. + // The function takes the following parameters: + // + // - bufferList *gst.BufferList: a #GstBufferList to push + // + // The function returns the following values: + // + // - goret gst.FlowReturn + PushBufferList func(Instance, *gst.BufferList) gst.FlowReturn + // PushSample allows you to override the implementation of the virtual method push_sample. + // The function takes the following parameters: + // + // - sample *gst.Sample: a #GstSample from which buffer and caps may be + // extracted + // + // The function returns the following values: + // + // - goret gst.FlowReturn + PushSample func(Instance, *gst.Sample) gst.FlowReturn + // SeekData allows you to override the implementation of the virtual method seek_data. + // The function takes the following parameters: + // + // - offset uint64 + // + // The function returns the following values: + // + // - goret bool + SeekData func(Instance, uint64) bool +} + +// UnsafeApplyAppSrcOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyAppSrcOverrides[Instance AppSrc](gclass unsafe.Pointer, overrides AppSrcOverrides[Instance]) { + gstbase.UnsafeApplyBaseSrcOverrides(gclass, overrides.BaseSrcOverrides) + + pclass := (*C.GstAppSrcClass)(gclass) + + if overrides.EndOfStream != nil { + pclass.end_of_stream = (*[0]byte)(C._gotk4_gstapp1_AppSrc_end_of_stream) + } + + if overrides.EnoughData != nil { + pclass.enough_data = (*[0]byte)(C._gotk4_gstapp1_AppSrc_enough_data) + } + + if overrides.NeedData != nil { + pclass.need_data = (*[0]byte)(C._gotk4_gstapp1_AppSrc_need_data) + } + + if overrides.PushBuffer != nil { + pclass.push_buffer = (*[0]byte)(C._gotk4_gstapp1_AppSrc_push_buffer) + } + + if overrides.PushBufferList != nil { + pclass.push_buffer_list = (*[0]byte)(C._gotk4_gstapp1_AppSrc_push_buffer_list) + } + + if overrides.PushSample != nil { + pclass.push_sample = (*[0]byte)(C._gotk4_gstapp1_AppSrc_push_sample) + } + + if overrides.SeekData != nil { + pclass.seek_data = (*[0]byte)(C._gotk4_gstapp1_AppSrc_seek_data) + } +} + // AppSinkClass wraps GstAppSinkClass +// +// AppSinkClass is the type struct for [AppSink] type AppSinkClass struct { *appSinkClass } @@ -2573,31 +2875,6 @@ func UnsafeAppSinkClassFromGlibBorrow(p unsafe.Pointer) *AppSinkClass { return &AppSinkClass{&appSinkClass{(*C.GstAppSinkClass)(p)}} } -// UnsafeAppSinkClassFromGlibNone is used to convert raw C.GstAppSinkClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeAppSinkClassFromGlibNone(p unsafe.Pointer) *AppSinkClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeAppSinkClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.appSinkClass, - func (intern *appSinkClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeAppSinkClassFromGlibFull is used to convert raw C.GstAppSinkClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeAppSinkClassFromGlibFull(p unsafe.Pointer) *AppSinkClass { - wrapped := UnsafeAppSinkClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.appSinkClass, - func (intern *appSinkClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeAppSinkClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [AppSinkClass] is expected to work anymore. @@ -2610,15 +2887,18 @@ func UnsafeAppSinkClassToGlibNone(a *AppSinkClass) unsafe.Pointer { return unsafe.Pointer(a.native) } -// UnsafeAppSinkClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeAppSinkClassToGlibFull(a *AppSinkClass) unsafe.Pointer { - runtime.SetFinalizer(a.appSinkClass, nil) - _p := unsafe.Pointer(a.native) - a.native = nil // AppSinkClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (a *AppSinkClass) ParentClass() *gstbase.BaseSinkClass { + parent := gstbase.UnsafeBaseSinkClassFromGlibBorrow(UnsafeAppSinkClassToGlibNone(a)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *AppSinkClass) {}, a) + return parent } + // AppSrcClass wraps GstAppSrcClass +// +// AppSrcClass is the type struct for [AppSrc] type AppSrcClass struct { *appSrcClass } @@ -2633,31 +2913,6 @@ func UnsafeAppSrcClassFromGlibBorrow(p unsafe.Pointer) *AppSrcClass { return &AppSrcClass{&appSrcClass{(*C.GstAppSrcClass)(p)}} } -// UnsafeAppSrcClassFromGlibNone is used to convert raw C.GstAppSrcClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeAppSrcClassFromGlibNone(p unsafe.Pointer) *AppSrcClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeAppSrcClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.appSrcClass, - func (intern *appSrcClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeAppSrcClassFromGlibFull is used to convert raw C.GstAppSrcClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeAppSrcClassFromGlibFull(p unsafe.Pointer) *AppSrcClass { - wrapped := UnsafeAppSrcClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.appSrcClass, - func (intern *appSrcClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeAppSrcClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [AppSrcClass] is expected to work anymore. @@ -2670,11 +2925,12 @@ func UnsafeAppSrcClassToGlibNone(a *AppSrcClass) unsafe.Pointer { return unsafe.Pointer(a.native) } -// UnsafeAppSrcClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeAppSrcClassToGlibFull(a *AppSrcClass) unsafe.Pointer { - runtime.SetFinalizer(a.appSrcClass, nil) - _p := unsafe.Pointer(a.native) - a.native = nil // AppSrcClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (a *AppSrcClass) ParentClass() *gstbase.BaseSrcClass { + parent := gstbase.UnsafeBaseSrcClassFromGlibBorrow(UnsafeAppSrcClassToGlibNone(a)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *AppSrcClass) {}, a) + return parent } + diff --git a/pkg/gstapp/gstapp_export.gen.go b/pkg/gstapp/gstapp_export.gen.go new file mode 100644 index 0000000..40bf8de --- /dev/null +++ b/pkg/gstapp/gstapp_export.gen.go @@ -0,0 +1,78 @@ +// Code generated by girgen for GstApp-1. DO NOT EDIT. + +package gstapp + + +// #include +import "C" + +//export _gotk4_gstapp1_AppSink_eos +func _gotk4_gstapp1_AppSink_eos(carg0 *C.GstAppSink) { + panic("unimplemented") +} + +//export _gotk4_gstapp1_AppSink_new_preroll +func _gotk4_gstapp1_AppSink_new_preroll(carg0 *C.GstAppSink) (cret C.GstFlowReturn) { + panic("unimplemented") +} + +//export _gotk4_gstapp1_AppSink_new_sample +func _gotk4_gstapp1_AppSink_new_sample(carg0 *C.GstAppSink) (cret C.GstFlowReturn) { + panic("unimplemented") +} + +//export _gotk4_gstapp1_AppSink_pull_preroll +func _gotk4_gstapp1_AppSink_pull_preroll(carg0 *C.GstAppSink) (cret *C.GstSample) { + panic("unimplemented") +} + +//export _gotk4_gstapp1_AppSink_pull_sample +func _gotk4_gstapp1_AppSink_pull_sample(carg0 *C.GstAppSink) (cret *C.GstSample) { + panic("unimplemented") +} + +//export _gotk4_gstapp1_AppSink_try_pull_preroll +func _gotk4_gstapp1_AppSink_try_pull_preroll(carg0 *C.GstAppSink, carg1 C.GstClockTime) (cret *C.GstSample) { + panic("unimplemented") +} + +//export _gotk4_gstapp1_AppSink_try_pull_sample +func _gotk4_gstapp1_AppSink_try_pull_sample(carg0 *C.GstAppSink, carg1 C.GstClockTime) (cret *C.GstSample) { + panic("unimplemented") +} + +//export _gotk4_gstapp1_AppSrc_end_of_stream +func _gotk4_gstapp1_AppSrc_end_of_stream(carg0 *C.GstAppSrc) (cret C.GstFlowReturn) { + panic("unimplemented") +} + +//export _gotk4_gstapp1_AppSrc_enough_data +func _gotk4_gstapp1_AppSrc_enough_data(carg0 *C.GstAppSrc) { + panic("unimplemented") +} + +//export _gotk4_gstapp1_AppSrc_need_data +func _gotk4_gstapp1_AppSrc_need_data(carg0 *C.GstAppSrc, carg1 C.guint) { + panic("unimplemented") +} + +//export _gotk4_gstapp1_AppSrc_push_buffer +func _gotk4_gstapp1_AppSrc_push_buffer(carg0 *C.GstAppSrc, carg1 *C.GstBuffer) (cret C.GstFlowReturn) { + panic("unimplemented") +} + +//export _gotk4_gstapp1_AppSrc_push_buffer_list +func _gotk4_gstapp1_AppSrc_push_buffer_list(carg0 *C.GstAppSrc, carg1 *C.GstBufferList) (cret C.GstFlowReturn) { + panic("unimplemented") +} + +//export _gotk4_gstapp1_AppSrc_push_sample +func _gotk4_gstapp1_AppSrc_push_sample(carg0 *C.GstAppSrc, carg1 *C.GstSample) (cret C.GstFlowReturn) { + panic("unimplemented") +} + +//export _gotk4_gstapp1_AppSrc_seek_data +func _gotk4_gstapp1_AppSrc_seek_data(carg0 *C.GstAppSrc, carg1 C.guint64) (cret C.gboolean) { + panic("unimplemented") +} + diff --git a/pkg/gstaudio/gstaudio.gen.go b/pkg/gstaudio/gstaudio.gen.go index 218de72..dbd2c7e 100644 --- a/pkg/gstaudio/gstaudio.gen.go +++ b/pkg/gstaudio/gstaudio.gen.go @@ -21,6 +21,286 @@ import ( // extern void _gotk4_gstaudio1_AudioBaseSinkCustomSlavingCallback(GstAudioBaseSink*, GstClockTime, GstClockTime, GstClockTimeDiff*, GstAudioBaseSinkDiscontReason, gpointer); // extern void _gotk4_gstaudio1_AudioRingBufferCallback(GstAudioRingBuffer*, guint8*, guint, gpointer); // extern void destroyUserdata(gpointer); +// extern gboolean _gotk4_gstaudio1_AudioAggregator_aggregate_one_buffer(GstAudioAggregator*, GstAudioAggregatorPad*, GstBuffer*, guint, GstBuffer*, guint, guint); +// extern GstBuffer* _gotk4_gstaudio1_AudioAggregator_create_output_buffer(GstAudioAggregator*, guint); +// gboolean _gotk4_gstaudio1_AudioAggregator_virtual_aggregate_one_buffer(void* fnptr, GstAudioAggregator* carg0, GstAudioAggregatorPad* carg1, GstBuffer* carg2, guint carg3, GstBuffer* carg4, guint carg5, guint carg6) { +// return ((gboolean (*) (GstAudioAggregator*, GstAudioAggregatorPad*, GstBuffer*, guint, GstBuffer*, guint, guint))(fnptr))(carg0, carg1, carg2, carg3, carg4, carg5, carg6); +// } +// GstBuffer* _gotk4_gstaudio1_AudioAggregator_virtual_create_output_buffer(void* fnptr, GstAudioAggregator* carg0, guint carg1) { +// return ((GstBuffer* (*) (GstAudioAggregator*, guint))(fnptr))(carg0, carg1); +// } +// extern GstBuffer* _gotk4_gstaudio1_AudioAggregatorPad_convert_buffer(GstAudioAggregatorPad*, GstAudioInfo*, GstAudioInfo*, GstBuffer*); +// extern void _gotk4_gstaudio1_AudioAggregatorPad_update_conversion_info(GstAudioAggregatorPad*); +// GstBuffer* _gotk4_gstaudio1_AudioAggregatorPad_virtual_convert_buffer(void* fnptr, GstAudioAggregatorPad* carg0, GstAudioInfo* carg1, GstAudioInfo* carg2, GstBuffer* carg3) { +// return ((GstBuffer* (*) (GstAudioAggregatorPad*, GstAudioInfo*, GstAudioInfo*, GstBuffer*))(fnptr))(carg0, carg1, carg2, carg3); +// } +// void _gotk4_gstaudio1_AudioAggregatorPad_virtual_update_conversion_info(void* fnptr, GstAudioAggregatorPad* carg0) { +// return ((void (*) (GstAudioAggregatorPad*))(fnptr))(carg0); +// } +// extern GstAudioRingBuffer* _gotk4_gstaudio1_AudioBaseSink_create_ringbuffer(GstAudioBaseSink*); +// extern GstBuffer* _gotk4_gstaudio1_AudioBaseSink_payload(GstAudioBaseSink*, GstBuffer*); +// GstAudioRingBuffer* _gotk4_gstaudio1_AudioBaseSink_virtual_create_ringbuffer(void* fnptr, GstAudioBaseSink* carg0) { +// return ((GstAudioRingBuffer* (*) (GstAudioBaseSink*))(fnptr))(carg0); +// } +// GstBuffer* _gotk4_gstaudio1_AudioBaseSink_virtual_payload(void* fnptr, GstAudioBaseSink* carg0, GstBuffer* carg1) { +// return ((GstBuffer* (*) (GstAudioBaseSink*, GstBuffer*))(fnptr))(carg0, carg1); +// } +// extern GstAudioRingBuffer* _gotk4_gstaudio1_AudioBaseSrc_create_ringbuffer(GstAudioBaseSrc*); +// GstAudioRingBuffer* _gotk4_gstaudio1_AudioBaseSrc_virtual_create_ringbuffer(void* fnptr, GstAudioBaseSrc* carg0) { +// return ((GstAudioRingBuffer* (*) (GstAudioBaseSrc*))(fnptr))(carg0); +// } +// extern void _gotk4_gstaudio1_AudioCdSrc_close(GstAudioCdSrc*); +// extern gboolean _gotk4_gstaudio1_AudioCdSrc_open(GstAudioCdSrc*, gchar*); +// extern GstBuffer* _gotk4_gstaudio1_AudioCdSrc_read_sector(GstAudioCdSrc*, gint); +// void _gotk4_gstaudio1_AudioCdSrc_virtual_close(void* fnptr, GstAudioCdSrc* carg0) { +// return ((void (*) (GstAudioCdSrc*))(fnptr))(carg0); +// } +// gboolean _gotk4_gstaudio1_AudioCdSrc_virtual_open(void* fnptr, GstAudioCdSrc* carg0, gchar* carg1) { +// return ((gboolean (*) (GstAudioCdSrc*, gchar*))(fnptr))(carg0, carg1); +// } +// GstBuffer* _gotk4_gstaudio1_AudioCdSrc_virtual_read_sector(void* fnptr, GstAudioCdSrc* carg0, gint carg1) { +// return ((GstBuffer* (*) (GstAudioCdSrc*, gint))(fnptr))(carg0, carg1); +// } +// extern gboolean _gotk4_gstaudio1_AudioDecoder_close(GstAudioDecoder*); +// extern gboolean _gotk4_gstaudio1_AudioDecoder_decide_allocation(GstAudioDecoder*, GstQuery*); +// extern void _gotk4_gstaudio1_AudioDecoder_flush(GstAudioDecoder*, gboolean); +// extern GstCaps* _gotk4_gstaudio1_AudioDecoder_getcaps(GstAudioDecoder*, GstCaps*); +// extern GstFlowReturn _gotk4_gstaudio1_AudioDecoder_handle_frame(GstAudioDecoder*, GstBuffer*); +// extern gboolean _gotk4_gstaudio1_AudioDecoder_negotiate(GstAudioDecoder*); +// extern gboolean _gotk4_gstaudio1_AudioDecoder_open(GstAudioDecoder*); +// extern GstFlowReturn _gotk4_gstaudio1_AudioDecoder_parse(GstAudioDecoder*, GstAdapter*, gint, gint); +// extern gboolean _gotk4_gstaudio1_AudioDecoder_propose_allocation(GstAudioDecoder*, GstQuery*); +// extern gboolean _gotk4_gstaudio1_AudioDecoder_set_format(GstAudioDecoder*, GstCaps*); +// extern gboolean _gotk4_gstaudio1_AudioDecoder_sink_event(GstAudioDecoder*, GstEvent*); +// extern gboolean _gotk4_gstaudio1_AudioDecoder_sink_query(GstAudioDecoder*, GstQuery*); +// extern gboolean _gotk4_gstaudio1_AudioDecoder_src_event(GstAudioDecoder*, GstEvent*); +// extern gboolean _gotk4_gstaudio1_AudioDecoder_src_query(GstAudioDecoder*, GstQuery*); +// extern gboolean _gotk4_gstaudio1_AudioDecoder_start(GstAudioDecoder*); +// extern gboolean _gotk4_gstaudio1_AudioDecoder_stop(GstAudioDecoder*); +// extern gboolean _gotk4_gstaudio1_AudioDecoder_transform_meta(GstAudioDecoder*, GstBuffer*, GstMeta*, GstBuffer*); +// gboolean _gotk4_gstaudio1_AudioDecoder_virtual_close(void* fnptr, GstAudioDecoder* carg0) { +// return ((gboolean (*) (GstAudioDecoder*))(fnptr))(carg0); +// } +// gboolean _gotk4_gstaudio1_AudioDecoder_virtual_decide_allocation(void* fnptr, GstAudioDecoder* carg0, GstQuery* carg1) { +// return ((gboolean (*) (GstAudioDecoder*, GstQuery*))(fnptr))(carg0, carg1); +// } +// void _gotk4_gstaudio1_AudioDecoder_virtual_flush(void* fnptr, GstAudioDecoder* carg0, gboolean carg1) { +// return ((void (*) (GstAudioDecoder*, gboolean))(fnptr))(carg0, carg1); +// } +// GstCaps* _gotk4_gstaudio1_AudioDecoder_virtual_getcaps(void* fnptr, GstAudioDecoder* carg0, GstCaps* carg1) { +// return ((GstCaps* (*) (GstAudioDecoder*, GstCaps*))(fnptr))(carg0, carg1); +// } +// GstFlowReturn _gotk4_gstaudio1_AudioDecoder_virtual_handle_frame(void* fnptr, GstAudioDecoder* carg0, GstBuffer* carg1) { +// return ((GstFlowReturn (*) (GstAudioDecoder*, GstBuffer*))(fnptr))(carg0, carg1); +// } +// gboolean _gotk4_gstaudio1_AudioDecoder_virtual_negotiate(void* fnptr, GstAudioDecoder* carg0) { +// return ((gboolean (*) (GstAudioDecoder*))(fnptr))(carg0); +// } +// gboolean _gotk4_gstaudio1_AudioDecoder_virtual_open(void* fnptr, GstAudioDecoder* carg0) { +// return ((gboolean (*) (GstAudioDecoder*))(fnptr))(carg0); +// } +// GstFlowReturn _gotk4_gstaudio1_AudioDecoder_virtual_parse(void* fnptr, GstAudioDecoder* carg0, GstAdapter* carg1, gint* carg2, gint* carg3) { +// return ((GstFlowReturn (*) (GstAudioDecoder*, GstAdapter*, gint*, gint*))(fnptr))(carg0, carg1, carg2, carg3); +// } +// gboolean _gotk4_gstaudio1_AudioDecoder_virtual_propose_allocation(void* fnptr, GstAudioDecoder* carg0, GstQuery* carg1) { +// return ((gboolean (*) (GstAudioDecoder*, GstQuery*))(fnptr))(carg0, carg1); +// } +// gboolean _gotk4_gstaudio1_AudioDecoder_virtual_set_format(void* fnptr, GstAudioDecoder* carg0, GstCaps* carg1) { +// return ((gboolean (*) (GstAudioDecoder*, GstCaps*))(fnptr))(carg0, carg1); +// } +// gboolean _gotk4_gstaudio1_AudioDecoder_virtual_sink_event(void* fnptr, GstAudioDecoder* carg0, GstEvent* carg1) { +// return ((gboolean (*) (GstAudioDecoder*, GstEvent*))(fnptr))(carg0, carg1); +// } +// gboolean _gotk4_gstaudio1_AudioDecoder_virtual_sink_query(void* fnptr, GstAudioDecoder* carg0, GstQuery* carg1) { +// return ((gboolean (*) (GstAudioDecoder*, GstQuery*))(fnptr))(carg0, carg1); +// } +// gboolean _gotk4_gstaudio1_AudioDecoder_virtual_src_event(void* fnptr, GstAudioDecoder* carg0, GstEvent* carg1) { +// return ((gboolean (*) (GstAudioDecoder*, GstEvent*))(fnptr))(carg0, carg1); +// } +// gboolean _gotk4_gstaudio1_AudioDecoder_virtual_src_query(void* fnptr, GstAudioDecoder* carg0, GstQuery* carg1) { +// return ((gboolean (*) (GstAudioDecoder*, GstQuery*))(fnptr))(carg0, carg1); +// } +// gboolean _gotk4_gstaudio1_AudioDecoder_virtual_start(void* fnptr, GstAudioDecoder* carg0) { +// return ((gboolean (*) (GstAudioDecoder*))(fnptr))(carg0); +// } +// gboolean _gotk4_gstaudio1_AudioDecoder_virtual_stop(void* fnptr, GstAudioDecoder* carg0) { +// return ((gboolean (*) (GstAudioDecoder*))(fnptr))(carg0); +// } +// gboolean _gotk4_gstaudio1_AudioDecoder_virtual_transform_meta(void* fnptr, GstAudioDecoder* carg0, GstBuffer* carg1, GstMeta* carg2, GstBuffer* carg3) { +// return ((gboolean (*) (GstAudioDecoder*, GstBuffer*, GstMeta*, GstBuffer*))(fnptr))(carg0, carg1, carg2, carg3); +// } +// extern gboolean _gotk4_gstaudio1_AudioEncoder_close(GstAudioEncoder*); +// extern gboolean _gotk4_gstaudio1_AudioEncoder_decide_allocation(GstAudioEncoder*, GstQuery*); +// extern void _gotk4_gstaudio1_AudioEncoder_flush(GstAudioEncoder*); +// extern GstCaps* _gotk4_gstaudio1_AudioEncoder_getcaps(GstAudioEncoder*, GstCaps*); +// extern GstFlowReturn _gotk4_gstaudio1_AudioEncoder_handle_frame(GstAudioEncoder*, GstBuffer*); +// extern gboolean _gotk4_gstaudio1_AudioEncoder_negotiate(GstAudioEncoder*); +// extern gboolean _gotk4_gstaudio1_AudioEncoder_open(GstAudioEncoder*); +// extern gboolean _gotk4_gstaudio1_AudioEncoder_propose_allocation(GstAudioEncoder*, GstQuery*); +// extern gboolean _gotk4_gstaudio1_AudioEncoder_set_format(GstAudioEncoder*, GstAudioInfo*); +// extern gboolean _gotk4_gstaudio1_AudioEncoder_sink_event(GstAudioEncoder*, GstEvent*); +// extern gboolean _gotk4_gstaudio1_AudioEncoder_sink_query(GstAudioEncoder*, GstQuery*); +// extern gboolean _gotk4_gstaudio1_AudioEncoder_src_event(GstAudioEncoder*, GstEvent*); +// extern gboolean _gotk4_gstaudio1_AudioEncoder_src_query(GstAudioEncoder*, GstQuery*); +// extern gboolean _gotk4_gstaudio1_AudioEncoder_start(GstAudioEncoder*); +// extern gboolean _gotk4_gstaudio1_AudioEncoder_stop(GstAudioEncoder*); +// extern gboolean _gotk4_gstaudio1_AudioEncoder_transform_meta(GstAudioEncoder*, GstBuffer*, GstMeta*, GstBuffer*); +// gboolean _gotk4_gstaudio1_AudioEncoder_virtual_close(void* fnptr, GstAudioEncoder* carg0) { +// return ((gboolean (*) (GstAudioEncoder*))(fnptr))(carg0); +// } +// gboolean _gotk4_gstaudio1_AudioEncoder_virtual_decide_allocation(void* fnptr, GstAudioEncoder* carg0, GstQuery* carg1) { +// return ((gboolean (*) (GstAudioEncoder*, GstQuery*))(fnptr))(carg0, carg1); +// } +// void _gotk4_gstaudio1_AudioEncoder_virtual_flush(void* fnptr, GstAudioEncoder* carg0) { +// return ((void (*) (GstAudioEncoder*))(fnptr))(carg0); +// } +// GstCaps* _gotk4_gstaudio1_AudioEncoder_virtual_getcaps(void* fnptr, GstAudioEncoder* carg0, GstCaps* carg1) { +// return ((GstCaps* (*) (GstAudioEncoder*, GstCaps*))(fnptr))(carg0, carg1); +// } +// GstFlowReturn _gotk4_gstaudio1_AudioEncoder_virtual_handle_frame(void* fnptr, GstAudioEncoder* carg0, GstBuffer* carg1) { +// return ((GstFlowReturn (*) (GstAudioEncoder*, GstBuffer*))(fnptr))(carg0, carg1); +// } +// gboolean _gotk4_gstaudio1_AudioEncoder_virtual_negotiate(void* fnptr, GstAudioEncoder* carg0) { +// return ((gboolean (*) (GstAudioEncoder*))(fnptr))(carg0); +// } +// gboolean _gotk4_gstaudio1_AudioEncoder_virtual_open(void* fnptr, GstAudioEncoder* carg0) { +// return ((gboolean (*) (GstAudioEncoder*))(fnptr))(carg0); +// } +// gboolean _gotk4_gstaudio1_AudioEncoder_virtual_propose_allocation(void* fnptr, GstAudioEncoder* carg0, GstQuery* carg1) { +// return ((gboolean (*) (GstAudioEncoder*, GstQuery*))(fnptr))(carg0, carg1); +// } +// gboolean _gotk4_gstaudio1_AudioEncoder_virtual_set_format(void* fnptr, GstAudioEncoder* carg0, GstAudioInfo* carg1) { +// return ((gboolean (*) (GstAudioEncoder*, GstAudioInfo*))(fnptr))(carg0, carg1); +// } +// gboolean _gotk4_gstaudio1_AudioEncoder_virtual_sink_event(void* fnptr, GstAudioEncoder* carg0, GstEvent* carg1) { +// return ((gboolean (*) (GstAudioEncoder*, GstEvent*))(fnptr))(carg0, carg1); +// } +// gboolean _gotk4_gstaudio1_AudioEncoder_virtual_sink_query(void* fnptr, GstAudioEncoder* carg0, GstQuery* carg1) { +// return ((gboolean (*) (GstAudioEncoder*, GstQuery*))(fnptr))(carg0, carg1); +// } +// gboolean _gotk4_gstaudio1_AudioEncoder_virtual_src_event(void* fnptr, GstAudioEncoder* carg0, GstEvent* carg1) { +// return ((gboolean (*) (GstAudioEncoder*, GstEvent*))(fnptr))(carg0, carg1); +// } +// gboolean _gotk4_gstaudio1_AudioEncoder_virtual_src_query(void* fnptr, GstAudioEncoder* carg0, GstQuery* carg1) { +// return ((gboolean (*) (GstAudioEncoder*, GstQuery*))(fnptr))(carg0, carg1); +// } +// gboolean _gotk4_gstaudio1_AudioEncoder_virtual_start(void* fnptr, GstAudioEncoder* carg0) { +// return ((gboolean (*) (GstAudioEncoder*))(fnptr))(carg0); +// } +// gboolean _gotk4_gstaudio1_AudioEncoder_virtual_stop(void* fnptr, GstAudioEncoder* carg0) { +// return ((gboolean (*) (GstAudioEncoder*))(fnptr))(carg0); +// } +// gboolean _gotk4_gstaudio1_AudioEncoder_virtual_transform_meta(void* fnptr, GstAudioEncoder* carg0, GstBuffer* carg1, GstMeta* carg2, GstBuffer* carg3) { +// return ((gboolean (*) (GstAudioEncoder*, GstBuffer*, GstMeta*, GstBuffer*))(fnptr))(carg0, carg1, carg2, carg3); +// } +// extern gboolean _gotk4_gstaudio1_AudioFilter_setup(GstAudioFilter*, GstAudioInfo*); +// gboolean _gotk4_gstaudio1_AudioFilter_virtual_setup(void* fnptr, GstAudioFilter* carg0, GstAudioInfo* carg1) { +// return ((gboolean (*) (GstAudioFilter*, GstAudioInfo*))(fnptr))(carg0, carg1); +// } +// extern gboolean _gotk4_gstaudio1_AudioRingBuffer_acquire(GstAudioRingBuffer*, GstAudioRingBufferSpec*); +// extern gboolean _gotk4_gstaudio1_AudioRingBuffer_activate(GstAudioRingBuffer*, gboolean); +// extern void _gotk4_gstaudio1_AudioRingBuffer_clear_all(GstAudioRingBuffer*); +// extern gboolean _gotk4_gstaudio1_AudioRingBuffer_close_device(GstAudioRingBuffer*); +// extern guint _gotk4_gstaudio1_AudioRingBuffer_delay(GstAudioRingBuffer*); +// extern gboolean _gotk4_gstaudio1_AudioRingBuffer_open_device(GstAudioRingBuffer*); +// extern gboolean _gotk4_gstaudio1_AudioRingBuffer_pause(GstAudioRingBuffer*); +// extern gboolean _gotk4_gstaudio1_AudioRingBuffer_release(GstAudioRingBuffer*); +// extern gboolean _gotk4_gstaudio1_AudioRingBuffer_resume(GstAudioRingBuffer*); +// extern gboolean _gotk4_gstaudio1_AudioRingBuffer_start(GstAudioRingBuffer*); +// extern gboolean _gotk4_gstaudio1_AudioRingBuffer_stop(GstAudioRingBuffer*); +// gboolean _gotk4_gstaudio1_AudioRingBuffer_virtual_acquire(void* fnptr, GstAudioRingBuffer* carg0, GstAudioRingBufferSpec* carg1) { +// return ((gboolean (*) (GstAudioRingBuffer*, GstAudioRingBufferSpec*))(fnptr))(carg0, carg1); +// } +// gboolean _gotk4_gstaudio1_AudioRingBuffer_virtual_activate(void* fnptr, GstAudioRingBuffer* carg0, gboolean carg1) { +// return ((gboolean (*) (GstAudioRingBuffer*, gboolean))(fnptr))(carg0, carg1); +// } +// void _gotk4_gstaudio1_AudioRingBuffer_virtual_clear_all(void* fnptr, GstAudioRingBuffer* carg0) { +// return ((void (*) (GstAudioRingBuffer*))(fnptr))(carg0); +// } +// gboolean _gotk4_gstaudio1_AudioRingBuffer_virtual_close_device(void* fnptr, GstAudioRingBuffer* carg0) { +// return ((gboolean (*) (GstAudioRingBuffer*))(fnptr))(carg0); +// } +// guint _gotk4_gstaudio1_AudioRingBuffer_virtual_delay(void* fnptr, GstAudioRingBuffer* carg0) { +// return ((guint (*) (GstAudioRingBuffer*))(fnptr))(carg0); +// } +// gboolean _gotk4_gstaudio1_AudioRingBuffer_virtual_open_device(void* fnptr, GstAudioRingBuffer* carg0) { +// return ((gboolean (*) (GstAudioRingBuffer*))(fnptr))(carg0); +// } +// gboolean _gotk4_gstaudio1_AudioRingBuffer_virtual_pause(void* fnptr, GstAudioRingBuffer* carg0) { +// return ((gboolean (*) (GstAudioRingBuffer*))(fnptr))(carg0); +// } +// gboolean _gotk4_gstaudio1_AudioRingBuffer_virtual_release(void* fnptr, GstAudioRingBuffer* carg0) { +// return ((gboolean (*) (GstAudioRingBuffer*))(fnptr))(carg0); +// } +// gboolean _gotk4_gstaudio1_AudioRingBuffer_virtual_resume(void* fnptr, GstAudioRingBuffer* carg0) { +// return ((gboolean (*) (GstAudioRingBuffer*))(fnptr))(carg0); +// } +// gboolean _gotk4_gstaudio1_AudioRingBuffer_virtual_start(void* fnptr, GstAudioRingBuffer* carg0) { +// return ((gboolean (*) (GstAudioRingBuffer*))(fnptr))(carg0); +// } +// gboolean _gotk4_gstaudio1_AudioRingBuffer_virtual_stop(void* fnptr, GstAudioRingBuffer* carg0) { +// return ((gboolean (*) (GstAudioRingBuffer*))(fnptr))(carg0); +// } +// extern gboolean _gotk4_gstaudio1_AudioSink_close(GstAudioSink*); +// extern guint _gotk4_gstaudio1_AudioSink_delay(GstAudioSink*); +// extern gboolean _gotk4_gstaudio1_AudioSink_open(GstAudioSink*); +// extern void _gotk4_gstaudio1_AudioSink_pause(GstAudioSink*); +// extern gboolean _gotk4_gstaudio1_AudioSink_prepare(GstAudioSink*, GstAudioRingBufferSpec*); +// extern void _gotk4_gstaudio1_AudioSink_reset(GstAudioSink*); +// extern void _gotk4_gstaudio1_AudioSink_resume(GstAudioSink*); +// extern void _gotk4_gstaudio1_AudioSink_stop(GstAudioSink*); +// extern gboolean _gotk4_gstaudio1_AudioSink_unprepare(GstAudioSink*); +// gboolean _gotk4_gstaudio1_AudioSink_virtual_close(void* fnptr, GstAudioSink* carg0) { +// return ((gboolean (*) (GstAudioSink*))(fnptr))(carg0); +// } +// guint _gotk4_gstaudio1_AudioSink_virtual_delay(void* fnptr, GstAudioSink* carg0) { +// return ((guint (*) (GstAudioSink*))(fnptr))(carg0); +// } +// gboolean _gotk4_gstaudio1_AudioSink_virtual_open(void* fnptr, GstAudioSink* carg0) { +// return ((gboolean (*) (GstAudioSink*))(fnptr))(carg0); +// } +// void _gotk4_gstaudio1_AudioSink_virtual_pause(void* fnptr, GstAudioSink* carg0) { +// return ((void (*) (GstAudioSink*))(fnptr))(carg0); +// } +// gboolean _gotk4_gstaudio1_AudioSink_virtual_prepare(void* fnptr, GstAudioSink* carg0, GstAudioRingBufferSpec* carg1) { +// return ((gboolean (*) (GstAudioSink*, GstAudioRingBufferSpec*))(fnptr))(carg0, carg1); +// } +// void _gotk4_gstaudio1_AudioSink_virtual_reset(void* fnptr, GstAudioSink* carg0) { +// return ((void (*) (GstAudioSink*))(fnptr))(carg0); +// } +// void _gotk4_gstaudio1_AudioSink_virtual_resume(void* fnptr, GstAudioSink* carg0) { +// return ((void (*) (GstAudioSink*))(fnptr))(carg0); +// } +// void _gotk4_gstaudio1_AudioSink_virtual_stop(void* fnptr, GstAudioSink* carg0) { +// return ((void (*) (GstAudioSink*))(fnptr))(carg0); +// } +// gboolean _gotk4_gstaudio1_AudioSink_virtual_unprepare(void* fnptr, GstAudioSink* carg0) { +// return ((gboolean (*) (GstAudioSink*))(fnptr))(carg0); +// } +// extern gboolean _gotk4_gstaudio1_AudioSrc_close(GstAudioSrc*); +// extern guint _gotk4_gstaudio1_AudioSrc_delay(GstAudioSrc*); +// extern gboolean _gotk4_gstaudio1_AudioSrc_open(GstAudioSrc*); +// extern gboolean _gotk4_gstaudio1_AudioSrc_prepare(GstAudioSrc*, GstAudioRingBufferSpec*); +// extern void _gotk4_gstaudio1_AudioSrc_reset(GstAudioSrc*); +// extern gboolean _gotk4_gstaudio1_AudioSrc_unprepare(GstAudioSrc*); +// gboolean _gotk4_gstaudio1_AudioSrc_virtual_close(void* fnptr, GstAudioSrc* carg0) { +// return ((gboolean (*) (GstAudioSrc*))(fnptr))(carg0); +// } +// guint _gotk4_gstaudio1_AudioSrc_virtual_delay(void* fnptr, GstAudioSrc* carg0) { +// return ((guint (*) (GstAudioSrc*))(fnptr))(carg0); +// } +// gboolean _gotk4_gstaudio1_AudioSrc_virtual_open(void* fnptr, GstAudioSrc* carg0) { +// return ((gboolean (*) (GstAudioSrc*))(fnptr))(carg0); +// } +// gboolean _gotk4_gstaudio1_AudioSrc_virtual_prepare(void* fnptr, GstAudioSrc* carg0, GstAudioRingBufferSpec* carg1) { +// return ((gboolean (*) (GstAudioSrc*, GstAudioRingBufferSpec*))(fnptr))(carg0, carg1); +// } +// void _gotk4_gstaudio1_AudioSrc_virtual_reset(void* fnptr, GstAudioSrc* carg0) { +// return ((void (*) (GstAudioSrc*))(fnptr))(carg0); +// } +// gboolean _gotk4_gstaudio1_AudioSrc_virtual_unprepare(void* fnptr, GstAudioSrc* carg0) { +// return ((gboolean (*) (GstAudioSrc*))(fnptr))(carg0); +// } import "C" // GType values. @@ -2169,6 +2449,7 @@ func AudioCheckValidChannelPositions(position []AudioChannelPosition, forceOrder } // AudioClippingMetaApiGetType wraps gst_audio_clipping_meta_api_get_type +// // The function returns the following values: // // - goret gobject.Type @@ -2185,6 +2466,7 @@ func AudioClippingMetaApiGetType() gobject.Type { } // AudioDownmixMetaApiGetType wraps gst_audio_downmix_meta_api_get_type +// // The function returns the following values: // // - goret gobject.Type @@ -2201,6 +2483,7 @@ func AudioDownmixMetaApiGetType() gobject.Type { } // AudioFormatsRaw wraps gst_audio_formats_raw +// // The function returns the following values: // // - len uint: the number of elements in the returned array @@ -2359,6 +2642,7 @@ func AudioIec61937Payload(src []uint8, dst []uint8, spec *AudioRingBufferSpec, e } // AudioLevelMetaApiGetType wraps gst_audio_level_meta_api_get_type +// // The function returns the following values: // // - goret gobject.Type @@ -2414,6 +2698,7 @@ func AudioMakeRawCaps(formats []AudioFormat, layout AudioLayout) *gst.Caps { } // AudioMetaApiGetType wraps gst_audio_meta_api_get_type +// // The function returns the following values: // // - goret gobject.Type @@ -2838,6 +3123,7 @@ func DsdConvert(inputData *uint8, outputData *uint8, inputFormat DsdFormat, outp } // DsdPlaneOffsetMetaApiGetType wraps gst_dsd_plane_offset_meta_api_get_type +// // The function returns the following values: // // - goret gobject.Type @@ -2883,6 +3169,7 @@ type StreamVolume interface { upcastToGstStreamVolume() *StreamVolumeInstance // GetMute wraps gst_stream_volume_get_mute + // // The function returns the following values: // // - goret bool @@ -2984,6 +3271,7 @@ func StreamVolumeConvertVolume(from StreamVolumeFormat, to StreamVolumeFormat, v } // GetMute wraps gst_stream_volume_get_mute +// // The function returns the following values: // // - goret bool @@ -3073,6 +3361,16 @@ func (volume *StreamVolumeInstance) SetVolume(format StreamVolumeFormat, val flo runtime.KeepAlive(val) } +// StreamVolumeOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type StreamVolumeOverrides[Instance StreamVolume] struct { +} + +// UnsafeApplyStreamVolumeOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyStreamVolumeOverrides[Instance StreamVolume](gclass unsafe.Pointer, overrides StreamVolumeOverrides[Instance]) { +} + // AudioAggregatorInstance is the instance type used by all types extending GstAudioAggregator. It is used internally by the bindings. Users should use the interface [AudioAggregator] instead. type AudioAggregatorInstance struct { _ [0]func() // equal guard @@ -3203,6 +3501,53 @@ func (aagg *AudioAggregatorInstance) SetSinkCaps(pad AudioAggregatorPad, caps *g runtime.KeepAlive(caps) } +// AudioAggregatorOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type AudioAggregatorOverrides[Instance AudioAggregator] struct { + // gstbase.AggregatorOverrides allows you to override virtual methods from the parent class gstbase.Aggregator + gstbase.AggregatorOverrides[Instance] + + // AggregateOneBuffer allows you to override the implementation of the virtual method aggregate_one_buffer. + // The function takes the following parameters: + // + // - pad AudioAggregatorPad + // - inbuf *gst.Buffer + // - inOffset uint + // - outbuf *gst.Buffer + // - outOffset uint + // - numFrames uint + // + // The function returns the following values: + // + // - goret bool + AggregateOneBuffer func(Instance, AudioAggregatorPad, *gst.Buffer, uint, *gst.Buffer, uint, uint) bool + // CreateOutputBuffer allows you to override the implementation of the virtual method create_output_buffer. + // The function takes the following parameters: + // + // - numFrames uint + // + // The function returns the following values: + // + // - goret *gst.Buffer + CreateOutputBuffer func(Instance, uint) *gst.Buffer +} + +// UnsafeApplyAudioAggregatorOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyAudioAggregatorOverrides[Instance AudioAggregator](gclass unsafe.Pointer, overrides AudioAggregatorOverrides[Instance]) { + gstbase.UnsafeApplyAggregatorOverrides(gclass, overrides.AggregatorOverrides) + + pclass := (*C.GstAudioAggregatorClass)(gclass) + + if overrides.AggregateOneBuffer != nil { + pclass.aggregate_one_buffer = (*[0]byte)(C._gotk4_gstaudio1_AudioAggregator_aggregate_one_buffer) + } + + if overrides.CreateOutputBuffer != nil { + pclass.create_output_buffer = (*[0]byte)(C._gotk4_gstaudio1_AudioAggregator_create_output_buffer) + } +} + // AudioAggregatorPadInstance is the instance type used by all types extending GstAudioAggregatorPad. It is used internally by the bindings. Users should use the interface [AudioAggregatorPad] instead. type AudioAggregatorPadInstance struct { _ [0]func() // equal guard @@ -3261,6 +3606,43 @@ func UnsafeAudioAggregatorPadToGlibFull(c AudioAggregatorPad) unsafe.Pointer { return gobject.UnsafeObjectToGlibFull(c) } +// AudioAggregatorPadOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type AudioAggregatorPadOverrides[Instance AudioAggregatorPad] struct { + // gstbase.AggregatorPadOverrides allows you to override virtual methods from the parent class gstbase.AggregatorPad + gstbase.AggregatorPadOverrides[Instance] + + // ConvertBuffer allows you to override the implementation of the virtual method convert_buffer. + // The function takes the following parameters: + // + // - inInfo *AudioInfo + // - outInfo *AudioInfo + // - buffer *gst.Buffer + // + // The function returns the following values: + // + // - goret *gst.Buffer + ConvertBuffer func(Instance, *AudioInfo, *AudioInfo, *gst.Buffer) *gst.Buffer + // UpdateConversionInfo allows you to override the implementation of the virtual method update_conversion_info. + UpdateConversionInfo func(Instance) +} + +// UnsafeApplyAudioAggregatorPadOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyAudioAggregatorPadOverrides[Instance AudioAggregatorPad](gclass unsafe.Pointer, overrides AudioAggregatorPadOverrides[Instance]) { + gstbase.UnsafeApplyAggregatorPadOverrides(gclass, overrides.AggregatorPadOverrides) + + pclass := (*C.GstAudioAggregatorPadClass)(gclass) + + if overrides.ConvertBuffer != nil { + pclass.convert_buffer = (*[0]byte)(C._gotk4_gstaudio1_AudioAggregatorPad_convert_buffer) + } + + if overrides.UpdateConversionInfo != nil { + pclass.update_conversion_info = (*[0]byte)(C._gotk4_gstaudio1_AudioAggregatorPad_update_conversion_info) + } +} + // AudioBaseSinkInstance is the instance type used by all types extending GstAudioBaseSink. It is used internally by the bindings. Users should use the interface [AudioBaseSink] instead. type AudioBaseSinkInstance struct { _ [0]func() // equal guard @@ -3279,6 +3661,7 @@ type AudioBaseSink interface { upcastToGstAudioBaseSink() *AudioBaseSinkInstance // CreateRingbuffer wraps gst_audio_base_sink_create_ringbuffer + // // The function returns the following values: // // - goret AudioRingBuffer (nullable) @@ -3288,6 +3671,7 @@ type AudioBaseSink interface { // the returned buffer (see gst_object_set_parent()). CreateRingbuffer() AudioRingBuffer // GetAlignmentThreshold wraps gst_audio_base_sink_get_alignment_threshold + // // The function returns the following values: // // - goret gst.ClockTime @@ -3295,6 +3679,7 @@ type AudioBaseSink interface { // Get the current alignment threshold, in nanoseconds, used by @sink. GetAlignmentThreshold() gst.ClockTime // GetDiscontWait wraps gst_audio_base_sink_get_discont_wait + // // The function returns the following values: // // - goret gst.ClockTime @@ -3302,6 +3687,7 @@ type AudioBaseSink interface { // Get the current discont wait, in nanoseconds, used by @sink. GetDiscontWait() gst.ClockTime // GetDriftTolerance wraps gst_audio_base_sink_get_drift_tolerance + // // The function returns the following values: // // - goret int64 @@ -3309,6 +3695,7 @@ type AudioBaseSink interface { // Get the current drift tolerance, in microseconds, used by @sink. GetDriftTolerance() int64 // GetProvideClock wraps gst_audio_base_sink_get_provide_clock + // // The function returns the following values: // // - goret bool @@ -3317,6 +3704,7 @@ type AudioBaseSink interface { // gst_audio_base_sink_set_provide_clock. GetProvideClock() bool // GetSlaveMethod wraps gst_audio_base_sink_get_slave_method + // // The function returns the following values: // // - goret AudioBaseSinkSlaveMethod @@ -3434,6 +3822,7 @@ func UnsafeAudioBaseSinkToGlibFull(c AudioBaseSink) unsafe.Pointer { } // CreateRingbuffer wraps gst_audio_base_sink_create_ringbuffer +// // The function returns the following values: // // - goret AudioRingBuffer (nullable) @@ -3460,6 +3849,7 @@ func (sink *AudioBaseSinkInstance) CreateRingbuffer() AudioRingBuffer { } // GetAlignmentThreshold wraps gst_audio_base_sink_get_alignment_threshold +// // The function returns the following values: // // - goret gst.ClockTime @@ -3482,6 +3872,7 @@ func (sink *AudioBaseSinkInstance) GetAlignmentThreshold() gst.ClockTime { } // GetDiscontWait wraps gst_audio_base_sink_get_discont_wait +// // The function returns the following values: // // - goret gst.ClockTime @@ -3504,6 +3895,7 @@ func (sink *AudioBaseSinkInstance) GetDiscontWait() gst.ClockTime { } // GetDriftTolerance wraps gst_audio_base_sink_get_drift_tolerance +// // The function returns the following values: // // - goret int64 @@ -3526,6 +3918,7 @@ func (sink *AudioBaseSinkInstance) GetDriftTolerance() int64 { } // GetProvideClock wraps gst_audio_base_sink_get_provide_clock +// // The function returns the following values: // // - goret bool @@ -3551,6 +3944,7 @@ func (sink *AudioBaseSinkInstance) GetProvideClock() bool { } // GetSlaveMethod wraps gst_audio_base_sink_get_slave_method +// // The function returns the following values: // // - goret AudioBaseSinkSlaveMethod @@ -3718,6 +4112,44 @@ func (sink *AudioBaseSinkInstance) SetSlaveMethod(method AudioBaseSinkSlaveMetho runtime.KeepAlive(method) } +// AudioBaseSinkOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type AudioBaseSinkOverrides[Instance AudioBaseSink] struct { + // gstbase.BaseSinkOverrides allows you to override virtual methods from the parent class gstbase.BaseSink + gstbase.BaseSinkOverrides[Instance] + + // CreateRingbuffer allows you to override the implementation of the virtual method create_ringbuffer. + // The function returns the following values: + // + // - goret AudioRingBuffer (nullable) + CreateRingbuffer func(Instance) AudioRingBuffer + // Payload allows you to override the implementation of the virtual method payload. + // The function takes the following parameters: + // + // - buffer *gst.Buffer + // + // The function returns the following values: + // + // - goret *gst.Buffer + Payload func(Instance, *gst.Buffer) *gst.Buffer +} + +// UnsafeApplyAudioBaseSinkOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyAudioBaseSinkOverrides[Instance AudioBaseSink](gclass unsafe.Pointer, overrides AudioBaseSinkOverrides[Instance]) { + gstbase.UnsafeApplyBaseSinkOverrides(gclass, overrides.BaseSinkOverrides) + + pclass := (*C.GstAudioBaseSinkClass)(gclass) + + if overrides.CreateRingbuffer != nil { + pclass.create_ringbuffer = (*[0]byte)(C._gotk4_gstaudio1_AudioBaseSink_create_ringbuffer) + } + + if overrides.Payload != nil { + pclass.payload = (*[0]byte)(C._gotk4_gstaudio1_AudioBaseSink_payload) + } +} + // AudioBaseSrcInstance is the instance type used by all types extending GstAudioBaseSrc. It is used internally by the bindings. Users should use the interface [AudioBaseSrc] instead. type AudioBaseSrcInstance struct { _ [0]func() // equal guard @@ -3736,6 +4168,7 @@ type AudioBaseSrc interface { upcastToGstAudioBaseSrc() *AudioBaseSrcInstance // CreateRingbuffer wraps gst_audio_base_src_create_ringbuffer + // // The function returns the following values: // // - goret AudioRingBuffer (nullable) @@ -3745,6 +4178,7 @@ type AudioBaseSrc interface { // returned buffer (see gst_object_set_parent()). CreateRingbuffer() AudioRingBuffer // GetProvideClock wraps gst_audio_base_src_get_provide_clock + // // The function returns the following values: // // - goret bool @@ -3753,6 +4187,7 @@ type AudioBaseSrc interface { // gst_audio_base_src_set_provide_clock. GetProvideClock() bool // GetSlaveMethod wraps gst_audio_base_src_get_slave_method + // // The function returns the following values: // // - goret AudioBaseSrcSlaveMethod @@ -3824,6 +4259,7 @@ func UnsafeAudioBaseSrcToGlibFull(c AudioBaseSrc) unsafe.Pointer { } // CreateRingbuffer wraps gst_audio_base_src_create_ringbuffer +// // The function returns the following values: // // - goret AudioRingBuffer (nullable) @@ -3850,6 +4286,7 @@ func (src *AudioBaseSrcInstance) CreateRingbuffer() AudioRingBuffer { } // GetProvideClock wraps gst_audio_base_src_get_provide_clock +// // The function returns the following values: // // - goret bool @@ -3875,6 +4312,7 @@ func (src *AudioBaseSrcInstance) GetProvideClock() bool { } // GetSlaveMethod wraps gst_audio_base_src_get_slave_method +// // The function returns the following values: // // - goret AudioBaseSrcSlaveMethod @@ -3938,6 +4376,31 @@ func (src *AudioBaseSrcInstance) SetSlaveMethod(method AudioBaseSrcSlaveMethod) runtime.KeepAlive(method) } +// AudioBaseSrcOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type AudioBaseSrcOverrides[Instance AudioBaseSrc] struct { + // gstbase.PushSrcOverrides allows you to override virtual methods from the parent class gstbase.PushSrc + gstbase.PushSrcOverrides[Instance] + + // CreateRingbuffer allows you to override the implementation of the virtual method create_ringbuffer. + // The function returns the following values: + // + // - goret AudioRingBuffer (nullable) + CreateRingbuffer func(Instance) AudioRingBuffer +} + +// UnsafeApplyAudioBaseSrcOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyAudioBaseSrcOverrides[Instance AudioBaseSrc](gclass unsafe.Pointer, overrides AudioBaseSrcOverrides[Instance]) { + gstbase.UnsafeApplyPushSrcOverrides(gclass, overrides.PushSrcOverrides) + + pclass := (*C.GstAudioBaseSrcClass)(gclass) + + if overrides.CreateRingbuffer != nil { + pclass.create_ringbuffer = (*[0]byte)(C._gotk4_gstaudio1_AudioBaseSrc_create_ringbuffer) + } +} + // AudioCdSrcInstance is the instance type used by all types extending GstAudioCdSrc. It is used internally by the bindings. Users should use the interface [AudioCdSrc] instead. type AudioCdSrcInstance struct { _ [0]func() // equal guard @@ -4097,6 +4560,54 @@ func (src *AudioCdSrcInstance) AddTrack(track *AudioCdSrcTrack) bool { return goret } +// AudioCdSrcOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type AudioCdSrcOverrides[Instance AudioCdSrc] struct { + // gstbase.PushSrcOverrides allows you to override virtual methods from the parent class gstbase.PushSrc + gstbase.PushSrcOverrides[Instance] + + // Close allows you to override the implementation of the virtual method close. + Close func(Instance) + // Open allows you to override the implementation of the virtual method open. + // The function takes the following parameters: + // + // - device string + // + // The function returns the following values: + // + // - goret bool + Open func(Instance, string) bool + // ReadSector allows you to override the implementation of the virtual method read_sector. + // The function takes the following parameters: + // + // - sector int + // + // The function returns the following values: + // + // - goret *gst.Buffer + ReadSector func(Instance, int) *gst.Buffer +} + +// UnsafeApplyAudioCdSrcOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyAudioCdSrcOverrides[Instance AudioCdSrc](gclass unsafe.Pointer, overrides AudioCdSrcOverrides[Instance]) { + gstbase.UnsafeApplyPushSrcOverrides(gclass, overrides.PushSrcOverrides) + + pclass := (*C.GstAudioCdSrcClass)(gclass) + + if overrides.Close != nil { + pclass.close = (*[0]byte)(C._gotk4_gstaudio1_AudioCdSrc_close) + } + + if overrides.Open != nil { + pclass.open = (*[0]byte)(C._gotk4_gstaudio1_AudioCdSrc_open) + } + + if overrides.ReadSector != nil { + pclass.read_sector = (*[0]byte)(C._gotk4_gstaudio1_AudioCdSrc_read_sector) + } +} + // AudioClockInstance is the instance type used by all types extending GstAudioClock. It is used internally by the bindings. Users should use the interface [AudioClock] instead. type AudioClockInstance struct { _ [0]func() // equal guard @@ -4128,6 +4639,7 @@ type AudioClock interface { // Adjust @time with the internal offset of the audio clock. Adjust(gst.ClockTime) gst.ClockTime // GetTime wraps gst_audio_clock_get_time + // // The function returns the following values: // // - goret gst.ClockTime @@ -4268,6 +4780,7 @@ func (clock *AudioClockInstance) Adjust(time gst.ClockTime) gst.ClockTime { } // GetTime wraps gst_audio_clock_get_time +// // The function returns the following values: // // - goret gst.ClockTime @@ -4329,6 +4842,20 @@ func (clock *AudioClockInstance) Reset(time gst.ClockTime) { runtime.KeepAlive(time) } +// AudioClockOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type AudioClockOverrides[Instance AudioClock] struct { + // gst.SystemClockOverrides allows you to override virtual methods from the parent class gst.SystemClock + gst.SystemClockOverrides[Instance] + +} + +// UnsafeApplyAudioClockOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyAudioClockOverrides[Instance AudioClock](gclass unsafe.Pointer, overrides AudioClockOverrides[Instance]) { + gst.UnsafeApplySystemClockOverrides(gclass, overrides.SystemClockOverrides) +} + // AudioDecoderInstance is the instance type used by all types extending GstAudioDecoder. It is used internally by the bindings. Users should use the interface [AudioDecoder] instead. type AudioDecoderInstance struct { _ [0]func() // equal guard @@ -4492,6 +5019,7 @@ type AudioDecoder interface { // invalidated by a call to this function. FinishSubframe(*gst.Buffer) gst.FlowReturn // GetAllocator wraps gst_audio_decoder_get_allocator + // // The function returns the following values: // // - allocator gst.Allocator (nullable): the #GstAllocator @@ -4505,16 +5033,19 @@ type AudioDecoder interface { // Unref the @allocator after use it. GetAllocator() (gst.Allocator, gst.AllocationParams) // GetAudioInfo wraps gst_audio_decoder_get_audio_info + // // The function returns the following values: // // - goret *AudioInfo GetAudioInfo() *AudioInfo // GetDelay wraps gst_audio_decoder_get_delay + // // The function returns the following values: // // - goret int GetDelay() int // GetDrainable wraps gst_audio_decoder_get_drainable + // // The function returns the following values: // // - goret bool @@ -4522,11 +5053,13 @@ type AudioDecoder interface { // Queries decoder drain handling. GetDrainable() bool // GetEstimateRate wraps gst_audio_decoder_get_estimate_rate + // // The function returns the following values: // // - goret int GetEstimateRate() int // GetLatency wraps gst_audio_decoder_get_latency + // // The function returns the following values: // // - min gst.ClockTime: a pointer to storage to hold minimum latency @@ -4536,11 +5069,13 @@ type AudioDecoder interface { // latency. GetLatency() (gst.ClockTime, gst.ClockTime) // GetMaxErrors wraps gst_audio_decoder_get_max_errors + // // The function returns the following values: // // - goret int GetMaxErrors() int // GetMinLatency wraps gst_audio_decoder_get_min_latency + // // The function returns the following values: // // - goret gst.ClockTime @@ -4548,6 +5083,7 @@ type AudioDecoder interface { // Queries decoder's latency aggregation. GetMinLatency() gst.ClockTime // GetNeedsFormat wraps gst_audio_decoder_get_needs_format + // // The function returns the following values: // // - goret bool @@ -4555,6 +5091,7 @@ type AudioDecoder interface { // Queries decoder required format handling. GetNeedsFormat() bool // GetParseState wraps gst_audio_decoder_get_parse_state + // // The function returns the following values: // // - sync bool: a pointer to a variable to hold the current sync state @@ -4563,6 +5100,7 @@ type AudioDecoder interface { // Return current parsing (sync and eos) state. GetParseState() (bool, bool) // GetPlc wraps gst_audio_decoder_get_plc + // // The function returns the following values: // // - goret bool @@ -4570,11 +5108,13 @@ type AudioDecoder interface { // Queries decoder packet loss concealment handling. GetPlc() bool // GetPlcAware wraps gst_audio_decoder_get_plc_aware + // // The function returns the following values: // // - goret int GetPlcAware() int // GetTolerance wraps gst_audio_decoder_get_tolerance + // // The function returns the following values: // // - goret gst.ClockTime @@ -4596,6 +5136,7 @@ type AudioDecoder interface { // not required to use this and can still do tag handling on its own. MergeTags(*gst.TagList, gst.TagMergeMode) // Negotiate wraps gst_audio_decoder_negotiate + // // The function returns the following values: // // - goret bool @@ -4930,6 +5471,7 @@ func (dec *AudioDecoderInstance) FinishSubframe(buf *gst.Buffer) gst.FlowReturn } // GetAllocator wraps gst_audio_decoder_get_allocator +// // The function returns the following values: // // - allocator gst.Allocator (nullable): the #GstAllocator @@ -4965,6 +5507,7 @@ func (dec *AudioDecoderInstance) GetAllocator() (gst.Allocator, gst.AllocationPa } // GetAudioInfo wraps gst_audio_decoder_get_audio_info +// // The function returns the following values: // // - goret *AudioInfo @@ -4985,6 +5528,7 @@ func (dec *AudioDecoderInstance) GetAudioInfo() *AudioInfo { } // GetDelay wraps gst_audio_decoder_get_delay +// // The function returns the following values: // // - goret int @@ -5005,6 +5549,7 @@ func (dec *AudioDecoderInstance) GetDelay() int { } // GetDrainable wraps gst_audio_decoder_get_drainable +// // The function returns the following values: // // - goret bool @@ -5029,6 +5574,7 @@ func (dec *AudioDecoderInstance) GetDrainable() bool { } // GetEstimateRate wraps gst_audio_decoder_get_estimate_rate +// // The function returns the following values: // // - goret int @@ -5049,6 +5595,7 @@ func (dec *AudioDecoderInstance) GetEstimateRate() int { } // GetLatency wraps gst_audio_decoder_get_latency +// // The function returns the following values: // // - min gst.ClockTime: a pointer to storage to hold minimum latency @@ -5076,6 +5623,7 @@ func (dec *AudioDecoderInstance) GetLatency() (gst.ClockTime, gst.ClockTime) { } // GetMaxErrors wraps gst_audio_decoder_get_max_errors +// // The function returns the following values: // // - goret int @@ -5096,6 +5644,7 @@ func (dec *AudioDecoderInstance) GetMaxErrors() int { } // GetMinLatency wraps gst_audio_decoder_get_min_latency +// // The function returns the following values: // // - goret gst.ClockTime @@ -5118,6 +5667,7 @@ func (dec *AudioDecoderInstance) GetMinLatency() gst.ClockTime { } // GetNeedsFormat wraps gst_audio_decoder_get_needs_format +// // The function returns the following values: // // - goret bool @@ -5142,6 +5692,7 @@ func (dec *AudioDecoderInstance) GetNeedsFormat() bool { } // GetParseState wraps gst_audio_decoder_get_parse_state +// // The function returns the following values: // // - sync bool: a pointer to a variable to hold the current sync state @@ -5172,6 +5723,7 @@ func (dec *AudioDecoderInstance) GetParseState() (bool, bool) { } // GetPlc wraps gst_audio_decoder_get_plc +// // The function returns the following values: // // - goret bool @@ -5196,6 +5748,7 @@ func (dec *AudioDecoderInstance) GetPlc() bool { } // GetPlcAware wraps gst_audio_decoder_get_plc_aware +// // The function returns the following values: // // - goret int @@ -5216,6 +5769,7 @@ func (dec *AudioDecoderInstance) GetPlcAware() int { } // GetTolerance wraps gst_audio_decoder_get_tolerance +// // The function returns the following values: // // - goret gst.ClockTime @@ -5268,6 +5822,7 @@ func (dec *AudioDecoderInstance) MergeTags(tags *gst.TagList, mode gst.TagMergeM } // Negotiate wraps gst_audio_decoder_negotiate +// // The function returns the following values: // // - goret bool @@ -5659,6 +6214,223 @@ func (decoder *AudioDecoderInstance) SetUseDefaultPadAcceptcaps(use bool) { runtime.KeepAlive(use) } +// AudioDecoderOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type AudioDecoderOverrides[Instance AudioDecoder] struct { + // gst.ElementOverrides allows you to override virtual methods from the parent class gst.Element + gst.ElementOverrides[Instance] + + // Close allows you to override the implementation of the virtual method close. + // The function returns the following values: + // + // - goret bool + Close func(Instance) bool + // DecideAllocation allows you to override the implementation of the virtual method decide_allocation. + // The function takes the following parameters: + // + // - query *gst.Query + // + // The function returns the following values: + // + // - goret bool + DecideAllocation func(Instance, *gst.Query) bool + // Flush allows you to override the implementation of the virtual method flush. + // The function takes the following parameters: + // + // - hard bool + Flush func(Instance, bool) + // Getcaps allows you to override the implementation of the virtual method getcaps. + // The function takes the following parameters: + // + // - filter *gst.Caps + // + // The function returns the following values: + // + // - goret *gst.Caps + Getcaps func(Instance, *gst.Caps) *gst.Caps + // HandleFrame allows you to override the implementation of the virtual method handle_frame. + // The function takes the following parameters: + // + // - buffer *gst.Buffer + // + // The function returns the following values: + // + // - goret gst.FlowReturn + HandleFrame func(Instance, *gst.Buffer) gst.FlowReturn + // Negotiate allows you to override the implementation of the virtual method negotiate. + // The function returns the following values: + // + // - goret bool + Negotiate func(Instance) bool + // Open allows you to override the implementation of the virtual method open. + // The function returns the following values: + // + // - goret bool + Open func(Instance) bool + // Parse allows you to override the implementation of the virtual method parse. + // The function takes the following parameters: + // + // - adapter gstbase.Adapter + // + // The function returns the following values: + // + // - offset int + // - length int + // - goret gst.FlowReturn + Parse func(Instance, gstbase.Adapter) (int, int, gst.FlowReturn) + // ProposeAllocation allows you to override the implementation of the virtual method propose_allocation. + // The function takes the following parameters: + // + // - query *gst.Query + // + // The function returns the following values: + // + // - goret bool + ProposeAllocation func(Instance, *gst.Query) bool + // SetFormat allows you to override the implementation of the virtual method set_format. + // The function takes the following parameters: + // + // - caps *gst.Caps + // + // The function returns the following values: + // + // - goret bool + SetFormat func(Instance, *gst.Caps) bool + // SinkEvent allows you to override the implementation of the virtual method sink_event. + // The function takes the following parameters: + // + // - event *gst.Event + // + // The function returns the following values: + // + // - goret bool + SinkEvent func(Instance, *gst.Event) bool + // SinkQuery allows you to override the implementation of the virtual method sink_query. + // The function takes the following parameters: + // + // - query *gst.Query + // + // The function returns the following values: + // + // - goret bool + SinkQuery func(Instance, *gst.Query) bool + // SrcEvent allows you to override the implementation of the virtual method src_event. + // The function takes the following parameters: + // + // - event *gst.Event + // + // The function returns the following values: + // + // - goret bool + SrcEvent func(Instance, *gst.Event) bool + // SrcQuery allows you to override the implementation of the virtual method src_query. + // The function takes the following parameters: + // + // - query *gst.Query + // + // The function returns the following values: + // + // - goret bool + SrcQuery func(Instance, *gst.Query) bool + // Start allows you to override the implementation of the virtual method start. + // The function returns the following values: + // + // - goret bool + Start func(Instance) bool + // Stop allows you to override the implementation of the virtual method stop. + // The function returns the following values: + // + // - goret bool + Stop func(Instance) bool + // TransformMeta allows you to override the implementation of the virtual method transform_meta. + // The function takes the following parameters: + // + // - outbuf *gst.Buffer + // - meta *gst.Meta + // - inbuf *gst.Buffer + // + // The function returns the following values: + // + // - goret bool + TransformMeta func(Instance, *gst.Buffer, *gst.Meta, *gst.Buffer) bool +} + +// UnsafeApplyAudioDecoderOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyAudioDecoderOverrides[Instance AudioDecoder](gclass unsafe.Pointer, overrides AudioDecoderOverrides[Instance]) { + gst.UnsafeApplyElementOverrides(gclass, overrides.ElementOverrides) + + pclass := (*C.GstAudioDecoderClass)(gclass) + + if overrides.Close != nil { + pclass.close = (*[0]byte)(C._gotk4_gstaudio1_AudioDecoder_close) + } + + if overrides.DecideAllocation != nil { + pclass.decide_allocation = (*[0]byte)(C._gotk4_gstaudio1_AudioDecoder_decide_allocation) + } + + if overrides.Flush != nil { + pclass.flush = (*[0]byte)(C._gotk4_gstaudio1_AudioDecoder_flush) + } + + if overrides.Getcaps != nil { + pclass.getcaps = (*[0]byte)(C._gotk4_gstaudio1_AudioDecoder_getcaps) + } + + if overrides.HandleFrame != nil { + pclass.handle_frame = (*[0]byte)(C._gotk4_gstaudio1_AudioDecoder_handle_frame) + } + + if overrides.Negotiate != nil { + pclass.negotiate = (*[0]byte)(C._gotk4_gstaudio1_AudioDecoder_negotiate) + } + + if overrides.Open != nil { + pclass.open = (*[0]byte)(C._gotk4_gstaudio1_AudioDecoder_open) + } + + if overrides.Parse != nil { + pclass.parse = (*[0]byte)(C._gotk4_gstaudio1_AudioDecoder_parse) + } + + if overrides.ProposeAllocation != nil { + pclass.propose_allocation = (*[0]byte)(C._gotk4_gstaudio1_AudioDecoder_propose_allocation) + } + + if overrides.SetFormat != nil { + pclass.set_format = (*[0]byte)(C._gotk4_gstaudio1_AudioDecoder_set_format) + } + + if overrides.SinkEvent != nil { + pclass.sink_event = (*[0]byte)(C._gotk4_gstaudio1_AudioDecoder_sink_event) + } + + if overrides.SinkQuery != nil { + pclass.sink_query = (*[0]byte)(C._gotk4_gstaudio1_AudioDecoder_sink_query) + } + + if overrides.SrcEvent != nil { + pclass.src_event = (*[0]byte)(C._gotk4_gstaudio1_AudioDecoder_src_event) + } + + if overrides.SrcQuery != nil { + pclass.src_query = (*[0]byte)(C._gotk4_gstaudio1_AudioDecoder_src_query) + } + + if overrides.Start != nil { + pclass.start = (*[0]byte)(C._gotk4_gstaudio1_AudioDecoder_start) + } + + if overrides.Stop != nil { + pclass.stop = (*[0]byte)(C._gotk4_gstaudio1_AudioDecoder_stop) + } + + if overrides.TransformMeta != nil { + pclass.transform_meta = (*[0]byte)(C._gotk4_gstaudio1_AudioDecoder_transform_meta) + } +} + // AudioEncoderInstance is the instance type used by all types extending GstAudioEncoder. It is used internally by the bindings. Users should use the interface [AudioEncoder] instead. type AudioEncoderInstance struct { _ [0]func() // equal guard @@ -5804,6 +6576,7 @@ type AudioEncoder interface { // may be invalidated by a call to this function. FinishFrame(*gst.Buffer, int) gst.FlowReturn // GetAllocator wraps gst_audio_encoder_get_allocator + // // The function returns the following values: // // - allocator gst.Allocator (nullable): the #GstAllocator @@ -5817,11 +6590,13 @@ type AudioEncoder interface { // Unref the @allocator after use it. GetAllocator() (gst.Allocator, gst.AllocationParams) // GetAudioInfo wraps gst_audio_encoder_get_audio_info + // // The function returns the following values: // // - goret *AudioInfo GetAudioInfo() *AudioInfo // GetDrainable wraps gst_audio_encoder_get_drainable + // // The function returns the following values: // // - goret bool @@ -5829,21 +6604,25 @@ type AudioEncoder interface { // Queries encoder drain handling. GetDrainable() bool // GetFrameMax wraps gst_audio_encoder_get_frame_max + // // The function returns the following values: // // - goret int GetFrameMax() int // GetFrameSamplesMax wraps gst_audio_encoder_get_frame_samples_max + // // The function returns the following values: // // - goret int GetFrameSamplesMax() int // GetFrameSamplesMin wraps gst_audio_encoder_get_frame_samples_min + // // The function returns the following values: // // - goret int GetFrameSamplesMin() int // GetHardMin wraps gst_audio_encoder_get_hard_min + // // The function returns the following values: // // - goret bool @@ -5851,11 +6630,13 @@ type AudioEncoder interface { // Queries encoder hard minimum handling. GetHardMin() bool // GetHardResync wraps gst_audio_encoder_get_hard_resync + // // The function returns the following values: // // - goret bool GetHardResync() bool // GetLatency wraps gst_audio_encoder_get_latency + // // The function returns the following values: // // - min gst.ClockTime: a pointer to storage to hold minimum latency @@ -5865,11 +6646,13 @@ type AudioEncoder interface { // latency. GetLatency() (gst.ClockTime, gst.ClockTime) // GetLookahead wraps gst_audio_encoder_get_lookahead + // // The function returns the following values: // // - goret int GetLookahead() int // GetMarkGranule wraps gst_audio_encoder_get_mark_granule + // // The function returns the following values: // // - goret bool @@ -5877,6 +6660,7 @@ type AudioEncoder interface { // Queries if the encoder will handle granule marking. GetMarkGranule() bool // GetPerfectTimestamp wraps gst_audio_encoder_get_perfect_timestamp + // // The function returns the following values: // // - goret bool @@ -5884,6 +6668,7 @@ type AudioEncoder interface { // Queries encoder perfect timestamp behaviour. GetPerfectTimestamp() bool // GetTolerance wraps gst_audio_encoder_get_tolerance + // // The function returns the following values: // // - goret gst.ClockTime @@ -5908,6 +6693,7 @@ type AudioEncoder interface { // MT safe. MergeTags(*gst.TagList, gst.TagMergeMode) // Negotiate wraps gst_audio_encoder_negotiate + // // The function returns the following values: // // - goret bool @@ -6202,6 +6988,7 @@ func (enc *AudioEncoderInstance) FinishFrame(buffer *gst.Buffer, samples int) gs } // GetAllocator wraps gst_audio_encoder_get_allocator +// // The function returns the following values: // // - allocator gst.Allocator (nullable): the #GstAllocator @@ -6237,6 +7024,7 @@ func (enc *AudioEncoderInstance) GetAllocator() (gst.Allocator, gst.AllocationPa } // GetAudioInfo wraps gst_audio_encoder_get_audio_info +// // The function returns the following values: // // - goret *AudioInfo @@ -6257,6 +7045,7 @@ func (enc *AudioEncoderInstance) GetAudioInfo() *AudioInfo { } // GetDrainable wraps gst_audio_encoder_get_drainable +// // The function returns the following values: // // - goret bool @@ -6281,6 +7070,7 @@ func (enc *AudioEncoderInstance) GetDrainable() bool { } // GetFrameMax wraps gst_audio_encoder_get_frame_max +// // The function returns the following values: // // - goret int @@ -6301,6 +7091,7 @@ func (enc *AudioEncoderInstance) GetFrameMax() int { } // GetFrameSamplesMax wraps gst_audio_encoder_get_frame_samples_max +// // The function returns the following values: // // - goret int @@ -6321,6 +7112,7 @@ func (enc *AudioEncoderInstance) GetFrameSamplesMax() int { } // GetFrameSamplesMin wraps gst_audio_encoder_get_frame_samples_min +// // The function returns the following values: // // - goret int @@ -6341,6 +7133,7 @@ func (enc *AudioEncoderInstance) GetFrameSamplesMin() int { } // GetHardMin wraps gst_audio_encoder_get_hard_min +// // The function returns the following values: // // - goret bool @@ -6365,6 +7158,7 @@ func (enc *AudioEncoderInstance) GetHardMin() bool { } // GetHardResync wraps gst_audio_encoder_get_hard_resync +// // The function returns the following values: // // - goret bool @@ -6387,6 +7181,7 @@ func (enc *AudioEncoderInstance) GetHardResync() bool { } // GetLatency wraps gst_audio_encoder_get_latency +// // The function returns the following values: // // - min gst.ClockTime: a pointer to storage to hold minimum latency @@ -6414,6 +7209,7 @@ func (enc *AudioEncoderInstance) GetLatency() (gst.ClockTime, gst.ClockTime) { } // GetLookahead wraps gst_audio_encoder_get_lookahead +// // The function returns the following values: // // - goret int @@ -6434,6 +7230,7 @@ func (enc *AudioEncoderInstance) GetLookahead() int { } // GetMarkGranule wraps gst_audio_encoder_get_mark_granule +// // The function returns the following values: // // - goret bool @@ -6458,6 +7255,7 @@ func (enc *AudioEncoderInstance) GetMarkGranule() bool { } // GetPerfectTimestamp wraps gst_audio_encoder_get_perfect_timestamp +// // The function returns the following values: // // - goret bool @@ -6482,6 +7280,7 @@ func (enc *AudioEncoderInstance) GetPerfectTimestamp() bool { } // GetTolerance wraps gst_audio_encoder_get_tolerance +// // The function returns the following values: // // - goret gst.ClockTime @@ -6537,6 +7336,7 @@ func (enc *AudioEncoderInstance) MergeTags(tags *gst.TagList, mode gst.TagMergeM } // Negotiate wraps gst_audio_encoder_negotiate +// // The function returns the following values: // // - goret bool @@ -6918,6 +7718,205 @@ func (enc *AudioEncoderInstance) SetTolerance(tolerance gst.ClockTime) { runtime.KeepAlive(tolerance) } +// AudioEncoderOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type AudioEncoderOverrides[Instance AudioEncoder] struct { + // gst.ElementOverrides allows you to override virtual methods from the parent class gst.Element + gst.ElementOverrides[Instance] + + // Close allows you to override the implementation of the virtual method close. + // The function returns the following values: + // + // - goret bool + Close func(Instance) bool + // DecideAllocation allows you to override the implementation of the virtual method decide_allocation. + // The function takes the following parameters: + // + // - query *gst.Query + // + // The function returns the following values: + // + // - goret bool + DecideAllocation func(Instance, *gst.Query) bool + // Flush allows you to override the implementation of the virtual method flush. + Flush func(Instance) + // Getcaps allows you to override the implementation of the virtual method getcaps. + // The function takes the following parameters: + // + // - filter *gst.Caps + // + // The function returns the following values: + // + // - goret *gst.Caps + Getcaps func(Instance, *gst.Caps) *gst.Caps + // HandleFrame allows you to override the implementation of the virtual method handle_frame. + // The function takes the following parameters: + // + // - buffer *gst.Buffer + // + // The function returns the following values: + // + // - goret gst.FlowReturn + HandleFrame func(Instance, *gst.Buffer) gst.FlowReturn + // Negotiate allows you to override the implementation of the virtual method negotiate. + // The function returns the following values: + // + // - goret bool + Negotiate func(Instance) bool + // Open allows you to override the implementation of the virtual method open. + // The function returns the following values: + // + // - goret bool + Open func(Instance) bool + // ProposeAllocation allows you to override the implementation of the virtual method propose_allocation. + // The function takes the following parameters: + // + // - query *gst.Query + // + // The function returns the following values: + // + // - goret bool + ProposeAllocation func(Instance, *gst.Query) bool + // SetFormat allows you to override the implementation of the virtual method set_format. + // The function takes the following parameters: + // + // - info *AudioInfo + // + // The function returns the following values: + // + // - goret bool + SetFormat func(Instance, *AudioInfo) bool + // SinkEvent allows you to override the implementation of the virtual method sink_event. + // The function takes the following parameters: + // + // - event *gst.Event + // + // The function returns the following values: + // + // - goret bool + SinkEvent func(Instance, *gst.Event) bool + // SinkQuery allows you to override the implementation of the virtual method sink_query. + // The function takes the following parameters: + // + // - query *gst.Query + // + // The function returns the following values: + // + // - goret bool + SinkQuery func(Instance, *gst.Query) bool + // SrcEvent allows you to override the implementation of the virtual method src_event. + // The function takes the following parameters: + // + // - event *gst.Event + // + // The function returns the following values: + // + // - goret bool + SrcEvent func(Instance, *gst.Event) bool + // SrcQuery allows you to override the implementation of the virtual method src_query. + // The function takes the following parameters: + // + // - query *gst.Query + // + // The function returns the following values: + // + // - goret bool + SrcQuery func(Instance, *gst.Query) bool + // Start allows you to override the implementation of the virtual method start. + // The function returns the following values: + // + // - goret bool + Start func(Instance) bool + // Stop allows you to override the implementation of the virtual method stop. + // The function returns the following values: + // + // - goret bool + Stop func(Instance) bool + // TransformMeta allows you to override the implementation of the virtual method transform_meta. + // The function takes the following parameters: + // + // - outbuf *gst.Buffer + // - meta *gst.Meta + // - inbuf *gst.Buffer + // + // The function returns the following values: + // + // - goret bool + TransformMeta func(Instance, *gst.Buffer, *gst.Meta, *gst.Buffer) bool +} + +// UnsafeApplyAudioEncoderOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyAudioEncoderOverrides[Instance AudioEncoder](gclass unsafe.Pointer, overrides AudioEncoderOverrides[Instance]) { + gst.UnsafeApplyElementOverrides(gclass, overrides.ElementOverrides) + + pclass := (*C.GstAudioEncoderClass)(gclass) + + if overrides.Close != nil { + pclass.close = (*[0]byte)(C._gotk4_gstaudio1_AudioEncoder_close) + } + + if overrides.DecideAllocation != nil { + pclass.decide_allocation = (*[0]byte)(C._gotk4_gstaudio1_AudioEncoder_decide_allocation) + } + + if overrides.Flush != nil { + pclass.flush = (*[0]byte)(C._gotk4_gstaudio1_AudioEncoder_flush) + } + + if overrides.Getcaps != nil { + pclass.getcaps = (*[0]byte)(C._gotk4_gstaudio1_AudioEncoder_getcaps) + } + + if overrides.HandleFrame != nil { + pclass.handle_frame = (*[0]byte)(C._gotk4_gstaudio1_AudioEncoder_handle_frame) + } + + if overrides.Negotiate != nil { + pclass.negotiate = (*[0]byte)(C._gotk4_gstaudio1_AudioEncoder_negotiate) + } + + if overrides.Open != nil { + pclass.open = (*[0]byte)(C._gotk4_gstaudio1_AudioEncoder_open) + } + + if overrides.ProposeAllocation != nil { + pclass.propose_allocation = (*[0]byte)(C._gotk4_gstaudio1_AudioEncoder_propose_allocation) + } + + if overrides.SetFormat != nil { + pclass.set_format = (*[0]byte)(C._gotk4_gstaudio1_AudioEncoder_set_format) + } + + if overrides.SinkEvent != nil { + pclass.sink_event = (*[0]byte)(C._gotk4_gstaudio1_AudioEncoder_sink_event) + } + + if overrides.SinkQuery != nil { + pclass.sink_query = (*[0]byte)(C._gotk4_gstaudio1_AudioEncoder_sink_query) + } + + if overrides.SrcEvent != nil { + pclass.src_event = (*[0]byte)(C._gotk4_gstaudio1_AudioEncoder_src_event) + } + + if overrides.SrcQuery != nil { + pclass.src_query = (*[0]byte)(C._gotk4_gstaudio1_AudioEncoder_src_query) + } + + if overrides.Start != nil { + pclass.start = (*[0]byte)(C._gotk4_gstaudio1_AudioEncoder_start) + } + + if overrides.Stop != nil { + pclass.stop = (*[0]byte)(C._gotk4_gstaudio1_AudioEncoder_stop) + } + + if overrides.TransformMeta != nil { + pclass.transform_meta = (*[0]byte)(C._gotk4_gstaudio1_AudioEncoder_transform_meta) + } +} + // AudioFilterInstance is the instance type used by all types extending GstAudioFilter. It is used internally by the bindings. Users should use the interface [AudioFilter] instead. type AudioFilterInstance struct { _ [0]func() // equal guard @@ -6988,6 +7987,35 @@ func UnsafeAudioFilterToGlibFull(c AudioFilter) unsafe.Pointer { return gobject.UnsafeObjectToGlibFull(c) } +// AudioFilterOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type AudioFilterOverrides[Instance AudioFilter] struct { + // gstbase.BaseTransformOverrides allows you to override virtual methods from the parent class gstbase.BaseTransform + gstbase.BaseTransformOverrides[Instance] + + // Setup allows you to override the implementation of the virtual method setup. + // The function takes the following parameters: + // + // - info *AudioInfo + // + // The function returns the following values: + // + // - goret bool + Setup func(Instance, *AudioInfo) bool +} + +// UnsafeApplyAudioFilterOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyAudioFilterOverrides[Instance AudioFilter](gclass unsafe.Pointer, overrides AudioFilterOverrides[Instance]) { + gstbase.UnsafeApplyBaseTransformOverrides(gclass, overrides.BaseTransformOverrides) + + pclass := (*C.GstAudioFilterClass)(gclass) + + if overrides.Setup != nil { + pclass.setup = (*[0]byte)(C._gotk4_gstaudio1_AudioFilter_setup) + } +} + // AudioRingBufferInstance is the instance type used by all types extending GstAudioRingBuffer. It is used internally by the bindings. Users should use the interface [AudioRingBuffer] instead. type AudioRingBufferInstance struct { _ [0]func() // equal guard @@ -7067,6 +8095,7 @@ type AudioRingBuffer interface { // MT safe. ClearAll() // CloseDevice wraps gst_audio_ring_buffer_close_device + // // The function returns the following values: // // - goret bool @@ -7091,6 +8120,7 @@ type AudioRingBuffer interface { // will be put in @dest_val. Convert(gst.Format, int64, gst.Format) (int64, bool) // Delay wraps gst_audio_ring_buffer_delay + // // The function returns the following values: // // - goret uint @@ -7107,6 +8137,7 @@ type AudioRingBuffer interface { // not yet transferred to the ringbuffer. Delay() uint // DeviceIsOpen wraps gst_audio_ring_buffer_device_is_open + // // The function returns the following values: // // - goret bool @@ -7114,6 +8145,7 @@ type AudioRingBuffer interface { // Checks the status of the device associated with the ring buffer. DeviceIsOpen() bool // IsAcquired wraps gst_audio_ring_buffer_is_acquired + // // The function returns the following values: // // - goret bool @@ -7121,6 +8153,7 @@ type AudioRingBuffer interface { // Check if the ringbuffer is acquired and ready to use. IsAcquired() bool // IsActive wraps gst_audio_ring_buffer_is_active + // // The function returns the following values: // // - goret bool @@ -7130,6 +8163,7 @@ type AudioRingBuffer interface { // MT safe. IsActive() bool // IsFlushing wraps gst_audio_ring_buffer_is_flushing + // // The function returns the following values: // // - goret bool @@ -7150,6 +8184,7 @@ type AudioRingBuffer interface { // MT safe. MayStart(bool) // OpenDevice wraps gst_audio_ring_buffer_open_device + // // The function returns the following values: // // - goret bool @@ -7159,6 +8194,7 @@ type AudioRingBuffer interface { // buffer. OpenDevice() bool // Pause wraps gst_audio_ring_buffer_pause + // // The function returns the following values: // // - goret bool @@ -7188,6 +8224,7 @@ type AudioRingBuffer interface { // @timestamp will return the timestamp associated with the data returned. Read(uint64, []uint8) (gst.ClockTime, uint) // Release wraps gst_audio_ring_buffer_release + // // The function returns the following values: // // - goret bool @@ -7195,6 +8232,7 @@ type AudioRingBuffer interface { // Free the resources of the ringbuffer. Release() bool // SamplesDone wraps gst_audio_ring_buffer_samples_done + // // The function returns the following values: // // - goret uint64 @@ -7253,6 +8291,7 @@ type AudioRingBuffer interface { // - timestamp gst.ClockTime SetTimestamp(int, gst.ClockTime) // Start wraps gst_audio_ring_buffer_start + // // The function returns the following values: // // - goret bool @@ -7260,6 +8299,7 @@ type AudioRingBuffer interface { // Start processing samples from the ringbuffer. Start() bool // Stop wraps gst_audio_ring_buffer_stop + // // The function returns the following values: // // - goret bool @@ -7500,6 +8540,7 @@ func (buf *AudioRingBufferInstance) ClearAll() { } // CloseDevice wraps gst_audio_ring_buffer_close_device +// // The function returns the following values: // // - goret bool @@ -7570,6 +8611,7 @@ func (buf *AudioRingBufferInstance) Convert(srcFmt gst.Format, srcVal int64, des } // Delay wraps gst_audio_ring_buffer_delay +// // The function returns the following values: // // - goret uint @@ -7601,6 +8643,7 @@ func (buf *AudioRingBufferInstance) Delay() uint { } // DeviceIsOpen wraps gst_audio_ring_buffer_device_is_open +// // The function returns the following values: // // - goret bool @@ -7625,6 +8668,7 @@ func (buf *AudioRingBufferInstance) DeviceIsOpen() bool { } // IsAcquired wraps gst_audio_ring_buffer_is_acquired +// // The function returns the following values: // // - goret bool @@ -7649,6 +8693,7 @@ func (buf *AudioRingBufferInstance) IsAcquired() bool { } // IsActive wraps gst_audio_ring_buffer_is_active +// // The function returns the following values: // // - goret bool @@ -7675,6 +8720,7 @@ func (buf *AudioRingBufferInstance) IsActive() bool { } // IsFlushing wraps gst_audio_ring_buffer_is_flushing +// // The function returns the following values: // // - goret bool @@ -7725,6 +8771,7 @@ func (buf *AudioRingBufferInstance) MayStart(allowed bool) { } // OpenDevice wraps gst_audio_ring_buffer_open_device +// // The function returns the following values: // // - goret bool @@ -7751,6 +8798,7 @@ func (buf *AudioRingBufferInstance) OpenDevice() bool { } // Pause wraps gst_audio_ring_buffer_pause +// // The function returns the following values: // // - goret bool @@ -7825,6 +8873,7 @@ func (buf *AudioRingBufferInstance) Read(sample uint64, data []uint8) (gst.Clock } // Release wraps gst_audio_ring_buffer_release +// // The function returns the following values: // // - goret bool @@ -7849,6 +8898,7 @@ func (buf *AudioRingBufferInstance) Release() bool { } // SamplesDone wraps gst_audio_ring_buffer_samples_done +// // The function returns the following values: // // - goret uint64 @@ -7985,6 +9035,7 @@ func (buf *AudioRingBufferInstance) SetTimestamp(readseg int, timestamp gst.Cloc } // Start wraps gst_audio_ring_buffer_start +// // The function returns the following values: // // - goret bool @@ -8009,6 +9060,7 @@ func (buf *AudioRingBufferInstance) Start() bool { } // Stop wraps gst_audio_ring_buffer_stop +// // The function returns the following values: // // - goret bool @@ -8032,6 +9084,126 @@ func (buf *AudioRingBufferInstance) Stop() bool { return goret } +// AudioRingBufferOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type AudioRingBufferOverrides[Instance AudioRingBuffer] struct { + // gst.ObjectOverrides allows you to override virtual methods from the parent class gst.Object + gst.ObjectOverrides[Instance] + + // Acquire allows you to override the implementation of the virtual method acquire. + // The function takes the following parameters: + // + // - spec *AudioRingBufferSpec: the specs of the buffer + // + // The function returns the following values: + // + // - goret bool + Acquire func(Instance, *AudioRingBufferSpec) bool + // Activate allows you to override the implementation of the virtual method activate. + // The function takes the following parameters: + // + // - active bool: the new mode + // + // The function returns the following values: + // + // - goret bool + Activate func(Instance, bool) bool + // ClearAll allows you to override the implementation of the virtual method clear_all. + ClearAll func(Instance) + // CloseDevice allows you to override the implementation of the virtual method close_device. + // The function returns the following values: + // + // - goret bool + CloseDevice func(Instance) bool + // Delay allows you to override the implementation of the virtual method delay. + // The function returns the following values: + // + // - goret uint + Delay func(Instance) uint + // OpenDevice allows you to override the implementation of the virtual method open_device. + // The function returns the following values: + // + // - goret bool + OpenDevice func(Instance) bool + // Pause allows you to override the implementation of the virtual method pause. + // The function returns the following values: + // + // - goret bool + Pause func(Instance) bool + // Release allows you to override the implementation of the virtual method release. + // The function returns the following values: + // + // - goret bool + Release func(Instance) bool + // Resume allows you to override the implementation of the virtual method resume. + // The function returns the following values: + // + // - goret bool + Resume func(Instance) bool + // Start allows you to override the implementation of the virtual method start. + // The function returns the following values: + // + // - goret bool + Start func(Instance) bool + // Stop allows you to override the implementation of the virtual method stop. + // The function returns the following values: + // + // - goret bool + Stop func(Instance) bool +} + +// UnsafeApplyAudioRingBufferOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyAudioRingBufferOverrides[Instance AudioRingBuffer](gclass unsafe.Pointer, overrides AudioRingBufferOverrides[Instance]) { + gst.UnsafeApplyObjectOverrides(gclass, overrides.ObjectOverrides) + + pclass := (*C.GstAudioRingBufferClass)(gclass) + + if overrides.Acquire != nil { + pclass.acquire = (*[0]byte)(C._gotk4_gstaudio1_AudioRingBuffer_acquire) + } + + if overrides.Activate != nil { + pclass.activate = (*[0]byte)(C._gotk4_gstaudio1_AudioRingBuffer_activate) + } + + if overrides.ClearAll != nil { + pclass.clear_all = (*[0]byte)(C._gotk4_gstaudio1_AudioRingBuffer_clear_all) + } + + if overrides.CloseDevice != nil { + pclass.close_device = (*[0]byte)(C._gotk4_gstaudio1_AudioRingBuffer_close_device) + } + + if overrides.Delay != nil { + pclass.delay = (*[0]byte)(C._gotk4_gstaudio1_AudioRingBuffer_delay) + } + + if overrides.OpenDevice != nil { + pclass.open_device = (*[0]byte)(C._gotk4_gstaudio1_AudioRingBuffer_open_device) + } + + if overrides.Pause != nil { + pclass.pause = (*[0]byte)(C._gotk4_gstaudio1_AudioRingBuffer_pause) + } + + if overrides.Release != nil { + pclass.release = (*[0]byte)(C._gotk4_gstaudio1_AudioRingBuffer_release) + } + + if overrides.Resume != nil { + pclass.resume = (*[0]byte)(C._gotk4_gstaudio1_AudioRingBuffer_resume) + } + + if overrides.Start != nil { + pclass.start = (*[0]byte)(C._gotk4_gstaudio1_AudioRingBuffer_start) + } + + if overrides.Stop != nil { + pclass.stop = (*[0]byte)(C._gotk4_gstaudio1_AudioRingBuffer_stop) + } +} + // AudioSinkInstance is the instance type used by all types extending GstAudioSink. It is used internally by the bindings. Users should use the interface [AudioSink] instead. type AudioSinkInstance struct { _ [0]func() // equal guard @@ -8112,6 +9284,95 @@ func UnsafeAudioSinkToGlibFull(c AudioSink) unsafe.Pointer { return gobject.UnsafeObjectToGlibFull(c) } +// AudioSinkOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type AudioSinkOverrides[Instance AudioSink] struct { + // AudioBaseSinkOverrides allows you to override virtual methods from the parent class AudioBaseSink + AudioBaseSinkOverrides[Instance] + + // Close allows you to override the implementation of the virtual method close. + // The function returns the following values: + // + // - goret bool + Close func(Instance) bool + // Delay allows you to override the implementation of the virtual method delay. + // The function returns the following values: + // + // - goret uint + Delay func(Instance) uint + // Open allows you to override the implementation of the virtual method open. + // The function returns the following values: + // + // - goret bool + Open func(Instance) bool + // Pause allows you to override the implementation of the virtual method pause. + Pause func(Instance) + // Prepare allows you to override the implementation of the virtual method prepare. + // The function takes the following parameters: + // + // - spec *AudioRingBufferSpec + // + // The function returns the following values: + // + // - goret bool + Prepare func(Instance, *AudioRingBufferSpec) bool + // Reset allows you to override the implementation of the virtual method reset. + Reset func(Instance) + // Resume allows you to override the implementation of the virtual method resume. + Resume func(Instance) + // Stop allows you to override the implementation of the virtual method stop. + Stop func(Instance) + // Unprepare allows you to override the implementation of the virtual method unprepare. + // The function returns the following values: + // + // - goret bool + Unprepare func(Instance) bool +} + +// UnsafeApplyAudioSinkOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyAudioSinkOverrides[Instance AudioSink](gclass unsafe.Pointer, overrides AudioSinkOverrides[Instance]) { + UnsafeApplyAudioBaseSinkOverrides(gclass, overrides.AudioBaseSinkOverrides) + + pclass := (*C.GstAudioSinkClass)(gclass) + + if overrides.Close != nil { + pclass.close = (*[0]byte)(C._gotk4_gstaudio1_AudioSink_close) + } + + if overrides.Delay != nil { + pclass.delay = (*[0]byte)(C._gotk4_gstaudio1_AudioSink_delay) + } + + if overrides.Open != nil { + pclass.open = (*[0]byte)(C._gotk4_gstaudio1_AudioSink_open) + } + + if overrides.Pause != nil { + pclass.pause = (*[0]byte)(C._gotk4_gstaudio1_AudioSink_pause) + } + + if overrides.Prepare != nil { + pclass.prepare = (*[0]byte)(C._gotk4_gstaudio1_AudioSink_prepare) + } + + if overrides.Reset != nil { + pclass.reset = (*[0]byte)(C._gotk4_gstaudio1_AudioSink_reset) + } + + if overrides.Resume != nil { + pclass.resume = (*[0]byte)(C._gotk4_gstaudio1_AudioSink_resume) + } + + if overrides.Stop != nil { + pclass.stop = (*[0]byte)(C._gotk4_gstaudio1_AudioSink_stop) + } + + if overrides.Unprepare != nil { + pclass.unprepare = (*[0]byte)(C._gotk4_gstaudio1_AudioSink_unprepare) + } +} + // AudioSrcInstance is the instance type used by all types extending GstAudioSrc. It is used internally by the bindings. Users should use the interface [AudioSrc] instead. type AudioSrcInstance struct { _ [0]func() // equal guard @@ -8187,6 +9448,77 @@ func UnsafeAudioSrcToGlibFull(c AudioSrc) unsafe.Pointer { return gobject.UnsafeObjectToGlibFull(c) } +// AudioSrcOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type AudioSrcOverrides[Instance AudioSrc] struct { + // AudioBaseSrcOverrides allows you to override virtual methods from the parent class AudioBaseSrc + AudioBaseSrcOverrides[Instance] + + // Close allows you to override the implementation of the virtual method close. + // The function returns the following values: + // + // - goret bool + Close func(Instance) bool + // Delay allows you to override the implementation of the virtual method delay. + // The function returns the following values: + // + // - goret uint + Delay func(Instance) uint + // Open allows you to override the implementation of the virtual method open. + // The function returns the following values: + // + // - goret bool + Open func(Instance) bool + // Prepare allows you to override the implementation of the virtual method prepare. + // The function takes the following parameters: + // + // - spec *AudioRingBufferSpec + // + // The function returns the following values: + // + // - goret bool + Prepare func(Instance, *AudioRingBufferSpec) bool + // Reset allows you to override the implementation of the virtual method reset. + Reset func(Instance) + // Unprepare allows you to override the implementation of the virtual method unprepare. + // The function returns the following values: + // + // - goret bool + Unprepare func(Instance) bool +} + +// UnsafeApplyAudioSrcOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyAudioSrcOverrides[Instance AudioSrc](gclass unsafe.Pointer, overrides AudioSrcOverrides[Instance]) { + UnsafeApplyAudioBaseSrcOverrides(gclass, overrides.AudioBaseSrcOverrides) + + pclass := (*C.GstAudioSrcClass)(gclass) + + if overrides.Close != nil { + pclass.close = (*[0]byte)(C._gotk4_gstaudio1_AudioSrc_close) + } + + if overrides.Delay != nil { + pclass.delay = (*[0]byte)(C._gotk4_gstaudio1_AudioSrc_delay) + } + + if overrides.Open != nil { + pclass.open = (*[0]byte)(C._gotk4_gstaudio1_AudioSrc_open) + } + + if overrides.Prepare != nil { + pclass.prepare = (*[0]byte)(C._gotk4_gstaudio1_AudioSrc_prepare) + } + + if overrides.Reset != nil { + pclass.reset = (*[0]byte)(C._gotk4_gstaudio1_AudioSrc_reset) + } + + if overrides.Unprepare != nil { + pclass.unprepare = (*[0]byte)(C._gotk4_gstaudio1_AudioSrc_unprepare) + } +} + // AudioAggregatorConvertPadInstance is the instance type used by all types extending GstAudioAggregatorConvertPad. It is used internally by the bindings. Users should use the interface [AudioAggregatorConvertPad] instead. type AudioAggregatorConvertPadInstance struct { _ [0]func() // equal guard @@ -8249,7 +9581,23 @@ func UnsafeAudioAggregatorConvertPadToGlibFull(c AudioAggregatorConvertPad) unsa return gobject.UnsafeObjectToGlibFull(c) } +// AudioAggregatorConvertPadOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type AudioAggregatorConvertPadOverrides[Instance AudioAggregatorConvertPad] struct { + // AudioAggregatorPadOverrides allows you to override virtual methods from the parent class AudioAggregatorPad + AudioAggregatorPadOverrides[Instance] + +} + +// UnsafeApplyAudioAggregatorConvertPadOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyAudioAggregatorConvertPadOverrides[Instance AudioAggregatorConvertPad](gclass unsafe.Pointer, overrides AudioAggregatorConvertPadOverrides[Instance]) { + UnsafeApplyAudioAggregatorPadOverrides(gclass, overrides.AudioAggregatorPadOverrides) +} + // AudioAggregatorClass wraps GstAudioAggregatorClass +// +// AudioAggregatorClass is the type struct for [AudioAggregator] type AudioAggregatorClass struct { *audioAggregatorClass } @@ -8264,31 +9612,6 @@ func UnsafeAudioAggregatorClassFromGlibBorrow(p unsafe.Pointer) *AudioAggregator return &AudioAggregatorClass{&audioAggregatorClass{(*C.GstAudioAggregatorClass)(p)}} } -// UnsafeAudioAggregatorClassFromGlibNone is used to convert raw C.GstAudioAggregatorClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeAudioAggregatorClassFromGlibNone(p unsafe.Pointer) *AudioAggregatorClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeAudioAggregatorClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.audioAggregatorClass, - func (intern *audioAggregatorClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeAudioAggregatorClassFromGlibFull is used to convert raw C.GstAudioAggregatorClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeAudioAggregatorClassFromGlibFull(p unsafe.Pointer) *AudioAggregatorClass { - wrapped := UnsafeAudioAggregatorClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.audioAggregatorClass, - func (intern *audioAggregatorClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeAudioAggregatorClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [AudioAggregatorClass] is expected to work anymore. @@ -8301,15 +9624,18 @@ func UnsafeAudioAggregatorClassToGlibNone(a *AudioAggregatorClass) unsafe.Pointe return unsafe.Pointer(a.native) } -// UnsafeAudioAggregatorClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeAudioAggregatorClassToGlibFull(a *AudioAggregatorClass) unsafe.Pointer { - runtime.SetFinalizer(a.audioAggregatorClass, nil) - _p := unsafe.Pointer(a.native) - a.native = nil // AudioAggregatorClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (a *AudioAggregatorClass) ParentClass() *gstbase.AggregatorClass { + parent := gstbase.UnsafeAggregatorClassFromGlibBorrow(UnsafeAudioAggregatorClassToGlibNone(a)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *AudioAggregatorClass) {}, a) + return parent } + // AudioAggregatorConvertPadClass wraps GstAudioAggregatorConvertPadClass +// +// AudioAggregatorConvertPadClass is the type struct for [AudioAggregatorConvertPad] type AudioAggregatorConvertPadClass struct { *audioAggregatorConvertPadClass } @@ -8324,31 +9650,6 @@ func UnsafeAudioAggregatorConvertPadClassFromGlibBorrow(p unsafe.Pointer) *Audio return &AudioAggregatorConvertPadClass{&audioAggregatorConvertPadClass{(*C.GstAudioAggregatorConvertPadClass)(p)}} } -// UnsafeAudioAggregatorConvertPadClassFromGlibNone is used to convert raw C.GstAudioAggregatorConvertPadClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeAudioAggregatorConvertPadClassFromGlibNone(p unsafe.Pointer) *AudioAggregatorConvertPadClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeAudioAggregatorConvertPadClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.audioAggregatorConvertPadClass, - func (intern *audioAggregatorConvertPadClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeAudioAggregatorConvertPadClassFromGlibFull is used to convert raw C.GstAudioAggregatorConvertPadClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeAudioAggregatorConvertPadClassFromGlibFull(p unsafe.Pointer) *AudioAggregatorConvertPadClass { - wrapped := UnsafeAudioAggregatorConvertPadClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.audioAggregatorConvertPadClass, - func (intern *audioAggregatorConvertPadClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeAudioAggregatorConvertPadClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [AudioAggregatorConvertPadClass] is expected to work anymore. @@ -8361,15 +9662,18 @@ func UnsafeAudioAggregatorConvertPadClassToGlibNone(a *AudioAggregatorConvertPad return unsafe.Pointer(a.native) } -// UnsafeAudioAggregatorConvertPadClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeAudioAggregatorConvertPadClassToGlibFull(a *AudioAggregatorConvertPadClass) unsafe.Pointer { - runtime.SetFinalizer(a.audioAggregatorConvertPadClass, nil) - _p := unsafe.Pointer(a.native) - a.native = nil // AudioAggregatorConvertPadClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (a *AudioAggregatorConvertPadClass) ParentClass() *AudioAggregatorPadClass { + parent := UnsafeAudioAggregatorPadClassFromGlibBorrow(UnsafeAudioAggregatorConvertPadClassToGlibNone(a)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *AudioAggregatorConvertPadClass) {}, a) + return parent } + // AudioAggregatorPadClass wraps GstAudioAggregatorPadClass +// +// AudioAggregatorPadClass is the type struct for [AudioAggregatorPad] type AudioAggregatorPadClass struct { *audioAggregatorPadClass } @@ -8384,31 +9688,6 @@ func UnsafeAudioAggregatorPadClassFromGlibBorrow(p unsafe.Pointer) *AudioAggrega return &AudioAggregatorPadClass{&audioAggregatorPadClass{(*C.GstAudioAggregatorPadClass)(p)}} } -// UnsafeAudioAggregatorPadClassFromGlibNone is used to convert raw C.GstAudioAggregatorPadClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeAudioAggregatorPadClassFromGlibNone(p unsafe.Pointer) *AudioAggregatorPadClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeAudioAggregatorPadClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.audioAggregatorPadClass, - func (intern *audioAggregatorPadClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeAudioAggregatorPadClassFromGlibFull is used to convert raw C.GstAudioAggregatorPadClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeAudioAggregatorPadClassFromGlibFull(p unsafe.Pointer) *AudioAggregatorPadClass { - wrapped := UnsafeAudioAggregatorPadClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.audioAggregatorPadClass, - func (intern *audioAggregatorPadClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeAudioAggregatorPadClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [AudioAggregatorPadClass] is expected to work anymore. @@ -8421,18 +9700,21 @@ func UnsafeAudioAggregatorPadClassToGlibNone(a *AudioAggregatorPadClass) unsafe. return unsafe.Pointer(a.native) } -// UnsafeAudioAggregatorPadClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeAudioAggregatorPadClassToGlibFull(a *AudioAggregatorPadClass) unsafe.Pointer { - runtime.SetFinalizer(a.audioAggregatorPadClass, nil) - _p := unsafe.Pointer(a.native) - a.native = nil // AudioAggregatorPadClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (a *AudioAggregatorPadClass) ParentClass() *gstbase.AggregatorPadClass { + parent := gstbase.UnsafeAggregatorPadClassFromGlibBorrow(UnsafeAudioAggregatorPadClassToGlibNone(a)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *AudioAggregatorPadClass) {}, a) + return parent } + // AudioBaseSinkClass wraps GstAudioBaseSinkClass // // #GstAudioBaseSink class. Override the vmethod to implement // functionality. +// +// AudioBaseSinkClass is the type struct for [AudioBaseSink] type AudioBaseSinkClass struct { *audioBaseSinkClass } @@ -8447,31 +9729,6 @@ func UnsafeAudioBaseSinkClassFromGlibBorrow(p unsafe.Pointer) *AudioBaseSinkClas return &AudioBaseSinkClass{&audioBaseSinkClass{(*C.GstAudioBaseSinkClass)(p)}} } -// UnsafeAudioBaseSinkClassFromGlibNone is used to convert raw C.GstAudioBaseSinkClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeAudioBaseSinkClassFromGlibNone(p unsafe.Pointer) *AudioBaseSinkClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeAudioBaseSinkClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.audioBaseSinkClass, - func (intern *audioBaseSinkClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeAudioBaseSinkClassFromGlibFull is used to convert raw C.GstAudioBaseSinkClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeAudioBaseSinkClassFromGlibFull(p unsafe.Pointer) *AudioBaseSinkClass { - wrapped := UnsafeAudioBaseSinkClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.audioBaseSinkClass, - func (intern *audioBaseSinkClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeAudioBaseSinkClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [AudioBaseSinkClass] is expected to work anymore. @@ -8484,18 +9741,21 @@ func UnsafeAudioBaseSinkClassToGlibNone(a *AudioBaseSinkClass) unsafe.Pointer { return unsafe.Pointer(a.native) } -// UnsafeAudioBaseSinkClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeAudioBaseSinkClassToGlibFull(a *AudioBaseSinkClass) unsafe.Pointer { - runtime.SetFinalizer(a.audioBaseSinkClass, nil) - _p := unsafe.Pointer(a.native) - a.native = nil // AudioBaseSinkClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (a *AudioBaseSinkClass) ParentClass() *gstbase.BaseSinkClass { + parent := gstbase.UnsafeBaseSinkClassFromGlibBorrow(UnsafeAudioBaseSinkClassToGlibNone(a)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *AudioBaseSinkClass) {}, a) + return parent } + // AudioBaseSrcClass wraps GstAudioBaseSrcClass // // #GstAudioBaseSrc class. Override the vmethod to implement // functionality. +// +// AudioBaseSrcClass is the type struct for [AudioBaseSrc] type AudioBaseSrcClass struct { *audioBaseSrcClass } @@ -8510,31 +9770,6 @@ func UnsafeAudioBaseSrcClassFromGlibBorrow(p unsafe.Pointer) *AudioBaseSrcClass return &AudioBaseSrcClass{&audioBaseSrcClass{(*C.GstAudioBaseSrcClass)(p)}} } -// UnsafeAudioBaseSrcClassFromGlibNone is used to convert raw C.GstAudioBaseSrcClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeAudioBaseSrcClassFromGlibNone(p unsafe.Pointer) *AudioBaseSrcClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeAudioBaseSrcClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.audioBaseSrcClass, - func (intern *audioBaseSrcClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeAudioBaseSrcClassFromGlibFull is used to convert raw C.GstAudioBaseSrcClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeAudioBaseSrcClassFromGlibFull(p unsafe.Pointer) *AudioBaseSrcClass { - wrapped := UnsafeAudioBaseSrcClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.audioBaseSrcClass, - func (intern *audioBaseSrcClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeAudioBaseSrcClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [AudioBaseSrcClass] is expected to work anymore. @@ -8547,14 +9782,15 @@ func UnsafeAudioBaseSrcClassToGlibNone(a *AudioBaseSrcClass) unsafe.Pointer { return unsafe.Pointer(a.native) } -// UnsafeAudioBaseSrcClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeAudioBaseSrcClassToGlibFull(a *AudioBaseSrcClass) unsafe.Pointer { - runtime.SetFinalizer(a.audioBaseSrcClass, nil) - _p := unsafe.Pointer(a.native) - a.native = nil // AudioBaseSrcClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (a *AudioBaseSrcClass) ParentClass() *gstbase.PushSrcClass { + parent := gstbase.UnsafePushSrcClassFromGlibBorrow(UnsafeAudioBaseSrcClassToGlibNone(a)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *AudioBaseSrcClass) {}, a) + return parent } + // AudioBuffer wraps GstAudioBuffer // // A structure containing the result of an audio buffer map operation, @@ -8579,7 +9815,7 @@ func UnsafeAudioBufferFromGlibBorrow(p unsafe.Pointer) *AudioBuffer { return &AudioBuffer{&audioBuffer{(*C.GstAudioBuffer)(p)}} } -// UnsafeAudioBufferFromGlibNone is used to convert raw C.GstAudioBuffer pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeAudioBufferFromGlibNone is used to convert raw C.GstAudioBuffer pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeAudioBufferFromGlibNone(p unsafe.Pointer) *AudioBuffer { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeAudioBufferFromGlibBorrow(p) @@ -8592,7 +9828,7 @@ func UnsafeAudioBufferFromGlibNone(p unsafe.Pointer) *AudioBuffer { return wrapped } -// UnsafeAudioBufferFromGlibFull is used to convert raw C.GstAudioBuffer pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeAudioBufferFromGlibFull is used to convert raw C.GstAudioBuffer pointers to go while taking ownership. This is used by the bindings internally. func UnsafeAudioBufferFromGlibFull(p unsafe.Pointer) *AudioBuffer { wrapped := UnsafeAudioBufferFromGlibBorrow(p) runtime.SetFinalizer( @@ -8624,6 +9860,7 @@ func UnsafeAudioBufferToGlibFull(a *AudioBuffer) unsafe.Pointer { a.native = nil // AudioBuffer is invalid from here on return _p } + // AudioBufferClip wraps gst_audio_buffer_clip // // The function takes the following parameters: @@ -8856,6 +10093,8 @@ func (buffer *AudioBuffer) Unmap() { // AudioCdSrcClass wraps GstAudioCdSrcClass // // Audio CD source base class. +// +// AudioCdSrcClass is the type struct for [AudioCdSrc] type AudioCdSrcClass struct { *audioCdSrcClass } @@ -8870,31 +10109,6 @@ func UnsafeAudioCdSrcClassFromGlibBorrow(p unsafe.Pointer) *AudioCdSrcClass { return &AudioCdSrcClass{&audioCdSrcClass{(*C.GstAudioCdSrcClass)(p)}} } -// UnsafeAudioCdSrcClassFromGlibNone is used to convert raw C.GstAudioCdSrcClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeAudioCdSrcClassFromGlibNone(p unsafe.Pointer) *AudioCdSrcClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeAudioCdSrcClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.audioCdSrcClass, - func (intern *audioCdSrcClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeAudioCdSrcClassFromGlibFull is used to convert raw C.GstAudioCdSrcClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeAudioCdSrcClassFromGlibFull(p unsafe.Pointer) *AudioCdSrcClass { - wrapped := UnsafeAudioCdSrcClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.audioCdSrcClass, - func (intern *audioCdSrcClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeAudioCdSrcClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [AudioCdSrcClass] is expected to work anymore. @@ -8907,14 +10121,15 @@ func UnsafeAudioCdSrcClassToGlibNone(a *AudioCdSrcClass) unsafe.Pointer { return unsafe.Pointer(a.native) } -// UnsafeAudioCdSrcClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeAudioCdSrcClassToGlibFull(a *AudioCdSrcClass) unsafe.Pointer { - runtime.SetFinalizer(a.audioCdSrcClass, nil) - _p := unsafe.Pointer(a.native) - a.native = nil // AudioCdSrcClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (a *AudioCdSrcClass) ParentClass() *gstbase.PushSrcClass { + parent := gstbase.UnsafePushSrcClassFromGlibBorrow(UnsafeAudioCdSrcClassToGlibNone(a)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *AudioCdSrcClass) {}, a) + return parent } + // AudioCdSrcTrack wraps GstAudioCdSrcTrack // // CD track abstraction to communicate TOC entries to the base class. @@ -8938,7 +10153,7 @@ func UnsafeAudioCdSrcTrackFromGlibBorrow(p unsafe.Pointer) *AudioCdSrcTrack { return &AudioCdSrcTrack{&audioCdSrcTrack{(*C.GstAudioCdSrcTrack)(p)}} } -// UnsafeAudioCdSrcTrackFromGlibNone is used to convert raw C.GstAudioCdSrcTrack pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeAudioCdSrcTrackFromGlibNone is used to convert raw C.GstAudioCdSrcTrack pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeAudioCdSrcTrackFromGlibNone(p unsafe.Pointer) *AudioCdSrcTrack { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeAudioCdSrcTrackFromGlibBorrow(p) @@ -8951,7 +10166,7 @@ func UnsafeAudioCdSrcTrackFromGlibNone(p unsafe.Pointer) *AudioCdSrcTrack { return wrapped } -// UnsafeAudioCdSrcTrackFromGlibFull is used to convert raw C.GstAudioCdSrcTrack pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeAudioCdSrcTrackFromGlibFull is used to convert raw C.GstAudioCdSrcTrack pointers to go while taking ownership. This is used by the bindings internally. func UnsafeAudioCdSrcTrackFromGlibFull(p unsafe.Pointer) *AudioCdSrcTrack { wrapped := UnsafeAudioCdSrcTrackFromGlibBorrow(p) runtime.SetFinalizer( @@ -8983,6 +10198,7 @@ func UnsafeAudioCdSrcTrackToGlibFull(a *AudioCdSrcTrack) unsafe.Pointer { a.native = nil // AudioCdSrcTrack is invalid from here on return _p } + // AudioChannelMixer wraps GstAudioChannelMixer type AudioChannelMixer struct { *audioChannelMixer @@ -8998,7 +10214,7 @@ func UnsafeAudioChannelMixerFromGlibBorrow(p unsafe.Pointer) *AudioChannelMixer return &AudioChannelMixer{&audioChannelMixer{(*C.GstAudioChannelMixer)(p)}} } -// UnsafeAudioChannelMixerFromGlibNone is used to convert raw C.GstAudioChannelMixer pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeAudioChannelMixerFromGlibNone is used to convert raw C.GstAudioChannelMixer pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeAudioChannelMixerFromGlibNone(p unsafe.Pointer) *AudioChannelMixer { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeAudioChannelMixerFromGlibBorrow(p) @@ -9011,7 +10227,7 @@ func UnsafeAudioChannelMixerFromGlibNone(p unsafe.Pointer) *AudioChannelMixer { return wrapped } -// UnsafeAudioChannelMixerFromGlibFull is used to convert raw C.GstAudioChannelMixer pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeAudioChannelMixerFromGlibFull is used to convert raw C.GstAudioChannelMixer pointers to go while taking ownership. This is used by the bindings internally. func UnsafeAudioChannelMixerFromGlibFull(p unsafe.Pointer) *AudioChannelMixer { wrapped := UnsafeAudioChannelMixerFromGlibBorrow(p) runtime.SetFinalizer( @@ -9043,7 +10259,9 @@ func UnsafeAudioChannelMixerToGlibFull(a *AudioChannelMixer) unsafe.Pointer { a.native = nil // AudioChannelMixer is invalid from here on return _p } + // IsPassthrough wraps gst_audio_channel_mixer_is_passthrough +// // The function returns the following values: // // - goret bool @@ -9104,7 +10322,7 @@ func UnsafeAudioClippingMetaFromGlibBorrow(p unsafe.Pointer) *AudioClippingMeta return &AudioClippingMeta{&audioClippingMeta{(*C.GstAudioClippingMeta)(p)}} } -// UnsafeAudioClippingMetaFromGlibNone is used to convert raw C.GstAudioClippingMeta pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeAudioClippingMetaFromGlibNone is used to convert raw C.GstAudioClippingMeta pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeAudioClippingMetaFromGlibNone(p unsafe.Pointer) *AudioClippingMeta { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeAudioClippingMetaFromGlibBorrow(p) @@ -9117,7 +10335,7 @@ func UnsafeAudioClippingMetaFromGlibNone(p unsafe.Pointer) *AudioClippingMeta { return wrapped } -// UnsafeAudioClippingMetaFromGlibFull is used to convert raw C.GstAudioClippingMeta pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeAudioClippingMetaFromGlibFull is used to convert raw C.GstAudioClippingMeta pointers to go while taking ownership. This is used by the bindings internally. func UnsafeAudioClippingMetaFromGlibFull(p unsafe.Pointer) *AudioClippingMeta { wrapped := UnsafeAudioClippingMetaFromGlibBorrow(p) runtime.SetFinalizer( @@ -9149,7 +10367,9 @@ func UnsafeAudioClippingMetaToGlibFull(a *AudioClippingMeta) unsafe.Pointer { a.native = nil // AudioClippingMeta is invalid from here on return _p } + // AudioClippingMetaGetInfo wraps gst_audio_clipping_meta_get_info +// // The function returns the following values: // // - goret *gst.MetaInfo @@ -9166,6 +10386,8 @@ func AudioClippingMetaGetInfo() *gst.MetaInfo { } // AudioClockClass wraps GstAudioClockClass +// +// AudioClockClass is the type struct for [AudioClock] type AudioClockClass struct { *audioClockClass } @@ -9180,31 +10402,6 @@ func UnsafeAudioClockClassFromGlibBorrow(p unsafe.Pointer) *AudioClockClass { return &AudioClockClass{&audioClockClass{(*C.GstAudioClockClass)(p)}} } -// UnsafeAudioClockClassFromGlibNone is used to convert raw C.GstAudioClockClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeAudioClockClassFromGlibNone(p unsafe.Pointer) *AudioClockClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeAudioClockClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.audioClockClass, - func (intern *audioClockClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeAudioClockClassFromGlibFull is used to convert raw C.GstAudioClockClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeAudioClockClassFromGlibFull(p unsafe.Pointer) *AudioClockClass { - wrapped := UnsafeAudioClockClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.audioClockClass, - func (intern *audioClockClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeAudioClockClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [AudioClockClass] is expected to work anymore. @@ -9217,14 +10414,15 @@ func UnsafeAudioClockClassToGlibNone(a *AudioClockClass) unsafe.Pointer { return unsafe.Pointer(a.native) } -// UnsafeAudioClockClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeAudioClockClassToGlibFull(a *AudioClockClass) unsafe.Pointer { - runtime.SetFinalizer(a.audioClockClass, nil) - _p := unsafe.Pointer(a.native) - a.native = nil // AudioClockClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (a *AudioClockClass) ParentClass() *gst.SystemClockClass { + parent := gst.UnsafeSystemClockClassFromGlibBorrow(UnsafeAudioClockClassToGlibNone(a)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *AudioClockClass) {}, a) + return parent } + // AudioConverter wraps GstAudioConverter // // This object is used to convert audio samples from one format to another. @@ -9261,7 +10459,7 @@ func UnsafeAudioConverterFromGlibBorrow(p unsafe.Pointer) *AudioConverter { return &AudioConverter{&audioConverter{(*C.GstAudioConverter)(p)}} } -// UnsafeAudioConverterFromGlibNone is used to convert raw C.GstAudioConverter pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeAudioConverterFromGlibNone is used to convert raw C.GstAudioConverter pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeAudioConverterFromGlibNone(p unsafe.Pointer) *AudioConverter { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeAudioConverterFromGlibBorrow(p) @@ -9274,7 +10472,7 @@ func UnsafeAudioConverterFromGlibNone(p unsafe.Pointer) *AudioConverter { return wrapped } -// UnsafeAudioConverterFromGlibFull is used to convert raw C.GstAudioConverter pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeAudioConverterFromGlibFull is used to convert raw C.GstAudioConverter pointers to go while taking ownership. This is used by the bindings internally. func UnsafeAudioConverterFromGlibFull(p unsafe.Pointer) *AudioConverter { wrapped := UnsafeAudioConverterFromGlibBorrow(p) runtime.SetFinalizer( @@ -9306,6 +10504,7 @@ func UnsafeAudioConverterToGlibFull(a *AudioConverter) unsafe.Pointer { a.native = nil // AudioConverter is invalid from here on return _p } + // NewAudioConverter wraps gst_audio_converter_new // // The function takes the following parameters: @@ -9354,6 +10553,7 @@ func NewAudioConverter(flags AudioConverterFlags, inInfo *AudioInfo, outInfo *Au } // GetConfig wraps gst_audio_converter_get_config +// // The function returns the following values: // // - inRate int: result input rate @@ -9415,6 +10615,7 @@ func (convert *AudioConverter) GetInFrames(outFrames uint) uint { } // GetMaxLatency wraps gst_audio_converter_get_max_latency +// // The function returns the following values: // // - goret uint @@ -9469,6 +10670,7 @@ func (convert *AudioConverter) GetOutFrames(inFrames uint) uint { } // IsPassthrough wraps gst_audio_converter_is_passthrough +// // The function returns the following values: // // - goret bool @@ -9507,6 +10709,7 @@ func (convert *AudioConverter) Reset() { } // SupportsInplace wraps gst_audio_converter_supports_inplace +// // The function returns the following values: // // - goret bool @@ -9591,6 +10794,8 @@ func (convert *AudioConverter) UpdateConfig(inRate int, outRate int, config *gst // Subclasses can override any of the available virtual methods or not, as // needed. At minimum @handle_frame (and likely @set_format) needs to be // overridden. +// +// AudioDecoderClass is the type struct for [AudioDecoder] type AudioDecoderClass struct { *audioDecoderClass } @@ -9605,31 +10810,6 @@ func UnsafeAudioDecoderClassFromGlibBorrow(p unsafe.Pointer) *AudioDecoderClass return &AudioDecoderClass{&audioDecoderClass{(*C.GstAudioDecoderClass)(p)}} } -// UnsafeAudioDecoderClassFromGlibNone is used to convert raw C.GstAudioDecoderClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeAudioDecoderClassFromGlibNone(p unsafe.Pointer) *AudioDecoderClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeAudioDecoderClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.audioDecoderClass, - func (intern *audioDecoderClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeAudioDecoderClassFromGlibFull is used to convert raw C.GstAudioDecoderClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeAudioDecoderClassFromGlibFull(p unsafe.Pointer) *AudioDecoderClass { - wrapped := UnsafeAudioDecoderClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.audioDecoderClass, - func (intern *audioDecoderClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeAudioDecoderClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [AudioDecoderClass] is expected to work anymore. @@ -9642,14 +10822,15 @@ func UnsafeAudioDecoderClassToGlibNone(a *AudioDecoderClass) unsafe.Pointer { return unsafe.Pointer(a.native) } -// UnsafeAudioDecoderClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeAudioDecoderClassToGlibFull(a *AudioDecoderClass) unsafe.Pointer { - runtime.SetFinalizer(a.audioDecoderClass, nil) - _p := unsafe.Pointer(a.native) - a.native = nil // AudioDecoderClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (a *AudioDecoderClass) ParentClass() *gst.ElementClass { + parent := gst.UnsafeElementClassFromGlibBorrow(UnsafeAudioDecoderClassToGlibNone(a)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *AudioDecoderClass) {}, a) + return parent } + // AudioDownmixMeta wraps GstAudioDownmixMeta // // Extra buffer metadata describing audio downmixing matrix. This metadata is @@ -9674,7 +10855,7 @@ func UnsafeAudioDownmixMetaFromGlibBorrow(p unsafe.Pointer) *AudioDownmixMeta { return &AudioDownmixMeta{&audioDownmixMeta{(*C.GstAudioDownmixMeta)(p)}} } -// UnsafeAudioDownmixMetaFromGlibNone is used to convert raw C.GstAudioDownmixMeta pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeAudioDownmixMetaFromGlibNone is used to convert raw C.GstAudioDownmixMeta pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeAudioDownmixMetaFromGlibNone(p unsafe.Pointer) *AudioDownmixMeta { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeAudioDownmixMetaFromGlibBorrow(p) @@ -9687,7 +10868,7 @@ func UnsafeAudioDownmixMetaFromGlibNone(p unsafe.Pointer) *AudioDownmixMeta { return wrapped } -// UnsafeAudioDownmixMetaFromGlibFull is used to convert raw C.GstAudioDownmixMeta pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeAudioDownmixMetaFromGlibFull is used to convert raw C.GstAudioDownmixMeta pointers to go while taking ownership. This is used by the bindings internally. func UnsafeAudioDownmixMetaFromGlibFull(p unsafe.Pointer) *AudioDownmixMeta { wrapped := UnsafeAudioDownmixMetaFromGlibBorrow(p) runtime.SetFinalizer( @@ -9719,7 +10900,9 @@ func UnsafeAudioDownmixMetaToGlibFull(a *AudioDownmixMeta) unsafe.Pointer { a.native = nil // AudioDownmixMeta is invalid from here on return _p } + // AudioDownmixMetaGetInfo wraps gst_audio_downmix_meta_get_info +// // The function returns the following values: // // - goret *gst.MetaInfo @@ -9739,6 +10922,8 @@ func AudioDownmixMetaGetInfo() *gst.MetaInfo { // // Subclasses can override any of the available virtual methods or not, as // needed. At minimum @set_format and @handle_frame needs to be overridden. +// +// AudioEncoderClass is the type struct for [AudioEncoder] type AudioEncoderClass struct { *audioEncoderClass } @@ -9753,31 +10938,6 @@ func UnsafeAudioEncoderClassFromGlibBorrow(p unsafe.Pointer) *AudioEncoderClass return &AudioEncoderClass{&audioEncoderClass{(*C.GstAudioEncoderClass)(p)}} } -// UnsafeAudioEncoderClassFromGlibNone is used to convert raw C.GstAudioEncoderClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeAudioEncoderClassFromGlibNone(p unsafe.Pointer) *AudioEncoderClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeAudioEncoderClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.audioEncoderClass, - func (intern *audioEncoderClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeAudioEncoderClassFromGlibFull is used to convert raw C.GstAudioEncoderClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeAudioEncoderClassFromGlibFull(p unsafe.Pointer) *AudioEncoderClass { - wrapped := UnsafeAudioEncoderClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.audioEncoderClass, - func (intern *audioEncoderClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeAudioEncoderClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [AudioEncoderClass] is expected to work anymore. @@ -9790,19 +10950,22 @@ func UnsafeAudioEncoderClassToGlibNone(a *AudioEncoderClass) unsafe.Pointer { return unsafe.Pointer(a.native) } -// UnsafeAudioEncoderClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeAudioEncoderClassToGlibFull(a *AudioEncoderClass) unsafe.Pointer { - runtime.SetFinalizer(a.audioEncoderClass, nil) - _p := unsafe.Pointer(a.native) - a.native = nil // AudioEncoderClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (a *AudioEncoderClass) ParentClass() *gst.ElementClass { + parent := gst.UnsafeElementClassFromGlibBorrow(UnsafeAudioEncoderClassToGlibNone(a)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *AudioEncoderClass) {}, a) + return parent } + // AudioFilterClass wraps GstAudioFilterClass // // In addition to the @setup virtual function, you should also override the // GstBaseTransform::transform and/or GstBaseTransform::transform_ip virtual // function. +// +// AudioFilterClass is the type struct for [AudioFilter] type AudioFilterClass struct { *audioFilterClass } @@ -9817,31 +10980,6 @@ func UnsafeAudioFilterClassFromGlibBorrow(p unsafe.Pointer) *AudioFilterClass { return &AudioFilterClass{&audioFilterClass{(*C.GstAudioFilterClass)(p)}} } -// UnsafeAudioFilterClassFromGlibNone is used to convert raw C.GstAudioFilterClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeAudioFilterClassFromGlibNone(p unsafe.Pointer) *AudioFilterClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeAudioFilterClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.audioFilterClass, - func (intern *audioFilterClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeAudioFilterClassFromGlibFull is used to convert raw C.GstAudioFilterClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeAudioFilterClassFromGlibFull(p unsafe.Pointer) *AudioFilterClass { - wrapped := UnsafeAudioFilterClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.audioFilterClass, - func (intern *audioFilterClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeAudioFilterClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [AudioFilterClass] is expected to work anymore. @@ -9854,14 +10992,15 @@ func UnsafeAudioFilterClassToGlibNone(a *AudioFilterClass) unsafe.Pointer { return unsafe.Pointer(a.native) } -// UnsafeAudioFilterClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeAudioFilterClassToGlibFull(a *AudioFilterClass) unsafe.Pointer { - runtime.SetFinalizer(a.audioFilterClass, nil) - _p := unsafe.Pointer(a.native) - a.native = nil // AudioFilterClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (a *AudioFilterClass) ParentClass() *gstbase.BaseTransformClass { + parent := gstbase.UnsafeBaseTransformClassFromGlibBorrow(UnsafeAudioFilterClassToGlibNone(a)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *AudioFilterClass) {}, a) + return parent } + // AddPadTemplates wraps gst_audio_filter_class_add_pad_templates // // The function takes the following parameters: @@ -9913,7 +11052,7 @@ func UnsafeAudioFormatInfoFromGlibBorrow(p unsafe.Pointer) *AudioFormatInfo { return &AudioFormatInfo{&audioFormatInfo{(*C.GstAudioFormatInfo)(p)}} } -// UnsafeAudioFormatInfoFromGlibNone is used to convert raw C.GstAudioFormatInfo pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeAudioFormatInfoFromGlibNone is used to convert raw C.GstAudioFormatInfo pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeAudioFormatInfoFromGlibNone(p unsafe.Pointer) *AudioFormatInfo { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeAudioFormatInfoFromGlibBorrow(p) @@ -9926,7 +11065,7 @@ func UnsafeAudioFormatInfoFromGlibNone(p unsafe.Pointer) *AudioFormatInfo { return wrapped } -// UnsafeAudioFormatInfoFromGlibFull is used to convert raw C.GstAudioFormatInfo pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeAudioFormatInfoFromGlibFull is used to convert raw C.GstAudioFormatInfo pointers to go while taking ownership. This is used by the bindings internally. func UnsafeAudioFormatInfoFromGlibFull(p unsafe.Pointer) *AudioFormatInfo { wrapped := UnsafeAudioFormatInfoFromGlibBorrow(p) runtime.SetFinalizer( @@ -9958,6 +11097,7 @@ func UnsafeAudioFormatInfoToGlibFull(a *AudioFormatInfo) unsafe.Pointer { a.native = nil // AudioFormatInfo is invalid from here on return _p } + // AudioInfo wraps GstAudioInfo // // Information describing audio properties. This information can be filled @@ -9990,7 +11130,7 @@ func UnsafeAudioInfoFromGlibBorrow(p unsafe.Pointer) *AudioInfo { return &AudioInfo{&audioInfo{(*C.GstAudioInfo)(p)}} } -// UnsafeAudioInfoFromGlibNone is used to convert raw C.GstAudioInfo pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeAudioInfoFromGlibNone is used to convert raw C.GstAudioInfo pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeAudioInfoFromGlibNone(p unsafe.Pointer) *AudioInfo { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeAudioInfoFromGlibBorrow(p) @@ -10003,7 +11143,7 @@ func UnsafeAudioInfoFromGlibNone(p unsafe.Pointer) *AudioInfo { return wrapped } -// UnsafeAudioInfoFromGlibFull is used to convert raw C.GstAudioInfo pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeAudioInfoFromGlibFull is used to convert raw C.GstAudioInfo pointers to go while taking ownership. This is used by the bindings internally. func UnsafeAudioInfoFromGlibFull(p unsafe.Pointer) *AudioInfo { wrapped := UnsafeAudioInfoFromGlibBorrow(p) runtime.SetFinalizer( @@ -10035,7 +11175,9 @@ func UnsafeAudioInfoToGlibFull(a *AudioInfo) unsafe.Pointer { a.native = nil // AudioInfo is invalid from here on return _p } + // NewAudioInfo wraps gst_audio_info_new +// // The function returns the following values: // // - goret *AudioInfo @@ -10119,6 +11261,7 @@ func AudioInfoFromCaps(caps *gst.Caps) (AudioInfo, bool) { } // AudioInfoInit wraps gst_audio_info_init +// // The function returns the following values: // // - info AudioInfo: a #GstAudioInfo @@ -10186,6 +11329,7 @@ func (info *AudioInfo) Convert(srcFmt gst.Format, srcVal int64, destFmt gst.Form } // Copy wraps gst_audio_info_copy +// // The function returns the following values: // // - goret *AudioInfo @@ -10275,6 +11419,7 @@ func (info *AudioInfo) SetFormat(format AudioFormat, rate int, channels int, pos } // ToCaps wraps gst_audio_info_to_caps +// // The function returns the following values: // // - goret *gst.Caps @@ -10313,7 +11458,7 @@ func UnsafeAudioLevelMetaFromGlibBorrow(p unsafe.Pointer) *AudioLevelMeta { return &AudioLevelMeta{&audioLevelMeta{(*C.GstAudioLevelMeta)(p)}} } -// UnsafeAudioLevelMetaFromGlibNone is used to convert raw C.GstAudioLevelMeta pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeAudioLevelMetaFromGlibNone is used to convert raw C.GstAudioLevelMeta pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeAudioLevelMetaFromGlibNone(p unsafe.Pointer) *AudioLevelMeta { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeAudioLevelMetaFromGlibBorrow(p) @@ -10326,7 +11471,7 @@ func UnsafeAudioLevelMetaFromGlibNone(p unsafe.Pointer) *AudioLevelMeta { return wrapped } -// UnsafeAudioLevelMetaFromGlibFull is used to convert raw C.GstAudioLevelMeta pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeAudioLevelMetaFromGlibFull is used to convert raw C.GstAudioLevelMeta pointers to go while taking ownership. This is used by the bindings internally. func UnsafeAudioLevelMetaFromGlibFull(p unsafe.Pointer) *AudioLevelMeta { wrapped := UnsafeAudioLevelMetaFromGlibBorrow(p) runtime.SetFinalizer( @@ -10358,7 +11503,9 @@ func UnsafeAudioLevelMetaToGlibFull(a *AudioLevelMeta) unsafe.Pointer { a.native = nil // AudioLevelMeta is invalid from here on return _p } + // AudioLevelMetaGetInfo wraps gst_audio_level_meta_get_info +// // The function returns the following values: // // - goret *gst.MetaInfo @@ -10395,7 +11542,7 @@ func UnsafeAudioMetaFromGlibBorrow(p unsafe.Pointer) *AudioMeta { return &AudioMeta{&audioMeta{(*C.GstAudioMeta)(p)}} } -// UnsafeAudioMetaFromGlibNone is used to convert raw C.GstAudioMeta pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeAudioMetaFromGlibNone is used to convert raw C.GstAudioMeta pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeAudioMetaFromGlibNone(p unsafe.Pointer) *AudioMeta { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeAudioMetaFromGlibBorrow(p) @@ -10408,7 +11555,7 @@ func UnsafeAudioMetaFromGlibNone(p unsafe.Pointer) *AudioMeta { return wrapped } -// UnsafeAudioMetaFromGlibFull is used to convert raw C.GstAudioMeta pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeAudioMetaFromGlibFull is used to convert raw C.GstAudioMeta pointers to go while taking ownership. This is used by the bindings internally. func UnsafeAudioMetaFromGlibFull(p unsafe.Pointer) *AudioMeta { wrapped := UnsafeAudioMetaFromGlibBorrow(p) runtime.SetFinalizer( @@ -10440,7 +11587,9 @@ func UnsafeAudioMetaToGlibFull(a *AudioMeta) unsafe.Pointer { a.native = nil // AudioMeta is invalid from here on return _p } + // AudioMetaGetInfo wraps gst_audio_meta_get_info +// // The function returns the following values: // // - goret *gst.MetaInfo @@ -10471,7 +11620,7 @@ func UnsafeAudioQuantizeFromGlibBorrow(p unsafe.Pointer) *AudioQuantize { return &AudioQuantize{&audioQuantize{(*C.GstAudioQuantize)(p)}} } -// UnsafeAudioQuantizeFromGlibNone is used to convert raw C.GstAudioQuantize pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeAudioQuantizeFromGlibNone is used to convert raw C.GstAudioQuantize pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeAudioQuantizeFromGlibNone(p unsafe.Pointer) *AudioQuantize { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeAudioQuantizeFromGlibBorrow(p) @@ -10484,7 +11633,7 @@ func UnsafeAudioQuantizeFromGlibNone(p unsafe.Pointer) *AudioQuantize { return wrapped } -// UnsafeAudioQuantizeFromGlibFull is used to convert raw C.GstAudioQuantize pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeAudioQuantizeFromGlibFull is used to convert raw C.GstAudioQuantize pointers to go while taking ownership. This is used by the bindings internally. func UnsafeAudioQuantizeFromGlibFull(p unsafe.Pointer) *AudioQuantize { wrapped := UnsafeAudioQuantizeFromGlibBorrow(p) runtime.SetFinalizer( @@ -10516,6 +11665,7 @@ func UnsafeAudioQuantizeToGlibFull(a *AudioQuantize) unsafe.Pointer { a.native = nil // AudioQuantize is invalid from here on return _p } + // Reset wraps gst_audio_quantize_reset // // Reset @quant to the state is was when created, clearing any @@ -10547,7 +11697,7 @@ func UnsafeAudioResamplerFromGlibBorrow(p unsafe.Pointer) *AudioResampler { return &AudioResampler{&audioResampler{(*C.GstAudioResampler)(p)}} } -// UnsafeAudioResamplerFromGlibNone is used to convert raw C.GstAudioResampler pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeAudioResamplerFromGlibNone is used to convert raw C.GstAudioResampler pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeAudioResamplerFromGlibNone(p unsafe.Pointer) *AudioResampler { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeAudioResamplerFromGlibBorrow(p) @@ -10560,7 +11710,7 @@ func UnsafeAudioResamplerFromGlibNone(p unsafe.Pointer) *AudioResampler { return wrapped } -// UnsafeAudioResamplerFromGlibFull is used to convert raw C.GstAudioResampler pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeAudioResamplerFromGlibFull is used to convert raw C.GstAudioResampler pointers to go while taking ownership. This is used by the bindings internally. func UnsafeAudioResamplerFromGlibFull(p unsafe.Pointer) *AudioResampler { wrapped := UnsafeAudioResamplerFromGlibBorrow(p) runtime.SetFinalizer( @@ -10592,6 +11742,7 @@ func UnsafeAudioResamplerToGlibFull(a *AudioResampler) unsafe.Pointer { a.native = nil // AudioResampler is invalid from here on return _p } + // NewAudioResampler wraps gst_audio_resampler_new // // The function takes the following parameters: @@ -10708,6 +11859,7 @@ func (resampler *AudioResampler) GetInFrames(outFrames uint) uint { } // GetMaxLatency wraps gst_audio_resampler_get_max_latency +// // The function returns the following values: // // - goret uint @@ -10822,6 +11974,8 @@ func (resampler *AudioResampler) Update(inRate int, outRate int, options *gst.St // AudioRingBufferClass wraps GstAudioRingBufferClass // // The vmethods that subclasses can override to implement the ringbuffer. +// +// AudioRingBufferClass is the type struct for [AudioRingBuffer] type AudioRingBufferClass struct { *audioRingBufferClass } @@ -10836,31 +11990,6 @@ func UnsafeAudioRingBufferClassFromGlibBorrow(p unsafe.Pointer) *AudioRingBuffer return &AudioRingBufferClass{&audioRingBufferClass{(*C.GstAudioRingBufferClass)(p)}} } -// UnsafeAudioRingBufferClassFromGlibNone is used to convert raw C.GstAudioRingBufferClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeAudioRingBufferClassFromGlibNone(p unsafe.Pointer) *AudioRingBufferClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeAudioRingBufferClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.audioRingBufferClass, - func (intern *audioRingBufferClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeAudioRingBufferClassFromGlibFull is used to convert raw C.GstAudioRingBufferClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeAudioRingBufferClassFromGlibFull(p unsafe.Pointer) *AudioRingBufferClass { - wrapped := UnsafeAudioRingBufferClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.audioRingBufferClass, - func (intern *audioRingBufferClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeAudioRingBufferClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [AudioRingBufferClass] is expected to work anymore. @@ -10873,14 +12002,15 @@ func UnsafeAudioRingBufferClassToGlibNone(a *AudioRingBufferClass) unsafe.Pointe return unsafe.Pointer(a.native) } -// UnsafeAudioRingBufferClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeAudioRingBufferClassToGlibFull(a *AudioRingBufferClass) unsafe.Pointer { - runtime.SetFinalizer(a.audioRingBufferClass, nil) - _p := unsafe.Pointer(a.native) - a.native = nil // AudioRingBufferClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (a *AudioRingBufferClass) ParentClass() *gst.ObjectClass { + parent := gst.UnsafeObjectClassFromGlibBorrow(UnsafeAudioRingBufferClassToGlibNone(a)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *AudioRingBufferClass) {}, a) + return parent } + // AudioRingBufferSpec wraps GstAudioRingBufferSpec // // The structure containing the format specification of the ringbuffer. @@ -10902,7 +12032,7 @@ func UnsafeAudioRingBufferSpecFromGlibBorrow(p unsafe.Pointer) *AudioRingBufferS return &AudioRingBufferSpec{&audioRingBufferSpec{(*C.GstAudioRingBufferSpec)(p)}} } -// UnsafeAudioRingBufferSpecFromGlibNone is used to convert raw C.GstAudioRingBufferSpec pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeAudioRingBufferSpecFromGlibNone is used to convert raw C.GstAudioRingBufferSpec pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeAudioRingBufferSpecFromGlibNone(p unsafe.Pointer) *AudioRingBufferSpec { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeAudioRingBufferSpecFromGlibBorrow(p) @@ -10915,7 +12045,7 @@ func UnsafeAudioRingBufferSpecFromGlibNone(p unsafe.Pointer) *AudioRingBufferSpe return wrapped } -// UnsafeAudioRingBufferSpecFromGlibFull is used to convert raw C.GstAudioRingBufferSpec pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeAudioRingBufferSpecFromGlibFull is used to convert raw C.GstAudioRingBufferSpec pointers to go while taking ownership. This is used by the bindings internally. func UnsafeAudioRingBufferSpecFromGlibFull(p unsafe.Pointer) *AudioRingBufferSpec { wrapped := UnsafeAudioRingBufferSpecFromGlibBorrow(p) runtime.SetFinalizer( @@ -10947,7 +12077,10 @@ func UnsafeAudioRingBufferSpecToGlibFull(a *AudioRingBufferSpec) unsafe.Pointer a.native = nil // AudioRingBufferSpec is invalid from here on return _p } + // AudioSinkClass wraps GstAudioSinkClass +// +// AudioSinkClass is the type struct for [AudioSink] type AudioSinkClass struct { *audioSinkClass } @@ -10962,31 +12095,6 @@ func UnsafeAudioSinkClassFromGlibBorrow(p unsafe.Pointer) *AudioSinkClass { return &AudioSinkClass{&audioSinkClass{(*C.GstAudioSinkClass)(p)}} } -// UnsafeAudioSinkClassFromGlibNone is used to convert raw C.GstAudioSinkClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeAudioSinkClassFromGlibNone(p unsafe.Pointer) *AudioSinkClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeAudioSinkClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.audioSinkClass, - func (intern *audioSinkClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeAudioSinkClassFromGlibFull is used to convert raw C.GstAudioSinkClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeAudioSinkClassFromGlibFull(p unsafe.Pointer) *AudioSinkClass { - wrapped := UnsafeAudioSinkClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.audioSinkClass, - func (intern *audioSinkClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeAudioSinkClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [AudioSinkClass] is expected to work anymore. @@ -10999,14 +12107,15 @@ func UnsafeAudioSinkClassToGlibNone(a *AudioSinkClass) unsafe.Pointer { return unsafe.Pointer(a.native) } -// UnsafeAudioSinkClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeAudioSinkClassToGlibFull(a *AudioSinkClass) unsafe.Pointer { - runtime.SetFinalizer(a.audioSinkClass, nil) - _p := unsafe.Pointer(a.native) - a.native = nil // AudioSinkClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (a *AudioSinkClass) ParentClass() *AudioBaseSinkClass { + parent := UnsafeAudioBaseSinkClassFromGlibBorrow(UnsafeAudioSinkClassToGlibNone(a)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *AudioSinkClass) {}, a) + return parent } + // AudioSinkClassExtension wraps GstAudioSinkClassExtension type AudioSinkClassExtension struct { *audioSinkClassExtension @@ -11022,7 +12131,7 @@ func UnsafeAudioSinkClassExtensionFromGlibBorrow(p unsafe.Pointer) *AudioSinkCla return &AudioSinkClassExtension{&audioSinkClassExtension{(*C.GstAudioSinkClassExtension)(p)}} } -// UnsafeAudioSinkClassExtensionFromGlibNone is used to convert raw C.GstAudioSinkClassExtension pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeAudioSinkClassExtensionFromGlibNone is used to convert raw C.GstAudioSinkClassExtension pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeAudioSinkClassExtensionFromGlibNone(p unsafe.Pointer) *AudioSinkClassExtension { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeAudioSinkClassExtensionFromGlibBorrow(p) @@ -11035,7 +12144,7 @@ func UnsafeAudioSinkClassExtensionFromGlibNone(p unsafe.Pointer) *AudioSinkClass return wrapped } -// UnsafeAudioSinkClassExtensionFromGlibFull is used to convert raw C.GstAudioSinkClassExtension pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeAudioSinkClassExtensionFromGlibFull is used to convert raw C.GstAudioSinkClassExtension pointers to go while taking ownership. This is used by the bindings internally. func UnsafeAudioSinkClassExtensionFromGlibFull(p unsafe.Pointer) *AudioSinkClassExtension { wrapped := UnsafeAudioSinkClassExtensionFromGlibBorrow(p) runtime.SetFinalizer( @@ -11067,10 +12176,13 @@ func UnsafeAudioSinkClassExtensionToGlibFull(a *AudioSinkClassExtension) unsafe. a.native = nil // AudioSinkClassExtension is invalid from here on return _p } + // AudioSrcClass wraps GstAudioSrcClass // // #GstAudioSrc class. Override the vmethod to implement // functionality. +// +// AudioSrcClass is the type struct for [AudioSrc] type AudioSrcClass struct { *audioSrcClass } @@ -11085,31 +12197,6 @@ func UnsafeAudioSrcClassFromGlibBorrow(p unsafe.Pointer) *AudioSrcClass { return &AudioSrcClass{&audioSrcClass{(*C.GstAudioSrcClass)(p)}} } -// UnsafeAudioSrcClassFromGlibNone is used to convert raw C.GstAudioSrcClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeAudioSrcClassFromGlibNone(p unsafe.Pointer) *AudioSrcClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeAudioSrcClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.audioSrcClass, - func (intern *audioSrcClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeAudioSrcClassFromGlibFull is used to convert raw C.GstAudioSrcClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeAudioSrcClassFromGlibFull(p unsafe.Pointer) *AudioSrcClass { - wrapped := UnsafeAudioSrcClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.audioSrcClass, - func (intern *audioSrcClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeAudioSrcClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [AudioSrcClass] is expected to work anymore. @@ -11122,14 +12209,15 @@ func UnsafeAudioSrcClassToGlibNone(a *AudioSrcClass) unsafe.Pointer { return unsafe.Pointer(a.native) } -// UnsafeAudioSrcClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeAudioSrcClassToGlibFull(a *AudioSrcClass) unsafe.Pointer { - runtime.SetFinalizer(a.audioSrcClass, nil) - _p := unsafe.Pointer(a.native) - a.native = nil // AudioSrcClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (a *AudioSrcClass) ParentClass() *AudioBaseSrcClass { + parent := UnsafeAudioBaseSrcClassFromGlibBorrow(UnsafeAudioSrcClassToGlibNone(a)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *AudioSrcClass) {}, a) + return parent } + // AudioStreamAlign wraps GstAudioStreamAlign // // #GstAudioStreamAlign provides a helper object that helps tracking audio @@ -11164,7 +12252,7 @@ func UnsafeAudioStreamAlignFromGlibBorrow(p unsafe.Pointer) *AudioStreamAlign { return &AudioStreamAlign{&audioStreamAlign{(*C.GstAudioStreamAlign)(p)}} } -// UnsafeAudioStreamAlignFromGlibNone is used to convert raw C.GstAudioStreamAlign pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeAudioStreamAlignFromGlibNone is used to convert raw C.GstAudioStreamAlign pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeAudioStreamAlignFromGlibNone(p unsafe.Pointer) *AudioStreamAlign { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeAudioStreamAlignFromGlibBorrow(p) @@ -11177,7 +12265,7 @@ func UnsafeAudioStreamAlignFromGlibNone(p unsafe.Pointer) *AudioStreamAlign { return wrapped } -// UnsafeAudioStreamAlignFromGlibFull is used to convert raw C.GstAudioStreamAlign pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeAudioStreamAlignFromGlibFull is used to convert raw C.GstAudioStreamAlign pointers to go while taking ownership. This is used by the bindings internally. func UnsafeAudioStreamAlignFromGlibFull(p unsafe.Pointer) *AudioStreamAlign { wrapped := UnsafeAudioStreamAlignFromGlibBorrow(p) runtime.SetFinalizer( @@ -11209,6 +12297,7 @@ func UnsafeAudioStreamAlignToGlibFull(a *AudioStreamAlign) unsafe.Pointer { a.native = nil // AudioStreamAlign is invalid from here on return _p } + // NewAudioStreamAlign wraps gst_audio_stream_align_new // // The function takes the following parameters: @@ -11255,6 +12344,7 @@ func NewAudioStreamAlign(rate int, alignmentThreshold gst.ClockTime, discontWait } // Copy wraps gst_audio_stream_align_copy +// // The function returns the following values: // // - goret *AudioStreamAlign @@ -11277,6 +12367,7 @@ func (align *AudioStreamAlign) Copy() *AudioStreamAlign { } // GetAlignmentThreshold wraps gst_audio_stream_align_get_alignment_threshold +// // The function returns the following values: // // - goret gst.ClockTime @@ -11299,6 +12390,7 @@ func (align *AudioStreamAlign) GetAlignmentThreshold() gst.ClockTime { } // GetDiscontWait wraps gst_audio_stream_align_get_discont_wait +// // The function returns the following values: // // - goret gst.ClockTime @@ -11321,6 +12413,7 @@ func (align *AudioStreamAlign) GetDiscontWait() gst.ClockTime { } // GetRate wraps gst_audio_stream_align_get_rate +// // The function returns the following values: // // - goret int @@ -11343,6 +12436,7 @@ func (align *AudioStreamAlign) GetRate() int { } // GetSamplesSinceDiscont wraps gst_audio_stream_align_get_samples_since_discont +// // The function returns the following values: // // - goret uint64 @@ -11366,6 +12460,7 @@ func (align *AudioStreamAlign) GetSamplesSinceDiscont() uint64 { } // GetTimestampAtDiscont wraps gst_audio_stream_align_get_timestamp_at_discont +// // The function returns the following values: // // - goret gst.ClockTime @@ -11606,7 +12701,7 @@ func UnsafeDsdInfoFromGlibBorrow(p unsafe.Pointer) *DsdInfo { return &DsdInfo{&dsdInfo{(*C.GstDsdInfo)(p)}} } -// UnsafeDsdInfoFromGlibNone is used to convert raw C.GstDsdInfo pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeDsdInfoFromGlibNone is used to convert raw C.GstDsdInfo pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeDsdInfoFromGlibNone(p unsafe.Pointer) *DsdInfo { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeDsdInfoFromGlibBorrow(p) @@ -11619,7 +12714,7 @@ func UnsafeDsdInfoFromGlibNone(p unsafe.Pointer) *DsdInfo { return wrapped } -// UnsafeDsdInfoFromGlibFull is used to convert raw C.GstDsdInfo pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeDsdInfoFromGlibFull is used to convert raw C.GstDsdInfo pointers to go while taking ownership. This is used by the bindings internally. func UnsafeDsdInfoFromGlibFull(p unsafe.Pointer) *DsdInfo { wrapped := UnsafeDsdInfoFromGlibBorrow(p) runtime.SetFinalizer( @@ -11651,7 +12746,9 @@ func UnsafeDsdInfoToGlibFull(d *DsdInfo) unsafe.Pointer { d.native = nil // DsdInfo is invalid from here on return _p } + // NewDsdInfo wraps gst_dsd_info_new +// // The function returns the following values: // // - goret *DsdInfo @@ -11733,6 +12830,7 @@ func DsdInfoFromCaps(caps *gst.Caps) (DsdInfo, bool) { } // DsdInfoInit wraps gst_dsd_info_init +// // The function returns the following values: // // - info DsdInfo: a #GstDsdInfo @@ -11753,6 +12851,7 @@ func DsdInfoInit() DsdInfo { } // Copy wraps gst_dsd_info_copy +// // The function returns the following values: // // - goret *DsdInfo @@ -11842,6 +12941,7 @@ func (info *DsdInfo) SetFormat(format DsdFormat, rate int, channels int, positio } // ToCaps wraps gst_dsd_info_to_caps +// // The function returns the following values: // // - goret *gst.Caps @@ -11898,7 +12998,7 @@ func UnsafeDsdPlaneOffsetMetaFromGlibBorrow(p unsafe.Pointer) *DsdPlaneOffsetMet return &DsdPlaneOffsetMeta{&dsdPlaneOffsetMeta{(*C.GstDsdPlaneOffsetMeta)(p)}} } -// UnsafeDsdPlaneOffsetMetaFromGlibNone is used to convert raw C.GstDsdPlaneOffsetMeta pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeDsdPlaneOffsetMetaFromGlibNone is used to convert raw C.GstDsdPlaneOffsetMeta pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeDsdPlaneOffsetMetaFromGlibNone(p unsafe.Pointer) *DsdPlaneOffsetMeta { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeDsdPlaneOffsetMetaFromGlibBorrow(p) @@ -11911,7 +13011,7 @@ func UnsafeDsdPlaneOffsetMetaFromGlibNone(p unsafe.Pointer) *DsdPlaneOffsetMeta return wrapped } -// UnsafeDsdPlaneOffsetMetaFromGlibFull is used to convert raw C.GstDsdPlaneOffsetMeta pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeDsdPlaneOffsetMetaFromGlibFull is used to convert raw C.GstDsdPlaneOffsetMeta pointers to go while taking ownership. This is used by the bindings internally. func UnsafeDsdPlaneOffsetMetaFromGlibFull(p unsafe.Pointer) *DsdPlaneOffsetMeta { wrapped := UnsafeDsdPlaneOffsetMetaFromGlibBorrow(p) runtime.SetFinalizer( @@ -11943,7 +13043,9 @@ func UnsafeDsdPlaneOffsetMetaToGlibFull(d *DsdPlaneOffsetMeta) unsafe.Pointer { d.native = nil // DsdPlaneOffsetMeta is invalid from here on return _p } + // DsdPlaneOffsetMetaGetInfo wraps gst_dsd_plane_offset_meta_get_info +// // The function returns the following values: // // - goret *gst.MetaInfo @@ -11974,7 +13076,7 @@ func UnsafeStreamVolumeInterfaceFromGlibBorrow(p unsafe.Pointer) *StreamVolumeIn return &StreamVolumeInterface{&streamVolumeInterface{(*C.GstStreamVolumeInterface)(p)}} } -// UnsafeStreamVolumeInterfaceFromGlibNone is used to convert raw C.GstStreamVolumeInterface pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeStreamVolumeInterfaceFromGlibNone is used to convert raw C.GstStreamVolumeInterface pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeStreamVolumeInterfaceFromGlibNone(p unsafe.Pointer) *StreamVolumeInterface { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeStreamVolumeInterfaceFromGlibBorrow(p) @@ -11987,7 +13089,7 @@ func UnsafeStreamVolumeInterfaceFromGlibNone(p unsafe.Pointer) *StreamVolumeInte return wrapped } -// UnsafeStreamVolumeInterfaceFromGlibFull is used to convert raw C.GstStreamVolumeInterface pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeStreamVolumeInterfaceFromGlibFull is used to convert raw C.GstStreamVolumeInterface pointers to go while taking ownership. This is used by the bindings internally. func UnsafeStreamVolumeInterfaceFromGlibFull(p unsafe.Pointer) *StreamVolumeInterface { wrapped := UnsafeStreamVolumeInterfaceFromGlibBorrow(p) runtime.SetFinalizer( @@ -12019,3 +13121,4 @@ func UnsafeStreamVolumeInterfaceToGlibFull(s *StreamVolumeInterface) unsafe.Poin s.native = nil // StreamVolumeInterface is invalid from here on return _p } + diff --git a/pkg/gstaudio/gstaudio_export.gen.go b/pkg/gstaudio/gstaudio_export.gen.go index 8475105..de8f6cd 100644 --- a/pkg/gstaudio/gstaudio_export.gen.go +++ b/pkg/gstaudio/gstaudio_export.gen.go @@ -86,3 +86,353 @@ func _gotk4_gstaudio1_AudioRingBufferCallback(carg1 *C.GstAudioRingBuffer, carg2 fn(rbuf, data) } +//export _gotk4_gstaudio1_AudioAggregator_aggregate_one_buffer +func _gotk4_gstaudio1_AudioAggregator_aggregate_one_buffer(carg0 *C.GstAudioAggregator, carg1 *C.GstAudioAggregatorPad, carg2 *C.GstBuffer, carg3 C.guint, carg4 *C.GstBuffer, carg5 C.guint, carg6 C.guint) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstaudio1_AudioAggregator_create_output_buffer +func _gotk4_gstaudio1_AudioAggregator_create_output_buffer(carg0 *C.GstAudioAggregator, carg1 C.guint) (cret *C.GstBuffer) { + panic("unimplemented") +} + +//export _gotk4_gstaudio1_AudioAggregatorPad_convert_buffer +func _gotk4_gstaudio1_AudioAggregatorPad_convert_buffer(carg0 *C.GstAudioAggregatorPad, carg1 *C.GstAudioInfo, carg2 *C.GstAudioInfo, carg3 *C.GstBuffer) (cret *C.GstBuffer) { + panic("unimplemented") +} + +//export _gotk4_gstaudio1_AudioAggregatorPad_update_conversion_info +func _gotk4_gstaudio1_AudioAggregatorPad_update_conversion_info(carg0 *C.GstAudioAggregatorPad) { + panic("unimplemented") +} + +//export _gotk4_gstaudio1_AudioBaseSink_create_ringbuffer +func _gotk4_gstaudio1_AudioBaseSink_create_ringbuffer(carg0 *C.GstAudioBaseSink) (cret *C.GstAudioRingBuffer) { + panic("unimplemented") +} + +//export _gotk4_gstaudio1_AudioBaseSink_payload +func _gotk4_gstaudio1_AudioBaseSink_payload(carg0 *C.GstAudioBaseSink, carg1 *C.GstBuffer) (cret *C.GstBuffer) { + panic("unimplemented") +} + +//export _gotk4_gstaudio1_AudioBaseSrc_create_ringbuffer +func _gotk4_gstaudio1_AudioBaseSrc_create_ringbuffer(carg0 *C.GstAudioBaseSrc) (cret *C.GstAudioRingBuffer) { + panic("unimplemented") +} + +//export _gotk4_gstaudio1_AudioCdSrc_close +func _gotk4_gstaudio1_AudioCdSrc_close(carg0 *C.GstAudioCdSrc) { + panic("unimplemented") +} + +//export _gotk4_gstaudio1_AudioCdSrc_open +func _gotk4_gstaudio1_AudioCdSrc_open(carg0 *C.GstAudioCdSrc, carg1 *C.gchar) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstaudio1_AudioCdSrc_read_sector +func _gotk4_gstaudio1_AudioCdSrc_read_sector(carg0 *C.GstAudioCdSrc, carg1 C.gint) (cret *C.GstBuffer) { + panic("unimplemented") +} + +//export _gotk4_gstaudio1_AudioDecoder_close +func _gotk4_gstaudio1_AudioDecoder_close(carg0 *C.GstAudioDecoder) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstaudio1_AudioDecoder_decide_allocation +func _gotk4_gstaudio1_AudioDecoder_decide_allocation(carg0 *C.GstAudioDecoder, carg1 *C.GstQuery) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstaudio1_AudioDecoder_flush +func _gotk4_gstaudio1_AudioDecoder_flush(carg0 *C.GstAudioDecoder, carg1 C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstaudio1_AudioDecoder_getcaps +func _gotk4_gstaudio1_AudioDecoder_getcaps(carg0 *C.GstAudioDecoder, carg1 *C.GstCaps) (cret *C.GstCaps) { + panic("unimplemented") +} + +//export _gotk4_gstaudio1_AudioDecoder_handle_frame +func _gotk4_gstaudio1_AudioDecoder_handle_frame(carg0 *C.GstAudioDecoder, carg1 *C.GstBuffer) (cret C.GstFlowReturn) { + panic("unimplemented") +} + +//export _gotk4_gstaudio1_AudioDecoder_negotiate +func _gotk4_gstaudio1_AudioDecoder_negotiate(carg0 *C.GstAudioDecoder) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstaudio1_AudioDecoder_open +func _gotk4_gstaudio1_AudioDecoder_open(carg0 *C.GstAudioDecoder) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstaudio1_AudioDecoder_parse +func _gotk4_gstaudio1_AudioDecoder_parse(carg0 *C.GstAudioDecoder, carg1 *C.GstAdapter, carg2 *C.gint, carg3 *C.gint) (cret C.GstFlowReturn) { + panic("unimplemented") +} + +//export _gotk4_gstaudio1_AudioDecoder_propose_allocation +func _gotk4_gstaudio1_AudioDecoder_propose_allocation(carg0 *C.GstAudioDecoder, carg1 *C.GstQuery) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstaudio1_AudioDecoder_set_format +func _gotk4_gstaudio1_AudioDecoder_set_format(carg0 *C.GstAudioDecoder, carg1 *C.GstCaps) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstaudio1_AudioDecoder_sink_event +func _gotk4_gstaudio1_AudioDecoder_sink_event(carg0 *C.GstAudioDecoder, carg1 *C.GstEvent) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstaudio1_AudioDecoder_sink_query +func _gotk4_gstaudio1_AudioDecoder_sink_query(carg0 *C.GstAudioDecoder, carg1 *C.GstQuery) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstaudio1_AudioDecoder_src_event +func _gotk4_gstaudio1_AudioDecoder_src_event(carg0 *C.GstAudioDecoder, carg1 *C.GstEvent) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstaudio1_AudioDecoder_src_query +func _gotk4_gstaudio1_AudioDecoder_src_query(carg0 *C.GstAudioDecoder, carg1 *C.GstQuery) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstaudio1_AudioDecoder_start +func _gotk4_gstaudio1_AudioDecoder_start(carg0 *C.GstAudioDecoder) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstaudio1_AudioDecoder_stop +func _gotk4_gstaudio1_AudioDecoder_stop(carg0 *C.GstAudioDecoder) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstaudio1_AudioDecoder_transform_meta +func _gotk4_gstaudio1_AudioDecoder_transform_meta(carg0 *C.GstAudioDecoder, carg1 *C.GstBuffer, carg2 *C.GstMeta, carg3 *C.GstBuffer) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstaudio1_AudioEncoder_close +func _gotk4_gstaudio1_AudioEncoder_close(carg0 *C.GstAudioEncoder) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstaudio1_AudioEncoder_decide_allocation +func _gotk4_gstaudio1_AudioEncoder_decide_allocation(carg0 *C.GstAudioEncoder, carg1 *C.GstQuery) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstaudio1_AudioEncoder_flush +func _gotk4_gstaudio1_AudioEncoder_flush(carg0 *C.GstAudioEncoder) { + panic("unimplemented") +} + +//export _gotk4_gstaudio1_AudioEncoder_getcaps +func _gotk4_gstaudio1_AudioEncoder_getcaps(carg0 *C.GstAudioEncoder, carg1 *C.GstCaps) (cret *C.GstCaps) { + panic("unimplemented") +} + +//export _gotk4_gstaudio1_AudioEncoder_handle_frame +func _gotk4_gstaudio1_AudioEncoder_handle_frame(carg0 *C.GstAudioEncoder, carg1 *C.GstBuffer) (cret C.GstFlowReturn) { + panic("unimplemented") +} + +//export _gotk4_gstaudio1_AudioEncoder_negotiate +func _gotk4_gstaudio1_AudioEncoder_negotiate(carg0 *C.GstAudioEncoder) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstaudio1_AudioEncoder_open +func _gotk4_gstaudio1_AudioEncoder_open(carg0 *C.GstAudioEncoder) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstaudio1_AudioEncoder_propose_allocation +func _gotk4_gstaudio1_AudioEncoder_propose_allocation(carg0 *C.GstAudioEncoder, carg1 *C.GstQuery) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstaudio1_AudioEncoder_set_format +func _gotk4_gstaudio1_AudioEncoder_set_format(carg0 *C.GstAudioEncoder, carg1 *C.GstAudioInfo) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstaudio1_AudioEncoder_sink_event +func _gotk4_gstaudio1_AudioEncoder_sink_event(carg0 *C.GstAudioEncoder, carg1 *C.GstEvent) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstaudio1_AudioEncoder_sink_query +func _gotk4_gstaudio1_AudioEncoder_sink_query(carg0 *C.GstAudioEncoder, carg1 *C.GstQuery) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstaudio1_AudioEncoder_src_event +func _gotk4_gstaudio1_AudioEncoder_src_event(carg0 *C.GstAudioEncoder, carg1 *C.GstEvent) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstaudio1_AudioEncoder_src_query +func _gotk4_gstaudio1_AudioEncoder_src_query(carg0 *C.GstAudioEncoder, carg1 *C.GstQuery) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstaudio1_AudioEncoder_start +func _gotk4_gstaudio1_AudioEncoder_start(carg0 *C.GstAudioEncoder) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstaudio1_AudioEncoder_stop +func _gotk4_gstaudio1_AudioEncoder_stop(carg0 *C.GstAudioEncoder) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstaudio1_AudioEncoder_transform_meta +func _gotk4_gstaudio1_AudioEncoder_transform_meta(carg0 *C.GstAudioEncoder, carg1 *C.GstBuffer, carg2 *C.GstMeta, carg3 *C.GstBuffer) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstaudio1_AudioFilter_setup +func _gotk4_gstaudio1_AudioFilter_setup(carg0 *C.GstAudioFilter, carg1 *C.GstAudioInfo) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstaudio1_AudioRingBuffer_acquire +func _gotk4_gstaudio1_AudioRingBuffer_acquire(carg0 *C.GstAudioRingBuffer, carg1 *C.GstAudioRingBufferSpec) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstaudio1_AudioRingBuffer_activate +func _gotk4_gstaudio1_AudioRingBuffer_activate(carg0 *C.GstAudioRingBuffer, carg1 C.gboolean) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstaudio1_AudioRingBuffer_clear_all +func _gotk4_gstaudio1_AudioRingBuffer_clear_all(carg0 *C.GstAudioRingBuffer) { + panic("unimplemented") +} + +//export _gotk4_gstaudio1_AudioRingBuffer_close_device +func _gotk4_gstaudio1_AudioRingBuffer_close_device(carg0 *C.GstAudioRingBuffer) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstaudio1_AudioRingBuffer_delay +func _gotk4_gstaudio1_AudioRingBuffer_delay(carg0 *C.GstAudioRingBuffer) (cret C.guint) { + panic("unimplemented") +} + +//export _gotk4_gstaudio1_AudioRingBuffer_open_device +func _gotk4_gstaudio1_AudioRingBuffer_open_device(carg0 *C.GstAudioRingBuffer) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstaudio1_AudioRingBuffer_pause +func _gotk4_gstaudio1_AudioRingBuffer_pause(carg0 *C.GstAudioRingBuffer) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstaudio1_AudioRingBuffer_release +func _gotk4_gstaudio1_AudioRingBuffer_release(carg0 *C.GstAudioRingBuffer) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstaudio1_AudioRingBuffer_resume +func _gotk4_gstaudio1_AudioRingBuffer_resume(carg0 *C.GstAudioRingBuffer) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstaudio1_AudioRingBuffer_start +func _gotk4_gstaudio1_AudioRingBuffer_start(carg0 *C.GstAudioRingBuffer) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstaudio1_AudioRingBuffer_stop +func _gotk4_gstaudio1_AudioRingBuffer_stop(carg0 *C.GstAudioRingBuffer) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstaudio1_AudioSink_close +func _gotk4_gstaudio1_AudioSink_close(carg0 *C.GstAudioSink) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstaudio1_AudioSink_delay +func _gotk4_gstaudio1_AudioSink_delay(carg0 *C.GstAudioSink) (cret C.guint) { + panic("unimplemented") +} + +//export _gotk4_gstaudio1_AudioSink_open +func _gotk4_gstaudio1_AudioSink_open(carg0 *C.GstAudioSink) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstaudio1_AudioSink_pause +func _gotk4_gstaudio1_AudioSink_pause(carg0 *C.GstAudioSink) { + panic("unimplemented") +} + +//export _gotk4_gstaudio1_AudioSink_prepare +func _gotk4_gstaudio1_AudioSink_prepare(carg0 *C.GstAudioSink, carg1 *C.GstAudioRingBufferSpec) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstaudio1_AudioSink_reset +func _gotk4_gstaudio1_AudioSink_reset(carg0 *C.GstAudioSink) { + panic("unimplemented") +} + +//export _gotk4_gstaudio1_AudioSink_resume +func _gotk4_gstaudio1_AudioSink_resume(carg0 *C.GstAudioSink) { + panic("unimplemented") +} + +//export _gotk4_gstaudio1_AudioSink_stop +func _gotk4_gstaudio1_AudioSink_stop(carg0 *C.GstAudioSink) { + panic("unimplemented") +} + +//export _gotk4_gstaudio1_AudioSink_unprepare +func _gotk4_gstaudio1_AudioSink_unprepare(carg0 *C.GstAudioSink) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstaudio1_AudioSrc_close +func _gotk4_gstaudio1_AudioSrc_close(carg0 *C.GstAudioSrc) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstaudio1_AudioSrc_delay +func _gotk4_gstaudio1_AudioSrc_delay(carg0 *C.GstAudioSrc) (cret C.guint) { + panic("unimplemented") +} + +//export _gotk4_gstaudio1_AudioSrc_open +func _gotk4_gstaudio1_AudioSrc_open(carg0 *C.GstAudioSrc) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstaudio1_AudioSrc_prepare +func _gotk4_gstaudio1_AudioSrc_prepare(carg0 *C.GstAudioSrc, carg1 *C.GstAudioRingBufferSpec) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstaudio1_AudioSrc_reset +func _gotk4_gstaudio1_AudioSrc_reset(carg0 *C.GstAudioSrc) { + panic("unimplemented") +} + +//export _gotk4_gstaudio1_AudioSrc_unprepare +func _gotk4_gstaudio1_AudioSrc_unprepare(carg0 *C.GstAudioSrc) (cret C.gboolean) { + panic("unimplemented") +} + diff --git a/pkg/gstbase/gstbase.gen.go b/pkg/gstbase/gstbase.gen.go index af3c623..94ae1f3 100644 --- a/pkg/gstbase/gstbase.gen.go +++ b/pkg/gstbase/gstbase.gen.go @@ -24,6 +24,398 @@ import ( // extern gboolean _gotk4_gstbase1_CollectPadsQueryFunction(GstCollectPads*, GstCollectData*, GstQuery*, gpointer); // extern gint _gotk4_gstbase1_CollectPadsCompareFunction(GstCollectPads*, GstCollectData*, GstClockTime, GstCollectData*, GstClockTime, gpointer); // extern void _gotk4_gstbase1_CollectPadsFlushFunction(GstCollectPads*, gpointer); +// extern GstFlowReturn _gotk4_gstbase1_Aggregator_aggregate(GstAggregator*, gboolean); +// extern GstBuffer* _gotk4_gstbase1_Aggregator_clip(GstAggregator*, GstAggregatorPad*, GstBuffer*); +// extern gboolean _gotk4_gstbase1_Aggregator_decide_allocation(GstAggregator*, GstQuery*); +// extern GstFlowReturn _gotk4_gstbase1_Aggregator_finish_buffer(GstAggregator*, GstBuffer*); +// extern GstFlowReturn _gotk4_gstbase1_Aggregator_finish_buffer_list(GstAggregator*, GstBufferList*); +// extern GstCaps* _gotk4_gstbase1_Aggregator_fixate_src_caps(GstAggregator*, GstCaps*); +// extern GstFlowReturn _gotk4_gstbase1_Aggregator_flush(GstAggregator*); +// extern GstClockTime _gotk4_gstbase1_Aggregator_get_next_time(GstAggregator*); +// extern gboolean _gotk4_gstbase1_Aggregator_negotiate(GstAggregator*); +// extern gboolean _gotk4_gstbase1_Aggregator_negotiated_src_caps(GstAggregator*, GstCaps*); +// extern GstSample* _gotk4_gstbase1_Aggregator_peek_next_sample(GstAggregator*, GstAggregatorPad*); +// extern gboolean _gotk4_gstbase1_Aggregator_propose_allocation(GstAggregator*, GstAggregatorPad*, GstQuery*, GstQuery*); +// extern gboolean _gotk4_gstbase1_Aggregator_sink_event(GstAggregator*, GstAggregatorPad*, GstEvent*); +// extern GstFlowReturn _gotk4_gstbase1_Aggregator_sink_event_pre_queue(GstAggregator*, GstAggregatorPad*, GstEvent*); +// extern gboolean _gotk4_gstbase1_Aggregator_sink_query(GstAggregator*, GstAggregatorPad*, GstQuery*); +// extern gboolean _gotk4_gstbase1_Aggregator_sink_query_pre_queue(GstAggregator*, GstAggregatorPad*, GstQuery*); +// extern gboolean _gotk4_gstbase1_Aggregator_src_activate(GstAggregator*, GstPadMode, gboolean); +// extern gboolean _gotk4_gstbase1_Aggregator_src_event(GstAggregator*, GstEvent*); +// extern gboolean _gotk4_gstbase1_Aggregator_src_query(GstAggregator*, GstQuery*); +// extern gboolean _gotk4_gstbase1_Aggregator_start(GstAggregator*); +// extern gboolean _gotk4_gstbase1_Aggregator_stop(GstAggregator*); +// extern GstFlowReturn _gotk4_gstbase1_Aggregator_update_src_caps(GstAggregator*, GstCaps*, GstCaps*); +// GstFlowReturn _gotk4_gstbase1_Aggregator_virtual_aggregate(void* fnptr, GstAggregator* carg0, gboolean carg1) { +// return ((GstFlowReturn (*) (GstAggregator*, gboolean))(fnptr))(carg0, carg1); +// } +// GstBuffer* _gotk4_gstbase1_Aggregator_virtual_clip(void* fnptr, GstAggregator* carg0, GstAggregatorPad* carg1, GstBuffer* carg2) { +// return ((GstBuffer* (*) (GstAggregator*, GstAggregatorPad*, GstBuffer*))(fnptr))(carg0, carg1, carg2); +// } +// gboolean _gotk4_gstbase1_Aggregator_virtual_decide_allocation(void* fnptr, GstAggregator* carg0, GstQuery* carg1) { +// return ((gboolean (*) (GstAggregator*, GstQuery*))(fnptr))(carg0, carg1); +// } +// GstFlowReturn _gotk4_gstbase1_Aggregator_virtual_finish_buffer(void* fnptr, GstAggregator* carg0, GstBuffer* carg1) { +// return ((GstFlowReturn (*) (GstAggregator*, GstBuffer*))(fnptr))(carg0, carg1); +// } +// GstFlowReturn _gotk4_gstbase1_Aggregator_virtual_finish_buffer_list(void* fnptr, GstAggregator* carg0, GstBufferList* carg1) { +// return ((GstFlowReturn (*) (GstAggregator*, GstBufferList*))(fnptr))(carg0, carg1); +// } +// GstCaps* _gotk4_gstbase1_Aggregator_virtual_fixate_src_caps(void* fnptr, GstAggregator* carg0, GstCaps* carg1) { +// return ((GstCaps* (*) (GstAggregator*, GstCaps*))(fnptr))(carg0, carg1); +// } +// GstFlowReturn _gotk4_gstbase1_Aggregator_virtual_flush(void* fnptr, GstAggregator* carg0) { +// return ((GstFlowReturn (*) (GstAggregator*))(fnptr))(carg0); +// } +// GstClockTime _gotk4_gstbase1_Aggregator_virtual_get_next_time(void* fnptr, GstAggregator* carg0) { +// return ((GstClockTime (*) (GstAggregator*))(fnptr))(carg0); +// } +// gboolean _gotk4_gstbase1_Aggregator_virtual_negotiate(void* fnptr, GstAggregator* carg0) { +// return ((gboolean (*) (GstAggregator*))(fnptr))(carg0); +// } +// gboolean _gotk4_gstbase1_Aggregator_virtual_negotiated_src_caps(void* fnptr, GstAggregator* carg0, GstCaps* carg1) { +// return ((gboolean (*) (GstAggregator*, GstCaps*))(fnptr))(carg0, carg1); +// } +// GstSample* _gotk4_gstbase1_Aggregator_virtual_peek_next_sample(void* fnptr, GstAggregator* carg0, GstAggregatorPad* carg1) { +// return ((GstSample* (*) (GstAggregator*, GstAggregatorPad*))(fnptr))(carg0, carg1); +// } +// gboolean _gotk4_gstbase1_Aggregator_virtual_propose_allocation(void* fnptr, GstAggregator* carg0, GstAggregatorPad* carg1, GstQuery* carg2, GstQuery* carg3) { +// return ((gboolean (*) (GstAggregator*, GstAggregatorPad*, GstQuery*, GstQuery*))(fnptr))(carg0, carg1, carg2, carg3); +// } +// gboolean _gotk4_gstbase1_Aggregator_virtual_sink_event(void* fnptr, GstAggregator* carg0, GstAggregatorPad* carg1, GstEvent* carg2) { +// return ((gboolean (*) (GstAggregator*, GstAggregatorPad*, GstEvent*))(fnptr))(carg0, carg1, carg2); +// } +// GstFlowReturn _gotk4_gstbase1_Aggregator_virtual_sink_event_pre_queue(void* fnptr, GstAggregator* carg0, GstAggregatorPad* carg1, GstEvent* carg2) { +// return ((GstFlowReturn (*) (GstAggregator*, GstAggregatorPad*, GstEvent*))(fnptr))(carg0, carg1, carg2); +// } +// gboolean _gotk4_gstbase1_Aggregator_virtual_sink_query(void* fnptr, GstAggregator* carg0, GstAggregatorPad* carg1, GstQuery* carg2) { +// return ((gboolean (*) (GstAggregator*, GstAggregatorPad*, GstQuery*))(fnptr))(carg0, carg1, carg2); +// } +// gboolean _gotk4_gstbase1_Aggregator_virtual_sink_query_pre_queue(void* fnptr, GstAggregator* carg0, GstAggregatorPad* carg1, GstQuery* carg2) { +// return ((gboolean (*) (GstAggregator*, GstAggregatorPad*, GstQuery*))(fnptr))(carg0, carg1, carg2); +// } +// gboolean _gotk4_gstbase1_Aggregator_virtual_src_activate(void* fnptr, GstAggregator* carg0, GstPadMode carg1, gboolean carg2) { +// return ((gboolean (*) (GstAggregator*, GstPadMode, gboolean))(fnptr))(carg0, carg1, carg2); +// } +// gboolean _gotk4_gstbase1_Aggregator_virtual_src_event(void* fnptr, GstAggregator* carg0, GstEvent* carg1) { +// return ((gboolean (*) (GstAggregator*, GstEvent*))(fnptr))(carg0, carg1); +// } +// gboolean _gotk4_gstbase1_Aggregator_virtual_src_query(void* fnptr, GstAggregator* carg0, GstQuery* carg1) { +// return ((gboolean (*) (GstAggregator*, GstQuery*))(fnptr))(carg0, carg1); +// } +// gboolean _gotk4_gstbase1_Aggregator_virtual_start(void* fnptr, GstAggregator* carg0) { +// return ((gboolean (*) (GstAggregator*))(fnptr))(carg0); +// } +// gboolean _gotk4_gstbase1_Aggregator_virtual_stop(void* fnptr, GstAggregator* carg0) { +// return ((gboolean (*) (GstAggregator*))(fnptr))(carg0); +// } +// GstFlowReturn _gotk4_gstbase1_Aggregator_virtual_update_src_caps(void* fnptr, GstAggregator* carg0, GstCaps* carg1, GstCaps** carg2) { +// return ((GstFlowReturn (*) (GstAggregator*, GstCaps*, GstCaps**))(fnptr))(carg0, carg1, carg2); +// } +// extern GstFlowReturn _gotk4_gstbase1_AggregatorPad_flush(GstAggregatorPad*, GstAggregator*); +// extern gboolean _gotk4_gstbase1_AggregatorPad_skip_buffer(GstAggregatorPad*, GstAggregator*, GstBuffer*); +// GstFlowReturn _gotk4_gstbase1_AggregatorPad_virtual_flush(void* fnptr, GstAggregatorPad* carg0, GstAggregator* carg1) { +// return ((GstFlowReturn (*) (GstAggregatorPad*, GstAggregator*))(fnptr))(carg0, carg1); +// } +// gboolean _gotk4_gstbase1_AggregatorPad_virtual_skip_buffer(void* fnptr, GstAggregatorPad* carg0, GstAggregator* carg1, GstBuffer* carg2) { +// return ((gboolean (*) (GstAggregatorPad*, GstAggregator*, GstBuffer*))(fnptr))(carg0, carg1, carg2); +// } +// extern gboolean _gotk4_gstbase1_BaseParse_convert(GstBaseParse*, GstFormat, gint64, GstFormat, gint64*); +// extern GstFlowReturn _gotk4_gstbase1_BaseParse_detect(GstBaseParse*, GstBuffer*); +// extern GstCaps* _gotk4_gstbase1_BaseParse_get_sink_caps(GstBaseParse*, GstCaps*); +// extern GstFlowReturn _gotk4_gstbase1_BaseParse_handle_frame(GstBaseParse*, GstBaseParseFrame*, gint); +// extern GstFlowReturn _gotk4_gstbase1_BaseParse_pre_push_frame(GstBaseParse*, GstBaseParseFrame*); +// extern gboolean _gotk4_gstbase1_BaseParse_set_sink_caps(GstBaseParse*, GstCaps*); +// extern gboolean _gotk4_gstbase1_BaseParse_sink_event(GstBaseParse*, GstEvent*); +// extern gboolean _gotk4_gstbase1_BaseParse_sink_query(GstBaseParse*, GstQuery*); +// extern gboolean _gotk4_gstbase1_BaseParse_src_event(GstBaseParse*, GstEvent*); +// extern gboolean _gotk4_gstbase1_BaseParse_src_query(GstBaseParse*, GstQuery*); +// extern gboolean _gotk4_gstbase1_BaseParse_start(GstBaseParse*); +// extern gboolean _gotk4_gstbase1_BaseParse_stop(GstBaseParse*); +// gboolean _gotk4_gstbase1_BaseParse_virtual_convert(void* fnptr, GstBaseParse* carg0, GstFormat carg1, gint64 carg2, GstFormat carg3, gint64* carg4) { +// return ((gboolean (*) (GstBaseParse*, GstFormat, gint64, GstFormat, gint64*))(fnptr))(carg0, carg1, carg2, carg3, carg4); +// } +// GstFlowReturn _gotk4_gstbase1_BaseParse_virtual_detect(void* fnptr, GstBaseParse* carg0, GstBuffer* carg1) { +// return ((GstFlowReturn (*) (GstBaseParse*, GstBuffer*))(fnptr))(carg0, carg1); +// } +// GstCaps* _gotk4_gstbase1_BaseParse_virtual_get_sink_caps(void* fnptr, GstBaseParse* carg0, GstCaps* carg1) { +// return ((GstCaps* (*) (GstBaseParse*, GstCaps*))(fnptr))(carg0, carg1); +// } +// GstFlowReturn _gotk4_gstbase1_BaseParse_virtual_handle_frame(void* fnptr, GstBaseParse* carg0, GstBaseParseFrame* carg1, gint* carg2) { +// return ((GstFlowReturn (*) (GstBaseParse*, GstBaseParseFrame*, gint*))(fnptr))(carg0, carg1, carg2); +// } +// GstFlowReturn _gotk4_gstbase1_BaseParse_virtual_pre_push_frame(void* fnptr, GstBaseParse* carg0, GstBaseParseFrame* carg1) { +// return ((GstFlowReturn (*) (GstBaseParse*, GstBaseParseFrame*))(fnptr))(carg0, carg1); +// } +// gboolean _gotk4_gstbase1_BaseParse_virtual_set_sink_caps(void* fnptr, GstBaseParse* carg0, GstCaps* carg1) { +// return ((gboolean (*) (GstBaseParse*, GstCaps*))(fnptr))(carg0, carg1); +// } +// gboolean _gotk4_gstbase1_BaseParse_virtual_sink_event(void* fnptr, GstBaseParse* carg0, GstEvent* carg1) { +// return ((gboolean (*) (GstBaseParse*, GstEvent*))(fnptr))(carg0, carg1); +// } +// gboolean _gotk4_gstbase1_BaseParse_virtual_sink_query(void* fnptr, GstBaseParse* carg0, GstQuery* carg1) { +// return ((gboolean (*) (GstBaseParse*, GstQuery*))(fnptr))(carg0, carg1); +// } +// gboolean _gotk4_gstbase1_BaseParse_virtual_src_event(void* fnptr, GstBaseParse* carg0, GstEvent* carg1) { +// return ((gboolean (*) (GstBaseParse*, GstEvent*))(fnptr))(carg0, carg1); +// } +// gboolean _gotk4_gstbase1_BaseParse_virtual_src_query(void* fnptr, GstBaseParse* carg0, GstQuery* carg1) { +// return ((gboolean (*) (GstBaseParse*, GstQuery*))(fnptr))(carg0, carg1); +// } +// gboolean _gotk4_gstbase1_BaseParse_virtual_start(void* fnptr, GstBaseParse* carg0) { +// return ((gboolean (*) (GstBaseParse*))(fnptr))(carg0); +// } +// gboolean _gotk4_gstbase1_BaseParse_virtual_stop(void* fnptr, GstBaseParse* carg0) { +// return ((gboolean (*) (GstBaseParse*))(fnptr))(carg0); +// } +// extern gboolean _gotk4_gstbase1_BaseSink_activate_pull(GstBaseSink*, gboolean); +// extern gboolean _gotk4_gstbase1_BaseSink_event(GstBaseSink*, GstEvent*); +// extern GstCaps* _gotk4_gstbase1_BaseSink_fixate(GstBaseSink*, GstCaps*); +// extern GstCaps* _gotk4_gstbase1_BaseSink_get_caps(GstBaseSink*, GstCaps*); +// extern void _gotk4_gstbase1_BaseSink_get_times(GstBaseSink*, GstBuffer*, GstClockTime, GstClockTime); +// extern GstFlowReturn _gotk4_gstbase1_BaseSink_prepare(GstBaseSink*, GstBuffer*); +// extern GstFlowReturn _gotk4_gstbase1_BaseSink_prepare_list(GstBaseSink*, GstBufferList*); +// extern GstFlowReturn _gotk4_gstbase1_BaseSink_preroll(GstBaseSink*, GstBuffer*); +// extern gboolean _gotk4_gstbase1_BaseSink_propose_allocation(GstBaseSink*, GstQuery*); +// extern gboolean _gotk4_gstbase1_BaseSink_query(GstBaseSink*, GstQuery*); +// extern GstFlowReturn _gotk4_gstbase1_BaseSink_render(GstBaseSink*, GstBuffer*); +// extern GstFlowReturn _gotk4_gstbase1_BaseSink_render_list(GstBaseSink*, GstBufferList*); +// extern gboolean _gotk4_gstbase1_BaseSink_set_caps(GstBaseSink*, GstCaps*); +// extern gboolean _gotk4_gstbase1_BaseSink_start(GstBaseSink*); +// extern gboolean _gotk4_gstbase1_BaseSink_stop(GstBaseSink*); +// extern gboolean _gotk4_gstbase1_BaseSink_unlock(GstBaseSink*); +// extern gboolean _gotk4_gstbase1_BaseSink_unlock_stop(GstBaseSink*); +// extern GstFlowReturn _gotk4_gstbase1_BaseSink_wait_event(GstBaseSink*, GstEvent*); +// gboolean _gotk4_gstbase1_BaseSink_virtual_activate_pull(void* fnptr, GstBaseSink* carg0, gboolean carg1) { +// return ((gboolean (*) (GstBaseSink*, gboolean))(fnptr))(carg0, carg1); +// } +// gboolean _gotk4_gstbase1_BaseSink_virtual_event(void* fnptr, GstBaseSink* carg0, GstEvent* carg1) { +// return ((gboolean (*) (GstBaseSink*, GstEvent*))(fnptr))(carg0, carg1); +// } +// GstCaps* _gotk4_gstbase1_BaseSink_virtual_fixate(void* fnptr, GstBaseSink* carg0, GstCaps* carg1) { +// return ((GstCaps* (*) (GstBaseSink*, GstCaps*))(fnptr))(carg0, carg1); +// } +// GstCaps* _gotk4_gstbase1_BaseSink_virtual_get_caps(void* fnptr, GstBaseSink* carg0, GstCaps* carg1) { +// return ((GstCaps* (*) (GstBaseSink*, GstCaps*))(fnptr))(carg0, carg1); +// } +// void _gotk4_gstbase1_BaseSink_virtual_get_times(void* fnptr, GstBaseSink* carg0, GstBuffer* carg1, GstClockTime* carg2, GstClockTime* carg3) { +// return ((void (*) (GstBaseSink*, GstBuffer*, GstClockTime*, GstClockTime*))(fnptr))(carg0, carg1, carg2, carg3); +// } +// GstFlowReturn _gotk4_gstbase1_BaseSink_virtual_prepare(void* fnptr, GstBaseSink* carg0, GstBuffer* carg1) { +// return ((GstFlowReturn (*) (GstBaseSink*, GstBuffer*))(fnptr))(carg0, carg1); +// } +// GstFlowReturn _gotk4_gstbase1_BaseSink_virtual_prepare_list(void* fnptr, GstBaseSink* carg0, GstBufferList* carg1) { +// return ((GstFlowReturn (*) (GstBaseSink*, GstBufferList*))(fnptr))(carg0, carg1); +// } +// GstFlowReturn _gotk4_gstbase1_BaseSink_virtual_preroll(void* fnptr, GstBaseSink* carg0, GstBuffer* carg1) { +// return ((GstFlowReturn (*) (GstBaseSink*, GstBuffer*))(fnptr))(carg0, carg1); +// } +// gboolean _gotk4_gstbase1_BaseSink_virtual_propose_allocation(void* fnptr, GstBaseSink* carg0, GstQuery* carg1) { +// return ((gboolean (*) (GstBaseSink*, GstQuery*))(fnptr))(carg0, carg1); +// } +// gboolean _gotk4_gstbase1_BaseSink_virtual_query(void* fnptr, GstBaseSink* carg0, GstQuery* carg1) { +// return ((gboolean (*) (GstBaseSink*, GstQuery*))(fnptr))(carg0, carg1); +// } +// GstFlowReturn _gotk4_gstbase1_BaseSink_virtual_render(void* fnptr, GstBaseSink* carg0, GstBuffer* carg1) { +// return ((GstFlowReturn (*) (GstBaseSink*, GstBuffer*))(fnptr))(carg0, carg1); +// } +// GstFlowReturn _gotk4_gstbase1_BaseSink_virtual_render_list(void* fnptr, GstBaseSink* carg0, GstBufferList* carg1) { +// return ((GstFlowReturn (*) (GstBaseSink*, GstBufferList*))(fnptr))(carg0, carg1); +// } +// gboolean _gotk4_gstbase1_BaseSink_virtual_set_caps(void* fnptr, GstBaseSink* carg0, GstCaps* carg1) { +// return ((gboolean (*) (GstBaseSink*, GstCaps*))(fnptr))(carg0, carg1); +// } +// gboolean _gotk4_gstbase1_BaseSink_virtual_start(void* fnptr, GstBaseSink* carg0) { +// return ((gboolean (*) (GstBaseSink*))(fnptr))(carg0); +// } +// gboolean _gotk4_gstbase1_BaseSink_virtual_stop(void* fnptr, GstBaseSink* carg0) { +// return ((gboolean (*) (GstBaseSink*))(fnptr))(carg0); +// } +// gboolean _gotk4_gstbase1_BaseSink_virtual_unlock(void* fnptr, GstBaseSink* carg0) { +// return ((gboolean (*) (GstBaseSink*))(fnptr))(carg0); +// } +// gboolean _gotk4_gstbase1_BaseSink_virtual_unlock_stop(void* fnptr, GstBaseSink* carg0) { +// return ((gboolean (*) (GstBaseSink*))(fnptr))(carg0); +// } +// GstFlowReturn _gotk4_gstbase1_BaseSink_virtual_wait_event(void* fnptr, GstBaseSink* carg0, GstEvent* carg1) { +// return ((GstFlowReturn (*) (GstBaseSink*, GstEvent*))(fnptr))(carg0, carg1); +// } +// extern GstFlowReturn _gotk4_gstbase1_BaseSrc_alloc(GstBaseSrc*, guint64, guint, GstBuffer*); +// extern gboolean _gotk4_gstbase1_BaseSrc_decide_allocation(GstBaseSrc*, GstQuery*); +// extern gboolean _gotk4_gstbase1_BaseSrc_do_seek(GstBaseSrc*, GstSegment*); +// extern gboolean _gotk4_gstbase1_BaseSrc_event(GstBaseSrc*, GstEvent*); +// extern GstFlowReturn _gotk4_gstbase1_BaseSrc_fill(GstBaseSrc*, guint64, guint, GstBuffer*); +// extern GstCaps* _gotk4_gstbase1_BaseSrc_fixate(GstBaseSrc*, GstCaps*); +// extern GstCaps* _gotk4_gstbase1_BaseSrc_get_caps(GstBaseSrc*, GstCaps*); +// extern gboolean _gotk4_gstbase1_BaseSrc_get_size(GstBaseSrc*, guint64); +// extern void _gotk4_gstbase1_BaseSrc_get_times(GstBaseSrc*, GstBuffer*, GstClockTime, GstClockTime); +// extern gboolean _gotk4_gstbase1_BaseSrc_is_seekable(GstBaseSrc*); +// extern gboolean _gotk4_gstbase1_BaseSrc_negotiate(GstBaseSrc*); +// extern gboolean _gotk4_gstbase1_BaseSrc_prepare_seek_segment(GstBaseSrc*, GstEvent*, GstSegment*); +// extern gboolean _gotk4_gstbase1_BaseSrc_query(GstBaseSrc*, GstQuery*); +// extern gboolean _gotk4_gstbase1_BaseSrc_set_caps(GstBaseSrc*, GstCaps*); +// extern gboolean _gotk4_gstbase1_BaseSrc_start(GstBaseSrc*); +// extern gboolean _gotk4_gstbase1_BaseSrc_stop(GstBaseSrc*); +// extern gboolean _gotk4_gstbase1_BaseSrc_unlock(GstBaseSrc*); +// extern gboolean _gotk4_gstbase1_BaseSrc_unlock_stop(GstBaseSrc*); +// GstFlowReturn _gotk4_gstbase1_BaseSrc_virtual_alloc(void* fnptr, GstBaseSrc* carg0, guint64 carg1, guint carg2, GstBuffer** carg3) { +// return ((GstFlowReturn (*) (GstBaseSrc*, guint64, guint, GstBuffer**))(fnptr))(carg0, carg1, carg2, carg3); +// } +// gboolean _gotk4_gstbase1_BaseSrc_virtual_decide_allocation(void* fnptr, GstBaseSrc* carg0, GstQuery* carg1) { +// return ((gboolean (*) (GstBaseSrc*, GstQuery*))(fnptr))(carg0, carg1); +// } +// gboolean _gotk4_gstbase1_BaseSrc_virtual_do_seek(void* fnptr, GstBaseSrc* carg0, GstSegment* carg1) { +// return ((gboolean (*) (GstBaseSrc*, GstSegment*))(fnptr))(carg0, carg1); +// } +// gboolean _gotk4_gstbase1_BaseSrc_virtual_event(void* fnptr, GstBaseSrc* carg0, GstEvent* carg1) { +// return ((gboolean (*) (GstBaseSrc*, GstEvent*))(fnptr))(carg0, carg1); +// } +// GstFlowReturn _gotk4_gstbase1_BaseSrc_virtual_fill(void* fnptr, GstBaseSrc* carg0, guint64 carg1, guint carg2, GstBuffer* carg3) { +// return ((GstFlowReturn (*) (GstBaseSrc*, guint64, guint, GstBuffer*))(fnptr))(carg0, carg1, carg2, carg3); +// } +// GstCaps* _gotk4_gstbase1_BaseSrc_virtual_fixate(void* fnptr, GstBaseSrc* carg0, GstCaps* carg1) { +// return ((GstCaps* (*) (GstBaseSrc*, GstCaps*))(fnptr))(carg0, carg1); +// } +// GstCaps* _gotk4_gstbase1_BaseSrc_virtual_get_caps(void* fnptr, GstBaseSrc* carg0, GstCaps* carg1) { +// return ((GstCaps* (*) (GstBaseSrc*, GstCaps*))(fnptr))(carg0, carg1); +// } +// gboolean _gotk4_gstbase1_BaseSrc_virtual_get_size(void* fnptr, GstBaseSrc* carg0, guint64* carg1) { +// return ((gboolean (*) (GstBaseSrc*, guint64*))(fnptr))(carg0, carg1); +// } +// void _gotk4_gstbase1_BaseSrc_virtual_get_times(void* fnptr, GstBaseSrc* carg0, GstBuffer* carg1, GstClockTime* carg2, GstClockTime* carg3) { +// return ((void (*) (GstBaseSrc*, GstBuffer*, GstClockTime*, GstClockTime*))(fnptr))(carg0, carg1, carg2, carg3); +// } +// gboolean _gotk4_gstbase1_BaseSrc_virtual_is_seekable(void* fnptr, GstBaseSrc* carg0) { +// return ((gboolean (*) (GstBaseSrc*))(fnptr))(carg0); +// } +// gboolean _gotk4_gstbase1_BaseSrc_virtual_negotiate(void* fnptr, GstBaseSrc* carg0) { +// return ((gboolean (*) (GstBaseSrc*))(fnptr))(carg0); +// } +// gboolean _gotk4_gstbase1_BaseSrc_virtual_prepare_seek_segment(void* fnptr, GstBaseSrc* carg0, GstEvent* carg1, GstSegment* carg2) { +// return ((gboolean (*) (GstBaseSrc*, GstEvent*, GstSegment*))(fnptr))(carg0, carg1, carg2); +// } +// gboolean _gotk4_gstbase1_BaseSrc_virtual_query(void* fnptr, GstBaseSrc* carg0, GstQuery* carg1) { +// return ((gboolean (*) (GstBaseSrc*, GstQuery*))(fnptr))(carg0, carg1); +// } +// gboolean _gotk4_gstbase1_BaseSrc_virtual_set_caps(void* fnptr, GstBaseSrc* carg0, GstCaps* carg1) { +// return ((gboolean (*) (GstBaseSrc*, GstCaps*))(fnptr))(carg0, carg1); +// } +// gboolean _gotk4_gstbase1_BaseSrc_virtual_start(void* fnptr, GstBaseSrc* carg0) { +// return ((gboolean (*) (GstBaseSrc*))(fnptr))(carg0); +// } +// gboolean _gotk4_gstbase1_BaseSrc_virtual_stop(void* fnptr, GstBaseSrc* carg0) { +// return ((gboolean (*) (GstBaseSrc*))(fnptr))(carg0); +// } +// gboolean _gotk4_gstbase1_BaseSrc_virtual_unlock(void* fnptr, GstBaseSrc* carg0) { +// return ((gboolean (*) (GstBaseSrc*))(fnptr))(carg0); +// } +// gboolean _gotk4_gstbase1_BaseSrc_virtual_unlock_stop(void* fnptr, GstBaseSrc* carg0) { +// return ((gboolean (*) (GstBaseSrc*))(fnptr))(carg0); +// } +// extern gboolean _gotk4_gstbase1_BaseTransform_accept_caps(GstBaseTransform*, GstPadDirection, GstCaps*); +// extern void _gotk4_gstbase1_BaseTransform_before_transform(GstBaseTransform*, GstBuffer*); +// extern gboolean _gotk4_gstbase1_BaseTransform_copy_metadata(GstBaseTransform*, GstBuffer*, GstBuffer*); +// extern gboolean _gotk4_gstbase1_BaseTransform_decide_allocation(GstBaseTransform*, GstQuery*); +// extern gboolean _gotk4_gstbase1_BaseTransform_filter_meta(GstBaseTransform*, GstQuery*, GType, GstStructure*); +// extern GstCaps* _gotk4_gstbase1_BaseTransform_fixate_caps(GstBaseTransform*, GstPadDirection, GstCaps*, GstCaps*); +// extern GstFlowReturn _gotk4_gstbase1_BaseTransform_generate_output(GstBaseTransform*, GstBuffer*); +// extern gboolean _gotk4_gstbase1_BaseTransform_get_unit_size(GstBaseTransform*, GstCaps*, gsize); +// extern GstFlowReturn _gotk4_gstbase1_BaseTransform_prepare_output_buffer(GstBaseTransform*, GstBuffer*, GstBuffer*); +// extern gboolean _gotk4_gstbase1_BaseTransform_propose_allocation(GstBaseTransform*, GstQuery*, GstQuery*); +// extern gboolean _gotk4_gstbase1_BaseTransform_query(GstBaseTransform*, GstPadDirection, GstQuery*); +// extern gboolean _gotk4_gstbase1_BaseTransform_set_caps(GstBaseTransform*, GstCaps*, GstCaps*); +// extern gboolean _gotk4_gstbase1_BaseTransform_sink_event(GstBaseTransform*, GstEvent*); +// extern gboolean _gotk4_gstbase1_BaseTransform_src_event(GstBaseTransform*, GstEvent*); +// extern gboolean _gotk4_gstbase1_BaseTransform_start(GstBaseTransform*); +// extern gboolean _gotk4_gstbase1_BaseTransform_stop(GstBaseTransform*); +// extern GstFlowReturn _gotk4_gstbase1_BaseTransform_submit_input_buffer(GstBaseTransform*, gboolean, GstBuffer*); +// extern GstFlowReturn _gotk4_gstbase1_BaseTransform_transform(GstBaseTransform*, GstBuffer*, GstBuffer*); +// extern GstCaps* _gotk4_gstbase1_BaseTransform_transform_caps(GstBaseTransform*, GstPadDirection, GstCaps*, GstCaps*); +// extern GstFlowReturn _gotk4_gstbase1_BaseTransform_transform_ip(GstBaseTransform*, GstBuffer*); +// extern gboolean _gotk4_gstbase1_BaseTransform_transform_meta(GstBaseTransform*, GstBuffer*, GstMeta*, GstBuffer*); +// extern gboolean _gotk4_gstbase1_BaseTransform_transform_size(GstBaseTransform*, GstPadDirection, GstCaps*, gsize, GstCaps*, gsize); +// gboolean _gotk4_gstbase1_BaseTransform_virtual_accept_caps(void* fnptr, GstBaseTransform* carg0, GstPadDirection carg1, GstCaps* carg2) { +// return ((gboolean (*) (GstBaseTransform*, GstPadDirection, GstCaps*))(fnptr))(carg0, carg1, carg2); +// } +// void _gotk4_gstbase1_BaseTransform_virtual_before_transform(void* fnptr, GstBaseTransform* carg0, GstBuffer* carg1) { +// return ((void (*) (GstBaseTransform*, GstBuffer*))(fnptr))(carg0, carg1); +// } +// gboolean _gotk4_gstbase1_BaseTransform_virtual_copy_metadata(void* fnptr, GstBaseTransform* carg0, GstBuffer* carg1, GstBuffer* carg2) { +// return ((gboolean (*) (GstBaseTransform*, GstBuffer*, GstBuffer*))(fnptr))(carg0, carg1, carg2); +// } +// gboolean _gotk4_gstbase1_BaseTransform_virtual_decide_allocation(void* fnptr, GstBaseTransform* carg0, GstQuery* carg1) { +// return ((gboolean (*) (GstBaseTransform*, GstQuery*))(fnptr))(carg0, carg1); +// } +// gboolean _gotk4_gstbase1_BaseTransform_virtual_filter_meta(void* fnptr, GstBaseTransform* carg0, GstQuery* carg1, GType carg2, GstStructure* carg3) { +// return ((gboolean (*) (GstBaseTransform*, GstQuery*, GType, GstStructure*))(fnptr))(carg0, carg1, carg2, carg3); +// } +// GstCaps* _gotk4_gstbase1_BaseTransform_virtual_fixate_caps(void* fnptr, GstBaseTransform* carg0, GstPadDirection carg1, GstCaps* carg2, GstCaps* carg3) { +// return ((GstCaps* (*) (GstBaseTransform*, GstPadDirection, GstCaps*, GstCaps*))(fnptr))(carg0, carg1, carg2, carg3); +// } +// GstFlowReturn _gotk4_gstbase1_BaseTransform_virtual_generate_output(void* fnptr, GstBaseTransform* carg0, GstBuffer** carg1) { +// return ((GstFlowReturn (*) (GstBaseTransform*, GstBuffer**))(fnptr))(carg0, carg1); +// } +// gboolean _gotk4_gstbase1_BaseTransform_virtual_get_unit_size(void* fnptr, GstBaseTransform* carg0, GstCaps* carg1, gsize* carg2) { +// return ((gboolean (*) (GstBaseTransform*, GstCaps*, gsize*))(fnptr))(carg0, carg1, carg2); +// } +// GstFlowReturn _gotk4_gstbase1_BaseTransform_virtual_prepare_output_buffer(void* fnptr, GstBaseTransform* carg0, GstBuffer* carg1, GstBuffer** carg2) { +// return ((GstFlowReturn (*) (GstBaseTransform*, GstBuffer*, GstBuffer**))(fnptr))(carg0, carg1, carg2); +// } +// gboolean _gotk4_gstbase1_BaseTransform_virtual_propose_allocation(void* fnptr, GstBaseTransform* carg0, GstQuery* carg1, GstQuery* carg2) { +// return ((gboolean (*) (GstBaseTransform*, GstQuery*, GstQuery*))(fnptr))(carg0, carg1, carg2); +// } +// gboolean _gotk4_gstbase1_BaseTransform_virtual_query(void* fnptr, GstBaseTransform* carg0, GstPadDirection carg1, GstQuery* carg2) { +// return ((gboolean (*) (GstBaseTransform*, GstPadDirection, GstQuery*))(fnptr))(carg0, carg1, carg2); +// } +// gboolean _gotk4_gstbase1_BaseTransform_virtual_set_caps(void* fnptr, GstBaseTransform* carg0, GstCaps* carg1, GstCaps* carg2) { +// return ((gboolean (*) (GstBaseTransform*, GstCaps*, GstCaps*))(fnptr))(carg0, carg1, carg2); +// } +// gboolean _gotk4_gstbase1_BaseTransform_virtual_sink_event(void* fnptr, GstBaseTransform* carg0, GstEvent* carg1) { +// return ((gboolean (*) (GstBaseTransform*, GstEvent*))(fnptr))(carg0, carg1); +// } +// gboolean _gotk4_gstbase1_BaseTransform_virtual_src_event(void* fnptr, GstBaseTransform* carg0, GstEvent* carg1) { +// return ((gboolean (*) (GstBaseTransform*, GstEvent*))(fnptr))(carg0, carg1); +// } +// gboolean _gotk4_gstbase1_BaseTransform_virtual_start(void* fnptr, GstBaseTransform* carg0) { +// return ((gboolean (*) (GstBaseTransform*))(fnptr))(carg0); +// } +// gboolean _gotk4_gstbase1_BaseTransform_virtual_stop(void* fnptr, GstBaseTransform* carg0) { +// return ((gboolean (*) (GstBaseTransform*))(fnptr))(carg0); +// } +// GstFlowReturn _gotk4_gstbase1_BaseTransform_virtual_submit_input_buffer(void* fnptr, GstBaseTransform* carg0, gboolean carg1, GstBuffer* carg2) { +// return ((GstFlowReturn (*) (GstBaseTransform*, gboolean, GstBuffer*))(fnptr))(carg0, carg1, carg2); +// } +// GstFlowReturn _gotk4_gstbase1_BaseTransform_virtual_transform(void* fnptr, GstBaseTransform* carg0, GstBuffer* carg1, GstBuffer* carg2) { +// return ((GstFlowReturn (*) (GstBaseTransform*, GstBuffer*, GstBuffer*))(fnptr))(carg0, carg1, carg2); +// } +// GstCaps* _gotk4_gstbase1_BaseTransform_virtual_transform_caps(void* fnptr, GstBaseTransform* carg0, GstPadDirection carg1, GstCaps* carg2, GstCaps* carg3) { +// return ((GstCaps* (*) (GstBaseTransform*, GstPadDirection, GstCaps*, GstCaps*))(fnptr))(carg0, carg1, carg2, carg3); +// } +// GstFlowReturn _gotk4_gstbase1_BaseTransform_virtual_transform_ip(void* fnptr, GstBaseTransform* carg0, GstBuffer* carg1) { +// return ((GstFlowReturn (*) (GstBaseTransform*, GstBuffer*))(fnptr))(carg0, carg1); +// } +// gboolean _gotk4_gstbase1_BaseTransform_virtual_transform_meta(void* fnptr, GstBaseTransform* carg0, GstBuffer* carg1, GstMeta* carg2, GstBuffer* carg3) { +// return ((gboolean (*) (GstBaseTransform*, GstBuffer*, GstMeta*, GstBuffer*))(fnptr))(carg0, carg1, carg2, carg3); +// } +// gboolean _gotk4_gstbase1_BaseTransform_virtual_transform_size(void* fnptr, GstBaseTransform* carg0, GstPadDirection carg1, GstCaps* carg2, gsize carg3, GstCaps* carg4, gsize* carg5) { +// return ((gboolean (*) (GstBaseTransform*, GstPadDirection, GstCaps*, gsize, GstCaps*, gsize*))(fnptr))(carg0, carg1, carg2, carg3, carg4, carg5); +// } +// extern void _gotk4_gstbase1_DataQueue_empty(GstDataQueue*); +// extern void _gotk4_gstbase1_DataQueue_full(GstDataQueue*); +// void _gotk4_gstbase1_DataQueue_virtual_empty(void* fnptr, GstDataQueue* carg0) { +// return ((void (*) (GstDataQueue*))(fnptr))(carg0); +// } +// void _gotk4_gstbase1_DataQueue_virtual_full(void* fnptr, GstDataQueue* carg0) { +// return ((void (*) (GstDataQueue*))(fnptr))(carg0); +// } +// extern GstFlowReturn _gotk4_gstbase1_PushSrc_alloc(GstPushSrc*, GstBuffer*); +// extern GstFlowReturn _gotk4_gstbase1_PushSrc_fill(GstPushSrc*, GstBuffer*); +// GstFlowReturn _gotk4_gstbase1_PushSrc_virtual_alloc(void* fnptr, GstPushSrc* carg0, GstBuffer** carg1) { +// return ((GstFlowReturn (*) (GstPushSrc*, GstBuffer**))(fnptr))(carg0, carg1); +// } +// GstFlowReturn _gotk4_gstbase1_PushSrc_virtual_fill(void* fnptr, GstPushSrc* carg0, GstBuffer* carg1) { +// return ((GstFlowReturn (*) (GstPushSrc*, GstBuffer*))(fnptr))(carg0, carg1); +// } import "C" // GType values. @@ -916,6 +1308,7 @@ type Adapter interface { upcastToGstAdapter() *AdapterInstance // Available wraps gst_adapter_available + // // The function returns the following values: // // - goret uint @@ -925,6 +1318,7 @@ type Adapter interface { // returning %NULL. Available() uint // AvailableFast wraps gst_adapter_available_fast + // // The function returns the following values: // // - goret uint @@ -954,6 +1348,7 @@ type Adapter interface { // the value of the @size argument an empty #GBytes structure may be returned. CopyBytes(uint, uint) *glib.Bytes // DistanceFromDiscont wraps gst_adapter_distance_from_discont + // // The function returns the following values: // // - goret uint64 @@ -966,6 +1361,7 @@ type Adapter interface { // following buffers based on their size. DistanceFromDiscont() uint64 // DtsAtDiscont wraps gst_adapter_dts_at_discont + // // The function returns the following values: // // - goret gst.ClockTime @@ -1110,6 +1506,7 @@ type Adapter interface { // enough data (offset+size bytes) in the adapter. MaskedScanUint32Peek(uint32, uint32, uint, uint) (uint32, int) // OffsetAtDiscont wraps gst_adapter_offset_at_discont + // // The function returns the following values: // // - goret uint64 @@ -1118,6 +1515,7 @@ type Adapter interface { // flag, or GST_BUFFER_OFFSET_NONE. OffsetAtDiscont() uint64 // PrevDts wraps gst_adapter_prev_dts + // // The function returns the following values: // // - distance uint64: pointer to location for distance, or %NULL @@ -1153,6 +1551,7 @@ type Adapter interface { // and distance returned are GST_CLOCK_TIME_NONE and 0 respectively. PrevDtsAtOffset(uint) (uint64, gst.ClockTime) // PrevOffset wraps gst_adapter_prev_offset + // // The function returns the following values: // // - distance uint64: pointer to a location for distance, or %NULL @@ -1168,6 +1567,7 @@ type Adapter interface { // and distance returned are GST_BUFFER_OFFSET_NONE and 0 respectively. PrevOffset() (uint64, uint64) // PrevPts wraps gst_adapter_prev_pts + // // The function returns the following values: // // - distance uint64: pointer to location for distance, or %NULL @@ -1203,6 +1603,7 @@ type Adapter interface { // and distance returned are GST_CLOCK_TIME_NONE and 0 respectively. PrevPtsAtOffset(uint) (uint64, gst.ClockTime) // PtsAtDiscont wraps gst_adapter_pts_at_discont + // // The function returns the following values: // // - goret gst.ClockTime @@ -1360,6 +1761,7 @@ func UnsafeAdapterToGlibFull(c Adapter) unsafe.Pointer { } // NewAdapter wraps gst_adapter_new +// // The function returns the following values: // // - goret Adapter @@ -1378,6 +1780,7 @@ func NewAdapter() Adapter { } // Available wraps gst_adapter_available +// // The function returns the following values: // // - goret uint @@ -1402,6 +1805,7 @@ func (adapter *AdapterInstance) Available() uint { } // AvailableFast wraps gst_adapter_available_fast +// // The function returns the following values: // // - goret uint @@ -1475,6 +1879,7 @@ func (adapter *AdapterInstance) CopyBytes(offset uint, size uint) *glib.Bytes { } // DistanceFromDiscont wraps gst_adapter_distance_from_discont +// // The function returns the following values: // // - goret uint64 @@ -1502,6 +1907,7 @@ func (adapter *AdapterInstance) DistanceFromDiscont() uint64 { } // DtsAtDiscont wraps gst_adapter_dts_at_discont +// // The function returns the following values: // // - goret gst.ClockTime @@ -1814,6 +2220,7 @@ func (adapter *AdapterInstance) MaskedScanUint32Peek(mask uint32, pattern uint32 } // OffsetAtDiscont wraps gst_adapter_offset_at_discont +// // The function returns the following values: // // - goret uint64 @@ -1837,6 +2244,7 @@ func (adapter *AdapterInstance) OffsetAtDiscont() uint64 { } // PrevDts wraps gst_adapter_prev_dts +// // The function returns the following values: // // - distance uint64: pointer to location for distance, or %NULL @@ -1911,6 +2319,7 @@ func (adapter *AdapterInstance) PrevDtsAtOffset(offset uint) (uint64, gst.ClockT } // PrevOffset wraps gst_adapter_prev_offset +// // The function returns the following values: // // - distance uint64: pointer to a location for distance, or %NULL @@ -1944,6 +2353,7 @@ func (adapter *AdapterInstance) PrevOffset() (uint64, uint64) { } // PrevPts wraps gst_adapter_prev_pts +// // The function returns the following values: // // - distance uint64: pointer to location for distance, or %NULL @@ -2018,6 +2428,7 @@ func (adapter *AdapterInstance) PrevPtsAtOffset(offset uint) (uint64, gst.ClockT } // PtsAtDiscont wraps gst_adapter_pts_at_discont +// // The function returns the following values: // // - goret gst.ClockTime @@ -2361,6 +2772,7 @@ type Aggregator interface { // sent before pushing the buffer. FinishBufferList(*gst.BufferList) gst.FlowReturn // GetAllocator wraps gst_aggregator_get_allocator + // // The function returns the following values: // // - allocator gst.Allocator (nullable): the #GstAllocator @@ -2374,11 +2786,13 @@ type Aggregator interface { // Unref the @allocator after use it. GetAllocator() (gst.Allocator, gst.AllocationParams) // GetBufferPool wraps gst_aggregator_get_buffer_pool + // // The function returns the following values: // // - goret gst.BufferPool (nullable) GetBufferPool() gst.BufferPool // GetForceLive wraps gst_aggregator_get_force_live + // // The function returns the following values: // // - goret bool @@ -2387,11 +2801,13 @@ type Aggregator interface { // %GST_FLOW_EOS from their aggregate implementation. GetForceLive() bool // GetIgnoreInactivePads wraps gst_aggregator_get_ignore_inactive_pads + // // The function returns the following values: // // - goret bool GetIgnoreInactivePads() bool // GetLatency wraps gst_aggregator_get_latency + // // The function returns the following values: // // - goret gst.ClockTime @@ -2403,6 +2819,7 @@ type Aggregator interface { // Typically only called by subclasses. GetLatency() gst.ClockTime // Negotiate wraps gst_aggregator_negotiate + // // The function returns the following values: // // - goret bool @@ -2489,6 +2906,7 @@ type Aggregator interface { // Sets the caps to be used on the src pad. SetSrcCaps(*gst.Caps) // SimpleGetNextTime wraps gst_aggregator_simple_get_next_time + // // The function returns the following values: // // - goret gst.ClockTime @@ -2626,6 +3044,7 @@ func (aggregator *AggregatorInstance) FinishBufferList(bufferlist *gst.BufferLis } // GetAllocator wraps gst_aggregator_get_allocator +// // The function returns the following values: // // - allocator gst.Allocator (nullable): the #GstAllocator @@ -2661,6 +3080,7 @@ func (self *AggregatorInstance) GetAllocator() (gst.Allocator, gst.AllocationPar } // GetBufferPool wraps gst_aggregator_get_buffer_pool +// // The function returns the following values: // // - goret gst.BufferPool (nullable) @@ -2683,6 +3103,7 @@ func (self *AggregatorInstance) GetBufferPool() gst.BufferPool { } // GetForceLive wraps gst_aggregator_get_force_live +// // The function returns the following values: // // - goret bool @@ -2708,6 +3129,7 @@ func (self *AggregatorInstance) GetForceLive() bool { } // GetIgnoreInactivePads wraps gst_aggregator_get_ignore_inactive_pads +// // The function returns the following values: // // - goret bool @@ -2730,6 +3152,7 @@ func (self *AggregatorInstance) GetIgnoreInactivePads() bool { } // GetLatency wraps gst_aggregator_get_latency +// // The function returns the following values: // // - goret gst.ClockTime @@ -2756,6 +3179,7 @@ func (self *AggregatorInstance) GetLatency() gst.ClockTime { } // Negotiate wraps gst_aggregator_negotiate +// // The function returns the following values: // // - goret bool @@ -2952,6 +3376,7 @@ func (self *AggregatorInstance) SetSrcCaps(caps *gst.Caps) { } // SimpleGetNextTime wraps gst_aggregator_simple_get_next_time +// // The function returns the following values: // // - goret gst.ClockTime @@ -3010,6 +3435,298 @@ func (self *AggregatorInstance) UpdateSegment(segment *gst.Segment) { func (o *AggregatorInstance) ConnectSamplesSelected(fn func(Aggregator, gst.Segment, uint64, uint64, uint64, gst.Structure)) gobject.SignalHandle { return o.Connect("samples-selected", fn) } + +// AggregatorOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type AggregatorOverrides[Instance Aggregator] struct { + // gst.ElementOverrides allows you to override virtual methods from the parent class gst.Element + gst.ElementOverrides[Instance] + + // Aggregate allows you to override the implementation of the virtual method aggregate. + // The function takes the following parameters: + // + // - timeout bool + // + // The function returns the following values: + // + // - goret gst.FlowReturn + Aggregate func(Instance, bool) gst.FlowReturn + // Clip allows you to override the implementation of the virtual method clip. + // The function takes the following parameters: + // + // - aggregatorPad AggregatorPad + // - buf *gst.Buffer + // + // The function returns the following values: + // + // - goret *gst.Buffer + Clip func(Instance, AggregatorPad, *gst.Buffer) *gst.Buffer + // DecideAllocation allows you to override the implementation of the virtual method decide_allocation. + // The function takes the following parameters: + // + // - query *gst.Query + // + // The function returns the following values: + // + // - goret bool + DecideAllocation func(Instance, *gst.Query) bool + // FinishBuffer allows you to override the implementation of the virtual method finish_buffer. + // The function takes the following parameters: + // + // - buffer *gst.Buffer: the #GstBuffer to push. + // + // The function returns the following values: + // + // - goret gst.FlowReturn + FinishBuffer func(Instance, *gst.Buffer) gst.FlowReturn + // FinishBufferList allows you to override the implementation of the virtual method finish_buffer_list. + // The function takes the following parameters: + // + // - bufferlist *gst.BufferList: the #GstBufferList to push. + // + // The function returns the following values: + // + // - goret gst.FlowReturn + FinishBufferList func(Instance, *gst.BufferList) gst.FlowReturn + // FixateSrcCaps allows you to override the implementation of the virtual method fixate_src_caps. + // The function takes the following parameters: + // + // - caps *gst.Caps + // + // The function returns the following values: + // + // - goret *gst.Caps + FixateSrcCaps func(Instance, *gst.Caps) *gst.Caps + // Flush allows you to override the implementation of the virtual method flush. + // The function returns the following values: + // + // - goret gst.FlowReturn + Flush func(Instance) gst.FlowReturn + // GetNextTime allows you to override the implementation of the virtual method get_next_time. + // The function returns the following values: + // + // - goret gst.ClockTime + GetNextTime func(Instance) gst.ClockTime + // Negotiate allows you to override the implementation of the virtual method negotiate. + // The function returns the following values: + // + // - goret bool + Negotiate func(Instance) bool + // NegotiatedSrcCaps allows you to override the implementation of the virtual method negotiated_src_caps. + // The function takes the following parameters: + // + // - caps *gst.Caps + // + // The function returns the following values: + // + // - goret bool + NegotiatedSrcCaps func(Instance, *gst.Caps) bool + // PeekNextSample allows you to override the implementation of the virtual method peek_next_sample. + // The function takes the following parameters: + // + // - aggregatorPad AggregatorPad + // + // The function returns the following values: + // + // - goret *gst.Sample (nullable) + PeekNextSample func(Instance, AggregatorPad) *gst.Sample + // ProposeAllocation allows you to override the implementation of the virtual method propose_allocation. + // The function takes the following parameters: + // + // - pad AggregatorPad + // - decideQuery *gst.Query + // - query *gst.Query + // + // The function returns the following values: + // + // - goret bool + ProposeAllocation func(Instance, AggregatorPad, *gst.Query, *gst.Query) bool + // SinkEvent allows you to override the implementation of the virtual method sink_event. + // The function takes the following parameters: + // + // - aggregatorPad AggregatorPad + // - event *gst.Event + // + // The function returns the following values: + // + // - goret bool + SinkEvent func(Instance, AggregatorPad, *gst.Event) bool + // SinkEventPreQueue allows you to override the implementation of the virtual method sink_event_pre_queue. + // The function takes the following parameters: + // + // - aggregatorPad AggregatorPad + // - event *gst.Event + // + // The function returns the following values: + // + // - goret gst.FlowReturn + SinkEventPreQueue func(Instance, AggregatorPad, *gst.Event) gst.FlowReturn + // SinkQuery allows you to override the implementation of the virtual method sink_query. + // The function takes the following parameters: + // + // - aggregatorPad AggregatorPad + // - query *gst.Query + // + // The function returns the following values: + // + // - goret bool + SinkQuery func(Instance, AggregatorPad, *gst.Query) bool + // SinkQueryPreQueue allows you to override the implementation of the virtual method sink_query_pre_queue. + // The function takes the following parameters: + // + // - aggregatorPad AggregatorPad + // - query *gst.Query + // + // The function returns the following values: + // + // - goret bool + SinkQueryPreQueue func(Instance, AggregatorPad, *gst.Query) bool + // SrcActivate allows you to override the implementation of the virtual method src_activate. + // The function takes the following parameters: + // + // - mode gst.PadMode + // - active bool + // + // The function returns the following values: + // + // - goret bool + SrcActivate func(Instance, gst.PadMode, bool) bool + // SrcEvent allows you to override the implementation of the virtual method src_event. + // The function takes the following parameters: + // + // - event *gst.Event + // + // The function returns the following values: + // + // - goret bool + SrcEvent func(Instance, *gst.Event) bool + // SrcQuery allows you to override the implementation of the virtual method src_query. + // The function takes the following parameters: + // + // - query *gst.Query + // + // The function returns the following values: + // + // - goret bool + SrcQuery func(Instance, *gst.Query) bool + // Start allows you to override the implementation of the virtual method start. + // The function returns the following values: + // + // - goret bool + Start func(Instance) bool + // Stop allows you to override the implementation of the virtual method stop. + // The function returns the following values: + // + // - goret bool + Stop func(Instance) bool + // UpdateSrcCaps allows you to override the implementation of the virtual method update_src_caps. + // The function takes the following parameters: + // + // - caps *gst.Caps + // + // The function returns the following values: + // + // - ret *gst.Caps + // - goret gst.FlowReturn + UpdateSrcCaps func(Instance, *gst.Caps) (*gst.Caps, gst.FlowReturn) +} + +// UnsafeApplyAggregatorOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyAggregatorOverrides[Instance Aggregator](gclass unsafe.Pointer, overrides AggregatorOverrides[Instance]) { + gst.UnsafeApplyElementOverrides(gclass, overrides.ElementOverrides) + + pclass := (*C.GstAggregatorClass)(gclass) + + if overrides.Aggregate != nil { + pclass.aggregate = (*[0]byte)(C._gotk4_gstbase1_Aggregator_aggregate) + } + + if overrides.Clip != nil { + pclass.clip = (*[0]byte)(C._gotk4_gstbase1_Aggregator_clip) + } + + if overrides.DecideAllocation != nil { + pclass.decide_allocation = (*[0]byte)(C._gotk4_gstbase1_Aggregator_decide_allocation) + } + + if overrides.FinishBuffer != nil { + pclass.finish_buffer = (*[0]byte)(C._gotk4_gstbase1_Aggregator_finish_buffer) + } + + if overrides.FinishBufferList != nil { + pclass.finish_buffer_list = (*[0]byte)(C._gotk4_gstbase1_Aggregator_finish_buffer_list) + } + + if overrides.FixateSrcCaps != nil { + pclass.fixate_src_caps = (*[0]byte)(C._gotk4_gstbase1_Aggregator_fixate_src_caps) + } + + if overrides.Flush != nil { + pclass.flush = (*[0]byte)(C._gotk4_gstbase1_Aggregator_flush) + } + + if overrides.GetNextTime != nil { + pclass.get_next_time = (*[0]byte)(C._gotk4_gstbase1_Aggregator_get_next_time) + } + + if overrides.Negotiate != nil { + pclass.negotiate = (*[0]byte)(C._gotk4_gstbase1_Aggregator_negotiate) + } + + if overrides.NegotiatedSrcCaps != nil { + pclass.negotiated_src_caps = (*[0]byte)(C._gotk4_gstbase1_Aggregator_negotiated_src_caps) + } + + if overrides.PeekNextSample != nil { + pclass.peek_next_sample = (*[0]byte)(C._gotk4_gstbase1_Aggregator_peek_next_sample) + } + + if overrides.ProposeAllocation != nil { + pclass.propose_allocation = (*[0]byte)(C._gotk4_gstbase1_Aggregator_propose_allocation) + } + + if overrides.SinkEvent != nil { + pclass.sink_event = (*[0]byte)(C._gotk4_gstbase1_Aggregator_sink_event) + } + + if overrides.SinkEventPreQueue != nil { + pclass.sink_event_pre_queue = (*[0]byte)(C._gotk4_gstbase1_Aggregator_sink_event_pre_queue) + } + + if overrides.SinkQuery != nil { + pclass.sink_query = (*[0]byte)(C._gotk4_gstbase1_Aggregator_sink_query) + } + + if overrides.SinkQueryPreQueue != nil { + pclass.sink_query_pre_queue = (*[0]byte)(C._gotk4_gstbase1_Aggregator_sink_query_pre_queue) + } + + if overrides.SrcActivate != nil { + pclass.src_activate = (*[0]byte)(C._gotk4_gstbase1_Aggregator_src_activate) + } + + if overrides.SrcEvent != nil { + pclass.src_event = (*[0]byte)(C._gotk4_gstbase1_Aggregator_src_event) + } + + if overrides.SrcQuery != nil { + pclass.src_query = (*[0]byte)(C._gotk4_gstbase1_Aggregator_src_query) + } + + if overrides.Start != nil { + pclass.start = (*[0]byte)(C._gotk4_gstbase1_Aggregator_start) + } + + if overrides.Stop != nil { + pclass.stop = (*[0]byte)(C._gotk4_gstbase1_Aggregator_stop) + } + + if overrides.UpdateSrcCaps != nil { + pclass.update_src_caps = (*[0]byte)(C._gotk4_gstbase1_Aggregator_update_src_caps) + } +} + // AggregatorPadInstance is the instance type used by all types extending GstAggregatorPad. It is used internally by the bindings. Users should use the interface [AggregatorPad] instead. type AggregatorPadInstance struct { _ [0]func() // equal guard @@ -3028,6 +3745,7 @@ type AggregatorPad interface { upcastToGstAggregatorPad() *AggregatorPadInstance // DropBuffer wraps gst_aggregator_pad_drop_buffer + // // The function returns the following values: // // - goret bool @@ -3035,6 +3753,7 @@ type AggregatorPad interface { // Drop the buffer currently queued in @pad. DropBuffer() bool // HasBuffer wraps gst_aggregator_pad_has_buffer + // // The function returns the following values: // // - goret bool @@ -3044,11 +3763,13 @@ type AggregatorPad interface { // gst_aggregator_pad_pop_buffer(). HasBuffer() bool // IsEos wraps gst_aggregator_pad_is_eos + // // The function returns the following values: // // - goret bool IsEos() bool // IsInactive wraps gst_aggregator_pad_is_inactive + // // The function returns the following values: // // - goret bool @@ -3056,11 +3777,13 @@ type AggregatorPad interface { // It is only valid to call this method from #GstAggregatorClass::aggregate() IsInactive() bool // PeekBuffer wraps gst_aggregator_pad_peek_buffer + // // The function returns the following values: // // - goret *gst.Buffer (nullable) PeekBuffer() *gst.Buffer // PopBuffer wraps gst_aggregator_pad_pop_buffer + // // The function returns the following values: // // - goret *gst.Buffer (nullable) @@ -3112,6 +3835,7 @@ func UnsafeAggregatorPadToGlibFull(c AggregatorPad) unsafe.Pointer { } // DropBuffer wraps gst_aggregator_pad_drop_buffer +// // The function returns the following values: // // - goret bool @@ -3136,6 +3860,7 @@ func (pad *AggregatorPadInstance) DropBuffer() bool { } // HasBuffer wraps gst_aggregator_pad_has_buffer +// // The function returns the following values: // // - goret bool @@ -3162,6 +3887,7 @@ func (pad *AggregatorPadInstance) HasBuffer() bool { } // IsEos wraps gst_aggregator_pad_is_eos +// // The function returns the following values: // // - goret bool @@ -3184,6 +3910,7 @@ func (pad *AggregatorPadInstance) IsEos() bool { } // IsInactive wraps gst_aggregator_pad_is_inactive +// // The function returns the following values: // // - goret bool @@ -3208,6 +3935,7 @@ func (pad *AggregatorPadInstance) IsInactive() bool { } // PeekBuffer wraps gst_aggregator_pad_peek_buffer +// // The function returns the following values: // // - goret *gst.Buffer (nullable) @@ -3230,6 +3958,7 @@ func (pad *AggregatorPadInstance) PeekBuffer() *gst.Buffer { } // PopBuffer wraps gst_aggregator_pad_pop_buffer +// // The function returns the following values: // // - goret *gst.Buffer (nullable) @@ -3257,6 +3986,50 @@ func (pad *AggregatorPadInstance) PopBuffer() *gst.Buffer { func (o *AggregatorPadInstance) ConnectBufferConsumed(fn func(AggregatorPad, gst.Buffer)) gobject.SignalHandle { return o.Connect("buffer-consumed", fn) } + +// AggregatorPadOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type AggregatorPadOverrides[Instance AggregatorPad] struct { + // gst.PadOverrides allows you to override virtual methods from the parent class gst.Pad + gst.PadOverrides[Instance] + + // Flush allows you to override the implementation of the virtual method flush. + // The function takes the following parameters: + // + // - aggregator Aggregator + // + // The function returns the following values: + // + // - goret gst.FlowReturn + Flush func(Instance, Aggregator) gst.FlowReturn + // SkipBuffer allows you to override the implementation of the virtual method skip_buffer. + // The function takes the following parameters: + // + // - aggregator Aggregator + // - buffer *gst.Buffer + // + // The function returns the following values: + // + // - goret bool + SkipBuffer func(Instance, Aggregator, *gst.Buffer) bool +} + +// UnsafeApplyAggregatorPadOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyAggregatorPadOverrides[Instance AggregatorPad](gclass unsafe.Pointer, overrides AggregatorPadOverrides[Instance]) { + gst.UnsafeApplyPadOverrides(gclass, overrides.PadOverrides) + + pclass := (*C.GstAggregatorPadClass)(gclass) + + if overrides.Flush != nil { + pclass.flush = (*[0]byte)(C._gotk4_gstbase1_AggregatorPad_flush) + } + + if overrides.SkipBuffer != nil { + pclass.skip_buffer = (*[0]byte)(C._gotk4_gstbase1_AggregatorPad_skip_buffer) + } +} + // BaseParseInstance is the instance type used by all types extending GstBaseParse. It is used internally by the bindings. Users should use the interface [BaseParse] instead. type BaseParseInstance struct { _ [0]func() // equal guard @@ -4192,6 +4965,174 @@ func (parse *BaseParseInstance) SetTsAtOffset(offset uint) { runtime.KeepAlive(offset) } +// BaseParseOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type BaseParseOverrides[Instance BaseParse] struct { + // gst.ElementOverrides allows you to override virtual methods from the parent class gst.Element + gst.ElementOverrides[Instance] + + // Convert allows you to override the implementation of the virtual method convert. + // The function takes the following parameters: + // + // - srcFormat gst.Format + // - srcValue int64 + // - destFormat gst.Format + // - destValue *int64 + // + // The function returns the following values: + // + // - goret bool + Convert func(Instance, gst.Format, int64, gst.Format, *int64) bool + // Detect allows you to override the implementation of the virtual method detect. + // The function takes the following parameters: + // + // - buffer *gst.Buffer + // + // The function returns the following values: + // + // - goret gst.FlowReturn + Detect func(Instance, *gst.Buffer) gst.FlowReturn + // GetSinkCaps allows you to override the implementation of the virtual method get_sink_caps. + // The function takes the following parameters: + // + // - filter *gst.Caps + // + // The function returns the following values: + // + // - goret *gst.Caps + GetSinkCaps func(Instance, *gst.Caps) *gst.Caps + // HandleFrame allows you to override the implementation of the virtual method handle_frame. + // The function takes the following parameters: + // + // - frame *BaseParseFrame + // + // The function returns the following values: + // + // - skipsize int + // - goret gst.FlowReturn + HandleFrame func(Instance, *BaseParseFrame) (int, gst.FlowReturn) + // PrePushFrame allows you to override the implementation of the virtual method pre_push_frame. + // The function takes the following parameters: + // + // - frame *BaseParseFrame + // + // The function returns the following values: + // + // - goret gst.FlowReturn + PrePushFrame func(Instance, *BaseParseFrame) gst.FlowReturn + // SetSinkCaps allows you to override the implementation of the virtual method set_sink_caps. + // The function takes the following parameters: + // + // - caps *gst.Caps + // + // The function returns the following values: + // + // - goret bool + SetSinkCaps func(Instance, *gst.Caps) bool + // SinkEvent allows you to override the implementation of the virtual method sink_event. + // The function takes the following parameters: + // + // - event *gst.Event + // + // The function returns the following values: + // + // - goret bool + SinkEvent func(Instance, *gst.Event) bool + // SinkQuery allows you to override the implementation of the virtual method sink_query. + // The function takes the following parameters: + // + // - query *gst.Query + // + // The function returns the following values: + // + // - goret bool + SinkQuery func(Instance, *gst.Query) bool + // SrcEvent allows you to override the implementation of the virtual method src_event. + // The function takes the following parameters: + // + // - event *gst.Event + // + // The function returns the following values: + // + // - goret bool + SrcEvent func(Instance, *gst.Event) bool + // SrcQuery allows you to override the implementation of the virtual method src_query. + // The function takes the following parameters: + // + // - query *gst.Query + // + // The function returns the following values: + // + // - goret bool + SrcQuery func(Instance, *gst.Query) bool + // Start allows you to override the implementation of the virtual method start. + // The function returns the following values: + // + // - goret bool + Start func(Instance) bool + // Stop allows you to override the implementation of the virtual method stop. + // The function returns the following values: + // + // - goret bool + Stop func(Instance) bool +} + +// UnsafeApplyBaseParseOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyBaseParseOverrides[Instance BaseParse](gclass unsafe.Pointer, overrides BaseParseOverrides[Instance]) { + gst.UnsafeApplyElementOverrides(gclass, overrides.ElementOverrides) + + pclass := (*C.GstBaseParseClass)(gclass) + + if overrides.Convert != nil { + pclass.convert = (*[0]byte)(C._gotk4_gstbase1_BaseParse_convert) + } + + if overrides.Detect != nil { + pclass.detect = (*[0]byte)(C._gotk4_gstbase1_BaseParse_detect) + } + + if overrides.GetSinkCaps != nil { + pclass.get_sink_caps = (*[0]byte)(C._gotk4_gstbase1_BaseParse_get_sink_caps) + } + + if overrides.HandleFrame != nil { + pclass.handle_frame = (*[0]byte)(C._gotk4_gstbase1_BaseParse_handle_frame) + } + + if overrides.PrePushFrame != nil { + pclass.pre_push_frame = (*[0]byte)(C._gotk4_gstbase1_BaseParse_pre_push_frame) + } + + if overrides.SetSinkCaps != nil { + pclass.set_sink_caps = (*[0]byte)(C._gotk4_gstbase1_BaseParse_set_sink_caps) + } + + if overrides.SinkEvent != nil { + pclass.sink_event = (*[0]byte)(C._gotk4_gstbase1_BaseParse_sink_event) + } + + if overrides.SinkQuery != nil { + pclass.sink_query = (*[0]byte)(C._gotk4_gstbase1_BaseParse_sink_query) + } + + if overrides.SrcEvent != nil { + pclass.src_event = (*[0]byte)(C._gotk4_gstbase1_BaseParse_src_event) + } + + if overrides.SrcQuery != nil { + pclass.src_query = (*[0]byte)(C._gotk4_gstbase1_BaseParse_src_query) + } + + if overrides.Start != nil { + pclass.start = (*[0]byte)(C._gotk4_gstbase1_BaseParse_start) + } + + if overrides.Stop != nil { + pclass.stop = (*[0]byte)(C._gotk4_gstbase1_BaseParse_stop) + } +} + // BaseSinkInstance is the instance type used by all types extending GstBaseSink. It is used internally by the bindings. Users should use the interface [BaseSink] instead. type BaseSinkInstance struct { _ [0]func() // equal guard @@ -4337,6 +5278,7 @@ type BaseSink interface { // This function should be called with the PREROLL_LOCK held. DoPreroll(*gst.MiniObject) gst.FlowReturn // GetBlocksize wraps gst_base_sink_get_blocksize + // // The function returns the following values: // // - goret uint @@ -4345,6 +5287,7 @@ type BaseSink interface { // mode. GetBlocksize() uint // GetDropOutOfSegment wraps gst_base_sink_get_drop_out_of_segment + // // The function returns the following values: // // - goret bool @@ -4353,6 +5296,7 @@ type BaseSink interface { // the current segment GetDropOutOfSegment() bool // GetLastSample wraps gst_base_sink_get_last_sample + // // The function returns the following values: // // - goret *gst.Sample (nullable) @@ -4365,6 +5309,7 @@ type BaseSink interface { // Free-function: gst_sample_unref GetLastSample() *gst.Sample // GetLatency wraps gst_base_sink_get_latency + // // The function returns the following values: // // - goret gst.ClockTime @@ -4372,6 +5317,7 @@ type BaseSink interface { // Get the currently configured latency. GetLatency() gst.ClockTime // GetMaxBitrate wraps gst_base_sink_get_max_bitrate + // // The function returns the following values: // // - goret uint64 @@ -4379,6 +5325,7 @@ type BaseSink interface { // Get the maximum amount of bits per second that the sink will render. GetMaxBitrate() uint64 // GetMaxLateness wraps gst_base_sink_get_max_lateness + // // The function returns the following values: // // - goret int64 @@ -4387,6 +5334,7 @@ type BaseSink interface { // more details. GetMaxLateness() int64 // GetProcessingDeadline wraps gst_base_sink_get_processing_deadline + // // The function returns the following values: // // - goret gst.ClockTime @@ -4396,6 +5344,7 @@ type BaseSink interface { // the processing deadline. GetProcessingDeadline() gst.ClockTime // GetRenderDelay wraps gst_base_sink_get_render_delay + // // The function returns the following values: // // - goret gst.ClockTime @@ -4404,6 +5353,7 @@ type BaseSink interface { // information about the render delay. GetRenderDelay() gst.ClockTime // GetStats wraps gst_base_sink_get_stats + // // The function returns the following values: // // - goret *gst.Structure @@ -4416,6 +5366,7 @@ type BaseSink interface { // - "rendered" G_TYPE_UINT64 Number of rendered frames GetStats() *gst.Structure // GetSync wraps gst_base_sink_get_sync + // // The function returns the following values: // // - goret bool @@ -4424,6 +5375,7 @@ type BaseSink interface { // clock. GetSync() bool // GetThrottleTime wraps gst_base_sink_get_throttle_time + // // The function returns the following values: // // - goret uint64 @@ -4432,6 +5384,7 @@ type BaseSink interface { // maximum buffers per second. GetThrottleTime() uint64 // GetTsOffset wraps gst_base_sink_get_ts_offset + // // The function returns the following values: // // - goret gst.ClockTimeDiff @@ -4439,6 +5392,7 @@ type BaseSink interface { // Get the synchronisation offset of @sink. GetTsOffset() gst.ClockTimeDiff // IsAsyncEnabled wraps gst_base_sink_is_async_enabled + // // The function returns the following values: // // - goret bool @@ -4447,6 +5401,7 @@ type BaseSink interface { // changes to PAUSED. IsAsyncEnabled() bool // IsLastSampleEnabled wraps gst_base_sink_is_last_sample_enabled + // // The function returns the following values: // // - goret bool @@ -4455,6 +5410,7 @@ type BaseSink interface { // the last-sample property. IsLastSampleEnabled() bool // IsQosEnabled wraps gst_base_sink_is_qos_enabled + // // The function returns the following values: // // - goret bool @@ -4463,6 +5419,7 @@ type BaseSink interface { // upstream. IsQosEnabled() bool // QueryLatency wraps gst_base_sink_query_latency + // // The function returns the following values: // // - live bool: if the sink is live @@ -4658,6 +5615,7 @@ type BaseSink interface { // sink. WaitClock(gst.ClockTime) (gst.ClockTimeDiff, gst.ClockReturn) // WaitPreroll wraps gst_base_sink_wait_preroll + // // The function returns the following values: // // - goret gst.FlowReturn @@ -4759,6 +5717,7 @@ func (sink *BaseSinkInstance) DoPreroll(obj *gst.MiniObject) gst.FlowReturn { } // GetBlocksize wraps gst_base_sink_get_blocksize +// // The function returns the following values: // // - goret uint @@ -4782,6 +5741,7 @@ func (sink *BaseSinkInstance) GetBlocksize() uint { } // GetDropOutOfSegment wraps gst_base_sink_get_drop_out_of_segment +// // The function returns the following values: // // - goret bool @@ -4807,6 +5767,7 @@ func (sink *BaseSinkInstance) GetDropOutOfSegment() bool { } // GetLastSample wraps gst_base_sink_get_last_sample +// // The function returns the following values: // // - goret *gst.Sample (nullable) @@ -4836,6 +5797,7 @@ func (sink *BaseSinkInstance) GetLastSample() *gst.Sample { } // GetLatency wraps gst_base_sink_get_latency +// // The function returns the following values: // // - goret gst.ClockTime @@ -4858,6 +5820,7 @@ func (sink *BaseSinkInstance) GetLatency() gst.ClockTime { } // GetMaxBitrate wraps gst_base_sink_get_max_bitrate +// // The function returns the following values: // // - goret uint64 @@ -4880,6 +5843,7 @@ func (sink *BaseSinkInstance) GetMaxBitrate() uint64 { } // GetMaxLateness wraps gst_base_sink_get_max_lateness +// // The function returns the following values: // // - goret int64 @@ -4903,6 +5867,7 @@ func (sink *BaseSinkInstance) GetMaxLateness() int64 { } // GetProcessingDeadline wraps gst_base_sink_get_processing_deadline +// // The function returns the following values: // // - goret gst.ClockTime @@ -4927,6 +5892,7 @@ func (sink *BaseSinkInstance) GetProcessingDeadline() gst.ClockTime { } // GetRenderDelay wraps gst_base_sink_get_render_delay +// // The function returns the following values: // // - goret gst.ClockTime @@ -4950,6 +5916,7 @@ func (sink *BaseSinkInstance) GetRenderDelay() gst.ClockTime { } // GetStats wraps gst_base_sink_get_stats +// // The function returns the following values: // // - goret *gst.Structure @@ -4977,6 +5944,7 @@ func (sink *BaseSinkInstance) GetStats() *gst.Structure { } // GetSync wraps gst_base_sink_get_sync +// // The function returns the following values: // // - goret bool @@ -5002,6 +5970,7 @@ func (sink *BaseSinkInstance) GetSync() bool { } // GetThrottleTime wraps gst_base_sink_get_throttle_time +// // The function returns the following values: // // - goret uint64 @@ -5025,6 +5994,7 @@ func (sink *BaseSinkInstance) GetThrottleTime() uint64 { } // GetTsOffset wraps gst_base_sink_get_ts_offset +// // The function returns the following values: // // - goret gst.ClockTimeDiff @@ -5047,6 +6017,7 @@ func (sink *BaseSinkInstance) GetTsOffset() gst.ClockTimeDiff { } // IsAsyncEnabled wraps gst_base_sink_is_async_enabled +// // The function returns the following values: // // - goret bool @@ -5072,6 +6043,7 @@ func (sink *BaseSinkInstance) IsAsyncEnabled() bool { } // IsLastSampleEnabled wraps gst_base_sink_is_last_sample_enabled +// // The function returns the following values: // // - goret bool @@ -5097,6 +6069,7 @@ func (sink *BaseSinkInstance) IsLastSampleEnabled() bool { } // IsQosEnabled wraps gst_base_sink_is_qos_enabled +// // The function returns the following values: // // - goret bool @@ -5122,6 +6095,7 @@ func (sink *BaseSinkInstance) IsQosEnabled() bool { } // QueryLatency wraps gst_base_sink_query_latency +// // The function returns the following values: // // - live bool: if the sink is live @@ -5534,6 +6508,7 @@ func (sink *BaseSinkInstance) WaitClock(time gst.ClockTime) (gst.ClockTimeDiff, } // WaitPreroll wraps gst_base_sink_wait_preroll +// // The function returns the following values: // // - goret gst.FlowReturn @@ -5572,6 +6547,241 @@ func (sink *BaseSinkInstance) WaitPreroll() gst.FlowReturn { return goret } +// BaseSinkOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type BaseSinkOverrides[Instance BaseSink] struct { + // gst.ElementOverrides allows you to override virtual methods from the parent class gst.Element + gst.ElementOverrides[Instance] + + // ActivatePull allows you to override the implementation of the virtual method activate_pull. + // The function takes the following parameters: + // + // - active bool + // + // The function returns the following values: + // + // - goret bool + ActivatePull func(Instance, bool) bool + // Event allows you to override the implementation of the virtual method event. + // The function takes the following parameters: + // + // - event *gst.Event + // + // The function returns the following values: + // + // - goret bool + Event func(Instance, *gst.Event) bool + // Fixate allows you to override the implementation of the virtual method fixate. + // The function takes the following parameters: + // + // - caps *gst.Caps + // + // The function returns the following values: + // + // - goret *gst.Caps + Fixate func(Instance, *gst.Caps) *gst.Caps + // GetCaps allows you to override the implementation of the virtual method get_caps. + // The function takes the following parameters: + // + // - filter *gst.Caps (nullable) + // + // The function returns the following values: + // + // - goret *gst.Caps + GetCaps func(Instance, *gst.Caps) *gst.Caps + // GetTimes allows you to override the implementation of the virtual method get_times. + // The function takes the following parameters: + // + // - buffer *gst.Buffer + // + // The function returns the following values: + // + // - start gst.ClockTime: the start #GstClockTime + // - end gst.ClockTime: the end #GstClockTime + GetTimes func(Instance, *gst.Buffer) (gst.ClockTime, gst.ClockTime) + // Prepare allows you to override the implementation of the virtual method prepare. + // The function takes the following parameters: + // + // - buffer *gst.Buffer + // + // The function returns the following values: + // + // - goret gst.FlowReturn + Prepare func(Instance, *gst.Buffer) gst.FlowReturn + // PrepareList allows you to override the implementation of the virtual method prepare_list. + // The function takes the following parameters: + // + // - bufferList *gst.BufferList + // + // The function returns the following values: + // + // - goret gst.FlowReturn + PrepareList func(Instance, *gst.BufferList) gst.FlowReturn + // Preroll allows you to override the implementation of the virtual method preroll. + // The function takes the following parameters: + // + // - buffer *gst.Buffer + // + // The function returns the following values: + // + // - goret gst.FlowReturn + Preroll func(Instance, *gst.Buffer) gst.FlowReturn + // ProposeAllocation allows you to override the implementation of the virtual method propose_allocation. + // The function takes the following parameters: + // + // - query *gst.Query + // + // The function returns the following values: + // + // - goret bool + ProposeAllocation func(Instance, *gst.Query) bool + // Query allows you to override the implementation of the virtual method query. + // The function takes the following parameters: + // + // - query *gst.Query + // + // The function returns the following values: + // + // - goret bool + Query func(Instance, *gst.Query) bool + // Render allows you to override the implementation of the virtual method render. + // The function takes the following parameters: + // + // - buffer *gst.Buffer + // + // The function returns the following values: + // + // - goret gst.FlowReturn + Render func(Instance, *gst.Buffer) gst.FlowReturn + // RenderList allows you to override the implementation of the virtual method render_list. + // The function takes the following parameters: + // + // - bufferList *gst.BufferList + // + // The function returns the following values: + // + // - goret gst.FlowReturn + RenderList func(Instance, *gst.BufferList) gst.FlowReturn + // SetCaps allows you to override the implementation of the virtual method set_caps. + // The function takes the following parameters: + // + // - caps *gst.Caps + // + // The function returns the following values: + // + // - goret bool + SetCaps func(Instance, *gst.Caps) bool + // Start allows you to override the implementation of the virtual method start. + // The function returns the following values: + // + // - goret bool + Start func(Instance) bool + // Stop allows you to override the implementation of the virtual method stop. + // The function returns the following values: + // + // - goret bool + Stop func(Instance) bool + // Unlock allows you to override the implementation of the virtual method unlock. + // The function returns the following values: + // + // - goret bool + Unlock func(Instance) bool + // UnlockStop allows you to override the implementation of the virtual method unlock_stop. + // The function returns the following values: + // + // - goret bool + UnlockStop func(Instance) bool + // WaitEvent allows you to override the implementation of the virtual method wait_event. + // The function takes the following parameters: + // + // - event *gst.Event + // + // The function returns the following values: + // + // - goret gst.FlowReturn + WaitEvent func(Instance, *gst.Event) gst.FlowReturn +} + +// UnsafeApplyBaseSinkOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyBaseSinkOverrides[Instance BaseSink](gclass unsafe.Pointer, overrides BaseSinkOverrides[Instance]) { + gst.UnsafeApplyElementOverrides(gclass, overrides.ElementOverrides) + + pclass := (*C.GstBaseSinkClass)(gclass) + + if overrides.ActivatePull != nil { + pclass.activate_pull = (*[0]byte)(C._gotk4_gstbase1_BaseSink_activate_pull) + } + + if overrides.Event != nil { + pclass.event = (*[0]byte)(C._gotk4_gstbase1_BaseSink_event) + } + + if overrides.Fixate != nil { + pclass.fixate = (*[0]byte)(C._gotk4_gstbase1_BaseSink_fixate) + } + + if overrides.GetCaps != nil { + pclass.get_caps = (*[0]byte)(C._gotk4_gstbase1_BaseSink_get_caps) + } + + if overrides.GetTimes != nil { + pclass.get_times = (*[0]byte)(C._gotk4_gstbase1_BaseSink_get_times) + } + + if overrides.Prepare != nil { + pclass.prepare = (*[0]byte)(C._gotk4_gstbase1_BaseSink_prepare) + } + + if overrides.PrepareList != nil { + pclass.prepare_list = (*[0]byte)(C._gotk4_gstbase1_BaseSink_prepare_list) + } + + if overrides.Preroll != nil { + pclass.preroll = (*[0]byte)(C._gotk4_gstbase1_BaseSink_preroll) + } + + if overrides.ProposeAllocation != nil { + pclass.propose_allocation = (*[0]byte)(C._gotk4_gstbase1_BaseSink_propose_allocation) + } + + if overrides.Query != nil { + pclass.query = (*[0]byte)(C._gotk4_gstbase1_BaseSink_query) + } + + if overrides.Render != nil { + pclass.render = (*[0]byte)(C._gotk4_gstbase1_BaseSink_render) + } + + if overrides.RenderList != nil { + pclass.render_list = (*[0]byte)(C._gotk4_gstbase1_BaseSink_render_list) + } + + if overrides.SetCaps != nil { + pclass.set_caps = (*[0]byte)(C._gotk4_gstbase1_BaseSink_set_caps) + } + + if overrides.Start != nil { + pclass.start = (*[0]byte)(C._gotk4_gstbase1_BaseSink_start) + } + + if overrides.Stop != nil { + pclass.stop = (*[0]byte)(C._gotk4_gstbase1_BaseSink_stop) + } + + if overrides.Unlock != nil { + pclass.unlock = (*[0]byte)(C._gotk4_gstbase1_BaseSink_unlock) + } + + if overrides.UnlockStop != nil { + pclass.unlock_stop = (*[0]byte)(C._gotk4_gstbase1_BaseSink_unlock_stop) + } + + if overrides.WaitEvent != nil { + pclass.wait_event = (*[0]byte)(C._gotk4_gstbase1_BaseSink_wait_event) + } +} + // BaseSrcInstance is the instance type used by all types extending GstBaseSrc. It is used internally by the bindings. Users should use the interface [BaseSrc] instead. type BaseSrcInstance struct { _ [0]func() // equal guard @@ -5699,6 +6909,7 @@ type BaseSrc interface { upcastToGstBaseSrc() *BaseSrcInstance // GetAllocator wraps gst_base_src_get_allocator + // // The function returns the following values: // // - allocator gst.Allocator (nullable): the #GstAllocator @@ -5711,6 +6922,7 @@ type BaseSrc interface { // Unref the @allocator after usage. GetAllocator() (gst.Allocator, gst.AllocationParams) // GetBlocksize wraps gst_base_src_get_blocksize + // // The function returns the following values: // // - goret uint @@ -5718,11 +6930,13 @@ type BaseSrc interface { // Get the number of bytes that @src will push out with each buffer. GetBlocksize() uint // GetBufferPool wraps gst_base_src_get_buffer_pool + // // The function returns the following values: // // - goret gst.BufferPool (nullable) GetBufferPool() gst.BufferPool // GetDoTimestamp wraps gst_base_src_get_do_timestamp + // // The function returns the following values: // // - goret bool @@ -5730,6 +6944,7 @@ type BaseSrc interface { // Query if @src timestamps outgoing buffers based on the current running_time. GetDoTimestamp() bool // IsAsync wraps gst_base_src_is_async + // // The function returns the following values: // // - goret bool @@ -5737,6 +6952,7 @@ type BaseSrc interface { // Get the current async behaviour of @src. See also gst_base_src_set_async(). IsAsync() bool // IsLive wraps gst_base_src_is_live + // // The function returns the following values: // // - goret bool @@ -5744,6 +6960,7 @@ type BaseSrc interface { // Check if an element is in live mode. IsLive() bool // Negotiate wraps gst_base_src_negotiate + // // The function returns the following values: // // - goret bool @@ -5823,6 +7040,7 @@ type BaseSrc interface { // which can be useful to ensure events ordering. PushSegment(*gst.Segment) bool // QueryLatency wraps gst_base_src_query_latency + // // The function returns the following values: // // - live bool: if the source is live @@ -5947,6 +7165,7 @@ type BaseSrc interface { // helper thread. StartComplete(gst.FlowReturn) // StartWait wraps gst_base_src_start_wait + // // The function returns the following values: // // - goret gst.FlowReturn @@ -5977,6 +7196,7 @@ type BaseSrc interface { // mode. SubmitBufferList(*gst.BufferList) // WaitPlaying wraps gst_base_src_wait_playing + // // The function returns the following values: // // - goret gst.FlowReturn @@ -6033,6 +7253,7 @@ func UnsafeBaseSrcToGlibFull(c BaseSrc) unsafe.Pointer { } // GetAllocator wraps gst_base_src_get_allocator +// // The function returns the following values: // // - allocator gst.Allocator (nullable): the #GstAllocator @@ -6067,6 +7288,7 @@ func (src *BaseSrcInstance) GetAllocator() (gst.Allocator, gst.AllocationParams) } // GetBlocksize wraps gst_base_src_get_blocksize +// // The function returns the following values: // // - goret uint @@ -6089,6 +7311,7 @@ func (src *BaseSrcInstance) GetBlocksize() uint { } // GetBufferPool wraps gst_base_src_get_buffer_pool +// // The function returns the following values: // // - goret gst.BufferPool (nullable) @@ -6111,6 +7334,7 @@ func (src *BaseSrcInstance) GetBufferPool() gst.BufferPool { } // GetDoTimestamp wraps gst_base_src_get_do_timestamp +// // The function returns the following values: // // - goret bool @@ -6135,6 +7359,7 @@ func (src *BaseSrcInstance) GetDoTimestamp() bool { } // IsAsync wraps gst_base_src_is_async +// // The function returns the following values: // // - goret bool @@ -6159,6 +7384,7 @@ func (src *BaseSrcInstance) IsAsync() bool { } // IsLive wraps gst_base_src_is_live +// // The function returns the following values: // // - goret bool @@ -6183,6 +7409,7 @@ func (src *BaseSrcInstance) IsLive() bool { } // Negotiate wraps gst_base_src_negotiate +// // The function returns the following values: // // - goret bool @@ -6345,6 +7572,7 @@ func (src *BaseSrcInstance) PushSegment(segment *gst.Segment) bool { } // QueryLatency wraps gst_base_src_query_latency +// // The function returns the following values: // // - live bool: if the source is live @@ -6615,6 +7843,7 @@ func (basesrc *BaseSrcInstance) StartComplete(ret gst.FlowReturn) { } // StartWait wraps gst_base_src_start_wait +// // The function returns the following values: // // - goret gst.FlowReturn @@ -6671,6 +7900,7 @@ func (src *BaseSrcInstance) SubmitBufferList(bufferList *gst.BufferList) { } // WaitPlaying wraps gst_base_src_wait_playing +// // The function returns the following values: // // - goret gst.FlowReturn @@ -6699,6 +7929,235 @@ func (src *BaseSrcInstance) WaitPlaying() gst.FlowReturn { return goret } +// BaseSrcOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type BaseSrcOverrides[Instance BaseSrc] struct { + // gst.ElementOverrides allows you to override virtual methods from the parent class gst.Element + gst.ElementOverrides[Instance] + + // Alloc allows you to override the implementation of the virtual method alloc. + // The function takes the following parameters: + // + // - offset uint64 + // - size uint + // + // The function returns the following values: + // + // - buf *gst.Buffer (nullable) + // - goret gst.FlowReturn + Alloc func(Instance, uint64, uint) (*gst.Buffer, gst.FlowReturn) + // DecideAllocation allows you to override the implementation of the virtual method decide_allocation. + // The function takes the following parameters: + // + // - query *gst.Query + // + // The function returns the following values: + // + // - goret bool + DecideAllocation func(Instance, *gst.Query) bool + // DoSeek allows you to override the implementation of the virtual method do_seek. + // The function takes the following parameters: + // + // - segment *gst.Segment + // + // The function returns the following values: + // + // - goret bool + DoSeek func(Instance, *gst.Segment) bool + // Event allows you to override the implementation of the virtual method event. + // The function takes the following parameters: + // + // - event *gst.Event + // + // The function returns the following values: + // + // - goret bool + Event func(Instance, *gst.Event) bool + // Fill allows you to override the implementation of the virtual method fill. + // The function takes the following parameters: + // + // - offset uint64 + // - size uint + // - buf *gst.Buffer + // + // The function returns the following values: + // + // - goret gst.FlowReturn + Fill func(Instance, uint64, uint, *gst.Buffer) gst.FlowReturn + // Fixate allows you to override the implementation of the virtual method fixate. + // The function takes the following parameters: + // + // - caps *gst.Caps + // + // The function returns the following values: + // + // - goret *gst.Caps + Fixate func(Instance, *gst.Caps) *gst.Caps + // GetCaps allows you to override the implementation of the virtual method get_caps. + // The function takes the following parameters: + // + // - filter *gst.Caps (nullable) + // + // The function returns the following values: + // + // - goret *gst.Caps + GetCaps func(Instance, *gst.Caps) *gst.Caps + // GetSize allows you to override the implementation of the virtual method get_size. + // The function returns the following values: + // + // - size uint64 + // - goret bool + GetSize func(Instance) (uint64, bool) + // GetTimes allows you to override the implementation of the virtual method get_times. + // The function takes the following parameters: + // + // - buffer *gst.Buffer + // + // The function returns the following values: + // + // - start gst.ClockTime + // - end gst.ClockTime + GetTimes func(Instance, *gst.Buffer) (gst.ClockTime, gst.ClockTime) + // IsSeekable allows you to override the implementation of the virtual method is_seekable. + // The function returns the following values: + // + // - goret bool + IsSeekable func(Instance) bool + // Negotiate allows you to override the implementation of the virtual method negotiate. + // The function returns the following values: + // + // - goret bool + Negotiate func(Instance) bool + // PrepareSeekSegment allows you to override the implementation of the virtual method prepare_seek_segment. + // The function takes the following parameters: + // + // - seek *gst.Event + // - segment *gst.Segment + // + // The function returns the following values: + // + // - goret bool + PrepareSeekSegment func(Instance, *gst.Event, *gst.Segment) bool + // Query allows you to override the implementation of the virtual method query. + // The function takes the following parameters: + // + // - query *gst.Query + // + // The function returns the following values: + // + // - goret bool + Query func(Instance, *gst.Query) bool + // SetCaps allows you to override the implementation of the virtual method set_caps. + // The function takes the following parameters: + // + // - caps *gst.Caps: a #GstCaps + // + // The function returns the following values: + // + // - goret bool + SetCaps func(Instance, *gst.Caps) bool + // Start allows you to override the implementation of the virtual method start. + // The function returns the following values: + // + // - goret bool + Start func(Instance) bool + // Stop allows you to override the implementation of the virtual method stop. + // The function returns the following values: + // + // - goret bool + Stop func(Instance) bool + // Unlock allows you to override the implementation of the virtual method unlock. + // The function returns the following values: + // + // - goret bool + Unlock func(Instance) bool + // UnlockStop allows you to override the implementation of the virtual method unlock_stop. + // The function returns the following values: + // + // - goret bool + UnlockStop func(Instance) bool +} + +// UnsafeApplyBaseSrcOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyBaseSrcOverrides[Instance BaseSrc](gclass unsafe.Pointer, overrides BaseSrcOverrides[Instance]) { + gst.UnsafeApplyElementOverrides(gclass, overrides.ElementOverrides) + + pclass := (*C.GstBaseSrcClass)(gclass) + + if overrides.Alloc != nil { + pclass.alloc = (*[0]byte)(C._gotk4_gstbase1_BaseSrc_alloc) + } + + if overrides.DecideAllocation != nil { + pclass.decide_allocation = (*[0]byte)(C._gotk4_gstbase1_BaseSrc_decide_allocation) + } + + if overrides.DoSeek != nil { + pclass.do_seek = (*[0]byte)(C._gotk4_gstbase1_BaseSrc_do_seek) + } + + if overrides.Event != nil { + pclass.event = (*[0]byte)(C._gotk4_gstbase1_BaseSrc_event) + } + + if overrides.Fill != nil { + pclass.fill = (*[0]byte)(C._gotk4_gstbase1_BaseSrc_fill) + } + + if overrides.Fixate != nil { + pclass.fixate = (*[0]byte)(C._gotk4_gstbase1_BaseSrc_fixate) + } + + if overrides.GetCaps != nil { + pclass.get_caps = (*[0]byte)(C._gotk4_gstbase1_BaseSrc_get_caps) + } + + if overrides.GetSize != nil { + pclass.get_size = (*[0]byte)(C._gotk4_gstbase1_BaseSrc_get_size) + } + + if overrides.GetTimes != nil { + pclass.get_times = (*[0]byte)(C._gotk4_gstbase1_BaseSrc_get_times) + } + + if overrides.IsSeekable != nil { + pclass.is_seekable = (*[0]byte)(C._gotk4_gstbase1_BaseSrc_is_seekable) + } + + if overrides.Negotiate != nil { + pclass.negotiate = (*[0]byte)(C._gotk4_gstbase1_BaseSrc_negotiate) + } + + if overrides.PrepareSeekSegment != nil { + pclass.prepare_seek_segment = (*[0]byte)(C._gotk4_gstbase1_BaseSrc_prepare_seek_segment) + } + + if overrides.Query != nil { + pclass.query = (*[0]byte)(C._gotk4_gstbase1_BaseSrc_query) + } + + if overrides.SetCaps != nil { + pclass.set_caps = (*[0]byte)(C._gotk4_gstbase1_BaseSrc_set_caps) + } + + if overrides.Start != nil { + pclass.start = (*[0]byte)(C._gotk4_gstbase1_BaseSrc_start) + } + + if overrides.Stop != nil { + pclass.stop = (*[0]byte)(C._gotk4_gstbase1_BaseSrc_stop) + } + + if overrides.Unlock != nil { + pclass.unlock = (*[0]byte)(C._gotk4_gstbase1_BaseSrc_unlock) + } + + if overrides.UnlockStop != nil { + pclass.unlock_stop = (*[0]byte)(C._gotk4_gstbase1_BaseSrc_unlock_stop) + } +} + // BaseTransformInstance is the instance type used by all types extending GstBaseTransform. It is used internally by the bindings. Users should use the interface [BaseTransform] instead. type BaseTransformInstance struct { _ [0]func() // equal guard @@ -6818,6 +8277,7 @@ type BaseTransform interface { upcastToGstBaseTransform() *BaseTransformInstance // GetAllocator wraps gst_base_transform_get_allocator + // // The function returns the following values: // // - allocator gst.Allocator (nullable): the #GstAllocator @@ -6830,11 +8290,13 @@ type BaseTransform interface { // Unref the @allocator after use. GetAllocator() (gst.Allocator, gst.AllocationParams) // GetBufferPool wraps gst_base_transform_get_buffer_pool + // // The function returns the following values: // // - goret gst.BufferPool (nullable) GetBufferPool() gst.BufferPool // IsInPlace wraps gst_base_transform_is_in_place + // // The function returns the following values: // // - goret bool @@ -6842,6 +8304,7 @@ type BaseTransform interface { // See if @trans is configured as a in_place transform. IsInPlace() bool // IsPassthrough wraps gst_base_transform_is_passthrough + // // The function returns the following values: // // - goret bool @@ -6849,6 +8312,7 @@ type BaseTransform interface { // See if @trans is configured as a passthrough transform. IsPassthrough() bool // IsQosEnabled wraps gst_base_transform_is_qos_enabled + // // The function returns the following values: // // - goret bool @@ -6856,6 +8320,7 @@ type BaseTransform interface { // Queries if the transform will handle QoS. IsQosEnabled() bool // Reconfigure wraps gst_base_transform_reconfigure + // // The function returns the following values: // // - goret bool @@ -7034,6 +8499,7 @@ func UnsafeBaseTransformToGlibFull(c BaseTransform) unsafe.Pointer { } // GetAllocator wraps gst_base_transform_get_allocator +// // The function returns the following values: // // - allocator gst.Allocator (nullable): the #GstAllocator @@ -7068,6 +8534,7 @@ func (trans *BaseTransformInstance) GetAllocator() (gst.Allocator, gst.Allocatio } // GetBufferPool wraps gst_base_transform_get_buffer_pool +// // The function returns the following values: // // - goret gst.BufferPool (nullable) @@ -7090,6 +8557,7 @@ func (trans *BaseTransformInstance) GetBufferPool() gst.BufferPool { } // IsInPlace wraps gst_base_transform_is_in_place +// // The function returns the following values: // // - goret bool @@ -7114,6 +8582,7 @@ func (trans *BaseTransformInstance) IsInPlace() bool { } // IsPassthrough wraps gst_base_transform_is_passthrough +// // The function returns the following values: // // - goret bool @@ -7138,6 +8607,7 @@ func (trans *BaseTransformInstance) IsPassthrough() bool { } // IsQosEnabled wraps gst_base_transform_is_qos_enabled +// // The function returns the following values: // // - goret bool @@ -7162,6 +8632,7 @@ func (trans *BaseTransformInstance) IsQosEnabled() bool { } // Reconfigure wraps gst_base_transform_reconfigure +// // The function returns the following values: // // - goret bool @@ -7432,6 +8903,314 @@ func (trans *BaseTransformInstance) UpdateSrcCaps(updatedCaps *gst.Caps) bool { return goret } +// BaseTransformOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type BaseTransformOverrides[Instance BaseTransform] struct { + // gst.ElementOverrides allows you to override virtual methods from the parent class gst.Element + gst.ElementOverrides[Instance] + + // AcceptCaps allows you to override the implementation of the virtual method accept_caps. + // The function takes the following parameters: + // + // - direction gst.PadDirection + // - caps *gst.Caps + // + // The function returns the following values: + // + // - goret bool + AcceptCaps func(Instance, gst.PadDirection, *gst.Caps) bool + // BeforeTransform allows you to override the implementation of the virtual method before_transform. + // The function takes the following parameters: + // + // - buffer *gst.Buffer + BeforeTransform func(Instance, *gst.Buffer) + // CopyMetadata allows you to override the implementation of the virtual method copy_metadata. + // The function takes the following parameters: + // + // - input *gst.Buffer + // - outbuf *gst.Buffer + // + // The function returns the following values: + // + // - goret bool + CopyMetadata func(Instance, *gst.Buffer, *gst.Buffer) bool + // DecideAllocation allows you to override the implementation of the virtual method decide_allocation. + // The function takes the following parameters: + // + // - query *gst.Query + // + // The function returns the following values: + // + // - goret bool + DecideAllocation func(Instance, *gst.Query) bool + // FilterMeta allows you to override the implementation of the virtual method filter_meta. + // The function takes the following parameters: + // + // - query *gst.Query + // - api gobject.Type + // - params *gst.Structure + // + // The function returns the following values: + // + // - goret bool + FilterMeta func(Instance, *gst.Query, gobject.Type, *gst.Structure) bool + // FixateCaps allows you to override the implementation of the virtual method fixate_caps. + // The function takes the following parameters: + // + // - direction gst.PadDirection + // - caps *gst.Caps + // - othercaps *gst.Caps + // + // The function returns the following values: + // + // - goret *gst.Caps + FixateCaps func(Instance, gst.PadDirection, *gst.Caps, *gst.Caps) *gst.Caps + // GenerateOutput allows you to override the implementation of the virtual method generate_output. + // The function returns the following values: + // + // - outbuf *gst.Buffer + // - goret gst.FlowReturn + GenerateOutput func(Instance) (*gst.Buffer, gst.FlowReturn) + // GetUnitSize allows you to override the implementation of the virtual method get_unit_size. + // The function takes the following parameters: + // + // - caps *gst.Caps + // + // The function returns the following values: + // + // - size uint + // - goret bool + GetUnitSize func(Instance, *gst.Caps) (uint, bool) + // PrepareOutputBuffer allows you to override the implementation of the virtual method prepare_output_buffer. + // The function takes the following parameters: + // + // - input *gst.Buffer + // + // The function returns the following values: + // + // - outbuf *gst.Buffer + // - goret gst.FlowReturn + PrepareOutputBuffer func(Instance, *gst.Buffer) (*gst.Buffer, gst.FlowReturn) + // ProposeAllocation allows you to override the implementation of the virtual method propose_allocation. + // The function takes the following parameters: + // + // - decideQuery *gst.Query + // - query *gst.Query + // + // The function returns the following values: + // + // - goret bool + ProposeAllocation func(Instance, *gst.Query, *gst.Query) bool + // Query allows you to override the implementation of the virtual method query. + // The function takes the following parameters: + // + // - direction gst.PadDirection + // - query *gst.Query + // + // The function returns the following values: + // + // - goret bool + Query func(Instance, gst.PadDirection, *gst.Query) bool + // SetCaps allows you to override the implementation of the virtual method set_caps. + // The function takes the following parameters: + // + // - incaps *gst.Caps + // - outcaps *gst.Caps + // + // The function returns the following values: + // + // - goret bool + SetCaps func(Instance, *gst.Caps, *gst.Caps) bool + // SinkEvent allows you to override the implementation of the virtual method sink_event. + // The function takes the following parameters: + // + // - event *gst.Event + // + // The function returns the following values: + // + // - goret bool + SinkEvent func(Instance, *gst.Event) bool + // SrcEvent allows you to override the implementation of the virtual method src_event. + // The function takes the following parameters: + // + // - event *gst.Event + // + // The function returns the following values: + // + // - goret bool + SrcEvent func(Instance, *gst.Event) bool + // Start allows you to override the implementation of the virtual method start. + // The function returns the following values: + // + // - goret bool + Start func(Instance) bool + // Stop allows you to override the implementation of the virtual method stop. + // The function returns the following values: + // + // - goret bool + Stop func(Instance) bool + // SubmitInputBuffer allows you to override the implementation of the virtual method submit_input_buffer. + // The function takes the following parameters: + // + // - isDiscont bool + // - input *gst.Buffer + // + // The function returns the following values: + // + // - goret gst.FlowReturn + SubmitInputBuffer func(Instance, bool, *gst.Buffer) gst.FlowReturn + // Transform allows you to override the implementation of the virtual method transform. + // The function takes the following parameters: + // + // - inbuf *gst.Buffer + // - outbuf *gst.Buffer + // + // The function returns the following values: + // + // - goret gst.FlowReturn + Transform func(Instance, *gst.Buffer, *gst.Buffer) gst.FlowReturn + // TransformCaps allows you to override the implementation of the virtual method transform_caps. + // The function takes the following parameters: + // + // - direction gst.PadDirection + // - caps *gst.Caps + // - filter *gst.Caps + // + // The function returns the following values: + // + // - goret *gst.Caps + TransformCaps func(Instance, gst.PadDirection, *gst.Caps, *gst.Caps) *gst.Caps + // TransformIP allows you to override the implementation of the virtual method transform_ip. + // The function takes the following parameters: + // + // - buf *gst.Buffer + // + // The function returns the following values: + // + // - goret gst.FlowReturn + TransformIP func(Instance, *gst.Buffer) gst.FlowReturn + // TransformMeta allows you to override the implementation of the virtual method transform_meta. + // The function takes the following parameters: + // + // - outbuf *gst.Buffer + // - meta *gst.Meta + // - inbuf *gst.Buffer + // + // The function returns the following values: + // + // - goret bool + TransformMeta func(Instance, *gst.Buffer, *gst.Meta, *gst.Buffer) bool + // TransformSize allows you to override the implementation of the virtual method transform_size. + // The function takes the following parameters: + // + // - direction gst.PadDirection + // - caps *gst.Caps + // - size uint + // - othercaps *gst.Caps + // + // The function returns the following values: + // + // - othersize uint + // - goret bool + TransformSize func(Instance, gst.PadDirection, *gst.Caps, uint, *gst.Caps) (uint, bool) +} + +// UnsafeApplyBaseTransformOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyBaseTransformOverrides[Instance BaseTransform](gclass unsafe.Pointer, overrides BaseTransformOverrides[Instance]) { + gst.UnsafeApplyElementOverrides(gclass, overrides.ElementOverrides) + + pclass := (*C.GstBaseTransformClass)(gclass) + + if overrides.AcceptCaps != nil { + pclass.accept_caps = (*[0]byte)(C._gotk4_gstbase1_BaseTransform_accept_caps) + } + + if overrides.BeforeTransform != nil { + pclass.before_transform = (*[0]byte)(C._gotk4_gstbase1_BaseTransform_before_transform) + } + + if overrides.CopyMetadata != nil { + pclass.copy_metadata = (*[0]byte)(C._gotk4_gstbase1_BaseTransform_copy_metadata) + } + + if overrides.DecideAllocation != nil { + pclass.decide_allocation = (*[0]byte)(C._gotk4_gstbase1_BaseTransform_decide_allocation) + } + + if overrides.FilterMeta != nil { + pclass.filter_meta = (*[0]byte)(C._gotk4_gstbase1_BaseTransform_filter_meta) + } + + if overrides.FixateCaps != nil { + pclass.fixate_caps = (*[0]byte)(C._gotk4_gstbase1_BaseTransform_fixate_caps) + } + + if overrides.GenerateOutput != nil { + pclass.generate_output = (*[0]byte)(C._gotk4_gstbase1_BaseTransform_generate_output) + } + + if overrides.GetUnitSize != nil { + pclass.get_unit_size = (*[0]byte)(C._gotk4_gstbase1_BaseTransform_get_unit_size) + } + + if overrides.PrepareOutputBuffer != nil { + pclass.prepare_output_buffer = (*[0]byte)(C._gotk4_gstbase1_BaseTransform_prepare_output_buffer) + } + + if overrides.ProposeAllocation != nil { + pclass.propose_allocation = (*[0]byte)(C._gotk4_gstbase1_BaseTransform_propose_allocation) + } + + if overrides.Query != nil { + pclass.query = (*[0]byte)(C._gotk4_gstbase1_BaseTransform_query) + } + + if overrides.SetCaps != nil { + pclass.set_caps = (*[0]byte)(C._gotk4_gstbase1_BaseTransform_set_caps) + } + + if overrides.SinkEvent != nil { + pclass.sink_event = (*[0]byte)(C._gotk4_gstbase1_BaseTransform_sink_event) + } + + if overrides.SrcEvent != nil { + pclass.src_event = (*[0]byte)(C._gotk4_gstbase1_BaseTransform_src_event) + } + + if overrides.Start != nil { + pclass.start = (*[0]byte)(C._gotk4_gstbase1_BaseTransform_start) + } + + if overrides.Stop != nil { + pclass.stop = (*[0]byte)(C._gotk4_gstbase1_BaseTransform_stop) + } + + if overrides.SubmitInputBuffer != nil { + pclass.submit_input_buffer = (*[0]byte)(C._gotk4_gstbase1_BaseTransform_submit_input_buffer) + } + + if overrides.Transform != nil { + pclass.transform = (*[0]byte)(C._gotk4_gstbase1_BaseTransform_transform) + } + + if overrides.TransformCaps != nil { + pclass.transform_caps = (*[0]byte)(C._gotk4_gstbase1_BaseTransform_transform_caps) + } + + if overrides.TransformIP != nil { + pclass.transform_ip = (*[0]byte)(C._gotk4_gstbase1_BaseTransform_transform_ip) + } + + if overrides.TransformMeta != nil { + pclass.transform_meta = (*[0]byte)(C._gotk4_gstbase1_BaseTransform_transform_meta) + } + + if overrides.TransformSize != nil { + pclass.transform_size = (*[0]byte)(C._gotk4_gstbase1_BaseTransform_transform_size) + } +} + // CollectPadsInstance is the instance type used by all types extending GstCollectPads. It is used internally by the bindings. Users should use the interface [CollectPads] instead. type CollectPadsInstance struct { _ [0]func() // equal guard @@ -7483,6 +9262,7 @@ type CollectPads interface { upcastToGstCollectPads() *CollectPadsInstance // Available wraps gst_collect_pads_available + // // The function returns the following values: // // - goret uint @@ -7823,6 +9603,7 @@ func UnsafeCollectPadsToGlibFull(c CollectPads) unsafe.Pointer { } // NewCollectPads wraps gst_collect_pads_new +// // The function returns the following values: // // - goret CollectPads @@ -7843,6 +9624,7 @@ func NewCollectPads() CollectPads { } // Available wraps gst_collect_pads_available +// // The function returns the following values: // // - goret uint @@ -8506,6 +10288,20 @@ func (pads *CollectPadsInstance) TakeBuffer(data *CollectData, size uint) *gst.B return goret } +// CollectPadsOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type CollectPadsOverrides[Instance CollectPads] struct { + // gst.ObjectOverrides allows you to override virtual methods from the parent class gst.Object + gst.ObjectOverrides[Instance] + +} + +// UnsafeApplyCollectPadsOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyCollectPadsOverrides[Instance CollectPads](gclass unsafe.Pointer, overrides CollectPadsOverrides[Instance]) { + gst.UnsafeApplyObjectOverrides(gclass, overrides.ObjectOverrides) +} + // DataQueueInstance is the instance type used by all types extending GstDataQueue. It is used internally by the bindings. Users should use the interface [DataQueue] instead. type DataQueueInstance struct { _ [0]func() // equal guard @@ -8582,6 +10378,7 @@ func UnsafeDataQueueToGlibFull(c DataQueue) unsafe.Pointer { func (o *DataQueueInstance) ConnectEmpty(fn func(DataQueue)) gobject.SignalHandle { return o.Connect("empty", fn) } + // ConnectFull connects the provided callback to the "full" signal // // Reports that the queue became full (full). @@ -8591,6 +10388,35 @@ func (o *DataQueueInstance) ConnectEmpty(fn func(DataQueue)) gobject.SignalHandl func (o *DataQueueInstance) ConnectFull(fn func(DataQueue)) gobject.SignalHandle { return o.Connect("full", fn) } + +// DataQueueOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type DataQueueOverrides[Instance DataQueue] struct { + // gobject.ObjectOverrides allows you to override virtual methods from the parent class gobject.Object + gobject.ObjectOverrides[Instance] + + // Empty allows you to override the implementation of the virtual method empty. + Empty func(Instance) + // Full allows you to override the implementation of the virtual method full. + Full func(Instance) +} + +// UnsafeApplyDataQueueOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyDataQueueOverrides[Instance DataQueue](gclass unsafe.Pointer, overrides DataQueueOverrides[Instance]) { + gobject.UnsafeApplyObjectOverrides(gclass, overrides.ObjectOverrides) + + pclass := (*C.GstDataQueueClass)(gclass) + + if overrides.Empty != nil { + pclass.empty = (*[0]byte)(C._gotk4_gstbase1_DataQueue_empty) + } + + if overrides.Full != nil { + pclass.full = (*[0]byte)(C._gotk4_gstbase1_DataQueue_full) + } +} + // PushSrcInstance is the instance type used by all types extending GstPushSrc. It is used internally by the bindings. Users should use the interface [PushSrc] instead. type PushSrcInstance struct { _ [0]func() // equal guard @@ -8667,7 +10493,48 @@ func UnsafePushSrcToGlibFull(c PushSrc) unsafe.Pointer { return gobject.UnsafeObjectToGlibFull(c) } +// PushSrcOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type PushSrcOverrides[Instance PushSrc] struct { + // BaseSrcOverrides allows you to override virtual methods from the parent class BaseSrc + BaseSrcOverrides[Instance] + + // Alloc allows you to override the implementation of the virtual method alloc. + // The function returns the following values: + // + // - buf *gst.Buffer (nullable) + // - goret gst.FlowReturn + Alloc func(Instance) (*gst.Buffer, gst.FlowReturn) + // Fill allows you to override the implementation of the virtual method fill. + // The function takes the following parameters: + // + // - buf *gst.Buffer + // + // The function returns the following values: + // + // - goret gst.FlowReturn + Fill func(Instance, *gst.Buffer) gst.FlowReturn +} + +// UnsafeApplyPushSrcOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyPushSrcOverrides[Instance PushSrc](gclass unsafe.Pointer, overrides PushSrcOverrides[Instance]) { + UnsafeApplyBaseSrcOverrides(gclass, overrides.BaseSrcOverrides) + + pclass := (*C.GstPushSrcClass)(gclass) + + if overrides.Alloc != nil { + pclass.alloc = (*[0]byte)(C._gotk4_gstbase1_PushSrc_alloc) + } + + if overrides.Fill != nil { + pclass.fill = (*[0]byte)(C._gotk4_gstbase1_PushSrc_fill) + } +} + // AdapterClass wraps GstAdapterClass +// +// AdapterClass is the type struct for [Adapter] type AdapterClass struct { *adapterClass } @@ -8682,31 +10549,6 @@ func UnsafeAdapterClassFromGlibBorrow(p unsafe.Pointer) *AdapterClass { return &AdapterClass{&adapterClass{(*C.GstAdapterClass)(p)}} } -// UnsafeAdapterClassFromGlibNone is used to convert raw C.GstAdapterClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeAdapterClassFromGlibNone(p unsafe.Pointer) *AdapterClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeAdapterClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.adapterClass, - func (intern *adapterClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeAdapterClassFromGlibFull is used to convert raw C.GstAdapterClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeAdapterClassFromGlibFull(p unsafe.Pointer) *AdapterClass { - wrapped := UnsafeAdapterClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.adapterClass, - func (intern *adapterClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeAdapterClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [AdapterClass] is expected to work anymore. @@ -8719,14 +10561,15 @@ func UnsafeAdapterClassToGlibNone(a *AdapterClass) unsafe.Pointer { return unsafe.Pointer(a.native) } -// UnsafeAdapterClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeAdapterClassToGlibFull(a *AdapterClass) unsafe.Pointer { - runtime.SetFinalizer(a.adapterClass, nil) - _p := unsafe.Pointer(a.native) - a.native = nil // AdapterClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (a *AdapterClass) ParentClass() *gobject.ObjectClass { + parent := gobject.UnsafeObjectClassFromGlibBorrow(UnsafeAdapterClassToGlibNone(a)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *AdapterClass) {}, a) + return parent } + // AggregatorClass wraps GstAggregatorClass // // The aggregator base class will handle in a thread-safe way all manners of @@ -8738,6 +10581,8 @@ func UnsafeAdapterClassToGlibFull(a *AdapterClass) unsafe.Pointer { // // Basically, a simple implementation will override @aggregate, and call // _finish_buffer from inside that function. +// +// AggregatorClass is the type struct for [Aggregator] type AggregatorClass struct { *aggregatorClass } @@ -8752,31 +10597,6 @@ func UnsafeAggregatorClassFromGlibBorrow(p unsafe.Pointer) *AggregatorClass { return &AggregatorClass{&aggregatorClass{(*C.GstAggregatorClass)(p)}} } -// UnsafeAggregatorClassFromGlibNone is used to convert raw C.GstAggregatorClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeAggregatorClassFromGlibNone(p unsafe.Pointer) *AggregatorClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeAggregatorClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.aggregatorClass, - func (intern *aggregatorClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeAggregatorClassFromGlibFull is used to convert raw C.GstAggregatorClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeAggregatorClassFromGlibFull(p unsafe.Pointer) *AggregatorClass { - wrapped := UnsafeAggregatorClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.aggregatorClass, - func (intern *aggregatorClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeAggregatorClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [AggregatorClass] is expected to work anymore. @@ -8789,15 +10609,18 @@ func UnsafeAggregatorClassToGlibNone(a *AggregatorClass) unsafe.Pointer { return unsafe.Pointer(a.native) } -// UnsafeAggregatorClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeAggregatorClassToGlibFull(a *AggregatorClass) unsafe.Pointer { - runtime.SetFinalizer(a.aggregatorClass, nil) - _p := unsafe.Pointer(a.native) - a.native = nil // AggregatorClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (a *AggregatorClass) ParentClass() *gst.ElementClass { + parent := gst.UnsafeElementClassFromGlibBorrow(UnsafeAggregatorClassToGlibNone(a)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *AggregatorClass) {}, a) + return parent } + // AggregatorPadClass wraps GstAggregatorPadClass +// +// AggregatorPadClass is the type struct for [AggregatorPad] type AggregatorPadClass struct { *aggregatorPadClass } @@ -8812,31 +10635,6 @@ func UnsafeAggregatorPadClassFromGlibBorrow(p unsafe.Pointer) *AggregatorPadClas return &AggregatorPadClass{&aggregatorPadClass{(*C.GstAggregatorPadClass)(p)}} } -// UnsafeAggregatorPadClassFromGlibNone is used to convert raw C.GstAggregatorPadClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeAggregatorPadClassFromGlibNone(p unsafe.Pointer) *AggregatorPadClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeAggregatorPadClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.aggregatorPadClass, - func (intern *aggregatorPadClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeAggregatorPadClassFromGlibFull is used to convert raw C.GstAggregatorPadClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeAggregatorPadClassFromGlibFull(p unsafe.Pointer) *AggregatorPadClass { - wrapped := UnsafeAggregatorPadClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.aggregatorPadClass, - func (intern *aggregatorPadClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeAggregatorPadClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [AggregatorPadClass] is expected to work anymore. @@ -8849,18 +10647,21 @@ func UnsafeAggregatorPadClassToGlibNone(a *AggregatorPadClass) unsafe.Pointer { return unsafe.Pointer(a.native) } -// UnsafeAggregatorPadClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeAggregatorPadClassToGlibFull(a *AggregatorPadClass) unsafe.Pointer { - runtime.SetFinalizer(a.aggregatorPadClass, nil) - _p := unsafe.Pointer(a.native) - a.native = nil // AggregatorPadClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (a *AggregatorPadClass) ParentClass() *gst.PadClass { + parent := gst.UnsafePadClassFromGlibBorrow(UnsafeAggregatorPadClassToGlibNone(a)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *AggregatorPadClass) {}, a) + return parent } + // BaseParseClass wraps GstBaseParseClass // // Subclasses can override any of the available virtual methods or not, as // needed. At minimum @handle_frame needs to be overridden. +// +// BaseParseClass is the type struct for [BaseParse] type BaseParseClass struct { *baseParseClass } @@ -8875,31 +10676,6 @@ func UnsafeBaseParseClassFromGlibBorrow(p unsafe.Pointer) *BaseParseClass { return &BaseParseClass{&baseParseClass{(*C.GstBaseParseClass)(p)}} } -// UnsafeBaseParseClassFromGlibNone is used to convert raw C.GstBaseParseClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeBaseParseClassFromGlibNone(p unsafe.Pointer) *BaseParseClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeBaseParseClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.baseParseClass, - func (intern *baseParseClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeBaseParseClassFromGlibFull is used to convert raw C.GstBaseParseClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeBaseParseClassFromGlibFull(p unsafe.Pointer) *BaseParseClass { - wrapped := UnsafeBaseParseClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.baseParseClass, - func (intern *baseParseClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeBaseParseClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [BaseParseClass] is expected to work anymore. @@ -8912,14 +10688,15 @@ func UnsafeBaseParseClassToGlibNone(b *BaseParseClass) unsafe.Pointer { return unsafe.Pointer(b.native) } -// UnsafeBaseParseClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeBaseParseClassToGlibFull(b *BaseParseClass) unsafe.Pointer { - runtime.SetFinalizer(b.baseParseClass, nil) - _p := unsafe.Pointer(b.native) - b.native = nil // BaseParseClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (b *BaseParseClass) ParentClass() *gst.ElementClass { + parent := gst.UnsafeElementClassFromGlibBorrow(UnsafeBaseParseClassToGlibNone(b)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *BaseParseClass) {}, b) + return parent } + // BaseParseFrame wraps GstBaseParseFrame // // Frame (context) data passed to each frame parsing virtual methods. In @@ -8955,7 +10732,7 @@ func UnsafeBaseParseFrameFromGlibBorrow(p unsafe.Pointer) *BaseParseFrame { return &BaseParseFrame{&baseParseFrame{(*C.GstBaseParseFrame)(p)}} } -// UnsafeBaseParseFrameFromGlibNone is used to convert raw C.GstBaseParseFrame pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeBaseParseFrameFromGlibNone is used to convert raw C.GstBaseParseFrame pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeBaseParseFrameFromGlibNone(p unsafe.Pointer) *BaseParseFrame { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeBaseParseFrameFromGlibBorrow(p) @@ -8968,7 +10745,7 @@ func UnsafeBaseParseFrameFromGlibNone(p unsafe.Pointer) *BaseParseFrame { return wrapped } -// UnsafeBaseParseFrameFromGlibFull is used to convert raw C.GstBaseParseFrame pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeBaseParseFrameFromGlibFull is used to convert raw C.GstBaseParseFrame pointers to go while taking ownership. This is used by the bindings internally. func UnsafeBaseParseFrameFromGlibFull(p unsafe.Pointer) *BaseParseFrame { wrapped := UnsafeBaseParseFrameFromGlibBorrow(p) runtime.SetFinalizer( @@ -9000,6 +10777,7 @@ func UnsafeBaseParseFrameToGlibFull(b *BaseParseFrame) unsafe.Pointer { b.native = nil // BaseParseFrame is invalid from here on return _p } + // NewBaseParseFrame wraps gst_base_parse_frame_new // // The function takes the following parameters: @@ -9040,6 +10818,7 @@ func NewBaseParseFrame(buffer *gst.Buffer, flags BaseParseFrameFlags, overhead i } // Copy wraps gst_base_parse_frame_copy +// // The function returns the following values: // // - goret *BaseParseFrame @@ -9082,6 +10861,8 @@ func (frame *BaseParseFrame) Init() { // Subclasses can override any of the available virtual methods or not, as // needed. At the minimum, the @render method should be overridden to // output/present buffers. +// +// BaseSinkClass is the type struct for [BaseSink] type BaseSinkClass struct { *baseSinkClass } @@ -9096,31 +10877,6 @@ func UnsafeBaseSinkClassFromGlibBorrow(p unsafe.Pointer) *BaseSinkClass { return &BaseSinkClass{&baseSinkClass{(*C.GstBaseSinkClass)(p)}} } -// UnsafeBaseSinkClassFromGlibNone is used to convert raw C.GstBaseSinkClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeBaseSinkClassFromGlibNone(p unsafe.Pointer) *BaseSinkClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeBaseSinkClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.baseSinkClass, - func (intern *baseSinkClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeBaseSinkClassFromGlibFull is used to convert raw C.GstBaseSinkClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeBaseSinkClassFromGlibFull(p unsafe.Pointer) *BaseSinkClass { - wrapped := UnsafeBaseSinkClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.baseSinkClass, - func (intern *baseSinkClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeBaseSinkClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [BaseSinkClass] is expected to work anymore. @@ -9133,19 +10889,22 @@ func UnsafeBaseSinkClassToGlibNone(b *BaseSinkClass) unsafe.Pointer { return unsafe.Pointer(b.native) } -// UnsafeBaseSinkClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeBaseSinkClassToGlibFull(b *BaseSinkClass) unsafe.Pointer { - runtime.SetFinalizer(b.baseSinkClass, nil) - _p := unsafe.Pointer(b.native) - b.native = nil // BaseSinkClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (b *BaseSinkClass) ParentClass() *gst.ElementClass { + parent := gst.UnsafeElementClassFromGlibBorrow(UnsafeBaseSinkClassToGlibNone(b)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *BaseSinkClass) {}, b) + return parent } + // BaseSrcClass wraps GstBaseSrcClass // // Subclasses can override any of the available virtual methods or not, as // needed. At the minimum, the @create method should be overridden to produce // buffers. +// +// BaseSrcClass is the type struct for [BaseSrc] type BaseSrcClass struct { *baseSrcClass } @@ -9160,31 +10919,6 @@ func UnsafeBaseSrcClassFromGlibBorrow(p unsafe.Pointer) *BaseSrcClass { return &BaseSrcClass{&baseSrcClass{(*C.GstBaseSrcClass)(p)}} } -// UnsafeBaseSrcClassFromGlibNone is used to convert raw C.GstBaseSrcClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeBaseSrcClassFromGlibNone(p unsafe.Pointer) *BaseSrcClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeBaseSrcClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.baseSrcClass, - func (intern *baseSrcClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeBaseSrcClassFromGlibFull is used to convert raw C.GstBaseSrcClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeBaseSrcClassFromGlibFull(p unsafe.Pointer) *BaseSrcClass { - wrapped := UnsafeBaseSrcClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.baseSrcClass, - func (intern *baseSrcClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeBaseSrcClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [BaseSrcClass] is expected to work anymore. @@ -9197,20 +10931,23 @@ func UnsafeBaseSrcClassToGlibNone(b *BaseSrcClass) unsafe.Pointer { return unsafe.Pointer(b.native) } -// UnsafeBaseSrcClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeBaseSrcClassToGlibFull(b *BaseSrcClass) unsafe.Pointer { - runtime.SetFinalizer(b.baseSrcClass, nil) - _p := unsafe.Pointer(b.native) - b.native = nil // BaseSrcClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (b *BaseSrcClass) ParentClass() *gst.ElementClass { + parent := gst.UnsafeElementClassFromGlibBorrow(UnsafeBaseSrcClassToGlibNone(b)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *BaseSrcClass) {}, b) + return parent } + // BaseTransformClass wraps GstBaseTransformClass // // Subclasses can override any of the available virtual methods or not, as // needed. At minimum either @transform or @transform_ip need to be overridden. // If the element can overwrite the input data with the results (data is of the // same type and quantity) it should provide @transform_ip. +// +// BaseTransformClass is the type struct for [BaseTransform] type BaseTransformClass struct { *baseTransformClass } @@ -9225,31 +10962,6 @@ func UnsafeBaseTransformClassFromGlibBorrow(p unsafe.Pointer) *BaseTransformClas return &BaseTransformClass{&baseTransformClass{(*C.GstBaseTransformClass)(p)}} } -// UnsafeBaseTransformClassFromGlibNone is used to convert raw C.GstBaseTransformClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeBaseTransformClassFromGlibNone(p unsafe.Pointer) *BaseTransformClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeBaseTransformClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.baseTransformClass, - func (intern *baseTransformClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeBaseTransformClassFromGlibFull is used to convert raw C.GstBaseTransformClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeBaseTransformClassFromGlibFull(p unsafe.Pointer) *BaseTransformClass { - wrapped := UnsafeBaseTransformClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.baseTransformClass, - func (intern *baseTransformClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeBaseTransformClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [BaseTransformClass] is expected to work anymore. @@ -9262,14 +10974,15 @@ func UnsafeBaseTransformClassToGlibNone(b *BaseTransformClass) unsafe.Pointer { return unsafe.Pointer(b.native) } -// UnsafeBaseTransformClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeBaseTransformClassToGlibFull(b *BaseTransformClass) unsafe.Pointer { - runtime.SetFinalizer(b.baseTransformClass, nil) - _p := unsafe.Pointer(b.native) - b.native = nil // BaseTransformClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (b *BaseTransformClass) ParentClass() *gst.ElementClass { + parent := gst.UnsafeElementClassFromGlibBorrow(UnsafeBaseTransformClassToGlibNone(b)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *BaseTransformClass) {}, b) + return parent } + // BitReader wraps GstBitReader // // #GstBitReader provides a bit reader that can read any number of bits @@ -9289,7 +11002,7 @@ func UnsafeBitReaderFromGlibBorrow(p unsafe.Pointer) *BitReader { return &BitReader{&bitReader{(*C.GstBitReader)(p)}} } -// UnsafeBitReaderFromGlibNone is used to convert raw C.GstBitReader pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeBitReaderFromGlibNone is used to convert raw C.GstBitReader pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeBitReaderFromGlibNone(p unsafe.Pointer) *BitReader { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeBitReaderFromGlibBorrow(p) @@ -9302,7 +11015,7 @@ func UnsafeBitReaderFromGlibNone(p unsafe.Pointer) *BitReader { return wrapped } -// UnsafeBitReaderFromGlibFull is used to convert raw C.GstBitReader pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeBitReaderFromGlibFull is used to convert raw C.GstBitReader pointers to go while taking ownership. This is used by the bindings internally. func UnsafeBitReaderFromGlibFull(p unsafe.Pointer) *BitReader { wrapped := UnsafeBitReaderFromGlibBorrow(p) runtime.SetFinalizer( @@ -9334,6 +11047,7 @@ func UnsafeBitReaderToGlibFull(b *BitReader) unsafe.Pointer { b.native = nil // BitReader is invalid from here on return _p } + // GetBitsUint16 wraps gst_bit_reader_get_bits_uint16 // // The function takes the following parameters: @@ -9479,6 +11193,7 @@ func (reader *BitReader) GetBitsUint8(nbits uint) (uint8, bool) { } // GetPos wraps gst_bit_reader_get_pos +// // The function returns the following values: // // - goret uint @@ -9501,6 +11216,7 @@ func (reader *BitReader) GetPos() uint { } // GetRemaining wraps gst_bit_reader_get_remaining +// // The function returns the following values: // // - goret uint @@ -9523,6 +11239,7 @@ func (reader *BitReader) GetRemaining() uint { } // GetSize wraps gst_bit_reader_get_size +// // The function returns the following values: // // - goret uint @@ -9777,6 +11494,7 @@ func (reader *BitReader) Skip(nbits uint) bool { } // SkipToByte wraps gst_bit_reader_skip_to_byte +// // The function returns the following values: // // - goret bool @@ -9819,7 +11537,7 @@ func UnsafeBitWriterFromGlibBorrow(p unsafe.Pointer) *BitWriter { return &BitWriter{&bitWriter{(*C.GstBitWriter)(p)}} } -// UnsafeBitWriterFromGlibNone is used to convert raw C.GstBitWriter pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeBitWriterFromGlibNone is used to convert raw C.GstBitWriter pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeBitWriterFromGlibNone(p unsafe.Pointer) *BitWriter { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeBitWriterFromGlibBorrow(p) @@ -9832,7 +11550,7 @@ func UnsafeBitWriterFromGlibNone(p unsafe.Pointer) *BitWriter { return wrapped } -// UnsafeBitWriterFromGlibFull is used to convert raw C.GstBitWriter pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeBitWriterFromGlibFull is used to convert raw C.GstBitWriter pointers to go while taking ownership. This is used by the bindings internally. func UnsafeBitWriterFromGlibFull(p unsafe.Pointer) *BitWriter { wrapped := UnsafeBitWriterFromGlibBorrow(p) runtime.SetFinalizer( @@ -9864,6 +11582,7 @@ func UnsafeBitWriterToGlibFull(b *BitWriter) unsafe.Pointer { b.native = nil // BitWriter is invalid from here on return _p } + // AlignBytes wraps gst_bit_writer_align_bytes // // The function takes the following parameters: @@ -9898,6 +11617,7 @@ func (bitwriter *BitWriter) AlignBytes(trailingBit uint8) bool { } // FreeAndGetBuffer wraps gst_bit_writer_free_and_get_buffer +// // The function returns the following values: // // - goret *gst.Buffer @@ -9923,6 +11643,7 @@ func (bitwriter *BitWriter) FreeAndGetBuffer() *gst.Buffer { } // GetRemaining wraps gst_bit_writer_get_remaining +// // The function returns the following values: // // - goret uint @@ -9943,6 +11664,7 @@ func (bitwriter *BitWriter) GetRemaining() uint { } // GetSize wraps gst_bit_writer_get_size +// // The function returns the following values: // // - goret uint @@ -10121,6 +11843,7 @@ func (bitwriter *BitWriter) Reset() { } // ResetAndGetBuffer wraps gst_bit_writer_reset_and_get_buffer +// // The function returns the following values: // // - goret *gst.Buffer @@ -10196,7 +11919,7 @@ func UnsafeByteReaderFromGlibBorrow(p unsafe.Pointer) *ByteReader { return &ByteReader{&byteReader{(*C.GstByteReader)(p)}} } -// UnsafeByteReaderFromGlibNone is used to convert raw C.GstByteReader pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeByteReaderFromGlibNone is used to convert raw C.GstByteReader pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeByteReaderFromGlibNone(p unsafe.Pointer) *ByteReader { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeByteReaderFromGlibBorrow(p) @@ -10209,7 +11932,7 @@ func UnsafeByteReaderFromGlibNone(p unsafe.Pointer) *ByteReader { return wrapped } -// UnsafeByteReaderFromGlibFull is used to convert raw C.GstByteReader pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeByteReaderFromGlibFull is used to convert raw C.GstByteReader pointers to go while taking ownership. This is used by the bindings internally. func UnsafeByteReaderFromGlibFull(p unsafe.Pointer) *ByteReader { wrapped := UnsafeByteReaderFromGlibBorrow(p) runtime.SetFinalizer( @@ -10241,7 +11964,9 @@ func UnsafeByteReaderToGlibFull(b *ByteReader) unsafe.Pointer { b.native = nil // ByteReader is invalid from here on return _p } + // DupStringUTF8 wraps gst_byte_reader_dup_string_utf8 +// // The function returns the following values: // // - str string: address of a @@ -10280,6 +12005,7 @@ func (reader *ByteReader) DupStringUTF8() (string, bool) { } // GetFloat32Be wraps gst_byte_reader_get_float32_be +// // The function returns the following values: // // - val float32: Pointer to a #gfloat to store the result @@ -10309,6 +12035,7 @@ func (reader *ByteReader) GetFloat32Be() (float32, bool) { } // GetFloat32LE wraps gst_byte_reader_get_float32_le +// // The function returns the following values: // // - val float32: Pointer to a #gfloat to store the result @@ -10338,6 +12065,7 @@ func (reader *ByteReader) GetFloat32LE() (float32, bool) { } // GetFloat64Be wraps gst_byte_reader_get_float64_be +// // The function returns the following values: // // - val float64: Pointer to a #gdouble to store the result @@ -10367,6 +12095,7 @@ func (reader *ByteReader) GetFloat64Be() (float64, bool) { } // GetFloat64LE wraps gst_byte_reader_get_float64_le +// // The function returns the following values: // // - val float64: Pointer to a #gdouble to store the result @@ -10396,6 +12125,7 @@ func (reader *ByteReader) GetFloat64LE() (float64, bool) { } // GetInt16Be wraps gst_byte_reader_get_int16_be +// // The function returns the following values: // // - val int16: Pointer to a #gint16 to store the result @@ -10425,6 +12155,7 @@ func (reader *ByteReader) GetInt16Be() (int16, bool) { } // GetInt16LE wraps gst_byte_reader_get_int16_le +// // The function returns the following values: // // - val int16: Pointer to a #gint16 to store the result @@ -10454,6 +12185,7 @@ func (reader *ByteReader) GetInt16LE() (int16, bool) { } // GetInt24Be wraps gst_byte_reader_get_int24_be +// // The function returns the following values: // // - val int32: Pointer to a #gint32 to store the result @@ -10483,6 +12215,7 @@ func (reader *ByteReader) GetInt24Be() (int32, bool) { } // GetInt24LE wraps gst_byte_reader_get_int24_le +// // The function returns the following values: // // - val int32: Pointer to a #gint32 to store the result @@ -10512,6 +12245,7 @@ func (reader *ByteReader) GetInt24LE() (int32, bool) { } // GetInt32Be wraps gst_byte_reader_get_int32_be +// // The function returns the following values: // // - val int32: Pointer to a #gint32 to store the result @@ -10541,6 +12275,7 @@ func (reader *ByteReader) GetInt32Be() (int32, bool) { } // GetInt32LE wraps gst_byte_reader_get_int32_le +// // The function returns the following values: // // - val int32: Pointer to a #gint32 to store the result @@ -10570,6 +12305,7 @@ func (reader *ByteReader) GetInt32LE() (int32, bool) { } // GetInt64Be wraps gst_byte_reader_get_int64_be +// // The function returns the following values: // // - val int64: Pointer to a #gint64 to store the result @@ -10599,6 +12335,7 @@ func (reader *ByteReader) GetInt64Be() (int64, bool) { } // GetInt64LE wraps gst_byte_reader_get_int64_le +// // The function returns the following values: // // - val int64: Pointer to a #gint64 to store the result @@ -10628,6 +12365,7 @@ func (reader *ByteReader) GetInt64LE() (int64, bool) { } // GetInt8 wraps gst_byte_reader_get_int8 +// // The function returns the following values: // // - val int8: Pointer to a #gint8 to store the result @@ -10656,6 +12394,7 @@ func (reader *ByteReader) GetInt8() (int8, bool) { } // GetPos wraps gst_byte_reader_get_pos +// // The function returns the following values: // // - goret uint @@ -10678,6 +12417,7 @@ func (reader *ByteReader) GetPos() uint { } // GetRemaining wraps gst_byte_reader_get_remaining +// // The function returns the following values: // // - goret uint @@ -10700,6 +12440,7 @@ func (reader *ByteReader) GetRemaining() uint { } // GetSize wraps gst_byte_reader_get_size +// // The function returns the following values: // // - goret uint @@ -10722,6 +12463,7 @@ func (reader *ByteReader) GetSize() uint { } // GetStringUTF8 wraps gst_byte_reader_get_string_utf8 +// // The function returns the following values: // // - str string: address of a @@ -10761,6 +12503,7 @@ func (reader *ByteReader) GetStringUTF8() (string, bool) { } // GetUint16Be wraps gst_byte_reader_get_uint16_be +// // The function returns the following values: // // - val uint16: Pointer to a #guint16 to store the result @@ -10790,6 +12533,7 @@ func (reader *ByteReader) GetUint16Be() (uint16, bool) { } // GetUint16LE wraps gst_byte_reader_get_uint16_le +// // The function returns the following values: // // - val uint16: Pointer to a #guint16 to store the result @@ -10819,6 +12563,7 @@ func (reader *ByteReader) GetUint16LE() (uint16, bool) { } // GetUint24Be wraps gst_byte_reader_get_uint24_be +// // The function returns the following values: // // - val uint32: Pointer to a #guint32 to store the result @@ -10848,6 +12593,7 @@ func (reader *ByteReader) GetUint24Be() (uint32, bool) { } // GetUint24LE wraps gst_byte_reader_get_uint24_le +// // The function returns the following values: // // - val uint32: Pointer to a #guint32 to store the result @@ -10877,6 +12623,7 @@ func (reader *ByteReader) GetUint24LE() (uint32, bool) { } // GetUint32Be wraps gst_byte_reader_get_uint32_be +// // The function returns the following values: // // - val uint32: Pointer to a #guint32 to store the result @@ -10906,6 +12653,7 @@ func (reader *ByteReader) GetUint32Be() (uint32, bool) { } // GetUint32LE wraps gst_byte_reader_get_uint32_le +// // The function returns the following values: // // - val uint32: Pointer to a #guint32 to store the result @@ -10935,6 +12683,7 @@ func (reader *ByteReader) GetUint32LE() (uint32, bool) { } // GetUint64Be wraps gst_byte_reader_get_uint64_be +// // The function returns the following values: // // - val uint64: Pointer to a #guint64 to store the result @@ -10964,6 +12713,7 @@ func (reader *ByteReader) GetUint64Be() (uint64, bool) { } // GetUint64LE wraps gst_byte_reader_get_uint64_le +// // The function returns the following values: // // - val uint64: Pointer to a #guint64 to store the result @@ -10993,6 +12743,7 @@ func (reader *ByteReader) GetUint64LE() (uint64, bool) { } // GetUint8 wraps gst_byte_reader_get_uint8 +// // The function returns the following values: // // - val uint8: Pointer to a #guint8 to store the result @@ -11154,6 +12905,7 @@ func (reader *ByteReader) MaskedScanUint32Peek(mask uint32, pattern uint32, offs } // PeekFloat32Be wraps gst_byte_reader_peek_float32_be +// // The function returns the following values: // // - val float32: Pointer to a #gfloat to store the result @@ -11183,6 +12935,7 @@ func (reader *ByteReader) PeekFloat32Be() (float32, bool) { } // PeekFloat32LE wraps gst_byte_reader_peek_float32_le +// // The function returns the following values: // // - val float32: Pointer to a #gfloat to store the result @@ -11212,6 +12965,7 @@ func (reader *ByteReader) PeekFloat32LE() (float32, bool) { } // PeekFloat64Be wraps gst_byte_reader_peek_float64_be +// // The function returns the following values: // // - val float64: Pointer to a #gdouble to store the result @@ -11241,6 +12995,7 @@ func (reader *ByteReader) PeekFloat64Be() (float64, bool) { } // PeekFloat64LE wraps gst_byte_reader_peek_float64_le +// // The function returns the following values: // // - val float64: Pointer to a #gdouble to store the result @@ -11270,6 +13025,7 @@ func (reader *ByteReader) PeekFloat64LE() (float64, bool) { } // PeekInt16Be wraps gst_byte_reader_peek_int16_be +// // The function returns the following values: // // - val int16: Pointer to a #gint16 to store the result @@ -11299,6 +13055,7 @@ func (reader *ByteReader) PeekInt16Be() (int16, bool) { } // PeekInt16LE wraps gst_byte_reader_peek_int16_le +// // The function returns the following values: // // - val int16: Pointer to a #gint16 to store the result @@ -11328,6 +13085,7 @@ func (reader *ByteReader) PeekInt16LE() (int16, bool) { } // PeekInt24Be wraps gst_byte_reader_peek_int24_be +// // The function returns the following values: // // - val int32: Pointer to a #gint32 to store the result @@ -11357,6 +13115,7 @@ func (reader *ByteReader) PeekInt24Be() (int32, bool) { } // PeekInt24LE wraps gst_byte_reader_peek_int24_le +// // The function returns the following values: // // - val int32: Pointer to a #gint32 to store the result @@ -11386,6 +13145,7 @@ func (reader *ByteReader) PeekInt24LE() (int32, bool) { } // PeekInt32Be wraps gst_byte_reader_peek_int32_be +// // The function returns the following values: // // - val int32: Pointer to a #gint32 to store the result @@ -11415,6 +13175,7 @@ func (reader *ByteReader) PeekInt32Be() (int32, bool) { } // PeekInt32LE wraps gst_byte_reader_peek_int32_le +// // The function returns the following values: // // - val int32: Pointer to a #gint32 to store the result @@ -11444,6 +13205,7 @@ func (reader *ByteReader) PeekInt32LE() (int32, bool) { } // PeekInt64Be wraps gst_byte_reader_peek_int64_be +// // The function returns the following values: // // - val int64: Pointer to a #gint64 to store the result @@ -11473,6 +13235,7 @@ func (reader *ByteReader) PeekInt64Be() (int64, bool) { } // PeekInt64LE wraps gst_byte_reader_peek_int64_le +// // The function returns the following values: // // - val int64: Pointer to a #gint64 to store the result @@ -11502,6 +13265,7 @@ func (reader *ByteReader) PeekInt64LE() (int64, bool) { } // PeekInt8 wraps gst_byte_reader_peek_int8 +// // The function returns the following values: // // - val int8: Pointer to a #gint8 to store the result @@ -11530,6 +13294,7 @@ func (reader *ByteReader) PeekInt8() (int8, bool) { } // PeekStringUTF8 wraps gst_byte_reader_peek_string_utf8 +// // The function returns the following values: // // - str string: address of a @@ -11569,6 +13334,7 @@ func (reader *ByteReader) PeekStringUTF8() (string, bool) { } // PeekUint16Be wraps gst_byte_reader_peek_uint16_be +// // The function returns the following values: // // - val uint16: Pointer to a #guint16 to store the result @@ -11598,6 +13364,7 @@ func (reader *ByteReader) PeekUint16Be() (uint16, bool) { } // PeekUint16LE wraps gst_byte_reader_peek_uint16_le +// // The function returns the following values: // // - val uint16: Pointer to a #guint16 to store the result @@ -11627,6 +13394,7 @@ func (reader *ByteReader) PeekUint16LE() (uint16, bool) { } // PeekUint24Be wraps gst_byte_reader_peek_uint24_be +// // The function returns the following values: // // - val uint32: Pointer to a #guint32 to store the result @@ -11656,6 +13424,7 @@ func (reader *ByteReader) PeekUint24Be() (uint32, bool) { } // PeekUint24LE wraps gst_byte_reader_peek_uint24_le +// // The function returns the following values: // // - val uint32: Pointer to a #guint32 to store the result @@ -11685,6 +13454,7 @@ func (reader *ByteReader) PeekUint24LE() (uint32, bool) { } // PeekUint32Be wraps gst_byte_reader_peek_uint32_be +// // The function returns the following values: // // - val uint32: Pointer to a #guint32 to store the result @@ -11714,6 +13484,7 @@ func (reader *ByteReader) PeekUint32Be() (uint32, bool) { } // PeekUint32LE wraps gst_byte_reader_peek_uint32_le +// // The function returns the following values: // // - val uint32: Pointer to a #guint32 to store the result @@ -11743,6 +13514,7 @@ func (reader *ByteReader) PeekUint32LE() (uint32, bool) { } // PeekUint64Be wraps gst_byte_reader_peek_uint64_be +// // The function returns the following values: // // - val uint64: Pointer to a #guint64 to store the result @@ -11772,6 +13544,7 @@ func (reader *ByteReader) PeekUint64Be() (uint64, bool) { } // PeekUint64LE wraps gst_byte_reader_peek_uint64_le +// // The function returns the following values: // // - val uint64: Pointer to a #guint64 to store the result @@ -11801,6 +13574,7 @@ func (reader *ByteReader) PeekUint64LE() (uint64, bool) { } // PeekUint8 wraps gst_byte_reader_peek_uint8 +// // The function returns the following values: // // - val uint8: Pointer to a #guint8 to store the result @@ -11893,6 +13667,7 @@ func (reader *ByteReader) Skip(nbytes uint) bool { } // SkipStringUTF16 wraps gst_byte_reader_skip_string_utf16 +// // The function returns the following values: // // - goret bool @@ -11922,6 +13697,7 @@ func (reader *ByteReader) SkipStringUTF16() bool { } // SkipStringUTF32 wraps gst_byte_reader_skip_string_utf32 +// // The function returns the following values: // // - goret bool @@ -11951,6 +13727,7 @@ func (reader *ByteReader) SkipStringUTF32() bool { } // SkipStringUTF8 wraps gst_byte_reader_skip_string_utf8 +// // The function returns the following values: // // - goret bool @@ -12001,7 +13778,7 @@ func UnsafeByteWriterFromGlibBorrow(p unsafe.Pointer) *ByteWriter { return &ByteWriter{&byteWriter{(*C.GstByteWriter)(p)}} } -// UnsafeByteWriterFromGlibNone is used to convert raw C.GstByteWriter pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeByteWriterFromGlibNone is used to convert raw C.GstByteWriter pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeByteWriterFromGlibNone(p unsafe.Pointer) *ByteWriter { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeByteWriterFromGlibBorrow(p) @@ -12014,7 +13791,7 @@ func UnsafeByteWriterFromGlibNone(p unsafe.Pointer) *ByteWriter { return wrapped } -// UnsafeByteWriterFromGlibFull is used to convert raw C.GstByteWriter pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeByteWriterFromGlibFull is used to convert raw C.GstByteWriter pointers to go while taking ownership. This is used by the bindings internally. func UnsafeByteWriterFromGlibFull(p unsafe.Pointer) *ByteWriter { wrapped := UnsafeByteWriterFromGlibBorrow(p) runtime.SetFinalizer( @@ -12046,6 +13823,7 @@ func UnsafeByteWriterToGlibFull(b *ByteWriter) unsafe.Pointer { b.native = nil // ByteWriter is invalid from here on return _p } + // EnsureFreeSpace wraps gst_byte_writer_ensure_free_space // // The function takes the following parameters: @@ -12116,6 +13894,7 @@ func (writer *ByteWriter) Fill(value uint8, size uint) bool { } // FreeAndGetBuffer wraps gst_byte_writer_free_and_get_buffer +// // The function returns the following values: // // - goret *gst.Buffer @@ -12141,6 +13920,7 @@ func (writer *ByteWriter) FreeAndGetBuffer() *gst.Buffer { } // FreeAndGetData wraps gst_byte_writer_free_and_get_data +// // The function returns the following values: // // - goret *uint8 @@ -12168,6 +13948,7 @@ func (writer *ByteWriter) FreeAndGetData() *uint8 { } // GetRemaining wraps gst_byte_writer_get_remaining +// // The function returns the following values: // // - goret uint @@ -13153,6 +14934,7 @@ func (writer *ByteWriter) Reset() { } // ResetAndGetBuffer wraps gst_byte_writer_reset_and_get_buffer +// // The function returns the following values: // // - goret *gst.Buffer @@ -13193,7 +14975,7 @@ func UnsafeCollectDataFromGlibBorrow(p unsafe.Pointer) *CollectData { return &CollectData{&collectData{(*C.GstCollectData)(p)}} } -// UnsafeCollectDataFromGlibNone is used to convert raw C.GstCollectData pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeCollectDataFromGlibNone is used to convert raw C.GstCollectData pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeCollectDataFromGlibNone(p unsafe.Pointer) *CollectData { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeCollectDataFromGlibBorrow(p) @@ -13206,7 +14988,7 @@ func UnsafeCollectDataFromGlibNone(p unsafe.Pointer) *CollectData { return wrapped } -// UnsafeCollectDataFromGlibFull is used to convert raw C.GstCollectData pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeCollectDataFromGlibFull is used to convert raw C.GstCollectData pointers to go while taking ownership. This is used by the bindings internally. func UnsafeCollectDataFromGlibFull(p unsafe.Pointer) *CollectData { wrapped := UnsafeCollectDataFromGlibBorrow(p) runtime.SetFinalizer( @@ -13238,7 +15020,10 @@ func UnsafeCollectDataToGlibFull(c *CollectData) unsafe.Pointer { c.native = nil // CollectData is invalid from here on return _p } + // CollectPadsClass wraps GstCollectPadsClass +// +// CollectPadsClass is the type struct for [CollectPads] type CollectPadsClass struct { *collectPadsClass } @@ -13253,31 +15038,6 @@ func UnsafeCollectPadsClassFromGlibBorrow(p unsafe.Pointer) *CollectPadsClass { return &CollectPadsClass{&collectPadsClass{(*C.GstCollectPadsClass)(p)}} } -// UnsafeCollectPadsClassFromGlibNone is used to convert raw C.GstCollectPadsClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeCollectPadsClassFromGlibNone(p unsafe.Pointer) *CollectPadsClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeCollectPadsClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.collectPadsClass, - func (intern *collectPadsClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeCollectPadsClassFromGlibFull is used to convert raw C.GstCollectPadsClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeCollectPadsClassFromGlibFull(p unsafe.Pointer) *CollectPadsClass { - wrapped := UnsafeCollectPadsClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.collectPadsClass, - func (intern *collectPadsClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeCollectPadsClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [CollectPadsClass] is expected to work anymore. @@ -13290,15 +15050,18 @@ func UnsafeCollectPadsClassToGlibNone(c *CollectPadsClass) unsafe.Pointer { return unsafe.Pointer(c.native) } -// UnsafeCollectPadsClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeCollectPadsClassToGlibFull(c *CollectPadsClass) unsafe.Pointer { - runtime.SetFinalizer(c.collectPadsClass, nil) - _p := unsafe.Pointer(c.native) - c.native = nil // CollectPadsClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (c *CollectPadsClass) ParentClass() *gst.ObjectClass { + parent := gst.UnsafeObjectClassFromGlibBorrow(UnsafeCollectPadsClassToGlibNone(c)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *CollectPadsClass) {}, c) + return parent } + // DataQueueClass wraps GstDataQueueClass +// +// DataQueueClass is the type struct for [DataQueue] type DataQueueClass struct { *dataQueueClass } @@ -13313,31 +15076,6 @@ func UnsafeDataQueueClassFromGlibBorrow(p unsafe.Pointer) *DataQueueClass { return &DataQueueClass{&dataQueueClass{(*C.GstDataQueueClass)(p)}} } -// UnsafeDataQueueClassFromGlibNone is used to convert raw C.GstDataQueueClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeDataQueueClassFromGlibNone(p unsafe.Pointer) *DataQueueClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeDataQueueClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.dataQueueClass, - func (intern *dataQueueClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeDataQueueClassFromGlibFull is used to convert raw C.GstDataQueueClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeDataQueueClassFromGlibFull(p unsafe.Pointer) *DataQueueClass { - wrapped := UnsafeDataQueueClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.dataQueueClass, - func (intern *dataQueueClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeDataQueueClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [DataQueueClass] is expected to work anymore. @@ -13350,14 +15088,15 @@ func UnsafeDataQueueClassToGlibNone(d *DataQueueClass) unsafe.Pointer { return unsafe.Pointer(d.native) } -// UnsafeDataQueueClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeDataQueueClassToGlibFull(d *DataQueueClass) unsafe.Pointer { - runtime.SetFinalizer(d.dataQueueClass, nil) - _p := unsafe.Pointer(d.native) - d.native = nil // DataQueueClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (d *DataQueueClass) ParentClass() *gobject.ObjectClass { + parent := gobject.UnsafeObjectClassFromGlibBorrow(UnsafeDataQueueClassToGlibNone(d)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *DataQueueClass) {}, d) + return parent } + // FlowCombiner wraps GstFlowCombiner // // Utility struct to help handling #GstFlowReturn combination. Useful for @@ -13417,7 +15156,7 @@ func UnsafeFlowCombinerFromGlibBorrow(p unsafe.Pointer) *FlowCombiner { return &FlowCombiner{&flowCombiner{(*C.GstFlowCombiner)(p)}} } -// UnsafeFlowCombinerFromGlibNone is used to convert raw C.GstFlowCombiner pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeFlowCombinerFromGlibNone is used to convert raw C.GstFlowCombiner pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeFlowCombinerFromGlibNone(p unsafe.Pointer) *FlowCombiner { C.gst_flow_combiner_ref((*C.GstFlowCombiner)(p)) wrapped := UnsafeFlowCombinerFromGlibBorrow(p) @@ -13430,7 +15169,7 @@ func UnsafeFlowCombinerFromGlibNone(p unsafe.Pointer) *FlowCombiner { return wrapped } -// UnsafeFlowCombinerFromGlibFull is used to convert raw C.GstFlowCombiner pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeFlowCombinerFromGlibFull is used to convert raw C.GstFlowCombiner pointers to go while taking ownership. This is used by the bindings internally. func UnsafeFlowCombinerFromGlibFull(p unsafe.Pointer) *FlowCombiner { wrapped := UnsafeFlowCombinerFromGlibBorrow(p) runtime.SetFinalizer( @@ -13469,7 +15208,9 @@ func UnsafeFlowCombinerToGlibFull(f *FlowCombiner) unsafe.Pointer { f.native = nil // FlowCombiner is invalid from here on return _p } + // NewFlowCombiner wraps gst_flow_combiner_new +// // The function returns the following values: // // - goret *FlowCombiner @@ -13629,6 +15370,8 @@ func (combiner *FlowCombiner) UpdatePadFlow(pad gst.Pad, fret gst.FlowReturn) gs // Subclasses can override any of the available virtual methods or not, as // needed. At the minimum, the @fill method should be overridden to produce // buffers. +// +// PushSrcClass is the type struct for [PushSrc] type PushSrcClass struct { *pushSrcClass } @@ -13643,31 +15386,6 @@ func UnsafePushSrcClassFromGlibBorrow(p unsafe.Pointer) *PushSrcClass { return &PushSrcClass{&pushSrcClass{(*C.GstPushSrcClass)(p)}} } -// UnsafePushSrcClassFromGlibNone is used to convert raw C.GstPushSrcClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafePushSrcClassFromGlibNone(p unsafe.Pointer) *PushSrcClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafePushSrcClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.pushSrcClass, - func (intern *pushSrcClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafePushSrcClassFromGlibFull is used to convert raw C.GstPushSrcClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafePushSrcClassFromGlibFull(p unsafe.Pointer) *PushSrcClass { - wrapped := UnsafePushSrcClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.pushSrcClass, - func (intern *pushSrcClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafePushSrcClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [PushSrcClass] is expected to work anymore. @@ -13680,11 +15398,12 @@ func UnsafePushSrcClassToGlibNone(p *PushSrcClass) unsafe.Pointer { return unsafe.Pointer(p.native) } -// UnsafePushSrcClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafePushSrcClassToGlibFull(p *PushSrcClass) unsafe.Pointer { - runtime.SetFinalizer(p.pushSrcClass, nil) - _p := unsafe.Pointer(p.native) - p.native = nil // PushSrcClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (p *PushSrcClass) ParentClass() *BaseSrcClass { + parent := UnsafeBaseSrcClassFromGlibBorrow(UnsafePushSrcClassToGlibNone(p)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *PushSrcClass) {}, p) + return parent } + diff --git a/pkg/gstbase/gstbase_export.gen.go b/pkg/gstbase/gstbase_export.gen.go index 830dab4..b3f20b2 100644 --- a/pkg/gstbase/gstbase_export.gen.go +++ b/pkg/gstbase/gstbase_export.gen.go @@ -198,3 +198,493 @@ func _gotk4_gstbase1_CollectPadsQueryFunction(carg1 *C.GstCollectPads, carg2 *C. return cret } +//export _gotk4_gstbase1_Aggregator_aggregate +func _gotk4_gstbase1_Aggregator_aggregate(carg0 *C.GstAggregator, carg1 C.gboolean) (cret C.GstFlowReturn) { + panic("unimplemented") +} + +//export _gotk4_gstbase1_Aggregator_clip +func _gotk4_gstbase1_Aggregator_clip(carg0 *C.GstAggregator, carg1 *C.GstAggregatorPad, carg2 *C.GstBuffer) (cret *C.GstBuffer) { + panic("unimplemented") +} + +//export _gotk4_gstbase1_Aggregator_decide_allocation +func _gotk4_gstbase1_Aggregator_decide_allocation(carg0 *C.GstAggregator, carg1 *C.GstQuery) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstbase1_Aggregator_finish_buffer +func _gotk4_gstbase1_Aggregator_finish_buffer(carg0 *C.GstAggregator, carg1 *C.GstBuffer) (cret C.GstFlowReturn) { + panic("unimplemented") +} + +//export _gotk4_gstbase1_Aggregator_finish_buffer_list +func _gotk4_gstbase1_Aggregator_finish_buffer_list(carg0 *C.GstAggregator, carg1 *C.GstBufferList) (cret C.GstFlowReturn) { + panic("unimplemented") +} + +//export _gotk4_gstbase1_Aggregator_fixate_src_caps +func _gotk4_gstbase1_Aggregator_fixate_src_caps(carg0 *C.GstAggregator, carg1 *C.GstCaps) (cret *C.GstCaps) { + panic("unimplemented") +} + +//export _gotk4_gstbase1_Aggregator_flush +func _gotk4_gstbase1_Aggregator_flush(carg0 *C.GstAggregator) (cret C.GstFlowReturn) { + panic("unimplemented") +} + +//export _gotk4_gstbase1_Aggregator_get_next_time +func _gotk4_gstbase1_Aggregator_get_next_time(carg0 *C.GstAggregator) (cret C.GstClockTime) { + panic("unimplemented") +} + +//export _gotk4_gstbase1_Aggregator_negotiate +func _gotk4_gstbase1_Aggregator_negotiate(carg0 *C.GstAggregator) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstbase1_Aggregator_negotiated_src_caps +func _gotk4_gstbase1_Aggregator_negotiated_src_caps(carg0 *C.GstAggregator, carg1 *C.GstCaps) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstbase1_Aggregator_peek_next_sample +func _gotk4_gstbase1_Aggregator_peek_next_sample(carg0 *C.GstAggregator, carg1 *C.GstAggregatorPad) (cret *C.GstSample) { + panic("unimplemented") +} + +//export _gotk4_gstbase1_Aggregator_propose_allocation +func _gotk4_gstbase1_Aggregator_propose_allocation(carg0 *C.GstAggregator, carg1 *C.GstAggregatorPad, carg2 *C.GstQuery, carg3 *C.GstQuery) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstbase1_Aggregator_sink_event +func _gotk4_gstbase1_Aggregator_sink_event(carg0 *C.GstAggregator, carg1 *C.GstAggregatorPad, carg2 *C.GstEvent) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstbase1_Aggregator_sink_event_pre_queue +func _gotk4_gstbase1_Aggregator_sink_event_pre_queue(carg0 *C.GstAggregator, carg1 *C.GstAggregatorPad, carg2 *C.GstEvent) (cret C.GstFlowReturn) { + panic("unimplemented") +} + +//export _gotk4_gstbase1_Aggregator_sink_query +func _gotk4_gstbase1_Aggregator_sink_query(carg0 *C.GstAggregator, carg1 *C.GstAggregatorPad, carg2 *C.GstQuery) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstbase1_Aggregator_sink_query_pre_queue +func _gotk4_gstbase1_Aggregator_sink_query_pre_queue(carg0 *C.GstAggregator, carg1 *C.GstAggregatorPad, carg2 *C.GstQuery) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstbase1_Aggregator_src_activate +func _gotk4_gstbase1_Aggregator_src_activate(carg0 *C.GstAggregator, carg1 C.GstPadMode, carg2 C.gboolean) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstbase1_Aggregator_src_event +func _gotk4_gstbase1_Aggregator_src_event(carg0 *C.GstAggregator, carg1 *C.GstEvent) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstbase1_Aggregator_src_query +func _gotk4_gstbase1_Aggregator_src_query(carg0 *C.GstAggregator, carg1 *C.GstQuery) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstbase1_Aggregator_start +func _gotk4_gstbase1_Aggregator_start(carg0 *C.GstAggregator) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstbase1_Aggregator_stop +func _gotk4_gstbase1_Aggregator_stop(carg0 *C.GstAggregator) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstbase1_Aggregator_update_src_caps +func _gotk4_gstbase1_Aggregator_update_src_caps(carg0 *C.GstAggregator, carg1 *C.GstCaps, carg2 **C.GstCaps) (cret C.GstFlowReturn) { + panic("unimplemented") +} + +//export _gotk4_gstbase1_AggregatorPad_flush +func _gotk4_gstbase1_AggregatorPad_flush(carg0 *C.GstAggregatorPad, carg1 *C.GstAggregator) (cret C.GstFlowReturn) { + panic("unimplemented") +} + +//export _gotk4_gstbase1_AggregatorPad_skip_buffer +func _gotk4_gstbase1_AggregatorPad_skip_buffer(carg0 *C.GstAggregatorPad, carg1 *C.GstAggregator, carg2 *C.GstBuffer) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstbase1_BaseParse_convert +func _gotk4_gstbase1_BaseParse_convert(carg0 *C.GstBaseParse, carg1 C.GstFormat, carg2 C.gint64, carg3 C.GstFormat, carg4 *C.gint64) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstbase1_BaseParse_detect +func _gotk4_gstbase1_BaseParse_detect(carg0 *C.GstBaseParse, carg1 *C.GstBuffer) (cret C.GstFlowReturn) { + panic("unimplemented") +} + +//export _gotk4_gstbase1_BaseParse_get_sink_caps +func _gotk4_gstbase1_BaseParse_get_sink_caps(carg0 *C.GstBaseParse, carg1 *C.GstCaps) (cret *C.GstCaps) { + panic("unimplemented") +} + +//export _gotk4_gstbase1_BaseParse_handle_frame +func _gotk4_gstbase1_BaseParse_handle_frame(carg0 *C.GstBaseParse, carg1 *C.GstBaseParseFrame, carg2 *C.gint) (cret C.GstFlowReturn) { + panic("unimplemented") +} + +//export _gotk4_gstbase1_BaseParse_pre_push_frame +func _gotk4_gstbase1_BaseParse_pre_push_frame(carg0 *C.GstBaseParse, carg1 *C.GstBaseParseFrame) (cret C.GstFlowReturn) { + panic("unimplemented") +} + +//export _gotk4_gstbase1_BaseParse_set_sink_caps +func _gotk4_gstbase1_BaseParse_set_sink_caps(carg0 *C.GstBaseParse, carg1 *C.GstCaps) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstbase1_BaseParse_sink_event +func _gotk4_gstbase1_BaseParse_sink_event(carg0 *C.GstBaseParse, carg1 *C.GstEvent) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstbase1_BaseParse_sink_query +func _gotk4_gstbase1_BaseParse_sink_query(carg0 *C.GstBaseParse, carg1 *C.GstQuery) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstbase1_BaseParse_src_event +func _gotk4_gstbase1_BaseParse_src_event(carg0 *C.GstBaseParse, carg1 *C.GstEvent) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstbase1_BaseParse_src_query +func _gotk4_gstbase1_BaseParse_src_query(carg0 *C.GstBaseParse, carg1 *C.GstQuery) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstbase1_BaseParse_start +func _gotk4_gstbase1_BaseParse_start(carg0 *C.GstBaseParse) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstbase1_BaseParse_stop +func _gotk4_gstbase1_BaseParse_stop(carg0 *C.GstBaseParse) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstbase1_BaseSink_activate_pull +func _gotk4_gstbase1_BaseSink_activate_pull(carg0 *C.GstBaseSink, carg1 C.gboolean) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstbase1_BaseSink_event +func _gotk4_gstbase1_BaseSink_event(carg0 *C.GstBaseSink, carg1 *C.GstEvent) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstbase1_BaseSink_fixate +func _gotk4_gstbase1_BaseSink_fixate(carg0 *C.GstBaseSink, carg1 *C.GstCaps) (cret *C.GstCaps) { + panic("unimplemented") +} + +//export _gotk4_gstbase1_BaseSink_get_caps +func _gotk4_gstbase1_BaseSink_get_caps(carg0 *C.GstBaseSink, carg1 *C.GstCaps) (cret *C.GstCaps) { + panic("unimplemented") +} + +//export _gotk4_gstbase1_BaseSink_get_times +func _gotk4_gstbase1_BaseSink_get_times(carg0 *C.GstBaseSink, carg1 *C.GstBuffer, carg2 *C.GstClockTime, carg3 *C.GstClockTime) { + panic("unimplemented") +} + +//export _gotk4_gstbase1_BaseSink_prepare +func _gotk4_gstbase1_BaseSink_prepare(carg0 *C.GstBaseSink, carg1 *C.GstBuffer) (cret C.GstFlowReturn) { + panic("unimplemented") +} + +//export _gotk4_gstbase1_BaseSink_prepare_list +func _gotk4_gstbase1_BaseSink_prepare_list(carg0 *C.GstBaseSink, carg1 *C.GstBufferList) (cret C.GstFlowReturn) { + panic("unimplemented") +} + +//export _gotk4_gstbase1_BaseSink_preroll +func _gotk4_gstbase1_BaseSink_preroll(carg0 *C.GstBaseSink, carg1 *C.GstBuffer) (cret C.GstFlowReturn) { + panic("unimplemented") +} + +//export _gotk4_gstbase1_BaseSink_propose_allocation +func _gotk4_gstbase1_BaseSink_propose_allocation(carg0 *C.GstBaseSink, carg1 *C.GstQuery) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstbase1_BaseSink_query +func _gotk4_gstbase1_BaseSink_query(carg0 *C.GstBaseSink, carg1 *C.GstQuery) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstbase1_BaseSink_render +func _gotk4_gstbase1_BaseSink_render(carg0 *C.GstBaseSink, carg1 *C.GstBuffer) (cret C.GstFlowReturn) { + panic("unimplemented") +} + +//export _gotk4_gstbase1_BaseSink_render_list +func _gotk4_gstbase1_BaseSink_render_list(carg0 *C.GstBaseSink, carg1 *C.GstBufferList) (cret C.GstFlowReturn) { + panic("unimplemented") +} + +//export _gotk4_gstbase1_BaseSink_set_caps +func _gotk4_gstbase1_BaseSink_set_caps(carg0 *C.GstBaseSink, carg1 *C.GstCaps) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstbase1_BaseSink_start +func _gotk4_gstbase1_BaseSink_start(carg0 *C.GstBaseSink) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstbase1_BaseSink_stop +func _gotk4_gstbase1_BaseSink_stop(carg0 *C.GstBaseSink) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstbase1_BaseSink_unlock +func _gotk4_gstbase1_BaseSink_unlock(carg0 *C.GstBaseSink) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstbase1_BaseSink_unlock_stop +func _gotk4_gstbase1_BaseSink_unlock_stop(carg0 *C.GstBaseSink) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstbase1_BaseSink_wait_event +func _gotk4_gstbase1_BaseSink_wait_event(carg0 *C.GstBaseSink, carg1 *C.GstEvent) (cret C.GstFlowReturn) { + panic("unimplemented") +} + +//export _gotk4_gstbase1_BaseSrc_alloc +func _gotk4_gstbase1_BaseSrc_alloc(carg0 *C.GstBaseSrc, carg1 C.guint64, carg2 C.guint, carg3 **C.GstBuffer) (cret C.GstFlowReturn) { + panic("unimplemented") +} + +//export _gotk4_gstbase1_BaseSrc_decide_allocation +func _gotk4_gstbase1_BaseSrc_decide_allocation(carg0 *C.GstBaseSrc, carg1 *C.GstQuery) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstbase1_BaseSrc_do_seek +func _gotk4_gstbase1_BaseSrc_do_seek(carg0 *C.GstBaseSrc, carg1 *C.GstSegment) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstbase1_BaseSrc_event +func _gotk4_gstbase1_BaseSrc_event(carg0 *C.GstBaseSrc, carg1 *C.GstEvent) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstbase1_BaseSrc_fill +func _gotk4_gstbase1_BaseSrc_fill(carg0 *C.GstBaseSrc, carg1 C.guint64, carg2 C.guint, carg3 *C.GstBuffer) (cret C.GstFlowReturn) { + panic("unimplemented") +} + +//export _gotk4_gstbase1_BaseSrc_fixate +func _gotk4_gstbase1_BaseSrc_fixate(carg0 *C.GstBaseSrc, carg1 *C.GstCaps) (cret *C.GstCaps) { + panic("unimplemented") +} + +//export _gotk4_gstbase1_BaseSrc_get_caps +func _gotk4_gstbase1_BaseSrc_get_caps(carg0 *C.GstBaseSrc, carg1 *C.GstCaps) (cret *C.GstCaps) { + panic("unimplemented") +} + +//export _gotk4_gstbase1_BaseSrc_get_size +func _gotk4_gstbase1_BaseSrc_get_size(carg0 *C.GstBaseSrc, carg1 *C.guint64) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstbase1_BaseSrc_get_times +func _gotk4_gstbase1_BaseSrc_get_times(carg0 *C.GstBaseSrc, carg1 *C.GstBuffer, carg2 *C.GstClockTime, carg3 *C.GstClockTime) { + panic("unimplemented") +} + +//export _gotk4_gstbase1_BaseSrc_is_seekable +func _gotk4_gstbase1_BaseSrc_is_seekable(carg0 *C.GstBaseSrc) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstbase1_BaseSrc_negotiate +func _gotk4_gstbase1_BaseSrc_negotiate(carg0 *C.GstBaseSrc) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstbase1_BaseSrc_prepare_seek_segment +func _gotk4_gstbase1_BaseSrc_prepare_seek_segment(carg0 *C.GstBaseSrc, carg1 *C.GstEvent, carg2 *C.GstSegment) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstbase1_BaseSrc_query +func _gotk4_gstbase1_BaseSrc_query(carg0 *C.GstBaseSrc, carg1 *C.GstQuery) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstbase1_BaseSrc_set_caps +func _gotk4_gstbase1_BaseSrc_set_caps(carg0 *C.GstBaseSrc, carg1 *C.GstCaps) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstbase1_BaseSrc_start +func _gotk4_gstbase1_BaseSrc_start(carg0 *C.GstBaseSrc) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstbase1_BaseSrc_stop +func _gotk4_gstbase1_BaseSrc_stop(carg0 *C.GstBaseSrc) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstbase1_BaseSrc_unlock +func _gotk4_gstbase1_BaseSrc_unlock(carg0 *C.GstBaseSrc) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstbase1_BaseSrc_unlock_stop +func _gotk4_gstbase1_BaseSrc_unlock_stop(carg0 *C.GstBaseSrc) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstbase1_BaseTransform_accept_caps +func _gotk4_gstbase1_BaseTransform_accept_caps(carg0 *C.GstBaseTransform, carg1 C.GstPadDirection, carg2 *C.GstCaps) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstbase1_BaseTransform_before_transform +func _gotk4_gstbase1_BaseTransform_before_transform(carg0 *C.GstBaseTransform, carg1 *C.GstBuffer) { + panic("unimplemented") +} + +//export _gotk4_gstbase1_BaseTransform_copy_metadata +func _gotk4_gstbase1_BaseTransform_copy_metadata(carg0 *C.GstBaseTransform, carg1 *C.GstBuffer, carg2 *C.GstBuffer) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstbase1_BaseTransform_decide_allocation +func _gotk4_gstbase1_BaseTransform_decide_allocation(carg0 *C.GstBaseTransform, carg1 *C.GstQuery) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstbase1_BaseTransform_filter_meta +func _gotk4_gstbase1_BaseTransform_filter_meta(carg0 *C.GstBaseTransform, carg1 *C.GstQuery, carg2 C.GType, carg3 *C.GstStructure) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstbase1_BaseTransform_fixate_caps +func _gotk4_gstbase1_BaseTransform_fixate_caps(carg0 *C.GstBaseTransform, carg1 C.GstPadDirection, carg2 *C.GstCaps, carg3 *C.GstCaps) (cret *C.GstCaps) { + panic("unimplemented") +} + +//export _gotk4_gstbase1_BaseTransform_generate_output +func _gotk4_gstbase1_BaseTransform_generate_output(carg0 *C.GstBaseTransform, carg1 **C.GstBuffer) (cret C.GstFlowReturn) { + panic("unimplemented") +} + +//export _gotk4_gstbase1_BaseTransform_get_unit_size +func _gotk4_gstbase1_BaseTransform_get_unit_size(carg0 *C.GstBaseTransform, carg1 *C.GstCaps, carg2 *C.gsize) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstbase1_BaseTransform_prepare_output_buffer +func _gotk4_gstbase1_BaseTransform_prepare_output_buffer(carg0 *C.GstBaseTransform, carg1 *C.GstBuffer, carg2 **C.GstBuffer) (cret C.GstFlowReturn) { + panic("unimplemented") +} + +//export _gotk4_gstbase1_BaseTransform_propose_allocation +func _gotk4_gstbase1_BaseTransform_propose_allocation(carg0 *C.GstBaseTransform, carg1 *C.GstQuery, carg2 *C.GstQuery) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstbase1_BaseTransform_query +func _gotk4_gstbase1_BaseTransform_query(carg0 *C.GstBaseTransform, carg1 C.GstPadDirection, carg2 *C.GstQuery) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstbase1_BaseTransform_set_caps +func _gotk4_gstbase1_BaseTransform_set_caps(carg0 *C.GstBaseTransform, carg1 *C.GstCaps, carg2 *C.GstCaps) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstbase1_BaseTransform_sink_event +func _gotk4_gstbase1_BaseTransform_sink_event(carg0 *C.GstBaseTransform, carg1 *C.GstEvent) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstbase1_BaseTransform_src_event +func _gotk4_gstbase1_BaseTransform_src_event(carg0 *C.GstBaseTransform, carg1 *C.GstEvent) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstbase1_BaseTransform_start +func _gotk4_gstbase1_BaseTransform_start(carg0 *C.GstBaseTransform) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstbase1_BaseTransform_stop +func _gotk4_gstbase1_BaseTransform_stop(carg0 *C.GstBaseTransform) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstbase1_BaseTransform_submit_input_buffer +func _gotk4_gstbase1_BaseTransform_submit_input_buffer(carg0 *C.GstBaseTransform, carg1 C.gboolean, carg2 *C.GstBuffer) (cret C.GstFlowReturn) { + panic("unimplemented") +} + +//export _gotk4_gstbase1_BaseTransform_transform +func _gotk4_gstbase1_BaseTransform_transform(carg0 *C.GstBaseTransform, carg1 *C.GstBuffer, carg2 *C.GstBuffer) (cret C.GstFlowReturn) { + panic("unimplemented") +} + +//export _gotk4_gstbase1_BaseTransform_transform_caps +func _gotk4_gstbase1_BaseTransform_transform_caps(carg0 *C.GstBaseTransform, carg1 C.GstPadDirection, carg2 *C.GstCaps, carg3 *C.GstCaps) (cret *C.GstCaps) { + panic("unimplemented") +} + +//export _gotk4_gstbase1_BaseTransform_transform_ip +func _gotk4_gstbase1_BaseTransform_transform_ip(carg0 *C.GstBaseTransform, carg1 *C.GstBuffer) (cret C.GstFlowReturn) { + panic("unimplemented") +} + +//export _gotk4_gstbase1_BaseTransform_transform_meta +func _gotk4_gstbase1_BaseTransform_transform_meta(carg0 *C.GstBaseTransform, carg1 *C.GstBuffer, carg2 *C.GstMeta, carg3 *C.GstBuffer) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstbase1_BaseTransform_transform_size +func _gotk4_gstbase1_BaseTransform_transform_size(carg0 *C.GstBaseTransform, carg1 C.GstPadDirection, carg2 *C.GstCaps, carg3 C.gsize, carg4 *C.GstCaps, carg5 *C.gsize) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstbase1_DataQueue_empty +func _gotk4_gstbase1_DataQueue_empty(carg0 *C.GstDataQueue) { + panic("unimplemented") +} + +//export _gotk4_gstbase1_DataQueue_full +func _gotk4_gstbase1_DataQueue_full(carg0 *C.GstDataQueue) { + panic("unimplemented") +} + +//export _gotk4_gstbase1_PushSrc_alloc +func _gotk4_gstbase1_PushSrc_alloc(carg0 *C.GstPushSrc, carg1 **C.GstBuffer) (cret C.GstFlowReturn) { + panic("unimplemented") +} + +//export _gotk4_gstbase1_PushSrc_fill +func _gotk4_gstbase1_PushSrc_fill(carg0 *C.GstPushSrc, carg1 *C.GstBuffer) (cret C.GstFlowReturn) { + panic("unimplemented") +} + diff --git a/pkg/gstcheck/gstcheck.gen.go b/pkg/gstcheck/gstcheck.gen.go index 272ff15..168bc79 100644 --- a/pkg/gstcheck/gstcheck.gen.go +++ b/pkg/gstcheck/gstcheck.gen.go @@ -1027,6 +1027,7 @@ type TestClock interface { // MT safe. AdvanceTime(gst.ClockTimeDiff) // Crank wraps gst_test_clock_crank + // // The function returns the following values: // // - goret bool @@ -1040,6 +1041,7 @@ type TestClock interface { // manually driving the clock forward to its next logical step. Crank() bool // GetNextEntryTime wraps gst_test_clock_get_next_entry_time + // // The function returns the following values: // // - goret gst.ClockTime @@ -1064,6 +1066,7 @@ type TestClock interface { // MT safe. HasID(gst.ClockID) bool // PeekIDCount wraps gst_test_clock_peek_id_count + // // The function returns the following values: // // - goret uint @@ -1074,6 +1077,7 @@ type TestClock interface { // MT safe. PeekIDCount() uint // PeekNextPendingID wraps gst_test_clock_peek_next_pending_id + // // The function returns the following values: // // - pendingId gst.ClockID: a #GstClockID clock @@ -1100,6 +1104,7 @@ type TestClock interface { // MT safe. ProcessID(gst.ClockID) bool // ProcessNextClockID wraps gst_test_clock_process_next_clock_id + // // The function returns the following values: // // - goret gst.ClockID (nullable) @@ -1120,6 +1125,7 @@ type TestClock interface { // MT safe. SetTime(gst.ClockTime) // WaitForNextPendingID wraps gst_test_clock_wait_for_next_pending_id + // // The function returns the following values: // // - pendingId gst.ClockID: #GstClockID @@ -1186,6 +1192,7 @@ func UnsafeTestClockToGlibFull(c TestClock) unsafe.Pointer { } // NewTestClock wraps gst_test_clock_new +// // The function returns the following values: // // - goret gst.Clock @@ -1258,6 +1265,7 @@ func (testClock *TestClockInstance) AdvanceTime(delta gst.ClockTimeDiff) { } // Crank wraps gst_test_clock_crank +// // The function returns the following values: // // - goret bool @@ -1288,6 +1296,7 @@ func (testClock *TestClockInstance) Crank() bool { } // GetNextEntryTime wraps gst_test_clock_get_next_entry_time +// // The function returns the following values: // // - goret gst.ClockTime @@ -1347,6 +1356,7 @@ func (testClock *TestClockInstance) HasID(id gst.ClockID) bool { } // PeekIDCount wraps gst_test_clock_peek_id_count +// // The function returns the following values: // // - goret uint @@ -1372,6 +1382,7 @@ func (testClock *TestClockInstance) PeekIDCount() uint { } // PeekNextPendingID wraps gst_test_clock_peek_next_pending_id +// // The function returns the following values: // // - pendingId gst.ClockID: a #GstClockID clock @@ -1438,6 +1449,7 @@ func (testClock *TestClockInstance) ProcessID(pendingId gst.ClockID) bool { } // ProcessNextClockID wraps gst_test_clock_process_next_clock_id +// // The function returns the following values: // // - goret gst.ClockID (nullable) @@ -1486,6 +1498,7 @@ func (testClock *TestClockInstance) SetTime(newTime gst.ClockTime) { } // WaitForNextPendingID wraps gst_test_clock_wait_for_next_pending_id +// // The function returns the following values: // // - pendingId gst.ClockID: #GstClockID @@ -1535,6 +1548,20 @@ func (testClock *TestClockInstance) WaitForPendingIDCount(count uint) { runtime.KeepAlive(count) } +// TestClockOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type TestClockOverrides[Instance TestClock] struct { + // gst.ClockOverrides allows you to override virtual methods from the parent class gst.Clock + gst.ClockOverrides[Instance] + +} + +// UnsafeApplyTestClockOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyTestClockOverrides[Instance TestClock](gclass unsafe.Pointer, overrides TestClockOverrides[Instance]) { + gst.UnsafeApplyClockOverrides(gclass, overrides.ClockOverrides) +} + // CheckABIStruct wraps GstCheckABIStruct type CheckABIStruct struct { *checkABIStruct @@ -1550,7 +1577,7 @@ func UnsafeCheckABIStructFromGlibBorrow(p unsafe.Pointer) *CheckABIStruct { return &CheckABIStruct{&checkABIStruct{(*C.GstCheckABIStruct)(p)}} } -// UnsafeCheckABIStructFromGlibNone is used to convert raw C.GstCheckABIStruct pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeCheckABIStructFromGlibNone is used to convert raw C.GstCheckABIStruct pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeCheckABIStructFromGlibNone(p unsafe.Pointer) *CheckABIStruct { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeCheckABIStructFromGlibBorrow(p) @@ -1563,7 +1590,7 @@ func UnsafeCheckABIStructFromGlibNone(p unsafe.Pointer) *CheckABIStruct { return wrapped } -// UnsafeCheckABIStructFromGlibFull is used to convert raw C.GstCheckABIStruct pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeCheckABIStructFromGlibFull is used to convert raw C.GstCheckABIStruct pointers to go while taking ownership. This is used by the bindings internally. func UnsafeCheckABIStructFromGlibFull(p unsafe.Pointer) *CheckABIStruct { wrapped := UnsafeCheckABIStructFromGlibBorrow(p) runtime.SetFinalizer( @@ -1595,6 +1622,7 @@ func UnsafeCheckABIStructToGlibFull(c *CheckABIStruct) unsafe.Pointer { c.native = nil // CheckABIStruct is invalid from here on return _p } + // CheckLogFilter wraps GstCheckLogFilter // // Opaque structure containing data about a log filter @@ -1613,7 +1641,7 @@ func UnsafeCheckLogFilterFromGlibBorrow(p unsafe.Pointer) *CheckLogFilter { return &CheckLogFilter{&checkLogFilter{(*C.GstCheckLogFilter)(p)}} } -// UnsafeCheckLogFilterFromGlibNone is used to convert raw C.GstCheckLogFilter pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeCheckLogFilterFromGlibNone is used to convert raw C.GstCheckLogFilter pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeCheckLogFilterFromGlibNone(p unsafe.Pointer) *CheckLogFilter { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeCheckLogFilterFromGlibBorrow(p) @@ -1626,7 +1654,7 @@ func UnsafeCheckLogFilterFromGlibNone(p unsafe.Pointer) *CheckLogFilter { return wrapped } -// UnsafeCheckLogFilterFromGlibFull is used to convert raw C.GstCheckLogFilter pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeCheckLogFilterFromGlibFull is used to convert raw C.GstCheckLogFilter pointers to go while taking ownership. This is used by the bindings internally. func UnsafeCheckLogFilterFromGlibFull(p unsafe.Pointer) *CheckLogFilter { wrapped := UnsafeCheckLogFilterFromGlibBorrow(p) runtime.SetFinalizer( @@ -1658,6 +1686,7 @@ func UnsafeCheckLogFilterToGlibFull(c *CheckLogFilter) unsafe.Pointer { c.native = nil // CheckLogFilter is invalid from here on return _p } + // Harness wraps GstHarness // // #GstHarness is meant to make writing unit test for GStreamer much easier. @@ -1764,7 +1793,7 @@ func UnsafeHarnessFromGlibBorrow(p unsafe.Pointer) *Harness { return &Harness{&harness{(*C.GstHarness)(p)}} } -// UnsafeHarnessFromGlibNone is used to convert raw C.GstHarness pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeHarnessFromGlibNone is used to convert raw C.GstHarness pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeHarnessFromGlibNone(p unsafe.Pointer) *Harness { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeHarnessFromGlibBorrow(p) @@ -1777,7 +1806,7 @@ func UnsafeHarnessFromGlibNone(p unsafe.Pointer) *Harness { return wrapped } -// UnsafeHarnessFromGlibFull is used to convert raw C.GstHarness pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeHarnessFromGlibFull is used to convert raw C.GstHarness pointers to go while taking ownership. This is used by the bindings internally. func UnsafeHarnessFromGlibFull(p unsafe.Pointer) *Harness { wrapped := UnsafeHarnessFromGlibBorrow(p) runtime.SetFinalizer( @@ -1809,6 +1838,7 @@ func UnsafeHarnessToGlibFull(h *Harness) unsafe.Pointer { h.native = nil // Harness is invalid from here on return _p } + // HarnessStressThreadStop wraps gst_harness_stress_thread_stop // // The function takes the following parameters: @@ -2125,6 +2155,7 @@ func (h *Harness) AddSrcParse(launchline string, hasClockWait bool) { } // BuffersInQueue wraps gst_harness_buffers_in_queue +// // The function returns the following values: // // - goret uint @@ -2149,6 +2180,7 @@ func (h *Harness) BuffersInQueue() uint { } // BuffersReceived wraps gst_harness_buffers_received +// // The function returns the following values: // // - goret uint @@ -2214,6 +2246,7 @@ func (h *Harness) CrankMultipleClockWaits(waits uint) bool { } // CrankSingleClockWait wraps gst_harness_crank_single_clock_wait +// // The function returns the following values: // // - goret bool @@ -2303,6 +2336,7 @@ func (h *Harness) DumpToFile(filename string) { } // EventsInQueue wraps gst_harness_events_in_queue +// // The function returns the following values: // // - goret uint @@ -2327,6 +2361,7 @@ func (h *Harness) EventsInQueue() uint { } // EventsReceived wraps gst_harness_events_received +// // The function returns the following values: // // - goret uint @@ -2391,6 +2426,7 @@ func (h *Harness) FindElement(elementName string) gst.Element { } // GetAllocator wraps gst_harness_get_allocator +// // The function returns the following values: // // - allocator gst.Allocator (nullable): the #GstAllocator used @@ -2425,6 +2461,7 @@ func (h *Harness) GetAllocator() (gst.Allocator, gst.AllocationParams) { } // GetLastPushedTimestamp wraps gst_harness_get_last_pushed_timestamp +// // The function returns the following values: // // - goret gst.ClockTime @@ -2450,6 +2487,7 @@ func (h *Harness) GetLastPushedTimestamp() gst.ClockTime { } // GetTestclock wraps gst_harness_get_testclock +// // The function returns the following values: // // - goret TestClock (nullable) @@ -2497,6 +2535,7 @@ func (h *Harness) Play() { } // Pull wraps gst_harness_pull +// // The function returns the following values: // // - goret *gst.Buffer (nullable) @@ -2525,6 +2564,7 @@ func (h *Harness) Pull() *gst.Buffer { } // PullEvent wraps gst_harness_pull_event +// // The function returns the following values: // // - goret *gst.Event (nullable) @@ -2552,6 +2592,7 @@ func (h *Harness) PullEvent() *gst.Event { } // PullUntilEos wraps gst_harness_pull_until_eos +// // The function returns the following values: // // - buf *gst.Buffer (nullable): A #GstBuffer, or %NULL if EOS or timeout occures @@ -2585,6 +2626,7 @@ func (h *Harness) PullUntilEos() (*gst.Buffer, bool) { } // PullUpstreamEvent wraps gst_harness_pull_upstream_event +// // The function returns the following values: // // - goret *gst.Event (nullable) @@ -2715,6 +2757,7 @@ func (h *Harness) PushEvent(event *gst.Event) bool { } // PushFromSrc wraps gst_harness_push_from_src +// // The function returns the following values: // // - goret gst.FlowReturn @@ -2744,6 +2787,7 @@ func (h *Harness) PushFromSrc() gst.FlowReturn { } // PushToSink wraps gst_harness_push_to_sink +// // The function returns the following values: // // - goret gst.FlowReturn @@ -2803,6 +2847,7 @@ func (h *Harness) PushUpstreamEvent(event *gst.Event) bool { } // QueryLatency wraps gst_harness_query_latency +// // The function returns the following values: // // - goret gst.ClockTime @@ -3222,6 +3267,7 @@ func (h *Harness) SrcCrankAndPushMany(cranks int, pushes int) gst.FlowReturn { } // SrcPushEvent wraps gst_harness_src_push_event +// // The function returns the following values: // // - goret bool @@ -3251,6 +3297,7 @@ func (h *Harness) SrcPushEvent() bool { } // TakeAllDataAsBuffer wraps gst_harness_take_all_data_as_buffer +// // The function returns the following values: // // - goret *gst.Buffer @@ -3273,6 +3320,7 @@ func (h *Harness) TakeAllDataAsBuffer() *gst.Buffer { } // TakeAllDataAsBytes wraps gst_harness_take_all_data_as_bytes +// // The function returns the following values: // // - goret *glib.Bytes @@ -3309,6 +3357,7 @@ func (h *Harness) Teardown() { } // TryPull wraps gst_harness_try_pull +// // The function returns the following values: // // - goret *gst.Buffer (nullable) @@ -3337,6 +3386,7 @@ func (h *Harness) TryPull() *gst.Buffer { } // TryPullEvent wraps gst_harness_try_pull_event +// // The function returns the following values: // // - goret *gst.Event (nullable) @@ -3364,6 +3414,7 @@ func (h *Harness) TryPullEvent() *gst.Event { } // TryPullUpstreamEvent wraps gst_harness_try_pull_upstream_event +// // The function returns the following values: // // - goret *gst.Event (nullable) @@ -3391,6 +3442,7 @@ func (h *Harness) TryPullUpstreamEvent() *gst.Event { } // UpstreamEventsInQueue wraps gst_harness_upstream_events_in_queue +// // The function returns the following values: // // - goret uint @@ -3415,6 +3467,7 @@ func (h *Harness) UpstreamEventsInQueue() uint { } // UpstreamEventsReceived wraps gst_harness_upstream_events_received +// // The function returns the following values: // // - goret uint @@ -3527,7 +3580,7 @@ func UnsafeHarnessThreadFromGlibBorrow(p unsafe.Pointer) *HarnessThread { return &HarnessThread{&harnessThread{(*C.GstHarnessThread)(p)}} } -// UnsafeHarnessThreadFromGlibNone is used to convert raw C.GstHarnessThread pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeHarnessThreadFromGlibNone is used to convert raw C.GstHarnessThread pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeHarnessThreadFromGlibNone(p unsafe.Pointer) *HarnessThread { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeHarnessThreadFromGlibBorrow(p) @@ -3540,7 +3593,7 @@ func UnsafeHarnessThreadFromGlibNone(p unsafe.Pointer) *HarnessThread { return wrapped } -// UnsafeHarnessThreadFromGlibFull is used to convert raw C.GstHarnessThread pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeHarnessThreadFromGlibFull is used to convert raw C.GstHarnessThread pointers to go while taking ownership. This is used by the bindings internally. func UnsafeHarnessThreadFromGlibFull(p unsafe.Pointer) *HarnessThread { wrapped := UnsafeHarnessThreadFromGlibBorrow(p) runtime.SetFinalizer( @@ -3572,6 +3625,7 @@ func UnsafeHarnessThreadToGlibFull(h *HarnessThread) unsafe.Pointer { h.native = nil // HarnessThread is invalid from here on return _p } + // StreamConsistency wraps GstStreamConsistency // // Opaque consistency checker handle. @@ -3589,7 +3643,7 @@ func UnsafeStreamConsistencyFromGlibBorrow(p unsafe.Pointer) *StreamConsistency return &StreamConsistency{&streamConsistency{(*C.GstStreamConsistency)(p)}} } -// UnsafeStreamConsistencyFromGlibNone is used to convert raw C.GstStreamConsistency pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeStreamConsistencyFromGlibNone is used to convert raw C.GstStreamConsistency pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeStreamConsistencyFromGlibNone(p unsafe.Pointer) *StreamConsistency { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeStreamConsistencyFromGlibBorrow(p) @@ -3602,7 +3656,7 @@ func UnsafeStreamConsistencyFromGlibNone(p unsafe.Pointer) *StreamConsistency { return wrapped } -// UnsafeStreamConsistencyFromGlibFull is used to convert raw C.GstStreamConsistency pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeStreamConsistencyFromGlibFull is used to convert raw C.GstStreamConsistency pointers to go while taking ownership. This is used by the bindings internally. func UnsafeStreamConsistencyFromGlibFull(p unsafe.Pointer) *StreamConsistency { wrapped := UnsafeStreamConsistencyFromGlibBorrow(p) runtime.SetFinalizer( @@ -3634,9 +3688,12 @@ func UnsafeStreamConsistencyToGlibFull(s *StreamConsistency) unsafe.Pointer { s.native = nil // StreamConsistency is invalid from here on return _p } + // TestClockClass wraps GstTestClockClass // // The class of a #GstTestClock, which has no virtual methods to override. +// +// TestClockClass is the type struct for [TestClock] type TestClockClass struct { *testClockClass } @@ -3651,31 +3708,6 @@ func UnsafeTestClockClassFromGlibBorrow(p unsafe.Pointer) *TestClockClass { return &TestClockClass{&testClockClass{(*C.GstTestClockClass)(p)}} } -// UnsafeTestClockClassFromGlibNone is used to convert raw C.GstTestClockClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeTestClockClassFromGlibNone(p unsafe.Pointer) *TestClockClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeTestClockClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.testClockClass, - func (intern *testClockClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeTestClockClassFromGlibFull is used to convert raw C.GstTestClockClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeTestClockClassFromGlibFull(p unsafe.Pointer) *TestClockClass { - wrapped := UnsafeTestClockClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.testClockClass, - func (intern *testClockClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeTestClockClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [TestClockClass] is expected to work anymore. @@ -3688,11 +3720,12 @@ func UnsafeTestClockClassToGlibNone(t *TestClockClass) unsafe.Pointer { return unsafe.Pointer(t.native) } -// UnsafeTestClockClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeTestClockClassToGlibFull(t *TestClockClass) unsafe.Pointer { - runtime.SetFinalizer(t.testClockClass, nil) - _p := unsafe.Pointer(t.native) - t.native = nil // TestClockClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (t *TestClockClass) ParentClass() *gst.ClockClass { + parent := gst.UnsafeClockClassFromGlibBorrow(UnsafeTestClockClassToGlibNone(t)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *TestClockClass) {}, t) + return parent } + diff --git a/pkg/gstcontroller/gstcontroller.gen.go b/pkg/gstcontroller/gstcontroller.gen.go index 73dc0ea..b3c8b0b 100644 --- a/pkg/gstcontroller/gstcontroller.gen.go +++ b/pkg/gstcontroller/gstcontroller.gen.go @@ -267,6 +267,20 @@ func NewARGBControlBinding(object gst.Object, propertyName string, csA gst.Contr return goret } +// ARGBControlBindingOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type ARGBControlBindingOverrides[Instance ARGBControlBinding] struct { + // gst.ControlBindingOverrides allows you to override virtual methods from the parent class gst.ControlBinding + gst.ControlBindingOverrides[Instance] + +} + +// UnsafeApplyARGBControlBindingOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyARGBControlBindingOverrides[Instance ARGBControlBinding](gclass unsafe.Pointer, overrides ARGBControlBindingOverrides[Instance]) { + gst.UnsafeApplyControlBindingOverrides(gclass, overrides.ControlBindingOverrides) +} + // DirectControlBindingInstance is the instance type used by all types extending GstDirectControlBinding. It is used internally by the bindings. Users should use the interface [DirectControlBinding] instead. type DirectControlBindingInstance struct { _ [0]func() // equal guard @@ -404,6 +418,20 @@ func NewDirectControlBindingAbsolute(object gst.Object, propertyName string, cs return goret } +// DirectControlBindingOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type DirectControlBindingOverrides[Instance DirectControlBinding] struct { + // gst.ControlBindingOverrides allows you to override virtual methods from the parent class gst.ControlBinding + gst.ControlBindingOverrides[Instance] + +} + +// UnsafeApplyDirectControlBindingOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyDirectControlBindingOverrides[Instance DirectControlBinding](gclass unsafe.Pointer, overrides DirectControlBindingOverrides[Instance]) { + gst.UnsafeApplyControlBindingOverrides(gclass, overrides.ControlBindingOverrides) +} + // LFOControlSourceInstance is the instance type used by all types extending GstLFOControlSource. It is used internally by the bindings. Users should use the interface [LFOControlSource] instead. type LFOControlSourceInstance struct { _ [0]func() // equal guard @@ -468,6 +496,7 @@ func UnsafeLFOControlSourceToGlibFull(c LFOControlSource) unsafe.Pointer { } // NewLFOControlSource wraps gst_lfo_control_source_new +// // The function returns the following values: // // - goret gst.ControlSource @@ -485,6 +514,20 @@ func NewLFOControlSource() gst.ControlSource { return goret } +// LFOControlSourceOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type LFOControlSourceOverrides[Instance LFOControlSource] struct { + // gst.ControlSourceOverrides allows you to override virtual methods from the parent class gst.ControlSource + gst.ControlSourceOverrides[Instance] + +} + +// UnsafeApplyLFOControlSourceOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyLFOControlSourceOverrides[Instance LFOControlSource](gclass unsafe.Pointer, overrides LFOControlSourceOverrides[Instance]) { + gst.UnsafeApplyControlSourceOverrides(gclass, overrides.ControlSourceOverrides) +} + // ProxyControlBindingInstance is the instance type used by all types extending GstProxyControlBinding. It is used internally by the bindings. Users should use the interface [ProxyControlBinding] instead. type ProxyControlBindingInstance struct { _ [0]func() // equal guard @@ -585,6 +628,20 @@ func NewProxyControlBinding(object gst.Object, propertyName string, refObject gs return goret } +// ProxyControlBindingOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type ProxyControlBindingOverrides[Instance ProxyControlBinding] struct { + // gst.ControlBindingOverrides allows you to override virtual methods from the parent class gst.ControlBinding + gst.ControlBindingOverrides[Instance] + +} + +// UnsafeApplyProxyControlBindingOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyProxyControlBindingOverrides[Instance ProxyControlBinding](gclass unsafe.Pointer, overrides ProxyControlBindingOverrides[Instance]) { + gst.UnsafeApplyControlBindingOverrides(gclass, overrides.ControlBindingOverrides) +} + // TimedValueControlSourceInstance is the instance type used by all types extending GstTimedValueControlSource. It is used internally by the bindings. Users should use the interface [TimedValueControlSource] instead. type TimedValueControlSourceInstance struct { _ [0]func() // equal guard @@ -622,6 +679,7 @@ type TimedValueControlSource interface { // For use in control source implementations. FindControlPointIter(gst.ClockTime) *glib.SequenceIter // GetAll wraps gst_timed_value_control_source_get_all + // // The function returns the following values: // // - goret []*gst.TimedValue @@ -630,6 +688,7 @@ type TimedValueControlSource interface { // Free the list after done with it. GetAll() []*gst.TimedValue // GetCount wraps gst_timed_value_control_source_get_count + // // The function returns the following values: // // - goret int @@ -757,6 +816,7 @@ func (self *TimedValueControlSourceInstance) FindControlPointIter(timestamp gst. } // GetAll wraps gst_timed_value_control_source_get_all +// // The function returns the following values: // // - goret []*gst.TimedValue @@ -787,6 +847,7 @@ func (self *TimedValueControlSourceInstance) GetAll() []*gst.TimedValue { } // GetCount wraps gst_timed_value_control_source_get_count +// // The function returns the following values: // // - goret int @@ -895,18 +956,35 @@ func (self *TimedValueControlSourceInstance) UnsetAll() { func (o *TimedValueControlSourceInstance) ConnectValueAdded(fn func(TimedValueControlSource, ControlPoint)) gobject.SignalHandle { return o.Connect("value-added", fn) } + // ConnectValueChanged connects the provided callback to the "value-changed" signal // // Emitted right after the new value has been set on @timed_signals func (o *TimedValueControlSourceInstance) ConnectValueChanged(fn func(TimedValueControlSource, ControlPoint)) gobject.SignalHandle { return o.Connect("value-changed", fn) } + // ConnectValueRemoved connects the provided callback to the "value-removed" signal // // Emitted when @timed_value is removed from @self func (o *TimedValueControlSourceInstance) ConnectValueRemoved(fn func(TimedValueControlSource, ControlPoint)) gobject.SignalHandle { return o.Connect("value-removed", fn) } + +// TimedValueControlSourceOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type TimedValueControlSourceOverrides[Instance TimedValueControlSource] struct { + // gst.ControlSourceOverrides allows you to override virtual methods from the parent class gst.ControlSource + gst.ControlSourceOverrides[Instance] + +} + +// UnsafeApplyTimedValueControlSourceOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyTimedValueControlSourceOverrides[Instance TimedValueControlSource](gclass unsafe.Pointer, overrides TimedValueControlSourceOverrides[Instance]) { + gst.UnsafeApplyControlSourceOverrides(gclass, overrides.ControlSourceOverrides) +} + // TriggerControlSourceInstance is the instance type used by all types extending GstTriggerControlSource. It is used internally by the bindings. Users should use the interface [TriggerControlSource] instead. type TriggerControlSourceInstance struct { _ [0]func() // equal guard @@ -973,6 +1051,7 @@ func UnsafeTriggerControlSourceToGlibFull(c TriggerControlSource) unsafe.Pointer } // NewTriggerControlSource wraps gst_trigger_control_source_new +// // The function returns the following values: // // - goret gst.ControlSource @@ -990,6 +1069,20 @@ func NewTriggerControlSource() gst.ControlSource { return goret } +// TriggerControlSourceOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type TriggerControlSourceOverrides[Instance TriggerControlSource] struct { + // TimedValueControlSourceOverrides allows you to override virtual methods from the parent class TimedValueControlSource + TimedValueControlSourceOverrides[Instance] + +} + +// UnsafeApplyTriggerControlSourceOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyTriggerControlSourceOverrides[Instance TriggerControlSource](gclass unsafe.Pointer, overrides TriggerControlSourceOverrides[Instance]) { + UnsafeApplyTimedValueControlSourceOverrides(gclass, overrides.TimedValueControlSourceOverrides) +} + // InterpolationControlSourceInstance is the instance type used by all types extending GstInterpolationControlSource. It is used internally by the bindings. Users should use the interface [InterpolationControlSource] instead. type InterpolationControlSourceInstance struct { _ [0]func() // equal guard @@ -1056,6 +1149,7 @@ func UnsafeInterpolationControlSourceToGlibFull(c InterpolationControlSource) un } // NewInterpolationControlSource wraps gst_interpolation_control_source_new +// // The function returns the following values: // // - goret gst.ControlSource @@ -1073,9 +1167,25 @@ func NewInterpolationControlSource() gst.ControlSource { return goret } +// InterpolationControlSourceOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type InterpolationControlSourceOverrides[Instance InterpolationControlSource] struct { + // TimedValueControlSourceOverrides allows you to override virtual methods from the parent class TimedValueControlSource + TimedValueControlSourceOverrides[Instance] + +} + +// UnsafeApplyInterpolationControlSourceOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyInterpolationControlSourceOverrides[Instance InterpolationControlSource](gclass unsafe.Pointer, overrides InterpolationControlSourceOverrides[Instance]) { + UnsafeApplyTimedValueControlSourceOverrides(gclass, overrides.TimedValueControlSourceOverrides) +} + // ARGBControlBindingClass wraps GstARGBControlBindingClass // // The class structure of #GstARGBControlBinding. +// +// ARGBControlBindingClass is the type struct for [ARGBControlBinding] type ARGBControlBindingClass struct { *argbControlBindingClass } @@ -1090,31 +1200,6 @@ func UnsafeARGBControlBindingClassFromGlibBorrow(p unsafe.Pointer) *ARGBControlB return &ARGBControlBindingClass{&argbControlBindingClass{(*C.GstARGBControlBindingClass)(p)}} } -// UnsafeARGBControlBindingClassFromGlibNone is used to convert raw C.GstARGBControlBindingClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeARGBControlBindingClassFromGlibNone(p unsafe.Pointer) *ARGBControlBindingClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeARGBControlBindingClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.argbControlBindingClass, - func (intern *argbControlBindingClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeARGBControlBindingClassFromGlibFull is used to convert raw C.GstARGBControlBindingClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeARGBControlBindingClassFromGlibFull(p unsafe.Pointer) *ARGBControlBindingClass { - wrapped := UnsafeARGBControlBindingClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.argbControlBindingClass, - func (intern *argbControlBindingClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeARGBControlBindingClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [ARGBControlBindingClass] is expected to work anymore. @@ -1127,14 +1212,15 @@ func UnsafeARGBControlBindingClassToGlibNone(a *ARGBControlBindingClass) unsafe. return unsafe.Pointer(a.native) } -// UnsafeARGBControlBindingClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeARGBControlBindingClassToGlibFull(a *ARGBControlBindingClass) unsafe.Pointer { - runtime.SetFinalizer(a.argbControlBindingClass, nil) - _p := unsafe.Pointer(a.native) - a.native = nil // ARGBControlBindingClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (a *ARGBControlBindingClass) ParentClass() *gst.ControlBindingClass { + parent := gst.UnsafeControlBindingClassFromGlibBorrow(UnsafeARGBControlBindingClassToGlibNone(a)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *ARGBControlBindingClass) {}, a) + return parent } + // ControlPoint wraps GstControlPoint // // An internal structure for value+time and various temporary @@ -1166,7 +1252,7 @@ func UnsafeControlPointFromGlibBorrow(p unsafe.Pointer) *ControlPoint { return &ControlPoint{&controlPoint{(*C.GstControlPoint)(p)}} } -// UnsafeControlPointFromGlibNone is used to convert raw C.GstControlPoint pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeControlPointFromGlibNone is used to convert raw C.GstControlPoint pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeControlPointFromGlibNone(p unsafe.Pointer) *ControlPoint { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeControlPointFromGlibBorrow(p) @@ -1179,7 +1265,7 @@ func UnsafeControlPointFromGlibNone(p unsafe.Pointer) *ControlPoint { return wrapped } -// UnsafeControlPointFromGlibFull is used to convert raw C.GstControlPoint pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeControlPointFromGlibFull is used to convert raw C.GstControlPoint pointers to go while taking ownership. This is used by the bindings internally. func UnsafeControlPointFromGlibFull(p unsafe.Pointer) *ControlPoint { wrapped := UnsafeControlPointFromGlibBorrow(p) runtime.SetFinalizer( @@ -1211,7 +1297,9 @@ func UnsafeControlPointToGlibFull(c *ControlPoint) unsafe.Pointer { c.native = nil // ControlPoint is invalid from here on return _p } + // Copy wraps gst_control_point_copy +// // The function returns the following values: // // - goret *ControlPoint @@ -1236,6 +1324,8 @@ func (cp *ControlPoint) Copy() *ControlPoint { // DirectControlBindingClass wraps GstDirectControlBindingClass // // The class structure of #GstDirectControlBinding. +// +// DirectControlBindingClass is the type struct for [DirectControlBinding] type DirectControlBindingClass struct { *directControlBindingClass } @@ -1250,31 +1340,6 @@ func UnsafeDirectControlBindingClassFromGlibBorrow(p unsafe.Pointer) *DirectCont return &DirectControlBindingClass{&directControlBindingClass{(*C.GstDirectControlBindingClass)(p)}} } -// UnsafeDirectControlBindingClassFromGlibNone is used to convert raw C.GstDirectControlBindingClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeDirectControlBindingClassFromGlibNone(p unsafe.Pointer) *DirectControlBindingClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeDirectControlBindingClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.directControlBindingClass, - func (intern *directControlBindingClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeDirectControlBindingClassFromGlibFull is used to convert raw C.GstDirectControlBindingClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeDirectControlBindingClassFromGlibFull(p unsafe.Pointer) *DirectControlBindingClass { - wrapped := UnsafeDirectControlBindingClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.directControlBindingClass, - func (intern *directControlBindingClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeDirectControlBindingClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [DirectControlBindingClass] is expected to work anymore. @@ -1287,15 +1352,18 @@ func UnsafeDirectControlBindingClassToGlibNone(d *DirectControlBindingClass) uns return unsafe.Pointer(d.native) } -// UnsafeDirectControlBindingClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeDirectControlBindingClassToGlibFull(d *DirectControlBindingClass) unsafe.Pointer { - runtime.SetFinalizer(d.directControlBindingClass, nil) - _p := unsafe.Pointer(d.native) - d.native = nil // DirectControlBindingClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (d *DirectControlBindingClass) ParentClass() *gst.ControlBindingClass { + parent := gst.UnsafeControlBindingClassFromGlibBorrow(UnsafeDirectControlBindingClassToGlibNone(d)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *DirectControlBindingClass) {}, d) + return parent } + // InterpolationControlSourceClass wraps GstInterpolationControlSourceClass +// +// InterpolationControlSourceClass is the type struct for [InterpolationControlSource] type InterpolationControlSourceClass struct { *interpolationControlSourceClass } @@ -1310,31 +1378,6 @@ func UnsafeInterpolationControlSourceClassFromGlibBorrow(p unsafe.Pointer) *Inte return &InterpolationControlSourceClass{&interpolationControlSourceClass{(*C.GstInterpolationControlSourceClass)(p)}} } -// UnsafeInterpolationControlSourceClassFromGlibNone is used to convert raw C.GstInterpolationControlSourceClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeInterpolationControlSourceClassFromGlibNone(p unsafe.Pointer) *InterpolationControlSourceClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeInterpolationControlSourceClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.interpolationControlSourceClass, - func (intern *interpolationControlSourceClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeInterpolationControlSourceClassFromGlibFull is used to convert raw C.GstInterpolationControlSourceClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeInterpolationControlSourceClassFromGlibFull(p unsafe.Pointer) *InterpolationControlSourceClass { - wrapped := UnsafeInterpolationControlSourceClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.interpolationControlSourceClass, - func (intern *interpolationControlSourceClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeInterpolationControlSourceClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [InterpolationControlSourceClass] is expected to work anymore. @@ -1347,15 +1390,18 @@ func UnsafeInterpolationControlSourceClassToGlibNone(i *InterpolationControlSour return unsafe.Pointer(i.native) } -// UnsafeInterpolationControlSourceClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeInterpolationControlSourceClassToGlibFull(i *InterpolationControlSourceClass) unsafe.Pointer { - runtime.SetFinalizer(i.interpolationControlSourceClass, nil) - _p := unsafe.Pointer(i.native) - i.native = nil // InterpolationControlSourceClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (i *InterpolationControlSourceClass) ParentClass() *TimedValueControlSourceClass { + parent := UnsafeTimedValueControlSourceClassFromGlibBorrow(UnsafeInterpolationControlSourceClassToGlibNone(i)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *InterpolationControlSourceClass) {}, i) + return parent } + // LFOControlSourceClass wraps GstLFOControlSourceClass +// +// LFOControlSourceClass is the type struct for [LFOControlSource] type LFOControlSourceClass struct { *lfoControlSourceClass } @@ -1370,31 +1416,6 @@ func UnsafeLFOControlSourceClassFromGlibBorrow(p unsafe.Pointer) *LFOControlSour return &LFOControlSourceClass{&lfoControlSourceClass{(*C.GstLFOControlSourceClass)(p)}} } -// UnsafeLFOControlSourceClassFromGlibNone is used to convert raw C.GstLFOControlSourceClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeLFOControlSourceClassFromGlibNone(p unsafe.Pointer) *LFOControlSourceClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeLFOControlSourceClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.lfoControlSourceClass, - func (intern *lfoControlSourceClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeLFOControlSourceClassFromGlibFull is used to convert raw C.GstLFOControlSourceClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeLFOControlSourceClassFromGlibFull(p unsafe.Pointer) *LFOControlSourceClass { - wrapped := UnsafeLFOControlSourceClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.lfoControlSourceClass, - func (intern *lfoControlSourceClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeLFOControlSourceClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [LFOControlSourceClass] is expected to work anymore. @@ -1407,17 +1428,20 @@ func UnsafeLFOControlSourceClassToGlibNone(l *LFOControlSourceClass) unsafe.Poin return unsafe.Pointer(l.native) } -// UnsafeLFOControlSourceClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeLFOControlSourceClassToGlibFull(l *LFOControlSourceClass) unsafe.Pointer { - runtime.SetFinalizer(l.lfoControlSourceClass, nil) - _p := unsafe.Pointer(l.native) - l.native = nil // LFOControlSourceClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (l *LFOControlSourceClass) ParentClass() *gst.ControlSourceClass { + parent := gst.UnsafeControlSourceClassFromGlibBorrow(UnsafeLFOControlSourceClassToGlibNone(l)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *LFOControlSourceClass) {}, l) + return parent } + // ProxyControlBindingClass wraps GstProxyControlBindingClass // // Opaque #GstProxyControlBindingClass struct +// +// ProxyControlBindingClass is the type struct for [ProxyControlBinding] type ProxyControlBindingClass struct { *proxyControlBindingClass } @@ -1432,31 +1456,6 @@ func UnsafeProxyControlBindingClassFromGlibBorrow(p unsafe.Pointer) *ProxyContro return &ProxyControlBindingClass{&proxyControlBindingClass{(*C.GstProxyControlBindingClass)(p)}} } -// UnsafeProxyControlBindingClassFromGlibNone is used to convert raw C.GstProxyControlBindingClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeProxyControlBindingClassFromGlibNone(p unsafe.Pointer) *ProxyControlBindingClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeProxyControlBindingClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.proxyControlBindingClass, - func (intern *proxyControlBindingClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeProxyControlBindingClassFromGlibFull is used to convert raw C.GstProxyControlBindingClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeProxyControlBindingClassFromGlibFull(p unsafe.Pointer) *ProxyControlBindingClass { - wrapped := UnsafeProxyControlBindingClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.proxyControlBindingClass, - func (intern *proxyControlBindingClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeProxyControlBindingClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [ProxyControlBindingClass] is expected to work anymore. @@ -1469,15 +1468,18 @@ func UnsafeProxyControlBindingClassToGlibNone(p *ProxyControlBindingClass) unsaf return unsafe.Pointer(p.native) } -// UnsafeProxyControlBindingClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeProxyControlBindingClassToGlibFull(p *ProxyControlBindingClass) unsafe.Pointer { - runtime.SetFinalizer(p.proxyControlBindingClass, nil) - _p := unsafe.Pointer(p.native) - p.native = nil // ProxyControlBindingClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (p *ProxyControlBindingClass) ParentClass() *gst.ControlBindingClass { + parent := gst.UnsafeControlBindingClassFromGlibBorrow(UnsafeProxyControlBindingClassToGlibNone(p)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *ProxyControlBindingClass) {}, p) + return parent } + // TimedValueControlSourceClass wraps GstTimedValueControlSourceClass +// +// TimedValueControlSourceClass is the type struct for [TimedValueControlSource] type TimedValueControlSourceClass struct { *timedValueControlSourceClass } @@ -1492,31 +1494,6 @@ func UnsafeTimedValueControlSourceClassFromGlibBorrow(p unsafe.Pointer) *TimedVa return &TimedValueControlSourceClass{&timedValueControlSourceClass{(*C.GstTimedValueControlSourceClass)(p)}} } -// UnsafeTimedValueControlSourceClassFromGlibNone is used to convert raw C.GstTimedValueControlSourceClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeTimedValueControlSourceClassFromGlibNone(p unsafe.Pointer) *TimedValueControlSourceClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeTimedValueControlSourceClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.timedValueControlSourceClass, - func (intern *timedValueControlSourceClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeTimedValueControlSourceClassFromGlibFull is used to convert raw C.GstTimedValueControlSourceClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeTimedValueControlSourceClassFromGlibFull(p unsafe.Pointer) *TimedValueControlSourceClass { - wrapped := UnsafeTimedValueControlSourceClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.timedValueControlSourceClass, - func (intern *timedValueControlSourceClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeTimedValueControlSourceClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [TimedValueControlSourceClass] is expected to work anymore. @@ -1529,15 +1506,18 @@ func UnsafeTimedValueControlSourceClassToGlibNone(t *TimedValueControlSourceClas return unsafe.Pointer(t.native) } -// UnsafeTimedValueControlSourceClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeTimedValueControlSourceClassToGlibFull(t *TimedValueControlSourceClass) unsafe.Pointer { - runtime.SetFinalizer(t.timedValueControlSourceClass, nil) - _p := unsafe.Pointer(t.native) - t.native = nil // TimedValueControlSourceClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (t *TimedValueControlSourceClass) ParentClass() *gst.ControlSourceClass { + parent := gst.UnsafeControlSourceClassFromGlibBorrow(UnsafeTimedValueControlSourceClassToGlibNone(t)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *TimedValueControlSourceClass) {}, t) + return parent } + // TriggerControlSourceClass wraps GstTriggerControlSourceClass +// +// TriggerControlSourceClass is the type struct for [TriggerControlSource] type TriggerControlSourceClass struct { *triggerControlSourceClass } @@ -1552,31 +1532,6 @@ func UnsafeTriggerControlSourceClassFromGlibBorrow(p unsafe.Pointer) *TriggerCon return &TriggerControlSourceClass{&triggerControlSourceClass{(*C.GstTriggerControlSourceClass)(p)}} } -// UnsafeTriggerControlSourceClassFromGlibNone is used to convert raw C.GstTriggerControlSourceClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeTriggerControlSourceClassFromGlibNone(p unsafe.Pointer) *TriggerControlSourceClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeTriggerControlSourceClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.triggerControlSourceClass, - func (intern *triggerControlSourceClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeTriggerControlSourceClassFromGlibFull is used to convert raw C.GstTriggerControlSourceClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeTriggerControlSourceClassFromGlibFull(p unsafe.Pointer) *TriggerControlSourceClass { - wrapped := UnsafeTriggerControlSourceClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.triggerControlSourceClass, - func (intern *triggerControlSourceClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeTriggerControlSourceClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [TriggerControlSourceClass] is expected to work anymore. @@ -1589,11 +1544,12 @@ func UnsafeTriggerControlSourceClassToGlibNone(t *TriggerControlSourceClass) uns return unsafe.Pointer(t.native) } -// UnsafeTriggerControlSourceClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeTriggerControlSourceClassToGlibFull(t *TriggerControlSourceClass) unsafe.Pointer { - runtime.SetFinalizer(t.triggerControlSourceClass, nil) - _p := unsafe.Pointer(t.native) - t.native = nil // TriggerControlSourceClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (t *TriggerControlSourceClass) ParentClass() *TimedValueControlSourceClass { + parent := UnsafeTimedValueControlSourceClassFromGlibBorrow(UnsafeTriggerControlSourceClassToGlibNone(t)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *TriggerControlSourceClass) {}, t) + return parent } + diff --git a/pkg/gstgl/gstgl.gen.go b/pkg/gstgl/gstgl.gen.go index 721b993..41ac05e 100644 --- a/pkg/gstgl/gstgl.gen.go +++ b/pkg/gstgl/gstgl.gen.go @@ -20,6 +20,162 @@ import ( // #cgo CFLAGS: -Wno-deprecated-declarations // #include // extern gboolean _gotk4_gstgl1_GLFilterRenderFunc(GstGLFilter*, GstGLMemory*, gpointer); +// extern gboolean _gotk4_gstgl1_GLBaseFilter_gl_set_caps(GstGLBaseFilter*, GstCaps*, GstCaps*); +// extern gboolean _gotk4_gstgl1_GLBaseFilter_gl_start(GstGLBaseFilter*); +// extern void _gotk4_gstgl1_GLBaseFilter_gl_stop(GstGLBaseFilter*); +// gboolean _gotk4_gstgl1_GLBaseFilter_virtual_gl_set_caps(void* fnptr, GstGLBaseFilter* carg0, GstCaps* carg1, GstCaps* carg2) { +// return ((gboolean (*) (GstGLBaseFilter*, GstCaps*, GstCaps*))(fnptr))(carg0, carg1, carg2); +// } +// gboolean _gotk4_gstgl1_GLBaseFilter_virtual_gl_start(void* fnptr, GstGLBaseFilter* carg0) { +// return ((gboolean (*) (GstGLBaseFilter*))(fnptr))(carg0); +// } +// void _gotk4_gstgl1_GLBaseFilter_virtual_gl_stop(void* fnptr, GstGLBaseFilter* carg0) { +// return ((void (*) (GstGLBaseFilter*))(fnptr))(carg0); +// } +// extern gboolean _gotk4_gstgl1_GLBaseMixer_gl_start(GstGLBaseMixer*); +// extern void _gotk4_gstgl1_GLBaseMixer_gl_stop(GstGLBaseMixer*); +// gboolean _gotk4_gstgl1_GLBaseMixer_virtual_gl_start(void* fnptr, GstGLBaseMixer* carg0) { +// return ((gboolean (*) (GstGLBaseMixer*))(fnptr))(carg0); +// } +// void _gotk4_gstgl1_GLBaseMixer_virtual_gl_stop(void* fnptr, GstGLBaseMixer* carg0) { +// return ((void (*) (GstGLBaseMixer*))(fnptr))(carg0); +// } +// extern gboolean _gotk4_gstgl1_GLBaseSrc_fill_gl_memory(GstGLBaseSrc*, GstGLMemory*); +// extern gboolean _gotk4_gstgl1_GLBaseSrc_gl_start(GstGLBaseSrc*); +// extern void _gotk4_gstgl1_GLBaseSrc_gl_stop(GstGLBaseSrc*); +// gboolean _gotk4_gstgl1_GLBaseSrc_virtual_fill_gl_memory(void* fnptr, GstGLBaseSrc* carg0, GstGLMemory* carg1) { +// return ((gboolean (*) (GstGLBaseSrc*, GstGLMemory*))(fnptr))(carg0, carg1); +// } +// gboolean _gotk4_gstgl1_GLBaseSrc_virtual_gl_start(void* fnptr, GstGLBaseSrc* carg0) { +// return ((gboolean (*) (GstGLBaseSrc*))(fnptr))(carg0); +// } +// void _gotk4_gstgl1_GLBaseSrc_virtual_gl_stop(void* fnptr, GstGLBaseSrc* carg0) { +// return ((void (*) (GstGLBaseSrc*))(fnptr))(carg0); +// } +// extern gboolean _gotk4_gstgl1_GLContext_activate(GstGLContext*, gboolean); +// extern gboolean _gotk4_gstgl1_GLContext_check_feature(GstGLContext*, gchar*); +// extern gboolean _gotk4_gstgl1_GLContext_choose_format(GstGLContext*, GError*); +// extern gboolean _gotk4_gstgl1_GLContext_create_context(GstGLContext*, GstGLAPI, GstGLContext*, GError*); +// extern void _gotk4_gstgl1_GLContext_destroy_context(GstGLContext*); +// extern GstStructure* _gotk4_gstgl1_GLContext_get_config(GstGLContext*); +// extern GstGLAPI _gotk4_gstgl1_GLContext_get_gl_api(GstGLContext*); +// extern GstGLPlatform _gotk4_gstgl1_GLContext_get_gl_platform(GstGLContext*); +// extern void _gotk4_gstgl1_GLContext_get_gl_platform_version(GstGLContext*, gint, gint); +// extern gboolean _gotk4_gstgl1_GLContext_request_config(GstGLContext*, GstStructure*); +// extern void _gotk4_gstgl1_GLContext_swap_buffers(GstGLContext*); +// gboolean _gotk4_gstgl1_GLContext_virtual_activate(void* fnptr, GstGLContext* carg0, gboolean carg1) { +// return ((gboolean (*) (GstGLContext*, gboolean))(fnptr))(carg0, carg1); +// } +// gboolean _gotk4_gstgl1_GLContext_virtual_check_feature(void* fnptr, GstGLContext* carg0, gchar* carg1) { +// return ((gboolean (*) (GstGLContext*, gchar*))(fnptr))(carg0, carg1); +// } +// gboolean _gotk4_gstgl1_GLContext_virtual_choose_format(void* fnptr, GstGLContext* carg0, GError** _cerr) { +// return ((gboolean (*) (GstGLContext*, GError**))(fnptr))(carg0, _cerr); +// } +// gboolean _gotk4_gstgl1_GLContext_virtual_create_context(void* fnptr, GstGLContext* carg0, GstGLAPI carg1, GstGLContext* carg2, GError** _cerr) { +// return ((gboolean (*) (GstGLContext*, GstGLAPI, GstGLContext*, GError**))(fnptr))(carg0, carg1, carg2, _cerr); +// } +// void _gotk4_gstgl1_GLContext_virtual_destroy_context(void* fnptr, GstGLContext* carg0) { +// return ((void (*) (GstGLContext*))(fnptr))(carg0); +// } +// GstStructure* _gotk4_gstgl1_GLContext_virtual_get_config(void* fnptr, GstGLContext* carg0) { +// return ((GstStructure* (*) (GstGLContext*))(fnptr))(carg0); +// } +// GstGLAPI _gotk4_gstgl1_GLContext_virtual_get_gl_api(void* fnptr, GstGLContext* carg0) { +// return ((GstGLAPI (*) (GstGLContext*))(fnptr))(carg0); +// } +// GstGLPlatform _gotk4_gstgl1_GLContext_virtual_get_gl_platform(void* fnptr, GstGLContext* carg0) { +// return ((GstGLPlatform (*) (GstGLContext*))(fnptr))(carg0); +// } +// void _gotk4_gstgl1_GLContext_virtual_get_gl_platform_version(void* fnptr, GstGLContext* carg0, gint* carg1, gint* carg2) { +// return ((void (*) (GstGLContext*, gint*, gint*))(fnptr))(carg0, carg1, carg2); +// } +// gboolean _gotk4_gstgl1_GLContext_virtual_request_config(void* fnptr, GstGLContext* carg0, GstStructure* carg1) { +// return ((gboolean (*) (GstGLContext*, GstStructure*))(fnptr))(carg0, carg1); +// } +// void _gotk4_gstgl1_GLContext_virtual_swap_buffers(void* fnptr, GstGLContext* carg0) { +// return ((void (*) (GstGLContext*))(fnptr))(carg0); +// } +// extern GstGLWindow* _gotk4_gstgl1_GLDisplay_create_window(GstGLDisplay*); +// GstGLWindow* _gotk4_gstgl1_GLDisplay_virtual_create_window(void* fnptr, GstGLDisplay* carg0) { +// return ((GstGLWindow* (*) (GstGLDisplay*))(fnptr))(carg0); +// } +// extern gboolean _gotk4_gstgl1_GLFilter_filter(GstGLFilter*, GstBuffer*, GstBuffer*); +// extern gboolean _gotk4_gstgl1_GLFilter_filter_texture(GstGLFilter*, GstGLMemory*, GstGLMemory*); +// extern gboolean _gotk4_gstgl1_GLFilter_init_fbo(GstGLFilter*); +// extern gboolean _gotk4_gstgl1_GLFilter_set_caps(GstGLFilter*, GstCaps*, GstCaps*); +// extern GstCaps* _gotk4_gstgl1_GLFilter_transform_internal_caps(GstGLFilter*, GstPadDirection, GstCaps*, GstCaps*); +// gboolean _gotk4_gstgl1_GLFilter_virtual_filter(void* fnptr, GstGLFilter* carg0, GstBuffer* carg1, GstBuffer* carg2) { +// return ((gboolean (*) (GstGLFilter*, GstBuffer*, GstBuffer*))(fnptr))(carg0, carg1, carg2); +// } +// gboolean _gotk4_gstgl1_GLFilter_virtual_filter_texture(void* fnptr, GstGLFilter* carg0, GstGLMemory* carg1, GstGLMemory* carg2) { +// return ((gboolean (*) (GstGLFilter*, GstGLMemory*, GstGLMemory*))(fnptr))(carg0, carg1, carg2); +// } +// gboolean _gotk4_gstgl1_GLFilter_virtual_init_fbo(void* fnptr, GstGLFilter* carg0) { +// return ((gboolean (*) (GstGLFilter*))(fnptr))(carg0); +// } +// gboolean _gotk4_gstgl1_GLFilter_virtual_set_caps(void* fnptr, GstGLFilter* carg0, GstCaps* carg1, GstCaps* carg2) { +// return ((gboolean (*) (GstGLFilter*, GstCaps*, GstCaps*))(fnptr))(carg0, carg1, carg2); +// } +// GstCaps* _gotk4_gstgl1_GLFilter_virtual_transform_internal_caps(void* fnptr, GstGLFilter* carg0, GstPadDirection carg1, GstCaps* carg2, GstCaps* carg3) { +// return ((GstCaps* (*) (GstGLFilter*, GstPadDirection, GstCaps*, GstCaps*))(fnptr))(carg0, carg1, carg2, carg3); +// } +// extern gboolean _gotk4_gstgl1_GLMixer_process_buffers(GstGLMixer*, GstBuffer*); +// extern gboolean _gotk4_gstgl1_GLMixer_process_textures(GstGLMixer*, GstGLMemory*); +// gboolean _gotk4_gstgl1_GLMixer_virtual_process_buffers(void* fnptr, GstGLMixer* carg0, GstBuffer* carg1) { +// return ((gboolean (*) (GstGLMixer*, GstBuffer*))(fnptr))(carg0, carg1); +// } +// gboolean _gotk4_gstgl1_GLMixer_virtual_process_textures(void* fnptr, GstGLMixer* carg0, GstGLMemory* carg1) { +// return ((gboolean (*) (GstGLMixer*, GstGLMemory*))(fnptr))(carg0, carg1); +// } +// extern void _gotk4_gstgl1_GLWindow_close(GstGLWindow*); +// extern gboolean _gotk4_gstgl1_GLWindow_controls_viewport(GstGLWindow*); +// extern void _gotk4_gstgl1_GLWindow_draw(GstGLWindow*); +// extern void _gotk4_gstgl1_GLWindow_handle_events(GstGLWindow*, gboolean); +// extern gboolean _gotk4_gstgl1_GLWindow_has_output_surface(GstGLWindow*); +// extern gboolean _gotk4_gstgl1_GLWindow_open(GstGLWindow*, GError*); +// extern void _gotk4_gstgl1_GLWindow_queue_resize(GstGLWindow*); +// extern void _gotk4_gstgl1_GLWindow_quit(GstGLWindow*); +// extern void _gotk4_gstgl1_GLWindow_run(GstGLWindow*); +// extern void _gotk4_gstgl1_GLWindow_set_preferred_size(GstGLWindow*, gint, gint); +// extern gboolean _gotk4_gstgl1_GLWindow_set_render_rectangle(GstGLWindow*, gint, gint, gint, gint); +// extern void _gotk4_gstgl1_GLWindow_show(GstGLWindow*); +// void _gotk4_gstgl1_GLWindow_virtual_close(void* fnptr, GstGLWindow* carg0) { +// return ((void (*) (GstGLWindow*))(fnptr))(carg0); +// } +// gboolean _gotk4_gstgl1_GLWindow_virtual_controls_viewport(void* fnptr, GstGLWindow* carg0) { +// return ((gboolean (*) (GstGLWindow*))(fnptr))(carg0); +// } +// void _gotk4_gstgl1_GLWindow_virtual_draw(void* fnptr, GstGLWindow* carg0) { +// return ((void (*) (GstGLWindow*))(fnptr))(carg0); +// } +// void _gotk4_gstgl1_GLWindow_virtual_handle_events(void* fnptr, GstGLWindow* carg0, gboolean carg1) { +// return ((void (*) (GstGLWindow*, gboolean))(fnptr))(carg0, carg1); +// } +// gboolean _gotk4_gstgl1_GLWindow_virtual_has_output_surface(void* fnptr, GstGLWindow* carg0) { +// return ((gboolean (*) (GstGLWindow*))(fnptr))(carg0); +// } +// gboolean _gotk4_gstgl1_GLWindow_virtual_open(void* fnptr, GstGLWindow* carg0, GError** _cerr) { +// return ((gboolean (*) (GstGLWindow*, GError**))(fnptr))(carg0, _cerr); +// } +// void _gotk4_gstgl1_GLWindow_virtual_queue_resize(void* fnptr, GstGLWindow* carg0) { +// return ((void (*) (GstGLWindow*))(fnptr))(carg0); +// } +// void _gotk4_gstgl1_GLWindow_virtual_quit(void* fnptr, GstGLWindow* carg0) { +// return ((void (*) (GstGLWindow*))(fnptr))(carg0); +// } +// void _gotk4_gstgl1_GLWindow_virtual_run(void* fnptr, GstGLWindow* carg0) { +// return ((void (*) (GstGLWindow*))(fnptr))(carg0); +// } +// void _gotk4_gstgl1_GLWindow_virtual_set_preferred_size(void* fnptr, GstGLWindow* carg0, gint carg1, gint carg2) { +// return ((void (*) (GstGLWindow*, gint, gint))(fnptr))(carg0, carg1, carg2); +// } +// gboolean _gotk4_gstgl1_GLWindow_virtual_set_render_rectangle(void* fnptr, GstGLWindow* carg0, gint carg1, gint carg2, gint carg3, gint carg4) { +// return ((gboolean (*) (GstGLWindow*, gint, gint, gint, gint))(fnptr))(carg0, carg1, carg2, carg3, carg4); +// } +// void _gotk4_gstgl1_GLWindow_virtual_show(void* fnptr, GstGLWindow* carg0) { +// return ((void (*) (GstGLWindow*))(fnptr))(carg0); +// } import "C" // GType values. @@ -203,6 +359,7 @@ func (e GLBaseMemoryError) String() string { } // GLBaseMemoryErrorQuark wraps gst_gl_base_memory_error_quark +// // The function returns the following values: // // - goret glib.Quark @@ -339,6 +496,7 @@ func (e GLContextError) String() string { } // GLContextErrorQuark wraps gst_gl_context_error_quark +// // The function returns the following values: // // - goret glib.Quark @@ -707,6 +865,7 @@ func (e GLSLError) String() string { } // GLSLErrorQuark wraps gst_glsl_error_quark +// // The function returns the following values: // // - goret glib.Quark @@ -1264,6 +1423,7 @@ func (e GLWindowError) String() string { } // GLWindowErrorQuark wraps gst_gl_window_error_quark +// // The function returns the following values: // // - goret glib.Quark @@ -2389,6 +2549,7 @@ func GLSizedGLFormatFromGLFormatType(_context GLContext, format uint, typ uint) } // GLStereoDownmixModeGetType wraps gst_gl_stereo_downmix_mode_get_type +// // The function returns the following values: // // - goret gobject.Type @@ -2405,6 +2566,7 @@ func GLStereoDownmixModeGetType() gobject.Type { } // GLSyncMetaApiGetType wraps gst_gl_sync_meta_api_get_type +// // The function returns the following values: // // - goret gobject.Type @@ -2738,11 +2900,13 @@ type GLBaseFilter interface { upcastToGstGLBaseFilter() *GLBaseFilterInstance // FindGLContext wraps gst_gl_base_filter_find_gl_context + // // The function returns the following values: // // - goret bool FindGLContext() bool // GetGLContext wraps gst_gl_base_filter_get_gl_context + // // The function returns the following values: // // - goret GLContext (nullable) @@ -2792,6 +2956,7 @@ func UnsafeGLBaseFilterToGlibFull(c GLBaseFilter) unsafe.Pointer { } // FindGLContext wraps gst_gl_base_filter_find_gl_context +// // The function returns the following values: // // - goret bool @@ -2814,6 +2979,7 @@ func (filter *GLBaseFilterInstance) FindGLContext() bool { } // GetGLContext wraps gst_gl_base_filter_get_gl_context +// // The function returns the following values: // // - goret GLContext (nullable) @@ -2835,6 +3001,51 @@ func (filter *GLBaseFilterInstance) GetGLContext() GLContext { return goret } +// GLBaseFilterOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type GLBaseFilterOverrides[Instance GLBaseFilter] struct { + // gstbase.BaseTransformOverrides allows you to override virtual methods from the parent class gstbase.BaseTransform + gstbase.BaseTransformOverrides[Instance] + + // GLSetCaps allows you to override the implementation of the virtual method gl_set_caps. + // The function takes the following parameters: + // + // - incaps *gst.Caps + // - outcaps *gst.Caps + // + // The function returns the following values: + // + // - goret bool + GLSetCaps func(Instance, *gst.Caps, *gst.Caps) bool + // GLStart allows you to override the implementation of the virtual method gl_start. + // The function returns the following values: + // + // - goret bool + GLStart func(Instance) bool + // GLStop allows you to override the implementation of the virtual method gl_stop. + GLStop func(Instance) +} + +// UnsafeApplyGLBaseFilterOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyGLBaseFilterOverrides[Instance GLBaseFilter](gclass unsafe.Pointer, overrides GLBaseFilterOverrides[Instance]) { + gstbase.UnsafeApplyBaseTransformOverrides(gclass, overrides.BaseTransformOverrides) + + pclass := (*C.GstGLBaseFilterClass)(gclass) + + if overrides.GLSetCaps != nil { + pclass.gl_set_caps = (*[0]byte)(C._gotk4_gstgl1_GLBaseFilter_gl_set_caps) + } + + if overrides.GLStart != nil { + pclass.gl_start = (*[0]byte)(C._gotk4_gstgl1_GLBaseFilter_gl_start) + } + + if overrides.GLStop != nil { + pclass.gl_stop = (*[0]byte)(C._gotk4_gstgl1_GLBaseFilter_gl_stop) + } +} + // GLBaseMemoryAllocatorInstance is the instance type used by all types extending GstGLBaseMemoryAllocator. It is used internally by the bindings. Users should use the interface [GLBaseMemoryAllocator] instead. type GLBaseMemoryAllocatorInstance struct { _ [0]func() // equal guard @@ -2891,6 +3102,20 @@ func UnsafeGLBaseMemoryAllocatorToGlibFull(c GLBaseMemoryAllocator) unsafe.Point return gobject.UnsafeObjectToGlibFull(c) } +// GLBaseMemoryAllocatorOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type GLBaseMemoryAllocatorOverrides[Instance GLBaseMemoryAllocator] struct { + // gst.AllocatorOverrides allows you to override virtual methods from the parent class gst.Allocator + gst.AllocatorOverrides[Instance] + +} + +// UnsafeApplyGLBaseMemoryAllocatorOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyGLBaseMemoryAllocatorOverrides[Instance GLBaseMemoryAllocator](gclass unsafe.Pointer, overrides GLBaseMemoryAllocatorOverrides[Instance]) { + gst.UnsafeApplyAllocatorOverrides(gclass, overrides.AllocatorOverrides) +} + // GLBaseMixerInstance is the instance type used by all types extending GstGLBaseMixer. It is used internally by the bindings. Users should use the interface [GLBaseMixer] instead. type GLBaseMixerInstance struct { _ [0]func() // equal guard @@ -2909,6 +3134,7 @@ type GLBaseMixer interface { upcastToGstGLBaseMixer() *GLBaseMixerInstance // GetGLContext wraps gst_gl_base_mixer_get_gl_context + // // The function returns the following values: // // - goret GLContext (nullable) @@ -2960,6 +3186,7 @@ func UnsafeGLBaseMixerToGlibFull(c GLBaseMixer) unsafe.Pointer { } // GetGLContext wraps gst_gl_base_mixer_get_gl_context +// // The function returns the following values: // // - goret GLContext (nullable) @@ -2981,6 +3208,37 @@ func (mix *GLBaseMixerInstance) GetGLContext() GLContext { return goret } +// GLBaseMixerOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type GLBaseMixerOverrides[Instance GLBaseMixer] struct { + // gstvideo.VideoAggregatorOverrides allows you to override virtual methods from the parent class gstvideo.VideoAggregator + gstvideo.VideoAggregatorOverrides[Instance] + + // GLStart allows you to override the implementation of the virtual method gl_start. + // The function returns the following values: + // + // - goret bool + GLStart func(Instance) bool + // GLStop allows you to override the implementation of the virtual method gl_stop. + GLStop func(Instance) +} + +// UnsafeApplyGLBaseMixerOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyGLBaseMixerOverrides[Instance GLBaseMixer](gclass unsafe.Pointer, overrides GLBaseMixerOverrides[Instance]) { + gstvideo.UnsafeApplyVideoAggregatorOverrides(gclass, overrides.VideoAggregatorOverrides) + + pclass := (*C.GstGLBaseMixerClass)(gclass) + + if overrides.GLStart != nil { + pclass.gl_start = (*[0]byte)(C._gotk4_gstgl1_GLBaseMixer_gl_start) + } + + if overrides.GLStop != nil { + pclass.gl_stop = (*[0]byte)(C._gotk4_gstgl1_GLBaseMixer_gl_stop) + } +} + // GLBaseMixerPadInstance is the instance type used by all types extending GstGLBaseMixerPad. It is used internally by the bindings. Users should use the interface [GLBaseMixerPad] instead. type GLBaseMixerPadInstance struct { _ [0]func() // equal guard @@ -3039,6 +3297,20 @@ func UnsafeGLBaseMixerPadToGlibFull(c GLBaseMixerPad) unsafe.Pointer { return gobject.UnsafeObjectToGlibFull(c) } +// GLBaseMixerPadOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type GLBaseMixerPadOverrides[Instance GLBaseMixerPad] struct { + // gstvideo.VideoAggregatorPadOverrides allows you to override virtual methods from the parent class gstvideo.VideoAggregatorPad + gstvideo.VideoAggregatorPadOverrides[Instance] + +} + +// UnsafeApplyGLBaseMixerPadOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyGLBaseMixerPadOverrides[Instance GLBaseMixerPad](gclass unsafe.Pointer, overrides GLBaseMixerPadOverrides[Instance]) { + gstvideo.UnsafeApplyVideoAggregatorPadOverrides(gclass, overrides.VideoAggregatorPadOverrides) +} + // GLBaseSrcInstance is the instance type used by all types extending GstGLBaseSrc. It is used internally by the bindings. Users should use the interface [GLBaseSrc] instead. type GLBaseSrcInstance struct { _ [0]func() // equal guard @@ -3102,6 +3374,50 @@ func UnsafeGLBaseSrcToGlibFull(c GLBaseSrc) unsafe.Pointer { return gobject.UnsafeObjectToGlibFull(c) } +// GLBaseSrcOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type GLBaseSrcOverrides[Instance GLBaseSrc] struct { + // gstbase.PushSrcOverrides allows you to override virtual methods from the parent class gstbase.PushSrc + gstbase.PushSrcOverrides[Instance] + + // FillGLMemory allows you to override the implementation of the virtual method fill_gl_memory. + // The function takes the following parameters: + // + // - mem *GLMemory + // + // The function returns the following values: + // + // - goret bool + FillGLMemory func(Instance, *GLMemory) bool + // GLStart allows you to override the implementation of the virtual method gl_start. + // The function returns the following values: + // + // - goret bool + GLStart func(Instance) bool + // GLStop allows you to override the implementation of the virtual method gl_stop. + GLStop func(Instance) +} + +// UnsafeApplyGLBaseSrcOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyGLBaseSrcOverrides[Instance GLBaseSrc](gclass unsafe.Pointer, overrides GLBaseSrcOverrides[Instance]) { + gstbase.UnsafeApplyPushSrcOverrides(gclass, overrides.PushSrcOverrides) + + pclass := (*C.GstGLBaseSrcClass)(gclass) + + if overrides.FillGLMemory != nil { + pclass.fill_gl_memory = (*[0]byte)(C._gotk4_gstgl1_GLBaseSrc_fill_gl_memory) + } + + if overrides.GLStart != nil { + pclass.gl_start = (*[0]byte)(C._gotk4_gstgl1_GLBaseSrc_gl_start) + } + + if overrides.GLStop != nil { + pclass.gl_stop = (*[0]byte)(C._gotk4_gstgl1_GLBaseSrc_gl_stop) + } +} + // GLBufferAllocatorInstance is the instance type used by all types extending GstGLBufferAllocator. It is used internally by the bindings. Users should use the interface [GLBufferAllocator] instead. type GLBufferAllocatorInstance struct { _ [0]func() // equal guard @@ -3160,6 +3476,20 @@ func UnsafeGLBufferAllocatorToGlibFull(c GLBufferAllocator) unsafe.Pointer { return gobject.UnsafeObjectToGlibFull(c) } +// GLBufferAllocatorOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type GLBufferAllocatorOverrides[Instance GLBufferAllocator] struct { + // GLBaseMemoryAllocatorOverrides allows you to override virtual methods from the parent class GLBaseMemoryAllocator + GLBaseMemoryAllocatorOverrides[Instance] + +} + +// UnsafeApplyGLBufferAllocatorOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyGLBufferAllocatorOverrides[Instance GLBufferAllocator](gclass unsafe.Pointer, overrides GLBufferAllocatorOverrides[Instance]) { + UnsafeApplyGLBaseMemoryAllocatorOverrides(gclass, overrides.GLBaseMemoryAllocatorOverrides) +} + // GLBufferPoolInstance is the instance type used by all types extending GstGLBufferPool. It is used internally by the bindings. Users should use the interface [GLBufferPool] instead. type GLBufferPoolInstance struct { _ [0]func() // equal guard @@ -3183,6 +3513,7 @@ type GLBufferPool interface { upcastToGstGLBufferPool() *GLBufferPoolInstance // GetGLAllocationParams wraps gst_gl_buffer_pool_get_gl_allocation_params + // // The function returns the following values: // // - goret *GLAllocationParams (nullable) @@ -3260,6 +3591,7 @@ func NewGLBufferPool(_context GLContext) gst.BufferPool { } // GetGLAllocationParams wraps gst_gl_buffer_pool_get_gl_allocation_params +// // The function returns the following values: // // - goret *GLAllocationParams (nullable) @@ -3286,6 +3618,20 @@ func (pool *GLBufferPoolInstance) GetGLAllocationParams() *GLAllocationParams { return goret } +// GLBufferPoolOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type GLBufferPoolOverrides[Instance GLBufferPool] struct { + // gst.BufferPoolOverrides allows you to override virtual methods from the parent class gst.BufferPool + gst.BufferPoolOverrides[Instance] + +} + +// UnsafeApplyGLBufferPoolOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyGLBufferPoolOverrides[Instance GLBufferPool](gclass unsafe.Pointer, overrides GLBufferPoolOverrides[Instance]) { + gst.UnsafeApplyBufferPoolOverrides(gclass, overrides.BufferPoolOverrides) +} + // GLColorConvertInstance is the instance type used by all types extending GstGLColorConvert. It is used internally by the bindings. Users should use the interface [GLColorConvert] instead. type GLColorConvertInstance struct { _ [0]func() // equal guard @@ -3651,6 +3997,20 @@ func (convert *GLColorConvertInstance) SetCaps(inCaps *gst.Caps, outCaps *gst.Ca return goret } +// GLColorConvertOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type GLColorConvertOverrides[Instance GLColorConvert] struct { + // gst.ObjectOverrides allows you to override virtual methods from the parent class gst.Object + gst.ObjectOverrides[Instance] + +} + +// UnsafeApplyGLColorConvertOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyGLColorConvertOverrides[Instance GLColorConvert](gclass unsafe.Pointer, overrides GLColorConvertOverrides[Instance]) { + gst.UnsafeApplyObjectOverrides(gclass, overrides.ObjectOverrides) +} + // GLContextInstance is the instance type used by all types extending GstGLContext. It is used internally by the bindings. Users should use the interface [GLContext] instead. type GLContextInstance struct { _ [0]func() // equal guard @@ -3801,6 +4161,7 @@ type GLContext interface { // called for this context. Destroy() // FillInfo wraps gst_gl_context_fill_info + // // The function returns the following values: // // - goret bool @@ -3811,6 +4172,7 @@ type GLContext interface { // allow wrapped contexts to be used as regular #GstGLContext's. FillInfo() (bool, error) // GetConfig wraps gst_gl_context_get_config + // // The function returns the following values: // // - goret *gst.Structure (nullable) @@ -3822,11 +4184,13 @@ type GLContext interface { // return %NULL when not supported. GetConfig() *gst.Structure // GetDisplay wraps gst_gl_context_get_display + // // The function returns the following values: // // - goret GLDisplay GetDisplay() GLDisplay // GetGLApi wraps gst_gl_context_get_gl_api + // // The function returns the following values: // // - goret GLAPI @@ -3837,6 +4201,7 @@ type GLContext interface { // the #GstGLWindow chosen. GetGLApi() GLAPI // GetGLPlatform wraps gst_gl_context_get_gl_platform + // // The function returns the following values: // // - goret GLPlatform @@ -3844,6 +4209,7 @@ type GLContext interface { // Gets the OpenGL platform that used by @context. GetGLPlatform() GLPlatform // GetGLPlatformVersion wraps gst_gl_context_get_gl_platform_version + // // The function returns the following values: // // - major int: return for the major version @@ -3853,6 +4219,7 @@ type GLContext interface { // after a call to gst_gl_context_create(). GetGLPlatformVersion() (int, int) // GetGLVersion wraps gst_gl_context_get_gl_version + // // The function returns the following values: // // - maj int: resulting major version @@ -3863,11 +4230,13 @@ type GLContext interface { // @context. GetGLVersion() (int, int) // GetWindow wraps gst_gl_context_get_window + // // The function returns the following values: // // - goret GLWindow (nullable) GetWindow() GLWindow // IsShared wraps gst_gl_context_is_shared + // // The function returns the following values: // // - goret bool @@ -4024,6 +4393,7 @@ func NewGLContext(display GLDisplay) GLContext { } // GLContextGetCurrent wraps gst_gl_context_get_current +// // The function returns the following values: // // - goret GLContext (nullable) @@ -4356,6 +4726,7 @@ func (_context *GLContextInstance) Destroy() { } // FillInfo wraps gst_gl_context_fill_info +// // The function returns the following values: // // - goret bool @@ -4388,6 +4759,7 @@ func (_context *GLContextInstance) FillInfo() (bool, error) { } // GetConfig wraps gst_gl_context_get_config +// // The function returns the following values: // // - goret *gst.Structure (nullable) @@ -4416,6 +4788,7 @@ func (_context *GLContextInstance) GetConfig() *gst.Structure { } // GetDisplay wraps gst_gl_context_get_display +// // The function returns the following values: // // - goret GLDisplay @@ -4436,6 +4809,7 @@ func (_context *GLContextInstance) GetDisplay() GLDisplay { } // GetGLApi wraps gst_gl_context_get_gl_api +// // The function returns the following values: // // - goret GLAPI @@ -4461,6 +4835,7 @@ func (_context *GLContextInstance) GetGLApi() GLAPI { } // GetGLPlatform wraps gst_gl_context_get_gl_platform +// // The function returns the following values: // // - goret GLPlatform @@ -4483,6 +4858,7 @@ func (_context *GLContextInstance) GetGLPlatform() GLPlatform { } // GetGLPlatformVersion wraps gst_gl_context_get_gl_platform_version +// // The function returns the following values: // // - major int: return for the major version @@ -4510,6 +4886,7 @@ func (_context *GLContextInstance) GetGLPlatformVersion() (int, int) { } // GetGLVersion wraps gst_gl_context_get_gl_version +// // The function returns the following values: // // - maj int: resulting major version @@ -4538,6 +4915,7 @@ func (_context *GLContextInstance) GetGLVersion() (int, int) { } // GetWindow wraps gst_gl_context_get_window +// // The function returns the following values: // // - goret GLWindow (nullable) @@ -4560,6 +4938,7 @@ func (_context *GLContextInstance) GetWindow() GLWindow { } // IsShared wraps gst_gl_context_is_shared +// // The function returns the following values: // // - goret bool @@ -4795,6 +5174,136 @@ func (_context *GLContextInstance) SwapBuffers() { runtime.KeepAlive(_context) } +// GLContextOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type GLContextOverrides[Instance GLContext] struct { + // gst.ObjectOverrides allows you to override virtual methods from the parent class gst.Object + gst.ObjectOverrides[Instance] + + // Activate allows you to override the implementation of the virtual method activate. + // The function takes the following parameters: + // + // - activate bool: %TRUE to activate, %FALSE to deactivate + // + // The function returns the following values: + // + // - goret bool + Activate func(Instance, bool) bool + // CheckFeature allows you to override the implementation of the virtual method check_feature. + // The function takes the following parameters: + // + // - feature string: a platform specific feature + // + // The function returns the following values: + // + // - goret bool + CheckFeature func(Instance, string) bool + // ChooseFormat allows you to override the implementation of the virtual method choose_format. + // The function returns the following values: + // + // - goret bool + // - _goerr error (nullable): an error + ChooseFormat func(Instance) (bool, error) + // CreateContext allows you to override the implementation of the virtual method create_context. + // The function takes the following parameters: + // + // - glApi GLAPI + // - otherContext GLContext + // + // The function returns the following values: + // + // - goret bool + // - _goerr error (nullable): an error + CreateContext func(Instance, GLAPI, GLContext) (bool, error) + // DestroyContext allows you to override the implementation of the virtual method destroy_context. + DestroyContext func(Instance) + // GetConfig allows you to override the implementation of the virtual method get_config. + // The function returns the following values: + // + // - goret *gst.Structure (nullable) + GetConfig func(Instance) *gst.Structure + // GetGLApi allows you to override the implementation of the virtual method get_gl_api. + // The function returns the following values: + // + // - goret GLAPI + GetGLApi func(Instance) GLAPI + // GetGLPlatform allows you to override the implementation of the virtual method get_gl_platform. + // The function returns the following values: + // + // - goret GLPlatform + GetGLPlatform func(Instance) GLPlatform + // GetGLPlatformVersion allows you to override the implementation of the virtual method get_gl_platform_version. + // The function returns the following values: + // + // - major int: return for the major version + // - minor int: return for the minor version + GetGLPlatformVersion func(Instance) (int, int) + // RequestConfig allows you to override the implementation of the virtual method request_config. + // The function takes the following parameters: + // + // - glConfig *gst.Structure (nullable): a configuration structure for + // configuring the OpenGL context + // + // The function returns the following values: + // + // - goret bool + RequestConfig func(Instance, *gst.Structure) bool + // SwapBuffers allows you to override the implementation of the virtual method swap_buffers. + SwapBuffers func(Instance) +} + +// UnsafeApplyGLContextOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyGLContextOverrides[Instance GLContext](gclass unsafe.Pointer, overrides GLContextOverrides[Instance]) { + gst.UnsafeApplyObjectOverrides(gclass, overrides.ObjectOverrides) + + pclass := (*C.GstGLContextClass)(gclass) + + if overrides.Activate != nil { + pclass.activate = (*[0]byte)(C._gotk4_gstgl1_GLContext_activate) + } + + if overrides.CheckFeature != nil { + pclass.check_feature = (*[0]byte)(C._gotk4_gstgl1_GLContext_check_feature) + } + + if overrides.ChooseFormat != nil { + pclass.choose_format = (*[0]byte)(C._gotk4_gstgl1_GLContext_choose_format) + } + + if overrides.CreateContext != nil { + pclass.create_context = (*[0]byte)(C._gotk4_gstgl1_GLContext_create_context) + } + + if overrides.DestroyContext != nil { + pclass.destroy_context = (*[0]byte)(C._gotk4_gstgl1_GLContext_destroy_context) + } + + if overrides.GetConfig != nil { + pclass.get_config = (*[0]byte)(C._gotk4_gstgl1_GLContext_get_config) + } + + if overrides.GetGLApi != nil { + pclass.get_gl_api = (*[0]byte)(C._gotk4_gstgl1_GLContext_get_gl_api) + } + + if overrides.GetGLPlatform != nil { + pclass.get_gl_platform = (*[0]byte)(C._gotk4_gstgl1_GLContext_get_gl_platform) + } + + if overrides.GetGLPlatformVersion != nil { + pclass.get_gl_platform_version = (*[0]byte)(C._gotk4_gstgl1_GLContext_get_gl_platform_version) + } + + if overrides.RequestConfig != nil { + pclass.request_config = (*[0]byte)(C._gotk4_gstgl1_GLContext_request_config) + } + + if overrides.SwapBuffers != nil { + pclass.swap_buffers = (*[0]byte)(C._gotk4_gstgl1_GLContext_swap_buffers) + } +} + // GLDisplayInstance is the instance type used by all types extending GstGLDisplay. It is used internally by the bindings. Users should use the interface [GLDisplay] instead. type GLDisplayInstance struct { _ [0]func() // equal guard @@ -4854,6 +5363,7 @@ type GLDisplay interface { // It requires the display's object lock to be held. CreateContext(GLContext) (GLContext, bool, error) // CreateWindow wraps gst_gl_display_create_window + // // The function returns the following values: // // - goret GLWindow (nullable) @@ -4870,6 +5380,7 @@ type GLDisplay interface { // API supported by a #GstGLContext. FilterGLApi(GLAPI) // GetGLApi wraps gst_gl_display_get_gl_api + // // The function returns the following values: // // - goret GLAPI @@ -4877,11 +5388,13 @@ type GLDisplay interface { // see gst_gl_display_filter_gl_api() for what the returned value represents GetGLApi() GLAPI // GetGLApiUnlocked wraps gst_gl_display_get_gl_api_unlocked + // // The function returns the following values: // // - goret GLAPI GetGLApiUnlocked() GLAPI // GetHandleType wraps gst_gl_display_get_handle_type + // // The function returns the following values: // // - goret GLDisplayType @@ -4951,6 +5464,7 @@ func UnsafeGLDisplayToGlibFull(c GLDisplay) unsafe.Pointer { } // NewGLDisplay wraps gst_gl_display_new +// // The function returns the following values: // // - goret GLDisplay @@ -5073,6 +5587,7 @@ func (display *GLDisplayInstance) CreateContext(otherContext GLContext) (GLConte } // CreateWindow wraps gst_gl_display_create_window +// // The function returns the following values: // // - goret GLWindow (nullable) @@ -5117,6 +5632,7 @@ func (display *GLDisplayInstance) FilterGLApi(glApi GLAPI) { } // GetGLApi wraps gst_gl_display_get_gl_api +// // The function returns the following values: // // - goret GLAPI @@ -5139,6 +5655,7 @@ func (display *GLDisplayInstance) GetGLApi() GLAPI { } // GetGLApiUnlocked wraps gst_gl_display_get_gl_api_unlocked +// // The function returns the following values: // // - goret GLAPI @@ -5159,6 +5676,7 @@ func (display *GLDisplayInstance) GetGLApiUnlocked() GLAPI { } // GetHandleType wraps gst_gl_display_get_handle_type +// // The function returns the following values: // // - goret GLDisplayType @@ -5235,6 +5753,32 @@ func (display *GLDisplayInstance) RemoveWindow(window GLWindow) bool { func (o *GLDisplayInstance) ConnectCreateContext(fn func(GLDisplay, GLContext) GLContextInstance) gobject.SignalHandle { return o.Connect("create-context", fn) } + +// GLDisplayOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type GLDisplayOverrides[Instance GLDisplay] struct { + // gst.ObjectOverrides allows you to override virtual methods from the parent class gst.Object + gst.ObjectOverrides[Instance] + + // CreateWindow allows you to override the implementation of the virtual method create_window. + // The function returns the following values: + // + // - goret GLWindow (nullable) + CreateWindow func(Instance) GLWindow +} + +// UnsafeApplyGLDisplayOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyGLDisplayOverrides[Instance GLDisplay](gclass unsafe.Pointer, overrides GLDisplayOverrides[Instance]) { + gst.UnsafeApplyObjectOverrides(gclass, overrides.ObjectOverrides) + + pclass := (*C.GstGLDisplayClass)(gclass) + + if overrides.CreateWindow != nil { + pclass.create_window = (*[0]byte)(C._gotk4_gstgl1_GLDisplay_create_window) + } +} + // GLFilterInstance is the instance type used by all types extending GstGLFilter. It is used internally by the bindings. Users should use the interface [GLFilter] instead. type GLFilterInstance struct { _ [0]func() // equal guard @@ -5480,6 +6024,88 @@ func (filter *GLFilterInstance) RenderToTargetWithShader(input *GLMemory, output runtime.KeepAlive(shader) } +// GLFilterOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type GLFilterOverrides[Instance GLFilter] struct { + // GLBaseFilterOverrides allows you to override virtual methods from the parent class GLBaseFilter + GLBaseFilterOverrides[Instance] + + // Filter allows you to override the implementation of the virtual method filter. + // The function takes the following parameters: + // + // - inbuf *gst.Buffer + // - outbuf *gst.Buffer + // + // The function returns the following values: + // + // - goret bool + Filter func(Instance, *gst.Buffer, *gst.Buffer) bool + // FilterTexture allows you to override the implementation of the virtual method filter_texture. + // The function takes the following parameters: + // + // - input *GLMemory: an input buffer + // - output *GLMemory: an output buffer + // + // The function returns the following values: + // + // - goret bool + FilterTexture func(Instance, *GLMemory, *GLMemory) bool + // InitFbo allows you to override the implementation of the virtual method init_fbo. + // The function returns the following values: + // + // - goret bool + InitFbo func(Instance) bool + // SetCaps allows you to override the implementation of the virtual method set_caps. + // The function takes the following parameters: + // + // - incaps *gst.Caps + // - outcaps *gst.Caps + // + // The function returns the following values: + // + // - goret bool + SetCaps func(Instance, *gst.Caps, *gst.Caps) bool + // TransformInternalCaps allows you to override the implementation of the virtual method transform_internal_caps. + // The function takes the following parameters: + // + // - direction gst.PadDirection + // - caps *gst.Caps + // - filterCaps *gst.Caps + // + // The function returns the following values: + // + // - goret *gst.Caps + TransformInternalCaps func(Instance, gst.PadDirection, *gst.Caps, *gst.Caps) *gst.Caps +} + +// UnsafeApplyGLFilterOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyGLFilterOverrides[Instance GLFilter](gclass unsafe.Pointer, overrides GLFilterOverrides[Instance]) { + UnsafeApplyGLBaseFilterOverrides(gclass, overrides.GLBaseFilterOverrides) + + pclass := (*C.GstGLFilterClass)(gclass) + + if overrides.Filter != nil { + pclass.filter = (*[0]byte)(C._gotk4_gstgl1_GLFilter_filter) + } + + if overrides.FilterTexture != nil { + pclass.filter_texture = (*[0]byte)(C._gotk4_gstgl1_GLFilter_filter_texture) + } + + if overrides.InitFbo != nil { + pclass.init_fbo = (*[0]byte)(C._gotk4_gstgl1_GLFilter_init_fbo) + } + + if overrides.SetCaps != nil { + pclass.set_caps = (*[0]byte)(C._gotk4_gstgl1_GLFilter_set_caps) + } + + if overrides.TransformInternalCaps != nil { + pclass.transform_internal_caps = (*[0]byte)(C._gotk4_gstgl1_GLFilter_transform_internal_caps) + } +} + // GLFramebufferInstance is the instance type used by all types extending GstGLFramebuffer. It is used internally by the bindings. Users should use the interface [GLFramebuffer] instead. type GLFramebufferInstance struct { _ [0]func() // equal guard @@ -5524,6 +6150,7 @@ type GLFramebuffer interface { // with. Bind() // GetEffectiveDimensions wraps gst_gl_framebuffer_get_effective_dimensions + // // The function returns the following values: // // - width uint: output width @@ -5533,6 +6160,7 @@ type GLFramebuffer interface { // @fb. GetEffectiveDimensions() (uint, uint) // GetID wraps gst_gl_framebuffer_get_id + // // The function returns the following values: // // - goret uint @@ -5683,6 +6311,7 @@ func (fb *GLFramebufferInstance) Bind() { } // GetEffectiveDimensions wraps gst_gl_framebuffer_get_effective_dimensions +// // The function returns the following values: // // - width uint: output width @@ -5710,6 +6339,7 @@ func (fb *GLFramebufferInstance) GetEffectiveDimensions() (uint, uint) { } // GetID wraps gst_gl_framebuffer_get_id +// // The function returns the following values: // // - goret uint @@ -5729,6 +6359,20 @@ func (fb *GLFramebufferInstance) GetID() uint { return goret } +// GLFramebufferOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type GLFramebufferOverrides[Instance GLFramebuffer] struct { + // gst.ObjectOverrides allows you to override virtual methods from the parent class gst.Object + gst.ObjectOverrides[Instance] + +} + +// UnsafeApplyGLFramebufferOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyGLFramebufferOverrides[Instance GLFramebuffer](gclass unsafe.Pointer, overrides GLFramebufferOverrides[Instance]) { + gst.UnsafeApplyObjectOverrides(gclass, overrides.ObjectOverrides) +} + // GLMemoryAllocatorInstance is the instance type used by all types extending GstGLMemoryAllocator. It is used internally by the bindings. Users should use the interface [GLMemoryAllocator] instead. type GLMemoryAllocatorInstance struct { _ [0]func() // equal guard @@ -5812,6 +6456,20 @@ func GLMemoryAllocatorGetDefault(_context GLContext) GLMemoryAllocator { return goret } +// GLMemoryAllocatorOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type GLMemoryAllocatorOverrides[Instance GLMemoryAllocator] struct { + // GLBaseMemoryAllocatorOverrides allows you to override virtual methods from the parent class GLBaseMemoryAllocator + GLBaseMemoryAllocatorOverrides[Instance] + +} + +// UnsafeApplyGLMemoryAllocatorOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyGLMemoryAllocatorOverrides[Instance GLMemoryAllocator](gclass unsafe.Pointer, overrides GLMemoryAllocatorOverrides[Instance]) { + UnsafeApplyGLBaseMemoryAllocatorOverrides(gclass, overrides.GLBaseMemoryAllocatorOverrides) +} + // GLMemoryPBOAllocatorInstance is the instance type used by all types extending GstGLMemoryPBOAllocator. It is used internally by the bindings. Users should use the interface [GLMemoryPBOAllocator] instead. type GLMemoryPBOAllocatorInstance struct { _ [0]func() // equal guard @@ -5872,6 +6530,20 @@ func UnsafeGLMemoryPBOAllocatorToGlibFull(c GLMemoryPBOAllocator) unsafe.Pointer return gobject.UnsafeObjectToGlibFull(c) } +// GLMemoryPBOAllocatorOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type GLMemoryPBOAllocatorOverrides[Instance GLMemoryPBOAllocator] struct { + // GLMemoryAllocatorOverrides allows you to override virtual methods from the parent class GLMemoryAllocator + GLMemoryAllocatorOverrides[Instance] + +} + +// UnsafeApplyGLMemoryPBOAllocatorOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyGLMemoryPBOAllocatorOverrides[Instance GLMemoryPBOAllocator](gclass unsafe.Pointer, overrides GLMemoryPBOAllocatorOverrides[Instance]) { + UnsafeApplyGLMemoryAllocatorOverrides(gclass, overrides.GLMemoryAllocatorOverrides) +} + // GLMixerInstance is the instance type used by all types extending GstGLMixer. It is used internally by the bindings. Users should use the interface [GLMixer] instead. type GLMixerInstance struct { _ [0]func() // equal guard @@ -5888,6 +6560,7 @@ type GLMixer interface { upcastToGstGLMixer() *GLMixerInstance // GetFramebuffer wraps gst_gl_mixer_get_framebuffer + // // The function returns the following values: // // - goret GLFramebuffer @@ -5955,6 +6628,7 @@ func UnsafeGLMixerToGlibFull(c GLMixer) unsafe.Pointer { } // GetFramebuffer wraps gst_gl_mixer_get_framebuffer +// // The function returns the following values: // // - goret GLFramebuffer @@ -6008,6 +6682,48 @@ func (mix *GLMixerInstance) ProcessTextures(outbuf *gst.Buffer) bool { return goret } +// GLMixerOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type GLMixerOverrides[Instance GLMixer] struct { + // GLBaseMixerOverrides allows you to override virtual methods from the parent class GLBaseMixer + GLBaseMixerOverrides[Instance] + + // ProcessBuffers allows you to override the implementation of the virtual method process_buffers. + // The function takes the following parameters: + // + // - outbuf *gst.Buffer + // + // The function returns the following values: + // + // - goret bool + ProcessBuffers func(Instance, *gst.Buffer) bool + // ProcessTextures allows you to override the implementation of the virtual method process_textures. + // The function takes the following parameters: + // + // - outTex *GLMemory + // + // The function returns the following values: + // + // - goret bool + ProcessTextures func(Instance, *GLMemory) bool +} + +// UnsafeApplyGLMixerOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyGLMixerOverrides[Instance GLMixer](gclass unsafe.Pointer, overrides GLMixerOverrides[Instance]) { + UnsafeApplyGLBaseMixerOverrides(gclass, overrides.GLBaseMixerOverrides) + + pclass := (*C.GstGLMixerClass)(gclass) + + if overrides.ProcessBuffers != nil { + pclass.process_buffers = (*[0]byte)(C._gotk4_gstgl1_GLMixer_process_buffers) + } + + if overrides.ProcessTextures != nil { + pclass.process_textures = (*[0]byte)(C._gotk4_gstgl1_GLMixer_process_textures) + } +} + // GLMixerPadInstance is the instance type used by all types extending GstGLMixerPad. It is used internally by the bindings. Users should use the interface [GLMixerPad] instead. type GLMixerPadInstance struct { _ [0]func() // equal guard @@ -6068,6 +6784,20 @@ func UnsafeGLMixerPadToGlibFull(c GLMixerPad) unsafe.Pointer { return gobject.UnsafeObjectToGlibFull(c) } +// GLMixerPadOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type GLMixerPadOverrides[Instance GLMixerPad] struct { + // GLBaseMixerPadOverrides allows you to override virtual methods from the parent class GLBaseMixerPad + GLBaseMixerPadOverrides[Instance] + +} + +// UnsafeApplyGLMixerPadOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyGLMixerPadOverrides[Instance GLMixerPad](gclass unsafe.Pointer, overrides GLMixerPadOverrides[Instance]) { + UnsafeApplyGLBaseMixerPadOverrides(gclass, overrides.GLBaseMixerPadOverrides) +} + // GLOverlayCompositorInstance is the instance type used by all types extending GstGLOverlayCompositor. It is used internally by the bindings. Users should use the interface [GLOverlayCompositor] instead. type GLOverlayCompositorInstance struct { _ [0]func() // equal guard @@ -6220,6 +6950,20 @@ func (compositor *GLOverlayCompositorInstance) UploadOverlays(buf *gst.Buffer) { runtime.KeepAlive(buf) } +// GLOverlayCompositorOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type GLOverlayCompositorOverrides[Instance GLOverlayCompositor] struct { + // gst.ObjectOverrides allows you to override virtual methods from the parent class gst.Object + gst.ObjectOverrides[Instance] + +} + +// UnsafeApplyGLOverlayCompositorOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyGLOverlayCompositorOverrides[Instance GLOverlayCompositor](gclass unsafe.Pointer, overrides GLOverlayCompositorOverrides[Instance]) { + gst.UnsafeApplyObjectOverrides(gclass, overrides.ObjectOverrides) +} + // GLRenderbufferAllocatorInstance is the instance type used by all types extending GstGLRenderbufferAllocator. It is used internally by the bindings. Users should use the interface [GLRenderbufferAllocator] instead. type GLRenderbufferAllocatorInstance struct { _ [0]func() // equal guard @@ -6278,6 +7022,20 @@ func UnsafeGLRenderbufferAllocatorToGlibFull(c GLRenderbufferAllocator) unsafe.P return gobject.UnsafeObjectToGlibFull(c) } +// GLRenderbufferAllocatorOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type GLRenderbufferAllocatorOverrides[Instance GLRenderbufferAllocator] struct { + // GLBaseMemoryAllocatorOverrides allows you to override virtual methods from the parent class GLBaseMemoryAllocator + GLBaseMemoryAllocatorOverrides[Instance] + +} + +// UnsafeApplyGLRenderbufferAllocatorOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyGLRenderbufferAllocatorOverrides[Instance GLRenderbufferAllocator](gclass unsafe.Pointer, overrides GLRenderbufferAllocatorOverrides[Instance]) { + UnsafeApplyGLBaseMemoryAllocatorOverrides(gclass, overrides.GLBaseMemoryAllocatorOverrides) +} + // GLSLStageInstance is the instance type used by all types extending GstGLSLStage. It is used internally by the bindings. Users should use the interface [GLSLStage] instead. type GLSLStageInstance struct { _ [0]func() // equal guard @@ -6294,27 +7052,32 @@ type GLSLStage interface { upcastToGstGLSLStage() *GLSLStageInstance // Compile wraps gst_glsl_stage_compile + // // The function returns the following values: // // - goret bool // - _goerr error (nullable): an error Compile() (bool, error) // GetHandle wraps gst_glsl_stage_get_handle + // // The function returns the following values: // // - goret uint GetHandle() uint // GetProfile wraps gst_glsl_stage_get_profile + // // The function returns the following values: // // - goret GLSLProfile GetProfile() GLSLProfile // GetShaderType wraps gst_glsl_stage_get_shader_type + // // The function returns the following values: // // - goret uint GetShaderType() uint // GetVersion wraps gst_glsl_stage_get_version + // // The function returns the following values: // // - goret GLSLVersion @@ -6541,6 +7304,7 @@ func NewGLSLStageWithStrings(_context GLContext, typ uint, version GLSLVersion, } // Compile wraps gst_glsl_stage_compile +// // The function returns the following values: // // - goret bool @@ -6569,6 +7333,7 @@ func (stage *GLSLStageInstance) Compile() (bool, error) { } // GetHandle wraps gst_glsl_stage_get_handle +// // The function returns the following values: // // - goret uint @@ -6589,6 +7354,7 @@ func (stage *GLSLStageInstance) GetHandle() uint { } // GetProfile wraps gst_glsl_stage_get_profile +// // The function returns the following values: // // - goret GLSLProfile @@ -6609,6 +7375,7 @@ func (stage *GLSLStageInstance) GetProfile() GLSLProfile { } // GetShaderType wraps gst_glsl_stage_get_shader_type +// // The function returns the following values: // // - goret uint @@ -6629,6 +7396,7 @@ func (stage *GLSLStageInstance) GetShaderType() uint { } // GetVersion wraps gst_glsl_stage_get_version +// // The function returns the following values: // // - goret GLSLVersion @@ -6692,6 +7460,20 @@ func (stage *GLSLStageInstance) SetStrings(version GLSLVersion, profile GLSLProf return goret } +// GLSLStageOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type GLSLStageOverrides[Instance GLSLStage] struct { + // gst.ObjectOverrides allows you to override virtual methods from the parent class gst.Object + gst.ObjectOverrides[Instance] + +} + +// UnsafeApplyGLSLStageOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyGLSLStageOverrides[Instance GLSLStage](gclass unsafe.Pointer, overrides GLSLStageOverrides[Instance]) { + gst.UnsafeApplyObjectOverrides(gclass, overrides.ObjectOverrides) +} + // GLShaderInstance is the instance type used by all types extending GstGLShader. It is used internally by the bindings. Users should use the interface [GLShader] instead. type GLShaderInstance struct { _ [0]func() // equal guard @@ -6803,11 +7585,13 @@ type GLShader interface { // - goret int GetAttributeLocation(string) int // GetProgramHandle wraps gst_gl_shader_get_program_handle + // // The function returns the following values: // // - goret int GetProgramHandle() int // IsLinked wraps gst_gl_shader_is_linked + // // The function returns the following values: // // - goret bool @@ -6815,6 +7599,7 @@ type GLShader interface { // Note: must be called in the GL thread IsLinked() bool // Link wraps gst_gl_shader_link + // // The function returns the following values: // // - goret bool @@ -7540,6 +8325,7 @@ func (shader *GLShaderInstance) GetAttributeLocation(name string) int { } // GetProgramHandle wraps gst_gl_shader_get_program_handle +// // The function returns the following values: // // - goret int @@ -7560,6 +8346,7 @@ func (shader *GLShaderInstance) GetProgramHandle() int { } // IsLinked wraps gst_gl_shader_is_linked +// // The function returns the following values: // // - goret bool @@ -7584,6 +8371,7 @@ func (shader *GLShaderInstance) IsLinked() bool { } // Link wraps gst_gl_shader_link +// // The function returns the following values: // // - goret bool @@ -8445,6 +9233,20 @@ func (shader *GLShaderInstance) Use() { runtime.KeepAlive(shader) } +// GLShaderOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type GLShaderOverrides[Instance GLShader] struct { + // gst.ObjectOverrides allows you to override virtual methods from the parent class gst.Object + gst.ObjectOverrides[Instance] + +} + +// UnsafeApplyGLShaderOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyGLShaderOverrides[Instance GLShader](gclass unsafe.Pointer, overrides GLShaderOverrides[Instance]) { + gst.UnsafeApplyObjectOverrides(gclass, overrides.ObjectOverrides) +} + // GLUploadInstance is the instance type used by all types extending GstGLUpload. It is used internally by the bindings. Users should use the interface [GLUpload] instead. type GLUploadInstance struct { _ [0]func() // equal guard @@ -8477,6 +9279,7 @@ type GLUpload interface { // Fixate the @othercaps based on the information of the @caps. FixateCaps(gst.PadDirection, *gst.Caps, *gst.Caps) *gst.Caps // GetCaps wraps gst_gl_upload_get_caps + // // The function returns the following values: // // - inCaps *gst.Caps: the input #GstCaps @@ -8603,6 +9406,7 @@ func NewGLUpload(_context GLContext) GLUpload { } // GLUploadGetInputTemplateCaps wraps gst_gl_upload_get_input_template_caps +// // The function returns the following values: // // - goret *gst.Caps @@ -8657,6 +9461,7 @@ func (upload *GLUploadInstance) FixateCaps(direction gst.PadDirection, caps *gst } // GetCaps wraps gst_gl_upload_get_caps +// // The function returns the following values: // // - inCaps *gst.Caps: the input #GstCaps @@ -8833,6 +9638,20 @@ func (upload *GLUploadInstance) TransformCaps(_context GLContext, direction gst. return goret } +// GLUploadOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type GLUploadOverrides[Instance GLUpload] struct { + // gst.ObjectOverrides allows you to override virtual methods from the parent class gst.Object + gst.ObjectOverrides[Instance] + +} + +// UnsafeApplyGLUploadOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyGLUploadOverrides[Instance GLUpload](gclass unsafe.Pointer, overrides GLUploadOverrides[Instance]) { + gst.UnsafeApplyObjectOverrides(gclass, overrides.ObjectOverrides) +} + // GLViewConvertInstance is the instance type used by all types extending GstGLViewConvert. It is used internally by the bindings. Users should use the interface [GLViewConvert] instead. type GLViewConvertInstance struct { _ [0]func() // equal guard @@ -8863,6 +9682,7 @@ type GLViewConvert interface { // Provides an implementation of #GstBaseTransformClass.fixate_caps() FixateCaps(gst.PadDirection, *gst.Caps, *gst.Caps) *gst.Caps // GetOutput wraps gst_gl_view_convert_get_output + // // The function returns the following values: // // - outbufPtr *gst.Buffer: a #GstBuffer @@ -8977,6 +9797,7 @@ func UnsafeGLViewConvertToGlibFull(c GLViewConvert) unsafe.Pointer { } // NewGLViewConvert wraps gst_gl_view_convert_new +// // The function returns the following values: // // - goret GLViewConvert @@ -9031,6 +9852,7 @@ func (viewconvert *GLViewConvertInstance) FixateCaps(direction gst.PadDirection, } // GetOutput wraps gst_gl_view_convert_get_output +// // The function returns the following values: // // - outbufPtr *gst.Buffer: a #GstBuffer @@ -9231,6 +10053,20 @@ func (viewconvert *GLViewConvertInstance) TransformCaps(direction gst.PadDirecti return goret } +// GLViewConvertOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type GLViewConvertOverrides[Instance GLViewConvert] struct { + // gst.ObjectOverrides allows you to override virtual methods from the parent class gst.Object + gst.ObjectOverrides[Instance] + +} + +// UnsafeApplyGLViewConvertOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyGLViewConvertOverrides[Instance GLViewConvert](gclass unsafe.Pointer, overrides GLViewConvertOverrides[Instance]) { + gst.UnsafeApplyObjectOverrides(gclass, overrides.ObjectOverrides) +} + // GLWindowInstance is the instance type used by all types extending GstGLWindow. It is used internally by the bindings. Users should use the interface [GLWindow] instead. type GLWindowInstance struct { _ [0]func() // equal guard @@ -9248,6 +10084,7 @@ type GLWindow interface { upcastToGstGLWindow() *GLWindowInstance // ControlsViewport wraps gst_gl_window_controls_viewport + // // The function returns the following values: // // - goret bool @@ -9259,11 +10096,13 @@ type GLWindow interface { // Redraw the window contents. Implementations should invoke the draw callback. Draw() // GetContext wraps gst_gl_window_get_context + // // The function returns the following values: // // - goret GLContext GetContext() GLContext // GetSurfaceDimensions wraps gst_gl_window_get_surface_dimensions + // // The function returns the following values: // // - width uint: resulting surface width @@ -9282,6 +10121,7 @@ type GLWindow interface { // from the @window. HandleEvents(bool) // HasOutputSurface wraps gst_gl_window_has_output_surface + // // The function returns the following values: // // - goret bool @@ -9452,6 +10292,7 @@ func NewGLWindow(display GLDisplay) GLWindow { } // ControlsViewport wraps gst_gl_window_controls_viewport +// // The function returns the following values: // // - goret bool @@ -9488,6 +10329,7 @@ func (window *GLWindowInstance) Draw() { } // GetContext wraps gst_gl_window_get_context +// // The function returns the following values: // // - goret GLContext @@ -9508,6 +10350,7 @@ func (window *GLWindowInstance) GetContext() GLContext { } // GetSurfaceDimensions wraps gst_gl_window_get_surface_dimensions +// // The function returns the following values: // // - width uint: resulting surface width @@ -9557,6 +10400,7 @@ func (window *GLWindowInstance) HandleEvents(handleEvents bool) { } // HasOutputSurface wraps gst_gl_window_has_output_surface +// // The function returns the following values: // // - goret bool @@ -9811,18 +10655,21 @@ func (window *GLWindowInstance) Show() { func (o *GLWindowInstance) ConnectKeyEvent(fn func(GLWindow, string, string)) gobject.SignalHandle { return o.Connect("key-event", fn) } + // ConnectMouseEvent connects the provided callback to the "mouse-event" signal // // Will be emitted when a mouse event is received by the GstGLwindow. func (o *GLWindowInstance) ConnectMouseEvent(fn func(GLWindow, string, int, float64, float64)) gobject.SignalHandle { return o.Connect("mouse-event", fn) } + // ConnectScrollEvent connects the provided callback to the "scroll-event" signal // // Will be emitted when a mouse scroll event is received by the GstGLwindow. func (o *GLWindowInstance) ConnectScrollEvent(fn func(GLWindow, float64, float64, float64, float64)) gobject.SignalHandle { return o.Connect("scroll-event", fn) } + // ConnectWindowHandleChanged connects the provided callback to the "window-handle-changed" signal // // Will be emitted when the window handle has been set into the native @@ -9832,6 +10679,122 @@ func (o *GLWindowInstance) ConnectScrollEvent(fn func(GLWindow, float64, float64 func (o *GLWindowInstance) ConnectWindowHandleChanged(fn func(GLWindow)) gobject.SignalHandle { return o.Connect("window-handle-changed", fn) } + +// GLWindowOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type GLWindowOverrides[Instance GLWindow] struct { + // gst.ObjectOverrides allows you to override virtual methods from the parent class gst.Object + gst.ObjectOverrides[Instance] + + // Close allows you to override the implementation of the virtual method close. + Close func(Instance) + // ControlsViewport allows you to override the implementation of the virtual method controls_viewport. + // The function returns the following values: + // + // - goret bool + ControlsViewport func(Instance) bool + // Draw allows you to override the implementation of the virtual method draw. + Draw func(Instance) + // HandleEvents allows you to override the implementation of the virtual method handle_events. + // The function takes the following parameters: + // + // - handleEvents bool: a #gboolean indicating if events should be handled or not. + HandleEvents func(Instance, bool) + // HasOutputSurface allows you to override the implementation of the virtual method has_output_surface. + // The function returns the following values: + // + // - goret bool + HasOutputSurface func(Instance) bool + // Open allows you to override the implementation of the virtual method open. + // The function returns the following values: + // + // - goret bool + // - _goerr error (nullable): an error + Open func(Instance) (bool, error) + // QueueResize allows you to override the implementation of the virtual method queue_resize. + QueueResize func(Instance) + // Quit allows you to override the implementation of the virtual method quit. + Quit func(Instance) + // Run allows you to override the implementation of the virtual method run. + Run func(Instance) + // SetPreferredSize allows you to override the implementation of the virtual method set_preferred_size. + // The function takes the following parameters: + // + // - width int: new preferred width + // - height int: new preferred height + SetPreferredSize func(Instance, int, int) + // SetRenderRectangle allows you to override the implementation of the virtual method set_render_rectangle. + // The function takes the following parameters: + // + // - x int: x position + // - y int: y position + // - width int: width + // - height int: height + // + // The function returns the following values: + // + // - goret bool + SetRenderRectangle func(Instance, int, int, int, int) bool + // Show allows you to override the implementation of the virtual method show. + Show func(Instance) +} + +// UnsafeApplyGLWindowOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyGLWindowOverrides[Instance GLWindow](gclass unsafe.Pointer, overrides GLWindowOverrides[Instance]) { + gst.UnsafeApplyObjectOverrides(gclass, overrides.ObjectOverrides) + + pclass := (*C.GstGLWindowClass)(gclass) + + if overrides.Close != nil { + pclass.close = (*[0]byte)(C._gotk4_gstgl1_GLWindow_close) + } + + if overrides.ControlsViewport != nil { + pclass.controls_viewport = (*[0]byte)(C._gotk4_gstgl1_GLWindow_controls_viewport) + } + + if overrides.Draw != nil { + pclass.draw = (*[0]byte)(C._gotk4_gstgl1_GLWindow_draw) + } + + if overrides.HandleEvents != nil { + pclass.handle_events = (*[0]byte)(C._gotk4_gstgl1_GLWindow_handle_events) + } + + if overrides.HasOutputSurface != nil { + pclass.has_output_surface = (*[0]byte)(C._gotk4_gstgl1_GLWindow_has_output_surface) + } + + if overrides.Open != nil { + pclass.open = (*[0]byte)(C._gotk4_gstgl1_GLWindow_open) + } + + if overrides.QueueResize != nil { + pclass.queue_resize = (*[0]byte)(C._gotk4_gstgl1_GLWindow_queue_resize) + } + + if overrides.Quit != nil { + pclass.quit = (*[0]byte)(C._gotk4_gstgl1_GLWindow_quit) + } + + if overrides.Run != nil { + pclass.run = (*[0]byte)(C._gotk4_gstgl1_GLWindow_run) + } + + if overrides.SetPreferredSize != nil { + pclass.set_preferred_size = (*[0]byte)(C._gotk4_gstgl1_GLWindow_set_preferred_size) + } + + if overrides.SetRenderRectangle != nil { + pclass.set_render_rectangle = (*[0]byte)(C._gotk4_gstgl1_GLWindow_set_render_rectangle) + } + + if overrides.Show != nil { + pclass.show = (*[0]byte)(C._gotk4_gstgl1_GLWindow_show) + } +} + // GLAllocationParams wraps GstGLAllocationParams type GLAllocationParams struct { *glAllocationParams @@ -9859,7 +10822,7 @@ func UnsafeGLAllocationParamsFromGlibBorrow(p unsafe.Pointer) *GLAllocationParam return &GLAllocationParams{&glAllocationParams{(*C.GstGLAllocationParams)(p)}} } -// UnsafeGLAllocationParamsFromGlibNone is used to convert raw C.GstGLAllocationParams pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeGLAllocationParamsFromGlibNone is used to convert raw C.GstGLAllocationParams pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeGLAllocationParamsFromGlibNone(p unsafe.Pointer) *GLAllocationParams { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeGLAllocationParamsFromGlibBorrow(p) @@ -9872,7 +10835,7 @@ func UnsafeGLAllocationParamsFromGlibNone(p unsafe.Pointer) *GLAllocationParams return wrapped } -// UnsafeGLAllocationParamsFromGlibFull is used to convert raw C.GstGLAllocationParams pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeGLAllocationParamsFromGlibFull is used to convert raw C.GstGLAllocationParams pointers to go while taking ownership. This is used by the bindings internally. func UnsafeGLAllocationParamsFromGlibFull(p unsafe.Pointer) *GLAllocationParams { wrapped := UnsafeGLAllocationParamsFromGlibBorrow(p) runtime.SetFinalizer( @@ -9904,7 +10867,9 @@ func UnsafeGLAllocationParamsToGlibFull(g *GLAllocationParams) unsafe.Pointer { g.native = nil // GLAllocationParams is invalid from here on return _p } + // Copy wraps gst_gl_allocation_params_copy +// // The function returns the following values: // // - goret *GLAllocationParams @@ -9975,7 +10940,7 @@ func UnsafeGLAsyncDebugFromGlibBorrow(p unsafe.Pointer) *GLAsyncDebug { return &GLAsyncDebug{&glAsyncDebug{(*C.GstGLAsyncDebug)(p)}} } -// UnsafeGLAsyncDebugFromGlibNone is used to convert raw C.GstGLAsyncDebug pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeGLAsyncDebugFromGlibNone is used to convert raw C.GstGLAsyncDebug pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeGLAsyncDebugFromGlibNone(p unsafe.Pointer) *GLAsyncDebug { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeGLAsyncDebugFromGlibBorrow(p) @@ -9988,7 +10953,7 @@ func UnsafeGLAsyncDebugFromGlibNone(p unsafe.Pointer) *GLAsyncDebug { return wrapped } -// UnsafeGLAsyncDebugFromGlibFull is used to convert raw C.GstGLAsyncDebug pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeGLAsyncDebugFromGlibFull is used to convert raw C.GstGLAsyncDebug pointers to go while taking ownership. This is used by the bindings internally. func UnsafeGLAsyncDebugFromGlibFull(p unsafe.Pointer) *GLAsyncDebug { wrapped := UnsafeGLAsyncDebugFromGlibBorrow(p) runtime.SetFinalizer( @@ -10020,6 +10985,7 @@ func UnsafeGLAsyncDebugToGlibFull(g *GLAsyncDebug) unsafe.Pointer { g.native = nil // GLAsyncDebug is invalid from here on return _p } + // Freeze wraps gst_gl_async_debug_freeze // // freeze the debug output. While frozen, any call to @@ -10088,6 +11054,8 @@ func (ad *GLAsyncDebug) Unset() { // GLBaseFilterClass wraps GstGLBaseFilterClass // // The base class for GStreamer GL Filter. +// +// GLBaseFilterClass is the type struct for [GLBaseFilter] type GLBaseFilterClass struct { *glBaseFilterClass } @@ -10102,31 +11070,6 @@ func UnsafeGLBaseFilterClassFromGlibBorrow(p unsafe.Pointer) *GLBaseFilterClass return &GLBaseFilterClass{&glBaseFilterClass{(*C.GstGLBaseFilterClass)(p)}} } -// UnsafeGLBaseFilterClassFromGlibNone is used to convert raw C.GstGLBaseFilterClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeGLBaseFilterClassFromGlibNone(p unsafe.Pointer) *GLBaseFilterClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeGLBaseFilterClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.glBaseFilterClass, - func (intern *glBaseFilterClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeGLBaseFilterClassFromGlibFull is used to convert raw C.GstGLBaseFilterClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeGLBaseFilterClassFromGlibFull(p unsafe.Pointer) *GLBaseFilterClass { - wrapped := UnsafeGLBaseFilterClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.glBaseFilterClass, - func (intern *glBaseFilterClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeGLBaseFilterClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [GLBaseFilterClass] is expected to work anymore. @@ -10139,14 +11082,15 @@ func UnsafeGLBaseFilterClassToGlibNone(g *GLBaseFilterClass) unsafe.Pointer { return unsafe.Pointer(g.native) } -// UnsafeGLBaseFilterClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeGLBaseFilterClassToGlibFull(g *GLBaseFilterClass) unsafe.Pointer { - runtime.SetFinalizer(g.glBaseFilterClass, nil) - _p := unsafe.Pointer(g.native) - g.native = nil // GLBaseFilterClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (g *GLBaseFilterClass) ParentClass() *gstbase.BaseTransformClass { + parent := gstbase.UnsafeBaseTransformClassFromGlibBorrow(UnsafeGLBaseFilterClassToGlibNone(g)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *GLBaseFilterClass) {}, g) + return parent } + // GLBaseMemory wraps GstGLBaseMemory // // GstGLBaseMemory is a #GstMemory subclass providing the basis of support @@ -10179,7 +11123,7 @@ func UnsafeGLBaseMemoryFromGlibBorrow(p unsafe.Pointer) *GLBaseMemory { return &GLBaseMemory{&glBaseMemory{(*C.GstGLBaseMemory)(p)}} } -// UnsafeGLBaseMemoryFromGlibNone is used to convert raw C.GstGLBaseMemory pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeGLBaseMemoryFromGlibNone is used to convert raw C.GstGLBaseMemory pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeGLBaseMemoryFromGlibNone(p unsafe.Pointer) *GLBaseMemory { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeGLBaseMemoryFromGlibBorrow(p) @@ -10192,7 +11136,7 @@ func UnsafeGLBaseMemoryFromGlibNone(p unsafe.Pointer) *GLBaseMemory { return wrapped } -// UnsafeGLBaseMemoryFromGlibFull is used to convert raw C.GstGLBaseMemory pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeGLBaseMemoryFromGlibFull is used to convert raw C.GstGLBaseMemory pointers to go while taking ownership. This is used by the bindings internally. func UnsafeGLBaseMemoryFromGlibFull(p unsafe.Pointer) *GLBaseMemory { wrapped := UnsafeGLBaseMemoryFromGlibBorrow(p) runtime.SetFinalizer( @@ -10224,6 +11168,7 @@ func UnsafeGLBaseMemoryToGlibFull(g *GLBaseMemory) unsafe.Pointer { g.native = nil // GLBaseMemory is invalid from here on return _p } + // GLBaseMemoryAlloc wraps gst_gl_base_memory_alloc // // The function takes the following parameters: @@ -10265,6 +11210,7 @@ func GLBaseMemoryInitOnce() { } // AllocData wraps gst_gl_base_memory_alloc_data +// // The function returns the following values: // // - goret bool @@ -10329,6 +11275,8 @@ func (src *GLBaseMemory) Memcpy(dest *GLBaseMemory, offset int, size int) bool { } // GLBaseMemoryAllocatorClass wraps GstGLBaseMemoryAllocatorClass +// +// GLBaseMemoryAllocatorClass is the type struct for [GLBaseMemoryAllocator] type GLBaseMemoryAllocatorClass struct { *glBaseMemoryAllocatorClass } @@ -10343,31 +11291,6 @@ func UnsafeGLBaseMemoryAllocatorClassFromGlibBorrow(p unsafe.Pointer) *GLBaseMem return &GLBaseMemoryAllocatorClass{&glBaseMemoryAllocatorClass{(*C.GstGLBaseMemoryAllocatorClass)(p)}} } -// UnsafeGLBaseMemoryAllocatorClassFromGlibNone is used to convert raw C.GstGLBaseMemoryAllocatorClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeGLBaseMemoryAllocatorClassFromGlibNone(p unsafe.Pointer) *GLBaseMemoryAllocatorClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeGLBaseMemoryAllocatorClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.glBaseMemoryAllocatorClass, - func (intern *glBaseMemoryAllocatorClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeGLBaseMemoryAllocatorClassFromGlibFull is used to convert raw C.GstGLBaseMemoryAllocatorClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeGLBaseMemoryAllocatorClassFromGlibFull(p unsafe.Pointer) *GLBaseMemoryAllocatorClass { - wrapped := UnsafeGLBaseMemoryAllocatorClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.glBaseMemoryAllocatorClass, - func (intern *glBaseMemoryAllocatorClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeGLBaseMemoryAllocatorClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [GLBaseMemoryAllocatorClass] is expected to work anymore. @@ -10380,15 +11303,18 @@ func UnsafeGLBaseMemoryAllocatorClassToGlibNone(g *GLBaseMemoryAllocatorClass) u return unsafe.Pointer(g.native) } -// UnsafeGLBaseMemoryAllocatorClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeGLBaseMemoryAllocatorClassToGlibFull(g *GLBaseMemoryAllocatorClass) unsafe.Pointer { - runtime.SetFinalizer(g.glBaseMemoryAllocatorClass, nil) - _p := unsafe.Pointer(g.native) - g.native = nil // GLBaseMemoryAllocatorClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (g *GLBaseMemoryAllocatorClass) ParentClass() *gst.AllocatorClass { + parent := gst.UnsafeAllocatorClassFromGlibBorrow(UnsafeGLBaseMemoryAllocatorClassToGlibNone(g)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *GLBaseMemoryAllocatorClass) {}, g) + return parent } + // GLBaseMixerClass wraps GstGLBaseMixerClass +// +// GLBaseMixerClass is the type struct for [GLBaseMixer] type GLBaseMixerClass struct { *glBaseMixerClass } @@ -10403,31 +11329,6 @@ func UnsafeGLBaseMixerClassFromGlibBorrow(p unsafe.Pointer) *GLBaseMixerClass { return &GLBaseMixerClass{&glBaseMixerClass{(*C.GstGLBaseMixerClass)(p)}} } -// UnsafeGLBaseMixerClassFromGlibNone is used to convert raw C.GstGLBaseMixerClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeGLBaseMixerClassFromGlibNone(p unsafe.Pointer) *GLBaseMixerClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeGLBaseMixerClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.glBaseMixerClass, - func (intern *glBaseMixerClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeGLBaseMixerClassFromGlibFull is used to convert raw C.GstGLBaseMixerClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeGLBaseMixerClassFromGlibFull(p unsafe.Pointer) *GLBaseMixerClass { - wrapped := UnsafeGLBaseMixerClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.glBaseMixerClass, - func (intern *glBaseMixerClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeGLBaseMixerClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [GLBaseMixerClass] is expected to work anymore. @@ -10440,15 +11341,18 @@ func UnsafeGLBaseMixerClassToGlibNone(g *GLBaseMixerClass) unsafe.Pointer { return unsafe.Pointer(g.native) } -// UnsafeGLBaseMixerClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeGLBaseMixerClassToGlibFull(g *GLBaseMixerClass) unsafe.Pointer { - runtime.SetFinalizer(g.glBaseMixerClass, nil) - _p := unsafe.Pointer(g.native) - g.native = nil // GLBaseMixerClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (g *GLBaseMixerClass) ParentClass() *gstvideo.VideoAggregatorClass { + parent := gstvideo.UnsafeVideoAggregatorClassFromGlibBorrow(UnsafeGLBaseMixerClassToGlibNone(g)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *GLBaseMixerClass) {}, g) + return parent } + // GLBaseMixerPadClass wraps GstGLBaseMixerPadClass +// +// GLBaseMixerPadClass is the type struct for [GLBaseMixerPad] type GLBaseMixerPadClass struct { *glBaseMixerPadClass } @@ -10463,31 +11367,6 @@ func UnsafeGLBaseMixerPadClassFromGlibBorrow(p unsafe.Pointer) *GLBaseMixerPadCl return &GLBaseMixerPadClass{&glBaseMixerPadClass{(*C.GstGLBaseMixerPadClass)(p)}} } -// UnsafeGLBaseMixerPadClassFromGlibNone is used to convert raw C.GstGLBaseMixerPadClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeGLBaseMixerPadClassFromGlibNone(p unsafe.Pointer) *GLBaseMixerPadClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeGLBaseMixerPadClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.glBaseMixerPadClass, - func (intern *glBaseMixerPadClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeGLBaseMixerPadClassFromGlibFull is used to convert raw C.GstGLBaseMixerPadClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeGLBaseMixerPadClassFromGlibFull(p unsafe.Pointer) *GLBaseMixerPadClass { - wrapped := UnsafeGLBaseMixerPadClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.glBaseMixerPadClass, - func (intern *glBaseMixerPadClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeGLBaseMixerPadClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [GLBaseMixerPadClass] is expected to work anymore. @@ -10500,17 +11379,20 @@ func UnsafeGLBaseMixerPadClassToGlibNone(g *GLBaseMixerPadClass) unsafe.Pointer return unsafe.Pointer(g.native) } -// UnsafeGLBaseMixerPadClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeGLBaseMixerPadClassToGlibFull(g *GLBaseMixerPadClass) unsafe.Pointer { - runtime.SetFinalizer(g.glBaseMixerPadClass, nil) - _p := unsafe.Pointer(g.native) - g.native = nil // GLBaseMixerPadClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (g *GLBaseMixerPadClass) ParentClass() *gstvideo.VideoAggregatorPadClass { + parent := gstvideo.UnsafeVideoAggregatorPadClassFromGlibBorrow(UnsafeGLBaseMixerPadClassToGlibNone(g)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *GLBaseMixerPadClass) {}, g) + return parent } + // GLBaseSrcClass wraps GstGLBaseSrcClass // // The base class for GStreamer GL Video sources. +// +// GLBaseSrcClass is the type struct for [GLBaseSrc] type GLBaseSrcClass struct { *glBaseSrcClass } @@ -10525,31 +11407,6 @@ func UnsafeGLBaseSrcClassFromGlibBorrow(p unsafe.Pointer) *GLBaseSrcClass { return &GLBaseSrcClass{&glBaseSrcClass{(*C.GstGLBaseSrcClass)(p)}} } -// UnsafeGLBaseSrcClassFromGlibNone is used to convert raw C.GstGLBaseSrcClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeGLBaseSrcClassFromGlibNone(p unsafe.Pointer) *GLBaseSrcClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeGLBaseSrcClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.glBaseSrcClass, - func (intern *glBaseSrcClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeGLBaseSrcClassFromGlibFull is used to convert raw C.GstGLBaseSrcClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeGLBaseSrcClassFromGlibFull(p unsafe.Pointer) *GLBaseSrcClass { - wrapped := UnsafeGLBaseSrcClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.glBaseSrcClass, - func (intern *glBaseSrcClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeGLBaseSrcClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [GLBaseSrcClass] is expected to work anymore. @@ -10562,14 +11419,15 @@ func UnsafeGLBaseSrcClassToGlibNone(g *GLBaseSrcClass) unsafe.Pointer { return unsafe.Pointer(g.native) } -// UnsafeGLBaseSrcClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeGLBaseSrcClassToGlibFull(g *GLBaseSrcClass) unsafe.Pointer { - runtime.SetFinalizer(g.glBaseSrcClass, nil) - _p := unsafe.Pointer(g.native) - g.native = nil // GLBaseSrcClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (g *GLBaseSrcClass) ParentClass() *gstbase.PushSrcClass { + parent := gstbase.UnsafePushSrcClassFromGlibBorrow(UnsafeGLBaseSrcClassToGlibNone(g)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *GLBaseSrcClass) {}, g) + return parent } + // GLBuffer wraps GstGLBuffer // // GstGLBuffer is a #GstMemory subclass providing support for the mapping of @@ -10602,7 +11460,7 @@ func UnsafeGLBufferFromGlibBorrow(p unsafe.Pointer) *GLBuffer { return &GLBuffer{&glBuffer{(*C.GstGLBuffer)(p)}} } -// UnsafeGLBufferFromGlibNone is used to convert raw C.GstGLBuffer pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeGLBufferFromGlibNone is used to convert raw C.GstGLBuffer pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeGLBufferFromGlibNone(p unsafe.Pointer) *GLBuffer { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeGLBufferFromGlibBorrow(p) @@ -10615,7 +11473,7 @@ func UnsafeGLBufferFromGlibNone(p unsafe.Pointer) *GLBuffer { return wrapped } -// UnsafeGLBufferFromGlibFull is used to convert raw C.GstGLBuffer pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeGLBufferFromGlibFull is used to convert raw C.GstGLBuffer pointers to go while taking ownership. This is used by the bindings internally. func UnsafeGLBufferFromGlibFull(p unsafe.Pointer) *GLBuffer { wrapped := UnsafeGLBufferFromGlibBorrow(p) runtime.SetFinalizer( @@ -10647,6 +11505,7 @@ func UnsafeGLBufferToGlibFull(g *GLBuffer) unsafe.Pointer { g.native = nil // GLBuffer is invalid from here on return _p } + // GLBufferInitOnce wraps gst_gl_buffer_init_once // // Initializes the GL Buffer allocator. It is safe to call this function @@ -10683,7 +11542,7 @@ func UnsafeGLBufferAllocationParamsFromGlibBorrow(p unsafe.Pointer) *GLBufferAll return &GLBufferAllocationParams{&glBufferAllocationParams{(*C.GstGLBufferAllocationParams)(p)}} } -// UnsafeGLBufferAllocationParamsFromGlibNone is used to convert raw C.GstGLBufferAllocationParams pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeGLBufferAllocationParamsFromGlibNone is used to convert raw C.GstGLBufferAllocationParams pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeGLBufferAllocationParamsFromGlibNone(p unsafe.Pointer) *GLBufferAllocationParams { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeGLBufferAllocationParamsFromGlibBorrow(p) @@ -10696,7 +11555,7 @@ func UnsafeGLBufferAllocationParamsFromGlibNone(p unsafe.Pointer) *GLBufferAlloc return wrapped } -// UnsafeGLBufferAllocationParamsFromGlibFull is used to convert raw C.GstGLBufferAllocationParams pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeGLBufferAllocationParamsFromGlibFull is used to convert raw C.GstGLBufferAllocationParams pointers to go while taking ownership. This is used by the bindings internally. func UnsafeGLBufferAllocationParamsFromGlibFull(p unsafe.Pointer) *GLBufferAllocationParams { wrapped := UnsafeGLBufferAllocationParamsFromGlibBorrow(p) runtime.SetFinalizer( @@ -10728,6 +11587,7 @@ func UnsafeGLBufferAllocationParamsToGlibFull(g *GLBufferAllocationParams) unsaf g.native = nil // GLBufferAllocationParams is invalid from here on return _p } + // NewGLBufferAllocationParams wraps gst_gl_buffer_allocation_params_new // // The function takes the following parameters: @@ -10774,6 +11634,8 @@ func NewGLBufferAllocationParams(_context GLContext, allocSize uint, allocParams // GLBufferAllocatorClass wraps GstGLBufferAllocatorClass // // The #GstGLBufferAllocatorClass only contains private data +// +// GLBufferAllocatorClass is the type struct for [GLBufferAllocator] type GLBufferAllocatorClass struct { *glBufferAllocatorClass } @@ -10788,31 +11650,6 @@ func UnsafeGLBufferAllocatorClassFromGlibBorrow(p unsafe.Pointer) *GLBufferAlloc return &GLBufferAllocatorClass{&glBufferAllocatorClass{(*C.GstGLBufferAllocatorClass)(p)}} } -// UnsafeGLBufferAllocatorClassFromGlibNone is used to convert raw C.GstGLBufferAllocatorClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeGLBufferAllocatorClassFromGlibNone(p unsafe.Pointer) *GLBufferAllocatorClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeGLBufferAllocatorClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.glBufferAllocatorClass, - func (intern *glBufferAllocatorClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeGLBufferAllocatorClassFromGlibFull is used to convert raw C.GstGLBufferAllocatorClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeGLBufferAllocatorClassFromGlibFull(p unsafe.Pointer) *GLBufferAllocatorClass { - wrapped := UnsafeGLBufferAllocatorClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.glBufferAllocatorClass, - func (intern *glBufferAllocatorClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeGLBufferAllocatorClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [GLBufferAllocatorClass] is expected to work anymore. @@ -10825,17 +11662,20 @@ func UnsafeGLBufferAllocatorClassToGlibNone(g *GLBufferAllocatorClass) unsafe.Po return unsafe.Pointer(g.native) } -// UnsafeGLBufferAllocatorClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeGLBufferAllocatorClassToGlibFull(g *GLBufferAllocatorClass) unsafe.Pointer { - runtime.SetFinalizer(g.glBufferAllocatorClass, nil) - _p := unsafe.Pointer(g.native) - g.native = nil // GLBufferAllocatorClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (g *GLBufferAllocatorClass) ParentClass() *GLBaseMemoryAllocatorClass { + parent := UnsafeGLBaseMemoryAllocatorClassFromGlibBorrow(UnsafeGLBufferAllocatorClassToGlibNone(g)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *GLBufferAllocatorClass) {}, g) + return parent } + // GLBufferPoolClass wraps GstGLBufferPoolClass // // The #GstGLBufferPoolClass structure contains only private data +// +// GLBufferPoolClass is the type struct for [GLBufferPool] type GLBufferPoolClass struct { *glBufferPoolClass } @@ -10850,31 +11690,6 @@ func UnsafeGLBufferPoolClassFromGlibBorrow(p unsafe.Pointer) *GLBufferPoolClass return &GLBufferPoolClass{&glBufferPoolClass{(*C.GstGLBufferPoolClass)(p)}} } -// UnsafeGLBufferPoolClassFromGlibNone is used to convert raw C.GstGLBufferPoolClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeGLBufferPoolClassFromGlibNone(p unsafe.Pointer) *GLBufferPoolClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeGLBufferPoolClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.glBufferPoolClass, - func (intern *glBufferPoolClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeGLBufferPoolClassFromGlibFull is used to convert raw C.GstGLBufferPoolClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeGLBufferPoolClassFromGlibFull(p unsafe.Pointer) *GLBufferPoolClass { - wrapped := UnsafeGLBufferPoolClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.glBufferPoolClass, - func (intern *glBufferPoolClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeGLBufferPoolClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [GLBufferPoolClass] is expected to work anymore. @@ -10887,17 +11702,20 @@ func UnsafeGLBufferPoolClassToGlibNone(g *GLBufferPoolClass) unsafe.Pointer { return unsafe.Pointer(g.native) } -// UnsafeGLBufferPoolClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeGLBufferPoolClassToGlibFull(g *GLBufferPoolClass) unsafe.Pointer { - runtime.SetFinalizer(g.glBufferPoolClass, nil) - _p := unsafe.Pointer(g.native) - g.native = nil // GLBufferPoolClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (g *GLBufferPoolClass) ParentClass() *gst.BufferPoolClass { + parent := gst.UnsafeBufferPoolClassFromGlibBorrow(UnsafeGLBufferPoolClassToGlibNone(g)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *GLBufferPoolClass) {}, g) + return parent } + // GLColorConvertClass wraps GstGLColorConvertClass // // The #GstGLColorConvertClass struct only contains private data +// +// GLColorConvertClass is the type struct for [GLColorConvert] type GLColorConvertClass struct { *glColorConvertClass } @@ -10912,31 +11730,6 @@ func UnsafeGLColorConvertClassFromGlibBorrow(p unsafe.Pointer) *GLColorConvertCl return &GLColorConvertClass{&glColorConvertClass{(*C.GstGLColorConvertClass)(p)}} } -// UnsafeGLColorConvertClassFromGlibNone is used to convert raw C.GstGLColorConvertClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeGLColorConvertClassFromGlibNone(p unsafe.Pointer) *GLColorConvertClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeGLColorConvertClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.glColorConvertClass, - func (intern *glColorConvertClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeGLColorConvertClassFromGlibFull is used to convert raw C.GstGLColorConvertClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeGLColorConvertClassFromGlibFull(p unsafe.Pointer) *GLColorConvertClass { - wrapped := UnsafeGLColorConvertClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.glColorConvertClass, - func (intern *glColorConvertClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeGLColorConvertClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [GLColorConvertClass] is expected to work anymore. @@ -10949,15 +11742,18 @@ func UnsafeGLColorConvertClassToGlibNone(g *GLColorConvertClass) unsafe.Pointer return unsafe.Pointer(g.native) } -// UnsafeGLColorConvertClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeGLColorConvertClassToGlibFull(g *GLColorConvertClass) unsafe.Pointer { - runtime.SetFinalizer(g.glColorConvertClass, nil) - _p := unsafe.Pointer(g.native) - g.native = nil // GLColorConvertClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (g *GLColorConvertClass) ParentClass() *gst.ObjectClass { + parent := gst.UnsafeObjectClassFromGlibBorrow(UnsafeGLColorConvertClassToGlibNone(g)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *GLColorConvertClass) {}, g) + return parent } + // GLContextClass wraps GstGLContextClass +// +// GLContextClass is the type struct for [GLContext] type GLContextClass struct { *glContextClass } @@ -10972,31 +11768,6 @@ func UnsafeGLContextClassFromGlibBorrow(p unsafe.Pointer) *GLContextClass { return &GLContextClass{&glContextClass{(*C.GstGLContextClass)(p)}} } -// UnsafeGLContextClassFromGlibNone is used to convert raw C.GstGLContextClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeGLContextClassFromGlibNone(p unsafe.Pointer) *GLContextClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeGLContextClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.glContextClass, - func (intern *glContextClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeGLContextClassFromGlibFull is used to convert raw C.GstGLContextClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeGLContextClassFromGlibFull(p unsafe.Pointer) *GLContextClass { - wrapped := UnsafeGLContextClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.glContextClass, - func (intern *glContextClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeGLContextClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [GLContextClass] is expected to work anymore. @@ -11009,15 +11780,18 @@ func UnsafeGLContextClassToGlibNone(g *GLContextClass) unsafe.Pointer { return unsafe.Pointer(g.native) } -// UnsafeGLContextClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeGLContextClassToGlibFull(g *GLContextClass) unsafe.Pointer { - runtime.SetFinalizer(g.glContextClass, nil) - _p := unsafe.Pointer(g.native) - g.native = nil // GLContextClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (g *GLContextClass) ParentClass() *gst.ObjectClass { + parent := gst.UnsafeObjectClassFromGlibBorrow(UnsafeGLContextClassToGlibNone(g)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *GLContextClass) {}, g) + return parent } + // GLDisplayClass wraps GstGLDisplayClass +// +// GLDisplayClass is the type struct for [GLDisplay] type GLDisplayClass struct { *glDisplayClass } @@ -11032,31 +11806,6 @@ func UnsafeGLDisplayClassFromGlibBorrow(p unsafe.Pointer) *GLDisplayClass { return &GLDisplayClass{&glDisplayClass{(*C.GstGLDisplayClass)(p)}} } -// UnsafeGLDisplayClassFromGlibNone is used to convert raw C.GstGLDisplayClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeGLDisplayClassFromGlibNone(p unsafe.Pointer) *GLDisplayClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeGLDisplayClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.glDisplayClass, - func (intern *glDisplayClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeGLDisplayClassFromGlibFull is used to convert raw C.GstGLDisplayClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeGLDisplayClassFromGlibFull(p unsafe.Pointer) *GLDisplayClass { - wrapped := UnsafeGLDisplayClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.glDisplayClass, - func (intern *glDisplayClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeGLDisplayClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [GLDisplayClass] is expected to work anymore. @@ -11069,15 +11818,18 @@ func UnsafeGLDisplayClassToGlibNone(g *GLDisplayClass) unsafe.Pointer { return unsafe.Pointer(g.native) } -// UnsafeGLDisplayClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeGLDisplayClassToGlibFull(g *GLDisplayClass) unsafe.Pointer { - runtime.SetFinalizer(g.glDisplayClass, nil) - _p := unsafe.Pointer(g.native) - g.native = nil // GLDisplayClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (g *GLDisplayClass) ParentClass() *gst.ObjectClass { + parent := gst.UnsafeObjectClassFromGlibBorrow(UnsafeGLDisplayClassToGlibNone(g)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *GLDisplayClass) {}, g) + return parent } + // GLFilterClass wraps GstGLFilterClass +// +// GLFilterClass is the type struct for [GLFilter] type GLFilterClass struct { *glFilterClass } @@ -11092,31 +11844,6 @@ func UnsafeGLFilterClassFromGlibBorrow(p unsafe.Pointer) *GLFilterClass { return &GLFilterClass{&glFilterClass{(*C.GstGLFilterClass)(p)}} } -// UnsafeGLFilterClassFromGlibNone is used to convert raw C.GstGLFilterClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeGLFilterClassFromGlibNone(p unsafe.Pointer) *GLFilterClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeGLFilterClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.glFilterClass, - func (intern *glFilterClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeGLFilterClassFromGlibFull is used to convert raw C.GstGLFilterClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeGLFilterClassFromGlibFull(p unsafe.Pointer) *GLFilterClass { - wrapped := UnsafeGLFilterClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.glFilterClass, - func (intern *glFilterClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeGLFilterClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [GLFilterClass] is expected to work anymore. @@ -11129,17 +11856,20 @@ func UnsafeGLFilterClassToGlibNone(g *GLFilterClass) unsafe.Pointer { return unsafe.Pointer(g.native) } -// UnsafeGLFilterClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeGLFilterClassToGlibFull(g *GLFilterClass) unsafe.Pointer { - runtime.SetFinalizer(g.glFilterClass, nil) - _p := unsafe.Pointer(g.native) - g.native = nil // GLFilterClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (g *GLFilterClass) ParentClass() *GLBaseFilterClass { + parent := UnsafeGLBaseFilterClassFromGlibBorrow(UnsafeGLFilterClassToGlibNone(g)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *GLFilterClass) {}, g) + return parent } + // GLFramebufferClass wraps GstGLFramebufferClass // // Opaque #GstGLFramebufferClass struct +// +// GLFramebufferClass is the type struct for [GLFramebuffer] type GLFramebufferClass struct { *glFramebufferClass } @@ -11154,31 +11884,6 @@ func UnsafeGLFramebufferClassFromGlibBorrow(p unsafe.Pointer) *GLFramebufferClas return &GLFramebufferClass{&glFramebufferClass{(*C.GstGLFramebufferClass)(p)}} } -// UnsafeGLFramebufferClassFromGlibNone is used to convert raw C.GstGLFramebufferClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeGLFramebufferClassFromGlibNone(p unsafe.Pointer) *GLFramebufferClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeGLFramebufferClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.glFramebufferClass, - func (intern *glFramebufferClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeGLFramebufferClassFromGlibFull is used to convert raw C.GstGLFramebufferClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeGLFramebufferClassFromGlibFull(p unsafe.Pointer) *GLFramebufferClass { - wrapped := UnsafeGLFramebufferClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.glFramebufferClass, - func (intern *glFramebufferClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeGLFramebufferClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [GLFramebufferClass] is expected to work anymore. @@ -11191,14 +11896,15 @@ func UnsafeGLFramebufferClassToGlibNone(g *GLFramebufferClass) unsafe.Pointer { return unsafe.Pointer(g.native) } -// UnsafeGLFramebufferClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeGLFramebufferClassToGlibFull(g *GLFramebufferClass) unsafe.Pointer { - runtime.SetFinalizer(g.glFramebufferClass, nil) - _p := unsafe.Pointer(g.native) - g.native = nil // GLFramebufferClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (g *GLFramebufferClass) ParentClass() *gst.ObjectClass { + parent := gst.UnsafeObjectClassFromGlibBorrow(UnsafeGLFramebufferClassToGlibNone(g)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *GLFramebufferClass) {}, g) + return parent } + // GLFuncs wraps GstGLFuncs // // Structure containing function pointers to OpenGL functions. @@ -11219,7 +11925,7 @@ func UnsafeGLFuncsFromGlibBorrow(p unsafe.Pointer) *GLFuncs { return &GLFuncs{&glFuncs{(*C.GstGLFuncs)(p)}} } -// UnsafeGLFuncsFromGlibNone is used to convert raw C.GstGLFuncs pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeGLFuncsFromGlibNone is used to convert raw C.GstGLFuncs pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeGLFuncsFromGlibNone(p unsafe.Pointer) *GLFuncs { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeGLFuncsFromGlibBorrow(p) @@ -11232,7 +11938,7 @@ func UnsafeGLFuncsFromGlibNone(p unsafe.Pointer) *GLFuncs { return wrapped } -// UnsafeGLFuncsFromGlibFull is used to convert raw C.GstGLFuncs pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeGLFuncsFromGlibFull is used to convert raw C.GstGLFuncs pointers to go while taking ownership. This is used by the bindings internally. func UnsafeGLFuncsFromGlibFull(p unsafe.Pointer) *GLFuncs { wrapped := UnsafeGLFuncsFromGlibBorrow(p) runtime.SetFinalizer( @@ -11264,6 +11970,7 @@ func UnsafeGLFuncsToGlibFull(g *GLFuncs) unsafe.Pointer { g.native = nil // GLFuncs is invalid from here on return _p } + // GLMemory wraps GstGLMemory // // GstGLMemory is a #GstGLBaseMemory subclass providing support for the mapping of @@ -11305,7 +12012,7 @@ func UnsafeGLMemoryFromGlibBorrow(p unsafe.Pointer) *GLMemory { return &GLMemory{&glMemory{(*C.GstGLMemory)(p)}} } -// UnsafeGLMemoryFromGlibNone is used to convert raw C.GstGLMemory pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeGLMemoryFromGlibNone is used to convert raw C.GstGLMemory pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeGLMemoryFromGlibNone(p unsafe.Pointer) *GLMemory { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeGLMemoryFromGlibBorrow(p) @@ -11318,7 +12025,7 @@ func UnsafeGLMemoryFromGlibNone(p unsafe.Pointer) *GLMemory { return wrapped } -// UnsafeGLMemoryFromGlibFull is used to convert raw C.GstGLMemory pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeGLMemoryFromGlibFull is used to convert raw C.GstGLMemory pointers to go while taking ownership. This is used by the bindings internally. func UnsafeGLMemoryFromGlibFull(p unsafe.Pointer) *GLMemory { wrapped := UnsafeGLMemoryFromGlibBorrow(p) runtime.SetFinalizer( @@ -11350,6 +12057,7 @@ func UnsafeGLMemoryToGlibFull(g *GLMemory) unsafe.Pointer { g.native = nil // GLMemory is invalid from here on return _p } + // GLMemoryInitOnce wraps gst_gl_memory_init_once // // Initializes the GL Base Texture allocator. It is safe to call this function @@ -11458,6 +12166,7 @@ func (src *GLMemory) CopyTeximage(texId uint, outTarget GLTextureTarget, outTexF } // GetTextureFormat wraps gst_gl_memory_get_texture_format +// // The function returns the following values: // // - goret GLFormat @@ -11478,6 +12187,7 @@ func (glMem *GLMemory) GetTextureFormat() GLFormat { } // GetTextureHeight wraps gst_gl_memory_get_texture_height +// // The function returns the following values: // // - goret int @@ -11498,6 +12208,7 @@ func (glMem *GLMemory) GetTextureHeight() int { } // GetTextureID wraps gst_gl_memory_get_texture_id +// // The function returns the following values: // // - goret uint @@ -11518,6 +12229,7 @@ func (glMem *GLMemory) GetTextureID() uint { } // GetTextureTarget wraps gst_gl_memory_get_texture_target +// // The function returns the following values: // // - goret GLTextureTarget @@ -11538,6 +12250,7 @@ func (glMem *GLMemory) GetTextureTarget() GLTextureTarget { } // GetTextureWidth wraps gst_gl_memory_get_texture_width +// // The function returns the following values: // // - goret int @@ -11558,6 +12271,8 @@ func (glMem *GLMemory) GetTextureWidth() int { } // GLMemoryAllocatorClass wraps GstGLMemoryAllocatorClass +// +// GLMemoryAllocatorClass is the type struct for [GLMemoryAllocator] type GLMemoryAllocatorClass struct { *glMemoryAllocatorClass } @@ -11572,31 +12287,6 @@ func UnsafeGLMemoryAllocatorClassFromGlibBorrow(p unsafe.Pointer) *GLMemoryAlloc return &GLMemoryAllocatorClass{&glMemoryAllocatorClass{(*C.GstGLMemoryAllocatorClass)(p)}} } -// UnsafeGLMemoryAllocatorClassFromGlibNone is used to convert raw C.GstGLMemoryAllocatorClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeGLMemoryAllocatorClassFromGlibNone(p unsafe.Pointer) *GLMemoryAllocatorClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeGLMemoryAllocatorClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.glMemoryAllocatorClass, - func (intern *glMemoryAllocatorClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeGLMemoryAllocatorClassFromGlibFull is used to convert raw C.GstGLMemoryAllocatorClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeGLMemoryAllocatorClassFromGlibFull(p unsafe.Pointer) *GLMemoryAllocatorClass { - wrapped := UnsafeGLMemoryAllocatorClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.glMemoryAllocatorClass, - func (intern *glMemoryAllocatorClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeGLMemoryAllocatorClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [GLMemoryAllocatorClass] is expected to work anymore. @@ -11609,14 +12299,15 @@ func UnsafeGLMemoryAllocatorClassToGlibNone(g *GLMemoryAllocatorClass) unsafe.Po return unsafe.Pointer(g.native) } -// UnsafeGLMemoryAllocatorClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeGLMemoryAllocatorClassToGlibFull(g *GLMemoryAllocatorClass) unsafe.Pointer { - runtime.SetFinalizer(g.glMemoryAllocatorClass, nil) - _p := unsafe.Pointer(g.native) - g.native = nil // GLMemoryAllocatorClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (g *GLMemoryAllocatorClass) ParentClass() *GLBaseMemoryAllocatorClass { + parent := UnsafeGLBaseMemoryAllocatorClassFromGlibBorrow(UnsafeGLMemoryAllocatorClassToGlibNone(g)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *GLMemoryAllocatorClass) {}, g) + return parent } + // GLMemoryPBO wraps GstGLMemoryPBO // // #GstGLMemoryPBO is created or wrapped through gst_gl_base_memory_alloc() @@ -11649,7 +12340,7 @@ func UnsafeGLMemoryPBOFromGlibBorrow(p unsafe.Pointer) *GLMemoryPBO { return &GLMemoryPBO{&glMemoryPBO{(*C.GstGLMemoryPBO)(p)}} } -// UnsafeGLMemoryPBOFromGlibNone is used to convert raw C.GstGLMemoryPBO pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeGLMemoryPBOFromGlibNone is used to convert raw C.GstGLMemoryPBO pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeGLMemoryPBOFromGlibNone(p unsafe.Pointer) *GLMemoryPBO { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeGLMemoryPBOFromGlibBorrow(p) @@ -11662,7 +12353,7 @@ func UnsafeGLMemoryPBOFromGlibNone(p unsafe.Pointer) *GLMemoryPBO { return wrapped } -// UnsafeGLMemoryPBOFromGlibFull is used to convert raw C.GstGLMemoryPBO pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeGLMemoryPBOFromGlibFull is used to convert raw C.GstGLMemoryPBO pointers to go while taking ownership. This is used by the bindings internally. func UnsafeGLMemoryPBOFromGlibFull(p unsafe.Pointer) *GLMemoryPBO { wrapped := UnsafeGLMemoryPBOFromGlibBorrow(p) runtime.SetFinalizer( @@ -11694,6 +12385,7 @@ func UnsafeGLMemoryPBOToGlibFull(g *GLMemoryPBO) unsafe.Pointer { g.native = nil // GLMemoryPBO is invalid from here on return _p } + // GLMemoryPBOInitOnce wraps gst_gl_memory_pbo_init_once func GLMemoryPBOInitOnce() { @@ -11797,6 +12489,8 @@ func (glMem *GLMemoryPBO) UploadTransfer() { // GLMemoryPBOAllocatorClass wraps GstGLMemoryPBOAllocatorClass // // Only contains private data +// +// GLMemoryPBOAllocatorClass is the type struct for [GLMemoryPBOAllocator] type GLMemoryPBOAllocatorClass struct { *glMemoryPBOAllocatorClass } @@ -11811,31 +12505,6 @@ func UnsafeGLMemoryPBOAllocatorClassFromGlibBorrow(p unsafe.Pointer) *GLMemoryPB return &GLMemoryPBOAllocatorClass{&glMemoryPBOAllocatorClass{(*C.GstGLMemoryPBOAllocatorClass)(p)}} } -// UnsafeGLMemoryPBOAllocatorClassFromGlibNone is used to convert raw C.GstGLMemoryPBOAllocatorClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeGLMemoryPBOAllocatorClassFromGlibNone(p unsafe.Pointer) *GLMemoryPBOAllocatorClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeGLMemoryPBOAllocatorClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.glMemoryPBOAllocatorClass, - func (intern *glMemoryPBOAllocatorClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeGLMemoryPBOAllocatorClassFromGlibFull is used to convert raw C.GstGLMemoryPBOAllocatorClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeGLMemoryPBOAllocatorClassFromGlibFull(p unsafe.Pointer) *GLMemoryPBOAllocatorClass { - wrapped := UnsafeGLMemoryPBOAllocatorClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.glMemoryPBOAllocatorClass, - func (intern *glMemoryPBOAllocatorClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeGLMemoryPBOAllocatorClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [GLMemoryPBOAllocatorClass] is expected to work anymore. @@ -11848,15 +12517,18 @@ func UnsafeGLMemoryPBOAllocatorClassToGlibNone(g *GLMemoryPBOAllocatorClass) uns return unsafe.Pointer(g.native) } -// UnsafeGLMemoryPBOAllocatorClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeGLMemoryPBOAllocatorClassToGlibFull(g *GLMemoryPBOAllocatorClass) unsafe.Pointer { - runtime.SetFinalizer(g.glMemoryPBOAllocatorClass, nil) - _p := unsafe.Pointer(g.native) - g.native = nil // GLMemoryPBOAllocatorClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (g *GLMemoryPBOAllocatorClass) ParentClass() *GLMemoryAllocatorClass { + parent := UnsafeGLMemoryAllocatorClassFromGlibBorrow(UnsafeGLMemoryPBOAllocatorClassToGlibNone(g)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *GLMemoryPBOAllocatorClass) {}, g) + return parent } + // GLMixerClass wraps GstGLMixerClass +// +// GLMixerClass is the type struct for [GLMixer] type GLMixerClass struct { *glMixerClass } @@ -11871,31 +12543,6 @@ func UnsafeGLMixerClassFromGlibBorrow(p unsafe.Pointer) *GLMixerClass { return &GLMixerClass{&glMixerClass{(*C.GstGLMixerClass)(p)}} } -// UnsafeGLMixerClassFromGlibNone is used to convert raw C.GstGLMixerClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeGLMixerClassFromGlibNone(p unsafe.Pointer) *GLMixerClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeGLMixerClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.glMixerClass, - func (intern *glMixerClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeGLMixerClassFromGlibFull is used to convert raw C.GstGLMixerClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeGLMixerClassFromGlibFull(p unsafe.Pointer) *GLMixerClass { - wrapped := UnsafeGLMixerClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.glMixerClass, - func (intern *glMixerClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeGLMixerClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [GLMixerClass] is expected to work anymore. @@ -11908,14 +12555,15 @@ func UnsafeGLMixerClassToGlibNone(g *GLMixerClass) unsafe.Pointer { return unsafe.Pointer(g.native) } -// UnsafeGLMixerClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeGLMixerClassToGlibFull(g *GLMixerClass) unsafe.Pointer { - runtime.SetFinalizer(g.glMixerClass, nil) - _p := unsafe.Pointer(g.native) - g.native = nil // GLMixerClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (g *GLMixerClass) ParentClass() *GLBaseMixerClass { + parent := UnsafeGLBaseMixerClassFromGlibBorrow(UnsafeGLMixerClassToGlibNone(g)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *GLMixerClass) {}, g) + return parent } + // AddRGBAPadTemplates wraps gst_gl_mixer_class_add_rgba_pad_templates // // Adds the default RGBA pad templates to this class. If you have any special @@ -11932,6 +12580,8 @@ func (klass *GLMixerClass) AddRGBAPadTemplates() { } // GLMixerPadClass wraps GstGLMixerPadClass +// +// GLMixerPadClass is the type struct for [GLMixerPad] type GLMixerPadClass struct { *glMixerPadClass } @@ -11946,31 +12596,6 @@ func UnsafeGLMixerPadClassFromGlibBorrow(p unsafe.Pointer) *GLMixerPadClass { return &GLMixerPadClass{&glMixerPadClass{(*C.GstGLMixerPadClass)(p)}} } -// UnsafeGLMixerPadClassFromGlibNone is used to convert raw C.GstGLMixerPadClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeGLMixerPadClassFromGlibNone(p unsafe.Pointer) *GLMixerPadClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeGLMixerPadClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.glMixerPadClass, - func (intern *glMixerPadClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeGLMixerPadClassFromGlibFull is used to convert raw C.GstGLMixerPadClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeGLMixerPadClassFromGlibFull(p unsafe.Pointer) *GLMixerPadClass { - wrapped := UnsafeGLMixerPadClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.glMixerPadClass, - func (intern *glMixerPadClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeGLMixerPadClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [GLMixerPadClass] is expected to work anymore. @@ -11983,15 +12608,18 @@ func UnsafeGLMixerPadClassToGlibNone(g *GLMixerPadClass) unsafe.Pointer { return unsafe.Pointer(g.native) } -// UnsafeGLMixerPadClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeGLMixerPadClassToGlibFull(g *GLMixerPadClass) unsafe.Pointer { - runtime.SetFinalizer(g.glMixerPadClass, nil) - _p := unsafe.Pointer(g.native) - g.native = nil // GLMixerPadClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (g *GLMixerPadClass) ParentClass() *GLBaseMixerPadClass { + parent := UnsafeGLBaseMixerPadClassFromGlibBorrow(UnsafeGLMixerPadClassToGlibNone(g)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *GLMixerPadClass) {}, g) + return parent } + // GLOverlayCompositorClass wraps GstGLOverlayCompositorClass +// +// GLOverlayCompositorClass is the type struct for [GLOverlayCompositor] type GLOverlayCompositorClass struct { *glOverlayCompositorClass } @@ -12006,31 +12634,6 @@ func UnsafeGLOverlayCompositorClassFromGlibBorrow(p unsafe.Pointer) *GLOverlayCo return &GLOverlayCompositorClass{&glOverlayCompositorClass{(*C.GstGLOverlayCompositorClass)(p)}} } -// UnsafeGLOverlayCompositorClassFromGlibNone is used to convert raw C.GstGLOverlayCompositorClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeGLOverlayCompositorClassFromGlibNone(p unsafe.Pointer) *GLOverlayCompositorClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeGLOverlayCompositorClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.glOverlayCompositorClass, - func (intern *glOverlayCompositorClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeGLOverlayCompositorClassFromGlibFull is used to convert raw C.GstGLOverlayCompositorClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeGLOverlayCompositorClassFromGlibFull(p unsafe.Pointer) *GLOverlayCompositorClass { - wrapped := UnsafeGLOverlayCompositorClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.glOverlayCompositorClass, - func (intern *glOverlayCompositorClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeGLOverlayCompositorClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [GLOverlayCompositorClass] is expected to work anymore. @@ -12043,14 +12646,15 @@ func UnsafeGLOverlayCompositorClassToGlibNone(g *GLOverlayCompositorClass) unsaf return unsafe.Pointer(g.native) } -// UnsafeGLOverlayCompositorClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeGLOverlayCompositorClassToGlibFull(g *GLOverlayCompositorClass) unsafe.Pointer { - runtime.SetFinalizer(g.glOverlayCompositorClass, nil) - _p := unsafe.Pointer(g.native) - g.native = nil // GLOverlayCompositorClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (g *GLOverlayCompositorClass) ParentClass() *gst.ObjectClass { + parent := gst.UnsafeObjectClassFromGlibBorrow(UnsafeGLOverlayCompositorClassToGlibNone(g)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *GLOverlayCompositorClass) {}, g) + return parent } + // GLQuery wraps GstGLQuery // // A #GstGLQuery represents and holds an OpenGL query object. Various types of @@ -12069,7 +12673,7 @@ func UnsafeGLQueryFromGlibBorrow(p unsafe.Pointer) *GLQuery { return &GLQuery{&glQuery{(*C.GstGLQuery)(p)}} } -// UnsafeGLQueryFromGlibNone is used to convert raw C.GstGLQuery pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeGLQueryFromGlibNone is used to convert raw C.GstGLQuery pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeGLQueryFromGlibNone(p unsafe.Pointer) *GLQuery { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeGLQueryFromGlibBorrow(p) @@ -12082,7 +12686,7 @@ func UnsafeGLQueryFromGlibNone(p unsafe.Pointer) *GLQuery { return wrapped } -// UnsafeGLQueryFromGlibFull is used to convert raw C.GstGLQuery pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeGLQueryFromGlibFull is used to convert raw C.GstGLQuery pointers to go while taking ownership. This is used by the bindings internally. func UnsafeGLQueryFromGlibFull(p unsafe.Pointer) *GLQuery { wrapped := UnsafeGLQueryFromGlibBorrow(p) runtime.SetFinalizer( @@ -12114,6 +12718,7 @@ func UnsafeGLQueryToGlibFull(g *GLQuery) unsafe.Pointer { g.native = nil // GLQuery is invalid from here on return _p } + // Counter wraps gst_gl_query_counter // // Record the result of a counter @@ -12160,6 +12765,7 @@ func (query *GLQuery) Init(_context GLContext, queryType GLQueryType) { } // Result wraps gst_gl_query_result +// // The function returns the following values: // // - goret uint64 @@ -12236,7 +12842,7 @@ func UnsafeGLRenderbufferFromGlibBorrow(p unsafe.Pointer) *GLRenderbuffer { return &GLRenderbuffer{&glRenderbuffer{(*C.GstGLRenderbuffer)(p)}} } -// UnsafeGLRenderbufferFromGlibNone is used to convert raw C.GstGLRenderbuffer pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeGLRenderbufferFromGlibNone is used to convert raw C.GstGLRenderbuffer pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeGLRenderbufferFromGlibNone(p unsafe.Pointer) *GLRenderbuffer { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeGLRenderbufferFromGlibBorrow(p) @@ -12249,7 +12855,7 @@ func UnsafeGLRenderbufferFromGlibNone(p unsafe.Pointer) *GLRenderbuffer { return wrapped } -// UnsafeGLRenderbufferFromGlibFull is used to convert raw C.GstGLRenderbuffer pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeGLRenderbufferFromGlibFull is used to convert raw C.GstGLRenderbuffer pointers to go while taking ownership. This is used by the bindings internally. func UnsafeGLRenderbufferFromGlibFull(p unsafe.Pointer) *GLRenderbuffer { wrapped := UnsafeGLRenderbufferFromGlibBorrow(p) runtime.SetFinalizer( @@ -12281,6 +12887,7 @@ func UnsafeGLRenderbufferToGlibFull(g *GLRenderbuffer) unsafe.Pointer { g.native = nil // GLRenderbuffer is invalid from here on return _p } + // GLRenderbufferInitOnce wraps gst_gl_renderbuffer_init_once // // Initializes the GL Base Texture allocator. It is safe to call this function @@ -12291,6 +12898,7 @@ func GLRenderbufferInitOnce() { } // GetFormat wraps gst_gl_renderbuffer_get_format +// // The function returns the following values: // // - goret GLFormat @@ -12311,6 +12919,7 @@ func (glMem *GLRenderbuffer) GetFormat() GLFormat { } // GetHeight wraps gst_gl_renderbuffer_get_height +// // The function returns the following values: // // - goret int @@ -12331,6 +12940,7 @@ func (glMem *GLRenderbuffer) GetHeight() int { } // GetID wraps gst_gl_renderbuffer_get_id +// // The function returns the following values: // // - goret uint @@ -12351,6 +12961,7 @@ func (glMem *GLRenderbuffer) GetID() uint { } // GetWidth wraps gst_gl_renderbuffer_get_width +// // The function returns the following values: // // - goret int @@ -12399,7 +13010,7 @@ func UnsafeGLRenderbufferAllocationParamsFromGlibBorrow(p unsafe.Pointer) *GLRen return &GLRenderbufferAllocationParams{&glRenderbufferAllocationParams{(*C.GstGLRenderbufferAllocationParams)(p)}} } -// UnsafeGLRenderbufferAllocationParamsFromGlibNone is used to convert raw C.GstGLRenderbufferAllocationParams pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeGLRenderbufferAllocationParamsFromGlibNone is used to convert raw C.GstGLRenderbufferAllocationParams pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeGLRenderbufferAllocationParamsFromGlibNone(p unsafe.Pointer) *GLRenderbufferAllocationParams { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeGLRenderbufferAllocationParamsFromGlibBorrow(p) @@ -12412,7 +13023,7 @@ func UnsafeGLRenderbufferAllocationParamsFromGlibNone(p unsafe.Pointer) *GLRende return wrapped } -// UnsafeGLRenderbufferAllocationParamsFromGlibFull is used to convert raw C.GstGLRenderbufferAllocationParams pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeGLRenderbufferAllocationParamsFromGlibFull is used to convert raw C.GstGLRenderbufferAllocationParams pointers to go while taking ownership. This is used by the bindings internally. func UnsafeGLRenderbufferAllocationParamsFromGlibFull(p unsafe.Pointer) *GLRenderbufferAllocationParams { wrapped := UnsafeGLRenderbufferAllocationParamsFromGlibBorrow(p) runtime.SetFinalizer( @@ -12444,6 +13055,7 @@ func UnsafeGLRenderbufferAllocationParamsToGlibFull(g *GLRenderbufferAllocationP g.native = nil // GLRenderbufferAllocationParams is invalid from here on return _p } + // NewGLRenderbufferAllocationParams wraps gst_gl_renderbuffer_allocation_params_new // // The function takes the following parameters: @@ -12490,6 +13102,8 @@ func NewGLRenderbufferAllocationParams(_context GLContext, allocParams *gst.Allo // GLRenderbufferAllocatorClass wraps GstGLRenderbufferAllocatorClass // // The #GstGLRenderbufferAllocatorClass only contains private data +// +// GLRenderbufferAllocatorClass is the type struct for [GLRenderbufferAllocator] type GLRenderbufferAllocatorClass struct { *glRenderbufferAllocatorClass } @@ -12504,31 +13118,6 @@ func UnsafeGLRenderbufferAllocatorClassFromGlibBorrow(p unsafe.Pointer) *GLRende return &GLRenderbufferAllocatorClass{&glRenderbufferAllocatorClass{(*C.GstGLRenderbufferAllocatorClass)(p)}} } -// UnsafeGLRenderbufferAllocatorClassFromGlibNone is used to convert raw C.GstGLRenderbufferAllocatorClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeGLRenderbufferAllocatorClassFromGlibNone(p unsafe.Pointer) *GLRenderbufferAllocatorClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeGLRenderbufferAllocatorClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.glRenderbufferAllocatorClass, - func (intern *glRenderbufferAllocatorClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeGLRenderbufferAllocatorClassFromGlibFull is used to convert raw C.GstGLRenderbufferAllocatorClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeGLRenderbufferAllocatorClassFromGlibFull(p unsafe.Pointer) *GLRenderbufferAllocatorClass { - wrapped := UnsafeGLRenderbufferAllocatorClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.glRenderbufferAllocatorClass, - func (intern *glRenderbufferAllocatorClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeGLRenderbufferAllocatorClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [GLRenderbufferAllocatorClass] is expected to work anymore. @@ -12541,17 +13130,20 @@ func UnsafeGLRenderbufferAllocatorClassToGlibNone(g *GLRenderbufferAllocatorClas return unsafe.Pointer(g.native) } -// UnsafeGLRenderbufferAllocatorClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeGLRenderbufferAllocatorClassToGlibFull(g *GLRenderbufferAllocatorClass) unsafe.Pointer { - runtime.SetFinalizer(g.glRenderbufferAllocatorClass, nil) - _p := unsafe.Pointer(g.native) - g.native = nil // GLRenderbufferAllocatorClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (g *GLRenderbufferAllocatorClass) ParentClass() *GLBaseMemoryAllocatorClass { + parent := UnsafeGLBaseMemoryAllocatorClassFromGlibBorrow(UnsafeGLRenderbufferAllocatorClassToGlibNone(g)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *GLRenderbufferAllocatorClass) {}, g) + return parent } + // GLSLStageClass wraps GstGLSLStageClass // // Opaque #GstGLSLStageClass struct +// +// GLSLStageClass is the type struct for [GLSLStage] type GLSLStageClass struct { *glslStageClass } @@ -12566,31 +13158,6 @@ func UnsafeGLSLStageClassFromGlibBorrow(p unsafe.Pointer) *GLSLStageClass { return &GLSLStageClass{&glslStageClass{(*C.GstGLSLStageClass)(p)}} } -// UnsafeGLSLStageClassFromGlibNone is used to convert raw C.GstGLSLStageClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeGLSLStageClassFromGlibNone(p unsafe.Pointer) *GLSLStageClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeGLSLStageClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.glslStageClass, - func (intern *glslStageClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeGLSLStageClassFromGlibFull is used to convert raw C.GstGLSLStageClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeGLSLStageClassFromGlibFull(p unsafe.Pointer) *GLSLStageClass { - wrapped := UnsafeGLSLStageClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.glslStageClass, - func (intern *glslStageClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeGLSLStageClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [GLSLStageClass] is expected to work anymore. @@ -12603,15 +13170,18 @@ func UnsafeGLSLStageClassToGlibNone(g *GLSLStageClass) unsafe.Pointer { return unsafe.Pointer(g.native) } -// UnsafeGLSLStageClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeGLSLStageClassToGlibFull(g *GLSLStageClass) unsafe.Pointer { - runtime.SetFinalizer(g.glslStageClass, nil) - _p := unsafe.Pointer(g.native) - g.native = nil // GLSLStageClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (g *GLSLStageClass) ParentClass() *gst.ObjectClass { + parent := gst.UnsafeObjectClassFromGlibBorrow(UnsafeGLSLStageClassToGlibNone(g)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *GLSLStageClass) {}, g) + return parent } + // GLShaderClass wraps GstGLShaderClass +// +// GLShaderClass is the type struct for [GLShader] type GLShaderClass struct { *glShaderClass } @@ -12626,31 +13196,6 @@ func UnsafeGLShaderClassFromGlibBorrow(p unsafe.Pointer) *GLShaderClass { return &GLShaderClass{&glShaderClass{(*C.GstGLShaderClass)(p)}} } -// UnsafeGLShaderClassFromGlibNone is used to convert raw C.GstGLShaderClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeGLShaderClassFromGlibNone(p unsafe.Pointer) *GLShaderClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeGLShaderClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.glShaderClass, - func (intern *glShaderClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeGLShaderClassFromGlibFull is used to convert raw C.GstGLShaderClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeGLShaderClassFromGlibFull(p unsafe.Pointer) *GLShaderClass { - wrapped := UnsafeGLShaderClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.glShaderClass, - func (intern *glShaderClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeGLShaderClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [GLShaderClass] is expected to work anymore. @@ -12663,14 +13208,15 @@ func UnsafeGLShaderClassToGlibNone(g *GLShaderClass) unsafe.Pointer { return unsafe.Pointer(g.native) } -// UnsafeGLShaderClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeGLShaderClassToGlibFull(g *GLShaderClass) unsafe.Pointer { - runtime.SetFinalizer(g.glShaderClass, nil) - _p := unsafe.Pointer(g.native) - g.native = nil // GLShaderClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (g *GLShaderClass) ParentClass() *gst.ObjectClass { + parent := gst.UnsafeObjectClassFromGlibBorrow(UnsafeGLShaderClassToGlibNone(g)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *GLShaderClass) {}, g) + return parent } + // GLSyncMeta wraps GstGLSyncMeta // // #GstGLSyncMeta provides the ability to synchronize the OpenGL command stream @@ -12689,7 +13235,7 @@ func UnsafeGLSyncMetaFromGlibBorrow(p unsafe.Pointer) *GLSyncMeta { return &GLSyncMeta{&glSyncMeta{(*C.GstGLSyncMeta)(p)}} } -// UnsafeGLSyncMetaFromGlibNone is used to convert raw C.GstGLSyncMeta pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeGLSyncMetaFromGlibNone is used to convert raw C.GstGLSyncMeta pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeGLSyncMetaFromGlibNone(p unsafe.Pointer) *GLSyncMeta { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeGLSyncMetaFromGlibBorrow(p) @@ -12702,7 +13248,7 @@ func UnsafeGLSyncMetaFromGlibNone(p unsafe.Pointer) *GLSyncMeta { return wrapped } -// UnsafeGLSyncMetaFromGlibFull is used to convert raw C.GstGLSyncMeta pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeGLSyncMetaFromGlibFull is used to convert raw C.GstGLSyncMeta pointers to go while taking ownership. This is used by the bindings internally. func UnsafeGLSyncMetaFromGlibFull(p unsafe.Pointer) *GLSyncMeta { wrapped := UnsafeGLSyncMetaFromGlibBorrow(p) runtime.SetFinalizer( @@ -12734,7 +13280,9 @@ func UnsafeGLSyncMetaToGlibFull(g *GLSyncMeta) unsafe.Pointer { g.native = nil // GLSyncMeta is invalid from here on return _p } + // GLSyncMetaGetInfo wraps gst_gl_sync_meta_get_info +// // The function returns the following values: // // - goret *gst.MetaInfo @@ -12813,6 +13361,8 @@ func (syncMeta *GLSyncMeta) WaitCpu(_context GLContext) { // GLUploadClass wraps GstGLUploadClass // // The #GstGLUploadClass struct only contains private data +// +// GLUploadClass is the type struct for [GLUpload] type GLUploadClass struct { *glUploadClass } @@ -12827,31 +13377,6 @@ func UnsafeGLUploadClassFromGlibBorrow(p unsafe.Pointer) *GLUploadClass { return &GLUploadClass{&glUploadClass{(*C.GstGLUploadClass)(p)}} } -// UnsafeGLUploadClassFromGlibNone is used to convert raw C.GstGLUploadClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeGLUploadClassFromGlibNone(p unsafe.Pointer) *GLUploadClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeGLUploadClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.glUploadClass, - func (intern *glUploadClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeGLUploadClassFromGlibFull is used to convert raw C.GstGLUploadClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeGLUploadClassFromGlibFull(p unsafe.Pointer) *GLUploadClass { - wrapped := UnsafeGLUploadClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.glUploadClass, - func (intern *glUploadClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeGLUploadClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [GLUploadClass] is expected to work anymore. @@ -12864,14 +13389,15 @@ func UnsafeGLUploadClassToGlibNone(g *GLUploadClass) unsafe.Pointer { return unsafe.Pointer(g.native) } -// UnsafeGLUploadClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeGLUploadClassToGlibFull(g *GLUploadClass) unsafe.Pointer { - runtime.SetFinalizer(g.glUploadClass, nil) - _p := unsafe.Pointer(g.native) - g.native = nil // GLUploadClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (g *GLUploadClass) ParentClass() *gst.ObjectClass { + parent := gst.UnsafeObjectClassFromGlibBorrow(UnsafeGLUploadClassToGlibNone(g)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *GLUploadClass) {}, g) + return parent } + // GLVideoAllocationParams wraps GstGLVideoAllocationParams type GLVideoAllocationParams struct { *glVideoAllocationParams @@ -12899,7 +13425,7 @@ func UnsafeGLVideoAllocationParamsFromGlibBorrow(p unsafe.Pointer) *GLVideoAlloc return &GLVideoAllocationParams{&glVideoAllocationParams{(*C.GstGLVideoAllocationParams)(p)}} } -// UnsafeGLVideoAllocationParamsFromGlibNone is used to convert raw C.GstGLVideoAllocationParams pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeGLVideoAllocationParamsFromGlibNone is used to convert raw C.GstGLVideoAllocationParams pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeGLVideoAllocationParamsFromGlibNone(p unsafe.Pointer) *GLVideoAllocationParams { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeGLVideoAllocationParamsFromGlibBorrow(p) @@ -12912,7 +13438,7 @@ func UnsafeGLVideoAllocationParamsFromGlibNone(p unsafe.Pointer) *GLVideoAllocat return wrapped } -// UnsafeGLVideoAllocationParamsFromGlibFull is used to convert raw C.GstGLVideoAllocationParams pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeGLVideoAllocationParamsFromGlibFull is used to convert raw C.GstGLVideoAllocationParams pointers to go while taking ownership. This is used by the bindings internally. func UnsafeGLVideoAllocationParamsFromGlibFull(p unsafe.Pointer) *GLVideoAllocationParams { wrapped := UnsafeGLVideoAllocationParamsFromGlibBorrow(p) runtime.SetFinalizer( @@ -12944,6 +13470,7 @@ func UnsafeGLVideoAllocationParamsToGlibFull(g *GLVideoAllocationParams) unsafe. g.native = nil // GLVideoAllocationParams is invalid from here on return _p } + // NewGLVideoAllocationParams wraps gst_gl_video_allocation_params_new // // The function takes the following parameters: @@ -13033,6 +13560,8 @@ func (params *GLVideoAllocationParams) FreeData() { // GLViewConvertClass wraps GstGLViewConvertClass // // Opaque #GstGLViewConvertClass struct +// +// GLViewConvertClass is the type struct for [GLViewConvert] type GLViewConvertClass struct { *glViewConvertClass } @@ -13047,31 +13576,6 @@ func UnsafeGLViewConvertClassFromGlibBorrow(p unsafe.Pointer) *GLViewConvertClas return &GLViewConvertClass{&glViewConvertClass{(*C.GstGLViewConvertClass)(p)}} } -// UnsafeGLViewConvertClassFromGlibNone is used to convert raw C.GstGLViewConvertClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeGLViewConvertClassFromGlibNone(p unsafe.Pointer) *GLViewConvertClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeGLViewConvertClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.glViewConvertClass, - func (intern *glViewConvertClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeGLViewConvertClassFromGlibFull is used to convert raw C.GstGLViewConvertClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeGLViewConvertClassFromGlibFull(p unsafe.Pointer) *GLViewConvertClass { - wrapped := UnsafeGLViewConvertClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.glViewConvertClass, - func (intern *glViewConvertClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeGLViewConvertClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [GLViewConvertClass] is expected to work anymore. @@ -13084,15 +13588,18 @@ func UnsafeGLViewConvertClassToGlibNone(g *GLViewConvertClass) unsafe.Pointer { return unsafe.Pointer(g.native) } -// UnsafeGLViewConvertClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeGLViewConvertClassToGlibFull(g *GLViewConvertClass) unsafe.Pointer { - runtime.SetFinalizer(g.glViewConvertClass, nil) - _p := unsafe.Pointer(g.native) - g.native = nil // GLViewConvertClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (g *GLViewConvertClass) ParentClass() *gst.ObjectClass { + parent := gst.UnsafeObjectClassFromGlibBorrow(UnsafeGLViewConvertClassToGlibNone(g)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *GLViewConvertClass) {}, g) + return parent } + // GLWindowClass wraps GstGLWindowClass +// +// GLWindowClass is the type struct for [GLWindow] type GLWindowClass struct { *glWindowClass } @@ -13107,31 +13614,6 @@ func UnsafeGLWindowClassFromGlibBorrow(p unsafe.Pointer) *GLWindowClass { return &GLWindowClass{&glWindowClass{(*C.GstGLWindowClass)(p)}} } -// UnsafeGLWindowClassFromGlibNone is used to convert raw C.GstGLWindowClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeGLWindowClassFromGlibNone(p unsafe.Pointer) *GLWindowClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeGLWindowClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.glWindowClass, - func (intern *glWindowClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeGLWindowClassFromGlibFull is used to convert raw C.GstGLWindowClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeGLWindowClassFromGlibFull(p unsafe.Pointer) *GLWindowClass { - wrapped := UnsafeGLWindowClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.glWindowClass, - func (intern *glWindowClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeGLWindowClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [GLWindowClass] is expected to work anymore. @@ -13144,11 +13626,12 @@ func UnsafeGLWindowClassToGlibNone(g *GLWindowClass) unsafe.Pointer { return unsafe.Pointer(g.native) } -// UnsafeGLWindowClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeGLWindowClassToGlibFull(g *GLWindowClass) unsafe.Pointer { - runtime.SetFinalizer(g.glWindowClass, nil) - _p := unsafe.Pointer(g.native) - g.native = nil // GLWindowClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (g *GLWindowClass) ParentClass() *gst.ObjectClass { + parent := gst.UnsafeObjectClassFromGlibBorrow(UnsafeGLWindowClassToGlibNone(g)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *GLWindowClass) {}, g) + return parent } + diff --git a/pkg/gstgl/gstgl_export.gen.go b/pkg/gstgl/gstgl_export.gen.go index 4391c59..3183518 100644 --- a/pkg/gstgl/gstgl_export.gen.go +++ b/pkg/gstgl/gstgl_export.gen.go @@ -58,3 +58,198 @@ func _gotk4_gstgl1_GLFilterRenderFunc(carg1 *C.GstGLFilter, carg2 *C.GstGLMemory return cret } +//export _gotk4_gstgl1_GLBaseFilter_gl_set_caps +func _gotk4_gstgl1_GLBaseFilter_gl_set_caps(carg0 *C.GstGLBaseFilter, carg1 *C.GstCaps, carg2 *C.GstCaps) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstgl1_GLBaseFilter_gl_start +func _gotk4_gstgl1_GLBaseFilter_gl_start(carg0 *C.GstGLBaseFilter) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstgl1_GLBaseFilter_gl_stop +func _gotk4_gstgl1_GLBaseFilter_gl_stop(carg0 *C.GstGLBaseFilter) { + panic("unimplemented") +} + +//export _gotk4_gstgl1_GLBaseMixer_gl_start +func _gotk4_gstgl1_GLBaseMixer_gl_start(carg0 *C.GstGLBaseMixer) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstgl1_GLBaseMixer_gl_stop +func _gotk4_gstgl1_GLBaseMixer_gl_stop(carg0 *C.GstGLBaseMixer) { + panic("unimplemented") +} + +//export _gotk4_gstgl1_GLBaseSrc_fill_gl_memory +func _gotk4_gstgl1_GLBaseSrc_fill_gl_memory(carg0 *C.GstGLBaseSrc, carg1 *C.GstGLMemory) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstgl1_GLBaseSrc_gl_start +func _gotk4_gstgl1_GLBaseSrc_gl_start(carg0 *C.GstGLBaseSrc) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstgl1_GLBaseSrc_gl_stop +func _gotk4_gstgl1_GLBaseSrc_gl_stop(carg0 *C.GstGLBaseSrc) { + panic("unimplemented") +} + +//export _gotk4_gstgl1_GLContext_activate +func _gotk4_gstgl1_GLContext_activate(carg0 *C.GstGLContext, carg1 C.gboolean) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstgl1_GLContext_check_feature +func _gotk4_gstgl1_GLContext_check_feature(carg0 *C.GstGLContext, carg1 *C.gchar) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstgl1_GLContext_choose_format +func _gotk4_gstgl1_GLContext_choose_format(carg0 *C.GstGLContext, _cerr **C.GError) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstgl1_GLContext_create_context +func _gotk4_gstgl1_GLContext_create_context(carg0 *C.GstGLContext, carg1 C.GstGLAPI, carg2 *C.GstGLContext, _cerr **C.GError) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstgl1_GLContext_destroy_context +func _gotk4_gstgl1_GLContext_destroy_context(carg0 *C.GstGLContext) { + panic("unimplemented") +} + +//export _gotk4_gstgl1_GLContext_get_config +func _gotk4_gstgl1_GLContext_get_config(carg0 *C.GstGLContext) (cret *C.GstStructure) { + panic("unimplemented") +} + +//export _gotk4_gstgl1_GLContext_get_gl_api +func _gotk4_gstgl1_GLContext_get_gl_api(carg0 *C.GstGLContext) (cret C.GstGLAPI) { + panic("unimplemented") +} + +//export _gotk4_gstgl1_GLContext_get_gl_platform +func _gotk4_gstgl1_GLContext_get_gl_platform(carg0 *C.GstGLContext) (cret C.GstGLPlatform) { + panic("unimplemented") +} + +//export _gotk4_gstgl1_GLContext_get_gl_platform_version +func _gotk4_gstgl1_GLContext_get_gl_platform_version(carg0 *C.GstGLContext, carg1 *C.gint, carg2 *C.gint) { + panic("unimplemented") +} + +//export _gotk4_gstgl1_GLContext_request_config +func _gotk4_gstgl1_GLContext_request_config(carg0 *C.GstGLContext, carg1 *C.GstStructure) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstgl1_GLContext_swap_buffers +func _gotk4_gstgl1_GLContext_swap_buffers(carg0 *C.GstGLContext) { + panic("unimplemented") +} + +//export _gotk4_gstgl1_GLDisplay_create_window +func _gotk4_gstgl1_GLDisplay_create_window(carg0 *C.GstGLDisplay) (cret *C.GstGLWindow) { + panic("unimplemented") +} + +//export _gotk4_gstgl1_GLFilter_filter +func _gotk4_gstgl1_GLFilter_filter(carg0 *C.GstGLFilter, carg1 *C.GstBuffer, carg2 *C.GstBuffer) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstgl1_GLFilter_filter_texture +func _gotk4_gstgl1_GLFilter_filter_texture(carg0 *C.GstGLFilter, carg1 *C.GstGLMemory, carg2 *C.GstGLMemory) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstgl1_GLFilter_init_fbo +func _gotk4_gstgl1_GLFilter_init_fbo(carg0 *C.GstGLFilter) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstgl1_GLFilter_set_caps +func _gotk4_gstgl1_GLFilter_set_caps(carg0 *C.GstGLFilter, carg1 *C.GstCaps, carg2 *C.GstCaps) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstgl1_GLFilter_transform_internal_caps +func _gotk4_gstgl1_GLFilter_transform_internal_caps(carg0 *C.GstGLFilter, carg1 C.GstPadDirection, carg2 *C.GstCaps, carg3 *C.GstCaps) (cret *C.GstCaps) { + panic("unimplemented") +} + +//export _gotk4_gstgl1_GLMixer_process_buffers +func _gotk4_gstgl1_GLMixer_process_buffers(carg0 *C.GstGLMixer, carg1 *C.GstBuffer) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstgl1_GLMixer_process_textures +func _gotk4_gstgl1_GLMixer_process_textures(carg0 *C.GstGLMixer, carg1 *C.GstGLMemory) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstgl1_GLWindow_close +func _gotk4_gstgl1_GLWindow_close(carg0 *C.GstGLWindow) { + panic("unimplemented") +} + +//export _gotk4_gstgl1_GLWindow_controls_viewport +func _gotk4_gstgl1_GLWindow_controls_viewport(carg0 *C.GstGLWindow) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstgl1_GLWindow_draw +func _gotk4_gstgl1_GLWindow_draw(carg0 *C.GstGLWindow) { + panic("unimplemented") +} + +//export _gotk4_gstgl1_GLWindow_handle_events +func _gotk4_gstgl1_GLWindow_handle_events(carg0 *C.GstGLWindow, carg1 C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstgl1_GLWindow_has_output_surface +func _gotk4_gstgl1_GLWindow_has_output_surface(carg0 *C.GstGLWindow) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstgl1_GLWindow_open +func _gotk4_gstgl1_GLWindow_open(carg0 *C.GstGLWindow, _cerr **C.GError) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstgl1_GLWindow_queue_resize +func _gotk4_gstgl1_GLWindow_queue_resize(carg0 *C.GstGLWindow) { + panic("unimplemented") +} + +//export _gotk4_gstgl1_GLWindow_quit +func _gotk4_gstgl1_GLWindow_quit(carg0 *C.GstGLWindow) { + panic("unimplemented") +} + +//export _gotk4_gstgl1_GLWindow_run +func _gotk4_gstgl1_GLWindow_run(carg0 *C.GstGLWindow) { + panic("unimplemented") +} + +//export _gotk4_gstgl1_GLWindow_set_preferred_size +func _gotk4_gstgl1_GLWindow_set_preferred_size(carg0 *C.GstGLWindow, carg1 C.gint, carg2 C.gint) { + panic("unimplemented") +} + +//export _gotk4_gstgl1_GLWindow_set_render_rectangle +func _gotk4_gstgl1_GLWindow_set_render_rectangle(carg0 *C.GstGLWindow, carg1 C.gint, carg2 C.gint, carg3 C.gint, carg4 C.gint) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstgl1_GLWindow_show +func _gotk4_gstgl1_GLWindow_show(carg0 *C.GstGLWindow) { + panic("unimplemented") +} + diff --git a/pkg/gstmpegts/gstmpegts.gen.go b/pkg/gstmpegts/gstmpegts.gen.go index c776741..dbe14d0 100644 --- a/pkg/gstmpegts/gstmpegts.gen.go +++ b/pkg/gstmpegts/gstmpegts.gen.go @@ -3020,6 +3020,7 @@ func MessageParseMpegtsSection(message *gst.Message) *Section { } // PesMetadataMetaApiGetType wraps gst_mpegts_pes_metadata_meta_api_get_type +// // The function returns the following values: // // - goret gobject.Type @@ -3066,6 +3067,7 @@ func NewScteCancel(eventId uint32) *SCTESIT { } // NewScteNull wraps gst_mpegts_scte_null_new +// // The function returns the following values: // // - goret *SCTESIT @@ -3189,7 +3191,7 @@ func UnsafeAtscEITFromGlibBorrow(p unsafe.Pointer) *AtscEIT { return &AtscEIT{&atscEIT{(*C.GstMpegtsAtscEIT)(p)}} } -// UnsafeAtscEITFromGlibNone is used to convert raw C.GstMpegtsAtscEIT pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeAtscEITFromGlibNone is used to convert raw C.GstMpegtsAtscEIT pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeAtscEITFromGlibNone(p unsafe.Pointer) *AtscEIT { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeAtscEITFromGlibBorrow(p) @@ -3202,7 +3204,7 @@ func UnsafeAtscEITFromGlibNone(p unsafe.Pointer) *AtscEIT { return wrapped } -// UnsafeAtscEITFromGlibFull is used to convert raw C.GstMpegtsAtscEIT pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeAtscEITFromGlibFull is used to convert raw C.GstMpegtsAtscEIT pointers to go while taking ownership. This is used by the bindings internally. func UnsafeAtscEITFromGlibFull(p unsafe.Pointer) *AtscEIT { wrapped := UnsafeAtscEITFromGlibBorrow(p) runtime.SetFinalizer( @@ -3234,6 +3236,7 @@ func UnsafeAtscEITToGlibFull(a *AtscEIT) unsafe.Pointer { a.native = nil // AtscEIT is invalid from here on return _p } + // AtscEITEvent wraps GstMpegtsAtscEITEvent // // An ATSC EIT Event @@ -3263,7 +3266,7 @@ func UnsafeAtscEITEventFromGlibBorrow(p unsafe.Pointer) *AtscEITEvent { return &AtscEITEvent{&atscEITEvent{(*C.GstMpegtsAtscEITEvent)(p)}} } -// UnsafeAtscEITEventFromGlibNone is used to convert raw C.GstMpegtsAtscEITEvent pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeAtscEITEventFromGlibNone is used to convert raw C.GstMpegtsAtscEITEvent pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeAtscEITEventFromGlibNone(p unsafe.Pointer) *AtscEITEvent { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeAtscEITEventFromGlibBorrow(p) @@ -3276,7 +3279,7 @@ func UnsafeAtscEITEventFromGlibNone(p unsafe.Pointer) *AtscEITEvent { return wrapped } -// UnsafeAtscEITEventFromGlibFull is used to convert raw C.GstMpegtsAtscEITEvent pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeAtscEITEventFromGlibFull is used to convert raw C.GstMpegtsAtscEITEvent pointers to go while taking ownership. This is used by the bindings internally. func UnsafeAtscEITEventFromGlibFull(p unsafe.Pointer) *AtscEITEvent { wrapped := UnsafeAtscEITEventFromGlibBorrow(p) runtime.SetFinalizer( @@ -3308,6 +3311,7 @@ func UnsafeAtscEITEventToGlibFull(a *AtscEITEvent) unsafe.Pointer { a.native = nil // AtscEITEvent is invalid from here on return _p } + // AtscETT wraps GstMpegtsAtscETT // // Extended Text Table (ATSC) @@ -3337,7 +3341,7 @@ func UnsafeAtscETTFromGlibBorrow(p unsafe.Pointer) *AtscETT { return &AtscETT{&atscETT{(*C.GstMpegtsAtscETT)(p)}} } -// UnsafeAtscETTFromGlibNone is used to convert raw C.GstMpegtsAtscETT pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeAtscETTFromGlibNone is used to convert raw C.GstMpegtsAtscETT pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeAtscETTFromGlibNone(p unsafe.Pointer) *AtscETT { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeAtscETTFromGlibBorrow(p) @@ -3350,7 +3354,7 @@ func UnsafeAtscETTFromGlibNone(p unsafe.Pointer) *AtscETT { return wrapped } -// UnsafeAtscETTFromGlibFull is used to convert raw C.GstMpegtsAtscETT pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeAtscETTFromGlibFull is used to convert raw C.GstMpegtsAtscETT pointers to go while taking ownership. This is used by the bindings internally. func UnsafeAtscETTFromGlibFull(p unsafe.Pointer) *AtscETT { wrapped := UnsafeAtscETTFromGlibBorrow(p) runtime.SetFinalizer( @@ -3382,6 +3386,7 @@ func UnsafeAtscETTToGlibFull(a *AtscETT) unsafe.Pointer { a.native = nil // AtscETT is invalid from here on return _p } + // AtscMGT wraps GstMpegtsAtscMGT // // Master Guide Table (A65) @@ -3411,7 +3416,7 @@ func UnsafeAtscMGTFromGlibBorrow(p unsafe.Pointer) *AtscMGT { return &AtscMGT{&atscMGT{(*C.GstMpegtsAtscMGT)(p)}} } -// UnsafeAtscMGTFromGlibNone is used to convert raw C.GstMpegtsAtscMGT pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeAtscMGTFromGlibNone is used to convert raw C.GstMpegtsAtscMGT pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeAtscMGTFromGlibNone(p unsafe.Pointer) *AtscMGT { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeAtscMGTFromGlibBorrow(p) @@ -3424,7 +3429,7 @@ func UnsafeAtscMGTFromGlibNone(p unsafe.Pointer) *AtscMGT { return wrapped } -// UnsafeAtscMGTFromGlibFull is used to convert raw C.GstMpegtsAtscMGT pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeAtscMGTFromGlibFull is used to convert raw C.GstMpegtsAtscMGT pointers to go while taking ownership. This is used by the bindings internally. func UnsafeAtscMGTFromGlibFull(p unsafe.Pointer) *AtscMGT { wrapped := UnsafeAtscMGTFromGlibBorrow(p) runtime.SetFinalizer( @@ -3456,7 +3461,9 @@ func UnsafeAtscMGTToGlibFull(a *AtscMGT) unsafe.Pointer { a.native = nil // AtscMGT is invalid from here on return _p } + // NewAtscMGT wraps gst_mpegts_atsc_mgt_new +// // The function returns the following values: // // - goret *AtscMGT @@ -3501,7 +3508,7 @@ func UnsafeAtscMGTTableFromGlibBorrow(p unsafe.Pointer) *AtscMGTTable { return &AtscMGTTable{&atscMGTTable{(*C.GstMpegtsAtscMGTTable)(p)}} } -// UnsafeAtscMGTTableFromGlibNone is used to convert raw C.GstMpegtsAtscMGTTable pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeAtscMGTTableFromGlibNone is used to convert raw C.GstMpegtsAtscMGTTable pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeAtscMGTTableFromGlibNone(p unsafe.Pointer) *AtscMGTTable { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeAtscMGTTableFromGlibBorrow(p) @@ -3514,7 +3521,7 @@ func UnsafeAtscMGTTableFromGlibNone(p unsafe.Pointer) *AtscMGTTable { return wrapped } -// UnsafeAtscMGTTableFromGlibFull is used to convert raw C.GstMpegtsAtscMGTTable pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeAtscMGTTableFromGlibFull is used to convert raw C.GstMpegtsAtscMGTTable pointers to go while taking ownership. This is used by the bindings internally. func UnsafeAtscMGTTableFromGlibFull(p unsafe.Pointer) *AtscMGTTable { wrapped := UnsafeAtscMGTTableFromGlibBorrow(p) runtime.SetFinalizer( @@ -3546,6 +3553,7 @@ func UnsafeAtscMGTTableToGlibFull(a *AtscMGTTable) unsafe.Pointer { a.native = nil // AtscMGTTable is invalid from here on return _p } + // AtscMultString wraps GstMpegtsAtscMultString type AtscMultString struct { *atscMultString @@ -3573,7 +3581,7 @@ func UnsafeAtscMultStringFromGlibBorrow(p unsafe.Pointer) *AtscMultString { return &AtscMultString{&atscMultString{(*C.GstMpegtsAtscMultString)(p)}} } -// UnsafeAtscMultStringFromGlibNone is used to convert raw C.GstMpegtsAtscMultString pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeAtscMultStringFromGlibNone is used to convert raw C.GstMpegtsAtscMultString pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeAtscMultStringFromGlibNone(p unsafe.Pointer) *AtscMultString { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeAtscMultStringFromGlibBorrow(p) @@ -3586,7 +3594,7 @@ func UnsafeAtscMultStringFromGlibNone(p unsafe.Pointer) *AtscMultString { return wrapped } -// UnsafeAtscMultStringFromGlibFull is used to convert raw C.GstMpegtsAtscMultString pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeAtscMultStringFromGlibFull is used to convert raw C.GstMpegtsAtscMultString pointers to go while taking ownership. This is used by the bindings internally. func UnsafeAtscMultStringFromGlibFull(p unsafe.Pointer) *AtscMultString { wrapped := UnsafeAtscMultStringFromGlibBorrow(p) runtime.SetFinalizer( @@ -3618,6 +3626,7 @@ func UnsafeAtscMultStringToGlibFull(a *AtscMultString) unsafe.Pointer { a.native = nil // AtscMultString is invalid from here on return _p } + // AtscRRT wraps GstMpegtsAtscRRT // // Region Rating Table (A65) @@ -3647,7 +3656,7 @@ func UnsafeAtscRRTFromGlibBorrow(p unsafe.Pointer) *AtscRRT { return &AtscRRT{&atscRRT{(*C.GstMpegtsAtscRRT)(p)}} } -// UnsafeAtscRRTFromGlibNone is used to convert raw C.GstMpegtsAtscRRT pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeAtscRRTFromGlibNone is used to convert raw C.GstMpegtsAtscRRT pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeAtscRRTFromGlibNone(p unsafe.Pointer) *AtscRRT { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeAtscRRTFromGlibBorrow(p) @@ -3660,7 +3669,7 @@ func UnsafeAtscRRTFromGlibNone(p unsafe.Pointer) *AtscRRT { return wrapped } -// UnsafeAtscRRTFromGlibFull is used to convert raw C.GstMpegtsAtscRRT pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeAtscRRTFromGlibFull is used to convert raw C.GstMpegtsAtscRRT pointers to go while taking ownership. This is used by the bindings internally. func UnsafeAtscRRTFromGlibFull(p unsafe.Pointer) *AtscRRT { wrapped := UnsafeAtscRRTFromGlibBorrow(p) runtime.SetFinalizer( @@ -3692,7 +3701,9 @@ func UnsafeAtscRRTToGlibFull(a *AtscRRT) unsafe.Pointer { a.native = nil // AtscRRT is invalid from here on return _p } + // NewAtscRRT wraps gst_mpegts_atsc_rrt_new +// // The function returns the following values: // // - goret *AtscRRT @@ -3735,7 +3746,7 @@ func UnsafeAtscRRTDimensionFromGlibBorrow(p unsafe.Pointer) *AtscRRTDimension { return &AtscRRTDimension{&atscRRTDimension{(*C.GstMpegtsAtscRRTDimension)(p)}} } -// UnsafeAtscRRTDimensionFromGlibNone is used to convert raw C.GstMpegtsAtscRRTDimension pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeAtscRRTDimensionFromGlibNone is used to convert raw C.GstMpegtsAtscRRTDimension pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeAtscRRTDimensionFromGlibNone(p unsafe.Pointer) *AtscRRTDimension { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeAtscRRTDimensionFromGlibBorrow(p) @@ -3748,7 +3759,7 @@ func UnsafeAtscRRTDimensionFromGlibNone(p unsafe.Pointer) *AtscRRTDimension { return wrapped } -// UnsafeAtscRRTDimensionFromGlibFull is used to convert raw C.GstMpegtsAtscRRTDimension pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeAtscRRTDimensionFromGlibFull is used to convert raw C.GstMpegtsAtscRRTDimension pointers to go while taking ownership. This is used by the bindings internally. func UnsafeAtscRRTDimensionFromGlibFull(p unsafe.Pointer) *AtscRRTDimension { wrapped := UnsafeAtscRRTDimensionFromGlibBorrow(p) runtime.SetFinalizer( @@ -3780,7 +3791,9 @@ func UnsafeAtscRRTDimensionToGlibFull(a *AtscRRTDimension) unsafe.Pointer { a.native = nil // AtscRRTDimension is invalid from here on return _p } + // NewAtscRRTDimension wraps gst_mpegts_atsc_rrt_dimension_new +// // The function returns the following values: // // - goret *AtscRRTDimension @@ -3823,7 +3836,7 @@ func UnsafeAtscRRTDimensionValueFromGlibBorrow(p unsafe.Pointer) *AtscRRTDimensi return &AtscRRTDimensionValue{&atscRRTDimensionValue{(*C.GstMpegtsAtscRRTDimensionValue)(p)}} } -// UnsafeAtscRRTDimensionValueFromGlibNone is used to convert raw C.GstMpegtsAtscRRTDimensionValue pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeAtscRRTDimensionValueFromGlibNone is used to convert raw C.GstMpegtsAtscRRTDimensionValue pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeAtscRRTDimensionValueFromGlibNone(p unsafe.Pointer) *AtscRRTDimensionValue { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeAtscRRTDimensionValueFromGlibBorrow(p) @@ -3836,7 +3849,7 @@ func UnsafeAtscRRTDimensionValueFromGlibNone(p unsafe.Pointer) *AtscRRTDimension return wrapped } -// UnsafeAtscRRTDimensionValueFromGlibFull is used to convert raw C.GstMpegtsAtscRRTDimensionValue pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeAtscRRTDimensionValueFromGlibFull is used to convert raw C.GstMpegtsAtscRRTDimensionValue pointers to go while taking ownership. This is used by the bindings internally. func UnsafeAtscRRTDimensionValueFromGlibFull(p unsafe.Pointer) *AtscRRTDimensionValue { wrapped := UnsafeAtscRRTDimensionValueFromGlibBorrow(p) runtime.SetFinalizer( @@ -3868,7 +3881,9 @@ func UnsafeAtscRRTDimensionValueToGlibFull(a *AtscRRTDimensionValue) unsafe.Poin a.native = nil // AtscRRTDimensionValue is invalid from here on return _p } + // NewAtscRRTDimensionValue wraps gst_mpegts_atsc_rrt_dimension_value_new +// // The function returns the following values: // // - goret *AtscRRTDimensionValue @@ -3913,7 +3928,7 @@ func UnsafeAtscSTTFromGlibBorrow(p unsafe.Pointer) *AtscSTT { return &AtscSTT{&atscSTT{(*C.GstMpegtsAtscSTT)(p)}} } -// UnsafeAtscSTTFromGlibNone is used to convert raw C.GstMpegtsAtscSTT pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeAtscSTTFromGlibNone is used to convert raw C.GstMpegtsAtscSTT pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeAtscSTTFromGlibNone(p unsafe.Pointer) *AtscSTT { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeAtscSTTFromGlibBorrow(p) @@ -3926,7 +3941,7 @@ func UnsafeAtscSTTFromGlibNone(p unsafe.Pointer) *AtscSTT { return wrapped } -// UnsafeAtscSTTFromGlibFull is used to convert raw C.GstMpegtsAtscSTT pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeAtscSTTFromGlibFull is used to convert raw C.GstMpegtsAtscSTT pointers to go while taking ownership. This is used by the bindings internally. func UnsafeAtscSTTFromGlibFull(p unsafe.Pointer) *AtscSTT { wrapped := UnsafeAtscSTTFromGlibBorrow(p) runtime.SetFinalizer( @@ -3958,7 +3973,9 @@ func UnsafeAtscSTTToGlibFull(a *AtscSTT) unsafe.Pointer { a.native = nil // AtscSTT is invalid from here on return _p } + // NewAtscSTT wraps gst_mpegts_atsc_stt_new +// // The function returns the following values: // // - goret *AtscSTT @@ -3975,6 +3992,7 @@ func NewAtscSTT() *AtscSTT { } // GetDatetimeUTC wraps gst_mpegts_atsc_stt_get_datetime_utc +// // The function returns the following values: // // - goret *gst.DateTime @@ -4023,7 +4041,7 @@ func UnsafeAtscStringSegmentFromGlibBorrow(p unsafe.Pointer) *AtscStringSegment return &AtscStringSegment{&atscStringSegment{(*C.GstMpegtsAtscStringSegment)(p)}} } -// UnsafeAtscStringSegmentFromGlibNone is used to convert raw C.GstMpegtsAtscStringSegment pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeAtscStringSegmentFromGlibNone is used to convert raw C.GstMpegtsAtscStringSegment pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeAtscStringSegmentFromGlibNone(p unsafe.Pointer) *AtscStringSegment { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeAtscStringSegmentFromGlibBorrow(p) @@ -4036,7 +4054,7 @@ func UnsafeAtscStringSegmentFromGlibNone(p unsafe.Pointer) *AtscStringSegment { return wrapped } -// UnsafeAtscStringSegmentFromGlibFull is used to convert raw C.GstMpegtsAtscStringSegment pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeAtscStringSegmentFromGlibFull is used to convert raw C.GstMpegtsAtscStringSegment pointers to go while taking ownership. This is used by the bindings internally. func UnsafeAtscStringSegmentFromGlibFull(p unsafe.Pointer) *AtscStringSegment { wrapped := UnsafeAtscStringSegmentFromGlibBorrow(p) runtime.SetFinalizer( @@ -4068,7 +4086,9 @@ func UnsafeAtscStringSegmentToGlibFull(a *AtscStringSegment) unsafe.Pointer { a.native = nil // AtscStringSegment is invalid from here on return _p } + // GetString wraps gst_mpegts_atsc_string_segment_get_string +// // The function returns the following values: // // - goret string @@ -4158,7 +4178,7 @@ func UnsafeAtscVCTFromGlibBorrow(p unsafe.Pointer) *AtscVCT { return &AtscVCT{&atscVCT{(*C.GstMpegtsAtscVCT)(p)}} } -// UnsafeAtscVCTFromGlibNone is used to convert raw C.GstMpegtsAtscVCT pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeAtscVCTFromGlibNone is used to convert raw C.GstMpegtsAtscVCT pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeAtscVCTFromGlibNone(p unsafe.Pointer) *AtscVCT { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeAtscVCTFromGlibBorrow(p) @@ -4171,7 +4191,7 @@ func UnsafeAtscVCTFromGlibNone(p unsafe.Pointer) *AtscVCT { return wrapped } -// UnsafeAtscVCTFromGlibFull is used to convert raw C.GstMpegtsAtscVCT pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeAtscVCTFromGlibFull is used to convert raw C.GstMpegtsAtscVCT pointers to go while taking ownership. This is used by the bindings internally. func UnsafeAtscVCTFromGlibFull(p unsafe.Pointer) *AtscVCT { wrapped := UnsafeAtscVCTFromGlibBorrow(p) runtime.SetFinalizer( @@ -4203,6 +4223,7 @@ func UnsafeAtscVCTToGlibFull(a *AtscVCT) unsafe.Pointer { a.native = nil // AtscVCT is invalid from here on return _p } + // AtscVCTSource wraps GstMpegtsAtscVCTSource // // Source from a %GstMpegtsAtscVCT, can be used both for TVCT and CVCT tables @@ -4232,7 +4253,7 @@ func UnsafeAtscVCTSourceFromGlibBorrow(p unsafe.Pointer) *AtscVCTSource { return &AtscVCTSource{&atscVCTSource{(*C.GstMpegtsAtscVCTSource)(p)}} } -// UnsafeAtscVCTSourceFromGlibNone is used to convert raw C.GstMpegtsAtscVCTSource pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeAtscVCTSourceFromGlibNone is used to convert raw C.GstMpegtsAtscVCTSource pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeAtscVCTSourceFromGlibNone(p unsafe.Pointer) *AtscVCTSource { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeAtscVCTSourceFromGlibBorrow(p) @@ -4245,7 +4266,7 @@ func UnsafeAtscVCTSourceFromGlibNone(p unsafe.Pointer) *AtscVCTSource { return wrapped } -// UnsafeAtscVCTSourceFromGlibFull is used to convert raw C.GstMpegtsAtscVCTSource pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeAtscVCTSourceFromGlibFull is used to convert raw C.GstMpegtsAtscVCTSource pointers to go while taking ownership. This is used by the bindings internally. func UnsafeAtscVCTSourceFromGlibFull(p unsafe.Pointer) *AtscVCTSource { wrapped := UnsafeAtscVCTSourceFromGlibBorrow(p) runtime.SetFinalizer( @@ -4277,6 +4298,7 @@ func UnsafeAtscVCTSourceToGlibFull(a *AtscVCTSource) unsafe.Pointer { a.native = nil // AtscVCTSource is invalid from here on return _p } + // AudioPreselectionDescriptor wraps GstMpegtsAudioPreselectionDescriptor // // Table 110: Audio Preselection Descriptor (ETSI EN 300 468 v1.16.1) @@ -4294,7 +4316,7 @@ func UnsafeAudioPreselectionDescriptorFromGlibBorrow(p unsafe.Pointer) *AudioPre return &AudioPreselectionDescriptor{&audioPreselectionDescriptor{(*C.GstMpegtsAudioPreselectionDescriptor)(p)}} } -// UnsafeAudioPreselectionDescriptorFromGlibNone is used to convert raw C.GstMpegtsAudioPreselectionDescriptor pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeAudioPreselectionDescriptorFromGlibNone is used to convert raw C.GstMpegtsAudioPreselectionDescriptor pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeAudioPreselectionDescriptorFromGlibNone(p unsafe.Pointer) *AudioPreselectionDescriptor { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeAudioPreselectionDescriptorFromGlibBorrow(p) @@ -4307,7 +4329,7 @@ func UnsafeAudioPreselectionDescriptorFromGlibNone(p unsafe.Pointer) *AudioPrese return wrapped } -// UnsafeAudioPreselectionDescriptorFromGlibFull is used to convert raw C.GstMpegtsAudioPreselectionDescriptor pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeAudioPreselectionDescriptorFromGlibFull is used to convert raw C.GstMpegtsAudioPreselectionDescriptor pointers to go while taking ownership. This is used by the bindings internally. func UnsafeAudioPreselectionDescriptorFromGlibFull(p unsafe.Pointer) *AudioPreselectionDescriptor { wrapped := UnsafeAudioPreselectionDescriptorFromGlibBorrow(p) runtime.SetFinalizer( @@ -4339,6 +4361,7 @@ func UnsafeAudioPreselectionDescriptorToGlibFull(a *AudioPreselectionDescriptor) a.native = nil // AudioPreselectionDescriptor is invalid from here on return _p } + // BAT wraps GstMpegtsBAT // // DVB Bouquet Association Table (EN 300 468) @@ -4368,7 +4391,7 @@ func UnsafeBATFromGlibBorrow(p unsafe.Pointer) *BAT { return &BAT{&baT{(*C.GstMpegtsBAT)(p)}} } -// UnsafeBATFromGlibNone is used to convert raw C.GstMpegtsBAT pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeBATFromGlibNone is used to convert raw C.GstMpegtsBAT pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeBATFromGlibNone(p unsafe.Pointer) *BAT { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeBATFromGlibBorrow(p) @@ -4381,7 +4404,7 @@ func UnsafeBATFromGlibNone(p unsafe.Pointer) *BAT { return wrapped } -// UnsafeBATFromGlibFull is used to convert raw C.GstMpegtsBAT pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeBATFromGlibFull is used to convert raw C.GstMpegtsBAT pointers to go while taking ownership. This is used by the bindings internally. func UnsafeBATFromGlibFull(p unsafe.Pointer) *BAT { wrapped := UnsafeBATFromGlibBorrow(p) runtime.SetFinalizer( @@ -4413,6 +4436,7 @@ func UnsafeBATToGlibFull(b *BAT) unsafe.Pointer { b.native = nil // BAT is invalid from here on return _p } + // BATStream wraps GstMpegtsBATStream type BATStream struct { *batStream @@ -4440,7 +4464,7 @@ func UnsafeBATStreamFromGlibBorrow(p unsafe.Pointer) *BATStream { return &BATStream{&batStream{(*C.GstMpegtsBATStream)(p)}} } -// UnsafeBATStreamFromGlibNone is used to convert raw C.GstMpegtsBATStream pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeBATStreamFromGlibNone is used to convert raw C.GstMpegtsBATStream pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeBATStreamFromGlibNone(p unsafe.Pointer) *BATStream { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeBATStreamFromGlibBorrow(p) @@ -4453,7 +4477,7 @@ func UnsafeBATStreamFromGlibNone(p unsafe.Pointer) *BATStream { return wrapped } -// UnsafeBATStreamFromGlibFull is used to convert raw C.GstMpegtsBATStream pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeBATStreamFromGlibFull is used to convert raw C.GstMpegtsBATStream pointers to go while taking ownership. This is used by the bindings internally. func UnsafeBATStreamFromGlibFull(p unsafe.Pointer) *BATStream { wrapped := UnsafeBATStreamFromGlibBorrow(p) runtime.SetFinalizer( @@ -4485,6 +4509,7 @@ func UnsafeBATStreamToGlibFull(b *BATStream) unsafe.Pointer { b.native = nil // BATStream is invalid from here on return _p } + // CableDeliverySystemDescriptor wraps GstMpegtsCableDeliverySystemDescriptor // // Cable Delivery System Descriptor (EN 300 468 v.1.13.1) @@ -4514,7 +4539,7 @@ func UnsafeCableDeliverySystemDescriptorFromGlibBorrow(p unsafe.Pointer) *CableD return &CableDeliverySystemDescriptor{&cableDeliverySystemDescriptor{(*C.GstMpegtsCableDeliverySystemDescriptor)(p)}} } -// UnsafeCableDeliverySystemDescriptorFromGlibNone is used to convert raw C.GstMpegtsCableDeliverySystemDescriptor pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeCableDeliverySystemDescriptorFromGlibNone is used to convert raw C.GstMpegtsCableDeliverySystemDescriptor pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeCableDeliverySystemDescriptorFromGlibNone(p unsafe.Pointer) *CableDeliverySystemDescriptor { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeCableDeliverySystemDescriptorFromGlibBorrow(p) @@ -4527,7 +4552,7 @@ func UnsafeCableDeliverySystemDescriptorFromGlibNone(p unsafe.Pointer) *CableDel return wrapped } -// UnsafeCableDeliverySystemDescriptorFromGlibFull is used to convert raw C.GstMpegtsCableDeliverySystemDescriptor pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeCableDeliverySystemDescriptorFromGlibFull is used to convert raw C.GstMpegtsCableDeliverySystemDescriptor pointers to go while taking ownership. This is used by the bindings internally. func UnsafeCableDeliverySystemDescriptorFromGlibFull(p unsafe.Pointer) *CableDeliverySystemDescriptor { wrapped := UnsafeCableDeliverySystemDescriptorFromGlibBorrow(p) runtime.SetFinalizer( @@ -4559,6 +4584,7 @@ func UnsafeCableDeliverySystemDescriptorToGlibFull(c *CableDeliverySystemDescrip c.native = nil // CableDeliverySystemDescriptor is invalid from here on return _p } + // ComponentDescriptor wraps GstMpegtsComponentDescriptor type ComponentDescriptor struct { *componentDescriptor @@ -4586,7 +4612,7 @@ func UnsafeComponentDescriptorFromGlibBorrow(p unsafe.Pointer) *ComponentDescrip return &ComponentDescriptor{&componentDescriptor{(*C.GstMpegtsComponentDescriptor)(p)}} } -// UnsafeComponentDescriptorFromGlibNone is used to convert raw C.GstMpegtsComponentDescriptor pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeComponentDescriptorFromGlibNone is used to convert raw C.GstMpegtsComponentDescriptor pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeComponentDescriptorFromGlibNone(p unsafe.Pointer) *ComponentDescriptor { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeComponentDescriptorFromGlibBorrow(p) @@ -4599,7 +4625,7 @@ func UnsafeComponentDescriptorFromGlibNone(p unsafe.Pointer) *ComponentDescripto return wrapped } -// UnsafeComponentDescriptorFromGlibFull is used to convert raw C.GstMpegtsComponentDescriptor pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeComponentDescriptorFromGlibFull is used to convert raw C.GstMpegtsComponentDescriptor pointers to go while taking ownership. This is used by the bindings internally. func UnsafeComponentDescriptorFromGlibFull(p unsafe.Pointer) *ComponentDescriptor { wrapped := UnsafeComponentDescriptorFromGlibBorrow(p) runtime.SetFinalizer( @@ -4631,6 +4657,7 @@ func UnsafeComponentDescriptorToGlibFull(c *ComponentDescriptor) unsafe.Pointer c.native = nil // ComponentDescriptor is invalid from here on return _p } + // Content wraps GstMpegtsContent type Content struct { *content @@ -4658,7 +4685,7 @@ func UnsafeContentFromGlibBorrow(p unsafe.Pointer) *Content { return &Content{&content{(*C.GstMpegtsContent)(p)}} } -// UnsafeContentFromGlibNone is used to convert raw C.GstMpegtsContent pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeContentFromGlibNone is used to convert raw C.GstMpegtsContent pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeContentFromGlibNone(p unsafe.Pointer) *Content { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeContentFromGlibBorrow(p) @@ -4671,7 +4698,7 @@ func UnsafeContentFromGlibNone(p unsafe.Pointer) *Content { return wrapped } -// UnsafeContentFromGlibFull is used to convert raw C.GstMpegtsContent pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeContentFromGlibFull is used to convert raw C.GstMpegtsContent pointers to go while taking ownership. This is used by the bindings internally. func UnsafeContentFromGlibFull(p unsafe.Pointer) *Content { wrapped := UnsafeContentFromGlibBorrow(p) runtime.SetFinalizer( @@ -4703,6 +4730,7 @@ func UnsafeContentToGlibFull(c *Content) unsafe.Pointer { c.native = nil // Content is invalid from here on return _p } + // DVBLinkageDescriptor wraps GstMpegtsDVBLinkageDescriptor type DVBLinkageDescriptor struct { *dvbLinkageDescriptor @@ -4730,7 +4758,7 @@ func UnsafeDVBLinkageDescriptorFromGlibBorrow(p unsafe.Pointer) *DVBLinkageDescr return &DVBLinkageDescriptor{&dvbLinkageDescriptor{(*C.GstMpegtsDVBLinkageDescriptor)(p)}} } -// UnsafeDVBLinkageDescriptorFromGlibNone is used to convert raw C.GstMpegtsDVBLinkageDescriptor pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeDVBLinkageDescriptorFromGlibNone is used to convert raw C.GstMpegtsDVBLinkageDescriptor pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeDVBLinkageDescriptorFromGlibNone(p unsafe.Pointer) *DVBLinkageDescriptor { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeDVBLinkageDescriptorFromGlibBorrow(p) @@ -4743,7 +4771,7 @@ func UnsafeDVBLinkageDescriptorFromGlibNone(p unsafe.Pointer) *DVBLinkageDescrip return wrapped } -// UnsafeDVBLinkageDescriptorFromGlibFull is used to convert raw C.GstMpegtsDVBLinkageDescriptor pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeDVBLinkageDescriptorFromGlibFull is used to convert raw C.GstMpegtsDVBLinkageDescriptor pointers to go while taking ownership. This is used by the bindings internally. func UnsafeDVBLinkageDescriptorFromGlibFull(p unsafe.Pointer) *DVBLinkageDescriptor { wrapped := UnsafeDVBLinkageDescriptorFromGlibBorrow(p) runtime.SetFinalizer( @@ -4775,7 +4803,9 @@ func UnsafeDVBLinkageDescriptorToGlibFull(d *DVBLinkageDescriptor) unsafe.Pointe d.native = nil // DVBLinkageDescriptor is invalid from here on return _p } + // GetEvent wraps gst_mpegts_dvb_linkage_descriptor_get_event +// // The function returns the following values: // // - goret *DVBLinkageEvent @@ -4796,6 +4826,7 @@ func (desc *DVBLinkageDescriptor) GetEvent() *DVBLinkageEvent { } // GetMobileHandOver wraps gst_mpegts_dvb_linkage_descriptor_get_mobile_hand_over +// // The function returns the following values: // // - goret *DVBLinkageMobileHandOver @@ -4842,7 +4873,7 @@ func UnsafeDVBLinkageEventFromGlibBorrow(p unsafe.Pointer) *DVBLinkageEvent { return &DVBLinkageEvent{&dvbLinkageEvent{(*C.GstMpegtsDVBLinkageEvent)(p)}} } -// UnsafeDVBLinkageEventFromGlibNone is used to convert raw C.GstMpegtsDVBLinkageEvent pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeDVBLinkageEventFromGlibNone is used to convert raw C.GstMpegtsDVBLinkageEvent pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeDVBLinkageEventFromGlibNone(p unsafe.Pointer) *DVBLinkageEvent { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeDVBLinkageEventFromGlibBorrow(p) @@ -4855,7 +4886,7 @@ func UnsafeDVBLinkageEventFromGlibNone(p unsafe.Pointer) *DVBLinkageEvent { return wrapped } -// UnsafeDVBLinkageEventFromGlibFull is used to convert raw C.GstMpegtsDVBLinkageEvent pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeDVBLinkageEventFromGlibFull is used to convert raw C.GstMpegtsDVBLinkageEvent pointers to go while taking ownership. This is used by the bindings internally. func UnsafeDVBLinkageEventFromGlibFull(p unsafe.Pointer) *DVBLinkageEvent { wrapped := UnsafeDVBLinkageEventFromGlibBorrow(p) runtime.SetFinalizer( @@ -4887,6 +4918,7 @@ func UnsafeDVBLinkageEventToGlibFull(d *DVBLinkageEvent) unsafe.Pointer { d.native = nil // DVBLinkageEvent is invalid from here on return _p } + // DVBLinkageExtendedEvent wraps GstMpegtsDVBLinkageExtendedEvent type DVBLinkageExtendedEvent struct { *dvbLinkageExtendedEvent @@ -4914,7 +4946,7 @@ func UnsafeDVBLinkageExtendedEventFromGlibBorrow(p unsafe.Pointer) *DVBLinkageEx return &DVBLinkageExtendedEvent{&dvbLinkageExtendedEvent{(*C.GstMpegtsDVBLinkageExtendedEvent)(p)}} } -// UnsafeDVBLinkageExtendedEventFromGlibNone is used to convert raw C.GstMpegtsDVBLinkageExtendedEvent pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeDVBLinkageExtendedEventFromGlibNone is used to convert raw C.GstMpegtsDVBLinkageExtendedEvent pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeDVBLinkageExtendedEventFromGlibNone(p unsafe.Pointer) *DVBLinkageExtendedEvent { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeDVBLinkageExtendedEventFromGlibBorrow(p) @@ -4927,7 +4959,7 @@ func UnsafeDVBLinkageExtendedEventFromGlibNone(p unsafe.Pointer) *DVBLinkageExte return wrapped } -// UnsafeDVBLinkageExtendedEventFromGlibFull is used to convert raw C.GstMpegtsDVBLinkageExtendedEvent pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeDVBLinkageExtendedEventFromGlibFull is used to convert raw C.GstMpegtsDVBLinkageExtendedEvent pointers to go while taking ownership. This is used by the bindings internally. func UnsafeDVBLinkageExtendedEventFromGlibFull(p unsafe.Pointer) *DVBLinkageExtendedEvent { wrapped := UnsafeDVBLinkageExtendedEventFromGlibBorrow(p) runtime.SetFinalizer( @@ -4959,6 +4991,7 @@ func UnsafeDVBLinkageExtendedEventToGlibFull(d *DVBLinkageExtendedEvent) unsafe. d.native = nil // DVBLinkageExtendedEvent is invalid from here on return _p } + // DVBLinkageMobileHandOver wraps GstMpegtsDVBLinkageMobileHandOver type DVBLinkageMobileHandOver struct { *dvbLinkageMobileHandOver @@ -4986,7 +5019,7 @@ func UnsafeDVBLinkageMobileHandOverFromGlibBorrow(p unsafe.Pointer) *DVBLinkageM return &DVBLinkageMobileHandOver{&dvbLinkageMobileHandOver{(*C.GstMpegtsDVBLinkageMobileHandOver)(p)}} } -// UnsafeDVBLinkageMobileHandOverFromGlibNone is used to convert raw C.GstMpegtsDVBLinkageMobileHandOver pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeDVBLinkageMobileHandOverFromGlibNone is used to convert raw C.GstMpegtsDVBLinkageMobileHandOver pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeDVBLinkageMobileHandOverFromGlibNone(p unsafe.Pointer) *DVBLinkageMobileHandOver { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeDVBLinkageMobileHandOverFromGlibBorrow(p) @@ -4999,7 +5032,7 @@ func UnsafeDVBLinkageMobileHandOverFromGlibNone(p unsafe.Pointer) *DVBLinkageMob return wrapped } -// UnsafeDVBLinkageMobileHandOverFromGlibFull is used to convert raw C.GstMpegtsDVBLinkageMobileHandOver pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeDVBLinkageMobileHandOverFromGlibFull is used to convert raw C.GstMpegtsDVBLinkageMobileHandOver pointers to go while taking ownership. This is used by the bindings internally. func UnsafeDVBLinkageMobileHandOverFromGlibFull(p unsafe.Pointer) *DVBLinkageMobileHandOver { wrapped := UnsafeDVBLinkageMobileHandOverFromGlibBorrow(p) runtime.SetFinalizer( @@ -5031,6 +5064,7 @@ func UnsafeDVBLinkageMobileHandOverToGlibFull(d *DVBLinkageMobileHandOver) unsaf d.native = nil // DVBLinkageMobileHandOver is invalid from here on return _p } + // DVBParentalRatingItem wraps GstMpegtsDVBParentalRatingItem type DVBParentalRatingItem struct { *dvbParentalRatingItem @@ -5058,7 +5092,7 @@ func UnsafeDVBParentalRatingItemFromGlibBorrow(p unsafe.Pointer) *DVBParentalRat return &DVBParentalRatingItem{&dvbParentalRatingItem{(*C.GstMpegtsDVBParentalRatingItem)(p)}} } -// UnsafeDVBParentalRatingItemFromGlibNone is used to convert raw C.GstMpegtsDVBParentalRatingItem pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeDVBParentalRatingItemFromGlibNone is used to convert raw C.GstMpegtsDVBParentalRatingItem pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeDVBParentalRatingItemFromGlibNone(p unsafe.Pointer) *DVBParentalRatingItem { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeDVBParentalRatingItemFromGlibBorrow(p) @@ -5071,7 +5105,7 @@ func UnsafeDVBParentalRatingItemFromGlibNone(p unsafe.Pointer) *DVBParentalRatin return wrapped } -// UnsafeDVBParentalRatingItemFromGlibFull is used to convert raw C.GstMpegtsDVBParentalRatingItem pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeDVBParentalRatingItemFromGlibFull is used to convert raw C.GstMpegtsDVBParentalRatingItem pointers to go while taking ownership. This is used by the bindings internally. func UnsafeDVBParentalRatingItemFromGlibFull(p unsafe.Pointer) *DVBParentalRatingItem { wrapped := UnsafeDVBParentalRatingItemFromGlibBorrow(p) runtime.SetFinalizer( @@ -5103,6 +5137,7 @@ func UnsafeDVBParentalRatingItemToGlibFull(d *DVBParentalRatingItem) unsafe.Poin d.native = nil // DVBParentalRatingItem is invalid from here on return _p } + // DVBServiceListItem wraps GstMpegtsDVBServiceListItem type DVBServiceListItem struct { *dvbServiceListItem @@ -5130,7 +5165,7 @@ func UnsafeDVBServiceListItemFromGlibBorrow(p unsafe.Pointer) *DVBServiceListIte return &DVBServiceListItem{&dvbServiceListItem{(*C.GstMpegtsDVBServiceListItem)(p)}} } -// UnsafeDVBServiceListItemFromGlibNone is used to convert raw C.GstMpegtsDVBServiceListItem pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeDVBServiceListItemFromGlibNone is used to convert raw C.GstMpegtsDVBServiceListItem pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeDVBServiceListItemFromGlibNone(p unsafe.Pointer) *DVBServiceListItem { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeDVBServiceListItemFromGlibBorrow(p) @@ -5143,7 +5178,7 @@ func UnsafeDVBServiceListItemFromGlibNone(p unsafe.Pointer) *DVBServiceListItem return wrapped } -// UnsafeDVBServiceListItemFromGlibFull is used to convert raw C.GstMpegtsDVBServiceListItem pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeDVBServiceListItemFromGlibFull is used to convert raw C.GstMpegtsDVBServiceListItem pointers to go while taking ownership. This is used by the bindings internally. func UnsafeDVBServiceListItemFromGlibFull(p unsafe.Pointer) *DVBServiceListItem { wrapped := UnsafeDVBServiceListItemFromGlibBorrow(p) runtime.SetFinalizer( @@ -5175,6 +5210,7 @@ func UnsafeDVBServiceListItemToGlibFull(d *DVBServiceListItem) unsafe.Pointer { d.native = nil // DVBServiceListItem is invalid from here on return _p } + // DataBroadcastDescriptor wraps GstMpegtsDataBroadcastDescriptor type DataBroadcastDescriptor struct { *dataBroadcastDescriptor @@ -5202,7 +5238,7 @@ func UnsafeDataBroadcastDescriptorFromGlibBorrow(p unsafe.Pointer) *DataBroadcas return &DataBroadcastDescriptor{&dataBroadcastDescriptor{(*C.GstMpegtsDataBroadcastDescriptor)(p)}} } -// UnsafeDataBroadcastDescriptorFromGlibNone is used to convert raw C.GstMpegtsDataBroadcastDescriptor pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeDataBroadcastDescriptorFromGlibNone is used to convert raw C.GstMpegtsDataBroadcastDescriptor pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeDataBroadcastDescriptorFromGlibNone(p unsafe.Pointer) *DataBroadcastDescriptor { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeDataBroadcastDescriptorFromGlibBorrow(p) @@ -5215,7 +5251,7 @@ func UnsafeDataBroadcastDescriptorFromGlibNone(p unsafe.Pointer) *DataBroadcastD return wrapped } -// UnsafeDataBroadcastDescriptorFromGlibFull is used to convert raw C.GstMpegtsDataBroadcastDescriptor pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeDataBroadcastDescriptorFromGlibFull is used to convert raw C.GstMpegtsDataBroadcastDescriptor pointers to go while taking ownership. This is used by the bindings internally. func UnsafeDataBroadcastDescriptorFromGlibFull(p unsafe.Pointer) *DataBroadcastDescriptor { wrapped := UnsafeDataBroadcastDescriptorFromGlibBorrow(p) runtime.SetFinalizer( @@ -5247,6 +5283,7 @@ func UnsafeDataBroadcastDescriptorToGlibFull(d *DataBroadcastDescriptor) unsafe. d.native = nil // DataBroadcastDescriptor is invalid from here on return _p } + // Descriptor wraps GstMpegtsDescriptor // // These are the base descriptor types and methods. @@ -5279,7 +5316,7 @@ func UnsafeDescriptorFromGlibBorrow(p unsafe.Pointer) *Descriptor { return &Descriptor{&descriptor{(*C.GstMpegtsDescriptor)(p)}} } -// UnsafeDescriptorFromGlibNone is used to convert raw C.GstMpegtsDescriptor pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeDescriptorFromGlibNone is used to convert raw C.GstMpegtsDescriptor pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeDescriptorFromGlibNone(p unsafe.Pointer) *Descriptor { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeDescriptorFromGlibBorrow(p) @@ -5292,7 +5329,7 @@ func UnsafeDescriptorFromGlibNone(p unsafe.Pointer) *Descriptor { return wrapped } -// UnsafeDescriptorFromGlibFull is used to convert raw C.GstMpegtsDescriptor pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeDescriptorFromGlibFull is used to convert raw C.GstMpegtsDescriptor pointers to go while taking ownership. This is used by the bindings internally. func UnsafeDescriptorFromGlibFull(p unsafe.Pointer) *Descriptor { wrapped := UnsafeDescriptorFromGlibBorrow(p) runtime.SetFinalizer( @@ -5324,6 +5361,7 @@ func UnsafeDescriptorToGlibFull(d *Descriptor) unsafe.Pointer { d.native = nil // Descriptor is invalid from here on return _p } + // DescriptorFromCustom wraps gst_mpegts_descriptor_from_custom // // The function takes the following parameters: @@ -5603,6 +5641,7 @@ func DescriptorParseAudioPreselectionFree(source *AudioPreselectionDescriptor) { } // ParseCableDeliverySystem wraps gst_mpegts_descriptor_parse_cable_delivery_system +// // The function returns the following values: // // - res CableDeliverySystemDescriptor: the #GstMpegtsCableDeliverySystemDescriptor to fill @@ -5633,6 +5672,7 @@ func (descriptor *Descriptor) ParseCableDeliverySystem() (CableDeliverySystemDes } // ParseDvbBouquetName wraps gst_mpegts_descriptor_parse_dvb_bouquet_name +// // The function returns the following values: // // - bouquetName string: the bouquet name @@ -5662,6 +5702,7 @@ func (descriptor *Descriptor) ParseDvbBouquetName() (string, bool) { } // ParseDvbComponent wraps gst_mpegts_descriptor_parse_dvb_component +// // The function returns the following values: // // - res *ComponentDescriptor: the #GstMpegtsComponentDescriptor to fill @@ -5690,6 +5731,7 @@ func (descriptor *Descriptor) ParseDvbComponent() (*ComponentDescriptor, bool) { } // ParseDvbDataBroadcast wraps gst_mpegts_descriptor_parse_dvb_data_broadcast +// // The function returns the following values: // // - res *DataBroadcastDescriptor: #GstMpegtsDataBroadcastDescriptor @@ -5718,6 +5760,7 @@ func (descriptor *Descriptor) ParseDvbDataBroadcast() (*DataBroadcastDescriptor, } // ParseDvbExtendedEvent wraps gst_mpegts_descriptor_parse_dvb_extended_event +// // The function returns the following values: // // - res *ExtendedEventDescriptor: the #GstMpegtsExtendedEventDescriptor to fill @@ -5746,6 +5789,7 @@ func (descriptor *Descriptor) ParseDvbExtendedEvent() (*ExtendedEventDescriptor, } // ParseDvbLinkage wraps gst_mpegts_descriptor_parse_dvb_linkage +// // The function returns the following values: // // - res *DVBLinkageDescriptor: the #GstMpegtsDVBLinkageDescriptor to fill @@ -5774,6 +5818,7 @@ func (descriptor *Descriptor) ParseDvbLinkage() (*DVBLinkageDescriptor, bool) { } // ParseDvbNetworkName wraps gst_mpegts_descriptor_parse_dvb_network_name +// // The function returns the following values: // // - name string: the extracted name @@ -5803,6 +5848,7 @@ func (descriptor *Descriptor) ParseDvbNetworkName() (string, bool) { } // ParseDvbScrambling wraps gst_mpegts_descriptor_parse_dvb_scrambling +// // The function returns the following values: // // - scramblingMode DVBScramblingModeType: This 8-bit field identifies the selected @@ -5835,6 +5881,7 @@ func (descriptor *Descriptor) ParseDvbScrambling() (DVBScramblingModeType, bool) } // ParseDvbService wraps gst_mpegts_descriptor_parse_dvb_service +// // The function returns the following values: // // - serviceType DVBServiceType: the service type @@ -5873,6 +5920,7 @@ func (descriptor *Descriptor) ParseDvbService() (DVBServiceType, string, string, } // ParseDvbShortEvent wraps gst_mpegts_descriptor_parse_dvb_short_event +// // The function returns the following values: // // - languageCode string: the language code @@ -5912,6 +5960,7 @@ func (descriptor *Descriptor) ParseDvbShortEvent() (string, string, string, bool } // ParseDvbStreamIdentifier wraps gst_mpegts_descriptor_parse_dvb_stream_identifier +// // The function returns the following values: // // - componentTag uint8: the component tag @@ -5940,6 +5989,7 @@ func (descriptor *Descriptor) ParseDvbStreamIdentifier() (uint8, bool) { } // ParseDvbStuffing wraps gst_mpegts_descriptor_parse_dvb_stuffing +// // The function returns the following values: // // - stuffingBytes *uint8: the stuffing bytes @@ -6022,6 +6072,7 @@ func (descriptor *Descriptor) ParseDvbSubtitlingIdx(idx uint) (string, uint8, ui } // ParseDvbSubtitlingNb wraps gst_mpegts_descriptor_parse_dvb_subtitling_nb +// // The function returns the following values: // // - goret uint @@ -6042,6 +6093,7 @@ func (descriptor *Descriptor) ParseDvbSubtitlingNb() uint { } // ParseDvbT2DeliverySystem wraps gst_mpegts_descriptor_parse_dvb_t2_delivery_system +// // The function returns the following values: // // - res *T2DeliverySystemDescriptor: #GstMpegtsT2DeliverySystemDescriptor @@ -6119,6 +6171,7 @@ func (descriptor *Descriptor) ParseDvbTeletextIdx(idx uint) (string, DVBTeletext } // ParseDvbTeletextNb wraps gst_mpegts_descriptor_parse_dvb_teletext_nb +// // The function returns the following values: // // - goret uint @@ -6141,6 +6194,7 @@ func (descriptor *Descriptor) ParseDvbTeletextNb() uint { } // ParseISO639Language wraps gst_mpegts_descriptor_parse_iso_639_language +// // The function returns the following values: // // - res *ISO639LanguageDescriptor: the #GstMpegtsISO639LanguageDescriptor to fill @@ -6216,6 +6270,7 @@ func (descriptor *Descriptor) ParseISO639LanguageIdx(idx uint) (string, ISO639Au } // ParseISO639LanguageNb wraps gst_mpegts_descriptor_parse_iso_639_language_nb +// // The function returns the following values: // // - goret uint @@ -6236,6 +6291,7 @@ func (descriptor *Descriptor) ParseISO639LanguageNb() uint { } // ParseLogicalChannel wraps gst_mpegts_descriptor_parse_logical_channel +// // The function returns the following values: // // - res LogicalChannelDescriptor: the #GstMpegtsLogicalChannelDescriptor to fill @@ -6266,6 +6322,7 @@ func (descriptor *Descriptor) ParseLogicalChannel() (LogicalChannelDescriptor, b } // ParseMetadata wraps gst_mpegts_descriptor_parse_metadata +// // The function returns the following values: // // - res *MetadataDescriptor: #GstMpegtsMetadataDescriptor @@ -6346,6 +6403,7 @@ func (descriptor *Descriptor) ParseMetadataStd(metadataInputLeakRate *uint32, me } // ParseSatelliteDeliverySystem wraps gst_mpegts_descriptor_parse_satellite_delivery_system +// // The function returns the following values: // // - res SatelliteDeliverySystemDescriptor: the #GstMpegtsSatelliteDeliverySystemDescriptor to fill @@ -6376,6 +6434,7 @@ func (descriptor *Descriptor) ParseSatelliteDeliverySystem() (SatelliteDeliveryS } // ParseTerrestrialDeliverySystem wraps gst_mpegts_descriptor_parse_terrestrial_delivery_system +// // The function returns the following values: // // - res TerrestrialDeliverySystemDescriptor: #GstMpegtsTerrestrialDeliverySystemDescriptor @@ -6434,7 +6493,7 @@ func UnsafeDvbMultilingualBouquetNameItemFromGlibBorrow(p unsafe.Pointer) *DvbMu return &DvbMultilingualBouquetNameItem{&dvbMultilingualBouquetNameItem{(*C.GstMpegtsDvbMultilingualBouquetNameItem)(p)}} } -// UnsafeDvbMultilingualBouquetNameItemFromGlibNone is used to convert raw C.GstMpegtsDvbMultilingualBouquetNameItem pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeDvbMultilingualBouquetNameItemFromGlibNone is used to convert raw C.GstMpegtsDvbMultilingualBouquetNameItem pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeDvbMultilingualBouquetNameItemFromGlibNone(p unsafe.Pointer) *DvbMultilingualBouquetNameItem { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeDvbMultilingualBouquetNameItemFromGlibBorrow(p) @@ -6447,7 +6506,7 @@ func UnsafeDvbMultilingualBouquetNameItemFromGlibNone(p unsafe.Pointer) *DvbMult return wrapped } -// UnsafeDvbMultilingualBouquetNameItemFromGlibFull is used to convert raw C.GstMpegtsDvbMultilingualBouquetNameItem pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeDvbMultilingualBouquetNameItemFromGlibFull is used to convert raw C.GstMpegtsDvbMultilingualBouquetNameItem pointers to go while taking ownership. This is used by the bindings internally. func UnsafeDvbMultilingualBouquetNameItemFromGlibFull(p unsafe.Pointer) *DvbMultilingualBouquetNameItem { wrapped := UnsafeDvbMultilingualBouquetNameItemFromGlibBorrow(p) runtime.SetFinalizer( @@ -6479,6 +6538,7 @@ func UnsafeDvbMultilingualBouquetNameItemToGlibFull(d *DvbMultilingualBouquetNam d.native = nil // DvbMultilingualBouquetNameItem is invalid from here on return _p } + // DvbMultilingualComponentItem wraps GstMpegtsDvbMultilingualComponentItem type DvbMultilingualComponentItem struct { *dvbMultilingualComponentItem @@ -6506,7 +6566,7 @@ func UnsafeDvbMultilingualComponentItemFromGlibBorrow(p unsafe.Pointer) *DvbMult return &DvbMultilingualComponentItem{&dvbMultilingualComponentItem{(*C.GstMpegtsDvbMultilingualComponentItem)(p)}} } -// UnsafeDvbMultilingualComponentItemFromGlibNone is used to convert raw C.GstMpegtsDvbMultilingualComponentItem pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeDvbMultilingualComponentItemFromGlibNone is used to convert raw C.GstMpegtsDvbMultilingualComponentItem pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeDvbMultilingualComponentItemFromGlibNone(p unsafe.Pointer) *DvbMultilingualComponentItem { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeDvbMultilingualComponentItemFromGlibBorrow(p) @@ -6519,7 +6579,7 @@ func UnsafeDvbMultilingualComponentItemFromGlibNone(p unsafe.Pointer) *DvbMultil return wrapped } -// UnsafeDvbMultilingualComponentItemFromGlibFull is used to convert raw C.GstMpegtsDvbMultilingualComponentItem pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeDvbMultilingualComponentItemFromGlibFull is used to convert raw C.GstMpegtsDvbMultilingualComponentItem pointers to go while taking ownership. This is used by the bindings internally. func UnsafeDvbMultilingualComponentItemFromGlibFull(p unsafe.Pointer) *DvbMultilingualComponentItem { wrapped := UnsafeDvbMultilingualComponentItemFromGlibBorrow(p) runtime.SetFinalizer( @@ -6551,6 +6611,7 @@ func UnsafeDvbMultilingualComponentItemToGlibFull(d *DvbMultilingualComponentIte d.native = nil // DvbMultilingualComponentItem is invalid from here on return _p } + // DvbMultilingualNetworkNameItem wraps GstMpegtsDvbMultilingualNetworkNameItem // // a multilingual network name entry @@ -6580,7 +6641,7 @@ func UnsafeDvbMultilingualNetworkNameItemFromGlibBorrow(p unsafe.Pointer) *DvbMu return &DvbMultilingualNetworkNameItem{&dvbMultilingualNetworkNameItem{(*C.GstMpegtsDvbMultilingualNetworkNameItem)(p)}} } -// UnsafeDvbMultilingualNetworkNameItemFromGlibNone is used to convert raw C.GstMpegtsDvbMultilingualNetworkNameItem pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeDvbMultilingualNetworkNameItemFromGlibNone is used to convert raw C.GstMpegtsDvbMultilingualNetworkNameItem pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeDvbMultilingualNetworkNameItemFromGlibNone(p unsafe.Pointer) *DvbMultilingualNetworkNameItem { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeDvbMultilingualNetworkNameItemFromGlibBorrow(p) @@ -6593,7 +6654,7 @@ func UnsafeDvbMultilingualNetworkNameItemFromGlibNone(p unsafe.Pointer) *DvbMult return wrapped } -// UnsafeDvbMultilingualNetworkNameItemFromGlibFull is used to convert raw C.GstMpegtsDvbMultilingualNetworkNameItem pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeDvbMultilingualNetworkNameItemFromGlibFull is used to convert raw C.GstMpegtsDvbMultilingualNetworkNameItem pointers to go while taking ownership. This is used by the bindings internally. func UnsafeDvbMultilingualNetworkNameItemFromGlibFull(p unsafe.Pointer) *DvbMultilingualNetworkNameItem { wrapped := UnsafeDvbMultilingualNetworkNameItemFromGlibBorrow(p) runtime.SetFinalizer( @@ -6625,6 +6686,7 @@ func UnsafeDvbMultilingualNetworkNameItemToGlibFull(d *DvbMultilingualNetworkNam d.native = nil // DvbMultilingualNetworkNameItem is invalid from here on return _p } + // DvbMultilingualServiceNameItem wraps GstMpegtsDvbMultilingualServiceNameItem // // a multilingual service name entry @@ -6654,7 +6716,7 @@ func UnsafeDvbMultilingualServiceNameItemFromGlibBorrow(p unsafe.Pointer) *DvbMu return &DvbMultilingualServiceNameItem{&dvbMultilingualServiceNameItem{(*C.GstMpegtsDvbMultilingualServiceNameItem)(p)}} } -// UnsafeDvbMultilingualServiceNameItemFromGlibNone is used to convert raw C.GstMpegtsDvbMultilingualServiceNameItem pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeDvbMultilingualServiceNameItemFromGlibNone is used to convert raw C.GstMpegtsDvbMultilingualServiceNameItem pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeDvbMultilingualServiceNameItemFromGlibNone(p unsafe.Pointer) *DvbMultilingualServiceNameItem { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeDvbMultilingualServiceNameItemFromGlibBorrow(p) @@ -6667,7 +6729,7 @@ func UnsafeDvbMultilingualServiceNameItemFromGlibNone(p unsafe.Pointer) *DvbMult return wrapped } -// UnsafeDvbMultilingualServiceNameItemFromGlibFull is used to convert raw C.GstMpegtsDvbMultilingualServiceNameItem pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeDvbMultilingualServiceNameItemFromGlibFull is used to convert raw C.GstMpegtsDvbMultilingualServiceNameItem pointers to go while taking ownership. This is used by the bindings internally. func UnsafeDvbMultilingualServiceNameItemFromGlibFull(p unsafe.Pointer) *DvbMultilingualServiceNameItem { wrapped := UnsafeDvbMultilingualServiceNameItemFromGlibBorrow(p) runtime.SetFinalizer( @@ -6699,6 +6761,7 @@ func UnsafeDvbMultilingualServiceNameItemToGlibFull(d *DvbMultilingualServiceNam d.native = nil // DvbMultilingualServiceNameItem is invalid from here on return _p } + // EIT wraps GstMpegtsEIT // // Event Information Table (EN 300 468) @@ -6728,7 +6791,7 @@ func UnsafeEITFromGlibBorrow(p unsafe.Pointer) *EIT { return &EIT{&eiT{(*C.GstMpegtsEIT)(p)}} } -// UnsafeEITFromGlibNone is used to convert raw C.GstMpegtsEIT pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeEITFromGlibNone is used to convert raw C.GstMpegtsEIT pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeEITFromGlibNone(p unsafe.Pointer) *EIT { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeEITFromGlibBorrow(p) @@ -6741,7 +6804,7 @@ func UnsafeEITFromGlibNone(p unsafe.Pointer) *EIT { return wrapped } -// UnsafeEITFromGlibFull is used to convert raw C.GstMpegtsEIT pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeEITFromGlibFull is used to convert raw C.GstMpegtsEIT pointers to go while taking ownership. This is used by the bindings internally. func UnsafeEITFromGlibFull(p unsafe.Pointer) *EIT { wrapped := UnsafeEITFromGlibBorrow(p) runtime.SetFinalizer( @@ -6773,6 +6836,7 @@ func UnsafeEITToGlibFull(e *EIT) unsafe.Pointer { e.native = nil // EIT is invalid from here on return _p } + // EITEvent wraps GstMpegtsEITEvent // // Event from a @GstMpegtsEIT @@ -6802,7 +6866,7 @@ func UnsafeEITEventFromGlibBorrow(p unsafe.Pointer) *EITEvent { return &EITEvent{&eitEvent{(*C.GstMpegtsEITEvent)(p)}} } -// UnsafeEITEventFromGlibNone is used to convert raw C.GstMpegtsEITEvent pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeEITEventFromGlibNone is used to convert raw C.GstMpegtsEITEvent pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeEITEventFromGlibNone(p unsafe.Pointer) *EITEvent { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeEITEventFromGlibBorrow(p) @@ -6815,7 +6879,7 @@ func UnsafeEITEventFromGlibNone(p unsafe.Pointer) *EITEvent { return wrapped } -// UnsafeEITEventFromGlibFull is used to convert raw C.GstMpegtsEITEvent pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeEITEventFromGlibFull is used to convert raw C.GstMpegtsEITEvent pointers to go while taking ownership. This is used by the bindings internally. func UnsafeEITEventFromGlibFull(p unsafe.Pointer) *EITEvent { wrapped := UnsafeEITEventFromGlibBorrow(p) runtime.SetFinalizer( @@ -6847,6 +6911,7 @@ func UnsafeEITEventToGlibFull(e *EITEvent) unsafe.Pointer { e.native = nil // EITEvent is invalid from here on return _p } + // ExtendedEventDescriptor wraps GstMpegtsExtendedEventDescriptor // // Extended Event Descriptor (EN 300 468 v.1.13.1) @@ -6876,7 +6941,7 @@ func UnsafeExtendedEventDescriptorFromGlibBorrow(p unsafe.Pointer) *ExtendedEven return &ExtendedEventDescriptor{&extendedEventDescriptor{(*C.GstMpegtsExtendedEventDescriptor)(p)}} } -// UnsafeExtendedEventDescriptorFromGlibNone is used to convert raw C.GstMpegtsExtendedEventDescriptor pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeExtendedEventDescriptorFromGlibNone is used to convert raw C.GstMpegtsExtendedEventDescriptor pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeExtendedEventDescriptorFromGlibNone(p unsafe.Pointer) *ExtendedEventDescriptor { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeExtendedEventDescriptorFromGlibBorrow(p) @@ -6889,7 +6954,7 @@ func UnsafeExtendedEventDescriptorFromGlibNone(p unsafe.Pointer) *ExtendedEventD return wrapped } -// UnsafeExtendedEventDescriptorFromGlibFull is used to convert raw C.GstMpegtsExtendedEventDescriptor pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeExtendedEventDescriptorFromGlibFull is used to convert raw C.GstMpegtsExtendedEventDescriptor pointers to go while taking ownership. This is used by the bindings internally. func UnsafeExtendedEventDescriptorFromGlibFull(p unsafe.Pointer) *ExtendedEventDescriptor { wrapped := UnsafeExtendedEventDescriptorFromGlibBorrow(p) runtime.SetFinalizer( @@ -6921,6 +6986,7 @@ func UnsafeExtendedEventDescriptorToGlibFull(e *ExtendedEventDescriptor) unsafe. e.native = nil // ExtendedEventDescriptor is invalid from here on return _p } + // ExtendedEventItem wraps GstMpegtsExtendedEventItem type ExtendedEventItem struct { *extendedEventItem @@ -6948,7 +7014,7 @@ func UnsafeExtendedEventItemFromGlibBorrow(p unsafe.Pointer) *ExtendedEventItem return &ExtendedEventItem{&extendedEventItem{(*C.GstMpegtsExtendedEventItem)(p)}} } -// UnsafeExtendedEventItemFromGlibNone is used to convert raw C.GstMpegtsExtendedEventItem pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeExtendedEventItemFromGlibNone is used to convert raw C.GstMpegtsExtendedEventItem pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeExtendedEventItemFromGlibNone(p unsafe.Pointer) *ExtendedEventItem { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeExtendedEventItemFromGlibBorrow(p) @@ -6961,7 +7027,7 @@ func UnsafeExtendedEventItemFromGlibNone(p unsafe.Pointer) *ExtendedEventItem { return wrapped } -// UnsafeExtendedEventItemFromGlibFull is used to convert raw C.GstMpegtsExtendedEventItem pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeExtendedEventItemFromGlibFull is used to convert raw C.GstMpegtsExtendedEventItem pointers to go while taking ownership. This is used by the bindings internally. func UnsafeExtendedEventItemFromGlibFull(p unsafe.Pointer) *ExtendedEventItem { wrapped := UnsafeExtendedEventItemFromGlibBorrow(p) runtime.SetFinalizer( @@ -6993,6 +7059,7 @@ func UnsafeExtendedEventItemToGlibFull(e *ExtendedEventItem) unsafe.Pointer { e.native = nil // ExtendedEventItem is invalid from here on return _p } + // ISO639LanguageDescriptor wraps GstMpegtsISO639LanguageDescriptor type ISO639LanguageDescriptor struct { *isO639LanguageDescriptor @@ -7020,7 +7087,7 @@ func UnsafeISO639LanguageDescriptorFromGlibBorrow(p unsafe.Pointer) *ISO639Langu return &ISO639LanguageDescriptor{&isO639LanguageDescriptor{(*C.GstMpegtsISO639LanguageDescriptor)(p)}} } -// UnsafeISO639LanguageDescriptorFromGlibNone is used to convert raw C.GstMpegtsISO639LanguageDescriptor pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeISO639LanguageDescriptorFromGlibNone is used to convert raw C.GstMpegtsISO639LanguageDescriptor pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeISO639LanguageDescriptorFromGlibNone(p unsafe.Pointer) *ISO639LanguageDescriptor { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeISO639LanguageDescriptorFromGlibBorrow(p) @@ -7033,7 +7100,7 @@ func UnsafeISO639LanguageDescriptorFromGlibNone(p unsafe.Pointer) *ISO639Languag return wrapped } -// UnsafeISO639LanguageDescriptorFromGlibFull is used to convert raw C.GstMpegtsISO639LanguageDescriptor pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeISO639LanguageDescriptorFromGlibFull is used to convert raw C.GstMpegtsISO639LanguageDescriptor pointers to go while taking ownership. This is used by the bindings internally. func UnsafeISO639LanguageDescriptorFromGlibFull(p unsafe.Pointer) *ISO639LanguageDescriptor { wrapped := UnsafeISO639LanguageDescriptorFromGlibBorrow(p) runtime.SetFinalizer( @@ -7065,6 +7132,7 @@ func UnsafeISO639LanguageDescriptorToGlibFull(i *ISO639LanguageDescriptor) unsaf i.native = nil // ISO639LanguageDescriptor is invalid from here on return _p } + // DescriptorFree wraps gst_mpegts_iso_639_language_descriptor_free func (desc *ISO639LanguageDescriptor) DescriptorFree() { var carg0 *C.GstMpegtsISO639LanguageDescriptor // in, none, converted @@ -7102,7 +7170,7 @@ func UnsafeLogicalChannelFromGlibBorrow(p unsafe.Pointer) *LogicalChannel { return &LogicalChannel{&logicalChannel{(*C.GstMpegtsLogicalChannel)(p)}} } -// UnsafeLogicalChannelFromGlibNone is used to convert raw C.GstMpegtsLogicalChannel pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeLogicalChannelFromGlibNone is used to convert raw C.GstMpegtsLogicalChannel pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeLogicalChannelFromGlibNone(p unsafe.Pointer) *LogicalChannel { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeLogicalChannelFromGlibBorrow(p) @@ -7115,7 +7183,7 @@ func UnsafeLogicalChannelFromGlibNone(p unsafe.Pointer) *LogicalChannel { return wrapped } -// UnsafeLogicalChannelFromGlibFull is used to convert raw C.GstMpegtsLogicalChannel pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeLogicalChannelFromGlibFull is used to convert raw C.GstMpegtsLogicalChannel pointers to go while taking ownership. This is used by the bindings internally. func UnsafeLogicalChannelFromGlibFull(p unsafe.Pointer) *LogicalChannel { wrapped := UnsafeLogicalChannelFromGlibBorrow(p) runtime.SetFinalizer( @@ -7147,6 +7215,7 @@ func UnsafeLogicalChannelToGlibFull(l *LogicalChannel) unsafe.Pointer { l.native = nil // LogicalChannel is invalid from here on return _p } + // LogicalChannelDescriptor wraps GstMpegtsLogicalChannelDescriptor type LogicalChannelDescriptor struct { *logicalChannelDescriptor @@ -7174,7 +7243,7 @@ func UnsafeLogicalChannelDescriptorFromGlibBorrow(p unsafe.Pointer) *LogicalChan return &LogicalChannelDescriptor{&logicalChannelDescriptor{(*C.GstMpegtsLogicalChannelDescriptor)(p)}} } -// UnsafeLogicalChannelDescriptorFromGlibNone is used to convert raw C.GstMpegtsLogicalChannelDescriptor pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeLogicalChannelDescriptorFromGlibNone is used to convert raw C.GstMpegtsLogicalChannelDescriptor pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeLogicalChannelDescriptorFromGlibNone(p unsafe.Pointer) *LogicalChannelDescriptor { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeLogicalChannelDescriptorFromGlibBorrow(p) @@ -7187,7 +7256,7 @@ func UnsafeLogicalChannelDescriptorFromGlibNone(p unsafe.Pointer) *LogicalChanne return wrapped } -// UnsafeLogicalChannelDescriptorFromGlibFull is used to convert raw C.GstMpegtsLogicalChannelDescriptor pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeLogicalChannelDescriptorFromGlibFull is used to convert raw C.GstMpegtsLogicalChannelDescriptor pointers to go while taking ownership. This is used by the bindings internally. func UnsafeLogicalChannelDescriptorFromGlibFull(p unsafe.Pointer) *LogicalChannelDescriptor { wrapped := UnsafeLogicalChannelDescriptorFromGlibBorrow(p) runtime.SetFinalizer( @@ -7219,6 +7288,7 @@ func UnsafeLogicalChannelDescriptorToGlibFull(l *LogicalChannelDescriptor) unsaf l.native = nil // LogicalChannelDescriptor is invalid from here on return _p } + // MetadataDescriptor wraps GstMpegtsMetadataDescriptor // // The metadata descriptor specifies parameters of a metadata service carried in an MPEG-2 Transport Stream (or Program Stream). The descriptor is included in the PMT in the descriptor loop for the elementary stream that carries the @@ -7253,7 +7323,7 @@ func UnsafeMetadataDescriptorFromGlibBorrow(p unsafe.Pointer) *MetadataDescripto return &MetadataDescriptor{&metadataDescriptor{(*C.GstMpegtsMetadataDescriptor)(p)}} } -// UnsafeMetadataDescriptorFromGlibNone is used to convert raw C.GstMpegtsMetadataDescriptor pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeMetadataDescriptorFromGlibNone is used to convert raw C.GstMpegtsMetadataDescriptor pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeMetadataDescriptorFromGlibNone(p unsafe.Pointer) *MetadataDescriptor { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeMetadataDescriptorFromGlibBorrow(p) @@ -7266,7 +7336,7 @@ func UnsafeMetadataDescriptorFromGlibNone(p unsafe.Pointer) *MetadataDescriptor return wrapped } -// UnsafeMetadataDescriptorFromGlibFull is used to convert raw C.GstMpegtsMetadataDescriptor pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeMetadataDescriptorFromGlibFull is used to convert raw C.GstMpegtsMetadataDescriptor pointers to go while taking ownership. This is used by the bindings internally. func UnsafeMetadataDescriptorFromGlibFull(p unsafe.Pointer) *MetadataDescriptor { wrapped := UnsafeMetadataDescriptorFromGlibBorrow(p) runtime.SetFinalizer( @@ -7298,6 +7368,7 @@ func UnsafeMetadataDescriptorToGlibFull(m *MetadataDescriptor) unsafe.Pointer { m.native = nil // MetadataDescriptor is invalid from here on return _p } + // NIT wraps GstMpegtsNIT // // Network Information Table (ISO/IEC 13818-1 / EN 300 468) @@ -7327,7 +7398,7 @@ func UnsafeNITFromGlibBorrow(p unsafe.Pointer) *NIT { return &NIT{&niT{(*C.GstMpegtsNIT)(p)}} } -// UnsafeNITFromGlibNone is used to convert raw C.GstMpegtsNIT pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeNITFromGlibNone is used to convert raw C.GstMpegtsNIT pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeNITFromGlibNone(p unsafe.Pointer) *NIT { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeNITFromGlibBorrow(p) @@ -7340,7 +7411,7 @@ func UnsafeNITFromGlibNone(p unsafe.Pointer) *NIT { return wrapped } -// UnsafeNITFromGlibFull is used to convert raw C.GstMpegtsNIT pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeNITFromGlibFull is used to convert raw C.GstMpegtsNIT pointers to go while taking ownership. This is used by the bindings internally. func UnsafeNITFromGlibFull(p unsafe.Pointer) *NIT { wrapped := UnsafeNITFromGlibBorrow(p) runtime.SetFinalizer( @@ -7372,7 +7443,9 @@ func UnsafeNITToGlibFull(n *NIT) unsafe.Pointer { n.native = nil // NIT is invalid from here on return _p } + // NewNIT wraps gst_mpegts_nit_new +// // The function returns the following values: // // - goret *NIT @@ -7417,7 +7490,7 @@ func UnsafeNITStreamFromGlibBorrow(p unsafe.Pointer) *NITStream { return &NITStream{&nitStream{(*C.GstMpegtsNITStream)(p)}} } -// UnsafeNITStreamFromGlibNone is used to convert raw C.GstMpegtsNITStream pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeNITStreamFromGlibNone is used to convert raw C.GstMpegtsNITStream pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeNITStreamFromGlibNone(p unsafe.Pointer) *NITStream { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeNITStreamFromGlibBorrow(p) @@ -7430,7 +7503,7 @@ func UnsafeNITStreamFromGlibNone(p unsafe.Pointer) *NITStream { return wrapped } -// UnsafeNITStreamFromGlibFull is used to convert raw C.GstMpegtsNITStream pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeNITStreamFromGlibFull is used to convert raw C.GstMpegtsNITStream pointers to go while taking ownership. This is used by the bindings internally. func UnsafeNITStreamFromGlibFull(p unsafe.Pointer) *NITStream { wrapped := UnsafeNITStreamFromGlibBorrow(p) runtime.SetFinalizer( @@ -7462,7 +7535,9 @@ func UnsafeNITStreamToGlibFull(n *NITStream) unsafe.Pointer { n.native = nil // NITStream is invalid from here on return _p } + // NewNITStream wraps gst_mpegts_nit_stream_new +// // The function returns the following values: // // - goret *NITStream @@ -7501,7 +7576,7 @@ func UnsafePESMetadataMetaFromGlibBorrow(p unsafe.Pointer) *PESMetadataMeta { return &PESMetadataMeta{&pesMetadataMeta{(*C.GstMpegtsPESMetadataMeta)(p)}} } -// UnsafePESMetadataMetaFromGlibNone is used to convert raw C.GstMpegtsPESMetadataMeta pointers to go while taking a reference. This is used by the bindings internally. +// UnsafePESMetadataMetaFromGlibNone is used to convert raw C.GstMpegtsPESMetadataMeta pointers to go without transferring ownership. This is used by the bindings internally. func UnsafePESMetadataMetaFromGlibNone(p unsafe.Pointer) *PESMetadataMeta { // FIXME: this has no ref function, what should we do here? wrapped := UnsafePESMetadataMetaFromGlibBorrow(p) @@ -7514,7 +7589,7 @@ func UnsafePESMetadataMetaFromGlibNone(p unsafe.Pointer) *PESMetadataMeta { return wrapped } -// UnsafePESMetadataMetaFromGlibFull is used to convert raw C.GstMpegtsPESMetadataMeta pointers to go while taking a reference. This is used by the bindings internally. +// UnsafePESMetadataMetaFromGlibFull is used to convert raw C.GstMpegtsPESMetadataMeta pointers to go while taking ownership. This is used by the bindings internally. func UnsafePESMetadataMetaFromGlibFull(p unsafe.Pointer) *PESMetadataMeta { wrapped := UnsafePESMetadataMetaFromGlibBorrow(p) runtime.SetFinalizer( @@ -7546,7 +7621,9 @@ func UnsafePESMetadataMetaToGlibFull(p *PESMetadataMeta) unsafe.Pointer { p.native = nil // PESMetadataMeta is invalid from here on return _p } + // PESMetadataMetaGetInfo wraps gst_mpegts_pes_metadata_meta_get_info +// // The function returns the following values: // // - goret *gst.MetaInfo @@ -7597,7 +7674,7 @@ func UnsafePMTFromGlibBorrow(p unsafe.Pointer) *PMT { return &PMT{&pmT{(*C.GstMpegtsPMT)(p)}} } -// UnsafePMTFromGlibNone is used to convert raw C.GstMpegtsPMT pointers to go while taking a reference. This is used by the bindings internally. +// UnsafePMTFromGlibNone is used to convert raw C.GstMpegtsPMT pointers to go without transferring ownership. This is used by the bindings internally. func UnsafePMTFromGlibNone(p unsafe.Pointer) *PMT { // FIXME: this has no ref function, what should we do here? wrapped := UnsafePMTFromGlibBorrow(p) @@ -7610,7 +7687,7 @@ func UnsafePMTFromGlibNone(p unsafe.Pointer) *PMT { return wrapped } -// UnsafePMTFromGlibFull is used to convert raw C.GstMpegtsPMT pointers to go while taking a reference. This is used by the bindings internally. +// UnsafePMTFromGlibFull is used to convert raw C.GstMpegtsPMT pointers to go while taking ownership. This is used by the bindings internally. func UnsafePMTFromGlibFull(p unsafe.Pointer) *PMT { wrapped := UnsafePMTFromGlibBorrow(p) runtime.SetFinalizer( @@ -7642,7 +7719,9 @@ func UnsafePMTToGlibFull(p *PMT) unsafe.Pointer { p.native = nil // PMT is invalid from here on return _p } + // NewPMT wraps gst_mpegts_pmt_new +// // The function returns the following values: // // - goret *PMT @@ -7691,7 +7770,7 @@ func UnsafePMTStreamFromGlibBorrow(p unsafe.Pointer) *PMTStream { return &PMTStream{&pmtStream{(*C.GstMpegtsPMTStream)(p)}} } -// UnsafePMTStreamFromGlibNone is used to convert raw C.GstMpegtsPMTStream pointers to go while taking a reference. This is used by the bindings internally. +// UnsafePMTStreamFromGlibNone is used to convert raw C.GstMpegtsPMTStream pointers to go without transferring ownership. This is used by the bindings internally. func UnsafePMTStreamFromGlibNone(p unsafe.Pointer) *PMTStream { // FIXME: this has no ref function, what should we do here? wrapped := UnsafePMTStreamFromGlibBorrow(p) @@ -7704,7 +7783,7 @@ func UnsafePMTStreamFromGlibNone(p unsafe.Pointer) *PMTStream { return wrapped } -// UnsafePMTStreamFromGlibFull is used to convert raw C.GstMpegtsPMTStream pointers to go while taking a reference. This is used by the bindings internally. +// UnsafePMTStreamFromGlibFull is used to convert raw C.GstMpegtsPMTStream pointers to go while taking ownership. This is used by the bindings internally. func UnsafePMTStreamFromGlibFull(p unsafe.Pointer) *PMTStream { wrapped := UnsafePMTStreamFromGlibBorrow(p) runtime.SetFinalizer( @@ -7736,7 +7815,9 @@ func UnsafePMTStreamToGlibFull(p *PMTStream) unsafe.Pointer { p.native = nil // PMTStream is invalid from here on return _p } + // NewPMTStream wraps gst_mpegts_pmt_stream_new +// // The function returns the following values: // // - goret *PMTStream @@ -7783,7 +7864,7 @@ func UnsafePatProgramFromGlibBorrow(p unsafe.Pointer) *PatProgram { return &PatProgram{&patProgram{(*C.GstMpegtsPatProgram)(p)}} } -// UnsafePatProgramFromGlibNone is used to convert raw C.GstMpegtsPatProgram pointers to go while taking a reference. This is used by the bindings internally. +// UnsafePatProgramFromGlibNone is used to convert raw C.GstMpegtsPatProgram pointers to go without transferring ownership. This is used by the bindings internally. func UnsafePatProgramFromGlibNone(p unsafe.Pointer) *PatProgram { // FIXME: this has no ref function, what should we do here? wrapped := UnsafePatProgramFromGlibBorrow(p) @@ -7796,7 +7877,7 @@ func UnsafePatProgramFromGlibNone(p unsafe.Pointer) *PatProgram { return wrapped } -// UnsafePatProgramFromGlibFull is used to convert raw C.GstMpegtsPatProgram pointers to go while taking a reference. This is used by the bindings internally. +// UnsafePatProgramFromGlibFull is used to convert raw C.GstMpegtsPatProgram pointers to go while taking ownership. This is used by the bindings internally. func UnsafePatProgramFromGlibFull(p unsafe.Pointer) *PatProgram { wrapped := UnsafePatProgramFromGlibBorrow(p) runtime.SetFinalizer( @@ -7828,7 +7909,9 @@ func UnsafePatProgramToGlibFull(p *PatProgram) unsafe.Pointer { p.native = nil // PatProgram is invalid from here on return _p } + // NewPatProgram wraps gst_mpegts_pat_program_new +// // The function returns the following values: // // - goret *PatProgram @@ -7873,7 +7956,7 @@ func UnsafeSCTESITFromGlibBorrow(p unsafe.Pointer) *SCTESIT { return &SCTESIT{&sctesiT{(*C.GstMpegtsSCTESIT)(p)}} } -// UnsafeSCTESITFromGlibNone is used to convert raw C.GstMpegtsSCTESIT pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeSCTESITFromGlibNone is used to convert raw C.GstMpegtsSCTESIT pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeSCTESITFromGlibNone(p unsafe.Pointer) *SCTESIT { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeSCTESITFromGlibBorrow(p) @@ -7886,7 +7969,7 @@ func UnsafeSCTESITFromGlibNone(p unsafe.Pointer) *SCTESIT { return wrapped } -// UnsafeSCTESITFromGlibFull is used to convert raw C.GstMpegtsSCTESIT pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeSCTESITFromGlibFull is used to convert raw C.GstMpegtsSCTESIT pointers to go while taking ownership. This is used by the bindings internally. func UnsafeSCTESITFromGlibFull(p unsafe.Pointer) *SCTESIT { wrapped := UnsafeSCTESITFromGlibBorrow(p) runtime.SetFinalizer( @@ -7918,7 +8001,9 @@ func UnsafeSCTESITToGlibFull(s *SCTESIT) unsafe.Pointer { s.native = nil // SCTESIT is invalid from here on return _p } + // NewSCTESIT wraps gst_mpegts_scte_sit_new +// // The function returns the following values: // // - goret *SCTESIT @@ -7965,7 +8050,7 @@ func UnsafeSCTESpliceComponentFromGlibBorrow(p unsafe.Pointer) *SCTESpliceCompon return &SCTESpliceComponent{&scteSpliceComponent{(*C.GstMpegtsSCTESpliceComponent)(p)}} } -// UnsafeSCTESpliceComponentFromGlibNone is used to convert raw C.GstMpegtsSCTESpliceComponent pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeSCTESpliceComponentFromGlibNone is used to convert raw C.GstMpegtsSCTESpliceComponent pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeSCTESpliceComponentFromGlibNone(p unsafe.Pointer) *SCTESpliceComponent { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeSCTESpliceComponentFromGlibBorrow(p) @@ -7978,7 +8063,7 @@ func UnsafeSCTESpliceComponentFromGlibNone(p unsafe.Pointer) *SCTESpliceComponen return wrapped } -// UnsafeSCTESpliceComponentFromGlibFull is used to convert raw C.GstMpegtsSCTESpliceComponent pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeSCTESpliceComponentFromGlibFull is used to convert raw C.GstMpegtsSCTESpliceComponent pointers to go while taking ownership. This is used by the bindings internally. func UnsafeSCTESpliceComponentFromGlibFull(p unsafe.Pointer) *SCTESpliceComponent { wrapped := UnsafeSCTESpliceComponentFromGlibBorrow(p) runtime.SetFinalizer( @@ -8010,6 +8095,7 @@ func UnsafeSCTESpliceComponentToGlibFull(s *SCTESpliceComponent) unsafe.Pointer s.native = nil // SCTESpliceComponent is invalid from here on return _p } + // NewSCTESpliceComponent wraps gst_mpegts_scte_splice_component_new // // The function takes the following parameters: @@ -8064,7 +8150,7 @@ func UnsafeSCTESpliceEventFromGlibBorrow(p unsafe.Pointer) *SCTESpliceEvent { return &SCTESpliceEvent{&scteSpliceEvent{(*C.GstMpegtsSCTESpliceEvent)(p)}} } -// UnsafeSCTESpliceEventFromGlibNone is used to convert raw C.GstMpegtsSCTESpliceEvent pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeSCTESpliceEventFromGlibNone is used to convert raw C.GstMpegtsSCTESpliceEvent pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeSCTESpliceEventFromGlibNone(p unsafe.Pointer) *SCTESpliceEvent { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeSCTESpliceEventFromGlibBorrow(p) @@ -8077,7 +8163,7 @@ func UnsafeSCTESpliceEventFromGlibNone(p unsafe.Pointer) *SCTESpliceEvent { return wrapped } -// UnsafeSCTESpliceEventFromGlibFull is used to convert raw C.GstMpegtsSCTESpliceEvent pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeSCTESpliceEventFromGlibFull is used to convert raw C.GstMpegtsSCTESpliceEvent pointers to go while taking ownership. This is used by the bindings internally. func UnsafeSCTESpliceEventFromGlibFull(p unsafe.Pointer) *SCTESpliceEvent { wrapped := UnsafeSCTESpliceEventFromGlibBorrow(p) runtime.SetFinalizer( @@ -8109,7 +8195,9 @@ func UnsafeSCTESpliceEventToGlibFull(s *SCTESpliceEvent) unsafe.Pointer { s.native = nil // SCTESpliceEvent is invalid from here on return _p } + // NewSCTESpliceEvent wraps gst_mpegts_scte_splice_event_new +// // The function returns the following values: // // - goret *SCTESpliceEvent @@ -8156,7 +8244,7 @@ func UnsafeSDTFromGlibBorrow(p unsafe.Pointer) *SDT { return &SDT{&sdT{(*C.GstMpegtsSDT)(p)}} } -// UnsafeSDTFromGlibNone is used to convert raw C.GstMpegtsSDT pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeSDTFromGlibNone is used to convert raw C.GstMpegtsSDT pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeSDTFromGlibNone(p unsafe.Pointer) *SDT { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeSDTFromGlibBorrow(p) @@ -8169,7 +8257,7 @@ func UnsafeSDTFromGlibNone(p unsafe.Pointer) *SDT { return wrapped } -// UnsafeSDTFromGlibFull is used to convert raw C.GstMpegtsSDT pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeSDTFromGlibFull is used to convert raw C.GstMpegtsSDT pointers to go while taking ownership. This is used by the bindings internally. func UnsafeSDTFromGlibFull(p unsafe.Pointer) *SDT { wrapped := UnsafeSDTFromGlibBorrow(p) runtime.SetFinalizer( @@ -8201,7 +8289,9 @@ func UnsafeSDTToGlibFull(s *SDT) unsafe.Pointer { s.native = nil // SDT is invalid from here on return _p } + // NewSDT wraps gst_mpegts_sdt_new +// // The function returns the following values: // // - goret *SDT @@ -8246,7 +8336,7 @@ func UnsafeSDTServiceFromGlibBorrow(p unsafe.Pointer) *SDTService { return &SDTService{&sdtService{(*C.GstMpegtsSDTService)(p)}} } -// UnsafeSDTServiceFromGlibNone is used to convert raw C.GstMpegtsSDTService pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeSDTServiceFromGlibNone is used to convert raw C.GstMpegtsSDTService pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeSDTServiceFromGlibNone(p unsafe.Pointer) *SDTService { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeSDTServiceFromGlibBorrow(p) @@ -8259,7 +8349,7 @@ func UnsafeSDTServiceFromGlibNone(p unsafe.Pointer) *SDTService { return wrapped } -// UnsafeSDTServiceFromGlibFull is used to convert raw C.GstMpegtsSDTService pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeSDTServiceFromGlibFull is used to convert raw C.GstMpegtsSDTService pointers to go while taking ownership. This is used by the bindings internally. func UnsafeSDTServiceFromGlibFull(p unsafe.Pointer) *SDTService { wrapped := UnsafeSDTServiceFromGlibBorrow(p) runtime.SetFinalizer( @@ -8291,7 +8381,9 @@ func UnsafeSDTServiceToGlibFull(s *SDTService) unsafe.Pointer { s.native = nil // SDTService is invalid from here on return _p } + // NewSDTService wraps gst_mpegts_sdt_service_new +// // The function returns the following values: // // - goret *SDTService @@ -8338,7 +8430,7 @@ func UnsafeSITFromGlibBorrow(p unsafe.Pointer) *SIT { return &SIT{&siT{(*C.GstMpegtsSIT)(p)}} } -// UnsafeSITFromGlibNone is used to convert raw C.GstMpegtsSIT pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeSITFromGlibNone is used to convert raw C.GstMpegtsSIT pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeSITFromGlibNone(p unsafe.Pointer) *SIT { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeSITFromGlibBorrow(p) @@ -8351,7 +8443,7 @@ func UnsafeSITFromGlibNone(p unsafe.Pointer) *SIT { return wrapped } -// UnsafeSITFromGlibFull is used to convert raw C.GstMpegtsSIT pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeSITFromGlibFull is used to convert raw C.GstMpegtsSIT pointers to go while taking ownership. This is used by the bindings internally. func UnsafeSITFromGlibFull(p unsafe.Pointer) *SIT { wrapped := UnsafeSITFromGlibBorrow(p) runtime.SetFinalizer( @@ -8383,6 +8475,7 @@ func UnsafeSITToGlibFull(s *SIT) unsafe.Pointer { s.native = nil // SIT is invalid from here on return _p } + // SITService wraps GstMpegtsSITService // // SIT Service entry @@ -8412,7 +8505,7 @@ func UnsafeSITServiceFromGlibBorrow(p unsafe.Pointer) *SITService { return &SITService{&sitService{(*C.GstMpegtsSITService)(p)}} } -// UnsafeSITServiceFromGlibNone is used to convert raw C.GstMpegtsSITService pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeSITServiceFromGlibNone is used to convert raw C.GstMpegtsSITService pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeSITServiceFromGlibNone(p unsafe.Pointer) *SITService { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeSITServiceFromGlibBorrow(p) @@ -8425,7 +8518,7 @@ func UnsafeSITServiceFromGlibNone(p unsafe.Pointer) *SITService { return wrapped } -// UnsafeSITServiceFromGlibFull is used to convert raw C.GstMpegtsSITService pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeSITServiceFromGlibFull is used to convert raw C.GstMpegtsSITService pointers to go while taking ownership. This is used by the bindings internally. func UnsafeSITServiceFromGlibFull(p unsafe.Pointer) *SITService { wrapped := UnsafeSITServiceFromGlibBorrow(p) runtime.SetFinalizer( @@ -8457,6 +8550,7 @@ func UnsafeSITServiceToGlibFull(s *SITService) unsafe.Pointer { s.native = nil // SITService is invalid from here on return _p } + // SatelliteDeliverySystemDescriptor wraps GstMpegtsSatelliteDeliverySystemDescriptor // // Satellite Delivery System Descriptor (EN 300 468 v.1.13.1) @@ -8486,7 +8580,7 @@ func UnsafeSatelliteDeliverySystemDescriptorFromGlibBorrow(p unsafe.Pointer) *Sa return &SatelliteDeliverySystemDescriptor{&satelliteDeliverySystemDescriptor{(*C.GstMpegtsSatelliteDeliverySystemDescriptor)(p)}} } -// UnsafeSatelliteDeliverySystemDescriptorFromGlibNone is used to convert raw C.GstMpegtsSatelliteDeliverySystemDescriptor pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeSatelliteDeliverySystemDescriptorFromGlibNone is used to convert raw C.GstMpegtsSatelliteDeliverySystemDescriptor pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeSatelliteDeliverySystemDescriptorFromGlibNone(p unsafe.Pointer) *SatelliteDeliverySystemDescriptor { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeSatelliteDeliverySystemDescriptorFromGlibBorrow(p) @@ -8499,7 +8593,7 @@ func UnsafeSatelliteDeliverySystemDescriptorFromGlibNone(p unsafe.Pointer) *Sate return wrapped } -// UnsafeSatelliteDeliverySystemDescriptorFromGlibFull is used to convert raw C.GstMpegtsSatelliteDeliverySystemDescriptor pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeSatelliteDeliverySystemDescriptorFromGlibFull is used to convert raw C.GstMpegtsSatelliteDeliverySystemDescriptor pointers to go while taking ownership. This is used by the bindings internally. func UnsafeSatelliteDeliverySystemDescriptorFromGlibFull(p unsafe.Pointer) *SatelliteDeliverySystemDescriptor { wrapped := UnsafeSatelliteDeliverySystemDescriptorFromGlibBorrow(p) runtime.SetFinalizer( @@ -8531,6 +8625,7 @@ func UnsafeSatelliteDeliverySystemDescriptorToGlibFull(s *SatelliteDeliverySyste s.native = nil // SatelliteDeliverySystemDescriptor is invalid from here on return _p } + // Section wraps GstMpegtsSection // // ## Generic usage of sections with %GstMpegtsSection @@ -8603,7 +8698,7 @@ func UnsafeSectionFromGlibBorrow(p unsafe.Pointer) *Section { return &Section{§ion{(*C.GstMpegtsSection)(p)}} } -// UnsafeSectionFromGlibNone is used to convert raw C.GstMpegtsSection pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeSectionFromGlibNone is used to convert raw C.GstMpegtsSection pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeSectionFromGlibNone(p unsafe.Pointer) *Section { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeSectionFromGlibBorrow(p) @@ -8616,7 +8711,7 @@ func UnsafeSectionFromGlibNone(p unsafe.Pointer) *Section { return wrapped } -// UnsafeSectionFromGlibFull is used to convert raw C.GstMpegtsSection pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeSectionFromGlibFull is used to convert raw C.GstMpegtsSection pointers to go while taking ownership. This is used by the bindings internally. func UnsafeSectionFromGlibFull(p unsafe.Pointer) *Section { wrapped := UnsafeSectionFromGlibBorrow(p) runtime.SetFinalizer( @@ -8648,6 +8743,7 @@ func UnsafeSectionToGlibFull(s *Section) unsafe.Pointer { s.native = nil // Section is invalid from here on return _p } + // NewSection wraps gst_mpegts_section_new // // The function takes the following parameters: @@ -8883,6 +8979,7 @@ func SectionFromSdt(sdt *SDT) *Section { } // GetAtscCvct wraps gst_mpegts_section_get_atsc_cvct +// // The function returns the following values: // // - goret *AtscVCT @@ -8905,6 +9002,7 @@ func (section *Section) GetAtscCvct() *AtscVCT { } // GetAtscEit wraps gst_mpegts_section_get_atsc_eit +// // The function returns the following values: // // - goret *AtscEIT @@ -8927,6 +9025,7 @@ func (section *Section) GetAtscEit() *AtscEIT { } // GetAtscEtt wraps gst_mpegts_section_get_atsc_ett +// // The function returns the following values: // // - goret *AtscETT @@ -8949,6 +9048,7 @@ func (section *Section) GetAtscEtt() *AtscETT { } // GetAtscMgt wraps gst_mpegts_section_get_atsc_mgt +// // The function returns the following values: // // - goret *AtscMGT @@ -8971,6 +9071,7 @@ func (section *Section) GetAtscMgt() *AtscMGT { } // GetAtscRrt wraps gst_mpegts_section_get_atsc_rrt +// // The function returns the following values: // // - goret *AtscRRT @@ -8993,6 +9094,7 @@ func (section *Section) GetAtscRrt() *AtscRRT { } // GetAtscStt wraps gst_mpegts_section_get_atsc_stt +// // The function returns the following values: // // - goret *AtscSTT @@ -9015,6 +9117,7 @@ func (section *Section) GetAtscStt() *AtscSTT { } // GetAtscTvct wraps gst_mpegts_section_get_atsc_tvct +// // The function returns the following values: // // - goret *AtscVCT @@ -9037,6 +9140,7 @@ func (section *Section) GetAtscTvct() *AtscVCT { } // GetBat wraps gst_mpegts_section_get_bat +// // The function returns the following values: // // - goret *BAT @@ -9059,6 +9163,7 @@ func (section *Section) GetBat() *BAT { } // GetData wraps gst_mpegts_section_get_data +// // The function returns the following values: // // - goret *glib.Bytes @@ -9081,6 +9186,7 @@ func (section *Section) GetData() *glib.Bytes { } // GetEit wraps gst_mpegts_section_get_eit +// // The function returns the following values: // // - goret *EIT @@ -9103,6 +9209,7 @@ func (section *Section) GetEit() *EIT { } // GetNit wraps gst_mpegts_section_get_nit +// // The function returns the following values: // // - goret *NIT @@ -9125,6 +9232,7 @@ func (section *Section) GetNit() *NIT { } // GetPmt wraps gst_mpegts_section_get_pmt +// // The function returns the following values: // // - goret *PMT @@ -9147,6 +9255,7 @@ func (section *Section) GetPmt() *PMT { } // GetScteSit wraps gst_mpegts_section_get_scte_sit +// // The function returns the following values: // // - goret *SCTESIT @@ -9169,6 +9278,7 @@ func (section *Section) GetScteSit() *SCTESIT { } // GetSdt wraps gst_mpegts_section_get_sdt +// // The function returns the following values: // // - goret *SDT @@ -9191,6 +9301,7 @@ func (section *Section) GetSdt() *SDT { } // GetSit wraps gst_mpegts_section_get_sit +// // The function returns the following values: // // - goret *SIT @@ -9213,6 +9324,7 @@ func (section *Section) GetSit() *SIT { } // GetTdt wraps gst_mpegts_section_get_tdt +// // The function returns the following values: // // - goret *gst.DateTime @@ -9235,6 +9347,7 @@ func (section *Section) GetTdt() *gst.DateTime { } // GetTot wraps gst_mpegts_section_get_tot +// // The function returns the following values: // // - goret *TOT @@ -9257,6 +9370,7 @@ func (section *Section) GetTot() *TOT { } // Packetize wraps gst_mpegts_section_packetize +// // The function returns the following values: // // - outputSize uint: #gsize to hold the size of the data @@ -9346,7 +9460,7 @@ func UnsafeT2DeliverySystemCellFromGlibBorrow(p unsafe.Pointer) *T2DeliverySyste return &T2DeliverySystemCell{&t2DeliverySystemCell{(*C.GstMpegtsT2DeliverySystemCell)(p)}} } -// UnsafeT2DeliverySystemCellFromGlibNone is used to convert raw C.GstMpegtsT2DeliverySystemCell pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeT2DeliverySystemCellFromGlibNone is used to convert raw C.GstMpegtsT2DeliverySystemCell pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeT2DeliverySystemCellFromGlibNone(p unsafe.Pointer) *T2DeliverySystemCell { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeT2DeliverySystemCellFromGlibBorrow(p) @@ -9359,7 +9473,7 @@ func UnsafeT2DeliverySystemCellFromGlibNone(p unsafe.Pointer) *T2DeliverySystemC return wrapped } -// UnsafeT2DeliverySystemCellFromGlibFull is used to convert raw C.GstMpegtsT2DeliverySystemCell pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeT2DeliverySystemCellFromGlibFull is used to convert raw C.GstMpegtsT2DeliverySystemCell pointers to go while taking ownership. This is used by the bindings internally. func UnsafeT2DeliverySystemCellFromGlibFull(p unsafe.Pointer) *T2DeliverySystemCell { wrapped := UnsafeT2DeliverySystemCellFromGlibBorrow(p) runtime.SetFinalizer( @@ -9391,6 +9505,7 @@ func UnsafeT2DeliverySystemCellToGlibFull(t *T2DeliverySystemCell) unsafe.Pointe t.native = nil // T2DeliverySystemCell is invalid from here on return _p } + // T2DeliverySystemCellExtension wraps GstMpegtsT2DeliverySystemCellExtension type T2DeliverySystemCellExtension struct { *t2DeliverySystemCellExtension @@ -9418,7 +9533,7 @@ func UnsafeT2DeliverySystemCellExtensionFromGlibBorrow(p unsafe.Pointer) *T2Deli return &T2DeliverySystemCellExtension{&t2DeliverySystemCellExtension{(*C.GstMpegtsT2DeliverySystemCellExtension)(p)}} } -// UnsafeT2DeliverySystemCellExtensionFromGlibNone is used to convert raw C.GstMpegtsT2DeliverySystemCellExtension pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeT2DeliverySystemCellExtensionFromGlibNone is used to convert raw C.GstMpegtsT2DeliverySystemCellExtension pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeT2DeliverySystemCellExtensionFromGlibNone(p unsafe.Pointer) *T2DeliverySystemCellExtension { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeT2DeliverySystemCellExtensionFromGlibBorrow(p) @@ -9431,7 +9546,7 @@ func UnsafeT2DeliverySystemCellExtensionFromGlibNone(p unsafe.Pointer) *T2Delive return wrapped } -// UnsafeT2DeliverySystemCellExtensionFromGlibFull is used to convert raw C.GstMpegtsT2DeliverySystemCellExtension pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeT2DeliverySystemCellExtensionFromGlibFull is used to convert raw C.GstMpegtsT2DeliverySystemCellExtension pointers to go while taking ownership. This is used by the bindings internally. func UnsafeT2DeliverySystemCellExtensionFromGlibFull(p unsafe.Pointer) *T2DeliverySystemCellExtension { wrapped := UnsafeT2DeliverySystemCellExtensionFromGlibBorrow(p) runtime.SetFinalizer( @@ -9463,6 +9578,7 @@ func UnsafeT2DeliverySystemCellExtensionToGlibFull(t *T2DeliverySystemCellExtens t.native = nil // T2DeliverySystemCellExtension is invalid from here on return _p } + // T2DeliverySystemDescriptor wraps GstMpegtsT2DeliverySystemDescriptor // // describe DVB-T2 transmissions according to EN 302 755 @@ -9492,7 +9608,7 @@ func UnsafeT2DeliverySystemDescriptorFromGlibBorrow(p unsafe.Pointer) *T2Deliver return &T2DeliverySystemDescriptor{&t2DeliverySystemDescriptor{(*C.GstMpegtsT2DeliverySystemDescriptor)(p)}} } -// UnsafeT2DeliverySystemDescriptorFromGlibNone is used to convert raw C.GstMpegtsT2DeliverySystemDescriptor pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeT2DeliverySystemDescriptorFromGlibNone is used to convert raw C.GstMpegtsT2DeliverySystemDescriptor pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeT2DeliverySystemDescriptorFromGlibNone(p unsafe.Pointer) *T2DeliverySystemDescriptor { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeT2DeliverySystemDescriptorFromGlibBorrow(p) @@ -9505,7 +9621,7 @@ func UnsafeT2DeliverySystemDescriptorFromGlibNone(p unsafe.Pointer) *T2DeliveryS return wrapped } -// UnsafeT2DeliverySystemDescriptorFromGlibFull is used to convert raw C.GstMpegtsT2DeliverySystemDescriptor pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeT2DeliverySystemDescriptorFromGlibFull is used to convert raw C.GstMpegtsT2DeliverySystemDescriptor pointers to go while taking ownership. This is used by the bindings internally. func UnsafeT2DeliverySystemDescriptorFromGlibFull(p unsafe.Pointer) *T2DeliverySystemDescriptor { wrapped := UnsafeT2DeliverySystemDescriptorFromGlibBorrow(p) runtime.SetFinalizer( @@ -9537,6 +9653,7 @@ func UnsafeT2DeliverySystemDescriptorToGlibFull(t *T2DeliverySystemDescriptor) u t.native = nil // T2DeliverySystemDescriptor is invalid from here on return _p } + // TOT wraps GstMpegtsTOT // // Time Offset Table (EN 300 468) @@ -9566,7 +9683,7 @@ func UnsafeTOTFromGlibBorrow(p unsafe.Pointer) *TOT { return &TOT{&toT{(*C.GstMpegtsTOT)(p)}} } -// UnsafeTOTFromGlibNone is used to convert raw C.GstMpegtsTOT pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeTOTFromGlibNone is used to convert raw C.GstMpegtsTOT pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeTOTFromGlibNone(p unsafe.Pointer) *TOT { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeTOTFromGlibBorrow(p) @@ -9579,7 +9696,7 @@ func UnsafeTOTFromGlibNone(p unsafe.Pointer) *TOT { return wrapped } -// UnsafeTOTFromGlibFull is used to convert raw C.GstMpegtsTOT pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeTOTFromGlibFull is used to convert raw C.GstMpegtsTOT pointers to go while taking ownership. This is used by the bindings internally. func UnsafeTOTFromGlibFull(p unsafe.Pointer) *TOT { wrapped := UnsafeTOTFromGlibBorrow(p) runtime.SetFinalizer( @@ -9611,6 +9728,7 @@ func UnsafeTOTToGlibFull(t *TOT) unsafe.Pointer { t.native = nil // TOT is invalid from here on return _p } + // TerrestrialDeliverySystemDescriptor wraps GstMpegtsTerrestrialDeliverySystemDescriptor // // Terrestrial Delivery System Descriptor (EN 300 468 v.1.13.1) @@ -9640,7 +9758,7 @@ func UnsafeTerrestrialDeliverySystemDescriptorFromGlibBorrow(p unsafe.Pointer) * return &TerrestrialDeliverySystemDescriptor{&terrestrialDeliverySystemDescriptor{(*C.GstMpegtsTerrestrialDeliverySystemDescriptor)(p)}} } -// UnsafeTerrestrialDeliverySystemDescriptorFromGlibNone is used to convert raw C.GstMpegtsTerrestrialDeliverySystemDescriptor pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeTerrestrialDeliverySystemDescriptorFromGlibNone is used to convert raw C.GstMpegtsTerrestrialDeliverySystemDescriptor pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeTerrestrialDeliverySystemDescriptorFromGlibNone(p unsafe.Pointer) *TerrestrialDeliverySystemDescriptor { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeTerrestrialDeliverySystemDescriptorFromGlibBorrow(p) @@ -9653,7 +9771,7 @@ func UnsafeTerrestrialDeliverySystemDescriptorFromGlibNone(p unsafe.Pointer) *Te return wrapped } -// UnsafeTerrestrialDeliverySystemDescriptorFromGlibFull is used to convert raw C.GstMpegtsTerrestrialDeliverySystemDescriptor pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeTerrestrialDeliverySystemDescriptorFromGlibFull is used to convert raw C.GstMpegtsTerrestrialDeliverySystemDescriptor pointers to go while taking ownership. This is used by the bindings internally. func UnsafeTerrestrialDeliverySystemDescriptorFromGlibFull(p unsafe.Pointer) *TerrestrialDeliverySystemDescriptor { wrapped := UnsafeTerrestrialDeliverySystemDescriptorFromGlibBorrow(p) runtime.SetFinalizer( @@ -9685,6 +9803,7 @@ func UnsafeTerrestrialDeliverySystemDescriptorToGlibFull(t *TerrestrialDeliveryS t.native = nil // TerrestrialDeliverySystemDescriptor is invalid from here on return _p } + // SuppressUnstableWarning should be overwritten by the user to suppress the warning var SuppressUnstableWarning = false func init() { diff --git a/pkg/gstnet/gstnet.gen.go b/pkg/gstnet/gstnet.gen.go index e1579a7..9e09807 100644 --- a/pkg/gstnet/gstnet.gen.go +++ b/pkg/gstnet/gstnet.gen.go @@ -180,6 +180,7 @@ func BufferGetNetAddressMeta(buffer *gst.Buffer) *NetAddressMeta { } // NetAddressMetaApiGetType wraps gst_net_address_meta_api_get_type +// // The function returns the following values: // // - goret gobject.Type @@ -196,6 +197,7 @@ func NetAddressMetaApiGetType() gobject.Type { } // NetControlMessageMetaApiGetType wraps gst_net_control_message_meta_api_get_type +// // The function returns the following values: // // - goret gobject.Type @@ -341,6 +343,7 @@ func PtpInitFull(config *gst.Structure) bool { } // PtpIsInitialized wraps gst_ptp_is_initialized +// // The function returns the following values: // // - goret bool @@ -361,6 +364,7 @@ func PtpIsInitialized() bool { } // PtpIsSupported wraps gst_ptp_is_supported +// // The function returns the following values: // // - goret bool @@ -554,6 +558,20 @@ func NewNetClientClock(name string, remoteAddress string, remotePort int, baseTi return goret } +// NetClientClockOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type NetClientClockOverrides[Instance NetClientClock] struct { + // gst.SystemClockOverrides allows you to override virtual methods from the parent class gst.SystemClock + gst.SystemClockOverrides[Instance] + +} + +// UnsafeApplyNetClientClockOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyNetClientClockOverrides[Instance NetClientClock](gclass unsafe.Pointer, overrides NetClientClockOverrides[Instance]) { + gst.UnsafeApplySystemClockOverrides(gclass, overrides.SystemClockOverrides) +} + // NetTimeProviderInstance is the instance type used by all types extending GstNetTimeProvider. It is used internally by the bindings. Users should use the interface [NetTimeProvider] instead. type NetTimeProviderInstance struct { _ [0]func() // equal guard @@ -663,6 +681,20 @@ func NewNetTimeProvider(clock gst.Clock, address string, port int) NetTimeProvid return goret } +// NetTimeProviderOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type NetTimeProviderOverrides[Instance NetTimeProvider] struct { + // gst.ObjectOverrides allows you to override virtual methods from the parent class gst.Object + gst.ObjectOverrides[Instance] + +} + +// UnsafeApplyNetTimeProviderOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyNetTimeProviderOverrides[Instance NetTimeProvider](gclass unsafe.Pointer, overrides NetTimeProviderOverrides[Instance]) { + gst.UnsafeApplyObjectOverrides(gclass, overrides.ObjectOverrides) +} + // NtpClockInstance is the instance type used by all types extending GstNtpClock. It is used internally by the bindings. Users should use the interface [NtpClock] instead. type NtpClockInstance struct { _ [0]func() // equal guard @@ -765,6 +797,20 @@ func NewNtpClock(name string, remoteAddress string, remotePort int, baseTime gst return goret } +// NtpClockOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type NtpClockOverrides[Instance NtpClock] struct { + // NetClientClockOverrides allows you to override virtual methods from the parent class NetClientClock + NetClientClockOverrides[Instance] + +} + +// UnsafeApplyNtpClockOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyNtpClockOverrides[Instance NtpClock](gclass unsafe.Pointer, overrides NtpClockOverrides[Instance]) { + UnsafeApplyNetClientClockOverrides(gclass, overrides.NetClientClockOverrides) +} + // PtpClockInstance is the instance type used by all types extending GstPtpClock. It is used internally by the bindings. Users should use the interface [PtpClock] instead. type PtpClockInstance struct { _ [0]func() // equal guard @@ -885,6 +931,20 @@ func NewPtpClock(name string, domain uint) gst.Clock { return goret } +// PtpClockOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type PtpClockOverrides[Instance PtpClock] struct { + // gst.SystemClockOverrides allows you to override virtual methods from the parent class gst.SystemClock + gst.SystemClockOverrides[Instance] + +} + +// UnsafeApplyPtpClockOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyPtpClockOverrides[Instance PtpClock](gclass unsafe.Pointer, overrides PtpClockOverrides[Instance]) { + gst.UnsafeApplySystemClockOverrides(gclass, overrides.SystemClockOverrides) +} + // NetAddressMeta wraps GstNetAddressMeta // // #GstNetAddressMeta can be used to store a network address (a #GSocketAddress) @@ -904,7 +964,7 @@ func UnsafeNetAddressMetaFromGlibBorrow(p unsafe.Pointer) *NetAddressMeta { return &NetAddressMeta{&netAddressMeta{(*C.GstNetAddressMeta)(p)}} } -// UnsafeNetAddressMetaFromGlibNone is used to convert raw C.GstNetAddressMeta pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeNetAddressMetaFromGlibNone is used to convert raw C.GstNetAddressMeta pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeNetAddressMetaFromGlibNone(p unsafe.Pointer) *NetAddressMeta { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeNetAddressMetaFromGlibBorrow(p) @@ -917,7 +977,7 @@ func UnsafeNetAddressMetaFromGlibNone(p unsafe.Pointer) *NetAddressMeta { return wrapped } -// UnsafeNetAddressMetaFromGlibFull is used to convert raw C.GstNetAddressMeta pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeNetAddressMetaFromGlibFull is used to convert raw C.GstNetAddressMeta pointers to go while taking ownership. This is used by the bindings internally. func UnsafeNetAddressMetaFromGlibFull(p unsafe.Pointer) *NetAddressMeta { wrapped := UnsafeNetAddressMetaFromGlibBorrow(p) runtime.SetFinalizer( @@ -949,7 +1009,9 @@ func UnsafeNetAddressMetaToGlibFull(n *NetAddressMeta) unsafe.Pointer { n.native = nil // NetAddressMeta is invalid from here on return _p } + // NetAddressMetaGetInfo wraps gst_net_address_meta_get_info +// // The function returns the following values: // // - goret *gst.MetaInfo @@ -966,6 +1028,8 @@ func NetAddressMetaGetInfo() *gst.MetaInfo { } // NetClientClockClass wraps GstNetClientClockClass +// +// NetClientClockClass is the type struct for [NetClientClock] type NetClientClockClass struct { *netClientClockClass } @@ -980,31 +1044,6 @@ func UnsafeNetClientClockClassFromGlibBorrow(p unsafe.Pointer) *NetClientClockCl return &NetClientClockClass{&netClientClockClass{(*C.GstNetClientClockClass)(p)}} } -// UnsafeNetClientClockClassFromGlibNone is used to convert raw C.GstNetClientClockClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeNetClientClockClassFromGlibNone(p unsafe.Pointer) *NetClientClockClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeNetClientClockClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.netClientClockClass, - func (intern *netClientClockClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeNetClientClockClassFromGlibFull is used to convert raw C.GstNetClientClockClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeNetClientClockClassFromGlibFull(p unsafe.Pointer) *NetClientClockClass { - wrapped := UnsafeNetClientClockClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.netClientClockClass, - func (intern *netClientClockClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeNetClientClockClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [NetClientClockClass] is expected to work anymore. @@ -1017,14 +1056,15 @@ func UnsafeNetClientClockClassToGlibNone(n *NetClientClockClass) unsafe.Pointer return unsafe.Pointer(n.native) } -// UnsafeNetClientClockClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeNetClientClockClassToGlibFull(n *NetClientClockClass) unsafe.Pointer { - runtime.SetFinalizer(n.netClientClockClass, nil) - _p := unsafe.Pointer(n.native) - n.native = nil // NetClientClockClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (n *NetClientClockClass) ParentClass() *gst.SystemClockClass { + parent := gst.UnsafeSystemClockClassFromGlibBorrow(UnsafeNetClientClockClassToGlibNone(n)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *NetClientClockClass) {}, n) + return parent } + // NetControlMessageMeta wraps GstNetControlMessageMeta // // #GstNetControlMessageMeta can be used to store control messages (ancillary @@ -1046,7 +1086,7 @@ func UnsafeNetControlMessageMetaFromGlibBorrow(p unsafe.Pointer) *NetControlMess return &NetControlMessageMeta{&netControlMessageMeta{(*C.GstNetControlMessageMeta)(p)}} } -// UnsafeNetControlMessageMetaFromGlibNone is used to convert raw C.GstNetControlMessageMeta pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeNetControlMessageMetaFromGlibNone is used to convert raw C.GstNetControlMessageMeta pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeNetControlMessageMetaFromGlibNone(p unsafe.Pointer) *NetControlMessageMeta { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeNetControlMessageMetaFromGlibBorrow(p) @@ -1059,7 +1099,7 @@ func UnsafeNetControlMessageMetaFromGlibNone(p unsafe.Pointer) *NetControlMessag return wrapped } -// UnsafeNetControlMessageMetaFromGlibFull is used to convert raw C.GstNetControlMessageMeta pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeNetControlMessageMetaFromGlibFull is used to convert raw C.GstNetControlMessageMeta pointers to go while taking ownership. This is used by the bindings internally. func UnsafeNetControlMessageMetaFromGlibFull(p unsafe.Pointer) *NetControlMessageMeta { wrapped := UnsafeNetControlMessageMetaFromGlibBorrow(p) runtime.SetFinalizer( @@ -1091,7 +1131,9 @@ func UnsafeNetControlMessageMetaToGlibFull(n *NetControlMessageMeta) unsafe.Poin n.native = nil // NetControlMessageMeta is invalid from here on return _p } + // NetControlMessageMetaGetInfo wraps gst_net_control_message_meta_get_info +// // The function returns the following values: // // - goret *gst.MetaInfo @@ -1137,7 +1179,7 @@ func UnsafeNetTimePacketFromGlibBorrow(p unsafe.Pointer) *NetTimePacket { return &NetTimePacket{&netTimePacket{(*C.GstNetTimePacket)(p)}} } -// UnsafeNetTimePacketFromGlibNone is used to convert raw C.GstNetTimePacket pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeNetTimePacketFromGlibNone is used to convert raw C.GstNetTimePacket pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeNetTimePacketFromGlibNone(p unsafe.Pointer) *NetTimePacket { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeNetTimePacketFromGlibBorrow(p) @@ -1150,7 +1192,7 @@ func UnsafeNetTimePacketFromGlibNone(p unsafe.Pointer) *NetTimePacket { return wrapped } -// UnsafeNetTimePacketFromGlibFull is used to convert raw C.GstNetTimePacket pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeNetTimePacketFromGlibFull is used to convert raw C.GstNetTimePacket pointers to go while taking ownership. This is used by the bindings internally. func UnsafeNetTimePacketFromGlibFull(p unsafe.Pointer) *NetTimePacket { wrapped := UnsafeNetTimePacketFromGlibBorrow(p) runtime.SetFinalizer( @@ -1182,6 +1224,7 @@ func UnsafeNetTimePacketToGlibFull(n *NetTimePacket) unsafe.Pointer { n.native = nil // NetTimePacket is invalid from here on return _p } + // NewNetTimePacket wraps gst_net_time_packet_new // // The function takes the following parameters: @@ -1257,6 +1300,7 @@ func NetTimePacketReceive(socket gio.Socket) (gio.SocketAddress, *NetTimePacket, } // Copy wraps gst_net_time_packet_copy +// // The function returns the following values: // // - goret *NetTimePacket @@ -1323,6 +1367,7 @@ func (packet *NetTimePacket) Send(socket gio.Socket, destAddress gio.SocketAddre } // Serialize wraps gst_net_time_packet_serialize +// // The function returns the following values: // // - goret [16]uint8 @@ -1352,6 +1397,8 @@ func (packet *NetTimePacket) Serialize() [16]uint8 { } // NetTimeProviderClass wraps GstNetTimeProviderClass +// +// NetTimeProviderClass is the type struct for [NetTimeProvider] type NetTimeProviderClass struct { *netTimeProviderClass } @@ -1366,31 +1413,6 @@ func UnsafeNetTimeProviderClassFromGlibBorrow(p unsafe.Pointer) *NetTimeProvider return &NetTimeProviderClass{&netTimeProviderClass{(*C.GstNetTimeProviderClass)(p)}} } -// UnsafeNetTimeProviderClassFromGlibNone is used to convert raw C.GstNetTimeProviderClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeNetTimeProviderClassFromGlibNone(p unsafe.Pointer) *NetTimeProviderClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeNetTimeProviderClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.netTimeProviderClass, - func (intern *netTimeProviderClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeNetTimeProviderClassFromGlibFull is used to convert raw C.GstNetTimeProviderClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeNetTimeProviderClassFromGlibFull(p unsafe.Pointer) *NetTimeProviderClass { - wrapped := UnsafeNetTimeProviderClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.netTimeProviderClass, - func (intern *netTimeProviderClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeNetTimeProviderClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [NetTimeProviderClass] is expected to work anymore. @@ -1403,15 +1425,18 @@ func UnsafeNetTimeProviderClassToGlibNone(n *NetTimeProviderClass) unsafe.Pointe return unsafe.Pointer(n.native) } -// UnsafeNetTimeProviderClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeNetTimeProviderClassToGlibFull(n *NetTimeProviderClass) unsafe.Pointer { - runtime.SetFinalizer(n.netTimeProviderClass, nil) - _p := unsafe.Pointer(n.native) - n.native = nil // NetTimeProviderClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (n *NetTimeProviderClass) ParentClass() *gst.ObjectClass { + parent := gst.UnsafeObjectClassFromGlibBorrow(UnsafeNetTimeProviderClassToGlibNone(n)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *NetTimeProviderClass) {}, n) + return parent } + // NtpClockClass wraps GstNtpClockClass +// +// NtpClockClass is the type struct for [NtpClock] type NtpClockClass struct { *ntpClockClass } @@ -1426,31 +1451,6 @@ func UnsafeNtpClockClassFromGlibBorrow(p unsafe.Pointer) *NtpClockClass { return &NtpClockClass{&ntpClockClass{(*C.GstNtpClockClass)(p)}} } -// UnsafeNtpClockClassFromGlibNone is used to convert raw C.GstNtpClockClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeNtpClockClassFromGlibNone(p unsafe.Pointer) *NtpClockClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeNtpClockClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.ntpClockClass, - func (intern *ntpClockClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeNtpClockClassFromGlibFull is used to convert raw C.GstNtpClockClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeNtpClockClassFromGlibFull(p unsafe.Pointer) *NtpClockClass { - wrapped := UnsafeNtpClockClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.ntpClockClass, - func (intern *ntpClockClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeNtpClockClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [NtpClockClass] is expected to work anymore. @@ -1463,17 +1463,20 @@ func UnsafeNtpClockClassToGlibNone(n *NtpClockClass) unsafe.Pointer { return unsafe.Pointer(n.native) } -// UnsafeNtpClockClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeNtpClockClassToGlibFull(n *NtpClockClass) unsafe.Pointer { - runtime.SetFinalizer(n.ntpClockClass, nil) - _p := unsafe.Pointer(n.native) - n.native = nil // NtpClockClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (n *NtpClockClass) ParentClass() *NetClientClockClass { + parent := UnsafeNetClientClockClassFromGlibBorrow(UnsafeNtpClockClassToGlibNone(n)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *NtpClockClass) {}, n) + return parent } + // PtpClockClass wraps GstPtpClockClass // // Opaque #GstPtpClockClass structure. +// +// PtpClockClass is the type struct for [PtpClock] type PtpClockClass struct { *ptpClockClass } @@ -1488,31 +1491,6 @@ func UnsafePtpClockClassFromGlibBorrow(p unsafe.Pointer) *PtpClockClass { return &PtpClockClass{&ptpClockClass{(*C.GstPtpClockClass)(p)}} } -// UnsafePtpClockClassFromGlibNone is used to convert raw C.GstPtpClockClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafePtpClockClassFromGlibNone(p unsafe.Pointer) *PtpClockClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafePtpClockClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.ptpClockClass, - func (intern *ptpClockClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafePtpClockClassFromGlibFull is used to convert raw C.GstPtpClockClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafePtpClockClassFromGlibFull(p unsafe.Pointer) *PtpClockClass { - wrapped := UnsafePtpClockClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.ptpClockClass, - func (intern *ptpClockClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafePtpClockClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [PtpClockClass] is expected to work anymore. @@ -1525,11 +1503,12 @@ func UnsafePtpClockClassToGlibNone(p *PtpClockClass) unsafe.Pointer { return unsafe.Pointer(p.native) } -// UnsafePtpClockClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafePtpClockClassToGlibFull(p *PtpClockClass) unsafe.Pointer { - runtime.SetFinalizer(p.ptpClockClass, nil) - _p := unsafe.Pointer(p.native) - p.native = nil // PtpClockClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (p *PtpClockClass) ParentClass() *gst.SystemClockClass { + parent := gst.UnsafeSystemClockClassFromGlibBorrow(UnsafePtpClockClassToGlibNone(p)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *PtpClockClass) {}, p) + return parent } + diff --git a/pkg/gstpbutils/gstpbutils.gen.go b/pkg/gstpbutils/gstpbutils.gen.go index 9aa54a4..7aea41c 100644 --- a/pkg/gstpbutils/gstpbutils.gen.go +++ b/pkg/gstpbutils/gstpbutils.gen.go @@ -18,6 +18,38 @@ import ( // #cgo CFLAGS: -Wno-deprecated-declarations // #include // extern void _gotk4_gstpbutils1_InstallPluginsResultFunc(GstInstallPluginsReturn, gpointer); +// extern gboolean _gotk4_gstpbutils1_AudioVisualizer_decide_allocation(GstAudioVisualizer*, GstQuery*); +// extern gboolean _gotk4_gstpbutils1_AudioVisualizer_render(GstAudioVisualizer*, GstBuffer*, GstVideoFrame*); +// extern gboolean _gotk4_gstpbutils1_AudioVisualizer_setup(GstAudioVisualizer*); +// gboolean _gotk4_gstpbutils1_AudioVisualizer_virtual_decide_allocation(void* fnptr, GstAudioVisualizer* carg0, GstQuery* carg1) { +// return ((gboolean (*) (GstAudioVisualizer*, GstQuery*))(fnptr))(carg0, carg1); +// } +// gboolean _gotk4_gstpbutils1_AudioVisualizer_virtual_render(void* fnptr, GstAudioVisualizer* carg0, GstBuffer* carg1, GstVideoFrame* carg2) { +// return ((gboolean (*) (GstAudioVisualizer*, GstBuffer*, GstVideoFrame*))(fnptr))(carg0, carg1, carg2); +// } +// gboolean _gotk4_gstpbutils1_AudioVisualizer_virtual_setup(void* fnptr, GstAudioVisualizer* carg0) { +// return ((gboolean (*) (GstAudioVisualizer*))(fnptr))(carg0); +// } +// extern void _gotk4_gstpbutils1_Discoverer_discovered(GstDiscoverer*, GstDiscovererInfo*, GError*); +// extern void _gotk4_gstpbutils1_Discoverer_finished(GstDiscoverer*); +// extern GstDiscovererInfo* _gotk4_gstpbutils1_Discoverer_load_serialize_info(GstDiscoverer*, gchar*); +// extern void _gotk4_gstpbutils1_Discoverer_source_setup(GstDiscoverer*, GstElement*); +// extern void _gotk4_gstpbutils1_Discoverer_starting(GstDiscoverer*); +// void _gotk4_gstpbutils1_Discoverer_virtual_discovered(void* fnptr, GstDiscoverer* carg0, GstDiscovererInfo* carg1, GError* carg2) { +// return ((void (*) (GstDiscoverer*, GstDiscovererInfo*, GError*))(fnptr))(carg0, carg1, carg2); +// } +// void _gotk4_gstpbutils1_Discoverer_virtual_finished(void* fnptr, GstDiscoverer* carg0) { +// return ((void (*) (GstDiscoverer*))(fnptr))(carg0); +// } +// GstDiscovererInfo* _gotk4_gstpbutils1_Discoverer_virtual_load_serialize_info(void* fnptr, GstDiscoverer* carg0, gchar* carg1) { +// return ((GstDiscovererInfo* (*) (GstDiscoverer*, gchar*))(fnptr))(carg0, carg1); +// } +// void _gotk4_gstpbutils1_Discoverer_virtual_source_setup(void* fnptr, GstDiscoverer* carg0, GstElement* carg1) { +// return ((void (*) (GstDiscoverer*, GstElement*))(fnptr))(carg0, carg1); +// } +// void _gotk4_gstpbutils1_Discoverer_virtual_starting(void* fnptr, GstDiscoverer* carg0) { +// return ((void (*) (GstDiscoverer*))(fnptr))(carg0); +// } import "C" // GType values. @@ -1412,6 +1444,7 @@ func EncodingListAllTargets(categoryname string) []EncodingTarget { } // EncodingListAvailableCategories wraps gst_encoding_list_available_categories +// // The function returns the following values: // // - goret []string @@ -1495,6 +1528,7 @@ func InstallPluginsAsync(details []string, ctx *InstallPluginsContext, fn Instal } // InstallPluginsInstallationInProgress wraps gst_install_plugins_installation_in_progress +// // The function returns the following values: // // - goret bool @@ -1516,6 +1550,7 @@ func InstallPluginsInstallationInProgress() bool { } // InstallPluginsSupported wraps gst_install_plugins_supported +// // The function returns the following values: // // - goret bool @@ -2350,6 +2385,7 @@ func PbUtilsInit() { } // PluginsBaseVersion wraps gst_plugins_base_version +// // The function returns the following values: // // - major uint: pointer to a guint to store the major version number, or %NULL @@ -2380,6 +2416,7 @@ func PluginsBaseVersion() (uint, uint, uint, uint) { } // PluginsBaseVersionString wraps gst_plugins_base_version_string +// // The function returns the following values: // // - goret string @@ -2462,6 +2499,58 @@ func UnsafeAudioVisualizerToGlibFull(c AudioVisualizer) unsafe.Pointer { return gobject.UnsafeObjectToGlibFull(c) } +// AudioVisualizerOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type AudioVisualizerOverrides[Instance AudioVisualizer] struct { + // gst.ElementOverrides allows you to override virtual methods from the parent class gst.Element + gst.ElementOverrides[Instance] + + // DecideAllocation allows you to override the implementation of the virtual method decide_allocation. + // The function takes the following parameters: + // + // - query *gst.Query + // + // The function returns the following values: + // + // - goret bool + DecideAllocation func(Instance, *gst.Query) bool + // Render allows you to override the implementation of the virtual method render. + // The function takes the following parameters: + // + // - audio *gst.Buffer + // - video *gstvideo.VideoFrame + // + // The function returns the following values: + // + // - goret bool + Render func(Instance, *gst.Buffer, *gstvideo.VideoFrame) bool + // Setup allows you to override the implementation of the virtual method setup. + // The function returns the following values: + // + // - goret bool + Setup func(Instance) bool +} + +// UnsafeApplyAudioVisualizerOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyAudioVisualizerOverrides[Instance AudioVisualizer](gclass unsafe.Pointer, overrides AudioVisualizerOverrides[Instance]) { + gst.UnsafeApplyElementOverrides(gclass, overrides.ElementOverrides) + + pclass := (*C.GstAudioVisualizerClass)(gclass) + + if overrides.DecideAllocation != nil { + pclass.decide_allocation = (*[0]byte)(C._gotk4_gstpbutils1_AudioVisualizer_decide_allocation) + } + + if overrides.Render != nil { + pclass.render = (*[0]byte)(C._gotk4_gstpbutils1_AudioVisualizer_render) + } + + if overrides.Setup != nil { + pclass.setup = (*[0]byte)(C._gotk4_gstpbutils1_AudioVisualizer_setup) + } +} + // DiscovererInstance is the instance type used by all types extending GstDiscoverer. It is used internally by the bindings. Users should use the interface [Discoverer] instead. type DiscovererInstance struct { _ [0]func() // equal guard @@ -2753,12 +2842,14 @@ func (discoverer *DiscovererInstance) Stop() { func (o *DiscovererInstance) ConnectDiscovered(fn func(Discoverer, DiscovererInfo, error)) gobject.SignalHandle { return o.Connect("discovered", fn) } + // ConnectFinished connects the provided callback to the "finished" signal // // Will be emitted in async mode when all pending URIs have been processed. func (o *DiscovererInstance) ConnectFinished(fn func(Discoverer)) gobject.SignalHandle { return o.Connect("finished", fn) } + // ConnectLoadSerializedInfo connects the provided callback to the "load-serialized-info" signal // // Retrieves information about a URI from and external source of information, @@ -2767,6 +2858,7 @@ func (o *DiscovererInstance) ConnectFinished(fn func(Discoverer)) gobject.Signal func (o *DiscovererInstance) ConnectLoadSerializedInfo(fn func(Discoverer, string) DiscovererInfoInstance) gobject.SignalHandle { return o.Connect("load-serialized-info", fn) } + // ConnectSourceSetup connects the provided callback to the "source-setup" signal // // This signal is emitted after the source element has been created for, so @@ -2779,12 +2871,74 @@ func (o *DiscovererInstance) ConnectLoadSerializedInfo(fn func(Discoverer, strin func (o *DiscovererInstance) ConnectSourceSetup(fn func(Discoverer, gst.Element)) gobject.SignalHandle { return o.Connect("source-setup", fn) } + // ConnectStarting connects the provided callback to the "starting" signal // // Will be emitted when the discover starts analyzing the pending URIs func (o *DiscovererInstance) ConnectStarting(fn func(Discoverer)) gobject.SignalHandle { return o.Connect("starting", fn) } + +// DiscovererOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type DiscovererOverrides[Instance Discoverer] struct { + // gobject.ObjectOverrides allows you to override virtual methods from the parent class gobject.Object + gobject.ObjectOverrides[Instance] + + // Discovered allows you to override the implementation of the virtual method discovered. + // The function takes the following parameters: + // + // - info DiscovererInfo + // - err error + Discovered func(Instance, DiscovererInfo, error) + // Finished allows you to override the implementation of the virtual method finished. + Finished func(Instance) + // LoadSerializeInfo allows you to override the implementation of the virtual method load_serialize_info. + // The function takes the following parameters: + // + // - uri string: the uri to load the info from + // + // The function returns the following values: + // + // - goret DiscovererInfo + LoadSerializeInfo func(Instance, string) DiscovererInfo + // SourceSetup allows you to override the implementation of the virtual method source_setup. + // The function takes the following parameters: + // + // - source gst.Element + SourceSetup func(Instance, gst.Element) + // Starting allows you to override the implementation of the virtual method starting. + Starting func(Instance) +} + +// UnsafeApplyDiscovererOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyDiscovererOverrides[Instance Discoverer](gclass unsafe.Pointer, overrides DiscovererOverrides[Instance]) { + gobject.UnsafeApplyObjectOverrides(gclass, overrides.ObjectOverrides) + + pclass := (*C.GstDiscovererClass)(gclass) + + if overrides.Discovered != nil { + pclass.discovered = (*[0]byte)(C._gotk4_gstpbutils1_Discoverer_discovered) + } + + if overrides.Finished != nil { + pclass.finished = (*[0]byte)(C._gotk4_gstpbutils1_Discoverer_finished) + } + + if overrides.LoadSerializeInfo != nil { + pclass.load_serialize_info = (*[0]byte)(C._gotk4_gstpbutils1_Discoverer_load_serialize_info) + } + + if overrides.SourceSetup != nil { + pclass.source_setup = (*[0]byte)(C._gotk4_gstpbutils1_Discoverer_source_setup) + } + + if overrides.Starting != nil { + pclass.starting = (*[0]byte)(C._gotk4_gstpbutils1_Discoverer_starting) + } +} + // DiscovererInfoInstance is the instance type used by all types extending GstDiscovererInfo. It is used internally by the bindings. Users should use the interface [DiscovererInfo] instead. type DiscovererInfoInstance struct { _ [0]func() // equal guard @@ -2801,11 +2955,13 @@ type DiscovererInfo interface { upcastToGstDiscovererInfo() *DiscovererInfoInstance // Copy wraps gst_discoverer_info_copy + // // The function returns the following values: // // - goret DiscovererInfo Copy() DiscovererInfo // GetAudioStreams wraps gst_discoverer_info_get_audio_streams + // // The function returns the following values: // // - goret []DiscovererAudioInfo @@ -2813,6 +2969,7 @@ type DiscovererInfo interface { // Finds all the #GstDiscovererAudioInfo contained in @info GetAudioStreams() []DiscovererAudioInfo // GetContainerStreams wraps gst_discoverer_info_get_container_streams + // // The function returns the following values: // // - goret []DiscovererContainerInfo @@ -2820,16 +2977,19 @@ type DiscovererInfo interface { // Finds all the #GstDiscovererContainerInfo contained in @info GetContainerStreams() []DiscovererContainerInfo // GetDuration wraps gst_discoverer_info_get_duration + // // The function returns the following values: // // - goret gst.ClockTime GetDuration() gst.ClockTime // GetLive wraps gst_discoverer_info_get_live + // // The function returns the following values: // // - goret bool GetLive() bool // GetMisc wraps gst_discoverer_info_get_misc + // // The function returns the following values: // // - goret *gst.Structure (nullable) @@ -2839,6 +2999,7 @@ type DiscovererInfo interface { // #gst_discoverer_info_get_missing_elements_installer_details GetMisc() *gst.Structure // GetMissingElementsInstallerDetails wraps gst_discoverer_info_get_missing_elements_installer_details + // // The function returns the following values: // // - goret []string @@ -2846,21 +3007,25 @@ type DiscovererInfo interface { // Get the installer details for missing elements GetMissingElementsInstallerDetails() []string // GetResult wraps gst_discoverer_info_get_result + // // The function returns the following values: // // - goret DiscovererResult GetResult() DiscovererResult // GetSeekable wraps gst_discoverer_info_get_seekable + // // The function returns the following values: // // - goret bool GetSeekable() bool // GetStreamInfo wraps gst_discoverer_info_get_stream_info + // // The function returns the following values: // // - goret DiscovererStreamInfo (nullable) GetStreamInfo() DiscovererStreamInfo // GetStreamList wraps gst_discoverer_info_get_stream_list + // // The function returns the following values: // // - goret []DiscovererStreamInfo @@ -2879,6 +3044,7 @@ type DiscovererInfo interface { // given @streamtype. GetStreams(gobject.Type) []DiscovererStreamInfo // GetSubtitleStreams wraps gst_discoverer_info_get_subtitle_streams + // // The function returns the following values: // // - goret []DiscovererSubtitleInfo @@ -2886,6 +3052,7 @@ type DiscovererInfo interface { // Finds all the #GstDiscovererSubtitleInfo contained in @info GetSubtitleStreams() []DiscovererSubtitleInfo // GetTags wraps gst_discoverer_info_get_tags + // // The function returns the following values: // // - goret *gst.TagList (nullable) @@ -2894,16 +3061,19 @@ type DiscovererInfo interface { // Deprecated: (since 1.20.0) Use gst_discoverer_{container,stream}_info_get_tags() instead. GetTags() *gst.TagList // GetToc wraps gst_discoverer_info_get_toc + // // The function returns the following values: // // - goret *gst.Toc (nullable) GetToc() *gst.Toc // GetURI wraps gst_discoverer_info_get_uri + // // The function returns the following values: // // - goret string GetURI() string // GetVideoStreams wraps gst_discoverer_info_get_video_streams + // // The function returns the following values: // // - goret []DiscovererVideoInfo @@ -2947,6 +3117,7 @@ func UnsafeDiscovererInfoToGlibFull(c DiscovererInfo) unsafe.Pointer { } // Copy wraps gst_discoverer_info_copy +// // The function returns the following values: // // - goret DiscovererInfo @@ -2967,6 +3138,7 @@ func (ptr *DiscovererInfoInstance) Copy() DiscovererInfo { } // GetAudioStreams wraps gst_discoverer_info_get_audio_streams +// // The function returns the following values: // // - goret []DiscovererAudioInfo @@ -2996,6 +3168,7 @@ func (info *DiscovererInfoInstance) GetAudioStreams() []DiscovererAudioInfo { } // GetContainerStreams wraps gst_discoverer_info_get_container_streams +// // The function returns the following values: // // - goret []DiscovererContainerInfo @@ -3025,6 +3198,7 @@ func (info *DiscovererInfoInstance) GetContainerStreams() []DiscovererContainerI } // GetDuration wraps gst_discoverer_info_get_duration +// // The function returns the following values: // // - goret gst.ClockTime @@ -3045,6 +3219,7 @@ func (info *DiscovererInfoInstance) GetDuration() gst.ClockTime { } // GetLive wraps gst_discoverer_info_get_live +// // The function returns the following values: // // - goret bool @@ -3067,6 +3242,7 @@ func (info *DiscovererInfoInstance) GetLive() bool { } // GetMisc wraps gst_discoverer_info_get_misc +// // The function returns the following values: // // - goret *gst.Structure (nullable) @@ -3093,6 +3269,7 @@ func (info *DiscovererInfoInstance) GetMisc() *gst.Structure { } // GetMissingElementsInstallerDetails wraps gst_discoverer_info_get_missing_elements_installer_details +// // The function returns the following values: // // - goret []string @@ -3117,6 +3294,7 @@ func (info *DiscovererInfoInstance) GetMissingElementsInstallerDetails() []strin } // GetResult wraps gst_discoverer_info_get_result +// // The function returns the following values: // // - goret DiscovererResult @@ -3137,6 +3315,7 @@ func (info *DiscovererInfoInstance) GetResult() DiscovererResult { } // GetSeekable wraps gst_discoverer_info_get_seekable +// // The function returns the following values: // // - goret bool @@ -3159,6 +3338,7 @@ func (info *DiscovererInfoInstance) GetSeekable() bool { } // GetStreamInfo wraps gst_discoverer_info_get_stream_info +// // The function returns the following values: // // - goret DiscovererStreamInfo (nullable) @@ -3181,6 +3361,7 @@ func (info *DiscovererInfoInstance) GetStreamInfo() DiscovererStreamInfo { } // GetStreamList wraps gst_discoverer_info_get_stream_list +// // The function returns the following values: // // - goret []DiscovererStreamInfo @@ -3246,6 +3427,7 @@ func (info *DiscovererInfoInstance) GetStreams(streamtype gobject.Type) []Discov } // GetSubtitleStreams wraps gst_discoverer_info_get_subtitle_streams +// // The function returns the following values: // // - goret []DiscovererSubtitleInfo @@ -3275,6 +3457,7 @@ func (info *DiscovererInfoInstance) GetSubtitleStreams() []DiscovererSubtitleInf } // GetTags wraps gst_discoverer_info_get_tags +// // The function returns the following values: // // - goret *gst.TagList (nullable) @@ -3300,6 +3483,7 @@ func (info *DiscovererInfoInstance) GetTags() *gst.TagList { } // GetToc wraps gst_discoverer_info_get_toc +// // The function returns the following values: // // - goret *gst.Toc (nullable) @@ -3322,6 +3506,7 @@ func (info *DiscovererInfoInstance) GetToc() *gst.Toc { } // GetURI wraps gst_discoverer_info_get_uri +// // The function returns the following values: // // - goret string @@ -3342,6 +3527,7 @@ func (info *DiscovererInfoInstance) GetURI() string { } // GetVideoStreams wraps gst_discoverer_info_get_video_streams +// // The function returns the following values: // // - goret []DiscovererVideoInfo @@ -3400,11 +3586,13 @@ type DiscovererStreamInfo interface { upcastToGstDiscovererStreamInfo() *DiscovererStreamInfoInstance // GetCaps wraps gst_discoverer_stream_info_get_caps + // // The function returns the following values: // // - goret *gst.Caps (nullable) GetCaps() *gst.Caps // GetMisc wraps gst_discoverer_stream_info_get_misc + // // The function returns the following values: // // - goret *gst.Structure (nullable) @@ -3414,36 +3602,43 @@ type DiscovererStreamInfo interface { // #gst_discoverer_info_get_missing_elements_installer_details GetMisc() *gst.Structure // GetNext wraps gst_discoverer_stream_info_get_next + // // The function returns the following values: // // - goret DiscovererStreamInfo (nullable) GetNext() DiscovererStreamInfo // GetPrevious wraps gst_discoverer_stream_info_get_previous + // // The function returns the following values: // // - goret DiscovererStreamInfo (nullable) GetPrevious() DiscovererStreamInfo // GetStreamID wraps gst_discoverer_stream_info_get_stream_id + // // The function returns the following values: // // - goret string (nullable) GetStreamID() string // GetStreamNumber wraps gst_discoverer_stream_info_get_stream_number + // // The function returns the following values: // // - goret int GetStreamNumber() int // GetStreamTypeNick wraps gst_discoverer_stream_info_get_stream_type_nick + // // The function returns the following values: // // - goret string GetStreamTypeNick() string // GetTags wraps gst_discoverer_stream_info_get_tags + // // The function returns the following values: // // - goret *gst.TagList (nullable) GetTags() *gst.TagList // GetToc wraps gst_discoverer_stream_info_get_toc + // // The function returns the following values: // // - goret *gst.Toc (nullable) @@ -3485,6 +3680,7 @@ func UnsafeDiscovererStreamInfoToGlibFull(c DiscovererStreamInfo) unsafe.Pointer } // GetCaps wraps gst_discoverer_stream_info_get_caps +// // The function returns the following values: // // - goret *gst.Caps (nullable) @@ -3507,6 +3703,7 @@ func (info *DiscovererStreamInfoInstance) GetCaps() *gst.Caps { } // GetMisc wraps gst_discoverer_stream_info_get_misc +// // The function returns the following values: // // - goret *gst.Structure (nullable) @@ -3533,6 +3730,7 @@ func (info *DiscovererStreamInfoInstance) GetMisc() *gst.Structure { } // GetNext wraps gst_discoverer_stream_info_get_next +// // The function returns the following values: // // - goret DiscovererStreamInfo (nullable) @@ -3555,6 +3753,7 @@ func (info *DiscovererStreamInfoInstance) GetNext() DiscovererStreamInfo { } // GetPrevious wraps gst_discoverer_stream_info_get_previous +// // The function returns the following values: // // - goret DiscovererStreamInfo (nullable) @@ -3577,6 +3776,7 @@ func (info *DiscovererStreamInfoInstance) GetPrevious() DiscovererStreamInfo { } // GetStreamID wraps gst_discoverer_stream_info_get_stream_id +// // The function returns the following values: // // - goret string (nullable) @@ -3599,6 +3799,7 @@ func (info *DiscovererStreamInfoInstance) GetStreamID() string { } // GetStreamNumber wraps gst_discoverer_stream_info_get_stream_number +// // The function returns the following values: // // - goret int @@ -3619,6 +3820,7 @@ func (info *DiscovererStreamInfoInstance) GetStreamNumber() int { } // GetStreamTypeNick wraps gst_discoverer_stream_info_get_stream_type_nick +// // The function returns the following values: // // - goret string @@ -3639,6 +3841,7 @@ func (info *DiscovererStreamInfoInstance) GetStreamTypeNick() string { } // GetTags wraps gst_discoverer_stream_info_get_tags +// // The function returns the following values: // // - goret *gst.TagList (nullable) @@ -3661,6 +3864,7 @@ func (info *DiscovererStreamInfoInstance) GetTags() *gst.TagList { } // GetToc wraps gst_discoverer_stream_info_get_toc +// // The function returns the following values: // // - goret *gst.Toc (nullable) @@ -3699,6 +3903,7 @@ type DiscovererSubtitleInfo interface { upcastToGstDiscovererSubtitleInfo() *DiscovererSubtitleInfoInstance // GetLanguage wraps gst_discoverer_subtitle_info_get_language + // // The function returns the following values: // // - goret string (nullable) @@ -3742,6 +3947,7 @@ func UnsafeDiscovererSubtitleInfoToGlibFull(c DiscovererSubtitleInfo) unsafe.Poi } // GetLanguage wraps gst_discoverer_subtitle_info_get_language +// // The function returns the following values: // // - goret string (nullable) @@ -3779,56 +3985,67 @@ type DiscovererVideoInfo interface { upcastToGstDiscovererVideoInfo() *DiscovererVideoInfoInstance // GetBitrate wraps gst_discoverer_video_info_get_bitrate + // // The function returns the following values: // // - goret uint GetBitrate() uint // GetDepth wraps gst_discoverer_video_info_get_depth + // // The function returns the following values: // // - goret uint GetDepth() uint // GetFramerateDenom wraps gst_discoverer_video_info_get_framerate_denom + // // The function returns the following values: // // - goret uint GetFramerateDenom() uint // GetFramerateNum wraps gst_discoverer_video_info_get_framerate_num + // // The function returns the following values: // // - goret uint GetFramerateNum() uint // GetHeight wraps gst_discoverer_video_info_get_height + // // The function returns the following values: // // - goret uint GetHeight() uint // GetMaxBitrate wraps gst_discoverer_video_info_get_max_bitrate + // // The function returns the following values: // // - goret uint GetMaxBitrate() uint // GetParDenom wraps gst_discoverer_video_info_get_par_denom + // // The function returns the following values: // // - goret uint GetParDenom() uint // GetParNum wraps gst_discoverer_video_info_get_par_num + // // The function returns the following values: // // - goret uint GetParNum() uint // GetWidth wraps gst_discoverer_video_info_get_width + // // The function returns the following values: // // - goret uint GetWidth() uint // IsImage wraps gst_discoverer_video_info_is_image + // // The function returns the following values: // // - goret bool IsImage() bool // IsInterlaced wraps gst_discoverer_video_info_is_interlaced + // // The function returns the following values: // // - goret bool @@ -3872,6 +4089,7 @@ func UnsafeDiscovererVideoInfoToGlibFull(c DiscovererVideoInfo) unsafe.Pointer { } // GetBitrate wraps gst_discoverer_video_info_get_bitrate +// // The function returns the following values: // // - goret uint @@ -3892,6 +4110,7 @@ func (info *DiscovererVideoInfoInstance) GetBitrate() uint { } // GetDepth wraps gst_discoverer_video_info_get_depth +// // The function returns the following values: // // - goret uint @@ -3912,6 +4131,7 @@ func (info *DiscovererVideoInfoInstance) GetDepth() uint { } // GetFramerateDenom wraps gst_discoverer_video_info_get_framerate_denom +// // The function returns the following values: // // - goret uint @@ -3932,6 +4152,7 @@ func (info *DiscovererVideoInfoInstance) GetFramerateDenom() uint { } // GetFramerateNum wraps gst_discoverer_video_info_get_framerate_num +// // The function returns the following values: // // - goret uint @@ -3952,6 +4173,7 @@ func (info *DiscovererVideoInfoInstance) GetFramerateNum() uint { } // GetHeight wraps gst_discoverer_video_info_get_height +// // The function returns the following values: // // - goret uint @@ -3972,6 +4194,7 @@ func (info *DiscovererVideoInfoInstance) GetHeight() uint { } // GetMaxBitrate wraps gst_discoverer_video_info_get_max_bitrate +// // The function returns the following values: // // - goret uint @@ -3992,6 +4215,7 @@ func (info *DiscovererVideoInfoInstance) GetMaxBitrate() uint { } // GetParDenom wraps gst_discoverer_video_info_get_par_denom +// // The function returns the following values: // // - goret uint @@ -4012,6 +4236,7 @@ func (info *DiscovererVideoInfoInstance) GetParDenom() uint { } // GetParNum wraps gst_discoverer_video_info_get_par_num +// // The function returns the following values: // // - goret uint @@ -4032,6 +4257,7 @@ func (info *DiscovererVideoInfoInstance) GetParNum() uint { } // GetWidth wraps gst_discoverer_video_info_get_width +// // The function returns the following values: // // - goret uint @@ -4052,6 +4278,7 @@ func (info *DiscovererVideoInfoInstance) GetWidth() uint { } // IsImage wraps gst_discoverer_video_info_is_image +// // The function returns the following values: // // - goret bool @@ -4074,6 +4301,7 @@ func (info *DiscovererVideoInfoInstance) IsImage() bool { } // IsInterlaced wraps gst_discoverer_video_info_is_interlaced +// // The function returns the following values: // // - goret bool @@ -4112,6 +4340,7 @@ type EncodingProfile interface { upcastToGstEncodingProfile() *EncodingProfileInstance // Copy wraps gst_encoding_profile_copy + // // The function returns the following values: // // - goret EncodingProfile @@ -4119,6 +4348,7 @@ type EncodingProfile interface { // Makes a deep copy of @self Copy() EncodingProfile // GetAllowDynamicOutput wraps gst_encoding_profile_get_allow_dynamic_output + // // The function returns the following values: // // - goret bool @@ -4127,26 +4357,31 @@ type EncodingProfile interface { // later during the encoding. GetAllowDynamicOutput() bool // GetDescription wraps gst_encoding_profile_get_description + // // The function returns the following values: // // - goret string (nullable) GetDescription() string // GetElementProperties wraps gst_encoding_profile_get_element_properties + // // The function returns the following values: // // - goret *gst.Structure (nullable) GetElementProperties() *gst.Structure // GetFileExtension wraps gst_encoding_profile_get_file_extension + // // The function returns the following values: // // - goret string (nullable) GetFileExtension() string // GetFormat wraps gst_encoding_profile_get_format + // // The function returns the following values: // // - goret *gst.Caps GetFormat() *gst.Caps // GetInputCaps wraps gst_encoding_profile_get_input_caps + // // The function returns the following values: // // - goret *gst.Caps @@ -4154,41 +4389,49 @@ type EncodingProfile interface { // Computes the full output caps that this @profile will be able to consume. GetInputCaps() *gst.Caps // GetName wraps gst_encoding_profile_get_name + // // The function returns the following values: // // - goret string (nullable) GetName() string // GetPresence wraps gst_encoding_profile_get_presence + // // The function returns the following values: // // - goret uint GetPresence() uint // GetPreset wraps gst_encoding_profile_get_preset + // // The function returns the following values: // // - goret string (nullable) GetPreset() string // GetPresetName wraps gst_encoding_profile_get_preset_name + // // The function returns the following values: // // - goret string (nullable) GetPresetName() string // GetRestriction wraps gst_encoding_profile_get_restriction + // // The function returns the following values: // // - goret *gst.Caps (nullable) GetRestriction() *gst.Caps // GetSingleSegment wraps gst_encoding_profile_get_single_segment + // // The function returns the following values: // // - goret bool GetSingleSegment() bool // GetTypeNick wraps gst_encoding_profile_get_type_nick + // // The function returns the following values: // // - goret string GetTypeNick() string // IsEnabled wraps gst_encoding_profile_is_enabled + // // The function returns the following values: // // - goret bool @@ -4436,6 +4679,7 @@ func EncodingProfileFromDiscoverer(info DiscovererInfo) EncodingProfile { } // Copy wraps gst_encoding_profile_copy +// // The function returns the following values: // // - goret EncodingProfile @@ -4458,6 +4702,7 @@ func (self *EncodingProfileInstance) Copy() EncodingProfile { } // GetAllowDynamicOutput wraps gst_encoding_profile_get_allow_dynamic_output +// // The function returns the following values: // // - goret bool @@ -4483,6 +4728,7 @@ func (profile *EncodingProfileInstance) GetAllowDynamicOutput() bool { } // GetDescription wraps gst_encoding_profile_get_description +// // The function returns the following values: // // - goret string (nullable) @@ -4505,6 +4751,7 @@ func (profile *EncodingProfileInstance) GetDescription() string { } // GetElementProperties wraps gst_encoding_profile_get_element_properties +// // The function returns the following values: // // - goret *gst.Structure (nullable) @@ -4527,6 +4774,7 @@ func (self *EncodingProfileInstance) GetElementProperties() *gst.Structure { } // GetFileExtension wraps gst_encoding_profile_get_file_extension +// // The function returns the following values: // // - goret string (nullable) @@ -4549,6 +4797,7 @@ func (profile *EncodingProfileInstance) GetFileExtension() string { } // GetFormat wraps gst_encoding_profile_get_format +// // The function returns the following values: // // - goret *gst.Caps @@ -4569,6 +4818,7 @@ func (profile *EncodingProfileInstance) GetFormat() *gst.Caps { } // GetInputCaps wraps gst_encoding_profile_get_input_caps +// // The function returns the following values: // // - goret *gst.Caps @@ -4591,6 +4841,7 @@ func (profile *EncodingProfileInstance) GetInputCaps() *gst.Caps { } // GetName wraps gst_encoding_profile_get_name +// // The function returns the following values: // // - goret string (nullable) @@ -4613,6 +4864,7 @@ func (profile *EncodingProfileInstance) GetName() string { } // GetPresence wraps gst_encoding_profile_get_presence +// // The function returns the following values: // // - goret uint @@ -4633,6 +4885,7 @@ func (profile *EncodingProfileInstance) GetPresence() uint { } // GetPreset wraps gst_encoding_profile_get_preset +// // The function returns the following values: // // - goret string (nullable) @@ -4655,6 +4908,7 @@ func (profile *EncodingProfileInstance) GetPreset() string { } // GetPresetName wraps gst_encoding_profile_get_preset_name +// // The function returns the following values: // // - goret string (nullable) @@ -4677,6 +4931,7 @@ func (profile *EncodingProfileInstance) GetPresetName() string { } // GetRestriction wraps gst_encoding_profile_get_restriction +// // The function returns the following values: // // - goret *gst.Caps (nullable) @@ -4699,6 +4954,7 @@ func (profile *EncodingProfileInstance) GetRestriction() *gst.Caps { } // GetSingleSegment wraps gst_encoding_profile_get_single_segment +// // The function returns the following values: // // - goret bool @@ -4721,6 +4977,7 @@ func (profile *EncodingProfileInstance) GetSingleSegment() bool { } // GetTypeNick wraps gst_encoding_profile_get_type_nick +// // The function returns the following values: // // - goret string @@ -4741,6 +4998,7 @@ func (profile *EncodingProfileInstance) GetTypeNick() string { } // IsEnabled wraps gst_encoding_profile_is_enabled +// // The function returns the following values: // // - goret bool @@ -5089,21 +5347,25 @@ type EncodingTarget interface { // count. AddProfile(EncodingProfile) bool // GetCategory wraps gst_encoding_target_get_category + // // The function returns the following values: // // - goret string GetCategory() string // GetDescription wraps gst_encoding_target_get_description + // // The function returns the following values: // // - goret string GetDescription() string // GetName wraps gst_encoding_target_get_name + // // The function returns the following values: // // - goret string GetName() string // GetPath wraps gst_encoding_target_get_path + // // The function returns the following values: // // - goret string (nullable) @@ -5119,11 +5381,13 @@ type EncodingTarget interface { // - goret EncodingProfile (nullable) GetProfile(string) EncodingProfile // GetProfiles wraps gst_encoding_target_get_profiles + // // The function returns the following values: // // - goret []EncodingProfile GetProfiles() []EncodingProfile // Save wraps gst_encoding_target_save + // // The function returns the following values: // // - goret bool @@ -5300,6 +5564,7 @@ func (target *EncodingTargetInstance) AddProfile(profile EncodingProfile) bool { } // GetCategory wraps gst_encoding_target_get_category +// // The function returns the following values: // // - goret string @@ -5320,6 +5585,7 @@ func (target *EncodingTargetInstance) GetCategory() string { } // GetDescription wraps gst_encoding_target_get_description +// // The function returns the following values: // // - goret string @@ -5340,6 +5606,7 @@ func (target *EncodingTargetInstance) GetDescription() string { } // GetName wraps gst_encoding_target_get_name +// // The function returns the following values: // // - goret string @@ -5360,6 +5627,7 @@ func (target *EncodingTargetInstance) GetName() string { } // GetPath wraps gst_encoding_target_get_path +// // The function returns the following values: // // - goret string (nullable) @@ -5413,6 +5681,7 @@ func (target *EncodingTargetInstance) GetProfile(name string) EncodingProfile { } // GetProfiles wraps gst_encoding_target_get_profiles +// // The function returns the following values: // // - goret []EncodingProfile @@ -5440,6 +5709,7 @@ func (target *EncodingTargetInstance) GetProfiles() []EncodingProfile { } // Save wraps gst_encoding_target_save +// // The function returns the following values: // // - goret bool @@ -5524,6 +5794,7 @@ type EncodingVideoProfile interface { upcastToGstEncodingVideoProfile() *EncodingVideoProfileInstance // GetPass wraps gst_encoding_video_profile_get_pass + // // The function returns the following values: // // - goret uint @@ -5531,6 +5802,7 @@ type EncodingVideoProfile interface { // Get the pass number if this is part of a multi-pass profile. GetPass() uint // GetVariableframerate wraps gst_encoding_video_profile_get_variableframerate + // // The function returns the following values: // // - goret bool @@ -5653,6 +5925,7 @@ func NewEncodingVideoProfile(format *gst.Caps, preset string, restriction *gst.C } // GetPass wraps gst_encoding_video_profile_get_pass +// // The function returns the following values: // // - goret uint @@ -5675,6 +5948,7 @@ func (prof *EncodingVideoProfileInstance) GetPass() uint { } // GetVariableframerate wraps gst_encoding_video_profile_get_variableframerate +// // The function returns the following values: // // - goret bool @@ -5760,36 +6034,43 @@ type DiscovererAudioInfo interface { upcastToGstDiscovererAudioInfo() *DiscovererAudioInfoInstance // GetBitrate wraps gst_discoverer_audio_info_get_bitrate + // // The function returns the following values: // // - goret uint GetBitrate() uint // GetChannelMask wraps gst_discoverer_audio_info_get_channel_mask + // // The function returns the following values: // // - goret uint64 GetChannelMask() uint64 // GetChannels wraps gst_discoverer_audio_info_get_channels + // // The function returns the following values: // // - goret uint GetChannels() uint // GetDepth wraps gst_discoverer_audio_info_get_depth + // // The function returns the following values: // // - goret uint GetDepth() uint // GetLanguage wraps gst_discoverer_audio_info_get_language + // // The function returns the following values: // // - goret string (nullable) GetLanguage() string // GetMaxBitrate wraps gst_discoverer_audio_info_get_max_bitrate + // // The function returns the following values: // // - goret uint GetMaxBitrate() uint // GetSampleRate wraps gst_discoverer_audio_info_get_sample_rate + // // The function returns the following values: // // - goret uint @@ -5833,6 +6114,7 @@ func UnsafeDiscovererAudioInfoToGlibFull(c DiscovererAudioInfo) unsafe.Pointer { } // GetBitrate wraps gst_discoverer_audio_info_get_bitrate +// // The function returns the following values: // // - goret uint @@ -5853,6 +6135,7 @@ func (info *DiscovererAudioInfoInstance) GetBitrate() uint { } // GetChannelMask wraps gst_discoverer_audio_info_get_channel_mask +// // The function returns the following values: // // - goret uint64 @@ -5873,6 +6156,7 @@ func (info *DiscovererAudioInfoInstance) GetChannelMask() uint64 { } // GetChannels wraps gst_discoverer_audio_info_get_channels +// // The function returns the following values: // // - goret uint @@ -5893,6 +6177,7 @@ func (info *DiscovererAudioInfoInstance) GetChannels() uint { } // GetDepth wraps gst_discoverer_audio_info_get_depth +// // The function returns the following values: // // - goret uint @@ -5913,6 +6198,7 @@ func (info *DiscovererAudioInfoInstance) GetDepth() uint { } // GetLanguage wraps gst_discoverer_audio_info_get_language +// // The function returns the following values: // // - goret string (nullable) @@ -5935,6 +6221,7 @@ func (info *DiscovererAudioInfoInstance) GetLanguage() string { } // GetMaxBitrate wraps gst_discoverer_audio_info_get_max_bitrate +// // The function returns the following values: // // - goret uint @@ -5955,6 +6242,7 @@ func (info *DiscovererAudioInfoInstance) GetMaxBitrate() uint { } // GetSampleRate wraps gst_discoverer_audio_info_get_sample_rate +// // The function returns the following values: // // - goret uint @@ -5990,11 +6278,13 @@ type DiscovererContainerInfo interface { upcastToGstDiscovererContainerInfo() *DiscovererContainerInfoInstance // GetStreams wraps gst_discoverer_container_info_get_streams + // // The function returns the following values: // // - goret []DiscovererStreamInfo GetStreams() []DiscovererStreamInfo // GetTags wraps gst_discoverer_container_info_get_tags + // // The function returns the following values: // // - goret *gst.TagList (nullable) @@ -6038,6 +6328,7 @@ func UnsafeDiscovererContainerInfoToGlibFull(c DiscovererContainerInfo) unsafe.P } // GetStreams wraps gst_discoverer_container_info_get_streams +// // The function returns the following values: // // - goret []DiscovererStreamInfo @@ -6065,6 +6356,7 @@ func (info *DiscovererContainerInfoInstance) GetStreams() []DiscovererStreamInfo } // GetTags wraps gst_discoverer_container_info_get_tags +// // The function returns the following values: // // - goret *gst.TagList (nullable) @@ -6231,6 +6523,7 @@ type EncodingContainerProfile interface { // @profile. ContainsProfile(EncodingProfile) bool // GetProfiles wraps gst_encoding_container_profile_get_profiles + // // The function returns the following values: // // - goret []EncodingProfile @@ -6391,6 +6684,7 @@ func (container *EncodingContainerProfileInstance) ContainsProfile(profile Encod } // GetProfiles wraps gst_encoding_container_profile_get_profiles +// // The function returns the following values: // // - goret []EncodingProfile @@ -6418,6 +6712,8 @@ func (profile *EncodingContainerProfileInstance) GetProfiles() []EncodingProfile } // AudioVisualizerClass wraps GstAudioVisualizerClass +// +// AudioVisualizerClass is the type struct for [AudioVisualizer] type AudioVisualizerClass struct { *audioVisualizerClass } @@ -6432,31 +6728,6 @@ func UnsafeAudioVisualizerClassFromGlibBorrow(p unsafe.Pointer) *AudioVisualizer return &AudioVisualizerClass{&audioVisualizerClass{(*C.GstAudioVisualizerClass)(p)}} } -// UnsafeAudioVisualizerClassFromGlibNone is used to convert raw C.GstAudioVisualizerClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeAudioVisualizerClassFromGlibNone(p unsafe.Pointer) *AudioVisualizerClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeAudioVisualizerClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.audioVisualizerClass, - func (intern *audioVisualizerClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeAudioVisualizerClassFromGlibFull is used to convert raw C.GstAudioVisualizerClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeAudioVisualizerClassFromGlibFull(p unsafe.Pointer) *AudioVisualizerClass { - wrapped := UnsafeAudioVisualizerClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.audioVisualizerClass, - func (intern *audioVisualizerClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeAudioVisualizerClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [AudioVisualizerClass] is expected to work anymore. @@ -6469,15 +6740,18 @@ func UnsafeAudioVisualizerClassToGlibNone(a *AudioVisualizerClass) unsafe.Pointe return unsafe.Pointer(a.native) } -// UnsafeAudioVisualizerClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeAudioVisualizerClassToGlibFull(a *AudioVisualizerClass) unsafe.Pointer { - runtime.SetFinalizer(a.audioVisualizerClass, nil) - _p := unsafe.Pointer(a.native) - a.native = nil // AudioVisualizerClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (a *AudioVisualizerClass) ParentClass() *gst.ElementClass { + parent := gst.UnsafeElementClassFromGlibBorrow(UnsafeAudioVisualizerClassToGlibNone(a)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *AudioVisualizerClass) {}, a) + return parent } + // DiscovererClass wraps GstDiscovererClass +// +// DiscovererClass is the type struct for [Discoverer] type DiscovererClass struct { *discovererClass } @@ -6492,31 +6766,6 @@ func UnsafeDiscovererClassFromGlibBorrow(p unsafe.Pointer) *DiscovererClass { return &DiscovererClass{&discovererClass{(*C.GstDiscovererClass)(p)}} } -// UnsafeDiscovererClassFromGlibNone is used to convert raw C.GstDiscovererClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeDiscovererClassFromGlibNone(p unsafe.Pointer) *DiscovererClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeDiscovererClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.discovererClass, - func (intern *discovererClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeDiscovererClassFromGlibFull is used to convert raw C.GstDiscovererClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeDiscovererClassFromGlibFull(p unsafe.Pointer) *DiscovererClass { - wrapped := UnsafeDiscovererClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.discovererClass, - func (intern *discovererClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeDiscovererClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [DiscovererClass] is expected to work anymore. @@ -6529,15 +6778,18 @@ func UnsafeDiscovererClassToGlibNone(d *DiscovererClass) unsafe.Pointer { return unsafe.Pointer(d.native) } -// UnsafeDiscovererClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeDiscovererClassToGlibFull(d *DiscovererClass) unsafe.Pointer { - runtime.SetFinalizer(d.discovererClass, nil) - _p := unsafe.Pointer(d.native) - d.native = nil // DiscovererClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (d *DiscovererClass) ParentClass() *gobject.ObjectClass { + parent := gobject.UnsafeObjectClassFromGlibBorrow(UnsafeDiscovererClassToGlibNone(d)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *DiscovererClass) {}, d) + return parent } + // EncodingAudioProfileClass wraps GstEncodingAudioProfileClass +// +// EncodingAudioProfileClass is the type struct for [EncodingAudioProfile] type EncodingAudioProfileClass struct { *encodingAudioProfileClass } @@ -6552,31 +6804,6 @@ func UnsafeEncodingAudioProfileClassFromGlibBorrow(p unsafe.Pointer) *EncodingAu return &EncodingAudioProfileClass{&encodingAudioProfileClass{(*C.GstEncodingAudioProfileClass)(p)}} } -// UnsafeEncodingAudioProfileClassFromGlibNone is used to convert raw C.GstEncodingAudioProfileClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeEncodingAudioProfileClassFromGlibNone(p unsafe.Pointer) *EncodingAudioProfileClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeEncodingAudioProfileClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.encodingAudioProfileClass, - func (intern *encodingAudioProfileClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeEncodingAudioProfileClassFromGlibFull is used to convert raw C.GstEncodingAudioProfileClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeEncodingAudioProfileClassFromGlibFull(p unsafe.Pointer) *EncodingAudioProfileClass { - wrapped := UnsafeEncodingAudioProfileClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.encodingAudioProfileClass, - func (intern *encodingAudioProfileClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeEncodingAudioProfileClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [EncodingAudioProfileClass] is expected to work anymore. @@ -6589,15 +6816,18 @@ func UnsafeEncodingAudioProfileClassToGlibNone(e *EncodingAudioProfileClass) uns return unsafe.Pointer(e.native) } -// UnsafeEncodingAudioProfileClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeEncodingAudioProfileClassToGlibFull(e *EncodingAudioProfileClass) unsafe.Pointer { - runtime.SetFinalizer(e.encodingAudioProfileClass, nil) - _p := unsafe.Pointer(e.native) - e.native = nil // EncodingAudioProfileClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (e *EncodingAudioProfileClass) ParentClass() *EncodingProfileClass { + parent := UnsafeEncodingProfileClassFromGlibBorrow(UnsafeEncodingAudioProfileClassToGlibNone(e)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *EncodingAudioProfileClass) {}, e) + return parent } + // EncodingContainerProfileClass wraps GstEncodingContainerProfileClass +// +// EncodingContainerProfileClass is the type struct for [EncodingContainerProfile] type EncodingContainerProfileClass struct { *encodingContainerProfileClass } @@ -6612,31 +6842,6 @@ func UnsafeEncodingContainerProfileClassFromGlibBorrow(p unsafe.Pointer) *Encodi return &EncodingContainerProfileClass{&encodingContainerProfileClass{(*C.GstEncodingContainerProfileClass)(p)}} } -// UnsafeEncodingContainerProfileClassFromGlibNone is used to convert raw C.GstEncodingContainerProfileClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeEncodingContainerProfileClassFromGlibNone(p unsafe.Pointer) *EncodingContainerProfileClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeEncodingContainerProfileClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.encodingContainerProfileClass, - func (intern *encodingContainerProfileClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeEncodingContainerProfileClassFromGlibFull is used to convert raw C.GstEncodingContainerProfileClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeEncodingContainerProfileClassFromGlibFull(p unsafe.Pointer) *EncodingContainerProfileClass { - wrapped := UnsafeEncodingContainerProfileClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.encodingContainerProfileClass, - func (intern *encodingContainerProfileClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeEncodingContainerProfileClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [EncodingContainerProfileClass] is expected to work anymore. @@ -6649,15 +6854,18 @@ func UnsafeEncodingContainerProfileClassToGlibNone(e *EncodingContainerProfileCl return unsafe.Pointer(e.native) } -// UnsafeEncodingContainerProfileClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeEncodingContainerProfileClassToGlibFull(e *EncodingContainerProfileClass) unsafe.Pointer { - runtime.SetFinalizer(e.encodingContainerProfileClass, nil) - _p := unsafe.Pointer(e.native) - e.native = nil // EncodingContainerProfileClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (e *EncodingContainerProfileClass) ParentClass() *EncodingProfileClass { + parent := UnsafeEncodingProfileClassFromGlibBorrow(UnsafeEncodingContainerProfileClassToGlibNone(e)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *EncodingContainerProfileClass) {}, e) + return parent } + // EncodingProfileClass wraps GstEncodingProfileClass +// +// EncodingProfileClass is the type struct for [EncodingProfile] type EncodingProfileClass struct { *encodingProfileClass } @@ -6672,31 +6880,6 @@ func UnsafeEncodingProfileClassFromGlibBorrow(p unsafe.Pointer) *EncodingProfile return &EncodingProfileClass{&encodingProfileClass{(*C.GstEncodingProfileClass)(p)}} } -// UnsafeEncodingProfileClassFromGlibNone is used to convert raw C.GstEncodingProfileClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeEncodingProfileClassFromGlibNone(p unsafe.Pointer) *EncodingProfileClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeEncodingProfileClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.encodingProfileClass, - func (intern *encodingProfileClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeEncodingProfileClassFromGlibFull is used to convert raw C.GstEncodingProfileClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeEncodingProfileClassFromGlibFull(p unsafe.Pointer) *EncodingProfileClass { - wrapped := UnsafeEncodingProfileClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.encodingProfileClass, - func (intern *encodingProfileClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeEncodingProfileClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [EncodingProfileClass] is expected to work anymore. @@ -6709,15 +6892,18 @@ func UnsafeEncodingProfileClassToGlibNone(e *EncodingProfileClass) unsafe.Pointe return unsafe.Pointer(e.native) } -// UnsafeEncodingProfileClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeEncodingProfileClassToGlibFull(e *EncodingProfileClass) unsafe.Pointer { - runtime.SetFinalizer(e.encodingProfileClass, nil) - _p := unsafe.Pointer(e.native) - e.native = nil // EncodingProfileClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (e *EncodingProfileClass) ParentClass() *gobject.ObjectClass { + parent := gobject.UnsafeObjectClassFromGlibBorrow(UnsafeEncodingProfileClassToGlibNone(e)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *EncodingProfileClass) {}, e) + return parent } + // EncodingVideoProfileClass wraps GstEncodingVideoProfileClass +// +// EncodingVideoProfileClass is the type struct for [EncodingVideoProfile] type EncodingVideoProfileClass struct { *encodingVideoProfileClass } @@ -6732,31 +6918,6 @@ func UnsafeEncodingVideoProfileClassFromGlibBorrow(p unsafe.Pointer) *EncodingVi return &EncodingVideoProfileClass{&encodingVideoProfileClass{(*C.GstEncodingVideoProfileClass)(p)}} } -// UnsafeEncodingVideoProfileClassFromGlibNone is used to convert raw C.GstEncodingVideoProfileClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeEncodingVideoProfileClassFromGlibNone(p unsafe.Pointer) *EncodingVideoProfileClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeEncodingVideoProfileClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.encodingVideoProfileClass, - func (intern *encodingVideoProfileClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeEncodingVideoProfileClassFromGlibFull is used to convert raw C.GstEncodingVideoProfileClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeEncodingVideoProfileClassFromGlibFull(p unsafe.Pointer) *EncodingVideoProfileClass { - wrapped := UnsafeEncodingVideoProfileClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.encodingVideoProfileClass, - func (intern *encodingVideoProfileClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeEncodingVideoProfileClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [EncodingVideoProfileClass] is expected to work anymore. @@ -6769,14 +6930,15 @@ func UnsafeEncodingVideoProfileClassToGlibNone(e *EncodingVideoProfileClass) uns return unsafe.Pointer(e.native) } -// UnsafeEncodingVideoProfileClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeEncodingVideoProfileClassToGlibFull(e *EncodingVideoProfileClass) unsafe.Pointer { - runtime.SetFinalizer(e.encodingVideoProfileClass, nil) - _p := unsafe.Pointer(e.native) - e.native = nil // EncodingVideoProfileClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (e *EncodingVideoProfileClass) ParentClass() *EncodingProfileClass { + parent := UnsafeEncodingProfileClassFromGlibBorrow(UnsafeEncodingVideoProfileClassToGlibNone(e)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *EncodingVideoProfileClass) {}, e) + return parent } + // InstallPluginsContext wraps GstInstallPluginsContext // // Opaque context structure for the plugin installation. Use the provided @@ -6807,7 +6969,7 @@ func UnsafeInstallPluginsContextFromGlibBorrow(p unsafe.Pointer) *InstallPlugins return &InstallPluginsContext{&installPluginsContext{(*C.GstInstallPluginsContext)(p)}} } -// UnsafeInstallPluginsContextFromGlibNone is used to convert raw C.GstInstallPluginsContext pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeInstallPluginsContextFromGlibNone is used to convert raw C.GstInstallPluginsContext pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeInstallPluginsContextFromGlibNone(p unsafe.Pointer) *InstallPluginsContext { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeInstallPluginsContextFromGlibBorrow(p) @@ -6820,7 +6982,7 @@ func UnsafeInstallPluginsContextFromGlibNone(p unsafe.Pointer) *InstallPluginsCo return wrapped } -// UnsafeInstallPluginsContextFromGlibFull is used to convert raw C.GstInstallPluginsContext pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeInstallPluginsContextFromGlibFull is used to convert raw C.GstInstallPluginsContext pointers to go while taking ownership. This is used by the bindings internally. func UnsafeInstallPluginsContextFromGlibFull(p unsafe.Pointer) *InstallPluginsContext { wrapped := UnsafeInstallPluginsContextFromGlibBorrow(p) runtime.SetFinalizer( @@ -6852,7 +7014,9 @@ func UnsafeInstallPluginsContextToGlibFull(i *InstallPluginsContext) unsafe.Poin i.native = nil // InstallPluginsContext is invalid from here on return _p } + // NewInstallPluginsContext wraps gst_install_plugins_context_new +// // The function returns the following values: // // - goret *InstallPluginsContext @@ -6871,6 +7035,7 @@ func NewInstallPluginsContext() *InstallPluginsContext { } // Copy wraps gst_install_plugins_context_copy +// // The function returns the following values: // // - goret *InstallPluginsContext diff --git a/pkg/gstpbutils/gstpbutils_export.gen.go b/pkg/gstpbutils/gstpbutils_export.gen.go index a9b2333..fb3e4f4 100644 --- a/pkg/gstpbutils/gstpbutils_export.gen.go +++ b/pkg/gstpbutils/gstpbutils_export.gen.go @@ -29,3 +29,43 @@ func _gotk4_gstpbutils1_InstallPluginsResultFunc(carg1 C.GstInstallPluginsReturn fn(result) } +//export _gotk4_gstpbutils1_AudioVisualizer_decide_allocation +func _gotk4_gstpbutils1_AudioVisualizer_decide_allocation(carg0 *C.GstAudioVisualizer, carg1 *C.GstQuery) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstpbutils1_AudioVisualizer_render +func _gotk4_gstpbutils1_AudioVisualizer_render(carg0 *C.GstAudioVisualizer, carg1 *C.GstBuffer, carg2 *C.GstVideoFrame) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstpbutils1_AudioVisualizer_setup +func _gotk4_gstpbutils1_AudioVisualizer_setup(carg0 *C.GstAudioVisualizer) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstpbutils1_Discoverer_discovered +func _gotk4_gstpbutils1_Discoverer_discovered(carg0 *C.GstDiscoverer, carg1 *C.GstDiscovererInfo, carg2 *C.GError) { + panic("unimplemented") +} + +//export _gotk4_gstpbutils1_Discoverer_finished +func _gotk4_gstpbutils1_Discoverer_finished(carg0 *C.GstDiscoverer) { + panic("unimplemented") +} + +//export _gotk4_gstpbutils1_Discoverer_load_serialize_info +func _gotk4_gstpbutils1_Discoverer_load_serialize_info(carg0 *C.GstDiscoverer, carg1 *C.gchar) (cret *C.GstDiscovererInfo) { + panic("unimplemented") +} + +//export _gotk4_gstpbutils1_Discoverer_source_setup +func _gotk4_gstpbutils1_Discoverer_source_setup(carg0 *C.GstDiscoverer, carg1 *C.GstElement) { + panic("unimplemented") +} + +//export _gotk4_gstpbutils1_Discoverer_starting +func _gotk4_gstpbutils1_Discoverer_starting(carg0 *C.GstDiscoverer) { + panic("unimplemented") +} + diff --git a/pkg/gstplay/gstplay.gen.go b/pkg/gstplay/gstplay.gen.go index 0c2a9b0..7fee5d9 100644 --- a/pkg/gstplay/gstplay.gen.go +++ b/pkg/gstplay/gstplay.gen.go @@ -182,6 +182,7 @@ func PlayErrorGetName(err PlayError) string { } // PlayErrorQuark wraps gst_play_error_quark +// // The function returns the following values: // // - goret glib.Quark @@ -785,6 +786,16 @@ func UnsafePlayVideoRendererToGlibFull(c PlayVideoRenderer) unsafe.Pointer { return gobject.UnsafeObjectToGlibFull(&i.Instance) } +// PlayVideoRendererOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type PlayVideoRendererOverrides[Instance PlayVideoRenderer] struct { +} + +// UnsafeApplyPlayVideoRendererOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyPlayVideoRendererOverrides[Instance PlayVideoRenderer](gclass unsafe.Pointer, overrides PlayVideoRendererOverrides[Instance]) { +} + // PlayInstance is the instance type used by all types extending GstPlay. It is used internally by the bindings. Users should use the interface [Play] instead. type PlayInstance struct { _ [0]func() // equal guard @@ -833,6 +844,7 @@ type Play interface { upcastToGstPlay() *PlayInstance // GetAudioVideoOffset wraps gst_play_get_audio_video_offset + // // The function returns the following values: // // - goret int64 @@ -852,6 +864,7 @@ type Play interface { // Retrieve the current value of the indicated @type. GetColorBalance(PlayColorBalanceType) float64 // GetConfig wraps gst_play_get_config + // // The function returns the following values: // // - goret *gst.Structure @@ -861,6 +874,7 @@ type Play interface { // or it must be freed after usage. GetConfig() *gst.Structure // GetCurrentAudioTrack wraps gst_play_get_current_audio_track + // // The function returns the following values: // // - goret PlayAudioInfo (nullable) @@ -868,6 +882,7 @@ type Play interface { // A Function to get current audio #GstPlayAudioInfo instance. GetCurrentAudioTrack() PlayAudioInfo // GetCurrentSubtitleTrack wraps gst_play_get_current_subtitle_track + // // The function returns the following values: // // - goret PlaySubtitleInfo (nullable) @@ -875,6 +890,7 @@ type Play interface { // A Function to get current subtitle #GstPlaySubtitleInfo instance. GetCurrentSubtitleTrack() PlaySubtitleInfo // GetCurrentVideoTrack wraps gst_play_get_current_video_track + // // The function returns the following values: // // - goret PlayVideoInfo (nullable) @@ -882,11 +898,13 @@ type Play interface { // A Function to get current video #GstPlayVideoInfo instance. GetCurrentVideoTrack() PlayVideoInfo // GetCurrentVisualization wraps gst_play_get_current_visualization + // // The function returns the following values: // // - goret string (nullable) GetCurrentVisualization() string // GetDuration wraps gst_play_get_duration + // // The function returns the following values: // // - goret gst.ClockTime @@ -894,6 +912,7 @@ type Play interface { // Retrieves the duration of the media stream that self represents. GetDuration() gst.ClockTime // GetMediaInfo wraps gst_play_get_media_info + // // The function returns the following values: // // - goret PlayMediaInfo (nullable) @@ -901,6 +920,7 @@ type Play interface { // A Function to get the current media info #GstPlayMediaInfo instance. GetMediaInfo() PlayMediaInfo // GetMessageBus wraps gst_play_get_message_bus + // // The function returns the following values: // // - goret gst.Bus @@ -919,6 +939,7 @@ type Play interface { // fill memory. To avoid that, the bus has to be set "flushing". GetMessageBus() gst.Bus // GetMultiviewFlags wraps gst_play_get_multiview_flags + // // The function returns the following values: // // - goret gstvideo.VideoMultiviewFlags @@ -926,6 +947,7 @@ type Play interface { // Retrieve the current value of the indicated @type. GetMultiviewFlags() gstvideo.VideoMultiviewFlags // GetMultiviewMode wraps gst_play_get_multiview_mode + // // The function returns the following values: // // - goret gstvideo.VideoMultiviewFramePacking @@ -933,26 +955,31 @@ type Play interface { // Retrieve the current value of the indicated @type. GetMultiviewMode() gstvideo.VideoMultiviewFramePacking // GetMute wraps gst_play_get_mute + // // The function returns the following values: // // - goret bool GetMute() bool // GetPipeline wraps gst_play_get_pipeline + // // The function returns the following values: // // - goret gst.Element GetPipeline() gst.Element // GetPosition wraps gst_play_get_position + // // The function returns the following values: // // - goret gst.ClockTime GetPosition() gst.ClockTime // GetRate wraps gst_play_get_rate + // // The function returns the following values: // // - goret float64 GetRate() float64 // GetSubtitleURI wraps gst_play_get_subtitle_uri + // // The function returns the following values: // // - goret string (nullable) @@ -960,6 +987,7 @@ type Play interface { // Current subtitle URI GetSubtitleURI() string // GetSubtitleVideoOffset wraps gst_play_get_subtitle_video_offset + // // The function returns the following values: // // - goret int64 @@ -967,6 +995,7 @@ type Play interface { // Retrieve the current value of subtitle-video-offset property GetSubtitleVideoOffset() int64 // GetURI wraps gst_play_get_uri + // // The function returns the following values: // // - goret string (nullable) @@ -992,6 +1021,7 @@ type Play interface { // Except for GST_PLAY_THUMBNAIL_RAW_NATIVE format, if no config is set, pixel-aspect-ratio would be 1/1 GetVideoSnapshot(PlaySnapshotFormat, *gst.Structure) *gst.Sample // GetVolume wraps gst_play_get_volume + // // The function returns the following values: // // - goret float64 @@ -999,6 +1029,7 @@ type Play interface { // Returns the current volume level, as a percentage between 0 and 1. GetVolume() float64 // HasColorBalance wraps gst_play_has_color_balance + // // The function returns the following values: // // - goret bool @@ -1618,6 +1649,7 @@ func PlayIsPlayMessage(msg *gst.Message) bool { } // GetAudioVideoOffset wraps gst_play_get_audio_video_offset +// // The function returns the following values: // // - goret int64 @@ -1670,6 +1702,7 @@ func (play *PlayInstance) GetColorBalance(typ PlayColorBalanceType) float64 { } // GetConfig wraps gst_play_get_config +// // The function returns the following values: // // - goret *gst.Structure @@ -1694,6 +1727,7 @@ func (play *PlayInstance) GetConfig() *gst.Structure { } // GetCurrentAudioTrack wraps gst_play_get_current_audio_track +// // The function returns the following values: // // - goret PlayAudioInfo (nullable) @@ -1718,6 +1752,7 @@ func (play *PlayInstance) GetCurrentAudioTrack() PlayAudioInfo { } // GetCurrentSubtitleTrack wraps gst_play_get_current_subtitle_track +// // The function returns the following values: // // - goret PlaySubtitleInfo (nullable) @@ -1742,6 +1777,7 @@ func (play *PlayInstance) GetCurrentSubtitleTrack() PlaySubtitleInfo { } // GetCurrentVideoTrack wraps gst_play_get_current_video_track +// // The function returns the following values: // // - goret PlayVideoInfo (nullable) @@ -1766,6 +1802,7 @@ func (play *PlayInstance) GetCurrentVideoTrack() PlayVideoInfo { } // GetCurrentVisualization wraps gst_play_get_current_visualization +// // The function returns the following values: // // - goret string (nullable) @@ -1789,6 +1826,7 @@ func (play *PlayInstance) GetCurrentVisualization() string { } // GetDuration wraps gst_play_get_duration +// // The function returns the following values: // // - goret gst.ClockTime @@ -1811,6 +1849,7 @@ func (play *PlayInstance) GetDuration() gst.ClockTime { } // GetMediaInfo wraps gst_play_get_media_info +// // The function returns the following values: // // - goret PlayMediaInfo (nullable) @@ -1835,6 +1874,7 @@ func (play *PlayInstance) GetMediaInfo() PlayMediaInfo { } // GetMessageBus wraps gst_play_get_message_bus +// // The function returns the following values: // // - goret gst.Bus @@ -1868,6 +1908,7 @@ func (play *PlayInstance) GetMessageBus() gst.Bus { } // GetMultiviewFlags wraps gst_play_get_multiview_flags +// // The function returns the following values: // // - goret gstvideo.VideoMultiviewFlags @@ -1890,6 +1931,7 @@ func (play *PlayInstance) GetMultiviewFlags() gstvideo.VideoMultiviewFlags { } // GetMultiviewMode wraps gst_play_get_multiview_mode +// // The function returns the following values: // // - goret gstvideo.VideoMultiviewFramePacking @@ -1912,6 +1954,7 @@ func (play *PlayInstance) GetMultiviewMode() gstvideo.VideoMultiviewFramePacking } // GetMute wraps gst_play_get_mute +// // The function returns the following values: // // - goret bool @@ -1934,6 +1977,7 @@ func (play *PlayInstance) GetMute() bool { } // GetPipeline wraps gst_play_get_pipeline +// // The function returns the following values: // // - goret gst.Element @@ -1954,6 +1998,7 @@ func (play *PlayInstance) GetPipeline() gst.Element { } // GetPosition wraps gst_play_get_position +// // The function returns the following values: // // - goret gst.ClockTime @@ -1974,6 +2019,7 @@ func (play *PlayInstance) GetPosition() gst.ClockTime { } // GetRate wraps gst_play_get_rate +// // The function returns the following values: // // - goret float64 @@ -1994,6 +2040,7 @@ func (play *PlayInstance) GetRate() float64 { } // GetSubtitleURI wraps gst_play_get_subtitle_uri +// // The function returns the following values: // // - goret string (nullable) @@ -2019,6 +2066,7 @@ func (play *PlayInstance) GetSubtitleURI() string { } // GetSubtitleVideoOffset wraps gst_play_get_subtitle_video_offset +// // The function returns the following values: // // - goret int64 @@ -2041,6 +2089,7 @@ func (play *PlayInstance) GetSubtitleVideoOffset() int64 { } // GetURI wraps gst_play_get_uri +// // The function returns the following values: // // - goret string (nullable) @@ -2109,6 +2158,7 @@ func (play *PlayInstance) GetVideoSnapshot(format PlaySnapshotFormat, config *gs } // GetVolume wraps gst_play_get_volume +// // The function returns the following values: // // - goret float64 @@ -2131,6 +2181,7 @@ func (play *PlayInstance) GetVolume() float64 { } // HasColorBalance wraps gst_play_has_color_balance +// // The function returns the following values: // // - goret bool @@ -2682,21 +2733,25 @@ type PlayMediaInfo interface { upcastToGstPlayMediaInfo() *PlayMediaInfoInstance // GetAudioStreams wraps gst_play_media_info_get_audio_streams + // // The function returns the following values: // // - goret []PlayAudioInfo GetAudioStreams() []PlayAudioInfo // GetContainerFormat wraps gst_play_media_info_get_container_format + // // The function returns the following values: // // - goret string (nullable) GetContainerFormat() string // GetDuration wraps gst_play_media_info_get_duration + // // The function returns the following values: // // - goret gst.ClockTime GetDuration() gst.ClockTime // GetImageSample wraps gst_play_media_info_get_image_sample + // // The function returns the following values: // // - goret *gst.Sample (nullable) @@ -2705,61 +2760,73 @@ type PlayMediaInfo interface { // Application can use `gst_sample_*_()` API's to get caps, buffer etc. GetImageSample() *gst.Sample // GetNumberOfAudioStreams wraps gst_play_media_info_get_number_of_audio_streams + // // The function returns the following values: // // - goret uint GetNumberOfAudioStreams() uint // GetNumberOfStreams wraps gst_play_media_info_get_number_of_streams + // // The function returns the following values: // // - goret uint GetNumberOfStreams() uint // GetNumberOfSubtitleStreams wraps gst_play_media_info_get_number_of_subtitle_streams + // // The function returns the following values: // // - goret uint GetNumberOfSubtitleStreams() uint // GetNumberOfVideoStreams wraps gst_play_media_info_get_number_of_video_streams + // // The function returns the following values: // // - goret uint GetNumberOfVideoStreams() uint // GetStreamList wraps gst_play_media_info_get_stream_list + // // The function returns the following values: // // - goret []PlayStreamInfo GetStreamList() []PlayStreamInfo // GetSubtitleStreams wraps gst_play_media_info_get_subtitle_streams + // // The function returns the following values: // // - goret []PlaySubtitleInfo GetSubtitleStreams() []PlaySubtitleInfo // GetTags wraps gst_play_media_info_get_tags + // // The function returns the following values: // // - goret *gst.TagList (nullable) GetTags() *gst.TagList // GetTitle wraps gst_play_media_info_get_title + // // The function returns the following values: // // - goret string (nullable) GetTitle() string // GetURI wraps gst_play_media_info_get_uri + // // The function returns the following values: // // - goret string GetURI() string // GetVideoStreams wraps gst_play_media_info_get_video_streams + // // The function returns the following values: // // - goret []PlayVideoInfo GetVideoStreams() []PlayVideoInfo // IsLive wraps gst_play_media_info_is_live + // // The function returns the following values: // // - goret bool IsLive() bool // IsSeekable wraps gst_play_media_info_is_seekable + // // The function returns the following values: // // - goret bool @@ -2801,6 +2868,7 @@ func UnsafePlayMediaInfoToGlibFull(c PlayMediaInfo) unsafe.Pointer { } // GetAudioStreams wraps gst_play_media_info_get_audio_streams +// // The function returns the following values: // // - goret []PlayAudioInfo @@ -2828,6 +2896,7 @@ func (info *PlayMediaInfoInstance) GetAudioStreams() []PlayAudioInfo { } // GetContainerFormat wraps gst_play_media_info_get_container_format +// // The function returns the following values: // // - goret string (nullable) @@ -2850,6 +2919,7 @@ func (info *PlayMediaInfoInstance) GetContainerFormat() string { } // GetDuration wraps gst_play_media_info_get_duration +// // The function returns the following values: // // - goret gst.ClockTime @@ -2870,6 +2940,7 @@ func (info *PlayMediaInfoInstance) GetDuration() gst.ClockTime { } // GetImageSample wraps gst_play_media_info_get_image_sample +// // The function returns the following values: // // - goret *gst.Sample (nullable) @@ -2895,6 +2966,7 @@ func (info *PlayMediaInfoInstance) GetImageSample() *gst.Sample { } // GetNumberOfAudioStreams wraps gst_play_media_info_get_number_of_audio_streams +// // The function returns the following values: // // - goret uint @@ -2915,6 +2987,7 @@ func (info *PlayMediaInfoInstance) GetNumberOfAudioStreams() uint { } // GetNumberOfStreams wraps gst_play_media_info_get_number_of_streams +// // The function returns the following values: // // - goret uint @@ -2935,6 +3008,7 @@ func (info *PlayMediaInfoInstance) GetNumberOfStreams() uint { } // GetNumberOfSubtitleStreams wraps gst_play_media_info_get_number_of_subtitle_streams +// // The function returns the following values: // // - goret uint @@ -2955,6 +3029,7 @@ func (info *PlayMediaInfoInstance) GetNumberOfSubtitleStreams() uint { } // GetNumberOfVideoStreams wraps gst_play_media_info_get_number_of_video_streams +// // The function returns the following values: // // - goret uint @@ -2975,6 +3050,7 @@ func (info *PlayMediaInfoInstance) GetNumberOfVideoStreams() uint { } // GetStreamList wraps gst_play_media_info_get_stream_list +// // The function returns the following values: // // - goret []PlayStreamInfo @@ -3002,6 +3078,7 @@ func (info *PlayMediaInfoInstance) GetStreamList() []PlayStreamInfo { } // GetSubtitleStreams wraps gst_play_media_info_get_subtitle_streams +// // The function returns the following values: // // - goret []PlaySubtitleInfo @@ -3029,6 +3106,7 @@ func (info *PlayMediaInfoInstance) GetSubtitleStreams() []PlaySubtitleInfo { } // GetTags wraps gst_play_media_info_get_tags +// // The function returns the following values: // // - goret *gst.TagList (nullable) @@ -3051,6 +3129,7 @@ func (info *PlayMediaInfoInstance) GetTags() *gst.TagList { } // GetTitle wraps gst_play_media_info_get_title +// // The function returns the following values: // // - goret string (nullable) @@ -3073,6 +3152,7 @@ func (info *PlayMediaInfoInstance) GetTitle() string { } // GetURI wraps gst_play_media_info_get_uri +// // The function returns the following values: // // - goret string @@ -3093,6 +3173,7 @@ func (info *PlayMediaInfoInstance) GetURI() string { } // GetVideoStreams wraps gst_play_media_info_get_video_streams +// // The function returns the following values: // // - goret []PlayVideoInfo @@ -3120,6 +3201,7 @@ func (info *PlayMediaInfoInstance) GetVideoStreams() []PlayVideoInfo { } // IsLive wraps gst_play_media_info_is_live +// // The function returns the following values: // // - goret bool @@ -3142,6 +3224,7 @@ func (info *PlayMediaInfoInstance) IsLive() bool { } // IsSeekable wraps gst_play_media_info_is_seekable +// // The function returns the following values: // // - goret bool @@ -3177,6 +3260,7 @@ type PlaySignalAdapter interface { upcastToGstPlaySignalAdapter() *PlaySignalAdapterInstance // GetPlay wraps gst_play_signal_adapter_get_play + // // The function returns the following values: // // - goret Play @@ -3340,6 +3424,7 @@ func NewPlaySignalAdapterWithMainContext(play Play, _context *glib.MainContext) } // GetPlay wraps gst_play_signal_adapter_get_play +// // The function returns the following values: // // - goret Play @@ -3363,58 +3448,71 @@ func (adapter *PlaySignalAdapterInstance) GetPlay() Play { func (o *PlaySignalAdapterInstance) ConnectBuffering(fn func(PlaySignalAdapter, int)) gobject.SignalHandle { return o.Connect("buffering", fn) } + // ConnectDurationChanged connects the provided callback to the "duration-changed" signal func (o *PlaySignalAdapterInstance) ConnectDurationChanged(fn func(PlaySignalAdapter, uint64)) gobject.SignalHandle { return o.Connect("duration-changed", fn) } + // ConnectEndOfStream connects the provided callback to the "end-of-stream" signal func (o *PlaySignalAdapterInstance) ConnectEndOfStream(fn func(PlaySignalAdapter)) gobject.SignalHandle { return o.Connect("end-of-stream", fn) } + // ConnectError connects the provided callback to the "error" signal // // Emitted on errors. func (o *PlaySignalAdapterInstance) ConnectError(fn func(PlaySignalAdapter, error, gst.Structure)) gobject.SignalHandle { return o.Connect("error", fn) } + // ConnectMediaInfoUpdated connects the provided callback to the "media-info-updated" signal func (o *PlaySignalAdapterInstance) ConnectMediaInfoUpdated(fn func(PlaySignalAdapter, PlayMediaInfo)) gobject.SignalHandle { return o.Connect("media-info-updated", fn) } + // ConnectMuteChanged connects the provided callback to the "mute-changed" signal func (o *PlaySignalAdapterInstance) ConnectMuteChanged(fn func(PlaySignalAdapter, bool)) gobject.SignalHandle { return o.Connect("mute-changed", fn) } + // ConnectPositionUpdated connects the provided callback to the "position-updated" signal func (o *PlaySignalAdapterInstance) ConnectPositionUpdated(fn func(PlaySignalAdapter, uint64)) gobject.SignalHandle { return o.Connect("position-updated", fn) } + // ConnectSeekDone connects the provided callback to the "seek-done" signal func (o *PlaySignalAdapterInstance) ConnectSeekDone(fn func(PlaySignalAdapter, uint64)) gobject.SignalHandle { return o.Connect("seek-done", fn) } + // ConnectStateChanged connects the provided callback to the "state-changed" signal func (o *PlaySignalAdapterInstance) ConnectStateChanged(fn func(PlaySignalAdapter, PlayState)) gobject.SignalHandle { return o.Connect("state-changed", fn) } + // ConnectURILoaded connects the provided callback to the "uri-loaded" signal func (o *PlaySignalAdapterInstance) ConnectURILoaded(fn func(PlaySignalAdapter, string)) gobject.SignalHandle { return o.Connect("uri-loaded", fn) } + // ConnectVideoDimensionsChanged connects the provided callback to the "video-dimensions-changed" signal func (o *PlaySignalAdapterInstance) ConnectVideoDimensionsChanged(fn func(PlaySignalAdapter, uint, uint)) gobject.SignalHandle { return o.Connect("video-dimensions-changed", fn) } + // ConnectVolumeChanged connects the provided callback to the "volume-changed" signal func (o *PlaySignalAdapterInstance) ConnectVolumeChanged(fn func(PlaySignalAdapter, float64)) gobject.SignalHandle { return o.Connect("volume-changed", fn) } + // ConnectWarning connects the provided callback to the "warning" signal // // Emitted on warnings. func (o *PlaySignalAdapterInstance) ConnectWarning(fn func(PlaySignalAdapter, error, gst.Structure)) gobject.SignalHandle { return o.Connect("warning", fn) } + // PlayStreamInfoInstance is the instance type used by all types extending GstPlayStreamInfo. It is used internally by the bindings. Users should use the interface [PlayStreamInfo] instead. type PlayStreamInfoInstance struct { _ [0]func() // equal guard @@ -3433,11 +3531,13 @@ type PlayStreamInfo interface { upcastToGstPlayStreamInfo() *PlayStreamInfoInstance // GetCaps wraps gst_play_stream_info_get_caps + // // The function returns the following values: // // - goret *gst.Caps (nullable) GetCaps() *gst.Caps // GetCodec wraps gst_play_stream_info_get_codec + // // The function returns the following values: // // - goret string (nullable) @@ -3445,6 +3545,7 @@ type PlayStreamInfo interface { // A string describing codec used in #GstPlayStreamInfo. GetCodec() string // GetIndex wraps gst_play_stream_info_get_index + // // The function returns the following values: // // - goret int @@ -3453,6 +3554,7 @@ type PlayStreamInfo interface { // unknown. GetIndex() int // GetStreamType wraps gst_play_stream_info_get_stream_type + // // The function returns the following values: // // - goret string @@ -3461,6 +3563,7 @@ type PlayStreamInfo interface { // of the given @info (ex: "audio", "video", "subtitle") GetStreamType() string // GetTags wraps gst_play_stream_info_get_tags + // // The function returns the following values: // // - goret *gst.TagList (nullable) @@ -3502,6 +3605,7 @@ func UnsafePlayStreamInfoToGlibFull(c PlayStreamInfo) unsafe.Pointer { } // GetCaps wraps gst_play_stream_info_get_caps +// // The function returns the following values: // // - goret *gst.Caps (nullable) @@ -3524,6 +3628,7 @@ func (info *PlayStreamInfoInstance) GetCaps() *gst.Caps { } // GetCodec wraps gst_play_stream_info_get_codec +// // The function returns the following values: // // - goret string (nullable) @@ -3548,6 +3653,7 @@ func (info *PlayStreamInfoInstance) GetCodec() string { } // GetIndex wraps gst_play_stream_info_get_index +// // The function returns the following values: // // - goret int @@ -3571,6 +3677,7 @@ func (info *PlayStreamInfoInstance) GetIndex() int { } // GetStreamType wraps gst_play_stream_info_get_stream_type +// // The function returns the following values: // // - goret string @@ -3594,6 +3701,7 @@ func (info *PlayStreamInfoInstance) GetStreamType() string { } // GetTags wraps gst_play_stream_info_get_tags +// // The function returns the following values: // // - goret *gst.TagList (nullable) @@ -3631,6 +3739,7 @@ type PlaySubtitleInfo interface { upcastToGstPlaySubtitleInfo() *PlaySubtitleInfoInstance // GetLanguage wraps gst_play_subtitle_info_get_language + // // The function returns the following values: // // - goret string (nullable) @@ -3674,6 +3783,7 @@ func UnsafePlaySubtitleInfoToGlibFull(c PlaySubtitleInfo) unsafe.Pointer { } // GetLanguage wraps gst_play_subtitle_info_get_language +// // The function returns the following values: // // - goret string (nullable) @@ -3711,27 +3821,32 @@ type PlayVideoInfo interface { upcastToGstPlayVideoInfo() *PlayVideoInfoInstance // GetBitrate wraps gst_play_video_info_get_bitrate + // // The function returns the following values: // // - goret int GetBitrate() int // GetFramerate wraps gst_play_video_info_get_framerate + // // The function returns the following values: // // - fpsN int: Numerator of frame rate // - fpsD int: Denominator of frame rate GetFramerate() (int, int) // GetHeight wraps gst_play_video_info_get_height + // // The function returns the following values: // // - goret int GetHeight() int // GetMaxBitrate wraps gst_play_video_info_get_max_bitrate + // // The function returns the following values: // // - goret int GetMaxBitrate() int // GetPixelAspectRatio wraps gst_play_video_info_get_pixel_aspect_ratio + // // The function returns the following values: // // - parN uint: numerator @@ -3740,6 +3855,7 @@ type PlayVideoInfo interface { // Returns the pixel aspect ratio in @par_n and @par_d GetPixelAspectRatio() (uint, uint) // GetWidth wraps gst_play_video_info_get_width + // // The function returns the following values: // // - goret int @@ -3783,6 +3899,7 @@ func UnsafePlayVideoInfoToGlibFull(c PlayVideoInfo) unsafe.Pointer { } // GetBitrate wraps gst_play_video_info_get_bitrate +// // The function returns the following values: // // - goret int @@ -3803,6 +3920,7 @@ func (info *PlayVideoInfoInstance) GetBitrate() int { } // GetFramerate wraps gst_play_video_info_get_framerate +// // The function returns the following values: // // - fpsN int: Numerator of frame rate @@ -3827,6 +3945,7 @@ func (info *PlayVideoInfoInstance) GetFramerate() (int, int) { } // GetHeight wraps gst_play_video_info_get_height +// // The function returns the following values: // // - goret int @@ -3847,6 +3966,7 @@ func (info *PlayVideoInfoInstance) GetHeight() int { } // GetMaxBitrate wraps gst_play_video_info_get_max_bitrate +// // The function returns the following values: // // - goret int @@ -3867,6 +3987,7 @@ func (info *PlayVideoInfoInstance) GetMaxBitrate() int { } // GetPixelAspectRatio wraps gst_play_video_info_get_pixel_aspect_ratio +// // The function returns the following values: // // - parN uint: numerator @@ -3893,6 +4014,7 @@ func (info *PlayVideoInfoInstance) GetPixelAspectRatio() (uint, uint) { } // GetWidth wraps gst_play_video_info_get_width +// // The function returns the following values: // // - goret int @@ -3931,6 +4053,7 @@ type PlayVideoOverlayVideoRenderer interface { // in the drawable even if the pipeline is PAUSED. Expose() // GetRenderRectangle wraps gst_play_video_overlay_video_renderer_get_render_rectangle + // // The function returns the following values: // // - x int: the horizontal offset of the render area inside the window @@ -4011,6 +4134,7 @@ func (self *PlayVideoOverlayVideoRendererInstance) Expose() { } // GetRenderRectangle wraps gst_play_video_overlay_video_renderer_get_render_rectangle +// // The function returns the following values: // // - x int: the horizontal offset of the render area inside the window @@ -4101,26 +4225,31 @@ type PlayAudioInfo interface { upcastToGstPlayAudioInfo() *PlayAudioInfoInstance // GetBitrate wraps gst_play_audio_info_get_bitrate + // // The function returns the following values: // // - goret int GetBitrate() int // GetChannels wraps gst_play_audio_info_get_channels + // // The function returns the following values: // // - goret int GetChannels() int // GetLanguage wraps gst_play_audio_info_get_language + // // The function returns the following values: // // - goret string (nullable) GetLanguage() string // GetMaxBitrate wraps gst_play_audio_info_get_max_bitrate + // // The function returns the following values: // // - goret int GetMaxBitrate() int // GetSampleRate wraps gst_play_audio_info_get_sample_rate + // // The function returns the following values: // // - goret int @@ -4164,6 +4293,7 @@ func UnsafePlayAudioInfoToGlibFull(c PlayAudioInfo) unsafe.Pointer { } // GetBitrate wraps gst_play_audio_info_get_bitrate +// // The function returns the following values: // // - goret int @@ -4184,6 +4314,7 @@ func (info *PlayAudioInfoInstance) GetBitrate() int { } // GetChannels wraps gst_play_audio_info_get_channels +// // The function returns the following values: // // - goret int @@ -4204,6 +4335,7 @@ func (info *PlayAudioInfoInstance) GetChannels() int { } // GetLanguage wraps gst_play_audio_info_get_language +// // The function returns the following values: // // - goret string (nullable) @@ -4226,6 +4358,7 @@ func (info *PlayAudioInfoInstance) GetLanguage() string { } // GetMaxBitrate wraps gst_play_audio_info_get_max_bitrate +// // The function returns the following values: // // - goret int @@ -4246,6 +4379,7 @@ func (info *PlayAudioInfoInstance) GetMaxBitrate() int { } // GetSampleRate wraps gst_play_audio_info_get_sample_rate +// // The function returns the following values: // // - goret int @@ -4266,6 +4400,8 @@ func (info *PlayAudioInfoInstance) GetSampleRate() int { } // PlayAudioInfoClass wraps GstPlayAudioInfoClass +// +// PlayAudioInfoClass is the type struct for [PlayAudioInfo] type PlayAudioInfoClass struct { *playAudioInfoClass } @@ -4280,31 +4416,6 @@ func UnsafePlayAudioInfoClassFromGlibBorrow(p unsafe.Pointer) *PlayAudioInfoClas return &PlayAudioInfoClass{&playAudioInfoClass{(*C.GstPlayAudioInfoClass)(p)}} } -// UnsafePlayAudioInfoClassFromGlibNone is used to convert raw C.GstPlayAudioInfoClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafePlayAudioInfoClassFromGlibNone(p unsafe.Pointer) *PlayAudioInfoClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafePlayAudioInfoClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.playAudioInfoClass, - func (intern *playAudioInfoClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafePlayAudioInfoClassFromGlibFull is used to convert raw C.GstPlayAudioInfoClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafePlayAudioInfoClassFromGlibFull(p unsafe.Pointer) *PlayAudioInfoClass { - wrapped := UnsafePlayAudioInfoClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.playAudioInfoClass, - func (intern *playAudioInfoClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafePlayAudioInfoClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [PlayAudioInfoClass] is expected to work anymore. @@ -4317,15 +4428,18 @@ func UnsafePlayAudioInfoClassToGlibNone(p *PlayAudioInfoClass) unsafe.Pointer { return unsafe.Pointer(p.native) } -// UnsafePlayAudioInfoClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafePlayAudioInfoClassToGlibFull(p *PlayAudioInfoClass) unsafe.Pointer { - runtime.SetFinalizer(p.playAudioInfoClass, nil) - _p := unsafe.Pointer(p.native) - p.native = nil // PlayAudioInfoClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (p *PlayAudioInfoClass) ParentClass() *PlayStreamInfoClass { + parent := UnsafePlayStreamInfoClassFromGlibBorrow(UnsafePlayAudioInfoClassToGlibNone(p)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *PlayAudioInfoClass) {}, p) + return parent } + // PlayClass wraps GstPlayClass +// +// PlayClass is the type struct for [Play] type PlayClass struct { *playClass } @@ -4340,31 +4454,6 @@ func UnsafePlayClassFromGlibBorrow(p unsafe.Pointer) *PlayClass { return &PlayClass{&playClass{(*C.GstPlayClass)(p)}} } -// UnsafePlayClassFromGlibNone is used to convert raw C.GstPlayClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafePlayClassFromGlibNone(p unsafe.Pointer) *PlayClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafePlayClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.playClass, - func (intern *playClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafePlayClassFromGlibFull is used to convert raw C.GstPlayClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafePlayClassFromGlibFull(p unsafe.Pointer) *PlayClass { - wrapped := UnsafePlayClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.playClass, - func (intern *playClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafePlayClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [PlayClass] is expected to work anymore. @@ -4377,15 +4466,18 @@ func UnsafePlayClassToGlibNone(p *PlayClass) unsafe.Pointer { return unsafe.Pointer(p.native) } -// UnsafePlayClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafePlayClassToGlibFull(p *PlayClass) unsafe.Pointer { - runtime.SetFinalizer(p.playClass, nil) - _p := unsafe.Pointer(p.native) - p.native = nil // PlayClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (p *PlayClass) ParentClass() *gst.ObjectClass { + parent := gst.UnsafeObjectClassFromGlibBorrow(UnsafePlayClassToGlibNone(p)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *PlayClass) {}, p) + return parent } + // PlayMediaInfoClass wraps GstPlayMediaInfoClass +// +// PlayMediaInfoClass is the type struct for [PlayMediaInfo] type PlayMediaInfoClass struct { *playMediaInfoClass } @@ -4400,31 +4492,6 @@ func UnsafePlayMediaInfoClassFromGlibBorrow(p unsafe.Pointer) *PlayMediaInfoClas return &PlayMediaInfoClass{&playMediaInfoClass{(*C.GstPlayMediaInfoClass)(p)}} } -// UnsafePlayMediaInfoClassFromGlibNone is used to convert raw C.GstPlayMediaInfoClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafePlayMediaInfoClassFromGlibNone(p unsafe.Pointer) *PlayMediaInfoClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafePlayMediaInfoClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.playMediaInfoClass, - func (intern *playMediaInfoClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafePlayMediaInfoClassFromGlibFull is used to convert raw C.GstPlayMediaInfoClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafePlayMediaInfoClassFromGlibFull(p unsafe.Pointer) *PlayMediaInfoClass { - wrapped := UnsafePlayMediaInfoClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.playMediaInfoClass, - func (intern *playMediaInfoClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafePlayMediaInfoClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [PlayMediaInfoClass] is expected to work anymore. @@ -4437,15 +4504,18 @@ func UnsafePlayMediaInfoClassToGlibNone(p *PlayMediaInfoClass) unsafe.Pointer { return unsafe.Pointer(p.native) } -// UnsafePlayMediaInfoClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafePlayMediaInfoClassToGlibFull(p *PlayMediaInfoClass) unsafe.Pointer { - runtime.SetFinalizer(p.playMediaInfoClass, nil) - _p := unsafe.Pointer(p.native) - p.native = nil // PlayMediaInfoClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (p *PlayMediaInfoClass) ParentClass() *gobject.ObjectClass { + parent := gobject.UnsafeObjectClassFromGlibBorrow(UnsafePlayMediaInfoClassToGlibNone(p)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *PlayMediaInfoClass) {}, p) + return parent } + // PlaySignalAdapterClass wraps GstPlaySignalAdapterClass +// +// PlaySignalAdapterClass is the type struct for [PlaySignalAdapter] type PlaySignalAdapterClass struct { *playSignalAdapterClass } @@ -4460,31 +4530,6 @@ func UnsafePlaySignalAdapterClassFromGlibBorrow(p unsafe.Pointer) *PlaySignalAda return &PlaySignalAdapterClass{&playSignalAdapterClass{(*C.GstPlaySignalAdapterClass)(p)}} } -// UnsafePlaySignalAdapterClassFromGlibNone is used to convert raw C.GstPlaySignalAdapterClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafePlaySignalAdapterClassFromGlibNone(p unsafe.Pointer) *PlaySignalAdapterClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafePlaySignalAdapterClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.playSignalAdapterClass, - func (intern *playSignalAdapterClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafePlaySignalAdapterClassFromGlibFull is used to convert raw C.GstPlaySignalAdapterClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafePlaySignalAdapterClassFromGlibFull(p unsafe.Pointer) *PlaySignalAdapterClass { - wrapped := UnsafePlaySignalAdapterClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.playSignalAdapterClass, - func (intern *playSignalAdapterClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafePlaySignalAdapterClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [PlaySignalAdapterClass] is expected to work anymore. @@ -4497,15 +4542,18 @@ func UnsafePlaySignalAdapterClassToGlibNone(p *PlaySignalAdapterClass) unsafe.Po return unsafe.Pointer(p.native) } -// UnsafePlaySignalAdapterClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafePlaySignalAdapterClassToGlibFull(p *PlaySignalAdapterClass) unsafe.Pointer { - runtime.SetFinalizer(p.playSignalAdapterClass, nil) - _p := unsafe.Pointer(p.native) - p.native = nil // PlaySignalAdapterClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (p *PlaySignalAdapterClass) ParentClass() *gobject.ObjectClass { + parent := gobject.UnsafeObjectClassFromGlibBorrow(UnsafePlaySignalAdapterClassToGlibNone(p)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *PlaySignalAdapterClass) {}, p) + return parent } + // PlayStreamInfoClass wraps GstPlayStreamInfoClass +// +// PlayStreamInfoClass is the type struct for [PlayStreamInfo] type PlayStreamInfoClass struct { *playStreamInfoClass } @@ -4520,31 +4568,6 @@ func UnsafePlayStreamInfoClassFromGlibBorrow(p unsafe.Pointer) *PlayStreamInfoCl return &PlayStreamInfoClass{&playStreamInfoClass{(*C.GstPlayStreamInfoClass)(p)}} } -// UnsafePlayStreamInfoClassFromGlibNone is used to convert raw C.GstPlayStreamInfoClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafePlayStreamInfoClassFromGlibNone(p unsafe.Pointer) *PlayStreamInfoClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafePlayStreamInfoClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.playStreamInfoClass, - func (intern *playStreamInfoClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafePlayStreamInfoClassFromGlibFull is used to convert raw C.GstPlayStreamInfoClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafePlayStreamInfoClassFromGlibFull(p unsafe.Pointer) *PlayStreamInfoClass { - wrapped := UnsafePlayStreamInfoClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.playStreamInfoClass, - func (intern *playStreamInfoClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafePlayStreamInfoClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [PlayStreamInfoClass] is expected to work anymore. @@ -4557,15 +4580,18 @@ func UnsafePlayStreamInfoClassToGlibNone(p *PlayStreamInfoClass) unsafe.Pointer return unsafe.Pointer(p.native) } -// UnsafePlayStreamInfoClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafePlayStreamInfoClassToGlibFull(p *PlayStreamInfoClass) unsafe.Pointer { - runtime.SetFinalizer(p.playStreamInfoClass, nil) - _p := unsafe.Pointer(p.native) - p.native = nil // PlayStreamInfoClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (p *PlayStreamInfoClass) ParentClass() *gobject.ObjectClass { + parent := gobject.UnsafeObjectClassFromGlibBorrow(UnsafePlayStreamInfoClassToGlibNone(p)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *PlayStreamInfoClass) {}, p) + return parent } + // PlaySubtitleInfoClass wraps GstPlaySubtitleInfoClass +// +// PlaySubtitleInfoClass is the type struct for [PlaySubtitleInfo] type PlaySubtitleInfoClass struct { *playSubtitleInfoClass } @@ -4580,31 +4606,6 @@ func UnsafePlaySubtitleInfoClassFromGlibBorrow(p unsafe.Pointer) *PlaySubtitleIn return &PlaySubtitleInfoClass{&playSubtitleInfoClass{(*C.GstPlaySubtitleInfoClass)(p)}} } -// UnsafePlaySubtitleInfoClassFromGlibNone is used to convert raw C.GstPlaySubtitleInfoClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafePlaySubtitleInfoClassFromGlibNone(p unsafe.Pointer) *PlaySubtitleInfoClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafePlaySubtitleInfoClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.playSubtitleInfoClass, - func (intern *playSubtitleInfoClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafePlaySubtitleInfoClassFromGlibFull is used to convert raw C.GstPlaySubtitleInfoClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafePlaySubtitleInfoClassFromGlibFull(p unsafe.Pointer) *PlaySubtitleInfoClass { - wrapped := UnsafePlaySubtitleInfoClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.playSubtitleInfoClass, - func (intern *playSubtitleInfoClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafePlaySubtitleInfoClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [PlaySubtitleInfoClass] is expected to work anymore. @@ -4617,15 +4618,18 @@ func UnsafePlaySubtitleInfoClassToGlibNone(p *PlaySubtitleInfoClass) unsafe.Poin return unsafe.Pointer(p.native) } -// UnsafePlaySubtitleInfoClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafePlaySubtitleInfoClassToGlibFull(p *PlaySubtitleInfoClass) unsafe.Pointer { - runtime.SetFinalizer(p.playSubtitleInfoClass, nil) - _p := unsafe.Pointer(p.native) - p.native = nil // PlaySubtitleInfoClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (p *PlaySubtitleInfoClass) ParentClass() *PlayStreamInfoClass { + parent := UnsafePlayStreamInfoClassFromGlibBorrow(UnsafePlaySubtitleInfoClassToGlibNone(p)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *PlaySubtitleInfoClass) {}, p) + return parent } + // PlayVideoInfoClass wraps GstPlayVideoInfoClass +// +// PlayVideoInfoClass is the type struct for [PlayVideoInfo] type PlayVideoInfoClass struct { *playVideoInfoClass } @@ -4640,31 +4644,6 @@ func UnsafePlayVideoInfoClassFromGlibBorrow(p unsafe.Pointer) *PlayVideoInfoClas return &PlayVideoInfoClass{&playVideoInfoClass{(*C.GstPlayVideoInfoClass)(p)}} } -// UnsafePlayVideoInfoClassFromGlibNone is used to convert raw C.GstPlayVideoInfoClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafePlayVideoInfoClassFromGlibNone(p unsafe.Pointer) *PlayVideoInfoClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafePlayVideoInfoClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.playVideoInfoClass, - func (intern *playVideoInfoClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafePlayVideoInfoClassFromGlibFull is used to convert raw C.GstPlayVideoInfoClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafePlayVideoInfoClassFromGlibFull(p unsafe.Pointer) *PlayVideoInfoClass { - wrapped := UnsafePlayVideoInfoClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.playVideoInfoClass, - func (intern *playVideoInfoClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafePlayVideoInfoClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [PlayVideoInfoClass] is expected to work anymore. @@ -4677,15 +4656,18 @@ func UnsafePlayVideoInfoClassToGlibNone(p *PlayVideoInfoClass) unsafe.Pointer { return unsafe.Pointer(p.native) } -// UnsafePlayVideoInfoClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafePlayVideoInfoClassToGlibFull(p *PlayVideoInfoClass) unsafe.Pointer { - runtime.SetFinalizer(p.playVideoInfoClass, nil) - _p := unsafe.Pointer(p.native) - p.native = nil // PlayVideoInfoClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (p *PlayVideoInfoClass) ParentClass() *PlayStreamInfoClass { + parent := UnsafePlayStreamInfoClassFromGlibBorrow(UnsafePlayVideoInfoClassToGlibNone(p)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *PlayVideoInfoClass) {}, p) + return parent } + // PlayVideoOverlayVideoRendererClass wraps GstPlayVideoOverlayVideoRendererClass +// +// PlayVideoOverlayVideoRendererClass is the type struct for [PlayVideoOverlayVideoRenderer] type PlayVideoOverlayVideoRendererClass struct { *playVideoOverlayVideoRendererClass } @@ -4700,31 +4682,6 @@ func UnsafePlayVideoOverlayVideoRendererClassFromGlibBorrow(p unsafe.Pointer) *P return &PlayVideoOverlayVideoRendererClass{&playVideoOverlayVideoRendererClass{(*C.GstPlayVideoOverlayVideoRendererClass)(p)}} } -// UnsafePlayVideoOverlayVideoRendererClassFromGlibNone is used to convert raw C.GstPlayVideoOverlayVideoRendererClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafePlayVideoOverlayVideoRendererClassFromGlibNone(p unsafe.Pointer) *PlayVideoOverlayVideoRendererClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafePlayVideoOverlayVideoRendererClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.playVideoOverlayVideoRendererClass, - func (intern *playVideoOverlayVideoRendererClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafePlayVideoOverlayVideoRendererClassFromGlibFull is used to convert raw C.GstPlayVideoOverlayVideoRendererClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafePlayVideoOverlayVideoRendererClassFromGlibFull(p unsafe.Pointer) *PlayVideoOverlayVideoRendererClass { - wrapped := UnsafePlayVideoOverlayVideoRendererClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.playVideoOverlayVideoRendererClass, - func (intern *playVideoOverlayVideoRendererClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafePlayVideoOverlayVideoRendererClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [PlayVideoOverlayVideoRendererClass] is expected to work anymore. @@ -4737,14 +4694,15 @@ func UnsafePlayVideoOverlayVideoRendererClassToGlibNone(p *PlayVideoOverlayVideo return unsafe.Pointer(p.native) } -// UnsafePlayVideoOverlayVideoRendererClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafePlayVideoOverlayVideoRendererClassToGlibFull(p *PlayVideoOverlayVideoRendererClass) unsafe.Pointer { - runtime.SetFinalizer(p.playVideoOverlayVideoRendererClass, nil) - _p := unsafe.Pointer(p.native) - p.native = nil // PlayVideoOverlayVideoRendererClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (p *PlayVideoOverlayVideoRendererClass) ParentClass() *gobject.ObjectClass { + parent := gobject.UnsafeObjectClassFromGlibBorrow(UnsafePlayVideoOverlayVideoRendererClassToGlibNone(p)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *PlayVideoOverlayVideoRendererClass) {}, p) + return parent } + // PlayVideoRendererInterface wraps GstPlayVideoRendererInterface type PlayVideoRendererInterface struct { *playVideoRendererInterface @@ -4760,7 +4718,7 @@ func UnsafePlayVideoRendererInterfaceFromGlibBorrow(p unsafe.Pointer) *PlayVideo return &PlayVideoRendererInterface{&playVideoRendererInterface{(*C.GstPlayVideoRendererInterface)(p)}} } -// UnsafePlayVideoRendererInterfaceFromGlibNone is used to convert raw C.GstPlayVideoRendererInterface pointers to go while taking a reference. This is used by the bindings internally. +// UnsafePlayVideoRendererInterfaceFromGlibNone is used to convert raw C.GstPlayVideoRendererInterface pointers to go without transferring ownership. This is used by the bindings internally. func UnsafePlayVideoRendererInterfaceFromGlibNone(p unsafe.Pointer) *PlayVideoRendererInterface { // FIXME: this has no ref function, what should we do here? wrapped := UnsafePlayVideoRendererInterfaceFromGlibBorrow(p) @@ -4773,7 +4731,7 @@ func UnsafePlayVideoRendererInterfaceFromGlibNone(p unsafe.Pointer) *PlayVideoRe return wrapped } -// UnsafePlayVideoRendererInterfaceFromGlibFull is used to convert raw C.GstPlayVideoRendererInterface pointers to go while taking a reference. This is used by the bindings internally. +// UnsafePlayVideoRendererInterfaceFromGlibFull is used to convert raw C.GstPlayVideoRendererInterface pointers to go while taking ownership. This is used by the bindings internally. func UnsafePlayVideoRendererInterfaceFromGlibFull(p unsafe.Pointer) *PlayVideoRendererInterface { wrapped := UnsafePlayVideoRendererInterfaceFromGlibBorrow(p) runtime.SetFinalizer( @@ -4805,6 +4763,7 @@ func UnsafePlayVideoRendererInterfaceToGlibFull(p *PlayVideoRendererInterface) u p.native = nil // PlayVideoRendererInterface is invalid from here on return _p } + // PlayVisualization wraps GstPlayVisualization // // A #GstPlayVisualization descriptor. @@ -4834,7 +4793,7 @@ func UnsafePlayVisualizationFromGlibBorrow(p unsafe.Pointer) *PlayVisualization return &PlayVisualization{&playVisualization{(*C.GstPlayVisualization)(p)}} } -// UnsafePlayVisualizationFromGlibNone is used to convert raw C.GstPlayVisualization pointers to go while taking a reference. This is used by the bindings internally. +// UnsafePlayVisualizationFromGlibNone is used to convert raw C.GstPlayVisualization pointers to go without transferring ownership. This is used by the bindings internally. func UnsafePlayVisualizationFromGlibNone(p unsafe.Pointer) *PlayVisualization { // FIXME: this has no ref function, what should we do here? wrapped := UnsafePlayVisualizationFromGlibBorrow(p) @@ -4847,7 +4806,7 @@ func UnsafePlayVisualizationFromGlibNone(p unsafe.Pointer) *PlayVisualization { return wrapped } -// UnsafePlayVisualizationFromGlibFull is used to convert raw C.GstPlayVisualization pointers to go while taking a reference. This is used by the bindings internally. +// UnsafePlayVisualizationFromGlibFull is used to convert raw C.GstPlayVisualization pointers to go while taking ownership. This is used by the bindings internally. func UnsafePlayVisualizationFromGlibFull(p unsafe.Pointer) *PlayVisualization { wrapped := UnsafePlayVisualizationFromGlibBorrow(p) runtime.SetFinalizer( @@ -4879,7 +4838,9 @@ func UnsafePlayVisualizationToGlibFull(p *PlayVisualization) unsafe.Pointer { p.native = nil // PlayVisualization is invalid from here on return _p } + // Copy wraps gst_play_visualization_copy +// // The function returns the following values: // // - goret *PlayVisualization diff --git a/pkg/gstplayer/gstplayer.gen.go b/pkg/gstplayer/gstplayer.gen.go index 9816d68..4ee7e4a 100644 --- a/pkg/gstplayer/gstplayer.gen.go +++ b/pkg/gstplayer/gstplayer.gen.go @@ -182,6 +182,7 @@ func PlayerErrorGetName(err PlayerError) string { } // PlayerErrorQuark wraps gst_player_error_quark +// // The function returns the following values: // // - goret glib.Quark @@ -347,6 +348,16 @@ func UnsafePlayerSignalDispatcherToGlibFull(c PlayerSignalDispatcher) unsafe.Poi return gobject.UnsafeObjectToGlibFull(&i.Instance) } +// PlayerSignalDispatcherOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type PlayerSignalDispatcherOverrides[Instance PlayerSignalDispatcher] struct { +} + +// UnsafeApplyPlayerSignalDispatcherOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyPlayerSignalDispatcherOverrides[Instance PlayerSignalDispatcher](gclass unsafe.Pointer, overrides PlayerSignalDispatcherOverrides[Instance]) { +} + // PlayerVideoRendererInstance is the instance type used by all types implementing GstPlayerVideoRenderer. It is used internally by the bindings. Users should use the interface [PlayerVideoRenderer] instead. type PlayerVideoRendererInstance struct { _ [0]func() // equal guard @@ -398,6 +409,16 @@ func UnsafePlayerVideoRendererToGlibFull(c PlayerVideoRenderer) unsafe.Pointer { return gobject.UnsafeObjectToGlibFull(&i.Instance) } +// PlayerVideoRendererOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type PlayerVideoRendererOverrides[Instance PlayerVideoRenderer] struct { +} + +// UnsafeApplyPlayerVideoRendererOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyPlayerVideoRendererOverrides[Instance PlayerVideoRenderer](gclass unsafe.Pointer, overrides PlayerVideoRendererOverrides[Instance]) { +} + // PlayerInstance is the instance type used by all types extending GstPlayer. It is used internally by the bindings. Users should use the interface [Player] instead. type PlayerInstance struct { _ [0]func() // equal guard @@ -415,6 +436,7 @@ type Player interface { upcastToGstPlayer() *PlayerInstance // GetAudioVideoOffset wraps gst_player_get_audio_video_offset + // // The function returns the following values: // // - goret int64 @@ -434,6 +456,7 @@ type Player interface { // Retrieve the current value of the indicated @type. GetColorBalance(PlayerColorBalanceType) float64 // GetConfig wraps gst_player_get_config + // // The function returns the following values: // // - goret *gst.Structure @@ -443,6 +466,7 @@ type Player interface { // or it must be freed after usage. GetConfig() *gst.Structure // GetCurrentAudioTrack wraps gst_player_get_current_audio_track + // // The function returns the following values: // // - goret PlayerAudioInfo (nullable) @@ -450,6 +474,7 @@ type Player interface { // A Function to get current audio #GstPlayerAudioInfo instance. GetCurrentAudioTrack() PlayerAudioInfo // GetCurrentSubtitleTrack wraps gst_player_get_current_subtitle_track + // // The function returns the following values: // // - goret PlayerSubtitleInfo (nullable) @@ -457,6 +482,7 @@ type Player interface { // A Function to get current subtitle #GstPlayerSubtitleInfo instance. GetCurrentSubtitleTrack() PlayerSubtitleInfo // GetCurrentVideoTrack wraps gst_player_get_current_video_track + // // The function returns the following values: // // - goret PlayerVideoInfo (nullable) @@ -464,11 +490,13 @@ type Player interface { // A Function to get current video #GstPlayerVideoInfo instance. GetCurrentVideoTrack() PlayerVideoInfo // GetCurrentVisualization wraps gst_player_get_current_visualization + // // The function returns the following values: // // - goret string (nullable) GetCurrentVisualization() string // GetDuration wraps gst_player_get_duration + // // The function returns the following values: // // - goret gst.ClockTime @@ -476,6 +504,7 @@ type Player interface { // Retrieves the duration of the media stream that self represents. GetDuration() gst.ClockTime // GetMediaInfo wraps gst_player_get_media_info + // // The function returns the following values: // // - goret PlayerMediaInfo (nullable) @@ -483,6 +512,7 @@ type Player interface { // A Function to get the current media info #GstPlayerMediaInfo instance. GetMediaInfo() PlayerMediaInfo // GetMultiviewFlags wraps gst_player_get_multiview_flags + // // The function returns the following values: // // - goret gstvideo.VideoMultiviewFlags @@ -490,6 +520,7 @@ type Player interface { // Retrieve the current value of the indicated @type. GetMultiviewFlags() gstvideo.VideoMultiviewFlags // GetMultiviewMode wraps gst_player_get_multiview_mode + // // The function returns the following values: // // - goret gstvideo.VideoMultiviewFramePacking @@ -497,26 +528,31 @@ type Player interface { // Retrieve the current value of the indicated @type. GetMultiviewMode() gstvideo.VideoMultiviewFramePacking // GetMute wraps gst_player_get_mute + // // The function returns the following values: // // - goret bool GetMute() bool // GetPipeline wraps gst_player_get_pipeline + // // The function returns the following values: // // - goret gst.Element GetPipeline() gst.Element // GetPosition wraps gst_player_get_position + // // The function returns the following values: // // - goret gst.ClockTime GetPosition() gst.ClockTime // GetRate wraps gst_player_get_rate + // // The function returns the following values: // // - goret float64 GetRate() float64 // GetSubtitleURI wraps gst_player_get_subtitle_uri + // // The function returns the following values: // // - goret string (nullable) @@ -524,6 +560,7 @@ type Player interface { // current subtitle URI GetSubtitleURI() string // GetSubtitleVideoOffset wraps gst_player_get_subtitle_video_offset + // // The function returns the following values: // // - goret int64 @@ -531,6 +568,7 @@ type Player interface { // Retrieve the current value of subtitle-video-offset property GetSubtitleVideoOffset() int64 // GetURI wraps gst_player_get_uri + // // The function returns the following values: // // - goret string (nullable) @@ -556,6 +594,7 @@ type Player interface { // Except for GST_PLAYER_THUMBNAIL_RAW_NATIVE format, if no config is set, pixel-aspect-ratio would be 1/1 GetVideoSnapshot(PlayerSnapshotFormat, *gst.Structure) *gst.Sample // GetVolume wraps gst_player_get_volume + // // The function returns the following values: // // - goret float64 @@ -563,6 +602,7 @@ type Player interface { // Returns the current volume level, as a percentage between 0 and 1. GetVolume() float64 // HasColorBalance wraps gst_player_has_color_balance + // // The function returns the following values: // // - goret bool @@ -1140,6 +1180,7 @@ func PlayerGetVideoStreams(info PlayerMediaInfo) []PlayerVideoInfo { } // GetAudioVideoOffset wraps gst_player_get_audio_video_offset +// // The function returns the following values: // // - goret int64 @@ -1192,6 +1233,7 @@ func (player *PlayerInstance) GetColorBalance(typ PlayerColorBalanceType) float6 } // GetConfig wraps gst_player_get_config +// // The function returns the following values: // // - goret *gst.Structure @@ -1216,6 +1258,7 @@ func (player *PlayerInstance) GetConfig() *gst.Structure { } // GetCurrentAudioTrack wraps gst_player_get_current_audio_track +// // The function returns the following values: // // - goret PlayerAudioInfo (nullable) @@ -1240,6 +1283,7 @@ func (player *PlayerInstance) GetCurrentAudioTrack() PlayerAudioInfo { } // GetCurrentSubtitleTrack wraps gst_player_get_current_subtitle_track +// // The function returns the following values: // // - goret PlayerSubtitleInfo (nullable) @@ -1264,6 +1308,7 @@ func (player *PlayerInstance) GetCurrentSubtitleTrack() PlayerSubtitleInfo { } // GetCurrentVideoTrack wraps gst_player_get_current_video_track +// // The function returns the following values: // // - goret PlayerVideoInfo (nullable) @@ -1288,6 +1333,7 @@ func (player *PlayerInstance) GetCurrentVideoTrack() PlayerVideoInfo { } // GetCurrentVisualization wraps gst_player_get_current_visualization +// // The function returns the following values: // // - goret string (nullable) @@ -1311,6 +1357,7 @@ func (player *PlayerInstance) GetCurrentVisualization() string { } // GetDuration wraps gst_player_get_duration +// // The function returns the following values: // // - goret gst.ClockTime @@ -1333,6 +1380,7 @@ func (player *PlayerInstance) GetDuration() gst.ClockTime { } // GetMediaInfo wraps gst_player_get_media_info +// // The function returns the following values: // // - goret PlayerMediaInfo (nullable) @@ -1357,6 +1405,7 @@ func (player *PlayerInstance) GetMediaInfo() PlayerMediaInfo { } // GetMultiviewFlags wraps gst_player_get_multiview_flags +// // The function returns the following values: // // - goret gstvideo.VideoMultiviewFlags @@ -1379,6 +1428,7 @@ func (player *PlayerInstance) GetMultiviewFlags() gstvideo.VideoMultiviewFlags { } // GetMultiviewMode wraps gst_player_get_multiview_mode +// // The function returns the following values: // // - goret gstvideo.VideoMultiviewFramePacking @@ -1401,6 +1451,7 @@ func (player *PlayerInstance) GetMultiviewMode() gstvideo.VideoMultiviewFramePac } // GetMute wraps gst_player_get_mute +// // The function returns the following values: // // - goret bool @@ -1423,6 +1474,7 @@ func (player *PlayerInstance) GetMute() bool { } // GetPipeline wraps gst_player_get_pipeline +// // The function returns the following values: // // - goret gst.Element @@ -1443,6 +1495,7 @@ func (player *PlayerInstance) GetPipeline() gst.Element { } // GetPosition wraps gst_player_get_position +// // The function returns the following values: // // - goret gst.ClockTime @@ -1463,6 +1516,7 @@ func (player *PlayerInstance) GetPosition() gst.ClockTime { } // GetRate wraps gst_player_get_rate +// // The function returns the following values: // // - goret float64 @@ -1483,6 +1537,7 @@ func (player *PlayerInstance) GetRate() float64 { } // GetSubtitleURI wraps gst_player_get_subtitle_uri +// // The function returns the following values: // // - goret string (nullable) @@ -1508,6 +1563,7 @@ func (player *PlayerInstance) GetSubtitleURI() string { } // GetSubtitleVideoOffset wraps gst_player_get_subtitle_video_offset +// // The function returns the following values: // // - goret int64 @@ -1530,6 +1586,7 @@ func (player *PlayerInstance) GetSubtitleVideoOffset() int64 { } // GetURI wraps gst_player_get_uri +// // The function returns the following values: // // - goret string (nullable) @@ -1598,6 +1655,7 @@ func (player *PlayerInstance) GetVideoSnapshot(format PlayerSnapshotFormat, conf } // GetVolume wraps gst_player_get_volume +// // The function returns the following values: // // - goret float64 @@ -1620,6 +1678,7 @@ func (player *PlayerInstance) GetVolume() float64 { } // HasColorBalance wraps gst_player_has_color_balance +// // The function returns the following values: // // - goret bool @@ -2163,54 +2222,67 @@ func (player *PlayerInstance) Stop() { func (o *PlayerInstance) ConnectBuffering(fn func(Player, int)) gobject.SignalHandle { return o.Connect("buffering", fn) } + // ConnectDurationChanged connects the provided callback to the "duration-changed" signal func (o *PlayerInstance) ConnectDurationChanged(fn func(Player, uint64)) gobject.SignalHandle { return o.Connect("duration-changed", fn) } + // ConnectEndOfStream connects the provided callback to the "end-of-stream" signal func (o *PlayerInstance) ConnectEndOfStream(fn func(Player)) gobject.SignalHandle { return o.Connect("end-of-stream", fn) } + // ConnectError connects the provided callback to the "error" signal func (o *PlayerInstance) ConnectError(fn func(Player, error)) gobject.SignalHandle { return o.Connect("error", fn) } + // ConnectMediaInfoUpdated connects the provided callback to the "media-info-updated" signal func (o *PlayerInstance) ConnectMediaInfoUpdated(fn func(Player, PlayerMediaInfo)) gobject.SignalHandle { return o.Connect("media-info-updated", fn) } + // ConnectMuteChanged connects the provided callback to the "mute-changed" signal func (o *PlayerInstance) ConnectMuteChanged(fn func(Player)) gobject.SignalHandle { return o.Connect("mute-changed", fn) } + // ConnectPositionUpdated connects the provided callback to the "position-updated" signal func (o *PlayerInstance) ConnectPositionUpdated(fn func(Player, uint64)) gobject.SignalHandle { return o.Connect("position-updated", fn) } + // ConnectSeekDone connects the provided callback to the "seek-done" signal func (o *PlayerInstance) ConnectSeekDone(fn func(Player, uint64)) gobject.SignalHandle { return o.Connect("seek-done", fn) } + // ConnectStateChanged connects the provided callback to the "state-changed" signal func (o *PlayerInstance) ConnectStateChanged(fn func(Player, PlayerState)) gobject.SignalHandle { return o.Connect("state-changed", fn) } + // ConnectURILoaded connects the provided callback to the "uri-loaded" signal func (o *PlayerInstance) ConnectURILoaded(fn func(Player, string)) gobject.SignalHandle { return o.Connect("uri-loaded", fn) } + // ConnectVideoDimensionsChanged connects the provided callback to the "video-dimensions-changed" signal func (o *PlayerInstance) ConnectVideoDimensionsChanged(fn func(Player, int, int)) gobject.SignalHandle { return o.Connect("video-dimensions-changed", fn) } + // ConnectVolumeChanged connects the provided callback to the "volume-changed" signal func (o *PlayerInstance) ConnectVolumeChanged(fn func(Player)) gobject.SignalHandle { return o.Connect("volume-changed", fn) } + // ConnectWarning connects the provided callback to the "warning" signal func (o *PlayerInstance) ConnectWarning(fn func(Player, error)) gobject.SignalHandle { return o.Connect("warning", fn) } + // PlayerGMainContextSignalDispatcherInstance is the instance type used by all types extending GstPlayerGMainContextSignalDispatcher. It is used internally by the bindings. Users should use the interface [PlayerGMainContextSignalDispatcher] instead. type PlayerGMainContextSignalDispatcherInstance struct { _ [0]func() // equal guard @@ -2305,21 +2377,25 @@ type PlayerMediaInfo interface { upcastToGstPlayerMediaInfo() *PlayerMediaInfoInstance // GetAudioStreams wraps gst_player_media_info_get_audio_streams + // // The function returns the following values: // // - goret []PlayerAudioInfo GetAudioStreams() []PlayerAudioInfo // GetContainerFormat wraps gst_player_media_info_get_container_format + // // The function returns the following values: // // - goret string (nullable) GetContainerFormat() string // GetDuration wraps gst_player_media_info_get_duration + // // The function returns the following values: // // - goret gst.ClockTime GetDuration() gst.ClockTime // GetImageSample wraps gst_player_media_info_get_image_sample + // // The function returns the following values: // // - goret *gst.Sample (nullable) @@ -2328,61 +2404,73 @@ type PlayerMediaInfo interface { // Application can use `gst_sample_*_()` API's to get caps, buffer etc. GetImageSample() *gst.Sample // GetNumberOfAudioStreams wraps gst_player_media_info_get_number_of_audio_streams + // // The function returns the following values: // // - goret uint GetNumberOfAudioStreams() uint // GetNumberOfStreams wraps gst_player_media_info_get_number_of_streams + // // The function returns the following values: // // - goret uint GetNumberOfStreams() uint // GetNumberOfSubtitleStreams wraps gst_player_media_info_get_number_of_subtitle_streams + // // The function returns the following values: // // - goret uint GetNumberOfSubtitleStreams() uint // GetNumberOfVideoStreams wraps gst_player_media_info_get_number_of_video_streams + // // The function returns the following values: // // - goret uint GetNumberOfVideoStreams() uint // GetStreamList wraps gst_player_media_info_get_stream_list + // // The function returns the following values: // // - goret []PlayerStreamInfo GetStreamList() []PlayerStreamInfo // GetSubtitleStreams wraps gst_player_media_info_get_subtitle_streams + // // The function returns the following values: // // - goret []PlayerSubtitleInfo GetSubtitleStreams() []PlayerSubtitleInfo // GetTags wraps gst_player_media_info_get_tags + // // The function returns the following values: // // - goret *gst.TagList (nullable) GetTags() *gst.TagList // GetTitle wraps gst_player_media_info_get_title + // // The function returns the following values: // // - goret string (nullable) GetTitle() string // GetURI wraps gst_player_media_info_get_uri + // // The function returns the following values: // // - goret string GetURI() string // GetVideoStreams wraps gst_player_media_info_get_video_streams + // // The function returns the following values: // // - goret []PlayerVideoInfo GetVideoStreams() []PlayerVideoInfo // IsLive wraps gst_player_media_info_is_live + // // The function returns the following values: // // - goret bool IsLive() bool // IsSeekable wraps gst_player_media_info_is_seekable + // // The function returns the following values: // // - goret bool @@ -2424,6 +2512,7 @@ func UnsafePlayerMediaInfoToGlibFull(c PlayerMediaInfo) unsafe.Pointer { } // GetAudioStreams wraps gst_player_media_info_get_audio_streams +// // The function returns the following values: // // - goret []PlayerAudioInfo @@ -2451,6 +2540,7 @@ func (info *PlayerMediaInfoInstance) GetAudioStreams() []PlayerAudioInfo { } // GetContainerFormat wraps gst_player_media_info_get_container_format +// // The function returns the following values: // // - goret string (nullable) @@ -2473,6 +2563,7 @@ func (info *PlayerMediaInfoInstance) GetContainerFormat() string { } // GetDuration wraps gst_player_media_info_get_duration +// // The function returns the following values: // // - goret gst.ClockTime @@ -2493,6 +2584,7 @@ func (info *PlayerMediaInfoInstance) GetDuration() gst.ClockTime { } // GetImageSample wraps gst_player_media_info_get_image_sample +// // The function returns the following values: // // - goret *gst.Sample (nullable) @@ -2518,6 +2610,7 @@ func (info *PlayerMediaInfoInstance) GetImageSample() *gst.Sample { } // GetNumberOfAudioStreams wraps gst_player_media_info_get_number_of_audio_streams +// // The function returns the following values: // // - goret uint @@ -2538,6 +2631,7 @@ func (info *PlayerMediaInfoInstance) GetNumberOfAudioStreams() uint { } // GetNumberOfStreams wraps gst_player_media_info_get_number_of_streams +// // The function returns the following values: // // - goret uint @@ -2558,6 +2652,7 @@ func (info *PlayerMediaInfoInstance) GetNumberOfStreams() uint { } // GetNumberOfSubtitleStreams wraps gst_player_media_info_get_number_of_subtitle_streams +// // The function returns the following values: // // - goret uint @@ -2578,6 +2673,7 @@ func (info *PlayerMediaInfoInstance) GetNumberOfSubtitleStreams() uint { } // GetNumberOfVideoStreams wraps gst_player_media_info_get_number_of_video_streams +// // The function returns the following values: // // - goret uint @@ -2598,6 +2694,7 @@ func (info *PlayerMediaInfoInstance) GetNumberOfVideoStreams() uint { } // GetStreamList wraps gst_player_media_info_get_stream_list +// // The function returns the following values: // // - goret []PlayerStreamInfo @@ -2625,6 +2722,7 @@ func (info *PlayerMediaInfoInstance) GetStreamList() []PlayerStreamInfo { } // GetSubtitleStreams wraps gst_player_media_info_get_subtitle_streams +// // The function returns the following values: // // - goret []PlayerSubtitleInfo @@ -2652,6 +2750,7 @@ func (info *PlayerMediaInfoInstance) GetSubtitleStreams() []PlayerSubtitleInfo { } // GetTags wraps gst_player_media_info_get_tags +// // The function returns the following values: // // - goret *gst.TagList (nullable) @@ -2674,6 +2773,7 @@ func (info *PlayerMediaInfoInstance) GetTags() *gst.TagList { } // GetTitle wraps gst_player_media_info_get_title +// // The function returns the following values: // // - goret string (nullable) @@ -2696,6 +2796,7 @@ func (info *PlayerMediaInfoInstance) GetTitle() string { } // GetURI wraps gst_player_media_info_get_uri +// // The function returns the following values: // // - goret string @@ -2716,6 +2817,7 @@ func (info *PlayerMediaInfoInstance) GetURI() string { } // GetVideoStreams wraps gst_player_media_info_get_video_streams +// // The function returns the following values: // // - goret []PlayerVideoInfo @@ -2743,6 +2845,7 @@ func (info *PlayerMediaInfoInstance) GetVideoStreams() []PlayerVideoInfo { } // IsLive wraps gst_player_media_info_is_live +// // The function returns the following values: // // - goret bool @@ -2765,6 +2868,7 @@ func (info *PlayerMediaInfoInstance) IsLive() bool { } // IsSeekable wraps gst_player_media_info_is_seekable +// // The function returns the following values: // // - goret bool @@ -2804,11 +2908,13 @@ type PlayerStreamInfo interface { upcastToGstPlayerStreamInfo() *PlayerStreamInfoInstance // GetCaps wraps gst_player_stream_info_get_caps + // // The function returns the following values: // // - goret *gst.Caps (nullable) GetCaps() *gst.Caps // GetCodec wraps gst_player_stream_info_get_codec + // // The function returns the following values: // // - goret string (nullable) @@ -2816,6 +2922,7 @@ type PlayerStreamInfo interface { // A string describing codec used in #GstPlayerStreamInfo. GetCodec() string // GetIndex wraps gst_player_stream_info_get_index + // // The function returns the following values: // // - goret int @@ -2824,6 +2931,7 @@ type PlayerStreamInfo interface { // unknown. GetIndex() int // GetStreamType wraps gst_player_stream_info_get_stream_type + // // The function returns the following values: // // - goret string @@ -2832,6 +2940,7 @@ type PlayerStreamInfo interface { // of the given @info (ex: "audio", "video", "subtitle") GetStreamType() string // GetTags wraps gst_player_stream_info_get_tags + // // The function returns the following values: // // - goret *gst.TagList (nullable) @@ -2873,6 +2982,7 @@ func UnsafePlayerStreamInfoToGlibFull(c PlayerStreamInfo) unsafe.Pointer { } // GetCaps wraps gst_player_stream_info_get_caps +// // The function returns the following values: // // - goret *gst.Caps (nullable) @@ -2895,6 +3005,7 @@ func (info *PlayerStreamInfoInstance) GetCaps() *gst.Caps { } // GetCodec wraps gst_player_stream_info_get_codec +// // The function returns the following values: // // - goret string (nullable) @@ -2919,6 +3030,7 @@ func (info *PlayerStreamInfoInstance) GetCodec() string { } // GetIndex wraps gst_player_stream_info_get_index +// // The function returns the following values: // // - goret int @@ -2942,6 +3054,7 @@ func (info *PlayerStreamInfoInstance) GetIndex() int { } // GetStreamType wraps gst_player_stream_info_get_stream_type +// // The function returns the following values: // // - goret string @@ -2965,6 +3078,7 @@ func (info *PlayerStreamInfoInstance) GetStreamType() string { } // GetTags wraps gst_player_stream_info_get_tags +// // The function returns the following values: // // - goret *gst.TagList (nullable) @@ -3002,6 +3116,7 @@ type PlayerSubtitleInfo interface { upcastToGstPlayerSubtitleInfo() *PlayerSubtitleInfoInstance // GetLanguage wraps gst_player_subtitle_info_get_language + // // The function returns the following values: // // - goret string (nullable) @@ -3045,6 +3160,7 @@ func UnsafePlayerSubtitleInfoToGlibFull(c PlayerSubtitleInfo) unsafe.Pointer { } // GetLanguage wraps gst_player_subtitle_info_get_language +// // The function returns the following values: // // - goret string (nullable) @@ -3082,27 +3198,32 @@ type PlayerVideoInfo interface { upcastToGstPlayerVideoInfo() *PlayerVideoInfoInstance // GetBitrate wraps gst_player_video_info_get_bitrate + // // The function returns the following values: // // - goret int GetBitrate() int // GetFramerate wraps gst_player_video_info_get_framerate + // // The function returns the following values: // // - fpsN int: Numerator of frame rate // - fpsD int: Denominator of frame rate GetFramerate() (int, int) // GetHeight wraps gst_player_video_info_get_height + // // The function returns the following values: // // - goret int GetHeight() int // GetMaxBitrate wraps gst_player_video_info_get_max_bitrate + // // The function returns the following values: // // - goret int GetMaxBitrate() int // GetPixelAspectRatio wraps gst_player_video_info_get_pixel_aspect_ratio + // // The function returns the following values: // // - parN uint: numerator @@ -3111,6 +3232,7 @@ type PlayerVideoInfo interface { // Returns the pixel aspect ratio in @par_n and @par_d GetPixelAspectRatio() (uint, uint) // GetWidth wraps gst_player_video_info_get_width + // // The function returns the following values: // // - goret int @@ -3154,6 +3276,7 @@ func UnsafePlayerVideoInfoToGlibFull(c PlayerVideoInfo) unsafe.Pointer { } // GetBitrate wraps gst_player_video_info_get_bitrate +// // The function returns the following values: // // - goret int @@ -3174,6 +3297,7 @@ func (info *PlayerVideoInfoInstance) GetBitrate() int { } // GetFramerate wraps gst_player_video_info_get_framerate +// // The function returns the following values: // // - fpsN int: Numerator of frame rate @@ -3198,6 +3322,7 @@ func (info *PlayerVideoInfoInstance) GetFramerate() (int, int) { } // GetHeight wraps gst_player_video_info_get_height +// // The function returns the following values: // // - goret int @@ -3218,6 +3343,7 @@ func (info *PlayerVideoInfoInstance) GetHeight() int { } // GetMaxBitrate wraps gst_player_video_info_get_max_bitrate +// // The function returns the following values: // // - goret int @@ -3238,6 +3364,7 @@ func (info *PlayerVideoInfoInstance) GetMaxBitrate() int { } // GetPixelAspectRatio wraps gst_player_video_info_get_pixel_aspect_ratio +// // The function returns the following values: // // - parN uint: numerator @@ -3264,6 +3391,7 @@ func (info *PlayerVideoInfoInstance) GetPixelAspectRatio() (uint, uint) { } // GetWidth wraps gst_player_video_info_get_width +// // The function returns the following values: // // - goret int @@ -3302,6 +3430,7 @@ type PlayerVideoOverlayVideoRenderer interface { // in the drawable even if the pipeline is PAUSED. Expose() // GetRenderRectangle wraps gst_player_video_overlay_video_renderer_get_render_rectangle + // // The function returns the following values: // // - x int: the horizontal offset of the render area inside the window @@ -3382,6 +3511,7 @@ func (self *PlayerVideoOverlayVideoRendererInstance) Expose() { } // GetRenderRectangle wraps gst_player_video_overlay_video_renderer_get_render_rectangle +// // The function returns the following values: // // - x int: the horizontal offset of the render area inside the window @@ -3472,26 +3602,31 @@ type PlayerAudioInfo interface { upcastToGstPlayerAudioInfo() *PlayerAudioInfoInstance // GetBitrate wraps gst_player_audio_info_get_bitrate + // // The function returns the following values: // // - goret int GetBitrate() int // GetChannels wraps gst_player_audio_info_get_channels + // // The function returns the following values: // // - goret int GetChannels() int // GetLanguage wraps gst_player_audio_info_get_language + // // The function returns the following values: // // - goret string (nullable) GetLanguage() string // GetMaxBitrate wraps gst_player_audio_info_get_max_bitrate + // // The function returns the following values: // // - goret int GetMaxBitrate() int // GetSampleRate wraps gst_player_audio_info_get_sample_rate + // // The function returns the following values: // // - goret int @@ -3535,6 +3670,7 @@ func UnsafePlayerAudioInfoToGlibFull(c PlayerAudioInfo) unsafe.Pointer { } // GetBitrate wraps gst_player_audio_info_get_bitrate +// // The function returns the following values: // // - goret int @@ -3555,6 +3691,7 @@ func (info *PlayerAudioInfoInstance) GetBitrate() int { } // GetChannels wraps gst_player_audio_info_get_channels +// // The function returns the following values: // // - goret int @@ -3575,6 +3712,7 @@ func (info *PlayerAudioInfoInstance) GetChannels() int { } // GetLanguage wraps gst_player_audio_info_get_language +// // The function returns the following values: // // - goret string (nullable) @@ -3597,6 +3735,7 @@ func (info *PlayerAudioInfoInstance) GetLanguage() string { } // GetMaxBitrate wraps gst_player_audio_info_get_max_bitrate +// // The function returns the following values: // // - goret int @@ -3617,6 +3756,7 @@ func (info *PlayerAudioInfoInstance) GetMaxBitrate() int { } // GetSampleRate wraps gst_player_audio_info_get_sample_rate +// // The function returns the following values: // // - goret int @@ -3637,6 +3777,8 @@ func (info *PlayerAudioInfoInstance) GetSampleRate() int { } // PlayerAudioInfoClass wraps GstPlayerAudioInfoClass +// +// PlayerAudioInfoClass is the type struct for [PlayerAudioInfo] type PlayerAudioInfoClass struct { *playerAudioInfoClass } @@ -3651,31 +3793,6 @@ func UnsafePlayerAudioInfoClassFromGlibBorrow(p unsafe.Pointer) *PlayerAudioInfo return &PlayerAudioInfoClass{&playerAudioInfoClass{(*C.GstPlayerAudioInfoClass)(p)}} } -// UnsafePlayerAudioInfoClassFromGlibNone is used to convert raw C.GstPlayerAudioInfoClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafePlayerAudioInfoClassFromGlibNone(p unsafe.Pointer) *PlayerAudioInfoClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafePlayerAudioInfoClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.playerAudioInfoClass, - func (intern *playerAudioInfoClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafePlayerAudioInfoClassFromGlibFull is used to convert raw C.GstPlayerAudioInfoClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafePlayerAudioInfoClassFromGlibFull(p unsafe.Pointer) *PlayerAudioInfoClass { - wrapped := UnsafePlayerAudioInfoClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.playerAudioInfoClass, - func (intern *playerAudioInfoClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafePlayerAudioInfoClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [PlayerAudioInfoClass] is expected to work anymore. @@ -3688,15 +3805,18 @@ func UnsafePlayerAudioInfoClassToGlibNone(p *PlayerAudioInfoClass) unsafe.Pointe return unsafe.Pointer(p.native) } -// UnsafePlayerAudioInfoClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafePlayerAudioInfoClassToGlibFull(p *PlayerAudioInfoClass) unsafe.Pointer { - runtime.SetFinalizer(p.playerAudioInfoClass, nil) - _p := unsafe.Pointer(p.native) - p.native = nil // PlayerAudioInfoClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (p *PlayerAudioInfoClass) ParentClass() *PlayerStreamInfoClass { + parent := UnsafePlayerStreamInfoClassFromGlibBorrow(UnsafePlayerAudioInfoClassToGlibNone(p)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *PlayerAudioInfoClass) {}, p) + return parent } + // PlayerClass wraps GstPlayerClass +// +// PlayerClass is the type struct for [Player] type PlayerClass struct { *playerClass } @@ -3711,31 +3831,6 @@ func UnsafePlayerClassFromGlibBorrow(p unsafe.Pointer) *PlayerClass { return &PlayerClass{&playerClass{(*C.GstPlayerClass)(p)}} } -// UnsafePlayerClassFromGlibNone is used to convert raw C.GstPlayerClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafePlayerClassFromGlibNone(p unsafe.Pointer) *PlayerClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafePlayerClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.playerClass, - func (intern *playerClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafePlayerClassFromGlibFull is used to convert raw C.GstPlayerClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafePlayerClassFromGlibFull(p unsafe.Pointer) *PlayerClass { - wrapped := UnsafePlayerClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.playerClass, - func (intern *playerClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafePlayerClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [PlayerClass] is expected to work anymore. @@ -3748,15 +3843,18 @@ func UnsafePlayerClassToGlibNone(p *PlayerClass) unsafe.Pointer { return unsafe.Pointer(p.native) } -// UnsafePlayerClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafePlayerClassToGlibFull(p *PlayerClass) unsafe.Pointer { - runtime.SetFinalizer(p.playerClass, nil) - _p := unsafe.Pointer(p.native) - p.native = nil // PlayerClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (p *PlayerClass) ParentClass() *gst.ObjectClass { + parent := gst.UnsafeObjectClassFromGlibBorrow(UnsafePlayerClassToGlibNone(p)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *PlayerClass) {}, p) + return parent } + // PlayerGMainContextSignalDispatcherClass wraps GstPlayerGMainContextSignalDispatcherClass +// +// PlayerGMainContextSignalDispatcherClass is the type struct for [PlayerGMainContextSignalDispatcher] type PlayerGMainContextSignalDispatcherClass struct { *playerGMainContextSignalDispatcherClass } @@ -3771,31 +3869,6 @@ func UnsafePlayerGMainContextSignalDispatcherClassFromGlibBorrow(p unsafe.Pointe return &PlayerGMainContextSignalDispatcherClass{&playerGMainContextSignalDispatcherClass{(*C.GstPlayerGMainContextSignalDispatcherClass)(p)}} } -// UnsafePlayerGMainContextSignalDispatcherClassFromGlibNone is used to convert raw C.GstPlayerGMainContextSignalDispatcherClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafePlayerGMainContextSignalDispatcherClassFromGlibNone(p unsafe.Pointer) *PlayerGMainContextSignalDispatcherClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafePlayerGMainContextSignalDispatcherClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.playerGMainContextSignalDispatcherClass, - func (intern *playerGMainContextSignalDispatcherClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafePlayerGMainContextSignalDispatcherClassFromGlibFull is used to convert raw C.GstPlayerGMainContextSignalDispatcherClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafePlayerGMainContextSignalDispatcherClassFromGlibFull(p unsafe.Pointer) *PlayerGMainContextSignalDispatcherClass { - wrapped := UnsafePlayerGMainContextSignalDispatcherClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.playerGMainContextSignalDispatcherClass, - func (intern *playerGMainContextSignalDispatcherClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafePlayerGMainContextSignalDispatcherClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [PlayerGMainContextSignalDispatcherClass] is expected to work anymore. @@ -3808,15 +3881,18 @@ func UnsafePlayerGMainContextSignalDispatcherClassToGlibNone(p *PlayerGMainConte return unsafe.Pointer(p.native) } -// UnsafePlayerGMainContextSignalDispatcherClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafePlayerGMainContextSignalDispatcherClassToGlibFull(p *PlayerGMainContextSignalDispatcherClass) unsafe.Pointer { - runtime.SetFinalizer(p.playerGMainContextSignalDispatcherClass, nil) - _p := unsafe.Pointer(p.native) - p.native = nil // PlayerGMainContextSignalDispatcherClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (p *PlayerGMainContextSignalDispatcherClass) ParentClass() *gobject.ObjectClass { + parent := gobject.UnsafeObjectClassFromGlibBorrow(UnsafePlayerGMainContextSignalDispatcherClassToGlibNone(p)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *PlayerGMainContextSignalDispatcherClass) {}, p) + return parent } + // PlayerMediaInfoClass wraps GstPlayerMediaInfoClass +// +// PlayerMediaInfoClass is the type struct for [PlayerMediaInfo] type PlayerMediaInfoClass struct { *playerMediaInfoClass } @@ -3831,31 +3907,6 @@ func UnsafePlayerMediaInfoClassFromGlibBorrow(p unsafe.Pointer) *PlayerMediaInfo return &PlayerMediaInfoClass{&playerMediaInfoClass{(*C.GstPlayerMediaInfoClass)(p)}} } -// UnsafePlayerMediaInfoClassFromGlibNone is used to convert raw C.GstPlayerMediaInfoClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafePlayerMediaInfoClassFromGlibNone(p unsafe.Pointer) *PlayerMediaInfoClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafePlayerMediaInfoClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.playerMediaInfoClass, - func (intern *playerMediaInfoClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafePlayerMediaInfoClassFromGlibFull is used to convert raw C.GstPlayerMediaInfoClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafePlayerMediaInfoClassFromGlibFull(p unsafe.Pointer) *PlayerMediaInfoClass { - wrapped := UnsafePlayerMediaInfoClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.playerMediaInfoClass, - func (intern *playerMediaInfoClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafePlayerMediaInfoClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [PlayerMediaInfoClass] is expected to work anymore. @@ -3868,14 +3919,15 @@ func UnsafePlayerMediaInfoClassToGlibNone(p *PlayerMediaInfoClass) unsafe.Pointe return unsafe.Pointer(p.native) } -// UnsafePlayerMediaInfoClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafePlayerMediaInfoClassToGlibFull(p *PlayerMediaInfoClass) unsafe.Pointer { - runtime.SetFinalizer(p.playerMediaInfoClass, nil) - _p := unsafe.Pointer(p.native) - p.native = nil // PlayerMediaInfoClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (p *PlayerMediaInfoClass) ParentClass() *gobject.ObjectClass { + parent := gobject.UnsafeObjectClassFromGlibBorrow(UnsafePlayerMediaInfoClassToGlibNone(p)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *PlayerMediaInfoClass) {}, p) + return parent } + // PlayerSignalDispatcherInterface wraps GstPlayerSignalDispatcherInterface type PlayerSignalDispatcherInterface struct { *playerSignalDispatcherInterface @@ -3891,7 +3943,7 @@ func UnsafePlayerSignalDispatcherInterfaceFromGlibBorrow(p unsafe.Pointer) *Play return &PlayerSignalDispatcherInterface{&playerSignalDispatcherInterface{(*C.GstPlayerSignalDispatcherInterface)(p)}} } -// UnsafePlayerSignalDispatcherInterfaceFromGlibNone is used to convert raw C.GstPlayerSignalDispatcherInterface pointers to go while taking a reference. This is used by the bindings internally. +// UnsafePlayerSignalDispatcherInterfaceFromGlibNone is used to convert raw C.GstPlayerSignalDispatcherInterface pointers to go without transferring ownership. This is used by the bindings internally. func UnsafePlayerSignalDispatcherInterfaceFromGlibNone(p unsafe.Pointer) *PlayerSignalDispatcherInterface { // FIXME: this has no ref function, what should we do here? wrapped := UnsafePlayerSignalDispatcherInterfaceFromGlibBorrow(p) @@ -3904,7 +3956,7 @@ func UnsafePlayerSignalDispatcherInterfaceFromGlibNone(p unsafe.Pointer) *Player return wrapped } -// UnsafePlayerSignalDispatcherInterfaceFromGlibFull is used to convert raw C.GstPlayerSignalDispatcherInterface pointers to go while taking a reference. This is used by the bindings internally. +// UnsafePlayerSignalDispatcherInterfaceFromGlibFull is used to convert raw C.GstPlayerSignalDispatcherInterface pointers to go while taking ownership. This is used by the bindings internally. func UnsafePlayerSignalDispatcherInterfaceFromGlibFull(p unsafe.Pointer) *PlayerSignalDispatcherInterface { wrapped := UnsafePlayerSignalDispatcherInterfaceFromGlibBorrow(p) runtime.SetFinalizer( @@ -3936,7 +3988,10 @@ func UnsafePlayerSignalDispatcherInterfaceToGlibFull(p *PlayerSignalDispatcherIn p.native = nil // PlayerSignalDispatcherInterface is invalid from here on return _p } + // PlayerStreamInfoClass wraps GstPlayerStreamInfoClass +// +// PlayerStreamInfoClass is the type struct for [PlayerStreamInfo] type PlayerStreamInfoClass struct { *playerStreamInfoClass } @@ -3951,31 +4006,6 @@ func UnsafePlayerStreamInfoClassFromGlibBorrow(p unsafe.Pointer) *PlayerStreamIn return &PlayerStreamInfoClass{&playerStreamInfoClass{(*C.GstPlayerStreamInfoClass)(p)}} } -// UnsafePlayerStreamInfoClassFromGlibNone is used to convert raw C.GstPlayerStreamInfoClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafePlayerStreamInfoClassFromGlibNone(p unsafe.Pointer) *PlayerStreamInfoClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafePlayerStreamInfoClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.playerStreamInfoClass, - func (intern *playerStreamInfoClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafePlayerStreamInfoClassFromGlibFull is used to convert raw C.GstPlayerStreamInfoClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafePlayerStreamInfoClassFromGlibFull(p unsafe.Pointer) *PlayerStreamInfoClass { - wrapped := UnsafePlayerStreamInfoClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.playerStreamInfoClass, - func (intern *playerStreamInfoClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafePlayerStreamInfoClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [PlayerStreamInfoClass] is expected to work anymore. @@ -3988,15 +4018,18 @@ func UnsafePlayerStreamInfoClassToGlibNone(p *PlayerStreamInfoClass) unsafe.Poin return unsafe.Pointer(p.native) } -// UnsafePlayerStreamInfoClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafePlayerStreamInfoClassToGlibFull(p *PlayerStreamInfoClass) unsafe.Pointer { - runtime.SetFinalizer(p.playerStreamInfoClass, nil) - _p := unsafe.Pointer(p.native) - p.native = nil // PlayerStreamInfoClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (p *PlayerStreamInfoClass) ParentClass() *gobject.ObjectClass { + parent := gobject.UnsafeObjectClassFromGlibBorrow(UnsafePlayerStreamInfoClassToGlibNone(p)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *PlayerStreamInfoClass) {}, p) + return parent } + // PlayerSubtitleInfoClass wraps GstPlayerSubtitleInfoClass +// +// PlayerSubtitleInfoClass is the type struct for [PlayerSubtitleInfo] type PlayerSubtitleInfoClass struct { *playerSubtitleInfoClass } @@ -4011,31 +4044,6 @@ func UnsafePlayerSubtitleInfoClassFromGlibBorrow(p unsafe.Pointer) *PlayerSubtit return &PlayerSubtitleInfoClass{&playerSubtitleInfoClass{(*C.GstPlayerSubtitleInfoClass)(p)}} } -// UnsafePlayerSubtitleInfoClassFromGlibNone is used to convert raw C.GstPlayerSubtitleInfoClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafePlayerSubtitleInfoClassFromGlibNone(p unsafe.Pointer) *PlayerSubtitleInfoClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafePlayerSubtitleInfoClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.playerSubtitleInfoClass, - func (intern *playerSubtitleInfoClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafePlayerSubtitleInfoClassFromGlibFull is used to convert raw C.GstPlayerSubtitleInfoClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafePlayerSubtitleInfoClassFromGlibFull(p unsafe.Pointer) *PlayerSubtitleInfoClass { - wrapped := UnsafePlayerSubtitleInfoClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.playerSubtitleInfoClass, - func (intern *playerSubtitleInfoClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafePlayerSubtitleInfoClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [PlayerSubtitleInfoClass] is expected to work anymore. @@ -4048,15 +4056,18 @@ func UnsafePlayerSubtitleInfoClassToGlibNone(p *PlayerSubtitleInfoClass) unsafe. return unsafe.Pointer(p.native) } -// UnsafePlayerSubtitleInfoClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafePlayerSubtitleInfoClassToGlibFull(p *PlayerSubtitleInfoClass) unsafe.Pointer { - runtime.SetFinalizer(p.playerSubtitleInfoClass, nil) - _p := unsafe.Pointer(p.native) - p.native = nil // PlayerSubtitleInfoClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (p *PlayerSubtitleInfoClass) ParentClass() *PlayerStreamInfoClass { + parent := UnsafePlayerStreamInfoClassFromGlibBorrow(UnsafePlayerSubtitleInfoClassToGlibNone(p)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *PlayerSubtitleInfoClass) {}, p) + return parent } + // PlayerVideoInfoClass wraps GstPlayerVideoInfoClass +// +// PlayerVideoInfoClass is the type struct for [PlayerVideoInfo] type PlayerVideoInfoClass struct { *playerVideoInfoClass } @@ -4071,31 +4082,6 @@ func UnsafePlayerVideoInfoClassFromGlibBorrow(p unsafe.Pointer) *PlayerVideoInfo return &PlayerVideoInfoClass{&playerVideoInfoClass{(*C.GstPlayerVideoInfoClass)(p)}} } -// UnsafePlayerVideoInfoClassFromGlibNone is used to convert raw C.GstPlayerVideoInfoClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafePlayerVideoInfoClassFromGlibNone(p unsafe.Pointer) *PlayerVideoInfoClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafePlayerVideoInfoClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.playerVideoInfoClass, - func (intern *playerVideoInfoClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafePlayerVideoInfoClassFromGlibFull is used to convert raw C.GstPlayerVideoInfoClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafePlayerVideoInfoClassFromGlibFull(p unsafe.Pointer) *PlayerVideoInfoClass { - wrapped := UnsafePlayerVideoInfoClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.playerVideoInfoClass, - func (intern *playerVideoInfoClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafePlayerVideoInfoClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [PlayerVideoInfoClass] is expected to work anymore. @@ -4108,15 +4094,18 @@ func UnsafePlayerVideoInfoClassToGlibNone(p *PlayerVideoInfoClass) unsafe.Pointe return unsafe.Pointer(p.native) } -// UnsafePlayerVideoInfoClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafePlayerVideoInfoClassToGlibFull(p *PlayerVideoInfoClass) unsafe.Pointer { - runtime.SetFinalizer(p.playerVideoInfoClass, nil) - _p := unsafe.Pointer(p.native) - p.native = nil // PlayerVideoInfoClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (p *PlayerVideoInfoClass) ParentClass() *PlayerStreamInfoClass { + parent := UnsafePlayerStreamInfoClassFromGlibBorrow(UnsafePlayerVideoInfoClassToGlibNone(p)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *PlayerVideoInfoClass) {}, p) + return parent } + // PlayerVideoOverlayVideoRendererClass wraps GstPlayerVideoOverlayVideoRendererClass +// +// PlayerVideoOverlayVideoRendererClass is the type struct for [PlayerVideoOverlayVideoRenderer] type PlayerVideoOverlayVideoRendererClass struct { *playerVideoOverlayVideoRendererClass } @@ -4131,31 +4120,6 @@ func UnsafePlayerVideoOverlayVideoRendererClassFromGlibBorrow(p unsafe.Pointer) return &PlayerVideoOverlayVideoRendererClass{&playerVideoOverlayVideoRendererClass{(*C.GstPlayerVideoOverlayVideoRendererClass)(p)}} } -// UnsafePlayerVideoOverlayVideoRendererClassFromGlibNone is used to convert raw C.GstPlayerVideoOverlayVideoRendererClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafePlayerVideoOverlayVideoRendererClassFromGlibNone(p unsafe.Pointer) *PlayerVideoOverlayVideoRendererClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafePlayerVideoOverlayVideoRendererClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.playerVideoOverlayVideoRendererClass, - func (intern *playerVideoOverlayVideoRendererClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafePlayerVideoOverlayVideoRendererClassFromGlibFull is used to convert raw C.GstPlayerVideoOverlayVideoRendererClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafePlayerVideoOverlayVideoRendererClassFromGlibFull(p unsafe.Pointer) *PlayerVideoOverlayVideoRendererClass { - wrapped := UnsafePlayerVideoOverlayVideoRendererClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.playerVideoOverlayVideoRendererClass, - func (intern *playerVideoOverlayVideoRendererClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafePlayerVideoOverlayVideoRendererClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [PlayerVideoOverlayVideoRendererClass] is expected to work anymore. @@ -4168,14 +4132,15 @@ func UnsafePlayerVideoOverlayVideoRendererClassToGlibNone(p *PlayerVideoOverlayV return unsafe.Pointer(p.native) } -// UnsafePlayerVideoOverlayVideoRendererClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafePlayerVideoOverlayVideoRendererClassToGlibFull(p *PlayerVideoOverlayVideoRendererClass) unsafe.Pointer { - runtime.SetFinalizer(p.playerVideoOverlayVideoRendererClass, nil) - _p := unsafe.Pointer(p.native) - p.native = nil // PlayerVideoOverlayVideoRendererClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (p *PlayerVideoOverlayVideoRendererClass) ParentClass() *gobject.ObjectClass { + parent := gobject.UnsafeObjectClassFromGlibBorrow(UnsafePlayerVideoOverlayVideoRendererClassToGlibNone(p)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *PlayerVideoOverlayVideoRendererClass) {}, p) + return parent } + // PlayerVideoRendererInterface wraps GstPlayerVideoRendererInterface type PlayerVideoRendererInterface struct { *playerVideoRendererInterface @@ -4191,7 +4156,7 @@ func UnsafePlayerVideoRendererInterfaceFromGlibBorrow(p unsafe.Pointer) *PlayerV return &PlayerVideoRendererInterface{&playerVideoRendererInterface{(*C.GstPlayerVideoRendererInterface)(p)}} } -// UnsafePlayerVideoRendererInterfaceFromGlibNone is used to convert raw C.GstPlayerVideoRendererInterface pointers to go while taking a reference. This is used by the bindings internally. +// UnsafePlayerVideoRendererInterfaceFromGlibNone is used to convert raw C.GstPlayerVideoRendererInterface pointers to go without transferring ownership. This is used by the bindings internally. func UnsafePlayerVideoRendererInterfaceFromGlibNone(p unsafe.Pointer) *PlayerVideoRendererInterface { // FIXME: this has no ref function, what should we do here? wrapped := UnsafePlayerVideoRendererInterfaceFromGlibBorrow(p) @@ -4204,7 +4169,7 @@ func UnsafePlayerVideoRendererInterfaceFromGlibNone(p unsafe.Pointer) *PlayerVid return wrapped } -// UnsafePlayerVideoRendererInterfaceFromGlibFull is used to convert raw C.GstPlayerVideoRendererInterface pointers to go while taking a reference. This is used by the bindings internally. +// UnsafePlayerVideoRendererInterfaceFromGlibFull is used to convert raw C.GstPlayerVideoRendererInterface pointers to go while taking ownership. This is used by the bindings internally. func UnsafePlayerVideoRendererInterfaceFromGlibFull(p unsafe.Pointer) *PlayerVideoRendererInterface { wrapped := UnsafePlayerVideoRendererInterfaceFromGlibBorrow(p) runtime.SetFinalizer( @@ -4236,6 +4201,7 @@ func UnsafePlayerVideoRendererInterfaceToGlibFull(p *PlayerVideoRendererInterfac p.native = nil // PlayerVideoRendererInterface is invalid from here on return _p } + // PlayerVisualization wraps GstPlayerVisualization // // A #GstPlayerVisualization descriptor. @@ -4265,7 +4231,7 @@ func UnsafePlayerVisualizationFromGlibBorrow(p unsafe.Pointer) *PlayerVisualizat return &PlayerVisualization{&playerVisualization{(*C.GstPlayerVisualization)(p)}} } -// UnsafePlayerVisualizationFromGlibNone is used to convert raw C.GstPlayerVisualization pointers to go while taking a reference. This is used by the bindings internally. +// UnsafePlayerVisualizationFromGlibNone is used to convert raw C.GstPlayerVisualization pointers to go without transferring ownership. This is used by the bindings internally. func UnsafePlayerVisualizationFromGlibNone(p unsafe.Pointer) *PlayerVisualization { // FIXME: this has no ref function, what should we do here? wrapped := UnsafePlayerVisualizationFromGlibBorrow(p) @@ -4278,7 +4244,7 @@ func UnsafePlayerVisualizationFromGlibNone(p unsafe.Pointer) *PlayerVisualizatio return wrapped } -// UnsafePlayerVisualizationFromGlibFull is used to convert raw C.GstPlayerVisualization pointers to go while taking a reference. This is used by the bindings internally. +// UnsafePlayerVisualizationFromGlibFull is used to convert raw C.GstPlayerVisualization pointers to go while taking ownership. This is used by the bindings internally. func UnsafePlayerVisualizationFromGlibFull(p unsafe.Pointer) *PlayerVisualization { wrapped := UnsafePlayerVisualizationFromGlibBorrow(p) runtime.SetFinalizer( @@ -4310,7 +4276,9 @@ func UnsafePlayerVisualizationToGlibFull(p *PlayerVisualization) unsafe.Pointer p.native = nil // PlayerVisualization is invalid from here on return _p } + // Copy wraps gst_player_visualization_copy +// // The function returns the following values: // // - goret *PlayerVisualization diff --git a/pkg/gstrtp/gstrtp.gen.go b/pkg/gstrtp/gstrtp.gen.go index 0553c76..a0f56a2 100644 --- a/pkg/gstrtp/gstrtp.gen.go +++ b/pkg/gstrtp/gstrtp.gen.go @@ -17,6 +17,82 @@ import ( // #cgo pkg-config: gstreamer-rtp-1.0 // #cgo CFLAGS: -Wno-deprecated-declarations // #include +// extern gboolean _gotk4_gstrtp1_RTPBaseDepayload_handle_event(GstRTPBaseDepayload*, GstEvent*); +// extern gboolean _gotk4_gstrtp1_RTPBaseDepayload_packet_lost(GstRTPBaseDepayload*, GstEvent*); +// extern GstBuffer* _gotk4_gstrtp1_RTPBaseDepayload_process(GstRTPBaseDepayload*, GstBuffer*); +// extern GstBuffer* _gotk4_gstrtp1_RTPBaseDepayload_process_rtp_packet(GstRTPBaseDepayload*, GstRTPBuffer*); +// extern gboolean _gotk4_gstrtp1_RTPBaseDepayload_set_caps(GstRTPBaseDepayload*, GstCaps*); +// gboolean _gotk4_gstrtp1_RTPBaseDepayload_virtual_handle_event(void* fnptr, GstRTPBaseDepayload* carg0, GstEvent* carg1) { +// return ((gboolean (*) (GstRTPBaseDepayload*, GstEvent*))(fnptr))(carg0, carg1); +// } +// gboolean _gotk4_gstrtp1_RTPBaseDepayload_virtual_packet_lost(void* fnptr, GstRTPBaseDepayload* carg0, GstEvent* carg1) { +// return ((gboolean (*) (GstRTPBaseDepayload*, GstEvent*))(fnptr))(carg0, carg1); +// } +// GstBuffer* _gotk4_gstrtp1_RTPBaseDepayload_virtual_process(void* fnptr, GstRTPBaseDepayload* carg0, GstBuffer* carg1) { +// return ((GstBuffer* (*) (GstRTPBaseDepayload*, GstBuffer*))(fnptr))(carg0, carg1); +// } +// GstBuffer* _gotk4_gstrtp1_RTPBaseDepayload_virtual_process_rtp_packet(void* fnptr, GstRTPBaseDepayload* carg0, GstRTPBuffer* carg1) { +// return ((GstBuffer* (*) (GstRTPBaseDepayload*, GstRTPBuffer*))(fnptr))(carg0, carg1); +// } +// gboolean _gotk4_gstrtp1_RTPBaseDepayload_virtual_set_caps(void* fnptr, GstRTPBaseDepayload* carg0, GstCaps* carg1) { +// return ((gboolean (*) (GstRTPBaseDepayload*, GstCaps*))(fnptr))(carg0, carg1); +// } +// extern GstCaps* _gotk4_gstrtp1_RTPBasePayload_get_caps(GstRTPBasePayload*, GstPad*, GstCaps*); +// extern GstFlowReturn _gotk4_gstrtp1_RTPBasePayload_handle_buffer(GstRTPBasePayload*, GstBuffer*); +// extern gboolean _gotk4_gstrtp1_RTPBasePayload_query(GstRTPBasePayload*, GstPad*, GstQuery*); +// extern gboolean _gotk4_gstrtp1_RTPBasePayload_set_caps(GstRTPBasePayload*, GstCaps*); +// extern gboolean _gotk4_gstrtp1_RTPBasePayload_sink_event(GstRTPBasePayload*, GstEvent*); +// extern gboolean _gotk4_gstrtp1_RTPBasePayload_src_event(GstRTPBasePayload*, GstEvent*); +// GstCaps* _gotk4_gstrtp1_RTPBasePayload_virtual_get_caps(void* fnptr, GstRTPBasePayload* carg0, GstPad* carg1, GstCaps* carg2) { +// return ((GstCaps* (*) (GstRTPBasePayload*, GstPad*, GstCaps*))(fnptr))(carg0, carg1, carg2); +// } +// GstFlowReturn _gotk4_gstrtp1_RTPBasePayload_virtual_handle_buffer(void* fnptr, GstRTPBasePayload* carg0, GstBuffer* carg1) { +// return ((GstFlowReturn (*) (GstRTPBasePayload*, GstBuffer*))(fnptr))(carg0, carg1); +// } +// gboolean _gotk4_gstrtp1_RTPBasePayload_virtual_query(void* fnptr, GstRTPBasePayload* carg0, GstPad* carg1, GstQuery* carg2) { +// return ((gboolean (*) (GstRTPBasePayload*, GstPad*, GstQuery*))(fnptr))(carg0, carg1, carg2); +// } +// gboolean _gotk4_gstrtp1_RTPBasePayload_virtual_set_caps(void* fnptr, GstRTPBasePayload* carg0, GstCaps* carg1) { +// return ((gboolean (*) (GstRTPBasePayload*, GstCaps*))(fnptr))(carg0, carg1); +// } +// gboolean _gotk4_gstrtp1_RTPBasePayload_virtual_sink_event(void* fnptr, GstRTPBasePayload* carg0, GstEvent* carg1) { +// return ((gboolean (*) (GstRTPBasePayload*, GstEvent*))(fnptr))(carg0, carg1); +// } +// gboolean _gotk4_gstrtp1_RTPBasePayload_virtual_src_event(void* fnptr, GstRTPBasePayload* carg0, GstEvent* carg1) { +// return ((gboolean (*) (GstRTPBasePayload*, GstEvent*))(fnptr))(carg0, carg1); +// } +// extern gsize _gotk4_gstrtp1_RTPHeaderExtension_get_max_size(GstRTPHeaderExtension*, GstBuffer*); +// extern GstRTPHeaderExtensionFlags _gotk4_gstrtp1_RTPHeaderExtension_get_supported_flags(GstRTPHeaderExtension*); +// extern gboolean _gotk4_gstrtp1_RTPHeaderExtension_read(GstRTPHeaderExtension*, GstRTPHeaderExtensionFlags, const guint8*, gsize, GstBuffer*); +// extern gboolean _gotk4_gstrtp1_RTPHeaderExtension_set_attributes(GstRTPHeaderExtension*, GstRTPHeaderExtensionDirection, gchar*); +// extern gboolean _gotk4_gstrtp1_RTPHeaderExtension_set_caps_from_attributes(GstRTPHeaderExtension*, GstCaps*); +// extern gboolean _gotk4_gstrtp1_RTPHeaderExtension_set_non_rtp_sink_caps(GstRTPHeaderExtension*, GstCaps*); +// extern gboolean _gotk4_gstrtp1_RTPHeaderExtension_update_non_rtp_src_caps(GstRTPHeaderExtension*, GstCaps*); +// extern gssize _gotk4_gstrtp1_RTPHeaderExtension_write(GstRTPHeaderExtension*, GstBuffer*, GstRTPHeaderExtensionFlags, GstBuffer*, guint8*, gsize); +// gsize _gotk4_gstrtp1_RTPHeaderExtension_virtual_get_max_size(void* fnptr, GstRTPHeaderExtension* carg0, GstBuffer* carg1) { +// return ((gsize (*) (GstRTPHeaderExtension*, GstBuffer*))(fnptr))(carg0, carg1); +// } +// GstRTPHeaderExtensionFlags _gotk4_gstrtp1_RTPHeaderExtension_virtual_get_supported_flags(void* fnptr, GstRTPHeaderExtension* carg0) { +// return ((GstRTPHeaderExtensionFlags (*) (GstRTPHeaderExtension*))(fnptr))(carg0); +// } +// gboolean _gotk4_gstrtp1_RTPHeaderExtension_virtual_read(void* fnptr, GstRTPHeaderExtension* carg0, GstRTPHeaderExtensionFlags carg1, const guint8* carg2, gsize carg3, GstBuffer* carg4) { +// return ((gboolean (*) (GstRTPHeaderExtension*, GstRTPHeaderExtensionFlags, const guint8*, gsize, GstBuffer*))(fnptr))(carg0, carg1, carg2, carg3, carg4); +// } +// gboolean _gotk4_gstrtp1_RTPHeaderExtension_virtual_set_attributes(void* fnptr, GstRTPHeaderExtension* carg0, GstRTPHeaderExtensionDirection carg1, gchar* carg2) { +// return ((gboolean (*) (GstRTPHeaderExtension*, GstRTPHeaderExtensionDirection, gchar*))(fnptr))(carg0, carg1, carg2); +// } +// gboolean _gotk4_gstrtp1_RTPHeaderExtension_virtual_set_caps_from_attributes(void* fnptr, GstRTPHeaderExtension* carg0, GstCaps* carg1) { +// return ((gboolean (*) (GstRTPHeaderExtension*, GstCaps*))(fnptr))(carg0, carg1); +// } +// gboolean _gotk4_gstrtp1_RTPHeaderExtension_virtual_set_non_rtp_sink_caps(void* fnptr, GstRTPHeaderExtension* carg0, GstCaps* carg1) { +// return ((gboolean (*) (GstRTPHeaderExtension*, GstCaps*))(fnptr))(carg0, carg1); +// } +// gboolean _gotk4_gstrtp1_RTPHeaderExtension_virtual_update_non_rtp_src_caps(void* fnptr, GstRTPHeaderExtension* carg0, GstCaps* carg1) { +// return ((gboolean (*) (GstRTPHeaderExtension*, GstCaps*))(fnptr))(carg0, carg1); +// } +// gssize _gotk4_gstrtp1_RTPHeaderExtension_virtual_write(void* fnptr, GstRTPHeaderExtension* carg0, GstBuffer* carg1, GstRTPHeaderExtensionFlags carg2, GstBuffer* carg3, guint8* carg4, gsize carg5) { +// return ((gssize (*) (GstRTPHeaderExtension*, GstBuffer*, GstRTPHeaderExtensionFlags, GstBuffer*, guint8*, gsize))(fnptr))(carg0, carg1, carg2, carg3, carg4, carg5); +// } import "C" // GType values. @@ -1080,6 +1156,7 @@ func RtcpUnixToNtp(unixtime uint64) uint64 { } // RtpGetHeaderExtensionList wraps gst_rtp_get_header_extension_list +// // The function returns the following values: // // - goret []gst.ElementFactory @@ -1107,6 +1184,7 @@ func RtpGetHeaderExtensionList() []gst.ElementFactory { } // RtpSourceMetaApiGetType wraps gst_rtp_source_meta_api_get_type +// // The function returns the following values: // // - goret gobject.Type @@ -1223,6 +1301,7 @@ type RTPBaseDepayload interface { // Must be called with the stream lock held. Flush(bool) // IsAggregateHdrextEnabled wraps gst_rtp_base_depayload_is_aggregate_hdrext_enabled + // // The function returns the following values: // // - goret bool @@ -1230,6 +1309,7 @@ type RTPBaseDepayload interface { // Queries whether header extensions will be aggregated per depayloaded buffers. IsAggregateHdrextEnabled() bool // IsSourceInfoEnabled wraps gst_rtp_base_depayload_is_source_info_enabled + // // The function returns the following values: // // - goret bool @@ -1420,6 +1500,7 @@ func (depayload *RTPBaseDepayloadInstance) Flush(keepCurrent bool) { } // IsAggregateHdrextEnabled wraps gst_rtp_base_depayload_is_aggregate_hdrext_enabled +// // The function returns the following values: // // - goret bool @@ -1444,6 +1525,7 @@ func (depayload *RTPBaseDepayloadInstance) IsAggregateHdrextEnabled() bool { } // IsSourceInfoEnabled wraps gst_rtp_base_depayload_is_source_info_enabled +// // The function returns the following values: // // - goret bool @@ -1581,12 +1663,14 @@ func (depayload *RTPBaseDepayloadInstance) SetSourceInfoEnabled(enable bool) { func (o *RTPBaseDepayloadInstance) EmitAddExtension(arg0 RTPHeaderExtension) { o.Emit("add-extension", arg0) } + // EmitClearExtensions emits the "clear-extensions" signal // // Clear all RTP header extensions used by this depayloader. func (o *RTPBaseDepayloadInstance) EmitClearExtensions() { o.Emit("clear-extensions") } + // ConnectRequestExtension connects the provided callback to the "request-extension" signal // // The returned @ext must be configured with the correct @ext_id and with the @@ -1594,6 +1678,88 @@ func (o *RTPBaseDepayloadInstance) EmitClearExtensions() { func (o *RTPBaseDepayloadInstance) ConnectRequestExtension(fn func(RTPBaseDepayload, uint, string) RTPHeaderExtensionInstance) gobject.SignalHandle { return o.Connect("request-extension", fn) } + +// RTPBaseDepayloadOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type RTPBaseDepayloadOverrides[Instance RTPBaseDepayload] struct { + // gst.ElementOverrides allows you to override virtual methods from the parent class gst.Element + gst.ElementOverrides[Instance] + + // HandleEvent allows you to override the implementation of the virtual method handle_event. + // The function takes the following parameters: + // + // - event *gst.Event + // + // The function returns the following values: + // + // - goret bool + HandleEvent func(Instance, *gst.Event) bool + // PacketLost allows you to override the implementation of the virtual method packet_lost. + // The function takes the following parameters: + // + // - event *gst.Event + // + // The function returns the following values: + // + // - goret bool + PacketLost func(Instance, *gst.Event) bool + // Process allows you to override the implementation of the virtual method process. + // The function takes the following parameters: + // + // - in *gst.Buffer + // + // The function returns the following values: + // + // - goret *gst.Buffer + Process func(Instance, *gst.Buffer) *gst.Buffer + // ProcessRtpPacket allows you to override the implementation of the virtual method process_rtp_packet. + // The function takes the following parameters: + // + // - rtpBuffer *RTPBuffer + // + // The function returns the following values: + // + // - goret *gst.Buffer + ProcessRtpPacket func(Instance, *RTPBuffer) *gst.Buffer + // SetCaps allows you to override the implementation of the virtual method set_caps. + // The function takes the following parameters: + // + // - caps *gst.Caps + // + // The function returns the following values: + // + // - goret bool + SetCaps func(Instance, *gst.Caps) bool +} + +// UnsafeApplyRTPBaseDepayloadOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyRTPBaseDepayloadOverrides[Instance RTPBaseDepayload](gclass unsafe.Pointer, overrides RTPBaseDepayloadOverrides[Instance]) { + gst.UnsafeApplyElementOverrides(gclass, overrides.ElementOverrides) + + pclass := (*C.GstRTPBaseDepayloadClass)(gclass) + + if overrides.HandleEvent != nil { + pclass.handle_event = (*[0]byte)(C._gotk4_gstrtp1_RTPBaseDepayload_handle_event) + } + + if overrides.PacketLost != nil { + pclass.packet_lost = (*[0]byte)(C._gotk4_gstrtp1_RTPBaseDepayload_packet_lost) + } + + if overrides.Process != nil { + pclass.process = (*[0]byte)(C._gotk4_gstrtp1_RTPBaseDepayload_process) + } + + if overrides.ProcessRtpPacket != nil { + pclass.process_rtp_packet = (*[0]byte)(C._gotk4_gstrtp1_RTPBaseDepayload_process_rtp_packet) + } + + if overrides.SetCaps != nil { + pclass.set_caps = (*[0]byte)(C._gotk4_gstrtp1_RTPBaseDepayload_set_caps) + } +} + // RTPBasePayloadInstance is the instance type used by all types extending GstRTPBasePayload. It is used internally by the bindings. Users should use the interface [RTPBasePayload] instead. type RTPBasePayloadInstance struct { _ [0]func() // equal guard @@ -1655,6 +1821,7 @@ type RTPBasePayload interface { // maximum size. IsFilled(uint, gst.ClockTime) bool // IsSourceInfoEnabled wraps gst_rtp_base_payload_is_source_info_enabled + // // The function returns the following values: // // - goret bool @@ -1893,6 +2060,7 @@ func (payload *RTPBasePayloadInstance) IsFilled(size uint, duration gst.ClockTim } // IsSourceInfoEnabled wraps gst_rtp_base_payload_is_source_info_enabled +// // The function returns the following values: // // - goret bool @@ -2083,12 +2251,14 @@ func (payload *RTPBasePayloadInstance) SetSourceInfoEnabled(enable bool) { func (o *RTPBasePayloadInstance) EmitAddExtension(arg0 RTPHeaderExtension) { o.Emit("add-extension", arg0) } + // EmitClearExtensions emits the "clear-extensions" signal // // Clear all RTP header extensions used by this payloader. func (o *RTPBasePayloadInstance) EmitClearExtensions() { o.Emit("clear-extensions") } + // ConnectRequestExtension connects the provided callback to the "request-extension" signal // // The returned @ext must be configured with the correct @ext_id and with the @@ -2096,6 +2266,103 @@ func (o *RTPBasePayloadInstance) EmitClearExtensions() { func (o *RTPBasePayloadInstance) ConnectRequestExtension(fn func(RTPBasePayload, uint, string) RTPHeaderExtensionInstance) gobject.SignalHandle { return o.Connect("request-extension", fn) } + +// RTPBasePayloadOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type RTPBasePayloadOverrides[Instance RTPBasePayload] struct { + // gst.ElementOverrides allows you to override virtual methods from the parent class gst.Element + gst.ElementOverrides[Instance] + + // GetCaps allows you to override the implementation of the virtual method get_caps. + // The function takes the following parameters: + // + // - pad gst.Pad + // - filter *gst.Caps + // + // The function returns the following values: + // + // - goret *gst.Caps + GetCaps func(Instance, gst.Pad, *gst.Caps) *gst.Caps + // HandleBuffer allows you to override the implementation of the virtual method handle_buffer. + // The function takes the following parameters: + // + // - buffer *gst.Buffer + // + // The function returns the following values: + // + // - goret gst.FlowReturn + HandleBuffer func(Instance, *gst.Buffer) gst.FlowReturn + // Query allows you to override the implementation of the virtual method query. + // The function takes the following parameters: + // + // - pad gst.Pad + // - query *gst.Query + // + // The function returns the following values: + // + // - goret bool + Query func(Instance, gst.Pad, *gst.Query) bool + // SetCaps allows you to override the implementation of the virtual method set_caps. + // The function takes the following parameters: + // + // - caps *gst.Caps + // + // The function returns the following values: + // + // - goret bool + SetCaps func(Instance, *gst.Caps) bool + // SinkEvent allows you to override the implementation of the virtual method sink_event. + // The function takes the following parameters: + // + // - event *gst.Event + // + // The function returns the following values: + // + // - goret bool + SinkEvent func(Instance, *gst.Event) bool + // SrcEvent allows you to override the implementation of the virtual method src_event. + // The function takes the following parameters: + // + // - event *gst.Event + // + // The function returns the following values: + // + // - goret bool + SrcEvent func(Instance, *gst.Event) bool +} + +// UnsafeApplyRTPBasePayloadOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyRTPBasePayloadOverrides[Instance RTPBasePayload](gclass unsafe.Pointer, overrides RTPBasePayloadOverrides[Instance]) { + gst.UnsafeApplyElementOverrides(gclass, overrides.ElementOverrides) + + pclass := (*C.GstRTPBasePayloadClass)(gclass) + + if overrides.GetCaps != nil { + pclass.get_caps = (*[0]byte)(C._gotk4_gstrtp1_RTPBasePayload_get_caps) + } + + if overrides.HandleBuffer != nil { + pclass.handle_buffer = (*[0]byte)(C._gotk4_gstrtp1_RTPBasePayload_handle_buffer) + } + + if overrides.Query != nil { + pclass.query = (*[0]byte)(C._gotk4_gstrtp1_RTPBasePayload_query) + } + + if overrides.SetCaps != nil { + pclass.set_caps = (*[0]byte)(C._gotk4_gstrtp1_RTPBasePayload_set_caps) + } + + if overrides.SinkEvent != nil { + pclass.sink_event = (*[0]byte)(C._gotk4_gstrtp1_RTPBasePayload_sink_event) + } + + if overrides.SrcEvent != nil { + pclass.src_event = (*[0]byte)(C._gotk4_gstrtp1_RTPBasePayload_src_event) + } +} + // RTPHeaderExtensionInstance is the instance type used by all types extending GstRTPHeaderExtension. It is used internally by the bindings. Users should use the interface [RTPHeaderExtension] instead. type RTPHeaderExtensionInstance struct { _ [0]func() // equal guard @@ -2112,6 +2379,7 @@ type RTPHeaderExtension interface { upcastToGstRTPHeaderExtension() *RTPHeaderExtensionInstance // GetDirection wraps gst_rtp_header_extension_get_direction + // // The function returns the following values: // // - goret RTPHeaderExtensionDirection @@ -2119,6 +2387,7 @@ type RTPHeaderExtension interface { // Retrieve the direction GetDirection() RTPHeaderExtensionDirection // GetID wraps gst_rtp_header_extension_get_id + // // The function returns the following values: // // - goret uint @@ -2141,16 +2410,19 @@ type RTPHeaderExtension interface { // information given in the input @buffer. GetMaxSize(*gst.Buffer) uint // GetSdpCapsFieldName wraps gst_rtp_header_extension_get_sdp_caps_field_name + // // The function returns the following values: // // - goret string GetSdpCapsFieldName() string // GetSupportedFlags wraps gst_rtp_header_extension_get_supported_flags + // // The function returns the following values: // // - goret RTPHeaderExtensionFlags GetSupportedFlags() RTPHeaderExtensionFlags // GetURI wraps gst_rtp_header_extension_get_uri + // // The function returns the following values: // // - goret string (nullable) @@ -2279,6 +2551,7 @@ type RTPHeaderExtension interface { // @caps must be writable as this function may modify them. UpdateNonRtpSrcCaps(*gst.Caps) bool // WantsUpdateNonRtpSrcCaps wraps gst_rtp_header_extension_wants_update_non_rtp_src_caps + // // The function returns the following values: // // - goret bool @@ -2376,6 +2649,7 @@ func RTPHeaderExtensionCreateFromURI(uri string) RTPHeaderExtension { } // GetDirection wraps gst_rtp_header_extension_get_direction +// // The function returns the following values: // // - goret RTPHeaderExtensionDirection @@ -2398,6 +2672,7 @@ func (ext *RTPHeaderExtensionInstance) GetDirection() RTPHeaderExtensionDirectio } // GetID wraps gst_rtp_header_extension_get_id +// // The function returns the following values: // // - goret uint @@ -2453,6 +2728,7 @@ func (ext *RTPHeaderExtensionInstance) GetMaxSize(inputMeta *gst.Buffer) uint { } // GetSdpCapsFieldName wraps gst_rtp_header_extension_get_sdp_caps_field_name +// // The function returns the following values: // // - goret string @@ -2474,6 +2750,7 @@ func (ext *RTPHeaderExtensionInstance) GetSdpCapsFieldName() string { } // GetSupportedFlags wraps gst_rtp_header_extension_get_supported_flags +// // The function returns the following values: // // - goret RTPHeaderExtensionFlags @@ -2494,6 +2771,7 @@ func (ext *RTPHeaderExtensionInstance) GetSupportedFlags() RTPHeaderExtensionFla } // GetURI wraps gst_rtp_header_extension_get_uri +// // The function returns the following values: // // - goret string (nullable) @@ -2808,6 +3086,7 @@ func (ext *RTPHeaderExtensionInstance) UpdateNonRtpSrcCaps(caps *gst.Caps) bool } // WantsUpdateNonRtpSrcCaps wraps gst_rtp_header_extension_wants_update_non_rtp_src_caps +// // The function returns the following values: // // - goret bool @@ -2882,6 +3161,130 @@ func (ext *RTPHeaderExtensionInstance) Write(inputMeta *gst.Buffer, writeFlags R return goret } +// RTPHeaderExtensionOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type RTPHeaderExtensionOverrides[Instance RTPHeaderExtension] struct { + // gst.ElementOverrides allows you to override virtual methods from the parent class gst.Element + gst.ElementOverrides[Instance] + + // GetMaxSize allows you to override the implementation of the virtual method get_max_size. + // The function takes the following parameters: + // + // - inputMeta *gst.Buffer: a #GstBuffer + // + // The function returns the following values: + // + // - goret uint + GetMaxSize func(Instance, *gst.Buffer) uint + // GetSupportedFlags allows you to override the implementation of the virtual method get_supported_flags. + // The function returns the following values: + // + // - goret RTPHeaderExtensionFlags + GetSupportedFlags func(Instance) RTPHeaderExtensionFlags + // Read allows you to override the implementation of the virtual method read. + // The function takes the following parameters: + // + // - readFlags RTPHeaderExtensionFlags: #GstRTPHeaderExtensionFlags for how the extension should + // be written + // - data []uint8: location to read the rtp header extension from + // - buffer *gst.Buffer: a #GstBuffer to modify if necessary + // + // The function returns the following values: + // + // - goret bool + Read func(Instance, RTPHeaderExtensionFlags, []uint8, *gst.Buffer) bool + // SetAttributes allows you to override the implementation of the virtual method set_attributes. + // The function takes the following parameters: + // + // - direction RTPHeaderExtensionDirection + // - attributes string + // + // The function returns the following values: + // + // - goret bool + SetAttributes func(Instance, RTPHeaderExtensionDirection, string) bool + // SetCapsFromAttributes allows you to override the implementation of the virtual method set_caps_from_attributes. + // The function takes the following parameters: + // + // - caps *gst.Caps: writable #GstCaps to modify + // + // The function returns the following values: + // + // - goret bool + SetCapsFromAttributes func(Instance, *gst.Caps) bool + // SetNonRtpSinkCaps allows you to override the implementation of the virtual method set_non_rtp_sink_caps. + // The function takes the following parameters: + // + // - caps *gst.Caps: sink #GstCaps + // + // The function returns the following values: + // + // - goret bool + SetNonRtpSinkCaps func(Instance, *gst.Caps) bool + // UpdateNonRtpSrcCaps allows you to override the implementation of the virtual method update_non_rtp_src_caps. + // The function takes the following parameters: + // + // - caps *gst.Caps: src #GstCaps to modify + // + // The function returns the following values: + // + // - goret bool + UpdateNonRtpSrcCaps func(Instance, *gst.Caps) bool + // Write allows you to override the implementation of the virtual method write. + // The function takes the following parameters: + // + // - inputMeta *gst.Buffer: the input #GstBuffer to read information from if necessary + // - writeFlags RTPHeaderExtensionFlags: #GstRTPHeaderExtensionFlags for how the extension should + // be written + // - output *gst.Buffer: output RTP #GstBuffer + // - data []uint8: location to write the rtp header extension into + // + // The function returns the following values: + // + // - goret int + Write func(Instance, *gst.Buffer, RTPHeaderExtensionFlags, *gst.Buffer, []uint8) int +} + +// UnsafeApplyRTPHeaderExtensionOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyRTPHeaderExtensionOverrides[Instance RTPHeaderExtension](gclass unsafe.Pointer, overrides RTPHeaderExtensionOverrides[Instance]) { + gst.UnsafeApplyElementOverrides(gclass, overrides.ElementOverrides) + + pclass := (*C.GstRTPHeaderExtensionClass)(gclass) + + if overrides.GetMaxSize != nil { + pclass.get_max_size = (*[0]byte)(C._gotk4_gstrtp1_RTPHeaderExtension_get_max_size) + } + + if overrides.GetSupportedFlags != nil { + pclass.get_supported_flags = (*[0]byte)(C._gotk4_gstrtp1_RTPHeaderExtension_get_supported_flags) + } + + if overrides.Read != nil { + pclass.read = (*[0]byte)(C._gotk4_gstrtp1_RTPHeaderExtension_read) + } + + if overrides.SetAttributes != nil { + pclass.set_attributes = (*[0]byte)(C._gotk4_gstrtp1_RTPHeaderExtension_set_attributes) + } + + if overrides.SetCapsFromAttributes != nil { + pclass.set_caps_from_attributes = (*[0]byte)(C._gotk4_gstrtp1_RTPHeaderExtension_set_caps_from_attributes) + } + + if overrides.SetNonRtpSinkCaps != nil { + pclass.set_non_rtp_sink_caps = (*[0]byte)(C._gotk4_gstrtp1_RTPHeaderExtension_set_non_rtp_sink_caps) + } + + if overrides.UpdateNonRtpSrcCaps != nil { + pclass.update_non_rtp_src_caps = (*[0]byte)(C._gotk4_gstrtp1_RTPHeaderExtension_update_non_rtp_src_caps) + } + + if overrides.Write != nil { + pclass.write = (*[0]byte)(C._gotk4_gstrtp1_RTPHeaderExtension_write) + } +} + // RTPBaseAudioPayloadInstance is the instance type used by all types extending GstRTPBaseAudioPayload. It is used internally by the bindings. Users should use the interface [RTPBaseAudioPayload] instead. type RTPBaseAudioPayloadInstance struct { _ [0]func() // equal guard @@ -2943,6 +3346,7 @@ type RTPBaseAudioPayload interface { // -1, the timestamp will be calculated automatically. Flush(uint, gst.ClockTime) gst.FlowReturn // GetAdapter wraps gst_rtp_base_audio_payload_get_adapter + // // The function returns the following values: // // - goret gstbase.Adapter @@ -3083,6 +3487,7 @@ func (baseaudiopayload *RTPBaseAudioPayloadInstance) Flush(payloadLen uint, time } // GetAdapter wraps gst_rtp_base_audio_payload_get_adapter +// // The function returns the following values: // // - goret gstbase.Adapter @@ -3231,6 +3636,20 @@ func (rtpbaseaudiopayload *RTPBaseAudioPayloadInstance) SetSamplebitsOptions(sam runtime.KeepAlive(sampleSize) } +// RTPBaseAudioPayloadOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type RTPBaseAudioPayloadOverrides[Instance RTPBaseAudioPayload] struct { + // RTPBasePayloadOverrides allows you to override virtual methods from the parent class RTPBasePayload + RTPBasePayloadOverrides[Instance] + +} + +// UnsafeApplyRTPBaseAudioPayloadOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyRTPBaseAudioPayloadOverrides[Instance RTPBaseAudioPayload](gclass unsafe.Pointer, overrides RTPBaseAudioPayloadOverrides[Instance]) { + UnsafeApplyRTPBasePayloadOverrides(gclass, overrides.RTPBasePayloadOverrides) +} + // RTCPBuffer wraps GstRTCPBuffer // // Note: The API in this module is not yet declared stable. @@ -3257,7 +3676,7 @@ func UnsafeRTCPBufferFromGlibBorrow(p unsafe.Pointer) *RTCPBuffer { return &RTCPBuffer{&rtcpBuffer{(*C.GstRTCPBuffer)(p)}} } -// UnsafeRTCPBufferFromGlibNone is used to convert raw C.GstRTCPBuffer pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeRTCPBufferFromGlibNone is used to convert raw C.GstRTCPBuffer pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeRTCPBufferFromGlibNone(p unsafe.Pointer) *RTCPBuffer { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeRTCPBufferFromGlibBorrow(p) @@ -3270,7 +3689,7 @@ func UnsafeRTCPBufferFromGlibNone(p unsafe.Pointer) *RTCPBuffer { return wrapped } -// UnsafeRTCPBufferFromGlibFull is used to convert raw C.GstRTCPBuffer pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeRTCPBufferFromGlibFull is used to convert raw C.GstRTCPBuffer pointers to go while taking ownership. This is used by the bindings internally. func UnsafeRTCPBufferFromGlibFull(p unsafe.Pointer) *RTCPBuffer { wrapped := UnsafeRTCPBufferFromGlibBorrow(p) runtime.SetFinalizer( @@ -3302,6 +3721,7 @@ func UnsafeRTCPBufferToGlibFull(r *RTCPBuffer) unsafe.Pointer { r.native = nil // RTCPBuffer is invalid from here on return _p } + // RTCPBufferMap wraps gst_rtcp_buffer_map // // The function takes the following parameters: @@ -3574,6 +3994,7 @@ func (rtcp *RTCPBuffer) GetFirstPacket(packet *RTCPPacket) bool { } // GetPacketCount wraps gst_rtcp_buffer_get_packet_count +// // The function returns the following values: // // - goret uint @@ -3596,6 +4017,7 @@ func (rtcp *RTCPBuffer) GetPacketCount() uint { } // Unmap wraps gst_rtcp_buffer_unmap +// // The function returns the following values: // // - goret bool @@ -3641,7 +4063,7 @@ func UnsafeRTCPPacketFromGlibBorrow(p unsafe.Pointer) *RTCPPacket { return &RTCPPacket{&rtcpPacket{(*C.GstRTCPPacket)(p)}} } -// UnsafeRTCPPacketFromGlibNone is used to convert raw C.GstRTCPPacket pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeRTCPPacketFromGlibNone is used to convert raw C.GstRTCPPacket pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeRTCPPacketFromGlibNone(p unsafe.Pointer) *RTCPPacket { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeRTCPPacketFromGlibBorrow(p) @@ -3654,7 +4076,7 @@ func UnsafeRTCPPacketFromGlibNone(p unsafe.Pointer) *RTCPPacket { return wrapped } -// UnsafeRTCPPacketFromGlibFull is used to convert raw C.GstRTCPPacket pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeRTCPPacketFromGlibFull is used to convert raw C.GstRTCPPacket pointers to go while taking ownership. This is used by the bindings internally. func UnsafeRTCPPacketFromGlibFull(p unsafe.Pointer) *RTCPPacket { wrapped := UnsafeRTCPPacketFromGlibBorrow(p) runtime.SetFinalizer( @@ -3686,6 +4108,7 @@ func UnsafeRTCPPacketToGlibFull(r *RTCPPacket) unsafe.Pointer { r.native = nil // RTCPPacket is invalid from here on return _p } + // AddProfileSpecificExt wraps gst_rtcp_packet_add_profile_specific_ext // // The function takes the following parameters: @@ -3781,6 +4204,7 @@ func (packet *RTCPPacket) AddRb(ssrc uint32, fractionlost uint8, packetslost int } // AppGetData wraps gst_rtcp_packet_app_get_data +// // The function returns the following values: // // - goret *uint8 @@ -3805,6 +4229,7 @@ func (packet *RTCPPacket) AppGetData() *uint8 { } // AppGetDataLength wraps gst_rtcp_packet_app_get_data_length +// // The function returns the following values: // // - goret uint16 @@ -3828,6 +4253,7 @@ func (packet *RTCPPacket) AppGetDataLength() uint16 { } // AppGetName wraps gst_rtcp_packet_app_get_name +// // The function returns the following values: // // - goret string @@ -3850,6 +4276,7 @@ func (packet *RTCPPacket) AppGetName() string { } // AppGetSsrc wraps gst_rtcp_packet_app_get_ssrc +// // The function returns the following values: // // - goret uint32 @@ -3872,6 +4299,7 @@ func (packet *RTCPPacket) AppGetSsrc() uint32 { } // AppGetSubtype wraps gst_rtcp_packet_app_get_subtype +// // The function returns the following values: // // - goret uint8 @@ -4083,6 +4511,7 @@ func (packet *RTCPPacket) ByeGetNthSsrc(nth uint) uint32 { } // ByeGetReason wraps gst_rtcp_packet_bye_get_reason +// // The function returns the following values: // // - goret string (nullable) @@ -4108,6 +4537,7 @@ func (packet *RTCPPacket) ByeGetReason() string { } // ByeGetReasonLen wraps gst_rtcp_packet_bye_get_reason_len +// // The function returns the following values: // // - goret uint8 @@ -4130,6 +4560,7 @@ func (packet *RTCPPacket) ByeGetReasonLen() uint8 { } // ByeGetSsrcCount wraps gst_rtcp_packet_bye_get_ssrc_count +// // The function returns the following values: // // - goret uint @@ -4185,6 +4616,7 @@ func (packet *RTCPPacket) ByeSetReason(reason string) bool { } // FbGetFci wraps gst_rtcp_packet_fb_get_fci +// // The function returns the following values: // // - goret *uint8 @@ -4209,6 +4641,7 @@ func (packet *RTCPPacket) FbGetFci() *uint8 { } // FbGetFciLength wraps gst_rtcp_packet_fb_get_fci_length +// // The function returns the following values: // // - goret uint16 @@ -4232,6 +4665,7 @@ func (packet *RTCPPacket) FbGetFciLength() uint16 { } // FbGetMediaSsrc wraps gst_rtcp_packet_fb_get_media_ssrc +// // The function returns the following values: // // - goret uint32 @@ -4254,6 +4688,7 @@ func (packet *RTCPPacket) FbGetMediaSsrc() uint32 { } // FbGetSenderSsrc wraps gst_rtcp_packet_fb_get_sender_ssrc +// // The function returns the following values: // // - goret uint32 @@ -4276,6 +4711,7 @@ func (packet *RTCPPacket) FbGetSenderSsrc() uint32 { } // FbGetType wraps gst_rtcp_packet_fb_get_type +// // The function returns the following values: // // - goret RTCPFBType @@ -4388,6 +4824,7 @@ func (packet *RTCPPacket) FbSetType(typ RTCPFBType) { } // GetCount wraps gst_rtcp_packet_get_count +// // The function returns the following values: // // - goret uint8 @@ -4410,6 +4847,7 @@ func (packet *RTCPPacket) GetCount() uint8 { } // GetLength wraps gst_rtcp_packet_get_length +// // The function returns the following values: // // - goret uint16 @@ -4433,6 +4871,7 @@ func (packet *RTCPPacket) GetLength() uint16 { } // GetPadding wraps gst_rtcp_packet_get_padding +// // The function returns the following values: // // - goret bool @@ -4457,6 +4896,7 @@ func (packet *RTCPPacket) GetPadding() bool { } // GetProfileSpecificExtLength wraps gst_rtcp_packet_get_profile_specific_ext_length +// // The function returns the following values: // // - goret uint16 @@ -4532,6 +4972,7 @@ func (packet *RTCPPacket) GetRb(nth uint) (uint32, uint8, int32, uint32, uint32, } // GetRbCount wraps gst_rtcp_packet_get_rb_count +// // The function returns the following values: // // - goret uint @@ -4554,6 +4995,7 @@ func (packet *RTCPPacket) GetRbCount() uint { } // GetType wraps gst_rtcp_packet_get_type +// // The function returns the following values: // // - goret RTCPType @@ -4576,6 +5018,7 @@ func (packet *RTCPPacket) GetType() RTCPType { } // MoveToNext wraps gst_rtcp_packet_move_to_next +// // The function returns the following values: // // - goret bool @@ -4601,6 +5044,7 @@ func (packet *RTCPPacket) MoveToNext() bool { } // Remove wraps gst_rtcp_packet_remove +// // The function returns the following values: // // - goret bool @@ -4625,6 +5069,7 @@ func (packet *RTCPPacket) Remove() bool { } // RrGetSsrc wraps gst_rtcp_packet_rr_get_ssrc +// // The function returns the following values: // // - goret uint32 @@ -4738,6 +5183,7 @@ func (packet *RTCPPacket) SdesAddItem(ssrc uint32) bool { } // SdesFirstEntry wraps gst_rtcp_packet_sdes_first_entry +// // The function returns the following values: // // - goret bool @@ -4762,6 +5208,7 @@ func (packet *RTCPPacket) SdesFirstEntry() bool { } // SdesFirstItem wraps gst_rtcp_packet_sdes_first_item +// // The function returns the following values: // // - goret bool @@ -4786,6 +5233,7 @@ func (packet *RTCPPacket) SdesFirstItem() bool { } // SdesGetItemCount wraps gst_rtcp_packet_sdes_get_item_count +// // The function returns the following values: // // - goret uint @@ -4808,6 +5256,7 @@ func (packet *RTCPPacket) SdesGetItemCount() uint { } // SdesGetSsrc wraps gst_rtcp_packet_sdes_get_ssrc +// // The function returns the following values: // // - goret uint32 @@ -4830,6 +5279,7 @@ func (packet *RTCPPacket) SdesGetSsrc() uint32 { } // SdesNextEntry wraps gst_rtcp_packet_sdes_next_entry +// // The function returns the following values: // // - goret bool @@ -4854,6 +5304,7 @@ func (packet *RTCPPacket) SdesNextEntry() bool { } // SdesNextItem wraps gst_rtcp_packet_sdes_next_item +// // The function returns the following values: // // - goret bool @@ -4927,6 +5378,7 @@ func (packet *RTCPPacket) SetRb(nth uint, ssrc uint32, fractionlost uint8, packe } // SrGetSenderInfo wraps gst_rtcp_packet_sr_get_sender_info +// // The function returns the following values: // // - ssrc uint32: result SSRC @@ -5000,6 +5452,7 @@ func (packet *RTCPPacket) SrSetSenderInfo(ssrc uint32, ntptime uint64, rtptime u } // XRFirstRb wraps gst_rtcp_packet_xr_first_rb +// // The function returns the following values: // // - goret bool @@ -5024,6 +5477,7 @@ func (packet *RTCPPacket) XRFirstRb() bool { } // XRGetBlockLength wraps gst_rtcp_packet_xr_get_block_length +// // The function returns the following values: // // - goret uint16 @@ -5044,6 +5498,7 @@ func (packet *RTCPPacket) XRGetBlockLength() uint16 { } // XRGetBlockType wraps gst_rtcp_packet_xr_get_block_type +// // The function returns the following values: // // - goret RTCPXRType @@ -5334,6 +5789,7 @@ func (packet *RTCPPacket) XRGetRrt(timestamp *uint64) bool { } // XRGetSsrc wraps gst_rtcp_packet_xr_get_ssrc +// // The function returns the following values: // // - goret uint32 @@ -5894,6 +6350,7 @@ func (packet *RTCPPacket) XRGetVoipSignalMetrics(signalLevel *uint8, noiseLevel } // XRNextRb wraps gst_rtcp_packet_xr_next_rb +// // The function returns the following values: // // - goret bool @@ -5920,6 +6377,8 @@ func (packet *RTCPPacket) XRNextRb() bool { // RTPBaseAudioPayloadClass wraps GstRTPBaseAudioPayloadClass // // Base class for audio RTP payloader. +// +// RTPBaseAudioPayloadClass is the type struct for [RTPBaseAudioPayload] type RTPBaseAudioPayloadClass struct { *rtpBaseAudioPayloadClass } @@ -5934,31 +6393,6 @@ func UnsafeRTPBaseAudioPayloadClassFromGlibBorrow(p unsafe.Pointer) *RTPBaseAudi return &RTPBaseAudioPayloadClass{&rtpBaseAudioPayloadClass{(*C.GstRTPBaseAudioPayloadClass)(p)}} } -// UnsafeRTPBaseAudioPayloadClassFromGlibNone is used to convert raw C.GstRTPBaseAudioPayloadClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeRTPBaseAudioPayloadClassFromGlibNone(p unsafe.Pointer) *RTPBaseAudioPayloadClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeRTPBaseAudioPayloadClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.rtpBaseAudioPayloadClass, - func (intern *rtpBaseAudioPayloadClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeRTPBaseAudioPayloadClassFromGlibFull is used to convert raw C.GstRTPBaseAudioPayloadClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeRTPBaseAudioPayloadClassFromGlibFull(p unsafe.Pointer) *RTPBaseAudioPayloadClass { - wrapped := UnsafeRTPBaseAudioPayloadClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.rtpBaseAudioPayloadClass, - func (intern *rtpBaseAudioPayloadClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeRTPBaseAudioPayloadClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [RTPBaseAudioPayloadClass] is expected to work anymore. @@ -5971,17 +6405,20 @@ func UnsafeRTPBaseAudioPayloadClassToGlibNone(r *RTPBaseAudioPayloadClass) unsaf return unsafe.Pointer(r.native) } -// UnsafeRTPBaseAudioPayloadClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeRTPBaseAudioPayloadClassToGlibFull(r *RTPBaseAudioPayloadClass) unsafe.Pointer { - runtime.SetFinalizer(r.rtpBaseAudioPayloadClass, nil) - _p := unsafe.Pointer(r.native) - r.native = nil // RTPBaseAudioPayloadClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (r *RTPBaseAudioPayloadClass) ParentClass() *RTPBasePayloadClass { + parent := UnsafeRTPBasePayloadClassFromGlibBorrow(UnsafeRTPBaseAudioPayloadClassToGlibNone(r)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *RTPBaseAudioPayloadClass) {}, r) + return parent } + // RTPBaseDepayloadClass wraps GstRTPBaseDepayloadClass // // Base class for RTP depayloaders. +// +// RTPBaseDepayloadClass is the type struct for [RTPBaseDepayload] type RTPBaseDepayloadClass struct { *rtpBaseDepayloadClass } @@ -5996,31 +6433,6 @@ func UnsafeRTPBaseDepayloadClassFromGlibBorrow(p unsafe.Pointer) *RTPBaseDepaylo return &RTPBaseDepayloadClass{&rtpBaseDepayloadClass{(*C.GstRTPBaseDepayloadClass)(p)}} } -// UnsafeRTPBaseDepayloadClassFromGlibNone is used to convert raw C.GstRTPBaseDepayloadClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeRTPBaseDepayloadClassFromGlibNone(p unsafe.Pointer) *RTPBaseDepayloadClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeRTPBaseDepayloadClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.rtpBaseDepayloadClass, - func (intern *rtpBaseDepayloadClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeRTPBaseDepayloadClassFromGlibFull is used to convert raw C.GstRTPBaseDepayloadClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeRTPBaseDepayloadClassFromGlibFull(p unsafe.Pointer) *RTPBaseDepayloadClass { - wrapped := UnsafeRTPBaseDepayloadClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.rtpBaseDepayloadClass, - func (intern *rtpBaseDepayloadClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeRTPBaseDepayloadClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [RTPBaseDepayloadClass] is expected to work anymore. @@ -6033,17 +6445,20 @@ func UnsafeRTPBaseDepayloadClassToGlibNone(r *RTPBaseDepayloadClass) unsafe.Poin return unsafe.Pointer(r.native) } -// UnsafeRTPBaseDepayloadClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeRTPBaseDepayloadClassToGlibFull(r *RTPBaseDepayloadClass) unsafe.Pointer { - runtime.SetFinalizer(r.rtpBaseDepayloadClass, nil) - _p := unsafe.Pointer(r.native) - r.native = nil // RTPBaseDepayloadClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (r *RTPBaseDepayloadClass) ParentClass() *gst.ElementClass { + parent := gst.UnsafeElementClassFromGlibBorrow(UnsafeRTPBaseDepayloadClassToGlibNone(r)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *RTPBaseDepayloadClass) {}, r) + return parent } + // RTPBasePayloadClass wraps GstRTPBasePayloadClass // // Base class for audio RTP payloader. +// +// RTPBasePayloadClass is the type struct for [RTPBasePayload] type RTPBasePayloadClass struct { *rtpBasePayloadClass } @@ -6058,31 +6473,6 @@ func UnsafeRTPBasePayloadClassFromGlibBorrow(p unsafe.Pointer) *RTPBasePayloadCl return &RTPBasePayloadClass{&rtpBasePayloadClass{(*C.GstRTPBasePayloadClass)(p)}} } -// UnsafeRTPBasePayloadClassFromGlibNone is used to convert raw C.GstRTPBasePayloadClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeRTPBasePayloadClassFromGlibNone(p unsafe.Pointer) *RTPBasePayloadClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeRTPBasePayloadClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.rtpBasePayloadClass, - func (intern *rtpBasePayloadClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeRTPBasePayloadClassFromGlibFull is used to convert raw C.GstRTPBasePayloadClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeRTPBasePayloadClassFromGlibFull(p unsafe.Pointer) *RTPBasePayloadClass { - wrapped := UnsafeRTPBasePayloadClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.rtpBasePayloadClass, - func (intern *rtpBasePayloadClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeRTPBasePayloadClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [RTPBasePayloadClass] is expected to work anymore. @@ -6095,14 +6485,15 @@ func UnsafeRTPBasePayloadClassToGlibNone(r *RTPBasePayloadClass) unsafe.Pointer return unsafe.Pointer(r.native) } -// UnsafeRTPBasePayloadClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeRTPBasePayloadClassToGlibFull(r *RTPBasePayloadClass) unsafe.Pointer { - runtime.SetFinalizer(r.rtpBasePayloadClass, nil) - _p := unsafe.Pointer(r.native) - r.native = nil // RTPBasePayloadClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (r *RTPBasePayloadClass) ParentClass() *gst.ElementClass { + parent := gst.UnsafeElementClassFromGlibBorrow(UnsafeRTPBasePayloadClassToGlibNone(r)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *RTPBasePayloadClass) {}, r) + return parent } + // RTPBuffer wraps GstRTPBuffer // // The GstRTPBuffer helper functions makes it easy to parse and create regular @@ -6122,7 +6513,7 @@ func UnsafeRTPBufferFromGlibBorrow(p unsafe.Pointer) *RTPBuffer { return &RTPBuffer{&rtpBuffer{(*C.GstRTPBuffer)(p)}} } -// UnsafeRTPBufferFromGlibNone is used to convert raw C.GstRTPBuffer pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeRTPBufferFromGlibNone is used to convert raw C.GstRTPBuffer pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeRTPBufferFromGlibNone(p unsafe.Pointer) *RTPBuffer { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeRTPBufferFromGlibBorrow(p) @@ -6135,7 +6526,7 @@ func UnsafeRTPBufferFromGlibNone(p unsafe.Pointer) *RTPBuffer { return wrapped } -// UnsafeRTPBufferFromGlibFull is used to convert raw C.GstRTPBuffer pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeRTPBufferFromGlibFull is used to convert raw C.GstRTPBuffer pointers to go while taking ownership. This is used by the bindings internally. func UnsafeRTPBufferFromGlibFull(p unsafe.Pointer) *RTPBuffer { wrapped := UnsafeRTPBufferFromGlibBorrow(p) runtime.SetFinalizer( @@ -6167,6 +6558,7 @@ func UnsafeRTPBufferToGlibFull(r *RTPBuffer) unsafe.Pointer { r.native = nil // RTPBuffer is invalid from here on return _p } + // RTPBufferAllocateData wraps gst_rtp_buffer_allocate_data // // The function takes the following parameters: @@ -6503,6 +6895,7 @@ func (rtp *RTPBuffer) GetCsrc(idx uint8) uint32 { } // GetCsrcCount wraps gst_rtp_buffer_get_csrc_count +// // The function returns the following values: // // - goret uint8 @@ -6525,6 +6918,7 @@ func (rtp *RTPBuffer) GetCsrcCount() uint8 { } // GetExtension wraps gst_rtp_buffer_get_extension +// // The function returns the following values: // // - goret bool @@ -6549,6 +6943,7 @@ func (rtp *RTPBuffer) GetExtension() bool { } // GetExtensionBytes wraps gst_rtp_buffer_get_extension_bytes +// // The function returns the following values: // // - bits uint16: location for header bits @@ -6584,6 +6979,7 @@ func (rtp *RTPBuffer) GetExtensionBytes() (uint16, *glib.Bytes) { } // GetHeaderLen wraps gst_rtp_buffer_get_header_len +// // The function returns the following values: // // - goret uint @@ -6607,6 +7003,7 @@ func (rtp *RTPBuffer) GetHeaderLen() uint { } // GetMarker wraps gst_rtp_buffer_get_marker +// // The function returns the following values: // // - goret bool @@ -6631,6 +7028,7 @@ func (rtp *RTPBuffer) GetMarker() bool { } // GetPacketLen wraps gst_rtp_buffer_get_packet_len +// // The function returns the following values: // // - goret uint @@ -6653,6 +7051,7 @@ func (rtp *RTPBuffer) GetPacketLen() uint { } // GetPadding wraps gst_rtp_buffer_get_padding +// // The function returns the following values: // // - goret bool @@ -6677,6 +7076,7 @@ func (rtp *RTPBuffer) GetPadding() bool { } // GetPayloadBuffer wraps gst_rtp_buffer_get_payload_buffer +// // The function returns the following values: // // - goret *gst.Buffer @@ -6701,6 +7101,7 @@ func (rtp *RTPBuffer) GetPayloadBuffer() *gst.Buffer { } // GetPayloadBytes wraps gst_rtp_buffer_get_payload_bytes +// // The function returns the following values: // // - goret *glib.Bytes (nullable) @@ -6727,6 +7128,7 @@ func (rtp *RTPBuffer) GetPayloadBytes() *glib.Bytes { } // GetPayloadLen wraps gst_rtp_buffer_get_payload_len +// // The function returns the following values: // // - goret uint @@ -6785,6 +7187,7 @@ func (rtp *RTPBuffer) GetPayloadSubbuffer(offset uint, len uint) *gst.Buffer { } // GetPayloadType wraps gst_rtp_buffer_get_payload_type +// // The function returns the following values: // // - goret uint8 @@ -6807,6 +7210,7 @@ func (rtp *RTPBuffer) GetPayloadType() uint8 { } // GetSeq wraps gst_rtp_buffer_get_seq +// // The function returns the following values: // // - goret uint16 @@ -6829,6 +7233,7 @@ func (rtp *RTPBuffer) GetSeq() uint16 { } // GetSsrc wraps gst_rtp_buffer_get_ssrc +// // The function returns the following values: // // - goret uint32 @@ -6851,6 +7256,7 @@ func (rtp *RTPBuffer) GetSsrc() uint32 { } // GetTimestamp wraps gst_rtp_buffer_get_timestamp +// // The function returns the following values: // // - goret uint32 @@ -6873,6 +7279,7 @@ func (rtp *RTPBuffer) GetTimestamp() uint32 { } // GetVersion wraps gst_rtp_buffer_get_version +// // The function returns the following values: // // - goret uint8 @@ -7190,6 +7597,8 @@ func (rtp *RTPBuffer) Unmap() { // RTPHeaderExtensionClass wraps GstRTPHeaderExtensionClass // // Base class for RTP Header extensions. +// +// RTPHeaderExtensionClass is the type struct for [RTPHeaderExtension] type RTPHeaderExtensionClass struct { *rtpHeaderExtensionClass } @@ -7204,31 +7613,6 @@ func UnsafeRTPHeaderExtensionClassFromGlibBorrow(p unsafe.Pointer) *RTPHeaderExt return &RTPHeaderExtensionClass{&rtpHeaderExtensionClass{(*C.GstRTPHeaderExtensionClass)(p)}} } -// UnsafeRTPHeaderExtensionClassFromGlibNone is used to convert raw C.GstRTPHeaderExtensionClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeRTPHeaderExtensionClassFromGlibNone(p unsafe.Pointer) *RTPHeaderExtensionClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeRTPHeaderExtensionClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.rtpHeaderExtensionClass, - func (intern *rtpHeaderExtensionClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeRTPHeaderExtensionClassFromGlibFull is used to convert raw C.GstRTPHeaderExtensionClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeRTPHeaderExtensionClassFromGlibFull(p unsafe.Pointer) *RTPHeaderExtensionClass { - wrapped := UnsafeRTPHeaderExtensionClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.rtpHeaderExtensionClass, - func (intern *rtpHeaderExtensionClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeRTPHeaderExtensionClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [RTPHeaderExtensionClass] is expected to work anymore. @@ -7241,14 +7625,15 @@ func UnsafeRTPHeaderExtensionClassToGlibNone(r *RTPHeaderExtensionClass) unsafe. return unsafe.Pointer(r.native) } -// UnsafeRTPHeaderExtensionClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeRTPHeaderExtensionClassToGlibFull(r *RTPHeaderExtensionClass) unsafe.Pointer { - runtime.SetFinalizer(r.rtpHeaderExtensionClass, nil) - _p := unsafe.Pointer(r.native) - r.native = nil // RTPHeaderExtensionClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (r *RTPHeaderExtensionClass) ParentClass() *gst.ElementClass { + parent := gst.UnsafeElementClassFromGlibBorrow(UnsafeRTPHeaderExtensionClassToGlibNone(r)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *RTPHeaderExtensionClass) {}, r) + return parent } + // SetURI wraps gst_rtp_header_extension_class_set_uri // // The function takes the following parameters: @@ -7286,7 +7671,7 @@ func UnsafeRTPPayloadInfoFromGlibBorrow(p unsafe.Pointer) *RTPPayloadInfo { return &RTPPayloadInfo{&rtpPayloadInfo{(*C.GstRTPPayloadInfo)(p)}} } -// UnsafeRTPPayloadInfoFromGlibNone is used to convert raw C.GstRTPPayloadInfo pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeRTPPayloadInfoFromGlibNone is used to convert raw C.GstRTPPayloadInfo pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeRTPPayloadInfoFromGlibNone(p unsafe.Pointer) *RTPPayloadInfo { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeRTPPayloadInfoFromGlibBorrow(p) @@ -7299,7 +7684,7 @@ func UnsafeRTPPayloadInfoFromGlibNone(p unsafe.Pointer) *RTPPayloadInfo { return wrapped } -// UnsafeRTPPayloadInfoFromGlibFull is used to convert raw C.GstRTPPayloadInfo pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeRTPPayloadInfoFromGlibFull is used to convert raw C.GstRTPPayloadInfo pointers to go while taking ownership. This is used by the bindings internally. func UnsafeRTPPayloadInfoFromGlibFull(p unsafe.Pointer) *RTPPayloadInfo { wrapped := UnsafeRTPPayloadInfoFromGlibBorrow(p) runtime.SetFinalizer( @@ -7331,6 +7716,7 @@ func UnsafeRTPPayloadInfoToGlibFull(r *RTPPayloadInfo) unsafe.Pointer { r.native = nil // RTPPayloadInfo is invalid from here on return _p } + // RTPPayloadInfoForName wraps gst_rtp_payload_info_for_name // // The function takes the following parameters: @@ -7418,7 +7804,7 @@ func UnsafeRTPSourceMetaFromGlibBorrow(p unsafe.Pointer) *RTPSourceMeta { return &RTPSourceMeta{&rtpSourceMeta{(*C.GstRTPSourceMeta)(p)}} } -// UnsafeRTPSourceMetaFromGlibNone is used to convert raw C.GstRTPSourceMeta pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeRTPSourceMetaFromGlibNone is used to convert raw C.GstRTPSourceMeta pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeRTPSourceMetaFromGlibNone(p unsafe.Pointer) *RTPSourceMeta { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeRTPSourceMetaFromGlibBorrow(p) @@ -7431,7 +7817,7 @@ func UnsafeRTPSourceMetaFromGlibNone(p unsafe.Pointer) *RTPSourceMeta { return wrapped } -// UnsafeRTPSourceMetaFromGlibFull is used to convert raw C.GstRTPSourceMeta pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeRTPSourceMetaFromGlibFull is used to convert raw C.GstRTPSourceMeta pointers to go while taking ownership. This is used by the bindings internally. func UnsafeRTPSourceMetaFromGlibFull(p unsafe.Pointer) *RTPSourceMeta { wrapped := UnsafeRTPSourceMetaFromGlibBorrow(p) runtime.SetFinalizer( @@ -7463,7 +7849,9 @@ func UnsafeRTPSourceMetaToGlibFull(r *RTPSourceMeta) unsafe.Pointer { r.native = nil // RTPSourceMeta is invalid from here on return _p } + // RTPSourceMetaGetInfo wraps gst_rtp_source_meta_get_info +// // The function returns the following values: // // - goret *gst.MetaInfo @@ -7516,6 +7904,7 @@ func (meta *RTPSourceMeta) AppendCsrc(csrc []uint32) bool { } // GetSourceCount wraps gst_rtp_source_meta_get_source_count +// // The function returns the following values: // // - goret uint diff --git a/pkg/gstrtp/gstrtp_export.gen.go b/pkg/gstrtp/gstrtp_export.gen.go new file mode 100644 index 0000000..3ebdae3 --- /dev/null +++ b/pkg/gstrtp/gstrtp_export.gen.go @@ -0,0 +1,103 @@ +// Code generated by girgen for GstRtp-1. DO NOT EDIT. + +package gstrtp + + +// #include +import "C" + +//export _gotk4_gstrtp1_RTPBaseDepayload_handle_event +func _gotk4_gstrtp1_RTPBaseDepayload_handle_event(carg0 *C.GstRTPBaseDepayload, carg1 *C.GstEvent) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstrtp1_RTPBaseDepayload_packet_lost +func _gotk4_gstrtp1_RTPBaseDepayload_packet_lost(carg0 *C.GstRTPBaseDepayload, carg1 *C.GstEvent) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstrtp1_RTPBaseDepayload_process +func _gotk4_gstrtp1_RTPBaseDepayload_process(carg0 *C.GstRTPBaseDepayload, carg1 *C.GstBuffer) (cret *C.GstBuffer) { + panic("unimplemented") +} + +//export _gotk4_gstrtp1_RTPBaseDepayload_process_rtp_packet +func _gotk4_gstrtp1_RTPBaseDepayload_process_rtp_packet(carg0 *C.GstRTPBaseDepayload, carg1 *C.GstRTPBuffer) (cret *C.GstBuffer) { + panic("unimplemented") +} + +//export _gotk4_gstrtp1_RTPBaseDepayload_set_caps +func _gotk4_gstrtp1_RTPBaseDepayload_set_caps(carg0 *C.GstRTPBaseDepayload, carg1 *C.GstCaps) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstrtp1_RTPBasePayload_get_caps +func _gotk4_gstrtp1_RTPBasePayload_get_caps(carg0 *C.GstRTPBasePayload, carg1 *C.GstPad, carg2 *C.GstCaps) (cret *C.GstCaps) { + panic("unimplemented") +} + +//export _gotk4_gstrtp1_RTPBasePayload_handle_buffer +func _gotk4_gstrtp1_RTPBasePayload_handle_buffer(carg0 *C.GstRTPBasePayload, carg1 *C.GstBuffer) (cret C.GstFlowReturn) { + panic("unimplemented") +} + +//export _gotk4_gstrtp1_RTPBasePayload_query +func _gotk4_gstrtp1_RTPBasePayload_query(carg0 *C.GstRTPBasePayload, carg1 *C.GstPad, carg2 *C.GstQuery) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstrtp1_RTPBasePayload_set_caps +func _gotk4_gstrtp1_RTPBasePayload_set_caps(carg0 *C.GstRTPBasePayload, carg1 *C.GstCaps) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstrtp1_RTPBasePayload_sink_event +func _gotk4_gstrtp1_RTPBasePayload_sink_event(carg0 *C.GstRTPBasePayload, carg1 *C.GstEvent) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstrtp1_RTPBasePayload_src_event +func _gotk4_gstrtp1_RTPBasePayload_src_event(carg0 *C.GstRTPBasePayload, carg1 *C.GstEvent) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstrtp1_RTPHeaderExtension_get_max_size +func _gotk4_gstrtp1_RTPHeaderExtension_get_max_size(carg0 *C.GstRTPHeaderExtension, carg1 *C.GstBuffer) (cret C.gsize) { + panic("unimplemented") +} + +//export _gotk4_gstrtp1_RTPHeaderExtension_get_supported_flags +func _gotk4_gstrtp1_RTPHeaderExtension_get_supported_flags(carg0 *C.GstRTPHeaderExtension) (cret C.GstRTPHeaderExtensionFlags) { + panic("unimplemented") +} + +//export _gotk4_gstrtp1_RTPHeaderExtension_read +func _gotk4_gstrtp1_RTPHeaderExtension_read(carg0 *C.GstRTPHeaderExtension, carg1 C.GstRTPHeaderExtensionFlags, carg2 *C.guint8, carg3 C.gsize, carg4 *C.GstBuffer) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstrtp1_RTPHeaderExtension_set_attributes +func _gotk4_gstrtp1_RTPHeaderExtension_set_attributes(carg0 *C.GstRTPHeaderExtension, carg1 C.GstRTPHeaderExtensionDirection, carg2 *C.gchar) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstrtp1_RTPHeaderExtension_set_caps_from_attributes +func _gotk4_gstrtp1_RTPHeaderExtension_set_caps_from_attributes(carg0 *C.GstRTPHeaderExtension, carg1 *C.GstCaps) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstrtp1_RTPHeaderExtension_set_non_rtp_sink_caps +func _gotk4_gstrtp1_RTPHeaderExtension_set_non_rtp_sink_caps(carg0 *C.GstRTPHeaderExtension, carg1 *C.GstCaps) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstrtp1_RTPHeaderExtension_update_non_rtp_src_caps +func _gotk4_gstrtp1_RTPHeaderExtension_update_non_rtp_src_caps(carg0 *C.GstRTPHeaderExtension, carg1 *C.GstCaps) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstrtp1_RTPHeaderExtension_write +func _gotk4_gstrtp1_RTPHeaderExtension_write(carg0 *C.GstRTPHeaderExtension, carg1 *C.GstBuffer, carg2 C.GstRTPHeaderExtensionFlags, carg3 *C.GstBuffer, carg4 *C.guint8, carg5 C.gsize) (cret C.gssize) { + panic("unimplemented") +} + diff --git a/pkg/gstrtsp/gstrtsp.gen.go b/pkg/gstrtsp/gstrtsp.gen.go index 063ea51..12c5437 100644 --- a/pkg/gstrtsp/gstrtsp.gen.go +++ b/pkg/gstrtsp/gstrtsp.gen.go @@ -22,6 +22,42 @@ import ( // #include // extern gboolean _gotk4_gstrtsp1_RTSPConnectionAcceptCertificateFunc(GTlsConnection*, GTlsCertificate*, GTlsCertificateFlags, gpointer); // extern void destroyUserdata(gpointer); +// extern GstRTSPResult _gotk4_gstrtsp1_RTSPExtension_after_send(GstRTSPExtension*, GstRTSPMessage*, GstRTSPMessage*); +// extern GstRTSPResult _gotk4_gstrtsp1_RTSPExtension_before_send(GstRTSPExtension*, GstRTSPMessage*); +// extern gboolean _gotk4_gstrtsp1_RTSPExtension_configure_stream(GstRTSPExtension*, GstCaps*); +// extern gboolean _gotk4_gstrtsp1_RTSPExtension_detect_server(GstRTSPExtension*, GstRTSPMessage*); +// extern GstRTSPResult _gotk4_gstrtsp1_RTSPExtension_parse_sdp(GstRTSPExtension*, GstSDPMessage*, GstStructure*); +// extern GstRTSPResult _gotk4_gstrtsp1_RTSPExtension_receive_request(GstRTSPExtension*, GstRTSPMessage*); +// extern GstRTSPResult _gotk4_gstrtsp1_RTSPExtension_send(GstRTSPExtension*, GstRTSPMessage*, GstRTSPMessage*); +// extern GstRTSPResult _gotk4_gstrtsp1_RTSPExtension_setup_media(GstRTSPExtension*, GstSDPMedia*); +// extern GstRTSPResult _gotk4_gstrtsp1_RTSPExtension_stream_select(GstRTSPExtension*, GstRTSPUrl*); +// GstRTSPResult _gotk4_gstrtsp1_RTSPExtension_virtual_after_send(void* fnptr, GstRTSPExtension* carg0, GstRTSPMessage* carg1, GstRTSPMessage* carg2) { +// return ((GstRTSPResult (*) (GstRTSPExtension*, GstRTSPMessage*, GstRTSPMessage*))(fnptr))(carg0, carg1, carg2); +// } +// GstRTSPResult _gotk4_gstrtsp1_RTSPExtension_virtual_before_send(void* fnptr, GstRTSPExtension* carg0, GstRTSPMessage* carg1) { +// return ((GstRTSPResult (*) (GstRTSPExtension*, GstRTSPMessage*))(fnptr))(carg0, carg1); +// } +// gboolean _gotk4_gstrtsp1_RTSPExtension_virtual_configure_stream(void* fnptr, GstRTSPExtension* carg0, GstCaps* carg1) { +// return ((gboolean (*) (GstRTSPExtension*, GstCaps*))(fnptr))(carg0, carg1); +// } +// gboolean _gotk4_gstrtsp1_RTSPExtension_virtual_detect_server(void* fnptr, GstRTSPExtension* carg0, GstRTSPMessage* carg1) { +// return ((gboolean (*) (GstRTSPExtension*, GstRTSPMessage*))(fnptr))(carg0, carg1); +// } +// GstRTSPResult _gotk4_gstrtsp1_RTSPExtension_virtual_parse_sdp(void* fnptr, GstRTSPExtension* carg0, GstSDPMessage* carg1, GstStructure* carg2) { +// return ((GstRTSPResult (*) (GstRTSPExtension*, GstSDPMessage*, GstStructure*))(fnptr))(carg0, carg1, carg2); +// } +// GstRTSPResult _gotk4_gstrtsp1_RTSPExtension_virtual_receive_request(void* fnptr, GstRTSPExtension* carg0, GstRTSPMessage* carg1) { +// return ((GstRTSPResult (*) (GstRTSPExtension*, GstRTSPMessage*))(fnptr))(carg0, carg1); +// } +// GstRTSPResult _gotk4_gstrtsp1_RTSPExtension_virtual_send(void* fnptr, GstRTSPExtension* carg0, GstRTSPMessage* carg1, GstRTSPMessage* carg2) { +// return ((GstRTSPResult (*) (GstRTSPExtension*, GstRTSPMessage*, GstRTSPMessage*))(fnptr))(carg0, carg1, carg2); +// } +// GstRTSPResult _gotk4_gstrtsp1_RTSPExtension_virtual_setup_media(void* fnptr, GstRTSPExtension* carg0, GstSDPMedia* carg1) { +// return ((GstRTSPResult (*) (GstRTSPExtension*, GstSDPMedia*))(fnptr))(carg0, carg1); +// } +// GstRTSPResult _gotk4_gstrtsp1_RTSPExtension_virtual_stream_select(void* fnptr, GstRTSPExtension* carg0, GstRTSPUrl* carg1) { +// return ((GstRTSPResult (*) (GstRTSPExtension*, GstRTSPUrl*))(fnptr))(carg0, carg1); +// } import "C" // GType values. @@ -1669,6 +1705,7 @@ func RtspHeaderAsText(field RTSPHeaderField) string { } // NewRtspMessage wraps gst_rtsp_message_new +// // The function returns the following values: // // - msg *RTSPMessage: a location for the new #GstRTSPMessage @@ -2343,6 +2380,138 @@ func (ext *RTSPExtensionInstance) StreamSelect(url *RTSPUrl) RTSPResult { func (o *RTSPExtensionInstance) ConnectSend(fn func(RTSPExtension, unsafe.Pointer, unsafe.Pointer) RTSPResult) gobject.SignalHandle { return o.Instance.Connect("send", fn) } + +// RTSPExtensionOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type RTSPExtensionOverrides[Instance RTSPExtension] struct { + // AfterSend allows you to override the implementation of the virtual method after_send. + // The function takes the following parameters: + // + // - req *RTSPMessage + // - resp *RTSPMessage + // + // The function returns the following values: + // + // - goret RTSPResult + AfterSend func(Instance, *RTSPMessage, *RTSPMessage) RTSPResult + // BeforeSend allows you to override the implementation of the virtual method before_send. + // The function takes the following parameters: + // + // - req *RTSPMessage + // + // The function returns the following values: + // + // - goret RTSPResult + BeforeSend func(Instance, *RTSPMessage) RTSPResult + // ConfigureStream allows you to override the implementation of the virtual method configure_stream. + // The function takes the following parameters: + // + // - caps *gst.Caps + // + // The function returns the following values: + // + // - goret bool + ConfigureStream func(Instance, *gst.Caps) bool + // DetectServer allows you to override the implementation of the virtual method detect_server. + // The function takes the following parameters: + // + // - resp *RTSPMessage + // + // The function returns the following values: + // + // - goret bool + DetectServer func(Instance, *RTSPMessage) bool + // ParseSdp allows you to override the implementation of the virtual method parse_sdp. + // The function takes the following parameters: + // + // - sdp *gstsdp.SDPMessage + // - s *gst.Structure + // + // The function returns the following values: + // + // - goret RTSPResult + ParseSdp func(Instance, *gstsdp.SDPMessage, *gst.Structure) RTSPResult + // ReceiveRequest allows you to override the implementation of the virtual method receive_request. + // The function takes the following parameters: + // + // - req *RTSPMessage + // + // The function returns the following values: + // + // - goret RTSPResult + ReceiveRequest func(Instance, *RTSPMessage) RTSPResult + // Send allows you to override the implementation of the virtual method send. + // The function takes the following parameters: + // + // - req *RTSPMessage + // - resp *RTSPMessage + // + // The function returns the following values: + // + // - goret RTSPResult + Send func(Instance, *RTSPMessage, *RTSPMessage) RTSPResult + // SetupMedia allows you to override the implementation of the virtual method setup_media. + // The function takes the following parameters: + // + // - media *gstsdp.SDPMedia + // + // The function returns the following values: + // + // - goret RTSPResult + SetupMedia func(Instance, *gstsdp.SDPMedia) RTSPResult + // StreamSelect allows you to override the implementation of the virtual method stream_select. + // The function takes the following parameters: + // + // - url *RTSPUrl + // + // The function returns the following values: + // + // - goret RTSPResult + StreamSelect func(Instance, *RTSPUrl) RTSPResult +} + +// UnsafeApplyRTSPExtensionOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyRTSPExtensionOverrides[Instance RTSPExtension](gclass unsafe.Pointer, overrides RTSPExtensionOverrides[Instance]) { + pclass := (*C.GstRTSPExtensionInterface)(gclass) + + if overrides.AfterSend != nil { + pclass.after_send = (*[0]byte)(C._gotk4_gstrtsp1_RTSPExtension_after_send) + } + + if overrides.BeforeSend != nil { + pclass.before_send = (*[0]byte)(C._gotk4_gstrtsp1_RTSPExtension_before_send) + } + + if overrides.ConfigureStream != nil { + pclass.configure_stream = (*[0]byte)(C._gotk4_gstrtsp1_RTSPExtension_configure_stream) + } + + if overrides.DetectServer != nil { + pclass.detect_server = (*[0]byte)(C._gotk4_gstrtsp1_RTSPExtension_detect_server) + } + + if overrides.ParseSdp != nil { + pclass.parse_sdp = (*[0]byte)(C._gotk4_gstrtsp1_RTSPExtension_parse_sdp) + } + + if overrides.ReceiveRequest != nil { + pclass.receive_request = (*[0]byte)(C._gotk4_gstrtsp1_RTSPExtension_receive_request) + } + + if overrides.Send != nil { + pclass.send = (*[0]byte)(C._gotk4_gstrtsp1_RTSPExtension_send) + } + + if overrides.SetupMedia != nil { + pclass.setup_media = (*[0]byte)(C._gotk4_gstrtsp1_RTSPExtension_setup_media) + } + + if overrides.StreamSelect != nil { + pclass.stream_select = (*[0]byte)(C._gotk4_gstrtsp1_RTSPExtension_stream_select) + } +} + // RTSPAuthCredential wraps GstRTSPAuthCredential // // RTSP Authentication credentials @@ -2372,7 +2541,7 @@ func UnsafeRTSPAuthCredentialFromGlibBorrow(p unsafe.Pointer) *RTSPAuthCredentia return &RTSPAuthCredential{&rtspAuthCredential{(*C.GstRTSPAuthCredential)(p)}} } -// UnsafeRTSPAuthCredentialFromGlibNone is used to convert raw C.GstRTSPAuthCredential pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeRTSPAuthCredentialFromGlibNone is used to convert raw C.GstRTSPAuthCredential pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeRTSPAuthCredentialFromGlibNone(p unsafe.Pointer) *RTSPAuthCredential { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeRTSPAuthCredentialFromGlibBorrow(p) @@ -2385,7 +2554,7 @@ func UnsafeRTSPAuthCredentialFromGlibNone(p unsafe.Pointer) *RTSPAuthCredential return wrapped } -// UnsafeRTSPAuthCredentialFromGlibFull is used to convert raw C.GstRTSPAuthCredential pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeRTSPAuthCredentialFromGlibFull is used to convert raw C.GstRTSPAuthCredential pointers to go while taking ownership. This is used by the bindings internally. func UnsafeRTSPAuthCredentialFromGlibFull(p unsafe.Pointer) *RTSPAuthCredential { wrapped := UnsafeRTSPAuthCredentialFromGlibBorrow(p) runtime.SetFinalizer( @@ -2417,6 +2586,7 @@ func UnsafeRTSPAuthCredentialToGlibFull(r *RTSPAuthCredential) unsafe.Pointer { r.native = nil // RTSPAuthCredential is invalid from here on return _p } + // RTSPAuthParam wraps GstRTSPAuthParam // // RTSP Authentication parameter @@ -2446,7 +2616,7 @@ func UnsafeRTSPAuthParamFromGlibBorrow(p unsafe.Pointer) *RTSPAuthParam { return &RTSPAuthParam{&rtspAuthParam{(*C.GstRTSPAuthParam)(p)}} } -// UnsafeRTSPAuthParamFromGlibNone is used to convert raw C.GstRTSPAuthParam pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeRTSPAuthParamFromGlibNone is used to convert raw C.GstRTSPAuthParam pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeRTSPAuthParamFromGlibNone(p unsafe.Pointer) *RTSPAuthParam { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeRTSPAuthParamFromGlibBorrow(p) @@ -2459,7 +2629,7 @@ func UnsafeRTSPAuthParamFromGlibNone(p unsafe.Pointer) *RTSPAuthParam { return wrapped } -// UnsafeRTSPAuthParamFromGlibFull is used to convert raw C.GstRTSPAuthParam pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeRTSPAuthParamFromGlibFull is used to convert raw C.GstRTSPAuthParam pointers to go while taking ownership. This is used by the bindings internally. func UnsafeRTSPAuthParamFromGlibFull(p unsafe.Pointer) *RTSPAuthParam { wrapped := UnsafeRTSPAuthParamFromGlibBorrow(p) runtime.SetFinalizer( @@ -2491,7 +2661,9 @@ func UnsafeRTSPAuthParamToGlibFull(r *RTSPAuthParam) unsafe.Pointer { r.native = nil // RTSPAuthParam is invalid from here on return _p } + // Copy wraps gst_rtsp_auth_param_copy +// // The function returns the following values: // // - goret *RTSPAuthParam @@ -2529,7 +2701,7 @@ func UnsafeRTSPConnectionFromGlibBorrow(p unsafe.Pointer) *RTSPConnection { return &RTSPConnection{&rtspConnection{(*C.GstRTSPConnection)(p)}} } -// UnsafeRTSPConnectionFromGlibNone is used to convert raw C.GstRTSPConnection pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeRTSPConnectionFromGlibNone is used to convert raw C.GstRTSPConnection pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeRTSPConnectionFromGlibNone(p unsafe.Pointer) *RTSPConnection { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeRTSPConnectionFromGlibBorrow(p) @@ -2542,7 +2714,7 @@ func UnsafeRTSPConnectionFromGlibNone(p unsafe.Pointer) *RTSPConnection { return wrapped } -// UnsafeRTSPConnectionFromGlibFull is used to convert raw C.GstRTSPConnection pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeRTSPConnectionFromGlibFull is used to convert raw C.GstRTSPConnection pointers to go while taking ownership. This is used by the bindings internally. func UnsafeRTSPConnectionFromGlibFull(p unsafe.Pointer) *RTSPConnection { wrapped := UnsafeRTSPConnectionFromGlibBorrow(p) runtime.SetFinalizer( @@ -2574,6 +2746,7 @@ func UnsafeRTSPConnectionToGlibFull(r *RTSPConnection) unsafe.Pointer { r.native = nil // RTSPConnection is invalid from here on return _p } + // RTSPConnectionAccept wraps gst_rtsp_connection_accept // // The function takes the following parameters: @@ -2739,6 +2912,7 @@ func (conn *RTSPConnection) ClearAuthParams() { } // Close wraps gst_rtsp_connection_close +// // The function returns the following values: // // - goret RTSPResult @@ -2911,6 +3085,7 @@ func (conn *RTSPConnection) Flush(flush bool) RTSPResult { } // GetIgnoreXServerReply wraps gst_rtsp_connection_get_ignore_x_server_reply +// // The function returns the following values: // // - goret bool @@ -2935,6 +3110,7 @@ func (conn *RTSPConnection) GetIgnoreXServerReply() bool { } // GetIP wraps gst_rtsp_connection_get_ip +// // The function returns the following values: // // - goret string @@ -2957,6 +3133,7 @@ func (conn *RTSPConnection) GetIP() string { } // GetReadSocket wraps gst_rtsp_connection_get_read_socket +// // The function returns the following values: // // - goret gio.Socket (nullable) @@ -2981,6 +3158,7 @@ func (conn *RTSPConnection) GetReadSocket() gio.Socket { } // GetRememberSessionID wraps gst_rtsp_connection_get_remember_session_id +// // The function returns the following values: // // - goret bool @@ -3003,6 +3181,7 @@ func (conn *RTSPConnection) GetRememberSessionID() bool { } // GetTLS wraps gst_rtsp_connection_get_tls +// // The function returns the following values: // // - goret gio.TlsConnection @@ -3038,6 +3217,7 @@ func (conn *RTSPConnection) GetTLS() (gio.TlsConnection, error) { } // GetTLSDatabase wraps gst_rtsp_connection_get_tls_database +// // The function returns the following values: // // - goret gio.TlsDatabase (nullable) @@ -3064,6 +3244,7 @@ func (conn *RTSPConnection) GetTLSDatabase() gio.TlsDatabase { } // GetTLSInteraction wraps gst_rtsp_connection_get_tls_interaction +// // The function returns the following values: // // - goret gio.TlsInteraction (nullable) @@ -3090,6 +3271,7 @@ func (conn *RTSPConnection) GetTLSInteraction() gio.TlsInteraction { } // GetTLSValidationFlags wraps gst_rtsp_connection_get_tls_validation_flags +// // The function returns the following values: // // - goret gio.TLSCertificateFlags @@ -3122,6 +3304,7 @@ func (conn *RTSPConnection) GetTLSValidationFlags() gio.TLSCertificateFlags { } // GetTunnelid wraps gst_rtsp_connection_get_tunnelid +// // The function returns the following values: // // - goret string (nullable) @@ -3146,6 +3329,7 @@ func (conn *RTSPConnection) GetTunnelid() string { } // GetURL wraps gst_rtsp_connection_get_url +// // The function returns the following values: // // - goret *RTSPUrl @@ -3168,6 +3352,7 @@ func (conn *RTSPConnection) GetURL() *RTSPUrl { } // GetWriteSocket wraps gst_rtsp_connection_get_write_socket +// // The function returns the following values: // // - goret gio.Socket (nullable) @@ -3192,6 +3377,7 @@ func (conn *RTSPConnection) GetWriteSocket() gio.Socket { } // IsTunneled wraps gst_rtsp_connection_is_tunneled +// // The function returns the following values: // // - goret bool @@ -3216,6 +3402,7 @@ func (conn *RTSPConnection) IsTunneled() bool { } // NextTimeoutUsec wraps gst_rtsp_connection_next_timeout_usec +// // The function returns the following values: // // - goret int64 @@ -3365,6 +3552,7 @@ func (conn *RTSPConnection) ReceiveUsec(message *RTSPMessage, timeout int64) RTS } // ResetTimeout wraps gst_rtsp_connection_reset_timeout +// // The function returns the following values: // // - goret RTSPResult @@ -3909,7 +4097,7 @@ func UnsafeRTSPExtensionInterfaceFromGlibBorrow(p unsafe.Pointer) *RTSPExtension return &RTSPExtensionInterface{&rtspExtensionInterface{(*C.GstRTSPExtensionInterface)(p)}} } -// UnsafeRTSPExtensionInterfaceFromGlibNone is used to convert raw C.GstRTSPExtensionInterface pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeRTSPExtensionInterfaceFromGlibNone is used to convert raw C.GstRTSPExtensionInterface pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeRTSPExtensionInterfaceFromGlibNone(p unsafe.Pointer) *RTSPExtensionInterface { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeRTSPExtensionInterfaceFromGlibBorrow(p) @@ -3922,7 +4110,7 @@ func UnsafeRTSPExtensionInterfaceFromGlibNone(p unsafe.Pointer) *RTSPExtensionIn return wrapped } -// UnsafeRTSPExtensionInterfaceFromGlibFull is used to convert raw C.GstRTSPExtensionInterface pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeRTSPExtensionInterfaceFromGlibFull is used to convert raw C.GstRTSPExtensionInterface pointers to go while taking ownership. This is used by the bindings internally. func UnsafeRTSPExtensionInterfaceFromGlibFull(p unsafe.Pointer) *RTSPExtensionInterface { wrapped := UnsafeRTSPExtensionInterfaceFromGlibBorrow(p) runtime.SetFinalizer( @@ -3954,6 +4142,7 @@ func UnsafeRTSPExtensionInterfaceToGlibFull(r *RTSPExtensionInterface) unsafe.Po r.native = nil // RTSPExtensionInterface is invalid from here on return _p } + // RTSPMessage wraps GstRTSPMessage // // Provides methods for creating and parsing request, response and data messages. @@ -3983,7 +4172,7 @@ func UnsafeRTSPMessageFromGlibBorrow(p unsafe.Pointer) *RTSPMessage { return &RTSPMessage{&rtspMessage{(*C.GstRTSPMessage)(p)}} } -// UnsafeRTSPMessageFromGlibNone is used to convert raw C.GstRTSPMessage pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeRTSPMessageFromGlibNone is used to convert raw C.GstRTSPMessage pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeRTSPMessageFromGlibNone(p unsafe.Pointer) *RTSPMessage { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeRTSPMessageFromGlibBorrow(p) @@ -3996,7 +4185,7 @@ func UnsafeRTSPMessageFromGlibNone(p unsafe.Pointer) *RTSPMessage { return wrapped } -// UnsafeRTSPMessageFromGlibFull is used to convert raw C.GstRTSPMessage pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeRTSPMessageFromGlibFull is used to convert raw C.GstRTSPMessage pointers to go while taking ownership. This is used by the bindings internally. func UnsafeRTSPMessageFromGlibFull(p unsafe.Pointer) *RTSPMessage { wrapped := UnsafeRTSPMessageFromGlibBorrow(p) runtime.SetFinalizer( @@ -4028,6 +4217,7 @@ func UnsafeRTSPMessageToGlibFull(r *RTSPMessage) unsafe.Pointer { r.native = nil // RTSPMessage is invalid from here on return _p } + // AddHeader wraps gst_rtsp_message_add_header // // The function takes the following parameters: @@ -4102,6 +4292,7 @@ func (msg *RTSPMessage) AddHeaderByName(header string, value string) RTSPResult } // Copy wraps gst_rtsp_message_copy +// // The function returns the following values: // // - copy *RTSPMessage (nullable): pointer to new #GstRTSPMessage @@ -4131,6 +4322,7 @@ func (msg *RTSPMessage) Copy() (*RTSPMessage, RTSPResult) { } // Dump wraps gst_rtsp_message_dump +// // The function returns the following values: // // - goret RTSPResult @@ -4153,6 +4345,7 @@ func (msg *RTSPMessage) Dump() RTSPResult { } // GetBodyBuffer wraps gst_rtsp_message_get_body_buffer +// // The function returns the following values: // // - buffer *gst.Buffer: location for the buffer @@ -4267,6 +4460,7 @@ func (msg *RTSPMessage) GetHeaderByName(header string, index int) (string, RTSPR } // GetType wraps gst_rtsp_message_get_type +// // The function returns the following values: // // - goret RTSPMsgType @@ -4289,6 +4483,7 @@ func (msg *RTSPMessage) GetType() RTSPMsgType { } // HasBodyBuffer wraps gst_rtsp_message_has_body_buffer +// // The function returns the following values: // // - goret bool @@ -4313,6 +4508,7 @@ func (msg *RTSPMessage) HasBodyBuffer() bool { } // Init wraps gst_rtsp_message_init +// // The function returns the following values: // // - goret RTSPResult @@ -4482,6 +4678,7 @@ func (msg *RTSPMessage) ParseAuthCredentials(field RTSPHeaderField) []*RTSPAuthC } // ParseData wraps gst_rtsp_message_parse_data +// // The function returns the following values: // // - channel uint8: location to hold the channel @@ -4508,6 +4705,7 @@ func (msg *RTSPMessage) ParseData() (uint8, RTSPResult) { } // ParseRequest wraps gst_rtsp_message_parse_request +// // The function returns the following values: // // - method RTSPMethod: location to hold the method @@ -4546,6 +4744,7 @@ func (msg *RTSPMessage) ParseRequest() (RTSPMethod, string, RTSPVersion, RTSPRes } // ParseResponse wraps gst_rtsp_message_parse_response +// // The function returns the following values: // // - code RTSPStatusCode: location to hold the status code @@ -4721,6 +4920,7 @@ func (msg *RTSPMessage) SetBodyBuffer(buffer *gst.Buffer) RTSPResult { } // StealBodyBuffer wraps gst_rtsp_message_steal_body_buffer +// // The function returns the following values: // // - buffer *gst.Buffer: location for the buffer @@ -4889,6 +5089,7 @@ func (msg *RTSPMessage) TakeHeaderByName(header string, value string) RTSPResult } // Unset wraps gst_rtsp_message_unset +// // The function returns the following values: // // - goret RTSPResult @@ -4930,7 +5131,7 @@ func UnsafeRTSPRangeFromGlibBorrow(p unsafe.Pointer) *RTSPRange { return &RTSPRange{&rtspRange{(*C.GstRTSPRange)(p)}} } -// UnsafeRTSPRangeFromGlibNone is used to convert raw C.GstRTSPRange pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeRTSPRangeFromGlibNone is used to convert raw C.GstRTSPRange pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeRTSPRangeFromGlibNone(p unsafe.Pointer) *RTSPRange { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeRTSPRangeFromGlibBorrow(p) @@ -4943,7 +5144,7 @@ func UnsafeRTSPRangeFromGlibNone(p unsafe.Pointer) *RTSPRange { return wrapped } -// UnsafeRTSPRangeFromGlibFull is used to convert raw C.GstRTSPRange pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeRTSPRangeFromGlibFull is used to convert raw C.GstRTSPRange pointers to go while taking ownership. This is used by the bindings internally. func UnsafeRTSPRangeFromGlibFull(p unsafe.Pointer) *RTSPRange { wrapped := UnsafeRTSPRangeFromGlibBorrow(p) runtime.SetFinalizer( @@ -4975,6 +5176,7 @@ func UnsafeRTSPRangeToGlibFull(r *RTSPRange) unsafe.Pointer { r.native = nil // RTSPRange is invalid from here on return _p } + // RTSPRangeConvertUnits wraps gst_rtsp_range_convert_units // // The function takes the following parameters: @@ -5146,7 +5348,7 @@ func UnsafeRTSPTimeFromGlibBorrow(p unsafe.Pointer) *RTSPTime { return &RTSPTime{&rtspTime{(*C.GstRTSPTime)(p)}} } -// UnsafeRTSPTimeFromGlibNone is used to convert raw C.GstRTSPTime pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeRTSPTimeFromGlibNone is used to convert raw C.GstRTSPTime pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeRTSPTimeFromGlibNone(p unsafe.Pointer) *RTSPTime { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeRTSPTimeFromGlibBorrow(p) @@ -5159,7 +5361,7 @@ func UnsafeRTSPTimeFromGlibNone(p unsafe.Pointer) *RTSPTime { return wrapped } -// UnsafeRTSPTimeFromGlibFull is used to convert raw C.GstRTSPTime pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeRTSPTimeFromGlibFull is used to convert raw C.GstRTSPTime pointers to go while taking ownership. This is used by the bindings internally. func UnsafeRTSPTimeFromGlibFull(p unsafe.Pointer) *RTSPTime { wrapped := UnsafeRTSPTimeFromGlibBorrow(p) runtime.SetFinalizer( @@ -5191,6 +5393,7 @@ func UnsafeRTSPTimeToGlibFull(r *RTSPTime) unsafe.Pointer { r.native = nil // RTSPTime is invalid from here on return _p } + // RTSPTime2 wraps GstRTSPTime2 // // Extra fields for a time indication. @@ -5208,7 +5411,7 @@ func UnsafeRTSPTime2FromGlibBorrow(p unsafe.Pointer) *RTSPTime2 { return &RTSPTime2{&rtspTime2{(*C.GstRTSPTime2)(p)}} } -// UnsafeRTSPTime2FromGlibNone is used to convert raw C.GstRTSPTime2 pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeRTSPTime2FromGlibNone is used to convert raw C.GstRTSPTime2 pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeRTSPTime2FromGlibNone(p unsafe.Pointer) *RTSPTime2 { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeRTSPTime2FromGlibBorrow(p) @@ -5221,7 +5424,7 @@ func UnsafeRTSPTime2FromGlibNone(p unsafe.Pointer) *RTSPTime2 { return wrapped } -// UnsafeRTSPTime2FromGlibFull is used to convert raw C.GstRTSPTime2 pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeRTSPTime2FromGlibFull is used to convert raw C.GstRTSPTime2 pointers to go while taking ownership. This is used by the bindings internally. func UnsafeRTSPTime2FromGlibFull(p unsafe.Pointer) *RTSPTime2 { wrapped := UnsafeRTSPTime2FromGlibBorrow(p) runtime.SetFinalizer( @@ -5253,6 +5456,7 @@ func UnsafeRTSPTime2ToGlibFull(r *RTSPTime2) unsafe.Pointer { r.native = nil // RTSPTime2 is invalid from here on return _p } + // RTSPTimeRange wraps GstRTSPTimeRange // // A time range. @@ -5270,7 +5474,7 @@ func UnsafeRTSPTimeRangeFromGlibBorrow(p unsafe.Pointer) *RTSPTimeRange { return &RTSPTimeRange{&rtspTimeRange{(*C.GstRTSPTimeRange)(p)}} } -// UnsafeRTSPTimeRangeFromGlibNone is used to convert raw C.GstRTSPTimeRange pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeRTSPTimeRangeFromGlibNone is used to convert raw C.GstRTSPTimeRange pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeRTSPTimeRangeFromGlibNone(p unsafe.Pointer) *RTSPTimeRange { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeRTSPTimeRangeFromGlibBorrow(p) @@ -5283,7 +5487,7 @@ func UnsafeRTSPTimeRangeFromGlibNone(p unsafe.Pointer) *RTSPTimeRange { return wrapped } -// UnsafeRTSPTimeRangeFromGlibFull is used to convert raw C.GstRTSPTimeRange pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeRTSPTimeRangeFromGlibFull is used to convert raw C.GstRTSPTimeRange pointers to go while taking ownership. This is used by the bindings internally. func UnsafeRTSPTimeRangeFromGlibFull(p unsafe.Pointer) *RTSPTimeRange { wrapped := UnsafeRTSPTimeRangeFromGlibBorrow(p) runtime.SetFinalizer( @@ -5315,6 +5519,7 @@ func UnsafeRTSPTimeRangeToGlibFull(r *RTSPTimeRange) unsafe.Pointer { r.native = nil // RTSPTimeRange is invalid from here on return _p } + // RTSPTransport wraps GstRTSPTransport // // Provides helper functions to deal with RTSP transport strings. @@ -5332,7 +5537,7 @@ func UnsafeRTSPTransportFromGlibBorrow(p unsafe.Pointer) *RTSPTransport { return &RTSPTransport{&rtspTransport{(*C.GstRTSPTransport)(p)}} } -// UnsafeRTSPTransportFromGlibNone is used to convert raw C.GstRTSPTransport pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeRTSPTransportFromGlibNone is used to convert raw C.GstRTSPTransport pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeRTSPTransportFromGlibNone(p unsafe.Pointer) *RTSPTransport { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeRTSPTransportFromGlibBorrow(p) @@ -5345,7 +5550,7 @@ func UnsafeRTSPTransportFromGlibNone(p unsafe.Pointer) *RTSPTransport { return wrapped } -// UnsafeRTSPTransportFromGlibFull is used to convert raw C.GstRTSPTransport pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeRTSPTransportFromGlibFull is used to convert raw C.GstRTSPTransport pointers to go while taking ownership. This is used by the bindings internally. func UnsafeRTSPTransportFromGlibFull(p unsafe.Pointer) *RTSPTransport { wrapped := UnsafeRTSPTransportFromGlibBorrow(p) runtime.SetFinalizer( @@ -5377,6 +5582,7 @@ func UnsafeRTSPTransportToGlibFull(r *RTSPTransport) unsafe.Pointer { r.native = nil // RTSPTransport is invalid from here on return _p } + // RTSPTransportGetManager wraps gst_rtsp_transport_get_manager // // The function takes the following parameters: @@ -5457,6 +5663,7 @@ func RTSPTransportGetMIME(trans RTSPTransMode) (string, RTSPResult) { } // RTSPTransportInit wraps gst_rtsp_transport_init +// // The function returns the following values: // // - transport RTSPTransport: a #GstRTSPTransport @@ -5481,6 +5688,7 @@ func RTSPTransportInit() (RTSPTransport, RTSPResult) { } // NewRTSPTransport wraps gst_rtsp_transport_new +// // The function returns the following values: // // - transport *RTSPTransport: location to hold the new #GstRTSPTransport @@ -5538,6 +5746,7 @@ func RTSPTransportParse(str string) (RTSPTransport, RTSPResult) { } // AsText wraps gst_rtsp_transport_as_text +// // The function returns the following values: // // - goret string (nullable) @@ -5564,6 +5773,7 @@ func (transport *RTSPTransport) AsText() string { } // GetMediaType wraps gst_rtsp_transport_get_media_type +// // The function returns the following values: // // - mediaType string: media type of @transport @@ -5619,7 +5829,7 @@ func UnsafeRTSPUrlFromGlibBorrow(p unsafe.Pointer) *RTSPUrl { return &RTSPUrl{&rtspUrl{(*C.GstRTSPUrl)(p)}} } -// UnsafeRTSPUrlFromGlibNone is used to convert raw C.GstRTSPUrl pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeRTSPUrlFromGlibNone is used to convert raw C.GstRTSPUrl pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeRTSPUrlFromGlibNone(p unsafe.Pointer) *RTSPUrl { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeRTSPUrlFromGlibBorrow(p) @@ -5632,7 +5842,7 @@ func UnsafeRTSPUrlFromGlibNone(p unsafe.Pointer) *RTSPUrl { return wrapped } -// UnsafeRTSPUrlFromGlibFull is used to convert raw C.GstRTSPUrl pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeRTSPUrlFromGlibFull is used to convert raw C.GstRTSPUrl pointers to go while taking ownership. This is used by the bindings internally. func UnsafeRTSPUrlFromGlibFull(p unsafe.Pointer) *RTSPUrl { wrapped := UnsafeRTSPUrlFromGlibBorrow(p) runtime.SetFinalizer( @@ -5664,6 +5874,7 @@ func UnsafeRTSPUrlToGlibFull(r *RTSPUrl) unsafe.Pointer { r.native = nil // RTSPUrl is invalid from here on return _p } + // RTSPUrlParse wraps gst_rtsp_url_parse // // The function takes the following parameters: @@ -5700,6 +5911,7 @@ func RTSPUrlParse(urlstr string) (*RTSPUrl, RTSPResult) { } // Copy wraps gst_rtsp_url_copy +// // The function returns the following values: // // - goret *RTSPUrl @@ -5722,6 +5934,7 @@ func (url *RTSPUrl) Copy() *RTSPUrl { } // DecodePathComponents wraps gst_rtsp_url_decode_path_components +// // The function returns the following values: // // - goret []string @@ -5756,6 +5969,7 @@ func (url *RTSPUrl) DecodePathComponents() []string { } // GetPort wraps gst_rtsp_url_get_port +// // The function returns the following values: // // - port uint16: location to hold the port @@ -5782,6 +5996,7 @@ func (url *RTSPUrl) GetPort() (uint16, RTSPResult) { } // GetRequestURI wraps gst_rtsp_url_get_request_uri +// // The function returns the following values: // // - goret string @@ -5885,7 +6100,7 @@ func UnsafeRTSPWatchFromGlibBorrow(p unsafe.Pointer) *RTSPWatch { return &RTSPWatch{&rtspWatch{(*C.GstRTSPWatch)(p)}} } -// UnsafeRTSPWatchFromGlibNone is used to convert raw C.GstRTSPWatch pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeRTSPWatchFromGlibNone is used to convert raw C.GstRTSPWatch pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeRTSPWatchFromGlibNone(p unsafe.Pointer) *RTSPWatch { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeRTSPWatchFromGlibBorrow(p) @@ -5898,7 +6113,7 @@ func UnsafeRTSPWatchFromGlibNone(p unsafe.Pointer) *RTSPWatch { return wrapped } -// UnsafeRTSPWatchFromGlibFull is used to convert raw C.GstRTSPWatch pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeRTSPWatchFromGlibFull is used to convert raw C.GstRTSPWatch pointers to go while taking ownership. This is used by the bindings internally. func UnsafeRTSPWatchFromGlibFull(p unsafe.Pointer) *RTSPWatch { wrapped := UnsafeRTSPWatchFromGlibBorrow(p) runtime.SetFinalizer( @@ -5930,6 +6145,7 @@ func UnsafeRTSPWatchToGlibFull(r *RTSPWatch) unsafe.Pointer { r.native = nil // RTSPWatch is invalid from here on return _p } + // Attach wraps gst_rtsp_watch_attach // // The function takes the following parameters: @@ -5963,6 +6179,7 @@ func (watch *RTSPWatch) Attach(_context *glib.MainContext) uint { } // GetSendBacklog wraps gst_rtsp_watch_get_send_backlog +// // The function returns the following values: // // - bytes uint: maximum bytes @@ -6240,7 +6457,7 @@ func UnsafeRTSPWatchFuncsFromGlibBorrow(p unsafe.Pointer) *RTSPWatchFuncs { return &RTSPWatchFuncs{&rtspWatchFuncs{(*C.GstRTSPWatchFuncs)(p)}} } -// UnsafeRTSPWatchFuncsFromGlibNone is used to convert raw C.GstRTSPWatchFuncs pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeRTSPWatchFuncsFromGlibNone is used to convert raw C.GstRTSPWatchFuncs pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeRTSPWatchFuncsFromGlibNone(p unsafe.Pointer) *RTSPWatchFuncs { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeRTSPWatchFuncsFromGlibBorrow(p) @@ -6253,7 +6470,7 @@ func UnsafeRTSPWatchFuncsFromGlibNone(p unsafe.Pointer) *RTSPWatchFuncs { return wrapped } -// UnsafeRTSPWatchFuncsFromGlibFull is used to convert raw C.GstRTSPWatchFuncs pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeRTSPWatchFuncsFromGlibFull is used to convert raw C.GstRTSPWatchFuncs pointers to go while taking ownership. This is used by the bindings internally. func UnsafeRTSPWatchFuncsFromGlibFull(p unsafe.Pointer) *RTSPWatchFuncs { wrapped := UnsafeRTSPWatchFuncsFromGlibBorrow(p) runtime.SetFinalizer( @@ -6285,3 +6502,4 @@ func UnsafeRTSPWatchFuncsToGlibFull(r *RTSPWatchFuncs) unsafe.Pointer { r.native = nil // RTSPWatchFuncs is invalid from here on return _p } + diff --git a/pkg/gstrtsp/gstrtsp_export.gen.go b/pkg/gstrtsp/gstrtsp_export.gen.go index 894e70f..0066989 100644 --- a/pkg/gstrtsp/gstrtsp_export.gen.go +++ b/pkg/gstrtsp/gstrtsp_export.gen.go @@ -41,3 +41,48 @@ func _gotk4_gstrtsp1_RTSPConnectionAcceptCertificateFunc(carg1 *C.GTlsConnection return cret } +//export _gotk4_gstrtsp1_RTSPExtension_after_send +func _gotk4_gstrtsp1_RTSPExtension_after_send(carg0 *C.GstRTSPExtension, carg1 *C.GstRTSPMessage, carg2 *C.GstRTSPMessage) (cret C.GstRTSPResult) { + panic("unimplemented") +} + +//export _gotk4_gstrtsp1_RTSPExtension_before_send +func _gotk4_gstrtsp1_RTSPExtension_before_send(carg0 *C.GstRTSPExtension, carg1 *C.GstRTSPMessage) (cret C.GstRTSPResult) { + panic("unimplemented") +} + +//export _gotk4_gstrtsp1_RTSPExtension_configure_stream +func _gotk4_gstrtsp1_RTSPExtension_configure_stream(carg0 *C.GstRTSPExtension, carg1 *C.GstCaps) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstrtsp1_RTSPExtension_detect_server +func _gotk4_gstrtsp1_RTSPExtension_detect_server(carg0 *C.GstRTSPExtension, carg1 *C.GstRTSPMessage) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstrtsp1_RTSPExtension_parse_sdp +func _gotk4_gstrtsp1_RTSPExtension_parse_sdp(carg0 *C.GstRTSPExtension, carg1 *C.GstSDPMessage, carg2 *C.GstStructure) (cret C.GstRTSPResult) { + panic("unimplemented") +} + +//export _gotk4_gstrtsp1_RTSPExtension_receive_request +func _gotk4_gstrtsp1_RTSPExtension_receive_request(carg0 *C.GstRTSPExtension, carg1 *C.GstRTSPMessage) (cret C.GstRTSPResult) { + panic("unimplemented") +} + +//export _gotk4_gstrtsp1_RTSPExtension_send +func _gotk4_gstrtsp1_RTSPExtension_send(carg0 *C.GstRTSPExtension, carg1 *C.GstRTSPMessage, carg2 *C.GstRTSPMessage) (cret C.GstRTSPResult) { + panic("unimplemented") +} + +//export _gotk4_gstrtsp1_RTSPExtension_setup_media +func _gotk4_gstrtsp1_RTSPExtension_setup_media(carg0 *C.GstRTSPExtension, carg1 *C.GstSDPMedia) (cret C.GstRTSPResult) { + panic("unimplemented") +} + +//export _gotk4_gstrtsp1_RTSPExtension_stream_select +func _gotk4_gstrtsp1_RTSPExtension_stream_select(carg0 *C.GstRTSPExtension, carg1 *C.GstRTSPUrl) (cret C.GstRTSPResult) { + panic("unimplemented") +} + diff --git a/pkg/gstsdp/gstsdp.gen.go b/pkg/gstsdp/gstsdp.gen.go index fd8d7d0..24d4f99 100644 --- a/pkg/gstsdp/gstsdp.gen.go +++ b/pkg/gstsdp/gstsdp.gen.go @@ -617,7 +617,7 @@ func UnsafeMIKEYDecryptInfoFromGlibBorrow(p unsafe.Pointer) *MIKEYDecryptInfo { return &MIKEYDecryptInfo{&mikeyDecryptInfo{(*C.GstMIKEYDecryptInfo)(p)}} } -// UnsafeMIKEYDecryptInfoFromGlibNone is used to convert raw C.GstMIKEYDecryptInfo pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeMIKEYDecryptInfoFromGlibNone is used to convert raw C.GstMIKEYDecryptInfo pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeMIKEYDecryptInfoFromGlibNone(p unsafe.Pointer) *MIKEYDecryptInfo { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeMIKEYDecryptInfoFromGlibBorrow(p) @@ -630,7 +630,7 @@ func UnsafeMIKEYDecryptInfoFromGlibNone(p unsafe.Pointer) *MIKEYDecryptInfo { return wrapped } -// UnsafeMIKEYDecryptInfoFromGlibFull is used to convert raw C.GstMIKEYDecryptInfo pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeMIKEYDecryptInfoFromGlibFull is used to convert raw C.GstMIKEYDecryptInfo pointers to go while taking ownership. This is used by the bindings internally. func UnsafeMIKEYDecryptInfoFromGlibFull(p unsafe.Pointer) *MIKEYDecryptInfo { wrapped := UnsafeMIKEYDecryptInfoFromGlibBorrow(p) runtime.SetFinalizer( @@ -662,6 +662,7 @@ func UnsafeMIKEYDecryptInfoToGlibFull(m *MIKEYDecryptInfo) unsafe.Pointer { m.native = nil // MIKEYDecryptInfo is invalid from here on return _p } + // MIKEYEncryptInfo wraps GstMIKEYEncryptInfo type MIKEYEncryptInfo struct { *mikeyEncryptInfo @@ -677,7 +678,7 @@ func UnsafeMIKEYEncryptInfoFromGlibBorrow(p unsafe.Pointer) *MIKEYEncryptInfo { return &MIKEYEncryptInfo{&mikeyEncryptInfo{(*C.GstMIKEYEncryptInfo)(p)}} } -// UnsafeMIKEYEncryptInfoFromGlibNone is used to convert raw C.GstMIKEYEncryptInfo pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeMIKEYEncryptInfoFromGlibNone is used to convert raw C.GstMIKEYEncryptInfo pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeMIKEYEncryptInfoFromGlibNone(p unsafe.Pointer) *MIKEYEncryptInfo { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeMIKEYEncryptInfoFromGlibBorrow(p) @@ -690,7 +691,7 @@ func UnsafeMIKEYEncryptInfoFromGlibNone(p unsafe.Pointer) *MIKEYEncryptInfo { return wrapped } -// UnsafeMIKEYEncryptInfoFromGlibFull is used to convert raw C.GstMIKEYEncryptInfo pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeMIKEYEncryptInfoFromGlibFull is used to convert raw C.GstMIKEYEncryptInfo pointers to go while taking ownership. This is used by the bindings internally. func UnsafeMIKEYEncryptInfoFromGlibFull(p unsafe.Pointer) *MIKEYEncryptInfo { wrapped := UnsafeMIKEYEncryptInfoFromGlibBorrow(p) runtime.SetFinalizer( @@ -722,6 +723,7 @@ func UnsafeMIKEYEncryptInfoToGlibFull(m *MIKEYEncryptInfo) unsafe.Pointer { m.native = nil // MIKEYEncryptInfo is invalid from here on return _p } + // MIKEYMapSRTP wraps GstMIKEYMapSRTP // // The Security policy Map item for SRTP @@ -739,7 +741,7 @@ func UnsafeMIKEYMapSRTPFromGlibBorrow(p unsafe.Pointer) *MIKEYMapSRTP { return &MIKEYMapSRTP{&mikeyMapSRTP{(*C.GstMIKEYMapSRTP)(p)}} } -// UnsafeMIKEYMapSRTPFromGlibNone is used to convert raw C.GstMIKEYMapSRTP pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeMIKEYMapSRTPFromGlibNone is used to convert raw C.GstMIKEYMapSRTP pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeMIKEYMapSRTPFromGlibNone(p unsafe.Pointer) *MIKEYMapSRTP { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeMIKEYMapSRTPFromGlibBorrow(p) @@ -752,7 +754,7 @@ func UnsafeMIKEYMapSRTPFromGlibNone(p unsafe.Pointer) *MIKEYMapSRTP { return wrapped } -// UnsafeMIKEYMapSRTPFromGlibFull is used to convert raw C.GstMIKEYMapSRTP pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeMIKEYMapSRTPFromGlibFull is used to convert raw C.GstMIKEYMapSRTP pointers to go while taking ownership. This is used by the bindings internally. func UnsafeMIKEYMapSRTPFromGlibFull(p unsafe.Pointer) *MIKEYMapSRTP { wrapped := UnsafeMIKEYMapSRTPFromGlibBorrow(p) runtime.SetFinalizer( @@ -784,6 +786,7 @@ func UnsafeMIKEYMapSRTPToGlibFull(m *MIKEYMapSRTP) unsafe.Pointer { m.native = nil // MIKEYMapSRTP is invalid from here on return _p } + // MIKEYMessage wraps GstMIKEYMessage // // Structure holding the information of the MIKEY message @@ -813,7 +816,7 @@ func UnsafeMIKEYMessageFromGlibBorrow(p unsafe.Pointer) *MIKEYMessage { return &MIKEYMessage{&mikeyMessage{(*C.GstMIKEYMessage)(p)}} } -// UnsafeMIKEYMessageFromGlibNone is used to convert raw C.GstMIKEYMessage pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeMIKEYMessageFromGlibNone is used to convert raw C.GstMIKEYMessage pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeMIKEYMessageFromGlibNone(p unsafe.Pointer) *MIKEYMessage { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeMIKEYMessageFromGlibBorrow(p) @@ -826,7 +829,7 @@ func UnsafeMIKEYMessageFromGlibNone(p unsafe.Pointer) *MIKEYMessage { return wrapped } -// UnsafeMIKEYMessageFromGlibFull is used to convert raw C.GstMIKEYMessage pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeMIKEYMessageFromGlibFull is used to convert raw C.GstMIKEYMessage pointers to go while taking ownership. This is used by the bindings internally. func UnsafeMIKEYMessageFromGlibFull(p unsafe.Pointer) *MIKEYMessage { wrapped := UnsafeMIKEYMessageFromGlibBorrow(p) runtime.SetFinalizer( @@ -858,7 +861,9 @@ func UnsafeMIKEYMessageToGlibFull(m *MIKEYMessage) unsafe.Pointer { m.native = nil // MIKEYMessage is invalid from here on return _p } + // NewMIKEYMessage wraps gst_mikey_message_new +// // The function returns the following values: // // - goret *MIKEYMessage @@ -1126,6 +1131,7 @@ func (msg *MIKEYMessage) AddRandLen(len uint8) bool { } // AddTNowNtpUTC wraps gst_mikey_message_add_t_now_ntp_utc +// // The function returns the following values: // // - goret bool @@ -1151,6 +1157,7 @@ func (msg *MIKEYMessage) AddTNowNtpUTC() bool { } // Base64Encode wraps gst_mikey_message_base64_encode +// // The function returns the following values: // // - goret string @@ -1240,6 +1247,7 @@ func (msg *MIKEYMessage) GetCsSrtp(idx uint) *MIKEYMapSRTP { } // GetNCs wraps gst_mikey_message_get_n_cs +// // The function returns the following values: // // - goret uint @@ -1262,6 +1270,7 @@ func (msg *MIKEYMessage) GetNCs() uint { } // GetNPayloads wraps gst_mikey_message_get_n_payloads +// // The function returns the following values: // // - goret uint @@ -1675,7 +1684,7 @@ func UnsafeMIKEYPayloadFromGlibBorrow(p unsafe.Pointer) *MIKEYPayload { return &MIKEYPayload{&mikeyPayload{(*C.GstMIKEYPayload)(p)}} } -// UnsafeMIKEYPayloadFromGlibNone is used to convert raw C.GstMIKEYPayload pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeMIKEYPayloadFromGlibNone is used to convert raw C.GstMIKEYPayload pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeMIKEYPayloadFromGlibNone(p unsafe.Pointer) *MIKEYPayload { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeMIKEYPayloadFromGlibBorrow(p) @@ -1688,7 +1697,7 @@ func UnsafeMIKEYPayloadFromGlibNone(p unsafe.Pointer) *MIKEYPayload { return wrapped } -// UnsafeMIKEYPayloadFromGlibFull is used to convert raw C.GstMIKEYPayload pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeMIKEYPayloadFromGlibFull is used to convert raw C.GstMIKEYPayload pointers to go while taking ownership. This is used by the bindings internally. func UnsafeMIKEYPayloadFromGlibFull(p unsafe.Pointer) *MIKEYPayload { wrapped := UnsafeMIKEYPayloadFromGlibBorrow(p) runtime.SetFinalizer( @@ -1720,6 +1729,7 @@ func UnsafeMIKEYPayloadToGlibFull(m *MIKEYPayload) unsafe.Pointer { m.native = nil // MIKEYPayload is invalid from here on return _p } + // NewMIKEYPayload wraps gst_mikey_payload_new // // The function takes the following parameters: @@ -1782,6 +1792,7 @@ func (payload *MIKEYPayload) KemacAddSub(newpay *MIKEYPayload) bool { } // KemacGetNSub wraps gst_mikey_payload_kemac_get_n_sub +// // The function returns the following values: // // - goret uint @@ -2183,6 +2194,7 @@ func (payload *MIKEYPayload) SpAddParam(typ uint8, val []uint8) bool { } // SpGetNParams wraps gst_mikey_payload_sp_get_n_params +// // The function returns the following values: // // - goret uint @@ -2324,7 +2336,7 @@ func UnsafeMIKEYPayloadKEMACFromGlibBorrow(p unsafe.Pointer) *MIKEYPayloadKEMAC return &MIKEYPayloadKEMAC{&mikeyPayloadKEMAC{(*C.GstMIKEYPayloadKEMAC)(p)}} } -// UnsafeMIKEYPayloadKEMACFromGlibNone is used to convert raw C.GstMIKEYPayloadKEMAC pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeMIKEYPayloadKEMACFromGlibNone is used to convert raw C.GstMIKEYPayloadKEMAC pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeMIKEYPayloadKEMACFromGlibNone(p unsafe.Pointer) *MIKEYPayloadKEMAC { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeMIKEYPayloadKEMACFromGlibBorrow(p) @@ -2337,7 +2349,7 @@ func UnsafeMIKEYPayloadKEMACFromGlibNone(p unsafe.Pointer) *MIKEYPayloadKEMAC { return wrapped } -// UnsafeMIKEYPayloadKEMACFromGlibFull is used to convert raw C.GstMIKEYPayloadKEMAC pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeMIKEYPayloadKEMACFromGlibFull is used to convert raw C.GstMIKEYPayloadKEMAC pointers to go while taking ownership. This is used by the bindings internally. func UnsafeMIKEYPayloadKEMACFromGlibFull(p unsafe.Pointer) *MIKEYPayloadKEMAC { wrapped := UnsafeMIKEYPayloadKEMACFromGlibBorrow(p) runtime.SetFinalizer( @@ -2369,6 +2381,7 @@ func UnsafeMIKEYPayloadKEMACToGlibFull(m *MIKEYPayloadKEMAC) unsafe.Pointer { m.native = nil // MIKEYPayloadKEMAC is invalid from here on return _p } + // MIKEYPayloadKeyData wraps GstMIKEYPayloadKeyData // // The Key data payload contains key material. It should be added as sub @@ -2387,7 +2400,7 @@ func UnsafeMIKEYPayloadKeyDataFromGlibBorrow(p unsafe.Pointer) *MIKEYPayloadKeyD return &MIKEYPayloadKeyData{&mikeyPayloadKeyData{(*C.GstMIKEYPayloadKeyData)(p)}} } -// UnsafeMIKEYPayloadKeyDataFromGlibNone is used to convert raw C.GstMIKEYPayloadKeyData pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeMIKEYPayloadKeyDataFromGlibNone is used to convert raw C.GstMIKEYPayloadKeyData pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeMIKEYPayloadKeyDataFromGlibNone(p unsafe.Pointer) *MIKEYPayloadKeyData { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeMIKEYPayloadKeyDataFromGlibBorrow(p) @@ -2400,7 +2413,7 @@ func UnsafeMIKEYPayloadKeyDataFromGlibNone(p unsafe.Pointer) *MIKEYPayloadKeyDat return wrapped } -// UnsafeMIKEYPayloadKeyDataFromGlibFull is used to convert raw C.GstMIKEYPayloadKeyData pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeMIKEYPayloadKeyDataFromGlibFull is used to convert raw C.GstMIKEYPayloadKeyData pointers to go while taking ownership. This is used by the bindings internally. func UnsafeMIKEYPayloadKeyDataFromGlibFull(p unsafe.Pointer) *MIKEYPayloadKeyData { wrapped := UnsafeMIKEYPayloadKeyDataFromGlibBorrow(p) runtime.SetFinalizer( @@ -2432,6 +2445,7 @@ func UnsafeMIKEYPayloadKeyDataToGlibFull(m *MIKEYPayloadKeyData) unsafe.Pointer m.native = nil // MIKEYPayloadKeyData is invalid from here on return _p } + // MIKEYPayloadPKE wraps GstMIKEYPayloadPKE // // The Envelope data payload contains the encrypted envelope key that is @@ -2452,7 +2466,7 @@ func UnsafeMIKEYPayloadPKEFromGlibBorrow(p unsafe.Pointer) *MIKEYPayloadPKE { return &MIKEYPayloadPKE{&mikeyPayloadPKE{(*C.GstMIKEYPayloadPKE)(p)}} } -// UnsafeMIKEYPayloadPKEFromGlibNone is used to convert raw C.GstMIKEYPayloadPKE pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeMIKEYPayloadPKEFromGlibNone is used to convert raw C.GstMIKEYPayloadPKE pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeMIKEYPayloadPKEFromGlibNone(p unsafe.Pointer) *MIKEYPayloadPKE { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeMIKEYPayloadPKEFromGlibBorrow(p) @@ -2465,7 +2479,7 @@ func UnsafeMIKEYPayloadPKEFromGlibNone(p unsafe.Pointer) *MIKEYPayloadPKE { return wrapped } -// UnsafeMIKEYPayloadPKEFromGlibFull is used to convert raw C.GstMIKEYPayloadPKE pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeMIKEYPayloadPKEFromGlibFull is used to convert raw C.GstMIKEYPayloadPKE pointers to go while taking ownership. This is used by the bindings internally. func UnsafeMIKEYPayloadPKEFromGlibFull(p unsafe.Pointer) *MIKEYPayloadPKE { wrapped := UnsafeMIKEYPayloadPKEFromGlibBorrow(p) runtime.SetFinalizer( @@ -2497,6 +2511,7 @@ func UnsafeMIKEYPayloadPKEToGlibFull(m *MIKEYPayloadPKE) unsafe.Pointer { m.native = nil // MIKEYPayloadPKE is invalid from here on return _p } + // MIKEYPayloadRAND wraps GstMIKEYPayloadRAND // // The RAND payload consists of a (pseudo-)random bit-string @@ -2514,7 +2529,7 @@ func UnsafeMIKEYPayloadRANDFromGlibBorrow(p unsafe.Pointer) *MIKEYPayloadRAND { return &MIKEYPayloadRAND{&mikeyPayloadRAND{(*C.GstMIKEYPayloadRAND)(p)}} } -// UnsafeMIKEYPayloadRANDFromGlibNone is used to convert raw C.GstMIKEYPayloadRAND pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeMIKEYPayloadRANDFromGlibNone is used to convert raw C.GstMIKEYPayloadRAND pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeMIKEYPayloadRANDFromGlibNone(p unsafe.Pointer) *MIKEYPayloadRAND { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeMIKEYPayloadRANDFromGlibBorrow(p) @@ -2527,7 +2542,7 @@ func UnsafeMIKEYPayloadRANDFromGlibNone(p unsafe.Pointer) *MIKEYPayloadRAND { return wrapped } -// UnsafeMIKEYPayloadRANDFromGlibFull is used to convert raw C.GstMIKEYPayloadRAND pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeMIKEYPayloadRANDFromGlibFull is used to convert raw C.GstMIKEYPayloadRAND pointers to go while taking ownership. This is used by the bindings internally. func UnsafeMIKEYPayloadRANDFromGlibFull(p unsafe.Pointer) *MIKEYPayloadRAND { wrapped := UnsafeMIKEYPayloadRANDFromGlibBorrow(p) runtime.SetFinalizer( @@ -2559,6 +2574,7 @@ func UnsafeMIKEYPayloadRANDToGlibFull(m *MIKEYPayloadRAND) unsafe.Pointer { m.native = nil // MIKEYPayloadRAND is invalid from here on return _p } + // MIKEYPayloadSP wraps GstMIKEYPayloadSP // // The Security Policy payload defines a set of policies that apply to a @@ -2577,7 +2593,7 @@ func UnsafeMIKEYPayloadSPFromGlibBorrow(p unsafe.Pointer) *MIKEYPayloadSP { return &MIKEYPayloadSP{&mikeyPayloadSP{(*C.GstMIKEYPayloadSP)(p)}} } -// UnsafeMIKEYPayloadSPFromGlibNone is used to convert raw C.GstMIKEYPayloadSP pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeMIKEYPayloadSPFromGlibNone is used to convert raw C.GstMIKEYPayloadSP pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeMIKEYPayloadSPFromGlibNone(p unsafe.Pointer) *MIKEYPayloadSP { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeMIKEYPayloadSPFromGlibBorrow(p) @@ -2590,7 +2606,7 @@ func UnsafeMIKEYPayloadSPFromGlibNone(p unsafe.Pointer) *MIKEYPayloadSP { return wrapped } -// UnsafeMIKEYPayloadSPFromGlibFull is used to convert raw C.GstMIKEYPayloadSP pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeMIKEYPayloadSPFromGlibFull is used to convert raw C.GstMIKEYPayloadSP pointers to go while taking ownership. This is used by the bindings internally. func UnsafeMIKEYPayloadSPFromGlibFull(p unsafe.Pointer) *MIKEYPayloadSP { wrapped := UnsafeMIKEYPayloadSPFromGlibBorrow(p) runtime.SetFinalizer( @@ -2622,6 +2638,7 @@ func UnsafeMIKEYPayloadSPToGlibFull(m *MIKEYPayloadSP) unsafe.Pointer { m.native = nil // MIKEYPayloadSP is invalid from here on return _p } + // MIKEYPayloadSPParam wraps GstMIKEYPayloadSPParam // // A Type/Length/Value field for security parameters @@ -2639,7 +2656,7 @@ func UnsafeMIKEYPayloadSPParamFromGlibBorrow(p unsafe.Pointer) *MIKEYPayloadSPPa return &MIKEYPayloadSPParam{&mikeyPayloadSPParam{(*C.GstMIKEYPayloadSPParam)(p)}} } -// UnsafeMIKEYPayloadSPParamFromGlibNone is used to convert raw C.GstMIKEYPayloadSPParam pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeMIKEYPayloadSPParamFromGlibNone is used to convert raw C.GstMIKEYPayloadSPParam pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeMIKEYPayloadSPParamFromGlibNone(p unsafe.Pointer) *MIKEYPayloadSPParam { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeMIKEYPayloadSPParamFromGlibBorrow(p) @@ -2652,7 +2669,7 @@ func UnsafeMIKEYPayloadSPParamFromGlibNone(p unsafe.Pointer) *MIKEYPayloadSPPara return wrapped } -// UnsafeMIKEYPayloadSPParamFromGlibFull is used to convert raw C.GstMIKEYPayloadSPParam pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeMIKEYPayloadSPParamFromGlibFull is used to convert raw C.GstMIKEYPayloadSPParam pointers to go while taking ownership. This is used by the bindings internally. func UnsafeMIKEYPayloadSPParamFromGlibFull(p unsafe.Pointer) *MIKEYPayloadSPParam { wrapped := UnsafeMIKEYPayloadSPParamFromGlibBorrow(p) runtime.SetFinalizer( @@ -2684,6 +2701,7 @@ func UnsafeMIKEYPayloadSPParamToGlibFull(m *MIKEYPayloadSPParam) unsafe.Pointer m.native = nil // MIKEYPayloadSPParam is invalid from here on return _p } + // MIKEYPayloadT wraps GstMIKEYPayloadT // // The timestamp payload carries the timestamp information @@ -2701,7 +2719,7 @@ func UnsafeMIKEYPayloadTFromGlibBorrow(p unsafe.Pointer) *MIKEYPayloadT { return &MIKEYPayloadT{&mikeyPayloadT{(*C.GstMIKEYPayloadT)(p)}} } -// UnsafeMIKEYPayloadTFromGlibNone is used to convert raw C.GstMIKEYPayloadT pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeMIKEYPayloadTFromGlibNone is used to convert raw C.GstMIKEYPayloadT pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeMIKEYPayloadTFromGlibNone(p unsafe.Pointer) *MIKEYPayloadT { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeMIKEYPayloadTFromGlibBorrow(p) @@ -2714,7 +2732,7 @@ func UnsafeMIKEYPayloadTFromGlibNone(p unsafe.Pointer) *MIKEYPayloadT { return wrapped } -// UnsafeMIKEYPayloadTFromGlibFull is used to convert raw C.GstMIKEYPayloadT pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeMIKEYPayloadTFromGlibFull is used to convert raw C.GstMIKEYPayloadT pointers to go while taking ownership. This is used by the bindings internally. func UnsafeMIKEYPayloadTFromGlibFull(p unsafe.Pointer) *MIKEYPayloadT { wrapped := UnsafeMIKEYPayloadTFromGlibBorrow(p) runtime.SetFinalizer( @@ -2746,6 +2764,7 @@ func UnsafeMIKEYPayloadTToGlibFull(m *MIKEYPayloadT) unsafe.Pointer { m.native = nil // MIKEYPayloadT is invalid from here on return _p } + // SDPAttribute wraps GstSDPAttribute // // The contents of the SDP "a=" field which contains a key/value pair. @@ -2763,7 +2782,7 @@ func UnsafeSDPAttributeFromGlibBorrow(p unsafe.Pointer) *SDPAttribute { return &SDPAttribute{&sdpAttribute{(*C.GstSDPAttribute)(p)}} } -// UnsafeSDPAttributeFromGlibNone is used to convert raw C.GstSDPAttribute pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeSDPAttributeFromGlibNone is used to convert raw C.GstSDPAttribute pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeSDPAttributeFromGlibNone(p unsafe.Pointer) *SDPAttribute { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeSDPAttributeFromGlibBorrow(p) @@ -2776,7 +2795,7 @@ func UnsafeSDPAttributeFromGlibNone(p unsafe.Pointer) *SDPAttribute { return wrapped } -// UnsafeSDPAttributeFromGlibFull is used to convert raw C.GstSDPAttribute pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeSDPAttributeFromGlibFull is used to convert raw C.GstSDPAttribute pointers to go while taking ownership. This is used by the bindings internally. func UnsafeSDPAttributeFromGlibFull(p unsafe.Pointer) *SDPAttribute { wrapped := UnsafeSDPAttributeFromGlibBorrow(p) runtime.SetFinalizer( @@ -2808,7 +2827,9 @@ func UnsafeSDPAttributeToGlibFull(s *SDPAttribute) unsafe.Pointer { s.native = nil // SDPAttribute is invalid from here on return _p } + // Clear wraps gst_sdp_attribute_clear +// // The function returns the following values: // // - goret SDPResult @@ -2886,7 +2907,7 @@ func UnsafeSDPBandwidthFromGlibBorrow(p unsafe.Pointer) *SDPBandwidth { return &SDPBandwidth{&sdpBandwidth{(*C.GstSDPBandwidth)(p)}} } -// UnsafeSDPBandwidthFromGlibNone is used to convert raw C.GstSDPBandwidth pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeSDPBandwidthFromGlibNone is used to convert raw C.GstSDPBandwidth pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeSDPBandwidthFromGlibNone(p unsafe.Pointer) *SDPBandwidth { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeSDPBandwidthFromGlibBorrow(p) @@ -2899,7 +2920,7 @@ func UnsafeSDPBandwidthFromGlibNone(p unsafe.Pointer) *SDPBandwidth { return wrapped } -// UnsafeSDPBandwidthFromGlibFull is used to convert raw C.GstSDPBandwidth pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeSDPBandwidthFromGlibFull is used to convert raw C.GstSDPBandwidth pointers to go while taking ownership. This is used by the bindings internally. func UnsafeSDPBandwidthFromGlibFull(p unsafe.Pointer) *SDPBandwidth { wrapped := UnsafeSDPBandwidthFromGlibBorrow(p) runtime.SetFinalizer( @@ -2931,7 +2952,9 @@ func UnsafeSDPBandwidthToGlibFull(s *SDPBandwidth) unsafe.Pointer { s.native = nil // SDPBandwidth is invalid from here on return _p } + // Clear wraps gst_sdp_bandwidth_clear +// // The function returns the following values: // // - goret SDPResult @@ -3005,7 +3028,7 @@ func UnsafeSDPConnectionFromGlibBorrow(p unsafe.Pointer) *SDPConnection { return &SDPConnection{&sdpConnection{(*C.GstSDPConnection)(p)}} } -// UnsafeSDPConnectionFromGlibNone is used to convert raw C.GstSDPConnection pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeSDPConnectionFromGlibNone is used to convert raw C.GstSDPConnection pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeSDPConnectionFromGlibNone(p unsafe.Pointer) *SDPConnection { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeSDPConnectionFromGlibBorrow(p) @@ -3018,7 +3041,7 @@ func UnsafeSDPConnectionFromGlibNone(p unsafe.Pointer) *SDPConnection { return wrapped } -// UnsafeSDPConnectionFromGlibFull is used to convert raw C.GstSDPConnection pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeSDPConnectionFromGlibFull is used to convert raw C.GstSDPConnection pointers to go while taking ownership. This is used by the bindings internally. func UnsafeSDPConnectionFromGlibFull(p unsafe.Pointer) *SDPConnection { wrapped := UnsafeSDPConnectionFromGlibBorrow(p) runtime.SetFinalizer( @@ -3050,7 +3073,9 @@ func UnsafeSDPConnectionToGlibFull(s *SDPConnection) unsafe.Pointer { s.native = nil // SDPConnection is invalid from here on return _p } + // Clear wraps gst_sdp_connection_clear +// // The function returns the following values: // // - goret SDPResult @@ -3140,7 +3165,7 @@ func UnsafeSDPKeyFromGlibBorrow(p unsafe.Pointer) *SDPKey { return &SDPKey{&sdpKey{(*C.GstSDPKey)(p)}} } -// UnsafeSDPKeyFromGlibNone is used to convert raw C.GstSDPKey pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeSDPKeyFromGlibNone is used to convert raw C.GstSDPKey pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeSDPKeyFromGlibNone(p unsafe.Pointer) *SDPKey { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeSDPKeyFromGlibBorrow(p) @@ -3153,7 +3178,7 @@ func UnsafeSDPKeyFromGlibNone(p unsafe.Pointer) *SDPKey { return wrapped } -// UnsafeSDPKeyFromGlibFull is used to convert raw C.GstSDPKey pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeSDPKeyFromGlibFull is used to convert raw C.GstSDPKey pointers to go while taking ownership. This is used by the bindings internally. func UnsafeSDPKeyFromGlibFull(p unsafe.Pointer) *SDPKey { wrapped := UnsafeSDPKeyFromGlibBorrow(p) runtime.SetFinalizer( @@ -3185,6 +3210,7 @@ func UnsafeSDPKeyToGlibFull(s *SDPKey) unsafe.Pointer { s.native = nil // SDPKey is invalid from here on return _p } + // SDPMedia wraps GstSDPMedia // // The contents of the SDP "m=" field with all related fields. @@ -3202,7 +3228,7 @@ func UnsafeSDPMediaFromGlibBorrow(p unsafe.Pointer) *SDPMedia { return &SDPMedia{&sdpMedia{(*C.GstSDPMedia)(p)}} } -// UnsafeSDPMediaFromGlibNone is used to convert raw C.GstSDPMedia pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeSDPMediaFromGlibNone is used to convert raw C.GstSDPMedia pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeSDPMediaFromGlibNone(p unsafe.Pointer) *SDPMedia { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeSDPMediaFromGlibBorrow(p) @@ -3215,7 +3241,7 @@ func UnsafeSDPMediaFromGlibNone(p unsafe.Pointer) *SDPMedia { return wrapped } -// UnsafeSDPMediaFromGlibFull is used to convert raw C.GstSDPMedia pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeSDPMediaFromGlibFull is used to convert raw C.GstSDPMedia pointers to go while taking ownership. This is used by the bindings internally. func UnsafeSDPMediaFromGlibFull(p unsafe.Pointer) *SDPMedia { wrapped := UnsafeSDPMediaFromGlibBorrow(p) runtime.SetFinalizer( @@ -3247,7 +3273,9 @@ func UnsafeSDPMediaToGlibFull(s *SDPMedia) unsafe.Pointer { s.native = nil // SDPMedia is invalid from here on return _p } + // SDPMediaInit wraps gst_sdp_media_init +// // The function returns the following values: // // - media SDPMedia: a #GstSDPMedia @@ -3277,6 +3305,7 @@ func SDPMediaInit() (SDPMedia, SDPResult) { } // NewSDPMedia wraps gst_sdp_media_new +// // The function returns the following values: // // - media *SDPMedia: pointer to new #GstSDPMedia @@ -3496,6 +3525,7 @@ func (media *SDPMedia) AddFormat(format string) SDPResult { } // AsText wraps gst_sdp_media_as_text +// // The function returns the following values: // // - goret string @@ -3519,6 +3549,7 @@ func (media *SDPMedia) AsText() string { } // AttributesLen wraps gst_sdp_media_attributes_len +// // The function returns the following values: // // - goret uint @@ -3571,6 +3602,7 @@ func (media *SDPMedia) AttributesToCaps(caps *gst.Caps) SDPResult { } // BandwidthsLen wraps gst_sdp_media_bandwidths_len +// // The function returns the following values: // // - goret uint @@ -3593,6 +3625,7 @@ func (media *SDPMedia) BandwidthsLen() uint { } // ConnectionsLen wraps gst_sdp_media_connections_len +// // The function returns the following values: // // - goret uint @@ -3615,6 +3648,7 @@ func (media *SDPMedia) ConnectionsLen() uint { } // Copy wraps gst_sdp_media_copy +// // The function returns the following values: // // - copy *SDPMedia: pointer to new #GstSDPMedia @@ -3642,6 +3676,7 @@ func (media *SDPMedia) Copy() (*SDPMedia, SDPResult) { } // FormatsLen wraps gst_sdp_media_formats_len +// // The function returns the following values: // // - goret uint @@ -3894,6 +3929,7 @@ func (media *SDPMedia) GetFormat(idx uint) string { } // GetInformation wraps gst_sdp_media_get_information +// // The function returns the following values: // // - goret string @@ -3916,6 +3952,7 @@ func (media *SDPMedia) GetInformation() string { } // GetKey wraps gst_sdp_media_get_key +// // The function returns the following values: // // - goret *SDPKey @@ -3938,6 +3975,7 @@ func (media *SDPMedia) GetKey() *SDPKey { } // GetMedia wraps gst_sdp_media_get_media +// // The function returns the following values: // // - goret string @@ -3960,6 +3998,7 @@ func (media *SDPMedia) GetMedia() string { } // GetNumPorts wraps gst_sdp_media_get_num_ports +// // The function returns the following values: // // - goret uint @@ -3982,6 +4021,7 @@ func (media *SDPMedia) GetNumPorts() uint { } // GetPort wraps gst_sdp_media_get_port +// // The function returns the following values: // // - goret uint @@ -4004,6 +4044,7 @@ func (media *SDPMedia) GetPort() uint { } // GetProto wraps gst_sdp_media_get_proto +// // The function returns the following values: // // - goret string @@ -4167,6 +4208,7 @@ func (media *SDPMedia) InsertFormat(idx int, format string) SDPResult { } // ParseKeymgmt wraps gst_sdp_media_parse_keymgmt +// // The function returns the following values: // // - mikey *MIKEYMessage: pointer to new #GstMIKEYMessage @@ -4614,6 +4656,7 @@ func (media *SDPMedia) SetProto(proto string) SDPResult { } // Uninit wraps gst_sdp_media_uninit +// // The function returns the following values: // // - goret SDPResult @@ -4667,7 +4710,7 @@ func UnsafeSDPMessageFromGlibBorrow(p unsafe.Pointer) *SDPMessage { return &SDPMessage{&sdpMessage{(*C.GstSDPMessage)(p)}} } -// UnsafeSDPMessageFromGlibNone is used to convert raw C.GstSDPMessage pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeSDPMessageFromGlibNone is used to convert raw C.GstSDPMessage pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeSDPMessageFromGlibNone(p unsafe.Pointer) *SDPMessage { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeSDPMessageFromGlibBorrow(p) @@ -4680,7 +4723,7 @@ func UnsafeSDPMessageFromGlibNone(p unsafe.Pointer) *SDPMessage { return wrapped } -// UnsafeSDPMessageFromGlibFull is used to convert raw C.GstSDPMessage pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeSDPMessageFromGlibFull is used to convert raw C.GstSDPMessage pointers to go while taking ownership. This is used by the bindings internally. func UnsafeSDPMessageFromGlibFull(p unsafe.Pointer) *SDPMessage { wrapped := UnsafeSDPMessageFromGlibBorrow(p) runtime.SetFinalizer( @@ -4712,6 +4755,7 @@ func UnsafeSDPMessageToGlibFull(s *SDPMessage) unsafe.Pointer { s.native = nil // SDPMessage is invalid from here on return _p } + // SDPMessageAsURI wraps gst_sdp_message_as_uri // // The function takes the following parameters: @@ -4750,6 +4794,7 @@ func SDPMessageAsURI(scheme string, msg *SDPMessage) string { } // SDPMessageInit wraps gst_sdp_message_init +// // The function returns the following values: // // - msg SDPMessage: a #GstSDPMessage @@ -4779,6 +4824,7 @@ func SDPMessageInit() (SDPMessage, SDPResult) { } // NewSDPMessage wraps gst_sdp_message_new +// // The function returns the following values: // // - msg *SDPMessage: pointer to new #GstSDPMessage @@ -5154,6 +5200,7 @@ func (msg *SDPMessage) AddZone(adjTime string, typedTime string) SDPResult { } // AsText wraps gst_sdp_message_as_text +// // The function returns the following values: // // - goret string @@ -5177,6 +5224,7 @@ func (msg *SDPMessage) AsText() string { } // AttributesLen wraps gst_sdp_message_attributes_len +// // The function returns the following values: // // - goret uint @@ -5229,6 +5277,7 @@ func (msg *SDPMessage) AttributesToCaps(caps *gst.Caps) SDPResult { } // BandwidthsLen wraps gst_sdp_message_bandwidths_len +// // The function returns the following values: // // - goret uint @@ -5251,6 +5300,7 @@ func (msg *SDPMessage) BandwidthsLen() uint { } // Copy wraps gst_sdp_message_copy +// // The function returns the following values: // // - copy *SDPMessage: pointer to new #GstSDPMessage @@ -5278,6 +5328,7 @@ func (msg *SDPMessage) Copy() (*SDPMessage, SDPResult) { } // Dump wraps gst_sdp_message_dump +// // The function returns the following values: // // - goret SDPResult @@ -5300,6 +5351,7 @@ func (msg *SDPMessage) Dump() SDPResult { } // EmailsLen wraps gst_sdp_message_emails_len +// // The function returns the following values: // // - goret uint @@ -5452,6 +5504,7 @@ func (msg *SDPMessage) GetBandwidth(idx uint) *SDPBandwidth { } // GetConnection wraps gst_sdp_message_get_connection +// // The function returns the following values: // // - goret *SDPConnection @@ -5504,6 +5557,7 @@ func (msg *SDPMessage) GetEmail(idx uint) string { } // GetInformation wraps gst_sdp_message_get_information +// // The function returns the following values: // // - goret string @@ -5526,6 +5580,7 @@ func (msg *SDPMessage) GetInformation() string { } // GetKey wraps gst_sdp_message_get_key +// // The function returns the following values: // // - goret *SDPKey @@ -5578,6 +5633,7 @@ func (msg *SDPMessage) GetMedia(idx uint) *SDPMedia { } // GetOrigin wraps gst_sdp_message_get_origin +// // The function returns the following values: // // - goret *SDPOrigin @@ -5630,6 +5686,7 @@ func (msg *SDPMessage) GetPhone(idx uint) string { } // GetSessionName wraps gst_sdp_message_get_session_name +// // The function returns the following values: // // - goret string @@ -5682,6 +5739,7 @@ func (msg *SDPMessage) GetTime(idx uint) *SDPTime { } // GetURI wraps gst_sdp_message_get_uri +// // The function returns the following values: // // - goret string @@ -5704,6 +5762,7 @@ func (msg *SDPMessage) GetURI() string { } // GetVersion wraps gst_sdp_message_get_version +// // The function returns the following values: // // - goret string @@ -5972,6 +6031,7 @@ func (msg *SDPMessage) InsertZone(idx int, zone *SDPZone) SDPResult { } // MediasLen wraps gst_sdp_message_medias_len +// // The function returns the following values: // // - goret uint @@ -5994,6 +6054,7 @@ func (msg *SDPMessage) MediasLen() uint { } // ParseKeymgmt wraps gst_sdp_message_parse_keymgmt +// // The function returns the following values: // // - mikey *MIKEYMessage: pointer to new #GstMIKEYMessage @@ -6021,6 +6082,7 @@ func (msg *SDPMessage) ParseKeymgmt() (*MIKEYMessage, SDPResult) { } // PhonesLen wraps gst_sdp_message_phones_len +// // The function returns the following values: // // - goret uint @@ -6725,6 +6787,7 @@ func (msg *SDPMessage) SetVersion(version string) SDPResult { } // TimesLen wraps gst_sdp_message_times_len +// // The function returns the following values: // // - goret uint @@ -6747,6 +6810,7 @@ func (msg *SDPMessage) TimesLen() uint { } // Uninit wraps gst_sdp_message_uninit +// // The function returns the following values: // // - goret SDPResult @@ -6771,6 +6835,7 @@ func (msg *SDPMessage) Uninit() SDPResult { } // ZonesLen wraps gst_sdp_message_zones_len +// // The function returns the following values: // // - goret uint @@ -6811,7 +6876,7 @@ func UnsafeSDPOriginFromGlibBorrow(p unsafe.Pointer) *SDPOrigin { return &SDPOrigin{&sdpOrigin{(*C.GstSDPOrigin)(p)}} } -// UnsafeSDPOriginFromGlibNone is used to convert raw C.GstSDPOrigin pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeSDPOriginFromGlibNone is used to convert raw C.GstSDPOrigin pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeSDPOriginFromGlibNone(p unsafe.Pointer) *SDPOrigin { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeSDPOriginFromGlibBorrow(p) @@ -6824,7 +6889,7 @@ func UnsafeSDPOriginFromGlibNone(p unsafe.Pointer) *SDPOrigin { return wrapped } -// UnsafeSDPOriginFromGlibFull is used to convert raw C.GstSDPOrigin pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeSDPOriginFromGlibFull is used to convert raw C.GstSDPOrigin pointers to go while taking ownership. This is used by the bindings internally. func UnsafeSDPOriginFromGlibFull(p unsafe.Pointer) *SDPOrigin { wrapped := UnsafeSDPOriginFromGlibBorrow(p) runtime.SetFinalizer( @@ -6856,6 +6921,7 @@ func UnsafeSDPOriginToGlibFull(s *SDPOrigin) unsafe.Pointer { s.native = nil // SDPOrigin is invalid from here on return _p } + // SDPTime wraps GstSDPTime // // The contents of the SDP "t=" field which specify the start and stop times for @@ -6874,7 +6940,7 @@ func UnsafeSDPTimeFromGlibBorrow(p unsafe.Pointer) *SDPTime { return &SDPTime{&sdpTime{(*C.GstSDPTime)(p)}} } -// UnsafeSDPTimeFromGlibNone is used to convert raw C.GstSDPTime pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeSDPTimeFromGlibNone is used to convert raw C.GstSDPTime pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeSDPTimeFromGlibNone(p unsafe.Pointer) *SDPTime { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeSDPTimeFromGlibBorrow(p) @@ -6887,7 +6953,7 @@ func UnsafeSDPTimeFromGlibNone(p unsafe.Pointer) *SDPTime { return wrapped } -// UnsafeSDPTimeFromGlibFull is used to convert raw C.GstSDPTime pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeSDPTimeFromGlibFull is used to convert raw C.GstSDPTime pointers to go while taking ownership. This is used by the bindings internally. func UnsafeSDPTimeFromGlibFull(p unsafe.Pointer) *SDPTime { wrapped := UnsafeSDPTimeFromGlibBorrow(p) runtime.SetFinalizer( @@ -6919,7 +6985,9 @@ func UnsafeSDPTimeToGlibFull(s *SDPTime) unsafe.Pointer { s.native = nil // SDPTime is invalid from here on return _p } + // Clear wraps gst_sdp_time_clear +// // The function returns the following values: // // - goret SDPResult @@ -7002,7 +7070,7 @@ func UnsafeSDPZoneFromGlibBorrow(p unsafe.Pointer) *SDPZone { return &SDPZone{&sdpZone{(*C.GstSDPZone)(p)}} } -// UnsafeSDPZoneFromGlibNone is used to convert raw C.GstSDPZone pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeSDPZoneFromGlibNone is used to convert raw C.GstSDPZone pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeSDPZoneFromGlibNone(p unsafe.Pointer) *SDPZone { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeSDPZoneFromGlibBorrow(p) @@ -7015,7 +7083,7 @@ func UnsafeSDPZoneFromGlibNone(p unsafe.Pointer) *SDPZone { return wrapped } -// UnsafeSDPZoneFromGlibFull is used to convert raw C.GstSDPZone pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeSDPZoneFromGlibFull is used to convert raw C.GstSDPZone pointers to go while taking ownership. This is used by the bindings internally. func UnsafeSDPZoneFromGlibFull(p unsafe.Pointer) *SDPZone { wrapped := UnsafeSDPZoneFromGlibBorrow(p) runtime.SetFinalizer( @@ -7047,7 +7115,9 @@ func UnsafeSDPZoneToGlibFull(s *SDPZone) unsafe.Pointer { s.native = nil // SDPZone is invalid from here on return _p } + // Clear wraps gst_sdp_zone_clear +// // The function returns the following values: // // - goret SDPResult diff --git a/pkg/gsttag/gsttag.gen.go b/pkg/gsttag/gsttag.gen.go index ce223f0..641018f 100644 --- a/pkg/gsttag/gsttag.gen.go +++ b/pkg/gsttag/gsttag.gen.go @@ -16,6 +16,22 @@ import ( // #cgo pkg-config: gstreamer-tag-1.0 // #cgo CFLAGS: -Wno-deprecated-declarations // #include +// extern gboolean _gotk4_gsttag1_TagDemux_identify_tag(GstTagDemux*, GstBuffer*, gboolean, guint*); +// extern GstTagList* _gotk4_gsttag1_TagDemux_merge_tags(GstTagDemux*, GstTagList*, GstTagList*); +// gboolean _gotk4_gsttag1_TagDemux_virtual_identify_tag(void* fnptr, GstTagDemux* carg0, GstBuffer* carg1, gboolean carg2, guint* carg3) { +// return ((gboolean (*) (GstTagDemux*, GstBuffer*, gboolean, guint*))(fnptr))(carg0, carg1, carg2, carg3); +// } +// GstTagList* _gotk4_gsttag1_TagDemux_virtual_merge_tags(void* fnptr, GstTagDemux* carg0, GstTagList* carg1, GstTagList* carg2) { +// return ((GstTagList* (*) (GstTagDemux*, GstTagList*, GstTagList*))(fnptr))(carg0, carg1, carg2); +// } +// extern GstBuffer* _gotk4_gsttag1_TagMux_render_end_tag(GstTagMux*, GstTagList*); +// extern GstBuffer* _gotk4_gsttag1_TagMux_render_start_tag(GstTagMux*, GstTagList*); +// GstBuffer* _gotk4_gsttag1_TagMux_virtual_render_end_tag(void* fnptr, GstTagMux* carg0, GstTagList* carg1) { +// return ((GstBuffer* (*) (GstTagMux*, GstTagList*))(fnptr))(carg0, carg1); +// } +// GstBuffer* _gotk4_gsttag1_TagMux_virtual_render_start_tag(void* fnptr, GstTagMux* carg0, GstTagList* carg1) { +// return ((GstBuffer* (*) (GstTagMux*, GstTagList*))(fnptr))(carg0, carg1); +// } import "C" // GType values. @@ -678,6 +694,7 @@ func TagGetLanguageCodeISO6392T(langCode string) string { } // TagGetLanguageCodes wraps gst_tag_get_language_codes +// // The function returns the following values: // // - goret []string @@ -930,6 +947,7 @@ func TagGetLicenseVersion(licenseRef string) string { } // TagGetLicenses wraps gst_tag_get_licenses +// // The function returns the following values: // // - goret []string @@ -953,6 +971,7 @@ func TagGetLicenses() []string { } // TagID3GenreCount wraps gst_tag_id3_genre_count +// // The function returns the following values: // // - goret uint @@ -1677,6 +1696,7 @@ func TagToVorbisTag(gstTag string) string { } // TagXmpListSchemas wraps gst_tag_xmp_list_schemas +// // The function returns the following values: // // - goret []string @@ -1970,6 +1990,16 @@ func (config *TagXmpWriterInstance) TagListToXmpBuffer(taglist *gst.TagList, rea return goret } +// TagXmpWriterOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type TagXmpWriterOverrides[Instance TagXmpWriter] struct { +} + +// UnsafeApplyTagXmpWriterOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyTagXmpWriterOverrides[Instance TagXmpWriter](gclass unsafe.Pointer, overrides TagXmpWriterOverrides[Instance]) { +} + // TagDemuxInstance is the instance type used by all types extending GstTagDemux. It is used internally by the bindings. Users should use the interface [TagDemux] instead. type TagDemuxInstance struct { _ [0]func() // equal guard @@ -2054,6 +2084,51 @@ func UnsafeTagDemuxToGlibFull(c TagDemux) unsafe.Pointer { return gobject.UnsafeObjectToGlibFull(c) } +// TagDemuxOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type TagDemuxOverrides[Instance TagDemux] struct { + // gst.ElementOverrides allows you to override virtual methods from the parent class gst.Element + gst.ElementOverrides[Instance] + + // IdentifyTag allows you to override the implementation of the virtual method identify_tag. + // The function takes the following parameters: + // + // - buffer *gst.Buffer + // - startTag bool + // - tagSize *uint + // + // The function returns the following values: + // + // - goret bool + IdentifyTag func(Instance, *gst.Buffer, bool, *uint) bool + // MergeTags allows you to override the implementation of the virtual method merge_tags. + // The function takes the following parameters: + // + // - startTags *gst.TagList + // - endTags *gst.TagList + // + // The function returns the following values: + // + // - goret *gst.TagList + MergeTags func(Instance, *gst.TagList, *gst.TagList) *gst.TagList +} + +// UnsafeApplyTagDemuxOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyTagDemuxOverrides[Instance TagDemux](gclass unsafe.Pointer, overrides TagDemuxOverrides[Instance]) { + gst.UnsafeApplyElementOverrides(gclass, overrides.ElementOverrides) + + pclass := (*C.GstTagDemuxClass)(gclass) + + if overrides.IdentifyTag != nil { + pclass.identify_tag = (*[0]byte)(C._gotk4_gsttag1_TagDemux_identify_tag) + } + + if overrides.MergeTags != nil { + pclass.merge_tags = (*[0]byte)(C._gotk4_gsttag1_TagDemux_merge_tags) + } +} + // TagMuxInstance is the instance type used by all types extending GstTagMux. It is used internally by the bindings. Users should use the interface [TagMux] instead. type TagMuxInstance struct { _ [0]func() // equal guard @@ -2129,10 +2204,54 @@ func UnsafeTagMuxToGlibFull(c TagMux) unsafe.Pointer { return gobject.UnsafeObjectToGlibFull(c) } +// TagMuxOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type TagMuxOverrides[Instance TagMux] struct { + // gst.ElementOverrides allows you to override virtual methods from the parent class gst.Element + gst.ElementOverrides[Instance] + + // RenderEndTag allows you to override the implementation of the virtual method render_end_tag. + // The function takes the following parameters: + // + // - tagList *gst.TagList + // + // The function returns the following values: + // + // - goret *gst.Buffer + RenderEndTag func(Instance, *gst.TagList) *gst.Buffer + // RenderStartTag allows you to override the implementation of the virtual method render_start_tag. + // The function takes the following parameters: + // + // - tagList *gst.TagList + // + // The function returns the following values: + // + // - goret *gst.Buffer + RenderStartTag func(Instance, *gst.TagList) *gst.Buffer +} + +// UnsafeApplyTagMuxOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyTagMuxOverrides[Instance TagMux](gclass unsafe.Pointer, overrides TagMuxOverrides[Instance]) { + gst.UnsafeApplyElementOverrides(gclass, overrides.ElementOverrides) + + pclass := (*C.GstTagMuxClass)(gclass) + + if overrides.RenderEndTag != nil { + pclass.render_end_tag = (*[0]byte)(C._gotk4_gsttag1_TagMux_render_end_tag) + } + + if overrides.RenderStartTag != nil { + pclass.render_start_tag = (*[0]byte)(C._gotk4_gsttag1_TagMux_render_start_tag) + } +} + // TagDemuxClass wraps GstTagDemuxClass // // The #GstTagDemuxClass structure. See documentation at beginning of section // for details about what subclasses need to override and do. +// +// TagDemuxClass is the type struct for [TagDemux] type TagDemuxClass struct { *tagDemuxClass } @@ -2147,31 +2266,6 @@ func UnsafeTagDemuxClassFromGlibBorrow(p unsafe.Pointer) *TagDemuxClass { return &TagDemuxClass{&tagDemuxClass{(*C.GstTagDemuxClass)(p)}} } -// UnsafeTagDemuxClassFromGlibNone is used to convert raw C.GstTagDemuxClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeTagDemuxClassFromGlibNone(p unsafe.Pointer) *TagDemuxClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeTagDemuxClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.tagDemuxClass, - func (intern *tagDemuxClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeTagDemuxClassFromGlibFull is used to convert raw C.GstTagDemuxClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeTagDemuxClassFromGlibFull(p unsafe.Pointer) *TagDemuxClass { - wrapped := UnsafeTagDemuxClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.tagDemuxClass, - func (intern *tagDemuxClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeTagDemuxClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [TagDemuxClass] is expected to work anymore. @@ -2184,18 +2278,21 @@ func UnsafeTagDemuxClassToGlibNone(t *TagDemuxClass) unsafe.Pointer { return unsafe.Pointer(t.native) } -// UnsafeTagDemuxClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeTagDemuxClassToGlibFull(t *TagDemuxClass) unsafe.Pointer { - runtime.SetFinalizer(t.tagDemuxClass, nil) - _p := unsafe.Pointer(t.native) - t.native = nil // TagDemuxClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (t *TagDemuxClass) ParentClass() *gst.ElementClass { + parent := gst.UnsafeElementClassFromGlibBorrow(UnsafeTagDemuxClassToGlibNone(t)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *TagDemuxClass) {}, t) + return parent } + // TagMuxClass wraps GstTagMuxClass // // The #GstTagMuxClass structure. Subclasses need to override at least one // of the two render vfuncs. +// +// TagMuxClass is the type struct for [TagMux] type TagMuxClass struct { *tagMuxClass } @@ -2210,31 +2307,6 @@ func UnsafeTagMuxClassFromGlibBorrow(p unsafe.Pointer) *TagMuxClass { return &TagMuxClass{&tagMuxClass{(*C.GstTagMuxClass)(p)}} } -// UnsafeTagMuxClassFromGlibNone is used to convert raw C.GstTagMuxClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeTagMuxClassFromGlibNone(p unsafe.Pointer) *TagMuxClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeTagMuxClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.tagMuxClass, - func (intern *tagMuxClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeTagMuxClassFromGlibFull is used to convert raw C.GstTagMuxClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeTagMuxClassFromGlibFull(p unsafe.Pointer) *TagMuxClass { - wrapped := UnsafeTagMuxClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.tagMuxClass, - func (intern *tagMuxClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeTagMuxClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [TagMuxClass] is expected to work anymore. @@ -2247,14 +2319,15 @@ func UnsafeTagMuxClassToGlibNone(t *TagMuxClass) unsafe.Pointer { return unsafe.Pointer(t.native) } -// UnsafeTagMuxClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeTagMuxClassToGlibFull(t *TagMuxClass) unsafe.Pointer { - runtime.SetFinalizer(t.tagMuxClass, nil) - _p := unsafe.Pointer(t.native) - t.native = nil // TagMuxClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (t *TagMuxClass) ParentClass() *gst.ElementClass { + parent := gst.UnsafeElementClassFromGlibBorrow(UnsafeTagMuxClassToGlibNone(t)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *TagMuxClass) {}, t) + return parent } + // TagXmpWriterInterface wraps GstTagXmpWriterInterface type TagXmpWriterInterface struct { *tagXmpWriterInterface @@ -2270,7 +2343,7 @@ func UnsafeTagXmpWriterInterfaceFromGlibBorrow(p unsafe.Pointer) *TagXmpWriterIn return &TagXmpWriterInterface{&tagXmpWriterInterface{(*C.GstTagXmpWriterInterface)(p)}} } -// UnsafeTagXmpWriterInterfaceFromGlibNone is used to convert raw C.GstTagXmpWriterInterface pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeTagXmpWriterInterfaceFromGlibNone is used to convert raw C.GstTagXmpWriterInterface pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeTagXmpWriterInterfaceFromGlibNone(p unsafe.Pointer) *TagXmpWriterInterface { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeTagXmpWriterInterfaceFromGlibBorrow(p) @@ -2283,7 +2356,7 @@ func UnsafeTagXmpWriterInterfaceFromGlibNone(p unsafe.Pointer) *TagXmpWriterInte return wrapped } -// UnsafeTagXmpWriterInterfaceFromGlibFull is used to convert raw C.GstTagXmpWriterInterface pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeTagXmpWriterInterfaceFromGlibFull is used to convert raw C.GstTagXmpWriterInterface pointers to go while taking ownership. This is used by the bindings internally. func UnsafeTagXmpWriterInterfaceFromGlibFull(p unsafe.Pointer) *TagXmpWriterInterface { wrapped := UnsafeTagXmpWriterInterfaceFromGlibBorrow(p) runtime.SetFinalizer( @@ -2315,3 +2388,4 @@ func UnsafeTagXmpWriterInterfaceToGlibFull(t *TagXmpWriterInterface) unsafe.Poin t.native = nil // TagXmpWriterInterface is invalid from here on return _p } + diff --git a/pkg/gsttag/gsttag_export.gen.go b/pkg/gsttag/gsttag_export.gen.go new file mode 100644 index 0000000..9fa36a3 --- /dev/null +++ b/pkg/gsttag/gsttag_export.gen.go @@ -0,0 +1,28 @@ +// Code generated by girgen for GstTag-1. DO NOT EDIT. + +package gsttag + + +// #include +import "C" + +//export _gotk4_gsttag1_TagDemux_identify_tag +func _gotk4_gsttag1_TagDemux_identify_tag(carg0 *C.GstTagDemux, carg1 *C.GstBuffer, carg2 C.gboolean, carg3 *C.guint) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gsttag1_TagDemux_merge_tags +func _gotk4_gsttag1_TagDemux_merge_tags(carg0 *C.GstTagDemux, carg1 *C.GstTagList, carg2 *C.GstTagList) (cret *C.GstTagList) { + panic("unimplemented") +} + +//export _gotk4_gsttag1_TagMux_render_end_tag +func _gotk4_gsttag1_TagMux_render_end_tag(carg0 *C.GstTagMux, carg1 *C.GstTagList) (cret *C.GstBuffer) { + panic("unimplemented") +} + +//export _gotk4_gsttag1_TagMux_render_start_tag +func _gotk4_gsttag1_TagMux_render_start_tag(carg0 *C.GstTagMux, carg1 *C.GstTagList) (cret *C.GstBuffer) { + panic("unimplemented") +} + diff --git a/pkg/gstvideo/gstvideo.gen.go b/pkg/gstvideo/gstvideo.gen.go index 1953e5c..cc97588 100644 --- a/pkg/gstvideo/gstvideo.gen.go +++ b/pkg/gstvideo/gstvideo.gen.go @@ -20,6 +20,298 @@ import ( // #include // extern void _gotk4_gstvideo1_VideoConvertSampleCallback(GstSample*, GError*, gpointer); // extern void destroyUserdata(gpointer); +// extern GstColorBalanceType _gotk4_gstvideo1_ColorBalance_get_balance_type(GstColorBalance*); +// extern gint _gotk4_gstvideo1_ColorBalance_get_value(GstColorBalance*, GstColorBalanceChannel*); +// extern GList* _gotk4_gstvideo1_ColorBalance_list_channels(GstColorBalance*); +// extern void _gotk4_gstvideo1_ColorBalance_set_value(GstColorBalance*, GstColorBalanceChannel*, gint); +// extern void _gotk4_gstvideo1_ColorBalance_value_changed(GstColorBalance*, GstColorBalanceChannel*, gint); +// GstColorBalanceType _gotk4_gstvideo1_ColorBalance_virtual_get_balance_type(void* fnptr, GstColorBalance* carg0) { +// return ((GstColorBalanceType (*) (GstColorBalance*))(fnptr))(carg0); +// } +// gint _gotk4_gstvideo1_ColorBalance_virtual_get_value(void* fnptr, GstColorBalance* carg0, GstColorBalanceChannel* carg1) { +// return ((gint (*) (GstColorBalance*, GstColorBalanceChannel*))(fnptr))(carg0, carg1); +// } +// GList* _gotk4_gstvideo1_ColorBalance_virtual_list_channels(void* fnptr, GstColorBalance* carg0) { +// return ((GList* (*) (GstColorBalance*))(fnptr))(carg0); +// } +// void _gotk4_gstvideo1_ColorBalance_virtual_set_value(void* fnptr, GstColorBalance* carg0, GstColorBalanceChannel* carg1, gint carg2) { +// return ((void (*) (GstColorBalance*, GstColorBalanceChannel*, gint))(fnptr))(carg0, carg1, carg2); +// } +// void _gotk4_gstvideo1_ColorBalance_virtual_value_changed(void* fnptr, GstColorBalance* carg0, GstColorBalanceChannel* carg1, gint carg2) { +// return ((void (*) (GstColorBalance*, GstColorBalanceChannel*, gint))(fnptr))(carg0, carg1, carg2); +// } +// extern void _gotk4_gstvideo1_Navigation_send_event(GstNavigation*, GstStructure*); +// extern void _gotk4_gstvideo1_Navigation_send_event_simple(GstNavigation*, GstEvent*); +// void _gotk4_gstvideo1_Navigation_virtual_send_event(void* fnptr, GstNavigation* carg0, GstStructure* carg1) { +// return ((void (*) (GstNavigation*, GstStructure*))(fnptr))(carg0, carg1); +// } +// void _gotk4_gstvideo1_Navigation_virtual_send_event_simple(void* fnptr, GstNavigation* carg0, GstEvent* carg1) { +// return ((void (*) (GstNavigation*, GstEvent*))(fnptr))(carg0, carg1); +// } +// extern gboolean _gotk4_gstvideo1_VideoOrientation_get_hcenter(GstVideoOrientation*, gint); +// extern gboolean _gotk4_gstvideo1_VideoOrientation_get_hflip(GstVideoOrientation*, gboolean); +// extern gboolean _gotk4_gstvideo1_VideoOrientation_get_vcenter(GstVideoOrientation*, gint); +// extern gboolean _gotk4_gstvideo1_VideoOrientation_get_vflip(GstVideoOrientation*, gboolean); +// extern gboolean _gotk4_gstvideo1_VideoOrientation_set_hcenter(GstVideoOrientation*, gint); +// extern gboolean _gotk4_gstvideo1_VideoOrientation_set_hflip(GstVideoOrientation*, gboolean); +// extern gboolean _gotk4_gstvideo1_VideoOrientation_set_vcenter(GstVideoOrientation*, gint); +// extern gboolean _gotk4_gstvideo1_VideoOrientation_set_vflip(GstVideoOrientation*, gboolean); +// gboolean _gotk4_gstvideo1_VideoOrientation_virtual_get_hcenter(void* fnptr, GstVideoOrientation* carg0, gint* carg1) { +// return ((gboolean (*) (GstVideoOrientation*, gint*))(fnptr))(carg0, carg1); +// } +// gboolean _gotk4_gstvideo1_VideoOrientation_virtual_get_hflip(void* fnptr, GstVideoOrientation* carg0, gboolean* carg1) { +// return ((gboolean (*) (GstVideoOrientation*, gboolean*))(fnptr))(carg0, carg1); +// } +// gboolean _gotk4_gstvideo1_VideoOrientation_virtual_get_vcenter(void* fnptr, GstVideoOrientation* carg0, gint* carg1) { +// return ((gboolean (*) (GstVideoOrientation*, gint*))(fnptr))(carg0, carg1); +// } +// gboolean _gotk4_gstvideo1_VideoOrientation_virtual_get_vflip(void* fnptr, GstVideoOrientation* carg0, gboolean* carg1) { +// return ((gboolean (*) (GstVideoOrientation*, gboolean*))(fnptr))(carg0, carg1); +// } +// gboolean _gotk4_gstvideo1_VideoOrientation_virtual_set_hcenter(void* fnptr, GstVideoOrientation* carg0, gint carg1) { +// return ((gboolean (*) (GstVideoOrientation*, gint))(fnptr))(carg0, carg1); +// } +// gboolean _gotk4_gstvideo1_VideoOrientation_virtual_set_hflip(void* fnptr, GstVideoOrientation* carg0, gboolean carg1) { +// return ((gboolean (*) (GstVideoOrientation*, gboolean))(fnptr))(carg0, carg1); +// } +// gboolean _gotk4_gstvideo1_VideoOrientation_virtual_set_vcenter(void* fnptr, GstVideoOrientation* carg0, gint carg1) { +// return ((gboolean (*) (GstVideoOrientation*, gint))(fnptr))(carg0, carg1); +// } +// gboolean _gotk4_gstvideo1_VideoOrientation_virtual_set_vflip(void* fnptr, GstVideoOrientation* carg0, gboolean carg1) { +// return ((gboolean (*) (GstVideoOrientation*, gboolean))(fnptr))(carg0, carg1); +// } +// extern void _gotk4_gstvideo1_VideoOverlay_expose(GstVideoOverlay*); +// extern void _gotk4_gstvideo1_VideoOverlay_handle_events(GstVideoOverlay*, gboolean); +// extern void _gotk4_gstvideo1_VideoOverlay_set_render_rectangle(GstVideoOverlay*, gint, gint, gint, gint); +// void _gotk4_gstvideo1_VideoOverlay_virtual_expose(void* fnptr, GstVideoOverlay* carg0) { +// return ((void (*) (GstVideoOverlay*))(fnptr))(carg0); +// } +// void _gotk4_gstvideo1_VideoOverlay_virtual_handle_events(void* fnptr, GstVideoOverlay* carg0, gboolean carg1) { +// return ((void (*) (GstVideoOverlay*, gboolean))(fnptr))(carg0, carg1); +// } +// void _gotk4_gstvideo1_VideoOverlay_virtual_set_render_rectangle(void* fnptr, GstVideoOverlay* carg0, gint carg1, gint carg2, gint carg3, gint carg4) { +// return ((void (*) (GstVideoOverlay*, gint, gint, gint, gint))(fnptr))(carg0, carg1, carg2, carg3, carg4); +// } +// extern void _gotk4_gstvideo1_ColorBalanceChannel_value_changed(GstColorBalanceChannel*, gint); +// void _gotk4_gstvideo1_ColorBalanceChannel_virtual_value_changed(void* fnptr, GstColorBalanceChannel* carg0, gint carg1) { +// return ((void (*) (GstColorBalanceChannel*, gint))(fnptr))(carg0, carg1); +// } +// extern GstFlowReturn _gotk4_gstvideo1_VideoAggregator_aggregate_frames(GstVideoAggregator*, GstBuffer*); +// extern void _gotk4_gstvideo1_VideoAggregator_find_best_format(GstVideoAggregator*, GstCaps*, GstVideoInfo*, gboolean); +// extern GstCaps* _gotk4_gstvideo1_VideoAggregator_update_caps(GstVideoAggregator*, GstCaps*); +// GstFlowReturn _gotk4_gstvideo1_VideoAggregator_virtual_aggregate_frames(void* fnptr, GstVideoAggregator* carg0, GstBuffer* carg1) { +// return ((GstFlowReturn (*) (GstVideoAggregator*, GstBuffer*))(fnptr))(carg0, carg1); +// } +// void _gotk4_gstvideo1_VideoAggregator_virtual_find_best_format(void* fnptr, GstVideoAggregator* carg0, GstCaps* carg1, GstVideoInfo* carg2, gboolean* carg3) { +// return ((void (*) (GstVideoAggregator*, GstCaps*, GstVideoInfo*, gboolean*))(fnptr))(carg0, carg1, carg2, carg3); +// } +// GstCaps* _gotk4_gstvideo1_VideoAggregator_virtual_update_caps(void* fnptr, GstVideoAggregator* carg0, GstCaps* carg1) { +// return ((GstCaps* (*) (GstVideoAggregator*, GstCaps*))(fnptr))(carg0, carg1); +// } +// extern void _gotk4_gstvideo1_VideoAggregatorPad_clean_frame(GstVideoAggregatorPad*, GstVideoAggregator*, GstVideoFrame*); +// extern gboolean _gotk4_gstvideo1_VideoAggregatorPad_prepare_frame(GstVideoAggregatorPad*, GstVideoAggregator*, GstBuffer*, GstVideoFrame*); +// extern void _gotk4_gstvideo1_VideoAggregatorPad_prepare_frame_finish(GstVideoAggregatorPad*, GstVideoAggregator*, GstVideoFrame*); +// extern void _gotk4_gstvideo1_VideoAggregatorPad_prepare_frame_start(GstVideoAggregatorPad*, GstVideoAggregator*, GstBuffer*, GstVideoFrame*); +// extern void _gotk4_gstvideo1_VideoAggregatorPad_update_conversion_info(GstVideoAggregatorPad*); +// void _gotk4_gstvideo1_VideoAggregatorPad_virtual_clean_frame(void* fnptr, GstVideoAggregatorPad* carg0, GstVideoAggregator* carg1, GstVideoFrame* carg2) { +// return ((void (*) (GstVideoAggregatorPad*, GstVideoAggregator*, GstVideoFrame*))(fnptr))(carg0, carg1, carg2); +// } +// gboolean _gotk4_gstvideo1_VideoAggregatorPad_virtual_prepare_frame(void* fnptr, GstVideoAggregatorPad* carg0, GstVideoAggregator* carg1, GstBuffer* carg2, GstVideoFrame* carg3) { +// return ((gboolean (*) (GstVideoAggregatorPad*, GstVideoAggregator*, GstBuffer*, GstVideoFrame*))(fnptr))(carg0, carg1, carg2, carg3); +// } +// void _gotk4_gstvideo1_VideoAggregatorPad_virtual_prepare_frame_finish(void* fnptr, GstVideoAggregatorPad* carg0, GstVideoAggregator* carg1, GstVideoFrame* carg2) { +// return ((void (*) (GstVideoAggregatorPad*, GstVideoAggregator*, GstVideoFrame*))(fnptr))(carg0, carg1, carg2); +// } +// void _gotk4_gstvideo1_VideoAggregatorPad_virtual_prepare_frame_start(void* fnptr, GstVideoAggregatorPad* carg0, GstVideoAggregator* carg1, GstBuffer* carg2, GstVideoFrame* carg3) { +// return ((void (*) (GstVideoAggregatorPad*, GstVideoAggregator*, GstBuffer*, GstVideoFrame*))(fnptr))(carg0, carg1, carg2, carg3); +// } +// void _gotk4_gstvideo1_VideoAggregatorPad_virtual_update_conversion_info(void* fnptr, GstVideoAggregatorPad* carg0) { +// return ((void (*) (GstVideoAggregatorPad*))(fnptr))(carg0); +// } +// extern gboolean _gotk4_gstvideo1_VideoDecoder_close(GstVideoDecoder*); +// extern gboolean _gotk4_gstvideo1_VideoDecoder_decide_allocation(GstVideoDecoder*, GstQuery*); +// extern GstFlowReturn _gotk4_gstvideo1_VideoDecoder_drain(GstVideoDecoder*); +// extern GstFlowReturn _gotk4_gstvideo1_VideoDecoder_finish(GstVideoDecoder*); +// extern gboolean _gotk4_gstvideo1_VideoDecoder_flush(GstVideoDecoder*); +// extern GstCaps* _gotk4_gstvideo1_VideoDecoder_getcaps(GstVideoDecoder*, GstCaps*); +// extern GstFlowReturn _gotk4_gstvideo1_VideoDecoder_handle_frame(GstVideoDecoder*, GstVideoCodecFrame*); +// extern gboolean _gotk4_gstvideo1_VideoDecoder_handle_missing_data(GstVideoDecoder*, GstClockTime, GstClockTime); +// extern gboolean _gotk4_gstvideo1_VideoDecoder_negotiate(GstVideoDecoder*); +// extern gboolean _gotk4_gstvideo1_VideoDecoder_open(GstVideoDecoder*); +// extern GstFlowReturn _gotk4_gstvideo1_VideoDecoder_parse(GstVideoDecoder*, GstVideoCodecFrame*, GstAdapter*, gboolean); +// extern gboolean _gotk4_gstvideo1_VideoDecoder_propose_allocation(GstVideoDecoder*, GstQuery*); +// extern gboolean _gotk4_gstvideo1_VideoDecoder_reset(GstVideoDecoder*, gboolean); +// extern gboolean _gotk4_gstvideo1_VideoDecoder_set_format(GstVideoDecoder*, GstVideoCodecState*); +// extern gboolean _gotk4_gstvideo1_VideoDecoder_sink_event(GstVideoDecoder*, GstEvent*); +// extern gboolean _gotk4_gstvideo1_VideoDecoder_sink_query(GstVideoDecoder*, GstQuery*); +// extern gboolean _gotk4_gstvideo1_VideoDecoder_src_event(GstVideoDecoder*, GstEvent*); +// extern gboolean _gotk4_gstvideo1_VideoDecoder_src_query(GstVideoDecoder*, GstQuery*); +// extern gboolean _gotk4_gstvideo1_VideoDecoder_start(GstVideoDecoder*); +// extern gboolean _gotk4_gstvideo1_VideoDecoder_stop(GstVideoDecoder*); +// extern gboolean _gotk4_gstvideo1_VideoDecoder_transform_meta(GstVideoDecoder*, GstVideoCodecFrame*, GstMeta*); +// gboolean _gotk4_gstvideo1_VideoDecoder_virtual_close(void* fnptr, GstVideoDecoder* carg0) { +// return ((gboolean (*) (GstVideoDecoder*))(fnptr))(carg0); +// } +// gboolean _gotk4_gstvideo1_VideoDecoder_virtual_decide_allocation(void* fnptr, GstVideoDecoder* carg0, GstQuery* carg1) { +// return ((gboolean (*) (GstVideoDecoder*, GstQuery*))(fnptr))(carg0, carg1); +// } +// GstFlowReturn _gotk4_gstvideo1_VideoDecoder_virtual_drain(void* fnptr, GstVideoDecoder* carg0) { +// return ((GstFlowReturn (*) (GstVideoDecoder*))(fnptr))(carg0); +// } +// GstFlowReturn _gotk4_gstvideo1_VideoDecoder_virtual_finish(void* fnptr, GstVideoDecoder* carg0) { +// return ((GstFlowReturn (*) (GstVideoDecoder*))(fnptr))(carg0); +// } +// gboolean _gotk4_gstvideo1_VideoDecoder_virtual_flush(void* fnptr, GstVideoDecoder* carg0) { +// return ((gboolean (*) (GstVideoDecoder*))(fnptr))(carg0); +// } +// GstCaps* _gotk4_gstvideo1_VideoDecoder_virtual_getcaps(void* fnptr, GstVideoDecoder* carg0, GstCaps* carg1) { +// return ((GstCaps* (*) (GstVideoDecoder*, GstCaps*))(fnptr))(carg0, carg1); +// } +// GstFlowReturn _gotk4_gstvideo1_VideoDecoder_virtual_handle_frame(void* fnptr, GstVideoDecoder* carg0, GstVideoCodecFrame* carg1) { +// return ((GstFlowReturn (*) (GstVideoDecoder*, GstVideoCodecFrame*))(fnptr))(carg0, carg1); +// } +// gboolean _gotk4_gstvideo1_VideoDecoder_virtual_handle_missing_data(void* fnptr, GstVideoDecoder* carg0, GstClockTime carg1, GstClockTime carg2) { +// return ((gboolean (*) (GstVideoDecoder*, GstClockTime, GstClockTime))(fnptr))(carg0, carg1, carg2); +// } +// gboolean _gotk4_gstvideo1_VideoDecoder_virtual_negotiate(void* fnptr, GstVideoDecoder* carg0) { +// return ((gboolean (*) (GstVideoDecoder*))(fnptr))(carg0); +// } +// gboolean _gotk4_gstvideo1_VideoDecoder_virtual_open(void* fnptr, GstVideoDecoder* carg0) { +// return ((gboolean (*) (GstVideoDecoder*))(fnptr))(carg0); +// } +// GstFlowReturn _gotk4_gstvideo1_VideoDecoder_virtual_parse(void* fnptr, GstVideoDecoder* carg0, GstVideoCodecFrame* carg1, GstAdapter* carg2, gboolean carg3) { +// return ((GstFlowReturn (*) (GstVideoDecoder*, GstVideoCodecFrame*, GstAdapter*, gboolean))(fnptr))(carg0, carg1, carg2, carg3); +// } +// gboolean _gotk4_gstvideo1_VideoDecoder_virtual_propose_allocation(void* fnptr, GstVideoDecoder* carg0, GstQuery* carg1) { +// return ((gboolean (*) (GstVideoDecoder*, GstQuery*))(fnptr))(carg0, carg1); +// } +// gboolean _gotk4_gstvideo1_VideoDecoder_virtual_reset(void* fnptr, GstVideoDecoder* carg0, gboolean carg1) { +// return ((gboolean (*) (GstVideoDecoder*, gboolean))(fnptr))(carg0, carg1); +// } +// gboolean _gotk4_gstvideo1_VideoDecoder_virtual_set_format(void* fnptr, GstVideoDecoder* carg0, GstVideoCodecState* carg1) { +// return ((gboolean (*) (GstVideoDecoder*, GstVideoCodecState*))(fnptr))(carg0, carg1); +// } +// gboolean _gotk4_gstvideo1_VideoDecoder_virtual_sink_event(void* fnptr, GstVideoDecoder* carg0, GstEvent* carg1) { +// return ((gboolean (*) (GstVideoDecoder*, GstEvent*))(fnptr))(carg0, carg1); +// } +// gboolean _gotk4_gstvideo1_VideoDecoder_virtual_sink_query(void* fnptr, GstVideoDecoder* carg0, GstQuery* carg1) { +// return ((gboolean (*) (GstVideoDecoder*, GstQuery*))(fnptr))(carg0, carg1); +// } +// gboolean _gotk4_gstvideo1_VideoDecoder_virtual_src_event(void* fnptr, GstVideoDecoder* carg0, GstEvent* carg1) { +// return ((gboolean (*) (GstVideoDecoder*, GstEvent*))(fnptr))(carg0, carg1); +// } +// gboolean _gotk4_gstvideo1_VideoDecoder_virtual_src_query(void* fnptr, GstVideoDecoder* carg0, GstQuery* carg1) { +// return ((gboolean (*) (GstVideoDecoder*, GstQuery*))(fnptr))(carg0, carg1); +// } +// gboolean _gotk4_gstvideo1_VideoDecoder_virtual_start(void* fnptr, GstVideoDecoder* carg0) { +// return ((gboolean (*) (GstVideoDecoder*))(fnptr))(carg0); +// } +// gboolean _gotk4_gstvideo1_VideoDecoder_virtual_stop(void* fnptr, GstVideoDecoder* carg0) { +// return ((gboolean (*) (GstVideoDecoder*))(fnptr))(carg0); +// } +// gboolean _gotk4_gstvideo1_VideoDecoder_virtual_transform_meta(void* fnptr, GstVideoDecoder* carg0, GstVideoCodecFrame* carg1, GstMeta* carg2) { +// return ((gboolean (*) (GstVideoDecoder*, GstVideoCodecFrame*, GstMeta*))(fnptr))(carg0, carg1, carg2); +// } +// extern gboolean _gotk4_gstvideo1_VideoEncoder_close(GstVideoEncoder*); +// extern gboolean _gotk4_gstvideo1_VideoEncoder_decide_allocation(GstVideoEncoder*, GstQuery*); +// extern GstFlowReturn _gotk4_gstvideo1_VideoEncoder_finish(GstVideoEncoder*); +// extern gboolean _gotk4_gstvideo1_VideoEncoder_flush(GstVideoEncoder*); +// extern GstCaps* _gotk4_gstvideo1_VideoEncoder_getcaps(GstVideoEncoder*, GstCaps*); +// extern GstFlowReturn _gotk4_gstvideo1_VideoEncoder_handle_frame(GstVideoEncoder*, GstVideoCodecFrame*); +// extern gboolean _gotk4_gstvideo1_VideoEncoder_negotiate(GstVideoEncoder*); +// extern gboolean _gotk4_gstvideo1_VideoEncoder_open(GstVideoEncoder*); +// extern GstFlowReturn _gotk4_gstvideo1_VideoEncoder_pre_push(GstVideoEncoder*, GstVideoCodecFrame*); +// extern gboolean _gotk4_gstvideo1_VideoEncoder_propose_allocation(GstVideoEncoder*, GstQuery*); +// extern gboolean _gotk4_gstvideo1_VideoEncoder_reset(GstVideoEncoder*, gboolean); +// extern gboolean _gotk4_gstvideo1_VideoEncoder_set_format(GstVideoEncoder*, GstVideoCodecState*); +// extern gboolean _gotk4_gstvideo1_VideoEncoder_sink_event(GstVideoEncoder*, GstEvent*); +// extern gboolean _gotk4_gstvideo1_VideoEncoder_sink_query(GstVideoEncoder*, GstQuery*); +// extern gboolean _gotk4_gstvideo1_VideoEncoder_src_event(GstVideoEncoder*, GstEvent*); +// extern gboolean _gotk4_gstvideo1_VideoEncoder_src_query(GstVideoEncoder*, GstQuery*); +// extern gboolean _gotk4_gstvideo1_VideoEncoder_start(GstVideoEncoder*); +// extern gboolean _gotk4_gstvideo1_VideoEncoder_stop(GstVideoEncoder*); +// extern gboolean _gotk4_gstvideo1_VideoEncoder_transform_meta(GstVideoEncoder*, GstVideoCodecFrame*, GstMeta*); +// gboolean _gotk4_gstvideo1_VideoEncoder_virtual_close(void* fnptr, GstVideoEncoder* carg0) { +// return ((gboolean (*) (GstVideoEncoder*))(fnptr))(carg0); +// } +// gboolean _gotk4_gstvideo1_VideoEncoder_virtual_decide_allocation(void* fnptr, GstVideoEncoder* carg0, GstQuery* carg1) { +// return ((gboolean (*) (GstVideoEncoder*, GstQuery*))(fnptr))(carg0, carg1); +// } +// GstFlowReturn _gotk4_gstvideo1_VideoEncoder_virtual_finish(void* fnptr, GstVideoEncoder* carg0) { +// return ((GstFlowReturn (*) (GstVideoEncoder*))(fnptr))(carg0); +// } +// gboolean _gotk4_gstvideo1_VideoEncoder_virtual_flush(void* fnptr, GstVideoEncoder* carg0) { +// return ((gboolean (*) (GstVideoEncoder*))(fnptr))(carg0); +// } +// GstCaps* _gotk4_gstvideo1_VideoEncoder_virtual_getcaps(void* fnptr, GstVideoEncoder* carg0, GstCaps* carg1) { +// return ((GstCaps* (*) (GstVideoEncoder*, GstCaps*))(fnptr))(carg0, carg1); +// } +// GstFlowReturn _gotk4_gstvideo1_VideoEncoder_virtual_handle_frame(void* fnptr, GstVideoEncoder* carg0, GstVideoCodecFrame* carg1) { +// return ((GstFlowReturn (*) (GstVideoEncoder*, GstVideoCodecFrame*))(fnptr))(carg0, carg1); +// } +// gboolean _gotk4_gstvideo1_VideoEncoder_virtual_negotiate(void* fnptr, GstVideoEncoder* carg0) { +// return ((gboolean (*) (GstVideoEncoder*))(fnptr))(carg0); +// } +// gboolean _gotk4_gstvideo1_VideoEncoder_virtual_open(void* fnptr, GstVideoEncoder* carg0) { +// return ((gboolean (*) (GstVideoEncoder*))(fnptr))(carg0); +// } +// GstFlowReturn _gotk4_gstvideo1_VideoEncoder_virtual_pre_push(void* fnptr, GstVideoEncoder* carg0, GstVideoCodecFrame* carg1) { +// return ((GstFlowReturn (*) (GstVideoEncoder*, GstVideoCodecFrame*))(fnptr))(carg0, carg1); +// } +// gboolean _gotk4_gstvideo1_VideoEncoder_virtual_propose_allocation(void* fnptr, GstVideoEncoder* carg0, GstQuery* carg1) { +// return ((gboolean (*) (GstVideoEncoder*, GstQuery*))(fnptr))(carg0, carg1); +// } +// gboolean _gotk4_gstvideo1_VideoEncoder_virtual_reset(void* fnptr, GstVideoEncoder* carg0, gboolean carg1) { +// return ((gboolean (*) (GstVideoEncoder*, gboolean))(fnptr))(carg0, carg1); +// } +// gboolean _gotk4_gstvideo1_VideoEncoder_virtual_set_format(void* fnptr, GstVideoEncoder* carg0, GstVideoCodecState* carg1) { +// return ((gboolean (*) (GstVideoEncoder*, GstVideoCodecState*))(fnptr))(carg0, carg1); +// } +// gboolean _gotk4_gstvideo1_VideoEncoder_virtual_sink_event(void* fnptr, GstVideoEncoder* carg0, GstEvent* carg1) { +// return ((gboolean (*) (GstVideoEncoder*, GstEvent*))(fnptr))(carg0, carg1); +// } +// gboolean _gotk4_gstvideo1_VideoEncoder_virtual_sink_query(void* fnptr, GstVideoEncoder* carg0, GstQuery* carg1) { +// return ((gboolean (*) (GstVideoEncoder*, GstQuery*))(fnptr))(carg0, carg1); +// } +// gboolean _gotk4_gstvideo1_VideoEncoder_virtual_src_event(void* fnptr, GstVideoEncoder* carg0, GstEvent* carg1) { +// return ((gboolean (*) (GstVideoEncoder*, GstEvent*))(fnptr))(carg0, carg1); +// } +// gboolean _gotk4_gstvideo1_VideoEncoder_virtual_src_query(void* fnptr, GstVideoEncoder* carg0, GstQuery* carg1) { +// return ((gboolean (*) (GstVideoEncoder*, GstQuery*))(fnptr))(carg0, carg1); +// } +// gboolean _gotk4_gstvideo1_VideoEncoder_virtual_start(void* fnptr, GstVideoEncoder* carg0) { +// return ((gboolean (*) (GstVideoEncoder*))(fnptr))(carg0); +// } +// gboolean _gotk4_gstvideo1_VideoEncoder_virtual_stop(void* fnptr, GstVideoEncoder* carg0) { +// return ((gboolean (*) (GstVideoEncoder*))(fnptr))(carg0); +// } +// gboolean _gotk4_gstvideo1_VideoEncoder_virtual_transform_meta(void* fnptr, GstVideoEncoder* carg0, GstVideoCodecFrame* carg1, GstMeta* carg2) { +// return ((gboolean (*) (GstVideoEncoder*, GstVideoCodecFrame*, GstMeta*))(fnptr))(carg0, carg1, carg2); +// } +// extern gboolean _gotk4_gstvideo1_VideoFilter_set_info(GstVideoFilter*, GstCaps*, GstVideoInfo*, GstCaps*, GstVideoInfo*); +// extern GstFlowReturn _gotk4_gstvideo1_VideoFilter_transform_frame(GstVideoFilter*, GstVideoFrame*, GstVideoFrame*); +// extern GstFlowReturn _gotk4_gstvideo1_VideoFilter_transform_frame_ip(GstVideoFilter*, GstVideoFrame*); +// gboolean _gotk4_gstvideo1_VideoFilter_virtual_set_info(void* fnptr, GstVideoFilter* carg0, GstCaps* carg1, GstVideoInfo* carg2, GstCaps* carg3, GstVideoInfo* carg4) { +// return ((gboolean (*) (GstVideoFilter*, GstCaps*, GstVideoInfo*, GstCaps*, GstVideoInfo*))(fnptr))(carg0, carg1, carg2, carg3, carg4); +// } +// GstFlowReturn _gotk4_gstvideo1_VideoFilter_virtual_transform_frame(void* fnptr, GstVideoFilter* carg0, GstVideoFrame* carg1, GstVideoFrame* carg2) { +// return ((GstFlowReturn (*) (GstVideoFilter*, GstVideoFrame*, GstVideoFrame*))(fnptr))(carg0, carg1, carg2); +// } +// GstFlowReturn _gotk4_gstvideo1_VideoFilter_virtual_transform_frame_ip(void* fnptr, GstVideoFilter* carg0, GstVideoFrame* carg1) { +// return ((GstFlowReturn (*) (GstVideoFilter*, GstVideoFrame*))(fnptr))(carg0, carg1); +// } +// extern gboolean _gotk4_gstvideo1_VideoSink_set_info(GstVideoSink*, GstCaps*, GstVideoInfo*); +// extern GstFlowReturn _gotk4_gstvideo1_VideoSink_show_frame(GstVideoSink*, GstBuffer*); +// gboolean _gotk4_gstvideo1_VideoSink_virtual_set_info(void* fnptr, GstVideoSink* carg0, GstCaps* carg1, GstVideoInfo* carg2) { +// return ((gboolean (*) (GstVideoSink*, GstCaps*, GstVideoInfo*))(fnptr))(carg0, carg1, carg2); +// } +// GstFlowReturn _gotk4_gstvideo1_VideoSink_virtual_show_frame(void* fnptr, GstVideoSink* carg0, GstBuffer* carg1) { +// return ((GstFlowReturn (*) (GstVideoSink*, GstBuffer*))(fnptr))(carg0, carg1); +// } +// extern void _gotk4_gstvideo1_VideoAggregatorConvertPad_create_conversion_info(GstVideoAggregatorConvertPad*, GstVideoAggregator*, GstVideoInfo*); +// void _gotk4_gstvideo1_VideoAggregatorConvertPad_virtual_create_conversion_info(void* fnptr, GstVideoAggregatorConvertPad* carg0, GstVideoAggregator* carg1, GstVideoInfo* carg2) { +// return ((void (*) (GstVideoAggregatorConvertPad*, GstVideoAggregator*, GstVideoInfo*))(fnptr))(carg0, carg1, carg2); +// } import "C" // GType values. @@ -5161,6 +5453,7 @@ func (f VideoTimeCodeFlags) String() string { type VideoConvertSampleCallback func(sample *gst.Sample, err error) // AncillaryMetaApiGetType wraps gst_ancillary_meta_api_get_type +// // The function returns the following values: // // - goret gobject.Type @@ -5968,6 +6261,7 @@ func IsVideoOverlayPrepareWindowHandleMessage(msg *gst.Message) bool { } // VideoAfdMetaApiGetType wraps gst_video_afd_meta_api_get_type +// // The function returns the following values: // // - goret gobject.Type @@ -5984,6 +6278,7 @@ func VideoAfdMetaApiGetType() gobject.Type { } // VideoAffineTransformationMetaApiGetType wraps gst_video_affine_transformation_meta_api_get_type +// // The function returns the following values: // // - goret gobject.Type @@ -6000,6 +6295,7 @@ func VideoAffineTransformationMetaApiGetType() gobject.Type { } // VideoBarMetaApiGetType wraps gst_video_bar_meta_api_get_type +// // The function returns the following values: // // - goret gobject.Type @@ -6171,6 +6467,7 @@ func VideoCalculateDisplayRatio(videoWidth uint, videoHeight uint, videoParN uin } // VideoCaptionMetaApiGetType wraps gst_video_caption_meta_api_get_type +// // The function returns the following values: // // - goret gobject.Type @@ -6287,6 +6584,7 @@ func VideoChromaToString(site VideoChromaSite) string { } // VideoCodecAlphaMetaApiGetType wraps gst_video_codec_alpha_meta_api_get_type +// // The function returns the following values: // // - goret gobject.Type @@ -6458,6 +6756,7 @@ func VideoConvertSampleAsync(sample *gst.Sample, toCaps *gst.Caps, timeout gst.C } // VideoCropMetaApiGetType wraps gst_video_crop_meta_api_get_type +// // The function returns the following values: // // - goret gobject.Type @@ -6908,6 +7207,7 @@ func VideoEventParseUpstreamForceKeyUnit(event *gst.Event) (gst.ClockTime, bool, } // VideoFormatsAny wraps gst_video_formats_any +// // The function returns the following values: // // - len uint: the number of elements in the returned array @@ -6935,6 +7235,7 @@ func VideoFormatsAny() (uint, []VideoFormat) { } // VideoFormatsRaw wraps gst_video_formats_raw +// // The function returns the following values: // // - len uint: the number of elements in the returned array @@ -6959,6 +7260,7 @@ func VideoFormatsRaw() (uint, []VideoFormat) { } // VideoGLTextureUploadMetaApiGetType wraps gst_video_gl_texture_upload_meta_api_get_type +// // The function returns the following values: // // - goret gobject.Type @@ -7165,6 +7467,7 @@ func VideoMakeRawCapsWithFeatures(formats []VideoFormat, features *gst.CapsFeatu } // VideoMetaApiGetType wraps gst_video_meta_api_get_type +// // The function returns the following values: // // - goret gobject.Type @@ -7181,6 +7484,7 @@ func VideoMetaApiGetType() gobject.Type { } // VideoMultiviewGetDoubledHeightModes wraps gst_video_multiview_get_doubled_height_modes +// // The function returns the following values: // // - goret *gobject.Value @@ -7197,6 +7501,7 @@ func VideoMultiviewGetDoubledHeightModes() *gobject.Value { } // VideoMultiviewGetDoubledSizeModes wraps gst_video_multiview_get_doubled_size_modes +// // The function returns the following values: // // - goret *gobject.Value @@ -7213,6 +7518,7 @@ func VideoMultiviewGetDoubledSizeModes() *gobject.Value { } // VideoMultiviewGetDoubledWidthModes wraps gst_video_multiview_get_doubled_width_modes +// // The function returns the following values: // // - goret *gobject.Value @@ -7229,6 +7535,7 @@ func VideoMultiviewGetDoubledWidthModes() *gobject.Value { } // VideoMultiviewGetMonoModes wraps gst_video_multiview_get_mono_modes +// // The function returns the following values: // // - goret *gobject.Value @@ -7245,6 +7552,7 @@ func VideoMultiviewGetMonoModes() *gobject.Value { } // VideoMultiviewGetUnpackedModes wraps gst_video_multiview_get_unpacked_modes +// // The function returns the following values: // // - goret *gobject.Value @@ -7330,6 +7638,7 @@ func VideoMultiviewVideoInfoChangeMode(info *VideoInfo, outMviewMode VideoMultiv } // VideoOverlayCompositionMetaApiGetType wraps gst_video_overlay_composition_meta_api_get_type +// // The function returns the following values: // // - goret gobject.Type @@ -7346,6 +7655,7 @@ func VideoOverlayCompositionMetaApiGetType() gobject.Type { } // VideoRegionOfInterestMetaApiGetType wraps gst_video_region_of_interest_meta_api_get_type +// // The function returns the following values: // // - goret gobject.Type @@ -7362,6 +7672,7 @@ func VideoRegionOfInterestMetaApiGetType() gobject.Type { } // VideoSeiUserDataUnregisteredMetaApiGetType wraps gst_video_sei_user_data_unregistered_meta_api_get_type +// // The function returns the following values: // // - goret gobject.Type @@ -7461,6 +7772,7 @@ func VideoTileGetIndex(mode VideoTileMode, x int, y int, xTiles int, yTiles int) } // VideoTimeCodeMetaApiGetType wraps gst_video_time_code_meta_api_get_type +// // The function returns the following values: // // - goret gobject.Type @@ -7495,6 +7807,7 @@ type ColorBalance interface { upcastToGstColorBalance() *ColorBalanceInstance // GetBalanceType wraps gst_color_balance_get_balance_type + // // The function returns the following values: // // - goret ColorBalanceType @@ -7519,6 +7832,7 @@ type ColorBalance interface { // #GstColorBalanceChannel object. GetValue(ColorBalanceChannel) int // ListChannels wraps gst_color_balance_list_channels + // // The function returns the following values: // // - goret []ColorBalanceChannel @@ -7596,6 +7910,7 @@ func UnsafeColorBalanceToGlibFull(c ColorBalance) unsafe.Pointer { } // GetBalanceType wraps gst_color_balance_get_balance_type +// // The function returns the following values: // // - goret ColorBalanceType @@ -7653,6 +7968,7 @@ func (balance *ColorBalanceInstance) GetValue(channel ColorBalanceChannel) int { } // ListChannels wraps gst_color_balance_list_channels +// // The function returns the following values: // // - goret []ColorBalanceChannel @@ -7741,6 +8057,69 @@ func (balance *ColorBalanceInstance) ValueChanged(channel ColorBalanceChannel, v func (o *ColorBalanceInstance) ConnectValueChanged(fn func(ColorBalance, ColorBalanceChannel, int)) gobject.SignalHandle { return o.Instance.Connect("value-changed", fn) } + +// ColorBalanceOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type ColorBalanceOverrides[Instance ColorBalance] struct { + // GetBalanceType allows you to override the implementation of the virtual method get_balance_type. + // The function returns the following values: + // + // - goret ColorBalanceType + GetBalanceType func(Instance) ColorBalanceType + // GetValue allows you to override the implementation of the virtual method get_value. + // The function takes the following parameters: + // + // - channel ColorBalanceChannel: A #GstColorBalanceChannel instance + // + // The function returns the following values: + // + // - goret int + GetValue func(Instance, ColorBalanceChannel) int + // ListChannels allows you to override the implementation of the virtual method list_channels. + // The function returns the following values: + // + // - goret []ColorBalanceChannel + ListChannels func(Instance) []ColorBalanceChannel + // SetValue allows you to override the implementation of the virtual method set_value. + // The function takes the following parameters: + // + // - channel ColorBalanceChannel: A #GstColorBalanceChannel instance + // - value int: The new value for the channel. + SetValue func(Instance, ColorBalanceChannel, int) + // ValueChanged allows you to override the implementation of the virtual method value_changed. + // The function takes the following parameters: + // + // - channel ColorBalanceChannel: A #GstColorBalanceChannel whose value has changed + // - value int: The new value of the channel + ValueChanged func(Instance, ColorBalanceChannel, int) +} + +// UnsafeApplyColorBalanceOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyColorBalanceOverrides[Instance ColorBalance](gclass unsafe.Pointer, overrides ColorBalanceOverrides[Instance]) { + pclass := (*C.GstColorBalanceInterface)(gclass) + + if overrides.GetBalanceType != nil { + pclass.get_balance_type = (*[0]byte)(C._gotk4_gstvideo1_ColorBalance_get_balance_type) + } + + if overrides.GetValue != nil { + pclass.get_value = (*[0]byte)(C._gotk4_gstvideo1_ColorBalance_get_value) + } + + if overrides.ListChannels != nil { + pclass.list_channels = (*[0]byte)(C._gotk4_gstvideo1_ColorBalance_list_channels) + } + + if overrides.SetValue != nil { + pclass.set_value = (*[0]byte)(C._gotk4_gstvideo1_ColorBalance_set_value) + } + + if overrides.ValueChanged != nil { + pclass.value_changed = (*[0]byte)(C._gotk4_gstvideo1_ColorBalance_value_changed) + } +} + // NavigationInstance is the instance type used by all types implementing GstNavigation. It is used internally by the bindings. Users should use the interface [Navigation] instead. type NavigationInstance struct { _ [0]func() // equal guard @@ -9041,6 +9420,7 @@ func NavigationQueryGetType(query *gst.Query) NavigationQueryType { } // NavigationQueryNewAngles wraps gst_navigation_query_new_angles +// // The function returns the following values: // // - goret *gst.Query @@ -9061,6 +9441,7 @@ func NavigationQueryNewAngles() *gst.Query { } // NavigationQueryNewCommands wraps gst_navigation_query_new_commands +// // The function returns the following values: // // - goret *gst.Query @@ -9393,6 +9774,35 @@ func (navigation *NavigationInstance) SendMouseScrollEvent(x float64, y float64, runtime.KeepAlive(deltaY) } +// NavigationOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type NavigationOverrides[Instance Navigation] struct { + // SendEvent allows you to override the implementation of the virtual method send_event. + // The function takes the following parameters: + // + // - structure *gst.Structure + SendEvent func(Instance, *gst.Structure) + // SendEventSimple allows you to override the implementation of the virtual method send_event_simple. + // The function takes the following parameters: + // + // - event *gst.Event: The event to send + SendEventSimple func(Instance, *gst.Event) +} + +// UnsafeApplyNavigationOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyNavigationOverrides[Instance Navigation](gclass unsafe.Pointer, overrides NavigationOverrides[Instance]) { + pclass := (*C.GstNavigationInterface)(gclass) + + if overrides.SendEvent != nil { + pclass.send_event = (*[0]byte)(C._gotk4_gstvideo1_Navigation_send_event) + } + + if overrides.SendEventSimple != nil { + pclass.send_event_simple = (*[0]byte)(C._gotk4_gstvideo1_Navigation_send_event_simple) + } +} + // VideoDirectionInstance is the instance type used by all types implementing GstVideoDirection. It is used internally by the bindings. Users should use the interface [VideoDirection] instead. type VideoDirectionInstance struct { _ [0]func() // equal guard @@ -9447,6 +9857,16 @@ func UnsafeVideoDirectionToGlibFull(c VideoDirection) unsafe.Pointer { return gobject.UnsafeObjectToGlibFull(&i.Instance) } +// VideoDirectionOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type VideoDirectionOverrides[Instance VideoDirection] struct { +} + +// UnsafeApplyVideoDirectionOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyVideoDirectionOverrides[Instance VideoDirection](gclass unsafe.Pointer, overrides VideoDirectionOverrides[Instance]) { +} + // VideoOrientationInstance is the instance type used by all types implementing GstVideoOrientation. It is used internally by the bindings. Users should use the interface [VideoOrientation] instead. type VideoOrientationInstance struct { _ [0]func() // equal guard @@ -9463,6 +9883,7 @@ type VideoOrientation interface { upcastToGstVideoOrientation() *VideoOrientationInstance // GetHcenter wraps gst_video_orientation_get_hcenter + // // The function returns the following values: // // - center int: return location for the result @@ -9471,6 +9892,7 @@ type VideoOrientation interface { // Get the horizontal centering offset from the given object. GetHcenter() (int, bool) // GetHflip wraps gst_video_orientation_get_hflip + // // The function returns the following values: // // - flip bool: return location for the result @@ -9479,6 +9901,7 @@ type VideoOrientation interface { // Get the horizontal flipping state (%TRUE for flipped) from the given object. GetHflip() (bool, bool) // GetVcenter wraps gst_video_orientation_get_vcenter + // // The function returns the following values: // // - center int: return location for the result @@ -9487,6 +9910,7 @@ type VideoOrientation interface { // Get the vertical centering offset from the given object. GetVcenter() (int, bool) // GetVflip wraps gst_video_orientation_get_vflip + // // The function returns the following values: // // - flip bool: return location for the result @@ -9617,6 +10041,7 @@ func VideoOrientationFromTag(taglist *gst.TagList) (VideoOrientationMethod, bool } // GetHcenter wraps gst_video_orientation_get_hcenter +// // The function returns the following values: // // - center int: return location for the result @@ -9645,6 +10070,7 @@ func (videoOrientation *VideoOrientationInstance) GetHcenter() (int, bool) { } // GetHflip wraps gst_video_orientation_get_hflip +// // The function returns the following values: // // - flip bool: return location for the result @@ -9675,6 +10101,7 @@ func (videoOrientation *VideoOrientationInstance) GetHflip() (bool, bool) { } // GetVcenter wraps gst_video_orientation_get_vcenter +// // The function returns the following values: // // - center int: return location for the result @@ -9703,6 +10130,7 @@ func (videoOrientation *VideoOrientationInstance) GetVcenter() (int, bool) { } // GetVflip wraps gst_video_orientation_get_vflip +// // The function returns the following values: // // - flip bool: return location for the result @@ -9864,6 +10292,109 @@ func (videoOrientation *VideoOrientationInstance) SetVflip(flip bool) bool { return goret } +// VideoOrientationOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type VideoOrientationOverrides[Instance VideoOrientation] struct { + // GetHcenter allows you to override the implementation of the virtual method get_hcenter. + // The function returns the following values: + // + // - center int: return location for the result + // - goret bool + GetHcenter func(Instance) (int, bool) + // GetHflip allows you to override the implementation of the virtual method get_hflip. + // The function returns the following values: + // + // - flip bool: return location for the result + // - goret bool + GetHflip func(Instance) (bool, bool) + // GetVcenter allows you to override the implementation of the virtual method get_vcenter. + // The function returns the following values: + // + // - center int: return location for the result + // - goret bool + GetVcenter func(Instance) (int, bool) + // GetVflip allows you to override the implementation of the virtual method get_vflip. + // The function returns the following values: + // + // - flip bool: return location for the result + // - goret bool + GetVflip func(Instance) (bool, bool) + // SetHcenter allows you to override the implementation of the virtual method set_hcenter. + // The function takes the following parameters: + // + // - center int: centering offset + // + // The function returns the following values: + // + // - goret bool + SetHcenter func(Instance, int) bool + // SetHflip allows you to override the implementation of the virtual method set_hflip. + // The function takes the following parameters: + // + // - flip bool: use flipping + // + // The function returns the following values: + // + // - goret bool + SetHflip func(Instance, bool) bool + // SetVcenter allows you to override the implementation of the virtual method set_vcenter. + // The function takes the following parameters: + // + // - center int: centering offset + // + // The function returns the following values: + // + // - goret bool + SetVcenter func(Instance, int) bool + // SetVflip allows you to override the implementation of the virtual method set_vflip. + // The function takes the following parameters: + // + // - flip bool: use flipping + // + // The function returns the following values: + // + // - goret bool + SetVflip func(Instance, bool) bool +} + +// UnsafeApplyVideoOrientationOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyVideoOrientationOverrides[Instance VideoOrientation](gclass unsafe.Pointer, overrides VideoOrientationOverrides[Instance]) { + pclass := (*C.GstVideoOrientationInterface)(gclass) + + if overrides.GetHcenter != nil { + pclass.get_hcenter = (*[0]byte)(C._gotk4_gstvideo1_VideoOrientation_get_hcenter) + } + + if overrides.GetHflip != nil { + pclass.get_hflip = (*[0]byte)(C._gotk4_gstvideo1_VideoOrientation_get_hflip) + } + + if overrides.GetVcenter != nil { + pclass.get_vcenter = (*[0]byte)(C._gotk4_gstvideo1_VideoOrientation_get_vcenter) + } + + if overrides.GetVflip != nil { + pclass.get_vflip = (*[0]byte)(C._gotk4_gstvideo1_VideoOrientation_get_vflip) + } + + if overrides.SetHcenter != nil { + pclass.set_hcenter = (*[0]byte)(C._gotk4_gstvideo1_VideoOrientation_set_hcenter) + } + + if overrides.SetHflip != nil { + pclass.set_hflip = (*[0]byte)(C._gotk4_gstvideo1_VideoOrientation_set_hflip) + } + + if overrides.SetVcenter != nil { + pclass.set_vcenter = (*[0]byte)(C._gotk4_gstvideo1_VideoOrientation_set_vcenter) + } + + if overrides.SetVflip != nil { + pclass.set_vflip = (*[0]byte)(C._gotk4_gstvideo1_VideoOrientation_set_vflip) + } +} + // VideoOverlayInstance is the instance type used by all types implementing GstVideoOverlay. It is used internally by the bindings. Users should use the interface [VideoOverlay] instead. type VideoOverlayInstance struct { _ [0]func() // equal guard @@ -10377,6 +10908,44 @@ func (overlay *VideoOverlayInstance) SetRenderRectangle(x int, y int, width int, return goret } +// VideoOverlayOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type VideoOverlayOverrides[Instance VideoOverlay] struct { + // Expose allows you to override the implementation of the virtual method expose. + Expose func(Instance) + // HandleEvents allows you to override the implementation of the virtual method handle_events. + // The function takes the following parameters: + // + // - handleEvents bool: a #gboolean indicating if events should be handled or not. + HandleEvents func(Instance, bool) + // SetRenderRectangle allows you to override the implementation of the virtual method set_render_rectangle. + // The function takes the following parameters: + // + // - x int + // - y int + // - width int + // - height int + SetRenderRectangle func(Instance, int, int, int, int) +} + +// UnsafeApplyVideoOverlayOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyVideoOverlayOverrides[Instance VideoOverlay](gclass unsafe.Pointer, overrides VideoOverlayOverrides[Instance]) { + pclass := (*C.GstVideoOverlayInterface)(gclass) + + if overrides.Expose != nil { + pclass.expose = (*[0]byte)(C._gotk4_gstvideo1_VideoOverlay_expose) + } + + if overrides.HandleEvents != nil { + pclass.handle_events = (*[0]byte)(C._gotk4_gstvideo1_VideoOverlay_handle_events) + } + + if overrides.SetRenderRectangle != nil { + pclass.set_render_rectangle = (*[0]byte)(C._gotk4_gstvideo1_VideoOverlay_set_render_rectangle) + } +} + // ColorBalanceChannelInstance is the instance type used by all types extending GstColorBalanceChannel. It is used internally by the bindings. Users should use the interface [ColorBalanceChannel] instead. type ColorBalanceChannelInstance struct { _ [0]func() // equal guard @@ -10440,6 +11009,32 @@ func UnsafeColorBalanceChannelToGlibFull(c ColorBalanceChannel) unsafe.Pointer { func (o *ColorBalanceChannelInstance) ConnectValueChanged(fn func(ColorBalanceChannel, int)) gobject.SignalHandle { return o.Connect("value-changed", fn) } + +// ColorBalanceChannelOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type ColorBalanceChannelOverrides[Instance ColorBalanceChannel] struct { + // gobject.ObjectOverrides allows you to override virtual methods from the parent class gobject.Object + gobject.ObjectOverrides[Instance] + + // ValueChanged allows you to override the implementation of the virtual method value_changed. + // The function takes the following parameters: + // + // - value int + ValueChanged func(Instance, int) +} + +// UnsafeApplyColorBalanceChannelOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyColorBalanceChannelOverrides[Instance ColorBalanceChannel](gclass unsafe.Pointer, overrides ColorBalanceChannelOverrides[Instance]) { + gobject.UnsafeApplyObjectOverrides(gclass, overrides.ObjectOverrides) + + pclass := (*C.GstColorBalanceChannelClass)(gclass) + + if overrides.ValueChanged != nil { + pclass.value_changed = (*[0]byte)(C._gotk4_gstvideo1_ColorBalanceChannel_value_changed) + } +} + // VideoAggregatorInstance is the instance type used by all types extending GstVideoAggregator. It is used internally by the bindings. Users should use the interface [VideoAggregator] instead. type VideoAggregatorInstance struct { _ [0]func() // equal guard @@ -10464,6 +11059,7 @@ type VideoAggregator interface { upcastToGstVideoAggregator() *VideoAggregatorInstance // GetExecutionTaskPool wraps gst_video_aggregator_get_execution_task_pool + // // The function returns the following values: // // - goret gst.TaskPool @@ -10519,6 +11115,7 @@ func UnsafeVideoAggregatorToGlibFull(c VideoAggregator) unsafe.Pointer { } // GetExecutionTaskPool wraps gst_video_aggregator_get_execution_task_pool +// // The function returns the following values: // // - goret gst.TaskPool @@ -10544,6 +11141,62 @@ func (vagg *VideoAggregatorInstance) GetExecutionTaskPool() gst.TaskPool { return goret } +// VideoAggregatorOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type VideoAggregatorOverrides[Instance VideoAggregator] struct { + // gstbase.AggregatorOverrides allows you to override virtual methods from the parent class gstbase.Aggregator + gstbase.AggregatorOverrides[Instance] + + // AggregateFrames allows you to override the implementation of the virtual method aggregate_frames. + // The function takes the following parameters: + // + // - outbuffer *gst.Buffer + // + // The function returns the following values: + // + // - goret gst.FlowReturn + AggregateFrames func(Instance, *gst.Buffer) gst.FlowReturn + // FindBestFormat allows you to override the implementation of the virtual method find_best_format. + // The function takes the following parameters: + // + // - downstreamCaps *gst.Caps + // - bestInfo *VideoInfo + // + // The function returns the following values: + // + // - atLeastOneAlpha bool + FindBestFormat func(Instance, *gst.Caps, *VideoInfo) bool + // UpdateCaps allows you to override the implementation of the virtual method update_caps. + // The function takes the following parameters: + // + // - caps *gst.Caps + // + // The function returns the following values: + // + // - goret *gst.Caps + UpdateCaps func(Instance, *gst.Caps) *gst.Caps +} + +// UnsafeApplyVideoAggregatorOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyVideoAggregatorOverrides[Instance VideoAggregator](gclass unsafe.Pointer, overrides VideoAggregatorOverrides[Instance]) { + gstbase.UnsafeApplyAggregatorOverrides(gclass, overrides.AggregatorOverrides) + + pclass := (*C.GstVideoAggregatorClass)(gclass) + + if overrides.AggregateFrames != nil { + pclass.aggregate_frames = (*[0]byte)(C._gotk4_gstvideo1_VideoAggregator_aggregate_frames) + } + + if overrides.FindBestFormat != nil { + pclass.find_best_format = (*[0]byte)(C._gotk4_gstvideo1_VideoAggregator_find_best_format) + } + + if overrides.UpdateCaps != nil { + pclass.update_caps = (*[0]byte)(C._gotk4_gstvideo1_VideoAggregator_update_caps) + } +} + // VideoAggregatorPadInstance is the instance type used by all types extending GstVideoAggregatorPad. It is used internally by the bindings. Users should use the interface [VideoAggregatorPad] instead. type VideoAggregatorPadInstance struct { _ [0]func() // equal guard @@ -10558,6 +11211,7 @@ type VideoAggregatorPad interface { upcastToGstVideoAggregatorPad() *VideoAggregatorPadInstance // GetCurrentBuffer wraps gst_video_aggregator_pad_get_current_buffer + // // The function returns the following values: // // - goret *gst.Buffer @@ -10572,6 +11226,7 @@ type VideoAggregatorPad interface { // returns. GetCurrentBuffer() *gst.Buffer // GetPreparedFrame wraps gst_video_aggregator_pad_get_prepared_frame + // // The function returns the following values: // // - goret *VideoFrame @@ -10586,6 +11241,7 @@ type VideoAggregatorPad interface { // returns. GetPreparedFrame() *VideoFrame // HasCurrentBuffer wraps gst_video_aggregator_pad_has_current_buffer + // // The function returns the following values: // // - goret bool @@ -10649,6 +11305,7 @@ func UnsafeVideoAggregatorPadToGlibFull(c VideoAggregatorPad) unsafe.Pointer { } // GetCurrentBuffer wraps gst_video_aggregator_pad_get_current_buffer +// // The function returns the following values: // // - goret *gst.Buffer @@ -10678,6 +11335,7 @@ func (pad *VideoAggregatorPadInstance) GetCurrentBuffer() *gst.Buffer { } // GetPreparedFrame wraps gst_video_aggregator_pad_get_prepared_frame +// // The function returns the following values: // // - goret *VideoFrame @@ -10707,6 +11365,7 @@ func (pad *VideoAggregatorPadInstance) GetPreparedFrame() *VideoFrame { } // HasCurrentBuffer wraps gst_video_aggregator_pad_has_current_buffer +// // The function returns the following values: // // - goret bool @@ -10755,6 +11414,74 @@ func (pad *VideoAggregatorPadInstance) SetNeedsAlpha(needsAlpha bool) { runtime.KeepAlive(needsAlpha) } +// VideoAggregatorPadOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type VideoAggregatorPadOverrides[Instance VideoAggregatorPad] struct { + // gstbase.AggregatorPadOverrides allows you to override virtual methods from the parent class gstbase.AggregatorPad + gstbase.AggregatorPadOverrides[Instance] + + // CleanFrame allows you to override the implementation of the virtual method clean_frame. + // The function takes the following parameters: + // + // - videoaggregator VideoAggregator + // - preparedFrame *VideoFrame + CleanFrame func(Instance, VideoAggregator, *VideoFrame) + // PrepareFrame allows you to override the implementation of the virtual method prepare_frame. + // The function takes the following parameters: + // + // - videoaggregator VideoAggregator + // - buffer *gst.Buffer + // - preparedFrame *VideoFrame + // + // The function returns the following values: + // + // - goret bool + PrepareFrame func(Instance, VideoAggregator, *gst.Buffer, *VideoFrame) bool + // PrepareFrameFinish allows you to override the implementation of the virtual method prepare_frame_finish. + // The function takes the following parameters: + // + // - videoaggregator VideoAggregator: the parent #GstVideoAggregator + // - preparedFrame *VideoFrame: the #GstVideoFrame to prepare into + PrepareFrameFinish func(Instance, VideoAggregator, *VideoFrame) + // PrepareFrameStart allows you to override the implementation of the virtual method prepare_frame_start. + // The function takes the following parameters: + // + // - videoaggregator VideoAggregator: the parent #GstVideoAggregator + // - buffer *gst.Buffer: the input #GstBuffer to prepare + // - preparedFrame *VideoFrame: the #GstVideoFrame to prepare into + PrepareFrameStart func(Instance, VideoAggregator, *gst.Buffer, *VideoFrame) + // UpdateConversionInfo allows you to override the implementation of the virtual method update_conversion_info. + UpdateConversionInfo func(Instance) +} + +// UnsafeApplyVideoAggregatorPadOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyVideoAggregatorPadOverrides[Instance VideoAggregatorPad](gclass unsafe.Pointer, overrides VideoAggregatorPadOverrides[Instance]) { + gstbase.UnsafeApplyAggregatorPadOverrides(gclass, overrides.AggregatorPadOverrides) + + pclass := (*C.GstVideoAggregatorPadClass)(gclass) + + if overrides.CleanFrame != nil { + pclass.clean_frame = (*[0]byte)(C._gotk4_gstvideo1_VideoAggregatorPad_clean_frame) + } + + if overrides.PrepareFrame != nil { + pclass.prepare_frame = (*[0]byte)(C._gotk4_gstvideo1_VideoAggregatorPad_prepare_frame) + } + + if overrides.PrepareFrameFinish != nil { + pclass.prepare_frame_finish = (*[0]byte)(C._gotk4_gstvideo1_VideoAggregatorPad_prepare_frame_finish) + } + + if overrides.PrepareFrameStart != nil { + pclass.prepare_frame_start = (*[0]byte)(C._gotk4_gstvideo1_VideoAggregatorPad_prepare_frame_start) + } + + if overrides.UpdateConversionInfo != nil { + pclass.update_conversion_info = (*[0]byte)(C._gotk4_gstvideo1_VideoAggregatorPad_update_conversion_info) + } +} + // VideoBufferPoolInstance is the instance type used by all types extending GstVideoBufferPool. It is used internally by the bindings. Users should use the interface [VideoBufferPool] instead. type VideoBufferPoolInstance struct { _ [0]func() // equal guard @@ -10810,6 +11537,7 @@ func UnsafeVideoBufferPoolToGlibFull(c VideoBufferPool) unsafe.Pointer { } // NewVideoBufferPool wraps gst_video_buffer_pool_new +// // The function returns the following values: // // - goret gst.BufferPool @@ -10828,6 +11556,20 @@ func NewVideoBufferPool() gst.BufferPool { return goret } +// VideoBufferPoolOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type VideoBufferPoolOverrides[Instance VideoBufferPool] struct { + // gst.BufferPoolOverrides allows you to override virtual methods from the parent class gst.BufferPool + gst.BufferPoolOverrides[Instance] + +} + +// UnsafeApplyVideoBufferPoolOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyVideoBufferPoolOverrides[Instance VideoBufferPool](gclass unsafe.Pointer, overrides VideoBufferPoolOverrides[Instance]) { + gst.UnsafeApplyBufferPoolOverrides(gclass, overrides.BufferPoolOverrides) +} + // VideoDecoderInstance is the instance type used by all types extending GstVideoDecoder. It is used internally by the bindings. Users should use the interface [VideoDecoder] instead. type VideoDecoderInstance struct { _ [0]func() // equal guard @@ -10969,6 +11711,7 @@ type VideoDecoder interface { // Removes next @n_bytes of input data and adds it to currently parsed frame. AddToFrame(int) // AllocateOutputBuffer wraps gst_video_decoder_allocate_output_buffer + // // The function returns the following values: // // - goret *gst.Buffer (nullable) @@ -11073,6 +11816,7 @@ type VideoDecoder interface { // should be called instead. FinishSubframe(*VideoCodecFrame) gst.FlowReturn // GetAllocator wraps gst_video_decoder_get_allocator + // // The function returns the following values: // // - allocator gst.Allocator (nullable): the #GstAllocator @@ -11086,11 +11830,13 @@ type VideoDecoder interface { // Unref the @allocator after use it. GetAllocator() (gst.Allocator, gst.AllocationParams) // GetBufferPool wraps gst_video_decoder_get_buffer_pool + // // The function returns the following values: // // - goret gst.BufferPool (nullable) GetBufferPool() gst.BufferPool // GetEstimateRate wraps gst_video_decoder_get_estimate_rate + // // The function returns the following values: // // - goret int @@ -11108,6 +11854,7 @@ type VideoDecoder interface { // Get a pending unfinished #GstVideoCodecFrame GetFrame(int) *VideoCodecFrame // GetFrames wraps gst_video_decoder_get_frames + // // The function returns the following values: // // - goret []*VideoCodecFrame @@ -11128,6 +11875,7 @@ type VideoDecoder interface { // the decoder baseclass in the @frame. GetInputSubframeIndex(*VideoCodecFrame) uint // GetLatency wraps gst_video_decoder_get_latency + // // The function returns the following values: // // - minLatency gst.ClockTime: address of variable in which to store the @@ -11154,11 +11902,13 @@ type VideoDecoder interface { // and should therefore occur as soon/skippy as possible. GetMaxDecodeTime(*VideoCodecFrame) gst.ClockTimeDiff // GetMaxErrors wraps gst_video_decoder_get_max_errors + // // The function returns the following values: // // - goret int GetMaxErrors() int // GetNeedsFormat wraps gst_video_decoder_get_needs_format + // // The function returns the following values: // // - goret bool @@ -11166,6 +11916,7 @@ type VideoDecoder interface { // Queries decoder required format handling. GetNeedsFormat() bool // GetNeedsSyncPoint wraps gst_video_decoder_get_needs_sync_point + // // The function returns the following values: // // - goret bool @@ -11174,6 +11925,7 @@ type VideoDecoder interface { // data in the beginning. GetNeedsSyncPoint() bool // GetOldestFrame wraps gst_video_decoder_get_oldest_frame + // // The function returns the following values: // // - goret *VideoCodecFrame (nullable) @@ -11181,6 +11933,7 @@ type VideoDecoder interface { // Get the oldest pending unfinished #GstVideoCodecFrame GetOldestFrame() *VideoCodecFrame // GetOutputState wraps gst_video_decoder_get_output_state + // // The function returns the following values: // // - goret *VideoCodecState (nullable) @@ -11188,6 +11941,7 @@ type VideoDecoder interface { // Get the #GstVideoCodecState currently describing the output stream. GetOutputState() *VideoCodecState // GetPacketized wraps gst_video_decoder_get_packetized + // // The function returns the following values: // // - goret bool @@ -11196,6 +11950,7 @@ type VideoDecoder interface { // base class. GetPacketized() bool // GetPendingFrameSize wraps gst_video_decoder_get_pending_frame_size + // // The function returns the following values: // // - goret uint @@ -11217,11 +11972,13 @@ type VideoDecoder interface { // the decoder baseclass. GetProcessedSubframeIndex(*VideoCodecFrame) uint // GetQosProportion wraps gst_video_decoder_get_qos_proportion + // // The function returns the following values: // // - goret float64 GetQosProportion() float64 // GetSubframeMode wraps gst_video_decoder_get_subframe_mode + // // The function returns the following values: // // - goret bool @@ -11231,6 +11988,7 @@ type VideoDecoder interface { // frame. GetSubframeMode() bool // HaveFrame wraps gst_video_decoder_have_frame + // // The function returns the following values: // // - goret gst.FlowReturn @@ -11271,6 +12029,7 @@ type VideoDecoder interface { // MT safe. MergeTags(*gst.TagList, gst.TagMergeMode) // Negotiate wraps gst_video_decoder_negotiate + // // The function returns the following values: // // - goret bool @@ -11546,6 +12305,7 @@ func (decoder *VideoDecoderInstance) AddToFrame(nBytes int) { } // AllocateOutputBuffer wraps gst_video_decoder_allocate_output_buffer +// // The function returns the following values: // // - goret *gst.Buffer (nullable) @@ -11778,6 +12538,7 @@ func (decoder *VideoDecoderInstance) FinishSubframe(frame *VideoCodecFrame) gst. } // GetAllocator wraps gst_video_decoder_get_allocator +// // The function returns the following values: // // - allocator gst.Allocator (nullable): the #GstAllocator @@ -11813,6 +12574,7 @@ func (decoder *VideoDecoderInstance) GetAllocator() (gst.Allocator, gst.Allocati } // GetBufferPool wraps gst_video_decoder_get_buffer_pool +// // The function returns the following values: // // - goret gst.BufferPool (nullable) @@ -11835,6 +12597,7 @@ func (decoder *VideoDecoderInstance) GetBufferPool() gst.BufferPool { } // GetEstimateRate wraps gst_video_decoder_get_estimate_rate +// // The function returns the following values: // // - goret int @@ -11887,6 +12650,7 @@ func (decoder *VideoDecoderInstance) GetFrame(frameNumber int) *VideoCodecFrame } // GetFrames wraps gst_video_decoder_get_frames +// // The function returns the following values: // // - goret []*VideoCodecFrame @@ -11947,6 +12711,7 @@ func (decoder *VideoDecoderInstance) GetInputSubframeIndex(frame *VideoCodecFram } // GetLatency wraps gst_video_decoder_get_latency +// // The function returns the following values: // // - minLatency gst.ClockTime: address of variable in which to store the @@ -12009,6 +12774,7 @@ func (decoder *VideoDecoderInstance) GetMaxDecodeTime(frame *VideoCodecFrame) gs } // GetMaxErrors wraps gst_video_decoder_get_max_errors +// // The function returns the following values: // // - goret int @@ -12029,6 +12795,7 @@ func (dec *VideoDecoderInstance) GetMaxErrors() int { } // GetNeedsFormat wraps gst_video_decoder_get_needs_format +// // The function returns the following values: // // - goret bool @@ -12053,6 +12820,7 @@ func (dec *VideoDecoderInstance) GetNeedsFormat() bool { } // GetNeedsSyncPoint wraps gst_video_decoder_get_needs_sync_point +// // The function returns the following values: // // - goret bool @@ -12078,6 +12846,7 @@ func (dec *VideoDecoderInstance) GetNeedsSyncPoint() bool { } // GetOldestFrame wraps gst_video_decoder_get_oldest_frame +// // The function returns the following values: // // - goret *VideoCodecFrame (nullable) @@ -12102,6 +12871,7 @@ func (decoder *VideoDecoderInstance) GetOldestFrame() *VideoCodecFrame { } // GetOutputState wraps gst_video_decoder_get_output_state +// // The function returns the following values: // // - goret *VideoCodecState (nullable) @@ -12126,6 +12896,7 @@ func (decoder *VideoDecoderInstance) GetOutputState() *VideoCodecState { } // GetPacketized wraps gst_video_decoder_get_packetized +// // The function returns the following values: // // - goret bool @@ -12151,6 +12922,7 @@ func (decoder *VideoDecoderInstance) GetPacketized() bool { } // GetPendingFrameSize wraps gst_video_decoder_get_pending_frame_size +// // The function returns the following values: // // - goret uint @@ -12205,6 +12977,7 @@ func (decoder *VideoDecoderInstance) GetProcessedSubframeIndex(frame *VideoCodec } // GetQosProportion wraps gst_video_decoder_get_qos_proportion +// // The function returns the following values: // // - goret float64 @@ -12225,6 +12998,7 @@ func (decoder *VideoDecoderInstance) GetQosProportion() float64 { } // GetSubframeMode wraps gst_video_decoder_get_subframe_mode +// // The function returns the following values: // // - goret bool @@ -12251,6 +13025,7 @@ func (decoder *VideoDecoderInstance) GetSubframeMode() bool { } // HaveFrame wraps gst_video_decoder_have_frame +// // The function returns the following values: // // - goret gst.FlowReturn @@ -12340,6 +13115,7 @@ func (decoder *VideoDecoderInstance) MergeTags(tags *gst.TagList, mode gst.TagMe } // Negotiate wraps gst_video_decoder_negotiate +// // The function returns the following values: // // - goret bool @@ -12788,6 +13564,267 @@ func (decoder *VideoDecoderInstance) SetUseDefaultPadAcceptcaps(use bool) { runtime.KeepAlive(use) } +// VideoDecoderOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type VideoDecoderOverrides[Instance VideoDecoder] struct { + // gst.ElementOverrides allows you to override virtual methods from the parent class gst.Element + gst.ElementOverrides[Instance] + + // Close allows you to override the implementation of the virtual method close. + // The function returns the following values: + // + // - goret bool + Close func(Instance) bool + // DecideAllocation allows you to override the implementation of the virtual method decide_allocation. + // The function takes the following parameters: + // + // - query *gst.Query + // + // The function returns the following values: + // + // - goret bool + DecideAllocation func(Instance, *gst.Query) bool + // Drain allows you to override the implementation of the virtual method drain. + // The function returns the following values: + // + // - goret gst.FlowReturn + Drain func(Instance) gst.FlowReturn + // Finish allows you to override the implementation of the virtual method finish. + // The function returns the following values: + // + // - goret gst.FlowReturn + Finish func(Instance) gst.FlowReturn + // Flush allows you to override the implementation of the virtual method flush. + // The function returns the following values: + // + // - goret bool + Flush func(Instance) bool + // Getcaps allows you to override the implementation of the virtual method getcaps. + // The function takes the following parameters: + // + // - filter *gst.Caps + // + // The function returns the following values: + // + // - goret *gst.Caps + Getcaps func(Instance, *gst.Caps) *gst.Caps + // HandleFrame allows you to override the implementation of the virtual method handle_frame. + // The function takes the following parameters: + // + // - frame *VideoCodecFrame: The frame to handle + // + // The function returns the following values: + // + // - goret gst.FlowReturn + HandleFrame func(Instance, *VideoCodecFrame) gst.FlowReturn + // HandleMissingData allows you to override the implementation of the virtual method handle_missing_data. + // The function takes the following parameters: + // + // - timestamp gst.ClockTime: Timestamp of the missing data + // - duration gst.ClockTime: Duration of the missing data + // + // The function returns the following values: + // + // - goret bool + HandleMissingData func(Instance, gst.ClockTime, gst.ClockTime) bool + // Negotiate allows you to override the implementation of the virtual method negotiate. + // The function returns the following values: + // + // - goret bool + Negotiate func(Instance) bool + // Open allows you to override the implementation of the virtual method open. + // The function returns the following values: + // + // - goret bool + Open func(Instance) bool + // Parse allows you to override the implementation of the virtual method parse. + // The function takes the following parameters: + // + // - frame *VideoCodecFrame + // - adapter gstbase.Adapter + // - atEos bool + // + // The function returns the following values: + // + // - goret gst.FlowReturn + Parse func(Instance, *VideoCodecFrame, gstbase.Adapter, bool) gst.FlowReturn + // ProposeAllocation allows you to override the implementation of the virtual method propose_allocation. + // The function takes the following parameters: + // + // - query *gst.Query + // + // The function returns the following values: + // + // - goret bool + ProposeAllocation func(Instance, *gst.Query) bool + // Reset allows you to override the implementation of the virtual method reset. + // The function takes the following parameters: + // + // - hard bool + // + // The function returns the following values: + // + // - goret bool + Reset func(Instance, bool) bool + // SetFormat allows you to override the implementation of the virtual method set_format. + // The function takes the following parameters: + // + // - state *VideoCodecState + // + // The function returns the following values: + // + // - goret bool + SetFormat func(Instance, *VideoCodecState) bool + // SinkEvent allows you to override the implementation of the virtual method sink_event. + // The function takes the following parameters: + // + // - event *gst.Event + // + // The function returns the following values: + // + // - goret bool + SinkEvent func(Instance, *gst.Event) bool + // SinkQuery allows you to override the implementation of the virtual method sink_query. + // The function takes the following parameters: + // + // - query *gst.Query + // + // The function returns the following values: + // + // - goret bool + SinkQuery func(Instance, *gst.Query) bool + // SrcEvent allows you to override the implementation of the virtual method src_event. + // The function takes the following parameters: + // + // - event *gst.Event + // + // The function returns the following values: + // + // - goret bool + SrcEvent func(Instance, *gst.Event) bool + // SrcQuery allows you to override the implementation of the virtual method src_query. + // The function takes the following parameters: + // + // - query *gst.Query + // + // The function returns the following values: + // + // - goret bool + SrcQuery func(Instance, *gst.Query) bool + // Start allows you to override the implementation of the virtual method start. + // The function returns the following values: + // + // - goret bool + Start func(Instance) bool + // Stop allows you to override the implementation of the virtual method stop. + // The function returns the following values: + // + // - goret bool + Stop func(Instance) bool + // TransformMeta allows you to override the implementation of the virtual method transform_meta. + // The function takes the following parameters: + // + // - frame *VideoCodecFrame + // - meta *gst.Meta + // + // The function returns the following values: + // + // - goret bool + TransformMeta func(Instance, *VideoCodecFrame, *gst.Meta) bool +} + +// UnsafeApplyVideoDecoderOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyVideoDecoderOverrides[Instance VideoDecoder](gclass unsafe.Pointer, overrides VideoDecoderOverrides[Instance]) { + gst.UnsafeApplyElementOverrides(gclass, overrides.ElementOverrides) + + pclass := (*C.GstVideoDecoderClass)(gclass) + + if overrides.Close != nil { + pclass.close = (*[0]byte)(C._gotk4_gstvideo1_VideoDecoder_close) + } + + if overrides.DecideAllocation != nil { + pclass.decide_allocation = (*[0]byte)(C._gotk4_gstvideo1_VideoDecoder_decide_allocation) + } + + if overrides.Drain != nil { + pclass.drain = (*[0]byte)(C._gotk4_gstvideo1_VideoDecoder_drain) + } + + if overrides.Finish != nil { + pclass.finish = (*[0]byte)(C._gotk4_gstvideo1_VideoDecoder_finish) + } + + if overrides.Flush != nil { + pclass.flush = (*[0]byte)(C._gotk4_gstvideo1_VideoDecoder_flush) + } + + if overrides.Getcaps != nil { + pclass.getcaps = (*[0]byte)(C._gotk4_gstvideo1_VideoDecoder_getcaps) + } + + if overrides.HandleFrame != nil { + pclass.handle_frame = (*[0]byte)(C._gotk4_gstvideo1_VideoDecoder_handle_frame) + } + + if overrides.HandleMissingData != nil { + pclass.handle_missing_data = (*[0]byte)(C._gotk4_gstvideo1_VideoDecoder_handle_missing_data) + } + + if overrides.Negotiate != nil { + pclass.negotiate = (*[0]byte)(C._gotk4_gstvideo1_VideoDecoder_negotiate) + } + + if overrides.Open != nil { + pclass.open = (*[0]byte)(C._gotk4_gstvideo1_VideoDecoder_open) + } + + if overrides.Parse != nil { + pclass.parse = (*[0]byte)(C._gotk4_gstvideo1_VideoDecoder_parse) + } + + if overrides.ProposeAllocation != nil { + pclass.propose_allocation = (*[0]byte)(C._gotk4_gstvideo1_VideoDecoder_propose_allocation) + } + + if overrides.Reset != nil { + pclass.reset = (*[0]byte)(C._gotk4_gstvideo1_VideoDecoder_reset) + } + + if overrides.SetFormat != nil { + pclass.set_format = (*[0]byte)(C._gotk4_gstvideo1_VideoDecoder_set_format) + } + + if overrides.SinkEvent != nil { + pclass.sink_event = (*[0]byte)(C._gotk4_gstvideo1_VideoDecoder_sink_event) + } + + if overrides.SinkQuery != nil { + pclass.sink_query = (*[0]byte)(C._gotk4_gstvideo1_VideoDecoder_sink_query) + } + + if overrides.SrcEvent != nil { + pclass.src_event = (*[0]byte)(C._gotk4_gstvideo1_VideoDecoder_src_event) + } + + if overrides.SrcQuery != nil { + pclass.src_query = (*[0]byte)(C._gotk4_gstvideo1_VideoDecoder_src_query) + } + + if overrides.Start != nil { + pclass.start = (*[0]byte)(C._gotk4_gstvideo1_VideoDecoder_start) + } + + if overrides.Stop != nil { + pclass.stop = (*[0]byte)(C._gotk4_gstvideo1_VideoDecoder_stop) + } + + if overrides.TransformMeta != nil { + pclass.transform_meta = (*[0]byte)(C._gotk4_gstvideo1_VideoDecoder_transform_meta) + } +} + // VideoEncoderInstance is the instance type used by all types extending GstVideoEncoder. It is used internally by the bindings. Users should use the interface [VideoEncoder] instead. type VideoEncoderInstance struct { _ [0]func() // equal guard @@ -12935,6 +13972,7 @@ type VideoEncoder interface { // will be pushed downstream. FinishSubframe(*VideoCodecFrame) gst.FlowReturn // GetAllocator wraps gst_video_encoder_get_allocator + // // The function returns the following values: // // - allocator gst.Allocator (nullable): the #GstAllocator @@ -12960,6 +13998,7 @@ type VideoEncoder interface { // Get a pending unfinished #GstVideoCodecFrame GetFrame(int) *VideoCodecFrame // GetFrames wraps gst_video_encoder_get_frames + // // The function returns the following values: // // - goret []*VideoCodecFrame @@ -12967,6 +14006,7 @@ type VideoEncoder interface { // Get all pending unfinished #GstVideoCodecFrame GetFrames() []*VideoCodecFrame // GetLatency wraps gst_video_encoder_get_latency + // // The function returns the following values: // // - minLatency gst.ClockTime: address of variable in which to store the @@ -12996,6 +14036,7 @@ type VideoEncoder interface { // #GstVideoEncoder:qos is disabled this function returns #G_MAXINT64. GetMaxEncodeTime(*VideoCodecFrame) gst.ClockTimeDiff // GetMinForceKeyUnitInterval wraps gst_video_encoder_get_min_force_key_unit_interval + // // The function returns the following values: // // - goret gst.ClockTime @@ -13004,6 +14045,7 @@ type VideoEncoder interface { // for more details. GetMinForceKeyUnitInterval() gst.ClockTime // GetOldestFrame wraps gst_video_encoder_get_oldest_frame + // // The function returns the following values: // // - goret *VideoCodecFrame (nullable) @@ -13011,6 +14053,7 @@ type VideoEncoder interface { // Get the oldest unfinished pending #GstVideoCodecFrame GetOldestFrame() *VideoCodecFrame // GetOutputState wraps gst_video_encoder_get_output_state + // // The function returns the following values: // // - goret *VideoCodecState (nullable) @@ -13018,6 +14061,7 @@ type VideoEncoder interface { // Get the current #GstVideoCodecState GetOutputState() *VideoCodecState // IsQosEnabled wraps gst_video_encoder_is_qos_enabled + // // The function returns the following values: // // - goret bool @@ -13043,6 +14087,7 @@ type VideoEncoder interface { // MT safe. MergeTags(*gst.TagList, gst.TagMergeMode) // Negotiate wraps gst_video_encoder_negotiate + // // The function returns the following values: // // - goret bool @@ -13328,6 +14373,7 @@ func (encoder *VideoEncoderInstance) FinishSubframe(frame *VideoCodecFrame) gst. } // GetAllocator wraps gst_video_encoder_get_allocator +// // The function returns the following values: // // - allocator gst.Allocator (nullable): the #GstAllocator @@ -13395,6 +14441,7 @@ func (encoder *VideoEncoderInstance) GetFrame(frameNumber int) *VideoCodecFrame } // GetFrames wraps gst_video_encoder_get_frames +// // The function returns the following values: // // - goret []*VideoCodecFrame @@ -13424,6 +14471,7 @@ func (encoder *VideoEncoderInstance) GetFrames() []*VideoCodecFrame { } // GetLatency wraps gst_video_encoder_get_latency +// // The function returns the following values: // // - minLatency gst.ClockTime: address of variable in which to store the @@ -13489,6 +14537,7 @@ func (encoder *VideoEncoderInstance) GetMaxEncodeTime(frame *VideoCodecFrame) gs } // GetMinForceKeyUnitInterval wraps gst_video_encoder_get_min_force_key_unit_interval +// // The function returns the following values: // // - goret gst.ClockTime @@ -13512,6 +14561,7 @@ func (encoder *VideoEncoderInstance) GetMinForceKeyUnitInterval() gst.ClockTime } // GetOldestFrame wraps gst_video_encoder_get_oldest_frame +// // The function returns the following values: // // - goret *VideoCodecFrame (nullable) @@ -13536,6 +14586,7 @@ func (encoder *VideoEncoderInstance) GetOldestFrame() *VideoCodecFrame { } // GetOutputState wraps gst_video_encoder_get_output_state +// // The function returns the following values: // // - goret *VideoCodecState (nullable) @@ -13560,6 +14611,7 @@ func (encoder *VideoEncoderInstance) GetOutputState() *VideoCodecState { } // IsQosEnabled wraps gst_video_encoder_is_qos_enabled +// // The function returns the following values: // // - goret bool @@ -13618,6 +14670,7 @@ func (encoder *VideoEncoderInstance) MergeTags(tags *gst.TagList, mode gst.TagMe } // Negotiate wraps gst_video_encoder_negotiate +// // The function returns the following values: // // - goret bool @@ -13827,6 +14880,242 @@ func (encoder *VideoEncoderInstance) SetQosEnabled(enabled bool) { runtime.KeepAlive(enabled) } +// VideoEncoderOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type VideoEncoderOverrides[Instance VideoEncoder] struct { + // gst.ElementOverrides allows you to override virtual methods from the parent class gst.Element + gst.ElementOverrides[Instance] + + // Close allows you to override the implementation of the virtual method close. + // The function returns the following values: + // + // - goret bool + Close func(Instance) bool + // DecideAllocation allows you to override the implementation of the virtual method decide_allocation. + // The function takes the following parameters: + // + // - query *gst.Query + // + // The function returns the following values: + // + // - goret bool + DecideAllocation func(Instance, *gst.Query) bool + // Finish allows you to override the implementation of the virtual method finish. + // The function returns the following values: + // + // - goret gst.FlowReturn + Finish func(Instance) gst.FlowReturn + // Flush allows you to override the implementation of the virtual method flush. + // The function returns the following values: + // + // - goret bool + Flush func(Instance) bool + // Getcaps allows you to override the implementation of the virtual method getcaps. + // The function takes the following parameters: + // + // - filter *gst.Caps + // + // The function returns the following values: + // + // - goret *gst.Caps + Getcaps func(Instance, *gst.Caps) *gst.Caps + // HandleFrame allows you to override the implementation of the virtual method handle_frame. + // The function takes the following parameters: + // + // - frame *VideoCodecFrame + // + // The function returns the following values: + // + // - goret gst.FlowReturn + HandleFrame func(Instance, *VideoCodecFrame) gst.FlowReturn + // Negotiate allows you to override the implementation of the virtual method negotiate. + // The function returns the following values: + // + // - goret bool + Negotiate func(Instance) bool + // Open allows you to override the implementation of the virtual method open. + // The function returns the following values: + // + // - goret bool + Open func(Instance) bool + // PrePush allows you to override the implementation of the virtual method pre_push. + // The function takes the following parameters: + // + // - frame *VideoCodecFrame + // + // The function returns the following values: + // + // - goret gst.FlowReturn + PrePush func(Instance, *VideoCodecFrame) gst.FlowReturn + // ProposeAllocation allows you to override the implementation of the virtual method propose_allocation. + // The function takes the following parameters: + // + // - query *gst.Query + // + // The function returns the following values: + // + // - goret bool + ProposeAllocation func(Instance, *gst.Query) bool + // Reset allows you to override the implementation of the virtual method reset. + // The function takes the following parameters: + // + // - hard bool + // + // The function returns the following values: + // + // - goret bool + Reset func(Instance, bool) bool + // SetFormat allows you to override the implementation of the virtual method set_format. + // The function takes the following parameters: + // + // - state *VideoCodecState + // + // The function returns the following values: + // + // - goret bool + SetFormat func(Instance, *VideoCodecState) bool + // SinkEvent allows you to override the implementation of the virtual method sink_event. + // The function takes the following parameters: + // + // - event *gst.Event + // + // The function returns the following values: + // + // - goret bool + SinkEvent func(Instance, *gst.Event) bool + // SinkQuery allows you to override the implementation of the virtual method sink_query. + // The function takes the following parameters: + // + // - query *gst.Query + // + // The function returns the following values: + // + // - goret bool + SinkQuery func(Instance, *gst.Query) bool + // SrcEvent allows you to override the implementation of the virtual method src_event. + // The function takes the following parameters: + // + // - event *gst.Event + // + // The function returns the following values: + // + // - goret bool + SrcEvent func(Instance, *gst.Event) bool + // SrcQuery allows you to override the implementation of the virtual method src_query. + // The function takes the following parameters: + // + // - query *gst.Query + // + // The function returns the following values: + // + // - goret bool + SrcQuery func(Instance, *gst.Query) bool + // Start allows you to override the implementation of the virtual method start. + // The function returns the following values: + // + // - goret bool + Start func(Instance) bool + // Stop allows you to override the implementation of the virtual method stop. + // The function returns the following values: + // + // - goret bool + Stop func(Instance) bool + // TransformMeta allows you to override the implementation of the virtual method transform_meta. + // The function takes the following parameters: + // + // - frame *VideoCodecFrame + // - meta *gst.Meta + // + // The function returns the following values: + // + // - goret bool + TransformMeta func(Instance, *VideoCodecFrame, *gst.Meta) bool +} + +// UnsafeApplyVideoEncoderOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyVideoEncoderOverrides[Instance VideoEncoder](gclass unsafe.Pointer, overrides VideoEncoderOverrides[Instance]) { + gst.UnsafeApplyElementOverrides(gclass, overrides.ElementOverrides) + + pclass := (*C.GstVideoEncoderClass)(gclass) + + if overrides.Close != nil { + pclass.close = (*[0]byte)(C._gotk4_gstvideo1_VideoEncoder_close) + } + + if overrides.DecideAllocation != nil { + pclass.decide_allocation = (*[0]byte)(C._gotk4_gstvideo1_VideoEncoder_decide_allocation) + } + + if overrides.Finish != nil { + pclass.finish = (*[0]byte)(C._gotk4_gstvideo1_VideoEncoder_finish) + } + + if overrides.Flush != nil { + pclass.flush = (*[0]byte)(C._gotk4_gstvideo1_VideoEncoder_flush) + } + + if overrides.Getcaps != nil { + pclass.getcaps = (*[0]byte)(C._gotk4_gstvideo1_VideoEncoder_getcaps) + } + + if overrides.HandleFrame != nil { + pclass.handle_frame = (*[0]byte)(C._gotk4_gstvideo1_VideoEncoder_handle_frame) + } + + if overrides.Negotiate != nil { + pclass.negotiate = (*[0]byte)(C._gotk4_gstvideo1_VideoEncoder_negotiate) + } + + if overrides.Open != nil { + pclass.open = (*[0]byte)(C._gotk4_gstvideo1_VideoEncoder_open) + } + + if overrides.PrePush != nil { + pclass.pre_push = (*[0]byte)(C._gotk4_gstvideo1_VideoEncoder_pre_push) + } + + if overrides.ProposeAllocation != nil { + pclass.propose_allocation = (*[0]byte)(C._gotk4_gstvideo1_VideoEncoder_propose_allocation) + } + + if overrides.Reset != nil { + pclass.reset = (*[0]byte)(C._gotk4_gstvideo1_VideoEncoder_reset) + } + + if overrides.SetFormat != nil { + pclass.set_format = (*[0]byte)(C._gotk4_gstvideo1_VideoEncoder_set_format) + } + + if overrides.SinkEvent != nil { + pclass.sink_event = (*[0]byte)(C._gotk4_gstvideo1_VideoEncoder_sink_event) + } + + if overrides.SinkQuery != nil { + pclass.sink_query = (*[0]byte)(C._gotk4_gstvideo1_VideoEncoder_sink_query) + } + + if overrides.SrcEvent != nil { + pclass.src_event = (*[0]byte)(C._gotk4_gstvideo1_VideoEncoder_src_event) + } + + if overrides.SrcQuery != nil { + pclass.src_query = (*[0]byte)(C._gotk4_gstvideo1_VideoEncoder_src_query) + } + + if overrides.Start != nil { + pclass.start = (*[0]byte)(C._gotk4_gstvideo1_VideoEncoder_start) + } + + if overrides.Stop != nil { + pclass.stop = (*[0]byte)(C._gotk4_gstvideo1_VideoEncoder_stop) + } + + if overrides.TransformMeta != nil { + pclass.transform_meta = (*[0]byte)(C._gotk4_gstvideo1_VideoEncoder_transform_meta) + } +} + // VideoFilterInstance is the instance type used by all types extending GstVideoFilter. It is used internally by the bindings. Users should use the interface [VideoFilter] instead. type VideoFilterInstance struct { _ [0]func() // equal guard @@ -13888,6 +15177,65 @@ func UnsafeVideoFilterToGlibFull(c VideoFilter) unsafe.Pointer { return gobject.UnsafeObjectToGlibFull(c) } +// VideoFilterOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type VideoFilterOverrides[Instance VideoFilter] struct { + // gstbase.BaseTransformOverrides allows you to override virtual methods from the parent class gstbase.BaseTransform + gstbase.BaseTransformOverrides[Instance] + + // SetInfo allows you to override the implementation of the virtual method set_info. + // The function takes the following parameters: + // + // - incaps *gst.Caps + // - inInfo *VideoInfo + // - outcaps *gst.Caps + // - outInfo *VideoInfo + // + // The function returns the following values: + // + // - goret bool + SetInfo func(Instance, *gst.Caps, *VideoInfo, *gst.Caps, *VideoInfo) bool + // TransformFrame allows you to override the implementation of the virtual method transform_frame. + // The function takes the following parameters: + // + // - inframe *VideoFrame + // - outframe *VideoFrame + // + // The function returns the following values: + // + // - goret gst.FlowReturn + TransformFrame func(Instance, *VideoFrame, *VideoFrame) gst.FlowReturn + // TransformFrameIP allows you to override the implementation of the virtual method transform_frame_ip. + // The function takes the following parameters: + // + // - frame *VideoFrame + // + // The function returns the following values: + // + // - goret gst.FlowReturn + TransformFrameIP func(Instance, *VideoFrame) gst.FlowReturn +} + +// UnsafeApplyVideoFilterOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyVideoFilterOverrides[Instance VideoFilter](gclass unsafe.Pointer, overrides VideoFilterOverrides[Instance]) { + gstbase.UnsafeApplyBaseTransformOverrides(gclass, overrides.BaseTransformOverrides) + + pclass := (*C.GstVideoFilterClass)(gclass) + + if overrides.SetInfo != nil { + pclass.set_info = (*[0]byte)(C._gotk4_gstvideo1_VideoFilter_set_info) + } + + if overrides.TransformFrame != nil { + pclass.transform_frame = (*[0]byte)(C._gotk4_gstvideo1_VideoFilter_transform_frame) + } + + if overrides.TransformFrameIP != nil { + pclass.transform_frame_ip = (*[0]byte)(C._gotk4_gstvideo1_VideoFilter_transform_frame_ip) + } +} + // VideoSinkInstance is the instance type used by all types extending GstVideoSink. It is used internally by the bindings. Users should use the interface [VideoSink] instead. type VideoSinkInstance struct { _ [0]func() // equal guard @@ -13994,6 +15342,49 @@ func VideoSinkCenterRect(src VideoRectangle, dst VideoRectangle, scaling bool) V return result } +// VideoSinkOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type VideoSinkOverrides[Instance VideoSink] struct { + // gstbase.BaseSinkOverrides allows you to override virtual methods from the parent class gstbase.BaseSink + gstbase.BaseSinkOverrides[Instance] + + // SetInfo allows you to override the implementation of the virtual method set_info. + // The function takes the following parameters: + // + // - caps *gst.Caps: A #GstCaps. + // - info *VideoInfo: A #GstVideoInfo corresponding to @caps. + // + // The function returns the following values: + // + // - goret bool + SetInfo func(Instance, *gst.Caps, *VideoInfo) bool + // ShowFrame allows you to override the implementation of the virtual method show_frame. + // The function takes the following parameters: + // + // - buf *gst.Buffer + // + // The function returns the following values: + // + // - goret gst.FlowReturn + ShowFrame func(Instance, *gst.Buffer) gst.FlowReturn +} + +// UnsafeApplyVideoSinkOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyVideoSinkOverrides[Instance VideoSink](gclass unsafe.Pointer, overrides VideoSinkOverrides[Instance]) { + gstbase.UnsafeApplyBaseSinkOverrides(gclass, overrides.BaseSinkOverrides) + + pclass := (*C.GstVideoSinkClass)(gclass) + + if overrides.SetInfo != nil { + pclass.set_info = (*[0]byte)(C._gotk4_gstvideo1_VideoSink_set_info) + } + + if overrides.ShowFrame != nil { + pclass.show_frame = (*[0]byte)(C._gotk4_gstvideo1_VideoSink_show_frame) + } +} + // VideoAggregatorConvertPadInstance is the instance type used by all types extending GstVideoAggregatorConvertPad. It is used internally by the bindings. Users should use the interface [VideoAggregatorConvertPad] instead. type VideoAggregatorConvertPadInstance struct { _ [0]func() // equal guard @@ -14075,6 +15466,32 @@ func (pad *VideoAggregatorConvertPadInstance) UpdateConversionInfo() { runtime.KeepAlive(pad) } +// VideoAggregatorConvertPadOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type VideoAggregatorConvertPadOverrides[Instance VideoAggregatorConvertPad] struct { + // VideoAggregatorPadOverrides allows you to override virtual methods from the parent class VideoAggregatorPad + VideoAggregatorPadOverrides[Instance] + + // CreateConversionInfo allows you to override the implementation of the virtual method create_conversion_info. + // The function takes the following parameters: + // + // - agg VideoAggregator + // - conversionInfo *VideoInfo + CreateConversionInfo func(Instance, VideoAggregator, *VideoInfo) +} + +// UnsafeApplyVideoAggregatorConvertPadOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyVideoAggregatorConvertPadOverrides[Instance VideoAggregatorConvertPad](gclass unsafe.Pointer, overrides VideoAggregatorConvertPadOverrides[Instance]) { + UnsafeApplyVideoAggregatorPadOverrides(gclass, overrides.VideoAggregatorPadOverrides) + + pclass := (*C.GstVideoAggregatorConvertPadClass)(gclass) + + if overrides.CreateConversionInfo != nil { + pclass.create_conversion_info = (*[0]byte)(C._gotk4_gstvideo1_VideoAggregatorConvertPad_create_conversion_info) + } +} + // VideoAggregatorParallelConvertPadInstance is the instance type used by all types extending GstVideoAggregatorParallelConvertPad. It is used internally by the bindings. Users should use the interface [VideoAggregatorParallelConvertPad] instead. type VideoAggregatorParallelConvertPadInstance struct { _ [0]func() // equal guard @@ -14139,6 +15556,20 @@ func UnsafeVideoAggregatorParallelConvertPadToGlibFull(c VideoAggregatorParallel return gobject.UnsafeObjectToGlibFull(c) } +// VideoAggregatorParallelConvertPadOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type VideoAggregatorParallelConvertPadOverrides[Instance VideoAggregatorParallelConvertPad] struct { + // VideoAggregatorConvertPadOverrides allows you to override virtual methods from the parent class VideoAggregatorConvertPad + VideoAggregatorConvertPadOverrides[Instance] + +} + +// UnsafeApplyVideoAggregatorParallelConvertPadOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyVideoAggregatorParallelConvertPadOverrides[Instance VideoAggregatorParallelConvertPad](gclass unsafe.Pointer, overrides VideoAggregatorParallelConvertPadOverrides[Instance]) { + UnsafeApplyVideoAggregatorConvertPadOverrides(gclass, overrides.VideoAggregatorConvertPadOverrides) +} + // AncillaryMeta wraps GstAncillaryMeta // // #GstMeta for carrying SMPTE-291M Ancillary data. Note that all the ADF fields @@ -14157,7 +15588,7 @@ func UnsafeAncillaryMetaFromGlibBorrow(p unsafe.Pointer) *AncillaryMeta { return &AncillaryMeta{&ancillaryMeta{(*C.GstAncillaryMeta)(p)}} } -// UnsafeAncillaryMetaFromGlibNone is used to convert raw C.GstAncillaryMeta pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeAncillaryMetaFromGlibNone is used to convert raw C.GstAncillaryMeta pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeAncillaryMetaFromGlibNone(p unsafe.Pointer) *AncillaryMeta { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeAncillaryMetaFromGlibBorrow(p) @@ -14170,7 +15601,7 @@ func UnsafeAncillaryMetaFromGlibNone(p unsafe.Pointer) *AncillaryMeta { return wrapped } -// UnsafeAncillaryMetaFromGlibFull is used to convert raw C.GstAncillaryMeta pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeAncillaryMetaFromGlibFull is used to convert raw C.GstAncillaryMeta pointers to go while taking ownership. This is used by the bindings internally. func UnsafeAncillaryMetaFromGlibFull(p unsafe.Pointer) *AncillaryMeta { wrapped := UnsafeAncillaryMetaFromGlibBorrow(p) runtime.SetFinalizer( @@ -14202,7 +15633,9 @@ func UnsafeAncillaryMetaToGlibFull(a *AncillaryMeta) unsafe.Pointer { a.native = nil // AncillaryMeta is invalid from here on return _p } + // AncillaryMetaGetInfo wraps gst_ancillary_meta_get_info +// // The function returns the following values: // // - goret *gst.MetaInfo @@ -14221,6 +15654,8 @@ func AncillaryMetaGetInfo() *gst.MetaInfo { // ColorBalanceChannelClass wraps GstColorBalanceChannelClass // // Color-balance channel class. +// +// ColorBalanceChannelClass is the type struct for [ColorBalanceChannel] type ColorBalanceChannelClass struct { *colorBalanceChannelClass } @@ -14235,31 +15670,6 @@ func UnsafeColorBalanceChannelClassFromGlibBorrow(p unsafe.Pointer) *ColorBalanc return &ColorBalanceChannelClass{&colorBalanceChannelClass{(*C.GstColorBalanceChannelClass)(p)}} } -// UnsafeColorBalanceChannelClassFromGlibNone is used to convert raw C.GstColorBalanceChannelClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeColorBalanceChannelClassFromGlibNone(p unsafe.Pointer) *ColorBalanceChannelClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeColorBalanceChannelClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.colorBalanceChannelClass, - func (intern *colorBalanceChannelClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeColorBalanceChannelClassFromGlibFull is used to convert raw C.GstColorBalanceChannelClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeColorBalanceChannelClassFromGlibFull(p unsafe.Pointer) *ColorBalanceChannelClass { - wrapped := UnsafeColorBalanceChannelClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.colorBalanceChannelClass, - func (intern *colorBalanceChannelClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeColorBalanceChannelClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [ColorBalanceChannelClass] is expected to work anymore. @@ -14272,14 +15682,15 @@ func UnsafeColorBalanceChannelClassToGlibNone(c *ColorBalanceChannelClass) unsaf return unsafe.Pointer(c.native) } -// UnsafeColorBalanceChannelClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeColorBalanceChannelClassToGlibFull(c *ColorBalanceChannelClass) unsafe.Pointer { - runtime.SetFinalizer(c.colorBalanceChannelClass, nil) - _p := unsafe.Pointer(c.native) - c.native = nil // ColorBalanceChannelClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (c *ColorBalanceChannelClass) ParentClass() *gobject.ObjectClass { + parent := gobject.UnsafeObjectClassFromGlibBorrow(UnsafeColorBalanceChannelClassToGlibNone(c)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *ColorBalanceChannelClass) {}, c) + return parent } + // ColorBalanceInterface wraps GstColorBalanceInterface // // Color-balance interface. @@ -14297,7 +15708,7 @@ func UnsafeColorBalanceInterfaceFromGlibBorrow(p unsafe.Pointer) *ColorBalanceIn return &ColorBalanceInterface{&colorBalanceInterface{(*C.GstColorBalanceInterface)(p)}} } -// UnsafeColorBalanceInterfaceFromGlibNone is used to convert raw C.GstColorBalanceInterface pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeColorBalanceInterfaceFromGlibNone is used to convert raw C.GstColorBalanceInterface pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeColorBalanceInterfaceFromGlibNone(p unsafe.Pointer) *ColorBalanceInterface { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeColorBalanceInterfaceFromGlibBorrow(p) @@ -14310,7 +15721,7 @@ func UnsafeColorBalanceInterfaceFromGlibNone(p unsafe.Pointer) *ColorBalanceInte return wrapped } -// UnsafeColorBalanceInterfaceFromGlibFull is used to convert raw C.GstColorBalanceInterface pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeColorBalanceInterfaceFromGlibFull is used to convert raw C.GstColorBalanceInterface pointers to go while taking ownership. This is used by the bindings internally. func UnsafeColorBalanceInterfaceFromGlibFull(p unsafe.Pointer) *ColorBalanceInterface { wrapped := UnsafeColorBalanceInterfaceFromGlibBorrow(p) runtime.SetFinalizer( @@ -14342,6 +15753,7 @@ func UnsafeColorBalanceInterfaceToGlibFull(c *ColorBalanceInterface) unsafe.Poin c.native = nil // ColorBalanceInterface is invalid from here on return _p } + // NavigationInterface wraps GstNavigationInterface // // Navigation interface. @@ -14359,7 +15771,7 @@ func UnsafeNavigationInterfaceFromGlibBorrow(p unsafe.Pointer) *NavigationInterf return &NavigationInterface{&navigationInterface{(*C.GstNavigationInterface)(p)}} } -// UnsafeNavigationInterfaceFromGlibNone is used to convert raw C.GstNavigationInterface pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeNavigationInterfaceFromGlibNone is used to convert raw C.GstNavigationInterface pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeNavigationInterfaceFromGlibNone(p unsafe.Pointer) *NavigationInterface { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeNavigationInterfaceFromGlibBorrow(p) @@ -14372,7 +15784,7 @@ func UnsafeNavigationInterfaceFromGlibNone(p unsafe.Pointer) *NavigationInterfac return wrapped } -// UnsafeNavigationInterfaceFromGlibFull is used to convert raw C.GstNavigationInterface pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeNavigationInterfaceFromGlibFull is used to convert raw C.GstNavigationInterface pointers to go while taking ownership. This is used by the bindings internally. func UnsafeNavigationInterfaceFromGlibFull(p unsafe.Pointer) *NavigationInterface { wrapped := UnsafeNavigationInterfaceFromGlibBorrow(p) runtime.SetFinalizer( @@ -14404,6 +15816,7 @@ func UnsafeNavigationInterfaceToGlibFull(n *NavigationInterface) unsafe.Pointer n.native = nil // NavigationInterface is invalid from here on return _p } + // VideoAFDMeta wraps GstVideoAFDMeta // // Active Format Description (AFD) @@ -14434,7 +15847,7 @@ func UnsafeVideoAFDMetaFromGlibBorrow(p unsafe.Pointer) *VideoAFDMeta { return &VideoAFDMeta{&videoAFDMeta{(*C.GstVideoAFDMeta)(p)}} } -// UnsafeVideoAFDMetaFromGlibNone is used to convert raw C.GstVideoAFDMeta pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeVideoAFDMetaFromGlibNone is used to convert raw C.GstVideoAFDMeta pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeVideoAFDMetaFromGlibNone(p unsafe.Pointer) *VideoAFDMeta { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeVideoAFDMetaFromGlibBorrow(p) @@ -14447,7 +15860,7 @@ func UnsafeVideoAFDMetaFromGlibNone(p unsafe.Pointer) *VideoAFDMeta { return wrapped } -// UnsafeVideoAFDMetaFromGlibFull is used to convert raw C.GstVideoAFDMeta pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeVideoAFDMetaFromGlibFull is used to convert raw C.GstVideoAFDMeta pointers to go while taking ownership. This is used by the bindings internally. func UnsafeVideoAFDMetaFromGlibFull(p unsafe.Pointer) *VideoAFDMeta { wrapped := UnsafeVideoAFDMetaFromGlibBorrow(p) runtime.SetFinalizer( @@ -14479,7 +15892,9 @@ func UnsafeVideoAFDMetaToGlibFull(v *VideoAFDMeta) unsafe.Pointer { v.native = nil // VideoAFDMeta is invalid from here on return _p } + // VideoAFDMetaGetInfo wraps gst_video_afd_meta_get_info +// // The function returns the following values: // // - goret *gst.MetaInfo @@ -14521,7 +15936,7 @@ func UnsafeVideoAffineTransformationMetaFromGlibBorrow(p unsafe.Pointer) *VideoA return &VideoAffineTransformationMeta{&videoAffineTransformationMeta{(*C.GstVideoAffineTransformationMeta)(p)}} } -// UnsafeVideoAffineTransformationMetaFromGlibNone is used to convert raw C.GstVideoAffineTransformationMeta pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeVideoAffineTransformationMetaFromGlibNone is used to convert raw C.GstVideoAffineTransformationMeta pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeVideoAffineTransformationMetaFromGlibNone(p unsafe.Pointer) *VideoAffineTransformationMeta { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeVideoAffineTransformationMetaFromGlibBorrow(p) @@ -14534,7 +15949,7 @@ func UnsafeVideoAffineTransformationMetaFromGlibNone(p unsafe.Pointer) *VideoAff return wrapped } -// UnsafeVideoAffineTransformationMetaFromGlibFull is used to convert raw C.GstVideoAffineTransformationMeta pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeVideoAffineTransformationMetaFromGlibFull is used to convert raw C.GstVideoAffineTransformationMeta pointers to go while taking ownership. This is used by the bindings internally. func UnsafeVideoAffineTransformationMetaFromGlibFull(p unsafe.Pointer) *VideoAffineTransformationMeta { wrapped := UnsafeVideoAffineTransformationMetaFromGlibBorrow(p) runtime.SetFinalizer( @@ -14566,7 +15981,9 @@ func UnsafeVideoAffineTransformationMetaToGlibFull(v *VideoAffineTransformationM v.native = nil // VideoAffineTransformationMeta is invalid from here on return _p } + // VideoAffineTransformationMetaGetInfo wraps gst_video_affine_transformation_meta_get_info +// // The function returns the following values: // // - goret *gst.MetaInfo @@ -14605,6 +16022,8 @@ func (meta *VideoAffineTransformationMeta) ApplyMatrix(matrix [16]float32) { } // VideoAggregatorClass wraps GstVideoAggregatorClass +// +// VideoAggregatorClass is the type struct for [VideoAggregator] type VideoAggregatorClass struct { *videoAggregatorClass } @@ -14619,31 +16038,6 @@ func UnsafeVideoAggregatorClassFromGlibBorrow(p unsafe.Pointer) *VideoAggregator return &VideoAggregatorClass{&videoAggregatorClass{(*C.GstVideoAggregatorClass)(p)}} } -// UnsafeVideoAggregatorClassFromGlibNone is used to convert raw C.GstVideoAggregatorClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeVideoAggregatorClassFromGlibNone(p unsafe.Pointer) *VideoAggregatorClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeVideoAggregatorClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.videoAggregatorClass, - func (intern *videoAggregatorClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeVideoAggregatorClassFromGlibFull is used to convert raw C.GstVideoAggregatorClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeVideoAggregatorClassFromGlibFull(p unsafe.Pointer) *VideoAggregatorClass { - wrapped := UnsafeVideoAggregatorClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.videoAggregatorClass, - func (intern *videoAggregatorClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeVideoAggregatorClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [VideoAggregatorClass] is expected to work anymore. @@ -14656,15 +16050,18 @@ func UnsafeVideoAggregatorClassToGlibNone(v *VideoAggregatorClass) unsafe.Pointe return unsafe.Pointer(v.native) } -// UnsafeVideoAggregatorClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeVideoAggregatorClassToGlibFull(v *VideoAggregatorClass) unsafe.Pointer { - runtime.SetFinalizer(v.videoAggregatorClass, nil) - _p := unsafe.Pointer(v.native) - v.native = nil // VideoAggregatorClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (v *VideoAggregatorClass) ParentClass() *gstbase.AggregatorClass { + parent := gstbase.UnsafeAggregatorClassFromGlibBorrow(UnsafeVideoAggregatorClassToGlibNone(v)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *VideoAggregatorClass) {}, v) + return parent } + // VideoAggregatorConvertPadClass wraps GstVideoAggregatorConvertPadClass +// +// VideoAggregatorConvertPadClass is the type struct for [VideoAggregatorConvertPad] type VideoAggregatorConvertPadClass struct { *videoAggregatorConvertPadClass } @@ -14679,31 +16076,6 @@ func UnsafeVideoAggregatorConvertPadClassFromGlibBorrow(p unsafe.Pointer) *Video return &VideoAggregatorConvertPadClass{&videoAggregatorConvertPadClass{(*C.GstVideoAggregatorConvertPadClass)(p)}} } -// UnsafeVideoAggregatorConvertPadClassFromGlibNone is used to convert raw C.GstVideoAggregatorConvertPadClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeVideoAggregatorConvertPadClassFromGlibNone(p unsafe.Pointer) *VideoAggregatorConvertPadClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeVideoAggregatorConvertPadClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.videoAggregatorConvertPadClass, - func (intern *videoAggregatorConvertPadClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeVideoAggregatorConvertPadClassFromGlibFull is used to convert raw C.GstVideoAggregatorConvertPadClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeVideoAggregatorConvertPadClassFromGlibFull(p unsafe.Pointer) *VideoAggregatorConvertPadClass { - wrapped := UnsafeVideoAggregatorConvertPadClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.videoAggregatorConvertPadClass, - func (intern *videoAggregatorConvertPadClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeVideoAggregatorConvertPadClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [VideoAggregatorConvertPadClass] is expected to work anymore. @@ -14716,15 +16088,18 @@ func UnsafeVideoAggregatorConvertPadClassToGlibNone(v *VideoAggregatorConvertPad return unsafe.Pointer(v.native) } -// UnsafeVideoAggregatorConvertPadClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeVideoAggregatorConvertPadClassToGlibFull(v *VideoAggregatorConvertPadClass) unsafe.Pointer { - runtime.SetFinalizer(v.videoAggregatorConvertPadClass, nil) - _p := unsafe.Pointer(v.native) - v.native = nil // VideoAggregatorConvertPadClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (v *VideoAggregatorConvertPadClass) ParentClass() *VideoAggregatorPadClass { + parent := UnsafeVideoAggregatorPadClassFromGlibBorrow(UnsafeVideoAggregatorConvertPadClassToGlibNone(v)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *VideoAggregatorConvertPadClass) {}, v) + return parent } + // VideoAggregatorPadClass wraps GstVideoAggregatorPadClass +// +// VideoAggregatorPadClass is the type struct for [VideoAggregatorPad] type VideoAggregatorPadClass struct { *videoAggregatorPadClass } @@ -14739,31 +16114,6 @@ func UnsafeVideoAggregatorPadClassFromGlibBorrow(p unsafe.Pointer) *VideoAggrega return &VideoAggregatorPadClass{&videoAggregatorPadClass{(*C.GstVideoAggregatorPadClass)(p)}} } -// UnsafeVideoAggregatorPadClassFromGlibNone is used to convert raw C.GstVideoAggregatorPadClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeVideoAggregatorPadClassFromGlibNone(p unsafe.Pointer) *VideoAggregatorPadClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeVideoAggregatorPadClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.videoAggregatorPadClass, - func (intern *videoAggregatorPadClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeVideoAggregatorPadClassFromGlibFull is used to convert raw C.GstVideoAggregatorPadClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeVideoAggregatorPadClassFromGlibFull(p unsafe.Pointer) *VideoAggregatorPadClass { - wrapped := UnsafeVideoAggregatorPadClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.videoAggregatorPadClass, - func (intern *videoAggregatorPadClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeVideoAggregatorPadClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [VideoAggregatorPadClass] is expected to work anymore. @@ -14776,15 +16126,18 @@ func UnsafeVideoAggregatorPadClassToGlibNone(v *VideoAggregatorPadClass) unsafe. return unsafe.Pointer(v.native) } -// UnsafeVideoAggregatorPadClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeVideoAggregatorPadClassToGlibFull(v *VideoAggregatorPadClass) unsafe.Pointer { - runtime.SetFinalizer(v.videoAggregatorPadClass, nil) - _p := unsafe.Pointer(v.native) - v.native = nil // VideoAggregatorPadClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (v *VideoAggregatorPadClass) ParentClass() *gstbase.AggregatorPadClass { + parent := gstbase.UnsafeAggregatorPadClassFromGlibBorrow(UnsafeVideoAggregatorPadClassToGlibNone(v)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *VideoAggregatorPadClass) {}, v) + return parent } + // VideoAggregatorParallelConvertPadClass wraps GstVideoAggregatorParallelConvertPadClass +// +// VideoAggregatorParallelConvertPadClass is the type struct for [VideoAggregatorParallelConvertPad] type VideoAggregatorParallelConvertPadClass struct { *videoAggregatorParallelConvertPadClass } @@ -14799,31 +16152,6 @@ func UnsafeVideoAggregatorParallelConvertPadClassFromGlibBorrow(p unsafe.Pointer return &VideoAggregatorParallelConvertPadClass{&videoAggregatorParallelConvertPadClass{(*C.GstVideoAggregatorParallelConvertPadClass)(p)}} } -// UnsafeVideoAggregatorParallelConvertPadClassFromGlibNone is used to convert raw C.GstVideoAggregatorParallelConvertPadClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeVideoAggregatorParallelConvertPadClassFromGlibNone(p unsafe.Pointer) *VideoAggregatorParallelConvertPadClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeVideoAggregatorParallelConvertPadClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.videoAggregatorParallelConvertPadClass, - func (intern *videoAggregatorParallelConvertPadClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeVideoAggregatorParallelConvertPadClassFromGlibFull is used to convert raw C.GstVideoAggregatorParallelConvertPadClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeVideoAggregatorParallelConvertPadClassFromGlibFull(p unsafe.Pointer) *VideoAggregatorParallelConvertPadClass { - wrapped := UnsafeVideoAggregatorParallelConvertPadClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.videoAggregatorParallelConvertPadClass, - func (intern *videoAggregatorParallelConvertPadClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeVideoAggregatorParallelConvertPadClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [VideoAggregatorParallelConvertPadClass] is expected to work anymore. @@ -14836,14 +16164,15 @@ func UnsafeVideoAggregatorParallelConvertPadClassToGlibNone(v *VideoAggregatorPa return unsafe.Pointer(v.native) } -// UnsafeVideoAggregatorParallelConvertPadClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeVideoAggregatorParallelConvertPadClassToGlibFull(v *VideoAggregatorParallelConvertPadClass) unsafe.Pointer { - runtime.SetFinalizer(v.videoAggregatorParallelConvertPadClass, nil) - _p := unsafe.Pointer(v.native) - v.native = nil // VideoAggregatorParallelConvertPadClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (v *VideoAggregatorParallelConvertPadClass) ParentClass() *VideoAggregatorConvertPadClass { + parent := UnsafeVideoAggregatorConvertPadClassFromGlibBorrow(UnsafeVideoAggregatorParallelConvertPadClassToGlibNone(v)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *VideoAggregatorParallelConvertPadClass) {}, v) + return parent } + // VideoAlignment wraps GstVideoAlignment // // Extra alignment parameters for the memory of video buffers. This @@ -14863,7 +16192,7 @@ func UnsafeVideoAlignmentFromGlibBorrow(p unsafe.Pointer) *VideoAlignment { return &VideoAlignment{&videoAlignment{(*C.GstVideoAlignment)(p)}} } -// UnsafeVideoAlignmentFromGlibNone is used to convert raw C.GstVideoAlignment pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeVideoAlignmentFromGlibNone is used to convert raw C.GstVideoAlignment pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeVideoAlignmentFromGlibNone(p unsafe.Pointer) *VideoAlignment { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeVideoAlignmentFromGlibBorrow(p) @@ -14876,7 +16205,7 @@ func UnsafeVideoAlignmentFromGlibNone(p unsafe.Pointer) *VideoAlignment { return wrapped } -// UnsafeVideoAlignmentFromGlibFull is used to convert raw C.GstVideoAlignment pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeVideoAlignmentFromGlibFull is used to convert raw C.GstVideoAlignment pointers to go while taking ownership. This is used by the bindings internally. func UnsafeVideoAlignmentFromGlibFull(p unsafe.Pointer) *VideoAlignment { wrapped := UnsafeVideoAlignmentFromGlibBorrow(p) runtime.SetFinalizer( @@ -14908,6 +16237,7 @@ func UnsafeVideoAlignmentToGlibFull(v *VideoAlignment) unsafe.Pointer { v.native = nil // VideoAlignment is invalid from here on return _p } + // Reset wraps gst_video_alignment_reset // // Set @align to its default values with no padding and no alignment. @@ -14940,7 +16270,7 @@ func UnsafeVideoAncillaryFromGlibBorrow(p unsafe.Pointer) *VideoAncillary { return &VideoAncillary{&videoAncillary{(*C.GstVideoAncillary)(p)}} } -// UnsafeVideoAncillaryFromGlibNone is used to convert raw C.GstVideoAncillary pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeVideoAncillaryFromGlibNone is used to convert raw C.GstVideoAncillary pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeVideoAncillaryFromGlibNone(p unsafe.Pointer) *VideoAncillary { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeVideoAncillaryFromGlibBorrow(p) @@ -14953,7 +16283,7 @@ func UnsafeVideoAncillaryFromGlibNone(p unsafe.Pointer) *VideoAncillary { return wrapped } -// UnsafeVideoAncillaryFromGlibFull is used to convert raw C.GstVideoAncillary pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeVideoAncillaryFromGlibFull is used to convert raw C.GstVideoAncillary pointers to go while taking ownership. This is used by the bindings internally. func UnsafeVideoAncillaryFromGlibFull(p unsafe.Pointer) *VideoAncillary { wrapped := UnsafeVideoAncillaryFromGlibBorrow(p) runtime.SetFinalizer( @@ -14985,6 +16315,7 @@ func UnsafeVideoAncillaryToGlibFull(v *VideoAncillary) unsafe.Pointer { v.native = nil // VideoAncillary is invalid from here on return _p } + // VideoBarMeta wraps GstVideoBarMeta // // Bar data should be included in video user data @@ -15013,7 +16344,7 @@ func UnsafeVideoBarMetaFromGlibBorrow(p unsafe.Pointer) *VideoBarMeta { return &VideoBarMeta{&videoBarMeta{(*C.GstVideoBarMeta)(p)}} } -// UnsafeVideoBarMetaFromGlibNone is used to convert raw C.GstVideoBarMeta pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeVideoBarMetaFromGlibNone is used to convert raw C.GstVideoBarMeta pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeVideoBarMetaFromGlibNone(p unsafe.Pointer) *VideoBarMeta { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeVideoBarMetaFromGlibBorrow(p) @@ -15026,7 +16357,7 @@ func UnsafeVideoBarMetaFromGlibNone(p unsafe.Pointer) *VideoBarMeta { return wrapped } -// UnsafeVideoBarMetaFromGlibFull is used to convert raw C.GstVideoBarMeta pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeVideoBarMetaFromGlibFull is used to convert raw C.GstVideoBarMeta pointers to go while taking ownership. This is used by the bindings internally. func UnsafeVideoBarMetaFromGlibFull(p unsafe.Pointer) *VideoBarMeta { wrapped := UnsafeVideoBarMetaFromGlibBorrow(p) runtime.SetFinalizer( @@ -15058,7 +16389,9 @@ func UnsafeVideoBarMetaToGlibFull(v *VideoBarMeta) unsafe.Pointer { v.native = nil // VideoBarMeta is invalid from here on return _p } + // VideoBarMetaGetInfo wraps gst_video_bar_meta_get_info +// // The function returns the following values: // // - goret *gst.MetaInfo @@ -15075,6 +16408,8 @@ func VideoBarMetaGetInfo() *gst.MetaInfo { } // VideoBufferPoolClass wraps GstVideoBufferPoolClass +// +// VideoBufferPoolClass is the type struct for [VideoBufferPool] type VideoBufferPoolClass struct { *videoBufferPoolClass } @@ -15089,31 +16424,6 @@ func UnsafeVideoBufferPoolClassFromGlibBorrow(p unsafe.Pointer) *VideoBufferPool return &VideoBufferPoolClass{&videoBufferPoolClass{(*C.GstVideoBufferPoolClass)(p)}} } -// UnsafeVideoBufferPoolClassFromGlibNone is used to convert raw C.GstVideoBufferPoolClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeVideoBufferPoolClassFromGlibNone(p unsafe.Pointer) *VideoBufferPoolClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeVideoBufferPoolClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.videoBufferPoolClass, - func (intern *videoBufferPoolClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeVideoBufferPoolClassFromGlibFull is used to convert raw C.GstVideoBufferPoolClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeVideoBufferPoolClassFromGlibFull(p unsafe.Pointer) *VideoBufferPoolClass { - wrapped := UnsafeVideoBufferPoolClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.videoBufferPoolClass, - func (intern *videoBufferPoolClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeVideoBufferPoolClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [VideoBufferPoolClass] is expected to work anymore. @@ -15126,14 +16436,15 @@ func UnsafeVideoBufferPoolClassToGlibNone(v *VideoBufferPoolClass) unsafe.Pointe return unsafe.Pointer(v.native) } -// UnsafeVideoBufferPoolClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeVideoBufferPoolClassToGlibFull(v *VideoBufferPoolClass) unsafe.Pointer { - runtime.SetFinalizer(v.videoBufferPoolClass, nil) - _p := unsafe.Pointer(v.native) - v.native = nil // VideoBufferPoolClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (v *VideoBufferPoolClass) ParentClass() *gst.BufferPoolClass { + parent := gst.UnsafeBufferPoolClassFromGlibBorrow(UnsafeVideoBufferPoolClassToGlibNone(v)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *VideoBufferPoolClass) {}, v) + return parent } + // VideoCaptionMeta wraps GstVideoCaptionMeta // // Extra buffer metadata providing Closed Caption. @@ -15151,7 +16462,7 @@ func UnsafeVideoCaptionMetaFromGlibBorrow(p unsafe.Pointer) *VideoCaptionMeta { return &VideoCaptionMeta{&videoCaptionMeta{(*C.GstVideoCaptionMeta)(p)}} } -// UnsafeVideoCaptionMetaFromGlibNone is used to convert raw C.GstVideoCaptionMeta pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeVideoCaptionMetaFromGlibNone is used to convert raw C.GstVideoCaptionMeta pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeVideoCaptionMetaFromGlibNone(p unsafe.Pointer) *VideoCaptionMeta { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeVideoCaptionMetaFromGlibBorrow(p) @@ -15164,7 +16475,7 @@ func UnsafeVideoCaptionMetaFromGlibNone(p unsafe.Pointer) *VideoCaptionMeta { return wrapped } -// UnsafeVideoCaptionMetaFromGlibFull is used to convert raw C.GstVideoCaptionMeta pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeVideoCaptionMetaFromGlibFull is used to convert raw C.GstVideoCaptionMeta pointers to go while taking ownership. This is used by the bindings internally. func UnsafeVideoCaptionMetaFromGlibFull(p unsafe.Pointer) *VideoCaptionMeta { wrapped := UnsafeVideoCaptionMetaFromGlibBorrow(p) runtime.SetFinalizer( @@ -15196,7 +16507,9 @@ func UnsafeVideoCaptionMetaToGlibFull(v *VideoCaptionMeta) unsafe.Pointer { v.native = nil // VideoCaptionMeta is invalid from here on return _p } + // VideoCaptionMetaGetInfo wraps gst_video_caption_meta_get_info +// // The function returns the following values: // // - goret *gst.MetaInfo @@ -15227,7 +16540,7 @@ func UnsafeVideoChromaResamplerFromGlibBorrow(p unsafe.Pointer) *VideoChromaResa return &VideoChromaResampler{&videoChromaResampler{(*C.GstVideoChromaResample)(p)}} } -// UnsafeVideoChromaResamplerFromGlibNone is used to convert raw C.GstVideoChromaResample pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeVideoChromaResamplerFromGlibNone is used to convert raw C.GstVideoChromaResample pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeVideoChromaResamplerFromGlibNone(p unsafe.Pointer) *VideoChromaResampler { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeVideoChromaResamplerFromGlibBorrow(p) @@ -15240,7 +16553,7 @@ func UnsafeVideoChromaResamplerFromGlibNone(p unsafe.Pointer) *VideoChromaResamp return wrapped } -// UnsafeVideoChromaResamplerFromGlibFull is used to convert raw C.GstVideoChromaResample pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeVideoChromaResamplerFromGlibFull is used to convert raw C.GstVideoChromaResample pointers to go while taking ownership. This is used by the bindings internally. func UnsafeVideoChromaResamplerFromGlibFull(p unsafe.Pointer) *VideoChromaResampler { wrapped := UnsafeVideoChromaResamplerFromGlibBorrow(p) runtime.SetFinalizer( @@ -15272,6 +16585,7 @@ func UnsafeVideoChromaResamplerToGlibFull(v *VideoChromaResampler) unsafe.Pointe v.native = nil // VideoChromaResampler is invalid from here on return _p } + // VideoCodecAlphaMeta wraps GstVideoCodecAlphaMeta // // This meta is primarily for internal use in GStreamer elements to support @@ -15294,7 +16608,7 @@ func UnsafeVideoCodecAlphaMetaFromGlibBorrow(p unsafe.Pointer) *VideoCodecAlphaM return &VideoCodecAlphaMeta{&videoCodecAlphaMeta{(*C.GstVideoCodecAlphaMeta)(p)}} } -// UnsafeVideoCodecAlphaMetaFromGlibNone is used to convert raw C.GstVideoCodecAlphaMeta pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeVideoCodecAlphaMetaFromGlibNone is used to convert raw C.GstVideoCodecAlphaMeta pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeVideoCodecAlphaMetaFromGlibNone(p unsafe.Pointer) *VideoCodecAlphaMeta { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeVideoCodecAlphaMetaFromGlibBorrow(p) @@ -15307,7 +16621,7 @@ func UnsafeVideoCodecAlphaMetaFromGlibNone(p unsafe.Pointer) *VideoCodecAlphaMet return wrapped } -// UnsafeVideoCodecAlphaMetaFromGlibFull is used to convert raw C.GstVideoCodecAlphaMeta pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeVideoCodecAlphaMetaFromGlibFull is used to convert raw C.GstVideoCodecAlphaMeta pointers to go while taking ownership. This is used by the bindings internally. func UnsafeVideoCodecAlphaMetaFromGlibFull(p unsafe.Pointer) *VideoCodecAlphaMeta { wrapped := UnsafeVideoCodecAlphaMetaFromGlibBorrow(p) runtime.SetFinalizer( @@ -15339,7 +16653,9 @@ func UnsafeVideoCodecAlphaMetaToGlibFull(v *VideoCodecAlphaMeta) unsafe.Pointer v.native = nil // VideoCodecAlphaMeta is invalid from here on return _p } + // VideoCodecAlphaMetaGetInfo wraps gst_video_codec_alpha_meta_get_info +// // The function returns the following values: // // - goret *gst.MetaInfo @@ -15385,7 +16701,7 @@ func UnsafeVideoCodecFrameFromGlibBorrow(p unsafe.Pointer) *VideoCodecFrame { return &VideoCodecFrame{&videoCodecFrame{(*C.GstVideoCodecFrame)(p)}} } -// UnsafeVideoCodecFrameFromGlibNone is used to convert raw C.GstVideoCodecFrame pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeVideoCodecFrameFromGlibNone is used to convert raw C.GstVideoCodecFrame pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeVideoCodecFrameFromGlibNone(p unsafe.Pointer) *VideoCodecFrame { C.gst_video_codec_frame_ref((*C.GstVideoCodecFrame)(p)) wrapped := UnsafeVideoCodecFrameFromGlibBorrow(p) @@ -15398,7 +16714,7 @@ func UnsafeVideoCodecFrameFromGlibNone(p unsafe.Pointer) *VideoCodecFrame { return wrapped } -// UnsafeVideoCodecFrameFromGlibFull is used to convert raw C.GstVideoCodecFrame pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeVideoCodecFrameFromGlibFull is used to convert raw C.GstVideoCodecFrame pointers to go while taking ownership. This is used by the bindings internally. func UnsafeVideoCodecFrameFromGlibFull(p unsafe.Pointer) *VideoCodecFrame { wrapped := UnsafeVideoCodecFrameFromGlibBorrow(p) runtime.SetFinalizer( @@ -15437,6 +16753,7 @@ func UnsafeVideoCodecFrameToGlibFull(v *VideoCodecFrame) unsafe.Pointer { v.native = nil // VideoCodecFrame is invalid from here on return _p } + // VideoCodecState wraps GstVideoCodecState // // Structure representing the state of an incoming or outgoing video @@ -15474,7 +16791,7 @@ func UnsafeVideoCodecStateFromGlibBorrow(p unsafe.Pointer) *VideoCodecState { return &VideoCodecState{&videoCodecState{(*C.GstVideoCodecState)(p)}} } -// UnsafeVideoCodecStateFromGlibNone is used to convert raw C.GstVideoCodecState pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeVideoCodecStateFromGlibNone is used to convert raw C.GstVideoCodecState pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeVideoCodecStateFromGlibNone(p unsafe.Pointer) *VideoCodecState { C.gst_video_codec_state_ref((*C.GstVideoCodecState)(p)) wrapped := UnsafeVideoCodecStateFromGlibBorrow(p) @@ -15487,7 +16804,7 @@ func UnsafeVideoCodecStateFromGlibNone(p unsafe.Pointer) *VideoCodecState { return wrapped } -// UnsafeVideoCodecStateFromGlibFull is used to convert raw C.GstVideoCodecState pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeVideoCodecStateFromGlibFull is used to convert raw C.GstVideoCodecState pointers to go while taking ownership. This is used by the bindings internally. func UnsafeVideoCodecStateFromGlibFull(p unsafe.Pointer) *VideoCodecState { wrapped := UnsafeVideoCodecStateFromGlibBorrow(p) runtime.SetFinalizer( @@ -15526,6 +16843,7 @@ func UnsafeVideoCodecStateToGlibFull(v *VideoCodecState) unsafe.Pointer { v.native = nil // VideoCodecState is invalid from here on return _p } + // VideoColorPrimariesInfo wraps GstVideoColorPrimariesInfo // // Structure describing the chromaticity coordinates of an RGB system. These @@ -15545,7 +16863,7 @@ func UnsafeVideoColorPrimariesInfoFromGlibBorrow(p unsafe.Pointer) *VideoColorPr return &VideoColorPrimariesInfo{&videoColorPrimariesInfo{(*C.GstVideoColorPrimariesInfo)(p)}} } -// UnsafeVideoColorPrimariesInfoFromGlibNone is used to convert raw C.GstVideoColorPrimariesInfo pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeVideoColorPrimariesInfoFromGlibNone is used to convert raw C.GstVideoColorPrimariesInfo pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeVideoColorPrimariesInfoFromGlibNone(p unsafe.Pointer) *VideoColorPrimariesInfo { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeVideoColorPrimariesInfoFromGlibBorrow(p) @@ -15558,7 +16876,7 @@ func UnsafeVideoColorPrimariesInfoFromGlibNone(p unsafe.Pointer) *VideoColorPrim return wrapped } -// UnsafeVideoColorPrimariesInfoFromGlibFull is used to convert raw C.GstVideoColorPrimariesInfo pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeVideoColorPrimariesInfoFromGlibFull is used to convert raw C.GstVideoColorPrimariesInfo pointers to go while taking ownership. This is used by the bindings internally. func UnsafeVideoColorPrimariesInfoFromGlibFull(p unsafe.Pointer) *VideoColorPrimariesInfo { wrapped := UnsafeVideoColorPrimariesInfoFromGlibBorrow(p) runtime.SetFinalizer( @@ -15590,6 +16908,7 @@ func UnsafeVideoColorPrimariesInfoToGlibFull(v *VideoColorPrimariesInfo) unsafe. v.native = nil // VideoColorPrimariesInfo is invalid from here on return _p } + // VideoColorimetry wraps GstVideoColorimetry // // Structure describing the color info. @@ -15607,7 +16926,7 @@ func UnsafeVideoColorimetryFromGlibBorrow(p unsafe.Pointer) *VideoColorimetry { return &VideoColorimetry{&videoColorimetry{(*C.GstVideoColorimetry)(p)}} } -// UnsafeVideoColorimetryFromGlibNone is used to convert raw C.GstVideoColorimetry pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeVideoColorimetryFromGlibNone is used to convert raw C.GstVideoColorimetry pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeVideoColorimetryFromGlibNone(p unsafe.Pointer) *VideoColorimetry { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeVideoColorimetryFromGlibBorrow(p) @@ -15620,7 +16939,7 @@ func UnsafeVideoColorimetryFromGlibNone(p unsafe.Pointer) *VideoColorimetry { return wrapped } -// UnsafeVideoColorimetryFromGlibFull is used to convert raw C.GstVideoColorimetry pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeVideoColorimetryFromGlibFull is used to convert raw C.GstVideoColorimetry pointers to go while taking ownership. This is used by the bindings internally. func UnsafeVideoColorimetryFromGlibFull(p unsafe.Pointer) *VideoColorimetry { wrapped := UnsafeVideoColorimetryFromGlibBorrow(p) runtime.SetFinalizer( @@ -15652,6 +16971,7 @@ func UnsafeVideoColorimetryToGlibFull(v *VideoColorimetry) unsafe.Pointer { v.native = nil // VideoColorimetry is invalid from here on return _p } + // FromString wraps gst_video_colorimetry_from_string // // The function takes the following parameters: @@ -15793,6 +17113,7 @@ func (cinfo *VideoColorimetry) Matches(color string) bool { } // ToString wraps gst_video_colorimetry_to_string +// // The function returns the following values: // // - goret string (nullable) @@ -15834,7 +17155,7 @@ func UnsafeVideoContentLightLevelFromGlibBorrow(p unsafe.Pointer) *VideoContentL return &VideoContentLightLevel{&videoContentLightLevel{(*C.GstVideoContentLightLevel)(p)}} } -// UnsafeVideoContentLightLevelFromGlibNone is used to convert raw C.GstVideoContentLightLevel pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeVideoContentLightLevelFromGlibNone is used to convert raw C.GstVideoContentLightLevel pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeVideoContentLightLevelFromGlibNone(p unsafe.Pointer) *VideoContentLightLevel { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeVideoContentLightLevelFromGlibBorrow(p) @@ -15847,7 +17168,7 @@ func UnsafeVideoContentLightLevelFromGlibNone(p unsafe.Pointer) *VideoContentLig return wrapped } -// UnsafeVideoContentLightLevelFromGlibFull is used to convert raw C.GstVideoContentLightLevel pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeVideoContentLightLevelFromGlibFull is used to convert raw C.GstVideoContentLightLevel pointers to go while taking ownership. This is used by the bindings internally. func UnsafeVideoContentLightLevelFromGlibFull(p unsafe.Pointer) *VideoContentLightLevel { wrapped := UnsafeVideoContentLightLevelFromGlibBorrow(p) runtime.SetFinalizer( @@ -15879,6 +17200,7 @@ func UnsafeVideoContentLightLevelToGlibFull(v *VideoContentLightLevel) unsafe.Po v.native = nil // VideoContentLightLevel is invalid from here on return _p } + // AddToCaps wraps gst_video_content_light_level_add_to_caps // // The function takes the following parameters: @@ -16022,6 +17344,7 @@ func (linfo *VideoContentLightLevel) IsEqual(other *VideoContentLightLevel) bool } // ToString wraps gst_video_content_light_level_to_string +// // The function returns the following values: // // - goret string @@ -16059,7 +17382,7 @@ func UnsafeVideoConverterFromGlibBorrow(p unsafe.Pointer) *VideoConverter { return &VideoConverter{&videoConverter{(*C.GstVideoConverter)(p)}} } -// UnsafeVideoConverterFromGlibNone is used to convert raw C.GstVideoConverter pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeVideoConverterFromGlibNone is used to convert raw C.GstVideoConverter pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeVideoConverterFromGlibNone(p unsafe.Pointer) *VideoConverter { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeVideoConverterFromGlibBorrow(p) @@ -16072,7 +17395,7 @@ func UnsafeVideoConverterFromGlibNone(p unsafe.Pointer) *VideoConverter { return wrapped } -// UnsafeVideoConverterFromGlibFull is used to convert raw C.GstVideoConverter pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeVideoConverterFromGlibFull is used to convert raw C.GstVideoConverter pointers to go while taking ownership. This is used by the bindings internally. func UnsafeVideoConverterFromGlibFull(p unsafe.Pointer) *VideoConverter { wrapped := UnsafeVideoConverterFromGlibBorrow(p) runtime.SetFinalizer( @@ -16104,6 +17427,7 @@ func UnsafeVideoConverterToGlibFull(v *VideoConverter) unsafe.Pointer { v.native = nil // VideoConverter is invalid from here on return _p } + // Frame wraps gst_video_converter_frame // // The function takes the following parameters: @@ -16145,6 +17469,7 @@ func (convert *VideoConverter) FrameFinish() { } // GetConfig wraps gst_video_converter_get_config +// // The function returns the following values: // // - goret *gst.Structure @@ -16167,6 +17492,7 @@ func (convert *VideoConverter) GetConfig() *gst.Structure { } // GetInInfo wraps gst_video_converter_get_in_info +// // The function returns the following values: // // - goret *VideoInfo @@ -16189,6 +17515,7 @@ func (convert *VideoConverter) GetInInfo() *VideoInfo { } // GetOutInfo wraps gst_video_converter_get_out_info +// // The function returns the following values: // // - goret *VideoInfo @@ -16266,7 +17593,7 @@ func UnsafeVideoCropMetaFromGlibBorrow(p unsafe.Pointer) *VideoCropMeta { return &VideoCropMeta{&videoCropMeta{(*C.GstVideoCropMeta)(p)}} } -// UnsafeVideoCropMetaFromGlibNone is used to convert raw C.GstVideoCropMeta pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeVideoCropMetaFromGlibNone is used to convert raw C.GstVideoCropMeta pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeVideoCropMetaFromGlibNone(p unsafe.Pointer) *VideoCropMeta { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeVideoCropMetaFromGlibBorrow(p) @@ -16279,7 +17606,7 @@ func UnsafeVideoCropMetaFromGlibNone(p unsafe.Pointer) *VideoCropMeta { return wrapped } -// UnsafeVideoCropMetaFromGlibFull is used to convert raw C.GstVideoCropMeta pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeVideoCropMetaFromGlibFull is used to convert raw C.GstVideoCropMeta pointers to go while taking ownership. This is used by the bindings internally. func UnsafeVideoCropMetaFromGlibFull(p unsafe.Pointer) *VideoCropMeta { wrapped := UnsafeVideoCropMetaFromGlibBorrow(p) runtime.SetFinalizer( @@ -16311,7 +17638,9 @@ func UnsafeVideoCropMetaToGlibFull(v *VideoCropMeta) unsafe.Pointer { v.native = nil // VideoCropMeta is invalid from here on return _p } + // VideoCropMetaGetInfo wraps gst_video_crop_meta_get_info +// // The function returns the following values: // // - goret *gst.MetaInfo @@ -16333,6 +17662,8 @@ func VideoCropMetaGetInfo() *gst.MetaInfo { // needed. At minimum @handle_frame needs to be overridden, and @set_format // and likely as well. If non-packetized input is supported or expected, // @parse needs to be overridden as well. +// +// VideoDecoderClass is the type struct for [VideoDecoder] type VideoDecoderClass struct { *videoDecoderClass } @@ -16347,31 +17678,6 @@ func UnsafeVideoDecoderClassFromGlibBorrow(p unsafe.Pointer) *VideoDecoderClass return &VideoDecoderClass{&videoDecoderClass{(*C.GstVideoDecoderClass)(p)}} } -// UnsafeVideoDecoderClassFromGlibNone is used to convert raw C.GstVideoDecoderClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeVideoDecoderClassFromGlibNone(p unsafe.Pointer) *VideoDecoderClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeVideoDecoderClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.videoDecoderClass, - func (intern *videoDecoderClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeVideoDecoderClassFromGlibFull is used to convert raw C.GstVideoDecoderClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeVideoDecoderClassFromGlibFull(p unsafe.Pointer) *VideoDecoderClass { - wrapped := UnsafeVideoDecoderClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.videoDecoderClass, - func (intern *videoDecoderClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeVideoDecoderClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [VideoDecoderClass] is expected to work anymore. @@ -16384,14 +17690,15 @@ func UnsafeVideoDecoderClassToGlibNone(v *VideoDecoderClass) unsafe.Pointer { return unsafe.Pointer(v.native) } -// UnsafeVideoDecoderClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeVideoDecoderClassToGlibFull(v *VideoDecoderClass) unsafe.Pointer { - runtime.SetFinalizer(v.videoDecoderClass, nil) - _p := unsafe.Pointer(v.native) - v.native = nil // VideoDecoderClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (v *VideoDecoderClass) ParentClass() *gst.ElementClass { + parent := gst.UnsafeElementClassFromGlibBorrow(UnsafeVideoDecoderClassToGlibNone(v)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *VideoDecoderClass) {}, v) + return parent } + // VideoDirectionInterface wraps GstVideoDirectionInterface // // #GstVideoDirectionInterface interface. @@ -16409,7 +17716,7 @@ func UnsafeVideoDirectionInterfaceFromGlibBorrow(p unsafe.Pointer) *VideoDirecti return &VideoDirectionInterface{&videoDirectionInterface{(*C.GstVideoDirectionInterface)(p)}} } -// UnsafeVideoDirectionInterfaceFromGlibNone is used to convert raw C.GstVideoDirectionInterface pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeVideoDirectionInterfaceFromGlibNone is used to convert raw C.GstVideoDirectionInterface pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeVideoDirectionInterfaceFromGlibNone(p unsafe.Pointer) *VideoDirectionInterface { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeVideoDirectionInterfaceFromGlibBorrow(p) @@ -16422,7 +17729,7 @@ func UnsafeVideoDirectionInterfaceFromGlibNone(p unsafe.Pointer) *VideoDirection return wrapped } -// UnsafeVideoDirectionInterfaceFromGlibFull is used to convert raw C.GstVideoDirectionInterface pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeVideoDirectionInterfaceFromGlibFull is used to convert raw C.GstVideoDirectionInterface pointers to go while taking ownership. This is used by the bindings internally. func UnsafeVideoDirectionInterfaceFromGlibFull(p unsafe.Pointer) *VideoDirectionInterface { wrapped := UnsafeVideoDirectionInterfaceFromGlibBorrow(p) runtime.SetFinalizer( @@ -16454,6 +17761,7 @@ func UnsafeVideoDirectionInterfaceToGlibFull(v *VideoDirectionInterface) unsafe. v.native = nil // VideoDirectionInterface is invalid from here on return _p } + // VideoDither wraps GstVideoDither // // GstVideoDither provides implementations of several dithering algorithms @@ -16472,7 +17780,7 @@ func UnsafeVideoDitherFromGlibBorrow(p unsafe.Pointer) *VideoDither { return &VideoDither{&videoDither{(*C.GstVideoDither)(p)}} } -// UnsafeVideoDitherFromGlibNone is used to convert raw C.GstVideoDither pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeVideoDitherFromGlibNone is used to convert raw C.GstVideoDither pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeVideoDitherFromGlibNone(p unsafe.Pointer) *VideoDither { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeVideoDitherFromGlibBorrow(p) @@ -16485,7 +17793,7 @@ func UnsafeVideoDitherFromGlibNone(p unsafe.Pointer) *VideoDither { return wrapped } -// UnsafeVideoDitherFromGlibFull is used to convert raw C.GstVideoDither pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeVideoDitherFromGlibFull is used to convert raw C.GstVideoDither pointers to go while taking ownership. This is used by the bindings internally. func UnsafeVideoDitherFromGlibFull(p unsafe.Pointer) *VideoDither { wrapped := UnsafeVideoDitherFromGlibBorrow(p) runtime.SetFinalizer( @@ -16517,11 +17825,14 @@ func UnsafeVideoDitherToGlibFull(v *VideoDither) unsafe.Pointer { v.native = nil // VideoDither is invalid from here on return _p } + // VideoEncoderClass wraps GstVideoEncoderClass // // Subclasses can override any of the available virtual methods or not, as // needed. At minimum @handle_frame needs to be overridden, and @set_format // and @get_caps are likely needed as well. +// +// VideoEncoderClass is the type struct for [VideoEncoder] type VideoEncoderClass struct { *videoEncoderClass } @@ -16536,31 +17847,6 @@ func UnsafeVideoEncoderClassFromGlibBorrow(p unsafe.Pointer) *VideoEncoderClass return &VideoEncoderClass{&videoEncoderClass{(*C.GstVideoEncoderClass)(p)}} } -// UnsafeVideoEncoderClassFromGlibNone is used to convert raw C.GstVideoEncoderClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeVideoEncoderClassFromGlibNone(p unsafe.Pointer) *VideoEncoderClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeVideoEncoderClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.videoEncoderClass, - func (intern *videoEncoderClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeVideoEncoderClassFromGlibFull is used to convert raw C.GstVideoEncoderClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeVideoEncoderClassFromGlibFull(p unsafe.Pointer) *VideoEncoderClass { - wrapped := UnsafeVideoEncoderClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.videoEncoderClass, - func (intern *videoEncoderClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeVideoEncoderClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [VideoEncoderClass] is expected to work anymore. @@ -16573,17 +17859,20 @@ func UnsafeVideoEncoderClassToGlibNone(v *VideoEncoderClass) unsafe.Pointer { return unsafe.Pointer(v.native) } -// UnsafeVideoEncoderClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeVideoEncoderClassToGlibFull(v *VideoEncoderClass) unsafe.Pointer { - runtime.SetFinalizer(v.videoEncoderClass, nil) - _p := unsafe.Pointer(v.native) - v.native = nil // VideoEncoderClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (v *VideoEncoderClass) ParentClass() *gst.ElementClass { + parent := gst.UnsafeElementClassFromGlibBorrow(UnsafeVideoEncoderClassToGlibNone(v)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *VideoEncoderClass) {}, v) + return parent } + // VideoFilterClass wraps GstVideoFilterClass // // The video filter class structure. +// +// VideoFilterClass is the type struct for [VideoFilter] type VideoFilterClass struct { *videoFilterClass } @@ -16598,31 +17887,6 @@ func UnsafeVideoFilterClassFromGlibBorrow(p unsafe.Pointer) *VideoFilterClass { return &VideoFilterClass{&videoFilterClass{(*C.GstVideoFilterClass)(p)}} } -// UnsafeVideoFilterClassFromGlibNone is used to convert raw C.GstVideoFilterClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeVideoFilterClassFromGlibNone(p unsafe.Pointer) *VideoFilterClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeVideoFilterClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.videoFilterClass, - func (intern *videoFilterClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeVideoFilterClassFromGlibFull is used to convert raw C.GstVideoFilterClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeVideoFilterClassFromGlibFull(p unsafe.Pointer) *VideoFilterClass { - wrapped := UnsafeVideoFilterClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.videoFilterClass, - func (intern *videoFilterClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeVideoFilterClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [VideoFilterClass] is expected to work anymore. @@ -16635,14 +17899,15 @@ func UnsafeVideoFilterClassToGlibNone(v *VideoFilterClass) unsafe.Pointer { return unsafe.Pointer(v.native) } -// UnsafeVideoFilterClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeVideoFilterClassToGlibFull(v *VideoFilterClass) unsafe.Pointer { - runtime.SetFinalizer(v.videoFilterClass, nil) - _p := unsafe.Pointer(v.native) - v.native = nil // VideoFilterClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (v *VideoFilterClass) ParentClass() *gstbase.BaseTransformClass { + parent := gstbase.UnsafeBaseTransformClassFromGlibBorrow(UnsafeVideoFilterClassToGlibNone(v)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *VideoFilterClass) {}, v) + return parent } + // VideoFormatInfo wraps GstVideoFormatInfo // // Information for a video format. @@ -16660,7 +17925,7 @@ func UnsafeVideoFormatInfoFromGlibBorrow(p unsafe.Pointer) *VideoFormatInfo { return &VideoFormatInfo{&videoFormatInfo{(*C.GstVideoFormatInfo)(p)}} } -// UnsafeVideoFormatInfoFromGlibNone is used to convert raw C.GstVideoFormatInfo pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeVideoFormatInfoFromGlibNone is used to convert raw C.GstVideoFormatInfo pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeVideoFormatInfoFromGlibNone(p unsafe.Pointer) *VideoFormatInfo { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeVideoFormatInfoFromGlibBorrow(p) @@ -16673,7 +17938,7 @@ func UnsafeVideoFormatInfoFromGlibNone(p unsafe.Pointer) *VideoFormatInfo { return wrapped } -// UnsafeVideoFormatInfoFromGlibFull is used to convert raw C.GstVideoFormatInfo pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeVideoFormatInfoFromGlibFull is used to convert raw C.GstVideoFormatInfo pointers to go while taking ownership. This is used by the bindings internally. func UnsafeVideoFormatInfoFromGlibFull(p unsafe.Pointer) *VideoFormatInfo { wrapped := UnsafeVideoFormatInfoFromGlibBorrow(p) runtime.SetFinalizer( @@ -16705,6 +17970,7 @@ func UnsafeVideoFormatInfoToGlibFull(v *VideoFormatInfo) unsafe.Pointer { v.native = nil // VideoFormatInfo is invalid from here on return _p } + // Component wraps gst_video_format_info_component // // The function takes the following parameters: @@ -16789,7 +18055,7 @@ func UnsafeVideoFrameFromGlibBorrow(p unsafe.Pointer) *VideoFrame { return &VideoFrame{&videoFrame{(*C.GstVideoFrame)(p)}} } -// UnsafeVideoFrameFromGlibNone is used to convert raw C.GstVideoFrame pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeVideoFrameFromGlibNone is used to convert raw C.GstVideoFrame pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeVideoFrameFromGlibNone(p unsafe.Pointer) *VideoFrame { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeVideoFrameFromGlibBorrow(p) @@ -16802,7 +18068,7 @@ func UnsafeVideoFrameFromGlibNone(p unsafe.Pointer) *VideoFrame { return wrapped } -// UnsafeVideoFrameFromGlibFull is used to convert raw C.GstVideoFrame pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeVideoFrameFromGlibFull is used to convert raw C.GstVideoFrame pointers to go while taking ownership. This is used by the bindings internally. func UnsafeVideoFrameFromGlibFull(p unsafe.Pointer) *VideoFrame { wrapped := UnsafeVideoFrameFromGlibBorrow(p) runtime.SetFinalizer( @@ -16834,6 +18100,7 @@ func UnsafeVideoFrameToGlibFull(v *VideoFrame) unsafe.Pointer { v.native = nil // VideoFrame is invalid from here on return _p } + // VideoFrameMap wraps gst_video_frame_map // // The function takes the following parameters: @@ -17079,7 +18346,7 @@ func UnsafeVideoGLTextureUploadMetaFromGlibBorrow(p unsafe.Pointer) *VideoGLText return &VideoGLTextureUploadMeta{&videoGLTextureUploadMeta{(*C.GstVideoGLTextureUploadMeta)(p)}} } -// UnsafeVideoGLTextureUploadMetaFromGlibNone is used to convert raw C.GstVideoGLTextureUploadMeta pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeVideoGLTextureUploadMetaFromGlibNone is used to convert raw C.GstVideoGLTextureUploadMeta pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeVideoGLTextureUploadMetaFromGlibNone(p unsafe.Pointer) *VideoGLTextureUploadMeta { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeVideoGLTextureUploadMetaFromGlibBorrow(p) @@ -17092,7 +18359,7 @@ func UnsafeVideoGLTextureUploadMetaFromGlibNone(p unsafe.Pointer) *VideoGLTextur return wrapped } -// UnsafeVideoGLTextureUploadMetaFromGlibFull is used to convert raw C.GstVideoGLTextureUploadMeta pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeVideoGLTextureUploadMetaFromGlibFull is used to convert raw C.GstVideoGLTextureUploadMeta pointers to go while taking ownership. This is used by the bindings internally. func UnsafeVideoGLTextureUploadMetaFromGlibFull(p unsafe.Pointer) *VideoGLTextureUploadMeta { wrapped := UnsafeVideoGLTextureUploadMetaFromGlibBorrow(p) runtime.SetFinalizer( @@ -17124,7 +18391,9 @@ func UnsafeVideoGLTextureUploadMetaToGlibFull(v *VideoGLTextureUploadMeta) unsaf v.native = nil // VideoGLTextureUploadMeta is invalid from here on return _p } + // VideoGLTextureUploadMetaGetInfo wraps gst_video_gl_texture_upload_meta_get_info +// // The function returns the following values: // // - goret *gst.MetaInfo @@ -17208,7 +18477,7 @@ func UnsafeVideoInfoFromGlibBorrow(p unsafe.Pointer) *VideoInfo { return &VideoInfo{&videoInfo{(*C.GstVideoInfo)(p)}} } -// UnsafeVideoInfoFromGlibNone is used to convert raw C.GstVideoInfo pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeVideoInfoFromGlibNone is used to convert raw C.GstVideoInfo pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeVideoInfoFromGlibNone(p unsafe.Pointer) *VideoInfo { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeVideoInfoFromGlibBorrow(p) @@ -17221,7 +18490,7 @@ func UnsafeVideoInfoFromGlibNone(p unsafe.Pointer) *VideoInfo { return wrapped } -// UnsafeVideoInfoFromGlibFull is used to convert raw C.GstVideoInfo pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeVideoInfoFromGlibFull is used to convert raw C.GstVideoInfo pointers to go while taking ownership. This is used by the bindings internally. func UnsafeVideoInfoFromGlibFull(p unsafe.Pointer) *VideoInfo { wrapped := UnsafeVideoInfoFromGlibBorrow(p) runtime.SetFinalizer( @@ -17253,7 +18522,9 @@ func UnsafeVideoInfoToGlibFull(v *VideoInfo) unsafe.Pointer { v.native = nil // VideoInfo is invalid from here on return _p } + // NewVideoInfo wraps gst_video_info_new +// // The function returns the following values: // // - goret *VideoInfo @@ -17337,6 +18608,7 @@ func VideoInfoFromCaps(caps *gst.Caps) (VideoInfo, bool) { } // VideoInfoInit wraps gst_video_info_init +// // The function returns the following values: // // - info VideoInfo: a #GstVideoInfo @@ -17484,6 +18756,7 @@ func (info *VideoInfo) Convert(srcFormat gst.Format, srcValue int64, destFormat } // Copy wraps gst_video_info_copy +// // The function returns the following values: // // - goret *VideoInfo @@ -17627,6 +18900,7 @@ func (info *VideoInfo) SetInterlacedFormat(format VideoFormat, mode VideoInterla } // ToCaps wraps gst_video_info_to_caps +// // The function returns the following values: // // - goret *gst.Caps @@ -17679,7 +18953,7 @@ func UnsafeVideoInfoDmaDrmFromGlibBorrow(p unsafe.Pointer) *VideoInfoDmaDrm { return &VideoInfoDmaDrm{&videoInfoDmaDrm{(*C.GstVideoInfoDmaDrm)(p)}} } -// UnsafeVideoInfoDmaDrmFromGlibNone is used to convert raw C.GstVideoInfoDmaDrm pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeVideoInfoDmaDrmFromGlibNone is used to convert raw C.GstVideoInfoDmaDrm pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeVideoInfoDmaDrmFromGlibNone(p unsafe.Pointer) *VideoInfoDmaDrm { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeVideoInfoDmaDrmFromGlibBorrow(p) @@ -17692,7 +18966,7 @@ func UnsafeVideoInfoDmaDrmFromGlibNone(p unsafe.Pointer) *VideoInfoDmaDrm { return wrapped } -// UnsafeVideoInfoDmaDrmFromGlibFull is used to convert raw C.GstVideoInfoDmaDrm pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeVideoInfoDmaDrmFromGlibFull is used to convert raw C.GstVideoInfoDmaDrm pointers to go while taking ownership. This is used by the bindings internally. func UnsafeVideoInfoDmaDrmFromGlibFull(p unsafe.Pointer) *VideoInfoDmaDrm { wrapped := UnsafeVideoInfoDmaDrmFromGlibBorrow(p) runtime.SetFinalizer( @@ -17724,7 +18998,9 @@ func UnsafeVideoInfoDmaDrmToGlibFull(v *VideoInfoDmaDrm) unsafe.Pointer { v.native = nil // VideoInfoDmaDrm is invalid from here on return _p } + // NewVideoInfoDmaDrm wraps gst_video_info_dma_drm_new +// // The function returns the following values: // // - goret *VideoInfoDmaDrm @@ -17852,6 +19128,7 @@ func VideoInfoDmaDrmFromVideoInfo(info *VideoInfo, modifier uint64) (VideoInfoDm } // VideoInfoDmaDrmInit wraps gst_video_info_dma_drm_init +// // The function returns the following values: // // - drmInfo VideoInfoDmaDrm: a #GstVideoInfoDmaDrm @@ -17872,6 +19149,7 @@ func VideoInfoDmaDrmInit() VideoInfoDmaDrm { } // ToCaps wraps gst_video_info_dma_drm_to_caps +// // The function returns the following values: // // - goret *gst.Caps (nullable) @@ -17899,6 +19177,7 @@ func (drmInfo *VideoInfoDmaDrm) ToCaps() *gst.Caps { } // ToVideoInfo wraps gst_video_info_dma_drm_to_video_info +// // The function returns the following values: // // - info VideoInfo: #GstVideoInfo @@ -17950,7 +19229,7 @@ func UnsafeVideoMasteringDisplayInfoFromGlibBorrow(p unsafe.Pointer) *VideoMaste return &VideoMasteringDisplayInfo{&videoMasteringDisplayInfo{(*C.GstVideoMasteringDisplayInfo)(p)}} } -// UnsafeVideoMasteringDisplayInfoFromGlibNone is used to convert raw C.GstVideoMasteringDisplayInfo pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeVideoMasteringDisplayInfoFromGlibNone is used to convert raw C.GstVideoMasteringDisplayInfo pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeVideoMasteringDisplayInfoFromGlibNone(p unsafe.Pointer) *VideoMasteringDisplayInfo { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeVideoMasteringDisplayInfoFromGlibBorrow(p) @@ -17963,7 +19242,7 @@ func UnsafeVideoMasteringDisplayInfoFromGlibNone(p unsafe.Pointer) *VideoMasteri return wrapped } -// UnsafeVideoMasteringDisplayInfoFromGlibFull is used to convert raw C.GstVideoMasteringDisplayInfo pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeVideoMasteringDisplayInfoFromGlibFull is used to convert raw C.GstVideoMasteringDisplayInfo pointers to go while taking ownership. This is used by the bindings internally. func UnsafeVideoMasteringDisplayInfoFromGlibFull(p unsafe.Pointer) *VideoMasteringDisplayInfo { wrapped := UnsafeVideoMasteringDisplayInfoFromGlibBorrow(p) runtime.SetFinalizer( @@ -17995,6 +19274,7 @@ func UnsafeVideoMasteringDisplayInfoToGlibFull(v *VideoMasteringDisplayInfo) uns v.native = nil // VideoMasteringDisplayInfo is invalid from here on return _p } + // VideoMasteringDisplayInfoFromString wraps gst_video_mastering_display_info_from_string // // The function takes the following parameters: @@ -18140,6 +19420,7 @@ func (minfo *VideoMasteringDisplayInfo) IsEqual(other *VideoMasteringDisplayInfo } // ToString wraps gst_video_mastering_display_info_to_string +// // The function returns the following values: // // - goret string @@ -18180,7 +19461,7 @@ func UnsafeVideoMasteringDisplayInfoCoordinatesFromGlibBorrow(p unsafe.Pointer) return &VideoMasteringDisplayInfoCoordinates{&videoMasteringDisplayInfoCoordinates{(*C.GstVideoMasteringDisplayInfoCoordinates)(p)}} } -// UnsafeVideoMasteringDisplayInfoCoordinatesFromGlibNone is used to convert raw C.GstVideoMasteringDisplayInfoCoordinates pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeVideoMasteringDisplayInfoCoordinatesFromGlibNone is used to convert raw C.GstVideoMasteringDisplayInfoCoordinates pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeVideoMasteringDisplayInfoCoordinatesFromGlibNone(p unsafe.Pointer) *VideoMasteringDisplayInfoCoordinates { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeVideoMasteringDisplayInfoCoordinatesFromGlibBorrow(p) @@ -18193,7 +19474,7 @@ func UnsafeVideoMasteringDisplayInfoCoordinatesFromGlibNone(p unsafe.Pointer) *V return wrapped } -// UnsafeVideoMasteringDisplayInfoCoordinatesFromGlibFull is used to convert raw C.GstVideoMasteringDisplayInfoCoordinates pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeVideoMasteringDisplayInfoCoordinatesFromGlibFull is used to convert raw C.GstVideoMasteringDisplayInfoCoordinates pointers to go while taking ownership. This is used by the bindings internally. func UnsafeVideoMasteringDisplayInfoCoordinatesFromGlibFull(p unsafe.Pointer) *VideoMasteringDisplayInfoCoordinates { wrapped := UnsafeVideoMasteringDisplayInfoCoordinatesFromGlibBorrow(p) runtime.SetFinalizer( @@ -18225,6 +19506,7 @@ func UnsafeVideoMasteringDisplayInfoCoordinatesToGlibFull(v *VideoMasteringDispl v.native = nil // VideoMasteringDisplayInfoCoordinates is invalid from here on return _p } + // VideoMeta wraps GstVideoMeta // // Extra buffer metadata describing image properties @@ -18260,7 +19542,7 @@ func UnsafeVideoMetaFromGlibBorrow(p unsafe.Pointer) *VideoMeta { return &VideoMeta{&videoMeta{(*C.GstVideoMeta)(p)}} } -// UnsafeVideoMetaFromGlibNone is used to convert raw C.GstVideoMeta pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeVideoMetaFromGlibNone is used to convert raw C.GstVideoMeta pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeVideoMetaFromGlibNone(p unsafe.Pointer) *VideoMeta { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeVideoMetaFromGlibBorrow(p) @@ -18273,7 +19555,7 @@ func UnsafeVideoMetaFromGlibNone(p unsafe.Pointer) *VideoMeta { return wrapped } -// UnsafeVideoMetaFromGlibFull is used to convert raw C.GstVideoMeta pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeVideoMetaFromGlibFull is used to convert raw C.GstVideoMeta pointers to go while taking ownership. This is used by the bindings internally. func UnsafeVideoMetaFromGlibFull(p unsafe.Pointer) *VideoMeta { wrapped := UnsafeVideoMetaFromGlibBorrow(p) runtime.SetFinalizer( @@ -18305,7 +19587,9 @@ func UnsafeVideoMetaToGlibFull(v *VideoMeta) unsafe.Pointer { v.native = nil // VideoMeta is invalid from here on return _p } + // VideoMetaGetInfo wraps gst_video_meta_get_info +// // The function returns the following values: // // - goret *gst.MetaInfo @@ -18375,7 +19659,7 @@ func UnsafeVideoMetaTransformFromGlibBorrow(p unsafe.Pointer) *VideoMetaTransfor return &VideoMetaTransform{&videoMetaTransform{(*C.GstVideoMetaTransform)(p)}} } -// UnsafeVideoMetaTransformFromGlibNone is used to convert raw C.GstVideoMetaTransform pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeVideoMetaTransformFromGlibNone is used to convert raw C.GstVideoMetaTransform pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeVideoMetaTransformFromGlibNone(p unsafe.Pointer) *VideoMetaTransform { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeVideoMetaTransformFromGlibBorrow(p) @@ -18388,7 +19672,7 @@ func UnsafeVideoMetaTransformFromGlibNone(p unsafe.Pointer) *VideoMetaTransform return wrapped } -// UnsafeVideoMetaTransformFromGlibFull is used to convert raw C.GstVideoMetaTransform pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeVideoMetaTransformFromGlibFull is used to convert raw C.GstVideoMetaTransform pointers to go while taking ownership. This is used by the bindings internally. func UnsafeVideoMetaTransformFromGlibFull(p unsafe.Pointer) *VideoMetaTransform { wrapped := UnsafeVideoMetaTransformFromGlibBorrow(p) runtime.SetFinalizer( @@ -18420,7 +19704,9 @@ func UnsafeVideoMetaTransformToGlibFull(v *VideoMetaTransform) unsafe.Pointer { v.native = nil // VideoMetaTransform is invalid from here on return _p } + // VideoMetaTransformScaleGetQuark wraps gst_video_meta_transform_scale_get_quark +// // The function returns the following values: // // - goret glib.Quark @@ -18455,7 +19741,7 @@ func UnsafeVideoOrientationInterfaceFromGlibBorrow(p unsafe.Pointer) *VideoOrien return &VideoOrientationInterface{&videoOrientationInterface{(*C.GstVideoOrientationInterface)(p)}} } -// UnsafeVideoOrientationInterfaceFromGlibNone is used to convert raw C.GstVideoOrientationInterface pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeVideoOrientationInterfaceFromGlibNone is used to convert raw C.GstVideoOrientationInterface pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeVideoOrientationInterfaceFromGlibNone(p unsafe.Pointer) *VideoOrientationInterface { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeVideoOrientationInterfaceFromGlibBorrow(p) @@ -18468,7 +19754,7 @@ func UnsafeVideoOrientationInterfaceFromGlibNone(p unsafe.Pointer) *VideoOrienta return wrapped } -// UnsafeVideoOrientationInterfaceFromGlibFull is used to convert raw C.GstVideoOrientationInterface pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeVideoOrientationInterfaceFromGlibFull is used to convert raw C.GstVideoOrientationInterface pointers to go while taking ownership. This is used by the bindings internally. func UnsafeVideoOrientationInterfaceFromGlibFull(p unsafe.Pointer) *VideoOrientationInterface { wrapped := UnsafeVideoOrientationInterfaceFromGlibBorrow(p) runtime.SetFinalizer( @@ -18500,6 +19786,7 @@ func UnsafeVideoOrientationInterfaceToGlibFull(v *VideoOrientationInterface) uns v.native = nil // VideoOrientationInterface is invalid from here on return _p } + // VideoOverlayComposition wraps GstVideoOverlayComposition // // Functions to create and handle overlay compositions on video buffers. @@ -18550,7 +19837,7 @@ func UnsafeVideoOverlayCompositionFromGlibBorrow(p unsafe.Pointer) *VideoOverlay return &VideoOverlayComposition{&videoOverlayComposition{(*C.GstVideoOverlayComposition)(p)}} } -// UnsafeVideoOverlayCompositionFromGlibNone is used to convert raw C.GstVideoOverlayComposition pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeVideoOverlayCompositionFromGlibNone is used to convert raw C.GstVideoOverlayComposition pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeVideoOverlayCompositionFromGlibNone(p unsafe.Pointer) *VideoOverlayComposition { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeVideoOverlayCompositionFromGlibBorrow(p) @@ -18563,7 +19850,7 @@ func UnsafeVideoOverlayCompositionFromGlibNone(p unsafe.Pointer) *VideoOverlayCo return wrapped } -// UnsafeVideoOverlayCompositionFromGlibFull is used to convert raw C.GstVideoOverlayComposition pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeVideoOverlayCompositionFromGlibFull is used to convert raw C.GstVideoOverlayComposition pointers to go while taking ownership. This is used by the bindings internally. func UnsafeVideoOverlayCompositionFromGlibFull(p unsafe.Pointer) *VideoOverlayComposition { wrapped := UnsafeVideoOverlayCompositionFromGlibBorrow(p) runtime.SetFinalizer( @@ -18595,6 +19882,7 @@ func UnsafeVideoOverlayCompositionToGlibFull(v *VideoOverlayComposition) unsafe. v.native = nil // VideoOverlayComposition is invalid from here on return _p } + // NewVideoOverlayComposition wraps gst_video_overlay_composition_new // // The function takes the following parameters: @@ -18688,6 +19976,7 @@ func (comp *VideoOverlayComposition) Blend(videoBuf *VideoFrame) bool { } // Copy wraps gst_video_overlay_composition_copy +// // The function returns the following values: // // - goret *VideoOverlayComposition @@ -18746,6 +20035,7 @@ func (comp *VideoOverlayComposition) GetRectangle(n uint) *VideoOverlayRectangle } // GetSeqnum wraps gst_video_overlay_composition_get_seqnum +// // The function returns the following values: // // - goret uint @@ -18771,6 +20061,7 @@ func (comp *VideoOverlayComposition) GetSeqnum() uint { } // MakeWritable wraps gst_video_overlay_composition_make_writable +// // The function returns the following values: // // - goret *VideoOverlayComposition @@ -18797,6 +20088,7 @@ func (comp *VideoOverlayComposition) MakeWritable() *VideoOverlayComposition { } // NRectangles wraps gst_video_overlay_composition_n_rectangles +// // The function returns the following values: // // - goret uint @@ -18835,7 +20127,7 @@ func UnsafeVideoOverlayCompositionMetaFromGlibBorrow(p unsafe.Pointer) *VideoOve return &VideoOverlayCompositionMeta{&videoOverlayCompositionMeta{(*C.GstVideoOverlayCompositionMeta)(p)}} } -// UnsafeVideoOverlayCompositionMetaFromGlibNone is used to convert raw C.GstVideoOverlayCompositionMeta pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeVideoOverlayCompositionMetaFromGlibNone is used to convert raw C.GstVideoOverlayCompositionMeta pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeVideoOverlayCompositionMetaFromGlibNone(p unsafe.Pointer) *VideoOverlayCompositionMeta { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeVideoOverlayCompositionMetaFromGlibBorrow(p) @@ -18848,7 +20140,7 @@ func UnsafeVideoOverlayCompositionMetaFromGlibNone(p unsafe.Pointer) *VideoOverl return wrapped } -// UnsafeVideoOverlayCompositionMetaFromGlibFull is used to convert raw C.GstVideoOverlayCompositionMeta pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeVideoOverlayCompositionMetaFromGlibFull is used to convert raw C.GstVideoOverlayCompositionMeta pointers to go while taking ownership. This is used by the bindings internally. func UnsafeVideoOverlayCompositionMetaFromGlibFull(p unsafe.Pointer) *VideoOverlayCompositionMeta { wrapped := UnsafeVideoOverlayCompositionMetaFromGlibBorrow(p) runtime.SetFinalizer( @@ -18880,7 +20172,9 @@ func UnsafeVideoOverlayCompositionMetaToGlibFull(v *VideoOverlayCompositionMeta) v.native = nil // VideoOverlayCompositionMeta is invalid from here on return _p } + // VideoOverlayCompositionMetaGetInfo wraps gst_video_overlay_composition_meta_get_info +// // The function returns the following values: // // - goret *gst.MetaInfo @@ -18913,7 +20207,7 @@ func UnsafeVideoOverlayInterfaceFromGlibBorrow(p unsafe.Pointer) *VideoOverlayIn return &VideoOverlayInterface{&videoOverlayInterface{(*C.GstVideoOverlayInterface)(p)}} } -// UnsafeVideoOverlayInterfaceFromGlibNone is used to convert raw C.GstVideoOverlayInterface pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeVideoOverlayInterfaceFromGlibNone is used to convert raw C.GstVideoOverlayInterface pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeVideoOverlayInterfaceFromGlibNone(p unsafe.Pointer) *VideoOverlayInterface { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeVideoOverlayInterfaceFromGlibBorrow(p) @@ -18926,7 +20220,7 @@ func UnsafeVideoOverlayInterfaceFromGlibNone(p unsafe.Pointer) *VideoOverlayInte return wrapped } -// UnsafeVideoOverlayInterfaceFromGlibFull is used to convert raw C.GstVideoOverlayInterface pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeVideoOverlayInterfaceFromGlibFull is used to convert raw C.GstVideoOverlayInterface pointers to go while taking ownership. This is used by the bindings internally. func UnsafeVideoOverlayInterfaceFromGlibFull(p unsafe.Pointer) *VideoOverlayInterface { wrapped := UnsafeVideoOverlayInterfaceFromGlibBorrow(p) runtime.SetFinalizer( @@ -18958,6 +20252,7 @@ func UnsafeVideoOverlayInterfaceToGlibFull(v *VideoOverlayInterface) unsafe.Poin v.native = nil // VideoOverlayInterface is invalid from here on return _p } + // VideoOverlayRectangle wraps GstVideoOverlayRectangle // // An opaque video overlay rectangle object. A rectangle contains a single @@ -18988,7 +20283,7 @@ func UnsafeVideoOverlayRectangleFromGlibBorrow(p unsafe.Pointer) *VideoOverlayRe return &VideoOverlayRectangle{&videoOverlayRectangle{(*C.GstVideoOverlayRectangle)(p)}} } -// UnsafeVideoOverlayRectangleFromGlibNone is used to convert raw C.GstVideoOverlayRectangle pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeVideoOverlayRectangleFromGlibNone is used to convert raw C.GstVideoOverlayRectangle pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeVideoOverlayRectangleFromGlibNone(p unsafe.Pointer) *VideoOverlayRectangle { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeVideoOverlayRectangleFromGlibBorrow(p) @@ -19001,7 +20296,7 @@ func UnsafeVideoOverlayRectangleFromGlibNone(p unsafe.Pointer) *VideoOverlayRect return wrapped } -// UnsafeVideoOverlayRectangleFromGlibFull is used to convert raw C.GstVideoOverlayRectangle pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeVideoOverlayRectangleFromGlibFull is used to convert raw C.GstVideoOverlayRectangle pointers to go while taking ownership. This is used by the bindings internally. func UnsafeVideoOverlayRectangleFromGlibFull(p unsafe.Pointer) *VideoOverlayRectangle { wrapped := UnsafeVideoOverlayRectangleFromGlibBorrow(p) runtime.SetFinalizer( @@ -19033,6 +20328,7 @@ func UnsafeVideoOverlayRectangleToGlibFull(v *VideoOverlayRectangle) unsafe.Poin v.native = nil // VideoOverlayRectangle is invalid from here on return _p } + // NewVideoOverlayRectangleRaw wraps gst_video_overlay_rectangle_new_raw // // The function takes the following parameters: @@ -19093,6 +20389,7 @@ func NewVideoOverlayRectangleRaw(pixels *gst.Buffer, renderX int, renderY int, r } // Copy wraps gst_video_overlay_rectangle_copy +// // The function returns the following values: // // - goret *VideoOverlayRectangle @@ -19118,6 +20415,7 @@ func (rectangle *VideoOverlayRectangle) Copy() *VideoOverlayRectangle { } // GetFlags wraps gst_video_overlay_rectangle_get_flags +// // The function returns the following values: // // - goret VideoOverlayFormatFlags @@ -19144,6 +20442,7 @@ func (rectangle *VideoOverlayRectangle) GetFlags() VideoOverlayFormatFlags { } // GetGlobalAlpha wraps gst_video_overlay_rectangle_get_global_alpha +// // The function returns the following values: // // - goret float32 @@ -19373,6 +20672,7 @@ func (rectangle *VideoOverlayRectangle) GetPixelsUnscaledRaw(flags VideoOverlayF } // GetRenderRectangle wraps gst_video_overlay_rectangle_get_render_rectangle +// // The function returns the following values: // // - renderX int: address where to store the X render offset @@ -19414,6 +20714,7 @@ func (rectangle *VideoOverlayRectangle) GetRenderRectangle() (int, int, uint, ui } // GetSeqnum wraps gst_video_overlay_rectangle_get_seqnum +// // The function returns the following values: // // - goret uint @@ -19530,7 +20831,7 @@ func UnsafeVideoRectangleFromGlibBorrow(p unsafe.Pointer) *VideoRectangle { return &VideoRectangle{&videoRectangle{(*C.GstVideoRectangle)(p)}} } -// UnsafeVideoRectangleFromGlibNone is used to convert raw C.GstVideoRectangle pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeVideoRectangleFromGlibNone is used to convert raw C.GstVideoRectangle pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeVideoRectangleFromGlibNone(p unsafe.Pointer) *VideoRectangle { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeVideoRectangleFromGlibBorrow(p) @@ -19543,7 +20844,7 @@ func UnsafeVideoRectangleFromGlibNone(p unsafe.Pointer) *VideoRectangle { return wrapped } -// UnsafeVideoRectangleFromGlibFull is used to convert raw C.GstVideoRectangle pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeVideoRectangleFromGlibFull is used to convert raw C.GstVideoRectangle pointers to go while taking ownership. This is used by the bindings internally. func UnsafeVideoRectangleFromGlibFull(p unsafe.Pointer) *VideoRectangle { wrapped := UnsafeVideoRectangleFromGlibBorrow(p) runtime.SetFinalizer( @@ -19575,6 +20876,7 @@ func UnsafeVideoRectangleToGlibFull(v *VideoRectangle) unsafe.Pointer { v.native = nil // VideoRectangle is invalid from here on return _p } + // VideoRegionOfInterestMeta wraps GstVideoRegionOfInterestMeta // // Extra buffer metadata describing an image region of interest @@ -19592,7 +20894,7 @@ func UnsafeVideoRegionOfInterestMetaFromGlibBorrow(p unsafe.Pointer) *VideoRegio return &VideoRegionOfInterestMeta{&videoRegionOfInterestMeta{(*C.GstVideoRegionOfInterestMeta)(p)}} } -// UnsafeVideoRegionOfInterestMetaFromGlibNone is used to convert raw C.GstVideoRegionOfInterestMeta pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeVideoRegionOfInterestMetaFromGlibNone is used to convert raw C.GstVideoRegionOfInterestMeta pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeVideoRegionOfInterestMetaFromGlibNone(p unsafe.Pointer) *VideoRegionOfInterestMeta { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeVideoRegionOfInterestMetaFromGlibBorrow(p) @@ -19605,7 +20907,7 @@ func UnsafeVideoRegionOfInterestMetaFromGlibNone(p unsafe.Pointer) *VideoRegionO return wrapped } -// UnsafeVideoRegionOfInterestMetaFromGlibFull is used to convert raw C.GstVideoRegionOfInterestMeta pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeVideoRegionOfInterestMetaFromGlibFull is used to convert raw C.GstVideoRegionOfInterestMeta pointers to go while taking ownership. This is used by the bindings internally. func UnsafeVideoRegionOfInterestMetaFromGlibFull(p unsafe.Pointer) *VideoRegionOfInterestMeta { wrapped := UnsafeVideoRegionOfInterestMetaFromGlibBorrow(p) runtime.SetFinalizer( @@ -19637,7 +20939,9 @@ func UnsafeVideoRegionOfInterestMetaToGlibFull(v *VideoRegionOfInterestMeta) uns v.native = nil // VideoRegionOfInterestMeta is invalid from here on return _p } + // VideoRegionOfInterestMetaGetInfo wraps gst_video_region_of_interest_meta_get_info +// // The function returns the following values: // // - goret *gst.MetaInfo @@ -19732,7 +21036,7 @@ func UnsafeVideoResamplerFromGlibBorrow(p unsafe.Pointer) *VideoResampler { return &VideoResampler{&videoResampler{(*C.GstVideoResampler)(p)}} } -// UnsafeVideoResamplerFromGlibNone is used to convert raw C.GstVideoResampler pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeVideoResamplerFromGlibNone is used to convert raw C.GstVideoResampler pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeVideoResamplerFromGlibNone(p unsafe.Pointer) *VideoResampler { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeVideoResamplerFromGlibBorrow(p) @@ -19745,7 +21049,7 @@ func UnsafeVideoResamplerFromGlibNone(p unsafe.Pointer) *VideoResampler { return wrapped } -// UnsafeVideoResamplerFromGlibFull is used to convert raw C.GstVideoResampler pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeVideoResamplerFromGlibFull is used to convert raw C.GstVideoResampler pointers to go while taking ownership. This is used by the bindings internally. func UnsafeVideoResamplerFromGlibFull(p unsafe.Pointer) *VideoResampler { wrapped := UnsafeVideoResamplerFromGlibBorrow(p) runtime.SetFinalizer( @@ -19777,6 +21081,7 @@ func UnsafeVideoResamplerToGlibFull(v *VideoResampler) unsafe.Pointer { v.native = nil // VideoResampler is invalid from here on return _p } + // Clear wraps gst_video_resampler_clear // // Clear a previously initialized #GstVideoResampler @resampler. @@ -19864,7 +21169,7 @@ func UnsafeVideoSEIUserDataUnregisteredMetaFromGlibBorrow(p unsafe.Pointer) *Vid return &VideoSEIUserDataUnregisteredMeta{&videoSEIUserDataUnregisteredMeta{(*C.GstVideoSEIUserDataUnregisteredMeta)(p)}} } -// UnsafeVideoSEIUserDataUnregisteredMetaFromGlibNone is used to convert raw C.GstVideoSEIUserDataUnregisteredMeta pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeVideoSEIUserDataUnregisteredMetaFromGlibNone is used to convert raw C.GstVideoSEIUserDataUnregisteredMeta pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeVideoSEIUserDataUnregisteredMetaFromGlibNone(p unsafe.Pointer) *VideoSEIUserDataUnregisteredMeta { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeVideoSEIUserDataUnregisteredMetaFromGlibBorrow(p) @@ -19877,7 +21182,7 @@ func UnsafeVideoSEIUserDataUnregisteredMetaFromGlibNone(p unsafe.Pointer) *Video return wrapped } -// UnsafeVideoSEIUserDataUnregisteredMetaFromGlibFull is used to convert raw C.GstVideoSEIUserDataUnregisteredMeta pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeVideoSEIUserDataUnregisteredMetaFromGlibFull is used to convert raw C.GstVideoSEIUserDataUnregisteredMeta pointers to go while taking ownership. This is used by the bindings internally. func UnsafeVideoSEIUserDataUnregisteredMetaFromGlibFull(p unsafe.Pointer) *VideoSEIUserDataUnregisteredMeta { wrapped := UnsafeVideoSEIUserDataUnregisteredMetaFromGlibBorrow(p) runtime.SetFinalizer( @@ -19909,7 +21214,9 @@ func UnsafeVideoSEIUserDataUnregisteredMetaToGlibFull(v *VideoSEIUserDataUnregis v.native = nil // VideoSEIUserDataUnregisteredMeta is invalid from here on return _p } + // VideoSEIUserDataUnregisteredMetaGetInfo wraps gst_video_sei_user_data_unregistered_meta_get_info +// // The function returns the following values: // // - goret *gst.MetaInfo @@ -19943,7 +21250,7 @@ func UnsafeVideoScalerFromGlibBorrow(p unsafe.Pointer) *VideoScaler { return &VideoScaler{&videoScaler{(*C.GstVideoScaler)(p)}} } -// UnsafeVideoScalerFromGlibNone is used to convert raw C.GstVideoScaler pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeVideoScalerFromGlibNone is used to convert raw C.GstVideoScaler pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeVideoScalerFromGlibNone(p unsafe.Pointer) *VideoScaler { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeVideoScalerFromGlibBorrow(p) @@ -19956,7 +21263,7 @@ func UnsafeVideoScalerFromGlibNone(p unsafe.Pointer) *VideoScaler { return wrapped } -// UnsafeVideoScalerFromGlibFull is used to convert raw C.GstVideoScaler pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeVideoScalerFromGlibFull is used to convert raw C.GstVideoScaler pointers to go while taking ownership. This is used by the bindings internally. func UnsafeVideoScalerFromGlibFull(p unsafe.Pointer) *VideoScaler { wrapped := UnsafeVideoScalerFromGlibBorrow(p) runtime.SetFinalizer( @@ -19988,6 +21295,7 @@ func UnsafeVideoScalerToGlibFull(v *VideoScaler) unsafe.Pointer { v.native = nil // VideoScaler is invalid from here on return _p } + // GetCoeff wraps gst_video_scaler_get_coeff // // The function takes the following parameters: @@ -20033,6 +21341,7 @@ func (scale *VideoScaler) GetCoeff(outOffset uint) (uint, uint, *float64) { } // GetMaxTaps wraps gst_video_scaler_get_max_taps +// // The function returns the following values: // // - goret uint @@ -20058,6 +21367,8 @@ func (scale *VideoScaler) GetMaxTaps() uint { // // The video sink class structure. Derived classes should override the // @show_frame virtual function. +// +// VideoSinkClass is the type struct for [VideoSink] type VideoSinkClass struct { *videoSinkClass } @@ -20072,31 +21383,6 @@ func UnsafeVideoSinkClassFromGlibBorrow(p unsafe.Pointer) *VideoSinkClass { return &VideoSinkClass{&videoSinkClass{(*C.GstVideoSinkClass)(p)}} } -// UnsafeVideoSinkClassFromGlibNone is used to convert raw C.GstVideoSinkClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeVideoSinkClassFromGlibNone(p unsafe.Pointer) *VideoSinkClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeVideoSinkClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.videoSinkClass, - func (intern *videoSinkClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeVideoSinkClassFromGlibFull is used to convert raw C.GstVideoSinkClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeVideoSinkClassFromGlibFull(p unsafe.Pointer) *VideoSinkClass { - wrapped := UnsafeVideoSinkClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.videoSinkClass, - func (intern *videoSinkClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeVideoSinkClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [VideoSinkClass] is expected to work anymore. @@ -20109,14 +21395,15 @@ func UnsafeVideoSinkClassToGlibNone(v *VideoSinkClass) unsafe.Pointer { return unsafe.Pointer(v.native) } -// UnsafeVideoSinkClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeVideoSinkClassToGlibFull(v *VideoSinkClass) unsafe.Pointer { - runtime.SetFinalizer(v.videoSinkClass, nil) - _p := unsafe.Pointer(v.native) - v.native = nil // VideoSinkClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (v *VideoSinkClass) ParentClass() *gstbase.BaseSinkClass { + parent := gstbase.UnsafeBaseSinkClassFromGlibBorrow(UnsafeVideoSinkClassToGlibNone(v)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *VideoSinkClass) {}, v) + return parent } + // VideoTileInfo wraps GstVideoTileInfo // // Description of a tile. This structure allow to describe arbitrary tile @@ -20135,7 +21422,7 @@ func UnsafeVideoTileInfoFromGlibBorrow(p unsafe.Pointer) *VideoTileInfo { return &VideoTileInfo{&videoTileInfo{(*C.GstVideoTileInfo)(p)}} } -// UnsafeVideoTileInfoFromGlibNone is used to convert raw C.GstVideoTileInfo pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeVideoTileInfoFromGlibNone is used to convert raw C.GstVideoTileInfo pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeVideoTileInfoFromGlibNone(p unsafe.Pointer) *VideoTileInfo { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeVideoTileInfoFromGlibBorrow(p) @@ -20148,7 +21435,7 @@ func UnsafeVideoTileInfoFromGlibNone(p unsafe.Pointer) *VideoTileInfo { return wrapped } -// UnsafeVideoTileInfoFromGlibFull is used to convert raw C.GstVideoTileInfo pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeVideoTileInfoFromGlibFull is used to convert raw C.GstVideoTileInfo pointers to go while taking ownership. This is used by the bindings internally. func UnsafeVideoTileInfoFromGlibFull(p unsafe.Pointer) *VideoTileInfo { wrapped := UnsafeVideoTileInfoFromGlibBorrow(p) runtime.SetFinalizer( @@ -20180,6 +21467,7 @@ func UnsafeVideoTileInfoToGlibFull(v *VideoTileInfo) unsafe.Pointer { v.native = nil // VideoTileInfo is invalid from here on return _p } + // VideoTimeCode wraps GstVideoTimeCode // // @field_count must be 0 for progressive video and 1 or 2 for interlaced. @@ -20204,7 +21492,7 @@ func UnsafeVideoTimeCodeFromGlibBorrow(p unsafe.Pointer) *VideoTimeCode { return &VideoTimeCode{&videoTimeCode{(*C.GstVideoTimeCode)(p)}} } -// UnsafeVideoTimeCodeFromGlibNone is used to convert raw C.GstVideoTimeCode pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeVideoTimeCodeFromGlibNone is used to convert raw C.GstVideoTimeCode pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeVideoTimeCodeFromGlibNone(p unsafe.Pointer) *VideoTimeCode { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeVideoTimeCodeFromGlibBorrow(p) @@ -20217,7 +21505,7 @@ func UnsafeVideoTimeCodeFromGlibNone(p unsafe.Pointer) *VideoTimeCode { return wrapped } -// UnsafeVideoTimeCodeFromGlibFull is used to convert raw C.GstVideoTimeCode pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeVideoTimeCodeFromGlibFull is used to convert raw C.GstVideoTimeCode pointers to go while taking ownership. This is used by the bindings internally. func UnsafeVideoTimeCodeFromGlibFull(p unsafe.Pointer) *VideoTimeCode { wrapped := UnsafeVideoTimeCodeFromGlibBorrow(p) runtime.SetFinalizer( @@ -20249,6 +21537,7 @@ func UnsafeVideoTimeCodeToGlibFull(v *VideoTimeCode) unsafe.Pointer { v.native = nil // VideoTimeCode is invalid from here on return _p } + // NewVideoTimeCode wraps gst_video_time_code_new // // The function takes the following parameters: @@ -20310,6 +21599,7 @@ func NewVideoTimeCode(fpsN uint, fpsD uint, latestDailyJam *glib.DateTime, flags } // NewVideoTimeCodeEmpty wraps gst_video_time_code_new_empty +// // The function returns the following values: // // - goret *VideoTimeCode @@ -20554,6 +21844,7 @@ func (tc1 *VideoTimeCode) Compare(tc2 *VideoTimeCode) int { } // Copy wraps gst_video_time_code_copy +// // The function returns the following values: // // - goret *VideoTimeCode @@ -20574,6 +21865,7 @@ func (tc *VideoTimeCode) Copy() *VideoTimeCode { } // FramesSinceDailyJam wraps gst_video_time_code_frames_since_daily_jam +// // The function returns the following values: // // - goret uint64 @@ -20752,6 +22044,7 @@ func (tc *VideoTimeCode) InitFromDateTimeFull(fpsN uint, fpsD uint, dt *glib.Dat } // IsValid wraps gst_video_time_code_is_valid +// // The function returns the following values: // // - goret bool @@ -20774,6 +22067,7 @@ func (tc *VideoTimeCode) IsValid() bool { } // NsecSinceDailyJam wraps gst_video_time_code_nsec_since_daily_jam +// // The function returns the following values: // // - goret uint64 @@ -20794,6 +22088,7 @@ func (tc *VideoTimeCode) NsecSinceDailyJam() uint64 { } // ToDateTime wraps gst_video_time_code_to_date_time +// // The function returns the following values: // // - goret *glib.DateTime (nullable) @@ -20818,6 +22113,7 @@ func (tc *VideoTimeCode) ToDateTime() *glib.DateTime { } // ToString wraps gst_video_time_code_to_string +// // The function returns the following values: // // - goret string @@ -20858,7 +22154,7 @@ func UnsafeVideoTimeCodeConfigFromGlibBorrow(p unsafe.Pointer) *VideoTimeCodeCon return &VideoTimeCodeConfig{&videoTimeCodeConfig{(*C.GstVideoTimeCodeConfig)(p)}} } -// UnsafeVideoTimeCodeConfigFromGlibNone is used to convert raw C.GstVideoTimeCodeConfig pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeVideoTimeCodeConfigFromGlibNone is used to convert raw C.GstVideoTimeCodeConfig pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeVideoTimeCodeConfigFromGlibNone(p unsafe.Pointer) *VideoTimeCodeConfig { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeVideoTimeCodeConfigFromGlibBorrow(p) @@ -20871,7 +22167,7 @@ func UnsafeVideoTimeCodeConfigFromGlibNone(p unsafe.Pointer) *VideoTimeCodeConfi return wrapped } -// UnsafeVideoTimeCodeConfigFromGlibFull is used to convert raw C.GstVideoTimeCodeConfig pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeVideoTimeCodeConfigFromGlibFull is used to convert raw C.GstVideoTimeCodeConfig pointers to go while taking ownership. This is used by the bindings internally. func UnsafeVideoTimeCodeConfigFromGlibFull(p unsafe.Pointer) *VideoTimeCodeConfig { wrapped := UnsafeVideoTimeCodeConfigFromGlibBorrow(p) runtime.SetFinalizer( @@ -20903,6 +22199,7 @@ func UnsafeVideoTimeCodeConfigToGlibFull(v *VideoTimeCodeConfig) unsafe.Pointer v.native = nil // VideoTimeCodeConfig is invalid from here on return _p } + // VideoTimeCodeInterval wraps GstVideoTimeCodeInterval // // A representation of a difference between two #GstVideoTimeCode instances. @@ -20933,7 +22230,7 @@ func UnsafeVideoTimeCodeIntervalFromGlibBorrow(p unsafe.Pointer) *VideoTimeCodeI return &VideoTimeCodeInterval{&videoTimeCodeInterval{(*C.GstVideoTimeCodeInterval)(p)}} } -// UnsafeVideoTimeCodeIntervalFromGlibNone is used to convert raw C.GstVideoTimeCodeInterval pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeVideoTimeCodeIntervalFromGlibNone is used to convert raw C.GstVideoTimeCodeInterval pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeVideoTimeCodeIntervalFromGlibNone(p unsafe.Pointer) *VideoTimeCodeInterval { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeVideoTimeCodeIntervalFromGlibBorrow(p) @@ -20946,7 +22243,7 @@ func UnsafeVideoTimeCodeIntervalFromGlibNone(p unsafe.Pointer) *VideoTimeCodeInt return wrapped } -// UnsafeVideoTimeCodeIntervalFromGlibFull is used to convert raw C.GstVideoTimeCodeInterval pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeVideoTimeCodeIntervalFromGlibFull is used to convert raw C.GstVideoTimeCodeInterval pointers to go while taking ownership. This is used by the bindings internally. func UnsafeVideoTimeCodeIntervalFromGlibFull(p unsafe.Pointer) *VideoTimeCodeInterval { wrapped := UnsafeVideoTimeCodeIntervalFromGlibBorrow(p) runtime.SetFinalizer( @@ -20978,6 +22275,7 @@ func UnsafeVideoTimeCodeIntervalToGlibFull(v *VideoTimeCodeInterval) unsafe.Poin v.native = nil // VideoTimeCodeInterval is invalid from here on return _p } + // NewVideoTimeCodeInterval wraps gst_video_time_code_interval_new // // The function takes the following parameters: @@ -21058,6 +22356,7 @@ func (tc *VideoTimeCodeInterval) Clear() { } // Copy wraps gst_video_time_code_interval_copy +// // The function returns the following values: // // - goret *VideoTimeCodeInterval @@ -21128,7 +22427,7 @@ func UnsafeVideoTimeCodeMetaFromGlibBorrow(p unsafe.Pointer) *VideoTimeCodeMeta return &VideoTimeCodeMeta{&videoTimeCodeMeta{(*C.GstVideoTimeCodeMeta)(p)}} } -// UnsafeVideoTimeCodeMetaFromGlibNone is used to convert raw C.GstVideoTimeCodeMeta pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeVideoTimeCodeMetaFromGlibNone is used to convert raw C.GstVideoTimeCodeMeta pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeVideoTimeCodeMetaFromGlibNone(p unsafe.Pointer) *VideoTimeCodeMeta { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeVideoTimeCodeMetaFromGlibBorrow(p) @@ -21141,7 +22440,7 @@ func UnsafeVideoTimeCodeMetaFromGlibNone(p unsafe.Pointer) *VideoTimeCodeMeta { return wrapped } -// UnsafeVideoTimeCodeMetaFromGlibFull is used to convert raw C.GstVideoTimeCodeMeta pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeVideoTimeCodeMetaFromGlibFull is used to convert raw C.GstVideoTimeCodeMeta pointers to go while taking ownership. This is used by the bindings internally. func UnsafeVideoTimeCodeMetaFromGlibFull(p unsafe.Pointer) *VideoTimeCodeMeta { wrapped := UnsafeVideoTimeCodeMetaFromGlibBorrow(p) runtime.SetFinalizer( @@ -21173,7 +22472,9 @@ func UnsafeVideoTimeCodeMetaToGlibFull(v *VideoTimeCodeMeta) unsafe.Pointer { v.native = nil // VideoTimeCodeMeta is invalid from here on return _p } + // VideoTimeCodeMetaGetInfo wraps gst_video_time_code_meta_get_info +// // The function returns the following values: // // - goret *gst.MetaInfo @@ -21219,7 +22520,7 @@ func UnsafeVideoVBIEncoderFromGlibBorrow(p unsafe.Pointer) *VideoVBIEncoder { return &VideoVBIEncoder{&videoVBIEncoder{(*C.GstVideoVBIEncoder)(p)}} } -// UnsafeVideoVBIEncoderFromGlibNone is used to convert raw C.GstVideoVBIEncoder pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeVideoVBIEncoderFromGlibNone is used to convert raw C.GstVideoVBIEncoder pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeVideoVBIEncoderFromGlibNone(p unsafe.Pointer) *VideoVBIEncoder { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeVideoVBIEncoderFromGlibBorrow(p) @@ -21232,7 +22533,7 @@ func UnsafeVideoVBIEncoderFromGlibNone(p unsafe.Pointer) *VideoVBIEncoder { return wrapped } -// UnsafeVideoVBIEncoderFromGlibFull is used to convert raw C.GstVideoVBIEncoder pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeVideoVBIEncoderFromGlibFull is used to convert raw C.GstVideoVBIEncoder pointers to go while taking ownership. This is used by the bindings internally. func UnsafeVideoVBIEncoderFromGlibFull(p unsafe.Pointer) *VideoVBIEncoder { wrapped := UnsafeVideoVBIEncoderFromGlibBorrow(p) runtime.SetFinalizer( @@ -21264,6 +22565,7 @@ func UnsafeVideoVBIEncoderToGlibFull(v *VideoVBIEncoder) unsafe.Pointer { v.native = nil // VideoVBIEncoder is invalid from here on return _p } + // NewVideoVBIEncoder wraps gst_video_vbi_encoder_new // // The function takes the following parameters: @@ -21353,6 +22655,7 @@ func (encoder *VideoVBIEncoder) AddAncillary(composite bool, DID uint8, SDIDBloc } // Copy wraps gst_video_vbi_encoder_copy +// // The function returns the following values: // // - goret *VideoVBIEncoder @@ -21421,7 +22724,7 @@ func UnsafeVideoVBIParserFromGlibBorrow(p unsafe.Pointer) *VideoVBIParser { return &VideoVBIParser{&videoVBIParser{(*C.GstVideoVBIParser)(p)}} } -// UnsafeVideoVBIParserFromGlibNone is used to convert raw C.GstVideoVBIParser pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeVideoVBIParserFromGlibNone is used to convert raw C.GstVideoVBIParser pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeVideoVBIParserFromGlibNone(p unsafe.Pointer) *VideoVBIParser { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeVideoVBIParserFromGlibBorrow(p) @@ -21434,7 +22737,7 @@ func UnsafeVideoVBIParserFromGlibNone(p unsafe.Pointer) *VideoVBIParser { return wrapped } -// UnsafeVideoVBIParserFromGlibFull is used to convert raw C.GstVideoVBIParser pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeVideoVBIParserFromGlibFull is used to convert raw C.GstVideoVBIParser pointers to go while taking ownership. This is used by the bindings internally. func UnsafeVideoVBIParserFromGlibFull(p unsafe.Pointer) *VideoVBIParser { wrapped := UnsafeVideoVBIParserFromGlibBorrow(p) runtime.SetFinalizer( @@ -21466,6 +22769,7 @@ func UnsafeVideoVBIParserToGlibFull(v *VideoVBIParser) unsafe.Pointer { v.native = nil // VideoVBIParser is invalid from here on return _p } + // NewVideoVBIParser wraps gst_video_vbi_parser_new // // The function takes the following parameters: @@ -21500,6 +22804,7 @@ func NewVideoVBIParser(format VideoFormat, pixelWidth uint32) *VideoVBIParser { } // Copy wraps gst_video_vbi_parser_copy +// // The function returns the following values: // // - goret *VideoVBIParser @@ -21520,6 +22825,7 @@ func (parser *VideoVBIParser) Copy() *VideoVBIParser { } // GetAncillary wraps gst_video_vbi_parser_get_ancillary +// // The function returns the following values: // // - anc VideoAncillary: a #GstVideoAncillary to start the eventual ancillary data diff --git a/pkg/gstvideo/gstvideo_export.gen.go b/pkg/gstvideo/gstvideo_export.gen.go index 6e9375b..1712028 100644 --- a/pkg/gstvideo/gstvideo_export.gen.go +++ b/pkg/gstvideo/gstvideo_export.gen.go @@ -33,3 +33,368 @@ func _gotk4_gstvideo1_VideoConvertSampleCallback(carg1 *C.GstSample, carg2 *C.GE fn(sample, err) } +//export _gotk4_gstvideo1_ColorBalance_get_balance_type +func _gotk4_gstvideo1_ColorBalance_get_balance_type(carg0 *C.GstColorBalance) (cret C.GstColorBalanceType) { + panic("unimplemented") +} + +//export _gotk4_gstvideo1_ColorBalance_get_value +func _gotk4_gstvideo1_ColorBalance_get_value(carg0 *C.GstColorBalance, carg1 *C.GstColorBalanceChannel) (cret C.gint) { + panic("unimplemented") +} + +//export _gotk4_gstvideo1_ColorBalance_list_channels +func _gotk4_gstvideo1_ColorBalance_list_channels(carg0 *C.GstColorBalance) (cret *C.GList) { + panic("unimplemented") +} + +//export _gotk4_gstvideo1_ColorBalance_set_value +func _gotk4_gstvideo1_ColorBalance_set_value(carg0 *C.GstColorBalance, carg1 *C.GstColorBalanceChannel, carg2 C.gint) { + panic("unimplemented") +} + +//export _gotk4_gstvideo1_ColorBalance_value_changed +func _gotk4_gstvideo1_ColorBalance_value_changed(carg0 *C.GstColorBalance, carg1 *C.GstColorBalanceChannel, carg2 C.gint) { + panic("unimplemented") +} + +//export _gotk4_gstvideo1_Navigation_send_event +func _gotk4_gstvideo1_Navigation_send_event(carg0 *C.GstNavigation, carg1 *C.GstStructure) { + panic("unimplemented") +} + +//export _gotk4_gstvideo1_Navigation_send_event_simple +func _gotk4_gstvideo1_Navigation_send_event_simple(carg0 *C.GstNavigation, carg1 *C.GstEvent) { + panic("unimplemented") +} + +//export _gotk4_gstvideo1_VideoOrientation_get_hcenter +func _gotk4_gstvideo1_VideoOrientation_get_hcenter(carg0 *C.GstVideoOrientation, carg1 *C.gint) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstvideo1_VideoOrientation_get_hflip +func _gotk4_gstvideo1_VideoOrientation_get_hflip(carg0 *C.GstVideoOrientation, carg1 *C.gboolean) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstvideo1_VideoOrientation_get_vcenter +func _gotk4_gstvideo1_VideoOrientation_get_vcenter(carg0 *C.GstVideoOrientation, carg1 *C.gint) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstvideo1_VideoOrientation_get_vflip +func _gotk4_gstvideo1_VideoOrientation_get_vflip(carg0 *C.GstVideoOrientation, carg1 *C.gboolean) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstvideo1_VideoOrientation_set_hcenter +func _gotk4_gstvideo1_VideoOrientation_set_hcenter(carg0 *C.GstVideoOrientation, carg1 C.gint) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstvideo1_VideoOrientation_set_hflip +func _gotk4_gstvideo1_VideoOrientation_set_hflip(carg0 *C.GstVideoOrientation, carg1 C.gboolean) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstvideo1_VideoOrientation_set_vcenter +func _gotk4_gstvideo1_VideoOrientation_set_vcenter(carg0 *C.GstVideoOrientation, carg1 C.gint) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstvideo1_VideoOrientation_set_vflip +func _gotk4_gstvideo1_VideoOrientation_set_vflip(carg0 *C.GstVideoOrientation, carg1 C.gboolean) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstvideo1_VideoOverlay_expose +func _gotk4_gstvideo1_VideoOverlay_expose(carg0 *C.GstVideoOverlay) { + panic("unimplemented") +} + +//export _gotk4_gstvideo1_VideoOverlay_handle_events +func _gotk4_gstvideo1_VideoOverlay_handle_events(carg0 *C.GstVideoOverlay, carg1 C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstvideo1_VideoOverlay_set_render_rectangle +func _gotk4_gstvideo1_VideoOverlay_set_render_rectangle(carg0 *C.GstVideoOverlay, carg1 C.gint, carg2 C.gint, carg3 C.gint, carg4 C.gint) { + panic("unimplemented") +} + +//export _gotk4_gstvideo1_ColorBalanceChannel_value_changed +func _gotk4_gstvideo1_ColorBalanceChannel_value_changed(carg0 *C.GstColorBalanceChannel, carg1 C.gint) { + panic("unimplemented") +} + +//export _gotk4_gstvideo1_VideoAggregator_aggregate_frames +func _gotk4_gstvideo1_VideoAggregator_aggregate_frames(carg0 *C.GstVideoAggregator, carg1 *C.GstBuffer) (cret C.GstFlowReturn) { + panic("unimplemented") +} + +//export _gotk4_gstvideo1_VideoAggregator_find_best_format +func _gotk4_gstvideo1_VideoAggregator_find_best_format(carg0 *C.GstVideoAggregator, carg1 *C.GstCaps, carg2 *C.GstVideoInfo, carg3 *C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstvideo1_VideoAggregator_update_caps +func _gotk4_gstvideo1_VideoAggregator_update_caps(carg0 *C.GstVideoAggregator, carg1 *C.GstCaps) (cret *C.GstCaps) { + panic("unimplemented") +} + +//export _gotk4_gstvideo1_VideoAggregatorPad_clean_frame +func _gotk4_gstvideo1_VideoAggregatorPad_clean_frame(carg0 *C.GstVideoAggregatorPad, carg1 *C.GstVideoAggregator, carg2 *C.GstVideoFrame) { + panic("unimplemented") +} + +//export _gotk4_gstvideo1_VideoAggregatorPad_prepare_frame +func _gotk4_gstvideo1_VideoAggregatorPad_prepare_frame(carg0 *C.GstVideoAggregatorPad, carg1 *C.GstVideoAggregator, carg2 *C.GstBuffer, carg3 *C.GstVideoFrame) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstvideo1_VideoAggregatorPad_prepare_frame_finish +func _gotk4_gstvideo1_VideoAggregatorPad_prepare_frame_finish(carg0 *C.GstVideoAggregatorPad, carg1 *C.GstVideoAggregator, carg2 *C.GstVideoFrame) { + panic("unimplemented") +} + +//export _gotk4_gstvideo1_VideoAggregatorPad_prepare_frame_start +func _gotk4_gstvideo1_VideoAggregatorPad_prepare_frame_start(carg0 *C.GstVideoAggregatorPad, carg1 *C.GstVideoAggregator, carg2 *C.GstBuffer, carg3 *C.GstVideoFrame) { + panic("unimplemented") +} + +//export _gotk4_gstvideo1_VideoAggregatorPad_update_conversion_info +func _gotk4_gstvideo1_VideoAggregatorPad_update_conversion_info(carg0 *C.GstVideoAggregatorPad) { + panic("unimplemented") +} + +//export _gotk4_gstvideo1_VideoDecoder_close +func _gotk4_gstvideo1_VideoDecoder_close(carg0 *C.GstVideoDecoder) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstvideo1_VideoDecoder_decide_allocation +func _gotk4_gstvideo1_VideoDecoder_decide_allocation(carg0 *C.GstVideoDecoder, carg1 *C.GstQuery) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstvideo1_VideoDecoder_drain +func _gotk4_gstvideo1_VideoDecoder_drain(carg0 *C.GstVideoDecoder) (cret C.GstFlowReturn) { + panic("unimplemented") +} + +//export _gotk4_gstvideo1_VideoDecoder_finish +func _gotk4_gstvideo1_VideoDecoder_finish(carg0 *C.GstVideoDecoder) (cret C.GstFlowReturn) { + panic("unimplemented") +} + +//export _gotk4_gstvideo1_VideoDecoder_flush +func _gotk4_gstvideo1_VideoDecoder_flush(carg0 *C.GstVideoDecoder) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstvideo1_VideoDecoder_getcaps +func _gotk4_gstvideo1_VideoDecoder_getcaps(carg0 *C.GstVideoDecoder, carg1 *C.GstCaps) (cret *C.GstCaps) { + panic("unimplemented") +} + +//export _gotk4_gstvideo1_VideoDecoder_handle_frame +func _gotk4_gstvideo1_VideoDecoder_handle_frame(carg0 *C.GstVideoDecoder, carg1 *C.GstVideoCodecFrame) (cret C.GstFlowReturn) { + panic("unimplemented") +} + +//export _gotk4_gstvideo1_VideoDecoder_handle_missing_data +func _gotk4_gstvideo1_VideoDecoder_handle_missing_data(carg0 *C.GstVideoDecoder, carg1 C.GstClockTime, carg2 C.GstClockTime) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstvideo1_VideoDecoder_negotiate +func _gotk4_gstvideo1_VideoDecoder_negotiate(carg0 *C.GstVideoDecoder) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstvideo1_VideoDecoder_open +func _gotk4_gstvideo1_VideoDecoder_open(carg0 *C.GstVideoDecoder) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstvideo1_VideoDecoder_parse +func _gotk4_gstvideo1_VideoDecoder_parse(carg0 *C.GstVideoDecoder, carg1 *C.GstVideoCodecFrame, carg2 *C.GstAdapter, carg3 C.gboolean) (cret C.GstFlowReturn) { + panic("unimplemented") +} + +//export _gotk4_gstvideo1_VideoDecoder_propose_allocation +func _gotk4_gstvideo1_VideoDecoder_propose_allocation(carg0 *C.GstVideoDecoder, carg1 *C.GstQuery) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstvideo1_VideoDecoder_reset +func _gotk4_gstvideo1_VideoDecoder_reset(carg0 *C.GstVideoDecoder, carg1 C.gboolean) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstvideo1_VideoDecoder_set_format +func _gotk4_gstvideo1_VideoDecoder_set_format(carg0 *C.GstVideoDecoder, carg1 *C.GstVideoCodecState) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstvideo1_VideoDecoder_sink_event +func _gotk4_gstvideo1_VideoDecoder_sink_event(carg0 *C.GstVideoDecoder, carg1 *C.GstEvent) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstvideo1_VideoDecoder_sink_query +func _gotk4_gstvideo1_VideoDecoder_sink_query(carg0 *C.GstVideoDecoder, carg1 *C.GstQuery) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstvideo1_VideoDecoder_src_event +func _gotk4_gstvideo1_VideoDecoder_src_event(carg0 *C.GstVideoDecoder, carg1 *C.GstEvent) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstvideo1_VideoDecoder_src_query +func _gotk4_gstvideo1_VideoDecoder_src_query(carg0 *C.GstVideoDecoder, carg1 *C.GstQuery) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstvideo1_VideoDecoder_start +func _gotk4_gstvideo1_VideoDecoder_start(carg0 *C.GstVideoDecoder) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstvideo1_VideoDecoder_stop +func _gotk4_gstvideo1_VideoDecoder_stop(carg0 *C.GstVideoDecoder) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstvideo1_VideoDecoder_transform_meta +func _gotk4_gstvideo1_VideoDecoder_transform_meta(carg0 *C.GstVideoDecoder, carg1 *C.GstVideoCodecFrame, carg2 *C.GstMeta) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstvideo1_VideoEncoder_close +func _gotk4_gstvideo1_VideoEncoder_close(carg0 *C.GstVideoEncoder) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstvideo1_VideoEncoder_decide_allocation +func _gotk4_gstvideo1_VideoEncoder_decide_allocation(carg0 *C.GstVideoEncoder, carg1 *C.GstQuery) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstvideo1_VideoEncoder_finish +func _gotk4_gstvideo1_VideoEncoder_finish(carg0 *C.GstVideoEncoder) (cret C.GstFlowReturn) { + panic("unimplemented") +} + +//export _gotk4_gstvideo1_VideoEncoder_flush +func _gotk4_gstvideo1_VideoEncoder_flush(carg0 *C.GstVideoEncoder) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstvideo1_VideoEncoder_getcaps +func _gotk4_gstvideo1_VideoEncoder_getcaps(carg0 *C.GstVideoEncoder, carg1 *C.GstCaps) (cret *C.GstCaps) { + panic("unimplemented") +} + +//export _gotk4_gstvideo1_VideoEncoder_handle_frame +func _gotk4_gstvideo1_VideoEncoder_handle_frame(carg0 *C.GstVideoEncoder, carg1 *C.GstVideoCodecFrame) (cret C.GstFlowReturn) { + panic("unimplemented") +} + +//export _gotk4_gstvideo1_VideoEncoder_negotiate +func _gotk4_gstvideo1_VideoEncoder_negotiate(carg0 *C.GstVideoEncoder) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstvideo1_VideoEncoder_open +func _gotk4_gstvideo1_VideoEncoder_open(carg0 *C.GstVideoEncoder) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstvideo1_VideoEncoder_pre_push +func _gotk4_gstvideo1_VideoEncoder_pre_push(carg0 *C.GstVideoEncoder, carg1 *C.GstVideoCodecFrame) (cret C.GstFlowReturn) { + panic("unimplemented") +} + +//export _gotk4_gstvideo1_VideoEncoder_propose_allocation +func _gotk4_gstvideo1_VideoEncoder_propose_allocation(carg0 *C.GstVideoEncoder, carg1 *C.GstQuery) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstvideo1_VideoEncoder_reset +func _gotk4_gstvideo1_VideoEncoder_reset(carg0 *C.GstVideoEncoder, carg1 C.gboolean) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstvideo1_VideoEncoder_set_format +func _gotk4_gstvideo1_VideoEncoder_set_format(carg0 *C.GstVideoEncoder, carg1 *C.GstVideoCodecState) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstvideo1_VideoEncoder_sink_event +func _gotk4_gstvideo1_VideoEncoder_sink_event(carg0 *C.GstVideoEncoder, carg1 *C.GstEvent) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstvideo1_VideoEncoder_sink_query +func _gotk4_gstvideo1_VideoEncoder_sink_query(carg0 *C.GstVideoEncoder, carg1 *C.GstQuery) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstvideo1_VideoEncoder_src_event +func _gotk4_gstvideo1_VideoEncoder_src_event(carg0 *C.GstVideoEncoder, carg1 *C.GstEvent) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstvideo1_VideoEncoder_src_query +func _gotk4_gstvideo1_VideoEncoder_src_query(carg0 *C.GstVideoEncoder, carg1 *C.GstQuery) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstvideo1_VideoEncoder_start +func _gotk4_gstvideo1_VideoEncoder_start(carg0 *C.GstVideoEncoder) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstvideo1_VideoEncoder_stop +func _gotk4_gstvideo1_VideoEncoder_stop(carg0 *C.GstVideoEncoder) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstvideo1_VideoEncoder_transform_meta +func _gotk4_gstvideo1_VideoEncoder_transform_meta(carg0 *C.GstVideoEncoder, carg1 *C.GstVideoCodecFrame, carg2 *C.GstMeta) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstvideo1_VideoFilter_set_info +func _gotk4_gstvideo1_VideoFilter_set_info(carg0 *C.GstVideoFilter, carg1 *C.GstCaps, carg2 *C.GstVideoInfo, carg3 *C.GstCaps, carg4 *C.GstVideoInfo) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstvideo1_VideoFilter_transform_frame +func _gotk4_gstvideo1_VideoFilter_transform_frame(carg0 *C.GstVideoFilter, carg1 *C.GstVideoFrame, carg2 *C.GstVideoFrame) (cret C.GstFlowReturn) { + panic("unimplemented") +} + +//export _gotk4_gstvideo1_VideoFilter_transform_frame_ip +func _gotk4_gstvideo1_VideoFilter_transform_frame_ip(carg0 *C.GstVideoFilter, carg1 *C.GstVideoFrame) (cret C.GstFlowReturn) { + panic("unimplemented") +} + +//export _gotk4_gstvideo1_VideoSink_set_info +func _gotk4_gstvideo1_VideoSink_set_info(carg0 *C.GstVideoSink, carg1 *C.GstCaps, carg2 *C.GstVideoInfo) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstvideo1_VideoSink_show_frame +func _gotk4_gstvideo1_VideoSink_show_frame(carg0 *C.GstVideoSink, carg1 *C.GstBuffer) (cret C.GstFlowReturn) { + panic("unimplemented") +} + +//export _gotk4_gstvideo1_VideoAggregatorConvertPad_create_conversion_info +func _gotk4_gstvideo1_VideoAggregatorConvertPad_create_conversion_info(carg0 *C.GstVideoAggregatorConvertPad, carg1 *C.GstVideoAggregator, carg2 *C.GstVideoInfo) { + panic("unimplemented") +} + diff --git a/pkg/gstwebrtc/gstwebrtc.gen.go b/pkg/gstwebrtc/gstwebrtc.gen.go index 7d9d452..7f5fed7 100644 --- a/pkg/gstwebrtc/gstwebrtc.gen.go +++ b/pkg/gstwebrtc/gstwebrtc.gen.go @@ -22,6 +22,94 @@ import ( // #include // extern void _gotk4_gstwebrtc1_WebRTCICEOnCandidateFunc(GstWebRTCICE*, guint, gchar*, gpointer); // extern void destroyUserdata(gpointer); +// extern void _gotk4_gstwebrtc1_WebRTCICE_add_candidate(GstWebRTCICE*, GstWebRTCICEStream*, gchar*, GstPromise*); +// extern GstWebRTCICEStream* _gotk4_gstwebrtc1_WebRTCICE_add_stream(GstWebRTCICE*, guint); +// extern gboolean _gotk4_gstwebrtc1_WebRTCICE_add_turn_server(GstWebRTCICE*, gchar*); +// extern GstWebRTCICETransport* _gotk4_gstwebrtc1_WebRTCICE_find_transport(GstWebRTCICE*, GstWebRTCICEStream*, GstWebRTCICEComponent); +// extern gboolean _gotk4_gstwebrtc1_WebRTCICE_gather_candidates(GstWebRTCICE*, GstWebRTCICEStream*); +// extern gchar* _gotk4_gstwebrtc1_WebRTCICE_get_http_proxy(GstWebRTCICE*); +// extern gboolean _gotk4_gstwebrtc1_WebRTCICE_get_is_controller(GstWebRTCICE*); +// extern gboolean _gotk4_gstwebrtc1_WebRTCICE_get_selected_pair(GstWebRTCICE*, GstWebRTCICEStream*, GstWebRTCICECandidateStats*, GstWebRTCICECandidateStats*); +// extern gchar* _gotk4_gstwebrtc1_WebRTCICE_get_stun_server(GstWebRTCICE*); +// extern gchar* _gotk4_gstwebrtc1_WebRTCICE_get_turn_server(GstWebRTCICE*); +// extern void _gotk4_gstwebrtc1_WebRTCICE_set_force_relay(GstWebRTCICE*, gboolean); +// extern void _gotk4_gstwebrtc1_WebRTCICE_set_http_proxy(GstWebRTCICE*, gchar*); +// extern void _gotk4_gstwebrtc1_WebRTCICE_set_is_controller(GstWebRTCICE*, gboolean); +// extern gboolean _gotk4_gstwebrtc1_WebRTCICE_set_local_credentials(GstWebRTCICE*, GstWebRTCICEStream*, gchar*, gchar*); +// extern void _gotk4_gstwebrtc1_WebRTCICE_set_on_ice_candidate(GstWebRTCICE*, GstWebRTCICEOnCandidateFunc, gpointer, GDestroyNotify); +// extern gboolean _gotk4_gstwebrtc1_WebRTCICE_set_remote_credentials(GstWebRTCICE*, GstWebRTCICEStream*, gchar*, gchar*); +// extern void _gotk4_gstwebrtc1_WebRTCICE_set_stun_server(GstWebRTCICE*, gchar*); +// extern void _gotk4_gstwebrtc1_WebRTCICE_set_tos(GstWebRTCICE*, GstWebRTCICEStream*, guint); +// extern void _gotk4_gstwebrtc1_WebRTCICE_set_turn_server(GstWebRTCICE*, gchar*); +// void _gotk4_gstwebrtc1_WebRTCICE_virtual_add_candidate(void* fnptr, GstWebRTCICE* carg0, GstWebRTCICEStream* carg1, gchar* carg2, GstPromise* carg3) { +// return ((void (*) (GstWebRTCICE*, GstWebRTCICEStream*, gchar*, GstPromise*))(fnptr))(carg0, carg1, carg2, carg3); +// } +// GstWebRTCICEStream* _gotk4_gstwebrtc1_WebRTCICE_virtual_add_stream(void* fnptr, GstWebRTCICE* carg0, guint carg1) { +// return ((GstWebRTCICEStream* (*) (GstWebRTCICE*, guint))(fnptr))(carg0, carg1); +// } +// gboolean _gotk4_gstwebrtc1_WebRTCICE_virtual_add_turn_server(void* fnptr, GstWebRTCICE* carg0, gchar* carg1) { +// return ((gboolean (*) (GstWebRTCICE*, gchar*))(fnptr))(carg0, carg1); +// } +// GstWebRTCICETransport* _gotk4_gstwebrtc1_WebRTCICE_virtual_find_transport(void* fnptr, GstWebRTCICE* carg0, GstWebRTCICEStream* carg1, GstWebRTCICEComponent carg2) { +// return ((GstWebRTCICETransport* (*) (GstWebRTCICE*, GstWebRTCICEStream*, GstWebRTCICEComponent))(fnptr))(carg0, carg1, carg2); +// } +// gboolean _gotk4_gstwebrtc1_WebRTCICE_virtual_gather_candidates(void* fnptr, GstWebRTCICE* carg0, GstWebRTCICEStream* carg1) { +// return ((gboolean (*) (GstWebRTCICE*, GstWebRTCICEStream*))(fnptr))(carg0, carg1); +// } +// gchar* _gotk4_gstwebrtc1_WebRTCICE_virtual_get_http_proxy(void* fnptr, GstWebRTCICE* carg0) { +// return ((gchar* (*) (GstWebRTCICE*))(fnptr))(carg0); +// } +// gboolean _gotk4_gstwebrtc1_WebRTCICE_virtual_get_is_controller(void* fnptr, GstWebRTCICE* carg0) { +// return ((gboolean (*) (GstWebRTCICE*))(fnptr))(carg0); +// } +// gboolean _gotk4_gstwebrtc1_WebRTCICE_virtual_get_selected_pair(void* fnptr, GstWebRTCICE* carg0, GstWebRTCICEStream* carg1, GstWebRTCICECandidateStats** carg2, GstWebRTCICECandidateStats** carg3) { +// return ((gboolean (*) (GstWebRTCICE*, GstWebRTCICEStream*, GstWebRTCICECandidateStats**, GstWebRTCICECandidateStats**))(fnptr))(carg0, carg1, carg2, carg3); +// } +// gchar* _gotk4_gstwebrtc1_WebRTCICE_virtual_get_stun_server(void* fnptr, GstWebRTCICE* carg0) { +// return ((gchar* (*) (GstWebRTCICE*))(fnptr))(carg0); +// } +// gchar* _gotk4_gstwebrtc1_WebRTCICE_virtual_get_turn_server(void* fnptr, GstWebRTCICE* carg0) { +// return ((gchar* (*) (GstWebRTCICE*))(fnptr))(carg0); +// } +// void _gotk4_gstwebrtc1_WebRTCICE_virtual_set_force_relay(void* fnptr, GstWebRTCICE* carg0, gboolean carg1) { +// return ((void (*) (GstWebRTCICE*, gboolean))(fnptr))(carg0, carg1); +// } +// void _gotk4_gstwebrtc1_WebRTCICE_virtual_set_http_proxy(void* fnptr, GstWebRTCICE* carg0, gchar* carg1) { +// return ((void (*) (GstWebRTCICE*, gchar*))(fnptr))(carg0, carg1); +// } +// void _gotk4_gstwebrtc1_WebRTCICE_virtual_set_is_controller(void* fnptr, GstWebRTCICE* carg0, gboolean carg1) { +// return ((void (*) (GstWebRTCICE*, gboolean))(fnptr))(carg0, carg1); +// } +// gboolean _gotk4_gstwebrtc1_WebRTCICE_virtual_set_local_credentials(void* fnptr, GstWebRTCICE* carg0, GstWebRTCICEStream* carg1, gchar* carg2, gchar* carg3) { +// return ((gboolean (*) (GstWebRTCICE*, GstWebRTCICEStream*, gchar*, gchar*))(fnptr))(carg0, carg1, carg2, carg3); +// } +// void _gotk4_gstwebrtc1_WebRTCICE_virtual_set_on_ice_candidate(void* fnptr, GstWebRTCICE* carg0, GstWebRTCICEOnCandidateFunc carg1, gpointer carg2, GDestroyNotify carg3) { +// return ((void (*) (GstWebRTCICE*, GstWebRTCICEOnCandidateFunc, gpointer, GDestroyNotify))(fnptr))(carg0, carg1, carg2, carg3); +// } +// gboolean _gotk4_gstwebrtc1_WebRTCICE_virtual_set_remote_credentials(void* fnptr, GstWebRTCICE* carg0, GstWebRTCICEStream* carg1, gchar* carg2, gchar* carg3) { +// return ((gboolean (*) (GstWebRTCICE*, GstWebRTCICEStream*, gchar*, gchar*))(fnptr))(carg0, carg1, carg2, carg3); +// } +// void _gotk4_gstwebrtc1_WebRTCICE_virtual_set_stun_server(void* fnptr, GstWebRTCICE* carg0, gchar* carg1) { +// return ((void (*) (GstWebRTCICE*, gchar*))(fnptr))(carg0, carg1); +// } +// void _gotk4_gstwebrtc1_WebRTCICE_virtual_set_tos(void* fnptr, GstWebRTCICE* carg0, GstWebRTCICEStream* carg1, guint carg2) { +// return ((void (*) (GstWebRTCICE*, GstWebRTCICEStream*, guint))(fnptr))(carg0, carg1, carg2); +// } +// void _gotk4_gstwebrtc1_WebRTCICE_virtual_set_turn_server(void* fnptr, GstWebRTCICE* carg0, gchar* carg1) { +// return ((void (*) (GstWebRTCICE*, gchar*))(fnptr))(carg0, carg1); +// } +// extern GstWebRTCICETransport* _gotk4_gstwebrtc1_WebRTCICEStream_find_transport(GstWebRTCICEStream*, GstWebRTCICEComponent); +// extern gboolean _gotk4_gstwebrtc1_WebRTCICEStream_gather_candidates(GstWebRTCICEStream*); +// GstWebRTCICETransport* _gotk4_gstwebrtc1_WebRTCICEStream_virtual_find_transport(void* fnptr, GstWebRTCICEStream* carg0, GstWebRTCICEComponent carg1) { +// return ((GstWebRTCICETransport* (*) (GstWebRTCICEStream*, GstWebRTCICEComponent))(fnptr))(carg0, carg1); +// } +// gboolean _gotk4_gstwebrtc1_WebRTCICEStream_virtual_gather_candidates(void* fnptr, GstWebRTCICEStream* carg0) { +// return ((gboolean (*) (GstWebRTCICEStream*))(fnptr))(carg0); +// } +// extern gboolean _gotk4_gstwebrtc1_WebRTCICETransport_gather_candidates(GstWebRTCICETransport*); +// gboolean _gotk4_gstwebrtc1_WebRTCICETransport_virtual_gather_candidates(void* fnptr, GstWebRTCICETransport* carg0) { +// return ((gboolean (*) (GstWebRTCICETransport*))(fnptr))(carg0); +// } import "C" // GType values. @@ -356,6 +444,7 @@ func (e WebRTCError) String() string { } // WebRTCErrorQuark wraps gst_webrtc_error_quark +// // The function returns the following values: // // - goret glib.Quark @@ -1373,38 +1462,47 @@ func (channel *WebRTCDataChannelInstance) SendStringFull(str string) (bool, erro func (o *WebRTCDataChannelInstance) EmitClose() { o.Emit("close") } + // ConnectOnBufferedAmountLow connects the provided callback to the "on-buffered-amount-low" signal func (o *WebRTCDataChannelInstance) ConnectOnBufferedAmountLow(fn func(WebRTCDataChannel)) gobject.SignalHandle { return o.Connect("on-buffered-amount-low", fn) } + // ConnectOnClose connects the provided callback to the "on-close" signal func (o *WebRTCDataChannelInstance) ConnectOnClose(fn func(WebRTCDataChannel)) gobject.SignalHandle { return o.Connect("on-close", fn) } + // ConnectOnError connects the provided callback to the "on-error" signal func (o *WebRTCDataChannelInstance) ConnectOnError(fn func(WebRTCDataChannel, error)) gobject.SignalHandle { return o.Connect("on-error", fn) } + // ConnectOnMessageData connects the provided callback to the "on-message-data" signal func (o *WebRTCDataChannelInstance) ConnectOnMessageData(fn func(WebRTCDataChannel, glib.Bytes)) gobject.SignalHandle { return o.Connect("on-message-data", fn) } + // ConnectOnMessageString connects the provided callback to the "on-message-string" signal func (o *WebRTCDataChannelInstance) ConnectOnMessageString(fn func(WebRTCDataChannel, string)) gobject.SignalHandle { return o.Connect("on-message-string", fn) } + // ConnectOnOpen connects the provided callback to the "on-open" signal func (o *WebRTCDataChannelInstance) ConnectOnOpen(fn func(WebRTCDataChannel)) gobject.SignalHandle { return o.Connect("on-open", fn) } + // EmitSendData emits the "send-data" signal func (o *WebRTCDataChannelInstance) EmitSendData(arg0 glib.Bytes) { o.Emit("send-data", arg0) } + // EmitSendString emits the "send-string" signal func (o *WebRTCDataChannelInstance) EmitSendString(arg0 string) { o.Emit("send-string", arg0) } + // WebRTCICEInstance is the instance type used by all types extending GstWebRTCICE. It is used internally by the bindings. Users should use the interface [WebRTCICE] instead. type WebRTCICEInstance struct { _ [0]func() // equal guard @@ -1468,11 +1566,13 @@ type WebRTCICE interface { // - goret bool GatherCandidates(WebRTCICEStream) bool // GetHTTPProxy wraps gst_webrtc_ice_get_http_proxy + // // The function returns the following values: // // - goret string GetHTTPProxy() string // GetIsController wraps gst_webrtc_ice_get_is_controller + // // The function returns the following values: // // - goret bool @@ -1510,11 +1610,13 @@ type WebRTCICE interface { // - goret bool GetSelectedPair(WebRTCICEStream) (*WebRTCICECandidateStats, *WebRTCICECandidateStats, bool) // GetStunServer wraps gst_webrtc_ice_get_stun_server + // // The function returns the following values: // // - goret string (nullable) GetStunServer() string // GetTurnServer wraps gst_webrtc_ice_get_turn_server + // // The function returns the following values: // // - goret string (nullable) @@ -1789,6 +1891,7 @@ func (ice *WebRTCICEInstance) GatherCandidates(stream WebRTCICEStream) bool { } // GetHTTPProxy wraps gst_webrtc_ice_get_http_proxy +// // The function returns the following values: // // - goret string @@ -1810,6 +1913,7 @@ func (ice *WebRTCICEInstance) GetHTTPProxy() string { } // GetIsController wraps gst_webrtc_ice_get_is_controller +// // The function returns the following values: // // - goret bool @@ -1930,6 +2034,7 @@ func (ice *WebRTCICEInstance) GetSelectedPair(stream WebRTCICEStream) (*WebRTCIC } // GetStunServer wraps gst_webrtc_ice_get_stun_server +// // The function returns the following values: // // - goret string (nullable) @@ -1953,6 +2058,7 @@ func (ice *WebRTCICEInstance) GetStunServer() string { } // GetTurnServer wraps gst_webrtc_ice_get_turn_server +// // The function returns the following values: // // - goret string (nullable) @@ -2204,6 +2310,233 @@ func (ice *WebRTCICEInstance) SetTurnServer(uri string) { func (o *WebRTCICEInstance) EmitAddLocalIPAddress(arg0 string) bool { return o.Emit("add-local-ip-address", arg0).(bool) } + +// WebRTCICEOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type WebRTCICEOverrides[Instance WebRTCICE] struct { + // gst.ObjectOverrides allows you to override virtual methods from the parent class gst.Object + gst.ObjectOverrides[Instance] + + // AddCandidate allows you to override the implementation of the virtual method add_candidate. + // The function takes the following parameters: + // + // - stream WebRTCICEStream: The #GstWebRTCICEStream + // - candidate string: The ICE candidate + // - promise *gst.Promise (nullable): A #GstPromise for task notifications (Since: 1.24) + AddCandidate func(Instance, WebRTCICEStream, string, *gst.Promise) + // AddStream allows you to override the implementation of the virtual method add_stream. + // The function takes the following parameters: + // + // - sessionId uint: The session id + // + // The function returns the following values: + // + // - goret WebRTCICEStream (nullable) + AddStream func(Instance, uint) WebRTCICEStream + // AddTurnServer allows you to override the implementation of the virtual method add_turn_server. + // The function takes the following parameters: + // + // - uri string: URI of the TURN server + // + // The function returns the following values: + // + // - goret bool + AddTurnServer func(Instance, string) bool + // FindTransport allows you to override the implementation of the virtual method find_transport. + // The function takes the following parameters: + // + // - stream WebRTCICEStream: The #GstWebRTCICEStream + // - component WebRTCICEComponent: The #GstWebRTCICEComponent + // + // The function returns the following values: + // + // - goret WebRTCICETransport (nullable) + FindTransport func(Instance, WebRTCICEStream, WebRTCICEComponent) WebRTCICETransport + // GatherCandidates allows you to override the implementation of the virtual method gather_candidates. + // The function takes the following parameters: + // + // - stream WebRTCICEStream: The #GstWebRTCICEStream + // + // The function returns the following values: + // + // - goret bool + GatherCandidates func(Instance, WebRTCICEStream) bool + // GetHTTPProxy allows you to override the implementation of the virtual method get_http_proxy. + // The function returns the following values: + // + // - goret string + GetHTTPProxy func(Instance) string + // GetIsController allows you to override the implementation of the virtual method get_is_controller. + // The function returns the following values: + // + // - goret bool + GetIsController func(Instance) bool + // GetSelectedPair allows you to override the implementation of the virtual method get_selected_pair. + // The function takes the following parameters: + // + // - stream WebRTCICEStream: The #GstWebRTCICEStream + // + // The function returns the following values: + // + // - localStats *WebRTCICECandidateStats: A pointer to #GstWebRTCICECandidateStats for local candidate + // - remoteStats *WebRTCICECandidateStats: pointer to #GstWebRTCICECandidateStats for remote candidate + // - goret bool + GetSelectedPair func(Instance, WebRTCICEStream) (*WebRTCICECandidateStats, *WebRTCICECandidateStats, bool) + // GetStunServer allows you to override the implementation of the virtual method get_stun_server. + // The function returns the following values: + // + // - goret string (nullable) + GetStunServer func(Instance) string + // GetTurnServer allows you to override the implementation of the virtual method get_turn_server. + // The function returns the following values: + // + // - goret string (nullable) + GetTurnServer func(Instance) string + // SetForceRelay allows you to override the implementation of the virtual method set_force_relay. + // The function takes the following parameters: + // + // - forceRelay bool: TRUE to enable force relay + SetForceRelay func(Instance, bool) + // SetHTTPProxy allows you to override the implementation of the virtual method set_http_proxy. + // The function takes the following parameters: + // + // - uri string: URI of the HTTP proxy of the form + // http://[username:password@]hostname[:port][?alpn=<alpn>] + SetHTTPProxy func(Instance, string) + // SetIsController allows you to override the implementation of the virtual method set_is_controller. + // The function takes the following parameters: + // + // - controller bool: TRUE to set as controller + SetIsController func(Instance, bool) + // SetLocalCredentials allows you to override the implementation of the virtual method set_local_credentials. + // The function takes the following parameters: + // + // - stream WebRTCICEStream: The #GstWebRTCICEStream + // - ufrag string: ICE username + // - pwd string: ICE password + // + // The function returns the following values: + // + // - goret bool + SetLocalCredentials func(Instance, WebRTCICEStream, string, string) bool + // SetOnIceCandidate allows you to override the implementation of the virtual method set_on_ice_candidate. + // The function takes the following parameters: + // + // - fn WebRTCICEOnCandidateFunc: The #GstWebRTCICEOnCandidateFunc callback function + SetOnIceCandidate func(Instance, WebRTCICEOnCandidateFunc) + // SetRemoteCredentials allows you to override the implementation of the virtual method set_remote_credentials. + // The function takes the following parameters: + // + // - stream WebRTCICEStream: The #GstWebRTCICEStream + // - ufrag string: ICE username + // - pwd string: ICE password + // + // The function returns the following values: + // + // - goret bool + SetRemoteCredentials func(Instance, WebRTCICEStream, string, string) bool + // SetStunServer allows you to override the implementation of the virtual method set_stun_server. + // The function takes the following parameters: + // + // - uri string (nullable): URI of the STUN server + SetStunServer func(Instance, string) + // SetTos allows you to override the implementation of the virtual method set_tos. + // The function takes the following parameters: + // + // - stream WebRTCICEStream: The #GstWebRTCICEStream + // - tos uint: ToS to be set + SetTos func(Instance, WebRTCICEStream, uint) + // SetTurnServer allows you to override the implementation of the virtual method set_turn_server. + // The function takes the following parameters: + // + // - uri string (nullable): URI of the TURN sever + SetTurnServer func(Instance, string) +} + +// UnsafeApplyWebRTCICEOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyWebRTCICEOverrides[Instance WebRTCICE](gclass unsafe.Pointer, overrides WebRTCICEOverrides[Instance]) { + gst.UnsafeApplyObjectOverrides(gclass, overrides.ObjectOverrides) + + pclass := (*C.GstWebRTCICEClass)(gclass) + + if overrides.AddCandidate != nil { + pclass.add_candidate = (*[0]byte)(C._gotk4_gstwebrtc1_WebRTCICE_add_candidate) + } + + if overrides.AddStream != nil { + pclass.add_stream = (*[0]byte)(C._gotk4_gstwebrtc1_WebRTCICE_add_stream) + } + + if overrides.AddTurnServer != nil { + pclass.add_turn_server = (*[0]byte)(C._gotk4_gstwebrtc1_WebRTCICE_add_turn_server) + } + + if overrides.FindTransport != nil { + pclass.find_transport = (*[0]byte)(C._gotk4_gstwebrtc1_WebRTCICE_find_transport) + } + + if overrides.GatherCandidates != nil { + pclass.gather_candidates = (*[0]byte)(C._gotk4_gstwebrtc1_WebRTCICE_gather_candidates) + } + + if overrides.GetHTTPProxy != nil { + pclass.get_http_proxy = (*[0]byte)(C._gotk4_gstwebrtc1_WebRTCICE_get_http_proxy) + } + + if overrides.GetIsController != nil { + pclass.get_is_controller = (*[0]byte)(C._gotk4_gstwebrtc1_WebRTCICE_get_is_controller) + } + + if overrides.GetSelectedPair != nil { + pclass.get_selected_pair = (*[0]byte)(C._gotk4_gstwebrtc1_WebRTCICE_get_selected_pair) + } + + if overrides.GetStunServer != nil { + pclass.get_stun_server = (*[0]byte)(C._gotk4_gstwebrtc1_WebRTCICE_get_stun_server) + } + + if overrides.GetTurnServer != nil { + pclass.get_turn_server = (*[0]byte)(C._gotk4_gstwebrtc1_WebRTCICE_get_turn_server) + } + + if overrides.SetForceRelay != nil { + pclass.set_force_relay = (*[0]byte)(C._gotk4_gstwebrtc1_WebRTCICE_set_force_relay) + } + + if overrides.SetHTTPProxy != nil { + pclass.set_http_proxy = (*[0]byte)(C._gotk4_gstwebrtc1_WebRTCICE_set_http_proxy) + } + + if overrides.SetIsController != nil { + pclass.set_is_controller = (*[0]byte)(C._gotk4_gstwebrtc1_WebRTCICE_set_is_controller) + } + + if overrides.SetLocalCredentials != nil { + pclass.set_local_credentials = (*[0]byte)(C._gotk4_gstwebrtc1_WebRTCICE_set_local_credentials) + } + + if overrides.SetOnIceCandidate != nil { + pclass.set_on_ice_candidate = (*[0]byte)(C._gotk4_gstwebrtc1_WebRTCICE_set_on_ice_candidate) + } + + if overrides.SetRemoteCredentials != nil { + pclass.set_remote_credentials = (*[0]byte)(C._gotk4_gstwebrtc1_WebRTCICE_set_remote_credentials) + } + + if overrides.SetStunServer != nil { + pclass.set_stun_server = (*[0]byte)(C._gotk4_gstwebrtc1_WebRTCICE_set_stun_server) + } + + if overrides.SetTos != nil { + pclass.set_tos = (*[0]byte)(C._gotk4_gstwebrtc1_WebRTCICE_set_tos) + } + + if overrides.SetTurnServer != nil { + pclass.set_turn_server = (*[0]byte)(C._gotk4_gstwebrtc1_WebRTCICE_set_turn_server) + } +} + // WebRTCICEStreamInstance is the instance type used by all types extending GstWebRTCICEStream. It is used internally by the bindings. Users should use the interface [WebRTCICEStream] instead. type WebRTCICEStreamInstance struct { _ [0]func() // equal guard @@ -2228,6 +2561,7 @@ type WebRTCICEStream interface { // - goret WebRTCICETransport (nullable) FindTransport(WebRTCICEComponent) WebRTCICETransport // GatherCandidates wraps gst_webrtc_ice_stream_gather_candidates + // // The function returns the following values: // // - goret bool @@ -2303,6 +2637,7 @@ func (stream *WebRTCICEStreamInstance) FindTransport(component WebRTCICEComponen } // GatherCandidates wraps gst_webrtc_ice_stream_gather_candidates +// // The function returns the following values: // // - goret bool @@ -2324,6 +2659,44 @@ func (ice *WebRTCICEStreamInstance) GatherCandidates() bool { return goret } +// WebRTCICEStreamOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type WebRTCICEStreamOverrides[Instance WebRTCICEStream] struct { + // gst.ObjectOverrides allows you to override virtual methods from the parent class gst.Object + gst.ObjectOverrides[Instance] + + // FindTransport allows you to override the implementation of the virtual method find_transport. + // The function takes the following parameters: + // + // - component WebRTCICEComponent: The #GstWebRTCICEComponent + // + // The function returns the following values: + // + // - goret WebRTCICETransport (nullable) + FindTransport func(Instance, WebRTCICEComponent) WebRTCICETransport + // GatherCandidates allows you to override the implementation of the virtual method gather_candidates. + // The function returns the following values: + // + // - goret bool + GatherCandidates func(Instance) bool +} + +// UnsafeApplyWebRTCICEStreamOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyWebRTCICEStreamOverrides[Instance WebRTCICEStream](gclass unsafe.Pointer, overrides WebRTCICEStreamOverrides[Instance]) { + gst.UnsafeApplyObjectOverrides(gclass, overrides.ObjectOverrides) + + pclass := (*C.GstWebRTCICEStreamClass)(gclass) + + if overrides.FindTransport != nil { + pclass.find_transport = (*[0]byte)(C._gotk4_gstwebrtc1_WebRTCICEStream_find_transport) + } + + if overrides.GatherCandidates != nil { + pclass.gather_candidates = (*[0]byte)(C._gotk4_gstwebrtc1_WebRTCICEStream_gather_candidates) + } +} + // WebRTCICETransportInstance is the instance type used by all types extending GstWebRTCICETransport. It is used internally by the bindings. Users should use the interface [WebRTCICETransport] instead. type WebRTCICETransportInstance struct { _ [0]func() // equal guard @@ -2477,10 +2850,37 @@ func (ice *WebRTCICETransportInstance) SelectedPairChange() { func (o *WebRTCICETransportInstance) ConnectOnNewCandidate(fn func(WebRTCICETransport, string)) gobject.SignalHandle { return o.Connect("on-new-candidate", fn) } + // ConnectOnSelectedCandidatePairChange connects the provided callback to the "on-selected-candidate-pair-change" signal func (o *WebRTCICETransportInstance) ConnectOnSelectedCandidatePairChange(fn func(WebRTCICETransport)) gobject.SignalHandle { return o.Connect("on-selected-candidate-pair-change", fn) } + +// WebRTCICETransportOverrides is the struct used to override the default implementation of virtual methods. +// it is generic over the extending instance type. +type WebRTCICETransportOverrides[Instance WebRTCICETransport] struct { + // gst.ObjectOverrides allows you to override virtual methods from the parent class gst.Object + gst.ObjectOverrides[Instance] + + // GatherCandidates allows you to override the implementation of the virtual method gather_candidates. + // The function returns the following values: + // + // - goret bool + GatherCandidates func(Instance) bool +} + +// UnsafeApplyWebRTCICETransportOverrides applies the overrides to init the gclass by setting the trampoline functions. +// This is used by the bindings internally and only exported for visibility to other bindings code. +func UnsafeApplyWebRTCICETransportOverrides[Instance WebRTCICETransport](gclass unsafe.Pointer, overrides WebRTCICETransportOverrides[Instance]) { + gst.UnsafeApplyObjectOverrides(gclass, overrides.ObjectOverrides) + + pclass := (*C.GstWebRTCICETransportClass)(gclass) + + if overrides.GatherCandidates != nil { + pclass.gather_candidates = (*[0]byte)(C._gotk4_gstwebrtc1_WebRTCICETransport_gather_candidates) + } +} + // WebRTCRTPReceiverInstance is the instance type used by all types extending GstWebRTCRTPReceiver. It is used internally by the bindings. Users should use the interface [WebRTCRTPReceiver] instead. type WebRTCRTPReceiverInstance struct { _ [0]func() // equal guard @@ -2732,6 +3132,8 @@ func UnsafeWebRTCSCTPTransportToGlibFull(c WebRTCSCTPTransport) unsafe.Pointer { } // WebRTCDTLSTransportClass wraps GstWebRTCDTLSTransportClass +// +// WebRTCDTLSTransportClass is the type struct for [WebRTCDTLSTransport] type WebRTCDTLSTransportClass struct { *webRTCDTLSTransportClass } @@ -2746,31 +3148,6 @@ func UnsafeWebRTCDTLSTransportClassFromGlibBorrow(p unsafe.Pointer) *WebRTCDTLST return &WebRTCDTLSTransportClass{&webRTCDTLSTransportClass{(*C.GstWebRTCDTLSTransportClass)(p)}} } -// UnsafeWebRTCDTLSTransportClassFromGlibNone is used to convert raw C.GstWebRTCDTLSTransportClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeWebRTCDTLSTransportClassFromGlibNone(p unsafe.Pointer) *WebRTCDTLSTransportClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeWebRTCDTLSTransportClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.webRTCDTLSTransportClass, - func (intern *webRTCDTLSTransportClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeWebRTCDTLSTransportClassFromGlibFull is used to convert raw C.GstWebRTCDTLSTransportClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeWebRTCDTLSTransportClassFromGlibFull(p unsafe.Pointer) *WebRTCDTLSTransportClass { - wrapped := UnsafeWebRTCDTLSTransportClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.webRTCDTLSTransportClass, - func (intern *webRTCDTLSTransportClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeWebRTCDTLSTransportClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [WebRTCDTLSTransportClass] is expected to work anymore. @@ -2783,15 +3160,18 @@ func UnsafeWebRTCDTLSTransportClassToGlibNone(w *WebRTCDTLSTransportClass) unsaf return unsafe.Pointer(w.native) } -// UnsafeWebRTCDTLSTransportClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeWebRTCDTLSTransportClassToGlibFull(w *WebRTCDTLSTransportClass) unsafe.Pointer { - runtime.SetFinalizer(w.webRTCDTLSTransportClass, nil) - _p := unsafe.Pointer(w.native) - w.native = nil // WebRTCDTLSTransportClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (w *WebRTCDTLSTransportClass) ParentClass() *gst.ObjectClass { + parent := gst.UnsafeObjectClassFromGlibBorrow(UnsafeWebRTCDTLSTransportClassToGlibNone(w)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *WebRTCDTLSTransportClass) {}, w) + return parent } + // WebRTCDataChannelClass wraps GstWebRTCDataChannelClass +// +// WebRTCDataChannelClass is the type struct for [WebRTCDataChannel] type WebRTCDataChannelClass struct { *webRTCDataChannelClass } @@ -2806,31 +3186,6 @@ func UnsafeWebRTCDataChannelClassFromGlibBorrow(p unsafe.Pointer) *WebRTCDataCha return &WebRTCDataChannelClass{&webRTCDataChannelClass{(*C.GstWebRTCDataChannelClass)(p)}} } -// UnsafeWebRTCDataChannelClassFromGlibNone is used to convert raw C.GstWebRTCDataChannelClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeWebRTCDataChannelClassFromGlibNone(p unsafe.Pointer) *WebRTCDataChannelClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeWebRTCDataChannelClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.webRTCDataChannelClass, - func (intern *webRTCDataChannelClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeWebRTCDataChannelClassFromGlibFull is used to convert raw C.GstWebRTCDataChannelClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeWebRTCDataChannelClassFromGlibFull(p unsafe.Pointer) *WebRTCDataChannelClass { - wrapped := UnsafeWebRTCDataChannelClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.webRTCDataChannelClass, - func (intern *webRTCDataChannelClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeWebRTCDataChannelClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [WebRTCDataChannelClass] is expected to work anymore. @@ -2843,14 +3198,15 @@ func UnsafeWebRTCDataChannelClassToGlibNone(w *WebRTCDataChannelClass) unsafe.Po return unsafe.Pointer(w.native) } -// UnsafeWebRTCDataChannelClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeWebRTCDataChannelClassToGlibFull(w *WebRTCDataChannelClass) unsafe.Pointer { - runtime.SetFinalizer(w.webRTCDataChannelClass, nil) - _p := unsafe.Pointer(w.native) - w.native = nil // WebRTCDataChannelClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (w *WebRTCDataChannelClass) ParentClass() *gobject.ObjectClass { + parent := gobject.UnsafeObjectClassFromGlibBorrow(UnsafeWebRTCDataChannelClassToGlibNone(w)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *WebRTCDataChannelClass) {}, w) + return parent } + // WebRTCICECandidateStats wraps GstWebRTCICECandidateStats type WebRTCICECandidateStats struct { *webRTCICECandidateStats @@ -2878,7 +3234,7 @@ func UnsafeWebRTCICECandidateStatsFromGlibBorrow(p unsafe.Pointer) *WebRTCICECan return &WebRTCICECandidateStats{&webRTCICECandidateStats{(*C.GstWebRTCICECandidateStats)(p)}} } -// UnsafeWebRTCICECandidateStatsFromGlibNone is used to convert raw C.GstWebRTCICECandidateStats pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeWebRTCICECandidateStatsFromGlibNone is used to convert raw C.GstWebRTCICECandidateStats pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeWebRTCICECandidateStatsFromGlibNone(p unsafe.Pointer) *WebRTCICECandidateStats { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeWebRTCICECandidateStatsFromGlibBorrow(p) @@ -2891,7 +3247,7 @@ func UnsafeWebRTCICECandidateStatsFromGlibNone(p unsafe.Pointer) *WebRTCICECandi return wrapped } -// UnsafeWebRTCICECandidateStatsFromGlibFull is used to convert raw C.GstWebRTCICECandidateStats pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeWebRTCICECandidateStatsFromGlibFull is used to convert raw C.GstWebRTCICECandidateStats pointers to go while taking ownership. This is used by the bindings internally. func UnsafeWebRTCICECandidateStatsFromGlibFull(p unsafe.Pointer) *WebRTCICECandidateStats { wrapped := UnsafeWebRTCICECandidateStatsFromGlibBorrow(p) runtime.SetFinalizer( @@ -2923,7 +3279,9 @@ func UnsafeWebRTCICECandidateStatsToGlibFull(w *WebRTCICECandidateStats) unsafe. w.native = nil // WebRTCICECandidateStats is invalid from here on return _p } + // Copy wraps gst_webrtc_ice_candidate_stats_copy +// // The function returns the following values: // // - goret *WebRTCICECandidateStats @@ -2944,6 +3302,8 @@ func (stats *WebRTCICECandidateStats) Copy() *WebRTCICECandidateStats { } // WebRTCICEClass wraps GstWebRTCICEClass +// +// WebRTCICEClass is the type struct for [WebRTCICE] type WebRTCICEClass struct { *webRTCICEClass } @@ -2958,31 +3318,6 @@ func UnsafeWebRTCICEClassFromGlibBorrow(p unsafe.Pointer) *WebRTCICEClass { return &WebRTCICEClass{&webRTCICEClass{(*C.GstWebRTCICEClass)(p)}} } -// UnsafeWebRTCICEClassFromGlibNone is used to convert raw C.GstWebRTCICEClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeWebRTCICEClassFromGlibNone(p unsafe.Pointer) *WebRTCICEClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeWebRTCICEClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.webRTCICEClass, - func (intern *webRTCICEClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeWebRTCICEClassFromGlibFull is used to convert raw C.GstWebRTCICEClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeWebRTCICEClassFromGlibFull(p unsafe.Pointer) *WebRTCICEClass { - wrapped := UnsafeWebRTCICEClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.webRTCICEClass, - func (intern *webRTCICEClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeWebRTCICEClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [WebRTCICEClass] is expected to work anymore. @@ -2995,15 +3330,18 @@ func UnsafeWebRTCICEClassToGlibNone(w *WebRTCICEClass) unsafe.Pointer { return unsafe.Pointer(w.native) } -// UnsafeWebRTCICEClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeWebRTCICEClassToGlibFull(w *WebRTCICEClass) unsafe.Pointer { - runtime.SetFinalizer(w.webRTCICEClass, nil) - _p := unsafe.Pointer(w.native) - w.native = nil // WebRTCICEClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (w *WebRTCICEClass) ParentClass() *gst.ObjectClass { + parent := gst.UnsafeObjectClassFromGlibBorrow(UnsafeWebRTCICEClassToGlibNone(w)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *WebRTCICEClass) {}, w) + return parent } + // WebRTCICEStreamClass wraps GstWebRTCICEStreamClass +// +// WebRTCICEStreamClass is the type struct for [WebRTCICEStream] type WebRTCICEStreamClass struct { *webRTCICEStreamClass } @@ -3018,31 +3356,6 @@ func UnsafeWebRTCICEStreamClassFromGlibBorrow(p unsafe.Pointer) *WebRTCICEStream return &WebRTCICEStreamClass{&webRTCICEStreamClass{(*C.GstWebRTCICEStreamClass)(p)}} } -// UnsafeWebRTCICEStreamClassFromGlibNone is used to convert raw C.GstWebRTCICEStreamClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeWebRTCICEStreamClassFromGlibNone(p unsafe.Pointer) *WebRTCICEStreamClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeWebRTCICEStreamClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.webRTCICEStreamClass, - func (intern *webRTCICEStreamClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeWebRTCICEStreamClassFromGlibFull is used to convert raw C.GstWebRTCICEStreamClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeWebRTCICEStreamClassFromGlibFull(p unsafe.Pointer) *WebRTCICEStreamClass { - wrapped := UnsafeWebRTCICEStreamClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.webRTCICEStreamClass, - func (intern *webRTCICEStreamClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeWebRTCICEStreamClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [WebRTCICEStreamClass] is expected to work anymore. @@ -3055,15 +3368,18 @@ func UnsafeWebRTCICEStreamClassToGlibNone(w *WebRTCICEStreamClass) unsafe.Pointe return unsafe.Pointer(w.native) } -// UnsafeWebRTCICEStreamClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeWebRTCICEStreamClassToGlibFull(w *WebRTCICEStreamClass) unsafe.Pointer { - runtime.SetFinalizer(w.webRTCICEStreamClass, nil) - _p := unsafe.Pointer(w.native) - w.native = nil // WebRTCICEStreamClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (w *WebRTCICEStreamClass) ParentClass() *gst.ObjectClass { + parent := gst.UnsafeObjectClassFromGlibBorrow(UnsafeWebRTCICEStreamClassToGlibNone(w)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *WebRTCICEStreamClass) {}, w) + return parent } + // WebRTCICETransportClass wraps GstWebRTCICETransportClass +// +// WebRTCICETransportClass is the type struct for [WebRTCICETransport] type WebRTCICETransportClass struct { *webRTCICETransportClass } @@ -3078,31 +3394,6 @@ func UnsafeWebRTCICETransportClassFromGlibBorrow(p unsafe.Pointer) *WebRTCICETra return &WebRTCICETransportClass{&webRTCICETransportClass{(*C.GstWebRTCICETransportClass)(p)}} } -// UnsafeWebRTCICETransportClassFromGlibNone is used to convert raw C.GstWebRTCICETransportClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeWebRTCICETransportClassFromGlibNone(p unsafe.Pointer) *WebRTCICETransportClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeWebRTCICETransportClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.webRTCICETransportClass, - func (intern *webRTCICETransportClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeWebRTCICETransportClassFromGlibFull is used to convert raw C.GstWebRTCICETransportClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeWebRTCICETransportClassFromGlibFull(p unsafe.Pointer) *WebRTCICETransportClass { - wrapped := UnsafeWebRTCICETransportClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.webRTCICETransportClass, - func (intern *webRTCICETransportClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeWebRTCICETransportClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [WebRTCICETransportClass] is expected to work anymore. @@ -3115,15 +3406,18 @@ func UnsafeWebRTCICETransportClassToGlibNone(w *WebRTCICETransportClass) unsafe. return unsafe.Pointer(w.native) } -// UnsafeWebRTCICETransportClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeWebRTCICETransportClassToGlibFull(w *WebRTCICETransportClass) unsafe.Pointer { - runtime.SetFinalizer(w.webRTCICETransportClass, nil) - _p := unsafe.Pointer(w.native) - w.native = nil // WebRTCICETransportClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (w *WebRTCICETransportClass) ParentClass() *gst.ObjectClass { + parent := gst.UnsafeObjectClassFromGlibBorrow(UnsafeWebRTCICETransportClassToGlibNone(w)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *WebRTCICETransportClass) {}, w) + return parent } + // WebRTCRTPReceiverClass wraps GstWebRTCRTPReceiverClass +// +// WebRTCRTPReceiverClass is the type struct for [WebRTCRTPReceiver] type WebRTCRTPReceiverClass struct { *webRTCRTPReceiverClass } @@ -3138,31 +3432,6 @@ func UnsafeWebRTCRTPReceiverClassFromGlibBorrow(p unsafe.Pointer) *WebRTCRTPRece return &WebRTCRTPReceiverClass{&webRTCRTPReceiverClass{(*C.GstWebRTCRTPReceiverClass)(p)}} } -// UnsafeWebRTCRTPReceiverClassFromGlibNone is used to convert raw C.GstWebRTCRTPReceiverClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeWebRTCRTPReceiverClassFromGlibNone(p unsafe.Pointer) *WebRTCRTPReceiverClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeWebRTCRTPReceiverClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.webRTCRTPReceiverClass, - func (intern *webRTCRTPReceiverClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeWebRTCRTPReceiverClassFromGlibFull is used to convert raw C.GstWebRTCRTPReceiverClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeWebRTCRTPReceiverClassFromGlibFull(p unsafe.Pointer) *WebRTCRTPReceiverClass { - wrapped := UnsafeWebRTCRTPReceiverClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.webRTCRTPReceiverClass, - func (intern *webRTCRTPReceiverClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeWebRTCRTPReceiverClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [WebRTCRTPReceiverClass] is expected to work anymore. @@ -3175,15 +3444,18 @@ func UnsafeWebRTCRTPReceiverClassToGlibNone(w *WebRTCRTPReceiverClass) unsafe.Po return unsafe.Pointer(w.native) } -// UnsafeWebRTCRTPReceiverClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeWebRTCRTPReceiverClassToGlibFull(w *WebRTCRTPReceiverClass) unsafe.Pointer { - runtime.SetFinalizer(w.webRTCRTPReceiverClass, nil) - _p := unsafe.Pointer(w.native) - w.native = nil // WebRTCRTPReceiverClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (w *WebRTCRTPReceiverClass) ParentClass() *gst.ObjectClass { + parent := gst.UnsafeObjectClassFromGlibBorrow(UnsafeWebRTCRTPReceiverClassToGlibNone(w)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *WebRTCRTPReceiverClass) {}, w) + return parent } + // WebRTCRTPSenderClass wraps GstWebRTCRTPSenderClass +// +// WebRTCRTPSenderClass is the type struct for [WebRTCRTPSender] type WebRTCRTPSenderClass struct { *webRTCRTPSenderClass } @@ -3198,31 +3470,6 @@ func UnsafeWebRTCRTPSenderClassFromGlibBorrow(p unsafe.Pointer) *WebRTCRTPSender return &WebRTCRTPSenderClass{&webRTCRTPSenderClass{(*C.GstWebRTCRTPSenderClass)(p)}} } -// UnsafeWebRTCRTPSenderClassFromGlibNone is used to convert raw C.GstWebRTCRTPSenderClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeWebRTCRTPSenderClassFromGlibNone(p unsafe.Pointer) *WebRTCRTPSenderClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeWebRTCRTPSenderClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.webRTCRTPSenderClass, - func (intern *webRTCRTPSenderClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeWebRTCRTPSenderClassFromGlibFull is used to convert raw C.GstWebRTCRTPSenderClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeWebRTCRTPSenderClassFromGlibFull(p unsafe.Pointer) *WebRTCRTPSenderClass { - wrapped := UnsafeWebRTCRTPSenderClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.webRTCRTPSenderClass, - func (intern *webRTCRTPSenderClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeWebRTCRTPSenderClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [WebRTCRTPSenderClass] is expected to work anymore. @@ -3235,15 +3482,18 @@ func UnsafeWebRTCRTPSenderClassToGlibNone(w *WebRTCRTPSenderClass) unsafe.Pointe return unsafe.Pointer(w.native) } -// UnsafeWebRTCRTPSenderClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeWebRTCRTPSenderClassToGlibFull(w *WebRTCRTPSenderClass) unsafe.Pointer { - runtime.SetFinalizer(w.webRTCRTPSenderClass, nil) - _p := unsafe.Pointer(w.native) - w.native = nil // WebRTCRTPSenderClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (w *WebRTCRTPSenderClass) ParentClass() *gst.ObjectClass { + parent := gst.UnsafeObjectClassFromGlibBorrow(UnsafeWebRTCRTPSenderClassToGlibNone(w)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *WebRTCRTPSenderClass) {}, w) + return parent } + // WebRTCRTPTransceiverClass wraps GstWebRTCRTPTransceiverClass +// +// WebRTCRTPTransceiverClass is the type struct for [WebRTCRTPTransceiver] type WebRTCRTPTransceiverClass struct { *webRTCRTPTransceiverClass } @@ -3258,31 +3508,6 @@ func UnsafeWebRTCRTPTransceiverClassFromGlibBorrow(p unsafe.Pointer) *WebRTCRTPT return &WebRTCRTPTransceiverClass{&webRTCRTPTransceiverClass{(*C.GstWebRTCRTPTransceiverClass)(p)}} } -// UnsafeWebRTCRTPTransceiverClassFromGlibNone is used to convert raw C.GstWebRTCRTPTransceiverClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeWebRTCRTPTransceiverClassFromGlibNone(p unsafe.Pointer) *WebRTCRTPTransceiverClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeWebRTCRTPTransceiverClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.webRTCRTPTransceiverClass, - func (intern *webRTCRTPTransceiverClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeWebRTCRTPTransceiverClassFromGlibFull is used to convert raw C.GstWebRTCRTPTransceiverClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeWebRTCRTPTransceiverClassFromGlibFull(p unsafe.Pointer) *WebRTCRTPTransceiverClass { - wrapped := UnsafeWebRTCRTPTransceiverClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.webRTCRTPTransceiverClass, - func (intern *webRTCRTPTransceiverClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeWebRTCRTPTransceiverClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [WebRTCRTPTransceiverClass] is expected to work anymore. @@ -3295,15 +3520,18 @@ func UnsafeWebRTCRTPTransceiverClassToGlibNone(w *WebRTCRTPTransceiverClass) uns return unsafe.Pointer(w.native) } -// UnsafeWebRTCRTPTransceiverClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeWebRTCRTPTransceiverClassToGlibFull(w *WebRTCRTPTransceiverClass) unsafe.Pointer { - runtime.SetFinalizer(w.webRTCRTPTransceiverClass, nil) - _p := unsafe.Pointer(w.native) - w.native = nil // WebRTCRTPTransceiverClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (w *WebRTCRTPTransceiverClass) ParentClass() *gst.ObjectClass { + parent := gst.UnsafeObjectClassFromGlibBorrow(UnsafeWebRTCRTPTransceiverClassToGlibNone(w)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *WebRTCRTPTransceiverClass) {}, w) + return parent } + // WebRTCSCTPTransportClass wraps GstWebRTCSCTPTransportClass +// +// WebRTCSCTPTransportClass is the type struct for [WebRTCSCTPTransport] type WebRTCSCTPTransportClass struct { *webRTCSCTPTransportClass } @@ -3318,31 +3546,6 @@ func UnsafeWebRTCSCTPTransportClassFromGlibBorrow(p unsafe.Pointer) *WebRTCSCTPT return &WebRTCSCTPTransportClass{&webRTCSCTPTransportClass{(*C.GstWebRTCSCTPTransportClass)(p)}} } -// UnsafeWebRTCSCTPTransportClassFromGlibNone is used to convert raw C.GstWebRTCSCTPTransportClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeWebRTCSCTPTransportClassFromGlibNone(p unsafe.Pointer) *WebRTCSCTPTransportClass { - // FIXME: this has no ref function, what should we do here? - wrapped := UnsafeWebRTCSCTPTransportClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.webRTCSCTPTransportClass, - func (intern *webRTCSCTPTransportClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - -// UnsafeWebRTCSCTPTransportClassFromGlibFull is used to convert raw C.GstWebRTCSCTPTransportClass pointers to go while taking a reference. This is used by the bindings internally. -func UnsafeWebRTCSCTPTransportClassFromGlibFull(p unsafe.Pointer) *WebRTCSCTPTransportClass { - wrapped := UnsafeWebRTCSCTPTransportClassFromGlibBorrow(p) - runtime.SetFinalizer( - wrapped.webRTCSCTPTransportClass, - func (intern *webRTCSCTPTransportClass) { - C.free(unsafe.Pointer(intern.native)) - }, - ) - return wrapped -} - // UnsafeWebRTCSCTPTransportClassFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [WebRTCSCTPTransportClass] is expected to work anymore. @@ -3355,14 +3558,15 @@ func UnsafeWebRTCSCTPTransportClassToGlibNone(w *WebRTCSCTPTransportClass) unsaf return unsafe.Pointer(w.native) } -// UnsafeWebRTCSCTPTransportClassToGlibFull returns the underlying C pointer and gives up ownership. -// This is used by the bindings internally. -func UnsafeWebRTCSCTPTransportClassToGlibFull(w *WebRTCSCTPTransportClass) unsafe.Pointer { - runtime.SetFinalizer(w.webRTCSCTPTransportClass, nil) - _p := unsafe.Pointer(w.native) - w.native = nil // WebRTCSCTPTransportClass is invalid from here on - return _p +// ParentClass returns the type struct of the parent class of this type struct. +// This essentially casts the underlying c pointer. +func (w *WebRTCSCTPTransportClass) ParentClass() *gst.ObjectClass { + parent := gst.UnsafeObjectClassFromGlibBorrow(UnsafeWebRTCSCTPTransportClassToGlibNone(w)) + // attach a cleanup to keep the instance alive as long as the parent is referenced + runtime.AddCleanup(parent, func(_ *WebRTCSCTPTransportClass) {}, w) + return parent } + // WebRTCSessionDescription wraps GstWebRTCSessionDescription // // See <https://www.w3.org/TR/webrtc/#rtcsessiondescription-class> @@ -3392,7 +3596,7 @@ func UnsafeWebRTCSessionDescriptionFromGlibBorrow(p unsafe.Pointer) *WebRTCSessi return &WebRTCSessionDescription{&webRTCSessionDescription{(*C.GstWebRTCSessionDescription)(p)}} } -// UnsafeWebRTCSessionDescriptionFromGlibNone is used to convert raw C.GstWebRTCSessionDescription pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeWebRTCSessionDescriptionFromGlibNone is used to convert raw C.GstWebRTCSessionDescription pointers to go without transferring ownership. This is used by the bindings internally. func UnsafeWebRTCSessionDescriptionFromGlibNone(p unsafe.Pointer) *WebRTCSessionDescription { // FIXME: this has no ref function, what should we do here? wrapped := UnsafeWebRTCSessionDescriptionFromGlibBorrow(p) @@ -3405,7 +3609,7 @@ func UnsafeWebRTCSessionDescriptionFromGlibNone(p unsafe.Pointer) *WebRTCSession return wrapped } -// UnsafeWebRTCSessionDescriptionFromGlibFull is used to convert raw C.GstWebRTCSessionDescription pointers to go while taking a reference. This is used by the bindings internally. +// UnsafeWebRTCSessionDescriptionFromGlibFull is used to convert raw C.GstWebRTCSessionDescription pointers to go while taking ownership. This is used by the bindings internally. func UnsafeWebRTCSessionDescriptionFromGlibFull(p unsafe.Pointer) *WebRTCSessionDescription { wrapped := UnsafeWebRTCSessionDescriptionFromGlibBorrow(p) runtime.SetFinalizer( @@ -3437,6 +3641,7 @@ func UnsafeWebRTCSessionDescriptionToGlibFull(w *WebRTCSessionDescription) unsaf w.native = nil // WebRTCSessionDescription is invalid from here on return _p } + // NewWebRTCSessionDescription wraps gst_webrtc_session_description_new // // The function takes the following parameters: @@ -3467,6 +3672,7 @@ func NewWebRTCSessionDescription(typ WebRTCSDPType, sdp *gstsdp.SDPMessage) *Web } // Copy wraps gst_webrtc_session_description_copy +// // The function returns the following values: // // - goret *WebRTCSessionDescription diff --git a/pkg/gstwebrtc/gstwebrtc_export.gen.go b/pkg/gstwebrtc/gstwebrtc_export.gen.go index 6c223b6..8b1622f 100644 --- a/pkg/gstwebrtc/gstwebrtc_export.gen.go +++ b/pkg/gstwebrtc/gstwebrtc_export.gen.go @@ -34,3 +34,113 @@ func _gotk4_gstwebrtc1_WebRTCICEOnCandidateFunc(carg1 *C.GstWebRTCICE, carg2 C.g fn(ice, streamId, candidate) } +//export _gotk4_gstwebrtc1_WebRTCICE_add_candidate +func _gotk4_gstwebrtc1_WebRTCICE_add_candidate(carg0 *C.GstWebRTCICE, carg1 *C.GstWebRTCICEStream, carg2 *C.gchar, carg3 *C.GstPromise) { + panic("unimplemented") +} + +//export _gotk4_gstwebrtc1_WebRTCICE_add_stream +func _gotk4_gstwebrtc1_WebRTCICE_add_stream(carg0 *C.GstWebRTCICE, carg1 C.guint) (cret *C.GstWebRTCICEStream) { + panic("unimplemented") +} + +//export _gotk4_gstwebrtc1_WebRTCICE_add_turn_server +func _gotk4_gstwebrtc1_WebRTCICE_add_turn_server(carg0 *C.GstWebRTCICE, carg1 *C.gchar) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstwebrtc1_WebRTCICE_find_transport +func _gotk4_gstwebrtc1_WebRTCICE_find_transport(carg0 *C.GstWebRTCICE, carg1 *C.GstWebRTCICEStream, carg2 C.GstWebRTCICEComponent) (cret *C.GstWebRTCICETransport) { + panic("unimplemented") +} + +//export _gotk4_gstwebrtc1_WebRTCICE_gather_candidates +func _gotk4_gstwebrtc1_WebRTCICE_gather_candidates(carg0 *C.GstWebRTCICE, carg1 *C.GstWebRTCICEStream) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstwebrtc1_WebRTCICE_get_http_proxy +func _gotk4_gstwebrtc1_WebRTCICE_get_http_proxy(carg0 *C.GstWebRTCICE) (cret *C.gchar) { + panic("unimplemented") +} + +//export _gotk4_gstwebrtc1_WebRTCICE_get_is_controller +func _gotk4_gstwebrtc1_WebRTCICE_get_is_controller(carg0 *C.GstWebRTCICE) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstwebrtc1_WebRTCICE_get_selected_pair +func _gotk4_gstwebrtc1_WebRTCICE_get_selected_pair(carg0 *C.GstWebRTCICE, carg1 *C.GstWebRTCICEStream, carg2 **C.GstWebRTCICECandidateStats, carg3 **C.GstWebRTCICECandidateStats) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstwebrtc1_WebRTCICE_get_stun_server +func _gotk4_gstwebrtc1_WebRTCICE_get_stun_server(carg0 *C.GstWebRTCICE) (cret *C.gchar) { + panic("unimplemented") +} + +//export _gotk4_gstwebrtc1_WebRTCICE_get_turn_server +func _gotk4_gstwebrtc1_WebRTCICE_get_turn_server(carg0 *C.GstWebRTCICE) (cret *C.gchar) { + panic("unimplemented") +} + +//export _gotk4_gstwebrtc1_WebRTCICE_set_force_relay +func _gotk4_gstwebrtc1_WebRTCICE_set_force_relay(carg0 *C.GstWebRTCICE, carg1 C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstwebrtc1_WebRTCICE_set_http_proxy +func _gotk4_gstwebrtc1_WebRTCICE_set_http_proxy(carg0 *C.GstWebRTCICE, carg1 *C.gchar) { + panic("unimplemented") +} + +//export _gotk4_gstwebrtc1_WebRTCICE_set_is_controller +func _gotk4_gstwebrtc1_WebRTCICE_set_is_controller(carg0 *C.GstWebRTCICE, carg1 C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstwebrtc1_WebRTCICE_set_local_credentials +func _gotk4_gstwebrtc1_WebRTCICE_set_local_credentials(carg0 *C.GstWebRTCICE, carg1 *C.GstWebRTCICEStream, carg2 *C.gchar, carg3 *C.gchar) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstwebrtc1_WebRTCICE_set_on_ice_candidate +func _gotk4_gstwebrtc1_WebRTCICE_set_on_ice_candidate(carg0 *C.GstWebRTCICE, carg1 C.GstWebRTCICEOnCandidateFunc, carg2 C.gpointer, carg3 C.GDestroyNotify) { + panic("unimplemented") +} + +//export _gotk4_gstwebrtc1_WebRTCICE_set_remote_credentials +func _gotk4_gstwebrtc1_WebRTCICE_set_remote_credentials(carg0 *C.GstWebRTCICE, carg1 *C.GstWebRTCICEStream, carg2 *C.gchar, carg3 *C.gchar) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstwebrtc1_WebRTCICE_set_stun_server +func _gotk4_gstwebrtc1_WebRTCICE_set_stun_server(carg0 *C.GstWebRTCICE, carg1 *C.gchar) { + panic("unimplemented") +} + +//export _gotk4_gstwebrtc1_WebRTCICE_set_tos +func _gotk4_gstwebrtc1_WebRTCICE_set_tos(carg0 *C.GstWebRTCICE, carg1 *C.GstWebRTCICEStream, carg2 C.guint) { + panic("unimplemented") +} + +//export _gotk4_gstwebrtc1_WebRTCICE_set_turn_server +func _gotk4_gstwebrtc1_WebRTCICE_set_turn_server(carg0 *C.GstWebRTCICE, carg1 *C.gchar) { + panic("unimplemented") +} + +//export _gotk4_gstwebrtc1_WebRTCICEStream_find_transport +func _gotk4_gstwebrtc1_WebRTCICEStream_find_transport(carg0 *C.GstWebRTCICEStream, carg1 C.GstWebRTCICEComponent) (cret *C.GstWebRTCICETransport) { + panic("unimplemented") +} + +//export _gotk4_gstwebrtc1_WebRTCICEStream_gather_candidates +func _gotk4_gstwebrtc1_WebRTCICEStream_gather_candidates(carg0 *C.GstWebRTCICEStream) (cret C.gboolean) { + panic("unimplemented") +} + +//export _gotk4_gstwebrtc1_WebRTCICETransport_gather_candidates +func _gotk4_gstwebrtc1_WebRTCICETransport_gather_candidates(carg0 *C.GstWebRTCICETransport) (cret C.gboolean) { + panic("unimplemented") +} +