// Code generated by girgen for Gst-1. DO NOT EDIT. package gst import ( "fmt" "runtime" "strings" "unsafe" "github.com/diamondburned/gotk4/pkg/core/userdata" "github.com/diamondburned/gotk4/pkg/glib/v2" "github.com/diamondburned/gotk4/pkg/gobject/v2" ) // #cgo pkg-config: gstreamer-1.0 // #cgo CFLAGS: -Wno-deprecated-declarations // #include // extern GstBusSyncReply _gotk4_gst1_BusSyncHandler(GstBus*, GstMessage*, gpointer); // extern GstPadProbeReturn _gotk4_gst1_PadProbeCallback(GstPad*, GstPadProbeInfo*, gpointer); // extern gboolean _gotk4_gst1_BufferForEachMetaFunc(GstBuffer*, GstMeta*, gpointer); // extern gboolean _gotk4_gst1_BufferListFunc(GstBuffer*, guint, gpointer); // extern gboolean _gotk4_gst1_BusFunc(GstBus*, GstMessage*, gpointer); // extern gboolean _gotk4_gst1_CapsFilterMapFunc(GstCapsFeatures*, GstStructure*, gpointer); // extern gboolean _gotk4_gst1_CapsForEachFunc(GstCapsFeatures*, GstStructure*, gpointer); // extern gboolean _gotk4_gst1_CapsMapFunc(GstCapsFeatures*, GstStructure*, gpointer); // extern gboolean _gotk4_gst1_ClockCallback(GstClock*, GstClockTime, GstClockID, gpointer); // extern gboolean _gotk4_gst1_ElementForEachPadFunc(GstElement*, GstPad*, gpointer); // extern gboolean _gotk4_gst1_IteratorFoldFunction(GValue*, GValue*, gpointer); // extern gboolean _gotk4_gst1_PadForwardFunction(GstPad*, gpointer); // extern gboolean _gotk4_gst1_PluginFeatureFilter(GstPluginFeature*, gpointer); // extern gboolean _gotk4_gst1_PluginFilter(GstPlugin*, gpointer); // extern gboolean _gotk4_gst1_PluginInitFullFunc(GstPlugin*, gpointer); // extern gboolean _gotk4_gst1_StructureFilterMapFunc(GQuark, GValue*, gpointer); // extern gboolean _gotk4_gst1_StructureForEachFunc(GQuark, GValue*, gpointer); // extern gboolean _gotk4_gst1_StructureMapFunc(GQuark, GValue*, gpointer); // extern void _gotk4_gst1_ElementCallAsyncFunc(GstElement*, gpointer); // extern void _gotk4_gst1_IteratorForEachFunction(GValue*, gpointer); // extern void _gotk4_gst1_LogFunction(GstDebugCategory*, GstDebugLevel, gchar*, gchar*, gint, GObject*, GstDebugMessage*, gpointer); // extern void _gotk4_gst1_PromiseChangeFunc(GstPromise*, gpointer); // extern void _gotk4_gst1_TagForEachFunc(GstTagList*, gchar*, gpointer); // 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. var ( TypeBufferingMode = gobject.Type(C.gst_buffering_mode_get_type()) TypeBusSyncReply = gobject.Type(C.gst_bus_sync_reply_get_type()) TypeCapsIntersectMode = gobject.Type(C.gst_caps_intersect_mode_get_type()) TypeClockEntryType = gobject.Type(C.gst_clock_entry_type_get_type()) TypeClockReturn = gobject.Type(C.gst_clock_return_get_type()) TypeClockType = gobject.Type(C.gst_clock_type_get_type()) TypeCoreError = gobject.Type(C.gst_core_error_get_type()) TypeDebugColorMode = gobject.Type(C.gst_debug_color_mode_get_type()) TypeDebugLevel = gobject.Type(C.gst_debug_level_get_type()) TypeEventType = gobject.Type(C.gst_event_type_get_type()) TypeFlowReturn = gobject.Type(C.gst_flow_return_get_type()) TypeFormat = gobject.Type(C.gst_format_get_type()) TypeIteratorItem = gobject.Type(C.gst_iterator_item_get_type()) TypeIteratorResult = gobject.Type(C.gst_iterator_result_get_type()) TypeLibraryError = gobject.Type(C.gst_library_error_get_type()) TypePadDirection = gobject.Type(C.gst_pad_direction_get_type()) TypePadLinkReturn = gobject.Type(C.gst_pad_link_return_get_type()) TypePadMode = gobject.Type(C.gst_pad_mode_get_type()) TypePadPresence = gobject.Type(C.gst_pad_presence_get_type()) TypePadProbeReturn = gobject.Type(C.gst_pad_probe_return_get_type()) TypeParseError = gobject.Type(C.gst_parse_error_get_type()) TypePluginError = gobject.Type(C.gst_plugin_error_get_type()) TypeProgressType = gobject.Type(C.gst_progress_type_get_type()) TypePromiseResult = gobject.Type(C.gst_promise_result_get_type()) TypeQOSType = gobject.Type(C.gst_qos_type_get_type()) TypeQueryType = gobject.Type(C.gst_query_type_get_type()) TypeRank = gobject.Type(C.gst_rank_get_type()) TypeResourceError = gobject.Type(C.gst_resource_error_get_type()) TypeSearchMode = gobject.Type(C.gst_search_mode_get_type()) TypeSeekType = gobject.Type(C.gst_seek_type_get_type()) TypeState = gobject.Type(C.gst_state_get_type()) TypeStateChange = gobject.Type(C.gst_state_change_get_type()) TypeStateChangeReturn = gobject.Type(C.gst_state_change_return_get_type()) TypeStreamError = gobject.Type(C.gst_stream_error_get_type()) TypeStreamStatusType = gobject.Type(C.gst_stream_status_type_get_type()) TypeStructureChangeType = gobject.Type(C.gst_structure_change_type_get_type()) TypeTagFlag = gobject.Type(C.gst_tag_flag_get_type()) TypeTagMergeMode = gobject.Type(C.gst_tag_merge_mode_get_type()) TypeTagScope = gobject.Type(C.gst_tag_scope_get_type()) TypeTaskState = gobject.Type(C.gst_task_state_get_type()) TypeTocEntryType = gobject.Type(C.gst_toc_entry_type_get_type()) TypeTocLoopType = gobject.Type(C.gst_toc_loop_type_get_type()) TypeTocScope = gobject.Type(C.gst_toc_scope_get_type()) TypeTracerValueScope = gobject.Type(C.gst_tracer_value_scope_get_type()) TypeTypeFindProbability = gobject.Type(C.gst_type_find_probability_get_type()) TypeURIError = gobject.Type(C.gst_uri_error_get_type()) TypeURIType = gobject.Type(C.gst_uri_type_get_type()) TypeAllocatorFlags = gobject.Type(C.gst_allocator_flags_get_type()) TypeBinFlags = gobject.Type(C.gst_bin_flags_get_type()) TypeBufferCopyFlagsType = gobject.Type(C.gst_buffer_copy_flags_get_type()) TypeBufferFlags = gobject.Type(C.gst_buffer_flags_get_type()) TypeBufferPoolAcquireFlags = gobject.Type(C.gst_buffer_pool_acquire_flags_get_type()) TypeBusFlags = gobject.Type(C.gst_bus_flags_get_type()) TypeCapsFlags = gobject.Type(C.gst_caps_flags_get_type()) TypeClockFlags = gobject.Type(C.gst_clock_flags_get_type()) TypeDebugColorFlags = gobject.Type(C.gst_debug_color_flags_get_type()) TypeDebugGraphDetails = gobject.Type(C.gst_debug_graph_details_get_type()) TypeElementFlags = gobject.Type(C.gst_element_flags_get_type()) TypeEventTypeFlags = gobject.Type(C.gst_event_type_flags_get_type()) TypeGapFlags = gobject.Type(C.gst_gap_flags_get_type()) TypeLockFlags = gobject.Type(C.gst_lock_flags_get_type()) TypeMapFlags = gobject.Type(C.gst_map_flags_get_type()) TypeMemoryFlags = gobject.Type(C.gst_memory_flags_get_type()) TypeMessageType = gobject.Type(C.gst_message_type_get_type()) TypeMetaFlags = gobject.Type(C.gst_meta_flags_get_type()) TypeMiniObjectFlags = gobject.Type(C.gst_mini_object_flags_get_type()) TypeObjectFlags = gobject.Type(C.gst_object_flags_get_type()) TypePadFlags = gobject.Type(C.gst_pad_flags_get_type()) TypePadLinkCheck = gobject.Type(C.gst_pad_link_check_get_type()) TypePadProbeType = gobject.Type(C.gst_pad_probe_type_get_type()) TypePadTemplateFlags = gobject.Type(C.gst_pad_template_flags_get_type()) TypeParseFlags = gobject.Type(C.gst_parse_flags_get_type()) TypePipelineFlags = gobject.Type(C.gst_pipeline_flags_get_type()) TypePluginAPIFlags = gobject.Type(C.gst_plugin_api_flags_get_type()) TypePluginDependencyFlags = gobject.Type(C.gst_plugin_dependency_flags_get_type()) TypePluginFlags = gobject.Type(C.gst_plugin_flags_get_type()) TypeQueryTypeFlags = gobject.Type(C.gst_query_type_flags_get_type()) TypeSchedulingFlags = gobject.Type(C.gst_scheduling_flags_get_type()) TypeSeekFlags = gobject.Type(C.gst_seek_flags_get_type()) TypeSegmentFlags = gobject.Type(C.gst_segment_flags_get_type()) TypeSerializeFlags = gobject.Type(C.gst_serialize_flags_get_type()) TypeStackTraceFlags = gobject.Type(C.gst_stack_trace_flags_get_type()) TypeStreamFlags = gobject.Type(C.gst_stream_flags_get_type()) TypeStreamType = gobject.Type(C.gst_stream_type_get_type()) TypeTracerValueFlags = gobject.Type(C.gst_tracer_value_flags_get_type()) TypeChildProxy = gobject.Type(C.gst_child_proxy_get_type()) TypePreset = gobject.Type(C.gst_preset_get_type()) TypeURIHandler = gobject.Type(C.gst_uri_handler_get_type()) TypeTagSetter = gobject.Type(C.gst_tag_setter_get_type()) TypeTocSetter = gobject.Type(C.gst_toc_setter_get_type()) TypeObject = gobject.Type(C.gst_object_get_type()) TypePad = gobject.Type(C.gst_pad_get_type()) TypePadTemplate = gobject.Type(C.gst_pad_template_get_type()) TypePlugin = gobject.Type(C.gst_plugin_get_type()) TypePluginFeature = gobject.Type(C.gst_plugin_feature_get_type()) TypeProxyPad = gobject.Type(C.gst_proxy_pad_get_type()) TypeRegistry = gobject.Type(C.gst_registry_get_type()) TypeStream = gobject.Type(C.gst_stream_get_type()) TypeStreamCollection = gobject.Type(C.gst_stream_collection_get_type()) TypeTask = gobject.Type(C.gst_task_get_type()) TypeTaskPool = gobject.Type(C.gst_task_pool_get_type()) TypeTracer = gobject.Type(C.gst_tracer_get_type()) TypeTracerFactory = gobject.Type(C.gst_tracer_factory_get_type()) TypeTracerRecord = gobject.Type(C.gst_tracer_record_get_type()) TypeTypeFindFactory = gobject.Type(C.gst_type_find_factory_get_type()) TypeAllocator = gobject.Type(C.gst_allocator_get_type()) TypeBufferPool = gobject.Type(C.gst_buffer_pool_get_type()) TypeBus = gobject.Type(C.gst_bus_get_type()) TypeClock = gobject.Type(C.gst_clock_get_type()) TypeControlBinding = gobject.Type(C.gst_control_binding_get_type()) TypeControlSource = gobject.Type(C.gst_control_source_get_type()) TypeDevice = gobject.Type(C.gst_device_get_type()) TypeDeviceMonitor = gobject.Type(C.gst_device_monitor_get_type()) TypeDeviceProvider = gobject.Type(C.gst_device_provider_get_type()) TypeDeviceProviderFactory = gobject.Type(C.gst_device_provider_factory_get_type()) TypeDynamicTypeFactory = gobject.Type(C.gst_dynamic_type_factory_get_type()) TypeElement = gobject.Type(C.gst_element_get_type()) TypeElementFactory = gobject.Type(C.gst_element_factory_get_type()) TypeGhostPad = gobject.Type(C.gst_ghost_pad_get_type()) TypeSharedTaskPool = gobject.Type(C.gst_shared_task_pool_get_type()) TypeSystemClock = gobject.Type(C.gst_system_clock_get_type()) TypeBin = gobject.Type(C.gst_bin_get_type()) TypePipeline = gobject.Type(C.gst_pipeline_get_type()) TypeAllocationParams = gobject.Type(C.gst_allocation_params_get_type()) TypeAtomicQueue = gobject.Type(C.gst_atomic_queue_get_type()) TypeBuffer = gobject.Type(C.gst_buffer_get_type()) TypeBufferList = gobject.Type(C.gst_buffer_list_get_type()) TypeCaps = gobject.Type(C.gst_caps_get_type()) TypeCapsFeatures = gobject.Type(C.gst_caps_features_get_type()) TypeContext = gobject.Type(C.gst_context_get_type()) TypeDateTime = gobject.Type(C.gst_date_time_get_type()) TypeEvent = gobject.Type(C.gst_event_get_type()) TypeIterator = gobject.Type(C.gst_iterator_get_type()) TypeMemory = gobject.Type(C.gst_memory_get_type()) TypeMessage = gobject.Type(C.gst_message_get_type()) TypeMiniObject = gobject.Type(C.gst_mini_object_get_type()) TypeParseContext = gobject.Type(C.gst_parse_context_get_type()) TypePromise = gobject.Type(C.gst_promise_get_type()) TypeQuery = gobject.Type(C.gst_query_get_type()) TypeSample = gobject.Type(C.gst_sample_get_type()) TypeSegment = gobject.Type(C.gst_segment_get_type()) TypeStaticCaps = gobject.Type(C.gst_static_caps_get_type()) TypeStaticPadTemplate = gobject.Type(C.gst_static_pad_template_get_type()) TypeStructure = gobject.Type(C.gst_structure_get_type()) TypeTagList = gobject.Type(C.gst_tag_list_get_type()) TypeToc = gobject.Type(C.gst_toc_get_type()) TypeTocEntry = gobject.Type(C.gst_toc_entry_get_type()) TypeTypeFind = gobject.Type(C.gst_type_find_get_type()) TypeUri = gobject.Type(C.gst_uri_get_type()) ) func init() { gobject.RegisterGValueMarshalers([]gobject.TypeMarshaler{ gobject.TypeMarshaler{T: TypeBufferingMode, F: marshalBufferingMode}, gobject.TypeMarshaler{T: TypeBusSyncReply, F: marshalBusSyncReply}, gobject.TypeMarshaler{T: TypeCapsIntersectMode, F: marshalCapsIntersectMode}, gobject.TypeMarshaler{T: TypeClockEntryType, F: marshalClockEntryType}, gobject.TypeMarshaler{T: TypeClockReturn, F: marshalClockReturn}, gobject.TypeMarshaler{T: TypeClockType, F: marshalClockType}, gobject.TypeMarshaler{T: TypeCoreError, F: marshalCoreError}, gobject.TypeMarshaler{T: TypeDebugColorMode, F: marshalDebugColorMode}, gobject.TypeMarshaler{T: TypeDebugLevel, F: marshalDebugLevel}, gobject.TypeMarshaler{T: TypeEventType, F: marshalEventType}, gobject.TypeMarshaler{T: TypeFlowReturn, F: marshalFlowReturn}, gobject.TypeMarshaler{T: TypeFormat, F: marshalFormat}, gobject.TypeMarshaler{T: TypeIteratorItem, F: marshalIteratorItem}, gobject.TypeMarshaler{T: TypeIteratorResult, F: marshalIteratorResult}, gobject.TypeMarshaler{T: TypeLibraryError, F: marshalLibraryError}, gobject.TypeMarshaler{T: TypePadDirection, F: marshalPadDirection}, gobject.TypeMarshaler{T: TypePadLinkReturn, F: marshalPadLinkReturn}, gobject.TypeMarshaler{T: TypePadMode, F: marshalPadMode}, gobject.TypeMarshaler{T: TypePadPresence, F: marshalPadPresence}, gobject.TypeMarshaler{T: TypePadProbeReturn, F: marshalPadProbeReturn}, gobject.TypeMarshaler{T: TypeParseError, F: marshalParseError}, gobject.TypeMarshaler{T: TypePluginError, F: marshalPluginError}, gobject.TypeMarshaler{T: TypeProgressType, F: marshalProgressType}, gobject.TypeMarshaler{T: TypePromiseResult, F: marshalPromiseResult}, gobject.TypeMarshaler{T: TypeQOSType, F: marshalQOSType}, gobject.TypeMarshaler{T: TypeQueryType, F: marshalQueryType}, gobject.TypeMarshaler{T: TypeRank, F: marshalRank}, gobject.TypeMarshaler{T: TypeResourceError, F: marshalResourceError}, gobject.TypeMarshaler{T: TypeSearchMode, F: marshalSearchMode}, gobject.TypeMarshaler{T: TypeSeekType, F: marshalSeekType}, gobject.TypeMarshaler{T: TypeState, F: marshalState}, gobject.TypeMarshaler{T: TypeStateChange, F: marshalStateChange}, gobject.TypeMarshaler{T: TypeStateChangeReturn, F: marshalStateChangeReturn}, gobject.TypeMarshaler{T: TypeStreamError, F: marshalStreamError}, gobject.TypeMarshaler{T: TypeStreamStatusType, F: marshalStreamStatusType}, gobject.TypeMarshaler{T: TypeStructureChangeType, F: marshalStructureChangeType}, gobject.TypeMarshaler{T: TypeTagFlag, F: marshalTagFlag}, gobject.TypeMarshaler{T: TypeTagMergeMode, F: marshalTagMergeMode}, gobject.TypeMarshaler{T: TypeTagScope, F: marshalTagScope}, gobject.TypeMarshaler{T: TypeTaskState, F: marshalTaskState}, gobject.TypeMarshaler{T: TypeTocEntryType, F: marshalTocEntryType}, gobject.TypeMarshaler{T: TypeTocLoopType, F: marshalTocLoopType}, gobject.TypeMarshaler{T: TypeTocScope, F: marshalTocScope}, gobject.TypeMarshaler{T: TypeTracerValueScope, F: marshalTracerValueScope}, gobject.TypeMarshaler{T: TypeTypeFindProbability, F: marshalTypeFindProbability}, gobject.TypeMarshaler{T: TypeURIError, F: marshalURIError}, gobject.TypeMarshaler{T: TypeURIType, F: marshalURIType}, gobject.TypeMarshaler{T: TypeAllocatorFlags, F: marshalAllocatorFlags}, gobject.TypeMarshaler{T: TypeBinFlags, F: marshalBinFlags}, gobject.TypeMarshaler{T: TypeBufferCopyFlagsType, F: marshalBufferCopyFlagsType}, gobject.TypeMarshaler{T: TypeBufferFlags, F: marshalBufferFlags}, gobject.TypeMarshaler{T: TypeBufferPoolAcquireFlags, F: marshalBufferPoolAcquireFlags}, gobject.TypeMarshaler{T: TypeBusFlags, F: marshalBusFlags}, gobject.TypeMarshaler{T: TypeCapsFlags, F: marshalCapsFlags}, gobject.TypeMarshaler{T: TypeClockFlags, F: marshalClockFlags}, gobject.TypeMarshaler{T: TypeDebugColorFlags, F: marshalDebugColorFlags}, gobject.TypeMarshaler{T: TypeDebugGraphDetails, F: marshalDebugGraphDetails}, gobject.TypeMarshaler{T: TypeElementFlags, F: marshalElementFlags}, gobject.TypeMarshaler{T: TypeEventTypeFlags, F: marshalEventTypeFlags}, gobject.TypeMarshaler{T: TypeGapFlags, F: marshalGapFlags}, gobject.TypeMarshaler{T: TypeLockFlags, F: marshalLockFlags}, gobject.TypeMarshaler{T: TypeMapFlags, F: marshalMapFlags}, gobject.TypeMarshaler{T: TypeMemoryFlags, F: marshalMemoryFlags}, gobject.TypeMarshaler{T: TypeMessageType, F: marshalMessageType}, gobject.TypeMarshaler{T: TypeMetaFlags, F: marshalMetaFlags}, gobject.TypeMarshaler{T: TypeMiniObjectFlags, F: marshalMiniObjectFlags}, gobject.TypeMarshaler{T: TypeObjectFlags, F: marshalObjectFlags}, gobject.TypeMarshaler{T: TypePadFlags, F: marshalPadFlags}, gobject.TypeMarshaler{T: TypePadLinkCheck, F: marshalPadLinkCheck}, gobject.TypeMarshaler{T: TypePadProbeType, F: marshalPadProbeType}, gobject.TypeMarshaler{T: TypePadTemplateFlags, F: marshalPadTemplateFlags}, gobject.TypeMarshaler{T: TypeParseFlags, F: marshalParseFlags}, gobject.TypeMarshaler{T: TypePipelineFlags, F: marshalPipelineFlags}, gobject.TypeMarshaler{T: TypePluginAPIFlags, F: marshalPluginAPIFlags}, gobject.TypeMarshaler{T: TypePluginDependencyFlags, F: marshalPluginDependencyFlags}, gobject.TypeMarshaler{T: TypePluginFlags, F: marshalPluginFlags}, gobject.TypeMarshaler{T: TypeQueryTypeFlags, F: marshalQueryTypeFlags}, gobject.TypeMarshaler{T: TypeSchedulingFlags, F: marshalSchedulingFlags}, gobject.TypeMarshaler{T: TypeSeekFlags, F: marshalSeekFlags}, gobject.TypeMarshaler{T: TypeSegmentFlags, F: marshalSegmentFlags}, gobject.TypeMarshaler{T: TypeSerializeFlags, F: marshalSerializeFlags}, gobject.TypeMarshaler{T: TypeStackTraceFlags, F: marshalStackTraceFlags}, gobject.TypeMarshaler{T: TypeStreamFlags, F: marshalStreamFlags}, gobject.TypeMarshaler{T: TypeStreamType, F: marshalStreamType}, gobject.TypeMarshaler{T: TypeTracerValueFlags, F: marshalTracerValueFlags}, gobject.TypeMarshaler{T: TypeChildProxy, F: marshalChildProxyInstance}, gobject.TypeMarshaler{T: TypePreset, F: marshalPresetInstance}, gobject.TypeMarshaler{T: TypeURIHandler, F: marshalURIHandlerInstance}, gobject.TypeMarshaler{T: TypeTagSetter, F: marshalTagSetterInstance}, gobject.TypeMarshaler{T: TypeTocSetter, F: marshalTocSetterInstance}, gobject.TypeMarshaler{T: TypeObject, F: marshalObjectInstance}, gobject.TypeMarshaler{T: TypePad, F: marshalPadInstance}, gobject.TypeMarshaler{T: TypePadTemplate, F: marshalPadTemplateInstance}, gobject.TypeMarshaler{T: TypePlugin, F: marshalPluginInstance}, gobject.TypeMarshaler{T: TypePluginFeature, F: marshalPluginFeatureInstance}, gobject.TypeMarshaler{T: TypeProxyPad, F: marshalProxyPadInstance}, gobject.TypeMarshaler{T: TypeRegistry, F: marshalRegistryInstance}, gobject.TypeMarshaler{T: TypeStream, F: marshalStreamInstance}, gobject.TypeMarshaler{T: TypeStreamCollection, F: marshalStreamCollectionInstance}, gobject.TypeMarshaler{T: TypeTask, F: marshalTaskInstance}, gobject.TypeMarshaler{T: TypeTaskPool, F: marshalTaskPoolInstance}, gobject.TypeMarshaler{T: TypeTracer, F: marshalTracerInstance}, gobject.TypeMarshaler{T: TypeTracerFactory, F: marshalTracerFactoryInstance}, gobject.TypeMarshaler{T: TypeTracerRecord, F: marshalTracerRecordInstance}, gobject.TypeMarshaler{T: TypeTypeFindFactory, F: marshalTypeFindFactoryInstance}, gobject.TypeMarshaler{T: TypeAllocator, F: marshalAllocatorInstance}, gobject.TypeMarshaler{T: TypeBufferPool, F: marshalBufferPoolInstance}, gobject.TypeMarshaler{T: TypeBus, F: marshalBusInstance}, gobject.TypeMarshaler{T: TypeClock, F: marshalClockInstance}, gobject.TypeMarshaler{T: TypeControlBinding, F: marshalControlBindingInstance}, gobject.TypeMarshaler{T: TypeControlSource, F: marshalControlSourceInstance}, gobject.TypeMarshaler{T: TypeDevice, F: marshalDeviceInstance}, gobject.TypeMarshaler{T: TypeDeviceMonitor, F: marshalDeviceMonitorInstance}, gobject.TypeMarshaler{T: TypeDeviceProvider, F: marshalDeviceProviderInstance}, gobject.TypeMarshaler{T: TypeDeviceProviderFactory, F: marshalDeviceProviderFactoryInstance}, gobject.TypeMarshaler{T: TypeDynamicTypeFactory, F: marshalDynamicTypeFactoryInstance}, gobject.TypeMarshaler{T: TypeElement, F: marshalElementInstance}, gobject.TypeMarshaler{T: TypeElementFactory, F: marshalElementFactoryInstance}, gobject.TypeMarshaler{T: TypeGhostPad, F: marshalGhostPadInstance}, gobject.TypeMarshaler{T: TypeSharedTaskPool, F: marshalSharedTaskPoolInstance}, gobject.TypeMarshaler{T: TypeSystemClock, F: marshalSystemClockInstance}, gobject.TypeMarshaler{T: TypeBin, F: marshalBinInstance}, gobject.TypeMarshaler{T: TypePipeline, F: marshalPipelineInstance}, gobject.TypeMarshaler{T: TypeAllocationParams, F: marshalAllocationParams}, gobject.TypeMarshaler{T: TypeAtomicQueue, F: marshalAtomicQueue}, gobject.TypeMarshaler{T: TypeBuffer, F: marshalBuffer}, gobject.TypeMarshaler{T: TypeBufferList, F: marshalBufferList}, gobject.TypeMarshaler{T: TypeCaps, F: marshalCaps}, gobject.TypeMarshaler{T: TypeCapsFeatures, F: marshalCapsFeatures}, gobject.TypeMarshaler{T: TypeContext, F: marshalContext}, gobject.TypeMarshaler{T: TypeDateTime, F: marshalDateTime}, gobject.TypeMarshaler{T: TypeEvent, F: marshalEvent}, gobject.TypeMarshaler{T: TypeIterator, F: marshalIterator}, gobject.TypeMarshaler{T: TypeMemory, F: marshalMemory}, gobject.TypeMarshaler{T: TypeMessage, F: marshalMessage}, gobject.TypeMarshaler{T: TypeMiniObject, F: marshalMiniObject}, gobject.TypeMarshaler{T: TypeParseContext, F: marshalParseContext}, gobject.TypeMarshaler{T: TypePromise, F: marshalPromise}, gobject.TypeMarshaler{T: TypeQuery, F: marshalQuery}, gobject.TypeMarshaler{T: TypeSample, F: marshalSample}, gobject.TypeMarshaler{T: TypeSegment, F: marshalSegment}, gobject.TypeMarshaler{T: TypeStaticCaps, F: marshalStaticCaps}, gobject.TypeMarshaler{T: TypeStaticPadTemplate, F: marshalStaticPadTemplate}, gobject.TypeMarshaler{T: TypeStructure, F: marshalStructure}, gobject.TypeMarshaler{T: TypeTagList, F: marshalTagList}, gobject.TypeMarshaler{T: TypeToc, F: marshalToc}, gobject.TypeMarshaler{T: TypeTocEntry, F: marshalTocEntry}, gobject.TypeMarshaler{T: TypeTypeFind, F: marshalTypeFind}, gobject.TypeMarshaler{T: TypeUri, F: marshalUri}, }) } // BUFFER_OFFSET_NONE wraps GST_BUFFER_OFFSET_NONE // // Constant for no-offset return results. const BUFFER_OFFSET_NONE = 18446744073709551615 // CAN_INLINE wraps GST_CAN_INLINE const CAN_INLINE = 1 // DEBUG_BG_MASK wraps GST_DEBUG_BG_MASK const DEBUG_BG_MASK = 240 // DEBUG_FG_MASK wraps GST_DEBUG_FG_MASK const DEBUG_FG_MASK = 15 // DEBUG_FORMAT_MASK wraps GST_DEBUG_FORMAT_MASK const DEBUG_FORMAT_MASK = 65280 // EVENT_NUM_SHIFT wraps GST_EVENT_NUM_SHIFT const EVENT_NUM_SHIFT = 8 // FLAG_SET_MASK_EXACT wraps GST_FLAG_SET_MASK_EXACT // // A mask value with all bits set, for use as a // GstFlagSet mask where all flag bits must match // exactly const FLAG_SET_MASK_EXACT = 4294967295 // FORMAT_PERCENT_MAX wraps GST_FORMAT_PERCENT_MAX // // The PERCENT format is between 0 and this value const FORMAT_PERCENT_MAX = 1000000 // FORMAT_PERCENT_SCALE wraps GST_FORMAT_PERCENT_SCALE // // The value used to scale down the reported PERCENT format value to // its real value. const FORMAT_PERCENT_SCALE = 10000 // GROUP_ID_INVALID wraps GST_GROUP_ID_INVALID // // A value which is guaranteed to never be returned by // gst_util_group_id_next(). // // Can be used as a default value in variables used to store group_id. const GROUP_ID_INVALID = 0 // PARAM_CONDITIONALLY_AVAILABLE wraps GST_PARAM_CONDITIONALLY_AVAILABLE // // Use this flag on GObject properties of GstObject to indicate that // they might not be available depending on environment such as OS, device, etc, // so such properties will be installed conditionally only if the GstObject is // able to support it. const PARAM_CONDITIONALLY_AVAILABLE = 16384 // PARAM_CONTROLLABLE wraps GST_PARAM_CONTROLLABLE // // Use this flag on GObject properties to signal they can make sense to be. // controlled over time. This hint is used by the GstController. const PARAM_CONTROLLABLE = 512 // PARAM_DOC_SHOW_DEFAULT wraps GST_PARAM_DOC_SHOW_DEFAULT // // Use this flag on GObject properties of GstObject to indicate that // during `gst-inspect` and friends, the default value should be used // as default instead of the current value. const PARAM_DOC_SHOW_DEFAULT = 8192 // PARAM_MUTABLE_PAUSED wraps GST_PARAM_MUTABLE_PAUSED // // Use this flag on GObject properties of GstElements to indicate that // they can be changed when the element is in the PAUSED or lower state. // This flag implies GST_PARAM_MUTABLE_READY. const PARAM_MUTABLE_PAUSED = 2048 // PARAM_MUTABLE_PLAYING wraps GST_PARAM_MUTABLE_PLAYING // // Use this flag on GObject properties of GstElements to indicate that // they can be changed when the element is in the PLAYING or lower state. // This flag implies GST_PARAM_MUTABLE_PAUSED. const PARAM_MUTABLE_PLAYING = 4096 // PARAM_MUTABLE_READY wraps GST_PARAM_MUTABLE_READY // // Use this flag on GObject properties of GstElements to indicate that // they can be changed when the element is in the READY or lower state. const PARAM_MUTABLE_READY = 1024 // PARAM_USER_SHIFT wraps GST_PARAM_USER_SHIFT // // Bits based on GST_PARAM_USER_SHIFT can be used by 3rd party applications. const PARAM_USER_SHIFT = 65536 // QUERY_NUM_SHIFT wraps GST_QUERY_NUM_SHIFT const QUERY_NUM_SHIFT = 8 // SEGMENT_INSTANT_FLAGS wraps GST_SEGMENT_INSTANT_FLAGS const SEGMENT_INSTANT_FLAGS = 912 // SEQNUM_INVALID wraps GST_SEQNUM_INVALID // // A value which is guaranteed to never be returned by // gst_util_seqnum_next(). // // Can be used as a default value in variables used to store seqnum. const SEQNUM_INVALID = 0 // TOC_REPEAT_COUNT_INFINITE wraps GST_TOC_REPEAT_COUNT_INFINITE // // Special value for the repeat_count set in gst_toc_entry_set_loop() or // returned by gst_toc_entry_set_loop() to indicate infinite looping. const TOC_REPEAT_COUNT_INFINITE = -1 // URI_NO_PORT wraps GST_URI_NO_PORT // // Value for #GstUri<!-- -->.port to indicate no port number. const URI_NO_PORT = 0 // VALUE_EQUAL wraps GST_VALUE_EQUAL // // Indicates that the first value provided to a comparison function // (gst_value_compare()) is equal to the second one. const VALUE_EQUAL = 0 // VALUE_GREATER_THAN wraps GST_VALUE_GREATER_THAN // // Indicates that the first value provided to a comparison function // (gst_value_compare()) is greater than the second one. const VALUE_GREATER_THAN = 1 // VALUE_LESS_THAN wraps GST_VALUE_LESS_THAN // // Indicates that the first value provided to a comparison function // (gst_value_compare()) is lesser than the second one. const VALUE_LESS_THAN = -1 // VALUE_UNORDERED wraps GST_VALUE_UNORDERED // // Indicates that the comparison function (gst_value_compare()) can not // determine a order for the two provided values. const VALUE_UNORDERED = 2 // VERSION_MAJOR wraps GST_VERSION_MAJOR // // The major version of GStreamer at compile time: const VERSION_MAJOR = 1 // VERSION_MICRO wraps GST_VERSION_MICRO // // The micro version of GStreamer at compile time: const VERSION_MICRO = 10 // VERSION_MINOR wraps GST_VERSION_MINOR // // The minor version of GStreamer at compile time: const VERSION_MINOR = 24 // VERSION_NANO wraps GST_VERSION_NANO // // The nano version of GStreamer at compile time: // Actual releases have 0, GIT versions have 1, prerelease versions have 2-... const VERSION_NANO = 0 // ClockID wraps GstClockID // // A datatype to hold the handle to an outstanding sync or async clock callback. type ClockID = unsafe.Pointer // ClockTimeDiff wraps GstClockTimeDiff // // A datatype to hold a time difference, measured in nanoseconds. type ClockTimeDiff = int64 // ElementFactoryListType wraps GstElementFactoryListType // // A type defining the type of an element factory. type ElementFactoryListType = uint64 // BufferingMode wraps GstBufferingMode // // The different types of buffering methods. type BufferingMode C.int const ( // BufferingStream wraps GST_BUFFERING_STREAM // // a small amount of data is buffered BufferingStream BufferingMode = 0 // BufferingDownload wraps GST_BUFFERING_DOWNLOAD // // the stream is being downloaded BufferingDownload BufferingMode = 1 // BufferingTimeshift wraps GST_BUFFERING_TIMESHIFT // // the stream is being downloaded in a ringbuffer BufferingTimeshift BufferingMode = 2 // BufferingLive wraps GST_BUFFERING_LIVE // // the stream is a live stream BufferingLive BufferingMode = 3 ) func marshalBufferingMode(p unsafe.Pointer) (any, error) { return BufferingMode(gobject.ValueFromNative(p).Enum()), nil } var _ gobject.GoValueInitializer = BufferingMode(0) func (e BufferingMode) InitGoValue(v *gobject.Value) { v.Init(TypeBufferingMode) v.SetEnum(int(e)) } func (e BufferingMode) String() string { switch e { case BufferingDownload: return "BufferingDownload" case BufferingLive: return "BufferingLive" case BufferingStream: return "BufferingStream" case BufferingTimeshift: return "BufferingTimeshift" default: return fmt.Sprintf("BufferingMode(%d)", e) } } // BusSyncReply wraps GstBusSyncReply // // The result values for a GstBusSyncHandler. type BusSyncReply C.int const ( // BusDrop wraps GST_BUS_DROP // // drop the message BusDrop BusSyncReply = 0 // BusPass wraps GST_BUS_PASS // // pass the message to the async queue BusPass BusSyncReply = 1 // BusAsync wraps GST_BUS_ASYNC // // pass message to async queue, continue if message is handled BusAsync BusSyncReply = 2 ) func marshalBusSyncReply(p unsafe.Pointer) (any, error) { return BusSyncReply(gobject.ValueFromNative(p).Enum()), nil } var _ gobject.GoValueInitializer = BusSyncReply(0) func (e BusSyncReply) InitGoValue(v *gobject.Value) { v.Init(TypeBusSyncReply) v.SetEnum(int(e)) } func (e BusSyncReply) String() string { switch e { case BusAsync: return "BusAsync" case BusDrop: return "BusDrop" case BusPass: return "BusPass" default: return fmt.Sprintf("BusSyncReply(%d)", e) } } // CapsIntersectMode wraps GstCapsIntersectMode // // Modes of caps intersection // // %GST_CAPS_INTERSECT_ZIG_ZAG tries to preserve overall order of both caps // by iterating on the caps' structures as the following matrix shows: // // ``` // caps1 // +------------- // | 1 2 4 7 // caps2 | 3 5 8 10 // | 6 9 11 12 // ``` // // Used when there is no explicit precedence of one caps over the other. e.g. // tee's sink pad getcaps function, it will probe its src pad peers' for their // caps and intersect them with this mode. // // %GST_CAPS_INTERSECT_FIRST is useful when an element wants to preserve // another element's caps priority order when intersecting with its own caps. // Example: If caps1 is `[A, B, C]` and caps2 is `[E, B, D, A]`, the result // would be `[A, B]`, maintaining the first caps priority on the intersection. type CapsIntersectMode C.int const ( // CapsIntersectZigZag wraps GST_CAPS_INTERSECT_ZIG_ZAG // // Zig-zags over both caps. CapsIntersectZigZag CapsIntersectMode = 0 // CapsIntersectFirst wraps GST_CAPS_INTERSECT_FIRST // // Keeps the first caps order. CapsIntersectFirst CapsIntersectMode = 1 ) func marshalCapsIntersectMode(p unsafe.Pointer) (any, error) { return CapsIntersectMode(gobject.ValueFromNative(p).Enum()), nil } var _ gobject.GoValueInitializer = CapsIntersectMode(0) func (e CapsIntersectMode) InitGoValue(v *gobject.Value) { v.Init(TypeCapsIntersectMode) v.SetEnum(int(e)) } func (e CapsIntersectMode) String() string { switch e { case CapsIntersectFirst: return "CapsIntersectFirst" case CapsIntersectZigZag: return "CapsIntersectZigZag" default: return fmt.Sprintf("CapsIntersectMode(%d)", e) } } // ClockEntryType wraps GstClockEntryType // // The type of the clock entry type ClockEntryType C.int const ( // ClockEntrySingle wraps GST_CLOCK_ENTRY_SINGLE // // a single shot timeout ClockEntrySingle ClockEntryType = 0 // ClockEntryPeriodic wraps GST_CLOCK_ENTRY_PERIODIC // // a periodic timeout request ClockEntryPeriodic ClockEntryType = 1 ) func marshalClockEntryType(p unsafe.Pointer) (any, error) { return ClockEntryType(gobject.ValueFromNative(p).Enum()), nil } var _ gobject.GoValueInitializer = ClockEntryType(0) func (e ClockEntryType) InitGoValue(v *gobject.Value) { v.Init(TypeClockEntryType) v.SetEnum(int(e)) } func (e ClockEntryType) String() string { switch e { case ClockEntryPeriodic: return "ClockEntryPeriodic" case ClockEntrySingle: return "ClockEntrySingle" default: return fmt.Sprintf("ClockEntryType(%d)", e) } } // ClockReturn wraps GstClockReturn // // The return value of a clock operation. type ClockReturn C.int const ( // ClockOK wraps GST_CLOCK_OK // // The operation succeeded. ClockOK ClockReturn = 0 // ClockEarly wraps GST_CLOCK_EARLY // // The operation was scheduled too late. ClockEarly ClockReturn = 1 // ClockUnscheduled wraps GST_CLOCK_UNSCHEDULED // // The clockID was unscheduled ClockUnscheduled ClockReturn = 2 // ClockBusy wraps GST_CLOCK_BUSY // // The ClockID is busy ClockBusy ClockReturn = 3 // ClockBadtime wraps GST_CLOCK_BADTIME // // A bad time was provided to a function. ClockBadtime ClockReturn = 4 // ClockError wraps GST_CLOCK_ERROR // // An error occurred ClockError ClockReturn = 5 // ClockUnsupported wraps GST_CLOCK_UNSUPPORTED // // Operation is not supported ClockUnsupported ClockReturn = 6 // ClockDone wraps GST_CLOCK_DONE // // The ClockID is done waiting ClockDone ClockReturn = 7 ) func marshalClockReturn(p unsafe.Pointer) (any, error) { return ClockReturn(gobject.ValueFromNative(p).Enum()), nil } var _ gobject.GoValueInitializer = ClockReturn(0) func (e ClockReturn) InitGoValue(v *gobject.Value) { v.Init(TypeClockReturn) v.SetEnum(int(e)) } func (e ClockReturn) String() string { switch e { case ClockBadtime: return "ClockBadtime" case ClockBusy: return "ClockBusy" case ClockDone: return "ClockDone" case ClockEarly: return "ClockEarly" case ClockError: return "ClockError" case ClockOK: return "ClockOK" case ClockUnscheduled: return "ClockUnscheduled" case ClockUnsupported: return "ClockUnsupported" default: return fmt.Sprintf("ClockReturn(%d)", e) } } // ClockType wraps GstClockType // // The different kind of clocks. type ClockType C.int const ( // ClockTypeRealtime wraps GST_CLOCK_TYPE_REALTIME // // time since Epoch ClockTypeRealtime ClockType = 0 // ClockTypeMonotonic wraps GST_CLOCK_TYPE_MONOTONIC // // monotonic time since some unspecified starting // point ClockTypeMonotonic ClockType = 1 // ClockTypeOther wraps GST_CLOCK_TYPE_OTHER // // some other time source is used (Since: 1.0.5) ClockTypeOther ClockType = 2 // ClockTypeTai wraps GST_CLOCK_TYPE_TAI // // time since Epoch, but using International Atomic Time // as reference (Since: 1.18) ClockTypeTai ClockType = 3 ) func marshalClockType(p unsafe.Pointer) (any, error) { return ClockType(gobject.ValueFromNative(p).Enum()), nil } var _ gobject.GoValueInitializer = ClockType(0) func (e ClockType) InitGoValue(v *gobject.Value) { v.Init(TypeClockType) v.SetEnum(int(e)) } func (e ClockType) String() string { switch e { case ClockTypeMonotonic: return "ClockTypeMonotonic" case ClockTypeOther: return "ClockTypeOther" case ClockTypeRealtime: return "ClockTypeRealtime" case ClockTypeTai: return "ClockTypeTai" default: return fmt.Sprintf("ClockType(%d)", e) } } // CoreError wraps GstCoreError // // Core errors are errors inside the core GStreamer library. type CoreError C.int const ( // CoreErrorFailed wraps GST_CORE_ERROR_FAILED // // a general error which doesn't fit in any other // category. Make sure you add a custom message to the error call. CoreErrorFailed CoreError = 1 // CoreErrorTooLaZY wraps GST_CORE_ERROR_TOO_LAZY // // do not use this except as a placeholder for // deciding where to go while developing code. CoreErrorTooLaZY CoreError = 2 // CoreErrorNotImplemented wraps GST_CORE_ERROR_NOT_IMPLEMENTED // // use this when you do not want to implement // this functionality yet. CoreErrorNotImplemented CoreError = 3 // CoreErrorStateChange wraps GST_CORE_ERROR_STATE_CHANGE // // used for state change errors. CoreErrorStateChange CoreError = 4 // CoreErrorPad wraps GST_CORE_ERROR_PAD // // used for pad-related errors. CoreErrorPad CoreError = 5 // CoreErrorThread wraps GST_CORE_ERROR_THREAD // // used for thread-related errors. CoreErrorThread CoreError = 6 // CoreErrorNegotiation wraps GST_CORE_ERROR_NEGOTIATION // // used for negotiation-related errors. CoreErrorNegotiation CoreError = 7 // CoreErrorEvent wraps GST_CORE_ERROR_EVENT // // used for event-related errors. CoreErrorEvent CoreError = 8 // CoreErrorSeek wraps GST_CORE_ERROR_SEEK // // used for seek-related errors. CoreErrorSeek CoreError = 9 // CoreErrorCaps wraps GST_CORE_ERROR_CAPS // // used for caps-related errors. CoreErrorCaps CoreError = 10 // CoreErrorTag wraps GST_CORE_ERROR_TAG // // used for negotiation-related errors. CoreErrorTag CoreError = 11 // CoreErrorMissingPlugin wraps GST_CORE_ERROR_MISSING_PLUGIN // // used if a plugin is missing. CoreErrorMissingPlugin CoreError = 12 // CoreErrorClock wraps GST_CORE_ERROR_CLOCK // // used for clock related errors. CoreErrorClock CoreError = 13 // CoreErrorDisabled wraps GST_CORE_ERROR_DISABLED // // used if functionality has been disabled at // compile time. CoreErrorDisabled CoreError = 14 // CoreErrorNumErrors wraps GST_CORE_ERROR_NUM_ERRORS // // the number of core error types. CoreErrorNumErrors CoreError = 15 ) func marshalCoreError(p unsafe.Pointer) (any, error) { return CoreError(gobject.ValueFromNative(p).Enum()), nil } var _ gobject.GoValueInitializer = CoreError(0) func (e CoreError) InitGoValue(v *gobject.Value) { v.Init(TypeCoreError) v.SetEnum(int(e)) } func (e CoreError) String() string { switch e { case CoreErrorCaps: return "CoreErrorCaps" case CoreErrorClock: return "CoreErrorClock" case CoreErrorDisabled: return "CoreErrorDisabled" case CoreErrorEvent: return "CoreErrorEvent" case CoreErrorFailed: return "CoreErrorFailed" case CoreErrorMissingPlugin: return "CoreErrorMissingPlugin" case CoreErrorNegotiation: return "CoreErrorNegotiation" case CoreErrorNotImplemented: return "CoreErrorNotImplemented" case CoreErrorNumErrors: return "CoreErrorNumErrors" case CoreErrorPad: return "CoreErrorPad" case CoreErrorSeek: return "CoreErrorSeek" case CoreErrorStateChange: return "CoreErrorStateChange" case CoreErrorTag: return "CoreErrorTag" case CoreErrorThread: return "CoreErrorThread" case CoreErrorTooLaZY: return "CoreErrorTooLaZY" default: return fmt.Sprintf("CoreError(%d)", e) } } // CoreErrorQuark wraps gst_core_error_quark // // The function returns the following values: // // - goret glib.Quark func CoreErrorQuark() glib.Quark { var cret C.GQuark // return, none, casted, alias cret = C.gst_core_error_quark() var goret glib.Quark goret = glib.Quark(cret) return goret } // DebugColorMode wraps GstDebugColorMode type DebugColorMode C.int const ( // DebugColorModeOff wraps GST_DEBUG_COLOR_MODE_OFF // // Do not use colors in logs. DebugColorModeOff DebugColorMode = 0 // DebugColorModeOn wraps GST_DEBUG_COLOR_MODE_ON // // Paint logs in a platform-specific way. DebugColorModeOn DebugColorMode = 1 // DebugColorModeUnix wraps GST_DEBUG_COLOR_MODE_UNIX // // Paint logs with UNIX terminal color codes // no matter what platform GStreamer is running on. DebugColorModeUnix DebugColorMode = 2 ) func marshalDebugColorMode(p unsafe.Pointer) (any, error) { return DebugColorMode(gobject.ValueFromNative(p).Enum()), nil } var _ gobject.GoValueInitializer = DebugColorMode(0) func (e DebugColorMode) InitGoValue(v *gobject.Value) { v.Init(TypeDebugColorMode) v.SetEnum(int(e)) } func (e DebugColorMode) String() string { switch e { case DebugColorModeOff: return "DebugColorModeOff" case DebugColorModeOn: return "DebugColorModeOn" case DebugColorModeUnix: return "DebugColorModeUnix" default: return fmt.Sprintf("DebugColorMode(%d)", e) } } // DebugLevel wraps GstDebugLevel // // The level defines the importance of a debugging message. The more important a // message is, the greater the probability that the debugging system outputs it. type DebugLevel C.int const ( // LevelNone wraps GST_LEVEL_NONE // // No debugging level specified or desired. Used to deactivate // debugging output. LevelNone DebugLevel = 0 // LevelError wraps GST_LEVEL_ERROR // // Error messages are to be used only when an error occurred // that stops the application from keeping working correctly. // An examples is gst_element_error, which outputs a message with this priority. // It does not mean that the application is terminating as with g_error. LevelError DebugLevel = 1 // LevelWarning wraps GST_LEVEL_WARNING // // Warning messages are to inform about abnormal behaviour // that could lead to problems or weird behaviour later on. An example of this // would be clocking issues ("your computer is pretty slow") or broken input // data ("Can't synchronize to stream.") LevelWarning DebugLevel = 2 // LevelFixme wraps GST_LEVEL_FIXME // // Fixme messages are messages that indicate that something // in the executed code path is not fully implemented or handled yet. Note // that this does not replace proper error handling in any way, the purpose // of this message is to make it easier to spot incomplete/unfinished pieces // of code when reading the debug log. LevelFixme DebugLevel = 3 // LevelInfo wraps GST_LEVEL_INFO // // Informational messages should be used to keep the developer // updated about what is happening. // Examples where this should be used are when a typefind function has // successfully determined the type of the stream or when an mp3 plugin detects // the format to be used. ("This file has mono sound.") LevelInfo DebugLevel = 4 // LevelDebug wraps GST_LEVEL_DEBUG // // Debugging messages should be used when something common // happens that is not the expected default behavior, or something that's // useful to know but doesn't happen all the time (ie. per loop iteration or // buffer processed or event handled). // An example would be notifications about state changes or receiving/sending // of events. LevelDebug DebugLevel = 5 // LevelLog wraps GST_LEVEL_LOG // // Log messages are messages that are very common but might be // useful to know. As a rule of thumb a pipeline that is running as expected // should never output anything else but LOG messages whilst processing data. // Use this log level to log recurring information in chain functions and // loop functions, for example. LevelLog DebugLevel = 6 // LevelTrace wraps GST_LEVEL_TRACE // // Tracing-related messages. // Examples for this are referencing/dereferencing of objects. LevelTrace DebugLevel = 7 // LevelMemdump wraps GST_LEVEL_MEMDUMP // // memory dump messages are used to log (small) chunks of // data as memory dumps in the log. They will be displayed as hexdump with // ASCII characters. LevelMemdump DebugLevel = 9 // LevelCount wraps GST_LEVEL_COUNT // // The number of defined debugging levels. LevelCount DebugLevel = 10 ) func marshalDebugLevel(p unsafe.Pointer) (any, error) { return DebugLevel(gobject.ValueFromNative(p).Enum()), nil } var _ gobject.GoValueInitializer = DebugLevel(0) func (e DebugLevel) InitGoValue(v *gobject.Value) { v.Init(TypeDebugLevel) v.SetEnum(int(e)) } func (e DebugLevel) String() string { switch e { case LevelCount: return "LevelCount" case LevelDebug: return "LevelDebug" case LevelError: return "LevelError" case LevelFixme: return "LevelFixme" case LevelInfo: return "LevelInfo" case LevelLog: return "LevelLog" case LevelMemdump: return "LevelMemdump" case LevelNone: return "LevelNone" case LevelTrace: return "LevelTrace" case LevelWarning: return "LevelWarning" default: return fmt.Sprintf("DebugLevel(%d)", e) } } // DebugLevelGetName wraps gst_debug_level_get_name // // The function takes the following parameters: // // - level DebugLevel: the level to get the name for // // The function returns the following values: // // - goret string // // Get the string representation of a debugging level func DebugLevelGetName(level DebugLevel) string { var carg1 C.GstDebugLevel // in, none, casted var cret *C.gchar // return, none, string carg1 = C.GstDebugLevel(level) cret = C.gst_debug_level_get_name(carg1) runtime.KeepAlive(level) var goret string goret = C.GoString((*C.char)(unsafe.Pointer(cret))) return goret } // EventType wraps GstEventType // // #GstEventType lists the standard event types that can be sent in a pipeline. // // The custom event types can be used for private messages between elements // that can't be expressed using normal // GStreamer buffer passing semantics. Custom events carry an arbitrary // #GstStructure. // Specific custom events are distinguished by the name of the structure. type EventType C.int const ( // EventUnknown wraps GST_EVENT_UNKNOWN // // unknown event. EventUnknown EventType = 0 // EventFlushStart wraps GST_EVENT_FLUSH_START // // Start a flush operation. This event clears all data // from the pipeline and unblock all streaming threads. EventFlushStart EventType = 2563 // EventFlushStop wraps GST_EVENT_FLUSH_STOP // // Stop a flush operation. This event resets the // running-time of the pipeline. EventFlushStop EventType = 5127 // EventStreamStart wraps GST_EVENT_STREAM_START // // Event to mark the start of a new stream. Sent before any // other serialized event and only sent at the start of a new stream, // not after flushing seeks. EventStreamStart EventType = 10254 // EventCaps wraps GST_EVENT_CAPS // // #GstCaps event. Notify the pad of a new media type. EventCaps EventType = 12814 // EventSegment wraps GST_EVENT_SEGMENT // // A new media segment follows in the dataflow. The // segment events contains information for clipping buffers and // converting buffer timestamps to running-time and // stream-time. EventSegment EventType = 17934 // EventStreamCollection wraps GST_EVENT_STREAM_COLLECTION // // A new #GstStreamCollection is available (Since: 1.10) EventStreamCollection EventType = 19230 // EventTag wraps GST_EVENT_TAG // // A new set of metadata tags has been found in the stream. EventTag EventType = 20510 // EventBuffersize wraps GST_EVENT_BUFFERSIZE // // Notification of buffering requirements. Currently not // used yet. EventBuffersize EventType = 23054 // EventSinkMessage wraps GST_EVENT_SINK_MESSAGE // // An event that sinks turn into a message. Used to // send messages that should be emitted in sync with // rendering. EventSinkMessage EventType = 25630 // EventStreamGroupDone wraps GST_EVENT_STREAM_GROUP_DONE // // Indicates that there is no more data for // the stream group ID in the message. Sent before EOS // in some instances and should be handled mostly the same. (Since: 1.10) EventStreamGroupDone EventType = 26894 // EventEos wraps GST_EVENT_EOS // // End-Of-Stream. No more data is to be expected to follow // without either a STREAM_START event, or a FLUSH_STOP and a SEGMENT // event. EventEos EventType = 28174 // EventToc wraps GST_EVENT_TOC // // An event which indicates that a new table of contents (TOC) // was found or updated. EventToc EventType = 30750 // EventProtection wraps GST_EVENT_PROTECTION // // An event which indicates that new or updated // encryption information has been found in the stream. EventProtection EventType = 33310 // EventSegmentDone wraps GST_EVENT_SEGMENT_DONE // // Marks the end of a segment playback. EventSegmentDone EventType = 38406 // EventGap wraps GST_EVENT_GAP // // Marks a gap in the datastream. EventGap EventType = 40966 // EventInstantRateChange wraps GST_EVENT_INSTANT_RATE_CHANGE // // Notify downstream that a playback rate override // should be applied as soon as possible. (Since: 1.18) EventInstantRateChange EventType = 46090 // EventQos wraps GST_EVENT_QOS // // A quality message. Used to indicate to upstream elements // that the downstream elements should adjust their processing // rate. EventQos EventType = 48641 // EventSeek wraps GST_EVENT_SEEK // // A request for a new playback position and rate. EventSeek EventType = 51201 // EventNavigation wraps GST_EVENT_NAVIGATION // // Navigation events are usually used for communicating // user requests, such as mouse or keyboard movements, // to upstream elements. EventNavigation EventType = 53761 // EventLatency wraps GST_EVENT_LATENCY // // Notification of new latency adjustment. Sinks will use // the latency information to adjust their synchronisation. EventLatency EventType = 56321 // EventStep wraps GST_EVENT_STEP // // A request for stepping through the media. Sinks will usually // execute the step operation. EventStep EventType = 58881 // EventReconfigure wraps GST_EVENT_RECONFIGURE // // A request for upstream renegotiating caps and reconfiguring. EventReconfigure EventType = 61441 // EventTocSelect wraps GST_EVENT_TOC_SELECT // // A request for a new playback position based on TOC // entry's UID. EventTocSelect EventType = 64001 // EventSelectStreams wraps GST_EVENT_SELECT_STREAMS // // A request to select one or more streams (Since: 1.10) EventSelectStreams EventType = 66561 // EventInstantRateSyncTime wraps GST_EVENT_INSTANT_RATE_SYNC_TIME // // Sent by the pipeline to notify elements that handle the // instant-rate-change event about the running-time when // the rate multiplier should be applied (or was applied). (Since: 1.18) EventInstantRateSyncTime EventType = 66817 // EventCustomUpstream wraps GST_EVENT_CUSTOM_UPSTREAM // // Upstream custom event EventCustomUpstream EventType = 69121 // EventCustomDownstream wraps GST_EVENT_CUSTOM_DOWNSTREAM // // Downstream custom event that travels in the // data flow. EventCustomDownstream EventType = 71686 // EventCustomDownstreamOob wraps GST_EVENT_CUSTOM_DOWNSTREAM_OOB // // Custom out-of-band downstream event. EventCustomDownstreamOob EventType = 74242 // EventCustomDownstreamSticky wraps GST_EVENT_CUSTOM_DOWNSTREAM_STICKY // // Custom sticky downstream event. EventCustomDownstreamSticky EventType = 76830 // EventCustomBoth wraps GST_EVENT_CUSTOM_BOTH // // Custom upstream or downstream event. // In-band when travelling downstream. EventCustomBoth EventType = 79367 // EventCustomBothOob wraps GST_EVENT_CUSTOM_BOTH_OOB // // Custom upstream or downstream out-of-band event. EventCustomBothOob EventType = 81923 ) func marshalEventType(p unsafe.Pointer) (any, error) { return EventType(gobject.ValueFromNative(p).Enum()), nil } var _ gobject.GoValueInitializer = EventType(0) func (e EventType) InitGoValue(v *gobject.Value) { v.Init(TypeEventType) v.SetEnum(int(e)) } func (e EventType) String() string { switch e { case EventBuffersize: return "EventBuffersize" case EventCaps: return "EventCaps" case EventCustomBoth: return "EventCustomBoth" case EventCustomBothOob: return "EventCustomBothOob" case EventCustomDownstream: return "EventCustomDownstream" case EventCustomDownstreamOob: return "EventCustomDownstreamOob" case EventCustomDownstreamSticky: return "EventCustomDownstreamSticky" case EventCustomUpstream: return "EventCustomUpstream" case EventEos: return "EventEos" case EventFlushStart: return "EventFlushStart" case EventFlushStop: return "EventFlushStop" case EventGap: return "EventGap" case EventInstantRateChange: return "EventInstantRateChange" case EventInstantRateSyncTime: return "EventInstantRateSyncTime" case EventLatency: return "EventLatency" case EventNavigation: return "EventNavigation" case EventProtection: return "EventProtection" case EventQos: return "EventQos" case EventReconfigure: return "EventReconfigure" case EventSeek: return "EventSeek" case EventSegment: return "EventSegment" case EventSegmentDone: return "EventSegmentDone" case EventSelectStreams: return "EventSelectStreams" case EventSinkMessage: return "EventSinkMessage" case EventStep: return "EventStep" case EventStreamCollection: return "EventStreamCollection" case EventStreamGroupDone: return "EventStreamGroupDone" case EventStreamStart: return "EventStreamStart" case EventTag: return "EventTag" case EventToc: return "EventToc" case EventTocSelect: return "EventTocSelect" case EventUnknown: return "EventUnknown" default: return fmt.Sprintf("EventType(%d)", e) } } // EventTypeGetFlags wraps gst_event_type_get_flags // // The function takes the following parameters: // // - typ EventType: a #GstEventType // // The function returns the following values: // // - goret EventTypeFlags // // Gets the #GstEventTypeFlags associated with @type. func EventTypeGetFlags(typ EventType) EventTypeFlags { var carg1 C.GstEventType // in, none, casted var cret C.GstEventTypeFlags // return, none, casted carg1 = C.GstEventType(typ) cret = C.gst_event_type_get_flags(carg1) runtime.KeepAlive(typ) var goret EventTypeFlags goret = EventTypeFlags(cret) return goret } // EventTypeGetName wraps gst_event_type_get_name // // The function takes the following parameters: // // - typ EventType: the event type // // The function returns the following values: // // - goret string // // Get a printable name for the given event type. Do not modify or free. func EventTypeGetName(typ EventType) string { var carg1 C.GstEventType // in, none, casted var cret *C.gchar // return, none, string carg1 = C.GstEventType(typ) cret = C.gst_event_type_get_name(carg1) runtime.KeepAlive(typ) var goret string goret = C.GoString((*C.char)(unsafe.Pointer(cret))) return goret } // EventTypeToQuark wraps gst_event_type_to_quark // // The function takes the following parameters: // // - typ EventType: the event type // // The function returns the following values: // // - goret glib.Quark // // Get the unique quark for the given event type. func EventTypeToQuark(typ EventType) glib.Quark { var carg1 C.GstEventType // in, none, casted var cret C.GQuark // return, none, casted, alias carg1 = C.GstEventType(typ) cret = C.gst_event_type_to_quark(carg1) runtime.KeepAlive(typ) var goret glib.Quark goret = glib.Quark(cret) return goret } // EventTypeToStickyOrdering wraps gst_event_type_to_sticky_ordering // // The function takes the following parameters: // // - typ EventType: a #GstEventType // // The function returns the following values: // // - goret uint // // Converts the #GstEventType to an unsigned integer that // represents the ordering of sticky events when re-sending them. // A lower value represents a higher-priority event. func EventTypeToStickyOrdering(typ EventType) uint { var carg1 C.GstEventType // in, none, casted var cret C.guint // return, none, casted carg1 = C.GstEventType(typ) cret = C.gst_event_type_to_sticky_ordering(carg1) runtime.KeepAlive(typ) var goret uint goret = uint(cret) return goret } // FlowReturn wraps GstFlowReturn // // The result of passing data to a pad. // // Note that the custom return values should not be exposed outside of the // element scope. type FlowReturn C.int const ( // FlowCustomSuccess2 wraps GST_FLOW_CUSTOM_SUCCESS_2 // // Pre-defined custom success code. FlowCustomSuccess2 FlowReturn = 102 // FlowCustomSuccess1 wraps GST_FLOW_CUSTOM_SUCCESS_1 // // Pre-defined custom success code (define your // custom success code to this to avoid compiler // warnings). FlowCustomSuccess1 FlowReturn = 101 // FlowCustomSuccess wraps GST_FLOW_CUSTOM_SUCCESS // // Elements can use values starting from // this (and higher) to define custom success // codes. FlowCustomSuccess FlowReturn = 100 // FlowOK wraps GST_FLOW_OK // // Data passing was ok. FlowOK FlowReturn = 0 // FlowNotLinked wraps GST_FLOW_NOT_LINKED // // Pad is not linked. FlowNotLinked FlowReturn = -1 // FlowFlushing wraps GST_FLOW_FLUSHING // // Pad is flushing. FlowFlushing FlowReturn = -2 // FlowEos wraps GST_FLOW_EOS // // Pad is EOS. FlowEos FlowReturn = -3 // FlowNotNegotiated wraps GST_FLOW_NOT_NEGOTIATED // // Pad is not negotiated. FlowNotNegotiated FlowReturn = -4 // FlowError wraps GST_FLOW_ERROR // // Some (fatal) error occurred. Element generating // this error should post an error message using // GST_ELEMENT_ERROR() with more details. FlowError FlowReturn = -5 // FlowNotSupported wraps GST_FLOW_NOT_SUPPORTED // // This operation is not supported. FlowNotSupported FlowReturn = -6 // FlowCustomError wraps GST_FLOW_CUSTOM_ERROR // // Elements can use values starting from // this (and lower) to define custom error codes. FlowCustomError FlowReturn = -100 // FlowCustomError1 wraps GST_FLOW_CUSTOM_ERROR_1 // // Pre-defined custom error code (define your // custom error code to this to avoid compiler // warnings). FlowCustomError1 FlowReturn = -101 // FlowCustomError2 wraps GST_FLOW_CUSTOM_ERROR_2 // // Pre-defined custom error code. FlowCustomError2 FlowReturn = -102 ) func marshalFlowReturn(p unsafe.Pointer) (any, error) { return FlowReturn(gobject.ValueFromNative(p).Enum()), nil } var _ gobject.GoValueInitializer = FlowReturn(0) func (e FlowReturn) InitGoValue(v *gobject.Value) { v.Init(TypeFlowReturn) v.SetEnum(int(e)) } func (e FlowReturn) String() string { switch e { case FlowCustomError: return "FlowCustomError" case FlowCustomError1: return "FlowCustomError1" case FlowCustomError2: return "FlowCustomError2" case FlowCustomSuccess: return "FlowCustomSuccess" case FlowCustomSuccess1: return "FlowCustomSuccess1" case FlowCustomSuccess2: return "FlowCustomSuccess2" case FlowEos: return "FlowEos" case FlowError: return "FlowError" case FlowFlushing: return "FlowFlushing" case FlowNotLinked: return "FlowNotLinked" case FlowNotNegotiated: return "FlowNotNegotiated" case FlowNotSupported: return "FlowNotSupported" case FlowOK: return "FlowOK" default: return fmt.Sprintf("FlowReturn(%d)", e) } } // Format wraps GstFormat // // Standard predefined formats type Format C.int const ( // FormatUndefined wraps GST_FORMAT_UNDEFINED // // undefined format FormatUndefined Format = 0 // FormatDefault wraps GST_FORMAT_DEFAULT // // the default format of the pad/element. This can be // samples for raw audio, frames/fields for raw video (some, but not all, // elements support this; use @GST_FORMAT_TIME if you don't have a good // reason to query for samples/frames) FormatDefault Format = 1 // FormatBytes wraps GST_FORMAT_BYTES // // bytes FormatBytes Format = 2 // FormatTime wraps GST_FORMAT_TIME // // time in nanoseconds FormatTime Format = 3 // FormatBuffers wraps GST_FORMAT_BUFFERS // // buffers (few, if any, elements implement this as of // May 2009) FormatBuffers Format = 4 // FormatPercent wraps GST_FORMAT_PERCENT // // percentage of stream (few, if any, elements implement // this as of May 2009) FormatPercent Format = 5 ) func marshalFormat(p unsafe.Pointer) (any, error) { return Format(gobject.ValueFromNative(p).Enum()), nil } var _ gobject.GoValueInitializer = Format(0) func (e Format) InitGoValue(v *gobject.Value) { v.Init(TypeFormat) v.SetEnum(int(e)) } func (e Format) String() string { switch e { case FormatBuffers: return "FormatBuffers" case FormatBytes: return "FormatBytes" case FormatDefault: return "FormatDefault" case FormatPercent: return "FormatPercent" case FormatTime: return "FormatTime" case FormatUndefined: return "FormatUndefined" default: return fmt.Sprintf("Format(%d)", e) } } // FormatGetByNick wraps gst_format_get_by_nick // // The function takes the following parameters: // // - nick string: The nick of the format // // The function returns the following values: // // - goret Format // // Return the format registered with the given nick. func FormatGetByNick(nick string) Format { var carg1 *C.gchar // in, none, string var cret C.GstFormat // return, none, casted carg1 = (*C.gchar)(unsafe.Pointer(C.CString(nick))) defer C.free(unsafe.Pointer(carg1)) cret = C.gst_format_get_by_nick(carg1) runtime.KeepAlive(nick) var goret Format goret = Format(cret) return goret } // FormatGetDetails wraps gst_format_get_details // // The function takes the following parameters: // // - format Format: The format to get details of // // The function returns the following values: // // - goret *FormatDefinition (nullable) // // Get details about the given format. func FormatGetDetails(format Format) *FormatDefinition { var carg1 C.GstFormat // in, none, casted var cret *C.GstFormatDefinition // return, none, converted, nullable carg1 = C.GstFormat(format) cret = C.gst_format_get_details(carg1) runtime.KeepAlive(format) var goret *FormatDefinition if cret != nil { goret = UnsafeFormatDefinitionFromGlibNone(unsafe.Pointer(cret)) } return goret } // FormatGetName wraps gst_format_get_name // // The function takes the following parameters: // // - format Format: a #GstFormat // // The function returns the following values: // // - goret string (nullable) // // Get a printable name for the given format. Do not modify or free. func FormatGetName(format Format) string { var carg1 C.GstFormat // in, none, casted var cret *C.gchar // return, none, string, nullable-string carg1 = C.GstFormat(format) cret = C.gst_format_get_name(carg1) runtime.KeepAlive(format) var goret string if cret != nil { goret = C.GoString((*C.char)(unsafe.Pointer(cret))) } return goret } // FormatIterateDefinitions wraps gst_format_iterate_definitions // // The function returns the following values: // // - goret *Iterator // // Iterate all the registered formats. The format definition is read // only. func FormatIterateDefinitions() *Iterator { var cret *C.GstIterator // return, full, converted cret = C.gst_format_iterate_definitions() var goret *Iterator goret = UnsafeIteratorFromGlibFull(unsafe.Pointer(cret)) return goret } // FormatRegister wraps gst_format_register // // The function takes the following parameters: // // - nick string: The nick of the new format // - description string: The description of the new format // // The function returns the following values: // // - goret Format // // Create a new GstFormat based on the nick or return an // already registered format with that nick. func FormatRegister(nick string, description string) Format { var carg1 *C.gchar // in, none, string var carg2 *C.gchar // in, none, string var cret C.GstFormat // return, none, casted carg1 = (*C.gchar)(unsafe.Pointer(C.CString(nick))) defer C.free(unsafe.Pointer(carg1)) carg2 = (*C.gchar)(unsafe.Pointer(C.CString(description))) defer C.free(unsafe.Pointer(carg2)) cret = C.gst_format_register(carg1, carg2) runtime.KeepAlive(nick) runtime.KeepAlive(description) var goret Format goret = Format(cret) return goret } // FormatToQuark wraps gst_format_to_quark // // The function takes the following parameters: // // - format Format: a #GstFormat // // The function returns the following values: // // - goret glib.Quark // // Get the unique quark for the given format. func FormatToQuark(format Format) glib.Quark { var carg1 C.GstFormat // in, none, casted var cret C.GQuark // return, none, casted, alias carg1 = C.GstFormat(format) cret = C.gst_format_to_quark(carg1) runtime.KeepAlive(format) var goret glib.Quark goret = glib.Quark(cret) return goret } // IteratorItem wraps GstIteratorItem // // The result of a #GstIteratorItemFunction. type IteratorItem C.int const ( // IteratorItemSkip wraps GST_ITERATOR_ITEM_SKIP // // Skip this item IteratorItemSkip IteratorItem = 0 // IteratorItemPass wraps GST_ITERATOR_ITEM_PASS // // Return item IteratorItemPass IteratorItem = 1 // IteratorItemEnd wraps GST_ITERATOR_ITEM_END // // Stop after this item. IteratorItemEnd IteratorItem = 2 ) func marshalIteratorItem(p unsafe.Pointer) (any, error) { return IteratorItem(gobject.ValueFromNative(p).Enum()), nil } var _ gobject.GoValueInitializer = IteratorItem(0) func (e IteratorItem) InitGoValue(v *gobject.Value) { v.Init(TypeIteratorItem) v.SetEnum(int(e)) } func (e IteratorItem) String() string { switch e { case IteratorItemEnd: return "IteratorItemEnd" case IteratorItemPass: return "IteratorItemPass" case IteratorItemSkip: return "IteratorItemSkip" default: return fmt.Sprintf("IteratorItem(%d)", e) } } // IteratorResult wraps GstIteratorResult // // The result of gst_iterator_next(). type IteratorResult C.int const ( // IteratorDone wraps GST_ITERATOR_DONE // // No more items in the iterator IteratorDone IteratorResult = 0 // IteratorOK wraps GST_ITERATOR_OK // // An item was retrieved IteratorOK IteratorResult = 1 // IteratorResync wraps GST_ITERATOR_RESYNC // // Datastructure changed while iterating IteratorResync IteratorResult = 2 // IteratorError wraps GST_ITERATOR_ERROR // // An error happened IteratorError IteratorResult = 3 ) func marshalIteratorResult(p unsafe.Pointer) (any, error) { return IteratorResult(gobject.ValueFromNative(p).Enum()), nil } var _ gobject.GoValueInitializer = IteratorResult(0) func (e IteratorResult) InitGoValue(v *gobject.Value) { v.Init(TypeIteratorResult) v.SetEnum(int(e)) } func (e IteratorResult) String() string { switch e { case IteratorDone: return "IteratorDone" case IteratorError: return "IteratorError" case IteratorOK: return "IteratorOK" case IteratorResync: return "IteratorResync" default: return fmt.Sprintf("IteratorResult(%d)", e) } } // LibraryError wraps GstLibraryError // // Library errors are for errors from the library being used by elements // (initializing, finalizing, settings, ...) type LibraryError C.int const ( // LibraryErrorFailed wraps GST_LIBRARY_ERROR_FAILED // // a general error which doesn't fit in any other // category. Make sure you add a custom message to the error call. LibraryErrorFailed LibraryError = 1 // LibraryErrorTooLaZY wraps GST_LIBRARY_ERROR_TOO_LAZY // // do not use this except as a placeholder for // deciding where to go while developing code. LibraryErrorTooLaZY LibraryError = 2 // LibraryErrorInit wraps GST_LIBRARY_ERROR_INIT // // used when the library could not be opened. LibraryErrorInit LibraryError = 3 // LibraryErrorShutdown wraps GST_LIBRARY_ERROR_SHUTDOWN // // used when the library could not be closed. LibraryErrorShutdown LibraryError = 4 // LibraryErrorSettings wraps GST_LIBRARY_ERROR_SETTINGS // // used when the library doesn't accept settings. LibraryErrorSettings LibraryError = 5 // LibraryErrorEncode wraps GST_LIBRARY_ERROR_ENCODE // // used when the library generated an encoding error. LibraryErrorEncode LibraryError = 6 // LibraryErrorNumErrors wraps GST_LIBRARY_ERROR_NUM_ERRORS // // the number of library error types. LibraryErrorNumErrors LibraryError = 7 ) func marshalLibraryError(p unsafe.Pointer) (any, error) { return LibraryError(gobject.ValueFromNative(p).Enum()), nil } var _ gobject.GoValueInitializer = LibraryError(0) func (e LibraryError) InitGoValue(v *gobject.Value) { v.Init(TypeLibraryError) v.SetEnum(int(e)) } func (e LibraryError) String() string { switch e { case LibraryErrorEncode: return "LibraryErrorEncode" case LibraryErrorFailed: return "LibraryErrorFailed" case LibraryErrorInit: return "LibraryErrorInit" case LibraryErrorNumErrors: return "LibraryErrorNumErrors" case LibraryErrorSettings: return "LibraryErrorSettings" case LibraryErrorShutdown: return "LibraryErrorShutdown" case LibraryErrorTooLaZY: return "LibraryErrorTooLaZY" default: return fmt.Sprintf("LibraryError(%d)", e) } } // LibraryErrorQuark wraps gst_library_error_quark // // The function returns the following values: // // - goret glib.Quark func LibraryErrorQuark() glib.Quark { var cret C.GQuark // return, none, casted, alias cret = C.gst_library_error_quark() var goret glib.Quark goret = glib.Quark(cret) return goret } // PadDirection wraps GstPadDirection // // The direction of a pad. type PadDirection C.int const ( // PadUnknown wraps GST_PAD_UNKNOWN // // direction is unknown. PadUnknown PadDirection = 0 // PadSrc wraps GST_PAD_SRC // // the pad is a source pad. PadSrc PadDirection = 1 // PadSink wraps GST_PAD_SINK // // the pad is a sink pad. PadSink PadDirection = 2 ) func marshalPadDirection(p unsafe.Pointer) (any, error) { return PadDirection(gobject.ValueFromNative(p).Enum()), nil } var _ gobject.GoValueInitializer = PadDirection(0) func (e PadDirection) InitGoValue(v *gobject.Value) { v.Init(TypePadDirection) v.SetEnum(int(e)) } func (e PadDirection) String() string { switch e { case PadSink: return "PadSink" case PadSrc: return "PadSrc" case PadUnknown: return "PadUnknown" default: return fmt.Sprintf("PadDirection(%d)", e) } } // PadLinkReturn wraps GstPadLinkReturn // // Result values from gst_pad_link and friends. type PadLinkReturn C.int const ( // PadLinkOK wraps GST_PAD_LINK_OK // // link succeeded PadLinkOK PadLinkReturn = 0 // PadLinkWrongHierarchy wraps GST_PAD_LINK_WRONG_HIERARCHY // // pads have no common grandparent PadLinkWrongHierarchy PadLinkReturn = -1 // PadLinkWasLinked wraps GST_PAD_LINK_WAS_LINKED // // pad was already linked PadLinkWasLinked PadLinkReturn = -2 // PadLinkWrongDirection wraps GST_PAD_LINK_WRONG_DIRECTION // // pads have wrong direction PadLinkWrongDirection PadLinkReturn = -3 // PadLinkNoformat wraps GST_PAD_LINK_NOFORMAT // // pads do not have common format PadLinkNoformat PadLinkReturn = -4 // PadLinkNosched wraps GST_PAD_LINK_NOSCHED // // pads cannot cooperate in scheduling PadLinkNosched PadLinkReturn = -5 // PadLinkRefused wraps GST_PAD_LINK_REFUSED // // refused for some reason PadLinkRefused PadLinkReturn = -6 ) func marshalPadLinkReturn(p unsafe.Pointer) (any, error) { return PadLinkReturn(gobject.ValueFromNative(p).Enum()), nil } var _ gobject.GoValueInitializer = PadLinkReturn(0) func (e PadLinkReturn) InitGoValue(v *gobject.Value) { v.Init(TypePadLinkReturn) v.SetEnum(int(e)) } func (e PadLinkReturn) String() string { switch e { case PadLinkNoformat: return "PadLinkNoformat" case PadLinkNosched: return "PadLinkNosched" case PadLinkOK: return "PadLinkOK" case PadLinkRefused: return "PadLinkRefused" case PadLinkWasLinked: return "PadLinkWasLinked" case PadLinkWrongDirection: return "PadLinkWrongDirection" case PadLinkWrongHierarchy: return "PadLinkWrongHierarchy" default: return fmt.Sprintf("PadLinkReturn(%d)", e) } } // PadMode wraps GstPadMode // // The status of a GstPad. After activating a pad, which usually happens when the // parent element goes from READY to PAUSED, the GstPadMode defines if the // pad operates in push or pull mode. type PadMode C.int const ( // PadModeNone wraps GST_PAD_MODE_NONE // // Pad will not handle dataflow PadModeNone PadMode = 0 // PadModePush wraps GST_PAD_MODE_PUSH // // Pad handles dataflow in downstream push mode PadModePush PadMode = 1 // PadModePull wraps GST_PAD_MODE_PULL // // Pad handles dataflow in upstream pull mode PadModePull PadMode = 2 ) func marshalPadMode(p unsafe.Pointer) (any, error) { return PadMode(gobject.ValueFromNative(p).Enum()), nil } var _ gobject.GoValueInitializer = PadMode(0) func (e PadMode) InitGoValue(v *gobject.Value) { v.Init(TypePadMode) v.SetEnum(int(e)) } func (e PadMode) String() string { switch e { case PadModeNone: return "PadModeNone" case PadModePull: return "PadModePull" case PadModePush: return "PadModePush" default: return fmt.Sprintf("PadMode(%d)", e) } } // PadModeGetName wraps gst_pad_mode_get_name // // The function takes the following parameters: // // - mode PadMode: the pad mode // // The function returns the following values: // // - goret string // // Return the name of a pad mode, for use in debug messages mostly. func PadModeGetName(mode PadMode) string { var carg1 C.GstPadMode // in, none, casted var cret *C.gchar // return, none, string carg1 = C.GstPadMode(mode) cret = C.gst_pad_mode_get_name(carg1) runtime.KeepAlive(mode) var goret string goret = C.GoString((*C.char)(unsafe.Pointer(cret))) return goret } // PadPresence wraps GstPadPresence // // Indicates when this pad will become available. type PadPresence C.int const ( // PadAlways wraps GST_PAD_ALWAYS // // the pad is always available PadAlways PadPresence = 0 // PadSometimes wraps GST_PAD_SOMETIMES // // the pad will become available depending on the media stream PadSometimes PadPresence = 1 // PadRequest wraps GST_PAD_REQUEST // // the pad is only available on request with // gst_element_request_pad(). PadRequest PadPresence = 2 ) func marshalPadPresence(p unsafe.Pointer) (any, error) { return PadPresence(gobject.ValueFromNative(p).Enum()), nil } var _ gobject.GoValueInitializer = PadPresence(0) func (e PadPresence) InitGoValue(v *gobject.Value) { v.Init(TypePadPresence) v.SetEnum(int(e)) } func (e PadPresence) String() string { switch e { case PadAlways: return "PadAlways" case PadRequest: return "PadRequest" case PadSometimes: return "PadSometimes" default: return fmt.Sprintf("PadPresence(%d)", e) } } // PadProbeReturn wraps GstPadProbeReturn // // Different return values for the #GstPadProbeCallback. type PadProbeReturn C.int const ( // PadProbeDrop wraps GST_PAD_PROBE_DROP // // drop data in data probes. For push mode this means that // the data item is not sent downstream. For pull mode, it means that // the data item is not passed upstream. In both cases, no other probes // are called for this item and %GST_FLOW_OK or %TRUE is returned to the // caller. PadProbeDrop PadProbeReturn = 0 // PadProbeOK wraps GST_PAD_PROBE_OK // // normal probe return value. This leaves the probe in // place, and defers decisions about dropping or passing data to other // probes, if any. If there are no other probes, the default behaviour // for the probe type applies ('block' for blocking probes, // and 'pass' for non-blocking probes). PadProbeOK PadProbeReturn = 1 // PadProbeRemove wraps GST_PAD_PROBE_REMOVE // // remove this probe, passing the data. For blocking probes // this will cause data flow to unblock, unless there are also other // blocking probes installed. PadProbeRemove PadProbeReturn = 2 // PadProbePass wraps GST_PAD_PROBE_PASS // // pass the data item in the block probe and block on the // next item. Note, that if there are multiple pad probes installed and // any probe returns PASS, the data will be passed. PadProbePass PadProbeReturn = 3 // PadProbeHandled wraps GST_PAD_PROBE_HANDLED // // Data has been handled in the probe and will not be // forwarded further. For events and buffers this is the same behaviour as // %GST_PAD_PROBE_DROP (except that in this case you need to unref the buffer // or event yourself). For queries it will also return %TRUE to the caller. // The probe can also modify the #GstFlowReturn value by using the // #GST_PAD_PROBE_INFO_FLOW_RETURN() accessor. // Note that the resulting query must contain valid entries. // Since: 1.6 PadProbeHandled PadProbeReturn = 4 ) func marshalPadProbeReturn(p unsafe.Pointer) (any, error) { return PadProbeReturn(gobject.ValueFromNative(p).Enum()), nil } var _ gobject.GoValueInitializer = PadProbeReturn(0) func (e PadProbeReturn) InitGoValue(v *gobject.Value) { v.Init(TypePadProbeReturn) v.SetEnum(int(e)) } func (e PadProbeReturn) String() string { switch e { case PadProbeDrop: return "PadProbeDrop" case PadProbeHandled: return "PadProbeHandled" case PadProbeOK: return "PadProbeOK" case PadProbePass: return "PadProbePass" case PadProbeRemove: return "PadProbeRemove" default: return fmt.Sprintf("PadProbeReturn(%d)", e) } } // ParseError wraps GstParseError // // The different parsing errors that can occur. type ParseError C.int const ( // ParseErrorSyntax wraps GST_PARSE_ERROR_SYNTAX // // A syntax error occurred. ParseErrorSyntax ParseError = 0 // ParseErrorNoSuchElement wraps GST_PARSE_ERROR_NO_SUCH_ELEMENT // // The description contained an unknown element ParseErrorNoSuchElement ParseError = 1 // ParseErrorNoSuchProperty wraps GST_PARSE_ERROR_NO_SUCH_PROPERTY // // An element did not have a specified property ParseErrorNoSuchProperty ParseError = 2 // ParseErrorLink wraps GST_PARSE_ERROR_LINK // // There was an error linking two pads. ParseErrorLink ParseError = 3 // ParseErrorCouldNotSetProperty wraps GST_PARSE_ERROR_COULD_NOT_SET_PROPERTY // // There was an error setting a property ParseErrorCouldNotSetProperty ParseError = 4 // ParseErrorEmptyBin wraps GST_PARSE_ERROR_EMPTY_BIN // // An empty bin was specified. ParseErrorEmptyBin ParseError = 5 // ParseErrorEmpty wraps GST_PARSE_ERROR_EMPTY // // An empty description was specified ParseErrorEmpty ParseError = 6 // ParseErrorDelayedLink wraps GST_PARSE_ERROR_DELAYED_LINK // // A delayed link did not get resolved. ParseErrorDelayedLink ParseError = 7 ) func marshalParseError(p unsafe.Pointer) (any, error) { return ParseError(gobject.ValueFromNative(p).Enum()), nil } var _ gobject.GoValueInitializer = ParseError(0) func (e ParseError) InitGoValue(v *gobject.Value) { v.Init(TypeParseError) v.SetEnum(int(e)) } func (e ParseError) String() string { switch e { case ParseErrorCouldNotSetProperty: return "ParseErrorCouldNotSetProperty" case ParseErrorDelayedLink: return "ParseErrorDelayedLink" case ParseErrorEmpty: return "ParseErrorEmpty" case ParseErrorEmptyBin: return "ParseErrorEmptyBin" case ParseErrorLink: return "ParseErrorLink" case ParseErrorNoSuchElement: return "ParseErrorNoSuchElement" case ParseErrorNoSuchProperty: return "ParseErrorNoSuchProperty" case ParseErrorSyntax: return "ParseErrorSyntax" default: return fmt.Sprintf("ParseError(%d)", e) } } // ParseErrorQuark wraps gst_parse_error_quark // // The function returns the following values: // // - goret glib.Quark // // Get the error quark used by the parsing subsystem. func ParseErrorQuark() glib.Quark { var cret C.GQuark // return, none, casted, alias cret = C.gst_parse_error_quark() var goret glib.Quark goret = glib.Quark(cret) return goret } // PluginError wraps GstPluginError // // The plugin loading errors type PluginError C.int const ( // PluginErrorModule wraps GST_PLUGIN_ERROR_MODULE // // The plugin could not be loaded PluginErrorModule PluginError = 0 // PluginErrorDependencies wraps GST_PLUGIN_ERROR_DEPENDENCIES // // The plugin has unresolved dependencies PluginErrorDependencies PluginError = 1 // PluginErrorNameMismatch wraps GST_PLUGIN_ERROR_NAME_MISMATCH // // The plugin has already be loaded from a different file PluginErrorNameMismatch PluginError = 2 ) func marshalPluginError(p unsafe.Pointer) (any, error) { return PluginError(gobject.ValueFromNative(p).Enum()), nil } var _ gobject.GoValueInitializer = PluginError(0) func (e PluginError) InitGoValue(v *gobject.Value) { v.Init(TypePluginError) v.SetEnum(int(e)) } func (e PluginError) String() string { switch e { case PluginErrorDependencies: return "PluginErrorDependencies" case PluginErrorModule: return "PluginErrorModule" case PluginErrorNameMismatch: return "PluginErrorNameMismatch" default: return fmt.Sprintf("PluginError(%d)", e) } } // PluginErrorQuark wraps gst_plugin_error_quark // // The function returns the following values: // // - goret glib.Quark // // Get the error quark. func PluginErrorQuark() glib.Quark { var cret C.GQuark // return, none, casted, alias cret = C.gst_plugin_error_quark() var goret glib.Quark goret = glib.Quark(cret) return goret } // ProgressType wraps GstProgressType // // The type of a %GST_MESSAGE_PROGRESS. The progress messages inform the // application of the status of asynchronous tasks. type ProgressType C.int const ( // ProgressTypeStart wraps GST_PROGRESS_TYPE_START // // A new task started. ProgressTypeStart ProgressType = 0 // ProgressTypeContinue wraps GST_PROGRESS_TYPE_CONTINUE // // A task completed and a new one continues. ProgressTypeContinue ProgressType = 1 // ProgressTypeComplete wraps GST_PROGRESS_TYPE_COMPLETE // // A task completed. ProgressTypeComplete ProgressType = 2 // ProgressTypeCanceled wraps GST_PROGRESS_TYPE_CANCELED // // A task was canceled. ProgressTypeCanceled ProgressType = 3 // ProgressTypeError wraps GST_PROGRESS_TYPE_ERROR // // A task caused an error. An error message is also // posted on the bus. ProgressTypeError ProgressType = 4 ) func marshalProgressType(p unsafe.Pointer) (any, error) { return ProgressType(gobject.ValueFromNative(p).Enum()), nil } var _ gobject.GoValueInitializer = ProgressType(0) func (e ProgressType) InitGoValue(v *gobject.Value) { v.Init(TypeProgressType) v.SetEnum(int(e)) } func (e ProgressType) String() string { switch e { case ProgressTypeCanceled: return "ProgressTypeCanceled" case ProgressTypeComplete: return "ProgressTypeComplete" case ProgressTypeContinue: return "ProgressTypeContinue" case ProgressTypeError: return "ProgressTypeError" case ProgressTypeStart: return "ProgressTypeStart" default: return fmt.Sprintf("ProgressType(%d)", e) } } // PromiseResult wraps GstPromiseResult // // The result of a #GstPromise type PromiseResult C.int const ( // PromiseResultPending wraps GST_PROMISE_RESULT_PENDING // // Initial state. Waiting for transition to any // other state. PromiseResultPending PromiseResult = 0 // PromiseResultInterrupted wraps GST_PROMISE_RESULT_INTERRUPTED // // Interrupted by the consumer as it doesn't // want the value anymore. PromiseResultInterrupted PromiseResult = 1 // PromiseResultReplied wraps GST_PROMISE_RESULT_REPLIED // // A producer marked a reply PromiseResultReplied PromiseResult = 2 // PromiseResultExpired wraps GST_PROMISE_RESULT_EXPIRED // // The promise expired (the carrying object // lost all refs) and the promise will never be fulfilled. PromiseResultExpired PromiseResult = 3 ) func marshalPromiseResult(p unsafe.Pointer) (any, error) { return PromiseResult(gobject.ValueFromNative(p).Enum()), nil } var _ gobject.GoValueInitializer = PromiseResult(0) func (e PromiseResult) InitGoValue(v *gobject.Value) { v.Init(TypePromiseResult) v.SetEnum(int(e)) } func (e PromiseResult) String() string { switch e { case PromiseResultExpired: return "PromiseResultExpired" case PromiseResultInterrupted: return "PromiseResultInterrupted" case PromiseResultPending: return "PromiseResultPending" case PromiseResultReplied: return "PromiseResultReplied" default: return fmt.Sprintf("PromiseResult(%d)", e) } } // QOSType wraps GstQOSType // // The different types of QoS events that can be given to the // gst_event_new_qos() method. type QOSType C.int const ( // QosTypeOverflow wraps GST_QOS_TYPE_OVERFLOW // // The QoS event type that is produced when upstream // elements are producing data too quickly and the element can't keep up // processing the data. Upstream should reduce their production rate. This // type is also used when buffers arrive early or in time. QosTypeOverflow QOSType = 0 // QosTypeUnderflow wraps GST_QOS_TYPE_UNDERFLOW // // The QoS event type that is produced when upstream // elements are producing data too slowly and need to speed up their // production rate. QosTypeUnderflow QOSType = 1 // QosTypeThrottle wraps GST_QOS_TYPE_THROTTLE // // The QoS event type that is produced when the // application enabled throttling to limit the data rate. QosTypeThrottle QOSType = 2 ) func marshalQOSType(p unsafe.Pointer) (any, error) { return QOSType(gobject.ValueFromNative(p).Enum()), nil } var _ gobject.GoValueInitializer = QOSType(0) func (e QOSType) InitGoValue(v *gobject.Value) { v.Init(TypeQOSType) v.SetEnum(int(e)) } func (e QOSType) String() string { switch e { case QosTypeOverflow: return "QosTypeOverflow" case QosTypeThrottle: return "QosTypeThrottle" case QosTypeUnderflow: return "QosTypeUnderflow" default: return fmt.Sprintf("QOSType(%d)", e) } } // QueryType wraps GstQueryType // // Standard predefined Query types type QueryType C.int const ( // QueryUnknown wraps GST_QUERY_UNKNOWN // // unknown query type QueryUnknown QueryType = 0 // QueryPosition wraps GST_QUERY_POSITION // // current position in stream QueryPosition QueryType = 2563 // QueryDuration wraps GST_QUERY_DURATION // // total duration of the stream QueryDuration QueryType = 5123 // QueryLatency wraps GST_QUERY_LATENCY // // latency of stream QueryLatency QueryType = 7683 // QueryJitter wraps GST_QUERY_JITTER // // current jitter of stream QueryJitter QueryType = 10243 // QueryRate wraps GST_QUERY_RATE // // current rate of the stream QueryRate QueryType = 12803 // QuerySeeking wraps GST_QUERY_SEEKING // // seeking capabilities QuerySeeking QueryType = 15363 // QuerySegment wraps GST_QUERY_SEGMENT // // segment start/stop positions QuerySegment QueryType = 17923 // QueryConvert wraps GST_QUERY_CONVERT // // convert values between formats QueryConvert QueryType = 20483 // QueryFormats wraps GST_QUERY_FORMATS // // query supported formats for convert QueryFormats QueryType = 23043 // QueryBuffering wraps GST_QUERY_BUFFERING // // query available media for efficient seeking. QueryBuffering QueryType = 28163 // QueryCustom wraps GST_QUERY_CUSTOM // // a custom application or element defined query. QueryCustom QueryType = 30723 // QueryURI wraps GST_QUERY_URI // // query the URI of the source or sink. QueryURI QueryType = 33283 // QueryAllocation wraps GST_QUERY_ALLOCATION // // the buffer allocation properties QueryAllocation QueryType = 35846 // QueryScheduling wraps GST_QUERY_SCHEDULING // // the scheduling properties QueryScheduling QueryType = 38401 // QueryAcceptCaps wraps GST_QUERY_ACCEPT_CAPS // // the accept caps query QueryAcceptCaps QueryType = 40963 // QueryCaps wraps GST_QUERY_CAPS // // the caps query QueryCaps QueryType = 43523 // QueryDrain wraps GST_QUERY_DRAIN // // wait till all serialized data is consumed downstream QueryDrain QueryType = 46086 // QueryContext wraps GST_QUERY_CONTEXT // // query the pipeline-local context from // downstream or upstream (since 1.2) QueryContext QueryType = 48643 // QueryBitrate wraps GST_QUERY_BITRATE // // the bitrate query (since 1.16) QueryBitrate QueryType = 51202 // QuerySelectable wraps GST_QUERY_SELECTABLE // // Query stream selection capability. QuerySelectable QueryType = 53763 ) func marshalQueryType(p unsafe.Pointer) (any, error) { return QueryType(gobject.ValueFromNative(p).Enum()), nil } var _ gobject.GoValueInitializer = QueryType(0) func (e QueryType) InitGoValue(v *gobject.Value) { v.Init(TypeQueryType) v.SetEnum(int(e)) } func (e QueryType) String() string { switch e { case QueryAcceptCaps: return "QueryAcceptCaps" case QueryAllocation: return "QueryAllocation" case QueryBitrate: return "QueryBitrate" case QueryBuffering: return "QueryBuffering" case QueryCaps: return "QueryCaps" case QueryContext: return "QueryContext" case QueryConvert: return "QueryConvert" case QueryCustom: return "QueryCustom" case QueryDrain: return "QueryDrain" case QueryDuration: return "QueryDuration" case QueryFormats: return "QueryFormats" case QueryJitter: return "QueryJitter" case QueryLatency: return "QueryLatency" case QueryPosition: return "QueryPosition" case QueryRate: return "QueryRate" case QueryScheduling: return "QueryScheduling" case QuerySeeking: return "QuerySeeking" case QuerySegment: return "QuerySegment" case QuerySelectable: return "QuerySelectable" case QueryURI: return "QueryURI" case QueryUnknown: return "QueryUnknown" default: return fmt.Sprintf("QueryType(%d)", e) } } // QueryTypeGetFlags wraps gst_query_type_get_flags // // The function takes the following parameters: // // - typ QueryType: a #GstQueryType // // The function returns the following values: // // - goret QueryTypeFlags // // Gets the #GstQueryTypeFlags associated with @type. func QueryTypeGetFlags(typ QueryType) QueryTypeFlags { var carg1 C.GstQueryType // in, none, casted var cret C.GstQueryTypeFlags // return, none, casted carg1 = C.GstQueryType(typ) cret = C.gst_query_type_get_flags(carg1) runtime.KeepAlive(typ) var goret QueryTypeFlags goret = QueryTypeFlags(cret) return goret } // QueryTypeGetName wraps gst_query_type_get_name // // The function takes the following parameters: // // - typ QueryType: the query type // // The function returns the following values: // // - goret string // // Get a printable name for the given query type. Do not modify or free. func QueryTypeGetName(typ QueryType) string { var carg1 C.GstQueryType // in, none, casted var cret *C.gchar // return, none, string carg1 = C.GstQueryType(typ) cret = C.gst_query_type_get_name(carg1) runtime.KeepAlive(typ) var goret string goret = C.GoString((*C.char)(unsafe.Pointer(cret))) return goret } // QueryTypeToQuark wraps gst_query_type_to_quark // // The function takes the following parameters: // // - typ QueryType: the query type // // The function returns the following values: // // - goret glib.Quark // // Get the unique quark for the given query type. func QueryTypeToQuark(typ QueryType) glib.Quark { var carg1 C.GstQueryType // in, none, casted var cret C.GQuark // return, none, casted, alias carg1 = C.GstQueryType(typ) cret = C.gst_query_type_to_quark(carg1) runtime.KeepAlive(typ) var goret glib.Quark goret = glib.Quark(cret) return goret } // Rank wraps GstRank // // Element priority ranks. Defines the order in which the autoplugger (or // similar rank-picking mechanisms, such as e.g. gst_element_make_from_uri()) // will choose this element over an alternative one with the same function. // // These constants serve as a rough guidance for defining the rank of a // #GstPluginFeature. Any value is valid, including values bigger than // @GST_RANK_PRIMARY. type Rank C.int const ( // RankNone wraps GST_RANK_NONE // // will be chosen last or not at all RankNone Rank = 0 // RankMarginal wraps GST_RANK_MARGINAL // // unlikely to be chosen RankMarginal Rank = 64 // RankSecondary wraps GST_RANK_SECONDARY // // likely to be chosen RankSecondary Rank = 128 // RankPrimary wraps GST_RANK_PRIMARY // // will be chosen first RankPrimary Rank = 256 ) func marshalRank(p unsafe.Pointer) (any, error) { return Rank(gobject.ValueFromNative(p).Enum()), nil } var _ gobject.GoValueInitializer = Rank(0) func (e Rank) InitGoValue(v *gobject.Value) { v.Init(TypeRank) v.SetEnum(int(e)) } func (e Rank) String() string { switch e { case RankMarginal: return "RankMarginal" case RankNone: return "RankNone" case RankPrimary: return "RankPrimary" case RankSecondary: return "RankSecondary" default: return fmt.Sprintf("Rank(%d)", e) } } // ResourceError wraps GstResourceError // // Resource errors are for any resource used by an element: // memory, files, network connections, process space, ... // They're typically used by source and sink elements. type ResourceError C.int const ( // ResourceErrorFailed wraps GST_RESOURCE_ERROR_FAILED // // a general error which doesn't fit in any other // category. Make sure you add a custom message to the error call. ResourceErrorFailed ResourceError = 1 // ResourceErrorTooLaZY wraps GST_RESOURCE_ERROR_TOO_LAZY // // do not use this except as a placeholder for // deciding where to go while developing code. ResourceErrorTooLaZY ResourceError = 2 // ResourceErrorNotFound wraps GST_RESOURCE_ERROR_NOT_FOUND // // used when the resource could not be found. ResourceErrorNotFound ResourceError = 3 // ResourceErrorBusy wraps GST_RESOURCE_ERROR_BUSY // // used when resource is busy. ResourceErrorBusy ResourceError = 4 // ResourceErrorOpenRead wraps GST_RESOURCE_ERROR_OPEN_READ // // used when resource fails to open for reading. ResourceErrorOpenRead ResourceError = 5 // ResourceErrorOpenWrite wraps GST_RESOURCE_ERROR_OPEN_WRITE // // used when resource fails to open for writing. ResourceErrorOpenWrite ResourceError = 6 // ResourceErrorOpenReadWrite wraps GST_RESOURCE_ERROR_OPEN_READ_WRITE // // used when resource cannot be opened for // both reading and writing, or either (but unspecified which). ResourceErrorOpenReadWrite ResourceError = 7 // ResourceErrorClose wraps GST_RESOURCE_ERROR_CLOSE // // used when the resource can't be closed. ResourceErrorClose ResourceError = 8 // ResourceErrorRead wraps GST_RESOURCE_ERROR_READ // // used when the resource can't be read from. ResourceErrorRead ResourceError = 9 // ResourceErrorWrite wraps GST_RESOURCE_ERROR_WRITE // // used when the resource can't be written to. ResourceErrorWrite ResourceError = 10 // ResourceErrorSeek wraps GST_RESOURCE_ERROR_SEEK // // used when a seek on the resource fails. ResourceErrorSeek ResourceError = 11 // ResourceErrorSync wraps GST_RESOURCE_ERROR_SYNC // // used when a synchronize on the resource fails. ResourceErrorSync ResourceError = 12 // ResourceErrorSettings wraps GST_RESOURCE_ERROR_SETTINGS // // used when settings can't be manipulated on. ResourceErrorSettings ResourceError = 13 // ResourceErrorNoSpaceLeft wraps GST_RESOURCE_ERROR_NO_SPACE_LEFT // // used when the resource has no space left. ResourceErrorNoSpaceLeft ResourceError = 14 // ResourceErrorNotAuthorized wraps GST_RESOURCE_ERROR_NOT_AUTHORIZED // // used when the resource can't be opened // due to missing authorization. // (Since: 1.2.4) ResourceErrorNotAuthorized ResourceError = 15 // ResourceErrorNumErrors wraps GST_RESOURCE_ERROR_NUM_ERRORS // // the number of resource error types. ResourceErrorNumErrors ResourceError = 16 ) func marshalResourceError(p unsafe.Pointer) (any, error) { return ResourceError(gobject.ValueFromNative(p).Enum()), nil } var _ gobject.GoValueInitializer = ResourceError(0) func (e ResourceError) InitGoValue(v *gobject.Value) { v.Init(TypeResourceError) v.SetEnum(int(e)) } func (e ResourceError) String() string { switch e { case ResourceErrorBusy: return "ResourceErrorBusy" case ResourceErrorClose: return "ResourceErrorClose" case ResourceErrorFailed: return "ResourceErrorFailed" case ResourceErrorNoSpaceLeft: return "ResourceErrorNoSpaceLeft" case ResourceErrorNotAuthorized: return "ResourceErrorNotAuthorized" case ResourceErrorNotFound: return "ResourceErrorNotFound" case ResourceErrorNumErrors: return "ResourceErrorNumErrors" case ResourceErrorOpenRead: return "ResourceErrorOpenRead" case ResourceErrorOpenReadWrite: return "ResourceErrorOpenReadWrite" case ResourceErrorOpenWrite: return "ResourceErrorOpenWrite" case ResourceErrorRead: return "ResourceErrorRead" case ResourceErrorSeek: return "ResourceErrorSeek" case ResourceErrorSettings: return "ResourceErrorSettings" case ResourceErrorSync: return "ResourceErrorSync" case ResourceErrorTooLaZY: return "ResourceErrorTooLaZY" case ResourceErrorWrite: return "ResourceErrorWrite" default: return fmt.Sprintf("ResourceError(%d)", e) } } // ResourceErrorQuark wraps gst_resource_error_quark // // The function returns the following values: // // - goret glib.Quark func ResourceErrorQuark() glib.Quark { var cret C.GQuark // return, none, casted, alias cret = C.gst_resource_error_quark() var goret glib.Quark goret = glib.Quark(cret) return goret } // SearchMode wraps GstSearchMode // // The different search modes. type SearchMode C.int const ( // SearchModeExact wraps GST_SEARCH_MODE_EXACT // // Only search for exact matches. SearchModeExact SearchMode = 0 // SearchModeBefore wraps GST_SEARCH_MODE_BEFORE // // Search for an exact match or the element just before. SearchModeBefore SearchMode = 1 // SearchModeAfter wraps GST_SEARCH_MODE_AFTER // // Search for an exact match or the element just after. SearchModeAfter SearchMode = 2 ) func marshalSearchMode(p unsafe.Pointer) (any, error) { return SearchMode(gobject.ValueFromNative(p).Enum()), nil } var _ gobject.GoValueInitializer = SearchMode(0) func (e SearchMode) InitGoValue(v *gobject.Value) { v.Init(TypeSearchMode) v.SetEnum(int(e)) } func (e SearchMode) String() string { switch e { case SearchModeAfter: return "SearchModeAfter" case SearchModeBefore: return "SearchModeBefore" case SearchModeExact: return "SearchModeExact" default: return fmt.Sprintf("SearchMode(%d)", e) } } // SeekType wraps GstSeekType // // The different types of seek events. When constructing a seek event with // gst_event_new_seek() or when doing gst_segment_do_seek (). type SeekType C.int const ( // SeekTypeNone wraps GST_SEEK_TYPE_NONE // // no change in position is required SeekTypeNone SeekType = 0 // SeekTypeSet wraps GST_SEEK_TYPE_SET // // absolute position is requested SeekTypeSet SeekType = 1 // SeekTypeEnd wraps GST_SEEK_TYPE_END // // relative position to duration is requested SeekTypeEnd SeekType = 2 ) func marshalSeekType(p unsafe.Pointer) (any, error) { return SeekType(gobject.ValueFromNative(p).Enum()), nil } var _ gobject.GoValueInitializer = SeekType(0) func (e SeekType) InitGoValue(v *gobject.Value) { v.Init(TypeSeekType) v.SetEnum(int(e)) } func (e SeekType) String() string { switch e { case SeekTypeEnd: return "SeekTypeEnd" case SeekTypeNone: return "SeekTypeNone" case SeekTypeSet: return "SeekTypeSet" default: return fmt.Sprintf("SeekType(%d)", e) } } // State wraps GstState // // The possible states an element can be in. States can be changed using // gst_element_set_state() and checked using gst_element_get_state(). type State C.int const ( // StateVoidPending wraps GST_STATE_VOID_PENDING // // no pending state. StateVoidPending State = 0 // StateNull wraps GST_STATE_NULL // // the NULL state or initial state of an element. StateNull State = 1 // StateReady wraps GST_STATE_READY // // the element is ready to go to PAUSED. StateReady State = 2 // StatePaused wraps GST_STATE_PAUSED // // the element is PAUSED, it is ready to accept and // process data. Sink elements however only accept one // buffer and then block. StatePaused State = 3 // StatePlaying wraps GST_STATE_PLAYING // // the element is PLAYING, the #GstClock is running and // the data is flowing. StatePlaying State = 4 ) func marshalState(p unsafe.Pointer) (any, error) { return State(gobject.ValueFromNative(p).Enum()), nil } var _ gobject.GoValueInitializer = State(0) func (e State) InitGoValue(v *gobject.Value) { v.Init(TypeState) v.SetEnum(int(e)) } func (e State) String() string { switch e { case StateNull: return "StateNull" case StatePaused: return "StatePaused" case StatePlaying: return "StatePlaying" case StateReady: return "StateReady" case StateVoidPending: return "StateVoidPending" default: return fmt.Sprintf("State(%d)", e) } } // StateChange wraps GstStateChange // // These are the different state changes an element goes through. // %GST_STATE_NULL &rArr; %GST_STATE_PLAYING is called an upwards state change // and %GST_STATE_PLAYING &rArr; %GST_STATE_NULL a downwards state change. type StateChange C.int const ( // StateChangeNullToReady wraps GST_STATE_CHANGE_NULL_TO_READY // // state change from NULL to READY. // * The element must check if the resources it needs are available. Device // sinks and -sources typically try to probe the device to constrain their // caps. // * The element opens the device (in case feature need to be probed). StateChangeNullToReady StateChange = 10 // StateChangeReadyToPaused wraps GST_STATE_CHANGE_READY_TO_PAUSED // // state change from READY to PAUSED. // * The element pads are activated in order to receive data in PAUSED. // Streaming threads are started. // * Some elements might need to return %GST_STATE_CHANGE_ASYNC and complete // the state change when they have enough information. It is a requirement // for sinks to return %GST_STATE_CHANGE_ASYNC and complete the state change // when they receive the first buffer or %GST_EVENT_EOS (preroll). // Sinks also block the dataflow when in PAUSED. // * A pipeline resets the running_time to 0. // * Live sources return %GST_STATE_CHANGE_NO_PREROLL and don't generate data. StateChangeReadyToPaused StateChange = 19 // StateChangePausedToPlaying wraps GST_STATE_CHANGE_PAUSED_TO_PLAYING // // state change from PAUSED to PLAYING. // * Most elements ignore this state change. // * The pipeline selects a #GstClock and distributes this to all the children // before setting them to PLAYING. This means that it is only allowed to // synchronize on the #GstClock in the PLAYING state. // * The pipeline uses the #GstClock and the running_time to calculate the // base_time. The base_time is distributed to all children when performing // the state change. // * Sink elements stop blocking on the preroll buffer or event and start // rendering the data. // * Sinks can post %GST_MESSAGE_EOS in the PLAYING state. It is not allowed // to post %GST_MESSAGE_EOS when not in the PLAYING state. // * While streaming in PAUSED or PLAYING elements can create and remove // sometimes pads. // * Live sources start generating data and return %GST_STATE_CHANGE_SUCCESS. StateChangePausedToPlaying StateChange = 28 // StateChangePlayingToPaused wraps GST_STATE_CHANGE_PLAYING_TO_PAUSED // // state change from PLAYING to PAUSED. // * Most elements ignore this state change. // * The pipeline calculates the running_time based on the last selected // #GstClock and the base_time. It stores this information to continue // playback when going back to the PLAYING state. // * Sinks unblock any #GstClock wait calls. // * When a sink does not have a pending buffer to play, it returns // #GST_STATE_CHANGE_ASYNC from this state change and completes the state // change when it receives a new buffer or an %GST_EVENT_EOS. // * Any queued %GST_MESSAGE_EOS items are removed since they will be reposted // when going back to the PLAYING state. The EOS messages are queued in // #GstBin containers. // * Live sources stop generating data and return %GST_STATE_CHANGE_NO_PREROLL. StateChangePlayingToPaused StateChange = 35 // StateChangePausedToReady wraps GST_STATE_CHANGE_PAUSED_TO_READY // // state change from PAUSED to READY. // * Sinks unblock any waits in the preroll. // * Elements unblock any waits on devices // * Chain or get_range functions return %GST_FLOW_FLUSHING. // * The element pads are deactivated so that streaming becomes impossible and // all streaming threads are stopped. // * The sink forgets all negotiated formats // * Elements remove all sometimes pads StateChangePausedToReady StateChange = 26 // StateChangeReadyToNull wraps GST_STATE_CHANGE_READY_TO_NULL // // state change from READY to NULL. // * Elements close devices // * Elements reset any internal state. StateChangeReadyToNull StateChange = 17 // StateChangeNullToNull wraps GST_STATE_CHANGE_NULL_TO_NULL // // state change from NULL to NULL. (Since: 1.14) StateChangeNullToNull StateChange = 9 // StateChangeReadyToReady wraps GST_STATE_CHANGE_READY_TO_READY // // state change from READY to READY, // This might happen when going to PAUSED asynchronously failed, in that case // elements should make sure they are in a proper, coherent READY state. (Since: 1.14) StateChangeReadyToReady StateChange = 18 // StateChangePausedToPaused wraps GST_STATE_CHANGE_PAUSED_TO_PAUSED // // state change from PAUSED to PAUSED. // This might happen when elements were in PLAYING state and 'lost state', // they should make sure to go back to real 'PAUSED' state (prerolling for example). (Since: 1.14) StateChangePausedToPaused StateChange = 27 // StateChangePlayingToPlaying wraps GST_STATE_CHANGE_PLAYING_TO_PLAYING // // state change from PLAYING to PLAYING. (Since: 1.14) StateChangePlayingToPlaying StateChange = 36 ) func marshalStateChange(p unsafe.Pointer) (any, error) { return StateChange(gobject.ValueFromNative(p).Enum()), nil } var _ gobject.GoValueInitializer = StateChange(0) func (e StateChange) InitGoValue(v *gobject.Value) { v.Init(TypeStateChange) v.SetEnum(int(e)) } func (e StateChange) String() string { switch e { case StateChangeNullToNull: return "StateChangeNullToNull" case StateChangeNullToReady: return "StateChangeNullToReady" case StateChangePausedToPaused: return "StateChangePausedToPaused" case StateChangePausedToPlaying: return "StateChangePausedToPlaying" case StateChangePausedToReady: return "StateChangePausedToReady" case StateChangePlayingToPaused: return "StateChangePlayingToPaused" case StateChangePlayingToPlaying: return "StateChangePlayingToPlaying" case StateChangeReadyToNull: return "StateChangeReadyToNull" case StateChangeReadyToPaused: return "StateChangeReadyToPaused" case StateChangeReadyToReady: return "StateChangeReadyToReady" default: return fmt.Sprintf("StateChange(%d)", e) } } // StateChangeGetName wraps gst_state_change_get_name // // The function takes the following parameters: // // - transition StateChange: a #GstStateChange to get the name of. // // The function returns the following values: // // - goret string // // Gets a string representing the given state transition. func StateChangeGetName(transition StateChange) string { var carg1 C.GstStateChange // in, none, casted var cret *C.gchar // return, none, string carg1 = C.GstStateChange(transition) cret = C.gst_state_change_get_name(carg1) runtime.KeepAlive(transition) var goret string goret = C.GoString((*C.char)(unsafe.Pointer(cret))) return goret } // StateChangeReturn wraps GstStateChangeReturn // // The possible return values from a state change function such as // gst_element_set_state(). Only @GST_STATE_CHANGE_FAILURE is a real failure. type StateChangeReturn C.int const ( // StateChangeFailure wraps GST_STATE_CHANGE_FAILURE // // the state change failed StateChangeFailure StateChangeReturn = 0 // StateChangeSuccess wraps GST_STATE_CHANGE_SUCCESS // // the state change succeeded StateChangeSuccess StateChangeReturn = 1 // StateChangeAsync wraps GST_STATE_CHANGE_ASYNC // // the state change will happen asynchronously StateChangeAsync StateChangeReturn = 2 // StateChangeNoPreroll wraps GST_STATE_CHANGE_NO_PREROLL // // the state change succeeded but the element // cannot produce data in %GST_STATE_PAUSED. // This typically happens with live sources. StateChangeNoPreroll StateChangeReturn = 3 ) func marshalStateChangeReturn(p unsafe.Pointer) (any, error) { return StateChangeReturn(gobject.ValueFromNative(p).Enum()), nil } var _ gobject.GoValueInitializer = StateChangeReturn(0) func (e StateChangeReturn) InitGoValue(v *gobject.Value) { v.Init(TypeStateChangeReturn) v.SetEnum(int(e)) } func (e StateChangeReturn) String() string { switch e { case StateChangeAsync: return "StateChangeAsync" case StateChangeFailure: return "StateChangeFailure" case StateChangeNoPreroll: return "StateChangeNoPreroll" case StateChangeSuccess: return "StateChangeSuccess" default: return fmt.Sprintf("StateChangeReturn(%d)", e) } } // StreamError wraps GstStreamError // // Stream errors are for anything related to the stream being processed: // format errors, media type errors, ... // They're typically used by decoders, demuxers, converters, ... type StreamError C.int const ( // StreamErrorFailed wraps GST_STREAM_ERROR_FAILED // // a general error which doesn't fit in any other // category. Make sure you add a custom message to the error call. StreamErrorFailed StreamError = 1 // StreamErrorTooLaZY wraps GST_STREAM_ERROR_TOO_LAZY // // do not use this except as a placeholder for // deciding where to go while developing code. StreamErrorTooLaZY StreamError = 2 // StreamErrorNotImplemented wraps GST_STREAM_ERROR_NOT_IMPLEMENTED // // use this when you do not want to implement // this functionality yet. StreamErrorNotImplemented StreamError = 3 // StreamErrorTypeNotFound wraps GST_STREAM_ERROR_TYPE_NOT_FOUND // // used when the element doesn't know the // stream's type. StreamErrorTypeNotFound StreamError = 4 // StreamErrorWrongType wraps GST_STREAM_ERROR_WRONG_TYPE // // used when the element doesn't handle this type // of stream. StreamErrorWrongType StreamError = 5 // StreamErrorCodecNotFound wraps GST_STREAM_ERROR_CODEC_NOT_FOUND // // used when there's no codec to handle the // stream's type. StreamErrorCodecNotFound StreamError = 6 // StreamErrorDecode wraps GST_STREAM_ERROR_DECODE // // used when decoding fails. StreamErrorDecode StreamError = 7 // StreamErrorEncode wraps GST_STREAM_ERROR_ENCODE // // used when encoding fails. StreamErrorEncode StreamError = 8 // StreamErrorDemux wraps GST_STREAM_ERROR_DEMUX // // used when demuxing fails. StreamErrorDemux StreamError = 9 // StreamErrorMux wraps GST_STREAM_ERROR_MUX // // used when muxing fails. StreamErrorMux StreamError = 10 // StreamErrorFormat wraps GST_STREAM_ERROR_FORMAT // // used when the stream is of the wrong format // (for example, wrong caps). StreamErrorFormat StreamError = 11 // StreamErrorDecrypt wraps GST_STREAM_ERROR_DECRYPT // // used when the stream is encrypted and can't be // decrypted because this is not supported by the element. StreamErrorDecrypt StreamError = 12 // StreamErrorDecryptNokey wraps GST_STREAM_ERROR_DECRYPT_NOKEY // // used when the stream is encrypted and // can't be decrypted because no suitable key is available. StreamErrorDecryptNokey StreamError = 13 // StreamErrorNumErrors wraps GST_STREAM_ERROR_NUM_ERRORS // // the number of stream error types. StreamErrorNumErrors StreamError = 14 ) func marshalStreamError(p unsafe.Pointer) (any, error) { return StreamError(gobject.ValueFromNative(p).Enum()), nil } var _ gobject.GoValueInitializer = StreamError(0) func (e StreamError) InitGoValue(v *gobject.Value) { v.Init(TypeStreamError) v.SetEnum(int(e)) } func (e StreamError) String() string { switch e { case StreamErrorCodecNotFound: return "StreamErrorCodecNotFound" case StreamErrorDecode: return "StreamErrorDecode" case StreamErrorDecrypt: return "StreamErrorDecrypt" case StreamErrorDecryptNokey: return "StreamErrorDecryptNokey" case StreamErrorDemux: return "StreamErrorDemux" case StreamErrorEncode: return "StreamErrorEncode" case StreamErrorFailed: return "StreamErrorFailed" case StreamErrorFormat: return "StreamErrorFormat" case StreamErrorMux: return "StreamErrorMux" case StreamErrorNotImplemented: return "StreamErrorNotImplemented" case StreamErrorNumErrors: return "StreamErrorNumErrors" case StreamErrorTooLaZY: return "StreamErrorTooLaZY" case StreamErrorTypeNotFound: return "StreamErrorTypeNotFound" case StreamErrorWrongType: return "StreamErrorWrongType" default: return fmt.Sprintf("StreamError(%d)", e) } } // StreamErrorQuark wraps gst_stream_error_quark // // The function returns the following values: // // - goret glib.Quark func StreamErrorQuark() glib.Quark { var cret C.GQuark // return, none, casted, alias cret = C.gst_stream_error_quark() var goret glib.Quark goret = glib.Quark(cret) return goret } // StreamStatusType wraps GstStreamStatusType // // The type of a %GST_MESSAGE_STREAM_STATUS. The stream status messages inform the // application of new streaming threads and their status. type StreamStatusType C.int const ( // StreamStatusTypeCreate wraps GST_STREAM_STATUS_TYPE_CREATE // // A new thread need to be created. StreamStatusTypeCreate StreamStatusType = 0 // StreamStatusTypeEnter wraps GST_STREAM_STATUS_TYPE_ENTER // // a thread entered its loop function StreamStatusTypeEnter StreamStatusType = 1 // StreamStatusTypeLeave wraps GST_STREAM_STATUS_TYPE_LEAVE // // a thread left its loop function StreamStatusTypeLeave StreamStatusType = 2 // StreamStatusTypeDestroy wraps GST_STREAM_STATUS_TYPE_DESTROY // // a thread is destroyed StreamStatusTypeDestroy StreamStatusType = 3 // StreamStatusTypeStart wraps GST_STREAM_STATUS_TYPE_START // // a thread is started StreamStatusTypeStart StreamStatusType = 8 // StreamStatusTypePause wraps GST_STREAM_STATUS_TYPE_PAUSE // // a thread is paused StreamStatusTypePause StreamStatusType = 9 // StreamStatusTypeStop wraps GST_STREAM_STATUS_TYPE_STOP // // a thread is stopped StreamStatusTypeStop StreamStatusType = 10 ) func marshalStreamStatusType(p unsafe.Pointer) (any, error) { return StreamStatusType(gobject.ValueFromNative(p).Enum()), nil } var _ gobject.GoValueInitializer = StreamStatusType(0) func (e StreamStatusType) InitGoValue(v *gobject.Value) { v.Init(TypeStreamStatusType) v.SetEnum(int(e)) } func (e StreamStatusType) String() string { switch e { case StreamStatusTypeCreate: return "StreamStatusTypeCreate" case StreamStatusTypeDestroy: return "StreamStatusTypeDestroy" case StreamStatusTypeEnter: return "StreamStatusTypeEnter" case StreamStatusTypeLeave: return "StreamStatusTypeLeave" case StreamStatusTypePause: return "StreamStatusTypePause" case StreamStatusTypeStart: return "StreamStatusTypeStart" case StreamStatusTypeStop: return "StreamStatusTypeStop" default: return fmt.Sprintf("StreamStatusType(%d)", e) } } // StructureChangeType wraps GstStructureChangeType // // The type of a %GST_MESSAGE_STRUCTURE_CHANGE. type StructureChangeType C.int const ( // StructureChangeTypePadLink wraps GST_STRUCTURE_CHANGE_TYPE_PAD_LINK // // Pad linking is starting or done. StructureChangeTypePadLink StructureChangeType = 0 // StructureChangeTypePadUnlink wraps GST_STRUCTURE_CHANGE_TYPE_PAD_UNLINK // // Pad unlinking is starting or done. StructureChangeTypePadUnlink StructureChangeType = 1 ) func marshalStructureChangeType(p unsafe.Pointer) (any, error) { return StructureChangeType(gobject.ValueFromNative(p).Enum()), nil } var _ gobject.GoValueInitializer = StructureChangeType(0) func (e StructureChangeType) InitGoValue(v *gobject.Value) { v.Init(TypeStructureChangeType) v.SetEnum(int(e)) } func (e StructureChangeType) String() string { switch e { case StructureChangeTypePadLink: return "StructureChangeTypePadLink" case StructureChangeTypePadUnlink: return "StructureChangeTypePadUnlink" default: return fmt.Sprintf("StructureChangeType(%d)", e) } } // TagFlag wraps GstTagFlag // // Extra tag flags used when registering tags. type TagFlag C.int const ( // TagFlagUndefined wraps GST_TAG_FLAG_UNDEFINED // // undefined flag TagFlagUndefined TagFlag = 0 // TagFlagMeta wraps GST_TAG_FLAG_META // // tag is meta data TagFlagMeta TagFlag = 1 // TagFlagEncoded wraps GST_TAG_FLAG_ENCODED // // tag is encoded TagFlagEncoded TagFlag = 2 // TagFlagDecoded wraps GST_TAG_FLAG_DECODED // // tag is decoded TagFlagDecoded TagFlag = 3 // TagFlagCount wraps GST_TAG_FLAG_COUNT // // number of tag flags TagFlagCount TagFlag = 4 ) func marshalTagFlag(p unsafe.Pointer) (any, error) { return TagFlag(gobject.ValueFromNative(p).Enum()), nil } var _ gobject.GoValueInitializer = TagFlag(0) func (e TagFlag) InitGoValue(v *gobject.Value) { v.Init(TypeTagFlag) v.SetEnum(int(e)) } func (e TagFlag) String() string { switch e { case TagFlagCount: return "TagFlagCount" case TagFlagDecoded: return "TagFlagDecoded" case TagFlagEncoded: return "TagFlagEncoded" case TagFlagMeta: return "TagFlagMeta" case TagFlagUndefined: return "TagFlagUndefined" default: return fmt.Sprintf("TagFlag(%d)", e) } } // TagMergeMode wraps GstTagMergeMode // // The different tag merging modes are basically replace, overwrite and append, // but they can be seen from two directions. Given two taglists: (A) the tags // already in the element and (B) the ones that are supplied to the element ( // e.g. via gst_tag_setter_merge_tags() / gst_tag_setter_add_tags() or a // %GST_EVENT_TAG), how are these tags merged? // In the table below this is shown for the cases that a tag exists in the list // (A) or does not exists (!A) and combinations thereof. // // | merge mode | A + B | A + !B | !A + B | !A + !B | // | ----------- | ----- | ------ | ------ | ------- | // | REPLACE_ALL | B | ø | B | ø | // | REPLACE | B | A | B | ø | // | APPEND | A, B | A | B | ø | // | PREPEND | B, A | A | B | ø | // | KEEP | A | A | B | ø | // | KEEP_ALL | A | A | ø | ø | type TagMergeMode C.int const ( // TagMergeUndefined wraps GST_TAG_MERGE_UNDEFINED // // undefined merge mode TagMergeUndefined TagMergeMode = 0 // TagMergeReplaceAll wraps GST_TAG_MERGE_REPLACE_ALL // // replace all tags (clear list and append) TagMergeReplaceAll TagMergeMode = 1 // TagMergeReplace wraps GST_TAG_MERGE_REPLACE // // replace tags TagMergeReplace TagMergeMode = 2 // TagMergeAppend wraps GST_TAG_MERGE_APPEND // // append tags TagMergeAppend TagMergeMode = 3 // TagMergePrepend wraps GST_TAG_MERGE_PREPEND // // prepend tags TagMergePrepend TagMergeMode = 4 // TagMergeKeep wraps GST_TAG_MERGE_KEEP // // keep existing tags TagMergeKeep TagMergeMode = 5 // TagMergeKeepAll wraps GST_TAG_MERGE_KEEP_ALL // // keep all existing tags TagMergeKeepAll TagMergeMode = 6 // TagMergeCount wraps GST_TAG_MERGE_COUNT // // the number of merge modes TagMergeCount TagMergeMode = 7 ) func marshalTagMergeMode(p unsafe.Pointer) (any, error) { return TagMergeMode(gobject.ValueFromNative(p).Enum()), nil } var _ gobject.GoValueInitializer = TagMergeMode(0) func (e TagMergeMode) InitGoValue(v *gobject.Value) { v.Init(TypeTagMergeMode) v.SetEnum(int(e)) } func (e TagMergeMode) String() string { switch e { case TagMergeAppend: return "TagMergeAppend" case TagMergeCount: return "TagMergeCount" case TagMergeKeep: return "TagMergeKeep" case TagMergeKeepAll: return "TagMergeKeepAll" case TagMergePrepend: return "TagMergePrepend" case TagMergeReplace: return "TagMergeReplace" case TagMergeReplaceAll: return "TagMergeReplaceAll" case TagMergeUndefined: return "TagMergeUndefined" default: return fmt.Sprintf("TagMergeMode(%d)", e) } } // TagScope wraps GstTagScope // // GstTagScope specifies if a taglist applies to the complete // medium or only to one single stream. type TagScope C.int const ( // TagScopeStream wraps GST_TAG_SCOPE_STREAM // // tags specific to this single stream TagScopeStream TagScope = 0 // TagScopeGlobal wraps GST_TAG_SCOPE_GLOBAL // // global tags for the complete medium TagScopeGlobal TagScope = 1 ) func marshalTagScope(p unsafe.Pointer) (any, error) { return TagScope(gobject.ValueFromNative(p).Enum()), nil } var _ gobject.GoValueInitializer = TagScope(0) func (e TagScope) InitGoValue(v *gobject.Value) { v.Init(TypeTagScope) v.SetEnum(int(e)) } func (e TagScope) String() string { switch e { case TagScopeGlobal: return "TagScopeGlobal" case TagScopeStream: return "TagScopeStream" default: return fmt.Sprintf("TagScope(%d)", e) } } // TaskState wraps GstTaskState // // The different states a task can be in type TaskState C.int const ( // TaskStarted wraps GST_TASK_STARTED // // the task is started and running TaskStarted TaskState = 0 // TaskStopped wraps GST_TASK_STOPPED // // the task is stopped TaskStopped TaskState = 1 // TaskPaused wraps GST_TASK_PAUSED // // the task is paused TaskPaused TaskState = 2 ) func marshalTaskState(p unsafe.Pointer) (any, error) { return TaskState(gobject.ValueFromNative(p).Enum()), nil } var _ gobject.GoValueInitializer = TaskState(0) func (e TaskState) InitGoValue(v *gobject.Value) { v.Init(TypeTaskState) v.SetEnum(int(e)) } func (e TaskState) String() string { switch e { case TaskPaused: return "TaskPaused" case TaskStarted: return "TaskStarted" case TaskStopped: return "TaskStopped" default: return fmt.Sprintf("TaskState(%d)", e) } } // TocEntryType wraps GstTocEntryType // // The different types of TOC entries (see #GstTocEntry). // // There are two types of TOC entries: alternatives or parts in a sequence. type TocEntryType C.int const ( // TocEntryTypeAngle wraps GST_TOC_ENTRY_TYPE_ANGLE // // entry is an angle (i.e. an alternative) TocEntryTypeAngle TocEntryType = -3 // TocEntryTypeVersion wraps GST_TOC_ENTRY_TYPE_VERSION // // entry is a version (i.e. alternative) TocEntryTypeVersion TocEntryType = -2 // TocEntryTypeEdition wraps GST_TOC_ENTRY_TYPE_EDITION // // entry is an edition (i.e. alternative) TocEntryTypeEdition TocEntryType = -1 // TocEntryTypeInvalid wraps GST_TOC_ENTRY_TYPE_INVALID // // invalid entry type value TocEntryTypeInvalid TocEntryType = 0 // TocEntryTypeTitle wraps GST_TOC_ENTRY_TYPE_TITLE // // entry is a title (i.e. a part of a sequence) TocEntryTypeTitle TocEntryType = 1 // TocEntryTypeTrack wraps GST_TOC_ENTRY_TYPE_TRACK // // entry is a track (i.e. a part of a sequence) TocEntryTypeTrack TocEntryType = 2 // TocEntryTypeChapter wraps GST_TOC_ENTRY_TYPE_CHAPTER // // entry is a chapter (i.e. a part of a sequence) TocEntryTypeChapter TocEntryType = 3 ) func marshalTocEntryType(p unsafe.Pointer) (any, error) { return TocEntryType(gobject.ValueFromNative(p).Enum()), nil } var _ gobject.GoValueInitializer = TocEntryType(0) func (e TocEntryType) InitGoValue(v *gobject.Value) { v.Init(TypeTocEntryType) v.SetEnum(int(e)) } func (e TocEntryType) String() string { switch e { case TocEntryTypeAngle: return "TocEntryTypeAngle" case TocEntryTypeChapter: return "TocEntryTypeChapter" case TocEntryTypeEdition: return "TocEntryTypeEdition" case TocEntryTypeInvalid: return "TocEntryTypeInvalid" case TocEntryTypeTitle: return "TocEntryTypeTitle" case TocEntryTypeTrack: return "TocEntryTypeTrack" case TocEntryTypeVersion: return "TocEntryTypeVersion" default: return fmt.Sprintf("TocEntryType(%d)", e) } } // TocEntryTypeGetNick wraps gst_toc_entry_type_get_nick // // The function takes the following parameters: // // - typ TocEntryType: a #GstTocEntryType. // // The function returns the following values: // // - goret string // // Converts @type to a string representation. func TocEntryTypeGetNick(typ TocEntryType) string { var carg1 C.GstTocEntryType // in, none, casted var cret *C.gchar // return, none, string carg1 = C.GstTocEntryType(typ) cret = C.gst_toc_entry_type_get_nick(carg1) runtime.KeepAlive(typ) var goret string goret = C.GoString((*C.char)(unsafe.Pointer(cret))) return goret } // TocLoopType wraps GstTocLoopType // // How a #GstTocEntry should be repeated. By default, entries are played a // single time. type TocLoopType C.int const ( // TocLoopNone wraps GST_TOC_LOOP_NONE // // single forward playback TocLoopNone TocLoopType = 0 // TocLoopForward wraps GST_TOC_LOOP_FORWARD // // repeat forward TocLoopForward TocLoopType = 1 // TocLoopReverse wraps GST_TOC_LOOP_REVERSE // // repeat backward TocLoopReverse TocLoopType = 2 // TocLoopPingPong wraps GST_TOC_LOOP_PING_PONG // // repeat forward and backward TocLoopPingPong TocLoopType = 3 ) func marshalTocLoopType(p unsafe.Pointer) (any, error) { return TocLoopType(gobject.ValueFromNative(p).Enum()), nil } var _ gobject.GoValueInitializer = TocLoopType(0) func (e TocLoopType) InitGoValue(v *gobject.Value) { v.Init(TypeTocLoopType) v.SetEnum(int(e)) } func (e TocLoopType) String() string { switch e { case TocLoopForward: return "TocLoopForward" case TocLoopNone: return "TocLoopNone" case TocLoopPingPong: return "TocLoopPingPong" case TocLoopReverse: return "TocLoopReverse" default: return fmt.Sprintf("TocLoopType(%d)", e) } } // TocScope wraps GstTocScope // // The scope of a TOC. type TocScope C.int const ( // TocScopeGlobal wraps GST_TOC_SCOPE_GLOBAL // // global TOC representing all selectable options // (this is what applications are usually interested in) TocScopeGlobal TocScope = 1 // TocScopeCurrent wraps GST_TOC_SCOPE_CURRENT // // TOC for the currently active/selected stream // (this is a TOC representing the current stream from start to EOS, // and is what a TOC writer / muxer is usually interested in; it will // usually be a subset of the global TOC, e.g. just the chapters of // the current title, or the chapters selected for playback from the // current title) TocScopeCurrent TocScope = 2 ) func marshalTocScope(p unsafe.Pointer) (any, error) { return TocScope(gobject.ValueFromNative(p).Enum()), nil } var _ gobject.GoValueInitializer = TocScope(0) func (e TocScope) InitGoValue(v *gobject.Value) { v.Init(TypeTocScope) v.SetEnum(int(e)) } func (e TocScope) String() string { switch e { case TocScopeCurrent: return "TocScopeCurrent" case TocScopeGlobal: return "TocScopeGlobal" default: return fmt.Sprintf("TocScope(%d)", e) } } // TracerValueScope wraps GstTracerValueScope // // Tracing record will contain fields that contain a measured value or extra // meta-data. One such meta data are values that tell where a measurement was // taken. This enumerating declares to which scope such a meta data field // relates to. If it is e.g. %GST_TRACER_VALUE_SCOPE_PAD, then each of the log // events may contain values for different #GstPads. type TracerValueScope C.int const ( // TracerValueScopeProcess wraps GST_TRACER_VALUE_SCOPE_PROCESS // // the value is related to the process TracerValueScopeProcess TracerValueScope = 0 // TracerValueScopeThread wraps GST_TRACER_VALUE_SCOPE_THREAD // // the value is related to a thread TracerValueScopeThread TracerValueScope = 1 // TracerValueScopeElement wraps GST_TRACER_VALUE_SCOPE_ELEMENT // // the value is related to an #GstElement TracerValueScopeElement TracerValueScope = 2 // TracerValueScopePad wraps GST_TRACER_VALUE_SCOPE_PAD // // the value is related to a #GstPad TracerValueScopePad TracerValueScope = 3 ) func marshalTracerValueScope(p unsafe.Pointer) (any, error) { return TracerValueScope(gobject.ValueFromNative(p).Enum()), nil } var _ gobject.GoValueInitializer = TracerValueScope(0) func (e TracerValueScope) InitGoValue(v *gobject.Value) { v.Init(TypeTracerValueScope) v.SetEnum(int(e)) } func (e TracerValueScope) String() string { switch e { case TracerValueScopeElement: return "TracerValueScopeElement" case TracerValueScopePad: return "TracerValueScopePad" case TracerValueScopeProcess: return "TracerValueScopeProcess" case TracerValueScopeThread: return "TracerValueScopeThread" default: return fmt.Sprintf("TracerValueScope(%d)", e) } } // TypeFindProbability wraps GstTypeFindProbability // // The probability of the typefind function. Higher values have more certainty // in doing a reliable typefind. type TypeFindProbability C.int const ( // TypeFindNone wraps GST_TYPE_FIND_NONE // // type undetected. TypeFindNone TypeFindProbability = 0 // TypeFindMinimum wraps GST_TYPE_FIND_MINIMUM // // unlikely typefind. TypeFindMinimum TypeFindProbability = 1 // TypeFindPossible wraps GST_TYPE_FIND_POSSIBLE // // possible type detected. TypeFindPossible TypeFindProbability = 50 // TypeFindLikely wraps GST_TYPE_FIND_LIKELY // // likely a type was detected. TypeFindLikely TypeFindProbability = 80 // TypeFindNearlyCertain wraps GST_TYPE_FIND_NEARLY_CERTAIN // // nearly certain that a type was detected. TypeFindNearlyCertain TypeFindProbability = 99 // TypeFindMaximum wraps GST_TYPE_FIND_MAXIMUM // // very certain a type was detected. TypeFindMaximum TypeFindProbability = 100 ) func marshalTypeFindProbability(p unsafe.Pointer) (any, error) { return TypeFindProbability(gobject.ValueFromNative(p).Enum()), nil } var _ gobject.GoValueInitializer = TypeFindProbability(0) func (e TypeFindProbability) InitGoValue(v *gobject.Value) { v.Init(TypeTypeFindProbability) v.SetEnum(int(e)) } func (e TypeFindProbability) String() string { switch e { case TypeFindLikely: return "TypeFindLikely" case TypeFindMaximum: return "TypeFindMaximum" case TypeFindMinimum: return "TypeFindMinimum" case TypeFindNearlyCertain: return "TypeFindNearlyCertain" case TypeFindNone: return "TypeFindNone" case TypeFindPossible: return "TypeFindPossible" default: return fmt.Sprintf("TypeFindProbability(%d)", e) } } // URIError wraps GstURIError // // Different URI-related errors that can occur. type URIError C.int const ( // URIErrorUnsupportedProtocol wraps GST_URI_ERROR_UNSUPPORTED_PROTOCOL // // The protocol is not supported URIErrorUnsupportedProtocol URIError = 0 // URIErrorBadURI wraps GST_URI_ERROR_BAD_URI // // There was a problem with the URI URIErrorBadURI URIError = 1 // URIErrorBadState wraps GST_URI_ERROR_BAD_STATE // // Could not set or change the URI because the // URI handler was in a state where that is not possible or not permitted URIErrorBadState URIError = 2 // URIErrorBadReference wraps GST_URI_ERROR_BAD_REFERENCE // // There was a problem with the entity that // the URI references URIErrorBadReference URIError = 3 ) func marshalURIError(p unsafe.Pointer) (any, error) { return URIError(gobject.ValueFromNative(p).Enum()), nil } var _ gobject.GoValueInitializer = URIError(0) func (e URIError) InitGoValue(v *gobject.Value) { v.Init(TypeURIError) v.SetEnum(int(e)) } func (e URIError) String() string { switch e { case URIErrorBadReference: return "URIErrorBadReference" case URIErrorBadState: return "URIErrorBadState" case URIErrorBadURI: return "URIErrorBadURI" case URIErrorUnsupportedProtocol: return "URIErrorUnsupportedProtocol" default: return fmt.Sprintf("URIError(%d)", e) } } // URIErrorQuark wraps gst_uri_error_quark // // The function returns the following values: // // - goret glib.Quark func URIErrorQuark() glib.Quark { var cret C.GQuark // return, none, casted, alias cret = C.gst_uri_error_quark() var goret glib.Quark goret = glib.Quark(cret) return goret } // URIType wraps GstURIType // // The different types of URI direction. type URIType C.int const ( // URIUnknown wraps GST_URI_UNKNOWN // // The URI direction is unknown URIUnknown URIType = 0 // URISink wraps GST_URI_SINK // // The URI is a consumer. URISink URIType = 1 // URISrc wraps GST_URI_SRC // // The URI is a producer. URISrc URIType = 2 ) func marshalURIType(p unsafe.Pointer) (any, error) { return URIType(gobject.ValueFromNative(p).Enum()), nil } var _ gobject.GoValueInitializer = URIType(0) func (e URIType) InitGoValue(v *gobject.Value) { v.Init(TypeURIType) v.SetEnum(int(e)) } func (e URIType) String() string { switch e { case URISink: return "URISink" case URISrc: return "URISrc" case URIUnknown: return "URIUnknown" default: return fmt.Sprintf("URIType(%d)", e) } } // AllocatorFlags wraps GstAllocatorFlags // // Flags for allocators. type AllocatorFlags C.gint const ( // AllocatorFlagCustomAlloc wraps GST_ALLOCATOR_FLAG_CUSTOM_ALLOC // // The allocator has a custom alloc function. // Only elements designed to work with this allocator should be using it, // other elements should ignore it from allocation propositions. // This implies %GST_ALLOCATOR_FLAG_NO_COPY. AllocatorFlagCustomAlloc AllocatorFlags = 16 // AllocatorFlagNoCopy wraps GST_ALLOCATOR_FLAG_NO_COPY // // When copying a #GstMemory allocated with this allocator, the copy will // instead be allocated using the default allocator. Use this when allocating a // new memory is an heavy opperation that should only be done with a // #GstBufferPool for example. AllocatorFlagNoCopy AllocatorFlags = 32 // AllocatorFlagLast wraps GST_ALLOCATOR_FLAG_LAST // // first flag that can be used for custom purposes AllocatorFlagLast AllocatorFlags = 1048576 ) func marshalAllocatorFlags(p unsafe.Pointer) (any, error) { return AllocatorFlags(gobject.ValueFromNative(p).Flags()), nil } // Has returns true if a contains other func (a AllocatorFlags) Has(other AllocatorFlags) bool { return (a & other) == other } var _ gobject.GoValueInitializer = AllocatorFlags(0) func (f AllocatorFlags) InitGoValue(v *gobject.Value) { v.Init(TypeAllocatorFlags) v.SetFlags(int(f)) } func (f AllocatorFlags) String() string { if f == 0 { return "AllocatorFlags(0)" } var parts []string if (f & AllocatorFlagCustomAlloc) != 0 { parts = append(parts, "AllocatorFlagCustomAlloc") } if (f & AllocatorFlagNoCopy) != 0 { parts = append(parts, "AllocatorFlagNoCopy") } if (f & AllocatorFlagLast) != 0 { parts = append(parts, "AllocatorFlagLast") } return "AllocatorFlags(" + strings.Join(parts, "|") + ")" } // BinFlags wraps GstBinFlags // // GstBinFlags are a set of flags specific to bins. Most are set/used // internally. They can be checked using the GST_OBJECT_FLAG_IS_SET() macro, // and (un)set using GST_OBJECT_FLAG_SET() and GST_OBJECT_FLAG_UNSET(). type BinFlags C.gint const ( // BinFlagNoResync wraps GST_BIN_FLAG_NO_RESYNC // // Don't resync a state change when elements are added or linked in the bin BinFlagNoResync BinFlags = 16384 // BinFlagStreamsAware wraps GST_BIN_FLAG_STREAMS_AWARE // // Indicates whether the bin can handle elements that add/remove source pads // at any point in time without first posting a no-more-pads signal. BinFlagStreamsAware BinFlags = 32768 // BinFlagLast wraps GST_BIN_FLAG_LAST // // The last enum in the series of flags for bins. Derived classes can use this // as first value in a list of flags. BinFlagLast BinFlags = 524288 ) func marshalBinFlags(p unsafe.Pointer) (any, error) { return BinFlags(gobject.ValueFromNative(p).Flags()), nil } // Has returns true if b contains other func (b BinFlags) Has(other BinFlags) bool { return (b & other) == other } var _ gobject.GoValueInitializer = BinFlags(0) func (f BinFlags) InitGoValue(v *gobject.Value) { v.Init(TypeBinFlags) v.SetFlags(int(f)) } func (f BinFlags) String() string { if f == 0 { return "BinFlags(0)" } var parts []string if (f & BinFlagNoResync) != 0 { parts = append(parts, "BinFlagNoResync") } if (f & BinFlagStreamsAware) != 0 { parts = append(parts, "BinFlagStreamsAware") } if (f & BinFlagLast) != 0 { parts = append(parts, "BinFlagLast") } return "BinFlags(" + strings.Join(parts, "|") + ")" } // BufferCopyFlagsType wraps GstBufferCopyFlags // // A set of flags that can be provided to the gst_buffer_copy_into() // function to specify which items should be copied. // // This type has been renamed from BufferCopyFlags. type BufferCopyFlagsType C.gint const ( // BufferCopyNone wraps GST_BUFFER_COPY_NONE // // copy nothing BufferCopyNone BufferCopyFlagsType = 0 // BufferCopyFlags wraps GST_BUFFER_COPY_FLAGS // // flag indicating that buffer flags should be copied BufferCopyFlags BufferCopyFlagsType = 1 // BufferCopyTimestamps wraps GST_BUFFER_COPY_TIMESTAMPS // // flag indicating that buffer pts, dts, // duration, offset and offset_end should be copied BufferCopyTimestamps BufferCopyFlagsType = 2 // BufferCopyMeta wraps GST_BUFFER_COPY_META // // flag indicating that buffer meta should be // copied BufferCopyMeta BufferCopyFlagsType = 4 // BufferCopyMemory wraps GST_BUFFER_COPY_MEMORY // // flag indicating that buffer memory should be reffed // and appended to already existing memory. Unless the memory is marked as // NO_SHARE, no actual copy of the memory is made but it is simply reffed. // Add @GST_BUFFER_COPY_DEEP to force a real copy. BufferCopyMemory BufferCopyFlagsType = 8 // BufferCopyMerge wraps GST_BUFFER_COPY_MERGE // // flag indicating that buffer memory should be // merged BufferCopyMerge BufferCopyFlagsType = 16 // BufferCopyDeep wraps GST_BUFFER_COPY_DEEP // // flag indicating that memory should always be copied instead of reffed BufferCopyDeep BufferCopyFlagsType = 32 ) func marshalBufferCopyFlagsType(p unsafe.Pointer) (any, error) { return BufferCopyFlagsType(gobject.ValueFromNative(p).Flags()), nil } // Has returns true if b contains other func (b BufferCopyFlagsType) Has(other BufferCopyFlagsType) bool { return (b & other) == other } var _ gobject.GoValueInitializer = BufferCopyFlagsType(0) func (f BufferCopyFlagsType) InitGoValue(v *gobject.Value) { v.Init(TypeBufferCopyFlagsType) v.SetFlags(int(f)) } func (f BufferCopyFlagsType) String() string { if f == 0 { return "BufferCopyFlagsType(0)" } var parts []string if (f & BufferCopyNone) != 0 { parts = append(parts, "BufferCopyNone") } if (f & BufferCopyFlags) != 0 { parts = append(parts, "BufferCopyFlags") } if (f & BufferCopyTimestamps) != 0 { parts = append(parts, "BufferCopyTimestamps") } if (f & BufferCopyMeta) != 0 { parts = append(parts, "BufferCopyMeta") } if (f & BufferCopyMemory) != 0 { parts = append(parts, "BufferCopyMemory") } if (f & BufferCopyMerge) != 0 { parts = append(parts, "BufferCopyMerge") } if (f & BufferCopyDeep) != 0 { parts = append(parts, "BufferCopyDeep") } return "BufferCopyFlagsType(" + strings.Join(parts, "|") + ")" } // BufferFlags wraps GstBufferFlags // // A set of buffer flags used to describe properties of a #GstBuffer. type BufferFlags C.gint const ( // BufferFlagLive wraps GST_BUFFER_FLAG_LIVE // // the buffer is live data and should be discarded in // the PAUSED state. BufferFlagLive BufferFlags = 16 // BufferFlagDecodeOnly wraps GST_BUFFER_FLAG_DECODE_ONLY // // the buffer contains data that should be dropped // because it will be clipped against the segment // boundaries or because it does not contain data // that should be shown to the user. BufferFlagDecodeOnly BufferFlags = 32 // BufferFlagDiscont wraps GST_BUFFER_FLAG_DISCONT // // the buffer marks a data discontinuity in the stream. // This typically occurs after a seek or a dropped buffer // from a live or network source. BufferFlagDiscont BufferFlags = 64 // BufferFlagResync wraps GST_BUFFER_FLAG_RESYNC // // the buffer timestamps might have a discontinuity // and this buffer is a good point to resynchronize. BufferFlagResync BufferFlags = 128 // BufferFlagCorrupted wraps GST_BUFFER_FLAG_CORRUPTED // // the buffer data is corrupted. BufferFlagCorrupted BufferFlags = 256 // BufferFlagMarker wraps GST_BUFFER_FLAG_MARKER // // the buffer contains a media specific marker. for // video this is the end of a frame boundary, for audio // this is the start of a talkspurt. for RTP // packets this matches the marker flag in the // RTP packet header. BufferFlagMarker BufferFlags = 512 // BufferFlagHeader wraps GST_BUFFER_FLAG_HEADER // // the buffer contains header information that is // needed to decode the following data. BufferFlagHeader BufferFlags = 1024 // BufferFlagGap wraps GST_BUFFER_FLAG_GAP // // the buffer has been created to fill a gap in the // stream and contains media neutral data (elements can // switch to optimized code path that ignores the buffer // content). BufferFlagGap BufferFlags = 2048 // BufferFlagDroppable wraps GST_BUFFER_FLAG_DROPPABLE // // the buffer can be dropped without breaking the // stream, for example to reduce bandwidth. BufferFlagDroppable BufferFlags = 4096 // BufferFlagDeltaUnit wraps GST_BUFFER_FLAG_DELTA_UNIT // // this unit cannot be decoded independently. BufferFlagDeltaUnit BufferFlags = 8192 // BufferFlagTagMemory wraps GST_BUFFER_FLAG_TAG_MEMORY // // this flag is set when memory of the buffer // is added/removed BufferFlagTagMemory BufferFlags = 16384 // BufferFlagSyncAfter wraps GST_BUFFER_FLAG_SYNC_AFTER // // Elements which write to disk or permanent storage should ensure the data // is synced after writing the contents of this buffer. BufferFlagSyncAfter BufferFlags = 32768 // BufferFlagNonDroppable wraps GST_BUFFER_FLAG_NON_DROPPABLE // // This buffer is important and should not be dropped. // // This can be used to mark important buffers, e.g. to flag RTP packets // carrying keyframes or codec setup data for RTP Forward Error Correction // purposes, or to prevent still video frames from being dropped by elements // due to QoS. BufferFlagNonDroppable BufferFlags = 65536 // BufferFlagLast wraps GST_BUFFER_FLAG_LAST // // additional media specific flags can be added starting from // this flag. BufferFlagLast BufferFlags = 1048576 ) func marshalBufferFlags(p unsafe.Pointer) (any, error) { return BufferFlags(gobject.ValueFromNative(p).Flags()), nil } // Has returns true if b contains other func (b BufferFlags) Has(other BufferFlags) bool { return (b & other) == other } var _ gobject.GoValueInitializer = BufferFlags(0) func (f BufferFlags) InitGoValue(v *gobject.Value) { v.Init(TypeBufferFlags) v.SetFlags(int(f)) } func (f BufferFlags) String() string { if f == 0 { return "BufferFlags(0)" } var parts []string if (f & BufferFlagLive) != 0 { parts = append(parts, "BufferFlagLive") } if (f & BufferFlagDecodeOnly) != 0 { parts = append(parts, "BufferFlagDecodeOnly") } if (f & BufferFlagDiscont) != 0 { parts = append(parts, "BufferFlagDiscont") } if (f & BufferFlagResync) != 0 { parts = append(parts, "BufferFlagResync") } if (f & BufferFlagCorrupted) != 0 { parts = append(parts, "BufferFlagCorrupted") } if (f & BufferFlagMarker) != 0 { parts = append(parts, "BufferFlagMarker") } if (f & BufferFlagHeader) != 0 { parts = append(parts, "BufferFlagHeader") } if (f & BufferFlagGap) != 0 { parts = append(parts, "BufferFlagGap") } if (f & BufferFlagDroppable) != 0 { parts = append(parts, "BufferFlagDroppable") } if (f & BufferFlagDeltaUnit) != 0 { parts = append(parts, "BufferFlagDeltaUnit") } if (f & BufferFlagTagMemory) != 0 { parts = append(parts, "BufferFlagTagMemory") } if (f & BufferFlagSyncAfter) != 0 { parts = append(parts, "BufferFlagSyncAfter") } if (f & BufferFlagNonDroppable) != 0 { parts = append(parts, "BufferFlagNonDroppable") } if (f & BufferFlagLast) != 0 { parts = append(parts, "BufferFlagLast") } return "BufferFlags(" + strings.Join(parts, "|") + ")" } // BufferPoolAcquireFlags wraps GstBufferPoolAcquireFlags // // Additional flags to control the allocation of a buffer type BufferPoolAcquireFlags C.gint const ( // BufferPoolAcquireFlagNone wraps GST_BUFFER_POOL_ACQUIRE_FLAG_NONE // // no flags BufferPoolAcquireFlagNone BufferPoolAcquireFlags = 0 // BufferPoolAcquireFlagKeyUnit wraps GST_BUFFER_POOL_ACQUIRE_FLAG_KEY_UNIT // // buffer is keyframe BufferPoolAcquireFlagKeyUnit BufferPoolAcquireFlags = 1 // BufferPoolAcquireFlagDontwait wraps GST_BUFFER_POOL_ACQUIRE_FLAG_DONTWAIT // // when the bufferpool is empty, acquire_buffer // will by default block until a buffer is released into the pool again. Setting // this flag makes acquire_buffer return #GST_FLOW_EOS instead of blocking. BufferPoolAcquireFlagDontwait BufferPoolAcquireFlags = 2 // BufferPoolAcquireFlagDiscont wraps GST_BUFFER_POOL_ACQUIRE_FLAG_DISCONT // // buffer is discont BufferPoolAcquireFlagDiscont BufferPoolAcquireFlags = 4 // BufferPoolAcquireFlagLast wraps GST_BUFFER_POOL_ACQUIRE_FLAG_LAST // // last flag, subclasses can use private flags // starting from this value. BufferPoolAcquireFlagLast BufferPoolAcquireFlags = 65536 ) func marshalBufferPoolAcquireFlags(p unsafe.Pointer) (any, error) { return BufferPoolAcquireFlags(gobject.ValueFromNative(p).Flags()), nil } // Has returns true if b contains other func (b BufferPoolAcquireFlags) Has(other BufferPoolAcquireFlags) bool { return (b & other) == other } var _ gobject.GoValueInitializer = BufferPoolAcquireFlags(0) func (f BufferPoolAcquireFlags) InitGoValue(v *gobject.Value) { v.Init(TypeBufferPoolAcquireFlags) v.SetFlags(int(f)) } func (f BufferPoolAcquireFlags) String() string { if f == 0 { return "BufferPoolAcquireFlags(0)" } var parts []string if (f & BufferPoolAcquireFlagNone) != 0 { parts = append(parts, "BufferPoolAcquireFlagNone") } if (f & BufferPoolAcquireFlagKeyUnit) != 0 { parts = append(parts, "BufferPoolAcquireFlagKeyUnit") } if (f & BufferPoolAcquireFlagDontwait) != 0 { parts = append(parts, "BufferPoolAcquireFlagDontwait") } if (f & BufferPoolAcquireFlagDiscont) != 0 { parts = append(parts, "BufferPoolAcquireFlagDiscont") } if (f & BufferPoolAcquireFlagLast) != 0 { parts = append(parts, "BufferPoolAcquireFlagLast") } return "BufferPoolAcquireFlags(" + strings.Join(parts, "|") + ")" } // BusFlags wraps GstBusFlags // // The standard flags that a bus may have. type BusFlags C.gint const ( // BusFlushing wraps GST_BUS_FLUSHING // // The bus is currently dropping all messages BusFlushing BusFlags = 16 // BusFlagLast wraps GST_BUS_FLAG_LAST // // offset to define more flags BusFlagLast BusFlags = 32 ) func marshalBusFlags(p unsafe.Pointer) (any, error) { return BusFlags(gobject.ValueFromNative(p).Flags()), nil } // Has returns true if b contains other func (b BusFlags) Has(other BusFlags) bool { return (b & other) == other } var _ gobject.GoValueInitializer = BusFlags(0) func (f BusFlags) InitGoValue(v *gobject.Value) { v.Init(TypeBusFlags) v.SetFlags(int(f)) } func (f BusFlags) String() string { if f == 0 { return "BusFlags(0)" } var parts []string if (f & BusFlushing) != 0 { parts = append(parts, "BusFlushing") } if (f & BusFlagLast) != 0 { parts = append(parts, "BusFlagLast") } return "BusFlags(" + strings.Join(parts, "|") + ")" } // CapsFlags wraps GstCapsFlags // // Extra flags for a caps. type CapsFlags C.gint const ( // CapsFlagAny wraps GST_CAPS_FLAG_ANY // // Caps has no specific content, but can contain // anything. CapsFlagAny CapsFlags = 16 ) func marshalCapsFlags(p unsafe.Pointer) (any, error) { return CapsFlags(gobject.ValueFromNative(p).Flags()), nil } // Has returns true if c contains other func (c CapsFlags) Has(other CapsFlags) bool { return (c & other) == other } var _ gobject.GoValueInitializer = CapsFlags(0) func (f CapsFlags) InitGoValue(v *gobject.Value) { v.Init(TypeCapsFlags) v.SetFlags(int(f)) } func (f CapsFlags) String() string { if f == 0 { return "CapsFlags(0)" } var parts []string if (f & CapsFlagAny) != 0 { parts = append(parts, "CapsFlagAny") } return "CapsFlags(" + strings.Join(parts, "|") + ")" } // ClockFlags wraps GstClockFlags // // The capabilities of this clock type ClockFlags C.gint const ( // ClockFlagCanDoSingleSync wraps GST_CLOCK_FLAG_CAN_DO_SINGLE_SYNC // // clock can do a single sync timeout request ClockFlagCanDoSingleSync ClockFlags = 16 // ClockFlagCanDoSingleAsync wraps GST_CLOCK_FLAG_CAN_DO_SINGLE_ASYNC // // clock can do a single async timeout request ClockFlagCanDoSingleAsync ClockFlags = 32 // ClockFlagCanDoPeriodicSync wraps GST_CLOCK_FLAG_CAN_DO_PERIODIC_SYNC // // clock can do sync periodic timeout requests ClockFlagCanDoPeriodicSync ClockFlags = 64 // ClockFlagCanDoPeriodicAsync wraps GST_CLOCK_FLAG_CAN_DO_PERIODIC_ASYNC // // clock can do async periodic timeout callbacks ClockFlagCanDoPeriodicAsync ClockFlags = 128 // ClockFlagCanSetResolution wraps GST_CLOCK_FLAG_CAN_SET_RESOLUTION // // clock's resolution can be changed ClockFlagCanSetResolution ClockFlags = 256 // ClockFlagCanSetMaster wraps GST_CLOCK_FLAG_CAN_SET_MASTER // // clock can be slaved to a master clock ClockFlagCanSetMaster ClockFlags = 512 // ClockFlagNeedsStartupSync wraps GST_CLOCK_FLAG_NEEDS_STARTUP_SYNC // // clock needs to be synced before it can be used ClockFlagNeedsStartupSync ClockFlags = 1024 // ClockFlagLast wraps GST_CLOCK_FLAG_LAST // // subclasses can add additional flags starting from this flag ClockFlagLast ClockFlags = 4096 ) func marshalClockFlags(p unsafe.Pointer) (any, error) { return ClockFlags(gobject.ValueFromNative(p).Flags()), nil } // Has returns true if c contains other func (c ClockFlags) Has(other ClockFlags) bool { return (c & other) == other } var _ gobject.GoValueInitializer = ClockFlags(0) func (f ClockFlags) InitGoValue(v *gobject.Value) { v.Init(TypeClockFlags) v.SetFlags(int(f)) } func (f ClockFlags) String() string { if f == 0 { return "ClockFlags(0)" } var parts []string if (f & ClockFlagCanDoSingleSync) != 0 { parts = append(parts, "ClockFlagCanDoSingleSync") } if (f & ClockFlagCanDoSingleAsync) != 0 { parts = append(parts, "ClockFlagCanDoSingleAsync") } if (f & ClockFlagCanDoPeriodicSync) != 0 { parts = append(parts, "ClockFlagCanDoPeriodicSync") } if (f & ClockFlagCanDoPeriodicAsync) != 0 { parts = append(parts, "ClockFlagCanDoPeriodicAsync") } if (f & ClockFlagCanSetResolution) != 0 { parts = append(parts, "ClockFlagCanSetResolution") } if (f & ClockFlagCanSetMaster) != 0 { parts = append(parts, "ClockFlagCanSetMaster") } if (f & ClockFlagNeedsStartupSync) != 0 { parts = append(parts, "ClockFlagNeedsStartupSync") } if (f & ClockFlagLast) != 0 { parts = append(parts, "ClockFlagLast") } return "ClockFlags(" + strings.Join(parts, "|") + ")" } // DebugColorFlags wraps GstDebugColorFlags // // These are some terminal style flags you can use when creating your // debugging categories to make them stand out in debugging output. type DebugColorFlags C.gint const ( // DebugFgBlack wraps GST_DEBUG_FG_BLACK // // Use black as foreground color. DebugFgBlack DebugColorFlags = 0 // DebugFgRed wraps GST_DEBUG_FG_RED // // Use red as foreground color. DebugFgRed DebugColorFlags = 1 // DebugFgGreen wraps GST_DEBUG_FG_GREEN // // Use green as foreground color. DebugFgGreen DebugColorFlags = 2 // DebugFgYellow wraps GST_DEBUG_FG_YELLOW // // Use yellow as foreground color. DebugFgYellow DebugColorFlags = 3 // DebugFgBlue wraps GST_DEBUG_FG_BLUE // // Use blue as foreground color. DebugFgBlue DebugColorFlags = 4 // DebugFgMagenta wraps GST_DEBUG_FG_MAGENTA // // Use magenta as foreground color. DebugFgMagenta DebugColorFlags = 5 // DebugFgCyan wraps GST_DEBUG_FG_CYAN // // Use cyan as foreground color. DebugFgCyan DebugColorFlags = 6 // DebugFgWhite wraps GST_DEBUG_FG_WHITE // // Use white as foreground color. DebugFgWhite DebugColorFlags = 7 // DebugBgBlack wraps GST_DEBUG_BG_BLACK // // Use black as background color. DebugBgBlack DebugColorFlags = 0 // DebugBgRed wraps GST_DEBUG_BG_RED // // Use red as background color. DebugBgRed DebugColorFlags = 16 // DebugBgGreen wraps GST_DEBUG_BG_GREEN // // Use green as background color. DebugBgGreen DebugColorFlags = 32 // DebugBgYellow wraps GST_DEBUG_BG_YELLOW // // Use yellow as background color. DebugBgYellow DebugColorFlags = 48 // DebugBgBlue wraps GST_DEBUG_BG_BLUE // // Use blue as background color. DebugBgBlue DebugColorFlags = 64 // DebugBgMagenta wraps GST_DEBUG_BG_MAGENTA // // Use magenta as background color. DebugBgMagenta DebugColorFlags = 80 // DebugBgCyan wraps GST_DEBUG_BG_CYAN // // Use cyan as background color. DebugBgCyan DebugColorFlags = 96 // DebugBgWhite wraps GST_DEBUG_BG_WHITE // // Use white as background color. DebugBgWhite DebugColorFlags = 112 // DebugBold wraps GST_DEBUG_BOLD // // Make the output bold. DebugBold DebugColorFlags = 256 // DebugUnderline wraps GST_DEBUG_UNDERLINE // // Underline the output. DebugUnderline DebugColorFlags = 512 ) func marshalDebugColorFlags(p unsafe.Pointer) (any, error) { return DebugColorFlags(gobject.ValueFromNative(p).Flags()), nil } // Has returns true if d contains other func (d DebugColorFlags) Has(other DebugColorFlags) bool { return (d & other) == other } var _ gobject.GoValueInitializer = DebugColorFlags(0) func (f DebugColorFlags) InitGoValue(v *gobject.Value) { v.Init(TypeDebugColorFlags) v.SetFlags(int(f)) } func (f DebugColorFlags) String() string { if f == 0 { return "DebugColorFlags(0)" } var parts []string if (f & DebugFgBlack) != 0 { parts = append(parts, "DebugFgBlack") } if (f & DebugFgRed) != 0 { parts = append(parts, "DebugFgRed") } if (f & DebugFgGreen) != 0 { parts = append(parts, "DebugFgGreen") } if (f & DebugFgYellow) != 0 { parts = append(parts, "DebugFgYellow") } if (f & DebugFgBlue) != 0 { parts = append(parts, "DebugFgBlue") } if (f & DebugFgMagenta) != 0 { parts = append(parts, "DebugFgMagenta") } if (f & DebugFgCyan) != 0 { parts = append(parts, "DebugFgCyan") } if (f & DebugFgWhite) != 0 { parts = append(parts, "DebugFgWhite") } if (f & DebugBgBlack) != 0 { parts = append(parts, "DebugBgBlack") } if (f & DebugBgRed) != 0 { parts = append(parts, "DebugBgRed") } if (f & DebugBgGreen) != 0 { parts = append(parts, "DebugBgGreen") } if (f & DebugBgYellow) != 0 { parts = append(parts, "DebugBgYellow") } if (f & DebugBgBlue) != 0 { parts = append(parts, "DebugBgBlue") } if (f & DebugBgMagenta) != 0 { parts = append(parts, "DebugBgMagenta") } if (f & DebugBgCyan) != 0 { parts = append(parts, "DebugBgCyan") } if (f & DebugBgWhite) != 0 { parts = append(parts, "DebugBgWhite") } if (f & DebugBold) != 0 { parts = append(parts, "DebugBold") } if (f & DebugUnderline) != 0 { parts = append(parts, "DebugUnderline") } return "DebugColorFlags(" + strings.Join(parts, "|") + ")" } // DebugGraphDetails wraps GstDebugGraphDetails // // Available details for pipeline graphs produced by GST_DEBUG_BIN_TO_DOT_FILE() // and GST_DEBUG_BIN_TO_DOT_FILE_WITH_TS(). type DebugGraphDetails C.gint const ( // DebugGraphShowMediaType wraps GST_DEBUG_GRAPH_SHOW_MEDIA_TYPE // // show caps-name on edges DebugGraphShowMediaType DebugGraphDetails = 1 // DebugGraphShowCapsDetails wraps GST_DEBUG_GRAPH_SHOW_CAPS_DETAILS // // show caps-details on edges DebugGraphShowCapsDetails DebugGraphDetails = 2 // DebugGraphShowNonDefaultParams wraps GST_DEBUG_GRAPH_SHOW_NON_DEFAULT_PARAMS // // show modified parameters on // elements DebugGraphShowNonDefaultParams DebugGraphDetails = 4 // DebugGraphShowStates wraps GST_DEBUG_GRAPH_SHOW_STATES // // show element states DebugGraphShowStates DebugGraphDetails = 8 // DebugGraphShowFullParams wraps GST_DEBUG_GRAPH_SHOW_FULL_PARAMS // // show full element parameter values even // if they are very long DebugGraphShowFullParams DebugGraphDetails = 16 // DebugGraphShowAll wraps GST_DEBUG_GRAPH_SHOW_ALL // // show all the typical details that one might want DebugGraphShowAll DebugGraphDetails = 15 // DebugGraphShowVerbose wraps GST_DEBUG_GRAPH_SHOW_VERBOSE // // show all details regardless of how large or // verbose they make the resulting output DebugGraphShowVerbose DebugGraphDetails = -1 ) func marshalDebugGraphDetails(p unsafe.Pointer) (any, error) { return DebugGraphDetails(gobject.ValueFromNative(p).Flags()), nil } // Has returns true if d contains other func (d DebugGraphDetails) Has(other DebugGraphDetails) bool { return (d & other) == other } var _ gobject.GoValueInitializer = DebugGraphDetails(0) func (f DebugGraphDetails) InitGoValue(v *gobject.Value) { v.Init(TypeDebugGraphDetails) v.SetFlags(int(f)) } func (f DebugGraphDetails) String() string { if f == 0 { return "DebugGraphDetails(0)" } var parts []string if (f & DebugGraphShowMediaType) != 0 { parts = append(parts, "DebugGraphShowMediaType") } if (f & DebugGraphShowCapsDetails) != 0 { parts = append(parts, "DebugGraphShowCapsDetails") } if (f & DebugGraphShowNonDefaultParams) != 0 { parts = append(parts, "DebugGraphShowNonDefaultParams") } if (f & DebugGraphShowStates) != 0 { parts = append(parts, "DebugGraphShowStates") } if (f & DebugGraphShowFullParams) != 0 { parts = append(parts, "DebugGraphShowFullParams") } if (f & DebugGraphShowAll) != 0 { parts = append(parts, "DebugGraphShowAll") } if (f & DebugGraphShowVerbose) != 0 { parts = append(parts, "DebugGraphShowVerbose") } return "DebugGraphDetails(" + strings.Join(parts, "|") + ")" } // ElementFlags wraps GstElementFlags // // The standard flags that an element may have. type ElementFlags C.gint const ( // ElementFlagLockedState wraps GST_ELEMENT_FLAG_LOCKED_STATE // // ignore state changes from parent ElementFlagLockedState ElementFlags = 16 // ElementFlagSink wraps GST_ELEMENT_FLAG_SINK // // the element is a sink ElementFlagSink ElementFlags = 32 // ElementFlagSource wraps GST_ELEMENT_FLAG_SOURCE // // the element is a source. ElementFlagSource ElementFlags = 64 // ElementFlagProvideClock wraps GST_ELEMENT_FLAG_PROVIDE_CLOCK // // the element can provide a clock ElementFlagProvideClock ElementFlags = 128 // ElementFlagRequireClock wraps GST_ELEMENT_FLAG_REQUIRE_CLOCK // // the element requires a clock ElementFlagRequireClock ElementFlags = 256 // ElementFlagIndexable wraps GST_ELEMENT_FLAG_INDEXABLE // // the element can use an index ElementFlagIndexable ElementFlags = 512 // ElementFlagLast wraps GST_ELEMENT_FLAG_LAST // // offset to define more flags ElementFlagLast ElementFlags = 16384 ) func marshalElementFlags(p unsafe.Pointer) (any, error) { return ElementFlags(gobject.ValueFromNative(p).Flags()), nil } // Has returns true if e contains other func (e ElementFlags) Has(other ElementFlags) bool { return (e & other) == other } var _ gobject.GoValueInitializer = ElementFlags(0) func (f ElementFlags) InitGoValue(v *gobject.Value) { v.Init(TypeElementFlags) v.SetFlags(int(f)) } func (f ElementFlags) String() string { if f == 0 { return "ElementFlags(0)" } var parts []string if (f & ElementFlagLockedState) != 0 { parts = append(parts, "ElementFlagLockedState") } if (f & ElementFlagSink) != 0 { parts = append(parts, "ElementFlagSink") } if (f & ElementFlagSource) != 0 { parts = append(parts, "ElementFlagSource") } if (f & ElementFlagProvideClock) != 0 { parts = append(parts, "ElementFlagProvideClock") } if (f & ElementFlagRequireClock) != 0 { parts = append(parts, "ElementFlagRequireClock") } if (f & ElementFlagIndexable) != 0 { parts = append(parts, "ElementFlagIndexable") } if (f & ElementFlagLast) != 0 { parts = append(parts, "ElementFlagLast") } return "ElementFlags(" + strings.Join(parts, "|") + ")" } // EventTypeFlags wraps GstEventTypeFlags // // #GstEventTypeFlags indicate the aspects of the different #GstEventType // values. You can get the type flags of a #GstEventType with the // gst_event_type_get_flags() function. type EventTypeFlags C.gint const ( // EventTypeUpstream wraps GST_EVENT_TYPE_UPSTREAM // // Set if the event can travel upstream. EventTypeUpstream EventTypeFlags = 1 // EventTypeDownstream wraps GST_EVENT_TYPE_DOWNSTREAM // // Set if the event can travel downstream. EventTypeDownstream EventTypeFlags = 2 // EventTypeSerialized wraps GST_EVENT_TYPE_SERIALIZED // // Set if the event should be serialized with data // flow. EventTypeSerialized EventTypeFlags = 4 // EventTypeSticky wraps GST_EVENT_TYPE_STICKY // // Set if the event is sticky on the pads. EventTypeSticky EventTypeFlags = 8 // EventTypeStickyMulti wraps GST_EVENT_TYPE_STICKY_MULTI // // Multiple sticky events can be on a pad, each // identified by the event name. EventTypeStickyMulti EventTypeFlags = 16 ) func marshalEventTypeFlags(p unsafe.Pointer) (any, error) { return EventTypeFlags(gobject.ValueFromNative(p).Flags()), nil } // Has returns true if e contains other func (e EventTypeFlags) Has(other EventTypeFlags) bool { return (e & other) == other } var _ gobject.GoValueInitializer = EventTypeFlags(0) func (f EventTypeFlags) InitGoValue(v *gobject.Value) { v.Init(TypeEventTypeFlags) v.SetFlags(int(f)) } func (f EventTypeFlags) String() string { if f == 0 { return "EventTypeFlags(0)" } var parts []string if (f & EventTypeUpstream) != 0 { parts = append(parts, "EventTypeUpstream") } if (f & EventTypeDownstream) != 0 { parts = append(parts, "EventTypeDownstream") } if (f & EventTypeSerialized) != 0 { parts = append(parts, "EventTypeSerialized") } if (f & EventTypeSticky) != 0 { parts = append(parts, "EventTypeSticky") } if (f & EventTypeStickyMulti) != 0 { parts = append(parts, "EventTypeStickyMulti") } return "EventTypeFlags(" + strings.Join(parts, "|") + ")" } // GapFlags wraps GstGapFlags // // The different flags that can be set on #GST_EVENT_GAP events. See // gst_event_set_gap_flags() for details. type GapFlags C.gint const ( // GapFlagMissingData wraps GST_GAP_FLAG_MISSING_DATA // // The #GST_EVENT_GAP signals missing data, // for example because of packet loss. GapFlagMissingData GapFlags = 1 ) func marshalGapFlags(p unsafe.Pointer) (any, error) { return GapFlags(gobject.ValueFromNative(p).Flags()), nil } // Has returns true if g contains other func (g GapFlags) Has(other GapFlags) bool { return (g & other) == other } var _ gobject.GoValueInitializer = GapFlags(0) func (f GapFlags) InitGoValue(v *gobject.Value) { v.Init(TypeGapFlags) v.SetFlags(int(f)) } func (f GapFlags) String() string { if f == 0 { return "GapFlags(0)" } var parts []string if (f & GapFlagMissingData) != 0 { parts = append(parts, "GapFlagMissingData") } return "GapFlags(" + strings.Join(parts, "|") + ")" } // LockFlags wraps GstLockFlags // // Flags used when locking miniobjects type LockFlags C.gint const ( // LockFlagRead wraps GST_LOCK_FLAG_READ // // lock for read access LockFlagRead LockFlags = 1 // LockFlagWrite wraps GST_LOCK_FLAG_WRITE // // lock for write access LockFlagWrite LockFlags = 2 // LockFlagExclusive wraps GST_LOCK_FLAG_EXCLUSIVE // // lock for exclusive access LockFlagExclusive LockFlags = 4 // LockFlagLast wraps GST_LOCK_FLAG_LAST // // first flag that can be used for custom purposes LockFlagLast LockFlags = 256 ) func marshalLockFlags(p unsafe.Pointer) (any, error) { return LockFlags(gobject.ValueFromNative(p).Flags()), nil } // Has returns true if l contains other func (l LockFlags) Has(other LockFlags) bool { return (l & other) == other } var _ gobject.GoValueInitializer = LockFlags(0) func (f LockFlags) InitGoValue(v *gobject.Value) { v.Init(TypeLockFlags) v.SetFlags(int(f)) } func (f LockFlags) String() string { if f == 0 { return "LockFlags(0)" } var parts []string if (f & LockFlagRead) != 0 { parts = append(parts, "LockFlagRead") } if (f & LockFlagWrite) != 0 { parts = append(parts, "LockFlagWrite") } if (f & LockFlagExclusive) != 0 { parts = append(parts, "LockFlagExclusive") } if (f & LockFlagLast) != 0 { parts = append(parts, "LockFlagLast") } return "LockFlags(" + strings.Join(parts, "|") + ")" } // MapFlags wraps GstMapFlags // // Flags used when mapping memory type MapFlags C.gint const ( // MapRead wraps GST_MAP_READ // // map for read access MapRead MapFlags = 1 // MapWrite wraps GST_MAP_WRITE // // map for write access MapWrite MapFlags = 2 // MapFlagLast wraps GST_MAP_FLAG_LAST // // first flag that can be used for custom purposes MapFlagLast MapFlags = 65536 ) func marshalMapFlags(p unsafe.Pointer) (any, error) { return MapFlags(gobject.ValueFromNative(p).Flags()), nil } // Has returns true if m contains other func (m MapFlags) Has(other MapFlags) bool { return (m & other) == other } var _ gobject.GoValueInitializer = MapFlags(0) func (f MapFlags) InitGoValue(v *gobject.Value) { v.Init(TypeMapFlags) v.SetFlags(int(f)) } func (f MapFlags) String() string { if f == 0 { return "MapFlags(0)" } var parts []string if (f & MapRead) != 0 { parts = append(parts, "MapRead") } if (f & MapWrite) != 0 { parts = append(parts, "MapWrite") } if (f & MapFlagLast) != 0 { parts = append(parts, "MapFlagLast") } return "MapFlags(" + strings.Join(parts, "|") + ")" } // MemoryFlags wraps GstMemoryFlags // // Flags for wrapped memory. type MemoryFlags C.gint const ( // MemoryFlagReadonly wraps GST_MEMORY_FLAG_READONLY // // memory is readonly. It is not allowed to map the // memory with #GST_MAP_WRITE. MemoryFlagReadonly MemoryFlags = 2 // MemoryFlagNoShare wraps GST_MEMORY_FLAG_NO_SHARE // // memory must not be shared. Copies will have to be // made when this memory needs to be shared between buffers. (DEPRECATED: // do not use in new code, instead you should create a custom GstAllocator for // memory pooling instead of relying on the GstBuffer they were originally // attached to.) MemoryFlagNoShare MemoryFlags = 16 // MemoryFlagZeroPrefixed wraps GST_MEMORY_FLAG_ZERO_PREFIXED // // the memory prefix is filled with 0 bytes MemoryFlagZeroPrefixed MemoryFlags = 32 // MemoryFlagZeroPadded wraps GST_MEMORY_FLAG_ZERO_PADDED // // the memory padding is filled with 0 bytes MemoryFlagZeroPadded MemoryFlags = 64 // MemoryFlagPhysicallyContiguous wraps GST_MEMORY_FLAG_PHYSICALLY_CONTIGUOUS // // the memory is physically // contiguous. (Since: 1.2) MemoryFlagPhysicallyContiguous MemoryFlags = 128 // MemoryFlagNotMappable wraps GST_MEMORY_FLAG_NOT_MAPPABLE // // the memory can't be mapped via // gst_memory_map() without any preconditions. (Since: 1.2) MemoryFlagNotMappable MemoryFlags = 256 // MemoryFlagLast wraps GST_MEMORY_FLAG_LAST // // first flag that can be used for custom purposes MemoryFlagLast MemoryFlags = 1048576 ) func marshalMemoryFlags(p unsafe.Pointer) (any, error) { return MemoryFlags(gobject.ValueFromNative(p).Flags()), nil } // Has returns true if m contains other func (m MemoryFlags) Has(other MemoryFlags) bool { return (m & other) == other } var _ gobject.GoValueInitializer = MemoryFlags(0) func (f MemoryFlags) InitGoValue(v *gobject.Value) { v.Init(TypeMemoryFlags) v.SetFlags(int(f)) } func (f MemoryFlags) String() string { if f == 0 { return "MemoryFlags(0)" } var parts []string if (f & MemoryFlagReadonly) != 0 { parts = append(parts, "MemoryFlagReadonly") } if (f & MemoryFlagNoShare) != 0 { parts = append(parts, "MemoryFlagNoShare") } if (f & MemoryFlagZeroPrefixed) != 0 { parts = append(parts, "MemoryFlagZeroPrefixed") } if (f & MemoryFlagZeroPadded) != 0 { parts = append(parts, "MemoryFlagZeroPadded") } if (f & MemoryFlagPhysicallyContiguous) != 0 { parts = append(parts, "MemoryFlagPhysicallyContiguous") } if (f & MemoryFlagNotMappable) != 0 { parts = append(parts, "MemoryFlagNotMappable") } if (f & MemoryFlagLast) != 0 { parts = append(parts, "MemoryFlagLast") } return "MemoryFlags(" + strings.Join(parts, "|") + ")" } // MessageType wraps GstMessageType // // The different message types that are available. type MessageType C.gint const ( // MessageUnknown wraps GST_MESSAGE_UNKNOWN // // an undefined message MessageUnknown MessageType = 0 // MessageEos wraps GST_MESSAGE_EOS // // end-of-stream reached in a pipeline. The application will // only receive this message in the PLAYING state and every time it sets a // pipeline to PLAYING that is in the EOS state. The application can perform a // flushing seek in the pipeline, which will undo the EOS state again. MessageEos MessageType = 1 // MessageError wraps GST_MESSAGE_ERROR // // an error occurred. When the application receives an error // message it should stop playback of the pipeline and not assume that more // data will be played. It is possible to specify a redirection url to the error // messages by setting a `redirect-location` field into the error message, application // or high level bins might use the information as required. MessageError MessageType = 2 // MessageWarning wraps GST_MESSAGE_WARNING // // a warning occurred. MessageWarning MessageType = 4 // MessageInfo wraps GST_MESSAGE_INFO // // an info message occurred MessageInfo MessageType = 8 // MessageTag wraps GST_MESSAGE_TAG // // a tag was found. MessageTag MessageType = 16 // MessageBuffering wraps GST_MESSAGE_BUFFERING // // the pipeline is buffering. When the application // receives a buffering message in the PLAYING state for a non-live pipeline it // must PAUSE the pipeline until the buffering completes, when the percentage // field in the message is 100%. For live pipelines, no action must be // performed and the buffering percentage can be used to inform the user about // the progress. MessageBuffering MessageType = 32 // MessageStateChanged wraps GST_MESSAGE_STATE_CHANGED // // a state change happened MessageStateChanged MessageType = 64 // MessageStateDirty wraps GST_MESSAGE_STATE_DIRTY // // an element changed state in a streaming thread. // This message is deprecated. MessageStateDirty MessageType = 128 // MessageStepDone wraps GST_MESSAGE_STEP_DONE // // a stepping operation finished. MessageStepDone MessageType = 256 // MessageClockProvide wraps GST_MESSAGE_CLOCK_PROVIDE // // an element notifies its capability of providing // a clock. This message is used internally and // never forwarded to the application. MessageClockProvide MessageType = 512 // MessageClockLost wraps GST_MESSAGE_CLOCK_LOST // // The current clock as selected by the pipeline became // unusable. The pipeline will select a new clock on // the next PLAYING state change. The application // should set the pipeline to PAUSED and back to // PLAYING when this message is received. MessageClockLost MessageType = 1024 // MessageNewClock wraps GST_MESSAGE_NEW_CLOCK // // a new clock was selected in the pipeline. MessageNewClock MessageType = 2048 // MessageStructureChange wraps GST_MESSAGE_STRUCTURE_CHANGE // // the structure of the pipeline changed. This // message is used internally and never forwarded to the application. MessageStructureChange MessageType = 4096 // MessageStreamStatus wraps GST_MESSAGE_STREAM_STATUS // // status about a stream, emitted when it starts, // stops, errors, etc.. MessageStreamStatus MessageType = 8192 // MessageApplication wraps GST_MESSAGE_APPLICATION // // message posted by the application, possibly // via an application-specific element. MessageApplication MessageType = 16384 // MessageElement wraps GST_MESSAGE_ELEMENT // // element-specific message, see the specific element's // documentation MessageElement MessageType = 32768 // MessageSegmentStart wraps GST_MESSAGE_SEGMENT_START // // pipeline started playback of a segment. This // message is used internally and never forwarded to the application. MessageSegmentStart MessageType = 65536 // MessageSegmentDone wraps GST_MESSAGE_SEGMENT_DONE // // pipeline completed playback of a segment. This // message is forwarded to the application after all elements that posted // @GST_MESSAGE_SEGMENT_START posted a GST_MESSAGE_SEGMENT_DONE message. MessageSegmentDone MessageType = 131072 // MessageDurationChanged wraps GST_MESSAGE_DURATION_CHANGED // // The duration of a pipeline changed. The // application can get the new duration with a duration query. MessageDurationChanged MessageType = 262144 // MessageLatency wraps GST_MESSAGE_LATENCY // // Posted by elements when their latency changes. The // application should recalculate and distribute a new latency. MessageLatency MessageType = 524288 // MessageAsyncStart wraps GST_MESSAGE_ASYNC_START // // Posted by elements when they start an ASYNC // #GstStateChange. This message is not forwarded to the application but is used // internally. MessageAsyncStart MessageType = 1048576 // MessageAsyncDone wraps GST_MESSAGE_ASYNC_DONE // // Posted by elements when they complete an ASYNC // #GstStateChange. The application will only receive this message from the toplevel // pipeline. MessageAsyncDone MessageType = 2097152 // MessageRequestState wraps GST_MESSAGE_REQUEST_STATE // // Posted by elements when they want the pipeline to // change state. This message is a suggestion to the application which can // decide to perform the state change on (part of) the pipeline. MessageRequestState MessageType = 4194304 // MessageStepStart wraps GST_MESSAGE_STEP_START // // A stepping operation was started. MessageStepStart MessageType = 8388608 // MessageQos wraps GST_MESSAGE_QOS // // A buffer was dropped or an element changed its processing // strategy for Quality of Service reasons. MessageQos MessageType = 16777216 // MessageProgress wraps GST_MESSAGE_PROGRESS // // A progress message. MessageProgress MessageType = 33554432 // MessageToc wraps GST_MESSAGE_TOC // // A new table of contents (TOC) was found or previously found TOC // was updated. MessageToc MessageType = 67108864 // MessageResetTime wraps GST_MESSAGE_RESET_TIME // // Message to request resetting the pipeline's // running time from the pipeline. This is an internal message which // applications will likely never receive. MessageResetTime MessageType = 134217728 // MessageStreamStart wraps GST_MESSAGE_STREAM_START // // Message indicating start of a new stream. Useful // e.g. when using playbin in gapless playback mode, to get notified when // the next title actually starts playing (which will be some time after // the URI for the next title has been set). MessageStreamStart MessageType = 268435456 // MessageNeedContext wraps GST_MESSAGE_NEED_CONTEXT // // Message indicating that an element wants a specific context (Since: 1.2) MessageNeedContext MessageType = 536870912 // MessageHaveContext wraps GST_MESSAGE_HAVE_CONTEXT // // Message indicating that an element created a context (Since: 1.2) MessageHaveContext MessageType = 1073741824 // MessageExtended wraps GST_MESSAGE_EXTENDED // // Message is an extended message type (see below). // These extended message IDs can't be used directly with mask-based API // like gst_bus_poll() or gst_bus_timed_pop_filtered(), but you can still // filter for GST_MESSAGE_EXTENDED and then check the result for the // specific type. (Since: 1.4) MessageExtended MessageType = -2147483648 // MessageDeviceAdded wraps GST_MESSAGE_DEVICE_ADDED // // Message indicating a #GstDevice was added to // a #GstDeviceProvider (Since: 1.4) MessageDeviceAdded MessageType = -2147483647 // MessageDeviceRemoved wraps GST_MESSAGE_DEVICE_REMOVED // // Message indicating a #GstDevice was removed // from a #GstDeviceProvider (Since: 1.4) MessageDeviceRemoved MessageType = -2147483646 // MessagePropertyNotify wraps GST_MESSAGE_PROPERTY_NOTIFY // // Message indicating a #GObject property has // changed (Since: 1.10) MessagePropertyNotify MessageType = -2147483645 // MessageStreamCollection wraps GST_MESSAGE_STREAM_COLLECTION // // Message indicating a new #GstStreamCollection // is available (Since: 1.10) MessageStreamCollection MessageType = -2147483644 // MessageStreamsSelected wraps GST_MESSAGE_STREAMS_SELECTED // // Message indicating the active selection of // #GstStreams has changed (Since: 1.10) MessageStreamsSelected MessageType = -2147483643 // MessageRedirect wraps GST_MESSAGE_REDIRECT // // Message indicating to request the application to // try to play the given URL(s). Useful if for example a HTTP 302/303 // response is received with a non-HTTP URL inside. (Since: 1.10) MessageRedirect MessageType = -2147483642 // MessageDeviceChanged wraps GST_MESSAGE_DEVICE_CHANGED // // Message indicating a #GstDevice was changed // a #GstDeviceProvider (Since: 1.16) MessageDeviceChanged MessageType = -2147483641 // MessageInstantRateRequest wraps GST_MESSAGE_INSTANT_RATE_REQUEST // // Message sent by elements to request the // running time from the pipeline when an instant rate change should // be applied (which may be in the past when the answer arrives). (Since: 1.18) MessageInstantRateRequest MessageType = -2147483640 // MessageAny wraps GST_MESSAGE_ANY // // mask for all of the above messages. MessageAny MessageType = -1 ) func marshalMessageType(p unsafe.Pointer) (any, error) { return MessageType(gobject.ValueFromNative(p).Flags()), nil } // Has returns true if m contains other func (m MessageType) Has(other MessageType) bool { return (m & other) == other } var _ gobject.GoValueInitializer = MessageType(0) func (f MessageType) InitGoValue(v *gobject.Value) { v.Init(TypeMessageType) v.SetFlags(int(f)) } func (f MessageType) String() string { if f == 0 { return "MessageType(0)" } var parts []string if (f & MessageUnknown) != 0 { parts = append(parts, "MessageUnknown") } if (f & MessageEos) != 0 { parts = append(parts, "MessageEos") } if (f & MessageError) != 0 { parts = append(parts, "MessageError") } if (f & MessageWarning) != 0 { parts = append(parts, "MessageWarning") } if (f & MessageInfo) != 0 { parts = append(parts, "MessageInfo") } if (f & MessageTag) != 0 { parts = append(parts, "MessageTag") } if (f & MessageBuffering) != 0 { parts = append(parts, "MessageBuffering") } if (f & MessageStateChanged) != 0 { parts = append(parts, "MessageStateChanged") } if (f & MessageStateDirty) != 0 { parts = append(parts, "MessageStateDirty") } if (f & MessageStepDone) != 0 { parts = append(parts, "MessageStepDone") } if (f & MessageClockProvide) != 0 { parts = append(parts, "MessageClockProvide") } if (f & MessageClockLost) != 0 { parts = append(parts, "MessageClockLost") } if (f & MessageNewClock) != 0 { parts = append(parts, "MessageNewClock") } if (f & MessageStructureChange) != 0 { parts = append(parts, "MessageStructureChange") } if (f & MessageStreamStatus) != 0 { parts = append(parts, "MessageStreamStatus") } if (f & MessageApplication) != 0 { parts = append(parts, "MessageApplication") } if (f & MessageElement) != 0 { parts = append(parts, "MessageElement") } if (f & MessageSegmentStart) != 0 { parts = append(parts, "MessageSegmentStart") } if (f & MessageSegmentDone) != 0 { parts = append(parts, "MessageSegmentDone") } if (f & MessageDurationChanged) != 0 { parts = append(parts, "MessageDurationChanged") } if (f & MessageLatency) != 0 { parts = append(parts, "MessageLatency") } if (f & MessageAsyncStart) != 0 { parts = append(parts, "MessageAsyncStart") } if (f & MessageAsyncDone) != 0 { parts = append(parts, "MessageAsyncDone") } if (f & MessageRequestState) != 0 { parts = append(parts, "MessageRequestState") } if (f & MessageStepStart) != 0 { parts = append(parts, "MessageStepStart") } if (f & MessageQos) != 0 { parts = append(parts, "MessageQos") } if (f & MessageProgress) != 0 { parts = append(parts, "MessageProgress") } if (f & MessageToc) != 0 { parts = append(parts, "MessageToc") } if (f & MessageResetTime) != 0 { parts = append(parts, "MessageResetTime") } if (f & MessageStreamStart) != 0 { parts = append(parts, "MessageStreamStart") } if (f & MessageNeedContext) != 0 { parts = append(parts, "MessageNeedContext") } if (f & MessageHaveContext) != 0 { parts = append(parts, "MessageHaveContext") } if (f & MessageExtended) != 0 { parts = append(parts, "MessageExtended") } if (f & MessageDeviceAdded) != 0 { parts = append(parts, "MessageDeviceAdded") } if (f & MessageDeviceRemoved) != 0 { parts = append(parts, "MessageDeviceRemoved") } if (f & MessagePropertyNotify) != 0 { parts = append(parts, "MessagePropertyNotify") } if (f & MessageStreamCollection) != 0 { parts = append(parts, "MessageStreamCollection") } if (f & MessageStreamsSelected) != 0 { parts = append(parts, "MessageStreamsSelected") } if (f & MessageRedirect) != 0 { parts = append(parts, "MessageRedirect") } if (f & MessageDeviceChanged) != 0 { parts = append(parts, "MessageDeviceChanged") } if (f & MessageInstantRateRequest) != 0 { parts = append(parts, "MessageInstantRateRequest") } if (f & MessageAny) != 0 { parts = append(parts, "MessageAny") } return "MessageType(" + strings.Join(parts, "|") + ")" } // MessageTypeGetName wraps gst_message_type_get_name // // The function takes the following parameters: // // - typ MessageType: the message type // // The function returns the following values: // // - goret string // // Get a printable name for the given message type. Do not modify or free. func MessageTypeGetName(typ MessageType) string { var carg1 C.GstMessageType // in, none, casted var cret *C.gchar // return, none, string carg1 = C.GstMessageType(typ) cret = C.gst_message_type_get_name(carg1) runtime.KeepAlive(typ) var goret string goret = C.GoString((*C.char)(unsafe.Pointer(cret))) return goret } // MessageTypeToQuark wraps gst_message_type_to_quark // // The function takes the following parameters: // // - typ MessageType: the message type // // The function returns the following values: // // - goret glib.Quark // // Get the unique quark for the given message type. func MessageTypeToQuark(typ MessageType) glib.Quark { var carg1 C.GstMessageType // in, none, casted var cret C.GQuark // return, none, casted, alias carg1 = C.GstMessageType(typ) cret = C.gst_message_type_to_quark(carg1) runtime.KeepAlive(typ) var goret glib.Quark goret = glib.Quark(cret) return goret } // MetaFlags wraps GstMetaFlags // // Extra metadata flags. type MetaFlags C.gint const ( // MetaFlagNone wraps GST_META_FLAG_NONE // // no flags MetaFlagNone MetaFlags = 0 // MetaFlagReadonly wraps GST_META_FLAG_READONLY // // metadata should not be modified MetaFlagReadonly MetaFlags = 1 // MetaFlagPooled wraps GST_META_FLAG_POOLED // // metadata is managed by a bufferpool MetaFlagPooled MetaFlags = 2 // MetaFlagLocked wraps GST_META_FLAG_LOCKED // // metadata should not be removed MetaFlagLocked MetaFlags = 4 // MetaFlagLast wraps GST_META_FLAG_LAST // // additional flags can be added starting from this flag. MetaFlagLast MetaFlags = 65536 ) func marshalMetaFlags(p unsafe.Pointer) (any, error) { return MetaFlags(gobject.ValueFromNative(p).Flags()), nil } // Has returns true if m contains other func (m MetaFlags) Has(other MetaFlags) bool { return (m & other) == other } var _ gobject.GoValueInitializer = MetaFlags(0) func (f MetaFlags) InitGoValue(v *gobject.Value) { v.Init(TypeMetaFlags) v.SetFlags(int(f)) } func (f MetaFlags) String() string { if f == 0 { return "MetaFlags(0)" } var parts []string if (f & MetaFlagNone) != 0 { parts = append(parts, "MetaFlagNone") } if (f & MetaFlagReadonly) != 0 { parts = append(parts, "MetaFlagReadonly") } if (f & MetaFlagPooled) != 0 { parts = append(parts, "MetaFlagPooled") } if (f & MetaFlagLocked) != 0 { parts = append(parts, "MetaFlagLocked") } if (f & MetaFlagLast) != 0 { parts = append(parts, "MetaFlagLast") } return "MetaFlags(" + strings.Join(parts, "|") + ")" } // MiniObjectFlags wraps GstMiniObjectFlags // // Flags for the mini object type MiniObjectFlags C.gint const ( // MiniObjectFlagLockable wraps GST_MINI_OBJECT_FLAG_LOCKABLE // // the object can be locked and unlocked with // gst_mini_object_lock() and gst_mini_object_unlock(). MiniObjectFlagLockable MiniObjectFlags = 1 // MiniObjectFlagLockReadonly wraps GST_MINI_OBJECT_FLAG_LOCK_READONLY // // the object is permanently locked in // READONLY mode. Only read locks can be performed on the object. MiniObjectFlagLockReadonly MiniObjectFlags = 2 // MiniObjectFlagMayBeLeaked wraps GST_MINI_OBJECT_FLAG_MAY_BE_LEAKED // // the object is expected to stay alive // even after gst_deinit() has been called and so should be ignored by leak // detection tools. (Since: 1.10) MiniObjectFlagMayBeLeaked MiniObjectFlags = 4 // MiniObjectFlagLast wraps GST_MINI_OBJECT_FLAG_LAST // // first flag that can be used by subclasses. MiniObjectFlagLast MiniObjectFlags = 16 ) func marshalMiniObjectFlags(p unsafe.Pointer) (any, error) { return MiniObjectFlags(gobject.ValueFromNative(p).Flags()), nil } // Has returns true if m contains other func (m MiniObjectFlags) Has(other MiniObjectFlags) bool { return (m & other) == other } var _ gobject.GoValueInitializer = MiniObjectFlags(0) func (f MiniObjectFlags) InitGoValue(v *gobject.Value) { v.Init(TypeMiniObjectFlags) v.SetFlags(int(f)) } func (f MiniObjectFlags) String() string { if f == 0 { return "MiniObjectFlags(0)" } var parts []string if (f & MiniObjectFlagLockable) != 0 { parts = append(parts, "MiniObjectFlagLockable") } if (f & MiniObjectFlagLockReadonly) != 0 { parts = append(parts, "MiniObjectFlagLockReadonly") } if (f & MiniObjectFlagMayBeLeaked) != 0 { parts = append(parts, "MiniObjectFlagMayBeLeaked") } if (f & MiniObjectFlagLast) != 0 { parts = append(parts, "MiniObjectFlagLast") } return "MiniObjectFlags(" + strings.Join(parts, "|") + ")" } // ObjectFlags wraps GstObjectFlags // // The standard flags that an gstobject may have. type ObjectFlags C.gint const ( // ObjectFlagMayBeLeaked wraps GST_OBJECT_FLAG_MAY_BE_LEAKED // // the object is expected to stay alive even // after gst_deinit() has been called and so should be ignored by leak // detection tools. (Since: 1.10) ObjectFlagMayBeLeaked ObjectFlags = 1 // ObjectFlagConstructed wraps GST_OBJECT_FLAG_CONSTRUCTED // // Flag that's set when the object has been constructed. This can be used by // API such as base class setters to differentiate between the case where // they're called from a subclass's instance init function (and where the // object isn't fully constructed yet, and so one shouldn't do anything but // set values in the instance structure), and the case where the object is // constructed. ObjectFlagConstructed ObjectFlags = 2 // ObjectFlagLast wraps GST_OBJECT_FLAG_LAST // // subclasses can add additional flags starting from this flag ObjectFlagLast ObjectFlags = 16 ) func marshalObjectFlags(p unsafe.Pointer) (any, error) { return ObjectFlags(gobject.ValueFromNative(p).Flags()), nil } // Has returns true if o contains other func (o ObjectFlags) Has(other ObjectFlags) bool { return (o & other) == other } var _ gobject.GoValueInitializer = ObjectFlags(0) func (f ObjectFlags) InitGoValue(v *gobject.Value) { v.Init(TypeObjectFlags) v.SetFlags(int(f)) } func (f ObjectFlags) String() string { if f == 0 { return "ObjectFlags(0)" } var parts []string if (f & ObjectFlagMayBeLeaked) != 0 { parts = append(parts, "ObjectFlagMayBeLeaked") } if (f & ObjectFlagConstructed) != 0 { parts = append(parts, "ObjectFlagConstructed") } if (f & ObjectFlagLast) != 0 { parts = append(parts, "ObjectFlagLast") } return "ObjectFlags(" + strings.Join(parts, "|") + ")" } // PadFlags wraps GstPadFlags // // Pad state flags type PadFlags C.gint const ( // PadFlagBlocked wraps GST_PAD_FLAG_BLOCKED // // is dataflow on a pad blocked PadFlagBlocked PadFlags = 16 // PadFlagFlushing wraps GST_PAD_FLAG_FLUSHING // // is pad flushing PadFlagFlushing PadFlags = 32 // PadFlagEos wraps GST_PAD_FLAG_EOS // // is pad in EOS state PadFlagEos PadFlags = 64 // PadFlagBlocking wraps GST_PAD_FLAG_BLOCKING // // is pad currently blocking on a buffer or event PadFlagBlocking PadFlags = 128 // PadFlagNeedParent wraps GST_PAD_FLAG_NEED_PARENT // // ensure that there is a parent object before calling // into the pad callbacks. PadFlagNeedParent PadFlags = 256 // PadFlagNeedReconfigure wraps GST_PAD_FLAG_NEED_RECONFIGURE // // the pad should be reconfigured/renegotiated. // The flag has to be unset manually after // reconfiguration happened. PadFlagNeedReconfigure PadFlags = 512 // PadFlagPendingEvents wraps GST_PAD_FLAG_PENDING_EVENTS // // the pad has pending events PadFlagPendingEvents PadFlags = 1024 // PadFlagFixedCaps wraps GST_PAD_FLAG_FIXED_CAPS // // the pad is using fixed caps. This means that // once the caps are set on the pad, the default caps query function // will only return those caps. PadFlagFixedCaps PadFlags = 2048 // PadFlagProxyCaps wraps GST_PAD_FLAG_PROXY_CAPS // // the default event and query handler will forward // all events and queries to the internally linked pads // instead of discarding them. PadFlagProxyCaps PadFlags = 4096 // PadFlagProxyAllocation wraps GST_PAD_FLAG_PROXY_ALLOCATION // // the default query handler will forward // allocation queries to the internally linked pads // instead of discarding them. PadFlagProxyAllocation PadFlags = 8192 // PadFlagProxyScheduling wraps GST_PAD_FLAG_PROXY_SCHEDULING // // the default query handler will forward // scheduling queries to the internally linked pads // instead of discarding them. PadFlagProxyScheduling PadFlags = 16384 // PadFlagAcceptIntersect wraps GST_PAD_FLAG_ACCEPT_INTERSECT // // the default accept-caps handler will check // it the caps intersect the query-caps result instead // of checking for a subset. This is interesting for // parsers that can accept incompletely specified caps. PadFlagAcceptIntersect PadFlags = 32768 // PadFlagAcceptTemplate wraps GST_PAD_FLAG_ACCEPT_TEMPLATE // // the default accept-caps handler will use // the template pad caps instead of query caps to // compare with the accept caps. Use this in combination // with %GST_PAD_FLAG_ACCEPT_INTERSECT. (Since: 1.6) PadFlagAcceptTemplate PadFlags = 65536 // PadFlagLast wraps GST_PAD_FLAG_LAST // // offset to define more flags PadFlagLast PadFlags = 1048576 ) func marshalPadFlags(p unsafe.Pointer) (any, error) { return PadFlags(gobject.ValueFromNative(p).Flags()), nil } // Has returns true if p contains other func (p PadFlags) Has(other PadFlags) bool { return (p & other) == other } var _ gobject.GoValueInitializer = PadFlags(0) func (f PadFlags) InitGoValue(v *gobject.Value) { v.Init(TypePadFlags) v.SetFlags(int(f)) } func (f PadFlags) String() string { if f == 0 { return "PadFlags(0)" } var parts []string if (f & PadFlagBlocked) != 0 { parts = append(parts, "PadFlagBlocked") } if (f & PadFlagFlushing) != 0 { parts = append(parts, "PadFlagFlushing") } if (f & PadFlagEos) != 0 { parts = append(parts, "PadFlagEos") } if (f & PadFlagBlocking) != 0 { parts = append(parts, "PadFlagBlocking") } if (f & PadFlagNeedParent) != 0 { parts = append(parts, "PadFlagNeedParent") } if (f & PadFlagNeedReconfigure) != 0 { parts = append(parts, "PadFlagNeedReconfigure") } if (f & PadFlagPendingEvents) != 0 { parts = append(parts, "PadFlagPendingEvents") } if (f & PadFlagFixedCaps) != 0 { parts = append(parts, "PadFlagFixedCaps") } if (f & PadFlagProxyCaps) != 0 { parts = append(parts, "PadFlagProxyCaps") } if (f & PadFlagProxyAllocation) != 0 { parts = append(parts, "PadFlagProxyAllocation") } if (f & PadFlagProxyScheduling) != 0 { parts = append(parts, "PadFlagProxyScheduling") } if (f & PadFlagAcceptIntersect) != 0 { parts = append(parts, "PadFlagAcceptIntersect") } if (f & PadFlagAcceptTemplate) != 0 { parts = append(parts, "PadFlagAcceptTemplate") } if (f & PadFlagLast) != 0 { parts = append(parts, "PadFlagLast") } return "PadFlags(" + strings.Join(parts, "|") + ")" } // PadLinkCheck wraps GstPadLinkCheck // // The amount of checking to be done when linking pads. @GST_PAD_LINK_CHECK_CAPS // and @GST_PAD_LINK_CHECK_TEMPLATE_CAPS are mutually exclusive. If both are // specified, expensive but safe @GST_PAD_LINK_CHECK_CAPS are performed. // // > Only disable some of the checks if you are 100% certain you know the link // > will not fail because of hierarchy/caps compatibility failures. If uncertain, // > use the default checks (%GST_PAD_LINK_CHECK_DEFAULT) or the regular methods // > for linking the pads. type PadLinkCheck C.gint const ( // PadLinkCheckNothing wraps GST_PAD_LINK_CHECK_NOTHING // // Don't check hierarchy or caps compatibility. PadLinkCheckNothing PadLinkCheck = 0 // PadLinkCheckHierarchy wraps GST_PAD_LINK_CHECK_HIERARCHY // // Check the pads have same parents/grandparents. // Could be omitted if it is already known that the two elements that own the // pads are in the same bin. PadLinkCheckHierarchy PadLinkCheck = 1 // PadLinkCheckTemplateCaps wraps GST_PAD_LINK_CHECK_TEMPLATE_CAPS // // Check if the pads are compatible by using // their template caps. This is much faster than @GST_PAD_LINK_CHECK_CAPS, but // would be unsafe e.g. if one pad has %GST_CAPS_ANY. PadLinkCheckTemplateCaps PadLinkCheck = 2 // PadLinkCheckCaps wraps GST_PAD_LINK_CHECK_CAPS // // Check if the pads are compatible by comparing the // caps returned by gst_pad_query_caps(). PadLinkCheckCaps PadLinkCheck = 4 // PadLinkCheckNoReconfigure wraps GST_PAD_LINK_CHECK_NO_RECONFIGURE // // Disables pushing a reconfigure event when pads are // linked. PadLinkCheckNoReconfigure PadLinkCheck = 8 // PadLinkCheckDefault wraps GST_PAD_LINK_CHECK_DEFAULT // // The default checks done when linking // pads (i.e. the ones used by gst_pad_link()). PadLinkCheckDefault PadLinkCheck = 5 ) func marshalPadLinkCheck(p unsafe.Pointer) (any, error) { return PadLinkCheck(gobject.ValueFromNative(p).Flags()), nil } // Has returns true if p contains other func (p PadLinkCheck) Has(other PadLinkCheck) bool { return (p & other) == other } var _ gobject.GoValueInitializer = PadLinkCheck(0) func (f PadLinkCheck) InitGoValue(v *gobject.Value) { v.Init(TypePadLinkCheck) v.SetFlags(int(f)) } func (f PadLinkCheck) String() string { if f == 0 { return "PadLinkCheck(0)" } var parts []string if (f & PadLinkCheckNothing) != 0 { parts = append(parts, "PadLinkCheckNothing") } if (f & PadLinkCheckHierarchy) != 0 { parts = append(parts, "PadLinkCheckHierarchy") } if (f & PadLinkCheckTemplateCaps) != 0 { parts = append(parts, "PadLinkCheckTemplateCaps") } if (f & PadLinkCheckCaps) != 0 { parts = append(parts, "PadLinkCheckCaps") } if (f & PadLinkCheckNoReconfigure) != 0 { parts = append(parts, "PadLinkCheckNoReconfigure") } if (f & PadLinkCheckDefault) != 0 { parts = append(parts, "PadLinkCheckDefault") } return "PadLinkCheck(" + strings.Join(parts, "|") + ")" } // PadProbeType wraps GstPadProbeType // // The different probing types that can occur. When either one of // @GST_PAD_PROBE_TYPE_IDLE or @GST_PAD_PROBE_TYPE_BLOCK is used, the probe will be a // blocking probe. type PadProbeType C.gint const ( // PadProbeTypeInvalid wraps GST_PAD_PROBE_TYPE_INVALID // // invalid probe type PadProbeTypeInvalid PadProbeType = 0 // PadProbeTypeIdle wraps GST_PAD_PROBE_TYPE_IDLE // // probe idle pads and block while the callback is called PadProbeTypeIdle PadProbeType = 1 // PadProbeTypeBlock wraps GST_PAD_PROBE_TYPE_BLOCK // // probe and block pads PadProbeTypeBlock PadProbeType = 2 // PadProbeTypeBuffer wraps GST_PAD_PROBE_TYPE_BUFFER // // probe buffers PadProbeTypeBuffer PadProbeType = 16 // PadProbeTypeBufferList wraps GST_PAD_PROBE_TYPE_BUFFER_LIST // // probe buffer lists PadProbeTypeBufferList PadProbeType = 32 // PadProbeTypeEventDownstream wraps GST_PAD_PROBE_TYPE_EVENT_DOWNSTREAM // // probe downstream events PadProbeTypeEventDownstream PadProbeType = 64 // PadProbeTypeEventUpstream wraps GST_PAD_PROBE_TYPE_EVENT_UPSTREAM // // probe upstream events PadProbeTypeEventUpstream PadProbeType = 128 // PadProbeTypeEventFlush wraps GST_PAD_PROBE_TYPE_EVENT_FLUSH // // probe flush events. This probe has to be // explicitly enabled and is not included in the // @@GST_PAD_PROBE_TYPE_EVENT_DOWNSTREAM or // @@GST_PAD_PROBE_TYPE_EVENT_UPSTREAM probe types. PadProbeTypeEventFlush PadProbeType = 256 // PadProbeTypeQueryDownstream wraps GST_PAD_PROBE_TYPE_QUERY_DOWNSTREAM // // probe downstream queries PadProbeTypeQueryDownstream PadProbeType = 512 // PadProbeTypeQueryUpstream wraps GST_PAD_PROBE_TYPE_QUERY_UPSTREAM // // probe upstream queries PadProbeTypeQueryUpstream PadProbeType = 1024 // PadProbeTypePush wraps GST_PAD_PROBE_TYPE_PUSH // // probe push PadProbeTypePush PadProbeType = 4096 // PadProbeTypePull wraps GST_PAD_PROBE_TYPE_PULL // // probe pull PadProbeTypePull PadProbeType = 8192 // PadProbeTypeBlocking wraps GST_PAD_PROBE_TYPE_BLOCKING // // probe and block at the next opportunity, at data flow or when idle PadProbeTypeBlocking PadProbeType = 3 // PadProbeTypeDataDownstream wraps GST_PAD_PROBE_TYPE_DATA_DOWNSTREAM // // probe downstream data (buffers, buffer lists, and events) PadProbeTypeDataDownstream PadProbeType = 112 // PadProbeTypeDataUpstream wraps GST_PAD_PROBE_TYPE_DATA_UPSTREAM // // probe upstream data (events) PadProbeTypeDataUpstream PadProbeType = 128 // PadProbeTypeDataBoth wraps GST_PAD_PROBE_TYPE_DATA_BOTH // // probe upstream and downstream data (buffers, buffer lists, and events) PadProbeTypeDataBoth PadProbeType = 240 // PadProbeTypeBlockDownstream wraps GST_PAD_PROBE_TYPE_BLOCK_DOWNSTREAM // // probe and block downstream data (buffers, buffer lists, and events) PadProbeTypeBlockDownstream PadProbeType = 114 // PadProbeTypeBlockUpstream wraps GST_PAD_PROBE_TYPE_BLOCK_UPSTREAM // // probe and block upstream data (events) PadProbeTypeBlockUpstream PadProbeType = 130 // PadProbeTypeEventBoth wraps GST_PAD_PROBE_TYPE_EVENT_BOTH // // probe upstream and downstream events PadProbeTypeEventBoth PadProbeType = 192 // PadProbeTypeQueryBoth wraps GST_PAD_PROBE_TYPE_QUERY_BOTH // // probe upstream and downstream queries PadProbeTypeQueryBoth PadProbeType = 1536 // PadProbeTypeAllBoth wraps GST_PAD_PROBE_TYPE_ALL_BOTH // // probe upstream events and queries and downstream buffers, buffer lists, events and queries PadProbeTypeAllBoth PadProbeType = 1776 // PadProbeTypeScheduling wraps GST_PAD_PROBE_TYPE_SCHEDULING // // probe push and pull PadProbeTypeScheduling PadProbeType = 12288 ) func marshalPadProbeType(p unsafe.Pointer) (any, error) { return PadProbeType(gobject.ValueFromNative(p).Flags()), nil } // Has returns true if p contains other func (p PadProbeType) Has(other PadProbeType) bool { return (p & other) == other } var _ gobject.GoValueInitializer = PadProbeType(0) func (f PadProbeType) InitGoValue(v *gobject.Value) { v.Init(TypePadProbeType) v.SetFlags(int(f)) } func (f PadProbeType) String() string { if f == 0 { return "PadProbeType(0)" } var parts []string if (f & PadProbeTypeInvalid) != 0 { parts = append(parts, "PadProbeTypeInvalid") } if (f & PadProbeTypeIdle) != 0 { parts = append(parts, "PadProbeTypeIdle") } if (f & PadProbeTypeBlock) != 0 { parts = append(parts, "PadProbeTypeBlock") } if (f & PadProbeTypeBuffer) != 0 { parts = append(parts, "PadProbeTypeBuffer") } if (f & PadProbeTypeBufferList) != 0 { parts = append(parts, "PadProbeTypeBufferList") } if (f & PadProbeTypeEventDownstream) != 0 { parts = append(parts, "PadProbeTypeEventDownstream") } if (f & PadProbeTypeEventUpstream) != 0 { parts = append(parts, "PadProbeTypeEventUpstream") } if (f & PadProbeTypeEventFlush) != 0 { parts = append(parts, "PadProbeTypeEventFlush") } if (f & PadProbeTypeQueryDownstream) != 0 { parts = append(parts, "PadProbeTypeQueryDownstream") } if (f & PadProbeTypeQueryUpstream) != 0 { parts = append(parts, "PadProbeTypeQueryUpstream") } if (f & PadProbeTypePush) != 0 { parts = append(parts, "PadProbeTypePush") } if (f & PadProbeTypePull) != 0 { parts = append(parts, "PadProbeTypePull") } if (f & PadProbeTypeBlocking) != 0 { parts = append(parts, "PadProbeTypeBlocking") } if (f & PadProbeTypeDataDownstream) != 0 { parts = append(parts, "PadProbeTypeDataDownstream") } if (f & PadProbeTypeDataUpstream) != 0 { parts = append(parts, "PadProbeTypeDataUpstream") } if (f & PadProbeTypeDataBoth) != 0 { parts = append(parts, "PadProbeTypeDataBoth") } if (f & PadProbeTypeBlockDownstream) != 0 { parts = append(parts, "PadProbeTypeBlockDownstream") } if (f & PadProbeTypeBlockUpstream) != 0 { parts = append(parts, "PadProbeTypeBlockUpstream") } if (f & PadProbeTypeEventBoth) != 0 { parts = append(parts, "PadProbeTypeEventBoth") } if (f & PadProbeTypeQueryBoth) != 0 { parts = append(parts, "PadProbeTypeQueryBoth") } if (f & PadProbeTypeAllBoth) != 0 { parts = append(parts, "PadProbeTypeAllBoth") } if (f & PadProbeTypeScheduling) != 0 { parts = append(parts, "PadProbeTypeScheduling") } return "PadProbeType(" + strings.Join(parts, "|") + ")" } // PadTemplateFlags wraps GstPadTemplateFlags // // Flags for the padtemplate type PadTemplateFlags C.gint const ( // PadTemplateFlagLast wraps GST_PAD_TEMPLATE_FLAG_LAST // // first flag that can be used by subclasses. PadTemplateFlagLast PadTemplateFlags = 256 ) func marshalPadTemplateFlags(p unsafe.Pointer) (any, error) { return PadTemplateFlags(gobject.ValueFromNative(p).Flags()), nil } // Has returns true if p contains other func (p PadTemplateFlags) Has(other PadTemplateFlags) bool { return (p & other) == other } var _ gobject.GoValueInitializer = PadTemplateFlags(0) func (f PadTemplateFlags) InitGoValue(v *gobject.Value) { v.Init(TypePadTemplateFlags) v.SetFlags(int(f)) } func (f PadTemplateFlags) String() string { if f == 0 { return "PadTemplateFlags(0)" } var parts []string if (f & PadTemplateFlagLast) != 0 { parts = append(parts, "PadTemplateFlagLast") } return "PadTemplateFlags(" + strings.Join(parts, "|") + ")" } // ParseFlags wraps GstParseFlags // // Parsing options. type ParseFlags C.gint const ( // ParseFlagNone wraps GST_PARSE_FLAG_NONE // // Do not use any special parsing options. ParseFlagNone ParseFlags = 0 // ParseFlagFatalErrors wraps GST_PARSE_FLAG_FATAL_ERRORS // // Always return %NULL when an error occurs // (default behaviour is to return partially constructed bins or elements // in some cases) ParseFlagFatalErrors ParseFlags = 1 // ParseFlagNoSingleElementBins wraps GST_PARSE_FLAG_NO_SINGLE_ELEMENT_BINS // // If a bin only has a single element, // just return the element. ParseFlagNoSingleElementBins ParseFlags = 2 // ParseFlagPlaceInBin wraps GST_PARSE_FLAG_PLACE_IN_BIN // // If more than one toplevel element is described // by the pipeline description string, put them in a #GstBin instead of a // #GstPipeline. (Since: 1.10) ParseFlagPlaceInBin ParseFlags = 4 ) func marshalParseFlags(p unsafe.Pointer) (any, error) { return ParseFlags(gobject.ValueFromNative(p).Flags()), nil } // Has returns true if p contains other func (p ParseFlags) Has(other ParseFlags) bool { return (p & other) == other } var _ gobject.GoValueInitializer = ParseFlags(0) func (f ParseFlags) InitGoValue(v *gobject.Value) { v.Init(TypeParseFlags) v.SetFlags(int(f)) } func (f ParseFlags) String() string { if f == 0 { return "ParseFlags(0)" } var parts []string if (f & ParseFlagNone) != 0 { parts = append(parts, "ParseFlagNone") } if (f & ParseFlagFatalErrors) != 0 { parts = append(parts, "ParseFlagFatalErrors") } if (f & ParseFlagNoSingleElementBins) != 0 { parts = append(parts, "ParseFlagNoSingleElementBins") } if (f & ParseFlagPlaceInBin) != 0 { parts = append(parts, "ParseFlagPlaceInBin") } return "ParseFlags(" + strings.Join(parts, "|") + ")" } // PipelineFlags wraps GstPipelineFlags // // Pipeline flags type PipelineFlags C.gint const ( // PipelineFlagFixedClock wraps GST_PIPELINE_FLAG_FIXED_CLOCK // // this pipeline works with a fixed clock PipelineFlagFixedClock PipelineFlags = 524288 // PipelineFlagLast wraps GST_PIPELINE_FLAG_LAST // // offset to define more flags PipelineFlagLast PipelineFlags = 8388608 ) func marshalPipelineFlags(p unsafe.Pointer) (any, error) { return PipelineFlags(gobject.ValueFromNative(p).Flags()), nil } // Has returns true if p contains other func (p PipelineFlags) Has(other PipelineFlags) bool { return (p & other) == other } var _ gobject.GoValueInitializer = PipelineFlags(0) func (f PipelineFlags) InitGoValue(v *gobject.Value) { v.Init(TypePipelineFlags) v.SetFlags(int(f)) } func (f PipelineFlags) String() string { if f == 0 { return "PipelineFlags(0)" } var parts []string if (f & PipelineFlagFixedClock) != 0 { parts = append(parts, "PipelineFlagFixedClock") } if (f & PipelineFlagLast) != 0 { parts = append(parts, "PipelineFlagLast") } return "PipelineFlags(" + strings.Join(parts, "|") + ")" } // PluginAPIFlags wraps GstPluginAPIFlags type PluginAPIFlags C.gint const ( // PluginApiFlagIgnoreEnumMembers wraps GST_PLUGIN_API_FLAG_IGNORE_ENUM_MEMBERS // // Ignore enum members when generating // the plugins cache. This is useful if the members of the enum are generated // dynamically, in order not to expose incorrect documentation to the end user. PluginApiFlagIgnoreEnumMembers PluginAPIFlags = 1 ) func marshalPluginAPIFlags(p unsafe.Pointer) (any, error) { return PluginAPIFlags(gobject.ValueFromNative(p).Flags()), nil } // Has returns true if p contains other func (p PluginAPIFlags) Has(other PluginAPIFlags) bool { return (p & other) == other } var _ gobject.GoValueInitializer = PluginAPIFlags(0) func (f PluginAPIFlags) InitGoValue(v *gobject.Value) { v.Init(TypePluginAPIFlags) v.SetFlags(int(f)) } func (f PluginAPIFlags) String() string { if f == 0 { return "PluginAPIFlags(0)" } var parts []string if (f & PluginApiFlagIgnoreEnumMembers) != 0 { parts = append(parts, "PluginApiFlagIgnoreEnumMembers") } return "PluginAPIFlags(" + strings.Join(parts, "|") + ")" } // PluginDependencyFlags wraps GstPluginDependencyFlags // // Flags used in connection with gst_plugin_add_dependency(). type PluginDependencyFlags C.gint const ( // PluginDependencyFlagNone wraps GST_PLUGIN_DEPENDENCY_FLAG_NONE // // no special flags PluginDependencyFlagNone PluginDependencyFlags = 0 // PluginDependencyFlagRecurse wraps GST_PLUGIN_DEPENDENCY_FLAG_RECURSE // // recurse into subdirectories PluginDependencyFlagRecurse PluginDependencyFlags = 1 // PluginDependencyFlagPathsAreDefaultOnly wraps GST_PLUGIN_DEPENDENCY_FLAG_PATHS_ARE_DEFAULT_ONLY // // use paths // argument only if none of the environment variables is set PluginDependencyFlagPathsAreDefaultOnly PluginDependencyFlags = 2 // PluginDependencyFlagFileNameIsSuffix wraps GST_PLUGIN_DEPENDENCY_FLAG_FILE_NAME_IS_SUFFIX // // interpret // filename argument as filter suffix and check all matching files in // the directory PluginDependencyFlagFileNameIsSuffix PluginDependencyFlags = 4 // PluginDependencyFlagFileNameIsPrefix wraps GST_PLUGIN_DEPENDENCY_FLAG_FILE_NAME_IS_PREFIX // // interpret // filename argument as filter prefix and check all matching files in // the directory. Since: 1.8. PluginDependencyFlagFileNameIsPrefix PluginDependencyFlags = 8 // PluginDependencyFlagPathsAreRelativeToExe wraps GST_PLUGIN_DEPENDENCY_FLAG_PATHS_ARE_RELATIVE_TO_EXE // // interpret // non-absolute paths as relative to the main executable directory. Since // 1.14. PluginDependencyFlagPathsAreRelativeToExe PluginDependencyFlags = 16 ) func marshalPluginDependencyFlags(p unsafe.Pointer) (any, error) { return PluginDependencyFlags(gobject.ValueFromNative(p).Flags()), nil } // Has returns true if p contains other func (p PluginDependencyFlags) Has(other PluginDependencyFlags) bool { return (p & other) == other } var _ gobject.GoValueInitializer = PluginDependencyFlags(0) func (f PluginDependencyFlags) InitGoValue(v *gobject.Value) { v.Init(TypePluginDependencyFlags) v.SetFlags(int(f)) } func (f PluginDependencyFlags) String() string { if f == 0 { return "PluginDependencyFlags(0)" } var parts []string if (f & PluginDependencyFlagNone) != 0 { parts = append(parts, "PluginDependencyFlagNone") } if (f & PluginDependencyFlagRecurse) != 0 { parts = append(parts, "PluginDependencyFlagRecurse") } if (f & PluginDependencyFlagPathsAreDefaultOnly) != 0 { parts = append(parts, "PluginDependencyFlagPathsAreDefaultOnly") } if (f & PluginDependencyFlagFileNameIsSuffix) != 0 { parts = append(parts, "PluginDependencyFlagFileNameIsSuffix") } if (f & PluginDependencyFlagFileNameIsPrefix) != 0 { parts = append(parts, "PluginDependencyFlagFileNameIsPrefix") } if (f & PluginDependencyFlagPathsAreRelativeToExe) != 0 { parts = append(parts, "PluginDependencyFlagPathsAreRelativeToExe") } return "PluginDependencyFlags(" + strings.Join(parts, "|") + ")" } // PluginFlags wraps GstPluginFlags // // The plugin loading state type PluginFlags C.gint const ( // PluginFlagCached wraps GST_PLUGIN_FLAG_CACHED // // Temporarily loaded plugins PluginFlagCached PluginFlags = 16 // PluginFlagBlacklisted wraps GST_PLUGIN_FLAG_BLACKLISTED // // The plugin won't be scanned (again) PluginFlagBlacklisted PluginFlags = 32 ) func marshalPluginFlags(p unsafe.Pointer) (any, error) { return PluginFlags(gobject.ValueFromNative(p).Flags()), nil } // Has returns true if p contains other func (p PluginFlags) Has(other PluginFlags) bool { return (p & other) == other } var _ gobject.GoValueInitializer = PluginFlags(0) func (f PluginFlags) InitGoValue(v *gobject.Value) { v.Init(TypePluginFlags) v.SetFlags(int(f)) } func (f PluginFlags) String() string { if f == 0 { return "PluginFlags(0)" } var parts []string if (f & PluginFlagCached) != 0 { parts = append(parts, "PluginFlagCached") } if (f & PluginFlagBlacklisted) != 0 { parts = append(parts, "PluginFlagBlacklisted") } return "PluginFlags(" + strings.Join(parts, "|") + ")" } // QueryTypeFlags wraps GstQueryTypeFlags // // #GstQueryTypeFlags indicate the aspects of the different #GstQueryType // values. You can get the type flags of a #GstQueryType with the // gst_query_type_get_flags() function. type QueryTypeFlags C.gint const ( // QueryTypeUpstream wraps GST_QUERY_TYPE_UPSTREAM // // Set if the query can travel upstream. QueryTypeUpstream QueryTypeFlags = 1 // QueryTypeDownstream wraps GST_QUERY_TYPE_DOWNSTREAM // // Set if the query can travel downstream. QueryTypeDownstream QueryTypeFlags = 2 // QueryTypeSerialized wraps GST_QUERY_TYPE_SERIALIZED // // Set if the query should be serialized with data // flow. QueryTypeSerialized QueryTypeFlags = 4 ) func marshalQueryTypeFlags(p unsafe.Pointer) (any, error) { return QueryTypeFlags(gobject.ValueFromNative(p).Flags()), nil } // Has returns true if q contains other func (q QueryTypeFlags) Has(other QueryTypeFlags) bool { return (q & other) == other } var _ gobject.GoValueInitializer = QueryTypeFlags(0) func (f QueryTypeFlags) InitGoValue(v *gobject.Value) { v.Init(TypeQueryTypeFlags) v.SetFlags(int(f)) } func (f QueryTypeFlags) String() string { if f == 0 { return "QueryTypeFlags(0)" } var parts []string if (f & QueryTypeUpstream) != 0 { parts = append(parts, "QueryTypeUpstream") } if (f & QueryTypeDownstream) != 0 { parts = append(parts, "QueryTypeDownstream") } if (f & QueryTypeSerialized) != 0 { parts = append(parts, "QueryTypeSerialized") } return "QueryTypeFlags(" + strings.Join(parts, "|") + ")" } // SchedulingFlags wraps GstSchedulingFlags // // The different scheduling flags. type SchedulingFlags C.gint const ( // SchedulingFlagSeekable wraps GST_SCHEDULING_FLAG_SEEKABLE // // if seeking is possible SchedulingFlagSeekable SchedulingFlags = 1 // SchedulingFlagSequential wraps GST_SCHEDULING_FLAG_SEQUENTIAL // // if sequential access is recommended SchedulingFlagSequential SchedulingFlags = 2 // SchedulingFlagBandwidthLimited wraps GST_SCHEDULING_FLAG_BANDWIDTH_LIMITED // // if bandwidth is limited and buffering possible (since 1.2) SchedulingFlagBandwidthLimited SchedulingFlags = 4 ) func marshalSchedulingFlags(p unsafe.Pointer) (any, error) { return SchedulingFlags(gobject.ValueFromNative(p).Flags()), nil } // Has returns true if s contains other func (s SchedulingFlags) Has(other SchedulingFlags) bool { return (s & other) == other } var _ gobject.GoValueInitializer = SchedulingFlags(0) func (f SchedulingFlags) InitGoValue(v *gobject.Value) { v.Init(TypeSchedulingFlags) v.SetFlags(int(f)) } func (f SchedulingFlags) String() string { if f == 0 { return "SchedulingFlags(0)" } var parts []string if (f & SchedulingFlagSeekable) != 0 { parts = append(parts, "SchedulingFlagSeekable") } if (f & SchedulingFlagSequential) != 0 { parts = append(parts, "SchedulingFlagSequential") } if (f & SchedulingFlagBandwidthLimited) != 0 { parts = append(parts, "SchedulingFlagBandwidthLimited") } return "SchedulingFlags(" + strings.Join(parts, "|") + ")" } // SeekFlags wraps GstSeekFlags // // Flags to be used with gst_element_seek() or gst_event_new_seek(). All flags // can be used together. // // A non flushing seek might take some time to perform as the currently // playing data in the pipeline will not be cleared. // // An accurate seek might be slower for formats that don't have any indexes // or timestamp markers in the stream. Specifying this flag might require a // complete scan of the file in those cases. // // When performing a segment seek: after the playback of the segment completes, // no EOS will be emitted by the element that performed the seek, but a // %GST_MESSAGE_SEGMENT_DONE message will be posted on the bus by the element. // When this message is posted, it is possible to send a new seek event to // continue playback. With this seek method it is possible to perform seamless // looping or simple linear editing. // // When only changing the playback rate and not the direction, the // %GST_SEEK_FLAG_INSTANT_RATE_CHANGE flag can be used for a non-flushing seek // to signal that the rate change should be applied immediately. This requires // special support in the seek handlers (e.g. demuxers) and any elements // synchronizing to the clock, and in general can't work in all cases (for example // UDP streaming where the delivery rate is controlled by a remote server). The // instant-rate-change mode supports changing the trickmode-related GST_SEEK_ flags, // but can't be used in conjunction with other seek flags that affect the new // playback position - as the playback position will not be changing. // // When doing fast forward (rate > 1.0) or fast reverse (rate < -1.0) trickmode // playback, the %GST_SEEK_FLAG_TRICKMODE flag can be used to instruct decoders // and demuxers to adjust the playback rate by skipping frames. This can improve // performance and decrease CPU usage because not all frames need to be decoded. // // Beyond that, the %GST_SEEK_FLAG_TRICKMODE_KEY_UNITS flag can be used to // request that decoders skip all frames except key units, and // %GST_SEEK_FLAG_TRICKMODE_NO_AUDIO flags can be used to request that audio // decoders do no decoding at all, and simple output silence. // // The %GST_SEEK_FLAG_SNAP_BEFORE flag can be used to snap to the previous // relevant location, and the %GST_SEEK_FLAG_SNAP_AFTER flag can be used to // select the next relevant location. If %GST_SEEK_FLAG_KEY_UNIT is specified, // the relevant location is a keyframe. If both flags are specified, the nearest // of these locations will be selected. If none are specified, the implementation is // free to select whichever it wants. // // The before and after here are in running time, so when playing backwards, // the next location refers to the one that will played in next, and not the // one that is located after in the actual source stream. // // Also see part-seeking.txt in the GStreamer design documentation for more // details on the meaning of these flags and the behaviour expected of // elements that handle them. type SeekFlags C.gint const ( // SeekFlagNone wraps GST_SEEK_FLAG_NONE // // no flag SeekFlagNone SeekFlags = 0 // SeekFlagFlush wraps GST_SEEK_FLAG_FLUSH // // flush pipeline SeekFlagFlush SeekFlags = 1 // SeekFlagAccurate wraps GST_SEEK_FLAG_ACCURATE // // accurate position is requested, this might // be considerably slower for some formats. SeekFlagAccurate SeekFlags = 2 // SeekFlagKeyUnit wraps GST_SEEK_FLAG_KEY_UNIT // // seek to the nearest keyframe. This might be // faster but less accurate. SeekFlagKeyUnit SeekFlags = 4 // SeekFlagSegment wraps GST_SEEK_FLAG_SEGMENT // // perform a segment seek. SeekFlagSegment SeekFlags = 8 // SeekFlagTrickmode wraps GST_SEEK_FLAG_TRICKMODE // // when doing fast forward or fast reverse playback, allow // elements to skip frames instead of generating all // frames. (Since: 1.6) SeekFlagTrickmode SeekFlags = 16 // SeekFlagSkip wraps GST_SEEK_FLAG_SKIP // // Deprecated backward compatibility flag, replaced // by %GST_SEEK_FLAG_TRICKMODE SeekFlagSkip SeekFlags = 16 // SeekFlagSnapBefore wraps GST_SEEK_FLAG_SNAP_BEFORE // // go to a location before the requested position, // if %GST_SEEK_FLAG_KEY_UNIT this means the keyframe at or before // the requested position the one at or before the seek target. SeekFlagSnapBefore SeekFlags = 32 // SeekFlagSnapAfter wraps GST_SEEK_FLAG_SNAP_AFTER // // go to a location after the requested position, // if %GST_SEEK_FLAG_KEY_UNIT this means the keyframe at of after the // requested position. SeekFlagSnapAfter SeekFlags = 64 // SeekFlagSnapNearest wraps GST_SEEK_FLAG_SNAP_NEAREST // // go to a position near the requested position, // if %GST_SEEK_FLAG_KEY_UNIT this means the keyframe closest // to the requested position, if both keyframes are at an equal // distance, behaves like %GST_SEEK_FLAG_SNAP_BEFORE. SeekFlagSnapNearest SeekFlags = 96 // SeekFlagTrickmodeKeyUnits wraps GST_SEEK_FLAG_TRICKMODE_KEY_UNITS // // when doing fast forward or fast reverse // playback, request that elements only decode keyframes // and skip all other content, for formats that have // keyframes. (Since: 1.6) SeekFlagTrickmodeKeyUnits SeekFlags = 128 // SeekFlagTrickmodeNoAudio wraps GST_SEEK_FLAG_TRICKMODE_NO_AUDIO // // when doing fast forward or fast reverse // playback, request that audio decoder elements skip // decoding and output only gap events or silence. (Since: 1.6) SeekFlagTrickmodeNoAudio SeekFlags = 256 // SeekFlagTrickmodeForwardPredicted wraps GST_SEEK_FLAG_TRICKMODE_FORWARD_PREDICTED // // When doing fast forward or fast reverse // playback, request that elements only decode keyframes and // forward predicted frames and skip all other content (for example // B-Frames), for formats that have keyframes and forward predicted // frames. (Since: 1.18) SeekFlagTrickmodeForwardPredicted SeekFlags = 512 // SeekFlagInstantRateChange wraps GST_SEEK_FLAG_INSTANT_RATE_CHANGE // // Signals that a rate change should be // applied immediately. Only valid if start/stop position // are GST_CLOCK_TIME_NONE, the playback direction does not change // and the seek is not flushing. (Since: 1.18) SeekFlagInstantRateChange SeekFlags = 1024 ) func marshalSeekFlags(p unsafe.Pointer) (any, error) { return SeekFlags(gobject.ValueFromNative(p).Flags()), nil } // Has returns true if s contains other func (s SeekFlags) Has(other SeekFlags) bool { return (s & other) == other } var _ gobject.GoValueInitializer = SeekFlags(0) func (f SeekFlags) InitGoValue(v *gobject.Value) { v.Init(TypeSeekFlags) v.SetFlags(int(f)) } func (f SeekFlags) String() string { if f == 0 { return "SeekFlags(0)" } var parts []string if (f & SeekFlagNone) != 0 { parts = append(parts, "SeekFlagNone") } if (f & SeekFlagFlush) != 0 { parts = append(parts, "SeekFlagFlush") } if (f & SeekFlagAccurate) != 0 { parts = append(parts, "SeekFlagAccurate") } if (f & SeekFlagKeyUnit) != 0 { parts = append(parts, "SeekFlagKeyUnit") } if (f & SeekFlagSegment) != 0 { parts = append(parts, "SeekFlagSegment") } if (f & SeekFlagTrickmode) != 0 { parts = append(parts, "SeekFlagTrickmode") } if (f & SeekFlagSkip) != 0 { parts = append(parts, "SeekFlagSkip") } if (f & SeekFlagSnapBefore) != 0 { parts = append(parts, "SeekFlagSnapBefore") } if (f & SeekFlagSnapAfter) != 0 { parts = append(parts, "SeekFlagSnapAfter") } if (f & SeekFlagSnapNearest) != 0 { parts = append(parts, "SeekFlagSnapNearest") } if (f & SeekFlagTrickmodeKeyUnits) != 0 { parts = append(parts, "SeekFlagTrickmodeKeyUnits") } if (f & SeekFlagTrickmodeNoAudio) != 0 { parts = append(parts, "SeekFlagTrickmodeNoAudio") } if (f & SeekFlagTrickmodeForwardPredicted) != 0 { parts = append(parts, "SeekFlagTrickmodeForwardPredicted") } if (f & SeekFlagInstantRateChange) != 0 { parts = append(parts, "SeekFlagInstantRateChange") } return "SeekFlags(" + strings.Join(parts, "|") + ")" } // SegmentFlags wraps GstSegmentFlags // // Flags for the GstSegment structure. Currently mapped to the corresponding // values of the seek flags. type SegmentFlags C.gint const ( // SegmentFlagNone wraps GST_SEGMENT_FLAG_NONE // // no flags SegmentFlagNone SegmentFlags = 0 // SegmentFlagReset wraps GST_SEGMENT_FLAG_RESET // // reset the pipeline running_time to the segment // running_time SegmentFlagReset SegmentFlags = 1 // SegmentFlagTrickmode wraps GST_SEGMENT_FLAG_TRICKMODE // // perform skip playback (Since: 1.6) SegmentFlagTrickmode SegmentFlags = 16 // SegmentFlagSkip wraps GST_SEGMENT_FLAG_SKIP // // Deprecated backward compatibility flag, replaced // by @GST_SEGMENT_FLAG_TRICKMODE SegmentFlagSkip SegmentFlags = 16 // SegmentFlagSegment wraps GST_SEGMENT_FLAG_SEGMENT // // send SEGMENT_DONE instead of EOS SegmentFlagSegment SegmentFlags = 8 // SegmentFlagTrickmodeKeyUnits wraps GST_SEGMENT_FLAG_TRICKMODE_KEY_UNITS // // Decode only keyframes, where // possible (Since: 1.6) SegmentFlagTrickmodeKeyUnits SegmentFlags = 128 // SegmentFlagTrickmodeForwardPredicted wraps GST_SEGMENT_FLAG_TRICKMODE_FORWARD_PREDICTED // // Decode only keyframes or forward // predicted frames, where possible (Since: 1.18) SegmentFlagTrickmodeForwardPredicted SegmentFlags = 512 // SegmentFlagTrickmodeNoAudio wraps GST_SEGMENT_FLAG_TRICKMODE_NO_AUDIO // // Do not decode any audio, where // possible (Since: 1.6) SegmentFlagTrickmodeNoAudio SegmentFlags = 256 ) func marshalSegmentFlags(p unsafe.Pointer) (any, error) { return SegmentFlags(gobject.ValueFromNative(p).Flags()), nil } // Has returns true if s contains other func (s SegmentFlags) Has(other SegmentFlags) bool { return (s & other) == other } var _ gobject.GoValueInitializer = SegmentFlags(0) func (f SegmentFlags) InitGoValue(v *gobject.Value) { v.Init(TypeSegmentFlags) v.SetFlags(int(f)) } func (f SegmentFlags) String() string { if f == 0 { return "SegmentFlags(0)" } var parts []string if (f & SegmentFlagNone) != 0 { parts = append(parts, "SegmentFlagNone") } if (f & SegmentFlagReset) != 0 { parts = append(parts, "SegmentFlagReset") } if (f & SegmentFlagTrickmode) != 0 { parts = append(parts, "SegmentFlagTrickmode") } if (f & SegmentFlagSkip) != 0 { parts = append(parts, "SegmentFlagSkip") } if (f & SegmentFlagSegment) != 0 { parts = append(parts, "SegmentFlagSegment") } if (f & SegmentFlagTrickmodeKeyUnits) != 0 { parts = append(parts, "SegmentFlagTrickmodeKeyUnits") } if (f & SegmentFlagTrickmodeForwardPredicted) != 0 { parts = append(parts, "SegmentFlagTrickmodeForwardPredicted") } if (f & SegmentFlagTrickmodeNoAudio) != 0 { parts = append(parts, "SegmentFlagTrickmodeNoAudio") } return "SegmentFlags(" + strings.Join(parts, "|") + ")" } // SerializeFlags wraps GstSerializeFlags type SerializeFlags C.gint const ( // SerializeFlagNone wraps GST_SERIALIZE_FLAG_NONE // // No special flags specified. SerializeFlagNone SerializeFlags = 0 // SerializeFlagBackwardCompat wraps GST_SERIALIZE_FLAG_BACKWARD_COMPAT // // Serialize using the old format for // nested structures. SerializeFlagBackwardCompat SerializeFlags = 1 // SerializeFlagStrict wraps GST_SERIALIZE_FLAG_STRICT // // Serialization fails if a value cannot be serialized instead of using // placeholder "NULL" value (e.g. pointers, objects). SerializeFlagStrict SerializeFlags = 2 ) func marshalSerializeFlags(p unsafe.Pointer) (any, error) { return SerializeFlags(gobject.ValueFromNative(p).Flags()), nil } // Has returns true if s contains other func (s SerializeFlags) Has(other SerializeFlags) bool { return (s & other) == other } var _ gobject.GoValueInitializer = SerializeFlags(0) func (f SerializeFlags) InitGoValue(v *gobject.Value) { v.Init(TypeSerializeFlags) v.SetFlags(int(f)) } func (f SerializeFlags) String() string { if f == 0 { return "SerializeFlags(0)" } var parts []string if (f & SerializeFlagNone) != 0 { parts = append(parts, "SerializeFlagNone") } if (f & SerializeFlagBackwardCompat) != 0 { parts = append(parts, "SerializeFlagBackwardCompat") } if (f & SerializeFlagStrict) != 0 { parts = append(parts, "SerializeFlagStrict") } return "SerializeFlags(" + strings.Join(parts, "|") + ")" } // StackTraceFlags wraps GstStackTraceFlags type StackTraceFlags C.gint const ( // StackTraceShowNone wraps GST_STACK_TRACE_SHOW_NONE // // Try to retrieve the minimum information // available, which may be none on some platforms // (Since: 1.18) StackTraceShowNone StackTraceFlags = 0 // StackTraceShowFull wraps GST_STACK_TRACE_SHOW_FULL // // Try to retrieve as much information as possible, // including source information when getting the // stack trace StackTraceShowFull StackTraceFlags = 1 ) func marshalStackTraceFlags(p unsafe.Pointer) (any, error) { return StackTraceFlags(gobject.ValueFromNative(p).Flags()), nil } // Has returns true if s contains other func (s StackTraceFlags) Has(other StackTraceFlags) bool { return (s & other) == other } var _ gobject.GoValueInitializer = StackTraceFlags(0) func (f StackTraceFlags) InitGoValue(v *gobject.Value) { v.Init(TypeStackTraceFlags) v.SetFlags(int(f)) } func (f StackTraceFlags) String() string { if f == 0 { return "StackTraceFlags(0)" } var parts []string if (f & StackTraceShowNone) != 0 { parts = append(parts, "StackTraceShowNone") } if (f & StackTraceShowFull) != 0 { parts = append(parts, "StackTraceShowFull") } return "StackTraceFlags(" + strings.Join(parts, "|") + ")" } // StreamFlags wraps GstStreamFlags type StreamFlags C.gint const ( // StreamFlagNone wraps GST_STREAM_FLAG_NONE // // This stream has no special attributes StreamFlagNone StreamFlags = 0 // StreamFlagSparse wraps GST_STREAM_FLAG_SPARSE // // This stream is a sparse stream (e.g. a subtitle // stream), data may flow only in irregular intervals with large gaps in // between. StreamFlagSparse StreamFlags = 1 // StreamFlagSelect wraps GST_STREAM_FLAG_SELECT // // This stream should be selected by default. This // flag may be used by demuxers to signal that a stream should be selected // by default in a playback scenario. StreamFlagSelect StreamFlags = 2 // StreamFlagUnselect wraps GST_STREAM_FLAG_UNSELECT // // This stream should not be selected by default. // This flag may be used by demuxers to signal that a stream should not // be selected by default in a playback scenario, but only if explicitly // selected by the user (e.g. an audio track for the hard of hearing or // a director's commentary track). StreamFlagUnselect StreamFlags = 4 ) func marshalStreamFlags(p unsafe.Pointer) (any, error) { return StreamFlags(gobject.ValueFromNative(p).Flags()), nil } // Has returns true if s contains other func (s StreamFlags) Has(other StreamFlags) bool { return (s & other) == other } var _ gobject.GoValueInitializer = StreamFlags(0) func (f StreamFlags) InitGoValue(v *gobject.Value) { v.Init(TypeStreamFlags) v.SetFlags(int(f)) } func (f StreamFlags) String() string { if f == 0 { return "StreamFlags(0)" } var parts []string if (f & StreamFlagNone) != 0 { parts = append(parts, "StreamFlagNone") } if (f & StreamFlagSparse) != 0 { parts = append(parts, "StreamFlagSparse") } if (f & StreamFlagSelect) != 0 { parts = append(parts, "StreamFlagSelect") } if (f & StreamFlagUnselect) != 0 { parts = append(parts, "StreamFlagUnselect") } return "StreamFlags(" + strings.Join(parts, "|") + ")" } // StreamType wraps GstStreamType // // #GstStreamType describes a high level classification set for // flows of data in #GstStream objects. // // Note that this is a flag, and therefore users should not assume it // will be a single value. Do not use the equality operator for checking // whether a stream is of a certain type. type StreamType C.gint const ( // StreamTypeUnknown wraps GST_STREAM_TYPE_UNKNOWN // // The stream is of unknown (unclassified) type. StreamTypeUnknown StreamType = 1 // StreamTypeAudio wraps GST_STREAM_TYPE_AUDIO // // The stream is of audio data StreamTypeAudio StreamType = 2 // StreamTypeVideo wraps GST_STREAM_TYPE_VIDEO // // The stream carries video data StreamTypeVideo StreamType = 4 // StreamTypeContainer wraps GST_STREAM_TYPE_CONTAINER // // The stream is a muxed container type StreamTypeContainer StreamType = 8 // StreamTypeText wraps GST_STREAM_TYPE_TEXT // // The stream contains subtitle / subpicture data. StreamTypeText StreamType = 16 ) func marshalStreamType(p unsafe.Pointer) (any, error) { return StreamType(gobject.ValueFromNative(p).Flags()), nil } // Has returns true if s contains other func (s StreamType) Has(other StreamType) bool { return (s & other) == other } var _ gobject.GoValueInitializer = StreamType(0) func (f StreamType) InitGoValue(v *gobject.Value) { v.Init(TypeStreamType) v.SetFlags(int(f)) } func (f StreamType) String() string { if f == 0 { return "StreamType(0)" } var parts []string if (f & StreamTypeUnknown) != 0 { parts = append(parts, "StreamTypeUnknown") } if (f & StreamTypeAudio) != 0 { parts = append(parts, "StreamTypeAudio") } if (f & StreamTypeVideo) != 0 { parts = append(parts, "StreamTypeVideo") } if (f & StreamTypeContainer) != 0 { parts = append(parts, "StreamTypeContainer") } if (f & StreamTypeText) != 0 { parts = append(parts, "StreamTypeText") } return "StreamType(" + strings.Join(parts, "|") + ")" } // StreamTypeGetName wraps gst_stream_type_get_name // // The function takes the following parameters: // // - stype StreamType: a #GstStreamType // // The function returns the following values: // // - goret string // // Get a descriptive string for a given #GstStreamType func StreamTypeGetName(stype StreamType) string { var carg1 C.GstStreamType // in, none, casted var cret *C.gchar // return, none, string carg1 = C.GstStreamType(stype) cret = C.gst_stream_type_get_name(carg1) runtime.KeepAlive(stype) var goret string goret = C.GoString((*C.char)(unsafe.Pointer(cret))) return goret } // TracerValueFlags wraps GstTracerValueFlags // // Flag that describe the value. These flags help applications processing the // logs to understand the values. type TracerValueFlags C.gint const ( // TracerValueFlagsNone wraps GST_TRACER_VALUE_FLAGS_NONE // // no flags TracerValueFlagsNone TracerValueFlags = 0 // TracerValueFlagsOptional wraps GST_TRACER_VALUE_FLAGS_OPTIONAL // // the value is optional. When using this flag // one need to have an additional boolean arg before this value in the // var-args list passed to gst_tracer_record_log(). TracerValueFlagsOptional TracerValueFlags = 1 // TracerValueFlagsAggregated wraps GST_TRACER_VALUE_FLAGS_AGGREGATED // // the value is a combined figure, since the // start of tracing. Examples are averages or timestamps. TracerValueFlagsAggregated TracerValueFlags = 2 ) func marshalTracerValueFlags(p unsafe.Pointer) (any, error) { return TracerValueFlags(gobject.ValueFromNative(p).Flags()), nil } // Has returns true if t contains other func (t TracerValueFlags) Has(other TracerValueFlags) bool { return (t & other) == other } var _ gobject.GoValueInitializer = TracerValueFlags(0) func (f TracerValueFlags) InitGoValue(v *gobject.Value) { v.Init(TypeTracerValueFlags) v.SetFlags(int(f)) } func (f TracerValueFlags) String() string { if f == 0 { return "TracerValueFlags(0)" } var parts []string if (f & TracerValueFlagsNone) != 0 { parts = append(parts, "TracerValueFlagsNone") } if (f & TracerValueFlagsOptional) != 0 { parts = append(parts, "TracerValueFlagsOptional") } if (f & TracerValueFlagsAggregated) != 0 { parts = append(parts, "TracerValueFlagsAggregated") } return "TracerValueFlags(" + strings.Join(parts, "|") + ")" } // BufferForEachMetaFunc wraps GstBufferForeachMetaFunc // // A function that will be called from gst_buffer_foreach_meta(). The @meta // field will point to a the reference of the meta. // // @buffer should not be modified from this callback. // // When this function returns %TRUE, the next meta will be // returned. When %FALSE is returned, gst_buffer_foreach_meta() will return. // // When @meta is set to %NULL, the item will be removed from the buffer. type BufferForEachMetaFunc func(buffer *Buffer) (meta *Meta, goret bool) // BufferListFunc wraps GstBufferListFunc // // A function that will be called from gst_buffer_list_foreach(). The @buffer // field will point to a the reference of the buffer at @idx. // // When this function returns %TRUE, the next buffer will be // returned. When %FALSE is returned, gst_buffer_list_foreach() will return. // // When @buffer is set to %NULL, the item will be removed from the bufferlist. // When @buffer has been made writable, the new buffer reference can be assigned // to @buffer. This function is responsible for unreffing the old buffer when // removing or modifying. type BufferListFunc func(idx uint) (buffer *Buffer, goret bool) // CapsFilterMapFunc wraps GstCapsFilterMapFunc // // A function that will be called in gst_caps_filter_and_map_in_place(). // The function may modify @features and @structure, and both will be // removed from the caps if %FALSE is returned. type CapsFilterMapFunc func(features *CapsFeatures, structure *Structure) (goret bool) // CapsForEachFunc wraps GstCapsForeachFunc // // A function that will be called in gst_caps_foreach(). The function may // not modify @features or @structure. type CapsForEachFunc func(features *CapsFeatures, structure *Structure) (goret bool) // CapsMapFunc wraps GstCapsMapFunc // // A function that will be called in gst_caps_map_in_place(). The function // may modify @features and @structure. type CapsMapFunc func(features *CapsFeatures, structure *Structure) (goret bool) // IteratorFoldFunction wraps GstIteratorFoldFunction // // A function to be passed to gst_iterator_fold(). type IteratorFoldFunction func(item *gobject.Value, ret *gobject.Value) (goret bool) // IteratorForEachFunction wraps GstIteratorForeachFunction // // A function that is called by gst_iterator_foreach() for every element. type IteratorForEachFunction func(item *gobject.Value) // LogFunction wraps GstLogFunction // // Function prototype for a logging function that can be registered with // gst_debug_add_log_function(). // Use G_GNUC_NO_INSTRUMENT on that function. type LogFunction func(category *DebugCategory, level DebugLevel, file string, function string, line int, object gobject.Object, message *DebugMessage) // MiniObjectNotify wraps GstMiniObjectNotify // // A #GstMiniObjectNotify function can be added to a mini object as a // callback that gets triggered when gst_mini_object_unref() drops the // last ref and @obj is about to be freed. type MiniObjectNotify func(obj *MiniObject) // PadForwardFunction wraps GstPadForwardFunction // // A forward function is called for all internally linked pads, see // gst_pad_forward(). type PadForwardFunction func(pad Pad) (goret bool) // PadProbeCallback wraps GstPadProbeCallback // // Callback used by gst_pad_add_probe(). Gets called to notify about the current // blocking type. // // The callback is allowed to modify the data pointer in @info. type PadProbeCallback func(pad Pad, info *PadProbeInfo) (goret PadProbeReturn) // PluginFeatureFilter wraps GstPluginFeatureFilter // // A function that can be used with e.g. gst_registry_feature_filter() // to get a list of pluginfeature that match certain criteria. type PluginFeatureFilter func(feature PluginFeature) (goret bool) // PluginFilter wraps GstPluginFilter // // A function that can be used with e.g. gst_registry_plugin_filter() // to get a list of plugins that match certain criteria. type PluginFilter func(plugin Plugin) (goret bool) // PluginInitFullFunc wraps GstPluginInitFullFunc // // A plugin should provide a pointer to a function of either #GstPluginInitFunc // or this type in the plugin_desc struct. // The function will be called by the loader at startup. One would then // register each #GstPluginFeature. This version allows // user data to be passed to init function (useful for bindings). type PluginInitFullFunc func(plugin Plugin) (goret bool) // PromiseChangeFunc wraps GstPromiseChangeFunc type PromiseChangeFunc func(promise *Promise) // StructureFilterMapFunc wraps GstStructureFilterMapFunc // // A function that will be called in gst_structure_filter_and_map_in_place(). // The function may modify @value, and the value will be removed from // the structure if %FALSE is returned. type StructureFilterMapFunc func(fieldId glib.Quark, value *gobject.Value) (goret bool) // StructureForEachFunc wraps GstStructureForeachFunc // // A function that will be called in gst_structure_foreach(). The function may // not modify @value. type StructureForEachFunc func(fieldId glib.Quark, value *gobject.Value) (goret bool) // StructureMapFunc wraps GstStructureMapFunc // // A function that will be called in gst_structure_map_in_place(). The function // may modify @value. type StructureMapFunc func(fieldId glib.Quark, value *gobject.Value) (goret bool) // TagForEachFunc wraps GstTagForeachFunc // // A function that will be called in gst_tag_list_foreach(). The function may // not modify the tag list. type TagForEachFunc func(list *TagList, tag string) // TaskFunction wraps GstTaskFunction // // A function that will repeatedly be called in the thread created by // a #GstTask. type TaskFunction func() // TaskPoolFunction wraps GstTaskPoolFunction // // Task function, see gst_task_pool_push(). type TaskPoolFunction func() // TypeFindFunction wraps GstTypeFindFunction // // A function that will be called by typefinding. type TypeFindFunction func(find *TypeFind) // BusFunc wraps GstBusFunc // // Specifies the type of function passed to gst_bus_add_watch() or // gst_bus_add_watch_full(), which is called from the mainloop when a message // is available on the bus. // // The message passed to the function will be unreffed after execution of this // function so it should not be freed in the function. // // Note that this function is used as a #GSourceFunc which means that returning // %FALSE will remove the #GSource from the mainloop. type BusFunc func(bus Bus, message *Message) (goret bool) // BusSyncHandler wraps GstBusSyncHandler // // Handler will be invoked synchronously, when a new message has been injected // into the bus. This function is mostly used internally. Only one sync handler // can be attached to a given bus. // // If the handler returns %GST_BUS_DROP, it should unref the message, else the // message should not be unreffed by the sync handler. type BusSyncHandler func(bus Bus, message *Message) (goret BusSyncReply) // ClockCallback wraps GstClockCallback // // The function prototype of the callback. type ClockCallback func(clock Clock, time ClockTime, id ClockID) (goret bool) // ElementCallAsyncFunc wraps GstElementCallAsyncFunc // // Callback prototype used in #gst_element_call_async type ElementCallAsyncFunc func(element Element) // ElementForEachPadFunc wraps GstElementForeachPadFunc // // Function called for each pad when using gst_element_foreach_sink_pad(), // gst_element_foreach_src_pad(), or gst_element_foreach_pad(). type ElementForEachPadFunc func(element Element, pad Pad) (goret bool) // DebugAddLogFunction wraps gst_debug_add_log_function // // The function takes the following parameters: // // - fn LogFunction: the function to use // // Adds the logging function to the list of logging functions. // Be sure to use #G_GNUC_NO_INSTRUMENT on that function, it is needed. func DebugAddLogFunction(fn LogFunction) { var carg1 C.GstLogFunction // callback, scope: notified, closure: carg2, destroy: carg3 var carg2 C.gpointer // implicit var carg3 C.GDestroyNotify // implicit carg1 = (*[0]byte)(C._gotk4_gst1_LogFunction) carg2 = C.gpointer(userdata.Register(fn)) carg3 = (C.GDestroyNotify)((*[0]byte)(C.destroyUserdata)) C.gst_debug_add_log_function(carg1, carg2, carg3) runtime.KeepAlive(fn) } // DebugAddRingBufferLogger wraps gst_debug_add_ring_buffer_logger // // The function takes the following parameters: // // - maxSizePerThread uint: Maximum size of log per thread in bytes // - threadTimeout uint: Timeout for threads in seconds // // Adds a memory ringbuffer based debug logger that stores up to // @max_size_per_thread bytes of logs per thread and times out threads after // @thread_timeout seconds of inactivity. // // Logs can be fetched with gst_debug_ring_buffer_logger_get_logs() and the // logger can be removed again with gst_debug_remove_ring_buffer_logger(). // Only one logger at a time is possible. func DebugAddRingBufferLogger(maxSizePerThread uint, threadTimeout uint) { var carg1 C.guint // in, none, casted var carg2 C.guint // in, none, casted carg1 = C.guint(maxSizePerThread) carg2 = C.guint(threadTimeout) C.gst_debug_add_ring_buffer_logger(carg1, carg2) runtime.KeepAlive(maxSizePerThread) runtime.KeepAlive(threadTimeout) } // DebugBinToDotData wraps gst_debug_bin_to_dot_data // // The function takes the following parameters: // // - bin Bin: the top-level pipeline that should be analyzed // - details DebugGraphDetails: type of #GstDebugGraphDetails to use // // The function returns the following values: // // - goret string // // To aid debugging applications one can use this method to obtain the whole // network of gstreamer elements that form the pipeline into a dot file. // This data can be processed with graphviz to get an image. func DebugBinToDotData(bin Bin, details DebugGraphDetails) string { var carg1 *C.GstBin // in, none, converted var carg2 C.GstDebugGraphDetails // in, none, casted var cret *C.gchar // return, full, string carg1 = (*C.GstBin)(UnsafeBinToGlibNone(bin)) carg2 = C.GstDebugGraphDetails(details) cret = C.gst_debug_bin_to_dot_data(carg1, carg2) runtime.KeepAlive(bin) runtime.KeepAlive(details) var goret string goret = C.GoString((*C.char)(unsafe.Pointer(cret))) defer C.free(unsafe.Pointer(cret)) return goret } // DebugBinToDotFile wraps gst_debug_bin_to_dot_file // // The function takes the following parameters: // // - bin Bin: the top-level pipeline that should be analyzed // - details DebugGraphDetails: type of #GstDebugGraphDetails to use // - fileName string: output base filename (e.g. "myplayer") // // To aid debugging applications one can use this method to write out the whole // network of gstreamer elements that form the pipeline into a dot file. // This file can be processed with graphviz to get an image. // // ``` shell // dot -Tpng -oimage.png graph_lowlevel.dot // ``` func DebugBinToDotFile(bin Bin, details DebugGraphDetails, fileName string) { var carg1 *C.GstBin // in, none, converted var carg2 C.GstDebugGraphDetails // in, none, casted var carg3 *C.gchar // in, none, string carg1 = (*C.GstBin)(UnsafeBinToGlibNone(bin)) carg2 = C.GstDebugGraphDetails(details) carg3 = (*C.gchar)(unsafe.Pointer(C.CString(fileName))) defer C.free(unsafe.Pointer(carg3)) C.gst_debug_bin_to_dot_file(carg1, carg2, carg3) runtime.KeepAlive(bin) runtime.KeepAlive(details) runtime.KeepAlive(fileName) } // DebugBinToDotFileWithTs wraps gst_debug_bin_to_dot_file_with_ts // // The function takes the following parameters: // // - bin Bin: the top-level pipeline that should be analyzed // - details DebugGraphDetails: type of #GstDebugGraphDetails to use // - fileName string: output base filename (e.g. "myplayer") // // This works like gst_debug_bin_to_dot_file(), but adds the current timestamp // to the filename, so that it can be used to take multiple snapshots. func DebugBinToDotFileWithTs(bin Bin, details DebugGraphDetails, fileName string) { var carg1 *C.GstBin // in, none, converted var carg2 C.GstDebugGraphDetails // in, none, casted var carg3 *C.gchar // in, none, string carg1 = (*C.GstBin)(UnsafeBinToGlibNone(bin)) carg2 = C.GstDebugGraphDetails(details) carg3 = (*C.gchar)(unsafe.Pointer(C.CString(fileName))) defer C.free(unsafe.Pointer(carg3)) C.gst_debug_bin_to_dot_file_with_ts(carg1, carg2, carg3) runtime.KeepAlive(bin) runtime.KeepAlive(details) runtime.KeepAlive(fileName) } // DebugConstructTermColor wraps gst_debug_construct_term_color // // The function takes the following parameters: // // - colorinfo uint: the color info // // The function returns the following values: // // - goret string // // Constructs a string that can be used for getting the desired color in color // terminals. // You need to free the string after use. func DebugConstructTermColor(colorinfo uint) string { var carg1 C.guint // in, none, casted var cret *C.gchar // return, full, string carg1 = C.guint(colorinfo) cret = C.gst_debug_construct_term_color(carg1) runtime.KeepAlive(colorinfo) var goret string goret = C.GoString((*C.char)(unsafe.Pointer(cret))) defer C.free(unsafe.Pointer(cret)) return goret } // DebugConstructWinColor wraps gst_debug_construct_win_color // // The function takes the following parameters: // // - colorinfo uint: the color info // // The function returns the following values: // // - goret int // // Constructs an integer that can be used for getting the desired color in // windows' terminals (cmd.exe). As there is no mean to underline, we simply // ignore this attribute. // // This function returns 0 on non-windows machines. func DebugConstructWinColor(colorinfo uint) int { var carg1 C.guint // in, none, casted var cret C.gint // return, none, casted carg1 = C.guint(colorinfo) cret = C.gst_debug_construct_win_color(carg1) runtime.KeepAlive(colorinfo) var goret int goret = int(cret) return goret } // DebugGetAllCategories wraps gst_debug_get_all_categories // // The function returns the following values: // // - goret []*DebugCategory // // Returns a snapshot of a all categories that are currently in use . This list // may change anytime. // The caller has to free the list after use. func DebugGetAllCategories() []*DebugCategory { var cret *C.GSList // container, transfer: container cret = C.gst_debug_get_all_categories() var goret []*DebugCategory goret = glib.UnsafeSListFromGlibFull( unsafe.Pointer(cret), func(v unsafe.Pointer) *DebugCategory { var dst *DebugCategory // converted dst = UnsafeDebugCategoryFromGlibNone(v) return dst }, ) return goret } // DebugGetColorMode wraps gst_debug_get_color_mode // // The function returns the following values: // // - goret DebugColorMode // // Changes the coloring mode for debug output. func DebugGetColorMode() DebugColorMode { var cret C.GstDebugColorMode // return, none, casted cret = C.gst_debug_get_color_mode() var goret DebugColorMode goret = DebugColorMode(cret) return goret } // DebugGetDefaultThreshold wraps gst_debug_get_default_threshold // // The function returns the following values: // // - goret DebugLevel // // Returns the default threshold that is used for new categories. func DebugGetDefaultThreshold() DebugLevel { var cret C.GstDebugLevel // return, none, casted cret = C.gst_debug_get_default_threshold() var goret DebugLevel goret = DebugLevel(cret) return goret } // DebugGetStackTrace wraps gst_debug_get_stack_trace // // The function takes the following parameters: // // - flags StackTraceFlags: A set of #GstStackTraceFlags to determine how the stack trace should // look like. Pass #GST_STACK_TRACE_SHOW_NONE to retrieve a minimal backtrace. // // The function returns the following values: // // - goret string (nullable) func DebugGetStackTrace(flags StackTraceFlags) string { var carg1 C.GstStackTraceFlags // in, none, casted var cret *C.gchar // return, full, string, nullable-string carg1 = C.GstStackTraceFlags(flags) cret = C.gst_debug_get_stack_trace(carg1) runtime.KeepAlive(flags) var goret string if cret != nil { goret = C.GoString((*C.char)(unsafe.Pointer(cret))) defer C.free(unsafe.Pointer(cret)) } return goret } // DebugIsActive wraps gst_debug_is_active // // The function returns the following values: // // - goret bool // // Checks if debugging output is activated. func DebugIsActive() bool { var cret C.gboolean // return cret = C.gst_debug_is_active() var goret bool if cret != 0 { goret = true } return goret } // DebugIsColored wraps gst_debug_is_colored // // The function returns the following values: // // - goret bool // // Checks if the debugging output should be colored. func DebugIsColored() bool { var cret C.gboolean // return cret = C.gst_debug_is_colored() var goret bool if cret != 0 { goret = true } return goret } // DebugLogGetLine wraps gst_debug_log_get_line // // The function takes the following parameters: // // - category *DebugCategory: category to log // - level DebugLevel: level of the message // - file string: the file that emitted the message, usually the __FILE__ identifier // - function string: the function that emitted the message // - line int: the line from that the message was emitted, usually __LINE__ // - object gobject.Object (nullable): the object this message relates to, // or %NULL if none // - message *DebugMessage: the actual message // // The function returns the following values: // // - goret string // // Returns the string representation for the specified debug log message // formatted in the same way as gst_debug_log_default() (the default handler), // without color. The purpose is to make it easy for custom log output // handlers to get a log output that is identical to what the default handler // would write out. func DebugLogGetLine(category *DebugCategory, level DebugLevel, file string, function string, line int, object gobject.Object, message *DebugMessage) string { var carg1 *C.GstDebugCategory // in, none, converted var carg2 C.GstDebugLevel // in, none, casted var carg3 *C.gchar // in, none, string var carg4 *C.gchar // in, none, string var carg5 C.gint // in, none, casted var carg6 *C.GObject // in, none, converted, nullable var carg7 *C.GstDebugMessage // in, none, converted var cret *C.gchar // return, full, string carg1 = (*C.GstDebugCategory)(UnsafeDebugCategoryToGlibNone(category)) carg2 = C.GstDebugLevel(level) carg3 = (*C.gchar)(unsafe.Pointer(C.CString(file))) defer C.free(unsafe.Pointer(carg3)) carg4 = (*C.gchar)(unsafe.Pointer(C.CString(function))) defer C.free(unsafe.Pointer(carg4)) carg5 = C.gint(line) if object != nil { carg6 = (*C.GObject)(gobject.UnsafeObjectToGlibNone(object)) } carg7 = (*C.GstDebugMessage)(UnsafeDebugMessageToGlibNone(message)) cret = C.gst_debug_log_get_line(carg1, carg2, carg3, carg4, carg5, carg6, carg7) runtime.KeepAlive(category) runtime.KeepAlive(level) runtime.KeepAlive(file) runtime.KeepAlive(function) runtime.KeepAlive(line) runtime.KeepAlive(object) runtime.KeepAlive(message) var goret string goret = C.GoString((*C.char)(unsafe.Pointer(cret))) defer C.free(unsafe.Pointer(cret)) return goret } // DebugLogIDLiteral wraps gst_debug_log_id_literal // // The function takes the following parameters: // // - category *DebugCategory: category to log // - level DebugLevel: level of the message is in // - file string: the file that emitted the message, usually the __FILE__ identifier // - function string: the function that emitted the message // - line int: the line from that the message was emitted, usually __LINE__ // - id string (nullable): the identifier of the object this message relates to // or %NULL if none // - messageString string: a message string // // Logs the given message using the currently registered debugging handlers. func DebugLogIDLiteral(category *DebugCategory, level DebugLevel, file string, function string, line int, id string, messageString string) { var carg1 *C.GstDebugCategory // in, none, converted var carg2 C.GstDebugLevel // in, none, casted var carg3 *C.gchar // in, none, string var carg4 *C.gchar // in, none, string var carg5 C.gint // in, none, casted var carg6 *C.gchar // in, none, string, nullable-string var carg7 *C.gchar // in, none, string carg1 = (*C.GstDebugCategory)(UnsafeDebugCategoryToGlibNone(category)) carg2 = C.GstDebugLevel(level) carg3 = (*C.gchar)(unsafe.Pointer(C.CString(file))) defer C.free(unsafe.Pointer(carg3)) carg4 = (*C.gchar)(unsafe.Pointer(C.CString(function))) defer C.free(unsafe.Pointer(carg4)) carg5 = C.gint(line) if id != "" { carg6 = (*C.gchar)(unsafe.Pointer(C.CString(id))) defer C.free(unsafe.Pointer(carg6)) } carg7 = (*C.gchar)(unsafe.Pointer(C.CString(messageString))) defer C.free(unsafe.Pointer(carg7)) C.gst_debug_log_id_literal(carg1, carg2, carg3, carg4, carg5, carg6, carg7) runtime.KeepAlive(category) runtime.KeepAlive(level) runtime.KeepAlive(file) runtime.KeepAlive(function) runtime.KeepAlive(line) runtime.KeepAlive(id) runtime.KeepAlive(messageString) } // DebugLogLiteral wraps gst_debug_log_literal // // The function takes the following parameters: // // - category *DebugCategory: category to log // - level DebugLevel: level of the message is in // - file string: the file that emitted the message, usually the __FILE__ identifier // - function string: the function that emitted the message // - line int: the line from that the message was emitted, usually __LINE__ // - object gobject.Object (nullable): the object this message relates to, // or %NULL if none // - messageString string: a message string // // Logs the given message using the currently registered debugging handlers. func DebugLogLiteral(category *DebugCategory, level DebugLevel, file string, function string, line int, object gobject.Object, messageString string) { var carg1 *C.GstDebugCategory // in, none, converted var carg2 C.GstDebugLevel // in, none, casted var carg3 *C.gchar // in, none, string var carg4 *C.gchar // in, none, string var carg5 C.gint // in, none, casted var carg6 *C.GObject // in, none, converted, nullable var carg7 *C.gchar // in, none, string carg1 = (*C.GstDebugCategory)(UnsafeDebugCategoryToGlibNone(category)) carg2 = C.GstDebugLevel(level) carg3 = (*C.gchar)(unsafe.Pointer(C.CString(file))) defer C.free(unsafe.Pointer(carg3)) carg4 = (*C.gchar)(unsafe.Pointer(C.CString(function))) defer C.free(unsafe.Pointer(carg4)) carg5 = C.gint(line) if object != nil { carg6 = (*C.GObject)(gobject.UnsafeObjectToGlibNone(object)) } carg7 = (*C.gchar)(unsafe.Pointer(C.CString(messageString))) defer C.free(unsafe.Pointer(carg7)) C.gst_debug_log_literal(carg1, carg2, carg3, carg4, carg5, carg6, carg7) runtime.KeepAlive(category) runtime.KeepAlive(level) runtime.KeepAlive(file) runtime.KeepAlive(function) runtime.KeepAlive(line) runtime.KeepAlive(object) runtime.KeepAlive(messageString) } // DebugPrintStackTrace wraps gst_debug_print_stack_trace // // If libunwind, glibc backtrace or DbgHelp are present // a stack trace is printed. func DebugPrintStackTrace() { C.gst_debug_print_stack_trace() } // DebugRemoveRingBufferLogger wraps gst_debug_remove_ring_buffer_logger // // Removes any previously added ring buffer logger with // gst_debug_add_ring_buffer_logger(). func DebugRemoveRingBufferLogger() { C.gst_debug_remove_ring_buffer_logger() } // DebugRingBufferLoggerGetLogs wraps gst_debug_ring_buffer_logger_get_logs // // The function returns the following values: // // - goret []string // // Fetches the current logs per thread from the ring buffer logger. See // gst_debug_add_ring_buffer_logger() for details. func DebugRingBufferLoggerGetLogs() []string { var cret **C.gchar // return, transfer: full, C Pointers: 2, Name: array[utf8], scope: , array (inner: *typesystem.StringPrimitive, zero-terminated) cret = C.gst_debug_ring_buffer_logger_get_logs() var goret []string _ = goret _ = cret panic("unimplemented conversion of []string (gchar**)") return goret } // DebugSetActive wraps gst_debug_set_active // // The function takes the following parameters: // // - active bool: Whether to use debugging output or not // // If activated, debugging messages are sent to the debugging // handlers. // It makes sense to deactivate it for speed issues. // > This function is not threadsafe. It makes sense to only call it // during initialization. func DebugSetActive(active bool) { var carg1 C.gboolean // in if active { carg1 = C.TRUE } C.gst_debug_set_active(carg1) runtime.KeepAlive(active) } // DebugSetColorMode wraps gst_debug_set_color_mode // // The function takes the following parameters: // // - mode DebugColorMode: The coloring mode for debug output. See @GstDebugColorMode. // // Changes the coloring mode for debug output. // // This function may be called before gst_init(). func DebugSetColorMode(mode DebugColorMode) { var carg1 C.GstDebugColorMode // in, none, casted carg1 = C.GstDebugColorMode(mode) C.gst_debug_set_color_mode(carg1) runtime.KeepAlive(mode) } // DebugSetColorModeFromString wraps gst_debug_set_color_mode_from_string // // The function takes the following parameters: // // - mode string: The coloring mode for debug output. One of the following: // "on", "auto", "off", "disable", "unix". // // Changes the coloring mode for debug output. // // This function may be called before gst_init(). func DebugSetColorModeFromString(mode string) { var carg1 *C.gchar // in, none, string carg1 = (*C.gchar)(unsafe.Pointer(C.CString(mode))) defer C.free(unsafe.Pointer(carg1)) C.gst_debug_set_color_mode_from_string(carg1) runtime.KeepAlive(mode) } // DebugSetColored wraps gst_debug_set_colored // // The function takes the following parameters: // // - colored bool: Whether to use colored output or not // // Sets or unsets the use of coloured debugging output. // Same as gst_debug_set_color_mode () with the argument being // being GST_DEBUG_COLOR_MODE_ON or GST_DEBUG_COLOR_MODE_OFF. // // This function may be called before gst_init(). func DebugSetColored(colored bool) { var carg1 C.gboolean // in if colored { carg1 = C.TRUE } C.gst_debug_set_colored(carg1) runtime.KeepAlive(colored) } // DebugSetDefaultThreshold wraps gst_debug_set_default_threshold // // The function takes the following parameters: // // - level DebugLevel: level to set // // Sets the default threshold to the given level and updates all categories to // use this threshold. // // This function may be called before gst_init(). func DebugSetDefaultThreshold(level DebugLevel) { var carg1 C.GstDebugLevel // in, none, casted carg1 = C.GstDebugLevel(level) C.gst_debug_set_default_threshold(carg1) runtime.KeepAlive(level) } // DebugSetThresholdForName wraps gst_debug_set_threshold_for_name // // The function takes the following parameters: // // - name string: name of the categories to set // - level DebugLevel: level to set them to // // Sets all categories which match the given glob style pattern to the given // level. func DebugSetThresholdForName(name string, level DebugLevel) { var carg1 *C.gchar // in, none, string var carg2 C.GstDebugLevel // in, none, casted carg1 = (*C.gchar)(unsafe.Pointer(C.CString(name))) defer C.free(unsafe.Pointer(carg1)) carg2 = C.GstDebugLevel(level) C.gst_debug_set_threshold_for_name(carg1, carg2) runtime.KeepAlive(name) runtime.KeepAlive(level) } // DebugSetThresholdFromString wraps gst_debug_set_threshold_from_string // // The function takes the following parameters: // // - list string: comma-separated list of "category:level" pairs to be used // as debug logging levels // - reset bool: %TRUE to clear all previously-set debug levels before setting // new thresholds // %FALSE if adding the threshold described by @list to the one already set. // // Sets the debug logging wanted in the same form as with the GST_DEBUG // environment variable. You can use wildcards such as `*`, but note that // the order matters when you use wild cards, e.g. `foosrc:6,*src:3,*:2` sets // everything to log level 2. func DebugSetThresholdFromString(list string, reset bool) { var carg1 *C.gchar // in, none, string var carg2 C.gboolean // in carg1 = (*C.gchar)(unsafe.Pointer(C.CString(list))) defer C.free(unsafe.Pointer(carg1)) if reset { carg2 = C.TRUE } C.gst_debug_set_threshold_from_string(carg1, carg2) runtime.KeepAlive(list) runtime.KeepAlive(reset) } // DebugUnsetThresholdForName wraps gst_debug_unset_threshold_for_name // // The function takes the following parameters: // // - name string: name of the categories to set // // Resets all categories with the given name back to the default level. func DebugUnsetThresholdForName(name string) { var carg1 *C.gchar // in, none, string carg1 = (*C.gchar)(unsafe.Pointer(C.CString(name))) defer C.free(unsafe.Pointer(carg1)) C.gst_debug_unset_threshold_for_name(carg1) runtime.KeepAlive(name) } // Deinit wraps gst_deinit // // Clean up any resources created by GStreamer in gst_init(). // // It is normally not needed to call this function in a normal application // as the resources will automatically be freed when the program terminates. // This function is therefore mostly used by testsuites and other memory // profiling tools. // // After this call GStreamer (including this method) should not be used anymore. func Deinit() { C.gst_deinit() } // DynamicTypeRegister wraps gst_dynamic_type_register // // The function takes the following parameters: // // - plugin Plugin: The #GstPlugin to register @dyn_type for // - typ gobject.Type: The #GType to register dynamically // // The function returns the following values: // // - goret bool // // Registers a new #GstDynamicTypeFactory in the registry func DynamicTypeRegister(plugin Plugin, typ gobject.Type) bool { var carg1 *C.GstPlugin // in, none, converted var carg2 C.GType // in, none, casted, alias var cret C.gboolean // return carg1 = (*C.GstPlugin)(UnsafePluginToGlibNone(plugin)) carg2 = C.GType(typ) cret = C.gst_dynamic_type_register(carg1, carg2) runtime.KeepAlive(plugin) runtime.KeepAlive(typ) var goret bool if cret != 0 { goret = true } return goret } // ErrorGetMessage wraps gst_error_get_message // // The function takes the following parameters: // // - domain glib.Quark: the GStreamer error domain this error belongs to. // - code int: the error code belonging to the domain. // // The function returns the following values: // // - goret string // // Get a string describing the error message in the current locale. func ErrorGetMessage(domain glib.Quark, code int) string { var carg1 C.GQuark // in, none, casted, alias var carg2 C.gint // in, none, casted var cret *C.gchar // return, full, string carg1 = C.GQuark(domain) carg2 = C.gint(code) cret = C.gst_error_get_message(carg1, carg2) runtime.KeepAlive(domain) runtime.KeepAlive(code) var goret string goret = C.GoString((*C.char)(unsafe.Pointer(cret))) defer C.free(unsafe.Pointer(cret)) return goret } // FilenameToURI wraps gst_filename_to_uri // // The function takes the following parameters: // // - filename string: absolute or relative file name path // // The function returns the following values: // // - goret string (nullable) // - _goerr error (nullable): an error // // Similar to g_filename_to_uri(), but attempts to handle relative file paths // as well. Before converting @filename into an URI, it will be prefixed by // the current working directory if it is a relative path, and then the path // will be canonicalised so that it doesn't contain any './' or '../' segments. // // On Windows @filename should be in UTF-8 encoding. func FilenameToURI(filename string) (string, error) { var carg1 *C.gchar // in, none, string var cret *C.gchar // return, full, string, nullable-string var _cerr *C.GError // out, full, converted, nullable carg1 = (*C.gchar)(unsafe.Pointer(C.CString(filename))) defer C.free(unsafe.Pointer(carg1)) cret = C.gst_filename_to_uri(carg1, &_cerr) runtime.KeepAlive(filename) var goret string var _goerr error if cret != nil { goret = C.GoString((*C.char)(unsafe.Pointer(cret))) defer C.free(unsafe.Pointer(cret)) } if _cerr != nil { _goerr = glib.UnsafeErrorFromGlibFull(unsafe.Pointer(_cerr)) } return goret, _goerr } // FlowGetName wraps gst_flow_get_name // // The function takes the following parameters: // // - ret FlowReturn: a #GstFlowReturn to get the name of. // // The function returns the following values: // // - goret string // // Gets a string representing the given flow return. func FlowGetName(ret FlowReturn) string { var carg1 C.GstFlowReturn // in, none, casted var cret *C.gchar // return, none, string carg1 = C.GstFlowReturn(ret) cret = C.gst_flow_get_name(carg1) runtime.KeepAlive(ret) var goret string goret = C.GoString((*C.char)(unsafe.Pointer(cret))) return goret } // FlowToQuark wraps gst_flow_to_quark // // The function takes the following parameters: // // - ret FlowReturn: a #GstFlowReturn to get the quark of. // // The function returns the following values: // // - goret glib.Quark // // Get the unique quark for the given GstFlowReturn. func FlowToQuark(ret FlowReturn) glib.Quark { var carg1 C.GstFlowReturn // in, none, casted var cret C.GQuark // return, none, casted, alias carg1 = C.GstFlowReturn(ret) cret = C.gst_flow_to_quark(carg1) runtime.KeepAlive(ret) var goret glib.Quark goret = glib.Quark(cret) return goret } // FormatsContains wraps gst_formats_contains // // The function takes the following parameters: // // - formats []Format: The format array to search // - format Format: the format to find // // The function returns the following values: // // - goret bool // // See if the given format is inside the format array. func FormatsContains(formats []Format, format Format) bool { var carg1 *C.GstFormat // in, transfer: none, C Pointers: 1, Name: array[Format], array (inner: *typesystem.Enum, zero-terminated) var carg2 C.GstFormat // in, none, casted var cret C.gboolean // return _ = formats _ = carg1 panic("unimplemented conversion of []Format (const GstFormat*)") carg2 = C.GstFormat(format) cret = C.gst_formats_contains(carg1, carg2) runtime.KeepAlive(formats) runtime.KeepAlive(format) var goret bool if cret != 0 { goret = true } return goret } // GetMainExecutablePath wraps gst_get_main_executable_path // // The function returns the following values: // // - goret string (nullable) // // This helper is mostly helpful for plugins that need to // inspect the folder of the main executable to determine // their set of features. // // When a plugin is initialized from the gst-plugin-scanner // external process, the returned path will be the same as from the // parent process. func GetMainExecutablePath() string { var cret *C.gchar // return, none, string, nullable-string cret = C.gst_get_main_executable_path() var goret string if cret != nil { goret = C.GoString((*C.char)(unsafe.Pointer(cret))) } return goret } // IsCapsFeatures wraps gst_is_caps_features // // The function takes the following parameters: // // - obj unsafe.Pointer (nullable) // // The function returns the following values: // // - goret bool // // Checks if @obj is a #GstCapsFeatures func IsCapsFeatures(obj unsafe.Pointer) bool { var carg1 C.gconstpointer // in, none, casted, nullable var cret C.gboolean // return if obj != nil { carg1 = C.gconstpointer(obj) } cret = C.gst_is_caps_features(carg1) runtime.KeepAlive(obj) var goret bool if cret != 0 { goret = true } return goret } // IsInitialized wraps gst_is_initialized // // The function returns the following values: // // - goret bool // // Use this function to check if GStreamer has been initialized with gst_init() // or gst_init_check(). func IsInitialized() bool { var cret C.gboolean // return cret = C.gst_is_initialized() var goret bool if cret != 0 { goret = true } return goret } // ParentBufferMetaApiGetType wraps gst_parent_buffer_meta_api_get_type // // The function returns the following values: // // - goret gobject.Type func ParentBufferMetaApiGetType() gobject.Type { var cret C.GType // return, none, casted, alias cret = C.gst_parent_buffer_meta_api_get_type() var goret gobject.Type goret = gobject.Type(cret) return goret } // ParseBinFromDescription wraps gst_parse_bin_from_description // // The function takes the following parameters: // // - binDescription string: command line describing the bin // - ghostUnlinkedPads bool: whether to automatically create ghost pads // for unlinked source or sink pads within the bin // // The function returns the following values: // // - goret Bin // - _goerr error (nullable): an error // // This is a convenience wrapper around gst_parse_launch() to create a // #GstBin from a gst-launch-style pipeline description. See // gst_parse_launch() and the gst-launch man page for details about the // syntax. Ghost pads on the bin for unlinked source or sink pads // within the bin can automatically be created (but only a maximum of // one ghost pad for each direction will be created; if you expect // multiple unlinked source pads or multiple unlinked sink pads // and want them all ghosted, you will have to create the ghost pads // yourself). func ParseBinFromDescription(binDescription string, ghostUnlinkedPads bool) (Bin, error) { var carg1 *C.gchar // in, none, string var carg2 C.gboolean // in var cret *C.GstElement // return, none, converted, casted *C.GstBin var _cerr *C.GError // out, full, converted, nullable carg1 = (*C.gchar)(unsafe.Pointer(C.CString(binDescription))) defer C.free(unsafe.Pointer(carg1)) if ghostUnlinkedPads { carg2 = C.TRUE } cret = C.gst_parse_bin_from_description(carg1, carg2, &_cerr) runtime.KeepAlive(binDescription) runtime.KeepAlive(ghostUnlinkedPads) var goret Bin var _goerr error goret = UnsafeBinFromGlibNone(unsafe.Pointer(cret)) if _cerr != nil { _goerr = glib.UnsafeErrorFromGlibFull(unsafe.Pointer(_cerr)) } return goret, _goerr } // ParseBinFromDescriptionFull wraps gst_parse_bin_from_description_full // // The function takes the following parameters: // // - binDescription string: command line describing the bin // - ghostUnlinkedPads bool: whether to automatically create ghost pads // for unlinked source or sink pads within the bin // - _context *ParseContext (nullable): a parse context allocated with // gst_parse_context_new(), or %NULL // - flags ParseFlags: parsing options, or #GST_PARSE_FLAG_NONE // // The function returns the following values: // // - goret Element // - _goerr error (nullable): an error // // This is a convenience wrapper around gst_parse_launch() to create a // #GstBin from a gst-launch-style pipeline description. See // gst_parse_launch() and the gst-launch man page for details about the // syntax. Ghost pads on the bin for unlinked source or sink pads // within the bin can automatically be created (but only a maximum of // one ghost pad for each direction will be created; if you expect // multiple unlinked source pads or multiple unlinked sink pads // and want them all ghosted, you will have to create the ghost pads // yourself). func ParseBinFromDescriptionFull(binDescription string, ghostUnlinkedPads bool, _context *ParseContext, flags ParseFlags) (Element, error) { var carg1 *C.gchar // in, none, string var carg2 C.gboolean // in var carg3 *C.GstParseContext // in, none, converted, nullable var carg4 C.GstParseFlags // in, none, casted var cret *C.GstElement // return, none, converted var _cerr *C.GError // out, full, converted, nullable carg1 = (*C.gchar)(unsafe.Pointer(C.CString(binDescription))) defer C.free(unsafe.Pointer(carg1)) if ghostUnlinkedPads { carg2 = C.TRUE } if _context != nil { carg3 = (*C.GstParseContext)(UnsafeParseContextToGlibNone(_context)) } carg4 = C.GstParseFlags(flags) cret = C.gst_parse_bin_from_description_full(carg1, carg2, carg3, carg4, &_cerr) runtime.KeepAlive(binDescription) runtime.KeepAlive(ghostUnlinkedPads) runtime.KeepAlive(_context) runtime.KeepAlive(flags) var goret Element var _goerr error goret = UnsafeElementFromGlibNone(unsafe.Pointer(cret)) if _cerr != nil { _goerr = glib.UnsafeErrorFromGlibFull(unsafe.Pointer(_cerr)) } return goret, _goerr } // ParseLaunch wraps gst_parse_launch // // The function takes the following parameters: // // - pipelineDescription string: the command line describing the pipeline // // The function returns the following values: // // - goret Element // - _goerr error (nullable): an error // // Create a new pipeline based on command line syntax. // Please note that you might get a return value that is not %NULL even though // the @error is set. In this case there was a recoverable parsing error and you // can try to play the pipeline. // // To create a sub-pipeline (bin) for embedding into an existing pipeline // use gst_parse_bin_from_description(). func ParseLaunch(pipelineDescription string) (Element, error) { var carg1 *C.gchar // in, none, string var cret *C.GstElement // return, none, converted var _cerr *C.GError // out, full, converted, nullable carg1 = (*C.gchar)(unsafe.Pointer(C.CString(pipelineDescription))) defer C.free(unsafe.Pointer(carg1)) cret = C.gst_parse_launch(carg1, &_cerr) runtime.KeepAlive(pipelineDescription) var goret Element var _goerr error goret = UnsafeElementFromGlibNone(unsafe.Pointer(cret)) if _cerr != nil { _goerr = glib.UnsafeErrorFromGlibFull(unsafe.Pointer(_cerr)) } return goret, _goerr } // ParseLaunchFull wraps gst_parse_launch_full // // The function takes the following parameters: // // - pipelineDescription string: the command line describing the pipeline // - _context *ParseContext (nullable): a parse context allocated with // gst_parse_context_new(), or %NULL // - flags ParseFlags: parsing options, or #GST_PARSE_FLAG_NONE // // The function returns the following values: // // - goret Element // - _goerr error (nullable): an error // // Create a new pipeline based on command line syntax. // Please note that you might get a return value that is not %NULL even though // the @error is set. In this case there was a recoverable parsing error and you // can try to play the pipeline. // // To create a sub-pipeline (bin) for embedding into an existing pipeline // use gst_parse_bin_from_description_full(). func ParseLaunchFull(pipelineDescription string, _context *ParseContext, flags ParseFlags) (Element, error) { var carg1 *C.gchar // in, none, string var carg2 *C.GstParseContext // in, none, converted, nullable var carg3 C.GstParseFlags // in, none, casted var cret *C.GstElement // return, none, converted var _cerr *C.GError // out, full, converted, nullable carg1 = (*C.gchar)(unsafe.Pointer(C.CString(pipelineDescription))) defer C.free(unsafe.Pointer(carg1)) if _context != nil { carg2 = (*C.GstParseContext)(UnsafeParseContextToGlibNone(_context)) } carg3 = C.GstParseFlags(flags) cret = C.gst_parse_launch_full(carg1, carg2, carg3, &_cerr) runtime.KeepAlive(pipelineDescription) runtime.KeepAlive(_context) runtime.KeepAlive(flags) var goret Element var _goerr error goret = UnsafeElementFromGlibNone(unsafe.Pointer(cret)) if _cerr != nil { _goerr = glib.UnsafeErrorFromGlibFull(unsafe.Pointer(_cerr)) } return goret, _goerr } // ProtectionFilterSystemsByAvailableDecryptors wraps gst_protection_filter_systems_by_available_decryptors // // The function takes the following parameters: // // - systemIdentifiers []string: // A null terminated array of strings that contains the UUID values of each // protection system that is to be checked. // // The function returns the following values: // // - goret []string (nullable) // // Iterates the supplied list of UUIDs and checks the GstRegistry for // all the decryptors supporting one of the supplied UUIDs. func ProtectionFilterSystemsByAvailableDecryptors(systemIdentifiers []string) []string { var carg1 **C.gchar // in, transfer: none, C Pointers: 2, Name: array[utf8], array (inner: *typesystem.StringPrimitive, zero-terminated) var cret **C.gchar // return, transfer: full, C Pointers: 2, Name: array[utf8], scope: , nullable, array (inner: *typesystem.StringPrimitive, zero-terminated) _ = systemIdentifiers _ = carg1 panic("unimplemented conversion of []string (const gchar**)") cret = C.gst_protection_filter_systems_by_available_decryptors(carg1) runtime.KeepAlive(systemIdentifiers) var goret []string _ = goret _ = cret panic("unimplemented conversion of []string (gchar**)") return goret } // ProtectionMetaApiGetType wraps gst_protection_meta_api_get_type // // The function returns the following values: // // - goret gobject.Type func ProtectionMetaApiGetType() gobject.Type { var cret C.GType // return, none, casted, alias cret = C.gst_protection_meta_api_get_type() var goret gobject.Type goret = gobject.Type(cret) return goret } // ProtectionSelectSystem wraps gst_protection_select_system // // The function takes the following parameters: // // - systemIdentifiers []string: A null terminated array of strings // that contains the UUID values of each protection system that is to be // checked. // // The function returns the following values: // // - goret string (nullable) // // Iterates the supplied list of UUIDs and checks the GstRegistry for // an element that supports one of the supplied UUIDs. If more than one // element matches, the system ID of the highest ranked element is selected. func ProtectionSelectSystem(systemIdentifiers []string) string { var carg1 **C.gchar // in, transfer: none, C Pointers: 2, Name: array[utf8], array (inner: *typesystem.StringPrimitive, zero-terminated) var cret *C.gchar // return, none, string, nullable-string _ = systemIdentifiers _ = carg1 panic("unimplemented conversion of []string (const gchar**)") cret = C.gst_protection_select_system(carg1) runtime.KeepAlive(systemIdentifiers) var goret string if cret != nil { goret = C.GoString((*C.char)(unsafe.Pointer(cret))) } return goret } // ReferenceTimestampMetaApiGetType wraps gst_reference_timestamp_meta_api_get_type // // The function returns the following values: // // - goret gobject.Type func ReferenceTimestampMetaApiGetType() gobject.Type { var cret C.GType // return, none, casted, alias cret = C.gst_reference_timestamp_meta_api_get_type() var goret gobject.Type goret = gobject.Type(cret) return goret } // SegtrapIsEnabled wraps gst_segtrap_is_enabled // // The function returns the following values: // // - goret bool // // Some functions in the GStreamer core might install a custom SIGSEGV handler // to better catch and report errors to the application. Currently this feature // is enabled by default when loading plugins. // // Applications might want to disable this behaviour with the // gst_segtrap_set_enabled() function. This is typically done if the application // wants to install its own handler without GStreamer interfering. func SegtrapIsEnabled() bool { var cret C.gboolean // return cret = C.gst_segtrap_is_enabled() var goret bool if cret != 0 { goret = true } return goret } // SegtrapSetEnabled wraps gst_segtrap_set_enabled // // The function takes the following parameters: // // - enabled bool: whether a custom SIGSEGV handler should be installed. // // Applications might want to disable/enable the SIGSEGV handling of // the GStreamer core. See gst_segtrap_is_enabled() for more information. func SegtrapSetEnabled(enabled bool) { var carg1 C.gboolean // in if enabled { carg1 = C.TRUE } C.gst_segtrap_set_enabled(carg1) runtime.KeepAlive(enabled) } // TagExists wraps gst_tag_exists // // The function takes the following parameters: // // - tag string: name of the tag // // The function returns the following values: // // - goret bool // // Checks if the given type is already registered. func TagExists(tag string) bool { var carg1 *C.gchar // in, none, string var cret C.gboolean // return carg1 = (*C.gchar)(unsafe.Pointer(C.CString(tag))) defer C.free(unsafe.Pointer(carg1)) cret = C.gst_tag_exists(carg1) runtime.KeepAlive(tag) var goret bool if cret != 0 { goret = true } return goret } // TagGetDescription wraps gst_tag_get_description // // The function takes the following parameters: // // - tag string: the tag // // The function returns the following values: // // - goret string // // Returns the human-readable description of this tag, You must not change or // free this string. func TagGetDescription(tag string) string { var carg1 *C.gchar // in, none, string var cret *C.gchar // return, none, string carg1 = (*C.gchar)(unsafe.Pointer(C.CString(tag))) defer C.free(unsafe.Pointer(carg1)) cret = C.gst_tag_get_description(carg1) runtime.KeepAlive(tag) var goret string goret = C.GoString((*C.char)(unsafe.Pointer(cret))) return goret } // TagGetFlag wraps gst_tag_get_flag // // The function takes the following parameters: // // - tag string: the tag // // The function returns the following values: // // - goret TagFlag // // Gets the flag of @tag. func TagGetFlag(tag string) TagFlag { var carg1 *C.gchar // in, none, string var cret C.GstTagFlag // return, none, casted carg1 = (*C.gchar)(unsafe.Pointer(C.CString(tag))) defer C.free(unsafe.Pointer(carg1)) cret = C.gst_tag_get_flag(carg1) runtime.KeepAlive(tag) var goret TagFlag goret = TagFlag(cret) return goret } // TagGetNick wraps gst_tag_get_nick // // The function takes the following parameters: // // - tag string: the tag // // The function returns the following values: // // - goret string // // Returns the human-readable name of this tag, You must not change or free // this string. func TagGetNick(tag string) string { var carg1 *C.gchar // in, none, string var cret *C.gchar // return, none, string carg1 = (*C.gchar)(unsafe.Pointer(C.CString(tag))) defer C.free(unsafe.Pointer(carg1)) cret = C.gst_tag_get_nick(carg1) runtime.KeepAlive(tag) var goret string goret = C.GoString((*C.char)(unsafe.Pointer(cret))) return goret } // TagGetType wraps gst_tag_get_type // // The function takes the following parameters: // // - tag string: the tag // // The function returns the following values: // // - goret gobject.Type // // Gets the #GType used for this tag. func TagGetType(tag string) gobject.Type { var carg1 *C.gchar // in, none, string var cret C.GType // return, none, casted, alias carg1 = (*C.gchar)(unsafe.Pointer(C.CString(tag))) defer C.free(unsafe.Pointer(carg1)) cret = C.gst_tag_get_type(carg1) runtime.KeepAlive(tag) var goret gobject.Type goret = gobject.Type(cret) return goret } // TagIsFixed wraps gst_tag_is_fixed // // The function takes the following parameters: // // - tag string: tag to check // // The function returns the following values: // // - goret bool // // Checks if the given tag is fixed. A fixed tag can only contain one value. // Unfixed tags can contain lists of values. func TagIsFixed(tag string) bool { var carg1 *C.gchar // in, none, string var cret C.gboolean // return carg1 = (*C.gchar)(unsafe.Pointer(C.CString(tag))) defer C.free(unsafe.Pointer(carg1)) cret = C.gst_tag_is_fixed(carg1) runtime.KeepAlive(tag) var goret bool if cret != 0 { goret = true } return goret } // TagMergeStringsWithComma wraps gst_tag_merge_strings_with_comma // // The function takes the following parameters: // // - src *gobject.Value: GValue to copy from // // The function returns the following values: // // - dest gobject.Value: uninitialized GValue to store result in // // This is a convenience function for the func argument of gst_tag_register(). // It concatenates all given strings using a comma. The tag must be registered // as a G_TYPE_STRING or this function will fail. func TagMergeStringsWithComma(src *gobject.Value) gobject.Value { var carg2 *C.GValue // in, none, converted var carg1 C.GValue // out, transfer: none, C Pointers: 0, Name: Value, caller-allocates carg2 = (*C.GValue)(gobject.UnsafeValueToGlibUseAnyInstead(src)) C.gst_tag_merge_strings_with_comma(&carg1, carg2) runtime.KeepAlive(src) var dest gobject.Value _ = dest _ = carg1 panic("unimplemented conversion of gobject.Value (GValue)") return dest } // TagMergeUseFirst wraps gst_tag_merge_use_first // // The function takes the following parameters: // // - src *gobject.Value: GValue to copy from // // The function returns the following values: // // - dest gobject.Value: uninitialized GValue to store result in // // This is a convenience function for the func argument of gst_tag_register(). // It creates a copy of the first value from the list. func TagMergeUseFirst(src *gobject.Value) gobject.Value { var carg2 *C.GValue // in, none, converted var carg1 C.GValue // out, transfer: none, C Pointers: 0, Name: Value, caller-allocates carg2 = (*C.GValue)(gobject.UnsafeValueToGlibUseAnyInstead(src)) C.gst_tag_merge_use_first(&carg1, carg2) runtime.KeepAlive(src) var dest gobject.Value _ = dest _ = carg1 panic("unimplemented conversion of gobject.Value (GValue)") return dest } // TracingGetActiveTracers wraps gst_tracing_get_active_tracers // // The function returns the following values: // // - goret []Tracer // // Get a list of all active tracer objects owned by the tracing framework for // the entirety of the run-time of the process or till gst_deinit() is called. func TracingGetActiveTracers() []Tracer { var cret *C.GList // container, transfer: full cret = C.gst_tracing_get_active_tracers() var goret []Tracer goret = glib.UnsafeListFromGlibFull( unsafe.Pointer(cret), func(v unsafe.Pointer) Tracer { var dst Tracer // converted dst = UnsafeTracerFromGlibFull(v) return dst }, ) return goret } // TypeIsPluginApi wraps gst_type_is_plugin_api // // The function takes the following parameters: // // - typ gobject.Type: a GType // // The function returns the following values: // // - flags PluginAPIFlags: What #GstPluginAPIFlags the plugin was marked with // - goret bool // // Checks if @type is plugin API. See gst_type_mark_as_plugin_api() for // details. func TypeIsPluginApi(typ gobject.Type) (PluginAPIFlags, bool) { var carg1 C.GType // in, none, casted, alias var carg2 C.GstPluginAPIFlags // out, full, casted var cret C.gboolean // return carg1 = C.GType(typ) cret = C.gst_type_is_plugin_api(carg1, &carg2) runtime.KeepAlive(typ) var flags PluginAPIFlags var goret bool flags = PluginAPIFlags(carg2) if cret != 0 { goret = true } return flags, goret } // TypeMarkAsPluginApi wraps gst_type_mark_as_plugin_api // // The function takes the following parameters: // // - typ gobject.Type: a GType // - flags PluginAPIFlags: a set of #GstPluginAPIFlags to further inform cache generation. // // Marks @type as plugin API. This should be called in `class_init` of // elements that expose new types (i.e. enums, flags or internal GObjects) via // properties, signals or pad templates. // // Types exposed by plugins are not automatically added to the documentation // as they might originate from another library and should in that case be // documented via that library instead. // // By marking a type as plugin API it will be included in the documentation of // the plugin that defines it. func TypeMarkAsPluginApi(typ gobject.Type, flags PluginAPIFlags) { var carg1 C.GType // in, none, casted, alias var carg2 C.GstPluginAPIFlags // in, none, casted carg1 = C.GType(typ) carg2 = C.GstPluginAPIFlags(flags) C.gst_type_mark_as_plugin_api(carg1, carg2) runtime.KeepAlive(typ) runtime.KeepAlive(flags) } // UpdateRegistry wraps gst_update_registry // // The function returns the following values: // // - goret bool // // Forces GStreamer to re-scan its plugin paths and update the default // plugin registry. // // Applications will almost never need to call this function, it is only // useful if the application knows new plugins have been installed (or old // ones removed) since the start of the application (or, to be precise, the // first call to gst_init()) and the application wants to make use of any // newly-installed plugins without restarting the application. // // Applications should assume that the registry update is neither atomic nor // thread-safe and should therefore not have any dynamic pipelines running // (including the playbin and decodebin elements) and should also not create // any elements or access the GStreamer registry while the update is in // progress. // // Note that this function may block for a significant amount of time. func UpdateRegistry() bool { var cret C.gboolean // return cret = C.gst_update_registry() var goret bool if cret != 0 { goret = true } return goret } // UtilCeilLog2 wraps gst_util_ceil_log2 // // The function takes the following parameters: // // - v uint32: a #guint32 value. // // The function returns the following values: // // - goret uint // // Returns smallest integral value not less than log2(v). func UtilCeilLog2(v uint32) uint { var carg1 C.guint32 // in, none, casted var cret C.guint // return, none, casted carg1 = C.guint32(v) cret = C.gst_util_ceil_log2(carg1) runtime.KeepAlive(v) var goret uint goret = uint(cret) return goret } // UtilDoubleToFraction wraps gst_util_double_to_fraction // // The function takes the following parameters: // // - src float64: #gdouble to transform // // The function returns the following values: // // - destN int: pointer to a #gint to hold the result numerator // - destD int: pointer to a #gint to hold the result denominator // // Transforms a #gdouble to a fraction and simplifies // the result. func UtilDoubleToFraction(src float64) (int, int) { var carg1 C.gdouble // in, none, casted var carg2 C.gint // out, full, casted var carg3 C.gint // out, full, casted carg1 = C.gdouble(src) C.gst_util_double_to_fraction(carg1, &carg2, &carg3) runtime.KeepAlive(src) var destN int var destD int destN = int(carg2) destD = int(carg3) return destN, destD } // UtilDumpBuffer wraps gst_util_dump_buffer // // The function takes the following parameters: // // - buf *Buffer: a #GstBuffer whose memory to dump // // Dumps the buffer memory into a hex representation. Useful for debugging. func UtilDumpBuffer(buf *Buffer) { var carg1 *C.GstBuffer // in, none, converted carg1 = (*C.GstBuffer)(UnsafeBufferToGlibNone(buf)) C.gst_util_dump_buffer(carg1) runtime.KeepAlive(buf) } // UtilDumpMem wraps gst_util_dump_mem // // The function takes the following parameters: // // - mem []byte: a pointer to the memory to dump // // Dumps the memory block into a hex representation. Useful for debugging. func UtilDumpMem(mem []byte) { var carg1 *C.guchar // in, transfer: none, C Pointers: 1, Name: array[guchar], array (inner: *typesystem.CastablePrimitive, length-by: carg2) var carg2 C.guint // implicit _ = mem _ = carg1 _ = carg2 panic("unimplemented conversion of []byte (const guchar*)") C.gst_util_dump_mem(carg1, carg2) runtime.KeepAlive(mem) } // UtilFilenameCompare wraps gst_util_filename_compare // // The function takes the following parameters: // // - a string: a filename to compare with @b // - b string: a filename to compare with @a // // The function returns the following values: // // - goret int // // Compares the given filenames using natural ordering. func UtilFilenameCompare(a string, b string) int { var carg1 *C.gchar // in, none, string var carg2 *C.gchar // in, none, string var cret C.gint // return, none, casted carg1 = (*C.gchar)(unsafe.Pointer(C.CString(a))) defer C.free(unsafe.Pointer(carg1)) carg2 = (*C.gchar)(unsafe.Pointer(C.CString(b))) defer C.free(unsafe.Pointer(carg2)) cret = C.gst_util_filename_compare(carg1, carg2) runtime.KeepAlive(a) runtime.KeepAlive(b) var goret int goret = int(cret) return goret } // UtilFractionAdd wraps gst_util_fraction_add // // The function takes the following parameters: // // - aN int: Numerator of first value // - aD int: Denominator of first value // - bN int: Numerator of second value // - bD int: Denominator of second value // // The function returns the following values: // // - resN int: Pointer to #gint to hold the result numerator // - resD int: Pointer to #gint to hold the result denominator // - goret bool // // Adds the fractions @a_n/@a_d and @b_n/@b_d and stores // the result in @res_n and @res_d. func UtilFractionAdd(aN int, aD int, bN int, bD int) (int, int, bool) { var carg1 C.gint // in, none, casted var carg2 C.gint // in, none, casted var carg3 C.gint // in, none, casted var carg4 C.gint // in, none, casted var carg5 C.gint // out, full, casted var carg6 C.gint // out, full, casted var cret C.gboolean // return carg1 = C.gint(aN) carg2 = C.gint(aD) carg3 = C.gint(bN) carg4 = C.gint(bD) cret = C.gst_util_fraction_add(carg1, carg2, carg3, carg4, &carg5, &carg6) runtime.KeepAlive(aN) runtime.KeepAlive(aD) runtime.KeepAlive(bN) runtime.KeepAlive(bD) var resN int var resD int var goret bool resN = int(carg5) resD = int(carg6) if cret != 0 { goret = true } return resN, resD, goret } // UtilFractionCompare wraps gst_util_fraction_compare // // The function takes the following parameters: // // - aN int: Numerator of first value // - aD int: Denominator of first value // - bN int: Numerator of second value // - bD int: Denominator of second value // // The function returns the following values: // // - goret int // // Compares the fractions @a_n/@a_d and @b_n/@b_d and returns // -1 if a < b, 0 if a = b and 1 if a > b. func UtilFractionCompare(aN int, aD int, bN int, bD int) int { var carg1 C.gint // in, none, casted var carg2 C.gint // in, none, casted var carg3 C.gint // in, none, casted var carg4 C.gint // in, none, casted var cret C.gint // return, none, casted carg1 = C.gint(aN) carg2 = C.gint(aD) carg3 = C.gint(bN) carg4 = C.gint(bD) cret = C.gst_util_fraction_compare(carg1, carg2, carg3, carg4) runtime.KeepAlive(aN) runtime.KeepAlive(aD) runtime.KeepAlive(bN) runtime.KeepAlive(bD) var goret int goret = int(cret) return goret } // UtilFractionMultiply wraps gst_util_fraction_multiply // // The function takes the following parameters: // // - aN int: Numerator of first value // - aD int: Denominator of first value // - bN int: Numerator of second value // - bD int: Denominator of second value // // The function returns the following values: // // - resN int: Pointer to #gint to hold the result numerator // - resD int: Pointer to #gint to hold the result denominator // - goret bool // // Multiplies the fractions @a_n/@a_d and @b_n/@b_d and stores // the result in @res_n and @res_d. func UtilFractionMultiply(aN int, aD int, bN int, bD int) (int, int, bool) { var carg1 C.gint // in, none, casted var carg2 C.gint // in, none, casted var carg3 C.gint // in, none, casted var carg4 C.gint // in, none, casted var carg5 C.gint // out, full, casted var carg6 C.gint // out, full, casted var cret C.gboolean // return carg1 = C.gint(aN) carg2 = C.gint(aD) carg3 = C.gint(bN) carg4 = C.gint(bD) cret = C.gst_util_fraction_multiply(carg1, carg2, carg3, carg4, &carg5, &carg6) runtime.KeepAlive(aN) runtime.KeepAlive(aD) runtime.KeepAlive(bN) runtime.KeepAlive(bD) var resN int var resD int var goret bool resN = int(carg5) resD = int(carg6) if cret != 0 { goret = true } return resN, resD, goret } // UtilFractionToDouble wraps gst_util_fraction_to_double // // The function takes the following parameters: // // - srcN int: Fraction numerator as #gint // - srcD int: Fraction denominator #gint // // The function returns the following values: // // - dest float64: pointer to a #gdouble for the result // // Transforms a fraction to a #gdouble. func UtilFractionToDouble(srcN int, srcD int) float64 { var carg1 C.gint // in, none, casted var carg2 C.gint // in, none, casted var carg3 C.gdouble // out, full, casted carg1 = C.gint(srcN) carg2 = C.gint(srcD) C.gst_util_fraction_to_double(carg1, carg2, &carg3) runtime.KeepAlive(srcN) runtime.KeepAlive(srcD) var dest float64 dest = float64(carg3) return dest } // UtilGdoubleToGuint64 wraps gst_util_gdouble_to_guint64 // // The function takes the following parameters: // // - value float64: The #gdouble value to convert guint64 double // // The function returns the following values: // // - goret uint64 func UtilGdoubleToGuint64(value float64) uint64 { var carg1 C.gdouble // in, none, casted var cret C.guint64 // return, none, casted carg1 = C.gdouble(value) cret = C.gst_util_gdouble_to_guint64(carg1) runtime.KeepAlive(value) var goret uint64 goret = uint64(cret) return goret } // UtilGetTimestamp wraps gst_util_get_timestamp // // The function returns the following values: // // - goret ClockTime // // Get a timestamp as GstClockTime to be used for interval measurements. // The timestamp should not be interpreted in any other way. func UtilGetTimestamp() ClockTime { var cret C.GstClockTime // return, none, casted, alias cret = C.gst_util_get_timestamp() var goret ClockTime goret = ClockTime(cret) return goret } // UtilGreatestCommonDivisor wraps gst_util_greatest_common_divisor // // The function takes the following parameters: // // - a int: First value as #gint // - b int: Second value as #gint // // The function returns the following values: // // - goret int // // Calculates the greatest common divisor of @a // and @b. func UtilGreatestCommonDivisor(a int, b int) int { var carg1 C.gint // in, none, casted var carg2 C.gint // in, none, casted var cret C.gint // return, none, casted carg1 = C.gint(a) carg2 = C.gint(b) cret = C.gst_util_greatest_common_divisor(carg1, carg2) runtime.KeepAlive(a) runtime.KeepAlive(b) var goret int goret = int(cret) return goret } // UtilGreatestCommonDivisorInt64 wraps gst_util_greatest_common_divisor_int64 // // The function takes the following parameters: // // - a int64: First value as #gint64 // - b int64: Second value as #gint64 // // The function returns the following values: // // - goret int64 // // Calculates the greatest common divisor of @a // and @b. func UtilGreatestCommonDivisorInt64(a int64, b int64) int64 { var carg1 C.gint64 // in, none, casted var carg2 C.gint64 // in, none, casted var cret C.gint64 // return, none, casted carg1 = C.gint64(a) carg2 = C.gint64(b) cret = C.gst_util_greatest_common_divisor_int64(carg1, carg2) runtime.KeepAlive(a) runtime.KeepAlive(b) var goret int64 goret = int64(cret) return goret } // UtilGroupIDNext wraps gst_util_group_id_next // // The function returns the following values: // // - goret uint // // Return a constantly incrementing group id. // // This function is used to generate a new group-id for the // stream-start event. // // This function never returns %GST_GROUP_ID_INVALID (which is 0) func UtilGroupIDNext() uint { var cret C.guint // return, none, casted cret = C.gst_util_group_id_next() var goret uint goret = uint(cret) return goret } // UtilGuint64ToGdouble wraps gst_util_guint64_to_gdouble // // The function takes the following parameters: // // - value uint64: The #guint64 value to convert to double // // The function returns the following values: // // - goret float64 func UtilGuint64ToGdouble(value uint64) float64 { var carg1 C.guint64 // in, none, casted var cret C.gdouble // return, none, casted carg1 = C.guint64(value) cret = C.gst_util_guint64_to_gdouble(carg1) runtime.KeepAlive(value) var goret float64 goret = float64(cret) return goret } // UtilSeqnumCompare wraps gst_util_seqnum_compare // // The function takes the following parameters: // // - s1 uint32: A sequence number. // - s2 uint32: Another sequence number. // // The function returns the following values: // // - goret int32 // // Compare two sequence numbers, handling wraparound. // // The current implementation just returns (gint32)(@s1 - @s2). func UtilSeqnumCompare(s1 uint32, s2 uint32) int32 { var carg1 C.guint32 // in, none, casted var carg2 C.guint32 // in, none, casted var cret C.gint32 // return, none, casted carg1 = C.guint32(s1) carg2 = C.guint32(s2) cret = C.gst_util_seqnum_compare(carg1, carg2) runtime.KeepAlive(s1) runtime.KeepAlive(s2) var goret int32 goret = int32(cret) return goret } // UtilSeqnumNext wraps gst_util_seqnum_next // // The function returns the following values: // // - goret uint32 // // Return a constantly incrementing sequence number. // // This function is used internally to GStreamer to be able to determine which // events and messages are "the same". For example, elements may set the seqnum // on a segment-done message to be the same as that of the last seek event, to // indicate that event and the message correspond to the same segment. // // This function never returns %GST_SEQNUM_INVALID (which is 0). func UtilSeqnumNext() uint32 { var cret C.guint32 // return, none, casted cret = C.gst_util_seqnum_next() var goret uint32 goret = uint32(cret) return goret } // UtilSetObjectArg wraps gst_util_set_object_arg // // The function takes the following parameters: // // - object gobject.Object: the object to set the argument of // - name string: the name of the argument to set // - value string: the string value to set // // Converts the string value to the type of the objects argument and // sets the argument with it. // // Note that this function silently returns if @object has no property named // @name or when @value cannot be converted to the type of the property. func UtilSetObjectArg(object gobject.Object, name string, value string) { var carg1 *C.GObject // in, none, converted var carg2 *C.gchar // in, none, string var carg3 *C.gchar // in, none, string carg1 = (*C.GObject)(gobject.UnsafeObjectToGlibNone(object)) carg2 = (*C.gchar)(unsafe.Pointer(C.CString(name))) defer C.free(unsafe.Pointer(carg2)) carg3 = (*C.gchar)(unsafe.Pointer(C.CString(value))) defer C.free(unsafe.Pointer(carg3)) C.gst_util_set_object_arg(carg1, carg2, carg3) runtime.KeepAlive(object) runtime.KeepAlive(name) runtime.KeepAlive(value) } // UtilSimplifyFraction wraps gst_util_simplify_fraction // // The function takes the following parameters: // // - numerator *int: First value as #gint // - denominator *int: Second value as #gint // - nTerms uint: non-significative terms (typical value: 8) // - threshold uint: threshold (typical value: 333) // // Calculates the simpler representation of @numerator and @denominator and // update both values with the resulting simplified fraction. // // Simplify a fraction using a simple continued fraction decomposition. // The idea here is to convert fractions such as 333333/10000000 to 1/30 // using 32 bit arithmetic only. The algorithm is not perfect and relies // upon two arbitrary parameters to remove non-significative terms from // the simple continued fraction decomposition. Using 8 and 333 for // @n_terms and @threshold respectively seems to give nice results. func UtilSimplifyFraction(numerator *int, denominator *int, nTerms uint, threshold uint) { var carg1 *C.gint // in, transfer: none, C Pointers: 1, Name: gint var carg2 *C.gint // in, transfer: none, C Pointers: 1, Name: gint var carg3 C.guint // in, none, casted var carg4 C.guint // in, none, casted _ = numerator _ = carg1 panic("unimplemented conversion of *int (gint*)") _ = denominator _ = carg2 panic("unimplemented conversion of *int (gint*)") carg3 = C.guint(nTerms) carg4 = C.guint(threshold) C.gst_util_simplify_fraction(carg1, carg2, carg3, carg4) runtime.KeepAlive(numerator) runtime.KeepAlive(denominator) runtime.KeepAlive(nTerms) runtime.KeepAlive(threshold) } // UtilUint64Scale wraps gst_util_uint64_scale // // The function takes the following parameters: // // - val uint64: the number to scale // - num uint64: the numerator of the scale ratio // - denom uint64: the denominator of the scale ratio // // The function returns the following values: // // - goret uint64 // // Scale @val by the rational number @num / @denom, avoiding overflows and // underflows and without loss of precision. // // This function can potentially be very slow if val and num are both // greater than G_MAXUINT32. func UtilUint64Scale(val uint64, num uint64, denom uint64) uint64 { var carg1 C.guint64 // in, none, casted var carg2 C.guint64 // in, none, casted var carg3 C.guint64 // in, none, casted var cret C.guint64 // return, none, casted carg1 = C.guint64(val) carg2 = C.guint64(num) carg3 = C.guint64(denom) cret = C.gst_util_uint64_scale(carg1, carg2, carg3) runtime.KeepAlive(val) runtime.KeepAlive(num) runtime.KeepAlive(denom) var goret uint64 goret = uint64(cret) return goret } // UtilUint64ScaleCeil wraps gst_util_uint64_scale_ceil // // The function takes the following parameters: // // - val uint64: the number to scale // - num uint64: the numerator of the scale ratio // - denom uint64: the denominator of the scale ratio // // The function returns the following values: // // - goret uint64 // // Scale @val by the rational number @num / @denom, avoiding overflows and // underflows and without loss of precision. // // This function can potentially be very slow if val and num are both // greater than G_MAXUINT32. func UtilUint64ScaleCeil(val uint64, num uint64, denom uint64) uint64 { var carg1 C.guint64 // in, none, casted var carg2 C.guint64 // in, none, casted var carg3 C.guint64 // in, none, casted var cret C.guint64 // return, none, casted carg1 = C.guint64(val) carg2 = C.guint64(num) carg3 = C.guint64(denom) cret = C.gst_util_uint64_scale_ceil(carg1, carg2, carg3) runtime.KeepAlive(val) runtime.KeepAlive(num) runtime.KeepAlive(denom) var goret uint64 goret = uint64(cret) return goret } // UtilUint64ScaleInt wraps gst_util_uint64_scale_int // // The function takes the following parameters: // // - val uint64: guint64 (such as a #GstClockTime) to scale. // - num int: numerator of the scale factor. // - denom int: denominator of the scale factor. // // The function returns the following values: // // - goret uint64 // // Scale @val by the rational number @num / @denom, avoiding overflows and // underflows and without loss of precision. @num must be non-negative and // @denom must be positive. func UtilUint64ScaleInt(val uint64, num int, denom int) uint64 { var carg1 C.guint64 // in, none, casted var carg2 C.gint // in, none, casted var carg3 C.gint // in, none, casted var cret C.guint64 // return, none, casted carg1 = C.guint64(val) carg2 = C.gint(num) carg3 = C.gint(denom) cret = C.gst_util_uint64_scale_int(carg1, carg2, carg3) runtime.KeepAlive(val) runtime.KeepAlive(num) runtime.KeepAlive(denom) var goret uint64 goret = uint64(cret) return goret } // UtilUint64ScaleIntCeil wraps gst_util_uint64_scale_int_ceil // // The function takes the following parameters: // // - val uint64: guint64 (such as a #GstClockTime) to scale. // - num int: numerator of the scale factor. // - denom int: denominator of the scale factor. // // The function returns the following values: // // - goret uint64 // // Scale @val by the rational number @num / @denom, avoiding overflows and // underflows and without loss of precision. @num must be non-negative and // @denom must be positive. func UtilUint64ScaleIntCeil(val uint64, num int, denom int) uint64 { var carg1 C.guint64 // in, none, casted var carg2 C.gint // in, none, casted var carg3 C.gint // in, none, casted var cret C.guint64 // return, none, casted carg1 = C.guint64(val) carg2 = C.gint(num) carg3 = C.gint(denom) cret = C.gst_util_uint64_scale_int_ceil(carg1, carg2, carg3) runtime.KeepAlive(val) runtime.KeepAlive(num) runtime.KeepAlive(denom) var goret uint64 goret = uint64(cret) return goret } // UtilUint64ScaleIntRound wraps gst_util_uint64_scale_int_round // // The function takes the following parameters: // // - val uint64: guint64 (such as a #GstClockTime) to scale. // - num int: numerator of the scale factor. // - denom int: denominator of the scale factor. // // The function returns the following values: // // - goret uint64 // // Scale @val by the rational number @num / @denom, avoiding overflows and // underflows and without loss of precision. @num must be non-negative and // @denom must be positive. func UtilUint64ScaleIntRound(val uint64, num int, denom int) uint64 { var carg1 C.guint64 // in, none, casted var carg2 C.gint // in, none, casted var carg3 C.gint // in, none, casted var cret C.guint64 // return, none, casted carg1 = C.guint64(val) carg2 = C.gint(num) carg3 = C.gint(denom) cret = C.gst_util_uint64_scale_int_round(carg1, carg2, carg3) runtime.KeepAlive(val) runtime.KeepAlive(num) runtime.KeepAlive(denom) var goret uint64 goret = uint64(cret) return goret } // UtilUint64ScaleRound wraps gst_util_uint64_scale_round // // The function takes the following parameters: // // - val uint64: the number to scale // - num uint64: the numerator of the scale ratio // - denom uint64: the denominator of the scale ratio // // The function returns the following values: // // - goret uint64 // // Scale @val by the rational number @num / @denom, avoiding overflows and // underflows and without loss of precision. // // This function can potentially be very slow if val and num are both // greater than G_MAXUINT32. func UtilUint64ScaleRound(val uint64, num uint64, denom uint64) uint64 { var carg1 C.guint64 // in, none, casted var carg2 C.guint64 // in, none, casted var carg3 C.guint64 // in, none, casted var cret C.guint64 // return, none, casted carg1 = C.guint64(val) carg2 = C.guint64(num) carg3 = C.guint64(denom) cret = C.gst_util_uint64_scale_round(carg1, carg2, carg3) runtime.KeepAlive(val) runtime.KeepAlive(num) runtime.KeepAlive(denom) var goret uint64 goret = uint64(cret) return goret } // ValueCanCompare wraps gst_value_can_compare // // The function takes the following parameters: // // - value1 *gobject.Value: a value to compare // - value2 *gobject.Value: another value to compare // // The function returns the following values: // // - goret bool // // Determines if @value1 and @value2 can be compared. func ValueCanCompare(value1 *gobject.Value, value2 *gobject.Value) bool { var carg1 *C.GValue // in, none, converted var carg2 *C.GValue // in, none, converted var cret C.gboolean // return carg1 = (*C.GValue)(gobject.UnsafeValueToGlibUseAnyInstead(value1)) carg2 = (*C.GValue)(gobject.UnsafeValueToGlibUseAnyInstead(value2)) cret = C.gst_value_can_compare(carg1, carg2) runtime.KeepAlive(value1) runtime.KeepAlive(value2) var goret bool if cret != 0 { goret = true } return goret } // ValueCanIntersect wraps gst_value_can_intersect // // The function takes the following parameters: // // - value1 *gobject.Value: a value to intersect // - value2 *gobject.Value: another value to intersect // // The function returns the following values: // // - goret bool // // Determines if intersecting two values will produce a valid result. // Two values will produce a valid intersection if they have the same // type. func ValueCanIntersect(value1 *gobject.Value, value2 *gobject.Value) bool { var carg1 *C.GValue // in, none, converted var carg2 *C.GValue // in, none, converted var cret C.gboolean // return carg1 = (*C.GValue)(gobject.UnsafeValueToGlibUseAnyInstead(value1)) carg2 = (*C.GValue)(gobject.UnsafeValueToGlibUseAnyInstead(value2)) cret = C.gst_value_can_intersect(carg1, carg2) runtime.KeepAlive(value1) runtime.KeepAlive(value2) var goret bool if cret != 0 { goret = true } return goret } // ValueCanSubtract wraps gst_value_can_subtract // // The function takes the following parameters: // // - minuend *gobject.Value: the value to subtract from // - subtrahend *gobject.Value: the value to subtract // // The function returns the following values: // // - goret bool // // Checks if it's possible to subtract @subtrahend from @minuend. func ValueCanSubtract(minuend *gobject.Value, subtrahend *gobject.Value) bool { var carg1 *C.GValue // in, none, converted var carg2 *C.GValue // in, none, converted var cret C.gboolean // return carg1 = (*C.GValue)(gobject.UnsafeValueToGlibUseAnyInstead(minuend)) carg2 = (*C.GValue)(gobject.UnsafeValueToGlibUseAnyInstead(subtrahend)) cret = C.gst_value_can_subtract(carg1, carg2) runtime.KeepAlive(minuend) runtime.KeepAlive(subtrahend) var goret bool if cret != 0 { goret = true } return goret } // ValueCanUnion wraps gst_value_can_union // // The function takes the following parameters: // // - value1 *gobject.Value: a value to union // - value2 *gobject.Value: another value to union // // The function returns the following values: // // - goret bool // // Determines if @value1 and @value2 can be non-trivially unioned. // Any two values can be trivially unioned by adding both of them // to a GstValueList. However, certain types have the possibility // to be unioned in a simpler way. For example, an integer range // and an integer can be unioned if the integer is a subset of the // integer range. If there is the possibility that two values can // be unioned, this function returns %TRUE. func ValueCanUnion(value1 *gobject.Value, value2 *gobject.Value) bool { var carg1 *C.GValue // in, none, converted var carg2 *C.GValue // in, none, converted var cret C.gboolean // return carg1 = (*C.GValue)(gobject.UnsafeValueToGlibUseAnyInstead(value1)) carg2 = (*C.GValue)(gobject.UnsafeValueToGlibUseAnyInstead(value2)) cret = C.gst_value_can_union(carg1, carg2) runtime.KeepAlive(value1) runtime.KeepAlive(value2) var goret bool if cret != 0 { goret = true } return goret } // ValueCompare wraps gst_value_compare // // The function takes the following parameters: // // - value1 *gobject.Value: a value to compare // - value2 *gobject.Value: another value to compare // // The function returns the following values: // // - goret int // // Compares @value1 and @value2. If @value1 and @value2 cannot be // compared, the function returns GST_VALUE_UNORDERED. Otherwise, // if @value1 is greater than @value2, GST_VALUE_GREATER_THAN is returned. // If @value1 is less than @value2, GST_VALUE_LESS_THAN is returned. // If the values are equal, GST_VALUE_EQUAL is returned. func ValueCompare(value1 *gobject.Value, value2 *gobject.Value) int { var carg1 *C.GValue // in, none, converted var carg2 *C.GValue // in, none, converted var cret C.gint // return, none, casted carg1 = (*C.GValue)(gobject.UnsafeValueToGlibUseAnyInstead(value1)) carg2 = (*C.GValue)(gobject.UnsafeValueToGlibUseAnyInstead(value2)) cret = C.gst_value_compare(carg1, carg2) runtime.KeepAlive(value1) runtime.KeepAlive(value2) var goret int goret = int(cret) return goret } // ValueDeserialize wraps gst_value_deserialize // // The function takes the following parameters: // // - src string: string to deserialize // // The function returns the following values: // // - dest gobject.Value: #GValue to fill with contents of // deserialization // - goret bool // // Tries to deserialize a string into the type specified by the given GValue. // If the operation succeeds, %TRUE is returned, %FALSE otherwise. func ValueDeserialize(src string) (gobject.Value, bool) { var carg2 *C.gchar // in, none, string var carg1 C.GValue // out, transfer: none, C Pointers: 0, Name: Value, caller-allocates var cret C.gboolean // return carg2 = (*C.gchar)(unsafe.Pointer(C.CString(src))) defer C.free(unsafe.Pointer(carg2)) cret = C.gst_value_deserialize(&carg1, carg2) runtime.KeepAlive(src) var dest gobject.Value var goret bool _ = dest _ = carg1 panic("unimplemented conversion of gobject.Value (GValue)") if cret != 0 { goret = true } return dest, goret } // ValueFixate wraps gst_value_fixate // // The function takes the following parameters: // // - dest *gobject.Value: the #GValue destination // - src *gobject.Value: the #GValue to fixate // // The function returns the following values: // // - goret bool // // Fixate @src into a new value @dest. // For ranges, the first element is taken. For lists and arrays, the // first item is fixated and returned. // If @src is already fixed, this function returns %FALSE. func ValueFixate(dest *gobject.Value, src *gobject.Value) bool { var carg1 *C.GValue // in, none, converted var carg2 *C.GValue // in, none, converted var cret C.gboolean // return carg1 = (*C.GValue)(gobject.UnsafeValueToGlibUseAnyInstead(dest)) carg2 = (*C.GValue)(gobject.UnsafeValueToGlibUseAnyInstead(src)) cret = C.gst_value_fixate(carg1, carg2) runtime.KeepAlive(dest) runtime.KeepAlive(src) var goret bool if cret != 0 { goret = true } return goret } // ValueFractionMultiply wraps gst_value_fraction_multiply // // The function takes the following parameters: // // - product *gobject.Value: a GValue initialized to #GST_TYPE_FRACTION // - factor1 *gobject.Value: a GValue initialized to #GST_TYPE_FRACTION // - factor2 *gobject.Value: a GValue initialized to #GST_TYPE_FRACTION // // The function returns the following values: // // - goret bool // // Multiplies the two #GValue items containing a #GST_TYPE_FRACTION and sets // @product to the product of the two fractions. func ValueFractionMultiply(product *gobject.Value, factor1 *gobject.Value, factor2 *gobject.Value) bool { var carg1 *C.GValue // in, none, converted var carg2 *C.GValue // in, none, converted var carg3 *C.GValue // in, none, converted var cret C.gboolean // return carg1 = (*C.GValue)(gobject.UnsafeValueToGlibUseAnyInstead(product)) carg2 = (*C.GValue)(gobject.UnsafeValueToGlibUseAnyInstead(factor1)) carg3 = (*C.GValue)(gobject.UnsafeValueToGlibUseAnyInstead(factor2)) cret = C.gst_value_fraction_multiply(carg1, carg2, carg3) runtime.KeepAlive(product) runtime.KeepAlive(factor1) runtime.KeepAlive(factor2) var goret bool if cret != 0 { goret = true } return goret } // ValueFractionSubtract wraps gst_value_fraction_subtract // // The function takes the following parameters: // // - dest *gobject.Value: a GValue initialized to #GST_TYPE_FRACTION // - minuend *gobject.Value: a GValue initialized to #GST_TYPE_FRACTION // - subtrahend *gobject.Value: a GValue initialized to #GST_TYPE_FRACTION // // The function returns the following values: // // - goret bool // // Subtracts the @subtrahend from the @minuend and sets @dest to the result. func ValueFractionSubtract(dest *gobject.Value, minuend *gobject.Value, subtrahend *gobject.Value) bool { var carg1 *C.GValue // in, none, converted var carg2 *C.GValue // in, none, converted var carg3 *C.GValue // in, none, converted var cret C.gboolean // return carg1 = (*C.GValue)(gobject.UnsafeValueToGlibUseAnyInstead(dest)) carg2 = (*C.GValue)(gobject.UnsafeValueToGlibUseAnyInstead(minuend)) carg3 = (*C.GValue)(gobject.UnsafeValueToGlibUseAnyInstead(subtrahend)) cret = C.gst_value_fraction_subtract(carg1, carg2, carg3) runtime.KeepAlive(dest) runtime.KeepAlive(minuend) runtime.KeepAlive(subtrahend) var goret bool if cret != 0 { goret = true } return goret } // ValueGetBitmask wraps gst_value_get_bitmask // // The function takes the following parameters: // // - value *gobject.Value: a GValue initialized to #GST_TYPE_BITMASK // // The function returns the following values: // // - goret uint64 // // Gets the bitmask specified by @value. func ValueGetBitmask(value *gobject.Value) uint64 { var carg1 *C.GValue // in, none, converted var cret C.guint64 // return, none, casted carg1 = (*C.GValue)(gobject.UnsafeValueToGlibUseAnyInstead(value)) cret = C.gst_value_get_bitmask(carg1) runtime.KeepAlive(value) var goret uint64 goret = uint64(cret) return goret } // ValueGetCaps wraps gst_value_get_caps // // The function takes the following parameters: // // - value *gobject.Value: a GValue initialized to GST_TYPE_CAPS // // The function returns the following values: // // - goret *Caps // // Gets the contents of @value. The reference count of the returned // #GstCaps will not be modified, therefore the caller must take one // before getting rid of the @value. func ValueGetCaps(value *gobject.Value) *Caps { var carg1 *C.GValue // in, none, converted var cret *C.GstCaps // return, none, converted carg1 = (*C.GValue)(gobject.UnsafeValueToGlibUseAnyInstead(value)) cret = C.gst_value_get_caps(carg1) runtime.KeepAlive(value) var goret *Caps goret = UnsafeCapsFromGlibNone(unsafe.Pointer(cret)) return goret } // ValueGetCapsFeatures wraps gst_value_get_caps_features // // The function takes the following parameters: // // - value *gobject.Value: a GValue initialized to GST_TYPE_CAPS_FEATURES // // The function returns the following values: // // - goret *CapsFeatures // // Gets the contents of @value. func ValueGetCapsFeatures(value *gobject.Value) *CapsFeatures { var carg1 *C.GValue // in, none, converted var cret *C.GstCapsFeatures // return, none, converted carg1 = (*C.GValue)(gobject.UnsafeValueToGlibUseAnyInstead(value)) cret = C.gst_value_get_caps_features(carg1) runtime.KeepAlive(value) var goret *CapsFeatures goret = UnsafeCapsFeaturesFromGlibNone(unsafe.Pointer(cret)) return goret } // ValueGetDoubleRangeMax wraps gst_value_get_double_range_max // // The function takes the following parameters: // // - value *gobject.Value: a GValue initialized to GST_TYPE_DOUBLE_RANGE // // The function returns the following values: // // - goret float64 // // Gets the maximum of the range specified by @value. func ValueGetDoubleRangeMax(value *gobject.Value) float64 { var carg1 *C.GValue // in, none, converted var cret C.gdouble // return, none, casted carg1 = (*C.GValue)(gobject.UnsafeValueToGlibUseAnyInstead(value)) cret = C.gst_value_get_double_range_max(carg1) runtime.KeepAlive(value) var goret float64 goret = float64(cret) return goret } // ValueGetDoubleRangeMin wraps gst_value_get_double_range_min // // The function takes the following parameters: // // - value *gobject.Value: a GValue initialized to GST_TYPE_DOUBLE_RANGE // // The function returns the following values: // // - goret float64 // // Gets the minimum of the range specified by @value. func ValueGetDoubleRangeMin(value *gobject.Value) float64 { var carg1 *C.GValue // in, none, converted var cret C.gdouble // return, none, casted carg1 = (*C.GValue)(gobject.UnsafeValueToGlibUseAnyInstead(value)) cret = C.gst_value_get_double_range_min(carg1) runtime.KeepAlive(value) var goret float64 goret = float64(cret) return goret } // ValueGetFlagsetFlags wraps gst_value_get_flagset_flags // // The function takes the following parameters: // // - value *gobject.Value: a GValue initialized to #GST_TYPE_FLAG_SET // // The function returns the following values: // // - goret uint // // Retrieve the flags field of a GstFlagSet @value. func ValueGetFlagsetFlags(value *gobject.Value) uint { var carg1 *C.GValue // in, none, converted var cret C.guint // return, none, casted carg1 = (*C.GValue)(gobject.UnsafeValueToGlibUseAnyInstead(value)) cret = C.gst_value_get_flagset_flags(carg1) runtime.KeepAlive(value) var goret uint goret = uint(cret) return goret } // ValueGetFlagsetMask wraps gst_value_get_flagset_mask // // The function takes the following parameters: // // - value *gobject.Value: a GValue initialized to #GST_TYPE_FLAG_SET // // The function returns the following values: // // - goret uint // // Retrieve the mask field of a GstFlagSet @value. func ValueGetFlagsetMask(value *gobject.Value) uint { var carg1 *C.GValue // in, none, converted var cret C.guint // return, none, casted carg1 = (*C.GValue)(gobject.UnsafeValueToGlibUseAnyInstead(value)) cret = C.gst_value_get_flagset_mask(carg1) runtime.KeepAlive(value) var goret uint goret = uint(cret) return goret } // ValueGetFractionDenominator wraps gst_value_get_fraction_denominator // // The function takes the following parameters: // // - value *gobject.Value: a GValue initialized to #GST_TYPE_FRACTION // // The function returns the following values: // // - goret int // // Gets the denominator of the fraction specified by @value. func ValueGetFractionDenominator(value *gobject.Value) int { var carg1 *C.GValue // in, none, converted var cret C.gint // return, none, casted carg1 = (*C.GValue)(gobject.UnsafeValueToGlibUseAnyInstead(value)) cret = C.gst_value_get_fraction_denominator(carg1) runtime.KeepAlive(value) var goret int goret = int(cret) return goret } // ValueGetFractionNumerator wraps gst_value_get_fraction_numerator // // The function takes the following parameters: // // - value *gobject.Value: a GValue initialized to #GST_TYPE_FRACTION // // The function returns the following values: // // - goret int // // Gets the numerator of the fraction specified by @value. func ValueGetFractionNumerator(value *gobject.Value) int { var carg1 *C.GValue // in, none, converted var cret C.gint // return, none, casted carg1 = (*C.GValue)(gobject.UnsafeValueToGlibUseAnyInstead(value)) cret = C.gst_value_get_fraction_numerator(carg1) runtime.KeepAlive(value) var goret int goret = int(cret) return goret } // ValueGetFractionRangeMax wraps gst_value_get_fraction_range_max // // The function takes the following parameters: // // - value *gobject.Value: a GValue initialized to GST_TYPE_FRACTION_RANGE // // The function returns the following values: // // - goret *gobject.Value (nullable) // // Gets the maximum of the range specified by @value. func ValueGetFractionRangeMax(value *gobject.Value) *gobject.Value { var carg1 *C.GValue // in, none, converted var cret *C.GValue // return, none, converted, nullable carg1 = (*C.GValue)(gobject.UnsafeValueToGlibUseAnyInstead(value)) cret = C.gst_value_get_fraction_range_max(carg1) runtime.KeepAlive(value) var goret *gobject.Value if cret != nil { goret = gobject.UnsafeValueFromGlibUseAnyInstead(unsafe.Pointer(cret)) } return goret } // ValueGetFractionRangeMin wraps gst_value_get_fraction_range_min // // The function takes the following parameters: // // - value *gobject.Value: a GValue initialized to GST_TYPE_FRACTION_RANGE // // The function returns the following values: // // - goret *gobject.Value (nullable) // // Gets the minimum of the range specified by @value. func ValueGetFractionRangeMin(value *gobject.Value) *gobject.Value { var carg1 *C.GValue // in, none, converted var cret *C.GValue // return, none, converted, nullable carg1 = (*C.GValue)(gobject.UnsafeValueToGlibUseAnyInstead(value)) cret = C.gst_value_get_fraction_range_min(carg1) runtime.KeepAlive(value) var goret *gobject.Value if cret != nil { goret = gobject.UnsafeValueFromGlibUseAnyInstead(unsafe.Pointer(cret)) } return goret } // ValueGetInt64RangeMax wraps gst_value_get_int64_range_max // // The function takes the following parameters: // // - value *gobject.Value: a GValue initialized to GST_TYPE_INT64_RANGE // // The function returns the following values: // // - goret int64 // // Gets the maximum of the range specified by @value. func ValueGetInt64RangeMax(value *gobject.Value) int64 { var carg1 *C.GValue // in, none, converted var cret C.gint64 // return, none, casted carg1 = (*C.GValue)(gobject.UnsafeValueToGlibUseAnyInstead(value)) cret = C.gst_value_get_int64_range_max(carg1) runtime.KeepAlive(value) var goret int64 goret = int64(cret) return goret } // ValueGetInt64RangeMin wraps gst_value_get_int64_range_min // // The function takes the following parameters: // // - value *gobject.Value: a GValue initialized to GST_TYPE_INT64_RANGE // // The function returns the following values: // // - goret int64 // // Gets the minimum of the range specified by @value. func ValueGetInt64RangeMin(value *gobject.Value) int64 { var carg1 *C.GValue // in, none, converted var cret C.gint64 // return, none, casted carg1 = (*C.GValue)(gobject.UnsafeValueToGlibUseAnyInstead(value)) cret = C.gst_value_get_int64_range_min(carg1) runtime.KeepAlive(value) var goret int64 goret = int64(cret) return goret } // ValueGetInt64RangeStep wraps gst_value_get_int64_range_step // // The function takes the following parameters: // // - value *gobject.Value: a GValue initialized to GST_TYPE_INT64_RANGE // // The function returns the following values: // // - goret int64 // // Gets the step of the range specified by @value. func ValueGetInt64RangeStep(value *gobject.Value) int64 { var carg1 *C.GValue // in, none, converted var cret C.gint64 // return, none, casted carg1 = (*C.GValue)(gobject.UnsafeValueToGlibUseAnyInstead(value)) cret = C.gst_value_get_int64_range_step(carg1) runtime.KeepAlive(value) var goret int64 goret = int64(cret) return goret } // ValueGetIntRangeMax wraps gst_value_get_int_range_max // // The function takes the following parameters: // // - value *gobject.Value: a GValue initialized to GST_TYPE_INT_RANGE // // The function returns the following values: // // - goret int // // Gets the maximum of the range specified by @value. func ValueGetIntRangeMax(value *gobject.Value) int { var carg1 *C.GValue // in, none, converted var cret C.gint // return, none, casted carg1 = (*C.GValue)(gobject.UnsafeValueToGlibUseAnyInstead(value)) cret = C.gst_value_get_int_range_max(carg1) runtime.KeepAlive(value) var goret int goret = int(cret) return goret } // ValueGetIntRangeMin wraps gst_value_get_int_range_min // // The function takes the following parameters: // // - value *gobject.Value: a GValue initialized to GST_TYPE_INT_RANGE // // The function returns the following values: // // - goret int // // Gets the minimum of the range specified by @value. func ValueGetIntRangeMin(value *gobject.Value) int { var carg1 *C.GValue // in, none, converted var cret C.gint // return, none, casted carg1 = (*C.GValue)(gobject.UnsafeValueToGlibUseAnyInstead(value)) cret = C.gst_value_get_int_range_min(carg1) runtime.KeepAlive(value) var goret int goret = int(cret) return goret } // ValueGetIntRangeStep wraps gst_value_get_int_range_step // // The function takes the following parameters: // // - value *gobject.Value: a GValue initialized to GST_TYPE_INT_RANGE // // The function returns the following values: // // - goret int // // Gets the step of the range specified by @value. func ValueGetIntRangeStep(value *gobject.Value) int { var carg1 *C.GValue // in, none, converted var cret C.gint // return, none, casted carg1 = (*C.GValue)(gobject.UnsafeValueToGlibUseAnyInstead(value)) cret = C.gst_value_get_int_range_step(carg1) runtime.KeepAlive(value) var goret int goret = int(cret) return goret } // ValueGetStructure wraps gst_value_get_structure // // The function takes the following parameters: // // - value *gobject.Value: a GValue initialized to GST_TYPE_STRUCTURE // // The function returns the following values: // // - goret *Structure // // Gets the contents of @value. func ValueGetStructure(value *gobject.Value) *Structure { var carg1 *C.GValue // in, none, converted var cret *C.GstStructure // return, none, converted carg1 = (*C.GValue)(gobject.UnsafeValueToGlibUseAnyInstead(value)) cret = C.gst_value_get_structure(carg1) runtime.KeepAlive(value) var goret *Structure goret = UnsafeStructureFromGlibNone(unsafe.Pointer(cret)) return goret } // ValueInitAndCopy wraps gst_value_init_and_copy // // The function takes the following parameters: // // - src *gobject.Value: the source value // // The function returns the following values: // // - dest gobject.Value: the target value // // Initialises the target value to be of the same type as source and then copies // the contents from source to target. func ValueInitAndCopy(src *gobject.Value) gobject.Value { var carg2 *C.GValue // in, none, converted var carg1 C.GValue // out, transfer: none, C Pointers: 0, Name: Value, caller-allocates carg2 = (*C.GValue)(gobject.UnsafeValueToGlibUseAnyInstead(src)) C.gst_value_init_and_copy(&carg1, carg2) runtime.KeepAlive(src) var dest gobject.Value _ = dest _ = carg1 panic("unimplemented conversion of gobject.Value (GValue)") return dest } // ValueIntersect wraps gst_value_intersect // // The function takes the following parameters: // // - value1 *gobject.Value: a value to intersect // - value2 *gobject.Value: another value to intersect // // The function returns the following values: // // - dest gobject.Value: // a uninitialized #GValue that will hold the calculated // intersection value. May be %NULL if the resulting set if not // needed. // - goret bool // // Calculates the intersection of two values. If the values have // a non-empty intersection, the value representing the intersection // is placed in @dest, unless %NULL. If the intersection is non-empty, // @dest is not modified. func ValueIntersect(value1 *gobject.Value, value2 *gobject.Value) (gobject.Value, bool) { var carg2 *C.GValue // in, none, converted var carg3 *C.GValue // in, none, converted var carg1 C.GValue // out, transfer: full, C Pointers: 0, Name: Value, optional, caller-allocates var cret C.gboolean // return carg2 = (*C.GValue)(gobject.UnsafeValueToGlibUseAnyInstead(value1)) carg3 = (*C.GValue)(gobject.UnsafeValueToGlibUseAnyInstead(value2)) cret = C.gst_value_intersect(&carg1, carg2, carg3) runtime.KeepAlive(value1) runtime.KeepAlive(value2) var dest gobject.Value var goret bool _ = dest _ = carg1 panic("unimplemented conversion of gobject.Value (GValue)") if cret != 0 { goret = true } return dest, goret } // ValueIsFixed wraps gst_value_is_fixed // // The function takes the following parameters: // // - value *gobject.Value: the #GValue to check // // The function returns the following values: // // - goret bool // // Tests if the given GValue, if available in a GstStructure (or any other // container) contains a "fixed" (which means: one value) or an "unfixed" // (which means: multiple possible values, such as data lists or data // ranges) value. func ValueIsFixed(value *gobject.Value) bool { var carg1 *C.GValue // in, none, converted var cret C.gboolean // return carg1 = (*C.GValue)(gobject.UnsafeValueToGlibUseAnyInstead(value)) cret = C.gst_value_is_fixed(carg1) runtime.KeepAlive(value) var goret bool if cret != 0 { goret = true } return goret } // ValueIsSubset wraps gst_value_is_subset // // The function takes the following parameters: // // - value1 *gobject.Value: a #GValue // - value2 *gobject.Value: a #GValue // // The function returns the following values: // // - goret bool // // Check that @value1 is a subset of @value2. func ValueIsSubset(value1 *gobject.Value, value2 *gobject.Value) bool { var carg1 *C.GValue // in, none, converted var carg2 *C.GValue // in, none, converted var cret C.gboolean // return carg1 = (*C.GValue)(gobject.UnsafeValueToGlibUseAnyInstead(value1)) carg2 = (*C.GValue)(gobject.UnsafeValueToGlibUseAnyInstead(value2)) cret = C.gst_value_is_subset(carg1, carg2) runtime.KeepAlive(value1) runtime.KeepAlive(value2) var goret bool if cret != 0 { goret = true } return goret } // ValueRegister wraps gst_value_register // // The function takes the following parameters: // // - table *ValueTable: structure containing functions to register // // Registers functions to perform calculations on #GValue items of a given // type. Each type can only be added once. func ValueRegister(table *ValueTable) { var carg1 *C.GstValueTable // in, none, converted carg1 = (*C.GstValueTable)(UnsafeValueTableToGlibNone(table)) C.gst_value_register(carg1) runtime.KeepAlive(table) } // ValueSerialize wraps gst_value_serialize // // The function takes the following parameters: // // - value *gobject.Value: a #GValue to serialize // // The function returns the following values: // // - goret string (nullable) // // tries to transform the given @value into a string representation that allows // getting back this string later on using gst_value_deserialize(). // // Free-function: g_free func ValueSerialize(value *gobject.Value) string { var carg1 *C.GValue // in, none, converted var cret *C.gchar // return, full, string, nullable-string carg1 = (*C.GValue)(gobject.UnsafeValueToGlibUseAnyInstead(value)) cret = C.gst_value_serialize(carg1) runtime.KeepAlive(value) var goret string if cret != nil { goret = C.GoString((*C.char)(unsafe.Pointer(cret))) defer C.free(unsafe.Pointer(cret)) } return goret } // ValueSetBitmask wraps gst_value_set_bitmask // // The function takes the following parameters: // // - value *gobject.Value: a GValue initialized to #GST_TYPE_BITMASK // - bitmask uint64: the bitmask // // Sets @value to the bitmask specified by @bitmask. func ValueSetBitmask(value *gobject.Value, bitmask uint64) { var carg1 *C.GValue // in, none, converted var carg2 C.guint64 // in, none, casted carg1 = (*C.GValue)(gobject.UnsafeValueToGlibUseAnyInstead(value)) carg2 = C.guint64(bitmask) C.gst_value_set_bitmask(carg1, carg2) runtime.KeepAlive(value) runtime.KeepAlive(bitmask) } // ValueSetCaps wraps gst_value_set_caps // // The function takes the following parameters: // // - value *gobject.Value: a GValue initialized to GST_TYPE_CAPS // - caps *Caps: the caps to set the value to // // Sets the contents of @value to @caps. A reference to the // provided @caps will be taken by the @value. func ValueSetCaps(value *gobject.Value, caps *Caps) { var carg1 *C.GValue // in, none, converted var carg2 *C.GstCaps // in, none, converted carg1 = (*C.GValue)(gobject.UnsafeValueToGlibUseAnyInstead(value)) carg2 = (*C.GstCaps)(UnsafeCapsToGlibNone(caps)) C.gst_value_set_caps(carg1, carg2) runtime.KeepAlive(value) runtime.KeepAlive(caps) } // ValueSetCapsFeatures wraps gst_value_set_caps_features // // The function takes the following parameters: // // - value *gobject.Value: a GValue initialized to GST_TYPE_CAPS_FEATURES // - features *CapsFeatures: the features to set the value to // // Sets the contents of @value to @features. func ValueSetCapsFeatures(value *gobject.Value, features *CapsFeatures) { var carg1 *C.GValue // in, none, converted var carg2 *C.GstCapsFeatures // in, none, converted carg1 = (*C.GValue)(gobject.UnsafeValueToGlibUseAnyInstead(value)) carg2 = (*C.GstCapsFeatures)(UnsafeCapsFeaturesToGlibNone(features)) C.gst_value_set_caps_features(carg1, carg2) runtime.KeepAlive(value) runtime.KeepAlive(features) } // ValueSetDoubleRange wraps gst_value_set_double_range // // The function takes the following parameters: // // - value *gobject.Value: a GValue initialized to GST_TYPE_DOUBLE_RANGE // - start float64: the start of the range // - end float64: the end of the range // // Sets @value to the range specified by @start and @end. func ValueSetDoubleRange(value *gobject.Value, start float64, end float64) { var carg1 *C.GValue // in, none, converted var carg2 C.gdouble // in, none, casted var carg3 C.gdouble // in, none, casted carg1 = (*C.GValue)(gobject.UnsafeValueToGlibUseAnyInstead(value)) carg2 = C.gdouble(start) carg3 = C.gdouble(end) C.gst_value_set_double_range(carg1, carg2, carg3) runtime.KeepAlive(value) runtime.KeepAlive(start) runtime.KeepAlive(end) } // ValueSetFlagset wraps gst_value_set_flagset // // The function takes the following parameters: // // - value *gobject.Value: a GValue initialized to %GST_TYPE_FLAG_SET // - flags uint: The value of the flags set or unset // - mask uint: The mask indicate which flags bits must match for comparisons // // Sets @value to the flags and mask values provided in @flags and @mask. // The @flags value indicates the values of flags, the @mask represents // which bits in the flag value have been set, and which are "don't care" func ValueSetFlagset(value *gobject.Value, flags uint, mask uint) { var carg1 *C.GValue // in, none, converted var carg2 C.guint // in, none, casted var carg3 C.guint // in, none, casted carg1 = (*C.GValue)(gobject.UnsafeValueToGlibUseAnyInstead(value)) carg2 = C.guint(flags) carg3 = C.guint(mask) C.gst_value_set_flagset(carg1, carg2, carg3) runtime.KeepAlive(value) runtime.KeepAlive(flags) runtime.KeepAlive(mask) } // ValueSetFraction wraps gst_value_set_fraction // // The function takes the following parameters: // // - value *gobject.Value: a GValue initialized to #GST_TYPE_FRACTION // - numerator int: the numerator of the fraction // - denominator int: the denominator of the fraction // // Sets @value to the fraction specified by @numerator over @denominator. // The fraction gets reduced to the smallest numerator and denominator, // and if necessary the sign is moved to the numerator. func ValueSetFraction(value *gobject.Value, numerator int, denominator int) { var carg1 *C.GValue // in, none, converted var carg2 C.gint // in, none, casted var carg3 C.gint // in, none, casted carg1 = (*C.GValue)(gobject.UnsafeValueToGlibUseAnyInstead(value)) carg2 = C.gint(numerator) carg3 = C.gint(denominator) C.gst_value_set_fraction(carg1, carg2, carg3) runtime.KeepAlive(value) runtime.KeepAlive(numerator) runtime.KeepAlive(denominator) } // ValueSetFractionRange wraps gst_value_set_fraction_range // // The function takes the following parameters: // // - value *gobject.Value: a GValue initialized to GST_TYPE_FRACTION_RANGE // - start *gobject.Value: the start of the range (a GST_TYPE_FRACTION GValue) // - end *gobject.Value: the end of the range (a GST_TYPE_FRACTION GValue) // // Sets @value to the range specified by @start and @end. func ValueSetFractionRange(value *gobject.Value, start *gobject.Value, end *gobject.Value) { var carg1 *C.GValue // in, none, converted var carg2 *C.GValue // in, none, converted var carg3 *C.GValue // in, none, converted carg1 = (*C.GValue)(gobject.UnsafeValueToGlibUseAnyInstead(value)) carg2 = (*C.GValue)(gobject.UnsafeValueToGlibUseAnyInstead(start)) carg3 = (*C.GValue)(gobject.UnsafeValueToGlibUseAnyInstead(end)) C.gst_value_set_fraction_range(carg1, carg2, carg3) runtime.KeepAlive(value) runtime.KeepAlive(start) runtime.KeepAlive(end) } // ValueSetFractionRangeFull wraps gst_value_set_fraction_range_full // // The function takes the following parameters: // // - value *gobject.Value: a GValue initialized to GST_TYPE_FRACTION_RANGE // - numeratorStart int: the numerator start of the range // - denominatorStart int: the denominator start of the range // - numeratorEnd int: the numerator end of the range // - denominatorEnd int: the denominator end of the range // // Sets @value to the range specified by @numerator_start/@denominator_start // and @numerator_end/@denominator_end. func ValueSetFractionRangeFull(value *gobject.Value, numeratorStart int, denominatorStart int, numeratorEnd int, denominatorEnd int) { var carg1 *C.GValue // in, none, converted var carg2 C.gint // in, none, casted var carg3 C.gint // in, none, casted var carg4 C.gint // in, none, casted var carg5 C.gint // in, none, casted carg1 = (*C.GValue)(gobject.UnsafeValueToGlibUseAnyInstead(value)) carg2 = C.gint(numeratorStart) carg3 = C.gint(denominatorStart) carg4 = C.gint(numeratorEnd) carg5 = C.gint(denominatorEnd) C.gst_value_set_fraction_range_full(carg1, carg2, carg3, carg4, carg5) runtime.KeepAlive(value) runtime.KeepAlive(numeratorStart) runtime.KeepAlive(denominatorStart) runtime.KeepAlive(numeratorEnd) runtime.KeepAlive(denominatorEnd) } // ValueSetInt64Range wraps gst_value_set_int64_range // // The function takes the following parameters: // // - value *gobject.Value: a GValue initialized to GST_TYPE_INT64_RANGE // - start int64: the start of the range // - end int64: the end of the range // // Sets @value to the range specified by @start and @end. func ValueSetInt64Range(value *gobject.Value, start int64, end int64) { var carg1 *C.GValue // in, none, converted var carg2 C.gint64 // in, none, casted var carg3 C.gint64 // in, none, casted carg1 = (*C.GValue)(gobject.UnsafeValueToGlibUseAnyInstead(value)) carg2 = C.gint64(start) carg3 = C.gint64(end) C.gst_value_set_int64_range(carg1, carg2, carg3) runtime.KeepAlive(value) runtime.KeepAlive(start) runtime.KeepAlive(end) } // ValueSetInt64RangeStep wraps gst_value_set_int64_range_step // // The function takes the following parameters: // // - value *gobject.Value: a GValue initialized to GST_TYPE_INT64_RANGE // - start int64: the start of the range // - end int64: the end of the range // - step int64: the step of the range // // Sets @value to the range specified by @start, @end and @step. func ValueSetInt64RangeStep(value *gobject.Value, start int64, end int64, step int64) { var carg1 *C.GValue // in, none, converted var carg2 C.gint64 // in, none, casted var carg3 C.gint64 // in, none, casted var carg4 C.gint64 // in, none, casted carg1 = (*C.GValue)(gobject.UnsafeValueToGlibUseAnyInstead(value)) carg2 = C.gint64(start) carg3 = C.gint64(end) carg4 = C.gint64(step) C.gst_value_set_int64_range_step(carg1, carg2, carg3, carg4) runtime.KeepAlive(value) runtime.KeepAlive(start) runtime.KeepAlive(end) runtime.KeepAlive(step) } // ValueSetIntRange wraps gst_value_set_int_range // // The function takes the following parameters: // // - value *gobject.Value: a GValue initialized to GST_TYPE_INT_RANGE // - start int: the start of the range // - end int: the end of the range // // Sets @value to the range specified by @start and @end. func ValueSetIntRange(value *gobject.Value, start int, end int) { var carg1 *C.GValue // in, none, converted var carg2 C.gint // in, none, casted var carg3 C.gint // in, none, casted carg1 = (*C.GValue)(gobject.UnsafeValueToGlibUseAnyInstead(value)) carg2 = C.gint(start) carg3 = C.gint(end) C.gst_value_set_int_range(carg1, carg2, carg3) runtime.KeepAlive(value) runtime.KeepAlive(start) runtime.KeepAlive(end) } // ValueSetIntRangeStep wraps gst_value_set_int_range_step // // The function takes the following parameters: // // - value *gobject.Value: a GValue initialized to GST_TYPE_INT_RANGE // - start int: the start of the range // - end int: the end of the range // - step int: the step of the range // // Sets @value to the range specified by @start, @end and @step. func ValueSetIntRangeStep(value *gobject.Value, start int, end int, step int) { var carg1 *C.GValue // in, none, converted var carg2 C.gint // in, none, casted var carg3 C.gint // in, none, casted var carg4 C.gint // in, none, casted carg1 = (*C.GValue)(gobject.UnsafeValueToGlibUseAnyInstead(value)) carg2 = C.gint(start) carg3 = C.gint(end) carg4 = C.gint(step) C.gst_value_set_int_range_step(carg1, carg2, carg3, carg4) runtime.KeepAlive(value) runtime.KeepAlive(start) runtime.KeepAlive(end) runtime.KeepAlive(step) } // ValueSetStructure wraps gst_value_set_structure // // The function takes the following parameters: // // - value *gobject.Value: a GValue initialized to GST_TYPE_STRUCTURE // - structure *Structure: the structure to set the value to // // Sets the contents of @value to @structure. func ValueSetStructure(value *gobject.Value, structure *Structure) { var carg1 *C.GValue // in, none, converted var carg2 *C.GstStructure // in, none, converted carg1 = (*C.GValue)(gobject.UnsafeValueToGlibUseAnyInstead(value)) carg2 = (*C.GstStructure)(UnsafeStructureToGlibNone(structure)) C.gst_value_set_structure(carg1, carg2) runtime.KeepAlive(value) runtime.KeepAlive(structure) } // ValueSubtract wraps gst_value_subtract // // The function takes the following parameters: // // - minuend *gobject.Value: the value to subtract from // - subtrahend *gobject.Value: the value to subtract // // The function returns the following values: // // - dest gobject.Value: the destination value // for the result if the subtraction is not empty. May be %NULL, // in which case the resulting set will not be computed, which can // give a fair speedup. // - goret bool // // Subtracts @subtrahend from @minuend and stores the result in @dest. // Note that this means subtraction as in sets, not as in mathematics. func ValueSubtract(minuend *gobject.Value, subtrahend *gobject.Value) (gobject.Value, bool) { var carg2 *C.GValue // in, none, converted var carg3 *C.GValue // in, none, converted var carg1 C.GValue // out, transfer: none, C Pointers: 0, Name: Value, optional, caller-allocates var cret C.gboolean // return carg2 = (*C.GValue)(gobject.UnsafeValueToGlibUseAnyInstead(minuend)) carg3 = (*C.GValue)(gobject.UnsafeValueToGlibUseAnyInstead(subtrahend)) cret = C.gst_value_subtract(&carg1, carg2, carg3) runtime.KeepAlive(minuend) runtime.KeepAlive(subtrahend) var dest gobject.Value var goret bool _ = dest _ = carg1 panic("unimplemented conversion of gobject.Value (GValue)") if cret != 0 { goret = true } return dest, goret } // ValueUnion wraps gst_value_union // // The function takes the following parameters: // // - value1 *gobject.Value: a value to union // - value2 *gobject.Value: another value to union // // The function returns the following values: // // - dest gobject.Value: the destination value // - goret bool // // Creates a GValue corresponding to the union of @value1 and @value2. func ValueUnion(value1 *gobject.Value, value2 *gobject.Value) (gobject.Value, bool) { var carg2 *C.GValue // in, none, converted var carg3 *C.GValue // in, none, converted var carg1 C.GValue // out, transfer: none, C Pointers: 0, Name: Value, caller-allocates var cret C.gboolean // return carg2 = (*C.GValue)(gobject.UnsafeValueToGlibUseAnyInstead(value1)) carg3 = (*C.GValue)(gobject.UnsafeValueToGlibUseAnyInstead(value2)) cret = C.gst_value_union(&carg1, carg2, carg3) runtime.KeepAlive(value1) runtime.KeepAlive(value2) var dest gobject.Value var goret bool _ = dest _ = carg1 panic("unimplemented conversion of gobject.Value (GValue)") if cret != 0 { goret = true } return dest, goret } // Version wraps gst_version // // The function returns the following values: // // - major uint: pointer to a guint to store the major version number // - minor uint: pointer to a guint to store the minor version number // - micro uint: pointer to a guint to store the micro version number // - nano uint: pointer to a guint to store the nano version number // // Gets the version number of the GStreamer library. func Version() (uint, uint, uint, uint) { var carg1 C.guint // out, full, casted var carg2 C.guint // out, full, casted var carg3 C.guint // out, full, casted var carg4 C.guint // out, full, casted C.gst_version(&carg1, &carg2, &carg3, &carg4) var major uint var minor uint var micro uint var nano uint major = uint(carg1) minor = uint(carg2) micro = uint(carg3) nano = uint(carg4) return major, minor, micro, nano } // VersionString wraps gst_version_string // // The function returns the following values: // // - goret string // // This function returns a string that is useful for describing this version // of GStreamer to the outside world: user agent strings, logging, ... func VersionString() string { var cret *C.gchar // return, full, string cret = C.gst_version_string() var goret string goret = C.GoString((*C.char)(unsafe.Pointer(cret))) defer C.free(unsafe.Pointer(cret)) return goret } // ChildProxyInstance is the instance type used by all types implementing GstChildProxy. It is used internally by the bindings. Users should use the interface [ChildProxy] instead. type ChildProxyInstance struct { _ [0]func() // equal guard Instance gobject.ObjectInstance } var _ ChildProxy = (*ChildProxyInstance)(nil) // ChildProxy wraps GstChildProxy // // This interface abstracts handling of property sets for elements with // children. Imagine elements such as mixers or polyphonic generators. They all // have multiple #GstPad or some kind of voice objects. Another use case are // container elements like #GstBin. // The element implementing the interface acts as a parent for those child // objects. // // By implementing this interface the child properties can be accessed from the // parent element by using gst_child_proxy_get() and gst_child_proxy_set(). // // Property names are written as `child-name::property-name`. The whole naming // scheme is recursive. Thus `child1::child2::property` is valid too, if // `child1` and `child2` implement the #GstChildProxy interface. type ChildProxy interface { ChildProxyExtManual // handwritten functions upcastToGstChildProxy() *ChildProxyInstance // ChildAdded wraps gst_child_proxy_child_added // // The function takes the following parameters: // // - child gobject.Object: the newly added child // - name string: the name of the new child // // Emits the #GstChildProxy::child-added signal. ChildAdded(gobject.Object, string) // ChildRemoved wraps gst_child_proxy_child_removed // // The function takes the following parameters: // // - child gobject.Object: the removed child // - name string: the name of the old child // // Emits the #GstChildProxy::child-removed signal. ChildRemoved(gobject.Object, string) // GetChildByIndex wraps gst_child_proxy_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) // // Fetches a child by its number. GetChildByIndex(uint) gobject.Object // GetChildByName wraps gst_child_proxy_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) // // Looks up a child element by the given name. // // This virtual method has a default implementation that uses #GstObject // together with gst_object_get_name(). If the interface is to be used with // #GObjects, this methods needs to be overridden. GetChildByName(string) gobject.Object // GetChildByNameRecurse wraps gst_child_proxy_get_child_by_name_recurse // // The function takes the following parameters: // // - name string: the full-path child's name // // The function returns the following values: // // - goret gobject.Object (nullable) // // Looks up a child element by the given full-path name. // // Similar to gst_child_proxy_get_child_by_name(), this method // searches and returns a child given a name. The difference is that // this method allows a hierarchical path in the form of // child1::child2::child3. In the later example this method would // return a reference to child3, if found. The name should be made of // 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 // // Gets the number of child objects this parent contains. GetChildrenCount() uint // ConnectChildAdded connects the provided callback to the "child-added" signal // // Will be emitted after the @object was added to the @child_proxy. ConnectChildAdded(func(ChildProxy, gobject.Object, string)) gobject.SignalHandle // ConnectChildRemoved connects the provided callback to the "child-removed" signal // // Will be emitted after the @object was removed from the @child_proxy. ConnectChildRemoved(func(ChildProxy, gobject.Object, string)) gobject.SignalHandle } var _ ChildProxy = (*ChildProxyInstance)(nil) func unsafeWrapChildProxy(base *gobject.ObjectInstance) *ChildProxyInstance { return &ChildProxyInstance{ Instance: *base, } } func marshalChildProxyInstance(p unsafe.Pointer) (any, error) { return unsafeWrapChildProxy(gobject.ValueFromNative(p).Object()), nil } func (c *ChildProxyInstance) upcastToGstChildProxy() *ChildProxyInstance { return c } // UnsafeChildProxyFromGlibNone is used to convert raw GstChildProxy pointers to go while taking a reference and attaching a finalizer. This is used by the bindings internally. func UnsafeChildProxyFromGlibNone(c unsafe.Pointer) ChildProxy { return gobject.UnsafeObjectFromGlibNone(c).(ChildProxy) } // UnsafeChildProxyFromGlibFull is used to convert raw GstChildProxy pointers to go while attaching a finalizer. This is used by the bindings internally. func UnsafeChildProxyFromGlibFull(c unsafe.Pointer) ChildProxy { return gobject.UnsafeObjectFromGlibFull(c).(ChildProxy) } // UnsafeChildProxyToGlibNone is used to convert the instance to it's C value GstChildProxy. This is used by the bindings internally. func UnsafeChildProxyToGlibNone(c ChildProxy) unsafe.Pointer { i := c.upcastToGstChildProxy() return gobject.UnsafeObjectToGlibNone(&i.Instance) } // UnsafeChildProxyToGlibFull is used to convert the instance to it's C value GstChildProxy, while removeing the finalizer. This is used by the bindings internally. func UnsafeChildProxyToGlibFull(c ChildProxy) unsafe.Pointer { i := c.upcastToGstChildProxy() return gobject.UnsafeObjectToGlibFull(&i.Instance) } // ChildAdded wraps gst_child_proxy_child_added // // The function takes the following parameters: // // - child gobject.Object: the newly added child // - name string: the name of the new child // // Emits the #GstChildProxy::child-added signal. func (parent *ChildProxyInstance) ChildAdded(child gobject.Object, name string) { var carg0 *C.GstChildProxy // in, none, converted var carg1 *C.GObject // in, none, converted var carg2 *C.gchar // in, none, string carg0 = (*C.GstChildProxy)(UnsafeChildProxyToGlibNone(parent)) carg1 = (*C.GObject)(gobject.UnsafeObjectToGlibNone(child)) carg2 = (*C.gchar)(unsafe.Pointer(C.CString(name))) defer C.free(unsafe.Pointer(carg2)) C.gst_child_proxy_child_added(carg0, carg1, carg2) runtime.KeepAlive(parent) runtime.KeepAlive(child) runtime.KeepAlive(name) } // ChildRemoved wraps gst_child_proxy_child_removed // // The function takes the following parameters: // // - child gobject.Object: the removed child // - name string: the name of the old child // // Emits the #GstChildProxy::child-removed signal. func (parent *ChildProxyInstance) ChildRemoved(child gobject.Object, name string) { var carg0 *C.GstChildProxy // in, none, converted var carg1 *C.GObject // in, none, converted var carg2 *C.gchar // in, none, string carg0 = (*C.GstChildProxy)(UnsafeChildProxyToGlibNone(parent)) carg1 = (*C.GObject)(gobject.UnsafeObjectToGlibNone(child)) carg2 = (*C.gchar)(unsafe.Pointer(C.CString(name))) defer C.free(unsafe.Pointer(carg2)) C.gst_child_proxy_child_removed(carg0, carg1, carg2) runtime.KeepAlive(parent) runtime.KeepAlive(child) runtime.KeepAlive(name) } // GetChildByIndex wraps gst_child_proxy_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) // // Fetches a child by its number. func (parent *ChildProxyInstance) GetChildByIndex(index uint) gobject.Object { var carg0 *C.GstChildProxy // in, none, converted var carg1 C.guint // in, none, casted var cret *C.GObject // return, full, converted, nullable carg0 = (*C.GstChildProxy)(UnsafeChildProxyToGlibNone(parent)) carg1 = C.guint(index) cret = C.gst_child_proxy_get_child_by_index(carg0, carg1) runtime.KeepAlive(parent) runtime.KeepAlive(index) var goret gobject.Object if cret != nil { goret = gobject.UnsafeObjectFromGlibFull(unsafe.Pointer(cret)) } return goret } // GetChildByName wraps gst_child_proxy_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) // // Looks up a child element by the given name. // // This virtual method has a default implementation that uses #GstObject // together with gst_object_get_name(). If the interface is to be used with // #GObjects, this methods needs to be overridden. func (parent *ChildProxyInstance) GetChildByName(name string) gobject.Object { var carg0 *C.GstChildProxy // in, none, converted var carg1 *C.gchar // in, none, string var cret *C.GObject // return, full, converted, nullable carg0 = (*C.GstChildProxy)(UnsafeChildProxyToGlibNone(parent)) carg1 = (*C.gchar)(unsafe.Pointer(C.CString(name))) defer C.free(unsafe.Pointer(carg1)) cret = C.gst_child_proxy_get_child_by_name(carg0, carg1) runtime.KeepAlive(parent) runtime.KeepAlive(name) var goret gobject.Object if cret != nil { goret = gobject.UnsafeObjectFromGlibFull(unsafe.Pointer(cret)) } return goret } // GetChildByNameRecurse wraps gst_child_proxy_get_child_by_name_recurse // // The function takes the following parameters: // // - name string: the full-path child's name // // The function returns the following values: // // - goret gobject.Object (nullable) // // Looks up a child element by the given full-path name. // // Similar to gst_child_proxy_get_child_by_name(), this method // searches and returns a child given a name. The difference is that // this method allows a hierarchical path in the form of // child1::child2::child3. In the later example this method would // return a reference to child3, if found. The name should be made of // element names only and should not contain any property names. func (childProxy *ChildProxyInstance) GetChildByNameRecurse(name string) gobject.Object { var carg0 *C.GstChildProxy // in, none, converted var carg1 *C.gchar // in, none, string var cret *C.GObject // return, full, converted, nullable carg0 = (*C.GstChildProxy)(UnsafeChildProxyToGlibNone(childProxy)) carg1 = (*C.gchar)(unsafe.Pointer(C.CString(name))) defer C.free(unsafe.Pointer(carg1)) cret = C.gst_child_proxy_get_child_by_name_recurse(carg0, carg1) runtime.KeepAlive(childProxy) runtime.KeepAlive(name) var goret gobject.Object if cret != nil { goret = gobject.UnsafeObjectFromGlibFull(unsafe.Pointer(cret)) } return goret } // GetChildrenCount wraps gst_child_proxy_get_children_count // // The function returns the following values: // // - goret uint // // Gets the number of child objects this parent contains. func (parent *ChildProxyInstance) GetChildrenCount() uint { var carg0 *C.GstChildProxy // in, none, converted var cret C.guint // return, none, casted carg0 = (*C.GstChildProxy)(UnsafeChildProxyToGlibNone(parent)) cret = C.gst_child_proxy_get_children_count(carg0) runtime.KeepAlive(parent) var goret uint goret = uint(cret) return goret } // ConnectChildAdded connects the provided callback to the "child-added" signal // // Will be emitted after the @object was added to the @child_proxy. 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 Instance gobject.ObjectInstance } var _ Preset = (*PresetInstance)(nil) // Preset wraps GstPreset // // This interface offers methods to query and manipulate parameter preset sets. // A preset is a bunch of property settings, together with meta data and a name. // The name of a preset serves as key for subsequent method calls to manipulate // single presets. // All instances of one type will share the list of presets. The list is created // on demand, if presets are not used, the list is not created. // // The interface comes with a default implementation that serves most plugins. // Wrapper plugins will override most methods to implement support for the // native preset format of those wrapped plugins. // One method that is useful to be overridden is gst_preset_get_property_names(). // With that one can control which properties are saved and in which order. // When implementing support for read-only presets, one should set the vmethods // for gst_preset_save_preset() and gst_preset_delete_preset() to %NULL. // Applications can use gst_preset_is_editable() to check for that. // // The default implementation supports presets located in a system directory, // application specific directory and in the users home directory. When getting // a list of presets individual presets are read and overlaid in 1) system, // 2) application and 3) user order. Whenever an earlier entry is newer, the // later entries will be updated. Since 1.8 you can also provide extra paths // where to find presets through the GST_PRESET_PATH environment variable. // Presets found in those paths will be considered as "app presets". type Preset interface { upcastToGstPreset() *PresetInstance // DeletePreset wraps gst_preset_delete_preset // // The function takes the following parameters: // // - name string: preset name to remove // // The function returns the following values: // // - goret bool // // Delete the given preset. DeletePreset(string) bool // GetMeta wraps gst_preset_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 // // Gets the @value for an existing meta data @tag. Meta data @tag names can be // 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 // // 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 // // 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 // // Check if one can add new presets, change existing ones and remove presets. IsEditable() bool // LoadPreset wraps gst_preset_load_preset // // The function takes the following parameters: // // - name string: preset name to load // // The function returns the following values: // // - goret bool // // Load the given preset. LoadPreset(string) bool // RenamePreset wraps gst_preset_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 // // Renames a preset. If there is already a preset by the @new_name it will be // overwritten. RenamePreset(string, string) bool // SavePreset wraps gst_preset_save_preset // // The function takes the following parameters: // // - name string: preset name to save // // The function returns the following values: // // - goret bool // // Save the current object settings as a preset under the given name. If there // is already a preset by this @name it will be overwritten. SavePreset(string) bool // SetMeta wraps gst_preset_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 // // Sets a new @value for an existing meta data item or adds a new item. Meta // data @tag names can be something like e.g. "comment". Supplying %NULL for the // @value will unset an existing value. SetMeta(string, string, string) bool } var _ Preset = (*PresetInstance)(nil) func unsafeWrapPreset(base *gobject.ObjectInstance) *PresetInstance { return &PresetInstance{ Instance: *base, } } func marshalPresetInstance(p unsafe.Pointer) (any, error) { return unsafeWrapPreset(gobject.ValueFromNative(p).Object()), nil } func (p *PresetInstance) upcastToGstPreset() *PresetInstance { return p } // UnsafePresetFromGlibNone is used to convert raw GstPreset pointers to go while taking a reference and attaching a finalizer. This is used by the bindings internally. func UnsafePresetFromGlibNone(c unsafe.Pointer) Preset { return gobject.UnsafeObjectFromGlibNone(c).(Preset) } // UnsafePresetFromGlibFull is used to convert raw GstPreset pointers to go while attaching a finalizer. This is used by the bindings internally. func UnsafePresetFromGlibFull(c unsafe.Pointer) Preset { return gobject.UnsafeObjectFromGlibFull(c).(Preset) } // UnsafePresetToGlibNone is used to convert the instance to it's C value GstPreset. This is used by the bindings internally. func UnsafePresetToGlibNone(c Preset) unsafe.Pointer { i := c.upcastToGstPreset() return gobject.UnsafeObjectToGlibNone(&i.Instance) } // UnsafePresetToGlibFull is used to convert the instance to it's C value GstPreset, while removeing the finalizer. This is used by the bindings internally. func UnsafePresetToGlibFull(c Preset) unsafe.Pointer { i := c.upcastToGstPreset() return gobject.UnsafeObjectToGlibFull(&i.Instance) } // PresetGetAppDir wraps gst_preset_get_app_dir // // The function returns the following values: // // - goret string (nullable) // // Gets the directory for application specific presets if set by the // application. func PresetGetAppDir() string { var cret *C.gchar // return, none, string, nullable cret = C.gst_preset_get_app_dir() var goret string if cret != nil { goret = C.GoString((*C.char)(unsafe.Pointer(cret))) } return goret } // PresetSetAppDir wraps gst_preset_set_app_dir // // The function takes the following parameters: // // - appDir string: the application specific preset dir // // The function returns the following values: // // - goret bool // // Sets an extra directory as an absolute path that should be considered when // looking for presets. Any presets in the application dir will shadow the // system presets. func PresetSetAppDir(appDir string) bool { var carg1 *C.gchar // in, none, string var cret C.gboolean // return carg1 = (*C.gchar)(unsafe.Pointer(C.CString(appDir))) defer C.free(unsafe.Pointer(carg1)) cret = C.gst_preset_set_app_dir(carg1) runtime.KeepAlive(appDir) var goret bool if cret != 0 { goret = true } return goret } // DeletePreset wraps gst_preset_delete_preset // // The function takes the following parameters: // // - name string: preset name to remove // // The function returns the following values: // // - goret bool // // Delete the given preset. func (preset *PresetInstance) DeletePreset(name string) bool { var carg0 *C.GstPreset // in, none, converted var carg1 *C.gchar // in, none, string var cret C.gboolean // return carg0 = (*C.GstPreset)(UnsafePresetToGlibNone(preset)) carg1 = (*C.gchar)(unsafe.Pointer(C.CString(name))) defer C.free(unsafe.Pointer(carg1)) cret = C.gst_preset_delete_preset(carg0, carg1) runtime.KeepAlive(preset) runtime.KeepAlive(name) var goret bool if cret != 0 { goret = true } return goret } // GetMeta wraps gst_preset_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 // // Gets the @value for an existing meta data @tag. Meta data @tag names can be // something like e.g. "comment". Returned values need to be released when done. func (preset *PresetInstance) GetMeta(name string, tag string) (string, bool) { var carg0 *C.GstPreset // in, none, converted var carg1 *C.gchar // in, none, string var carg2 *C.gchar // in, none, string var carg3 *C.gchar // out, full, string var cret C.gboolean // return carg0 = (*C.GstPreset)(UnsafePresetToGlibNone(preset)) carg1 = (*C.gchar)(unsafe.Pointer(C.CString(name))) defer C.free(unsafe.Pointer(carg1)) carg2 = (*C.gchar)(unsafe.Pointer(C.CString(tag))) defer C.free(unsafe.Pointer(carg2)) cret = C.gst_preset_get_meta(carg0, carg1, carg2, &carg3) runtime.KeepAlive(preset) runtime.KeepAlive(name) runtime.KeepAlive(tag) var value string var goret bool value = C.GoString((*C.char)(unsafe.Pointer(carg3))) defer C.free(unsafe.Pointer(carg3)) if cret != 0 { goret = true } return value, goret } // GetPresetNames wraps gst_preset_get_preset_names // // The function returns the following values: // // - goret []string // // Get a copy of preset names as a %NULL terminated string array. func (preset *PresetInstance) GetPresetNames() []string { var carg0 *C.GstPreset // in, none, converted var cret **C.gchar // return, transfer: full, C Pointers: 2, Name: array[utf8], scope: , array (inner: *typesystem.StringPrimitive, zero-terminated) carg0 = (*C.GstPreset)(UnsafePresetToGlibNone(preset)) cret = C.gst_preset_get_preset_names(carg0) runtime.KeepAlive(preset) var goret []string _ = goret _ = cret panic("unimplemented conversion of []string (gchar**)") return goret } // GetPropertyNames wraps gst_preset_get_property_names // // The function returns the following values: // // - goret []string // // Get a the names of the GObject properties that can be used for presets. func (preset *PresetInstance) GetPropertyNames() []string { var carg0 *C.GstPreset // in, none, converted var cret **C.gchar // return, transfer: full, C Pointers: 2, Name: array[utf8], scope: , array (inner: *typesystem.StringPrimitive, zero-terminated) carg0 = (*C.GstPreset)(UnsafePresetToGlibNone(preset)) cret = C.gst_preset_get_property_names(carg0) runtime.KeepAlive(preset) var goret []string _ = goret _ = cret panic("unimplemented conversion of []string (gchar**)") return goret } // IsEditable wraps gst_preset_is_editable // // The function returns the following values: // // - goret bool // // Check if one can add new presets, change existing ones and remove presets. func (preset *PresetInstance) IsEditable() bool { var carg0 *C.GstPreset // in, none, converted var cret C.gboolean // return carg0 = (*C.GstPreset)(UnsafePresetToGlibNone(preset)) cret = C.gst_preset_is_editable(carg0) runtime.KeepAlive(preset) var goret bool if cret != 0 { goret = true } return goret } // LoadPreset wraps gst_preset_load_preset // // The function takes the following parameters: // // - name string: preset name to load // // The function returns the following values: // // - goret bool // // Load the given preset. func (preset *PresetInstance) LoadPreset(name string) bool { var carg0 *C.GstPreset // in, none, converted var carg1 *C.gchar // in, none, string var cret C.gboolean // return carg0 = (*C.GstPreset)(UnsafePresetToGlibNone(preset)) carg1 = (*C.gchar)(unsafe.Pointer(C.CString(name))) defer C.free(unsafe.Pointer(carg1)) cret = C.gst_preset_load_preset(carg0, carg1) runtime.KeepAlive(preset) runtime.KeepAlive(name) var goret bool if cret != 0 { goret = true } return goret } // RenamePreset wraps gst_preset_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 // // Renames a preset. If there is already a preset by the @new_name it will be // overwritten. func (preset *PresetInstance) RenamePreset(oldName string, newName string) bool { var carg0 *C.GstPreset // in, none, converted var carg1 *C.gchar // in, none, string var carg2 *C.gchar // in, none, string var cret C.gboolean // return carg0 = (*C.GstPreset)(UnsafePresetToGlibNone(preset)) carg1 = (*C.gchar)(unsafe.Pointer(C.CString(oldName))) defer C.free(unsafe.Pointer(carg1)) carg2 = (*C.gchar)(unsafe.Pointer(C.CString(newName))) defer C.free(unsafe.Pointer(carg2)) cret = C.gst_preset_rename_preset(carg0, carg1, carg2) runtime.KeepAlive(preset) runtime.KeepAlive(oldName) runtime.KeepAlive(newName) var goret bool if cret != 0 { goret = true } return goret } // SavePreset wraps gst_preset_save_preset // // The function takes the following parameters: // // - name string: preset name to save // // The function returns the following values: // // - goret bool // // Save the current object settings as a preset under the given name. If there // is already a preset by this @name it will be overwritten. func (preset *PresetInstance) SavePreset(name string) bool { var carg0 *C.GstPreset // in, none, converted var carg1 *C.gchar // in, none, string var cret C.gboolean // return carg0 = (*C.GstPreset)(UnsafePresetToGlibNone(preset)) carg1 = (*C.gchar)(unsafe.Pointer(C.CString(name))) defer C.free(unsafe.Pointer(carg1)) cret = C.gst_preset_save_preset(carg0, carg1) runtime.KeepAlive(preset) runtime.KeepAlive(name) var goret bool if cret != 0 { goret = true } return goret } // SetMeta wraps gst_preset_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 // // Sets a new @value for an existing meta data item or adds a new item. Meta // data @tag names can be something like e.g. "comment". Supplying %NULL for the // @value will unset an existing value. func (preset *PresetInstance) SetMeta(name string, tag string, value string) bool { var carg0 *C.GstPreset // in, none, converted var carg1 *C.gchar // in, none, string var carg2 *C.gchar // in, none, string var carg3 *C.gchar // in, none, string, nullable-string var cret C.gboolean // return carg0 = (*C.GstPreset)(UnsafePresetToGlibNone(preset)) carg1 = (*C.gchar)(unsafe.Pointer(C.CString(name))) defer C.free(unsafe.Pointer(carg1)) carg2 = (*C.gchar)(unsafe.Pointer(C.CString(tag))) defer C.free(unsafe.Pointer(carg2)) if value != "" { carg3 = (*C.gchar)(unsafe.Pointer(C.CString(value))) defer C.free(unsafe.Pointer(carg3)) } cret = C.gst_preset_set_meta(carg0, carg1, carg2, carg3) runtime.KeepAlive(preset) runtime.KeepAlive(name) runtime.KeepAlive(tag) runtime.KeepAlive(value) var goret bool if cret != 0 { goret = true } 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 Instance gobject.ObjectInstance } var _ URIHandler = (*URIHandlerInstance)(nil) // URIHandler wraps GstURIHandler // // The #GstURIHandler is an interface that is implemented by Source and Sink // #GstElement to unify handling of URI. // // An application can use the following functions to quickly get an element // that handles the given URI for reading or writing // (gst_element_make_from_uri()). // // Source and Sink plugins should implement this interface when possible. type URIHandler interface { upcastToGstURIHandler() *URIHandlerInstance // GetProtocols wraps gst_uri_handler_get_protocols // // The function returns the following values: // // - goret []string (nullable) // // Gets the list of protocols supported by @handler. This list may not be // modified. GetProtocols() []string // GetURI wraps gst_uri_handler_get_uri // // The function returns the following values: // // - goret string (nullable) // // Gets the currently handled URI. GetURI() string // GetURIType wraps gst_uri_handler_get_uri_type // // The function returns the following values: // // - goret URIType // // Gets the type of the given URI handler GetURIType() URIType // SetURI wraps gst_uri_handler_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 // // Tries to set the URI of the given handler. SetURI(string) (bool, error) } var _ URIHandler = (*URIHandlerInstance)(nil) func unsafeWrapURIHandler(base *gobject.ObjectInstance) *URIHandlerInstance { return &URIHandlerInstance{ Instance: *base, } } func marshalURIHandlerInstance(p unsafe.Pointer) (any, error) { return unsafeWrapURIHandler(gobject.ValueFromNative(p).Object()), nil } func (u *URIHandlerInstance) upcastToGstURIHandler() *URIHandlerInstance { return u } // UnsafeURIHandlerFromGlibNone is used to convert raw GstURIHandler pointers to go while taking a reference and attaching a finalizer. This is used by the bindings internally. func UnsafeURIHandlerFromGlibNone(c unsafe.Pointer) URIHandler { return gobject.UnsafeObjectFromGlibNone(c).(URIHandler) } // UnsafeURIHandlerFromGlibFull is used to convert raw GstURIHandler pointers to go while attaching a finalizer. This is used by the bindings internally. func UnsafeURIHandlerFromGlibFull(c unsafe.Pointer) URIHandler { return gobject.UnsafeObjectFromGlibFull(c).(URIHandler) } // UnsafeURIHandlerToGlibNone is used to convert the instance to it's C value GstURIHandler. This is used by the bindings internally. func UnsafeURIHandlerToGlibNone(c URIHandler) unsafe.Pointer { i := c.upcastToGstURIHandler() return gobject.UnsafeObjectToGlibNone(&i.Instance) } // UnsafeURIHandlerToGlibFull is used to convert the instance to it's C value GstURIHandler, while removeing the finalizer. This is used by the bindings internally. func UnsafeURIHandlerToGlibFull(c URIHandler) unsafe.Pointer { i := c.upcastToGstURIHandler() return gobject.UnsafeObjectToGlibFull(&i.Instance) } // GetProtocols wraps gst_uri_handler_get_protocols // // The function returns the following values: // // - goret []string (nullable) // // Gets the list of protocols supported by @handler. This list may not be // modified. func (handler *URIHandlerInstance) GetProtocols() []string { var carg0 *C.GstURIHandler // in, none, converted var cret **C.gchar // return, transfer: none, C Pointers: 2, Name: array[utf8], scope: , nullable, array (inner: *typesystem.StringPrimitive, zero-terminated) carg0 = (*C.GstURIHandler)(UnsafeURIHandlerToGlibNone(handler)) cret = C.gst_uri_handler_get_protocols(carg0) runtime.KeepAlive(handler) var goret []string _ = goret _ = cret panic("unimplemented conversion of []string (const gchar* const*)") return goret } // GetURI wraps gst_uri_handler_get_uri // // The function returns the following values: // // - goret string (nullable) // // Gets the currently handled URI. func (handler *URIHandlerInstance) GetURI() string { var carg0 *C.GstURIHandler // in, none, converted var cret *C.gchar // return, full, string, nullable-string carg0 = (*C.GstURIHandler)(UnsafeURIHandlerToGlibNone(handler)) cret = C.gst_uri_handler_get_uri(carg0) runtime.KeepAlive(handler) var goret string if cret != nil { goret = C.GoString((*C.char)(unsafe.Pointer(cret))) defer C.free(unsafe.Pointer(cret)) } return goret } // GetURIType wraps gst_uri_handler_get_uri_type // // The function returns the following values: // // - goret URIType // // Gets the type of the given URI handler func (handler *URIHandlerInstance) GetURIType() URIType { var carg0 *C.GstURIHandler // in, none, converted var cret C.GstURIType // return, none, casted carg0 = (*C.GstURIHandler)(UnsafeURIHandlerToGlibNone(handler)) cret = C.gst_uri_handler_get_uri_type(carg0) runtime.KeepAlive(handler) var goret URIType goret = URIType(cret) return goret } // SetURI wraps gst_uri_handler_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 // // Tries to set the URI of the given handler. func (handler *URIHandlerInstance) SetURI(uri string) (bool, error) { var carg0 *C.GstURIHandler // in, none, converted var carg1 *C.gchar // in, none, string var cret C.gboolean // return var _cerr *C.GError // out, full, converted, nullable carg0 = (*C.GstURIHandler)(UnsafeURIHandlerToGlibNone(handler)) carg1 = (*C.gchar)(unsafe.Pointer(C.CString(uri))) defer C.free(unsafe.Pointer(carg1)) cret = C.gst_uri_handler_set_uri(carg0, carg1, &_cerr) runtime.KeepAlive(handler) runtime.KeepAlive(uri) var goret bool var _goerr error if cret != 0 { goret = true } if _cerr != nil { _goerr = glib.UnsafeErrorFromGlibFull(unsafe.Pointer(_cerr)) } 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 Instance gobject.ObjectInstance } var _ TagSetter = (*TagSetterInstance)(nil) // TagSetter wraps GstTagSetter // // Element interface that allows setting of media metadata. // // Elements that support changing a stream's metadata will implement this // interface. Examples of such elements are 'vorbisenc', 'theoraenc' and // 'id3v2mux'. // // If you just want to retrieve metadata in your application then all you // need to do is watch for tag messages on your pipeline's bus. This // interface is only for setting metadata, not for extracting it. To set tags // from the application, find tagsetter elements and set tags using e.g. // gst_tag_setter_merge_tags() or gst_tag_setter_add_tags(). Also consider // setting the #GstTagMergeMode that is used for tag events that arrive at the // tagsetter element (default mode is to keep existing tags). // The application should do that before the element goes to %GST_STATE_PAUSED. // // Elements implementing the #GstTagSetter interface often have to merge // any tags received from upstream and the tags set by the application via // the interface. This can be done like this: // // |[<!-- language="C" --> // GstTagMergeMode merge_mode; // const GstTagList *application_tags; // const GstTagList *event_tags; // GstTagSetter *tagsetter; // GstTagList *result; // // tagsetter = GST_TAG_SETTER (element); // // merge_mode = gst_tag_setter_get_tag_merge_mode (tagsetter); // application_tags = gst_tag_setter_get_tag_list (tagsetter); // event_tags = (const GstTagList *) element->event_tags; // // GST_LOG_OBJECT (tagsetter, "merging tags, merge mode = %d", merge_mode); // GST_LOG_OBJECT (tagsetter, "event tags: %" GST_PTR_FORMAT, event_tags); // GST_LOG_OBJECT (tagsetter, "set tags: %" GST_PTR_FORMAT, application_tags); // // result = gst_tag_list_merge (application_tags, event_tags, merge_mode); // // GST_LOG_OBJECT (tagsetter, "final tags: %" GST_PTR_FORMAT, result); // ]| type TagSetter interface { TagSetterExtManual // handwritten functions upcastToGstTagSetter() *TagSetterInstance // GetTagList wraps gst_tag_setter_get_tag_list // // The function returns the following values: // // - goret *TagList (nullable) // // Returns the current list of tags the setter uses. The list should not be // modified or freed. // // 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 // // Queries the mode by which tags inside the setter are overwritten by tags // from events GetTagMergeMode() TagMergeMode // MergeTags wraps gst_tag_setter_merge_tags // // The function takes the following parameters: // // - list *TagList: a tag list to merge from // - mode TagMergeMode: the mode to merge with // // Merges the given list into the setter's list using the given mode. MergeTags(*TagList, TagMergeMode) // ResetTags wraps gst_tag_setter_reset_tags // // Reset the internal taglist. Elements should call this from within the // state-change handler. ResetTags() // SetTagMergeMode wraps gst_tag_setter_set_tag_merge_mode // // The function takes the following parameters: // // - mode TagMergeMode: The mode with which tags are added // // Sets the given merge mode that is used for adding tags from events to tags // specified by this interface. The default is #GST_TAG_MERGE_KEEP, which keeps // the tags set with this interface and discards tags from events. SetTagMergeMode(TagMergeMode) } var _ TagSetter = (*TagSetterInstance)(nil) func unsafeWrapTagSetter(base *gobject.ObjectInstance) *TagSetterInstance { return &TagSetterInstance{ Instance: *base, } } func marshalTagSetterInstance(p unsafe.Pointer) (any, error) { return unsafeWrapTagSetter(gobject.ValueFromNative(p).Object()), nil } func (t *TagSetterInstance) upcastToGstTagSetter() *TagSetterInstance { return t } // UnsafeTagSetterFromGlibNone is used to convert raw GstTagSetter pointers to go while taking a reference and attaching a finalizer. This is used by the bindings internally. func UnsafeTagSetterFromGlibNone(c unsafe.Pointer) TagSetter { return gobject.UnsafeObjectFromGlibNone(c).(TagSetter) } // UnsafeTagSetterFromGlibFull is used to convert raw GstTagSetter pointers to go while attaching a finalizer. This is used by the bindings internally. func UnsafeTagSetterFromGlibFull(c unsafe.Pointer) TagSetter { return gobject.UnsafeObjectFromGlibFull(c).(TagSetter) } // UnsafeTagSetterToGlibNone is used to convert the instance to it's C value GstTagSetter. This is used by the bindings internally. func UnsafeTagSetterToGlibNone(c TagSetter) unsafe.Pointer { i := c.upcastToGstTagSetter() return gobject.UnsafeObjectToGlibNone(&i.Instance) } // UnsafeTagSetterToGlibFull is used to convert the instance to it's C value GstTagSetter, while removeing the finalizer. This is used by the bindings internally. func UnsafeTagSetterToGlibFull(c TagSetter) unsafe.Pointer { i := c.upcastToGstTagSetter() return gobject.UnsafeObjectToGlibFull(&i.Instance) } // GetTagList wraps gst_tag_setter_get_tag_list // // The function returns the following values: // // - goret *TagList (nullable) // // Returns the current list of tags the setter uses. The list should not be // modified or freed. // // This function is not thread-safe. func (setter *TagSetterInstance) GetTagList() *TagList { var carg0 *C.GstTagSetter // in, none, converted var cret *C.GstTagList // return, none, converted, nullable carg0 = (*C.GstTagSetter)(UnsafeTagSetterToGlibNone(setter)) cret = C.gst_tag_setter_get_tag_list(carg0) runtime.KeepAlive(setter) var goret *TagList if cret != nil { goret = UnsafeTagListFromGlibNone(unsafe.Pointer(cret)) } return goret } // GetTagMergeMode wraps gst_tag_setter_get_tag_merge_mode // // The function returns the following values: // // - goret TagMergeMode // // Queries the mode by which tags inside the setter are overwritten by tags // from events func (setter *TagSetterInstance) GetTagMergeMode() TagMergeMode { var carg0 *C.GstTagSetter // in, none, converted var cret C.GstTagMergeMode // return, none, casted carg0 = (*C.GstTagSetter)(UnsafeTagSetterToGlibNone(setter)) cret = C.gst_tag_setter_get_tag_merge_mode(carg0) runtime.KeepAlive(setter) var goret TagMergeMode goret = TagMergeMode(cret) return goret } // MergeTags wraps gst_tag_setter_merge_tags // // The function takes the following parameters: // // - list *TagList: a tag list to merge from // - mode TagMergeMode: the mode to merge with // // Merges the given list into the setter's list using the given mode. func (setter *TagSetterInstance) MergeTags(list *TagList, mode TagMergeMode) { var carg0 *C.GstTagSetter // in, none, converted var carg1 *C.GstTagList // in, none, converted var carg2 C.GstTagMergeMode // in, none, casted carg0 = (*C.GstTagSetter)(UnsafeTagSetterToGlibNone(setter)) carg1 = (*C.GstTagList)(UnsafeTagListToGlibNone(list)) carg2 = C.GstTagMergeMode(mode) C.gst_tag_setter_merge_tags(carg0, carg1, carg2) runtime.KeepAlive(setter) runtime.KeepAlive(list) runtime.KeepAlive(mode) } // ResetTags wraps gst_tag_setter_reset_tags // // Reset the internal taglist. Elements should call this from within the // state-change handler. func (setter *TagSetterInstance) ResetTags() { var carg0 *C.GstTagSetter // in, none, converted carg0 = (*C.GstTagSetter)(UnsafeTagSetterToGlibNone(setter)) C.gst_tag_setter_reset_tags(carg0) runtime.KeepAlive(setter) } // SetTagMergeMode wraps gst_tag_setter_set_tag_merge_mode // // The function takes the following parameters: // // - mode TagMergeMode: The mode with which tags are added // // Sets the given merge mode that is used for adding tags from events to tags // specified by this interface. The default is #GST_TAG_MERGE_KEEP, which keeps // the tags set with this interface and discards tags from events. func (setter *TagSetterInstance) SetTagMergeMode(mode TagMergeMode) { var carg0 *C.GstTagSetter // in, none, converted var carg1 C.GstTagMergeMode // in, none, casted carg0 = (*C.GstTagSetter)(UnsafeTagSetterToGlibNone(setter)) carg1 = C.GstTagMergeMode(mode) C.gst_tag_setter_set_tag_merge_mode(carg0, carg1) runtime.KeepAlive(setter) 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 Instance gobject.ObjectInstance } var _ TocSetter = (*TocSetterInstance)(nil) // TocSetter wraps GstTocSetter // // Element interface that allows setting of the TOC. // // Elements that support some kind of chapters or editions (or tracks like in // the FLAC cue sheet) will implement this interface. // // If you just want to retrieve the TOC in your application then all you // need to do is watch for TOC messages on your pipeline's bus (or you can // perform TOC query). This interface is only for setting TOC data, not for // extracting it. To set TOC from the application, find proper tocsetter element // and set TOC using gst_toc_setter_set_toc(). // // Elements implementing the #GstTocSetter interface can extend existing TOC // by getting extend UID for that (you can use gst_toc_find_entry() to retrieve it) // with any TOC entries received from downstream. type TocSetter interface { upcastToGstTocSetter() *TocSetterInstance // GetToc wraps gst_toc_setter_get_toc // // The function returns the following values: // // - goret *Toc (nullable) // // Return current TOC the setter uses. The TOC should not be // modified without making it writable first. GetToc() *Toc // Reset wraps gst_toc_setter_reset // // Reset the internal TOC. Elements should call this from within the // state-change handler. Reset() // SetToc wraps gst_toc_setter_set_toc // // The function takes the following parameters: // // - toc *Toc (nullable): a #GstToc to set. // // Set the given TOC on the setter. Previously set TOC will be // unreffed before setting a new one. SetToc(*Toc) } var _ TocSetter = (*TocSetterInstance)(nil) func unsafeWrapTocSetter(base *gobject.ObjectInstance) *TocSetterInstance { return &TocSetterInstance{ Instance: *base, } } func marshalTocSetterInstance(p unsafe.Pointer) (any, error) { return unsafeWrapTocSetter(gobject.ValueFromNative(p).Object()), nil } func (t *TocSetterInstance) upcastToGstTocSetter() *TocSetterInstance { return t } // UnsafeTocSetterFromGlibNone is used to convert raw GstTocSetter pointers to go while taking a reference and attaching a finalizer. This is used by the bindings internally. func UnsafeTocSetterFromGlibNone(c unsafe.Pointer) TocSetter { return gobject.UnsafeObjectFromGlibNone(c).(TocSetter) } // UnsafeTocSetterFromGlibFull is used to convert raw GstTocSetter pointers to go while attaching a finalizer. This is used by the bindings internally. func UnsafeTocSetterFromGlibFull(c unsafe.Pointer) TocSetter { return gobject.UnsafeObjectFromGlibFull(c).(TocSetter) } // UnsafeTocSetterToGlibNone is used to convert the instance to it's C value GstTocSetter. This is used by the bindings internally. func UnsafeTocSetterToGlibNone(c TocSetter) unsafe.Pointer { i := c.upcastToGstTocSetter() return gobject.UnsafeObjectToGlibNone(&i.Instance) } // UnsafeTocSetterToGlibFull is used to convert the instance to it's C value GstTocSetter, while removeing the finalizer. This is used by the bindings internally. func UnsafeTocSetterToGlibFull(c TocSetter) unsafe.Pointer { i := c.upcastToGstTocSetter() return gobject.UnsafeObjectToGlibFull(&i.Instance) } // GetToc wraps gst_toc_setter_get_toc // // The function returns the following values: // // - goret *Toc (nullable) // // Return current TOC the setter uses. The TOC should not be // modified without making it writable first. func (setter *TocSetterInstance) GetToc() *Toc { var carg0 *C.GstTocSetter // in, none, converted var cret *C.GstToc // return, full, converted, nullable carg0 = (*C.GstTocSetter)(UnsafeTocSetterToGlibNone(setter)) cret = C.gst_toc_setter_get_toc(carg0) runtime.KeepAlive(setter) var goret *Toc if cret != nil { goret = UnsafeTocFromGlibFull(unsafe.Pointer(cret)) } return goret } // Reset wraps gst_toc_setter_reset // // Reset the internal TOC. Elements should call this from within the // state-change handler. func (setter *TocSetterInstance) Reset() { var carg0 *C.GstTocSetter // in, none, converted carg0 = (*C.GstTocSetter)(UnsafeTocSetterToGlibNone(setter)) C.gst_toc_setter_reset(carg0) runtime.KeepAlive(setter) } // SetToc wraps gst_toc_setter_set_toc // // The function takes the following parameters: // // - toc *Toc (nullable): a #GstToc to set. // // Set the given TOC on the setter. Previously set TOC will be // unreffed before setting a new one. func (setter *TocSetterInstance) SetToc(toc *Toc) { var carg0 *C.GstTocSetter // in, none, converted var carg1 *C.GstToc // in, none, converted, nullable carg0 = (*C.GstTocSetter)(UnsafeTocSetterToGlibNone(setter)) if toc != nil { carg1 = (*C.GstToc)(UnsafeTocToGlibNone(toc)) } C.gst_toc_setter_set_toc(carg0, carg1) runtime.KeepAlive(setter) 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 gobject.InitiallyUnownedInstance } var _ Object = (*ObjectInstance)(nil) // Object wraps GstObject // // #GstObject provides a root for the object hierarchy tree filed in by the // GStreamer library. It is currently a thin wrapper on top of // #GInitiallyUnowned. It is an abstract class that is not very usable on its own. // // #GstObject gives us basic refcounting, parenting functionality and locking. // Most of the functions are just extended for special GStreamer needs and can be // found under the same name in the base class of #GstObject which is #GObject // (e.g. g_object_ref() becomes gst_object_ref()). // // Since #GstObject derives from #GInitiallyUnowned, it also inherits the // floating reference. Be aware that functions such as gst_bin_add() and // gst_element_add_pad() take ownership of the floating reference. // // In contrast to #GObject instances, #GstObject adds a name property. The functions // gst_object_set_name() and gst_object_get_name() are used to set/get the name // of the object. // // ## controlled properties // // Controlled properties offers a lightweight way to adjust gobject properties // over stream-time. It works by using time-stamped value pairs that are queued // for element-properties. At run-time the elements continuously pull value // changes for the current stream-time. // // What needs to be changed in a #GstElement? // Very little - it is just two steps to make a plugin controllable! // // * mark gobject-properties paramspecs that make sense to be controlled, // by GST_PARAM_CONTROLLABLE. // // * when processing data (get, chain, loop function) at the beginning call // gst_object_sync_values(element,timestamp). // This will make the controller update all GObject properties that are // under its control with the current values based on the timestamp. // // What needs to be done in applications? Again it's not a lot to change. // // * create a #GstControlSource. // csource = gst_interpolation_control_source_new (); // g_object_set (csource, "mode", GST_INTERPOLATION_MODE_LINEAR, NULL); // // * Attach the #GstControlSource on the controller to a property. // gst_object_add_control_binding (object, gst_direct_control_binding_new (object, "prop1", csource)); // // * Set the control values // gst_timed_value_control_source_set ((GstTimedValueControlSource *)csource,0 * GST_SECOND, value1); // gst_timed_value_control_source_set ((GstTimedValueControlSource *)csource,1 * GST_SECOND, value2); // // * start your pipeline type Object interface { ObjectExtManual // handwritten functions gobject.InitiallyUnowned upcastToGstObject() *ObjectInstance // AddControlBinding wraps gst_object_add_control_binding // // The function takes the following parameters: // // - binding ControlBinding: the #GstControlBinding that should be used // // The function returns the following values: // // - goret bool // // Attach the #GstControlBinding to the object. If there already was a // #GstControlBinding for this property it will be replaced. // // The object's reference count will be incremented, and any floating // reference will be removed (see gst_object_ref_sink()) AddControlBinding(ControlBinding) bool // DefaultError wraps gst_object_default_error // // The function takes the following parameters: // // - debug string (nullable): an additional debug information string, or %NULL // - err error: the GError. // // A default error function that uses g_printerr() to display the error message // and the optional debug string.. // // The default handler will simply print the error string using g_print. DefaultError(string, error) // CurrentControlBinding wraps gst_object_get_control_binding // // The function takes the following parameters: // // - propertyName string: name of the property // // The function returns the following values: // // - goret ControlBinding (nullable) // // Gets the corresponding #GstControlBinding for the property. This should be // unreferenced again after use. CurrentControlBinding(string) ControlBinding // GetControlRate wraps gst_object_get_control_rate // // The function returns the following values: // // - goret ClockTime // // Obtain the control-rate for this @object. Audio processing #GstElement // objects will use this rate to sub-divide their processing loop and call // gst_object_sync_values() in between. The length of the processing segment // should be up to @control-rate nanoseconds. // // If the @object is not under property control, this will return // %GST_CLOCK_TIME_NONE. This allows the element to avoid the sub-dividing. // // The control-rate is not expected to change if the element is in // %GST_STATE_PAUSED or %GST_STATE_PLAYING. GetControlRate() ClockTime // GetName wraps gst_object_get_name // // The function returns the following values: // // - goret string (nullable) // // Returns a copy of the name of @object. // Caller should g_free() the return value after usage. // For a nameless object, this returns %NULL, which you can safely g_free() // as well. // // Free-function: g_free GetName() string // GetParent wraps gst_object_get_parent // // The function returns the following values: // // - goret Object (nullable) // // Returns the parent of @object. This function increases the refcount // 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 // // Generates a string describing the path of @object in // the object hierarchy. Only useful (or used) for debugging. // // Free-function: g_free GetPathString() string // HasActiveControlBindings wraps gst_object_has_active_control_bindings // // The function returns the following values: // // - goret bool // // Check if the @object has active controlled properties. HasActiveControlBindings() bool // HasAncestor wraps gst_object_has_ancestor // // The function takes the following parameters: // // - ancestor Object: a #GstObject to check as ancestor // // The function returns the following values: // // - goret bool // // Check if @object has an ancestor @ancestor somewhere up in // the hierarchy. One can e.g. check if a #GstElement is inside a #GstPipeline. // // Deprecated: Use gst_object_has_as_ancestor() instead. // // MT safe. Grabs and releases @object's locks. HasAncestor(Object) bool // HasAsAncestor wraps gst_object_has_as_ancestor // // The function takes the following parameters: // // - ancestor Object: a #GstObject to check as ancestor // // The function returns the following values: // // - goret bool // // Check if @object has an ancestor @ancestor somewhere up in // the hierarchy. One can e.g. check if a #GstElement is inside a #GstPipeline. HasAsAncestor(Object) bool // HasAsParent wraps gst_object_has_as_parent // // The function takes the following parameters: // // - parent Object: a #GstObject to check as parent // // The function returns the following values: // // - goret bool // // Check if @parent is the parent of @object. // E.g. a #GstElement can check if it owns a given #GstPad. HasAsParent(Object) bool // RemoveControlBinding wraps gst_object_remove_control_binding // // The function takes the following parameters: // // - binding ControlBinding: the binding // // The function returns the following values: // // - goret bool // // Removes the corresponding #GstControlBinding. If it was the // last ref of the binding, it will be disposed. RemoveControlBinding(ControlBinding) bool // SetControlBindingDisabled wraps gst_object_set_control_binding_disabled // // The function takes the following parameters: // // - propertyName string: property to disable // - disabled bool: boolean that specifies whether to disable the controller // or not. // // This function is used to disable the control bindings on a property for // some time, i.e. gst_object_sync_values() will do nothing for the // property. SetControlBindingDisabled(string, bool) // SetControlBindingsDisabled wraps gst_object_set_control_bindings_disabled // // The function takes the following parameters: // // - disabled bool: boolean that specifies whether to disable the controller // or not. // // This function is used to disable all controlled properties of the @object for // some time, i.e. gst_object_sync_values() will do nothing. SetControlBindingsDisabled(bool) // SetControlRate wraps gst_object_set_control_rate // // The function takes the following parameters: // // - controlRate ClockTime: the new control-rate in nanoseconds. // // Change the control-rate for this @object. Audio processing #GstElement // objects will use this rate to sub-divide their processing loop and call // gst_object_sync_values() in between. The length of the processing segment // should be up to @control-rate nanoseconds. // // The control-rate should not change if the element is in %GST_STATE_PAUSED or // %GST_STATE_PLAYING. SetControlRate(ClockTime) // SetName wraps gst_object_set_name // // The function takes the following parameters: // // - name string (nullable): new name of object // // The function returns the following values: // // - goret bool // // Sets the name of @object, or gives @object a guaranteed unique // name (if @name is %NULL). // This function makes a copy of the provided name, so the caller // retains ownership of the name it sent. SetName(string) bool // SetParent wraps gst_object_set_parent // // The function takes the following parameters: // // - parent Object: new parent of object // // The function returns the following values: // // - goret bool // // Sets the parent of @object to @parent. The object's reference count will // 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 // // Returns a suggestion for timestamps where buffers should be split // to get best controller results. SuggestNextSync() ClockTime // SyncValues wraps gst_object_sync_values // // The function takes the following parameters: // // - timestamp ClockTime: the time that should be processed // // The function returns the following values: // // - goret bool // // Sets the properties of the object, according to the #GstControlSources that // (maybe) handle them and for the given timestamp. // // If this function fails, it is most likely the application developers fault. // Most probably the control sources are not setup correctly. SyncValues(ClockTime) bool // Unparent wraps gst_object_unparent // // Clear the parent of @object, removing the associated reference. // This function decreases the refcount of @object. // // MT safe. Grabs and releases @object's lock. Unparent() } func unsafeWrapObject(base *gobject.ObjectInstance) *ObjectInstance { return &ObjectInstance{ InitiallyUnownedInstance: gobject.InitiallyUnownedInstance{ ObjectInstance: *base, }, } } func marshalObjectInstance(p unsafe.Pointer) (any, error) { return unsafeWrapObject(gobject.ValueFromNative(p).Object()), nil } // UnsafeObjectFromGlibNone is used to convert raw GstObject pointers to go while taking a reference and attaching a finalizer. This is used by the bindings internally. func UnsafeObjectFromGlibNone(c unsafe.Pointer) Object { return gobject.UnsafeObjectFromGlibNone(c).(Object) } // UnsafeObjectFromGlibFull is used to convert raw GstObject pointers to go while attaching a finalizer. This is used by the bindings internally. func UnsafeObjectFromGlibFull(c unsafe.Pointer) Object { return gobject.UnsafeObjectFromGlibFull(c).(Object) } func (o *ObjectInstance) upcastToGstObject() *ObjectInstance { return o } // UnsafeObjectToGlibNone is used to convert the instance to it's C value GstObject. This is used by the bindings internally. func UnsafeObjectToGlibNone(c Object) unsafe.Pointer { return gobject.UnsafeObjectToGlibNone(c) } // UnsafeObjectToGlibFull is used to convert the instance to it's C value GstObject, while removeing the finalizer. This is used by the bindings internally. func UnsafeObjectToGlibFull(c Object) unsafe.Pointer { return gobject.UnsafeObjectToGlibFull(c) } // AddControlBinding wraps gst_object_add_control_binding // // The function takes the following parameters: // // - binding ControlBinding: the #GstControlBinding that should be used // // The function returns the following values: // // - goret bool // // Attach the #GstControlBinding to the object. If there already was a // #GstControlBinding for this property it will be replaced. // // The object's reference count will be incremented, and any floating // reference will be removed (see gst_object_ref_sink()) func (object *ObjectInstance) AddControlBinding(binding ControlBinding) bool { var carg0 *C.GstObject // in, none, converted var carg1 *C.GstControlBinding // in, none, converted var cret C.gboolean // return carg0 = (*C.GstObject)(UnsafeObjectToGlibNone(object)) carg1 = (*C.GstControlBinding)(UnsafeControlBindingToGlibNone(binding)) cret = C.gst_object_add_control_binding(carg0, carg1) runtime.KeepAlive(object) runtime.KeepAlive(binding) var goret bool if cret != 0 { goret = true } return goret } // DefaultError wraps gst_object_default_error // // The function takes the following parameters: // // - debug string (nullable): an additional debug information string, or %NULL // - err error: the GError. // // A default error function that uses g_printerr() to display the error message // and the optional debug string.. // // The default handler will simply print the error string using g_print. func (source *ObjectInstance) DefaultError(debug string, err error) { var carg0 *C.GstObject // in, none, converted var carg2 *C.gchar // in, none, string, nullable-string var carg1 *C.GError // in, none, converted carg0 = (*C.GstObject)(UnsafeObjectToGlibNone(source)) if debug != "" { carg2 = (*C.gchar)(unsafe.Pointer(C.CString(debug))) defer C.free(unsafe.Pointer(carg2)) } carg1 = (*C.GError)(glib.UnsafeErrorToGlibNone(err)) C.gst_object_default_error(carg0, carg1, carg2) runtime.KeepAlive(source) runtime.KeepAlive(debug) runtime.KeepAlive(err) } // CurrentControlBinding wraps gst_object_get_control_binding // // The function takes the following parameters: // // - propertyName string: name of the property // // The function returns the following values: // // - goret ControlBinding (nullable) // // Gets the corresponding #GstControlBinding for the property. This should be // unreferenced again after use. func (object *ObjectInstance) CurrentControlBinding(propertyName string) ControlBinding { var carg0 *C.GstObject // in, none, converted var carg1 *C.gchar // in, none, string var cret *C.GstControlBinding // return, full, converted, nullable carg0 = (*C.GstObject)(UnsafeObjectToGlibNone(object)) carg1 = (*C.gchar)(unsafe.Pointer(C.CString(propertyName))) defer C.free(unsafe.Pointer(carg1)) cret = C.gst_object_get_control_binding(carg0, carg1) runtime.KeepAlive(object) runtime.KeepAlive(propertyName) var goret ControlBinding if cret != nil { goret = UnsafeControlBindingFromGlibFull(unsafe.Pointer(cret)) } return goret } // GetControlRate wraps gst_object_get_control_rate // // The function returns the following values: // // - goret ClockTime // // Obtain the control-rate for this @object. Audio processing #GstElement // objects will use this rate to sub-divide their processing loop and call // gst_object_sync_values() in between. The length of the processing segment // should be up to @control-rate nanoseconds. // // If the @object is not under property control, this will return // %GST_CLOCK_TIME_NONE. This allows the element to avoid the sub-dividing. // // The control-rate is not expected to change if the element is in // %GST_STATE_PAUSED or %GST_STATE_PLAYING. func (object *ObjectInstance) GetControlRate() ClockTime { var carg0 *C.GstObject // in, none, converted var cret C.GstClockTime // return, none, casted, alias carg0 = (*C.GstObject)(UnsafeObjectToGlibNone(object)) cret = C.gst_object_get_control_rate(carg0) runtime.KeepAlive(object) var goret ClockTime goret = ClockTime(cret) return goret } // GetName wraps gst_object_get_name // // The function returns the following values: // // - goret string (nullable) // // Returns a copy of the name of @object. // Caller should g_free() the return value after usage. // For a nameless object, this returns %NULL, which you can safely g_free() // as well. // // Free-function: g_free func (object *ObjectInstance) GetName() string { var carg0 *C.GstObject // in, none, converted var cret *C.gchar // return, full, string, nullable-string carg0 = (*C.GstObject)(UnsafeObjectToGlibNone(object)) cret = C.gst_object_get_name(carg0) runtime.KeepAlive(object) var goret string if cret != nil { goret = C.GoString((*C.char)(unsafe.Pointer(cret))) defer C.free(unsafe.Pointer(cret)) } return goret } // GetParent wraps gst_object_get_parent // // The function returns the following values: // // - goret Object (nullable) // // Returns the parent of @object. This function increases the refcount // of the parent object so you should gst_object_unref() it after usage. func (object *ObjectInstance) GetParent() Object { var carg0 *C.GstObject // in, none, converted var cret *C.GstObject // return, full, converted, nullable carg0 = (*C.GstObject)(UnsafeObjectToGlibNone(object)) cret = C.gst_object_get_parent(carg0) runtime.KeepAlive(object) var goret Object if cret != nil { goret = UnsafeObjectFromGlibFull(unsafe.Pointer(cret)) } return goret } // GetPathString wraps gst_object_get_path_string // // The function returns the following values: // // - goret string // // Generates a string describing the path of @object in // the object hierarchy. Only useful (or used) for debugging. // // Free-function: g_free func (object *ObjectInstance) GetPathString() string { var carg0 *C.GstObject // in, none, converted var cret *C.gchar // return, full, string carg0 = (*C.GstObject)(UnsafeObjectToGlibNone(object)) cret = C.gst_object_get_path_string(carg0) runtime.KeepAlive(object) var goret string goret = C.GoString((*C.char)(unsafe.Pointer(cret))) defer C.free(unsafe.Pointer(cret)) return goret } // HasActiveControlBindings wraps gst_object_has_active_control_bindings // // The function returns the following values: // // - goret bool // // Check if the @object has active controlled properties. func (object *ObjectInstance) HasActiveControlBindings() bool { var carg0 *C.GstObject // in, none, converted var cret C.gboolean // return carg0 = (*C.GstObject)(UnsafeObjectToGlibNone(object)) cret = C.gst_object_has_active_control_bindings(carg0) runtime.KeepAlive(object) var goret bool if cret != 0 { goret = true } return goret } // HasAncestor wraps gst_object_has_ancestor // // The function takes the following parameters: // // - ancestor Object: a #GstObject to check as ancestor // // The function returns the following values: // // - goret bool // // Check if @object has an ancestor @ancestor somewhere up in // the hierarchy. One can e.g. check if a #GstElement is inside a #GstPipeline. // // Deprecated: Use gst_object_has_as_ancestor() instead. // // MT safe. Grabs and releases @object's locks. func (object *ObjectInstance) HasAncestor(ancestor Object) bool { var carg0 *C.GstObject // in, none, converted var carg1 *C.GstObject // in, none, converted var cret C.gboolean // return carg0 = (*C.GstObject)(UnsafeObjectToGlibNone(object)) carg1 = (*C.GstObject)(UnsafeObjectToGlibNone(ancestor)) cret = C.gst_object_has_ancestor(carg0, carg1) runtime.KeepAlive(object) runtime.KeepAlive(ancestor) var goret bool if cret != 0 { goret = true } return goret } // HasAsAncestor wraps gst_object_has_as_ancestor // // The function takes the following parameters: // // - ancestor Object: a #GstObject to check as ancestor // // The function returns the following values: // // - goret bool // // Check if @object has an ancestor @ancestor somewhere up in // the hierarchy. One can e.g. check if a #GstElement is inside a #GstPipeline. func (object *ObjectInstance) HasAsAncestor(ancestor Object) bool { var carg0 *C.GstObject // in, none, converted var carg1 *C.GstObject // in, none, converted var cret C.gboolean // return carg0 = (*C.GstObject)(UnsafeObjectToGlibNone(object)) carg1 = (*C.GstObject)(UnsafeObjectToGlibNone(ancestor)) cret = C.gst_object_has_as_ancestor(carg0, carg1) runtime.KeepAlive(object) runtime.KeepAlive(ancestor) var goret bool if cret != 0 { goret = true } return goret } // HasAsParent wraps gst_object_has_as_parent // // The function takes the following parameters: // // - parent Object: a #GstObject to check as parent // // The function returns the following values: // // - goret bool // // Check if @parent is the parent of @object. // E.g. a #GstElement can check if it owns a given #GstPad. func (object *ObjectInstance) HasAsParent(parent Object) bool { var carg0 *C.GstObject // in, none, converted var carg1 *C.GstObject // in, none, converted var cret C.gboolean // return carg0 = (*C.GstObject)(UnsafeObjectToGlibNone(object)) carg1 = (*C.GstObject)(UnsafeObjectToGlibNone(parent)) cret = C.gst_object_has_as_parent(carg0, carg1) runtime.KeepAlive(object) runtime.KeepAlive(parent) var goret bool if cret != 0 { goret = true } return goret } // RemoveControlBinding wraps gst_object_remove_control_binding // // The function takes the following parameters: // // - binding ControlBinding: the binding // // The function returns the following values: // // - goret bool // // Removes the corresponding #GstControlBinding. If it was the // last ref of the binding, it will be disposed. func (object *ObjectInstance) RemoveControlBinding(binding ControlBinding) bool { var carg0 *C.GstObject // in, none, converted var carg1 *C.GstControlBinding // in, none, converted var cret C.gboolean // return carg0 = (*C.GstObject)(UnsafeObjectToGlibNone(object)) carg1 = (*C.GstControlBinding)(UnsafeControlBindingToGlibNone(binding)) cret = C.gst_object_remove_control_binding(carg0, carg1) runtime.KeepAlive(object) runtime.KeepAlive(binding) var goret bool if cret != 0 { goret = true } return goret } // SetControlBindingDisabled wraps gst_object_set_control_binding_disabled // // The function takes the following parameters: // // - propertyName string: property to disable // - disabled bool: boolean that specifies whether to disable the controller // or not. // // This function is used to disable the control bindings on a property for // some time, i.e. gst_object_sync_values() will do nothing for the // property. func (object *ObjectInstance) SetControlBindingDisabled(propertyName string, disabled bool) { var carg0 *C.GstObject // in, none, converted var carg1 *C.gchar // in, none, string var carg2 C.gboolean // in carg0 = (*C.GstObject)(UnsafeObjectToGlibNone(object)) carg1 = (*C.gchar)(unsafe.Pointer(C.CString(propertyName))) defer C.free(unsafe.Pointer(carg1)) if disabled { carg2 = C.TRUE } C.gst_object_set_control_binding_disabled(carg0, carg1, carg2) runtime.KeepAlive(object) runtime.KeepAlive(propertyName) runtime.KeepAlive(disabled) } // SetControlBindingsDisabled wraps gst_object_set_control_bindings_disabled // // The function takes the following parameters: // // - disabled bool: boolean that specifies whether to disable the controller // or not. // // This function is used to disable all controlled properties of the @object for // some time, i.e. gst_object_sync_values() will do nothing. func (object *ObjectInstance) SetControlBindingsDisabled(disabled bool) { var carg0 *C.GstObject // in, none, converted var carg1 C.gboolean // in carg0 = (*C.GstObject)(UnsafeObjectToGlibNone(object)) if disabled { carg1 = C.TRUE } C.gst_object_set_control_bindings_disabled(carg0, carg1) runtime.KeepAlive(object) runtime.KeepAlive(disabled) } // SetControlRate wraps gst_object_set_control_rate // // The function takes the following parameters: // // - controlRate ClockTime: the new control-rate in nanoseconds. // // Change the control-rate for this @object. Audio processing #GstElement // objects will use this rate to sub-divide their processing loop and call // gst_object_sync_values() in between. The length of the processing segment // should be up to @control-rate nanoseconds. // // The control-rate should not change if the element is in %GST_STATE_PAUSED or // %GST_STATE_PLAYING. func (object *ObjectInstance) SetControlRate(controlRate ClockTime) { var carg0 *C.GstObject // in, none, converted var carg1 C.GstClockTime // in, none, casted, alias carg0 = (*C.GstObject)(UnsafeObjectToGlibNone(object)) carg1 = C.GstClockTime(controlRate) C.gst_object_set_control_rate(carg0, carg1) runtime.KeepAlive(object) runtime.KeepAlive(controlRate) } // SetName wraps gst_object_set_name // // The function takes the following parameters: // // - name string (nullable): new name of object // // The function returns the following values: // // - goret bool // // Sets the name of @object, or gives @object a guaranteed unique // name (if @name is %NULL). // This function makes a copy of the provided name, so the caller // retains ownership of the name it sent. func (object *ObjectInstance) SetName(name string) bool { var carg0 *C.GstObject // in, none, converted var carg1 *C.gchar // in, none, string, nullable-string var cret C.gboolean // return carg0 = (*C.GstObject)(UnsafeObjectToGlibNone(object)) if name != "" { carg1 = (*C.gchar)(unsafe.Pointer(C.CString(name))) defer C.free(unsafe.Pointer(carg1)) } cret = C.gst_object_set_name(carg0, carg1) runtime.KeepAlive(object) runtime.KeepAlive(name) var goret bool if cret != 0 { goret = true } return goret } // SetParent wraps gst_object_set_parent // // The function takes the following parameters: // // - parent Object: new parent of object // // The function returns the following values: // // - goret bool // // Sets the parent of @object to @parent. The object's reference count will // be incremented, and any floating reference will be removed (see gst_object_ref_sink()). func (object *ObjectInstance) SetParent(parent Object) bool { var carg0 *C.GstObject // in, none, converted var carg1 *C.GstObject // in, none, converted var cret C.gboolean // return carg0 = (*C.GstObject)(UnsafeObjectToGlibNone(object)) carg1 = (*C.GstObject)(UnsafeObjectToGlibNone(parent)) cret = C.gst_object_set_parent(carg0, carg1) runtime.KeepAlive(object) runtime.KeepAlive(parent) var goret bool if cret != 0 { goret = true } return goret } // SuggestNextSync wraps gst_object_suggest_next_sync // // The function returns the following values: // // - goret ClockTime // // Returns a suggestion for timestamps where buffers should be split // to get best controller results. func (object *ObjectInstance) SuggestNextSync() ClockTime { var carg0 *C.GstObject // in, none, converted var cret C.GstClockTime // return, none, casted, alias carg0 = (*C.GstObject)(UnsafeObjectToGlibNone(object)) cret = C.gst_object_suggest_next_sync(carg0) runtime.KeepAlive(object) var goret ClockTime goret = ClockTime(cret) return goret } // SyncValues wraps gst_object_sync_values // // The function takes the following parameters: // // - timestamp ClockTime: the time that should be processed // // The function returns the following values: // // - goret bool // // Sets the properties of the object, according to the #GstControlSources that // (maybe) handle them and for the given timestamp. // // If this function fails, it is most likely the application developers fault. // Most probably the control sources are not setup correctly. func (object *ObjectInstance) SyncValues(timestamp ClockTime) bool { var carg0 *C.GstObject // in, none, converted var carg1 C.GstClockTime // in, none, casted, alias var cret C.gboolean // return carg0 = (*C.GstObject)(UnsafeObjectToGlibNone(object)) carg1 = C.GstClockTime(timestamp) cret = C.gst_object_sync_values(carg0, carg1) runtime.KeepAlive(object) runtime.KeepAlive(timestamp) var goret bool if cret != 0 { goret = true } return goret } // Unparent wraps gst_object_unparent // // Clear the parent of @object, removing the associated reference. // This function decreases the refcount of @object. // // MT safe. Grabs and releases @object's lock. func (object *ObjectInstance) Unparent() { var carg0 *C.GstObject // in, none, converted carg0 = (*C.GstObject)(UnsafeObjectToGlibNone(object)) C.gst_object_unparent(carg0) 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 ObjectInstance } var _ Pad = (*PadInstance)(nil) // Pad wraps GstPad // // A #GstElement is linked to other elements via "pads", which are extremely // light-weight generic link points. // // Pads have a #GstPadDirection, source pads produce data, sink pads consume // data. // // Pads are typically created from a #GstPadTemplate with // gst_pad_new_from_template() and are then added to a #GstElement. This usually // happens when the element is created but it can also happen dynamically based // on the data that the element is processing or based on the pads that the // application requests. // // Pads without pad templates can be created with gst_pad_new(), // which takes a direction and a name as an argument. If the name is %NULL, // then a guaranteed unique name will be assigned to it. // // A #GstElement creating a pad will typically use the various // gst_pad_set_*_function\() calls to register callbacks for events, queries or // dataflow on the pads. // // gst_pad_get_parent() will retrieve the #GstElement that owns the pad. // // After two pads are retrieved from an element by gst_element_get_static_pad(), // the pads can be linked with gst_pad_link(). (For quick links, // you can also use gst_element_link(), which will make the obvious // link for you if it's straightforward.). Pads can be unlinked again with // gst_pad_unlink(). gst_pad_get_peer() can be used to check what the pad is // linked to. // // Before dataflow is possible on the pads, they need to be activated with // gst_pad_set_active(). // // gst_pad_query() and gst_pad_peer_query() can be used to query various // properties of the pad and the stream. // // To send a #GstEvent on a pad, use gst_pad_send_event() and // gst_pad_push_event(). Some events will be sticky on the pad, meaning that // after they pass on the pad they can be queried later with // gst_pad_get_sticky_event() and gst_pad_sticky_events_foreach(). // gst_pad_get_current_caps() and gst_pad_has_current_caps() are convenience // functions to query the current sticky CAPS event on a pad. // // GstElements will use gst_pad_push() and gst_pad_pull_range() to push out // or pull in a buffer. // // The dataflow, events and queries that happen on a pad can be monitored with // probes that can be installed with gst_pad_add_probe(). gst_pad_is_blocked() // can be used to check if a block probe is installed on the pad. // gst_pad_is_blocking() checks if the blocking probe is currently blocking the // pad. gst_pad_remove_probe() is used to remove a previously installed probe // and unblock blocking probes if any. // // Pad have an offset that can be retrieved with gst_pad_get_offset(). This // offset will be applied to the running_time of all data passing over the pad. // gst_pad_set_offset() can be used to change the offset. // // Convenience functions exist to start, pause and stop the task on a pad with // gst_pad_start_task(), gst_pad_pause_task() and gst_pad_stop_task() // respectively. type Pad interface { Object upcastToGstPad() *PadInstance // ActivateMode wraps gst_pad_activate_mode // // The function takes the following parameters: // // - mode PadMode: the requested activation mode // - active bool: whether or not the pad should be active. // // The function returns the following values: // // - goret bool // // Activates or deactivates the given pad in @mode via dispatching to the // pad's activatemodefunc. For use from within pad activation functions only. // // If you don't know what this is, you probably don't want to call it. ActivateMode(PadMode, bool) bool // AddProbe wraps gst_pad_add_probe // // The function takes the following parameters: // // - mask PadProbeType: the probe mask // - callback PadProbeCallback: #GstPadProbeCallback that will be called with notifications of // the pad state // // The function returns the following values: // // - goret uint32 // // Be notified of different states of pads. The provided callback is called for // every state that matches @mask. // // Probes are called in groups: First GST_PAD_PROBE_TYPE_BLOCK probes are // called, then others, then finally GST_PAD_PROBE_TYPE_IDLE. The only // exception here are GST_PAD_PROBE_TYPE_IDLE probes that are called // immediately if the pad is already idle while calling gst_pad_add_probe(). // In each of the groups, probes are called in the order in which they were // added. AddProbe(PadProbeType, PadProbeCallback) uint32 // CanLink wraps gst_pad_can_link // // The function takes the following parameters: // // - sinkpad Pad: the sink #GstPad. // // The function returns the following values: // // - goret bool // // Checks if the source pad and the sink pad are compatible so they can be // linked. CanLink(Pad) bool // Chain wraps gst_pad_chain // // The function takes the following parameters: // // - buffer *Buffer: the #GstBuffer to send, return GST_FLOW_ERROR // if not. // // The function returns the following values: // // - goret FlowReturn // // Chain a buffer to @pad. // // The function returns #GST_FLOW_FLUSHING if the pad was flushing. // // If the buffer type is not acceptable for @pad (as negotiated with a // preceding GST_EVENT_CAPS event), this function returns // #GST_FLOW_NOT_NEGOTIATED. // // The function proceeds calling the chain function installed on @pad (see // gst_pad_set_chain_function()) and the return value of that function is // returned to the caller. #GST_FLOW_NOT_SUPPORTED is returned if @pad has no // chain function. // // In all cases, success or failure, the caller loses its reference to @buffer // after calling this function. Chain(*Buffer) FlowReturn // ChainList wraps gst_pad_chain_list // // The function takes the following parameters: // // - list *BufferList: the #GstBufferList to send, return GST_FLOW_ERROR // if not. // // The function returns the following values: // // - goret FlowReturn // // Chain a bufferlist to @pad. // // The function returns #GST_FLOW_FLUSHING if the pad was flushing. // // If @pad was not negotiated properly with a CAPS event, this function // returns #GST_FLOW_NOT_NEGOTIATED. // // The function proceeds calling the chainlist function installed on @pad (see // gst_pad_set_chain_list_function()) and the return value of that function is // returned to the caller. #GST_FLOW_NOT_SUPPORTED is returned if @pad has no // chainlist function. // // In all cases, success or failure, the caller loses its reference to @list // after calling this function. // // MT safe. ChainList(*BufferList) FlowReturn // CheckReconfigure wraps gst_pad_check_reconfigure // // The function returns the following values: // // - goret bool // // Check and clear the #GST_PAD_FLAG_NEED_RECONFIGURE flag on @pad and return %TRUE // if the flag was set. CheckReconfigure() bool // CreateStreamID wraps gst_pad_create_stream_id // // The function takes the following parameters: // // - parent Element: Parent #GstElement of @pad // - streamId string (nullable): The stream-id // // The function returns the following values: // // - goret string // // Creates a stream-id for the source #GstPad @pad by combining the // upstream information with the optional @stream_id of the stream // of @pad. @pad must have a parent #GstElement and which must have zero // or one sinkpad. @stream_id can only be %NULL if the parent element // of @pad has only a single source pad. // // This function generates an unique stream-id by getting the upstream // stream-start event stream ID and appending @stream_id to it. If the // element has no sinkpad it will generate an upstream stream-id by // doing an URI query on the element and in the worst case just uses // a random number. Source elements that don't implement the URI // handler interface should ideally generate a unique, deterministic // stream-id manually instead. // // Since stream IDs are sorted alphabetically, any numbers in the // stream ID should be printed with a fixed number of characters, // preceded by 0's, such as by using the format \%03u instead of \%u. CreateStreamID(Element, string) string // EventDefault wraps gst_pad_event_default // // The function takes the following parameters: // // - parent Object (nullable): the parent of @pad or %NULL // - event *Event: the #GstEvent to handle. // // The function returns the following values: // // - goret bool // // Invokes the default event handler for the given pad. // // The EOS event will pause the task associated with @pad before it is forwarded // to all internally linked pads, // // The event is sent to all pads internally linked to @pad. This function // takes ownership of @event. EventDefault(Object, *Event) bool // Forward wraps gst_pad_forward // // The function takes the following parameters: // // - forward PadForwardFunction: a #GstPadForwardFunction // // The function returns the following values: // // - goret bool // // Calls @forward for all internally linked pads of @pad. This function deals with // dynamically changing internal pads and will make sure that the @forward // function is only called once for each pad. // // 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) // // Gets the capabilities of the allowed media types that can flow through // @pad and its peer. // // The allowed capabilities is calculated as the intersection of the results of // calling gst_pad_query_caps() on @pad and its peer. The caller owns a reference // on the resulting caps. GetAllowedCaps() *Caps // GetCurrentCaps wraps gst_pad_get_current_caps // // The function returns the following values: // // - goret *Caps (nullable) // // Gets the capabilities currently configured on @pad with the last // #GST_EVENT_CAPS event. GetCurrentCaps() *Caps // GetDirection wraps gst_pad_get_direction // // The function returns the following values: // // - goret PadDirection // // Gets the direction of the pad. The direction of the pad is // decided at construction time so this function does not take // the LOCK. GetDirection() PadDirection // GetLastFlowReturn wraps gst_pad_get_last_flow_return // // The function returns the following values: // // - goret FlowReturn // // 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 // // Get the offset applied to the running time of @pad. @pad has to be a source // pad. GetOffset() int64 // GetPadTemplate wraps gst_pad_get_pad_template // // The function returns the following values: // // - goret PadTemplate (nullable) // // Gets the template for @pad. GetPadTemplate() PadTemplate // GetPadTemplateCaps wraps gst_pad_get_pad_template_caps // // The function returns the following values: // // - goret *Caps // // 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) // // Gets the parent of @pad, cast to a #GstElement. If a @pad has no parent or // 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) // // Gets the peer of @pad. This function refs the peer pad so // you need to unref it after use. GetPeer() Pad // GetRange wraps gst_pad_get_range // // The function takes the following parameters: // // - offset uint64: The start offset of the buffer // - size uint: The length of the buffer // // The function returns the following values: // // - buffer *Buffer: a pointer to hold the #GstBuffer, // returns #GST_FLOW_ERROR if %NULL. // - goret FlowReturn // // When @pad is flushing this function returns #GST_FLOW_FLUSHING // immediately and @buffer is %NULL. // // Calls the getrange function of @pad, see #GstPadGetRangeFunction for a // description of a getrange function. If @pad has no getrange function // installed (see gst_pad_set_getrange_function()) this function returns // #GST_FLOW_NOT_SUPPORTED. // // If @buffer points to a variable holding %NULL, a valid new #GstBuffer will be // placed in @buffer when this function returns #GST_FLOW_OK. The new buffer // must be freed with gst_buffer_unref() after usage. // // When @buffer points to a variable that points to a valid #GstBuffer, the // buffer will be filled with the result data when this function returns // #GST_FLOW_OK. If the provided buffer is larger than @size, only // @size bytes will be filled in the result buffer and its size will be updated // accordingly. // // Note that less than @size bytes can be returned in @buffer when, for example, // an EOS condition is near or when @buffer is not large enough to hold @size // bytes. The caller should check the result buffer size to get the result size. // // When this function returns any other result value than #GST_FLOW_OK, @buffer // will be unchanged. // // 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) // // If there is a single internal link of the given pad, this function will // return it. Otherwise, it will return NULL. GetSingleInternalLink() Pad // GetStickyEvent wraps gst_pad_get_sticky_event // // The function takes the following parameters: // // - eventType EventType: the #GstEventType that should be retrieved. // - idx uint: the index of the event // // The function returns the following values: // // - goret *Event (nullable) // // Returns a new reference of the sticky event of type @event_type // from the event. GetStickyEvent(EventType, uint) *Event // GetStream wraps gst_pad_get_stream // // The function returns the following values: // // - goret Stream (nullable) // // Returns the current #GstStream for the @pad, or %NULL if none has been // set yet, i.e. the pad has not received a stream-start event yet. // // This is a convenience wrapper around gst_pad_get_sticky_event() and // gst_event_parse_stream(). GetStream() Stream // GetStreamID wraps gst_pad_get_stream_id // // The function returns the following values: // // - goret string (nullable) // // Returns the current stream-id for the @pad, or %NULL if none has been // set yet, i.e. the pad has not received a stream-start event yet. // // This is a convenience wrapper around gst_pad_get_sticky_event() and // gst_event_parse_stream_start(). // // The returned stream-id string should be treated as an opaque string, its // contents should not be interpreted. GetStreamID() string // GetTaskState wraps gst_pad_get_task_state // // The function returns the following values: // // - goret TaskState // // Get @pad task state. If no task is currently // set, #GST_TASK_STOPPED is returned. GetTaskState() TaskState // HasCurrentCaps wraps gst_pad_has_current_caps // // The function returns the following values: // // - goret bool // // 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 // // Query if a pad is active IsActive() bool // IsBlocked wraps gst_pad_is_blocked // // The function returns the following values: // // - goret bool // // Checks if the pad is blocked or not. This function returns the // last requested state of the pad. It is not certain that the pad // 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 // // Checks if the pad is blocking or not. This is a guaranteed state // 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 // // 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) // // Gets an iterator for the pads to which the given pad is linked to inside // of the parent element. // // Each #GstPad element yielded by the iterator will have its refcount increased, // so unref after use. // // Free-function: gst_iterator_free IterateInternalLinks() *Iterator // IterateInternalLinksDefault wraps gst_pad_iterate_internal_links_default // // The function takes the following parameters: // // - parent Object (nullable): the parent of @pad or %NULL // // The function returns the following values: // // - goret *Iterator (nullable) // // Iterate the list of pads to which the given pad is linked to inside of // the parent element. // This is the default handler, and thus returns an iterator of all of the // pads inside the parent element with opposite direction. // // The caller must free this iterator after use with gst_iterator_free(). IterateInternalLinksDefault(Object) *Iterator // Link wraps gst_pad_link // // The function takes the following parameters: // // - sinkpad Pad: the sink #GstPad to link. // // The function returns the following values: // // - goret PadLinkReturn // // Links the source pad and the sink pad. Link(Pad) PadLinkReturn // LinkFull wraps gst_pad_link_full // // The function takes the following parameters: // // - sinkpad Pad: the sink #GstPad to link. // - flags PadLinkCheck: the checks to validate when linking // // The function returns the following values: // // - goret PadLinkReturn // // Links the source pad and the sink pad. // // This variant of #gst_pad_link provides a more granular control on the // checks being done when linking. While providing some considerable speedups // the caller of this method must be aware that wrong usage of those flags // can cause severe issues. Refer to the documentation of #GstPadLinkCheck // for more information. // // MT Safe. LinkFull(Pad, PadLinkCheck) PadLinkReturn // LinkMaybeGhosting wraps gst_pad_link_maybe_ghosting // // The function takes the following parameters: // // - sink Pad: a #GstPad // // The function returns the following values: // // - goret bool // // Links @src to @sink, creating any #GstGhostPad's in between as necessary. // // This is a convenience function to save having to create and add intermediate // #GstGhostPad's as required for linking across #GstBin boundaries. // // If @src or @sink pads don't have parent elements or do not share a common // ancestor, the link will fail. LinkMaybeGhosting(Pad) bool // LinkMaybeGhostingFull wraps gst_pad_link_maybe_ghosting_full // // The function takes the following parameters: // // - sink Pad: a #GstPad // - flags PadLinkCheck: some #GstPadLinkCheck flags // // The function returns the following values: // // - goret bool // // Links @src to @sink, creating any #GstGhostPad's in between as necessary. // // This is a convenience function to save having to create and add intermediate // #GstGhostPad's as required for linking across #GstBin boundaries. // // If @src or @sink pads don't have parent elements or do not share a common // ancestor, the link will fail. // // Calling gst_pad_link_maybe_ghosting_full() with // @flags == %GST_PAD_LINK_CHECK_DEFAULT is the recommended way of linking // pads with safety checks applied. LinkMaybeGhostingFull(Pad, PadLinkCheck) bool // MarkReconfigure wraps gst_pad_mark_reconfigure // // Mark a pad for needing reconfiguration. The next call to // 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 // // Check the #GST_PAD_FLAG_NEED_RECONFIGURE flag on @pad and return %TRUE // if the flag was set. NeedsReconfigure() bool // PauseTask wraps gst_pad_pause_task // // The function returns the following values: // // - goret bool // // Pause the task of @pad. This function will also wait until the // function executed by the task is finished if this function is not // called from the task function. PauseTask() bool // PeerQuery wraps gst_pad_peer_query // // The function takes the following parameters: // // - query *Query: the #GstQuery to perform. // // The function returns the following values: // // - goret bool // // Performs gst_pad_query() on the peer of @pad. // // The caller is responsible for both the allocation and deallocation of // the query structure. PeerQuery(*Query) bool // PeerQueryAcceptCaps wraps gst_pad_peer_query_accept_caps // // The function takes the following parameters: // // - caps *Caps: a #GstCaps to check on the pad // // The function returns the following values: // // - goret bool // // Check if the peer of @pad accepts @caps. If @pad has no peer, this function // returns %TRUE. PeerQueryAcceptCaps(*Caps) bool // PeerQueryCaps wraps gst_pad_peer_query_caps // // The function takes the following parameters: // // - filter *Caps (nullable): a #GstCaps filter, or %NULL. // // The function returns the following values: // // - goret *Caps // // Gets the capabilities of the peer connected to this pad. Similar to // gst_pad_query_caps(). // // When called on srcpads @filter contains the caps that // upstream could produce in the order preferred by upstream. When // called on sinkpads @filter contains the caps accepted by // downstream in the preferred order. @filter might be %NULL but // if it is not %NULL the returned caps will be a subset of @filter. PeerQueryCaps(*Caps) *Caps // PeerQueryConvert wraps gst_pad_peer_query_convert // // The function takes the following parameters: // // - srcFormat Format: a #GstFormat to convert from. // - srcVal int64: a value to convert. // - destFormat Format: the #GstFormat to convert to. // // The function returns the following values: // // - destVal int64: a pointer to the result. // - goret bool // // Queries the peer pad of a given sink pad to convert @src_val in @src_format // to @dest_format. PeerQueryConvert(Format, int64, Format) (int64, bool) // PeerQueryDuration wraps gst_pad_peer_query_duration // // The function takes the following parameters: // // - format Format: the #GstFormat requested // // The function returns the following values: // // - duration int64: a location in which to store the total // duration, or %NULL. // - goret bool // // Queries the peer pad of a given sink pad for the total stream duration. PeerQueryDuration(Format) (int64, bool) // PeerQueryPosition wraps gst_pad_peer_query_position // // The function takes the following parameters: // // - format Format: the #GstFormat requested // // The function returns the following values: // // - cur int64: a location in which to store the current // position, or %NULL. // - goret bool // // Queries the peer of a given sink pad for the stream position. PeerQueryPosition(Format) (int64, bool) // ProxyQueryAcceptCaps wraps gst_pad_proxy_query_accept_caps // // The function takes the following parameters: // // - query *Query: an ACCEPT_CAPS #GstQuery. // // The function returns the following values: // // - goret bool // // Checks if all internally linked pads of @pad accepts the caps in @query and // returns the intersection of the results. // // This function is useful as a default accept caps query function for an element // that can handle any stream format, but requires caps that are acceptable for // all opposite pads. ProxyQueryAcceptCaps(*Query) bool // ProxyQueryCaps wraps gst_pad_proxy_query_caps // // The function takes the following parameters: // // - query *Query: a CAPS #GstQuery. // // The function returns the following values: // // - goret bool // // Calls gst_pad_query_caps() for all internally linked pads of @pad and returns // the intersection of the results. // // This function is useful as a default caps query function for an element // that can handle any stream format, but requires all its pads to have // the same caps. Two such elements are tee and adder. ProxyQueryCaps(*Query) bool // PullRange wraps gst_pad_pull_range // // The function takes the following parameters: // // - offset uint64: The start offset of the buffer // - size uint: The length of the buffer // // The function returns the following values: // // - buffer *Buffer: a pointer to hold the #GstBuffer, returns // GST_FLOW_ERROR if %NULL. // - goret FlowReturn // // Pulls a @buffer from the peer pad or fills up a provided buffer. // // This function will first trigger the pad block signal if it was // installed. // // When @pad is not linked #GST_FLOW_NOT_LINKED is returned else this // function returns the result of gst_pad_get_range() on the peer pad. // See gst_pad_get_range() for a list of return values and for the // semantics of the arguments of this function. // // If @buffer points to a variable holding %NULL, a valid new #GstBuffer will be // placed in @buffer when this function returns #GST_FLOW_OK. The new buffer // must be freed with gst_buffer_unref() after usage. When this function // returns any other result value, @buffer will still point to %NULL. // // When @buffer points to a variable that points to a valid #GstBuffer, the // buffer will be filled with the result data when this function returns // #GST_FLOW_OK. When this function returns any other result value, // @buffer will be unchanged. If the provided buffer is larger than @size, only // @size bytes will be filled in the result buffer and its size will be updated // accordingly. // // Note that less than @size bytes can be returned in @buffer when, for example, // an EOS condition is near or when @buffer is not large enough to hold @size // bytes. The caller should check the result buffer size to get the result size. PullRange(uint64, uint) (*Buffer, FlowReturn) // Push wraps gst_pad_push // // The function takes the following parameters: // // - buffer *Buffer: the #GstBuffer to push returns GST_FLOW_ERROR // if not. // // The function returns the following values: // // - goret FlowReturn // // Pushes a buffer to the peer of @pad. // // This function will call installed block probes before triggering any // installed data probes. // // The function proceeds calling gst_pad_chain() on the peer pad and returns // the value from that function. If @pad has no peer, #GST_FLOW_NOT_LINKED will // be returned. // // In all cases, success or failure, the caller loses its reference to @buffer // after calling this function. Push(*Buffer) FlowReturn // PushEvent wraps gst_pad_push_event // // The function takes the following parameters: // // - event *Event: the #GstEvent to send to the pad. // // The function returns the following values: // // - goret bool // // Sends the event to the peer of the given pad. This function is // mainly used by elements to send events to their peer // elements. // // This function takes ownership of the provided event so you should // gst_event_ref() it if you want to reuse the event after this call. PushEvent(*Event) bool // PushList wraps gst_pad_push_list // // The function takes the following parameters: // // - list *BufferList: the #GstBufferList to push returns GST_FLOW_ERROR // if not. // // The function returns the following values: // // - goret FlowReturn // // Pushes a buffer list to the peer of @pad. // // This function will call installed block probes before triggering any // installed data probes. // // The function proceeds calling the chain function on the peer pad and returns // the value from that function. If @pad has no peer, #GST_FLOW_NOT_LINKED will // be returned. If the peer pad does not have any installed chainlist function // every group buffer of the list will be merged into a normal #GstBuffer and // chained via gst_pad_chain(). // // In all cases, success or failure, the caller loses its reference to @list // after calling this function. PushList(*BufferList) FlowReturn // Query wraps gst_pad_query // // The function takes the following parameters: // // - query *Query: the #GstQuery to perform. // // The function returns the following values: // // - goret bool // // Dispatches a query to a pad. The query should have been allocated by the // caller via one of the type-specific allocation functions. The element that // the pad belongs to is responsible for filling the query with an appropriate // response, which should then be parsed with a type-specific query parsing // function. // // Again, the caller is responsible for both the allocation and deallocation of // the query structure. // // Please also note that some queries might need a running pipeline to work. Query(*Query) bool // QueryAcceptCaps wraps gst_pad_query_accept_caps // // The function takes the following parameters: // // - caps *Caps: a #GstCaps to check on the pad // // The function returns the following values: // // - goret bool // // Check if the given pad accepts the caps. QueryAcceptCaps(*Caps) bool // QueryCaps wraps gst_pad_query_caps // // The function takes the following parameters: // // - filter *Caps (nullable): suggested #GstCaps, or %NULL // // The function returns the following values: // // - goret *Caps // // Gets the capabilities this pad can produce or consume. // Note that this method doesn't necessarily return the caps set by sending a // gst_event_new_caps() - use gst_pad_get_current_caps() for that instead. // gst_pad_query_caps returns all possible caps a pad can operate with, using // the pad's CAPS query function, If the query fails, this function will return // @filter, if not %NULL, otherwise ANY. // // When called on sinkpads @filter contains the caps that // upstream could produce in the order preferred by upstream. When // called on srcpads @filter contains the caps accepted by // downstream in the preferred order. @filter might be %NULL but // if it is not %NULL the returned caps will be a subset of @filter. // // Note that this function does not return writable #GstCaps, use // gst_caps_make_writable() before modifying the caps. QueryCaps(*Caps) *Caps // QueryConvert wraps gst_pad_query_convert // // The function takes the following parameters: // // - srcFormat Format: a #GstFormat to convert from. // - srcVal int64: a value to convert. // - destFormat Format: the #GstFormat to convert to. // // The function returns the following values: // // - destVal int64: a pointer to the result. // - goret bool // // Queries a pad to convert @src_val in @src_format to @dest_format. QueryConvert(Format, int64, Format) (int64, bool) // QueryDefault wraps gst_pad_query_default // // The function takes the following parameters: // // - parent Object (nullable): the parent of @pad or %NULL // - query *Query: the #GstQuery to handle. // // The function returns the following values: // // - goret bool // // Invokes the default query handler for the given pad. // The query is sent to all pads internally linked to @pad. Note that // if there are many possible sink pads that are internally linked to // @pad, only one will be sent the query. // Multi-sinkpad elements should implement custom query handlers. QueryDefault(Object, *Query) bool // QueryDuration wraps gst_pad_query_duration // // The function takes the following parameters: // // - format Format: the #GstFormat requested // // The function returns the following values: // // - duration int64: a location in which to store the total // duration, or %NULL. // - goret bool // // Queries a pad for the total stream duration. QueryDuration(Format) (int64, bool) // QueryPosition wraps gst_pad_query_position // // The function takes the following parameters: // // - format Format: the #GstFormat requested // // The function returns the following values: // // - cur int64: A location in which to store the current position, or %NULL. // - goret bool // // Queries a pad for the stream position. QueryPosition(Format) (int64, bool) // RemoveProbe wraps gst_pad_remove_probe // // The function takes the following parameters: // // - id uint32: the probe id to remove // // Remove the probe with @id from @pad. // // MT safe. RemoveProbe(uint32) // SendEvent wraps gst_pad_send_event // // The function takes the following parameters: // // - event *Event: the #GstEvent to send to the pad. // // The function returns the following values: // // - goret bool // // Sends the event to the pad. This function can be used // by applications to send events in the pipeline. // // If @pad is a source pad, @event should be an upstream event. If @pad is a // sink pad, @event should be a downstream event. For example, you would not // send a #GST_EVENT_EOS on a src pad; EOS events only propagate downstream. // Furthermore, some downstream events have to be serialized with data flow, // like EOS, while some can travel out-of-band, like #GST_EVENT_FLUSH_START. If // the event needs to be serialized with data flow, this function will take the // pad's stream lock while calling its event function. // // To find out whether an event type is upstream, downstream, or downstream and // serialized, see #GstEventTypeFlags, gst_event_type_get_flags(), // #GST_EVENT_IS_UPSTREAM, #GST_EVENT_IS_DOWNSTREAM, and // #GST_EVENT_IS_SERIALIZED. Note that in practice that an application or // plugin doesn't need to bother itself with this information; the core handles // all necessary locks and checks. // // This function takes ownership of the provided event so you should // gst_event_ref() it if you want to reuse the event after this call. SendEvent(*Event) bool // SetActive wraps gst_pad_set_active // // The function takes the following parameters: // // - active bool: whether or not the pad should be active. // // The function returns the following values: // // - goret bool // // Activates or deactivates the given pad. // Normally called from within core state change functions. // // If @active, makes sure the pad is active. If it is already active, either in // push or pull mode, just return. Otherwise dispatches to the pad's activate // function to perform the actual activation. // // If not @active, calls gst_pad_activate_mode() with the pad's current mode // and a %FALSE argument. SetActive(bool) bool // SetOffset wraps gst_pad_set_offset // // The function takes the following parameters: // // - offset int64: the offset // // Set the offset that will be applied to the running time of @pad. SetOffset(int64) // StartTask wraps gst_pad_start_task // // The function takes the following parameters: // // - fn TaskFunction: the task function to call // // The function returns the following values: // // - goret bool // // Starts a task that repeatedly calls @func with @user_data. This function // is mostly used in pad activation functions to start the dataflow. // The #GST_PAD_STREAM_LOCK of @pad will automatically be acquired // before @func is called. StartTask(TaskFunction) bool // StopTask wraps gst_pad_stop_task // // The function returns the following values: // // - goret bool // // Stop the task of @pad. This function will also make sure that the // function executed by the task will effectively stop if not called // from the GstTaskFunction. // // This function will deadlock if called from the GstTaskFunction of // the task. Use gst_task_pause() instead. // // Regardless of whether the pad has a task, the stream lock is acquired and // released so as to ensure that streaming through this pad has finished. StopTask() bool // StoreStickyEvent wraps gst_pad_store_sticky_event // // The function takes the following parameters: // // - event *Event: a #GstEvent // // The function returns the following values: // // - goret FlowReturn // // Store the sticky @event on @pad StoreStickyEvent(*Event) FlowReturn // Unlink wraps gst_pad_unlink // // The function takes the following parameters: // // - sinkpad Pad: the sink #GstPad to unlink. // // The function returns the following values: // // - goret bool // // Unlinks the source pad from the sink pad. Will emit the #GstPad::unlinked // signal on both pads. Unlink(Pad) bool // UseFixedCaps wraps gst_pad_use_fixed_caps // // A helper function you can use that sets the FIXED_CAPS flag // This way the default CAPS query will always return the negotiated caps // or in case the pad is not negotiated, the padtemplate caps. // // The negotiated caps are the caps of the last CAPS event that passed on the // pad. Use this function on a pad that, once it negotiated to a CAPS, cannot // be renegotiated to something else. UseFixedCaps() // ConnectLinked connects the provided callback to the "linked" signal // // Signals that a pad has been linked to the peer pad. ConnectLinked(func(Pad, Pad)) gobject.SignalHandle // ConnectUnlinked connects the provided callback to the "unlinked" signal // // Signals that a pad has been unlinked from the peer pad. ConnectUnlinked(func(Pad, Pad)) gobject.SignalHandle } func unsafeWrapPad(base *gobject.ObjectInstance) *PadInstance { return &PadInstance{ ObjectInstance: ObjectInstance{ InitiallyUnownedInstance: gobject.InitiallyUnownedInstance{ ObjectInstance: *base, }, }, } } func marshalPadInstance(p unsafe.Pointer) (any, error) { return unsafeWrapPad(gobject.ValueFromNative(p).Object()), nil } // UnsafePadFromGlibNone is used to convert raw GstPad pointers to go while taking a reference and attaching a finalizer. This is used by the bindings internally. func UnsafePadFromGlibNone(c unsafe.Pointer) Pad { return gobject.UnsafeObjectFromGlibNone(c).(Pad) } // UnsafePadFromGlibFull is used to convert raw GstPad pointers to go while attaching a finalizer. This is used by the bindings internally. func UnsafePadFromGlibFull(c unsafe.Pointer) Pad { return gobject.UnsafeObjectFromGlibFull(c).(Pad) } func (p *PadInstance) upcastToGstPad() *PadInstance { return p } // UnsafePadToGlibNone is used to convert the instance to it's C value GstPad. This is used by the bindings internally. func UnsafePadToGlibNone(c Pad) unsafe.Pointer { return gobject.UnsafeObjectToGlibNone(c) } // UnsafePadToGlibFull is used to convert the instance to it's C value GstPad, while removeing the finalizer. This is used by the bindings internally. func UnsafePadToGlibFull(c Pad) unsafe.Pointer { return gobject.UnsafeObjectToGlibFull(c) } // NewPad wraps gst_pad_new // // The function takes the following parameters: // // - name string (nullable): the name of the new pad. // - direction PadDirection: the #GstPadDirection of the pad. // // The function returns the following values: // // - goret Pad // // Creates a new pad with the given name in the given direction. // If name is %NULL, a guaranteed unique name (across all pads) // will be assigned. // This function makes a copy of the name so you can safely free the name. func NewPad(name string, direction PadDirection) Pad { var carg1 *C.gchar // in, none, string, nullable-string var carg2 C.GstPadDirection // in, none, casted var cret *C.GstPad // return, none, converted if name != "" { carg1 = (*C.gchar)(unsafe.Pointer(C.CString(name))) defer C.free(unsafe.Pointer(carg1)) } carg2 = C.GstPadDirection(direction) cret = C.gst_pad_new(carg1, carg2) runtime.KeepAlive(name) runtime.KeepAlive(direction) var goret Pad goret = UnsafePadFromGlibNone(unsafe.Pointer(cret)) return goret } // NewPadFromStaticTemplate wraps gst_pad_new_from_static_template // // The function takes the following parameters: // // - templ *StaticPadTemplate: the #GstStaticPadTemplate to use // - name string: the name of the pad // // The function returns the following values: // // - goret Pad // // Creates a new pad with the given name from the given static template. // If name is %NULL, a guaranteed unique name (across all pads) // will be assigned. // This function makes a copy of the name so you can safely free the name. func NewPadFromStaticTemplate(templ *StaticPadTemplate, name string) Pad { var carg1 *C.GstStaticPadTemplate // in, none, converted var carg2 *C.gchar // in, none, string var cret *C.GstPad // return, none, converted carg1 = (*C.GstStaticPadTemplate)(UnsafeStaticPadTemplateToGlibNone(templ)) carg2 = (*C.gchar)(unsafe.Pointer(C.CString(name))) defer C.free(unsafe.Pointer(carg2)) cret = C.gst_pad_new_from_static_template(carg1, carg2) runtime.KeepAlive(templ) runtime.KeepAlive(name) var goret Pad goret = UnsafePadFromGlibNone(unsafe.Pointer(cret)) return goret } // NewPadFromTemplate wraps gst_pad_new_from_template // // The function takes the following parameters: // // - templ PadTemplate: the pad template to use // - name string (nullable): the name of the pad // // The function returns the following values: // // - goret Pad // // Creates a new pad with the given name from the given template. // If name is %NULL, a guaranteed unique name (across all pads) // will be assigned. // This function makes a copy of the name so you can safely free the name. func NewPadFromTemplate(templ PadTemplate, name string) Pad { var carg1 *C.GstPadTemplate // in, none, converted var carg2 *C.gchar // in, none, string, nullable-string var cret *C.GstPad // return, none, converted carg1 = (*C.GstPadTemplate)(UnsafePadTemplateToGlibNone(templ)) if name != "" { carg2 = (*C.gchar)(unsafe.Pointer(C.CString(name))) defer C.free(unsafe.Pointer(carg2)) } cret = C.gst_pad_new_from_template(carg1, carg2) runtime.KeepAlive(templ) runtime.KeepAlive(name) var goret Pad goret = UnsafePadFromGlibNone(unsafe.Pointer(cret)) return goret } // PadLinkGetName wraps gst_pad_link_get_name // // The function takes the following parameters: // // - ret PadLinkReturn: a #GstPadLinkReturn to get the name of. // // The function returns the following values: // // - goret string // // Gets a string representing the given pad-link return. func PadLinkGetName(ret PadLinkReturn) string { var carg1 C.GstPadLinkReturn // in, none, casted var cret *C.gchar // return, none, string carg1 = C.GstPadLinkReturn(ret) cret = C.gst_pad_link_get_name(carg1) runtime.KeepAlive(ret) var goret string goret = C.GoString((*C.char)(unsafe.Pointer(cret))) return goret } // ActivateMode wraps gst_pad_activate_mode // // The function takes the following parameters: // // - mode PadMode: the requested activation mode // - active bool: whether or not the pad should be active. // // The function returns the following values: // // - goret bool // // Activates or deactivates the given pad in @mode via dispatching to the // pad's activatemodefunc. For use from within pad activation functions only. // // If you don't know what this is, you probably don't want to call it. func (pad *PadInstance) ActivateMode(mode PadMode, active bool) bool { var carg0 *C.GstPad // in, none, converted var carg1 C.GstPadMode // in, none, casted var carg2 C.gboolean // in var cret C.gboolean // return carg0 = (*C.GstPad)(UnsafePadToGlibNone(pad)) carg1 = C.GstPadMode(mode) if active { carg2 = C.TRUE } cret = C.gst_pad_activate_mode(carg0, carg1, carg2) runtime.KeepAlive(pad) runtime.KeepAlive(mode) runtime.KeepAlive(active) var goret bool if cret != 0 { goret = true } return goret } // AddProbe wraps gst_pad_add_probe // // The function takes the following parameters: // // - mask PadProbeType: the probe mask // - callback PadProbeCallback: #GstPadProbeCallback that will be called with notifications of // the pad state // // The function returns the following values: // // - goret uint32 // // Be notified of different states of pads. The provided callback is called for // every state that matches @mask. // // Probes are called in groups: First GST_PAD_PROBE_TYPE_BLOCK probes are // called, then others, then finally GST_PAD_PROBE_TYPE_IDLE. The only // exception here are GST_PAD_PROBE_TYPE_IDLE probes that are called // immediately if the pad is already idle while calling gst_pad_add_probe(). // In each of the groups, probes are called in the order in which they were // added. func (pad *PadInstance) AddProbe(mask PadProbeType, callback PadProbeCallback) uint32 { var carg0 *C.GstPad // in, none, converted var carg1 C.GstPadProbeType // in, none, casted var carg2 C.GstPadProbeCallback // callback, scope: notified, closure: carg3, destroy: carg4 var carg3 C.gpointer // implicit var carg4 C.GDestroyNotify // implicit var cret C.gulong // return, none, casted carg0 = (*C.GstPad)(UnsafePadToGlibNone(pad)) carg1 = C.GstPadProbeType(mask) carg2 = (*[0]byte)(C._gotk4_gst1_PadProbeCallback) carg3 = C.gpointer(userdata.Register(callback)) carg4 = (C.GDestroyNotify)((*[0]byte)(C.destroyUserdata)) cret = C.gst_pad_add_probe(carg0, carg1, carg2, carg3, carg4) runtime.KeepAlive(pad) runtime.KeepAlive(mask) runtime.KeepAlive(callback) var goret uint32 goret = uint32(cret) return goret } // CanLink wraps gst_pad_can_link // // The function takes the following parameters: // // - sinkpad Pad: the sink #GstPad. // // The function returns the following values: // // - goret bool // // Checks if the source pad and the sink pad are compatible so they can be // linked. func (srcpad *PadInstance) CanLink(sinkpad Pad) bool { var carg0 *C.GstPad // in, none, converted var carg1 *C.GstPad // in, none, converted var cret C.gboolean // return carg0 = (*C.GstPad)(UnsafePadToGlibNone(srcpad)) carg1 = (*C.GstPad)(UnsafePadToGlibNone(sinkpad)) cret = C.gst_pad_can_link(carg0, carg1) runtime.KeepAlive(srcpad) runtime.KeepAlive(sinkpad) var goret bool if cret != 0 { goret = true } return goret } // Chain wraps gst_pad_chain // // The function takes the following parameters: // // - buffer *Buffer: the #GstBuffer to send, return GST_FLOW_ERROR // if not. // // The function returns the following values: // // - goret FlowReturn // // Chain a buffer to @pad. // // The function returns #GST_FLOW_FLUSHING if the pad was flushing. // // If the buffer type is not acceptable for @pad (as negotiated with a // preceding GST_EVENT_CAPS event), this function returns // #GST_FLOW_NOT_NEGOTIATED. // // The function proceeds calling the chain function installed on @pad (see // gst_pad_set_chain_function()) and the return value of that function is // returned to the caller. #GST_FLOW_NOT_SUPPORTED is returned if @pad has no // chain function. // // In all cases, success or failure, the caller loses its reference to @buffer // after calling this function. func (pad *PadInstance) Chain(buffer *Buffer) FlowReturn { var carg0 *C.GstPad // in, none, converted var carg1 *C.GstBuffer // in, full, converted var cret C.GstFlowReturn // return, none, casted carg0 = (*C.GstPad)(UnsafePadToGlibNone(pad)) carg1 = (*C.GstBuffer)(UnsafeBufferToGlibFull(buffer)) cret = C.gst_pad_chain(carg0, carg1) runtime.KeepAlive(pad) runtime.KeepAlive(buffer) var goret FlowReturn goret = FlowReturn(cret) return goret } // ChainList wraps gst_pad_chain_list // // The function takes the following parameters: // // - list *BufferList: the #GstBufferList to send, return GST_FLOW_ERROR // if not. // // The function returns the following values: // // - goret FlowReturn // // Chain a bufferlist to @pad. // // The function returns #GST_FLOW_FLUSHING if the pad was flushing. // // If @pad was not negotiated properly with a CAPS event, this function // returns #GST_FLOW_NOT_NEGOTIATED. // // The function proceeds calling the chainlist function installed on @pad (see // gst_pad_set_chain_list_function()) and the return value of that function is // returned to the caller. #GST_FLOW_NOT_SUPPORTED is returned if @pad has no // chainlist function. // // In all cases, success or failure, the caller loses its reference to @list // after calling this function. // // MT safe. func (pad *PadInstance) ChainList(list *BufferList) FlowReturn { var carg0 *C.GstPad // in, none, converted var carg1 *C.GstBufferList // in, full, converted var cret C.GstFlowReturn // return, none, casted carg0 = (*C.GstPad)(UnsafePadToGlibNone(pad)) carg1 = (*C.GstBufferList)(UnsafeBufferListToGlibFull(list)) cret = C.gst_pad_chain_list(carg0, carg1) runtime.KeepAlive(pad) runtime.KeepAlive(list) var goret FlowReturn goret = FlowReturn(cret) return goret } // CheckReconfigure wraps gst_pad_check_reconfigure // // The function returns the following values: // // - goret bool // // Check and clear the #GST_PAD_FLAG_NEED_RECONFIGURE flag on @pad and return %TRUE // if the flag was set. func (pad *PadInstance) CheckReconfigure() bool { var carg0 *C.GstPad // in, none, converted var cret C.gboolean // return carg0 = (*C.GstPad)(UnsafePadToGlibNone(pad)) cret = C.gst_pad_check_reconfigure(carg0) runtime.KeepAlive(pad) var goret bool if cret != 0 { goret = true } return goret } // CreateStreamID wraps gst_pad_create_stream_id // // The function takes the following parameters: // // - parent Element: Parent #GstElement of @pad // - streamId string (nullable): The stream-id // // The function returns the following values: // // - goret string // // Creates a stream-id for the source #GstPad @pad by combining the // upstream information with the optional @stream_id of the stream // of @pad. @pad must have a parent #GstElement and which must have zero // or one sinkpad. @stream_id can only be %NULL if the parent element // of @pad has only a single source pad. // // This function generates an unique stream-id by getting the upstream // stream-start event stream ID and appending @stream_id to it. If the // element has no sinkpad it will generate an upstream stream-id by // doing an URI query on the element and in the worst case just uses // a random number. Source elements that don't implement the URI // handler interface should ideally generate a unique, deterministic // stream-id manually instead. // // Since stream IDs are sorted alphabetically, any numbers in the // stream ID should be printed with a fixed number of characters, // preceded by 0's, such as by using the format \%03u instead of \%u. func (pad *PadInstance) CreateStreamID(parent Element, streamId string) string { var carg0 *C.GstPad // in, none, converted var carg1 *C.GstElement // in, none, converted var carg2 *C.gchar // in, none, string, nullable-string var cret *C.gchar // return, full, string carg0 = (*C.GstPad)(UnsafePadToGlibNone(pad)) carg1 = (*C.GstElement)(UnsafeElementToGlibNone(parent)) if streamId != "" { carg2 = (*C.gchar)(unsafe.Pointer(C.CString(streamId))) defer C.free(unsafe.Pointer(carg2)) } cret = C.gst_pad_create_stream_id(carg0, carg1, carg2) runtime.KeepAlive(pad) runtime.KeepAlive(parent) runtime.KeepAlive(streamId) var goret string goret = C.GoString((*C.char)(unsafe.Pointer(cret))) defer C.free(unsafe.Pointer(cret)) return goret } // EventDefault wraps gst_pad_event_default // // The function takes the following parameters: // // - parent Object (nullable): the parent of @pad or %NULL // - event *Event: the #GstEvent to handle. // // The function returns the following values: // // - goret bool // // Invokes the default event handler for the given pad. // // The EOS event will pause the task associated with @pad before it is forwarded // to all internally linked pads, // // The event is sent to all pads internally linked to @pad. This function // takes ownership of @event. func (pad *PadInstance) EventDefault(parent Object, event *Event) bool { var carg0 *C.GstPad // in, none, converted var carg1 *C.GstObject // in, none, converted, nullable var carg2 *C.GstEvent // in, full, converted var cret C.gboolean // return carg0 = (*C.GstPad)(UnsafePadToGlibNone(pad)) if parent != nil { carg1 = (*C.GstObject)(UnsafeObjectToGlibNone(parent)) } carg2 = (*C.GstEvent)(UnsafeEventToGlibFull(event)) cret = C.gst_pad_event_default(carg0, carg1, carg2) runtime.KeepAlive(pad) runtime.KeepAlive(parent) runtime.KeepAlive(event) var goret bool if cret != 0 { goret = true } return goret } // Forward wraps gst_pad_forward // // The function takes the following parameters: // // - forward PadForwardFunction: a #GstPadForwardFunction // // The function returns the following values: // // - goret bool // // Calls @forward for all internally linked pads of @pad. This function deals with // dynamically changing internal pads and will make sure that the @forward // function is only called once for each pad. // // When @forward returns %TRUE, no further pads will be processed. func (pad *PadInstance) Forward(forward PadForwardFunction) bool { var carg0 *C.GstPad // in, none, converted var carg1 C.GstPadForwardFunction // callback, scope: call, closure: carg2 var carg2 C.gpointer // implicit var cret C.gboolean // return carg0 = (*C.GstPad)(UnsafePadToGlibNone(pad)) carg1 = (*[0]byte)(C._gotk4_gst1_PadForwardFunction) carg2 = C.gpointer(userdata.Register(forward)) defer userdata.Delete(unsafe.Pointer(carg2)) cret = C.gst_pad_forward(carg0, carg1, carg2) runtime.KeepAlive(pad) runtime.KeepAlive(forward) var goret bool if cret != 0 { goret = true } return goret } // GetAllowedCaps wraps gst_pad_get_allowed_caps // // The function returns the following values: // // - goret *Caps (nullable) // // Gets the capabilities of the allowed media types that can flow through // @pad and its peer. // // The allowed capabilities is calculated as the intersection of the results of // calling gst_pad_query_caps() on @pad and its peer. The caller owns a reference // on the resulting caps. func (pad *PadInstance) GetAllowedCaps() *Caps { var carg0 *C.GstPad // in, none, converted var cret *C.GstCaps // return, full, converted, nullable carg0 = (*C.GstPad)(UnsafePadToGlibNone(pad)) cret = C.gst_pad_get_allowed_caps(carg0) runtime.KeepAlive(pad) var goret *Caps if cret != nil { goret = UnsafeCapsFromGlibFull(unsafe.Pointer(cret)) } return goret } // GetCurrentCaps wraps gst_pad_get_current_caps // // The function returns the following values: // // - goret *Caps (nullable) // // Gets the capabilities currently configured on @pad with the last // #GST_EVENT_CAPS event. func (pad *PadInstance) GetCurrentCaps() *Caps { var carg0 *C.GstPad // in, none, converted var cret *C.GstCaps // return, full, converted, nullable carg0 = (*C.GstPad)(UnsafePadToGlibNone(pad)) cret = C.gst_pad_get_current_caps(carg0) runtime.KeepAlive(pad) var goret *Caps if cret != nil { goret = UnsafeCapsFromGlibFull(unsafe.Pointer(cret)) } return goret } // GetDirection wraps gst_pad_get_direction // // The function returns the following values: // // - goret PadDirection // // Gets the direction of the pad. The direction of the pad is // decided at construction time so this function does not take // the LOCK. func (pad *PadInstance) GetDirection() PadDirection { var carg0 *C.GstPad // in, none, converted var cret C.GstPadDirection // return, none, casted carg0 = (*C.GstPad)(UnsafePadToGlibNone(pad)) cret = C.gst_pad_get_direction(carg0) runtime.KeepAlive(pad) var goret PadDirection goret = PadDirection(cret) return goret } // GetLastFlowReturn wraps gst_pad_get_last_flow_return // // The function returns the following values: // // - goret FlowReturn // // Gets the #GstFlowReturn return from the last data passed by this pad. func (pad *PadInstance) GetLastFlowReturn() FlowReturn { var carg0 *C.GstPad // in, none, converted var cret C.GstFlowReturn // return, none, casted carg0 = (*C.GstPad)(UnsafePadToGlibNone(pad)) cret = C.gst_pad_get_last_flow_return(carg0) runtime.KeepAlive(pad) var goret FlowReturn goret = FlowReturn(cret) return goret } // GetOffset wraps gst_pad_get_offset // // The function returns the following values: // // - goret int64 // // Get the offset applied to the running time of @pad. @pad has to be a source // pad. func (pad *PadInstance) GetOffset() int64 { var carg0 *C.GstPad // in, none, converted var cret C.gint64 // return, none, casted carg0 = (*C.GstPad)(UnsafePadToGlibNone(pad)) cret = C.gst_pad_get_offset(carg0) runtime.KeepAlive(pad) var goret int64 goret = int64(cret) return goret } // GetPadTemplate wraps gst_pad_get_pad_template // // The function returns the following values: // // - goret PadTemplate (nullable) // // Gets the template for @pad. func (pad *PadInstance) GetPadTemplate() PadTemplate { var carg0 *C.GstPad // in, none, converted var cret *C.GstPadTemplate // return, full, converted, nullable carg0 = (*C.GstPad)(UnsafePadToGlibNone(pad)) cret = C.gst_pad_get_pad_template(carg0) runtime.KeepAlive(pad) var goret PadTemplate if cret != nil { goret = UnsafePadTemplateFromGlibFull(unsafe.Pointer(cret)) } return goret } // GetPadTemplateCaps wraps gst_pad_get_pad_template_caps // // The function returns the following values: // // - goret *Caps // // Gets the capabilities for @pad's template. func (pad *PadInstance) GetPadTemplateCaps() *Caps { var carg0 *C.GstPad // in, none, converted var cret *C.GstCaps // return, full, converted carg0 = (*C.GstPad)(UnsafePadToGlibNone(pad)) cret = C.gst_pad_get_pad_template_caps(carg0) runtime.KeepAlive(pad) var goret *Caps goret = UnsafeCapsFromGlibFull(unsafe.Pointer(cret)) return goret } // GetParentElement wraps gst_pad_get_parent_element // // The function returns the following values: // // - goret Element (nullable) // // Gets the parent of @pad, cast to a #GstElement. If a @pad has no parent or // its parent is not an element, return %NULL. func (pad *PadInstance) GetParentElement() Element { var carg0 *C.GstPad // in, none, converted var cret *C.GstElement // return, full, converted, nullable carg0 = (*C.GstPad)(UnsafePadToGlibNone(pad)) cret = C.gst_pad_get_parent_element(carg0) runtime.KeepAlive(pad) var goret Element if cret != nil { goret = UnsafeElementFromGlibFull(unsafe.Pointer(cret)) } return goret } // GetPeer wraps gst_pad_get_peer // // The function returns the following values: // // - goret Pad (nullable) // // Gets the peer of @pad. This function refs the peer pad so // you need to unref it after use. func (pad *PadInstance) GetPeer() Pad { var carg0 *C.GstPad // in, none, converted var cret *C.GstPad // return, full, converted, nullable carg0 = (*C.GstPad)(UnsafePadToGlibNone(pad)) cret = C.gst_pad_get_peer(carg0) runtime.KeepAlive(pad) var goret Pad if cret != nil { goret = UnsafePadFromGlibFull(unsafe.Pointer(cret)) } return goret } // GetRange wraps gst_pad_get_range // // The function takes the following parameters: // // - offset uint64: The start offset of the buffer // - size uint: The length of the buffer // // The function returns the following values: // // - buffer *Buffer: a pointer to hold the #GstBuffer, // returns #GST_FLOW_ERROR if %NULL. // - goret FlowReturn // // When @pad is flushing this function returns #GST_FLOW_FLUSHING // immediately and @buffer is %NULL. // // Calls the getrange function of @pad, see #GstPadGetRangeFunction for a // description of a getrange function. If @pad has no getrange function // installed (see gst_pad_set_getrange_function()) this function returns // #GST_FLOW_NOT_SUPPORTED. // // If @buffer points to a variable holding %NULL, a valid new #GstBuffer will be // placed in @buffer when this function returns #GST_FLOW_OK. The new buffer // must be freed with gst_buffer_unref() after usage. // // When @buffer points to a variable that points to a valid #GstBuffer, the // buffer will be filled with the result data when this function returns // #GST_FLOW_OK. If the provided buffer is larger than @size, only // @size bytes will be filled in the result buffer and its size will be updated // accordingly. // // Note that less than @size bytes can be returned in @buffer when, for example, // an EOS condition is near or when @buffer is not large enough to hold @size // bytes. The caller should check the result buffer size to get the result size. // // When this function returns any other result value than #GST_FLOW_OK, @buffer // will be unchanged. // // This is a lowlevel function. Usually gst_pad_pull_range() is used. func (pad *PadInstance) GetRange(offset uint64, size uint) (*Buffer, FlowReturn) { var carg0 *C.GstPad // in, none, converted var carg1 C.guint64 // in, none, casted var carg2 C.guint // in, none, casted var carg3 *C.GstBuffer // out, full, converted var cret C.GstFlowReturn // return, none, casted carg0 = (*C.GstPad)(UnsafePadToGlibNone(pad)) carg1 = C.guint64(offset) carg2 = C.guint(size) cret = C.gst_pad_get_range(carg0, carg1, carg2, &carg3) runtime.KeepAlive(pad) runtime.KeepAlive(offset) runtime.KeepAlive(size) var buffer *Buffer var goret FlowReturn buffer = UnsafeBufferFromGlibFull(unsafe.Pointer(carg3)) goret = FlowReturn(cret) return buffer, goret } // GetSingleInternalLink wraps gst_pad_get_single_internal_link // // The function returns the following values: // // - goret Pad (nullable) // // If there is a single internal link of the given pad, this function will // return it. Otherwise, it will return NULL. func (pad *PadInstance) GetSingleInternalLink() Pad { var carg0 *C.GstPad // in, none, converted var cret *C.GstPad // return, full, converted, nullable carg0 = (*C.GstPad)(UnsafePadToGlibNone(pad)) cret = C.gst_pad_get_single_internal_link(carg0) runtime.KeepAlive(pad) var goret Pad if cret != nil { goret = UnsafePadFromGlibFull(unsafe.Pointer(cret)) } return goret } // GetStickyEvent wraps gst_pad_get_sticky_event // // The function takes the following parameters: // // - eventType EventType: the #GstEventType that should be retrieved. // - idx uint: the index of the event // // The function returns the following values: // // - goret *Event (nullable) // // Returns a new reference of the sticky event of type @event_type // from the event. func (pad *PadInstance) GetStickyEvent(eventType EventType, idx uint) *Event { var carg0 *C.GstPad // in, none, converted var carg1 C.GstEventType // in, none, casted var carg2 C.guint // in, none, casted var cret *C.GstEvent // return, full, converted, nullable carg0 = (*C.GstPad)(UnsafePadToGlibNone(pad)) carg1 = C.GstEventType(eventType) carg2 = C.guint(idx) cret = C.gst_pad_get_sticky_event(carg0, carg1, carg2) runtime.KeepAlive(pad) runtime.KeepAlive(eventType) runtime.KeepAlive(idx) var goret *Event if cret != nil { goret = UnsafeEventFromGlibFull(unsafe.Pointer(cret)) } return goret } // GetStream wraps gst_pad_get_stream // // The function returns the following values: // // - goret Stream (nullable) // // Returns the current #GstStream for the @pad, or %NULL if none has been // set yet, i.e. the pad has not received a stream-start event yet. // // This is a convenience wrapper around gst_pad_get_sticky_event() and // gst_event_parse_stream(). func (pad *PadInstance) GetStream() Stream { var carg0 *C.GstPad // in, none, converted var cret *C.GstStream // return, full, converted, nullable carg0 = (*C.GstPad)(UnsafePadToGlibNone(pad)) cret = C.gst_pad_get_stream(carg0) runtime.KeepAlive(pad) var goret Stream if cret != nil { goret = UnsafeStreamFromGlibFull(unsafe.Pointer(cret)) } return goret } // GetStreamID wraps gst_pad_get_stream_id // // The function returns the following values: // // - goret string (nullable) // // Returns the current stream-id for the @pad, or %NULL if none has been // set yet, i.e. the pad has not received a stream-start event yet. // // This is a convenience wrapper around gst_pad_get_sticky_event() and // gst_event_parse_stream_start(). // // The returned stream-id string should be treated as an opaque string, its // contents should not be interpreted. func (pad *PadInstance) GetStreamID() string { var carg0 *C.GstPad // in, none, converted var cret *C.gchar // return, full, string, nullable-string carg0 = (*C.GstPad)(UnsafePadToGlibNone(pad)) cret = C.gst_pad_get_stream_id(carg0) runtime.KeepAlive(pad) var goret string if cret != nil { goret = C.GoString((*C.char)(unsafe.Pointer(cret))) defer C.free(unsafe.Pointer(cret)) } return goret } // GetTaskState wraps gst_pad_get_task_state // // The function returns the following values: // // - goret TaskState // // Get @pad task state. If no task is currently // set, #GST_TASK_STOPPED is returned. func (pad *PadInstance) GetTaskState() TaskState { var carg0 *C.GstPad // in, none, converted var cret C.GstTaskState // return, none, casted carg0 = (*C.GstPad)(UnsafePadToGlibNone(pad)) cret = C.gst_pad_get_task_state(carg0) runtime.KeepAlive(pad) var goret TaskState goret = TaskState(cret) return goret } // HasCurrentCaps wraps gst_pad_has_current_caps // // The function returns the following values: // // - goret bool // // Check if @pad has caps set on it with a #GST_EVENT_CAPS event. func (pad *PadInstance) HasCurrentCaps() bool { var carg0 *C.GstPad // in, none, converted var cret C.gboolean // return carg0 = (*C.GstPad)(UnsafePadToGlibNone(pad)) cret = C.gst_pad_has_current_caps(carg0) runtime.KeepAlive(pad) var goret bool if cret != 0 { goret = true } return goret } // IsActive wraps gst_pad_is_active // // The function returns the following values: // // - goret bool // // Query if a pad is active func (pad *PadInstance) IsActive() bool { var carg0 *C.GstPad // in, none, converted var cret C.gboolean // return carg0 = (*C.GstPad)(UnsafePadToGlibNone(pad)) cret = C.gst_pad_is_active(carg0) runtime.KeepAlive(pad) var goret bool if cret != 0 { goret = true } return goret } // IsBlocked wraps gst_pad_is_blocked // // The function returns the following values: // // - goret bool // // Checks if the pad is blocked or not. This function returns the // last requested state of the pad. It is not certain that the pad // is actually blocking at this point (see gst_pad_is_blocking()). func (pad *PadInstance) IsBlocked() bool { var carg0 *C.GstPad // in, none, converted var cret C.gboolean // return carg0 = (*C.GstPad)(UnsafePadToGlibNone(pad)) cret = C.gst_pad_is_blocked(carg0) runtime.KeepAlive(pad) var goret bool if cret != 0 { goret = true } return goret } // IsBlocking wraps gst_pad_is_blocking // // The function returns the following values: // // - goret bool // // Checks if the pad is blocking or not. This is a guaranteed state // of whether the pad is actually blocking on a #GstBuffer or a #GstEvent. func (pad *PadInstance) IsBlocking() bool { var carg0 *C.GstPad // in, none, converted var cret C.gboolean // return carg0 = (*C.GstPad)(UnsafePadToGlibNone(pad)) cret = C.gst_pad_is_blocking(carg0) runtime.KeepAlive(pad) var goret bool if cret != 0 { goret = true } return goret } // IsLinked wraps gst_pad_is_linked // // The function returns the following values: // // - goret bool // // Checks if a @pad is linked to another pad or not. func (pad *PadInstance) IsLinked() bool { var carg0 *C.GstPad // in, none, converted var cret C.gboolean // return carg0 = (*C.GstPad)(UnsafePadToGlibNone(pad)) cret = C.gst_pad_is_linked(carg0) runtime.KeepAlive(pad) var goret bool if cret != 0 { goret = true } return goret } // IterateInternalLinks wraps gst_pad_iterate_internal_links // // The function returns the following values: // // - goret *Iterator (nullable) // // Gets an iterator for the pads to which the given pad is linked to inside // of the parent element. // // Each #GstPad element yielded by the iterator will have its refcount increased, // so unref after use. // // Free-function: gst_iterator_free func (pad *PadInstance) IterateInternalLinks() *Iterator { var carg0 *C.GstPad // in, none, converted var cret *C.GstIterator // return, full, converted, nullable carg0 = (*C.GstPad)(UnsafePadToGlibNone(pad)) cret = C.gst_pad_iterate_internal_links(carg0) runtime.KeepAlive(pad) var goret *Iterator if cret != nil { goret = UnsafeIteratorFromGlibFull(unsafe.Pointer(cret)) } return goret } // IterateInternalLinksDefault wraps gst_pad_iterate_internal_links_default // // The function takes the following parameters: // // - parent Object (nullable): the parent of @pad or %NULL // // The function returns the following values: // // - goret *Iterator (nullable) // // Iterate the list of pads to which the given pad is linked to inside of // the parent element. // This is the default handler, and thus returns an iterator of all of the // pads inside the parent element with opposite direction. // // The caller must free this iterator after use with gst_iterator_free(). func (pad *PadInstance) IterateInternalLinksDefault(parent Object) *Iterator { var carg0 *C.GstPad // in, none, converted var carg1 *C.GstObject // in, none, converted, nullable var cret *C.GstIterator // return, full, converted, nullable carg0 = (*C.GstPad)(UnsafePadToGlibNone(pad)) if parent != nil { carg1 = (*C.GstObject)(UnsafeObjectToGlibNone(parent)) } cret = C.gst_pad_iterate_internal_links_default(carg0, carg1) runtime.KeepAlive(pad) runtime.KeepAlive(parent) var goret *Iterator if cret != nil { goret = UnsafeIteratorFromGlibFull(unsafe.Pointer(cret)) } return goret } // Link wraps gst_pad_link // // The function takes the following parameters: // // - sinkpad Pad: the sink #GstPad to link. // // The function returns the following values: // // - goret PadLinkReturn // // Links the source pad and the sink pad. func (srcpad *PadInstance) Link(sinkpad Pad) PadLinkReturn { var carg0 *C.GstPad // in, none, converted var carg1 *C.GstPad // in, none, converted var cret C.GstPadLinkReturn // return, none, casted carg0 = (*C.GstPad)(UnsafePadToGlibNone(srcpad)) carg1 = (*C.GstPad)(UnsafePadToGlibNone(sinkpad)) cret = C.gst_pad_link(carg0, carg1) runtime.KeepAlive(srcpad) runtime.KeepAlive(sinkpad) var goret PadLinkReturn goret = PadLinkReturn(cret) return goret } // LinkFull wraps gst_pad_link_full // // The function takes the following parameters: // // - sinkpad Pad: the sink #GstPad to link. // - flags PadLinkCheck: the checks to validate when linking // // The function returns the following values: // // - goret PadLinkReturn // // Links the source pad and the sink pad. // // This variant of #gst_pad_link provides a more granular control on the // checks being done when linking. While providing some considerable speedups // the caller of this method must be aware that wrong usage of those flags // can cause severe issues. Refer to the documentation of #GstPadLinkCheck // for more information. // // MT Safe. func (srcpad *PadInstance) LinkFull(sinkpad Pad, flags PadLinkCheck) PadLinkReturn { var carg0 *C.GstPad // in, none, converted var carg1 *C.GstPad // in, none, converted var carg2 C.GstPadLinkCheck // in, none, casted var cret C.GstPadLinkReturn // return, none, casted carg0 = (*C.GstPad)(UnsafePadToGlibNone(srcpad)) carg1 = (*C.GstPad)(UnsafePadToGlibNone(sinkpad)) carg2 = C.GstPadLinkCheck(flags) cret = C.gst_pad_link_full(carg0, carg1, carg2) runtime.KeepAlive(srcpad) runtime.KeepAlive(sinkpad) runtime.KeepAlive(flags) var goret PadLinkReturn goret = PadLinkReturn(cret) return goret } // LinkMaybeGhosting wraps gst_pad_link_maybe_ghosting // // The function takes the following parameters: // // - sink Pad: a #GstPad // // The function returns the following values: // // - goret bool // // Links @src to @sink, creating any #GstGhostPad's in between as necessary. // // This is a convenience function to save having to create and add intermediate // #GstGhostPad's as required for linking across #GstBin boundaries. // // If @src or @sink pads don't have parent elements or do not share a common // ancestor, the link will fail. func (src *PadInstance) LinkMaybeGhosting(sink Pad) bool { var carg0 *C.GstPad // in, none, converted var carg1 *C.GstPad // in, none, converted var cret C.gboolean // return carg0 = (*C.GstPad)(UnsafePadToGlibNone(src)) carg1 = (*C.GstPad)(UnsafePadToGlibNone(sink)) cret = C.gst_pad_link_maybe_ghosting(carg0, carg1) runtime.KeepAlive(src) runtime.KeepAlive(sink) var goret bool if cret != 0 { goret = true } return goret } // LinkMaybeGhostingFull wraps gst_pad_link_maybe_ghosting_full // // The function takes the following parameters: // // - sink Pad: a #GstPad // - flags PadLinkCheck: some #GstPadLinkCheck flags // // The function returns the following values: // // - goret bool // // Links @src to @sink, creating any #GstGhostPad's in between as necessary. // // This is a convenience function to save having to create and add intermediate // #GstGhostPad's as required for linking across #GstBin boundaries. // // If @src or @sink pads don't have parent elements or do not share a common // ancestor, the link will fail. // // Calling gst_pad_link_maybe_ghosting_full() with // @flags == %GST_PAD_LINK_CHECK_DEFAULT is the recommended way of linking // pads with safety checks applied. func (src *PadInstance) LinkMaybeGhostingFull(sink Pad, flags PadLinkCheck) bool { var carg0 *C.GstPad // in, none, converted var carg1 *C.GstPad // in, none, converted var carg2 C.GstPadLinkCheck // in, none, casted var cret C.gboolean // return carg0 = (*C.GstPad)(UnsafePadToGlibNone(src)) carg1 = (*C.GstPad)(UnsafePadToGlibNone(sink)) carg2 = C.GstPadLinkCheck(flags) cret = C.gst_pad_link_maybe_ghosting_full(carg0, carg1, carg2) runtime.KeepAlive(src) runtime.KeepAlive(sink) runtime.KeepAlive(flags) var goret bool if cret != 0 { goret = true } return goret } // MarkReconfigure wraps gst_pad_mark_reconfigure // // Mark a pad for needing reconfiguration. The next call to // gst_pad_check_reconfigure() will return %TRUE after this call. func (pad *PadInstance) MarkReconfigure() { var carg0 *C.GstPad // in, none, converted carg0 = (*C.GstPad)(UnsafePadToGlibNone(pad)) C.gst_pad_mark_reconfigure(carg0) runtime.KeepAlive(pad) } // NeedsReconfigure wraps gst_pad_needs_reconfigure // // The function returns the following values: // // - goret bool // // Check the #GST_PAD_FLAG_NEED_RECONFIGURE flag on @pad and return %TRUE // if the flag was set. func (pad *PadInstance) NeedsReconfigure() bool { var carg0 *C.GstPad // in, none, converted var cret C.gboolean // return carg0 = (*C.GstPad)(UnsafePadToGlibNone(pad)) cret = C.gst_pad_needs_reconfigure(carg0) runtime.KeepAlive(pad) var goret bool if cret != 0 { goret = true } return goret } // PauseTask wraps gst_pad_pause_task // // The function returns the following values: // // - goret bool // // Pause the task of @pad. This function will also wait until the // function executed by the task is finished if this function is not // called from the task function. func (pad *PadInstance) PauseTask() bool { var carg0 *C.GstPad // in, none, converted var cret C.gboolean // return carg0 = (*C.GstPad)(UnsafePadToGlibNone(pad)) cret = C.gst_pad_pause_task(carg0) runtime.KeepAlive(pad) var goret bool if cret != 0 { goret = true } return goret } // PeerQuery wraps gst_pad_peer_query // // The function takes the following parameters: // // - query *Query: the #GstQuery to perform. // // The function returns the following values: // // - goret bool // // Performs gst_pad_query() on the peer of @pad. // // The caller is responsible for both the allocation and deallocation of // the query structure. func (pad *PadInstance) PeerQuery(query *Query) bool { var carg0 *C.GstPad // in, none, converted var carg1 *C.GstQuery // in, none, converted var cret C.gboolean // return carg0 = (*C.GstPad)(UnsafePadToGlibNone(pad)) carg1 = (*C.GstQuery)(UnsafeQueryToGlibNone(query)) cret = C.gst_pad_peer_query(carg0, carg1) runtime.KeepAlive(pad) runtime.KeepAlive(query) var goret bool if cret != 0 { goret = true } return goret } // PeerQueryAcceptCaps wraps gst_pad_peer_query_accept_caps // // The function takes the following parameters: // // - caps *Caps: a #GstCaps to check on the pad // // The function returns the following values: // // - goret bool // // Check if the peer of @pad accepts @caps. If @pad has no peer, this function // returns %TRUE. func (pad *PadInstance) PeerQueryAcceptCaps(caps *Caps) bool { var carg0 *C.GstPad // in, none, converted var carg1 *C.GstCaps // in, none, converted var cret C.gboolean // return carg0 = (*C.GstPad)(UnsafePadToGlibNone(pad)) carg1 = (*C.GstCaps)(UnsafeCapsToGlibNone(caps)) cret = C.gst_pad_peer_query_accept_caps(carg0, carg1) runtime.KeepAlive(pad) runtime.KeepAlive(caps) var goret bool if cret != 0 { goret = true } return goret } // PeerQueryCaps wraps gst_pad_peer_query_caps // // The function takes the following parameters: // // - filter *Caps (nullable): a #GstCaps filter, or %NULL. // // The function returns the following values: // // - goret *Caps // // Gets the capabilities of the peer connected to this pad. Similar to // gst_pad_query_caps(). // // When called on srcpads @filter contains the caps that // upstream could produce in the order preferred by upstream. When // called on sinkpads @filter contains the caps accepted by // downstream in the preferred order. @filter might be %NULL but // if it is not %NULL the returned caps will be a subset of @filter. func (pad *PadInstance) PeerQueryCaps(filter *Caps) *Caps { var carg0 *C.GstPad // in, none, converted var carg1 *C.GstCaps // in, none, converted, nullable var cret *C.GstCaps // return, full, converted carg0 = (*C.GstPad)(UnsafePadToGlibNone(pad)) if filter != nil { carg1 = (*C.GstCaps)(UnsafeCapsToGlibNone(filter)) } cret = C.gst_pad_peer_query_caps(carg0, carg1) runtime.KeepAlive(pad) runtime.KeepAlive(filter) var goret *Caps goret = UnsafeCapsFromGlibFull(unsafe.Pointer(cret)) return goret } // PeerQueryConvert wraps gst_pad_peer_query_convert // // The function takes the following parameters: // // - srcFormat Format: a #GstFormat to convert from. // - srcVal int64: a value to convert. // - destFormat Format: the #GstFormat to convert to. // // The function returns the following values: // // - destVal int64: a pointer to the result. // - goret bool // // Queries the peer pad of a given sink pad to convert @src_val in @src_format // to @dest_format. func (pad *PadInstance) PeerQueryConvert(srcFormat Format, srcVal int64, destFormat Format) (int64, bool) { var carg0 *C.GstPad // in, none, converted var carg1 C.GstFormat // in, none, casted var carg2 C.gint64 // in, none, casted var carg3 C.GstFormat // in, none, casted var carg4 C.gint64 // out, full, casted var cret C.gboolean // return carg0 = (*C.GstPad)(UnsafePadToGlibNone(pad)) carg1 = C.GstFormat(srcFormat) carg2 = C.gint64(srcVal) carg3 = C.GstFormat(destFormat) cret = C.gst_pad_peer_query_convert(carg0, carg1, carg2, carg3, &carg4) runtime.KeepAlive(pad) runtime.KeepAlive(srcFormat) runtime.KeepAlive(srcVal) runtime.KeepAlive(destFormat) var destVal int64 var goret bool destVal = int64(carg4) if cret != 0 { goret = true } return destVal, goret } // PeerQueryDuration wraps gst_pad_peer_query_duration // // The function takes the following parameters: // // - format Format: the #GstFormat requested // // The function returns the following values: // // - duration int64: a location in which to store the total // duration, or %NULL. // - goret bool // // Queries the peer pad of a given sink pad for the total stream duration. func (pad *PadInstance) PeerQueryDuration(format Format) (int64, bool) { var carg0 *C.GstPad // in, none, converted var carg1 C.GstFormat // in, none, casted var carg2 C.gint64 // out, full, casted var cret C.gboolean // return carg0 = (*C.GstPad)(UnsafePadToGlibNone(pad)) carg1 = C.GstFormat(format) cret = C.gst_pad_peer_query_duration(carg0, carg1, &carg2) runtime.KeepAlive(pad) runtime.KeepAlive(format) var duration int64 var goret bool duration = int64(carg2) if cret != 0 { goret = true } return duration, goret } // PeerQueryPosition wraps gst_pad_peer_query_position // // The function takes the following parameters: // // - format Format: the #GstFormat requested // // The function returns the following values: // // - cur int64: a location in which to store the current // position, or %NULL. // - goret bool // // Queries the peer of a given sink pad for the stream position. func (pad *PadInstance) PeerQueryPosition(format Format) (int64, bool) { var carg0 *C.GstPad // in, none, converted var carg1 C.GstFormat // in, none, casted var carg2 C.gint64 // out, full, casted var cret C.gboolean // return carg0 = (*C.GstPad)(UnsafePadToGlibNone(pad)) carg1 = C.GstFormat(format) cret = C.gst_pad_peer_query_position(carg0, carg1, &carg2) runtime.KeepAlive(pad) runtime.KeepAlive(format) var cur int64 var goret bool cur = int64(carg2) if cret != 0 { goret = true } return cur, goret } // ProxyQueryAcceptCaps wraps gst_pad_proxy_query_accept_caps // // The function takes the following parameters: // // - query *Query: an ACCEPT_CAPS #GstQuery. // // The function returns the following values: // // - goret bool // // Checks if all internally linked pads of @pad accepts the caps in @query and // returns the intersection of the results. // // This function is useful as a default accept caps query function for an element // that can handle any stream format, but requires caps that are acceptable for // all opposite pads. func (pad *PadInstance) ProxyQueryAcceptCaps(query *Query) bool { var carg0 *C.GstPad // in, none, converted var carg1 *C.GstQuery // in, none, converted var cret C.gboolean // return carg0 = (*C.GstPad)(UnsafePadToGlibNone(pad)) carg1 = (*C.GstQuery)(UnsafeQueryToGlibNone(query)) cret = C.gst_pad_proxy_query_accept_caps(carg0, carg1) runtime.KeepAlive(pad) runtime.KeepAlive(query) var goret bool if cret != 0 { goret = true } return goret } // ProxyQueryCaps wraps gst_pad_proxy_query_caps // // The function takes the following parameters: // // - query *Query: a CAPS #GstQuery. // // The function returns the following values: // // - goret bool // // Calls gst_pad_query_caps() for all internally linked pads of @pad and returns // the intersection of the results. // // This function is useful as a default caps query function for an element // that can handle any stream format, but requires all its pads to have // the same caps. Two such elements are tee and adder. func (pad *PadInstance) ProxyQueryCaps(query *Query) bool { var carg0 *C.GstPad // in, none, converted var carg1 *C.GstQuery // in, none, converted var cret C.gboolean // return carg0 = (*C.GstPad)(UnsafePadToGlibNone(pad)) carg1 = (*C.GstQuery)(UnsafeQueryToGlibNone(query)) cret = C.gst_pad_proxy_query_caps(carg0, carg1) runtime.KeepAlive(pad) runtime.KeepAlive(query) var goret bool if cret != 0 { goret = true } return goret } // PullRange wraps gst_pad_pull_range // // The function takes the following parameters: // // - offset uint64: The start offset of the buffer // - size uint: The length of the buffer // // The function returns the following values: // // - buffer *Buffer: a pointer to hold the #GstBuffer, returns // GST_FLOW_ERROR if %NULL. // - goret FlowReturn // // Pulls a @buffer from the peer pad or fills up a provided buffer. // // This function will first trigger the pad block signal if it was // installed. // // When @pad is not linked #GST_FLOW_NOT_LINKED is returned else this // function returns the result of gst_pad_get_range() on the peer pad. // See gst_pad_get_range() for a list of return values and for the // semantics of the arguments of this function. // // If @buffer points to a variable holding %NULL, a valid new #GstBuffer will be // placed in @buffer when this function returns #GST_FLOW_OK. The new buffer // must be freed with gst_buffer_unref() after usage. When this function // returns any other result value, @buffer will still point to %NULL. // // When @buffer points to a variable that points to a valid #GstBuffer, the // buffer will be filled with the result data when this function returns // #GST_FLOW_OK. When this function returns any other result value, // @buffer will be unchanged. If the provided buffer is larger than @size, only // @size bytes will be filled in the result buffer and its size will be updated // accordingly. // // Note that less than @size bytes can be returned in @buffer when, for example, // an EOS condition is near or when @buffer is not large enough to hold @size // bytes. The caller should check the result buffer size to get the result size. func (pad *PadInstance) PullRange(offset uint64, size uint) (*Buffer, FlowReturn) { var carg0 *C.GstPad // in, none, converted var carg1 C.guint64 // in, none, casted var carg2 C.guint // in, none, casted var carg3 *C.GstBuffer // out, full, converted var cret C.GstFlowReturn // return, none, casted carg0 = (*C.GstPad)(UnsafePadToGlibNone(pad)) carg1 = C.guint64(offset) carg2 = C.guint(size) cret = C.gst_pad_pull_range(carg0, carg1, carg2, &carg3) runtime.KeepAlive(pad) runtime.KeepAlive(offset) runtime.KeepAlive(size) var buffer *Buffer var goret FlowReturn buffer = UnsafeBufferFromGlibFull(unsafe.Pointer(carg3)) goret = FlowReturn(cret) return buffer, goret } // Push wraps gst_pad_push // // The function takes the following parameters: // // - buffer *Buffer: the #GstBuffer to push returns GST_FLOW_ERROR // if not. // // The function returns the following values: // // - goret FlowReturn // // Pushes a buffer to the peer of @pad. // // This function will call installed block probes before triggering any // installed data probes. // // The function proceeds calling gst_pad_chain() on the peer pad and returns // the value from that function. If @pad has no peer, #GST_FLOW_NOT_LINKED will // be returned. // // In all cases, success or failure, the caller loses its reference to @buffer // after calling this function. func (pad *PadInstance) Push(buffer *Buffer) FlowReturn { var carg0 *C.GstPad // in, none, converted var carg1 *C.GstBuffer // in, full, converted var cret C.GstFlowReturn // return, none, casted carg0 = (*C.GstPad)(UnsafePadToGlibNone(pad)) carg1 = (*C.GstBuffer)(UnsafeBufferToGlibFull(buffer)) cret = C.gst_pad_push(carg0, carg1) runtime.KeepAlive(pad) runtime.KeepAlive(buffer) var goret FlowReturn goret = FlowReturn(cret) return goret } // PushEvent wraps gst_pad_push_event // // The function takes the following parameters: // // - event *Event: the #GstEvent to send to the pad. // // The function returns the following values: // // - goret bool // // Sends the event to the peer of the given pad. This function is // mainly used by elements to send events to their peer // elements. // // This function takes ownership of the provided event so you should // gst_event_ref() it if you want to reuse the event after this call. func (pad *PadInstance) PushEvent(event *Event) bool { var carg0 *C.GstPad // in, none, converted var carg1 *C.GstEvent // in, full, converted var cret C.gboolean // return carg0 = (*C.GstPad)(UnsafePadToGlibNone(pad)) carg1 = (*C.GstEvent)(UnsafeEventToGlibFull(event)) cret = C.gst_pad_push_event(carg0, carg1) runtime.KeepAlive(pad) runtime.KeepAlive(event) var goret bool if cret != 0 { goret = true } return goret } // PushList wraps gst_pad_push_list // // The function takes the following parameters: // // - list *BufferList: the #GstBufferList to push returns GST_FLOW_ERROR // if not. // // The function returns the following values: // // - goret FlowReturn // // Pushes a buffer list to the peer of @pad. // // This function will call installed block probes before triggering any // installed data probes. // // The function proceeds calling the chain function on the peer pad and returns // the value from that function. If @pad has no peer, #GST_FLOW_NOT_LINKED will // be returned. If the peer pad does not have any installed chainlist function // every group buffer of the list will be merged into a normal #GstBuffer and // chained via gst_pad_chain(). // // In all cases, success or failure, the caller loses its reference to @list // after calling this function. func (pad *PadInstance) PushList(list *BufferList) FlowReturn { var carg0 *C.GstPad // in, none, converted var carg1 *C.GstBufferList // in, full, converted var cret C.GstFlowReturn // return, none, casted carg0 = (*C.GstPad)(UnsafePadToGlibNone(pad)) carg1 = (*C.GstBufferList)(UnsafeBufferListToGlibFull(list)) cret = C.gst_pad_push_list(carg0, carg1) runtime.KeepAlive(pad) runtime.KeepAlive(list) var goret FlowReturn goret = FlowReturn(cret) return goret } // Query wraps gst_pad_query // // The function takes the following parameters: // // - query *Query: the #GstQuery to perform. // // The function returns the following values: // // - goret bool // // Dispatches a query to a pad. The query should have been allocated by the // caller via one of the type-specific allocation functions. The element that // the pad belongs to is responsible for filling the query with an appropriate // response, which should then be parsed with a type-specific query parsing // function. // // Again, the caller is responsible for both the allocation and deallocation of // the query structure. // // Please also note that some queries might need a running pipeline to work. func (pad *PadInstance) Query(query *Query) bool { var carg0 *C.GstPad // in, none, converted var carg1 *C.GstQuery // in, none, converted var cret C.gboolean // return carg0 = (*C.GstPad)(UnsafePadToGlibNone(pad)) carg1 = (*C.GstQuery)(UnsafeQueryToGlibNone(query)) cret = C.gst_pad_query(carg0, carg1) runtime.KeepAlive(pad) runtime.KeepAlive(query) var goret bool if cret != 0 { goret = true } return goret } // QueryAcceptCaps wraps gst_pad_query_accept_caps // // The function takes the following parameters: // // - caps *Caps: a #GstCaps to check on the pad // // The function returns the following values: // // - goret bool // // Check if the given pad accepts the caps. func (pad *PadInstance) QueryAcceptCaps(caps *Caps) bool { var carg0 *C.GstPad // in, none, converted var carg1 *C.GstCaps // in, none, converted var cret C.gboolean // return carg0 = (*C.GstPad)(UnsafePadToGlibNone(pad)) carg1 = (*C.GstCaps)(UnsafeCapsToGlibNone(caps)) cret = C.gst_pad_query_accept_caps(carg0, carg1) runtime.KeepAlive(pad) runtime.KeepAlive(caps) var goret bool if cret != 0 { goret = true } return goret } // QueryCaps wraps gst_pad_query_caps // // The function takes the following parameters: // // - filter *Caps (nullable): suggested #GstCaps, or %NULL // // The function returns the following values: // // - goret *Caps // // Gets the capabilities this pad can produce or consume. // Note that this method doesn't necessarily return the caps set by sending a // gst_event_new_caps() - use gst_pad_get_current_caps() for that instead. // gst_pad_query_caps returns all possible caps a pad can operate with, using // the pad's CAPS query function, If the query fails, this function will return // @filter, if not %NULL, otherwise ANY. // // When called on sinkpads @filter contains the caps that // upstream could produce in the order preferred by upstream. When // called on srcpads @filter contains the caps accepted by // downstream in the preferred order. @filter might be %NULL but // if it is not %NULL the returned caps will be a subset of @filter. // // Note that this function does not return writable #GstCaps, use // gst_caps_make_writable() before modifying the caps. func (pad *PadInstance) QueryCaps(filter *Caps) *Caps { var carg0 *C.GstPad // in, none, converted var carg1 *C.GstCaps // in, none, converted, nullable var cret *C.GstCaps // return, full, converted carg0 = (*C.GstPad)(UnsafePadToGlibNone(pad)) if filter != nil { carg1 = (*C.GstCaps)(UnsafeCapsToGlibNone(filter)) } cret = C.gst_pad_query_caps(carg0, carg1) runtime.KeepAlive(pad) runtime.KeepAlive(filter) var goret *Caps goret = UnsafeCapsFromGlibFull(unsafe.Pointer(cret)) return goret } // QueryConvert wraps gst_pad_query_convert // // The function takes the following parameters: // // - srcFormat Format: a #GstFormat to convert from. // - srcVal int64: a value to convert. // - destFormat Format: the #GstFormat to convert to. // // The function returns the following values: // // - destVal int64: a pointer to the result. // - goret bool // // Queries a pad to convert @src_val in @src_format to @dest_format. func (pad *PadInstance) QueryConvert(srcFormat Format, srcVal int64, destFormat Format) (int64, bool) { var carg0 *C.GstPad // in, none, converted var carg1 C.GstFormat // in, none, casted var carg2 C.gint64 // in, none, casted var carg3 C.GstFormat // in, none, casted var carg4 C.gint64 // out, full, casted var cret C.gboolean // return carg0 = (*C.GstPad)(UnsafePadToGlibNone(pad)) carg1 = C.GstFormat(srcFormat) carg2 = C.gint64(srcVal) carg3 = C.GstFormat(destFormat) cret = C.gst_pad_query_convert(carg0, carg1, carg2, carg3, &carg4) runtime.KeepAlive(pad) runtime.KeepAlive(srcFormat) runtime.KeepAlive(srcVal) runtime.KeepAlive(destFormat) var destVal int64 var goret bool destVal = int64(carg4) if cret != 0 { goret = true } return destVal, goret } // QueryDefault wraps gst_pad_query_default // // The function takes the following parameters: // // - parent Object (nullable): the parent of @pad or %NULL // - query *Query: the #GstQuery to handle. // // The function returns the following values: // // - goret bool // // Invokes the default query handler for the given pad. // The query is sent to all pads internally linked to @pad. Note that // if there are many possible sink pads that are internally linked to // @pad, only one will be sent the query. // Multi-sinkpad elements should implement custom query handlers. func (pad *PadInstance) QueryDefault(parent Object, query *Query) bool { var carg0 *C.GstPad // in, none, converted var carg1 *C.GstObject // in, none, converted, nullable var carg2 *C.GstQuery // in, none, converted var cret C.gboolean // return carg0 = (*C.GstPad)(UnsafePadToGlibNone(pad)) if parent != nil { carg1 = (*C.GstObject)(UnsafeObjectToGlibNone(parent)) } carg2 = (*C.GstQuery)(UnsafeQueryToGlibNone(query)) cret = C.gst_pad_query_default(carg0, carg1, carg2) runtime.KeepAlive(pad) runtime.KeepAlive(parent) runtime.KeepAlive(query) var goret bool if cret != 0 { goret = true } return goret } // QueryDuration wraps gst_pad_query_duration // // The function takes the following parameters: // // - format Format: the #GstFormat requested // // The function returns the following values: // // - duration int64: a location in which to store the total // duration, or %NULL. // - goret bool // // Queries a pad for the total stream duration. func (pad *PadInstance) QueryDuration(format Format) (int64, bool) { var carg0 *C.GstPad // in, none, converted var carg1 C.GstFormat // in, none, casted var carg2 C.gint64 // out, full, casted var cret C.gboolean // return carg0 = (*C.GstPad)(UnsafePadToGlibNone(pad)) carg1 = C.GstFormat(format) cret = C.gst_pad_query_duration(carg0, carg1, &carg2) runtime.KeepAlive(pad) runtime.KeepAlive(format) var duration int64 var goret bool duration = int64(carg2) if cret != 0 { goret = true } return duration, goret } // QueryPosition wraps gst_pad_query_position // // The function takes the following parameters: // // - format Format: the #GstFormat requested // // The function returns the following values: // // - cur int64: A location in which to store the current position, or %NULL. // - goret bool // // Queries a pad for the stream position. func (pad *PadInstance) QueryPosition(format Format) (int64, bool) { var carg0 *C.GstPad // in, none, converted var carg1 C.GstFormat // in, none, casted var carg2 C.gint64 // out, full, casted var cret C.gboolean // return carg0 = (*C.GstPad)(UnsafePadToGlibNone(pad)) carg1 = C.GstFormat(format) cret = C.gst_pad_query_position(carg0, carg1, &carg2) runtime.KeepAlive(pad) runtime.KeepAlive(format) var cur int64 var goret bool cur = int64(carg2) if cret != 0 { goret = true } return cur, goret } // RemoveProbe wraps gst_pad_remove_probe // // The function takes the following parameters: // // - id uint32: the probe id to remove // // Remove the probe with @id from @pad. // // MT safe. func (pad *PadInstance) RemoveProbe(id uint32) { var carg0 *C.GstPad // in, none, converted var carg1 C.gulong // in, none, casted carg0 = (*C.GstPad)(UnsafePadToGlibNone(pad)) carg1 = C.gulong(id) C.gst_pad_remove_probe(carg0, carg1) runtime.KeepAlive(pad) runtime.KeepAlive(id) } // SendEvent wraps gst_pad_send_event // // The function takes the following parameters: // // - event *Event: the #GstEvent to send to the pad. // // The function returns the following values: // // - goret bool // // Sends the event to the pad. This function can be used // by applications to send events in the pipeline. // // If @pad is a source pad, @event should be an upstream event. If @pad is a // sink pad, @event should be a downstream event. For example, you would not // send a #GST_EVENT_EOS on a src pad; EOS events only propagate downstream. // Furthermore, some downstream events have to be serialized with data flow, // like EOS, while some can travel out-of-band, like #GST_EVENT_FLUSH_START. If // the event needs to be serialized with data flow, this function will take the // pad's stream lock while calling its event function. // // To find out whether an event type is upstream, downstream, or downstream and // serialized, see #GstEventTypeFlags, gst_event_type_get_flags(), // #GST_EVENT_IS_UPSTREAM, #GST_EVENT_IS_DOWNSTREAM, and // #GST_EVENT_IS_SERIALIZED. Note that in practice that an application or // plugin doesn't need to bother itself with this information; the core handles // all necessary locks and checks. // // This function takes ownership of the provided event so you should // gst_event_ref() it if you want to reuse the event after this call. func (pad *PadInstance) SendEvent(event *Event) bool { var carg0 *C.GstPad // in, none, converted var carg1 *C.GstEvent // in, full, converted var cret C.gboolean // return carg0 = (*C.GstPad)(UnsafePadToGlibNone(pad)) carg1 = (*C.GstEvent)(UnsafeEventToGlibFull(event)) cret = C.gst_pad_send_event(carg0, carg1) runtime.KeepAlive(pad) runtime.KeepAlive(event) var goret bool if cret != 0 { goret = true } return goret } // SetActive wraps gst_pad_set_active // // The function takes the following parameters: // // - active bool: whether or not the pad should be active. // // The function returns the following values: // // - goret bool // // Activates or deactivates the given pad. // Normally called from within core state change functions. // // If @active, makes sure the pad is active. If it is already active, either in // push or pull mode, just return. Otherwise dispatches to the pad's activate // function to perform the actual activation. // // If not @active, calls gst_pad_activate_mode() with the pad's current mode // and a %FALSE argument. func (pad *PadInstance) SetActive(active bool) bool { var carg0 *C.GstPad // in, none, converted var carg1 C.gboolean // in var cret C.gboolean // return carg0 = (*C.GstPad)(UnsafePadToGlibNone(pad)) if active { carg1 = C.TRUE } cret = C.gst_pad_set_active(carg0, carg1) runtime.KeepAlive(pad) runtime.KeepAlive(active) var goret bool if cret != 0 { goret = true } return goret } // SetOffset wraps gst_pad_set_offset // // The function takes the following parameters: // // - offset int64: the offset // // Set the offset that will be applied to the running time of @pad. func (pad *PadInstance) SetOffset(offset int64) { var carg0 *C.GstPad // in, none, converted var carg1 C.gint64 // in, none, casted carg0 = (*C.GstPad)(UnsafePadToGlibNone(pad)) carg1 = C.gint64(offset) C.gst_pad_set_offset(carg0, carg1) runtime.KeepAlive(pad) runtime.KeepAlive(offset) } // StartTask wraps gst_pad_start_task // // The function takes the following parameters: // // - fn TaskFunction: the task function to call // // The function returns the following values: // // - goret bool // // Starts a task that repeatedly calls @func with @user_data. This function // is mostly used in pad activation functions to start the dataflow. // The #GST_PAD_STREAM_LOCK of @pad will automatically be acquired // before @func is called. func (pad *PadInstance) StartTask(fn TaskFunction) bool { var carg0 *C.GstPad // in, none, converted var carg1 C.GstTaskFunction // callback, scope: notified, closure: carg2, destroy: carg3 var carg2 C.gpointer // implicit var carg3 C.GDestroyNotify // implicit var cret C.gboolean // return carg0 = (*C.GstPad)(UnsafePadToGlibNone(pad)) carg1 = (*[0]byte)(C._gotk4_gst1_TaskFunction) carg2 = C.gpointer(userdata.Register(fn)) carg3 = (C.GDestroyNotify)((*[0]byte)(C.destroyUserdata)) cret = C.gst_pad_start_task(carg0, carg1, carg2, carg3) runtime.KeepAlive(pad) runtime.KeepAlive(fn) var goret bool if cret != 0 { goret = true } return goret } // StopTask wraps gst_pad_stop_task // // The function returns the following values: // // - goret bool // // Stop the task of @pad. This function will also make sure that the // function executed by the task will effectively stop if not called // from the GstTaskFunction. // // This function will deadlock if called from the GstTaskFunction of // the task. Use gst_task_pause() instead. // // Regardless of whether the pad has a task, the stream lock is acquired and // released so as to ensure that streaming through this pad has finished. func (pad *PadInstance) StopTask() bool { var carg0 *C.GstPad // in, none, converted var cret C.gboolean // return carg0 = (*C.GstPad)(UnsafePadToGlibNone(pad)) cret = C.gst_pad_stop_task(carg0) runtime.KeepAlive(pad) var goret bool if cret != 0 { goret = true } return goret } // StoreStickyEvent wraps gst_pad_store_sticky_event // // The function takes the following parameters: // // - event *Event: a #GstEvent // // The function returns the following values: // // - goret FlowReturn // // Store the sticky @event on @pad func (pad *PadInstance) StoreStickyEvent(event *Event) FlowReturn { var carg0 *C.GstPad // in, none, converted var carg1 *C.GstEvent // in, none, converted var cret C.GstFlowReturn // return, none, casted carg0 = (*C.GstPad)(UnsafePadToGlibNone(pad)) carg1 = (*C.GstEvent)(UnsafeEventToGlibNone(event)) cret = C.gst_pad_store_sticky_event(carg0, carg1) runtime.KeepAlive(pad) runtime.KeepAlive(event) var goret FlowReturn goret = FlowReturn(cret) return goret } // Unlink wraps gst_pad_unlink // // The function takes the following parameters: // // - sinkpad Pad: the sink #GstPad to unlink. // // The function returns the following values: // // - goret bool // // Unlinks the source pad from the sink pad. Will emit the #GstPad::unlinked // signal on both pads. func (srcpad *PadInstance) Unlink(sinkpad Pad) bool { var carg0 *C.GstPad // in, none, converted var carg1 *C.GstPad // in, none, converted var cret C.gboolean // return carg0 = (*C.GstPad)(UnsafePadToGlibNone(srcpad)) carg1 = (*C.GstPad)(UnsafePadToGlibNone(sinkpad)) cret = C.gst_pad_unlink(carg0, carg1) runtime.KeepAlive(srcpad) runtime.KeepAlive(sinkpad) var goret bool if cret != 0 { goret = true } return goret } // UseFixedCaps wraps gst_pad_use_fixed_caps // // A helper function you can use that sets the FIXED_CAPS flag // This way the default CAPS query will always return the negotiated caps // or in case the pad is not negotiated, the padtemplate caps. // // The negotiated caps are the caps of the last CAPS event that passed on the // pad. Use this function on a pad that, once it negotiated to a CAPS, cannot // be renegotiated to something else. func (pad *PadInstance) UseFixedCaps() { var carg0 *C.GstPad // in, none, converted carg0 = (*C.GstPad)(UnsafePadToGlibNone(pad)) C.gst_pad_use_fixed_caps(carg0) runtime.KeepAlive(pad) } // ConnectLinked connects the provided callback to the "linked" signal // // Signals that a pad has been linked to the peer pad. 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 ObjectInstance } var _ PadTemplate = (*PadTemplateInstance)(nil) // PadTemplate wraps GstPadTemplate // // Padtemplates describe the possible media types a pad or an elementfactory can // handle. This allows for both inspection of handled types before loading the // element plugin as well as identifying pads on elements that are not yet // created (request or sometimes pads). // // Pad and PadTemplates have #GstCaps attached to it to describe the media type // they are capable of dealing with. gst_pad_template_get_caps() or // GST_PAD_TEMPLATE_CAPS() are used to get the caps of a padtemplate. It's not // possible to modify the caps of a padtemplate after creation. // // PadTemplates have a #GstPadPresence property which identifies the lifetime // of the pad and that can be retrieved with GST_PAD_TEMPLATE_PRESENCE(). Also // the direction of the pad can be retrieved from the #GstPadTemplate with // GST_PAD_TEMPLATE_DIRECTION(). // // The GST_PAD_TEMPLATE_NAME_TEMPLATE () is important for GST_PAD_REQUEST pads // because it has to be used as the name in the gst_element_request_pad_simple() // call to instantiate a pad from this template. // // Padtemplates can be created with gst_pad_template_new() or with // gst_static_pad_template_get (), which creates a #GstPadTemplate from a // #GstStaticPadTemplate that can be filled with the // convenient GST_STATIC_PAD_TEMPLATE() macro. // // A padtemplate can be used to create a pad (see gst_pad_new_from_template() // or gst_pad_new_from_static_template ()) or to add to an element class // (see gst_element_class_add_static_pad_template ()). // // The following code example shows the code to create a pad from a padtemplate. // |[<!-- language="C" --> // GstStaticPadTemplate my_template = // GST_STATIC_PAD_TEMPLATE ( // "sink", // the name of the pad // GST_PAD_SINK, // the direction of the pad // GST_PAD_ALWAYS, // when this pad will be present // GST_STATIC_CAPS ( // the capabilities of the padtemplate // "audio/x-raw, " // "channels = (int) [ 1, 6 ]" // ) // ); // void // my_method (void) // { // GstPad *pad; // pad = gst_pad_new_from_static_template (&my_template, "sink"); // ... // } // ]| // // The following example shows you how to add the padtemplate to an // element class, this is usually done in the class_init of the class: // |[<!-- language="C" --> // static void // my_element_class_init (GstMyElementClass *klass) // { // GstElementClass *gstelement_class = GST_ELEMENT_CLASS (klass); // // gst_element_class_add_static_pad_template (gstelement_class, &my_template); // } // ]| type PadTemplate interface { Object upcastToGstPadTemplate() *PadTemplateInstance // GetCaps wraps gst_pad_template_get_caps // // The function returns the following values: // // - goret *Caps // // 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 // // See gst_pad_template_set_documentation_caps(). GetDocumentationCaps() *Caps // PadCreated wraps gst_pad_template_pad_created // // The function takes the following parameters: // // - pad Pad: the #GstPad that created it // // Emit the pad-created signal for this template when created by this pad. PadCreated(Pad) // SetDocumentationCaps wraps gst_pad_template_set_documentation_caps // // The function takes the following parameters: // // - caps *Caps: the documented capabilities // // Certain elements will dynamically construct the caps of their // pad templates. In order not to let environment-specific information // into the documentation, element authors should use this method to // expose "stable" caps to the reader. SetDocumentationCaps(*Caps) // ConnectPadCreated connects the provided callback to the "pad-created" signal // // This signal is fired when an element creates a pad from this template. ConnectPadCreated(func(PadTemplate, Pad)) gobject.SignalHandle } func unsafeWrapPadTemplate(base *gobject.ObjectInstance) *PadTemplateInstance { return &PadTemplateInstance{ ObjectInstance: ObjectInstance{ InitiallyUnownedInstance: gobject.InitiallyUnownedInstance{ ObjectInstance: *base, }, }, } } func marshalPadTemplateInstance(p unsafe.Pointer) (any, error) { return unsafeWrapPadTemplate(gobject.ValueFromNative(p).Object()), nil } // UnsafePadTemplateFromGlibNone is used to convert raw GstPadTemplate pointers to go while taking a reference and attaching a finalizer. This is used by the bindings internally. func UnsafePadTemplateFromGlibNone(c unsafe.Pointer) PadTemplate { return gobject.UnsafeObjectFromGlibNone(c).(PadTemplate) } // UnsafePadTemplateFromGlibFull is used to convert raw GstPadTemplate pointers to go while attaching a finalizer. This is used by the bindings internally. func UnsafePadTemplateFromGlibFull(c unsafe.Pointer) PadTemplate { return gobject.UnsafeObjectFromGlibFull(c).(PadTemplate) } func (p *PadTemplateInstance) upcastToGstPadTemplate() *PadTemplateInstance { return p } // UnsafePadTemplateToGlibNone is used to convert the instance to it's C value GstPadTemplate. This is used by the bindings internally. func UnsafePadTemplateToGlibNone(c PadTemplate) unsafe.Pointer { return gobject.UnsafeObjectToGlibNone(c) } // UnsafePadTemplateToGlibFull is used to convert the instance to it's C value GstPadTemplate, while removeing the finalizer. This is used by the bindings internally. func UnsafePadTemplateToGlibFull(c PadTemplate) unsafe.Pointer { return gobject.UnsafeObjectToGlibFull(c) } // NewPadTemplate wraps gst_pad_template_new // // The function takes the following parameters: // // - nameTemplate string: the name template. // - direction PadDirection: the #GstPadDirection of the template. // - presence PadPresence: the #GstPadPresence of the pad. // - caps *Caps: a #GstCaps set for the template. // // The function returns the following values: // // - goret PadTemplate (nullable) // // Creates a new pad template with a name according to the given template // and with the given arguments. func NewPadTemplate(nameTemplate string, direction PadDirection, presence PadPresence, caps *Caps) PadTemplate { var carg1 *C.gchar // in, none, string var carg2 C.GstPadDirection // in, none, casted var carg3 C.GstPadPresence // in, none, casted var carg4 *C.GstCaps // in, none, converted var cret *C.GstPadTemplate // return, none, converted, nullable carg1 = (*C.gchar)(unsafe.Pointer(C.CString(nameTemplate))) defer C.free(unsafe.Pointer(carg1)) carg2 = C.GstPadDirection(direction) carg3 = C.GstPadPresence(presence) carg4 = (*C.GstCaps)(UnsafeCapsToGlibNone(caps)) cret = C.gst_pad_template_new(carg1, carg2, carg3, carg4) runtime.KeepAlive(nameTemplate) runtime.KeepAlive(direction) runtime.KeepAlive(presence) runtime.KeepAlive(caps) var goret PadTemplate if cret != nil { goret = UnsafePadTemplateFromGlibNone(unsafe.Pointer(cret)) } return goret } // NewPadTemplateFromStaticPadTemplateWithGType wraps gst_pad_template_new_from_static_pad_template_with_gtype // // The function takes the following parameters: // // - padTemplate *StaticPadTemplate: the static pad template // - padType gobject.Type: The #GType of the pad to create // // The function returns the following values: // // - goret PadTemplate (nullable) // // Converts a #GstStaticPadTemplate into a #GstPadTemplate with a type. func NewPadTemplateFromStaticPadTemplateWithGType(padTemplate *StaticPadTemplate, padType gobject.Type) PadTemplate { var carg1 *C.GstStaticPadTemplate // in, none, converted var carg2 C.GType // in, none, casted, alias var cret *C.GstPadTemplate // return, none, converted, nullable carg1 = (*C.GstStaticPadTemplate)(UnsafeStaticPadTemplateToGlibNone(padTemplate)) carg2 = C.GType(padType) cret = C.gst_pad_template_new_from_static_pad_template_with_gtype(carg1, carg2) runtime.KeepAlive(padTemplate) runtime.KeepAlive(padType) var goret PadTemplate if cret != nil { goret = UnsafePadTemplateFromGlibNone(unsafe.Pointer(cret)) } return goret } // NewPadTemplateWithGType wraps gst_pad_template_new_with_gtype // // The function takes the following parameters: // // - nameTemplate string: the name template. // - direction PadDirection: the #GstPadDirection of the template. // - presence PadPresence: the #GstPadPresence of the pad. // - caps *Caps: a #GstCaps set for the template. // - padType gobject.Type: The #GType of the pad to create // // The function returns the following values: // // - goret PadTemplate (nullable) // // Creates a new pad template with a name according to the given template // and with the given arguments. func NewPadTemplateWithGType(nameTemplate string, direction PadDirection, presence PadPresence, caps *Caps, padType gobject.Type) PadTemplate { var carg1 *C.gchar // in, none, string var carg2 C.GstPadDirection // in, none, casted var carg3 C.GstPadPresence // in, none, casted var carg4 *C.GstCaps // in, none, converted var carg5 C.GType // in, none, casted, alias var cret *C.GstPadTemplate // return, none, converted, nullable carg1 = (*C.gchar)(unsafe.Pointer(C.CString(nameTemplate))) defer C.free(unsafe.Pointer(carg1)) carg2 = C.GstPadDirection(direction) carg3 = C.GstPadPresence(presence) carg4 = (*C.GstCaps)(UnsafeCapsToGlibNone(caps)) carg5 = C.GType(padType) cret = C.gst_pad_template_new_with_gtype(carg1, carg2, carg3, carg4, carg5) runtime.KeepAlive(nameTemplate) runtime.KeepAlive(direction) runtime.KeepAlive(presence) runtime.KeepAlive(caps) runtime.KeepAlive(padType) var goret PadTemplate if cret != nil { goret = UnsafePadTemplateFromGlibNone(unsafe.Pointer(cret)) } return goret } // GetCaps wraps gst_pad_template_get_caps // // The function returns the following values: // // - goret *Caps // // Gets the capabilities of the pad template. func (templ *PadTemplateInstance) GetCaps() *Caps { var carg0 *C.GstPadTemplate // in, none, converted var cret *C.GstCaps // return, full, converted carg0 = (*C.GstPadTemplate)(UnsafePadTemplateToGlibNone(templ)) cret = C.gst_pad_template_get_caps(carg0) runtime.KeepAlive(templ) var goret *Caps goret = UnsafeCapsFromGlibFull(unsafe.Pointer(cret)) return goret } // GetDocumentationCaps wraps gst_pad_template_get_documentation_caps // // The function returns the following values: // // - goret *Caps // // See gst_pad_template_set_documentation_caps(). func (templ *PadTemplateInstance) GetDocumentationCaps() *Caps { var carg0 *C.GstPadTemplate // in, none, converted var cret *C.GstCaps // return, full, converted carg0 = (*C.GstPadTemplate)(UnsafePadTemplateToGlibNone(templ)) cret = C.gst_pad_template_get_documentation_caps(carg0) runtime.KeepAlive(templ) var goret *Caps goret = UnsafeCapsFromGlibFull(unsafe.Pointer(cret)) return goret } // PadCreated wraps gst_pad_template_pad_created // // The function takes the following parameters: // // - pad Pad: the #GstPad that created it // // Emit the pad-created signal for this template when created by this pad. func (templ *PadTemplateInstance) PadCreated(pad Pad) { var carg0 *C.GstPadTemplate // in, none, converted var carg1 *C.GstPad // in, none, converted carg0 = (*C.GstPadTemplate)(UnsafePadTemplateToGlibNone(templ)) carg1 = (*C.GstPad)(UnsafePadToGlibNone(pad)) C.gst_pad_template_pad_created(carg0, carg1) runtime.KeepAlive(templ) runtime.KeepAlive(pad) } // SetDocumentationCaps wraps gst_pad_template_set_documentation_caps // // The function takes the following parameters: // // - caps *Caps: the documented capabilities // // Certain elements will dynamically construct the caps of their // pad templates. In order not to let environment-specific information // into the documentation, element authors should use this method to // expose "stable" caps to the reader. func (templ *PadTemplateInstance) SetDocumentationCaps(caps *Caps) { var carg0 *C.GstPadTemplate // in, none, converted var carg1 *C.GstCaps // in, none, converted carg0 = (*C.GstPadTemplate)(UnsafePadTemplateToGlibNone(templ)) carg1 = (*C.GstCaps)(UnsafeCapsToGlibNone(caps)) C.gst_pad_template_set_documentation_caps(carg0, carg1) runtime.KeepAlive(templ) runtime.KeepAlive(caps) } // ConnectPadCreated connects the provided callback to the "pad-created" signal // // This signal is fired when an element creates a pad from this template. 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 ObjectInstance } var _ Plugin = (*PluginInstance)(nil) // Plugin wraps GstPlugin // // GStreamer is extensible, so #GstElement instances can be loaded at runtime. // A plugin system can provide one or more of the basic GStreamer // #GstPluginFeature subclasses. // // A plugin should export a symbol `gst_plugin_desc` that is a // struct of type #GstPluginDesc. // the plugin loader will check the version of the core library the plugin was // linked against and will create a new #GstPlugin. It will then call the // #GstPluginInitFunc function that was provided in the // `gst_plugin_desc`. // // Once you have a handle to a #GstPlugin (e.g. from the #GstRegistry), you // can add any object that subclasses #GstPluginFeature. // // Usually plugins are always automatically loaded so you don't need to call // gst_plugin_load() explicitly to bring it into memory. There are options to // statically link plugins to an app or even use GStreamer without a plugin // repository in which case gst_plugin_load() can be needed to bring the plugin // into memory. type Plugin interface { Object upcastToGstPlugin() *PluginInstance // AddDependency wraps gst_plugin_add_dependency // // The function takes the following parameters: // // - envVars []string (nullable): %NULL-terminated array of environment variables affecting the // feature set of the plugin (e.g. an environment variable containing // paths where to look for additional modules/plugins of a library), // or %NULL. Environment variable names may be followed by a path component // which will be added to the content of the environment variable, e.g. // "HOME/.mystuff/plugins". // - paths []string (nullable): %NULL-terminated array of directories/paths where dependent files // may be, or %NULL. // - names []string (nullable): %NULL-terminated array of file names (or file name suffixes, // depending on @flags) to be used in combination with the paths from // @paths and/or the paths extracted from the environment variables in // @env_vars, or %NULL. // - flags PluginDependencyFlags: optional flags, or #GST_PLUGIN_DEPENDENCY_FLAG_NONE // // Make GStreamer aware of external dependencies which affect the feature // set of this plugin (ie. the elements or typefinders associated with it). // // GStreamer will re-inspect plugins with external dependencies whenever any // of the external dependencies change. This is useful for plugins which wrap // other plugin systems, e.g. a plugin which wraps a plugin-based visualisation // library and makes visualisations available as GStreamer elements, or a // codec loader which exposes elements and/or caps dependent on what external // codec libraries are currently installed. AddDependency([]string, []string, []string, PluginDependencyFlags) // AddDependencySimple wraps gst_plugin_add_dependency_simple // // The function takes the following parameters: // // - envVars string (nullable): one or more environment variables (separated by ':', ';' or ','), // or %NULL. Environment variable names may be followed by a path component // which will be added to the content of the environment variable, e.g. // "HOME/.mystuff/plugins:MYSTUFF_PLUGINS_PATH" // - paths string (nullable): one ore more directory paths (separated by ':' or ';' or ','), // or %NULL. Example: "/usr/lib/mystuff/plugins" // - names string (nullable): one or more file names or file name suffixes (separated by commas), // or %NULL // - flags PluginDependencyFlags: optional flags, or #GST_PLUGIN_DEPENDENCY_FLAG_NONE // // Make GStreamer aware of external dependencies which affect the feature // set of this plugin (ie. the elements or typefinders associated with it). // // GStreamer will re-inspect plugins with external dependencies whenever any // of the external dependencies change. This is useful for plugins which wrap // other plugin systems, e.g. a plugin which wraps a plugin-based visualisation // library and makes visualisations available as GStreamer elements, or a // codec loader which exposes elements and/or caps dependent on what external // codec libraries are currently installed. // // Convenience wrapper function for gst_plugin_add_dependency() which // takes simple strings as arguments instead of string arrays, with multiple // arguments separated by predefined delimiters (see above). AddDependencySimple(string, string, string, PluginDependencyFlags) // AddStatusError wraps gst_plugin_add_status_error // // The function takes the following parameters: // // - message string: the status error message AddStatusError(string) // AddStatusInfo wraps gst_plugin_add_status_info // // The function takes the following parameters: // // - message string: the status info message AddStatusInfo(string) // AddStatusWarning wraps gst_plugin_add_status_warning // // The function takes the following parameters: // // - message string: the status warning message AddStatusWarning(string) // GetCacheData wraps gst_plugin_get_cache_data // // The function returns the following values: // // - goret *Structure (nullable) // // Gets the plugin specific data cache. If it is %NULL there is no cached data // 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 // // 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) // // get the filename of the plugin GetFilename() string // GetLicense wraps gst_plugin_get_license // // The function returns the following values: // // - goret string // // get the license of the plugin GetLicense() string // GetName wraps gst_plugin_get_name // // The function returns the following values: // // - goret string // // Get the short name of the plugin GetName() string // GetOrigin wraps gst_plugin_get_origin // // The function returns the following values: // // - goret string // // get the URL where the plugin comes from GetOrigin() string // GetPackage wraps gst_plugin_get_package // // The function returns the following values: // // - goret string // // 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) // // Get the release date (and possibly time) in form of a string, if available. // // For normal GStreamer plugin releases this will usually just be a date in // the form of "YYYY-MM-DD", while pre-releases and builds from git may contain // a time component after the date as well, in which case the string will be // formatted like "YYYY-MM-DDTHH:MMZ" (e.g. "2012-04-30T09:30Z"). // // 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 // // 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 // // get the version of the plugin GetVersion() string // IsLoaded wraps gst_plugin_is_loaded // // The function returns the following values: // // - goret bool // // queries if the plugin is loaded into memory IsLoaded() bool // Load wraps gst_plugin_load // // The function returns the following values: // // - goret Plugin (nullable) // // Loads @plugin. Note that the *return value* is the loaded plugin; @plugin is // untouched. The normal use pattern of this function goes like this: // // |[ // GstPlugin *loaded_plugin; // loaded_plugin = gst_plugin_load (plugin); // // presumably, we're no longer interested in the potentially-unloaded plugin // gst_object_unref (plugin); // plugin = loaded_plugin; // ]| Load() Plugin // SetCacheData wraps gst_plugin_set_cache_data // // The function takes the following parameters: // // - cacheData *Structure: a structure containing the data to cache // // Adds plugin specific data to cache. Passes the ownership of the structure to // the @plugin. // // The cache is flushed every time the registry is rebuilt. SetCacheData(*Structure) } func unsafeWrapPlugin(base *gobject.ObjectInstance) *PluginInstance { return &PluginInstance{ ObjectInstance: ObjectInstance{ InitiallyUnownedInstance: gobject.InitiallyUnownedInstance{ ObjectInstance: *base, }, }, } } func marshalPluginInstance(p unsafe.Pointer) (any, error) { return unsafeWrapPlugin(gobject.ValueFromNative(p).Object()), nil } // UnsafePluginFromGlibNone is used to convert raw GstPlugin pointers to go while taking a reference and attaching a finalizer. This is used by the bindings internally. func UnsafePluginFromGlibNone(c unsafe.Pointer) Plugin { return gobject.UnsafeObjectFromGlibNone(c).(Plugin) } // UnsafePluginFromGlibFull is used to convert raw GstPlugin pointers to go while attaching a finalizer. This is used by the bindings internally. func UnsafePluginFromGlibFull(c unsafe.Pointer) Plugin { return gobject.UnsafeObjectFromGlibFull(c).(Plugin) } func (p *PluginInstance) upcastToGstPlugin() *PluginInstance { return p } // UnsafePluginToGlibNone is used to convert the instance to it's C value GstPlugin. This is used by the bindings internally. func UnsafePluginToGlibNone(c Plugin) unsafe.Pointer { return gobject.UnsafeObjectToGlibNone(c) } // UnsafePluginToGlibFull is used to convert the instance to it's C value GstPlugin, while removeing the finalizer. This is used by the bindings internally. func UnsafePluginToGlibFull(c Plugin) unsafe.Pointer { return gobject.UnsafeObjectToGlibFull(c) } // PluginLoadByName wraps gst_plugin_load_by_name // // The function takes the following parameters: // // - name string: name of plugin to load // // The function returns the following values: // // - goret Plugin (nullable) // // Load the named plugin. Refs the plugin. func PluginLoadByName(name string) Plugin { var carg1 *C.gchar // in, none, string var cret *C.GstPlugin // return, full, converted, nullable carg1 = (*C.gchar)(unsafe.Pointer(C.CString(name))) defer C.free(unsafe.Pointer(carg1)) cret = C.gst_plugin_load_by_name(carg1) runtime.KeepAlive(name) var goret Plugin if cret != nil { goret = UnsafePluginFromGlibFull(unsafe.Pointer(cret)) } return goret } // PluginLoadFile wraps gst_plugin_load_file // // The function takes the following parameters: // // - filename string: the plugin filename to load // // The function returns the following values: // // - goret Plugin // - _goerr error (nullable): an error // // Loads the given plugin and refs it. Caller needs to unref after use. func PluginLoadFile(filename string) (Plugin, error) { var carg1 *C.gchar // in, none, string var cret *C.GstPlugin // return, full, converted var _cerr *C.GError // out, full, converted, nullable carg1 = (*C.gchar)(unsafe.Pointer(C.CString(filename))) defer C.free(unsafe.Pointer(carg1)) cret = C.gst_plugin_load_file(carg1, &_cerr) runtime.KeepAlive(filename) var goret Plugin var _goerr error goret = UnsafePluginFromGlibFull(unsafe.Pointer(cret)) if _cerr != nil { _goerr = glib.UnsafeErrorFromGlibFull(unsafe.Pointer(_cerr)) } return goret, _goerr } // PluginRegisterStaticFull wraps gst_plugin_register_static_full // // The function takes the following parameters: // // - majorVersion int: the major version number of the GStreamer core that the // plugin was compiled for, you can just use GST_VERSION_MAJOR here // - minorVersion int: the minor version number of the GStreamer core that the // plugin was compiled for, you can just use GST_VERSION_MINOR here // - name string: a unique name of the plugin (ideally prefixed with an application- or // library-specific namespace prefix in order to avoid name conflicts in // case a similar plugin with the same name ever gets added to GStreamer) // - description string: description of the plugin // - initFullFunc PluginInitFullFunc: pointer to the init function with user data // of this plugin. // - version string: version string of the plugin // - license string: effective license of plugin. Must be one of the approved licenses // (see #GstPluginDesc above) or the plugin will not be registered. // - source string: source module plugin belongs to // - pkg string: shipped package plugin belongs to // - origin string: URL to provider of plugin // // The function returns the following values: // // - goret bool // // Registers a static plugin, ie. a plugin which is private to an application // or library and contained within the application or library (as opposed to // being shipped as a separate module file) with a #GstPluginInitFullFunc // which allows user data to be passed to the callback function (useful // for bindings). // // You must make sure that GStreamer has been initialised (with gst_init() or // via gst_init_get_option_group()) before calling this function. func PluginRegisterStaticFull(majorVersion int, minorVersion int, name string, description string, initFullFunc PluginInitFullFunc, version string, license string, source string, pkg string, origin string) bool { var carg1 C.gint // in, none, casted var carg2 C.gint // in, none, casted var carg3 *C.gchar // in, none, string var carg4 *C.gchar // in, none, string var carg5 C.GstPluginInitFullFunc // callback, scope: call, closure: carg11 var carg6 *C.gchar // in, none, string var carg7 *C.gchar // in, none, string var carg8 *C.gchar // in, none, string var carg9 *C.gchar // in, none, string var carg10 *C.gchar // in, none, string var carg11 C.gpointer // implicit var cret C.gboolean // return carg1 = C.gint(majorVersion) carg2 = C.gint(minorVersion) carg3 = (*C.gchar)(unsafe.Pointer(C.CString(name))) defer C.free(unsafe.Pointer(carg3)) carg4 = (*C.gchar)(unsafe.Pointer(C.CString(description))) defer C.free(unsafe.Pointer(carg4)) carg5 = (*[0]byte)(C._gotk4_gst1_PluginInitFullFunc) carg11 = C.gpointer(userdata.Register(initFullFunc)) defer userdata.Delete(unsafe.Pointer(carg11)) carg6 = (*C.gchar)(unsafe.Pointer(C.CString(version))) defer C.free(unsafe.Pointer(carg6)) carg7 = (*C.gchar)(unsafe.Pointer(C.CString(license))) defer C.free(unsafe.Pointer(carg7)) carg8 = (*C.gchar)(unsafe.Pointer(C.CString(source))) defer C.free(unsafe.Pointer(carg8)) carg9 = (*C.gchar)(unsafe.Pointer(C.CString(pkg))) defer C.free(unsafe.Pointer(carg9)) carg10 = (*C.gchar)(unsafe.Pointer(C.CString(origin))) defer C.free(unsafe.Pointer(carg10)) cret = C.gst_plugin_register_static_full(carg1, carg2, carg3, carg4, carg5, carg6, carg7, carg8, carg9, carg10, carg11) runtime.KeepAlive(majorVersion) runtime.KeepAlive(minorVersion) runtime.KeepAlive(name) runtime.KeepAlive(description) runtime.KeepAlive(initFullFunc) runtime.KeepAlive(version) runtime.KeepAlive(license) runtime.KeepAlive(source) runtime.KeepAlive(pkg) runtime.KeepAlive(origin) var goret bool if cret != 0 { goret = true } return goret } // AddDependency wraps gst_plugin_add_dependency // // The function takes the following parameters: // // - envVars []string (nullable): %NULL-terminated array of environment variables affecting the // feature set of the plugin (e.g. an environment variable containing // paths where to look for additional modules/plugins of a library), // or %NULL. Environment variable names may be followed by a path component // which will be added to the content of the environment variable, e.g. // "HOME/.mystuff/plugins". // - paths []string (nullable): %NULL-terminated array of directories/paths where dependent files // may be, or %NULL. // - names []string (nullable): %NULL-terminated array of file names (or file name suffixes, // depending on @flags) to be used in combination with the paths from // @paths and/or the paths extracted from the environment variables in // @env_vars, or %NULL. // - flags PluginDependencyFlags: optional flags, or #GST_PLUGIN_DEPENDENCY_FLAG_NONE // // Make GStreamer aware of external dependencies which affect the feature // set of this plugin (ie. the elements or typefinders associated with it). // // GStreamer will re-inspect plugins with external dependencies whenever any // of the external dependencies change. This is useful for plugins which wrap // other plugin systems, e.g. a plugin which wraps a plugin-based visualisation // library and makes visualisations available as GStreamer elements, or a // codec loader which exposes elements and/or caps dependent on what external // codec libraries are currently installed. func (plugin *PluginInstance) AddDependency(envVars []string, paths []string, names []string, flags PluginDependencyFlags) { var carg0 *C.GstPlugin // in, none, converted var carg1 **C.gchar // in, transfer: none, C Pointers: 2, Name: array[utf8], nullable, array (inner: *typesystem.StringPrimitive, zero-terminated) var carg2 **C.gchar // in, transfer: none, C Pointers: 2, Name: array[utf8], nullable, array (inner: *typesystem.StringPrimitive, zero-terminated) var carg3 **C.gchar // in, transfer: none, C Pointers: 2, Name: array[utf8], nullable, array (inner: *typesystem.StringPrimitive, zero-terminated) var carg4 C.GstPluginDependencyFlags // in, none, casted carg0 = (*C.GstPlugin)(UnsafePluginToGlibNone(plugin)) _ = envVars _ = carg1 panic("unimplemented conversion of []string (const gchar**)") _ = paths _ = carg2 panic("unimplemented conversion of []string (const gchar**)") _ = names _ = carg3 panic("unimplemented conversion of []string (const gchar**)") carg4 = C.GstPluginDependencyFlags(flags) C.gst_plugin_add_dependency(carg0, carg1, carg2, carg3, carg4) runtime.KeepAlive(plugin) runtime.KeepAlive(envVars) runtime.KeepAlive(paths) runtime.KeepAlive(names) runtime.KeepAlive(flags) } // AddDependencySimple wraps gst_plugin_add_dependency_simple // // The function takes the following parameters: // // - envVars string (nullable): one or more environment variables (separated by ':', ';' or ','), // or %NULL. Environment variable names may be followed by a path component // which will be added to the content of the environment variable, e.g. // "HOME/.mystuff/plugins:MYSTUFF_PLUGINS_PATH" // - paths string (nullable): one ore more directory paths (separated by ':' or ';' or ','), // or %NULL. Example: "/usr/lib/mystuff/plugins" // - names string (nullable): one or more file names or file name suffixes (separated by commas), // or %NULL // - flags PluginDependencyFlags: optional flags, or #GST_PLUGIN_DEPENDENCY_FLAG_NONE // // Make GStreamer aware of external dependencies which affect the feature // set of this plugin (ie. the elements or typefinders associated with it). // // GStreamer will re-inspect plugins with external dependencies whenever any // of the external dependencies change. This is useful for plugins which wrap // other plugin systems, e.g. a plugin which wraps a plugin-based visualisation // library and makes visualisations available as GStreamer elements, or a // codec loader which exposes elements and/or caps dependent on what external // codec libraries are currently installed. // // Convenience wrapper function for gst_plugin_add_dependency() which // takes simple strings as arguments instead of string arrays, with multiple // arguments separated by predefined delimiters (see above). func (plugin *PluginInstance) AddDependencySimple(envVars string, paths string, names string, flags PluginDependencyFlags) { var carg0 *C.GstPlugin // in, none, converted var carg1 *C.gchar // in, none, string, nullable-string var carg2 *C.gchar // in, none, string, nullable-string var carg3 *C.gchar // in, none, string, nullable-string var carg4 C.GstPluginDependencyFlags // in, none, casted carg0 = (*C.GstPlugin)(UnsafePluginToGlibNone(plugin)) if envVars != "" { carg1 = (*C.gchar)(unsafe.Pointer(C.CString(envVars))) defer C.free(unsafe.Pointer(carg1)) } if paths != "" { carg2 = (*C.gchar)(unsafe.Pointer(C.CString(paths))) defer C.free(unsafe.Pointer(carg2)) } if names != "" { carg3 = (*C.gchar)(unsafe.Pointer(C.CString(names))) defer C.free(unsafe.Pointer(carg3)) } carg4 = C.GstPluginDependencyFlags(flags) C.gst_plugin_add_dependency_simple(carg0, carg1, carg2, carg3, carg4) runtime.KeepAlive(plugin) runtime.KeepAlive(envVars) runtime.KeepAlive(paths) runtime.KeepAlive(names) runtime.KeepAlive(flags) } // AddStatusError wraps gst_plugin_add_status_error // // The function takes the following parameters: // // - message string: the status error message func (plugin *PluginInstance) AddStatusError(message string) { var carg0 *C.GstPlugin // in, none, converted var carg1 *C.gchar // in, none, string carg0 = (*C.GstPlugin)(UnsafePluginToGlibNone(plugin)) carg1 = (*C.gchar)(unsafe.Pointer(C.CString(message))) defer C.free(unsafe.Pointer(carg1)) C.gst_plugin_add_status_error(carg0, carg1) runtime.KeepAlive(plugin) runtime.KeepAlive(message) } // AddStatusInfo wraps gst_plugin_add_status_info // // The function takes the following parameters: // // - message string: the status info message func (plugin *PluginInstance) AddStatusInfo(message string) { var carg0 *C.GstPlugin // in, none, converted var carg1 *C.gchar // in, none, string carg0 = (*C.GstPlugin)(UnsafePluginToGlibNone(plugin)) carg1 = (*C.gchar)(unsafe.Pointer(C.CString(message))) defer C.free(unsafe.Pointer(carg1)) C.gst_plugin_add_status_info(carg0, carg1) runtime.KeepAlive(plugin) runtime.KeepAlive(message) } // AddStatusWarning wraps gst_plugin_add_status_warning // // The function takes the following parameters: // // - message string: the status warning message func (plugin *PluginInstance) AddStatusWarning(message string) { var carg0 *C.GstPlugin // in, none, converted var carg1 *C.gchar // in, none, string carg0 = (*C.GstPlugin)(UnsafePluginToGlibNone(plugin)) carg1 = (*C.gchar)(unsafe.Pointer(C.CString(message))) defer C.free(unsafe.Pointer(carg1)) C.gst_plugin_add_status_warning(carg0, carg1) runtime.KeepAlive(plugin) runtime.KeepAlive(message) } // GetCacheData wraps gst_plugin_get_cache_data // // The function returns the following values: // // - goret *Structure (nullable) // // Gets the plugin specific data cache. If it is %NULL there is no cached data // stored. This is the case when the registry is getting rebuilt. func (plugin *PluginInstance) GetCacheData() *Structure { var carg0 *C.GstPlugin // in, none, converted var cret *C.GstStructure // return, none, converted, nullable carg0 = (*C.GstPlugin)(UnsafePluginToGlibNone(plugin)) cret = C.gst_plugin_get_cache_data(carg0) runtime.KeepAlive(plugin) var goret *Structure if cret != nil { goret = UnsafeStructureFromGlibNone(unsafe.Pointer(cret)) } return goret } // GetDescription wraps gst_plugin_get_description // // The function returns the following values: // // - goret string // // Get the long descriptive name of the plugin func (plugin *PluginInstance) GetDescription() string { var carg0 *C.GstPlugin // in, none, converted var cret *C.gchar // return, none, string carg0 = (*C.GstPlugin)(UnsafePluginToGlibNone(plugin)) cret = C.gst_plugin_get_description(carg0) runtime.KeepAlive(plugin) var goret string goret = C.GoString((*C.char)(unsafe.Pointer(cret))) return goret } // GetFilename wraps gst_plugin_get_filename // // The function returns the following values: // // - goret string (nullable) // // get the filename of the plugin func (plugin *PluginInstance) GetFilename() string { var carg0 *C.GstPlugin // in, none, converted var cret *C.gchar // return, none, string, nullable carg0 = (*C.GstPlugin)(UnsafePluginToGlibNone(plugin)) cret = C.gst_plugin_get_filename(carg0) runtime.KeepAlive(plugin) var goret string if cret != nil { goret = C.GoString((*C.char)(unsafe.Pointer(cret))) } return goret } // GetLicense wraps gst_plugin_get_license // // The function returns the following values: // // - goret string // // get the license of the plugin func (plugin *PluginInstance) GetLicense() string { var carg0 *C.GstPlugin // in, none, converted var cret *C.gchar // return, none, string carg0 = (*C.GstPlugin)(UnsafePluginToGlibNone(plugin)) cret = C.gst_plugin_get_license(carg0) runtime.KeepAlive(plugin) var goret string goret = C.GoString((*C.char)(unsafe.Pointer(cret))) return goret } // GetName wraps gst_plugin_get_name // // The function returns the following values: // // - goret string // // Get the short name of the plugin func (plugin *PluginInstance) GetName() string { var carg0 *C.GstPlugin // in, none, converted var cret *C.gchar // return, none, string carg0 = (*C.GstPlugin)(UnsafePluginToGlibNone(plugin)) cret = C.gst_plugin_get_name(carg0) runtime.KeepAlive(plugin) var goret string goret = C.GoString((*C.char)(unsafe.Pointer(cret))) return goret } // GetOrigin wraps gst_plugin_get_origin // // The function returns the following values: // // - goret string // // get the URL where the plugin comes from func (plugin *PluginInstance) GetOrigin() string { var carg0 *C.GstPlugin // in, none, converted var cret *C.gchar // return, none, string carg0 = (*C.GstPlugin)(UnsafePluginToGlibNone(plugin)) cret = C.gst_plugin_get_origin(carg0) runtime.KeepAlive(plugin) var goret string goret = C.GoString((*C.char)(unsafe.Pointer(cret))) return goret } // GetPackage wraps gst_plugin_get_package // // The function returns the following values: // // - goret string // // get the package the plugin belongs to. func (plugin *PluginInstance) GetPackage() string { var carg0 *C.GstPlugin // in, none, converted var cret *C.gchar // return, none, string carg0 = (*C.GstPlugin)(UnsafePluginToGlibNone(plugin)) cret = C.gst_plugin_get_package(carg0) runtime.KeepAlive(plugin) var goret string goret = C.GoString((*C.char)(unsafe.Pointer(cret))) return goret } // GetReleaseDateString wraps gst_plugin_get_release_date_string // // The function returns the following values: // // - goret string (nullable) // // Get the release date (and possibly time) in form of a string, if available. // // For normal GStreamer plugin releases this will usually just be a date in // the form of "YYYY-MM-DD", while pre-releases and builds from git may contain // a time component after the date as well, in which case the string will be // formatted like "YYYY-MM-DDTHH:MMZ" (e.g. "2012-04-30T09:30Z"). // // There may be plugins that do not have a valid release date set on them. func (plugin *PluginInstance) GetReleaseDateString() string { var carg0 *C.GstPlugin // in, none, converted var cret *C.gchar // return, none, string, nullable-string carg0 = (*C.GstPlugin)(UnsafePluginToGlibNone(plugin)) cret = C.gst_plugin_get_release_date_string(carg0) runtime.KeepAlive(plugin) var goret string if cret != nil { goret = C.GoString((*C.char)(unsafe.Pointer(cret))) } return goret } // GetSource wraps gst_plugin_get_source // // The function returns the following values: // // - goret string // // get the source module the plugin belongs to. func (plugin *PluginInstance) GetSource() string { var carg0 *C.GstPlugin // in, none, converted var cret *C.gchar // return, none, string carg0 = (*C.GstPlugin)(UnsafePluginToGlibNone(plugin)) cret = C.gst_plugin_get_source(carg0) runtime.KeepAlive(plugin) var goret string goret = C.GoString((*C.char)(unsafe.Pointer(cret))) return goret } // GetStatusErrors wraps gst_plugin_get_status_errors // // The function returns the following values: // // - goret []string (nullable) func (plugin *PluginInstance) GetStatusErrors() []string { var carg0 *C.GstPlugin // in, none, converted var cret **C.gchar // return, transfer: full, C Pointers: 2, Name: array[utf8], scope: , nullable, array (inner: *typesystem.StringPrimitive, zero-terminated) carg0 = (*C.GstPlugin)(UnsafePluginToGlibNone(plugin)) cret = C.gst_plugin_get_status_errors(carg0) runtime.KeepAlive(plugin) var goret []string _ = goret _ = cret panic("unimplemented conversion of []string (gchar**)") return goret } // GetStatusInfos wraps gst_plugin_get_status_infos // // The function returns the following values: // // - goret []string (nullable) func (plugin *PluginInstance) GetStatusInfos() []string { var carg0 *C.GstPlugin // in, none, converted var cret **C.gchar // return, transfer: full, C Pointers: 2, Name: array[utf8], scope: , nullable, array (inner: *typesystem.StringPrimitive, zero-terminated) carg0 = (*C.GstPlugin)(UnsafePluginToGlibNone(plugin)) cret = C.gst_plugin_get_status_infos(carg0) runtime.KeepAlive(plugin) var goret []string _ = goret _ = cret panic("unimplemented conversion of []string (gchar**)") return goret } // GetStatusWarnings wraps gst_plugin_get_status_warnings // // The function returns the following values: // // - goret []string (nullable) func (plugin *PluginInstance) GetStatusWarnings() []string { var carg0 *C.GstPlugin // in, none, converted var cret **C.gchar // return, transfer: full, C Pointers: 2, Name: array[utf8], scope: , nullable, array (inner: *typesystem.StringPrimitive, zero-terminated) carg0 = (*C.GstPlugin)(UnsafePluginToGlibNone(plugin)) cret = C.gst_plugin_get_status_warnings(carg0) runtime.KeepAlive(plugin) var goret []string _ = goret _ = cret panic("unimplemented conversion of []string (gchar**)") return goret } // GetVersion wraps gst_plugin_get_version // // The function returns the following values: // // - goret string // // get the version of the plugin func (plugin *PluginInstance) GetVersion() string { var carg0 *C.GstPlugin // in, none, converted var cret *C.gchar // return, none, string carg0 = (*C.GstPlugin)(UnsafePluginToGlibNone(plugin)) cret = C.gst_plugin_get_version(carg0) runtime.KeepAlive(plugin) var goret string goret = C.GoString((*C.char)(unsafe.Pointer(cret))) return goret } // IsLoaded wraps gst_plugin_is_loaded // // The function returns the following values: // // - goret bool // // queries if the plugin is loaded into memory func (plugin *PluginInstance) IsLoaded() bool { var carg0 *C.GstPlugin // in, none, converted var cret C.gboolean // return carg0 = (*C.GstPlugin)(UnsafePluginToGlibNone(plugin)) cret = C.gst_plugin_is_loaded(carg0) runtime.KeepAlive(plugin) var goret bool if cret != 0 { goret = true } return goret } // Load wraps gst_plugin_load // // The function returns the following values: // // - goret Plugin (nullable) // // Loads @plugin. Note that the *return value* is the loaded plugin; @plugin is // untouched. The normal use pattern of this function goes like this: // // |[ // GstPlugin *loaded_plugin; // loaded_plugin = gst_plugin_load (plugin); // // presumably, we're no longer interested in the potentially-unloaded plugin // gst_object_unref (plugin); // plugin = loaded_plugin; // ]| func (plugin *PluginInstance) Load() Plugin { var carg0 *C.GstPlugin // in, none, converted var cret *C.GstPlugin // return, full, converted, nullable carg0 = (*C.GstPlugin)(UnsafePluginToGlibNone(plugin)) cret = C.gst_plugin_load(carg0) runtime.KeepAlive(plugin) var goret Plugin if cret != nil { goret = UnsafePluginFromGlibFull(unsafe.Pointer(cret)) } return goret } // SetCacheData wraps gst_plugin_set_cache_data // // The function takes the following parameters: // // - cacheData *Structure: a structure containing the data to cache // // Adds plugin specific data to cache. Passes the ownership of the structure to // the @plugin. // // The cache is flushed every time the registry is rebuilt. func (plugin *PluginInstance) SetCacheData(cacheData *Structure) { var carg0 *C.GstPlugin // in, none, converted var carg1 *C.GstStructure // in, full, converted carg0 = (*C.GstPlugin)(UnsafePluginToGlibNone(plugin)) carg1 = (*C.GstStructure)(UnsafeStructureToGlibFull(cacheData)) C.gst_plugin_set_cache_data(carg0, carg1) runtime.KeepAlive(plugin) runtime.KeepAlive(cacheData) } // PluginFeatureInstance is the instance type used by all types extending GstPluginFeature. It is used internally by the bindings. Users should use the interface [PluginFeature] instead. type PluginFeatureInstance struct { _ [0]func() // equal guard ObjectInstance } var _ PluginFeature = (*PluginFeatureInstance)(nil) // PluginFeature wraps GstPluginFeature // // This is a base class for anything that can be added to a #GstPlugin. type PluginFeature interface { Object upcastToGstPluginFeature() *PluginFeatureInstance // CheckVersion wraps gst_plugin_feature_check_version // // The function takes the following parameters: // // - minMajor uint: minimum required major version // - minMinor uint: minimum required minor version // - minMicro uint: minimum required micro version // // The function returns the following values: // // - goret bool // // Checks whether the given plugin feature is at least the required version. // // Note: Since version 1.24 this function no longer returns %TRUE if the // version is a git development version (e.g. 1.23.0.1) and the check is // for the "next" micro version, that is it will no longer return %TRUE for // e.g. 1.23.0.1 if the check is for 1.23.1. It is still possible to parse // 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) // // 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) // // 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 // // Gets the rank of a plugin feature. GetRank() uint // Load wraps gst_plugin_feature_load // // The function returns the following values: // // - goret PluginFeature (nullable) // // Loads the plugin containing @feature if it's not already loaded. @feature is // unaffected; use the return value instead. // // Normally this function is used like this: // |[<!-- language="C" --> // GstPluginFeature *loaded_feature; // // loaded_feature = gst_plugin_feature_load (feature); // // presumably, we're no longer interested in the potentially-unloaded feature // gst_object_unref (feature); // feature = loaded_feature; // ]| Load() PluginFeature // SetRank wraps gst_plugin_feature_set_rank // // The function takes the following parameters: // // - rank uint: rank value - higher number means more priority rank // // Specifies a rank for a plugin feature, so that autoplugging uses // the most appropriate feature. SetRank(uint) } func unsafeWrapPluginFeature(base *gobject.ObjectInstance) *PluginFeatureInstance { return &PluginFeatureInstance{ ObjectInstance: ObjectInstance{ InitiallyUnownedInstance: gobject.InitiallyUnownedInstance{ ObjectInstance: *base, }, }, } } func marshalPluginFeatureInstance(p unsafe.Pointer) (any, error) { return unsafeWrapPluginFeature(gobject.ValueFromNative(p).Object()), nil } // UnsafePluginFeatureFromGlibNone is used to convert raw GstPluginFeature pointers to go while taking a reference and attaching a finalizer. This is used by the bindings internally. func UnsafePluginFeatureFromGlibNone(c unsafe.Pointer) PluginFeature { return gobject.UnsafeObjectFromGlibNone(c).(PluginFeature) } // UnsafePluginFeatureFromGlibFull is used to convert raw GstPluginFeature pointers to go while attaching a finalizer. This is used by the bindings internally. func UnsafePluginFeatureFromGlibFull(c unsafe.Pointer) PluginFeature { return gobject.UnsafeObjectFromGlibFull(c).(PluginFeature) } func (p *PluginFeatureInstance) upcastToGstPluginFeature() *PluginFeatureInstance { return p } // UnsafePluginFeatureToGlibNone is used to convert the instance to it's C value GstPluginFeature. This is used by the bindings internally. func UnsafePluginFeatureToGlibNone(c PluginFeature) unsafe.Pointer { return gobject.UnsafeObjectToGlibNone(c) } // UnsafePluginFeatureToGlibFull is used to convert the instance to it's C value GstPluginFeature, while removeing the finalizer. This is used by the bindings internally. func UnsafePluginFeatureToGlibFull(c PluginFeature) unsafe.Pointer { return gobject.UnsafeObjectToGlibFull(c) } // PluginFeatureRankCompareFunc wraps gst_plugin_feature_rank_compare_func // // The function takes the following parameters: // // - p1 unsafe.Pointer (nullable): a #GstPluginFeature // - p2 unsafe.Pointer (nullable): a #GstPluginFeature // // The function returns the following values: // // - goret int // // Compares the two given #GstPluginFeature instances. This function can be // used as a #GCompareFunc when sorting by rank and then by name. func PluginFeatureRankCompareFunc(p1 unsafe.Pointer, p2 unsafe.Pointer) int { var carg1 C.gconstpointer // in, none, casted, nullable var carg2 C.gconstpointer // in, none, casted, nullable var cret C.gint // return, none, casted if p1 != nil { carg1 = C.gconstpointer(p1) } if p2 != nil { carg2 = C.gconstpointer(p2) } cret = C.gst_plugin_feature_rank_compare_func(carg1, carg2) runtime.KeepAlive(p1) runtime.KeepAlive(p2) var goret int goret = int(cret) return goret } // CheckVersion wraps gst_plugin_feature_check_version // // The function takes the following parameters: // // - minMajor uint: minimum required major version // - minMinor uint: minimum required minor version // - minMicro uint: minimum required micro version // // The function returns the following values: // // - goret bool // // Checks whether the given plugin feature is at least the required version. // // Note: Since version 1.24 this function no longer returns %TRUE if the // version is a git development version (e.g. 1.23.0.1) and the check is // for the "next" micro version, that is it will no longer return %TRUE for // e.g. 1.23.0.1 if the check is for 1.23.1. It is still possible to parse // the nano version from the string and do this check that way if needed. func (feature *PluginFeatureInstance) CheckVersion(minMajor uint, minMinor uint, minMicro uint) bool { var carg0 *C.GstPluginFeature // in, none, converted var carg1 C.guint // in, none, casted var carg2 C.guint // in, none, casted var carg3 C.guint // in, none, casted var cret C.gboolean // return carg0 = (*C.GstPluginFeature)(UnsafePluginFeatureToGlibNone(feature)) carg1 = C.guint(minMajor) carg2 = C.guint(minMinor) carg3 = C.guint(minMicro) cret = C.gst_plugin_feature_check_version(carg0, carg1, carg2, carg3) runtime.KeepAlive(feature) runtime.KeepAlive(minMajor) runtime.KeepAlive(minMinor) runtime.KeepAlive(minMicro) var goret bool if cret != 0 { goret = true } return goret } // GetPlugin wraps gst_plugin_feature_get_plugin // // The function returns the following values: // // - goret Plugin (nullable) // // Get the plugin that provides this feature. func (feature *PluginFeatureInstance) GetPlugin() Plugin { var carg0 *C.GstPluginFeature // in, none, converted var cret *C.GstPlugin // return, full, converted, nullable carg0 = (*C.GstPluginFeature)(UnsafePluginFeatureToGlibNone(feature)) cret = C.gst_plugin_feature_get_plugin(carg0) runtime.KeepAlive(feature) var goret Plugin if cret != nil { goret = UnsafePluginFromGlibFull(unsafe.Pointer(cret)) } return goret } // GetPluginName wraps gst_plugin_feature_get_plugin_name // // The function returns the following values: // // - goret string (nullable) // // Get the name of the plugin that provides this feature. func (feature *PluginFeatureInstance) GetPluginName() string { var carg0 *C.GstPluginFeature // in, none, converted var cret *C.gchar // return, none, string, nullable-string carg0 = (*C.GstPluginFeature)(UnsafePluginFeatureToGlibNone(feature)) cret = C.gst_plugin_feature_get_plugin_name(carg0) runtime.KeepAlive(feature) var goret string if cret != nil { goret = C.GoString((*C.char)(unsafe.Pointer(cret))) } return goret } // GetRank wraps gst_plugin_feature_get_rank // // The function returns the following values: // // - goret uint // // Gets the rank of a plugin feature. func (feature *PluginFeatureInstance) GetRank() uint { var carg0 *C.GstPluginFeature // in, none, converted var cret C.guint // return, none, casted carg0 = (*C.GstPluginFeature)(UnsafePluginFeatureToGlibNone(feature)) cret = C.gst_plugin_feature_get_rank(carg0) runtime.KeepAlive(feature) var goret uint goret = uint(cret) return goret } // Load wraps gst_plugin_feature_load // // The function returns the following values: // // - goret PluginFeature (nullable) // // Loads the plugin containing @feature if it's not already loaded. @feature is // unaffected; use the return value instead. // // Normally this function is used like this: // |[<!-- language="C" --> // GstPluginFeature *loaded_feature; // // loaded_feature = gst_plugin_feature_load (feature); // // presumably, we're no longer interested in the potentially-unloaded feature // gst_object_unref (feature); // feature = loaded_feature; // ]| func (feature *PluginFeatureInstance) Load() PluginFeature { var carg0 *C.GstPluginFeature // in, none, converted var cret *C.GstPluginFeature // return, full, converted, nullable carg0 = (*C.GstPluginFeature)(UnsafePluginFeatureToGlibNone(feature)) cret = C.gst_plugin_feature_load(carg0) runtime.KeepAlive(feature) var goret PluginFeature if cret != nil { goret = UnsafePluginFeatureFromGlibFull(unsafe.Pointer(cret)) } return goret } // SetRank wraps gst_plugin_feature_set_rank // // The function takes the following parameters: // // - rank uint: rank value - higher number means more priority rank // // Specifies a rank for a plugin feature, so that autoplugging uses // the most appropriate feature. func (feature *PluginFeatureInstance) SetRank(rank uint) { var carg0 *C.GstPluginFeature // in, none, converted var carg1 C.guint // in, none, casted carg0 = (*C.GstPluginFeature)(UnsafePluginFeatureToGlibNone(feature)) carg1 = C.guint(rank) C.gst_plugin_feature_set_rank(carg0, carg1) runtime.KeepAlive(feature) runtime.KeepAlive(rank) } // ProxyPadInstance is the instance type used by all types extending GstProxyPad. It is used internally by the bindings. Users should use the interface [ProxyPad] instead. type ProxyPadInstance struct { _ [0]func() // equal guard PadInstance } var _ ProxyPad = (*ProxyPadInstance)(nil) // ProxyPad wraps GstProxyPad type ProxyPad interface { Pad upcastToGstProxyPad() *ProxyPadInstance // GetInternal wraps gst_proxy_pad_get_internal // // The function returns the following values: // // - goret ProxyPad (nullable) // // Get the internal pad of @pad. Unref target pad after usage. // // The internal pad of a #GstGhostPad is the internally used // pad of opposite direction, which is used to link to the target. GetInternal() ProxyPad } func unsafeWrapProxyPad(base *gobject.ObjectInstance) *ProxyPadInstance { return &ProxyPadInstance{ PadInstance: PadInstance{ ObjectInstance: ObjectInstance{ InitiallyUnownedInstance: gobject.InitiallyUnownedInstance{ ObjectInstance: *base, }, }, }, } } func marshalProxyPadInstance(p unsafe.Pointer) (any, error) { return unsafeWrapProxyPad(gobject.ValueFromNative(p).Object()), nil } // UnsafeProxyPadFromGlibNone is used to convert raw GstProxyPad pointers to go while taking a reference and attaching a finalizer. This is used by the bindings internally. func UnsafeProxyPadFromGlibNone(c unsafe.Pointer) ProxyPad { return gobject.UnsafeObjectFromGlibNone(c).(ProxyPad) } // UnsafeProxyPadFromGlibFull is used to convert raw GstProxyPad pointers to go while attaching a finalizer. This is used by the bindings internally. func UnsafeProxyPadFromGlibFull(c unsafe.Pointer) ProxyPad { return gobject.UnsafeObjectFromGlibFull(c).(ProxyPad) } func (p *ProxyPadInstance) upcastToGstProxyPad() *ProxyPadInstance { return p } // UnsafeProxyPadToGlibNone is used to convert the instance to it's C value GstProxyPad. This is used by the bindings internally. func UnsafeProxyPadToGlibNone(c ProxyPad) unsafe.Pointer { return gobject.UnsafeObjectToGlibNone(c) } // UnsafeProxyPadToGlibFull is used to convert the instance to it's C value GstProxyPad, while removeing the finalizer. This is used by the bindings internally. func UnsafeProxyPadToGlibFull(c ProxyPad) unsafe.Pointer { return gobject.UnsafeObjectToGlibFull(c) } // ProxyPadChainDefault wraps gst_proxy_pad_chain_default // // The function takes the following parameters: // // - pad Pad: a sink #GstPad, returns GST_FLOW_ERROR if not. // - parent Object (nullable): the parent of @pad or %NULL // - buffer *Buffer: the #GstBuffer to send, return GST_FLOW_ERROR // if not. // // The function returns the following values: // // - goret FlowReturn // // Invoke the default chain function of the proxy pad. func ProxyPadChainDefault(pad Pad, parent Object, buffer *Buffer) FlowReturn { var carg1 *C.GstPad // in, none, converted var carg2 *C.GstObject // in, none, converted, nullable var carg3 *C.GstBuffer // in, full, converted var cret C.GstFlowReturn // return, none, casted carg1 = (*C.GstPad)(UnsafePadToGlibNone(pad)) if parent != nil { carg2 = (*C.GstObject)(UnsafeObjectToGlibNone(parent)) } carg3 = (*C.GstBuffer)(UnsafeBufferToGlibFull(buffer)) cret = C.gst_proxy_pad_chain_default(carg1, carg2, carg3) runtime.KeepAlive(pad) runtime.KeepAlive(parent) runtime.KeepAlive(buffer) var goret FlowReturn goret = FlowReturn(cret) return goret } // ProxyPadChainListDefault wraps gst_proxy_pad_chain_list_default // // The function takes the following parameters: // // - pad Pad: a sink #GstPad, returns GST_FLOW_ERROR if not. // - parent Object (nullable): the parent of @pad or %NULL // - list *BufferList: the #GstBufferList to send, return GST_FLOW_ERROR // if not. // // The function returns the following values: // // - goret FlowReturn // // Invoke the default chain list function of the proxy pad. func ProxyPadChainListDefault(pad Pad, parent Object, list *BufferList) FlowReturn { var carg1 *C.GstPad // in, none, converted var carg2 *C.GstObject // in, none, converted, nullable var carg3 *C.GstBufferList // in, full, converted var cret C.GstFlowReturn // return, none, casted carg1 = (*C.GstPad)(UnsafePadToGlibNone(pad)) if parent != nil { carg2 = (*C.GstObject)(UnsafeObjectToGlibNone(parent)) } carg3 = (*C.GstBufferList)(UnsafeBufferListToGlibFull(list)) cret = C.gst_proxy_pad_chain_list_default(carg1, carg2, carg3) runtime.KeepAlive(pad) runtime.KeepAlive(parent) runtime.KeepAlive(list) var goret FlowReturn goret = FlowReturn(cret) return goret } // ProxyPadGetrangeDefault wraps gst_proxy_pad_getrange_default // // The function takes the following parameters: // // - pad Pad: a src #GstPad, returns #GST_FLOW_ERROR if not. // - parent Object: the parent of @pad // - offset uint64: The start offset of the buffer // - size uint: The length of the buffer // // The function returns the following values: // // - buffer *Buffer: a pointer to hold the #GstBuffer, // returns #GST_FLOW_ERROR if %NULL. // - goret FlowReturn // // Invoke the default getrange function of the proxy pad. func ProxyPadGetrangeDefault(pad Pad, parent Object, offset uint64, size uint) (*Buffer, FlowReturn) { var carg1 *C.GstPad // in, none, converted var carg2 *C.GstObject // in, none, converted var carg3 C.guint64 // in, none, casted var carg4 C.guint // in, none, casted var carg5 *C.GstBuffer // out, full, converted var cret C.GstFlowReturn // return, none, casted carg1 = (*C.GstPad)(UnsafePadToGlibNone(pad)) carg2 = (*C.GstObject)(UnsafeObjectToGlibNone(parent)) carg3 = C.guint64(offset) carg4 = C.guint(size) cret = C.gst_proxy_pad_getrange_default(carg1, carg2, carg3, carg4, &carg5) runtime.KeepAlive(pad) runtime.KeepAlive(parent) runtime.KeepAlive(offset) runtime.KeepAlive(size) var buffer *Buffer var goret FlowReturn buffer = UnsafeBufferFromGlibFull(unsafe.Pointer(carg5)) goret = FlowReturn(cret) return buffer, goret } // ProxyPadIterateInternalLinksDefault wraps gst_proxy_pad_iterate_internal_links_default // // The function takes the following parameters: // // - pad Pad: the #GstPad to get the internal links of. // - parent Object (nullable): the parent of @pad or %NULL // // The function returns the following values: // // - goret *Iterator (nullable) // // Invoke the default iterate internal links function of the proxy pad. func ProxyPadIterateInternalLinksDefault(pad Pad, parent Object) *Iterator { var carg1 *C.GstPad // in, none, converted var carg2 *C.GstObject // in, none, converted, nullable var cret *C.GstIterator // return, full, converted, nullable carg1 = (*C.GstPad)(UnsafePadToGlibNone(pad)) if parent != nil { carg2 = (*C.GstObject)(UnsafeObjectToGlibNone(parent)) } cret = C.gst_proxy_pad_iterate_internal_links_default(carg1, carg2) runtime.KeepAlive(pad) runtime.KeepAlive(parent) var goret *Iterator if cret != nil { goret = UnsafeIteratorFromGlibFull(unsafe.Pointer(cret)) } return goret } // GetInternal wraps gst_proxy_pad_get_internal // // The function returns the following values: // // - goret ProxyPad (nullable) // // Get the internal pad of @pad. Unref target pad after usage. // // The internal pad of a #GstGhostPad is the internally used // pad of opposite direction, which is used to link to the target. func (pad *ProxyPadInstance) GetInternal() ProxyPad { var carg0 *C.GstProxyPad // in, none, converted var cret *C.GstProxyPad // return, full, converted, nullable carg0 = (*C.GstProxyPad)(UnsafeProxyPadToGlibNone(pad)) cret = C.gst_proxy_pad_get_internal(carg0) runtime.KeepAlive(pad) var goret ProxyPad if cret != nil { goret = UnsafeProxyPadFromGlibFull(unsafe.Pointer(cret)) } 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 ObjectInstance } var _ Registry = (*RegistryInstance)(nil) // Registry wraps GstRegistry // // One registry holds the metadata of a set of plugins. // // <emphasis role="bold">Design:</emphasis> // // The #GstRegistry object is a list of plugins and some functions for dealing // with them. Each #GstPlugin is matched 1-1 with a file on disk, and may or may // not be loaded at a given time. // // The primary source, at all times, of plugin information is each plugin file // itself. Thus, if an application wants information about a particular plugin, // or wants to search for a feature that satisfies given criteria, the primary // means of doing so is to load every plugin and look at the resulting // information that is gathered in the default registry. Clearly, this is a time // consuming process, so we cache information in the registry file. The format // and location of the cache file is internal to gstreamer. // // On startup, plugins are searched for in the plugin search path. The following // locations are checked in this order: // // * location from --gst-plugin-path commandline option. // * the GST_PLUGIN_PATH environment variable. // * the GST_PLUGIN_SYSTEM_PATH environment variable. // * default locations (if GST_PLUGIN_SYSTEM_PATH is not set). // Those default locations are: // `$XDG_DATA_HOME/gstreamer-$GST_API_VERSION/plugins/` // and `$prefix/libs/gstreamer-$GST_API_VERSION/`. // [$XDG_DATA_HOME](http://standards.freedesktop.org/basedir-spec/basedir-spec-latest.html) defaults to // `$HOME/.local/share`. // // The registry cache file is loaded from // `$XDG_CACHE_HOME/gstreamer-$GST_API_VERSION/registry-$ARCH.bin` // (where $XDG_CACHE_HOME defaults to `$HOME/.cache`) or the file listed in the `GST_REGISTRY` // env var. One reason to change the registry location is for testing. // // For each plugin that is found in the plugin search path, there could be 3 // possibilities for cached information: // // * the cache may not contain information about a given file. // * the cache may have stale information. // * the cache may have current information. // // In the first two cases, the plugin is loaded and the cache updated. In // addition to these cases, the cache may have entries for plugins that are not // relevant to the current process. These are marked as not available to the // current process. If the cache is updated for whatever reason, it is marked // dirty. // // A dirty cache is written out at the end of initialization. Each entry is // checked to make sure the information is minimally valid. If not, the entry is // simply dropped. // // ## Implementation notes: // // The "cache" and "registry" are different concepts and can represent // different sets of plugins. For various reasons, at init time, the cache is // stored in the default registry, and plugins not relevant to the current // process are marked with the %GST_PLUGIN_FLAG_CACHED bit. These plugins are // removed at the end of initialization. type Registry interface { Object upcastToGstRegistry() *RegistryInstance // AddFeature wraps gst_registry_add_feature // // The function takes the following parameters: // // - feature PluginFeature: the feature to add // // The function returns the following values: // // - goret bool // // Add the feature to the registry. The feature-added signal will be emitted. // // @feature's reference count will be incremented, and any floating // reference will be removed (see gst_object_ref_sink()) AddFeature(PluginFeature) bool // AddPlugin wraps gst_registry_add_plugin // // The function takes the following parameters: // // - plugin Plugin: the plugin to add // // The function returns the following values: // // - goret bool // // Add the plugin to the registry. The plugin-added signal will be emitted. // // @plugin's reference count will be incremented, and any floating // reference will be removed (see gst_object_ref_sink()) AddPlugin(Plugin) bool // CheckFeatureVersion wraps gst_registry_check_feature_version // // The function takes the following parameters: // // - featureName string: the name of the feature (e.g. "oggdemux") // - minMajor uint: the minimum major version number // - minMinor uint: the minimum minor version number // - minMicro uint: the minimum micro version number // // The function returns the following values: // // - goret bool // // Checks whether a plugin feature by the given name exists in // @registry and whether its version is at least the // version required. CheckFeatureVersion(string, uint, uint, uint) bool // FeatureFilter wraps gst_registry_feature_filter // // The function takes the following parameters: // // - filter PluginFeatureFilter: the filter to use // - first bool: only return first match // // The function returns the following values: // // - goret []PluginFeature // // Runs a filter against all features of the plugins in the registry // and returns a GList with the results. // If the first flag is set, only the first match is // returned (as a list with a single object). FeatureFilter(PluginFeatureFilter, bool) []PluginFeature // FindFeature wraps gst_registry_find_feature // // The function takes the following parameters: // // - name string: the pluginfeature name to find // - typ gobject.Type: the pluginfeature type to find // // The function returns the following values: // // - goret PluginFeature (nullable) // // Find the pluginfeature with the given name and type in the registry. FindFeature(string, gobject.Type) PluginFeature // FindPlugin wraps gst_registry_find_plugin // // The function takes the following parameters: // // - name string: the plugin name to find // // The function returns the following values: // // - goret Plugin (nullable) // // Find the plugin with the given name in the registry. // The plugin will be reffed; caller is responsible for unreffing. FindPlugin(string) Plugin // GetFeatureList wraps gst_registry_get_feature_list // // The function takes the following parameters: // // - typ gobject.Type: a #GType. // // The function returns the following values: // // - goret []PluginFeature // // Retrieves a #GList of #GstPluginFeature of @type. GetFeatureList(gobject.Type) []PluginFeature // GetFeatureListByPlugin wraps gst_registry_get_feature_list_by_plugin // // The function takes the following parameters: // // - name string: a plugin name. // // The function returns the following values: // // - goret []PluginFeature // // 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 // // Returns the registry's feature list cookie. This changes // 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 // // Get a copy of all plugins registered in the given registry. The refcount // of each element in the list in incremented. GetPluginList() []Plugin // Lookup wraps gst_registry_lookup // // The function takes the following parameters: // // - filename string: the name of the file to look up // // The function returns the following values: // // - goret Plugin (nullable) // // Look up a plugin in the given registry with the given filename. // If found, plugin is reffed. Lookup(string) Plugin // LookupFeature wraps gst_registry_lookup_feature // // The function takes the following parameters: // // - name string: a #GstPluginFeature name // // The function returns the following values: // // - goret PluginFeature (nullable) // // Find a #GstPluginFeature with @name in @registry. LookupFeature(string) PluginFeature // PluginFilter wraps gst_registry_plugin_filter // // The function takes the following parameters: // // - filter PluginFilter: the filter to use // - first bool: only return first match // // The function returns the following values: // // - goret []Plugin // // Runs a filter against all plugins in the registry and returns a #GList with // the results. If the first flag is set, only the first match is // returned (as a list with a single object). // Every plugin is reffed; use gst_plugin_list_free() after use, which // will unref again. PluginFilter(PluginFilter, bool) []Plugin // RemoveFeature wraps gst_registry_remove_feature // // The function takes the following parameters: // // - feature PluginFeature: the feature to remove // // Remove the feature from the registry. // // MT safe. RemoveFeature(PluginFeature) // RemovePlugin wraps gst_registry_remove_plugin // // The function takes the following parameters: // // - plugin Plugin: the plugin to remove // // Remove the plugin from the registry. // // MT safe. RemovePlugin(Plugin) // ScanPath wraps gst_registry_scan_path // // The function takes the following parameters: // // - path string: the path to scan // // The function returns the following values: // // - goret bool // // Scan the given path for plugins to add to the registry. The syntax of the // path is specific to the registry. ScanPath(string) bool // ConnectFeatureAdded connects the provided callback to the "feature-added" signal // // Signals that a feature has been added to the registry (possibly // replacing a previously-added one by the same name) ConnectFeatureAdded(func(Registry, PluginFeature)) gobject.SignalHandle // ConnectPluginAdded connects the provided callback to the "plugin-added" signal // // Signals that a plugin has been added to the registry (possibly // replacing a previously-added one by the same name) ConnectPluginAdded(func(Registry, Plugin)) gobject.SignalHandle } func unsafeWrapRegistry(base *gobject.ObjectInstance) *RegistryInstance { return &RegistryInstance{ ObjectInstance: ObjectInstance{ InitiallyUnownedInstance: gobject.InitiallyUnownedInstance{ ObjectInstance: *base, }, }, } } func marshalRegistryInstance(p unsafe.Pointer) (any, error) { return unsafeWrapRegistry(gobject.ValueFromNative(p).Object()), nil } // UnsafeRegistryFromGlibNone is used to convert raw GstRegistry pointers to go while taking a reference and attaching a finalizer. This is used by the bindings internally. func UnsafeRegistryFromGlibNone(c unsafe.Pointer) Registry { return gobject.UnsafeObjectFromGlibNone(c).(Registry) } // UnsafeRegistryFromGlibFull is used to convert raw GstRegistry pointers to go while attaching a finalizer. This is used by the bindings internally. func UnsafeRegistryFromGlibFull(c unsafe.Pointer) Registry { return gobject.UnsafeObjectFromGlibFull(c).(Registry) } func (r *RegistryInstance) upcastToGstRegistry() *RegistryInstance { return r } // UnsafeRegistryToGlibNone is used to convert the instance to it's C value GstRegistry. This is used by the bindings internally. func UnsafeRegistryToGlibNone(c Registry) unsafe.Pointer { return gobject.UnsafeObjectToGlibNone(c) } // UnsafeRegistryToGlibFull is used to convert the instance to it's C value GstRegistry, while removeing the finalizer. This is used by the bindings internally. func UnsafeRegistryToGlibFull(c Registry) unsafe.Pointer { return gobject.UnsafeObjectToGlibFull(c) } // RegistryForkIsEnabled wraps gst_registry_fork_is_enabled // // The function returns the following values: // // - goret bool // // By default GStreamer will perform scanning and rebuilding of the // registry file using a helper child process. // // Applications might want to disable this behaviour with the // gst_registry_fork_set_enabled() function, in which case new plugins // are scanned (and loaded) into the application process. func RegistryForkIsEnabled() bool { var cret C.gboolean // return cret = C.gst_registry_fork_is_enabled() var goret bool if cret != 0 { goret = true } return goret } // RegistryForkSetEnabled wraps gst_registry_fork_set_enabled // // The function takes the following parameters: // // - enabled bool: whether rebuilding the registry can use a temporary child helper process. // // Applications might want to disable/enable spawning of a child helper process // when rebuilding the registry. See gst_registry_fork_is_enabled() for more // information. func RegistryForkSetEnabled(enabled bool) { var carg1 C.gboolean // in if enabled { carg1 = C.TRUE } C.gst_registry_fork_set_enabled(carg1) runtime.KeepAlive(enabled) } // RegistryGet wraps gst_registry_get // // The function returns the following values: // // - goret Registry // // Retrieves the singleton plugin registry. The caller does not own a // reference on the registry, as it is alive as long as GStreamer is // initialized. func RegistryGet() Registry { var cret *C.GstRegistry // return, none, converted cret = C.gst_registry_get() var goret Registry goret = UnsafeRegistryFromGlibNone(unsafe.Pointer(cret)) return goret } // AddFeature wraps gst_registry_add_feature // // The function takes the following parameters: // // - feature PluginFeature: the feature to add // // The function returns the following values: // // - goret bool // // Add the feature to the registry. The feature-added signal will be emitted. // // @feature's reference count will be incremented, and any floating // reference will be removed (see gst_object_ref_sink()) func (registry *RegistryInstance) AddFeature(feature PluginFeature) bool { var carg0 *C.GstRegistry // in, none, converted var carg1 *C.GstPluginFeature // in, none, converted var cret C.gboolean // return carg0 = (*C.GstRegistry)(UnsafeRegistryToGlibNone(registry)) carg1 = (*C.GstPluginFeature)(UnsafePluginFeatureToGlibNone(feature)) cret = C.gst_registry_add_feature(carg0, carg1) runtime.KeepAlive(registry) runtime.KeepAlive(feature) var goret bool if cret != 0 { goret = true } return goret } // AddPlugin wraps gst_registry_add_plugin // // The function takes the following parameters: // // - plugin Plugin: the plugin to add // // The function returns the following values: // // - goret bool // // Add the plugin to the registry. The plugin-added signal will be emitted. // // @plugin's reference count will be incremented, and any floating // reference will be removed (see gst_object_ref_sink()) func (registry *RegistryInstance) AddPlugin(plugin Plugin) bool { var carg0 *C.GstRegistry // in, none, converted var carg1 *C.GstPlugin // in, none, converted var cret C.gboolean // return carg0 = (*C.GstRegistry)(UnsafeRegistryToGlibNone(registry)) carg1 = (*C.GstPlugin)(UnsafePluginToGlibNone(plugin)) cret = C.gst_registry_add_plugin(carg0, carg1) runtime.KeepAlive(registry) runtime.KeepAlive(plugin) var goret bool if cret != 0 { goret = true } return goret } // CheckFeatureVersion wraps gst_registry_check_feature_version // // The function takes the following parameters: // // - featureName string: the name of the feature (e.g. "oggdemux") // - minMajor uint: the minimum major version number // - minMinor uint: the minimum minor version number // - minMicro uint: the minimum micro version number // // The function returns the following values: // // - goret bool // // Checks whether a plugin feature by the given name exists in // @registry and whether its version is at least the // version required. func (registry *RegistryInstance) CheckFeatureVersion(featureName string, minMajor uint, minMinor uint, minMicro uint) bool { var carg0 *C.GstRegistry // in, none, converted var carg1 *C.gchar // in, none, string var carg2 C.guint // in, none, casted var carg3 C.guint // in, none, casted var carg4 C.guint // in, none, casted var cret C.gboolean // return carg0 = (*C.GstRegistry)(UnsafeRegistryToGlibNone(registry)) carg1 = (*C.gchar)(unsafe.Pointer(C.CString(featureName))) defer C.free(unsafe.Pointer(carg1)) carg2 = C.guint(minMajor) carg3 = C.guint(minMinor) carg4 = C.guint(minMicro) cret = C.gst_registry_check_feature_version(carg0, carg1, carg2, carg3, carg4) runtime.KeepAlive(registry) runtime.KeepAlive(featureName) runtime.KeepAlive(minMajor) runtime.KeepAlive(minMinor) runtime.KeepAlive(minMicro) var goret bool if cret != 0 { goret = true } return goret } // FeatureFilter wraps gst_registry_feature_filter // // The function takes the following parameters: // // - filter PluginFeatureFilter: the filter to use // - first bool: only return first match // // The function returns the following values: // // - goret []PluginFeature // // Runs a filter against all features of the plugins in the registry // and returns a GList with the results. // If the first flag is set, only the first match is // returned (as a list with a single object). func (registry *RegistryInstance) FeatureFilter(filter PluginFeatureFilter, first bool) []PluginFeature { var carg0 *C.GstRegistry // in, none, converted var carg1 C.GstPluginFeatureFilter // callback, scope: call, closure: carg3 var carg2 C.gboolean // in var carg3 C.gpointer // implicit var cret *C.GList // container, transfer: full carg0 = (*C.GstRegistry)(UnsafeRegistryToGlibNone(registry)) carg1 = (*[0]byte)(C._gotk4_gst1_PluginFeatureFilter) carg3 = C.gpointer(userdata.Register(filter)) defer userdata.Delete(unsafe.Pointer(carg3)) if first { carg2 = C.TRUE } cret = C.gst_registry_feature_filter(carg0, carg1, carg2, carg3) runtime.KeepAlive(registry) runtime.KeepAlive(filter) runtime.KeepAlive(first) var goret []PluginFeature goret = glib.UnsafeListFromGlibFull( unsafe.Pointer(cret), func(v unsafe.Pointer) PluginFeature { var dst PluginFeature // converted dst = UnsafePluginFeatureFromGlibFull(v) return dst }, ) return goret } // FindFeature wraps gst_registry_find_feature // // The function takes the following parameters: // // - name string: the pluginfeature name to find // - typ gobject.Type: the pluginfeature type to find // // The function returns the following values: // // - goret PluginFeature (nullable) // // Find the pluginfeature with the given name and type in the registry. func (registry *RegistryInstance) FindFeature(name string, typ gobject.Type) PluginFeature { var carg0 *C.GstRegistry // in, none, converted var carg1 *C.gchar // in, none, string var carg2 C.GType // in, none, casted, alias var cret *C.GstPluginFeature // return, full, converted, nullable carg0 = (*C.GstRegistry)(UnsafeRegistryToGlibNone(registry)) carg1 = (*C.gchar)(unsafe.Pointer(C.CString(name))) defer C.free(unsafe.Pointer(carg1)) carg2 = C.GType(typ) cret = C.gst_registry_find_feature(carg0, carg1, carg2) runtime.KeepAlive(registry) runtime.KeepAlive(name) runtime.KeepAlive(typ) var goret PluginFeature if cret != nil { goret = UnsafePluginFeatureFromGlibFull(unsafe.Pointer(cret)) } return goret } // FindPlugin wraps gst_registry_find_plugin // // The function takes the following parameters: // // - name string: the plugin name to find // // The function returns the following values: // // - goret Plugin (nullable) // // Find the plugin with the given name in the registry. // The plugin will be reffed; caller is responsible for unreffing. func (registry *RegistryInstance) FindPlugin(name string) Plugin { var carg0 *C.GstRegistry // in, none, converted var carg1 *C.gchar // in, none, string var cret *C.GstPlugin // return, full, converted, nullable carg0 = (*C.GstRegistry)(UnsafeRegistryToGlibNone(registry)) carg1 = (*C.gchar)(unsafe.Pointer(C.CString(name))) defer C.free(unsafe.Pointer(carg1)) cret = C.gst_registry_find_plugin(carg0, carg1) runtime.KeepAlive(registry) runtime.KeepAlive(name) var goret Plugin if cret != nil { goret = UnsafePluginFromGlibFull(unsafe.Pointer(cret)) } return goret } // GetFeatureList wraps gst_registry_get_feature_list // // The function takes the following parameters: // // - typ gobject.Type: a #GType. // // The function returns the following values: // // - goret []PluginFeature // // Retrieves a #GList of #GstPluginFeature of @type. func (registry *RegistryInstance) GetFeatureList(typ gobject.Type) []PluginFeature { var carg0 *C.GstRegistry // in, none, converted var carg1 C.GType // in, none, casted, alias var cret *C.GList // container, transfer: full carg0 = (*C.GstRegistry)(UnsafeRegistryToGlibNone(registry)) carg1 = C.GType(typ) cret = C.gst_registry_get_feature_list(carg0, carg1) runtime.KeepAlive(registry) runtime.KeepAlive(typ) var goret []PluginFeature goret = glib.UnsafeListFromGlibFull( unsafe.Pointer(cret), func(v unsafe.Pointer) PluginFeature { var dst PluginFeature // converted dst = UnsafePluginFeatureFromGlibFull(v) return dst }, ) return goret } // GetFeatureListByPlugin wraps gst_registry_get_feature_list_by_plugin // // The function takes the following parameters: // // - name string: a plugin name. // // The function returns the following values: // // - goret []PluginFeature // // Retrieves a #GList of features of the plugin with name @name. func (registry *RegistryInstance) GetFeatureListByPlugin(name string) []PluginFeature { var carg0 *C.GstRegistry // in, none, converted var carg1 *C.gchar // in, none, string var cret *C.GList // container, transfer: full carg0 = (*C.GstRegistry)(UnsafeRegistryToGlibNone(registry)) carg1 = (*C.gchar)(unsafe.Pointer(C.CString(name))) defer C.free(unsafe.Pointer(carg1)) cret = C.gst_registry_get_feature_list_by_plugin(carg0, carg1) runtime.KeepAlive(registry) runtime.KeepAlive(name) var goret []PluginFeature goret = glib.UnsafeListFromGlibFull( unsafe.Pointer(cret), func(v unsafe.Pointer) PluginFeature { var dst PluginFeature // converted dst = UnsafePluginFeatureFromGlibFull(v) return dst }, ) return goret } // GetFeatureListCookie wraps gst_registry_get_feature_list_cookie // // The function returns the following values: // // - goret uint32 // // Returns the registry's feature list cookie. This changes // every time a feature is added or removed from the registry. func (registry *RegistryInstance) GetFeatureListCookie() uint32 { var carg0 *C.GstRegistry // in, none, converted var cret C.guint32 // return, none, casted carg0 = (*C.GstRegistry)(UnsafeRegistryToGlibNone(registry)) cret = C.gst_registry_get_feature_list_cookie(carg0) runtime.KeepAlive(registry) var goret uint32 goret = uint32(cret) return goret } // GetPluginList wraps gst_registry_get_plugin_list // // The function returns the following values: // // - goret []Plugin // // Get a copy of all plugins registered in the given registry. The refcount // of each element in the list in incremented. func (registry *RegistryInstance) GetPluginList() []Plugin { var carg0 *C.GstRegistry // in, none, converted var cret *C.GList // container, transfer: full carg0 = (*C.GstRegistry)(UnsafeRegistryToGlibNone(registry)) cret = C.gst_registry_get_plugin_list(carg0) runtime.KeepAlive(registry) var goret []Plugin goret = glib.UnsafeListFromGlibFull( unsafe.Pointer(cret), func(v unsafe.Pointer) Plugin { var dst Plugin // converted dst = UnsafePluginFromGlibFull(v) return dst }, ) return goret } // Lookup wraps gst_registry_lookup // // The function takes the following parameters: // // - filename string: the name of the file to look up // // The function returns the following values: // // - goret Plugin (nullable) // // Look up a plugin in the given registry with the given filename. // If found, plugin is reffed. func (registry *RegistryInstance) Lookup(filename string) Plugin { var carg0 *C.GstRegistry // in, none, converted var carg1 *C.char // in, none, string, casted *C.gchar var cret *C.GstPlugin // return, full, converted, nullable carg0 = (*C.GstRegistry)(UnsafeRegistryToGlibNone(registry)) carg1 = (*C.char)(unsafe.Pointer(C.CString(filename))) defer C.free(unsafe.Pointer(carg1)) cret = C.gst_registry_lookup(carg0, carg1) runtime.KeepAlive(registry) runtime.KeepAlive(filename) var goret Plugin if cret != nil { goret = UnsafePluginFromGlibFull(unsafe.Pointer(cret)) } return goret } // LookupFeature wraps gst_registry_lookup_feature // // The function takes the following parameters: // // - name string: a #GstPluginFeature name // // The function returns the following values: // // - goret PluginFeature (nullable) // // Find a #GstPluginFeature with @name in @registry. func (registry *RegistryInstance) LookupFeature(name string) PluginFeature { var carg0 *C.GstRegistry // in, none, converted var carg1 *C.char // in, none, string, casted *C.gchar var cret *C.GstPluginFeature // return, full, converted, nullable carg0 = (*C.GstRegistry)(UnsafeRegistryToGlibNone(registry)) carg1 = (*C.char)(unsafe.Pointer(C.CString(name))) defer C.free(unsafe.Pointer(carg1)) cret = C.gst_registry_lookup_feature(carg0, carg1) runtime.KeepAlive(registry) runtime.KeepAlive(name) var goret PluginFeature if cret != nil { goret = UnsafePluginFeatureFromGlibFull(unsafe.Pointer(cret)) } return goret } // PluginFilter wraps gst_registry_plugin_filter // // The function takes the following parameters: // // - filter PluginFilter: the filter to use // - first bool: only return first match // // The function returns the following values: // // - goret []Plugin // // Runs a filter against all plugins in the registry and returns a #GList with // the results. If the first flag is set, only the first match is // returned (as a list with a single object). // Every plugin is reffed; use gst_plugin_list_free() after use, which // will unref again. func (registry *RegistryInstance) PluginFilter(filter PluginFilter, first bool) []Plugin { var carg0 *C.GstRegistry // in, none, converted var carg1 C.GstPluginFilter // callback, scope: call, closure: carg3 var carg2 C.gboolean // in var carg3 C.gpointer // implicit var cret *C.GList // container, transfer: full carg0 = (*C.GstRegistry)(UnsafeRegistryToGlibNone(registry)) carg1 = (*[0]byte)(C._gotk4_gst1_PluginFilter) carg3 = C.gpointer(userdata.Register(filter)) defer userdata.Delete(unsafe.Pointer(carg3)) if first { carg2 = C.TRUE } cret = C.gst_registry_plugin_filter(carg0, carg1, carg2, carg3) runtime.KeepAlive(registry) runtime.KeepAlive(filter) runtime.KeepAlive(first) var goret []Plugin goret = glib.UnsafeListFromGlibFull( unsafe.Pointer(cret), func(v unsafe.Pointer) Plugin { var dst Plugin // converted dst = UnsafePluginFromGlibFull(v) return dst }, ) return goret } // RemoveFeature wraps gst_registry_remove_feature // // The function takes the following parameters: // // - feature PluginFeature: the feature to remove // // Remove the feature from the registry. // // MT safe. func (registry *RegistryInstance) RemoveFeature(feature PluginFeature) { var carg0 *C.GstRegistry // in, none, converted var carg1 *C.GstPluginFeature // in, none, converted carg0 = (*C.GstRegistry)(UnsafeRegistryToGlibNone(registry)) carg1 = (*C.GstPluginFeature)(UnsafePluginFeatureToGlibNone(feature)) C.gst_registry_remove_feature(carg0, carg1) runtime.KeepAlive(registry) runtime.KeepAlive(feature) } // RemovePlugin wraps gst_registry_remove_plugin // // The function takes the following parameters: // // - plugin Plugin: the plugin to remove // // Remove the plugin from the registry. // // MT safe. func (registry *RegistryInstance) RemovePlugin(plugin Plugin) { var carg0 *C.GstRegistry // in, none, converted var carg1 *C.GstPlugin // in, none, converted carg0 = (*C.GstRegistry)(UnsafeRegistryToGlibNone(registry)) carg1 = (*C.GstPlugin)(UnsafePluginToGlibNone(plugin)) C.gst_registry_remove_plugin(carg0, carg1) runtime.KeepAlive(registry) runtime.KeepAlive(plugin) } // ScanPath wraps gst_registry_scan_path // // The function takes the following parameters: // // - path string: the path to scan // // The function returns the following values: // // - goret bool // // Scan the given path for plugins to add to the registry. The syntax of the // path is specific to the registry. func (registry *RegistryInstance) ScanPath(path string) bool { var carg0 *C.GstRegistry // in, none, converted var carg1 *C.gchar // in, none, string var cret C.gboolean // return carg0 = (*C.GstRegistry)(UnsafeRegistryToGlibNone(registry)) carg1 = (*C.gchar)(unsafe.Pointer(C.CString(path))) defer C.free(unsafe.Pointer(carg1)) cret = C.gst_registry_scan_path(carg0, carg1) runtime.KeepAlive(registry) runtime.KeepAlive(path) var goret bool if cret != 0 { goret = true } return goret } // ConnectFeatureAdded connects the provided callback to the "feature-added" signal // // Signals that a feature has been added to the registry (possibly // replacing a previously-added one by the same name) 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 // replacing a previously-added one by the same name) 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 ObjectInstance } var _ Stream = (*StreamInstance)(nil) // Stream wraps GstStream // // A high-level object representing a single stream. It might be backed, or // not, by an actual flow of data in a pipeline (#GstPad). // // A #GstStream does not care about data changes (such as decoding, encoding, // parsing,...) as long as the underlying data flow corresponds to the same // high-level flow (ex: a certain audio track). // // A #GstStream contains all the information pertinent to a stream, such as // stream-id, tags, caps, type, ... // // Elements can subclass a #GstStream for internal usage (to contain information // pertinent to streams of data). type Stream interface { Object upcastToGstStream() *StreamInstance // GetCaps wraps gst_stream_get_caps // // The function returns the following values: // // - goret *Caps (nullable) // // Retrieve the caps for @stream, if any GetCaps() *Caps // GetStreamFlags wraps gst_stream_get_stream_flags // // The function returns the following values: // // - goret StreamFlags // // 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) // // Returns the stream ID of @stream. GetStreamID() string // GetStreamType wraps gst_stream_get_stream_type // // The function returns the following values: // // - goret StreamType // // Retrieve the stream type for @stream GetStreamType() StreamType // GetTags wraps gst_stream_get_tags // // The function returns the following values: // // - goret *TagList (nullable) // // Retrieve the tags for @stream, if any GetTags() *TagList // SetCaps wraps gst_stream_set_caps // // The function takes the following parameters: // // - caps *Caps (nullable): a #GstCaps // // Set the caps for the #GstStream SetCaps(*Caps) // SetStreamFlags wraps gst_stream_set_stream_flags // // The function takes the following parameters: // // - flags StreamFlags: the flags to set on @stream // // Set the @flags for the @stream. SetStreamFlags(StreamFlags) // SetStreamType wraps gst_stream_set_stream_type // // The function takes the following parameters: // // - streamType StreamType: the type to set on @stream // // Set the stream type of @stream SetStreamType(StreamType) // SetTags wraps gst_stream_set_tags // // The function takes the following parameters: // // - tags *TagList (nullable): a #GstTagList // // Set the tags for the #GstStream SetTags(*TagList) } func unsafeWrapStream(base *gobject.ObjectInstance) *StreamInstance { return &StreamInstance{ ObjectInstance: ObjectInstance{ InitiallyUnownedInstance: gobject.InitiallyUnownedInstance{ ObjectInstance: *base, }, }, } } func marshalStreamInstance(p unsafe.Pointer) (any, error) { return unsafeWrapStream(gobject.ValueFromNative(p).Object()), nil } // UnsafeStreamFromGlibNone is used to convert raw GstStream pointers to go while taking a reference and attaching a finalizer. This is used by the bindings internally. func UnsafeStreamFromGlibNone(c unsafe.Pointer) Stream { return gobject.UnsafeObjectFromGlibNone(c).(Stream) } // UnsafeStreamFromGlibFull is used to convert raw GstStream pointers to go while attaching a finalizer. This is used by the bindings internally. func UnsafeStreamFromGlibFull(c unsafe.Pointer) Stream { return gobject.UnsafeObjectFromGlibFull(c).(Stream) } func (s *StreamInstance) upcastToGstStream() *StreamInstance { return s } // UnsafeStreamToGlibNone is used to convert the instance to it's C value GstStream. This is used by the bindings internally. func UnsafeStreamToGlibNone(c Stream) unsafe.Pointer { return gobject.UnsafeObjectToGlibNone(c) } // UnsafeStreamToGlibFull is used to convert the instance to it's C value GstStream, while removeing the finalizer. This is used by the bindings internally. func UnsafeStreamToGlibFull(c Stream) unsafe.Pointer { return gobject.UnsafeObjectToGlibFull(c) } // NewStream wraps gst_stream_new // // The function takes the following parameters: // // - streamId string (nullable): the id for the new stream. If %NULL, // a new one will be automatically generated // - caps *Caps (nullable): the #GstCaps of the stream // - typ StreamType: the #GstStreamType of the stream // - flags StreamFlags: the #GstStreamFlags of the stream // // The function returns the following values: // // - goret Stream // // Create a new #GstStream for the given @stream_id, @caps, @type // and @flags func NewStream(streamId string, caps *Caps, typ StreamType, flags StreamFlags) Stream { var carg1 *C.gchar // in, none, string, nullable-string var carg2 *C.GstCaps // in, none, converted, nullable var carg3 C.GstStreamType // in, none, casted var carg4 C.GstStreamFlags // in, none, casted var cret *C.GstStream // return, full, converted if streamId != "" { carg1 = (*C.gchar)(unsafe.Pointer(C.CString(streamId))) defer C.free(unsafe.Pointer(carg1)) } if caps != nil { carg2 = (*C.GstCaps)(UnsafeCapsToGlibNone(caps)) } carg3 = C.GstStreamType(typ) carg4 = C.GstStreamFlags(flags) cret = C.gst_stream_new(carg1, carg2, carg3, carg4) runtime.KeepAlive(streamId) runtime.KeepAlive(caps) runtime.KeepAlive(typ) runtime.KeepAlive(flags) var goret Stream goret = UnsafeStreamFromGlibFull(unsafe.Pointer(cret)) return goret } // GetCaps wraps gst_stream_get_caps // // The function returns the following values: // // - goret *Caps (nullable) // // Retrieve the caps for @stream, if any func (stream *StreamInstance) GetCaps() *Caps { var carg0 *C.GstStream // in, none, converted var cret *C.GstCaps // return, full, converted, nullable carg0 = (*C.GstStream)(UnsafeStreamToGlibNone(stream)) cret = C.gst_stream_get_caps(carg0) runtime.KeepAlive(stream) var goret *Caps if cret != nil { goret = UnsafeCapsFromGlibFull(unsafe.Pointer(cret)) } return goret } // GetStreamFlags wraps gst_stream_get_stream_flags // // The function returns the following values: // // - goret StreamFlags // // Retrieve the current stream flags for @stream func (stream *StreamInstance) GetStreamFlags() StreamFlags { var carg0 *C.GstStream // in, none, converted var cret C.GstStreamFlags // return, none, casted carg0 = (*C.GstStream)(UnsafeStreamToGlibNone(stream)) cret = C.gst_stream_get_stream_flags(carg0) runtime.KeepAlive(stream) var goret StreamFlags goret = StreamFlags(cret) return goret } // GetStreamID wraps gst_stream_get_stream_id // // The function returns the following values: // // - goret string (nullable) // // Returns the stream ID of @stream. func (stream *StreamInstance) GetStreamID() string { var carg0 *C.GstStream // in, none, converted var cret *C.gchar // return, none, string, nullable-string carg0 = (*C.GstStream)(UnsafeStreamToGlibNone(stream)) cret = C.gst_stream_get_stream_id(carg0) runtime.KeepAlive(stream) var goret string if cret != nil { goret = C.GoString((*C.char)(unsafe.Pointer(cret))) } return goret } // GetStreamType wraps gst_stream_get_stream_type // // The function returns the following values: // // - goret StreamType // // Retrieve the stream type for @stream func (stream *StreamInstance) GetStreamType() StreamType { var carg0 *C.GstStream // in, none, converted var cret C.GstStreamType // return, none, casted carg0 = (*C.GstStream)(UnsafeStreamToGlibNone(stream)) cret = C.gst_stream_get_stream_type(carg0) runtime.KeepAlive(stream) var goret StreamType goret = StreamType(cret) return goret } // GetTags wraps gst_stream_get_tags // // The function returns the following values: // // - goret *TagList (nullable) // // Retrieve the tags for @stream, if any func (stream *StreamInstance) GetTags() *TagList { var carg0 *C.GstStream // in, none, converted var cret *C.GstTagList // return, full, converted, nullable carg0 = (*C.GstStream)(UnsafeStreamToGlibNone(stream)) cret = C.gst_stream_get_tags(carg0) runtime.KeepAlive(stream) var goret *TagList if cret != nil { goret = UnsafeTagListFromGlibFull(unsafe.Pointer(cret)) } return goret } // SetCaps wraps gst_stream_set_caps // // The function takes the following parameters: // // - caps *Caps (nullable): a #GstCaps // // Set the caps for the #GstStream func (stream *StreamInstance) SetCaps(caps *Caps) { var carg0 *C.GstStream // in, none, converted var carg1 *C.GstCaps // in, none, converted, nullable carg0 = (*C.GstStream)(UnsafeStreamToGlibNone(stream)) if caps != nil { carg1 = (*C.GstCaps)(UnsafeCapsToGlibNone(caps)) } C.gst_stream_set_caps(carg0, carg1) runtime.KeepAlive(stream) runtime.KeepAlive(caps) } // SetStreamFlags wraps gst_stream_set_stream_flags // // The function takes the following parameters: // // - flags StreamFlags: the flags to set on @stream // // Set the @flags for the @stream. func (stream *StreamInstance) SetStreamFlags(flags StreamFlags) { var carg0 *C.GstStream // in, none, converted var carg1 C.GstStreamFlags // in, none, casted carg0 = (*C.GstStream)(UnsafeStreamToGlibNone(stream)) carg1 = C.GstStreamFlags(flags) C.gst_stream_set_stream_flags(carg0, carg1) runtime.KeepAlive(stream) runtime.KeepAlive(flags) } // SetStreamType wraps gst_stream_set_stream_type // // The function takes the following parameters: // // - streamType StreamType: the type to set on @stream // // Set the stream type of @stream func (stream *StreamInstance) SetStreamType(streamType StreamType) { var carg0 *C.GstStream // in, none, converted var carg1 C.GstStreamType // in, none, casted carg0 = (*C.GstStream)(UnsafeStreamToGlibNone(stream)) carg1 = C.GstStreamType(streamType) C.gst_stream_set_stream_type(carg0, carg1) runtime.KeepAlive(stream) runtime.KeepAlive(streamType) } // SetTags wraps gst_stream_set_tags // // The function takes the following parameters: // // - tags *TagList (nullable): a #GstTagList // // Set the tags for the #GstStream func (stream *StreamInstance) SetTags(tags *TagList) { var carg0 *C.GstStream // in, none, converted var carg1 *C.GstTagList // in, none, converted, nullable carg0 = (*C.GstStream)(UnsafeStreamToGlibNone(stream)) if tags != nil { carg1 = (*C.GstTagList)(UnsafeTagListToGlibNone(tags)) } C.gst_stream_set_tags(carg0, carg1) runtime.KeepAlive(stream) 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 ObjectInstance } var _ StreamCollection = (*StreamCollectionInstance)(nil) // StreamCollection wraps GstStreamCollection // // A collection of #GstStream that are available. // // A #GstStreamCollection will be provided by elements that can make those // streams available. Applications can use the collection to show the user // what streams are available by using %gst_stream_collection_get_stream() // // Once posted, a #GstStreamCollection is immutable. Updates are made by sending // a new #GstStreamCollection message, which may or may not share some of // the #GstStream objects from the collection it replaces. The receiver can check // the sender of a stream collection message to know which collection is // obsoleted. // // Several elements in a pipeline can provide #GstStreamCollection. // // Applications can activate streams from a collection by using the // #GST_EVENT_SELECT_STREAMS event on a pipeline, bin or element. type StreamCollection interface { Object upcastToGstStreamCollection() *StreamCollectionInstance // AddStream wraps gst_stream_collection_add_stream // // The function takes the following parameters: // // - stream Stream: the #GstStream to add // // The function returns the following values: // // - goret bool // // 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 // // Get the number of streams this collection contains GetSize() uint // GetStream wraps gst_stream_collection_get_stream // // The function takes the following parameters: // // - index uint: Index of the stream to retrieve // // The function returns the following values: // // - goret Stream (nullable) // // Retrieve the #GstStream with index @index from the collection. // // 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) // // Returns the upstream id of the @collection. GetUpstreamID() string } func unsafeWrapStreamCollection(base *gobject.ObjectInstance) *StreamCollectionInstance { return &StreamCollectionInstance{ ObjectInstance: ObjectInstance{ InitiallyUnownedInstance: gobject.InitiallyUnownedInstance{ ObjectInstance: *base, }, }, } } func marshalStreamCollectionInstance(p unsafe.Pointer) (any, error) { return unsafeWrapStreamCollection(gobject.ValueFromNative(p).Object()), nil } // UnsafeStreamCollectionFromGlibNone is used to convert raw GstStreamCollection pointers to go while taking a reference and attaching a finalizer. This is used by the bindings internally. func UnsafeStreamCollectionFromGlibNone(c unsafe.Pointer) StreamCollection { return gobject.UnsafeObjectFromGlibNone(c).(StreamCollection) } // UnsafeStreamCollectionFromGlibFull is used to convert raw GstStreamCollection pointers to go while attaching a finalizer. This is used by the bindings internally. func UnsafeStreamCollectionFromGlibFull(c unsafe.Pointer) StreamCollection { return gobject.UnsafeObjectFromGlibFull(c).(StreamCollection) } func (s *StreamCollectionInstance) upcastToGstStreamCollection() *StreamCollectionInstance { return s } // UnsafeStreamCollectionToGlibNone is used to convert the instance to it's C value GstStreamCollection. This is used by the bindings internally. func UnsafeStreamCollectionToGlibNone(c StreamCollection) unsafe.Pointer { return gobject.UnsafeObjectToGlibNone(c) } // UnsafeStreamCollectionToGlibFull is used to convert the instance to it's C value GstStreamCollection, while removeing the finalizer. This is used by the bindings internally. func UnsafeStreamCollectionToGlibFull(c StreamCollection) unsafe.Pointer { return gobject.UnsafeObjectToGlibFull(c) } // NewStreamCollection wraps gst_stream_collection_new // // The function takes the following parameters: // // - upstreamId string (nullable): The stream id of the parent stream // // The function returns the following values: // // - goret StreamCollection // // Create a new #GstStreamCollection. func NewStreamCollection(upstreamId string) StreamCollection { var carg1 *C.gchar // in, none, string, nullable-string var cret *C.GstStreamCollection // return, full, converted if upstreamId != "" { carg1 = (*C.gchar)(unsafe.Pointer(C.CString(upstreamId))) defer C.free(unsafe.Pointer(carg1)) } cret = C.gst_stream_collection_new(carg1) runtime.KeepAlive(upstreamId) var goret StreamCollection goret = UnsafeStreamCollectionFromGlibFull(unsafe.Pointer(cret)) return goret } // AddStream wraps gst_stream_collection_add_stream // // The function takes the following parameters: // // - stream Stream: the #GstStream to add // // The function returns the following values: // // - goret bool // // Add the given @stream to the @collection. func (collection *StreamCollectionInstance) AddStream(stream Stream) bool { var carg0 *C.GstStreamCollection // in, none, converted var carg1 *C.GstStream // in, full, converted var cret C.gboolean // return carg0 = (*C.GstStreamCollection)(UnsafeStreamCollectionToGlibNone(collection)) carg1 = (*C.GstStream)(UnsafeStreamToGlibFull(stream)) cret = C.gst_stream_collection_add_stream(carg0, carg1) runtime.KeepAlive(collection) runtime.KeepAlive(stream) var goret bool if cret != 0 { goret = true } return goret } // GetSize wraps gst_stream_collection_get_size // // The function returns the following values: // // - goret uint // // Get the number of streams this collection contains func (collection *StreamCollectionInstance) GetSize() uint { var carg0 *C.GstStreamCollection // in, none, converted var cret C.guint // return, none, casted carg0 = (*C.GstStreamCollection)(UnsafeStreamCollectionToGlibNone(collection)) cret = C.gst_stream_collection_get_size(carg0) runtime.KeepAlive(collection) var goret uint goret = uint(cret) return goret } // GetStream wraps gst_stream_collection_get_stream // // The function takes the following parameters: // // - index uint: Index of the stream to retrieve // // The function returns the following values: // // - goret Stream (nullable) // // Retrieve the #GstStream with index @index from the collection. // // The caller should not modify the returned #GstStream func (collection *StreamCollectionInstance) GetStream(index uint) Stream { var carg0 *C.GstStreamCollection // in, none, converted var carg1 C.guint // in, none, casted var cret *C.GstStream // return, none, converted, nullable carg0 = (*C.GstStreamCollection)(UnsafeStreamCollectionToGlibNone(collection)) carg1 = C.guint(index) cret = C.gst_stream_collection_get_stream(carg0, carg1) runtime.KeepAlive(collection) runtime.KeepAlive(index) var goret Stream if cret != nil { goret = UnsafeStreamFromGlibNone(unsafe.Pointer(cret)) } return goret } // GetUpstreamID wraps gst_stream_collection_get_upstream_id // // The function returns the following values: // // - goret string (nullable) // // Returns the upstream id of the @collection. func (collection *StreamCollectionInstance) GetUpstreamID() string { var carg0 *C.GstStreamCollection // in, none, converted var cret *C.gchar // return, none, string, nullable-string carg0 = (*C.GstStreamCollection)(UnsafeStreamCollectionToGlibNone(collection)) cret = C.gst_stream_collection_get_upstream_id(carg0) runtime.KeepAlive(collection) var goret string if cret != nil { goret = C.GoString((*C.char)(unsafe.Pointer(cret))) } 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 ObjectInstance } var _ Task = (*TaskInstance)(nil) // Task wraps GstTask // // #GstTask is used by #GstElement and #GstPad to provide the data passing // threads in a #GstPipeline. // // A #GstPad will typically start a #GstTask to push or pull data to/from the // peer pads. Most source elements start a #GstTask to push data. In some cases // a demuxer element can start a #GstTask to pull data from a peer element. This // is typically done when the demuxer can perform random access on the upstream // peer element for improved performance. // // Although convenience functions exist on #GstPad to start/pause/stop tasks, it // might sometimes be needed to create a #GstTask manually if it is not related to // a #GstPad. // // Before the #GstTask can be run, it needs a #GRecMutex that can be set with // gst_task_set_lock(). // // The task can be started, paused and stopped with gst_task_start(), gst_task_pause() // and gst_task_stop() respectively or with the gst_task_set_state() function. // // A #GstTask will repeatedly call the #GstTaskFunction with the user data // that was provided when creating the task with gst_task_new(). While calling // the function it will acquire the provided lock. The provided lock is released // when the task pauses or stops. // // Stopping a task with gst_task_stop() will not immediately make sure the task is // not running anymore. Use gst_task_join() to make sure the task is completely // stopped and the thread is stopped. // // After creating a #GstTask, use gst_object_unref() to free its resources. This can // only be done when the task is not running anymore. // // Task functions can send a #GstMessage to send out-of-band data to the // application. The application can receive messages from the #GstBus in its // mainloop. // // For debugging purposes, the task will configure its object name as the thread // name on Linux. Please note that the object name should be configured before the // task is started; changing the object name after the task has been started, has // no effect on the thread name. type Task interface { Object upcastToGstTask() *TaskInstance // GetPool wraps gst_task_get_pool // // The function returns the following values: // // - goret TaskPool // // Get the #GstTaskPool that this task will use for its streaming // threads. // // MT safe. GetPool() TaskPool // GetState wraps gst_task_get_state // // The function returns the following values: // // - goret TaskState // // Get the current state of the task. GetState() TaskState // Join wraps gst_task_join // // The function returns the following values: // // - goret bool // // Joins @task. After this call, it is safe to unref the task // and clean up the lock set with gst_task_set_lock(). // // The task will automatically be stopped with this call. // // This function cannot be called from within a task function as this // would cause a deadlock. The function will detect this and print a // g_warning. Join() bool // Pause wraps gst_task_pause // // The function returns the following values: // // - goret bool // // Pauses @task. This method can also be called on a task in the // stopped state, in which case a thread will be started and will remain // in the paused state. This function does not wait for the task to complete // the paused state. Pause() bool // Resume wraps gst_task_resume // // The function returns the following values: // // - goret bool // // Resume @task in case it was paused. If the task was stopped, it will // remain in that state and this function will return %FALSE. Resume() bool // SetPool wraps gst_task_set_pool // // The function takes the following parameters: // // - pool TaskPool: a #GstTaskPool // // Set @pool as the new GstTaskPool for @task. Any new streaming threads that // will be created by @task will now use @pool. // // MT safe. SetPool(TaskPool) // SetState wraps gst_task_set_state // // The function takes the following parameters: // // - state TaskState: the new task state // // The function returns the following values: // // - goret bool // // Sets the state of @task to @state. // // The @task must have a lock associated with it using // gst_task_set_lock() when going to GST_TASK_STARTED or GST_TASK_PAUSED or // this function will return %FALSE. // // MT safe. SetState(TaskState) bool // Start wraps gst_task_start // // The function returns the following values: // // - goret bool // // Starts @task. The @task must have a lock associated with it using // 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 // // Stops @task. This method merely schedules the task to stop and // will not wait for the task to have completely stopped. Use // gst_task_join() to stop and wait for completion. Stop() bool } func unsafeWrapTask(base *gobject.ObjectInstance) *TaskInstance { return &TaskInstance{ ObjectInstance: ObjectInstance{ InitiallyUnownedInstance: gobject.InitiallyUnownedInstance{ ObjectInstance: *base, }, }, } } func marshalTaskInstance(p unsafe.Pointer) (any, error) { return unsafeWrapTask(gobject.ValueFromNative(p).Object()), nil } // UnsafeTaskFromGlibNone is used to convert raw GstTask pointers to go while taking a reference and attaching a finalizer. This is used by the bindings internally. func UnsafeTaskFromGlibNone(c unsafe.Pointer) Task { return gobject.UnsafeObjectFromGlibNone(c).(Task) } // UnsafeTaskFromGlibFull is used to convert raw GstTask pointers to go while attaching a finalizer. This is used by the bindings internally. func UnsafeTaskFromGlibFull(c unsafe.Pointer) Task { return gobject.UnsafeObjectFromGlibFull(c).(Task) } func (t *TaskInstance) upcastToGstTask() *TaskInstance { return t } // UnsafeTaskToGlibNone is used to convert the instance to it's C value GstTask. This is used by the bindings internally. func UnsafeTaskToGlibNone(c Task) unsafe.Pointer { return gobject.UnsafeObjectToGlibNone(c) } // UnsafeTaskToGlibFull is used to convert the instance to it's C value GstTask, while removeing the finalizer. This is used by the bindings internally. func UnsafeTaskToGlibFull(c Task) unsafe.Pointer { return gobject.UnsafeObjectToGlibFull(c) } // NewTask wraps gst_task_new // // The function takes the following parameters: // // - fn TaskFunction: The #GstTaskFunction to use // // The function returns the following values: // // - goret Task // // Create a new Task that will repeatedly call the provided @func // with @user_data as a parameter. Typically the task will run in // a new thread. // // The function cannot be changed after the task has been created. You // must create a new #GstTask to change the function. // // This function will not yet create and start a thread. Use gst_task_start() or // gst_task_pause() to create and start the GThread. // // Before the task can be used, a #GRecMutex must be configured using the // gst_task_set_lock() function. This lock will always be acquired while // @func is called. func NewTask(fn TaskFunction) Task { var carg1 C.GstTaskFunction // callback, scope: notified, closure: carg2, destroy: carg3 var carg2 C.gpointer // implicit var carg3 C.GDestroyNotify // implicit var cret *C.GstTask // return, full, converted carg1 = (*[0]byte)(C._gotk4_gst1_TaskFunction) carg2 = C.gpointer(userdata.Register(fn)) carg3 = (C.GDestroyNotify)((*[0]byte)(C.destroyUserdata)) cret = C.gst_task_new(carg1, carg2, carg3) runtime.KeepAlive(fn) var goret Task goret = UnsafeTaskFromGlibFull(unsafe.Pointer(cret)) return goret } // TaskCleanupAll wraps gst_task_cleanup_all // // Wait for all tasks to be stopped. This is mainly used internally // to ensure proper cleanup of internal data structures in test suites. // // MT safe. func TaskCleanupAll() { C.gst_task_cleanup_all() } // GetPool wraps gst_task_get_pool // // The function returns the following values: // // - goret TaskPool // // Get the #GstTaskPool that this task will use for its streaming // threads. // // MT safe. func (task *TaskInstance) GetPool() TaskPool { var carg0 *C.GstTask // in, none, converted var cret *C.GstTaskPool // return, full, converted carg0 = (*C.GstTask)(UnsafeTaskToGlibNone(task)) cret = C.gst_task_get_pool(carg0) runtime.KeepAlive(task) var goret TaskPool goret = UnsafeTaskPoolFromGlibFull(unsafe.Pointer(cret)) return goret } // GetState wraps gst_task_get_state // // The function returns the following values: // // - goret TaskState // // Get the current state of the task. func (task *TaskInstance) GetState() TaskState { var carg0 *C.GstTask // in, none, converted var cret C.GstTaskState // return, none, casted carg0 = (*C.GstTask)(UnsafeTaskToGlibNone(task)) cret = C.gst_task_get_state(carg0) runtime.KeepAlive(task) var goret TaskState goret = TaskState(cret) return goret } // Join wraps gst_task_join // // The function returns the following values: // // - goret bool // // Joins @task. After this call, it is safe to unref the task // and clean up the lock set with gst_task_set_lock(). // // The task will automatically be stopped with this call. // // This function cannot be called from within a task function as this // would cause a deadlock. The function will detect this and print a // g_warning. func (task *TaskInstance) Join() bool { var carg0 *C.GstTask // in, none, converted var cret C.gboolean // return carg0 = (*C.GstTask)(UnsafeTaskToGlibNone(task)) cret = C.gst_task_join(carg0) runtime.KeepAlive(task) var goret bool if cret != 0 { goret = true } return goret } // Pause wraps gst_task_pause // // The function returns the following values: // // - goret bool // // Pauses @task. This method can also be called on a task in the // stopped state, in which case a thread will be started and will remain // in the paused state. This function does not wait for the task to complete // the paused state. func (task *TaskInstance) Pause() bool { var carg0 *C.GstTask // in, none, converted var cret C.gboolean // return carg0 = (*C.GstTask)(UnsafeTaskToGlibNone(task)) cret = C.gst_task_pause(carg0) runtime.KeepAlive(task) var goret bool if cret != 0 { goret = true } return goret } // Resume wraps gst_task_resume // // The function returns the following values: // // - goret bool // // Resume @task in case it was paused. If the task was stopped, it will // remain in that state and this function will return %FALSE. func (task *TaskInstance) Resume() bool { var carg0 *C.GstTask // in, none, converted var cret C.gboolean // return carg0 = (*C.GstTask)(UnsafeTaskToGlibNone(task)) cret = C.gst_task_resume(carg0) runtime.KeepAlive(task) var goret bool if cret != 0 { goret = true } return goret } // SetPool wraps gst_task_set_pool // // The function takes the following parameters: // // - pool TaskPool: a #GstTaskPool // // Set @pool as the new GstTaskPool for @task. Any new streaming threads that // will be created by @task will now use @pool. // // MT safe. func (task *TaskInstance) SetPool(pool TaskPool) { var carg0 *C.GstTask // in, none, converted var carg1 *C.GstTaskPool // in, none, converted carg0 = (*C.GstTask)(UnsafeTaskToGlibNone(task)) carg1 = (*C.GstTaskPool)(UnsafeTaskPoolToGlibNone(pool)) C.gst_task_set_pool(carg0, carg1) runtime.KeepAlive(task) runtime.KeepAlive(pool) } // SetState wraps gst_task_set_state // // The function takes the following parameters: // // - state TaskState: the new task state // // The function returns the following values: // // - goret bool // // Sets the state of @task to @state. // // The @task must have a lock associated with it using // gst_task_set_lock() when going to GST_TASK_STARTED or GST_TASK_PAUSED or // this function will return %FALSE. // // MT safe. func (task *TaskInstance) SetState(state TaskState) bool { var carg0 *C.GstTask // in, none, converted var carg1 C.GstTaskState // in, none, casted var cret C.gboolean // return carg0 = (*C.GstTask)(UnsafeTaskToGlibNone(task)) carg1 = C.GstTaskState(state) cret = C.gst_task_set_state(carg0, carg1) runtime.KeepAlive(task) runtime.KeepAlive(state) var goret bool if cret != 0 { goret = true } return goret } // Start wraps gst_task_start // // The function returns the following values: // // - goret bool // // Starts @task. The @task must have a lock associated with it using // gst_task_set_lock() or this function will return %FALSE. func (task *TaskInstance) Start() bool { var carg0 *C.GstTask // in, none, converted var cret C.gboolean // return carg0 = (*C.GstTask)(UnsafeTaskToGlibNone(task)) cret = C.gst_task_start(carg0) runtime.KeepAlive(task) var goret bool if cret != 0 { goret = true } return goret } // Stop wraps gst_task_stop // // The function returns the following values: // // - goret bool // // Stops @task. This method merely schedules the task to stop and // will not wait for the task to have completely stopped. Use // gst_task_join() to stop and wait for completion. func (task *TaskInstance) Stop() bool { var carg0 *C.GstTask // in, none, converted var cret C.gboolean // return carg0 = (*C.GstTask)(UnsafeTaskToGlibNone(task)) cret = C.gst_task_stop(carg0) runtime.KeepAlive(task) var goret bool if cret != 0 { goret = true } 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 ObjectInstance } var _ TaskPool = (*TaskPoolInstance)(nil) // TaskPool wraps GstTaskPool // // This object provides an abstraction for creating threads. The default // implementation uses a regular GThreadPool to start tasks. // // Subclasses can be made to create custom threads. type TaskPool interface { Object upcastToGstTaskPool() *TaskPoolInstance // Cleanup wraps gst_task_pool_cleanup // // Wait for all tasks to be stopped. This is mainly used internally // to ensure proper cleanup of internal data structures in test suites. // // MT safe. Cleanup() // Prepare wraps gst_task_pool_prepare // // The function returns the following values: // // - _goerr error (nullable): an error // // Prepare the taskpool for accepting gst_task_pool_push() operations. // // MT safe. Prepare() error } func unsafeWrapTaskPool(base *gobject.ObjectInstance) *TaskPoolInstance { return &TaskPoolInstance{ ObjectInstance: ObjectInstance{ InitiallyUnownedInstance: gobject.InitiallyUnownedInstance{ ObjectInstance: *base, }, }, } } func marshalTaskPoolInstance(p unsafe.Pointer) (any, error) { return unsafeWrapTaskPool(gobject.ValueFromNative(p).Object()), nil } // UnsafeTaskPoolFromGlibNone is used to convert raw GstTaskPool pointers to go while taking a reference and attaching a finalizer. This is used by the bindings internally. func UnsafeTaskPoolFromGlibNone(c unsafe.Pointer) TaskPool { return gobject.UnsafeObjectFromGlibNone(c).(TaskPool) } // UnsafeTaskPoolFromGlibFull is used to convert raw GstTaskPool pointers to go while attaching a finalizer. This is used by the bindings internally. func UnsafeTaskPoolFromGlibFull(c unsafe.Pointer) TaskPool { return gobject.UnsafeObjectFromGlibFull(c).(TaskPool) } func (t *TaskPoolInstance) upcastToGstTaskPool() *TaskPoolInstance { return t } // UnsafeTaskPoolToGlibNone is used to convert the instance to it's C value GstTaskPool. This is used by the bindings internally. func UnsafeTaskPoolToGlibNone(c TaskPool) unsafe.Pointer { return gobject.UnsafeObjectToGlibNone(c) } // UnsafeTaskPoolToGlibFull is used to convert the instance to it's C value GstTaskPool, while removeing the finalizer. This is used by the bindings internally. func UnsafeTaskPoolToGlibFull(c TaskPool) unsafe.Pointer { return gobject.UnsafeObjectToGlibFull(c) } // NewTaskPool wraps gst_task_pool_new // // The function returns the following values: // // - goret TaskPool // // Create a new default task pool. The default task pool will use a regular // GThreadPool for threads. func NewTaskPool() TaskPool { var cret *C.GstTaskPool // return, full, converted cret = C.gst_task_pool_new() var goret TaskPool goret = UnsafeTaskPoolFromGlibFull(unsafe.Pointer(cret)) return goret } // Cleanup wraps gst_task_pool_cleanup // // Wait for all tasks to be stopped. This is mainly used internally // to ensure proper cleanup of internal data structures in test suites. // // MT safe. func (pool *TaskPoolInstance) Cleanup() { var carg0 *C.GstTaskPool // in, none, converted carg0 = (*C.GstTaskPool)(UnsafeTaskPoolToGlibNone(pool)) C.gst_task_pool_cleanup(carg0) runtime.KeepAlive(pool) } // Prepare wraps gst_task_pool_prepare // // The function returns the following values: // // - _goerr error (nullable): an error // // Prepare the taskpool for accepting gst_task_pool_push() operations. // // MT safe. func (pool *TaskPoolInstance) Prepare() error { var carg0 *C.GstTaskPool // in, none, converted var _cerr *C.GError // out, full, converted, nullable carg0 = (*C.GstTaskPool)(UnsafeTaskPoolToGlibNone(pool)) C.gst_task_pool_prepare(carg0, &_cerr) runtime.KeepAlive(pool) var _goerr error if _cerr != nil { _goerr = glib.UnsafeErrorFromGlibFull(unsafe.Pointer(_cerr)) } 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 ObjectInstance } var _ Tracer = (*TracerInstance)(nil) // Tracer wraps GstTracer // // Tracing modules will subclass #GstTracer and register through // gst_tracer_register(). Modules can attach to various hook-types - see // gst_tracing_register_hook(). When invoked they receive hook specific // contextual data, which they must not modify. type Tracer interface { Object upcastToGstTracer() *TracerInstance } func unsafeWrapTracer(base *gobject.ObjectInstance) *TracerInstance { return &TracerInstance{ ObjectInstance: ObjectInstance{ InitiallyUnownedInstance: gobject.InitiallyUnownedInstance{ ObjectInstance: *base, }, }, } } func marshalTracerInstance(p unsafe.Pointer) (any, error) { return unsafeWrapTracer(gobject.ValueFromNative(p).Object()), nil } // UnsafeTracerFromGlibNone is used to convert raw GstTracer pointers to go while taking a reference and attaching a finalizer. This is used by the bindings internally. func UnsafeTracerFromGlibNone(c unsafe.Pointer) Tracer { return gobject.UnsafeObjectFromGlibNone(c).(Tracer) } // UnsafeTracerFromGlibFull is used to convert raw GstTracer pointers to go while attaching a finalizer. This is used by the bindings internally. func UnsafeTracerFromGlibFull(c unsafe.Pointer) Tracer { return gobject.UnsafeObjectFromGlibFull(c).(Tracer) } func (t *TracerInstance) upcastToGstTracer() *TracerInstance { return t } // UnsafeTracerToGlibNone is used to convert the instance to it's C value GstTracer. This is used by the bindings internally. func UnsafeTracerToGlibNone(c Tracer) unsafe.Pointer { return gobject.UnsafeObjectToGlibNone(c) } // UnsafeTracerToGlibFull is used to convert the instance to it's C value GstTracer, while removeing the finalizer. This is used by the bindings internally. func UnsafeTracerToGlibFull(c Tracer) unsafe.Pointer { return gobject.UnsafeObjectToGlibFull(c) } // TracerRegister wraps gst_tracer_register // // The function takes the following parameters: // // - plugin Plugin (nullable): A #GstPlugin, or %NULL for a static typefind function // - name string: The name for registering // - typ gobject.Type: GType of tracer to register // // The function returns the following values: // // - goret bool // // Create a new tracer-factory capable of instantiating objects of the // @type and add the factory to @plugin. func TracerRegister(plugin Plugin, name string, typ gobject.Type) bool { var carg1 *C.GstPlugin // in, none, converted, nullable var carg2 *C.gchar // in, none, string var carg3 C.GType // in, none, casted, alias var cret C.gboolean // return if plugin != nil { carg1 = (*C.GstPlugin)(UnsafePluginToGlibNone(plugin)) } carg2 = (*C.gchar)(unsafe.Pointer(C.CString(name))) defer C.free(unsafe.Pointer(carg2)) carg3 = C.GType(typ) cret = C.gst_tracer_register(carg1, carg2, carg3) runtime.KeepAlive(plugin) runtime.KeepAlive(name) runtime.KeepAlive(typ) var goret bool if cret != 0 { goret = true } 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 PluginFeatureInstance } var _ TracerFactory = (*TracerFactoryInstance)(nil) // TracerFactory wraps GstTracerFactory // // Use gst_tracer_factory_get_list() to get a list of tracer factories known to // GStreamer. type TracerFactory interface { PluginFeature upcastToGstTracerFactory() *TracerFactoryInstance // GetTracerType wraps gst_tracer_factory_get_tracer_type // // The function returns the following values: // // - goret gobject.Type // // Get the #GType for elements managed by this factory. The type can // only be retrieved if the element factory is loaded, which can be // assured with gst_plugin_feature_load(). GetTracerType() gobject.Type } func unsafeWrapTracerFactory(base *gobject.ObjectInstance) *TracerFactoryInstance { return &TracerFactoryInstance{ PluginFeatureInstance: PluginFeatureInstance{ ObjectInstance: ObjectInstance{ InitiallyUnownedInstance: gobject.InitiallyUnownedInstance{ ObjectInstance: *base, }, }, }, } } func marshalTracerFactoryInstance(p unsafe.Pointer) (any, error) { return unsafeWrapTracerFactory(gobject.ValueFromNative(p).Object()), nil } // UnsafeTracerFactoryFromGlibNone is used to convert raw GstTracerFactory pointers to go while taking a reference and attaching a finalizer. This is used by the bindings internally. func UnsafeTracerFactoryFromGlibNone(c unsafe.Pointer) TracerFactory { return gobject.UnsafeObjectFromGlibNone(c).(TracerFactory) } // UnsafeTracerFactoryFromGlibFull is used to convert raw GstTracerFactory pointers to go while attaching a finalizer. This is used by the bindings internally. func UnsafeTracerFactoryFromGlibFull(c unsafe.Pointer) TracerFactory { return gobject.UnsafeObjectFromGlibFull(c).(TracerFactory) } func (t *TracerFactoryInstance) upcastToGstTracerFactory() *TracerFactoryInstance { return t } // UnsafeTracerFactoryToGlibNone is used to convert the instance to it's C value GstTracerFactory. This is used by the bindings internally. func UnsafeTracerFactoryToGlibNone(c TracerFactory) unsafe.Pointer { return gobject.UnsafeObjectToGlibNone(c) } // UnsafeTracerFactoryToGlibFull is used to convert the instance to it's C value GstTracerFactory, while removeing the finalizer. This is used by the bindings internally. func UnsafeTracerFactoryToGlibFull(c TracerFactory) unsafe.Pointer { return gobject.UnsafeObjectToGlibFull(c) } // TracerFactoryGetList wraps gst_tracer_factory_get_list // // The function returns the following values: // // - goret []TracerFactory // // Gets the list of all registered tracer factories. You must free the // list using gst_plugin_feature_list_free(). // // The returned factories are sorted by factory name. // // Free-function: gst_plugin_feature_list_free func TracerFactoryGetList() []TracerFactory { var cret *C.GList // container, transfer: full cret = C.gst_tracer_factory_get_list() var goret []TracerFactory goret = glib.UnsafeListFromGlibFull( unsafe.Pointer(cret), func(v unsafe.Pointer) TracerFactory { var dst TracerFactory // converted dst = UnsafeTracerFactoryFromGlibFull(v) return dst }, ) return goret } // GetTracerType wraps gst_tracer_factory_get_tracer_type // // The function returns the following values: // // - goret gobject.Type // // Get the #GType for elements managed by this factory. The type can // only be retrieved if the element factory is loaded, which can be // assured with gst_plugin_feature_load(). func (factory *TracerFactoryInstance) GetTracerType() gobject.Type { var carg0 *C.GstTracerFactory // in, none, converted var cret C.GType // return, none, casted, alias carg0 = (*C.GstTracerFactory)(UnsafeTracerFactoryToGlibNone(factory)) cret = C.gst_tracer_factory_get_tracer_type(carg0) runtime.KeepAlive(factory) var goret gobject.Type goret = gobject.Type(cret) return goret } // TracerRecordInstance is the instance type used by all types extending GstTracerRecord. It is used internally by the bindings. Users should use the interface [TracerRecord] instead. type TracerRecordInstance struct { _ [0]func() // equal guard ObjectInstance } var _ TracerRecord = (*TracerRecordInstance)(nil) // TracerRecord wraps GstTracerRecord // // Tracing modules will create instances of this class to announce the data they // will log and create a log formatter. type TracerRecord interface { Object upcastToGstTracerRecord() *TracerRecordInstance } func unsafeWrapTracerRecord(base *gobject.ObjectInstance) *TracerRecordInstance { return &TracerRecordInstance{ ObjectInstance: ObjectInstance{ InitiallyUnownedInstance: gobject.InitiallyUnownedInstance{ ObjectInstance: *base, }, }, } } func marshalTracerRecordInstance(p unsafe.Pointer) (any, error) { return unsafeWrapTracerRecord(gobject.ValueFromNative(p).Object()), nil } // UnsafeTracerRecordFromGlibNone is used to convert raw GstTracerRecord pointers to go while taking a reference and attaching a finalizer. This is used by the bindings internally. func UnsafeTracerRecordFromGlibNone(c unsafe.Pointer) TracerRecord { return gobject.UnsafeObjectFromGlibNone(c).(TracerRecord) } // UnsafeTracerRecordFromGlibFull is used to convert raw GstTracerRecord pointers to go while attaching a finalizer. This is used by the bindings internally. func UnsafeTracerRecordFromGlibFull(c unsafe.Pointer) TracerRecord { return gobject.UnsafeObjectFromGlibFull(c).(TracerRecord) } func (t *TracerRecordInstance) upcastToGstTracerRecord() *TracerRecordInstance { return t } // UnsafeTracerRecordToGlibNone is used to convert the instance to it's C value GstTracerRecord. This is used by the bindings internally. func UnsafeTracerRecordToGlibNone(c TracerRecord) unsafe.Pointer { return gobject.UnsafeObjectToGlibNone(c) } // UnsafeTracerRecordToGlibFull is used to convert the instance to it's C value GstTracerRecord, while removeing the finalizer. This is used by the bindings internally. func UnsafeTracerRecordToGlibFull(c TracerRecord) unsafe.Pointer { return gobject.UnsafeObjectToGlibFull(c) } // TypeFindFactoryInstance is the instance type used by all types extending GstTypeFindFactory. It is used internally by the bindings. Users should use the interface [TypeFindFactory] instead. type TypeFindFactoryInstance struct { _ [0]func() // equal guard PluginFeatureInstance } var _ TypeFindFactory = (*TypeFindFactoryInstance)(nil) // TypeFindFactory wraps GstTypeFindFactory // // These functions allow querying information about registered typefind // functions. How to create and register these functions is described in // the section <link linkend="gstreamer-Writing-typefind-functions"> // "Writing typefind functions"</link>. // // The following example shows how to write a very simple typefinder that // identifies the given data. You can get quite a bit more complicated than // that though. // |[<!-- language="C" --> // typedef struct { // guint8 *data; // guint size; // guint probability; // GstCaps *data; // } MyTypeFind; // static void // my_peek (gpointer data, gint64 offset, guint size) // { // MyTypeFind *find = (MyTypeFind *) data; // if (offset >= 0 && offset + size <= find->size) { // return find->data + offset; // } // return NULL; // } // static void // my_suggest (gpointer data, guint probability, GstCaps *caps) // { // MyTypeFind *find = (MyTypeFind *) data; // if (probability > find->probability) { // find->probability = probability; // gst_caps_replace (&find->caps, caps); // } // } // static GstCaps * // find_type (guint8 *data, guint size) // { // GList *walk, *type_list; // MyTypeFind find = {data, size, 0, NULL}; // GstTypeFind gst_find = {my_peek, my_suggest, &find, }; // walk = type_list = gst_type_find_factory_get_list (); // while (walk) { // GstTypeFindFactory *factory = GST_TYPE_FIND_FACTORY (walk->data); // walk = g_list_next (walk) // gst_type_find_factory_call_function (factory, &gst_find); // } // g_list_free (type_list); // return find.caps; // }; // ]| type TypeFindFactory interface { PluginFeature upcastToGstTypeFindFactory() *TypeFindFactoryInstance // CallFunction wraps gst_type_find_factory_call_function // // The function takes the following parameters: // // - find *TypeFind: a properly setup #GstTypeFind entry. The get_data // and suggest_type members must be set. // // 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) // // 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) // // Gets the extensions associated with a #GstTypeFindFactory. The returned // array should not be changed. If you need to change stuff in it, you should // copy it using g_strdupv(). This function may return %NULL to indicate // a 0-length list. GetExtensions() []string // HasFunction wraps gst_type_find_factory_has_function // // The function returns the following values: // // - goret bool // // Check whether the factory has a typefind function. Typefind factories // without typefind functions are a last-effort fallback mechanism to // e.g. assume a certain media type based on the file extension. HasFunction() bool } func unsafeWrapTypeFindFactory(base *gobject.ObjectInstance) *TypeFindFactoryInstance { return &TypeFindFactoryInstance{ PluginFeatureInstance: PluginFeatureInstance{ ObjectInstance: ObjectInstance{ InitiallyUnownedInstance: gobject.InitiallyUnownedInstance{ ObjectInstance: *base, }, }, }, } } func marshalTypeFindFactoryInstance(p unsafe.Pointer) (any, error) { return unsafeWrapTypeFindFactory(gobject.ValueFromNative(p).Object()), nil } // UnsafeTypeFindFactoryFromGlibNone is used to convert raw GstTypeFindFactory pointers to go while taking a reference and attaching a finalizer. This is used by the bindings internally. func UnsafeTypeFindFactoryFromGlibNone(c unsafe.Pointer) TypeFindFactory { return gobject.UnsafeObjectFromGlibNone(c).(TypeFindFactory) } // UnsafeTypeFindFactoryFromGlibFull is used to convert raw GstTypeFindFactory pointers to go while attaching a finalizer. This is used by the bindings internally. func UnsafeTypeFindFactoryFromGlibFull(c unsafe.Pointer) TypeFindFactory { return gobject.UnsafeObjectFromGlibFull(c).(TypeFindFactory) } func (t *TypeFindFactoryInstance) upcastToGstTypeFindFactory() *TypeFindFactoryInstance { return t } // UnsafeTypeFindFactoryToGlibNone is used to convert the instance to it's C value GstTypeFindFactory. This is used by the bindings internally. func UnsafeTypeFindFactoryToGlibNone(c TypeFindFactory) unsafe.Pointer { return gobject.UnsafeObjectToGlibNone(c) } // UnsafeTypeFindFactoryToGlibFull is used to convert the instance to it's C value GstTypeFindFactory, while removeing the finalizer. This is used by the bindings internally. func UnsafeTypeFindFactoryToGlibFull(c TypeFindFactory) unsafe.Pointer { return gobject.UnsafeObjectToGlibFull(c) } // TypeFindFactoryGetList wraps gst_type_find_factory_get_list // // The function returns the following values: // // - goret []TypeFindFactory // // Gets the list of all registered typefind factories. You must free the // list using gst_plugin_feature_list_free(). // // The returned factories are sorted by highest rank first, and then by // factory name. // // Free-function: gst_plugin_feature_list_free func TypeFindFactoryGetList() []TypeFindFactory { var cret *C.GList // container, transfer: full cret = C.gst_type_find_factory_get_list() var goret []TypeFindFactory goret = glib.UnsafeListFromGlibFull( unsafe.Pointer(cret), func(v unsafe.Pointer) TypeFindFactory { var dst TypeFindFactory // converted dst = UnsafeTypeFindFactoryFromGlibFull(v) return dst }, ) return goret } // CallFunction wraps gst_type_find_factory_call_function // // The function takes the following parameters: // // - find *TypeFind: a properly setup #GstTypeFind entry. The get_data // and suggest_type members must be set. // // Calls the #GstTypeFindFunction associated with this factory. func (factory *TypeFindFactoryInstance) CallFunction(find *TypeFind) { var carg0 *C.GstTypeFindFactory // in, none, converted var carg1 *C.GstTypeFind // in, none, converted carg0 = (*C.GstTypeFindFactory)(UnsafeTypeFindFactoryToGlibNone(factory)) carg1 = (*C.GstTypeFind)(UnsafeTypeFindToGlibNone(find)) C.gst_type_find_factory_call_function(carg0, carg1) runtime.KeepAlive(factory) runtime.KeepAlive(find) } // GetCaps wraps gst_type_find_factory_get_caps // // The function returns the following values: // // - goret *Caps (nullable) // // Gets the #GstCaps associated with a typefind factory. func (factory *TypeFindFactoryInstance) GetCaps() *Caps { var carg0 *C.GstTypeFindFactory // in, none, converted var cret *C.GstCaps // return, none, converted, nullable carg0 = (*C.GstTypeFindFactory)(UnsafeTypeFindFactoryToGlibNone(factory)) cret = C.gst_type_find_factory_get_caps(carg0) runtime.KeepAlive(factory) var goret *Caps if cret != nil { goret = UnsafeCapsFromGlibNone(unsafe.Pointer(cret)) } return goret } // GetExtensions wraps gst_type_find_factory_get_extensions // // The function returns the following values: // // - goret []string (nullable) // // Gets the extensions associated with a #GstTypeFindFactory. The returned // array should not be changed. If you need to change stuff in it, you should // copy it using g_strdupv(). This function may return %NULL to indicate // a 0-length list. func (factory *TypeFindFactoryInstance) GetExtensions() []string { var carg0 *C.GstTypeFindFactory // in, none, converted var cret **C.gchar // return, transfer: none, C Pointers: 2, Name: array[utf8], scope: , nullable, array (inner: *typesystem.StringPrimitive, zero-terminated) carg0 = (*C.GstTypeFindFactory)(UnsafeTypeFindFactoryToGlibNone(factory)) cret = C.gst_type_find_factory_get_extensions(carg0) runtime.KeepAlive(factory) var goret []string _ = goret _ = cret panic("unimplemented conversion of []string (const gchar* const*)") return goret } // HasFunction wraps gst_type_find_factory_has_function // // The function returns the following values: // // - goret bool // // Check whether the factory has a typefind function. Typefind factories // without typefind functions are a last-effort fallback mechanism to // e.g. assume a certain media type based on the file extension. func (factory *TypeFindFactoryInstance) HasFunction() bool { var carg0 *C.GstTypeFindFactory // in, none, converted var cret C.gboolean // return carg0 = (*C.GstTypeFindFactory)(UnsafeTypeFindFactoryToGlibNone(factory)) cret = C.gst_type_find_factory_has_function(carg0) runtime.KeepAlive(factory) var goret bool if cret != 0 { goret = true } return goret } // AllocatorInstance is the instance type used by all types extending GstAllocator. It is used internally by the bindings. Users should use the interface [Allocator] instead. type AllocatorInstance struct { _ [0]func() // equal guard ObjectInstance } var _ Allocator = (*AllocatorInstance)(nil) // Allocator wraps GstAllocator // // Memory is usually created by allocators with a gst_allocator_alloc() // method call. When %NULL is used as the allocator, the default allocator will // be used. // // New allocators can be registered with gst_allocator_register(). // Allocators are identified by name and can be retrieved with // gst_allocator_find(). gst_allocator_set_default() can be used to change the // default allocator. // // New memory can be created with gst_memory_new_wrapped() that wraps the memory // allocated elsewhere. type Allocator interface { Object upcastToGstAllocator() *AllocatorInstance // Alloc wraps gst_allocator_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) // // Use @allocator to allocate a new memory block with memory that is at least // @size big. // // The optional @params can specify the prefix and padding for the memory. If // %NULL is passed, no flags, no extra prefix/padding and a default alignment is // used. // // The prefix/padding will be filled with 0 if flags contains // #GST_MEMORY_FLAG_ZERO_PREFIXED and #GST_MEMORY_FLAG_ZERO_PADDED respectively. // // When @allocator is %NULL, the default allocator will be used. // // The alignment in @params is given as a bitmask so that @align + 1 equals // the amount of bytes to align to. For example, to align to 8 bytes, // use an alignment of 7. Alloc(uint, *AllocationParams) *Memory // Free wraps gst_allocator_free // // The function takes the following parameters: // // - memory *Memory: the memory to free // // Free @memory that was previously allocated with gst_allocator_alloc(). Free(*Memory) // SetDefault wraps gst_allocator_set_default // // Set the default allocator. SetDefault() } func unsafeWrapAllocator(base *gobject.ObjectInstance) *AllocatorInstance { return &AllocatorInstance{ ObjectInstance: ObjectInstance{ InitiallyUnownedInstance: gobject.InitiallyUnownedInstance{ ObjectInstance: *base, }, }, } } func marshalAllocatorInstance(p unsafe.Pointer) (any, error) { return unsafeWrapAllocator(gobject.ValueFromNative(p).Object()), nil } // UnsafeAllocatorFromGlibNone is used to convert raw GstAllocator pointers to go while taking a reference and attaching a finalizer. This is used by the bindings internally. func UnsafeAllocatorFromGlibNone(c unsafe.Pointer) Allocator { return gobject.UnsafeObjectFromGlibNone(c).(Allocator) } // UnsafeAllocatorFromGlibFull is used to convert raw GstAllocator pointers to go while attaching a finalizer. This is used by the bindings internally. func UnsafeAllocatorFromGlibFull(c unsafe.Pointer) Allocator { return gobject.UnsafeObjectFromGlibFull(c).(Allocator) } func (a *AllocatorInstance) upcastToGstAllocator() *AllocatorInstance { return a } // UnsafeAllocatorToGlibNone is used to convert the instance to it's C value GstAllocator. This is used by the bindings internally. func UnsafeAllocatorToGlibNone(c Allocator) unsafe.Pointer { return gobject.UnsafeObjectToGlibNone(c) } // UnsafeAllocatorToGlibFull is used to convert the instance to it's C value GstAllocator, while removeing the finalizer. This is used by the bindings internally. func UnsafeAllocatorToGlibFull(c Allocator) unsafe.Pointer { return gobject.UnsafeObjectToGlibFull(c) } // AllocatorFind wraps gst_allocator_find // // The function takes the following parameters: // // - name string (nullable): the name of the allocator // // The function returns the following values: // // - goret Allocator (nullable) // // Find a previously registered allocator with @name. When @name is %NULL, the // default allocator will be returned. func AllocatorFind(name string) Allocator { var carg1 *C.gchar // in, none, string, nullable-string var cret *C.GstAllocator // return, full, converted, nullable if name != "" { carg1 = (*C.gchar)(unsafe.Pointer(C.CString(name))) defer C.free(unsafe.Pointer(carg1)) } cret = C.gst_allocator_find(carg1) runtime.KeepAlive(name) var goret Allocator if cret != nil { goret = UnsafeAllocatorFromGlibFull(unsafe.Pointer(cret)) } return goret } // AllocatorRegister wraps gst_allocator_register // // The function takes the following parameters: // // - name string: the name of the allocator // - allocator Allocator: #GstAllocator // // Registers the memory @allocator with @name. func AllocatorRegister(name string, allocator Allocator) { var carg1 *C.gchar // in, none, string var carg2 *C.GstAllocator // in, full, converted carg1 = (*C.gchar)(unsafe.Pointer(C.CString(name))) defer C.free(unsafe.Pointer(carg1)) carg2 = (*C.GstAllocator)(UnsafeAllocatorToGlibFull(allocator)) C.gst_allocator_register(carg1, carg2) runtime.KeepAlive(name) runtime.KeepAlive(allocator) } // Alloc wraps gst_allocator_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) // // Use @allocator to allocate a new memory block with memory that is at least // @size big. // // The optional @params can specify the prefix and padding for the memory. If // %NULL is passed, no flags, no extra prefix/padding and a default alignment is // used. // // The prefix/padding will be filled with 0 if flags contains // #GST_MEMORY_FLAG_ZERO_PREFIXED and #GST_MEMORY_FLAG_ZERO_PADDED respectively. // // When @allocator is %NULL, the default allocator will be used. // // The alignment in @params is given as a bitmask so that @align + 1 equals // the amount of bytes to align to. For example, to align to 8 bytes, // use an alignment of 7. func (allocator *AllocatorInstance) Alloc(size uint, params *AllocationParams) *Memory { var carg0 *C.GstAllocator // in, none, converted var carg1 C.gsize // in, none, casted var carg2 *C.GstAllocationParams // in, none, converted, nullable var cret *C.GstMemory // return, full, converted, nullable carg0 = (*C.GstAllocator)(UnsafeAllocatorToGlibNone(allocator)) carg1 = C.gsize(size) if params != nil { carg2 = (*C.GstAllocationParams)(UnsafeAllocationParamsToGlibNone(params)) } cret = C.gst_allocator_alloc(carg0, carg1, carg2) runtime.KeepAlive(allocator) runtime.KeepAlive(size) runtime.KeepAlive(params) var goret *Memory if cret != nil { goret = UnsafeMemoryFromGlibFull(unsafe.Pointer(cret)) } return goret } // Free wraps gst_allocator_free // // The function takes the following parameters: // // - memory *Memory: the memory to free // // Free @memory that was previously allocated with gst_allocator_alloc(). func (allocator *AllocatorInstance) Free(memory *Memory) { var carg0 *C.GstAllocator // in, none, converted var carg1 *C.GstMemory // in, full, converted carg0 = (*C.GstAllocator)(UnsafeAllocatorToGlibNone(allocator)) carg1 = (*C.GstMemory)(UnsafeMemoryToGlibFull(memory)) C.gst_allocator_free(carg0, carg1) runtime.KeepAlive(allocator) runtime.KeepAlive(memory) } // SetDefault wraps gst_allocator_set_default // // Set the default allocator. func (allocator *AllocatorInstance) SetDefault() { var carg0 *C.GstAllocator // in, none, converted carg0 = (*C.GstAllocator)(UnsafeAllocatorToGlibNone(allocator)) C.gst_allocator_set_default(carg0) 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 ObjectInstance } var _ BufferPool = (*BufferPoolInstance)(nil) // BufferPool wraps GstBufferPool // // A #GstBufferPool is an object that can be used to pre-allocate and recycle // buffers of the same size and with the same properties. // // A #GstBufferPool is created with gst_buffer_pool_new(). // // Once a pool is created, it needs to be configured. A call to // gst_buffer_pool_get_config() returns the current configuration structure from // the pool. With gst_buffer_pool_config_set_params() and // gst_buffer_pool_config_set_allocator() the bufferpool parameters and // allocator can be configured. Other properties can be configured in the pool // depending on the pool implementation. // // A bufferpool can have extra options that can be enabled with // gst_buffer_pool_config_add_option(). The available options can be retrieved // with gst_buffer_pool_get_options(). Some options allow for additional // configuration properties to be set. // // After the configuration structure has been configured, // gst_buffer_pool_set_config() updates the configuration in the pool. This can // fail when the configuration structure is not accepted. // // After the pool has been configured, it can be activated with // gst_buffer_pool_set_active(). This will preallocate the configured resources // in the pool. // // When the pool is active, gst_buffer_pool_acquire_buffer() can be used to // retrieve a buffer from the pool. // // Buffers allocated from a bufferpool will automatically be returned to the // pool with gst_buffer_pool_release_buffer() when their refcount drops to 0. // // The bufferpool can be deactivated again with gst_buffer_pool_set_active(). // All further gst_buffer_pool_acquire_buffer() calls will return an error. When // all buffers are returned to the pool they will be freed. type BufferPool interface { Object upcastToGstBufferPool() *BufferPoolInstance // AcquireBuffer wraps gst_buffer_pool_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 // // Acquires a buffer from @pool. @buffer should point to a memory location that // can hold a pointer to the new buffer. When the pool is empty, this function // will by default block until a buffer is released into the pool again or when // the pool is set to flushing or deactivated. // // @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 // // Gets a copy of the current configuration of the pool. This configuration // 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 // // Gets a %NULL terminated array of string with supported bufferpool options for // @pool. An option would typically be enabled with // gst_buffer_pool_config_add_option(). GetOptions() []string // HasOption wraps gst_buffer_pool_has_option // // The function takes the following parameters: // // - option string: an option // // The function returns the following values: // // - goret bool // // Checks if the bufferpool supports @option. HasOption(string) bool // IsActive wraps gst_buffer_pool_is_active // // The function returns the following values: // // - goret bool // // Checks if @pool is active. A pool can be activated with the // gst_buffer_pool_set_active() call. IsActive() bool // ReleaseBuffer wraps gst_buffer_pool_release_buffer // // The function takes the following parameters: // // - buffer *Buffer: a #GstBuffer // // Releases @buffer to @pool. @buffer should have previously been allocated from // @pool with gst_buffer_pool_acquire_buffer(). // // This function is usually called automatically when the last ref on @buffer // disappears. ReleaseBuffer(*Buffer) // SetActive wraps gst_buffer_pool_set_active // // The function takes the following parameters: // // - active bool: the new active state // // The function returns the following values: // // - goret bool // // Controls the active state of @pool. When the pool is inactive, new calls to // gst_buffer_pool_acquire_buffer() will return with %GST_FLOW_FLUSHING. // // Activating the bufferpool will preallocate all resources in the pool based on // the configuration of the pool. // // Deactivating will free the resources again when there are no outstanding // buffers. When there are outstanding buffers, they will be freed as soon as // they are all returned to the pool. SetActive(bool) bool // SetConfig wraps gst_buffer_pool_set_config // // The function takes the following parameters: // // - config *Structure: a #GstStructure // // The function returns the following values: // // - goret bool // // Sets the configuration of the pool. If the pool is already configured, and // the configuration hasn't changed, this function will return %TRUE. If the // pool is active, this method will return %FALSE and active configuration // will remain. Buffers allocated from this pool must be returned or else this // function will do nothing and return %FALSE. // // @config is a #GstStructure that contains the configuration parameters for // the pool. A default and mandatory set of parameters can be configured with // gst_buffer_pool_config_set_params(), gst_buffer_pool_config_set_allocator() // and gst_buffer_pool_config_add_option(). // // If the parameters in @config can not be set exactly, this function returns // %FALSE and will try to update as much state as possible. The new state can // then be retrieved and refined with gst_buffer_pool_get_config(). // // This function takes ownership of @config. SetConfig(*Structure) bool // SetFlushing wraps gst_buffer_pool_set_flushing // // The function takes the following parameters: // // - flushing bool: whether to start or stop flushing // // Enables or disables the flushing state of a @pool without freeing or // allocating buffers. SetFlushing(bool) } func unsafeWrapBufferPool(base *gobject.ObjectInstance) *BufferPoolInstance { return &BufferPoolInstance{ ObjectInstance: ObjectInstance{ InitiallyUnownedInstance: gobject.InitiallyUnownedInstance{ ObjectInstance: *base, }, }, } } func marshalBufferPoolInstance(p unsafe.Pointer) (any, error) { return unsafeWrapBufferPool(gobject.ValueFromNative(p).Object()), nil } // UnsafeBufferPoolFromGlibNone is used to convert raw GstBufferPool pointers to go while taking a reference and attaching a finalizer. This is used by the bindings internally. func UnsafeBufferPoolFromGlibNone(c unsafe.Pointer) BufferPool { return gobject.UnsafeObjectFromGlibNone(c).(BufferPool) } // UnsafeBufferPoolFromGlibFull is used to convert raw GstBufferPool pointers to go while attaching a finalizer. This is used by the bindings internally. func UnsafeBufferPoolFromGlibFull(c unsafe.Pointer) BufferPool { return gobject.UnsafeObjectFromGlibFull(c).(BufferPool) } func (b *BufferPoolInstance) upcastToGstBufferPool() *BufferPoolInstance { return b } // UnsafeBufferPoolToGlibNone is used to convert the instance to it's C value GstBufferPool. This is used by the bindings internally. func UnsafeBufferPoolToGlibNone(c BufferPool) unsafe.Pointer { return gobject.UnsafeObjectToGlibNone(c) } // UnsafeBufferPoolToGlibFull is used to convert the instance to it's C value GstBufferPool, while removeing the finalizer. This is used by the bindings internally. func UnsafeBufferPoolToGlibFull(c BufferPool) unsafe.Pointer { return gobject.UnsafeObjectToGlibFull(c) } // NewBufferPool wraps gst_buffer_pool_new // // The function returns the following values: // // - goret BufferPool // // Creates a new #GstBufferPool instance. func NewBufferPool() BufferPool { var cret *C.GstBufferPool // return, full, converted cret = C.gst_buffer_pool_new() var goret BufferPool goret = UnsafeBufferPoolFromGlibFull(unsafe.Pointer(cret)) return goret } // BufferPoolConfigAddOption wraps gst_buffer_pool_config_add_option // // The function takes the following parameters: // // - config *Structure: a #GstBufferPool configuration // - option string: an option to add // // Enables the option in @config. This will instruct the @bufferpool to enable // the specified option on the buffers that it allocates. // // The options supported by @pool can be retrieved with gst_buffer_pool_get_options(). func BufferPoolConfigAddOption(config *Structure, option string) { var carg1 *C.GstStructure // in, none, converted var carg2 *C.gchar // in, none, string carg1 = (*C.GstStructure)(UnsafeStructureToGlibNone(config)) carg2 = (*C.gchar)(unsafe.Pointer(C.CString(option))) defer C.free(unsafe.Pointer(carg2)) C.gst_buffer_pool_config_add_option(carg1, carg2) runtime.KeepAlive(config) runtime.KeepAlive(option) } // BufferPoolConfigGetAllocator wraps gst_buffer_pool_config_get_allocator // // The function takes the following parameters: // // - config *Structure: a #GstBufferPool configuration // // The function returns the following values: // // - allocator Allocator (nullable): a #GstAllocator, or %NULL // - params AllocationParams: #GstAllocationParams, or %NULL // - goret bool // // Gets the @allocator and @params from @config. func BufferPoolConfigGetAllocator(config *Structure) (Allocator, AllocationParams, bool) { var carg1 *C.GstStructure // in, none, converted var carg2 *C.GstAllocator // out, none, converted, nullable var carg3 C.GstAllocationParams // out, transfer: none, C Pointers: 0, Name: AllocationParams, optional, caller-allocates var cret C.gboolean // return carg1 = (*C.GstStructure)(UnsafeStructureToGlibNone(config)) cret = C.gst_buffer_pool_config_get_allocator(carg1, &carg2, &carg3) runtime.KeepAlive(config) var allocator Allocator var params AllocationParams var goret bool if carg2 != nil { allocator = UnsafeAllocatorFromGlibNone(unsafe.Pointer(carg2)) } _ = params _ = carg3 panic("unimplemented conversion of AllocationParams (GstAllocationParams)") if cret != 0 { goret = true } return allocator, params, goret } // BufferPoolConfigGetOption wraps gst_buffer_pool_config_get_option // // The function takes the following parameters: // // - config *Structure: a #GstBufferPool configuration // - index uint: position in the option array to read // // The function returns the following values: // // - goret string (nullable) // // Parses an available @config and gets the option at @index of the options API // array. func BufferPoolConfigGetOption(config *Structure, index uint) string { var carg1 *C.GstStructure // in, none, converted var carg2 C.guint // in, none, casted var cret *C.gchar // return, none, string, nullable-string carg1 = (*C.GstStructure)(UnsafeStructureToGlibNone(config)) carg2 = C.guint(index) cret = C.gst_buffer_pool_config_get_option(carg1, carg2) runtime.KeepAlive(config) runtime.KeepAlive(index) var goret string if cret != nil { goret = C.GoString((*C.char)(unsafe.Pointer(cret))) } return goret } // BufferPoolConfigGetParams wraps gst_buffer_pool_config_get_params // // The function takes the following parameters: // // - config *Structure: a #GstBufferPool configuration // // The function returns the following values: // // - caps *Caps (nullable): the caps of buffers // - size uint: the size of each buffer, not including prefix and padding // - minBuffers uint: the minimum amount of buffers to allocate. // - maxBuffers uint: the maximum amount of buffers to allocate or 0 for unlimited. // - goret bool // // Gets the configuration values from @config. func BufferPoolConfigGetParams(config *Structure) (*Caps, uint, uint, uint, bool) { var carg1 *C.GstStructure // in, none, converted var carg2 *C.GstCaps // out, none, converted, nullable var carg3 C.guint // out, full, casted var carg4 C.guint // out, full, casted var carg5 C.guint // out, full, casted var cret C.gboolean // return carg1 = (*C.GstStructure)(UnsafeStructureToGlibNone(config)) cret = C.gst_buffer_pool_config_get_params(carg1, &carg2, &carg3, &carg4, &carg5) runtime.KeepAlive(config) var caps *Caps var size uint var minBuffers uint var maxBuffers uint var goret bool if carg2 != nil { caps = UnsafeCapsFromGlibNone(unsafe.Pointer(carg2)) } size = uint(carg3) minBuffers = uint(carg4) maxBuffers = uint(carg5) if cret != 0 { goret = true } return caps, size, minBuffers, maxBuffers, goret } // BufferPoolConfigHasOption wraps gst_buffer_pool_config_has_option // // The function takes the following parameters: // // - config *Structure: a #GstBufferPool configuration // - option string: an option // // The function returns the following values: // // - goret bool // // Checks if @config contains @option. func BufferPoolConfigHasOption(config *Structure, option string) bool { var carg1 *C.GstStructure // in, none, converted var carg2 *C.gchar // in, none, string var cret C.gboolean // return carg1 = (*C.GstStructure)(UnsafeStructureToGlibNone(config)) carg2 = (*C.gchar)(unsafe.Pointer(C.CString(option))) defer C.free(unsafe.Pointer(carg2)) cret = C.gst_buffer_pool_config_has_option(carg1, carg2) runtime.KeepAlive(config) runtime.KeepAlive(option) var goret bool if cret != 0 { goret = true } return goret } // BufferPoolConfigNOptions wraps gst_buffer_pool_config_n_options // // The function takes the following parameters: // // - config *Structure: a #GstBufferPool configuration // // The function returns the following values: // // - goret uint // // Retrieves the number of values currently stored in the options array of the // @config structure. func BufferPoolConfigNOptions(config *Structure) uint { var carg1 *C.GstStructure // in, none, converted var cret C.guint // return, none, casted carg1 = (*C.GstStructure)(UnsafeStructureToGlibNone(config)) cret = C.gst_buffer_pool_config_n_options(carg1) runtime.KeepAlive(config) var goret uint goret = uint(cret) return goret } // BufferPoolConfigSetAllocator wraps gst_buffer_pool_config_set_allocator // // The function takes the following parameters: // // - config *Structure: a #GstBufferPool configuration // - allocator Allocator (nullable): a #GstAllocator // - params *AllocationParams (nullable): #GstAllocationParams // // Sets the @allocator and @params on @config. // // One of @allocator and @params can be %NULL, but not both. When @allocator // is %NULL, the default allocator of the pool will use the values in @param // to perform its allocation. When @param is %NULL, the pool will use the // provided @allocator with its default #GstAllocationParams. // // A call to gst_buffer_pool_set_config() can update the allocator and params // with the values that it is able to do. Some pools are, for example, not able // to operate with different allocators or cannot allocate with the values // specified in @params. Use gst_buffer_pool_get_config() to get the currently // used values. func BufferPoolConfigSetAllocator(config *Structure, allocator Allocator, params *AllocationParams) { var carg1 *C.GstStructure // in, none, converted var carg2 *C.GstAllocator // in, none, converted, nullable var carg3 *C.GstAllocationParams // in, none, converted, nullable carg1 = (*C.GstStructure)(UnsafeStructureToGlibNone(config)) if allocator != nil { carg2 = (*C.GstAllocator)(UnsafeAllocatorToGlibNone(allocator)) } if params != nil { carg3 = (*C.GstAllocationParams)(UnsafeAllocationParamsToGlibNone(params)) } C.gst_buffer_pool_config_set_allocator(carg1, carg2, carg3) runtime.KeepAlive(config) runtime.KeepAlive(allocator) runtime.KeepAlive(params) } // BufferPoolConfigSetParams wraps gst_buffer_pool_config_set_params // // The function takes the following parameters: // // - config *Structure: a #GstBufferPool configuration // - caps *Caps (nullable): caps for the buffers // - size uint: the size of each buffer, not including prefix and padding // - minBuffers uint: the minimum amount of buffers to allocate. // - maxBuffers uint: the maximum amount of buffers to allocate or 0 for unlimited. // // Configures @config with the given parameters. func BufferPoolConfigSetParams(config *Structure, caps *Caps, size uint, minBuffers uint, maxBuffers uint) { var carg1 *C.GstStructure // in, none, converted var carg2 *C.GstCaps // in, none, converted, nullable var carg3 C.guint // in, none, casted var carg4 C.guint // in, none, casted var carg5 C.guint // in, none, casted carg1 = (*C.GstStructure)(UnsafeStructureToGlibNone(config)) if caps != nil { carg2 = (*C.GstCaps)(UnsafeCapsToGlibNone(caps)) } carg3 = C.guint(size) carg4 = C.guint(minBuffers) carg5 = C.guint(maxBuffers) C.gst_buffer_pool_config_set_params(carg1, carg2, carg3, carg4, carg5) runtime.KeepAlive(config) runtime.KeepAlive(caps) runtime.KeepAlive(size) runtime.KeepAlive(minBuffers) runtime.KeepAlive(maxBuffers) } // BufferPoolConfigValidateParams wraps gst_buffer_pool_config_validate_params // // The function takes the following parameters: // // - config *Structure: a #GstBufferPool configuration // - caps *Caps (nullable): the excepted caps of buffers // - size uint: the expected size of each buffer, not including prefix and padding // - minBuffers uint: the expected minimum amount of buffers to allocate. // - maxBuffers uint: the expect maximum amount of buffers to allocate or 0 for unlimited. // // The function returns the following values: // // - goret bool // // Validates that changes made to @config are still valid in the context of the // expected parameters. This function is a helper that can be used to validate // changes made by a pool to a config when gst_buffer_pool_set_config() // returns %FALSE. This expects that @caps haven't changed and that // @min_buffers aren't lower then what we initially expected. // This does not check if options or allocator parameters are still valid, // won't check if size have changed, since changing the size is valid to adapt // padding. func BufferPoolConfigValidateParams(config *Structure, caps *Caps, size uint, minBuffers uint, maxBuffers uint) bool { var carg1 *C.GstStructure // in, none, converted var carg2 *C.GstCaps // in, none, converted, nullable var carg3 C.guint // in, none, casted var carg4 C.guint // in, none, casted var carg5 C.guint // in, none, casted var cret C.gboolean // return carg1 = (*C.GstStructure)(UnsafeStructureToGlibNone(config)) if caps != nil { carg2 = (*C.GstCaps)(UnsafeCapsToGlibNone(caps)) } carg3 = C.guint(size) carg4 = C.guint(minBuffers) carg5 = C.guint(maxBuffers) cret = C.gst_buffer_pool_config_validate_params(carg1, carg2, carg3, carg4, carg5) runtime.KeepAlive(config) runtime.KeepAlive(caps) runtime.KeepAlive(size) runtime.KeepAlive(minBuffers) runtime.KeepAlive(maxBuffers) var goret bool if cret != 0 { goret = true } return goret } // AcquireBuffer wraps gst_buffer_pool_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 // // Acquires a buffer from @pool. @buffer should point to a memory location that // can hold a pointer to the new buffer. When the pool is empty, this function // will by default block until a buffer is released into the pool again or when // the pool is set to flushing or deactivated. // // @params can contain optional parameters to influence the allocation. func (pool *BufferPoolInstance) AcquireBuffer(params *BufferPoolAcquireParams) (*Buffer, FlowReturn) { var carg0 *C.GstBufferPool // in, none, converted var carg2 *C.GstBufferPoolAcquireParams // in, none, converted, nullable var carg1 *C.GstBuffer // out, full, converted, nullable var cret C.GstFlowReturn // return, none, casted carg0 = (*C.GstBufferPool)(UnsafeBufferPoolToGlibNone(pool)) if params != nil { carg2 = (*C.GstBufferPoolAcquireParams)(UnsafeBufferPoolAcquireParamsToGlibNone(params)) } cret = C.gst_buffer_pool_acquire_buffer(carg0, &carg1, carg2) runtime.KeepAlive(pool) runtime.KeepAlive(params) var buffer *Buffer var goret FlowReturn if carg1 != nil { buffer = UnsafeBufferFromGlibFull(unsafe.Pointer(carg1)) } goret = FlowReturn(cret) return buffer, goret } // GetConfig wraps gst_buffer_pool_get_config // // The function returns the following values: // // - goret *Structure // // Gets a copy of the current configuration of the pool. This configuration // can be modified and used for the gst_buffer_pool_set_config() call. func (pool *BufferPoolInstance) GetConfig() *Structure { var carg0 *C.GstBufferPool // in, none, converted var cret *C.GstStructure // return, full, converted carg0 = (*C.GstBufferPool)(UnsafeBufferPoolToGlibNone(pool)) cret = C.gst_buffer_pool_get_config(carg0) runtime.KeepAlive(pool) var goret *Structure goret = UnsafeStructureFromGlibFull(unsafe.Pointer(cret)) return goret } // GetOptions wraps gst_buffer_pool_get_options // // The function returns the following values: // // - goret []string // // Gets a %NULL terminated array of string with supported bufferpool options for // @pool. An option would typically be enabled with // gst_buffer_pool_config_add_option(). func (pool *BufferPoolInstance) GetOptions() []string { var carg0 *C.GstBufferPool // in, none, converted var cret **C.gchar // return, transfer: none, C Pointers: 2, Name: array[utf8], scope: , array (inner: *typesystem.StringPrimitive, zero-terminated) carg0 = (*C.GstBufferPool)(UnsafeBufferPoolToGlibNone(pool)) cret = C.gst_buffer_pool_get_options(carg0) runtime.KeepAlive(pool) var goret []string _ = goret _ = cret panic("unimplemented conversion of []string (const gchar**)") return goret } // HasOption wraps gst_buffer_pool_has_option // // The function takes the following parameters: // // - option string: an option // // The function returns the following values: // // - goret bool // // Checks if the bufferpool supports @option. func (pool *BufferPoolInstance) HasOption(option string) bool { var carg0 *C.GstBufferPool // in, none, converted var carg1 *C.gchar // in, none, string var cret C.gboolean // return carg0 = (*C.GstBufferPool)(UnsafeBufferPoolToGlibNone(pool)) carg1 = (*C.gchar)(unsafe.Pointer(C.CString(option))) defer C.free(unsafe.Pointer(carg1)) cret = C.gst_buffer_pool_has_option(carg0, carg1) runtime.KeepAlive(pool) runtime.KeepAlive(option) var goret bool if cret != 0 { goret = true } return goret } // IsActive wraps gst_buffer_pool_is_active // // The function returns the following values: // // - goret bool // // Checks if @pool is active. A pool can be activated with the // gst_buffer_pool_set_active() call. func (pool *BufferPoolInstance) IsActive() bool { var carg0 *C.GstBufferPool // in, none, converted var cret C.gboolean // return carg0 = (*C.GstBufferPool)(UnsafeBufferPoolToGlibNone(pool)) cret = C.gst_buffer_pool_is_active(carg0) runtime.KeepAlive(pool) var goret bool if cret != 0 { goret = true } return goret } // ReleaseBuffer wraps gst_buffer_pool_release_buffer // // The function takes the following parameters: // // - buffer *Buffer: a #GstBuffer // // Releases @buffer to @pool. @buffer should have previously been allocated from // @pool with gst_buffer_pool_acquire_buffer(). // // This function is usually called automatically when the last ref on @buffer // disappears. func (pool *BufferPoolInstance) ReleaseBuffer(buffer *Buffer) { var carg0 *C.GstBufferPool // in, none, converted var carg1 *C.GstBuffer // in, full, converted carg0 = (*C.GstBufferPool)(UnsafeBufferPoolToGlibNone(pool)) carg1 = (*C.GstBuffer)(UnsafeBufferToGlibFull(buffer)) C.gst_buffer_pool_release_buffer(carg0, carg1) runtime.KeepAlive(pool) runtime.KeepAlive(buffer) } // SetActive wraps gst_buffer_pool_set_active // // The function takes the following parameters: // // - active bool: the new active state // // The function returns the following values: // // - goret bool // // Controls the active state of @pool. When the pool is inactive, new calls to // gst_buffer_pool_acquire_buffer() will return with %GST_FLOW_FLUSHING. // // Activating the bufferpool will preallocate all resources in the pool based on // the configuration of the pool. // // Deactivating will free the resources again when there are no outstanding // buffers. When there are outstanding buffers, they will be freed as soon as // they are all returned to the pool. func (pool *BufferPoolInstance) SetActive(active bool) bool { var carg0 *C.GstBufferPool // in, none, converted var carg1 C.gboolean // in var cret C.gboolean // return carg0 = (*C.GstBufferPool)(UnsafeBufferPoolToGlibNone(pool)) if active { carg1 = C.TRUE } cret = C.gst_buffer_pool_set_active(carg0, carg1) runtime.KeepAlive(pool) runtime.KeepAlive(active) var goret bool if cret != 0 { goret = true } return goret } // SetConfig wraps gst_buffer_pool_set_config // // The function takes the following parameters: // // - config *Structure: a #GstStructure // // The function returns the following values: // // - goret bool // // Sets the configuration of the pool. If the pool is already configured, and // the configuration hasn't changed, this function will return %TRUE. If the // pool is active, this method will return %FALSE and active configuration // will remain. Buffers allocated from this pool must be returned or else this // function will do nothing and return %FALSE. // // @config is a #GstStructure that contains the configuration parameters for // the pool. A default and mandatory set of parameters can be configured with // gst_buffer_pool_config_set_params(), gst_buffer_pool_config_set_allocator() // and gst_buffer_pool_config_add_option(). // // If the parameters in @config can not be set exactly, this function returns // %FALSE and will try to update as much state as possible. The new state can // then be retrieved and refined with gst_buffer_pool_get_config(). // // This function takes ownership of @config. func (pool *BufferPoolInstance) SetConfig(config *Structure) bool { var carg0 *C.GstBufferPool // in, none, converted var carg1 *C.GstStructure // in, full, converted var cret C.gboolean // return carg0 = (*C.GstBufferPool)(UnsafeBufferPoolToGlibNone(pool)) carg1 = (*C.GstStructure)(UnsafeStructureToGlibFull(config)) cret = C.gst_buffer_pool_set_config(carg0, carg1) runtime.KeepAlive(pool) runtime.KeepAlive(config) var goret bool if cret != 0 { goret = true } return goret } // SetFlushing wraps gst_buffer_pool_set_flushing // // The function takes the following parameters: // // - flushing bool: whether to start or stop flushing // // Enables or disables the flushing state of a @pool without freeing or // allocating buffers. func (pool *BufferPoolInstance) SetFlushing(flushing bool) { var carg0 *C.GstBufferPool // in, none, converted var carg1 C.gboolean // in carg0 = (*C.GstBufferPool)(UnsafeBufferPoolToGlibNone(pool)) if flushing { carg1 = C.TRUE } C.gst_buffer_pool_set_flushing(carg0, carg1) runtime.KeepAlive(pool) 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 ObjectInstance } var _ Bus = (*BusInstance)(nil) // Bus wraps GstBus // // The #GstBus is an object responsible for delivering #GstMessage packets in // a first-in first-out way from the streaming threads (see #GstTask) to the // application. // // Since the application typically only wants to deal with delivery of these // messages from one thread, the GstBus will marshall the messages between // different threads. This is important since the actual streaming of media // is done in another thread than the application. // // The GstBus provides support for #GSource based notifications. This makes it // possible to handle the delivery in the glib #GMainLoop. // // The #GSource callback function gst_bus_async_signal_func() can be used to // convert all bus messages into signal emissions. // // A message is posted on the bus with the gst_bus_post() method. With the // gst_bus_peek() and gst_bus_pop() methods one can look at or retrieve a // previously posted message. // // The bus can be polled with the gst_bus_poll() method. This methods blocks // up to the specified timeout value until one of the specified messages types // is posted on the bus. The application can then gst_bus_pop() the messages // from the bus to handle them. // Alternatively the application can register an asynchronous bus function // using gst_bus_add_watch_full() or gst_bus_add_watch(). This function will // install a #GSource in the default glib main loop and will deliver messages // a short while after they have been posted. Note that the main loop should // be running for the asynchronous callbacks. // // It is also possible to get messages from the bus without any thread // marshalling with the gst_bus_set_sync_handler() method. This makes it // possible to react to a message in the same thread that posted the // message on the bus. This should only be used if the application is able // to deal with messages from different threads. // // Every #GstPipeline has one bus. // // Note that a #GstPipeline will set its bus into flushing state when changing // from READY to NULL state. type Bus interface { BusExtManual // handwritten functions Object upcastToGstBus() *BusInstance // AddSignalWatch wraps gst_bus_add_signal_watch // // Adds a bus signal watch to the default main context with the default priority // ( %G_PRIORITY_DEFAULT ). It is also possible to use a non-default // main context set up using g_main_context_push_thread_default() (before // one had to create a bus watch source and attach it to the desired main // context 'manually'). // // After calling this statement, the bus will emit the "message" signal for each // message posted on the bus. // // This function may be called multiple times. To clean up, the caller is // responsible for calling gst_bus_remove_signal_watch() as many times as this // function is called. AddSignalWatch() // AddSignalWatchFull wraps gst_bus_add_signal_watch_full // // The function takes the following parameters: // // - priority int: The priority of the watch. // // Adds a bus signal watch to the default main context with the given @priority // (e.g. %G_PRIORITY_DEFAULT). It is also possible to use a non-default main // context set up using g_main_context_push_thread_default() // (before one had to create a bus watch source and attach it to the desired // main context 'manually'). // // After calling this statement, the bus will emit the "message" signal for each // message posted on the bus when the #GMainLoop is running. // // This function may be called multiple times. To clean up, the caller is // responsible for calling gst_bus_remove_signal_watch() as many times as this // function is called. // // There can only be a single bus watch per bus, you must remove any signal // watch before you can set another type of watch. AddSignalWatchFull(int) // AddWatchFull wraps gst_bus_add_watch_full // // The function takes the following parameters: // // - priority int: The priority of the watch. // - fn BusFunc: A function to call when a message is received. // // The function returns the following values: // // - goret uint // // Adds a bus watch to the default main context with the given @priority (e.g. // %G_PRIORITY_DEFAULT). It is also possible to use a non-default main // context set up using g_main_context_push_thread_default() (before // one had to create a bus watch source and attach it to the desired main // context 'manually'). // // This function is used to receive asynchronous messages in the main loop. // There can only be a single bus watch per bus, you must remove it before you // can set a new one. // // The bus watch will only work if a #GMainLoop is being run. // // When @func is called, the message belongs to the caller; if you want to // keep a copy of it, call gst_message_ref() before leaving @func. // // The watch can be removed using gst_bus_remove_watch() or by returning %FALSE // from @func. If the watch was added to the default main context it is also // possible to remove the watch using g_source_remove(). // // The bus watch will take its own reference to the @bus, so it is safe to unref // @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) // // Create watch for this bus. The #GSource will be dispatched whenever // a message is on the bus. After the GSource is dispatched, the // message is popped off the bus and unreffed. // // As with other watches, there can only be one watch on the bus, including // any signal watch added with #gst_bus_add_signal_watch. CreateWatch() *glib.Source // DisableSyncMessageEmission wraps gst_bus_disable_sync_message_emission // // Instructs GStreamer to stop emitting the "sync-message" signal for this bus. // See gst_bus_enable_sync_message_emission() for more information. // // In the event that multiple pieces of code have called // gst_bus_enable_sync_message_emission(), the sync-message emissions will only // be stopped after all calls to gst_bus_enable_sync_message_emission() were // "cancelled" by calling this function. In this way the semantics are exactly // the same as gst_object_ref() that which calls enable should also call // disable. DisableSyncMessageEmission() // EnableSyncMessageEmission wraps gst_bus_enable_sync_message_emission // // Instructs GStreamer to emit the "sync-message" signal after running the bus's // sync handler. This function is here so that code can ensure that they can // synchronously receive messages without having to affect what the bin's sync // handler is. // // This function may be called multiple times. To clean up, the caller is // responsible for calling gst_bus_disable_sync_message_emission() as many times // as this function is called. // // While this function looks similar to gst_bus_add_signal_watch(), it is not // exactly the same -- this function enables *synchronous* emission of // signals when messages arrive; gst_bus_add_signal_watch() adds an idle callback // to pop messages off the bus *asynchronously*. The sync-message signal // comes from the thread of whatever object posted the message; the "message" // 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 // // Gets the file descriptor from the bus which can be used to get notified about // messages being available with functions like g_poll(), and allows integration // into other event loops based on file descriptors. // Whenever a message is available, the POLLIN / %G_IO_IN event is set. // // Warning: NEVER read or write anything to the returned fd but only use it // for getting notifications via g_poll() or similar and then use the normal // GstBus API, e.g. gst_bus_pop(). GetPollfd() glib.PollFD // HavePending wraps gst_bus_have_pending // // The function returns the following values: // // - goret bool // // Checks if there are pending messages on the bus that // should be handled. HavePending() bool // Peek wraps gst_bus_peek // // The function returns the following values: // // - goret *Message (nullable) // // Peeks the message on the top of the bus' queue. The message will remain // on the bus' message queue. Peek() *Message // Poll wraps gst_bus_poll // // The function takes the following parameters: // // - events MessageType: a mask of #GstMessageType, representing the set of message types to // poll for (note special handling of extended message types below) // - timeout ClockTime: the poll timeout, as a #GstClockTime, or #GST_CLOCK_TIME_NONE to poll // indefinitely. // // The function returns the following values: // // - goret *Message (nullable) // // Polls the bus for messages. Will block while waiting for messages to come. // You can specify a maximum time to poll with the @timeout parameter. If // @timeout is negative, this function will block indefinitely. // // All messages not in @events will be popped off the bus and will be ignored. // It is not possible to use message enums beyond #GST_MESSAGE_EXTENDED in the // @events mask // // Because poll is implemented using the "message" signal enabled by // gst_bus_add_signal_watch(), calling gst_bus_poll() will cause the "message" // signal to be emitted for every message that poll sees. Thus a "message" // signal handler will see the same messages that this function sees -- neither // will steal messages from the other. // // This function will run a #GMainLoop from the default main context when // polling. // // You should never use this function, since it is pure evil. This is // especially true for GUI applications based on Gtk+ or Qt, but also for any // other non-trivial application that uses the GLib main loop. As this function // runs a GLib main loop, any callback attached to the default GLib main // context may be invoked. This could be timeouts, GUI events, I/O events etc.; // even if gst_bus_poll() is called with a 0 timeout. Any of these callbacks // may do things you do not expect, e.g. destroy the main application window or // some other resource; change other application state; display a dialog and // run another main loop until the user clicks it away. In short, using this // function may add a lot of complexity to your code through unexpected // re-entrancy and unexpected changes to your application's state. // // For 0 timeouts use gst_bus_pop_filtered() instead of this function; for // other short timeouts use gst_bus_timed_pop_filtered(); everything else is // better handled by setting up an asynchronous bus watch and doing things // from there. Poll(MessageType, ClockTime) *Message // Pop wraps gst_bus_pop // // The function returns the following values: // // - goret *Message (nullable) // // Gets a message from the bus. Pop() *Message // PopFiltered wraps gst_bus_pop_filtered // // The function takes the following parameters: // // - types MessageType: message types to take into account // // The function returns the following values: // // - goret *Message (nullable) // // Gets a message matching @type from the bus. Will discard all messages on // the bus that do not match @type and that have been posted before the first // message that does match @type. If there is no message matching @type on // the bus, all messages will be discarded. It is not possible to use message // enums beyond #GST_MESSAGE_EXTENDED in the @events mask. PopFiltered(MessageType) *Message // Post wraps gst_bus_post // // The function takes the following parameters: // // - message *Message: the #GstMessage to post // // The function returns the following values: // // - goret bool // // Posts a message on the given bus. Ownership of the message // is taken by the bus. Post(*Message) bool // RemoveSignalWatch wraps gst_bus_remove_signal_watch // // 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 // // Removes an installed bus watch from @bus. RemoveWatch() bool // SetFlushing wraps gst_bus_set_flushing // // The function takes the following parameters: // // - flushing bool: whether or not to flush the bus // // If @flushing, flushes out and unrefs any messages queued in the bus. Releases // references to the message origin objects. Will flush future messages until // gst_bus_set_flushing() sets @flushing to %FALSE. SetFlushing(bool) // SetSyncHandler wraps gst_bus_set_sync_handler // // The function takes the following parameters: // // - fn BusSyncHandler (nullable): The handler function to install // // Sets the synchronous handler on the bus. The function will be called // every time a new message is posted on the bus. Note that the function // will be called in the same thread context as the posting object. This // function is usually only called by the creator of the bus. Applications // should handle messages asynchronously using the gst_bus watch and poll // functions. // // Before 1.16.3 it was not possible to replace an existing handler and // clearing an existing handler with %NULL was not thread-safe. SetSyncHandler(BusSyncHandler) // TimedPop wraps gst_bus_timed_pop // // The function takes the following parameters: // // - timeout ClockTime: a timeout // // The function returns the following values: // // - goret *Message (nullable) // // Gets a message from the bus, waiting up to the specified timeout. // // If @timeout is 0, this function behaves like gst_bus_pop(). If @timeout is // #GST_CLOCK_TIME_NONE, this function will block forever until a message was // posted on the bus. TimedPop(ClockTime) *Message // TimedPopFiltered wraps gst_bus_timed_pop_filtered // // The function takes the following parameters: // // - timeout ClockTime: a timeout in nanoseconds, or %GST_CLOCK_TIME_NONE to wait forever // - types MessageType: message types to take into account, %GST_MESSAGE_ANY for any type // // The function returns the following values: // // - goret *Message (nullable) // // Gets a message from the bus whose type matches the message type mask @types, // waiting up to the specified timeout (and discarding any messages that do not // match the mask provided). // // If @timeout is 0, this function behaves like gst_bus_pop_filtered(). If // @timeout is #GST_CLOCK_TIME_NONE, this function will block forever until a // matching message was posted on the bus. TimedPopFiltered(ClockTime, MessageType) *Message // ConnectMessage connects the provided callback to the "message" signal // // A message has been posted on the bus. This signal is emitted from a // #GSource added to the mainloop. this signal will only be emitted when // there is a #GMainLoop running. ConnectMessage(func(Bus, Message)) gobject.SignalHandle // ConnectSyncMessage connects the provided callback to the "sync-message" signal // // A message has been posted on the bus. This signal is emitted from the // thread that posted the message so one has to be careful with locking. // // This signal will not be emitted by default, you have to call // gst_bus_enable_sync_message_emission() before. ConnectSyncMessage(func(Bus, Message)) gobject.SignalHandle } func unsafeWrapBus(base *gobject.ObjectInstance) *BusInstance { return &BusInstance{ ObjectInstance: ObjectInstance{ InitiallyUnownedInstance: gobject.InitiallyUnownedInstance{ ObjectInstance: *base, }, }, } } func marshalBusInstance(p unsafe.Pointer) (any, error) { return unsafeWrapBus(gobject.ValueFromNative(p).Object()), nil } // UnsafeBusFromGlibNone is used to convert raw GstBus pointers to go while taking a reference and attaching a finalizer. This is used by the bindings internally. func UnsafeBusFromGlibNone(c unsafe.Pointer) Bus { return gobject.UnsafeObjectFromGlibNone(c).(Bus) } // UnsafeBusFromGlibFull is used to convert raw GstBus pointers to go while attaching a finalizer. This is used by the bindings internally. func UnsafeBusFromGlibFull(c unsafe.Pointer) Bus { return gobject.UnsafeObjectFromGlibFull(c).(Bus) } func (b *BusInstance) upcastToGstBus() *BusInstance { return b } // UnsafeBusToGlibNone is used to convert the instance to it's C value GstBus. This is used by the bindings internally. func UnsafeBusToGlibNone(c Bus) unsafe.Pointer { return gobject.UnsafeObjectToGlibNone(c) } // UnsafeBusToGlibFull is used to convert the instance to it's C value GstBus, while removeing the finalizer. This is used by the bindings internally. func UnsafeBusToGlibFull(c Bus) unsafe.Pointer { return gobject.UnsafeObjectToGlibFull(c) } // NewBus wraps gst_bus_new // // The function returns the following values: // // - goret Bus // // Creates a new #GstBus instance. func NewBus() Bus { var cret *C.GstBus // return, full, converted cret = C.gst_bus_new() var goret Bus goret = UnsafeBusFromGlibFull(unsafe.Pointer(cret)) return goret } // AddSignalWatch wraps gst_bus_add_signal_watch // // Adds a bus signal watch to the default main context with the default priority // ( %G_PRIORITY_DEFAULT ). It is also possible to use a non-default // main context set up using g_main_context_push_thread_default() (before // one had to create a bus watch source and attach it to the desired main // context 'manually'). // // After calling this statement, the bus will emit the "message" signal for each // message posted on the bus. // // This function may be called multiple times. To clean up, the caller is // responsible for calling gst_bus_remove_signal_watch() as many times as this // function is called. func (bus *BusInstance) AddSignalWatch() { var carg0 *C.GstBus // in, none, converted carg0 = (*C.GstBus)(UnsafeBusToGlibNone(bus)) C.gst_bus_add_signal_watch(carg0) runtime.KeepAlive(bus) } // AddSignalWatchFull wraps gst_bus_add_signal_watch_full // // The function takes the following parameters: // // - priority int: The priority of the watch. // // Adds a bus signal watch to the default main context with the given @priority // (e.g. %G_PRIORITY_DEFAULT). It is also possible to use a non-default main // context set up using g_main_context_push_thread_default() // (before one had to create a bus watch source and attach it to the desired // main context 'manually'). // // After calling this statement, the bus will emit the "message" signal for each // message posted on the bus when the #GMainLoop is running. // // This function may be called multiple times. To clean up, the caller is // responsible for calling gst_bus_remove_signal_watch() as many times as this // function is called. // // There can only be a single bus watch per bus, you must remove any signal // watch before you can set another type of watch. func (bus *BusInstance) AddSignalWatchFull(priority int) { var carg0 *C.GstBus // in, none, converted var carg1 C.gint // in, none, casted carg0 = (*C.GstBus)(UnsafeBusToGlibNone(bus)) carg1 = C.gint(priority) C.gst_bus_add_signal_watch_full(carg0, carg1) runtime.KeepAlive(bus) runtime.KeepAlive(priority) } // AddWatchFull wraps gst_bus_add_watch_full // // The function takes the following parameters: // // - priority int: The priority of the watch. // - fn BusFunc: A function to call when a message is received. // // The function returns the following values: // // - goret uint // // Adds a bus watch to the default main context with the given @priority (e.g. // %G_PRIORITY_DEFAULT). It is also possible to use a non-default main // context set up using g_main_context_push_thread_default() (before // one had to create a bus watch source and attach it to the desired main // context 'manually'). // // This function is used to receive asynchronous messages in the main loop. // There can only be a single bus watch per bus, you must remove it before you // can set a new one. // // The bus watch will only work if a #GMainLoop is being run. // // When @func is called, the message belongs to the caller; if you want to // keep a copy of it, call gst_message_ref() before leaving @func. // // The watch can be removed using gst_bus_remove_watch() or by returning %FALSE // from @func. If the watch was added to the default main context it is also // possible to remove the watch using g_source_remove(). // // The bus watch will take its own reference to the @bus, so it is safe to unref // @bus using gst_object_unref() after setting the bus watch. func (bus *BusInstance) AddWatchFull(priority int, fn BusFunc) uint { var carg0 *C.GstBus // in, none, converted var carg1 C.gint // in, none, casted var carg2 C.GstBusFunc // callback, scope: notified, closure: carg3, destroy: carg4 var carg3 C.gpointer // implicit var carg4 C.GDestroyNotify // implicit var cret C.guint // return, none, casted carg0 = (*C.GstBus)(UnsafeBusToGlibNone(bus)) carg1 = C.gint(priority) carg2 = (*[0]byte)(C._gotk4_gst1_BusFunc) carg3 = C.gpointer(userdata.Register(fn)) carg4 = (C.GDestroyNotify)((*[0]byte)(C.destroyUserdata)) cret = C.gst_bus_add_watch_full(carg0, carg1, carg2, carg3, carg4) runtime.KeepAlive(bus) runtime.KeepAlive(priority) runtime.KeepAlive(fn) var goret uint goret = uint(cret) return goret } // CreateWatch wraps gst_bus_create_watch // // The function returns the following values: // // - goret *glib.Source (nullable) // // Create watch for this bus. The #GSource will be dispatched whenever // a message is on the bus. After the GSource is dispatched, the // message is popped off the bus and unreffed. // // As with other watches, there can only be one watch on the bus, including // any signal watch added with #gst_bus_add_signal_watch. func (bus *BusInstance) CreateWatch() *glib.Source { var carg0 *C.GstBus // in, none, converted var cret *C.GSource // return, full, converted, nullable carg0 = (*C.GstBus)(UnsafeBusToGlibNone(bus)) cret = C.gst_bus_create_watch(carg0) runtime.KeepAlive(bus) var goret *glib.Source if cret != nil { goret = glib.UnsafeSourceFromGlibFull(unsafe.Pointer(cret)) } return goret } // DisableSyncMessageEmission wraps gst_bus_disable_sync_message_emission // // Instructs GStreamer to stop emitting the "sync-message" signal for this bus. // See gst_bus_enable_sync_message_emission() for more information. // // In the event that multiple pieces of code have called // gst_bus_enable_sync_message_emission(), the sync-message emissions will only // be stopped after all calls to gst_bus_enable_sync_message_emission() were // "cancelled" by calling this function. In this way the semantics are exactly // the same as gst_object_ref() that which calls enable should also call // disable. func (bus *BusInstance) DisableSyncMessageEmission() { var carg0 *C.GstBus // in, none, converted carg0 = (*C.GstBus)(UnsafeBusToGlibNone(bus)) C.gst_bus_disable_sync_message_emission(carg0) runtime.KeepAlive(bus) } // EnableSyncMessageEmission wraps gst_bus_enable_sync_message_emission // // Instructs GStreamer to emit the "sync-message" signal after running the bus's // sync handler. This function is here so that code can ensure that they can // synchronously receive messages without having to affect what the bin's sync // handler is. // // This function may be called multiple times. To clean up, the caller is // responsible for calling gst_bus_disable_sync_message_emission() as many times // as this function is called. // // While this function looks similar to gst_bus_add_signal_watch(), it is not // exactly the same -- this function enables *synchronous* emission of // signals when messages arrive; gst_bus_add_signal_watch() adds an idle callback // to pop messages off the bus *asynchronously*. The sync-message signal // comes from the thread of whatever object posted the message; the "message" // signal is marshalled to the main thread via the #GMainLoop. func (bus *BusInstance) EnableSyncMessageEmission() { var carg0 *C.GstBus // in, none, converted carg0 = (*C.GstBus)(UnsafeBusToGlibNone(bus)) C.gst_bus_enable_sync_message_emission(carg0) runtime.KeepAlive(bus) } // GetPollfd wraps gst_bus_get_pollfd // // The function returns the following values: // // - fd glib.PollFD: A GPollFD to fill // // Gets the file descriptor from the bus which can be used to get notified about // messages being available with functions like g_poll(), and allows integration // into other event loops based on file descriptors. // Whenever a message is available, the POLLIN / %G_IO_IN event is set. // // Warning: NEVER read or write anything to the returned fd but only use it // for getting notifications via g_poll() or similar and then use the normal // GstBus API, e.g. gst_bus_pop(). func (bus *BusInstance) GetPollfd() glib.PollFD { var carg0 *C.GstBus // in, none, converted var carg1 C.GPollFD // out, transfer: none, C Pointers: 0, Name: PollFD, caller-allocates carg0 = (*C.GstBus)(UnsafeBusToGlibNone(bus)) C.gst_bus_get_pollfd(carg0, &carg1) runtime.KeepAlive(bus) var fd glib.PollFD _ = fd _ = carg1 panic("unimplemented conversion of glib.PollFD (GPollFD)") return fd } // HavePending wraps gst_bus_have_pending // // The function returns the following values: // // - goret bool // // Checks if there are pending messages on the bus that // should be handled. func (bus *BusInstance) HavePending() bool { var carg0 *C.GstBus // in, none, converted var cret C.gboolean // return carg0 = (*C.GstBus)(UnsafeBusToGlibNone(bus)) cret = C.gst_bus_have_pending(carg0) runtime.KeepAlive(bus) var goret bool if cret != 0 { goret = true } return goret } // Peek wraps gst_bus_peek // // The function returns the following values: // // - goret *Message (nullable) // // Peeks the message on the top of the bus' queue. The message will remain // on the bus' message queue. func (bus *BusInstance) Peek() *Message { var carg0 *C.GstBus // in, none, converted var cret *C.GstMessage // return, full, converted, nullable carg0 = (*C.GstBus)(UnsafeBusToGlibNone(bus)) cret = C.gst_bus_peek(carg0) runtime.KeepAlive(bus) var goret *Message if cret != nil { goret = UnsafeMessageFromGlibFull(unsafe.Pointer(cret)) } return goret } // Poll wraps gst_bus_poll // // The function takes the following parameters: // // - events MessageType: a mask of #GstMessageType, representing the set of message types to // poll for (note special handling of extended message types below) // - timeout ClockTime: the poll timeout, as a #GstClockTime, or #GST_CLOCK_TIME_NONE to poll // indefinitely. // // The function returns the following values: // // - goret *Message (nullable) // // Polls the bus for messages. Will block while waiting for messages to come. // You can specify a maximum time to poll with the @timeout parameter. If // @timeout is negative, this function will block indefinitely. // // All messages not in @events will be popped off the bus and will be ignored. // It is not possible to use message enums beyond #GST_MESSAGE_EXTENDED in the // @events mask // // Because poll is implemented using the "message" signal enabled by // gst_bus_add_signal_watch(), calling gst_bus_poll() will cause the "message" // signal to be emitted for every message that poll sees. Thus a "message" // signal handler will see the same messages that this function sees -- neither // will steal messages from the other. // // This function will run a #GMainLoop from the default main context when // polling. // // You should never use this function, since it is pure evil. This is // especially true for GUI applications based on Gtk+ or Qt, but also for any // other non-trivial application that uses the GLib main loop. As this function // runs a GLib main loop, any callback attached to the default GLib main // context may be invoked. This could be timeouts, GUI events, I/O events etc.; // even if gst_bus_poll() is called with a 0 timeout. Any of these callbacks // may do things you do not expect, e.g. destroy the main application window or // some other resource; change other application state; display a dialog and // run another main loop until the user clicks it away. In short, using this // function may add a lot of complexity to your code through unexpected // re-entrancy and unexpected changes to your application's state. // // For 0 timeouts use gst_bus_pop_filtered() instead of this function; for // other short timeouts use gst_bus_timed_pop_filtered(); everything else is // better handled by setting up an asynchronous bus watch and doing things // from there. func (bus *BusInstance) Poll(events MessageType, timeout ClockTime) *Message { var carg0 *C.GstBus // in, none, converted var carg1 C.GstMessageType // in, none, casted var carg2 C.GstClockTime // in, none, casted, alias var cret *C.GstMessage // return, full, converted, nullable carg0 = (*C.GstBus)(UnsafeBusToGlibNone(bus)) carg1 = C.GstMessageType(events) carg2 = C.GstClockTime(timeout) cret = C.gst_bus_poll(carg0, carg1, carg2) runtime.KeepAlive(bus) runtime.KeepAlive(events) runtime.KeepAlive(timeout) var goret *Message if cret != nil { goret = UnsafeMessageFromGlibFull(unsafe.Pointer(cret)) } return goret } // Pop wraps gst_bus_pop // // The function returns the following values: // // - goret *Message (nullable) // // Gets a message from the bus. func (bus *BusInstance) Pop() *Message { var carg0 *C.GstBus // in, none, converted var cret *C.GstMessage // return, full, converted, nullable carg0 = (*C.GstBus)(UnsafeBusToGlibNone(bus)) cret = C.gst_bus_pop(carg0) runtime.KeepAlive(bus) var goret *Message if cret != nil { goret = UnsafeMessageFromGlibFull(unsafe.Pointer(cret)) } return goret } // PopFiltered wraps gst_bus_pop_filtered // // The function takes the following parameters: // // - types MessageType: message types to take into account // // The function returns the following values: // // - goret *Message (nullable) // // Gets a message matching @type from the bus. Will discard all messages on // the bus that do not match @type and that have been posted before the first // message that does match @type. If there is no message matching @type on // the bus, all messages will be discarded. It is not possible to use message // enums beyond #GST_MESSAGE_EXTENDED in the @events mask. func (bus *BusInstance) PopFiltered(types MessageType) *Message { var carg0 *C.GstBus // in, none, converted var carg1 C.GstMessageType // in, none, casted var cret *C.GstMessage // return, full, converted, nullable carg0 = (*C.GstBus)(UnsafeBusToGlibNone(bus)) carg1 = C.GstMessageType(types) cret = C.gst_bus_pop_filtered(carg0, carg1) runtime.KeepAlive(bus) runtime.KeepAlive(types) var goret *Message if cret != nil { goret = UnsafeMessageFromGlibFull(unsafe.Pointer(cret)) } return goret } // Post wraps gst_bus_post // // The function takes the following parameters: // // - message *Message: the #GstMessage to post // // The function returns the following values: // // - goret bool // // Posts a message on the given bus. Ownership of the message // is taken by the bus. func (bus *BusInstance) Post(message *Message) bool { var carg0 *C.GstBus // in, none, converted var carg1 *C.GstMessage // in, full, converted var cret C.gboolean // return carg0 = (*C.GstBus)(UnsafeBusToGlibNone(bus)) carg1 = (*C.GstMessage)(UnsafeMessageToGlibFull(message)) cret = C.gst_bus_post(carg0, carg1) runtime.KeepAlive(bus) runtime.KeepAlive(message) var goret bool if cret != 0 { goret = true } return goret } // RemoveSignalWatch wraps gst_bus_remove_signal_watch // // Removes a signal watch previously added with gst_bus_add_signal_watch(). func (bus *BusInstance) RemoveSignalWatch() { var carg0 *C.GstBus // in, none, converted carg0 = (*C.GstBus)(UnsafeBusToGlibNone(bus)) C.gst_bus_remove_signal_watch(carg0) runtime.KeepAlive(bus) } // RemoveWatch wraps gst_bus_remove_watch // // The function returns the following values: // // - goret bool // // Removes an installed bus watch from @bus. func (bus *BusInstance) RemoveWatch() bool { var carg0 *C.GstBus // in, none, converted var cret C.gboolean // return carg0 = (*C.GstBus)(UnsafeBusToGlibNone(bus)) cret = C.gst_bus_remove_watch(carg0) runtime.KeepAlive(bus) var goret bool if cret != 0 { goret = true } return goret } // SetFlushing wraps gst_bus_set_flushing // // The function takes the following parameters: // // - flushing bool: whether or not to flush the bus // // If @flushing, flushes out and unrefs any messages queued in the bus. Releases // references to the message origin objects. Will flush future messages until // gst_bus_set_flushing() sets @flushing to %FALSE. func (bus *BusInstance) SetFlushing(flushing bool) { var carg0 *C.GstBus // in, none, converted var carg1 C.gboolean // in carg0 = (*C.GstBus)(UnsafeBusToGlibNone(bus)) if flushing { carg1 = C.TRUE } C.gst_bus_set_flushing(carg0, carg1) runtime.KeepAlive(bus) runtime.KeepAlive(flushing) } // SetSyncHandler wraps gst_bus_set_sync_handler // // The function takes the following parameters: // // - fn BusSyncHandler (nullable): The handler function to install // // Sets the synchronous handler on the bus. The function will be called // every time a new message is posted on the bus. Note that the function // will be called in the same thread context as the posting object. This // function is usually only called by the creator of the bus. Applications // should handle messages asynchronously using the gst_bus watch and poll // functions. // // Before 1.16.3 it was not possible to replace an existing handler and // clearing an existing handler with %NULL was not thread-safe. func (bus *BusInstance) SetSyncHandler(fn BusSyncHandler) { var carg0 *C.GstBus // in, none, converted var carg1 C.GstBusSyncHandler // callback, scope: notified, closure: carg2, destroy: carg3, nullable var carg2 C.gpointer // implicit var carg3 C.GDestroyNotify // implicit carg0 = (*C.GstBus)(UnsafeBusToGlibNone(bus)) if fn != nil { carg1 = (*[0]byte)(C._gotk4_gst1_BusSyncHandler) carg2 = C.gpointer(userdata.Register(fn)) carg3 = (C.GDestroyNotify)((*[0]byte)(C.destroyUserdata)) } C.gst_bus_set_sync_handler(carg0, carg1, carg2, carg3) runtime.KeepAlive(bus) runtime.KeepAlive(fn) } // TimedPop wraps gst_bus_timed_pop // // The function takes the following parameters: // // - timeout ClockTime: a timeout // // The function returns the following values: // // - goret *Message (nullable) // // Gets a message from the bus, waiting up to the specified timeout. // // If @timeout is 0, this function behaves like gst_bus_pop(). If @timeout is // #GST_CLOCK_TIME_NONE, this function will block forever until a message was // posted on the bus. func (bus *BusInstance) TimedPop(timeout ClockTime) *Message { var carg0 *C.GstBus // in, none, converted var carg1 C.GstClockTime // in, none, casted, alias var cret *C.GstMessage // return, full, converted, nullable carg0 = (*C.GstBus)(UnsafeBusToGlibNone(bus)) carg1 = C.GstClockTime(timeout) cret = C.gst_bus_timed_pop(carg0, carg1) runtime.KeepAlive(bus) runtime.KeepAlive(timeout) var goret *Message if cret != nil { goret = UnsafeMessageFromGlibFull(unsafe.Pointer(cret)) } return goret } // TimedPopFiltered wraps gst_bus_timed_pop_filtered // // The function takes the following parameters: // // - timeout ClockTime: a timeout in nanoseconds, or %GST_CLOCK_TIME_NONE to wait forever // - types MessageType: message types to take into account, %GST_MESSAGE_ANY for any type // // The function returns the following values: // // - goret *Message (nullable) // // Gets a message from the bus whose type matches the message type mask @types, // waiting up to the specified timeout (and discarding any messages that do not // match the mask provided). // // If @timeout is 0, this function behaves like gst_bus_pop_filtered(). If // @timeout is #GST_CLOCK_TIME_NONE, this function will block forever until a // matching message was posted on the bus. func (bus *BusInstance) TimedPopFiltered(timeout ClockTime, types MessageType) *Message { var carg0 *C.GstBus // in, none, converted var carg1 C.GstClockTime // in, none, casted, alias var carg2 C.GstMessageType // in, none, casted var cret *C.GstMessage // return, full, converted, nullable carg0 = (*C.GstBus)(UnsafeBusToGlibNone(bus)) carg1 = C.GstClockTime(timeout) carg2 = C.GstMessageType(types) cret = C.gst_bus_timed_pop_filtered(carg0, carg1, carg2) runtime.KeepAlive(bus) runtime.KeepAlive(timeout) runtime.KeepAlive(types) var goret *Message if cret != nil { goret = UnsafeMessageFromGlibFull(unsafe.Pointer(cret)) } return goret } // ConnectMessage connects the provided callback to the "message" signal // // A message has been posted on the bus. This signal is emitted from a // #GSource added to the mainloop. this signal will only be emitted when // there is a #GMainLoop running. 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 // thread that posted the message so one has to be careful with locking. // // This signal will not be emitted by default, you have to call // gst_bus_enable_sync_message_emission() before. 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 ObjectInstance } var _ Clock = (*ClockInstance)(nil) // Clock wraps GstClock // // GStreamer uses a global clock to synchronize the plugins in a pipeline. // Different clock implementations are possible by implementing this abstract // base class or, more conveniently, by subclassing #GstSystemClock. // // The #GstClock returns a monotonically increasing time with the method // gst_clock_get_time(). Its accuracy and base time depend on the specific // clock implementation but time is always expressed in nanoseconds. Since the // baseline of the clock is undefined, the clock time returned is not // meaningful in itself, what matters are the deltas between two clock times. // The time returned by a clock is called the absolute time. // // The pipeline uses the clock to calculate the running time. Usually all // renderers synchronize to the global clock using the buffer timestamps, the // #GST_EVENT_SEGMENT events and the element's base time, see #GstPipeline. // // A clock implementation can support periodic and single shot clock // notifications both synchronous and asynchronous. // // One first needs to create a #GstClockID for the periodic or single shot // notification using gst_clock_new_single_shot_id() or // gst_clock_new_periodic_id(). // // To perform a blocking wait for the specific time of the #GstClockID use // gst_clock_id_wait(). To receive a callback when the specific time is reached // in the clock use gst_clock_id_wait_async(). Both these calls can be // interrupted with the gst_clock_id_unschedule() call. If the blocking wait is // unscheduled a return value of #GST_CLOCK_UNSCHEDULED is returned. // // Periodic callbacks scheduled async will be repeatedly called automatically // until they are unscheduled. To schedule a sync periodic callback, // gst_clock_id_wait() should be called repeatedly. // // The async callbacks can happen from any thread, either provided by the core // or from a streaming thread. The application should be prepared for this. // // A #GstClockID that has been unscheduled cannot be used again for any wait // operation, a new #GstClockID should be created and the old unscheduled one // should be destroyed with gst_clock_id_unref(). // // It is possible to perform a blocking wait on the same #GstClockID from // multiple threads. However, registering the same #GstClockID for multiple // async notifications is not possible, the callback will only be called for // the thread registering the entry last. // // None of the wait operations unref the #GstClockID, the owner is responsible // for unreffing the ids itself. This holds for both periodic and single shot // notifications. The reason being that the owner of the #GstClockID has to // keep a handle to the #GstClockID to unblock the wait on FLUSHING events or // state changes and if the entry would be unreffed automatically, the handle // might become invalid without any notification. // // These clock operations do not operate on the running time, so the callbacks // will also occur when not in PLAYING state as if the clock just keeps on // running. Some clocks however do not progress when the element that provided // the clock is not PLAYING. // // When a clock has the #GST_CLOCK_FLAG_CAN_SET_MASTER flag set, it can be // slaved to another #GstClock with gst_clock_set_master(). The clock will // then automatically be synchronized to this master clock by repeatedly // sampling the master clock and the slave clock and recalibrating the slave // clock with gst_clock_set_calibration(). This feature is mostly useful for // plugins that have an internal clock but must operate with another clock // selected by the #GstPipeline. They can track the offset and rate difference // of their internal clock relative to the master clock by using the // gst_clock_get_calibration() function. // // The master/slave synchronisation can be tuned with the #GstClock:timeout, // #GstClock:window-size and #GstClock:window-threshold properties. // The #GstClock:timeout property defines the interval to sample the master // clock and run the calibration functions. #GstClock:window-size defines the // number of samples to use when calibrating and #GstClock:window-threshold // defines the minimum number of samples before the calibration is performed. type Clock interface { Object upcastToGstClock() *ClockInstance // AddObservation wraps gst_clock_add_observation // // The function takes the following parameters: // // - slave ClockTime: a time on the slave // - master ClockTime: a time on the master // // The function returns the following values: // // - rSquared float64: a pointer to hold the result // - goret bool // // The time @master of the master clock and the time @slave of the slave // clock are added to the list of observations. If enough observations // are available, a linear regression algorithm is run on the // observations and @clock is recalibrated. // // If this functions returns %TRUE, @r_squared will contain the // correlation coefficient of the interpolation. A value of 1.0 // means a perfect regression was performed. This value can // be used to control the sampling frequency of the master and slave // clocks. AddObservation(ClockTime, ClockTime) (float64, bool) // AddObservationUnapplied wraps gst_clock_add_observation_unapplied // // The function takes the following parameters: // // - slave ClockTime: a time on the slave // - master ClockTime: a time on the master // // The function returns the following values: // // - rSquared float64: a pointer to hold the result // - internal ClockTime: a location to store the internal time // - external ClockTime: a location to store the external time // - rateNum ClockTime: a location to store the rate numerator // - rateDenom ClockTime: a location to store the rate denominator // - goret bool // // Add a clock observation to the internal slaving algorithm the same as // gst_clock_add_observation(), and return the result of the master clock // estimation, without updating the internal calibration. // // The caller can then take the results and call gst_clock_set_calibration() // with the values, or some modified version of them. AddObservationUnapplied(ClockTime, ClockTime) (float64, ClockTime, ClockTime, ClockTime, ClockTime, bool) // AdjustUnlocked wraps gst_clock_adjust_unlocked // // The function takes the following parameters: // // - internal ClockTime: a clock time // // The function returns the following values: // // - goret ClockTime // // Converts the given @internal clock time to the external time, adjusting for the // rate and reference time set with gst_clock_set_calibration() and making sure // that the returned time is increasing. This function should be called with the // clock's OBJECT_LOCK held and is mainly used by clock subclasses. // // This function is the reverse of gst_clock_unadjust_unlocked(). AdjustUnlocked(ClockTime) ClockTime // AdjustWithCalibration wraps gst_clock_adjust_with_calibration // // The function takes the following parameters: // // - internalTarget ClockTime: a clock time // - cinternal ClockTime: a reference internal time // - cexternal ClockTime: a reference external time // - cnum ClockTime: the numerator of the rate of the clock relative to its // internal time // - cdenom ClockTime: the denominator of the rate of the clock // // The function returns the following values: // // - goret ClockTime // // Converts the given @internal_target clock time to the external time, // using the passed calibration parameters. This function performs the // same calculation as gst_clock_adjust_unlocked() when called using the // current calibration parameters, but doesn't ensure a monotonically // increasing result as gst_clock_adjust_unlocked() does. // // 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 // - external ClockTime: a location to store the external time // - rateNum ClockTime: a location to store the rate numerator // - rateDenom ClockTime: a location to store the rate denominator // // Gets the internal rate and reference time of @clock. See // gst_clock_set_calibration() for more information. // // @internal, @external, @rate_num, and @rate_denom can be left %NULL if the // 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 // // Gets the current internal time of the given clock. The time is returned // unadjusted for the offset and the rate. GetInternalTime() ClockTime // GetMaster wraps gst_clock_get_master // // The function returns the following values: // // - goret Clock (nullable) // // Gets the master clock that @clock is slaved to or %NULL when the clock is // not slaved to any master clock. GetMaster() Clock // GetResolution wraps gst_clock_get_resolution // // The function returns the following values: // // - goret ClockTime // // Gets the accuracy of the clock. The accuracy of the clock is the granularity // 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 // // Gets the current time of the given clock. The time is always // monotonically increasing and adjusted according to the current // offset and rate. GetTime() ClockTime // GetTimeout wraps gst_clock_get_timeout // // The function returns the following values: // // - goret ClockTime // // 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 // // Checks if the clock is currently synced, by looking at whether // %GST_CLOCK_FLAG_NEEDS_STARTUP_SYNC is set. IsSynced() bool // NewPeriodicID wraps gst_clock_new_periodic_id // // The function takes the following parameters: // // - startTime ClockTime: the requested start time // - interval ClockTime: the requested interval // // The function returns the following values: // // - goret ClockID // // Gets an ID from @clock to trigger a periodic notification. // The periodic notifications will start at time @start_time and // will then be fired with the given @interval. NewPeriodicID(ClockTime, ClockTime) ClockID // NewSingleShotID wraps gst_clock_new_single_shot_id // // The function takes the following parameters: // // - time ClockTime: the requested time // // The function returns the following values: // // - goret ClockID // // Gets a #GstClockID from @clock to trigger a single shot // notification at the requested time. NewSingleShotID(ClockTime) ClockID // PeriodicIDReinit wraps gst_clock_periodic_id_reinit // // The function takes the following parameters: // // - id ClockID: a #GstClockID // - startTime ClockTime: the requested start time // - interval ClockTime: the requested interval // // The function returns the following values: // // - goret bool // // Reinitializes the provided periodic @id to the provided start time and // interval. Does not modify the reference count. PeriodicIDReinit(ClockID, ClockTime, ClockTime) bool // SetCalibration wraps gst_clock_set_calibration // // The function takes the following parameters: // // - internal ClockTime: a reference internal time // - external ClockTime: a reference external time // - rateNum ClockTime: the numerator of the rate of the clock relative to its // internal time // - rateDenom ClockTime: the denominator of the rate of the clock // // Adjusts the rate and time of @clock. A rate of 1/1 is the normal speed of // the clock. Values bigger than 1/1 make the clock go faster. // // @internal and @external are calibration parameters that arrange that // gst_clock_get_time() should have been @external at internal time @internal. // This internal time should not be in the future; that is, it should be less // than the value of gst_clock_get_internal_time() when this function is called. // // Subsequent calls to gst_clock_get_time() will return clock times computed as // follows: // // ``` C // time = (internal_time - internal) * rate_num / rate_denom + external // ``` // // This formula is implemented in gst_clock_adjust_unlocked(). Of course, it // tries to do the integer arithmetic as precisely as possible. // // Note that gst_clock_get_time() always returns increasing values so when you // move the clock backwards, gst_clock_get_time() will report the previous value // until the clock catches up. SetCalibration(ClockTime, ClockTime, ClockTime, ClockTime) // SetMaster wraps gst_clock_set_master // // The function takes the following parameters: // // - master Clock (nullable): a master #GstClock // // The function returns the following values: // // - goret bool // // Sets @master as the master clock for @clock. @clock will be automatically // calibrated so that gst_clock_get_time() reports the same time as the // master clock. // // A clock provider that slaves its clock to a master can get the current // calibration values with gst_clock_get_calibration(). // // @master can be %NULL in which case @clock will not be slaved anymore. It will // however keep reporting its time adjusted with the last configured rate // and time offsets. SetMaster(Clock) bool // SetResolution wraps gst_clock_set_resolution // // The function takes the following parameters: // // - resolution ClockTime: The resolution to set // // The function returns the following values: // // - goret ClockTime // // Sets the accuracy of the clock. Some clocks have the possibility to operate // with different accuracy at the expense of more resource usage. There is // normally no need to change the default resolution of a clock. The resolution // of a clock can only be changed if the clock has the // #GST_CLOCK_FLAG_CAN_SET_RESOLUTION flag set. SetResolution(ClockTime) ClockTime // SetSynced wraps gst_clock_set_synced // // The function takes the following parameters: // // - synced bool: if the clock is synced // // Sets @clock to synced and emits the #GstClock::synced signal, and wakes up any // thread waiting in gst_clock_wait_for_sync(). // // This function must only be called if %GST_CLOCK_FLAG_NEEDS_STARTUP_SYNC // is set on the clock, and is intended to be called by subclasses only. SetSynced(bool) // SetTimeout wraps gst_clock_set_timeout // // The function takes the following parameters: // // - timeout ClockTime: a timeout // // Sets the amount of time, in nanoseconds, to sample master and slave // clocks SetTimeout(ClockTime) // SingleShotIDReinit wraps gst_clock_single_shot_id_reinit // // The function takes the following parameters: // // - id ClockID: a #GstClockID // - time ClockTime: The requested time. // // The function returns the following values: // // - goret bool // // Reinitializes the provided single shot @id to the provided time. Does not // modify the reference count. SingleShotIDReinit(ClockID, ClockTime) bool // UnadjustUnlocked wraps gst_clock_unadjust_unlocked // // The function takes the following parameters: // // - external ClockTime: an external clock time // // The function returns the following values: // // - goret ClockTime // // Converts the given @external clock time to the internal time of @clock, // using the rate and reference time set with gst_clock_set_calibration(). // This function should be called with the clock's OBJECT_LOCK held and // is mainly used by clock subclasses. // // This function is the reverse of gst_clock_adjust_unlocked(). UnadjustUnlocked(ClockTime) ClockTime // UnadjustWithCalibration wraps gst_clock_unadjust_with_calibration // // The function takes the following parameters: // // - externalTarget ClockTime: a clock time // - cinternal ClockTime: a reference internal time // - cexternal ClockTime: a reference external time // - cnum ClockTime: the numerator of the rate of the clock relative to its // internal time // - cdenom ClockTime: the denominator of the rate of the clock // // The function returns the following values: // // - goret ClockTime // // Converts the given @external_target clock time to the internal time, // using the passed calibration parameters. This function performs the // same calculation as gst_clock_unadjust_unlocked() when called using the // current calibration parameters. // // Note: The @clock parameter is unused and can be NULL UnadjustWithCalibration(ClockTime, ClockTime, ClockTime, ClockTime, ClockTime) ClockTime // WaitForSync wraps gst_clock_wait_for_sync // // The function takes the following parameters: // // - timeout ClockTime: timeout for waiting or %GST_CLOCK_TIME_NONE // // The function returns the following values: // // - goret bool // // Waits until @clock is synced for reporting the current time. If @timeout // is %GST_CLOCK_TIME_NONE it will wait forever, otherwise it will time out // after @timeout nanoseconds. // // For asynchronous waiting, the #GstClock::synced signal can be used. // // This returns immediately with %TRUE if %GST_CLOCK_FLAG_NEEDS_STARTUP_SYNC // is not set on the clock, or if the clock is already synced. WaitForSync(ClockTime) bool // ConnectSynced connects the provided callback to the "synced" signal // // Signaled on clocks with %GST_CLOCK_FLAG_NEEDS_STARTUP_SYNC set once // the clock is synchronized, or when it completely lost synchronization. // This signal will not be emitted on clocks without the flag. // // This signal will be emitted from an arbitrary thread, most likely not // the application's main thread. ConnectSynced(func(Clock, bool)) gobject.SignalHandle } func unsafeWrapClock(base *gobject.ObjectInstance) *ClockInstance { return &ClockInstance{ ObjectInstance: ObjectInstance{ InitiallyUnownedInstance: gobject.InitiallyUnownedInstance{ ObjectInstance: *base, }, }, } } func marshalClockInstance(p unsafe.Pointer) (any, error) { return unsafeWrapClock(gobject.ValueFromNative(p).Object()), nil } // UnsafeClockFromGlibNone is used to convert raw GstClock pointers to go while taking a reference and attaching a finalizer. This is used by the bindings internally. func UnsafeClockFromGlibNone(c unsafe.Pointer) Clock { return gobject.UnsafeObjectFromGlibNone(c).(Clock) } // UnsafeClockFromGlibFull is used to convert raw GstClock pointers to go while attaching a finalizer. This is used by the bindings internally. func UnsafeClockFromGlibFull(c unsafe.Pointer) Clock { return gobject.UnsafeObjectFromGlibFull(c).(Clock) } func (c *ClockInstance) upcastToGstClock() *ClockInstance { return c } // UnsafeClockToGlibNone is used to convert the instance to it's C value GstClock. This is used by the bindings internally. func UnsafeClockToGlibNone(c Clock) unsafe.Pointer { return gobject.UnsafeObjectToGlibNone(c) } // UnsafeClockToGlibFull is used to convert the instance to it's C value GstClock, while removeing the finalizer. This is used by the bindings internally. func UnsafeClockToGlibFull(c Clock) unsafe.Pointer { return gobject.UnsafeObjectToGlibFull(c) } // ClockIDCompareFunc wraps gst_clock_id_compare_func // // The function takes the following parameters: // // - id1 unsafe.Pointer (nullable): A #GstClockID // - id2 unsafe.Pointer (nullable): A #GstClockID to compare with // // The function returns the following values: // // - goret int // // Compares the two #GstClockID instances. This function can be used // as a GCompareFunc when sorting ids. func ClockIDCompareFunc(id1 unsafe.Pointer, id2 unsafe.Pointer) int { var carg1 C.gconstpointer // in, none, casted, nullable var carg2 C.gconstpointer // in, none, casted, nullable var cret C.gint // return, none, casted if id1 != nil { carg1 = C.gconstpointer(id1) } if id2 != nil { carg2 = C.gconstpointer(id2) } cret = C.gst_clock_id_compare_func(carg1, carg2) runtime.KeepAlive(id1) runtime.KeepAlive(id2) var goret int goret = int(cret) return goret } // ClockIDGetClock wraps gst_clock_id_get_clock // // The function takes the following parameters: // // - id ClockID: a #GstClockID // // The function returns the following values: // // - goret Clock (nullable) // // This function returns the underlying clock. func ClockIDGetClock(id ClockID) Clock { var carg1 C.GstClockID // in, none, casted, alias var cret *C.GstClock // return, full, converted, nullable carg1 = C.GstClockID(id) cret = C.gst_clock_id_get_clock(carg1) runtime.KeepAlive(id) var goret Clock if cret != nil { goret = UnsafeClockFromGlibFull(unsafe.Pointer(cret)) } return goret } // ClockIDGetTime wraps gst_clock_id_get_time // // The function takes the following parameters: // // - id ClockID: The #GstClockID to query // // The function returns the following values: // // - goret ClockTime // // Gets the time of the clock ID func ClockIDGetTime(id ClockID) ClockTime { var carg1 C.GstClockID // in, none, casted, alias var cret C.GstClockTime // return, none, casted, alias carg1 = C.GstClockID(id) cret = C.gst_clock_id_get_time(carg1) runtime.KeepAlive(id) var goret ClockTime goret = ClockTime(cret) return goret } // ClockIDRef wraps gst_clock_id_ref // // The function takes the following parameters: // // - id ClockID: The #GstClockID to ref // // The function returns the following values: // // - goret ClockID // // Increases the refcount of given @id. func ClockIDRef(id ClockID) ClockID { var carg1 C.GstClockID // in, none, casted, alias var cret C.GstClockID // return, full, casted, alias carg1 = C.GstClockID(id) cret = C.gst_clock_id_ref(carg1) runtime.KeepAlive(id) var goret ClockID goret = ClockID(cret) return goret } // ClockIDUnref wraps gst_clock_id_unref // // The function takes the following parameters: // // - id ClockID: The #GstClockID to unref // // Unrefs given @id. When the refcount reaches 0 the // #GstClockID will be freed. func ClockIDUnref(id ClockID) { var carg1 C.GstClockID // in, full, casted, alias carg1 = C.GstClockID(id) C.gst_clock_id_unref(carg1) runtime.KeepAlive(id) } // ClockIDUnschedule wraps gst_clock_id_unschedule // // The function takes the following parameters: // // - id ClockID: The id to unschedule // // Cancels an outstanding request with @id. This can either // be an outstanding async notification or a pending sync notification. // After this call, @id cannot be used anymore to receive sync or // async notifications, you need to create a new #GstClockID. func ClockIDUnschedule(id ClockID) { var carg1 C.GstClockID // in, none, casted, alias carg1 = C.GstClockID(id) C.gst_clock_id_unschedule(carg1) runtime.KeepAlive(id) } // ClockIDUsesClock wraps gst_clock_id_uses_clock // // The function takes the following parameters: // // - id ClockID: a #GstClockID to check // - clock Clock: a #GstClock to compare against // // The function returns the following values: // // - goret bool // // This function returns whether @id uses @clock as the underlying clock. // @clock can be NULL, in which case the return value indicates whether // the underlying clock has been freed. If this is the case, the @id is // no longer usable and should be freed. func ClockIDUsesClock(id ClockID, clock Clock) bool { var carg1 C.GstClockID // in, none, casted, alias var carg2 *C.GstClock // in, none, converted var cret C.gboolean // return carg1 = C.GstClockID(id) carg2 = (*C.GstClock)(UnsafeClockToGlibNone(clock)) cret = C.gst_clock_id_uses_clock(carg1, carg2) runtime.KeepAlive(id) runtime.KeepAlive(clock) var goret bool if cret != 0 { goret = true } return goret } // ClockIDWait wraps gst_clock_id_wait // // The function takes the following parameters: // // - id ClockID: The #GstClockID to wait on // // The function returns the following values: // // - jitter ClockTimeDiff: a pointer that will contain the jitter, // can be %NULL. // - goret ClockReturn // // Performs a blocking wait on @id. // @id should have been created with gst_clock_new_single_shot_id() // or gst_clock_new_periodic_id() and should not have been unscheduled // with a call to gst_clock_id_unschedule(). // // If the @jitter argument is not %NULL and this function returns #GST_CLOCK_OK // or #GST_CLOCK_EARLY, it will contain the difference // against the clock and the time of @id when this method was // called. // Positive values indicate how late @id was relative to the clock // (in which case this function will return #GST_CLOCK_EARLY). // Negative values indicate how much time was spent waiting on the clock // before this function returned. func ClockIDWait(id ClockID) (ClockTimeDiff, ClockReturn) { var carg1 C.GstClockID // in, none, casted, alias var carg2 C.GstClockTimeDiff // out, full, casted, alias var cret C.GstClockReturn // return, none, casted carg1 = C.GstClockID(id) cret = C.gst_clock_id_wait(carg1, &carg2) runtime.KeepAlive(id) var jitter ClockTimeDiff var goret ClockReturn jitter = ClockTimeDiff(carg2) goret = ClockReturn(cret) return jitter, goret } // ClockIDWaitAsync wraps gst_clock_id_wait_async // // The function takes the following parameters: // // - id ClockID: a #GstClockID to wait on // - fn ClockCallback: The callback function // // The function returns the following values: // // - goret ClockReturn // // Registers a callback on the given #GstClockID @id with the given // function and user_data. When passing a #GstClockID with an invalid // time to this function, the callback will be called immediately // with a time set to %GST_CLOCK_TIME_NONE. The callback will // be called when the time of @id has been reached. // // The callback @func can be invoked from any thread, either provided by the // core or from a streaming thread. The application should be prepared for this. func ClockIDWaitAsync(id ClockID, fn ClockCallback) ClockReturn { var carg1 C.GstClockID // in, none, casted, alias var carg2 C.GstClockCallback // callback, scope: notified, closure: carg3, destroy: carg4 var carg3 C.gpointer // implicit var carg4 C.GDestroyNotify // implicit var cret C.GstClockReturn // return, none, casted carg1 = C.GstClockID(id) carg2 = (*[0]byte)(C._gotk4_gst1_ClockCallback) carg3 = C.gpointer(userdata.Register(fn)) carg4 = (C.GDestroyNotify)((*[0]byte)(C.destroyUserdata)) cret = C.gst_clock_id_wait_async(carg1, carg2, carg3, carg4) runtime.KeepAlive(id) runtime.KeepAlive(fn) var goret ClockReturn goret = ClockReturn(cret) return goret } // AddObservation wraps gst_clock_add_observation // // The function takes the following parameters: // // - slave ClockTime: a time on the slave // - master ClockTime: a time on the master // // The function returns the following values: // // - rSquared float64: a pointer to hold the result // - goret bool // // The time @master of the master clock and the time @slave of the slave // clock are added to the list of observations. If enough observations // are available, a linear regression algorithm is run on the // observations and @clock is recalibrated. // // If this functions returns %TRUE, @r_squared will contain the // correlation coefficient of the interpolation. A value of 1.0 // means a perfect regression was performed. This value can // be used to control the sampling frequency of the master and slave // clocks. func (clock *ClockInstance) AddObservation(slave ClockTime, master ClockTime) (float64, bool) { var carg0 *C.GstClock // in, none, converted var carg1 C.GstClockTime // in, none, casted, alias var carg2 C.GstClockTime // in, none, casted, alias var carg3 C.gdouble // out, full, casted var cret C.gboolean // return carg0 = (*C.GstClock)(UnsafeClockToGlibNone(clock)) carg1 = C.GstClockTime(slave) carg2 = C.GstClockTime(master) cret = C.gst_clock_add_observation(carg0, carg1, carg2, &carg3) runtime.KeepAlive(clock) runtime.KeepAlive(slave) runtime.KeepAlive(master) var rSquared float64 var goret bool rSquared = float64(carg3) if cret != 0 { goret = true } return rSquared, goret } // AddObservationUnapplied wraps gst_clock_add_observation_unapplied // // The function takes the following parameters: // // - slave ClockTime: a time on the slave // - master ClockTime: a time on the master // // The function returns the following values: // // - rSquared float64: a pointer to hold the result // - internal ClockTime: a location to store the internal time // - external ClockTime: a location to store the external time // - rateNum ClockTime: a location to store the rate numerator // - rateDenom ClockTime: a location to store the rate denominator // - goret bool // // Add a clock observation to the internal slaving algorithm the same as // gst_clock_add_observation(), and return the result of the master clock // estimation, without updating the internal calibration. // // The caller can then take the results and call gst_clock_set_calibration() // with the values, or some modified version of them. func (clock *ClockInstance) AddObservationUnapplied(slave ClockTime, master ClockTime) (float64, ClockTime, ClockTime, ClockTime, ClockTime, bool) { var carg0 *C.GstClock // in, none, converted var carg1 C.GstClockTime // in, none, casted, alias var carg2 C.GstClockTime // in, none, casted, alias var carg3 C.gdouble // out, full, casted var carg4 C.GstClockTime // out, full, casted, alias var carg5 C.GstClockTime // out, full, casted, alias var carg6 C.GstClockTime // out, full, casted, alias var carg7 C.GstClockTime // out, full, casted, alias var cret C.gboolean // return carg0 = (*C.GstClock)(UnsafeClockToGlibNone(clock)) carg1 = C.GstClockTime(slave) carg2 = C.GstClockTime(master) cret = C.gst_clock_add_observation_unapplied(carg0, carg1, carg2, &carg3, &carg4, &carg5, &carg6, &carg7) runtime.KeepAlive(clock) runtime.KeepAlive(slave) runtime.KeepAlive(master) var rSquared float64 var internal ClockTime var external ClockTime var rateNum ClockTime var rateDenom ClockTime var goret bool rSquared = float64(carg3) internal = ClockTime(carg4) external = ClockTime(carg5) rateNum = ClockTime(carg6) rateDenom = ClockTime(carg7) if cret != 0 { goret = true } return rSquared, internal, external, rateNum, rateDenom, goret } // AdjustUnlocked wraps gst_clock_adjust_unlocked // // The function takes the following parameters: // // - internal ClockTime: a clock time // // The function returns the following values: // // - goret ClockTime // // Converts the given @internal clock time to the external time, adjusting for the // rate and reference time set with gst_clock_set_calibration() and making sure // that the returned time is increasing. This function should be called with the // clock's OBJECT_LOCK held and is mainly used by clock subclasses. // // This function is the reverse of gst_clock_unadjust_unlocked(). func (clock *ClockInstance) AdjustUnlocked(internal ClockTime) ClockTime { var carg0 *C.GstClock // in, none, converted var carg1 C.GstClockTime // in, none, casted, alias var cret C.GstClockTime // return, none, casted, alias carg0 = (*C.GstClock)(UnsafeClockToGlibNone(clock)) carg1 = C.GstClockTime(internal) cret = C.gst_clock_adjust_unlocked(carg0, carg1) runtime.KeepAlive(clock) runtime.KeepAlive(internal) var goret ClockTime goret = ClockTime(cret) return goret } // AdjustWithCalibration wraps gst_clock_adjust_with_calibration // // The function takes the following parameters: // // - internalTarget ClockTime: a clock time // - cinternal ClockTime: a reference internal time // - cexternal ClockTime: a reference external time // - cnum ClockTime: the numerator of the rate of the clock relative to its // internal time // - cdenom ClockTime: the denominator of the rate of the clock // // The function returns the following values: // // - goret ClockTime // // Converts the given @internal_target clock time to the external time, // using the passed calibration parameters. This function performs the // same calculation as gst_clock_adjust_unlocked() when called using the // current calibration parameters, but doesn't ensure a monotonically // increasing result as gst_clock_adjust_unlocked() does. // // Note: The @clock parameter is unused and can be NULL func (clock *ClockInstance) AdjustWithCalibration(internalTarget ClockTime, cinternal ClockTime, cexternal ClockTime, cnum ClockTime, cdenom ClockTime) ClockTime { var carg0 *C.GstClock // in, none, converted var carg1 C.GstClockTime // in, none, casted, alias var carg2 C.GstClockTime // in, none, casted, alias var carg3 C.GstClockTime // in, none, casted, alias var carg4 C.GstClockTime // in, none, casted, alias var carg5 C.GstClockTime // in, none, casted, alias var cret C.GstClockTime // return, none, casted, alias carg0 = (*C.GstClock)(UnsafeClockToGlibNone(clock)) carg1 = C.GstClockTime(internalTarget) carg2 = C.GstClockTime(cinternal) carg3 = C.GstClockTime(cexternal) carg4 = C.GstClockTime(cnum) carg5 = C.GstClockTime(cdenom) cret = C.gst_clock_adjust_with_calibration(carg0, carg1, carg2, carg3, carg4, carg5) runtime.KeepAlive(clock) runtime.KeepAlive(internalTarget) runtime.KeepAlive(cinternal) runtime.KeepAlive(cexternal) runtime.KeepAlive(cnum) runtime.KeepAlive(cdenom) var goret ClockTime goret = ClockTime(cret) return goret } // GetCalibration wraps gst_clock_get_calibration // // The function returns the following values: // // - internal ClockTime: a location to store the internal time // - external ClockTime: a location to store the external time // - rateNum ClockTime: a location to store the rate numerator // - rateDenom ClockTime: a location to store the rate denominator // // Gets the internal rate and reference time of @clock. See // gst_clock_set_calibration() for more information. // // @internal, @external, @rate_num, and @rate_denom can be left %NULL if the // caller is not interested in the values. func (clock *ClockInstance) GetCalibration() (ClockTime, ClockTime, ClockTime, ClockTime) { var carg0 *C.GstClock // in, none, converted var carg1 C.GstClockTime // out, full, casted, alias var carg2 C.GstClockTime // out, full, casted, alias var carg3 C.GstClockTime // out, full, casted, alias var carg4 C.GstClockTime // out, full, casted, alias carg0 = (*C.GstClock)(UnsafeClockToGlibNone(clock)) C.gst_clock_get_calibration(carg0, &carg1, &carg2, &carg3, &carg4) runtime.KeepAlive(clock) var internal ClockTime var external ClockTime var rateNum ClockTime var rateDenom ClockTime internal = ClockTime(carg1) external = ClockTime(carg2) rateNum = ClockTime(carg3) rateDenom = ClockTime(carg4) return internal, external, rateNum, rateDenom } // GetInternalTime wraps gst_clock_get_internal_time // // The function returns the following values: // // - goret ClockTime // // Gets the current internal time of the given clock. The time is returned // unadjusted for the offset and the rate. func (clock *ClockInstance) GetInternalTime() ClockTime { var carg0 *C.GstClock // in, none, converted var cret C.GstClockTime // return, none, casted, alias carg0 = (*C.GstClock)(UnsafeClockToGlibNone(clock)) cret = C.gst_clock_get_internal_time(carg0) runtime.KeepAlive(clock) var goret ClockTime goret = ClockTime(cret) return goret } // GetMaster wraps gst_clock_get_master // // The function returns the following values: // // - goret Clock (nullable) // // Gets the master clock that @clock is slaved to or %NULL when the clock is // not slaved to any master clock. func (clock *ClockInstance) GetMaster() Clock { var carg0 *C.GstClock // in, none, converted var cret *C.GstClock // return, full, converted, nullable carg0 = (*C.GstClock)(UnsafeClockToGlibNone(clock)) cret = C.gst_clock_get_master(carg0) runtime.KeepAlive(clock) var goret Clock if cret != nil { goret = UnsafeClockFromGlibFull(unsafe.Pointer(cret)) } return goret } // GetResolution wraps gst_clock_get_resolution // // The function returns the following values: // // - goret ClockTime // // Gets the accuracy of the clock. The accuracy of the clock is the granularity // of the values returned by gst_clock_get_time(). func (clock *ClockInstance) GetResolution() ClockTime { var carg0 *C.GstClock // in, none, converted var cret C.GstClockTime // return, none, casted, alias carg0 = (*C.GstClock)(UnsafeClockToGlibNone(clock)) cret = C.gst_clock_get_resolution(carg0) runtime.KeepAlive(clock) var goret ClockTime goret = ClockTime(cret) return goret } // GetTime wraps gst_clock_get_time // // The function returns the following values: // // - goret ClockTime // // Gets the current time of the given clock. The time is always // monotonically increasing and adjusted according to the current // offset and rate. func (clock *ClockInstance) GetTime() ClockTime { var carg0 *C.GstClock // in, none, converted var cret C.GstClockTime // return, none, casted, alias carg0 = (*C.GstClock)(UnsafeClockToGlibNone(clock)) cret = C.gst_clock_get_time(carg0) runtime.KeepAlive(clock) var goret ClockTime goret = ClockTime(cret) return goret } // GetTimeout wraps gst_clock_get_timeout // // The function returns the following values: // // - goret ClockTime // // Gets the amount of time that master and slave clocks are sampled. func (clock *ClockInstance) GetTimeout() ClockTime { var carg0 *C.GstClock // in, none, converted var cret C.GstClockTime // return, none, casted, alias carg0 = (*C.GstClock)(UnsafeClockToGlibNone(clock)) cret = C.gst_clock_get_timeout(carg0) runtime.KeepAlive(clock) var goret ClockTime goret = ClockTime(cret) return goret } // IsSynced wraps gst_clock_is_synced // // The function returns the following values: // // - goret bool // // Checks if the clock is currently synced, by looking at whether // %GST_CLOCK_FLAG_NEEDS_STARTUP_SYNC is set. func (clock *ClockInstance) IsSynced() bool { var carg0 *C.GstClock // in, none, converted var cret C.gboolean // return carg0 = (*C.GstClock)(UnsafeClockToGlibNone(clock)) cret = C.gst_clock_is_synced(carg0) runtime.KeepAlive(clock) var goret bool if cret != 0 { goret = true } return goret } // NewPeriodicID wraps gst_clock_new_periodic_id // // The function takes the following parameters: // // - startTime ClockTime: the requested start time // - interval ClockTime: the requested interval // // The function returns the following values: // // - goret ClockID // // Gets an ID from @clock to trigger a periodic notification. // The periodic notifications will start at time @start_time and // will then be fired with the given @interval. func (clock *ClockInstance) NewPeriodicID(startTime ClockTime, interval ClockTime) ClockID { var carg0 *C.GstClock // in, none, converted var carg1 C.GstClockTime // in, none, casted, alias var carg2 C.GstClockTime // in, none, casted, alias var cret C.GstClockID // return, full, casted, alias carg0 = (*C.GstClock)(UnsafeClockToGlibNone(clock)) carg1 = C.GstClockTime(startTime) carg2 = C.GstClockTime(interval) cret = C.gst_clock_new_periodic_id(carg0, carg1, carg2) runtime.KeepAlive(clock) runtime.KeepAlive(startTime) runtime.KeepAlive(interval) var goret ClockID goret = ClockID(cret) return goret } // NewSingleShotID wraps gst_clock_new_single_shot_id // // The function takes the following parameters: // // - time ClockTime: the requested time // // The function returns the following values: // // - goret ClockID // // Gets a #GstClockID from @clock to trigger a single shot // notification at the requested time. func (clock *ClockInstance) NewSingleShotID(time ClockTime) ClockID { var carg0 *C.GstClock // in, none, converted var carg1 C.GstClockTime // in, none, casted, alias var cret C.GstClockID // return, full, casted, alias carg0 = (*C.GstClock)(UnsafeClockToGlibNone(clock)) carg1 = C.GstClockTime(time) cret = C.gst_clock_new_single_shot_id(carg0, carg1) runtime.KeepAlive(clock) runtime.KeepAlive(time) var goret ClockID goret = ClockID(cret) return goret } // PeriodicIDReinit wraps gst_clock_periodic_id_reinit // // The function takes the following parameters: // // - id ClockID: a #GstClockID // - startTime ClockTime: the requested start time // - interval ClockTime: the requested interval // // The function returns the following values: // // - goret bool // // Reinitializes the provided periodic @id to the provided start time and // interval. Does not modify the reference count. func (clock *ClockInstance) PeriodicIDReinit(id ClockID, startTime ClockTime, interval ClockTime) bool { var carg0 *C.GstClock // in, none, converted var carg1 C.GstClockID // in, none, casted, alias var carg2 C.GstClockTime // in, none, casted, alias var carg3 C.GstClockTime // in, none, casted, alias var cret C.gboolean // return carg0 = (*C.GstClock)(UnsafeClockToGlibNone(clock)) carg1 = C.GstClockID(id) carg2 = C.GstClockTime(startTime) carg3 = C.GstClockTime(interval) cret = C.gst_clock_periodic_id_reinit(carg0, carg1, carg2, carg3) runtime.KeepAlive(clock) runtime.KeepAlive(id) runtime.KeepAlive(startTime) runtime.KeepAlive(interval) var goret bool if cret != 0 { goret = true } return goret } // SetCalibration wraps gst_clock_set_calibration // // The function takes the following parameters: // // - internal ClockTime: a reference internal time // - external ClockTime: a reference external time // - rateNum ClockTime: the numerator of the rate of the clock relative to its // internal time // - rateDenom ClockTime: the denominator of the rate of the clock // // Adjusts the rate and time of @clock. A rate of 1/1 is the normal speed of // the clock. Values bigger than 1/1 make the clock go faster. // // @internal and @external are calibration parameters that arrange that // gst_clock_get_time() should have been @external at internal time @internal. // This internal time should not be in the future; that is, it should be less // than the value of gst_clock_get_internal_time() when this function is called. // // Subsequent calls to gst_clock_get_time() will return clock times computed as // follows: // // ``` C // time = (internal_time - internal) * rate_num / rate_denom + external // ``` // // This formula is implemented in gst_clock_adjust_unlocked(). Of course, it // tries to do the integer arithmetic as precisely as possible. // // Note that gst_clock_get_time() always returns increasing values so when you // move the clock backwards, gst_clock_get_time() will report the previous value // until the clock catches up. func (clock *ClockInstance) SetCalibration(internal ClockTime, external ClockTime, rateNum ClockTime, rateDenom ClockTime) { var carg0 *C.GstClock // in, none, converted var carg1 C.GstClockTime // in, none, casted, alias var carg2 C.GstClockTime // in, none, casted, alias var carg3 C.GstClockTime // in, none, casted, alias var carg4 C.GstClockTime // in, none, casted, alias carg0 = (*C.GstClock)(UnsafeClockToGlibNone(clock)) carg1 = C.GstClockTime(internal) carg2 = C.GstClockTime(external) carg3 = C.GstClockTime(rateNum) carg4 = C.GstClockTime(rateDenom) C.gst_clock_set_calibration(carg0, carg1, carg2, carg3, carg4) runtime.KeepAlive(clock) runtime.KeepAlive(internal) runtime.KeepAlive(external) runtime.KeepAlive(rateNum) runtime.KeepAlive(rateDenom) } // SetMaster wraps gst_clock_set_master // // The function takes the following parameters: // // - master Clock (nullable): a master #GstClock // // The function returns the following values: // // - goret bool // // Sets @master as the master clock for @clock. @clock will be automatically // calibrated so that gst_clock_get_time() reports the same time as the // master clock. // // A clock provider that slaves its clock to a master can get the current // calibration values with gst_clock_get_calibration(). // // @master can be %NULL in which case @clock will not be slaved anymore. It will // however keep reporting its time adjusted with the last configured rate // and time offsets. func (clock *ClockInstance) SetMaster(master Clock) bool { var carg0 *C.GstClock // in, none, converted var carg1 *C.GstClock // in, none, converted, nullable var cret C.gboolean // return carg0 = (*C.GstClock)(UnsafeClockToGlibNone(clock)) if master != nil { carg1 = (*C.GstClock)(UnsafeClockToGlibNone(master)) } cret = C.gst_clock_set_master(carg0, carg1) runtime.KeepAlive(clock) runtime.KeepAlive(master) var goret bool if cret != 0 { goret = true } return goret } // SetResolution wraps gst_clock_set_resolution // // The function takes the following parameters: // // - resolution ClockTime: The resolution to set // // The function returns the following values: // // - goret ClockTime // // Sets the accuracy of the clock. Some clocks have the possibility to operate // with different accuracy at the expense of more resource usage. There is // normally no need to change the default resolution of a clock. The resolution // of a clock can only be changed if the clock has the // #GST_CLOCK_FLAG_CAN_SET_RESOLUTION flag set. func (clock *ClockInstance) SetResolution(resolution ClockTime) ClockTime { var carg0 *C.GstClock // in, none, converted var carg1 C.GstClockTime // in, none, casted, alias var cret C.GstClockTime // return, none, casted, alias carg0 = (*C.GstClock)(UnsafeClockToGlibNone(clock)) carg1 = C.GstClockTime(resolution) cret = C.gst_clock_set_resolution(carg0, carg1) runtime.KeepAlive(clock) runtime.KeepAlive(resolution) var goret ClockTime goret = ClockTime(cret) return goret } // SetSynced wraps gst_clock_set_synced // // The function takes the following parameters: // // - synced bool: if the clock is synced // // Sets @clock to synced and emits the #GstClock::synced signal, and wakes up any // thread waiting in gst_clock_wait_for_sync(). // // This function must only be called if %GST_CLOCK_FLAG_NEEDS_STARTUP_SYNC // is set on the clock, and is intended to be called by subclasses only. func (clock *ClockInstance) SetSynced(synced bool) { var carg0 *C.GstClock // in, none, converted var carg1 C.gboolean // in carg0 = (*C.GstClock)(UnsafeClockToGlibNone(clock)) if synced { carg1 = C.TRUE } C.gst_clock_set_synced(carg0, carg1) runtime.KeepAlive(clock) runtime.KeepAlive(synced) } // SetTimeout wraps gst_clock_set_timeout // // The function takes the following parameters: // // - timeout ClockTime: a timeout // // Sets the amount of time, in nanoseconds, to sample master and slave // clocks func (clock *ClockInstance) SetTimeout(timeout ClockTime) { var carg0 *C.GstClock // in, none, converted var carg1 C.GstClockTime // in, none, casted, alias carg0 = (*C.GstClock)(UnsafeClockToGlibNone(clock)) carg1 = C.GstClockTime(timeout) C.gst_clock_set_timeout(carg0, carg1) runtime.KeepAlive(clock) runtime.KeepAlive(timeout) } // SingleShotIDReinit wraps gst_clock_single_shot_id_reinit // // The function takes the following parameters: // // - id ClockID: a #GstClockID // - time ClockTime: The requested time. // // The function returns the following values: // // - goret bool // // Reinitializes the provided single shot @id to the provided time. Does not // modify the reference count. func (clock *ClockInstance) SingleShotIDReinit(id ClockID, time ClockTime) bool { var carg0 *C.GstClock // in, none, converted var carg1 C.GstClockID // in, none, casted, alias var carg2 C.GstClockTime // in, none, casted, alias var cret C.gboolean // return carg0 = (*C.GstClock)(UnsafeClockToGlibNone(clock)) carg1 = C.GstClockID(id) carg2 = C.GstClockTime(time) cret = C.gst_clock_single_shot_id_reinit(carg0, carg1, carg2) runtime.KeepAlive(clock) runtime.KeepAlive(id) runtime.KeepAlive(time) var goret bool if cret != 0 { goret = true } return goret } // UnadjustUnlocked wraps gst_clock_unadjust_unlocked // // The function takes the following parameters: // // - external ClockTime: an external clock time // // The function returns the following values: // // - goret ClockTime // // Converts the given @external clock time to the internal time of @clock, // using the rate and reference time set with gst_clock_set_calibration(). // This function should be called with the clock's OBJECT_LOCK held and // is mainly used by clock subclasses. // // This function is the reverse of gst_clock_adjust_unlocked(). func (clock *ClockInstance) UnadjustUnlocked(external ClockTime) ClockTime { var carg0 *C.GstClock // in, none, converted var carg1 C.GstClockTime // in, none, casted, alias var cret C.GstClockTime // return, none, casted, alias carg0 = (*C.GstClock)(UnsafeClockToGlibNone(clock)) carg1 = C.GstClockTime(external) cret = C.gst_clock_unadjust_unlocked(carg0, carg1) runtime.KeepAlive(clock) runtime.KeepAlive(external) var goret ClockTime goret = ClockTime(cret) return goret } // UnadjustWithCalibration wraps gst_clock_unadjust_with_calibration // // The function takes the following parameters: // // - externalTarget ClockTime: a clock time // - cinternal ClockTime: a reference internal time // - cexternal ClockTime: a reference external time // - cnum ClockTime: the numerator of the rate of the clock relative to its // internal time // - cdenom ClockTime: the denominator of the rate of the clock // // The function returns the following values: // // - goret ClockTime // // Converts the given @external_target clock time to the internal time, // using the passed calibration parameters. This function performs the // same calculation as gst_clock_unadjust_unlocked() when called using the // current calibration parameters. // // Note: The @clock parameter is unused and can be NULL func (clock *ClockInstance) UnadjustWithCalibration(externalTarget ClockTime, cinternal ClockTime, cexternal ClockTime, cnum ClockTime, cdenom ClockTime) ClockTime { var carg0 *C.GstClock // in, none, converted var carg1 C.GstClockTime // in, none, casted, alias var carg2 C.GstClockTime // in, none, casted, alias var carg3 C.GstClockTime // in, none, casted, alias var carg4 C.GstClockTime // in, none, casted, alias var carg5 C.GstClockTime // in, none, casted, alias var cret C.GstClockTime // return, none, casted, alias carg0 = (*C.GstClock)(UnsafeClockToGlibNone(clock)) carg1 = C.GstClockTime(externalTarget) carg2 = C.GstClockTime(cinternal) carg3 = C.GstClockTime(cexternal) carg4 = C.GstClockTime(cnum) carg5 = C.GstClockTime(cdenom) cret = C.gst_clock_unadjust_with_calibration(carg0, carg1, carg2, carg3, carg4, carg5) runtime.KeepAlive(clock) runtime.KeepAlive(externalTarget) runtime.KeepAlive(cinternal) runtime.KeepAlive(cexternal) runtime.KeepAlive(cnum) runtime.KeepAlive(cdenom) var goret ClockTime goret = ClockTime(cret) return goret } // WaitForSync wraps gst_clock_wait_for_sync // // The function takes the following parameters: // // - timeout ClockTime: timeout for waiting or %GST_CLOCK_TIME_NONE // // The function returns the following values: // // - goret bool // // Waits until @clock is synced for reporting the current time. If @timeout // is %GST_CLOCK_TIME_NONE it will wait forever, otherwise it will time out // after @timeout nanoseconds. // // For asynchronous waiting, the #GstClock::synced signal can be used. // // This returns immediately with %TRUE if %GST_CLOCK_FLAG_NEEDS_STARTUP_SYNC // is not set on the clock, or if the clock is already synced. func (clock *ClockInstance) WaitForSync(timeout ClockTime) bool { var carg0 *C.GstClock // in, none, converted var carg1 C.GstClockTime // in, none, casted, alias var cret C.gboolean // return carg0 = (*C.GstClock)(UnsafeClockToGlibNone(clock)) carg1 = C.GstClockTime(timeout) cret = C.gst_clock_wait_for_sync(carg0, carg1) runtime.KeepAlive(clock) runtime.KeepAlive(timeout) var goret bool if cret != 0 { goret = true } return goret } // ConnectSynced connects the provided callback to the "synced" signal // // Signaled on clocks with %GST_CLOCK_FLAG_NEEDS_STARTUP_SYNC set once // the clock is synchronized, or when it completely lost synchronization. // This signal will not be emitted on clocks without the flag. // // This signal will be emitted from an arbitrary thread, most likely not // the application's main thread. 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 ObjectInstance } var _ ControlBinding = (*ControlBindingInstance)(nil) // ControlBinding wraps GstControlBinding // // A base class for value mapping objects that attaches control sources to #GObject // properties. Such an object is taking one or more #GstControlSource instances, // combines them and maps the resulting value to the type and value range of the // bound property. type ControlBinding interface { Object upcastToGstControlBinding() *ControlBindingInstance // IsDisabled wraps gst_control_binding_is_disabled // // The function returns the following values: // // - goret bool // // Checks if the control binding is disabled. IsDisabled() bool // SetDisabled wraps gst_control_binding_set_disabled // // The function takes the following parameters: // // - disabled bool: boolean that specifies whether to disable the controller // or not. // // This function is used to disable a control binding for some time, i.e. // gst_object_sync_values() will do nothing. SetDisabled(bool) // SyncControlBindingValues wraps gst_control_binding_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 // // Sets the property of the @object, according to the #GstControlSources that // handles it and for the given timestamp. // // If this function fails, it is most likely the application developers fault. // Most probably the control sources are not setup correctly. SyncControlBindingValues(Object, ClockTime, ClockTime) bool } func unsafeWrapControlBinding(base *gobject.ObjectInstance) *ControlBindingInstance { return &ControlBindingInstance{ ObjectInstance: ObjectInstance{ InitiallyUnownedInstance: gobject.InitiallyUnownedInstance{ ObjectInstance: *base, }, }, } } func marshalControlBindingInstance(p unsafe.Pointer) (any, error) { return unsafeWrapControlBinding(gobject.ValueFromNative(p).Object()), nil } // UnsafeControlBindingFromGlibNone is used to convert raw GstControlBinding pointers to go while taking a reference and attaching a finalizer. This is used by the bindings internally. func UnsafeControlBindingFromGlibNone(c unsafe.Pointer) ControlBinding { return gobject.UnsafeObjectFromGlibNone(c).(ControlBinding) } // UnsafeControlBindingFromGlibFull is used to convert raw GstControlBinding pointers to go while attaching a finalizer. This is used by the bindings internally. func UnsafeControlBindingFromGlibFull(c unsafe.Pointer) ControlBinding { return gobject.UnsafeObjectFromGlibFull(c).(ControlBinding) } func (c *ControlBindingInstance) upcastToGstControlBinding() *ControlBindingInstance { return c } // UnsafeControlBindingToGlibNone is used to convert the instance to it's C value GstControlBinding. This is used by the bindings internally. func UnsafeControlBindingToGlibNone(c ControlBinding) unsafe.Pointer { return gobject.UnsafeObjectToGlibNone(c) } // UnsafeControlBindingToGlibFull is used to convert the instance to it's C value GstControlBinding, while removeing the finalizer. This is used by the bindings internally. func UnsafeControlBindingToGlibFull(c ControlBinding) unsafe.Pointer { return gobject.UnsafeObjectToGlibFull(c) } // IsDisabled wraps gst_control_binding_is_disabled // // The function returns the following values: // // - goret bool // // Checks if the control binding is disabled. func (binding *ControlBindingInstance) IsDisabled() bool { var carg0 *C.GstControlBinding // in, none, converted var cret C.gboolean // return carg0 = (*C.GstControlBinding)(UnsafeControlBindingToGlibNone(binding)) cret = C.gst_control_binding_is_disabled(carg0) runtime.KeepAlive(binding) var goret bool if cret != 0 { goret = true } return goret } // SetDisabled wraps gst_control_binding_set_disabled // // The function takes the following parameters: // // - disabled bool: boolean that specifies whether to disable the controller // or not. // // This function is used to disable a control binding for some time, i.e. // gst_object_sync_values() will do nothing. func (binding *ControlBindingInstance) SetDisabled(disabled bool) { var carg0 *C.GstControlBinding // in, none, converted var carg1 C.gboolean // in carg0 = (*C.GstControlBinding)(UnsafeControlBindingToGlibNone(binding)) if disabled { carg1 = C.TRUE } C.gst_control_binding_set_disabled(carg0, carg1) runtime.KeepAlive(binding) runtime.KeepAlive(disabled) } // SyncControlBindingValues wraps gst_control_binding_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 // // Sets the property of the @object, according to the #GstControlSources that // handles it and for the given timestamp. // // If this function fails, it is most likely the application developers fault. // Most probably the control sources are not setup correctly. func (binding *ControlBindingInstance) SyncControlBindingValues(object Object, timestamp ClockTime, lastSync ClockTime) bool { var carg0 *C.GstControlBinding // in, none, converted var carg1 *C.GstObject // in, none, converted var carg2 C.GstClockTime // in, none, casted, alias var carg3 C.GstClockTime // in, none, casted, alias var cret C.gboolean // return carg0 = (*C.GstControlBinding)(UnsafeControlBindingToGlibNone(binding)) carg1 = (*C.GstObject)(UnsafeObjectToGlibNone(object)) carg2 = C.GstClockTime(timestamp) carg3 = C.GstClockTime(lastSync) cret = C.gst_control_binding_sync_values(carg0, carg1, carg2, carg3) runtime.KeepAlive(binding) runtime.KeepAlive(object) runtime.KeepAlive(timestamp) runtime.KeepAlive(lastSync) var goret bool if cret != 0 { goret = true } 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 ObjectInstance } var _ ControlSource = (*ControlSourceInstance)(nil) // ControlSource wraps GstControlSource // // The #GstControlSource is a base class for control value sources that could // be used to get timestamp-value pairs. A control source essentially is a // function over time. // // A #GstControlSource is used by first getting an instance of a specific // control-source, creating a binding for the control-source to the target property // of the element and then adding the binding to the element. The binding will // convert the data types and value range to fit to the bound property. // // For implementing a new #GstControlSource one has to implement // #GstControlSourceGetValue and #GstControlSourceGetValueArray functions. // These are then used by gst_control_source_get_value() and // gst_control_source_get_value_array() to get values for specific timestamps. type ControlSource interface { Object upcastToGstControlSource() *ControlSourceInstance // ControlSourceGetValue wraps gst_control_source_get_value // // The function takes the following parameters: // // - timestamp ClockTime: the time for which the value should be returned // // The function returns the following values: // // - value float64: the value // - goret bool // // Gets the value for this #GstControlSource at a given timestamp. ControlSourceGetValue(ClockTime) (float64, bool) // ControlSourceGetValueArray wraps gst_control_source_get_value_array // // The function takes the following parameters: // // - timestamp ClockTime: the first timestamp // - interval ClockTime: the time steps // - values []float64: array to put control-values in // // The function returns the following values: // // - goret bool // // Gets an array of values for for this #GstControlSource. Values that are // undefined contain NANs. ControlSourceGetValueArray(ClockTime, ClockTime, []float64) bool } func unsafeWrapControlSource(base *gobject.ObjectInstance) *ControlSourceInstance { return &ControlSourceInstance{ ObjectInstance: ObjectInstance{ InitiallyUnownedInstance: gobject.InitiallyUnownedInstance{ ObjectInstance: *base, }, }, } } func marshalControlSourceInstance(p unsafe.Pointer) (any, error) { return unsafeWrapControlSource(gobject.ValueFromNative(p).Object()), nil } // UnsafeControlSourceFromGlibNone is used to convert raw GstControlSource pointers to go while taking a reference and attaching a finalizer. This is used by the bindings internally. func UnsafeControlSourceFromGlibNone(c unsafe.Pointer) ControlSource { return gobject.UnsafeObjectFromGlibNone(c).(ControlSource) } // UnsafeControlSourceFromGlibFull is used to convert raw GstControlSource pointers to go while attaching a finalizer. This is used by the bindings internally. func UnsafeControlSourceFromGlibFull(c unsafe.Pointer) ControlSource { return gobject.UnsafeObjectFromGlibFull(c).(ControlSource) } func (c *ControlSourceInstance) upcastToGstControlSource() *ControlSourceInstance { return c } // UnsafeControlSourceToGlibNone is used to convert the instance to it's C value GstControlSource. This is used by the bindings internally. func UnsafeControlSourceToGlibNone(c ControlSource) unsafe.Pointer { return gobject.UnsafeObjectToGlibNone(c) } // UnsafeControlSourceToGlibFull is used to convert the instance to it's C value GstControlSource, while removeing the finalizer. This is used by the bindings internally. func UnsafeControlSourceToGlibFull(c ControlSource) unsafe.Pointer { return gobject.UnsafeObjectToGlibFull(c) } // ControlSourceGetValue wraps gst_control_source_get_value // // The function takes the following parameters: // // - timestamp ClockTime: the time for which the value should be returned // // The function returns the following values: // // - value float64: the value // - goret bool // // Gets the value for this #GstControlSource at a given timestamp. func (self *ControlSourceInstance) ControlSourceGetValue(timestamp ClockTime) (float64, bool) { var carg0 *C.GstControlSource // in, none, converted var carg1 C.GstClockTime // in, none, casted, alias var carg2 C.gdouble // out, full, casted var cret C.gboolean // return carg0 = (*C.GstControlSource)(UnsafeControlSourceToGlibNone(self)) carg1 = C.GstClockTime(timestamp) cret = C.gst_control_source_get_value(carg0, carg1, &carg2) runtime.KeepAlive(self) runtime.KeepAlive(timestamp) var value float64 var goret bool value = float64(carg2) if cret != 0 { goret = true } return value, goret } // ControlSourceGetValueArray wraps gst_control_source_get_value_array // // The function takes the following parameters: // // - timestamp ClockTime: the first timestamp // - interval ClockTime: the time steps // - values []float64: array to put control-values in // // The function returns the following values: // // - goret bool // // Gets an array of values for for this #GstControlSource. Values that are // undefined contain NANs. func (self *ControlSourceInstance) ControlSourceGetValueArray(timestamp ClockTime, interval ClockTime, values []float64) bool { var carg0 *C.GstControlSource // in, none, converted var carg1 C.GstClockTime // in, none, casted, alias var carg2 C.GstClockTime // in, none, casted, alias var carg3 C.guint // implicit var carg4 *C.gdouble // in, transfer: none, C Pointers: 1, Name: array[gdouble], array (inner: *typesystem.CastablePrimitive, length-by: carg3) var cret C.gboolean // return carg0 = (*C.GstControlSource)(UnsafeControlSourceToGlibNone(self)) carg1 = C.GstClockTime(timestamp) carg2 = C.GstClockTime(interval) _ = values _ = carg4 _ = carg3 panic("unimplemented conversion of []float64 (gdouble*)") cret = C.gst_control_source_get_value_array(carg0, carg1, carg2, carg3, carg4) runtime.KeepAlive(self) runtime.KeepAlive(timestamp) runtime.KeepAlive(interval) runtime.KeepAlive(values) var goret bool if cret != 0 { goret = true } 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 ObjectInstance } var _ Device = (*DeviceInstance)(nil) // Device wraps GstDevice // // #GstDevice are objects representing a device, they contain // relevant metadata about the device, such as its class and the #GstCaps // representing the media types it can produce or handle. // // #GstDevice are created by #GstDeviceProvider objects which can be // aggregated by #GstDeviceMonitor objects. type Device interface { Object upcastToGstDevice() *DeviceInstance // CreateElement wraps gst_device_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) // // Creates the element with all of the required parameters set to use // this device. CreateElement(string) Element // GetCaps wraps gst_device_get_caps // // The function returns the following values: // // - goret *Caps (nullable) // // 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 // // Gets the "class" of a device. This is a "/" separated list of // classes that represent this device. They are a subset of the // 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 // // 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) // // Gets the extra properties of a device. GetProperties() *Structure // HasClasses wraps gst_device_has_classes // // The function takes the following parameters: // // - classes string: a "/"-separated list of device classes to match, only match if // all classes are matched // // The function returns the following values: // // - goret bool // // Check if @device matches all of the given classes HasClasses(string) bool // HasClassesv wraps gst_device_has_classesv // // The function takes the following parameters: // // - classes []string: a %NULL terminated array of classes // to match, only match if all classes are matched // // The function returns the following values: // // - goret bool // // Check if @factory matches all of the given classes HasClassesv([]string) bool // ReconfigureElement wraps gst_device_reconfigure_element // // The function takes the following parameters: // // - element Element: a #GstElement // // The function returns the following values: // // - goret bool // // Tries to reconfigure an existing element to use the device. If this // function fails, then one must destroy the element and create a new one // using gst_device_create_element(). // // Note: This should only be implemented for elements can change their // device in the PLAYING state. ReconfigureElement(Element) bool // ConnectRemoved connects the provided callback to the "removed" signal ConnectRemoved(func(Device)) gobject.SignalHandle } func unsafeWrapDevice(base *gobject.ObjectInstance) *DeviceInstance { return &DeviceInstance{ ObjectInstance: ObjectInstance{ InitiallyUnownedInstance: gobject.InitiallyUnownedInstance{ ObjectInstance: *base, }, }, } } func marshalDeviceInstance(p unsafe.Pointer) (any, error) { return unsafeWrapDevice(gobject.ValueFromNative(p).Object()), nil } // UnsafeDeviceFromGlibNone is used to convert raw GstDevice pointers to go while taking a reference and attaching a finalizer. This is used by the bindings internally. func UnsafeDeviceFromGlibNone(c unsafe.Pointer) Device { return gobject.UnsafeObjectFromGlibNone(c).(Device) } // UnsafeDeviceFromGlibFull is used to convert raw GstDevice pointers to go while attaching a finalizer. This is used by the bindings internally. func UnsafeDeviceFromGlibFull(c unsafe.Pointer) Device { return gobject.UnsafeObjectFromGlibFull(c).(Device) } func (d *DeviceInstance) upcastToGstDevice() *DeviceInstance { return d } // UnsafeDeviceToGlibNone is used to convert the instance to it's C value GstDevice. This is used by the bindings internally. func UnsafeDeviceToGlibNone(c Device) unsafe.Pointer { return gobject.UnsafeObjectToGlibNone(c) } // UnsafeDeviceToGlibFull is used to convert the instance to it's C value GstDevice, while removeing the finalizer. This is used by the bindings internally. func UnsafeDeviceToGlibFull(c Device) unsafe.Pointer { return gobject.UnsafeObjectToGlibFull(c) } // CreateElement wraps gst_device_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) // // Creates the element with all of the required parameters set to use // this device. func (device *DeviceInstance) CreateElement(name string) Element { var carg0 *C.GstDevice // in, none, converted var carg1 *C.gchar // in, none, string, nullable-string var cret *C.GstElement // return, none, converted, nullable carg0 = (*C.GstDevice)(UnsafeDeviceToGlibNone(device)) if name != "" { carg1 = (*C.gchar)(unsafe.Pointer(C.CString(name))) defer C.free(unsafe.Pointer(carg1)) } cret = C.gst_device_create_element(carg0, carg1) runtime.KeepAlive(device) runtime.KeepAlive(name) var goret Element if cret != nil { goret = UnsafeElementFromGlibNone(unsafe.Pointer(cret)) } return goret } // GetCaps wraps gst_device_get_caps // // The function returns the following values: // // - goret *Caps (nullable) // // Getter for the #GstCaps that this device supports. func (device *DeviceInstance) GetCaps() *Caps { var carg0 *C.GstDevice // in, none, converted var cret *C.GstCaps // return, full, converted, nullable carg0 = (*C.GstDevice)(UnsafeDeviceToGlibNone(device)) cret = C.gst_device_get_caps(carg0) runtime.KeepAlive(device) var goret *Caps if cret != nil { goret = UnsafeCapsFromGlibFull(unsafe.Pointer(cret)) } return goret } // GetDeviceClass wraps gst_device_get_device_class // // The function returns the following values: // // - goret string // // Gets the "class" of a device. This is a "/" separated list of // classes that represent this device. They are a subset of the // classes of the #GstDeviceProvider that produced this device. func (device *DeviceInstance) GetDeviceClass() string { var carg0 *C.GstDevice // in, none, converted var cret *C.gchar // return, full, string carg0 = (*C.GstDevice)(UnsafeDeviceToGlibNone(device)) cret = C.gst_device_get_device_class(carg0) runtime.KeepAlive(device) var goret string goret = C.GoString((*C.char)(unsafe.Pointer(cret))) defer C.free(unsafe.Pointer(cret)) return goret } // GetDisplayName wraps gst_device_get_display_name // // The function returns the following values: // // - goret string // // Gets the user-friendly name of the device. func (device *DeviceInstance) GetDisplayName() string { var carg0 *C.GstDevice // in, none, converted var cret *C.gchar // return, full, string carg0 = (*C.GstDevice)(UnsafeDeviceToGlibNone(device)) cret = C.gst_device_get_display_name(carg0) runtime.KeepAlive(device) var goret string goret = C.GoString((*C.char)(unsafe.Pointer(cret))) defer C.free(unsafe.Pointer(cret)) return goret } // GetProperties wraps gst_device_get_properties // // The function returns the following values: // // - goret *Structure (nullable) // // Gets the extra properties of a device. func (device *DeviceInstance) GetProperties() *Structure { var carg0 *C.GstDevice // in, none, converted var cret *C.GstStructure // return, full, converted, nullable carg0 = (*C.GstDevice)(UnsafeDeviceToGlibNone(device)) cret = C.gst_device_get_properties(carg0) runtime.KeepAlive(device) var goret *Structure if cret != nil { goret = UnsafeStructureFromGlibFull(unsafe.Pointer(cret)) } return goret } // HasClasses wraps gst_device_has_classes // // The function takes the following parameters: // // - classes string: a "/"-separated list of device classes to match, only match if // all classes are matched // // The function returns the following values: // // - goret bool // // Check if @device matches all of the given classes func (device *DeviceInstance) HasClasses(classes string) bool { var carg0 *C.GstDevice // in, none, converted var carg1 *C.gchar // in, none, string var cret C.gboolean // return carg0 = (*C.GstDevice)(UnsafeDeviceToGlibNone(device)) carg1 = (*C.gchar)(unsafe.Pointer(C.CString(classes))) defer C.free(unsafe.Pointer(carg1)) cret = C.gst_device_has_classes(carg0, carg1) runtime.KeepAlive(device) runtime.KeepAlive(classes) var goret bool if cret != 0 { goret = true } return goret } // HasClassesv wraps gst_device_has_classesv // // The function takes the following parameters: // // - classes []string: a %NULL terminated array of classes // to match, only match if all classes are matched // // The function returns the following values: // // - goret bool // // Check if @factory matches all of the given classes func (device *DeviceInstance) HasClassesv(classes []string) bool { var carg0 *C.GstDevice // in, none, converted var carg1 **C.gchar // in, transfer: none, C Pointers: 2, Name: array[utf8], array (inner: *typesystem.StringPrimitive, zero-terminated) var cret C.gboolean // return carg0 = (*C.GstDevice)(UnsafeDeviceToGlibNone(device)) _ = classes _ = carg1 panic("unimplemented conversion of []string (gchar**)") cret = C.gst_device_has_classesv(carg0, carg1) runtime.KeepAlive(device) runtime.KeepAlive(classes) var goret bool if cret != 0 { goret = true } return goret } // ReconfigureElement wraps gst_device_reconfigure_element // // The function takes the following parameters: // // - element Element: a #GstElement // // The function returns the following values: // // - goret bool // // Tries to reconfigure an existing element to use the device. If this // function fails, then one must destroy the element and create a new one // using gst_device_create_element(). // // Note: This should only be implemented for elements can change their // device in the PLAYING state. func (device *DeviceInstance) ReconfigureElement(element Element) bool { var carg0 *C.GstDevice // in, none, converted var carg1 *C.GstElement // in, none, converted var cret C.gboolean // return carg0 = (*C.GstDevice)(UnsafeDeviceToGlibNone(device)) carg1 = (*C.GstElement)(UnsafeElementToGlibNone(element)) cret = C.gst_device_reconfigure_element(carg0, carg1) runtime.KeepAlive(device) runtime.KeepAlive(element) var goret bool if cret != 0 { goret = true } return goret } // ConnectRemoved connects the provided callback to the "removed" signal 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 ObjectInstance } var _ DeviceMonitor = (*DeviceMonitorInstance)(nil) // DeviceMonitor wraps GstDeviceMonitor // // Applications should create a #GstDeviceMonitor when they want // to probe, list and monitor devices of a specific type. The // #GstDeviceMonitor will create the appropriate // #GstDeviceProvider objects and manage them. It will then post // messages on its #GstBus for devices that have been added and // removed. // // The device monitor will monitor all devices matching the filters that // the application has set. // // The basic use pattern of a device monitor is as follows: // |[ // static gboolean // my_bus_func (GstBus * bus, GstMessage * message, gpointer user_data) // { // GstDevice *device; // gchar *name; // // switch (GST_MESSAGE_TYPE (message)) { // case GST_MESSAGE_DEVICE_ADDED: // gst_message_parse_device_added (message, &device); // name = gst_device_get_display_name (device); // g_print("Device added: %s\n", name); // g_free (name); // gst_object_unref (device); // break; // case GST_MESSAGE_DEVICE_REMOVED: // gst_message_parse_device_removed (message, &device); // name = gst_device_get_display_name (device); // g_print("Device removed: %s\n", name); // g_free (name); // gst_object_unref (device); // break; // default: // break; // } // // return G_SOURCE_CONTINUE; // } // // GstDeviceMonitor * // setup_raw_video_source_device_monitor (void) { // GstDeviceMonitor *monitor; // GstBus *bus; // GstCaps *caps; // // monitor = gst_device_monitor_new (); // // bus = gst_device_monitor_get_bus (monitor); // gst_bus_add_watch (bus, my_bus_func, NULL); // gst_object_unref (bus); // // caps = gst_caps_new_empty_simple ("video/x-raw"); // gst_device_monitor_add_filter (monitor, "Video/Source", caps); // gst_caps_unref (caps); // // gst_device_monitor_start (monitor); // // return monitor; // } // ]| type DeviceMonitor interface { Object upcastToGstDeviceMonitor() *DeviceMonitorInstance // AddFilter wraps gst_device_monitor_add_filter // // The function takes the following parameters: // // - classes string (nullable): device classes to use as filter or %NULL for any class // - caps *Caps (nullable): the #GstCaps to filter or %NULL for ANY // // The function returns the following values: // // - goret uint // // Adds a filter for which #GstDevice will be monitored, any device that matches // all these classes and the #GstCaps will be returned. // // If this function is called multiple times to add more filters, each will be // matched independently. That is, adding more filters will not further restrict // what devices are matched. // // The #GstCaps supported by the device as returned by gst_device_get_caps() are // not intersected with caps filters added using this function. // // 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 // // Gets the #GstBus of this #GstDeviceMonitor GetBus() Bus // GetDevices wraps gst_device_monitor_get_devices // // The function returns the following values: // // - goret []Device (nullable) // // Gets a list of devices from all of the relevant monitors. This may actually // 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 // // Get a list of the currently selected device provider factories. // // This GetProviders() []string // GetShowAllDevices wraps gst_device_monitor_get_show_all_devices // // The function returns the following values: // // - goret bool // // Get if @monitor is currently showing all devices, even those from hidden // providers. GetShowAllDevices() bool // RemoveFilter wraps gst_device_monitor_remove_filter // // The function takes the following parameters: // // - filterId uint: the id of the filter // // The function returns the following values: // // - goret bool // // Removes a filter from the #GstDeviceMonitor using the id that was returned // by gst_device_monitor_add_filter(). RemoveFilter(uint) bool // SetShowAllDevices wraps gst_device_monitor_set_show_all_devices // // The function takes the following parameters: // // - showAll bool: show all devices // // Set if all devices should be visible, even those devices from hidden // 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 // // Starts monitoring the devices, one this has succeeded, the // %GST_MESSAGE_DEVICE_ADDED and %GST_MESSAGE_DEVICE_REMOVED messages // will be emitted on the bus when the list of devices changes. Start() bool // Stop wraps gst_device_monitor_stop // // Stops monitoring the devices. Stop() } func unsafeWrapDeviceMonitor(base *gobject.ObjectInstance) *DeviceMonitorInstance { return &DeviceMonitorInstance{ ObjectInstance: ObjectInstance{ InitiallyUnownedInstance: gobject.InitiallyUnownedInstance{ ObjectInstance: *base, }, }, } } func marshalDeviceMonitorInstance(p unsafe.Pointer) (any, error) { return unsafeWrapDeviceMonitor(gobject.ValueFromNative(p).Object()), nil } // UnsafeDeviceMonitorFromGlibNone is used to convert raw GstDeviceMonitor pointers to go while taking a reference and attaching a finalizer. This is used by the bindings internally. func UnsafeDeviceMonitorFromGlibNone(c unsafe.Pointer) DeviceMonitor { return gobject.UnsafeObjectFromGlibNone(c).(DeviceMonitor) } // UnsafeDeviceMonitorFromGlibFull is used to convert raw GstDeviceMonitor pointers to go while attaching a finalizer. This is used by the bindings internally. func UnsafeDeviceMonitorFromGlibFull(c unsafe.Pointer) DeviceMonitor { return gobject.UnsafeObjectFromGlibFull(c).(DeviceMonitor) } func (d *DeviceMonitorInstance) upcastToGstDeviceMonitor() *DeviceMonitorInstance { return d } // UnsafeDeviceMonitorToGlibNone is used to convert the instance to it's C value GstDeviceMonitor. This is used by the bindings internally. func UnsafeDeviceMonitorToGlibNone(c DeviceMonitor) unsafe.Pointer { return gobject.UnsafeObjectToGlibNone(c) } // UnsafeDeviceMonitorToGlibFull is used to convert the instance to it's C value GstDeviceMonitor, while removeing the finalizer. This is used by the bindings internally. func UnsafeDeviceMonitorToGlibFull(c DeviceMonitor) unsafe.Pointer { return gobject.UnsafeObjectToGlibFull(c) } // NewDeviceMonitor wraps gst_device_monitor_new // // The function returns the following values: // // - goret DeviceMonitor // // Create a new #GstDeviceMonitor func NewDeviceMonitor() DeviceMonitor { var cret *C.GstDeviceMonitor // return, full, converted cret = C.gst_device_monitor_new() var goret DeviceMonitor goret = UnsafeDeviceMonitorFromGlibFull(unsafe.Pointer(cret)) return goret } // AddFilter wraps gst_device_monitor_add_filter // // The function takes the following parameters: // // - classes string (nullable): device classes to use as filter or %NULL for any class // - caps *Caps (nullable): the #GstCaps to filter or %NULL for ANY // // The function returns the following values: // // - goret uint // // Adds a filter for which #GstDevice will be monitored, any device that matches // all these classes and the #GstCaps will be returned. // // If this function is called multiple times to add more filters, each will be // matched independently. That is, adding more filters will not further restrict // what devices are matched. // // The #GstCaps supported by the device as returned by gst_device_get_caps() are // not intersected with caps filters added using this function. // // Filters must be added before the #GstDeviceMonitor is started. func (monitor *DeviceMonitorInstance) AddFilter(classes string, caps *Caps) uint { var carg0 *C.GstDeviceMonitor // in, none, converted var carg1 *C.gchar // in, none, string, nullable-string var carg2 *C.GstCaps // in, none, converted, nullable var cret C.guint // return, none, casted carg0 = (*C.GstDeviceMonitor)(UnsafeDeviceMonitorToGlibNone(monitor)) if classes != "" { carg1 = (*C.gchar)(unsafe.Pointer(C.CString(classes))) defer C.free(unsafe.Pointer(carg1)) } if caps != nil { carg2 = (*C.GstCaps)(UnsafeCapsToGlibNone(caps)) } cret = C.gst_device_monitor_add_filter(carg0, carg1, carg2) runtime.KeepAlive(monitor) runtime.KeepAlive(classes) runtime.KeepAlive(caps) var goret uint goret = uint(cret) return goret } // GetBus wraps gst_device_monitor_get_bus // // The function returns the following values: // // - goret Bus // // Gets the #GstBus of this #GstDeviceMonitor func (monitor *DeviceMonitorInstance) GetBus() Bus { var carg0 *C.GstDeviceMonitor // in, none, converted var cret *C.GstBus // return, full, converted carg0 = (*C.GstDeviceMonitor)(UnsafeDeviceMonitorToGlibNone(monitor)) cret = C.gst_device_monitor_get_bus(carg0) runtime.KeepAlive(monitor) var goret Bus goret = UnsafeBusFromGlibFull(unsafe.Pointer(cret)) return goret } // GetDevices wraps gst_device_monitor_get_devices // // The function returns the following values: // // - goret []Device (nullable) // // Gets a list of devices from all of the relevant monitors. This may actually // probe the hardware if the monitor is not currently started. func (monitor *DeviceMonitorInstance) GetDevices() []Device { var carg0 *C.GstDeviceMonitor // in, none, converted var cret *C.GList // container, transfer: full carg0 = (*C.GstDeviceMonitor)(UnsafeDeviceMonitorToGlibNone(monitor)) cret = C.gst_device_monitor_get_devices(carg0) runtime.KeepAlive(monitor) var goret []Device goret = glib.UnsafeListFromGlibFull( unsafe.Pointer(cret), func(v unsafe.Pointer) Device { var dst Device // converted dst = UnsafeDeviceFromGlibFull(v) return dst }, ) return goret } // GetProviders wraps gst_device_monitor_get_providers // // The function returns the following values: // // - goret []string // // Get a list of the currently selected device provider factories. // // This func (monitor *DeviceMonitorInstance) GetProviders() []string { var carg0 *C.GstDeviceMonitor // in, none, converted var cret **C.gchar // return, transfer: full, C Pointers: 2, Name: array[utf8], scope: , array (inner: *typesystem.StringPrimitive, zero-terminated) carg0 = (*C.GstDeviceMonitor)(UnsafeDeviceMonitorToGlibNone(monitor)) cret = C.gst_device_monitor_get_providers(carg0) runtime.KeepAlive(monitor) var goret []string _ = goret _ = cret panic("unimplemented conversion of []string (gchar**)") return goret } // GetShowAllDevices wraps gst_device_monitor_get_show_all_devices // // The function returns the following values: // // - goret bool // // Get if @monitor is currently showing all devices, even those from hidden // providers. func (monitor *DeviceMonitorInstance) GetShowAllDevices() bool { var carg0 *C.GstDeviceMonitor // in, none, converted var cret C.gboolean // return carg0 = (*C.GstDeviceMonitor)(UnsafeDeviceMonitorToGlibNone(monitor)) cret = C.gst_device_monitor_get_show_all_devices(carg0) runtime.KeepAlive(monitor) var goret bool if cret != 0 { goret = true } return goret } // RemoveFilter wraps gst_device_monitor_remove_filter // // The function takes the following parameters: // // - filterId uint: the id of the filter // // The function returns the following values: // // - goret bool // // Removes a filter from the #GstDeviceMonitor using the id that was returned // by gst_device_monitor_add_filter(). func (monitor *DeviceMonitorInstance) RemoveFilter(filterId uint) bool { var carg0 *C.GstDeviceMonitor // in, none, converted var carg1 C.guint // in, none, casted var cret C.gboolean // return carg0 = (*C.GstDeviceMonitor)(UnsafeDeviceMonitorToGlibNone(monitor)) carg1 = C.guint(filterId) cret = C.gst_device_monitor_remove_filter(carg0, carg1) runtime.KeepAlive(monitor) runtime.KeepAlive(filterId) var goret bool if cret != 0 { goret = true } return goret } // SetShowAllDevices wraps gst_device_monitor_set_show_all_devices // // The function takes the following parameters: // // - showAll bool: show all devices // // Set if all devices should be visible, even those devices from hidden // providers. Setting @show_all to true might show some devices multiple times. func (monitor *DeviceMonitorInstance) SetShowAllDevices(showAll bool) { var carg0 *C.GstDeviceMonitor // in, none, converted var carg1 C.gboolean // in carg0 = (*C.GstDeviceMonitor)(UnsafeDeviceMonitorToGlibNone(monitor)) if showAll { carg1 = C.TRUE } C.gst_device_monitor_set_show_all_devices(carg0, carg1) runtime.KeepAlive(monitor) runtime.KeepAlive(showAll) } // Start wraps gst_device_monitor_start // // The function returns the following values: // // - goret bool // // Starts monitoring the devices, one this has succeeded, the // %GST_MESSAGE_DEVICE_ADDED and %GST_MESSAGE_DEVICE_REMOVED messages // will be emitted on the bus when the list of devices changes. func (monitor *DeviceMonitorInstance) Start() bool { var carg0 *C.GstDeviceMonitor // in, none, converted var cret C.gboolean // return carg0 = (*C.GstDeviceMonitor)(UnsafeDeviceMonitorToGlibNone(monitor)) cret = C.gst_device_monitor_start(carg0) runtime.KeepAlive(monitor) var goret bool if cret != 0 { goret = true } return goret } // Stop wraps gst_device_monitor_stop // // Stops monitoring the devices. func (monitor *DeviceMonitorInstance) Stop() { var carg0 *C.GstDeviceMonitor // in, none, converted carg0 = (*C.GstDeviceMonitor)(UnsafeDeviceMonitorToGlibNone(monitor)) C.gst_device_monitor_stop(carg0) 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 ObjectInstance } var _ DeviceProvider = (*DeviceProviderInstance)(nil) // DeviceProvider wraps GstDeviceProvider // // A #GstDeviceProvider subclass is provided by a plugin that handles devices // if there is a way to programmatically list connected devices. It can also // optionally provide updates to the list of connected devices. // // Each #GstDeviceProvider subclass is a singleton, a plugin should // normally provide a single subclass for all devices. // // Applications would normally use a #GstDeviceMonitor to monitor devices // from all relevant providers. type DeviceProvider interface { Object upcastToGstDeviceProvider() *DeviceProviderInstance // CanMonitor wraps gst_device_provider_can_monitor // // The function returns the following values: // // - goret bool CanMonitor() bool // DeviceAdd wraps gst_device_provider_device_add // // The function takes the following parameters: // // - device Device: a #GstDevice that has been added // // Posts a message on the provider's #GstBus to inform applications that // a new device has been added. // // This is for use by subclasses. // // @device's reference count will be incremented, and any floating reference // will be removed (see gst_object_ref_sink()). DeviceAdd(Device) // DeviceChanged wraps gst_device_provider_device_changed // // The function takes the following parameters: // // - device Device: the new version of @changed_device // - changedDevice Device: the old version of the device that has been updated // // This function is used when @changed_device was modified into its new form // @device. This will post a `DEVICE_CHANGED` message on the bus to let // the application know that the device was modified. #GstDevice is immutable // for MT. safety purposes so this is an "atomic" way of letting the application // know when a device was modified. DeviceChanged(Device, Device) // DeviceRemove wraps gst_device_provider_device_remove // // The function takes the following parameters: // // - device Device: a #GstDevice that has been removed // // Posts a message on the provider's #GstBus to inform applications that // a device has been removed. // // This is for use by subclasses. DeviceRemove(Device) // GetBus wraps gst_device_provider_get_bus // // The function returns the following values: // // - goret Bus // // Gets the #GstBus of this #GstDeviceProvider GetBus() Bus // GetDevices wraps gst_device_provider_get_devices // // The function returns the following values: // // - goret []Device // // Gets a list of devices that this provider understands. This may actually // probe the hardware if the provider is not currently started. // // If the provider has been started, this will returned the same #GstDevice // 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) // // 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 // // Get the provider factory names of the #GstDeviceProvider instances that // are hidden by @provider. GetHiddenProviders() []string // GetMetadata wraps gst_device_provider_get_metadata // // The function takes the following parameters: // // - key string: the key to get // // The function returns the following values: // // - goret string // // Get metadata with @key in @provider. GetMetadata(string) string // HideProvider wraps gst_device_provider_hide_provider // // The function takes the following parameters: // // - name string: a provider factory name // // Make @provider hide the devices from the factory with @name. // // This function is used when @provider will also provide the devices reported // by provider factory @name. A monitor should stop monitoring the // 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 // // 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 // // Starts providering the devices. This will cause #GST_MESSAGE_DEVICE_ADDED // and #GST_MESSAGE_DEVICE_REMOVED messages to be posted on the provider's bus // when devices are added or removed from the system. // // Since the #GstDeviceProvider is a singleton, // gst_device_provider_start() may already have been called by another // user of the object, gst_device_provider_stop() needs to be called the same // number of times. // // After this function has been called, gst_device_provider_get_devices() will // return the same objects that have been received from the // #GST_MESSAGE_DEVICE_ADDED messages and will no longer probe. Start() bool // Stop wraps gst_device_provider_stop // // Decreases the use-count by one. If the use count reaches zero, this // #GstDeviceProvider will stop providering the devices. This needs to be // called the same number of times that gst_device_provider_start() was called. Stop() // UnhideProvider wraps gst_device_provider_unhide_provider // // The function takes the following parameters: // // - name string: a provider factory name // // Make @provider unhide the devices from factory @name. // // This function is used when @provider will no longer provide the devices // reported by provider factory @name. A monitor should start // monitoring the devices from provider factory @name in order to see // all devices again. UnhideProvider(string) // ConnectProviderHidden connects the provided callback to the "provider-hidden" signal ConnectProviderHidden(func(DeviceProvider, string)) gobject.SignalHandle // ConnectProviderUnhidden connects the provided callback to the "provider-unhidden" signal ConnectProviderUnhidden(func(DeviceProvider, string)) gobject.SignalHandle } func unsafeWrapDeviceProvider(base *gobject.ObjectInstance) *DeviceProviderInstance { return &DeviceProviderInstance{ ObjectInstance: ObjectInstance{ InitiallyUnownedInstance: gobject.InitiallyUnownedInstance{ ObjectInstance: *base, }, }, } } func marshalDeviceProviderInstance(p unsafe.Pointer) (any, error) { return unsafeWrapDeviceProvider(gobject.ValueFromNative(p).Object()), nil } // UnsafeDeviceProviderFromGlibNone is used to convert raw GstDeviceProvider pointers to go while taking a reference and attaching a finalizer. This is used by the bindings internally. func UnsafeDeviceProviderFromGlibNone(c unsafe.Pointer) DeviceProvider { return gobject.UnsafeObjectFromGlibNone(c).(DeviceProvider) } // UnsafeDeviceProviderFromGlibFull is used to convert raw GstDeviceProvider pointers to go while attaching a finalizer. This is used by the bindings internally. func UnsafeDeviceProviderFromGlibFull(c unsafe.Pointer) DeviceProvider { return gobject.UnsafeObjectFromGlibFull(c).(DeviceProvider) } func (d *DeviceProviderInstance) upcastToGstDeviceProvider() *DeviceProviderInstance { return d } // UnsafeDeviceProviderToGlibNone is used to convert the instance to it's C value GstDeviceProvider. This is used by the bindings internally. func UnsafeDeviceProviderToGlibNone(c DeviceProvider) unsafe.Pointer { return gobject.UnsafeObjectToGlibNone(c) } // UnsafeDeviceProviderToGlibFull is used to convert the instance to it's C value GstDeviceProvider, while removeing the finalizer. This is used by the bindings internally. func UnsafeDeviceProviderToGlibFull(c DeviceProvider) unsafe.Pointer { return gobject.UnsafeObjectToGlibFull(c) } // DeviceProviderRegister wraps gst_device_provider_register // // The function takes the following parameters: // // - plugin Plugin (nullable): #GstPlugin to register the device provider with, or %NULL for // a static device provider. // - name string: name of device providers of this type // - rank uint: rank of device provider (higher rank means more importance when autoplugging) // - typ gobject.Type: GType of device provider to register // // The function returns the following values: // // - goret bool // // Create a new device providerfactory capable of instantiating objects of the // @type and add the factory to @plugin. func DeviceProviderRegister(plugin Plugin, name string, rank uint, typ gobject.Type) bool { var carg1 *C.GstPlugin // in, none, converted, nullable var carg2 *C.gchar // in, none, string var carg3 C.guint // in, none, casted var carg4 C.GType // in, none, casted, alias var cret C.gboolean // return if plugin != nil { carg1 = (*C.GstPlugin)(UnsafePluginToGlibNone(plugin)) } carg2 = (*C.gchar)(unsafe.Pointer(C.CString(name))) defer C.free(unsafe.Pointer(carg2)) carg3 = C.guint(rank) carg4 = C.GType(typ) cret = C.gst_device_provider_register(carg1, carg2, carg3, carg4) runtime.KeepAlive(plugin) runtime.KeepAlive(name) runtime.KeepAlive(rank) runtime.KeepAlive(typ) var goret bool if cret != 0 { goret = true } return goret } // CanMonitor wraps gst_device_provider_can_monitor // // The function returns the following values: // // - goret bool func (provider *DeviceProviderInstance) CanMonitor() bool { var carg0 *C.GstDeviceProvider // in, none, converted var cret C.gboolean // return carg0 = (*C.GstDeviceProvider)(UnsafeDeviceProviderToGlibNone(provider)) cret = C.gst_device_provider_can_monitor(carg0) runtime.KeepAlive(provider) var goret bool if cret != 0 { goret = true } return goret } // DeviceAdd wraps gst_device_provider_device_add // // The function takes the following parameters: // // - device Device: a #GstDevice that has been added // // Posts a message on the provider's #GstBus to inform applications that // a new device has been added. // // This is for use by subclasses. // // @device's reference count will be incremented, and any floating reference // will be removed (see gst_object_ref_sink()). func (provider *DeviceProviderInstance) DeviceAdd(device Device) { var carg0 *C.GstDeviceProvider // in, none, converted var carg1 *C.GstDevice // in, none, converted carg0 = (*C.GstDeviceProvider)(UnsafeDeviceProviderToGlibNone(provider)) carg1 = (*C.GstDevice)(UnsafeDeviceToGlibNone(device)) C.gst_device_provider_device_add(carg0, carg1) runtime.KeepAlive(provider) runtime.KeepAlive(device) } // DeviceChanged wraps gst_device_provider_device_changed // // The function takes the following parameters: // // - device Device: the new version of @changed_device // - changedDevice Device: the old version of the device that has been updated // // This function is used when @changed_device was modified into its new form // @device. This will post a `DEVICE_CHANGED` message on the bus to let // the application know that the device was modified. #GstDevice is immutable // for MT. safety purposes so this is an "atomic" way of letting the application // know when a device was modified. func (provider *DeviceProviderInstance) DeviceChanged(device Device, changedDevice Device) { var carg0 *C.GstDeviceProvider // in, none, converted var carg1 *C.GstDevice // in, none, converted var carg2 *C.GstDevice // in, none, converted carg0 = (*C.GstDeviceProvider)(UnsafeDeviceProviderToGlibNone(provider)) carg1 = (*C.GstDevice)(UnsafeDeviceToGlibNone(device)) carg2 = (*C.GstDevice)(UnsafeDeviceToGlibNone(changedDevice)) C.gst_device_provider_device_changed(carg0, carg1, carg2) runtime.KeepAlive(provider) runtime.KeepAlive(device) runtime.KeepAlive(changedDevice) } // DeviceRemove wraps gst_device_provider_device_remove // // The function takes the following parameters: // // - device Device: a #GstDevice that has been removed // // Posts a message on the provider's #GstBus to inform applications that // a device has been removed. // // This is for use by subclasses. func (provider *DeviceProviderInstance) DeviceRemove(device Device) { var carg0 *C.GstDeviceProvider // in, none, converted var carg1 *C.GstDevice // in, none, converted carg0 = (*C.GstDeviceProvider)(UnsafeDeviceProviderToGlibNone(provider)) carg1 = (*C.GstDevice)(UnsafeDeviceToGlibNone(device)) C.gst_device_provider_device_remove(carg0, carg1) runtime.KeepAlive(provider) runtime.KeepAlive(device) } // GetBus wraps gst_device_provider_get_bus // // The function returns the following values: // // - goret Bus // // Gets the #GstBus of this #GstDeviceProvider func (provider *DeviceProviderInstance) GetBus() Bus { var carg0 *C.GstDeviceProvider // in, none, converted var cret *C.GstBus // return, full, converted carg0 = (*C.GstDeviceProvider)(UnsafeDeviceProviderToGlibNone(provider)) cret = C.gst_device_provider_get_bus(carg0) runtime.KeepAlive(provider) var goret Bus goret = UnsafeBusFromGlibFull(unsafe.Pointer(cret)) return goret } // GetDevices wraps gst_device_provider_get_devices // // The function returns the following values: // // - goret []Device // // Gets a list of devices that this provider understands. This may actually // probe the hardware if the provider is not currently started. // // If the provider has been started, this will returned the same #GstDevice // objedcts that have been returned by the #GST_MESSAGE_DEVICE_ADDED messages. func (provider *DeviceProviderInstance) GetDevices() []Device { var carg0 *C.GstDeviceProvider // in, none, converted var cret *C.GList // container, transfer: full carg0 = (*C.GstDeviceProvider)(UnsafeDeviceProviderToGlibNone(provider)) cret = C.gst_device_provider_get_devices(carg0) runtime.KeepAlive(provider) var goret []Device goret = glib.UnsafeListFromGlibFull( unsafe.Pointer(cret), func(v unsafe.Pointer) Device { var dst Device // converted dst = UnsafeDeviceFromGlibFull(v) return dst }, ) return goret } // GetFactory wraps gst_device_provider_get_factory // // The function returns the following values: // // - goret DeviceProviderFactory (nullable) // // Retrieves the factory that was used to create this device provider. func (provider *DeviceProviderInstance) GetFactory() DeviceProviderFactory { var carg0 *C.GstDeviceProvider // in, none, converted var cret *C.GstDeviceProviderFactory // return, none, converted, nullable carg0 = (*C.GstDeviceProvider)(UnsafeDeviceProviderToGlibNone(provider)) cret = C.gst_device_provider_get_factory(carg0) runtime.KeepAlive(provider) var goret DeviceProviderFactory if cret != nil { goret = UnsafeDeviceProviderFactoryFromGlibNone(unsafe.Pointer(cret)) } return goret } // GetHiddenProviders wraps gst_device_provider_get_hidden_providers // // The function returns the following values: // // - goret []string // // Get the provider factory names of the #GstDeviceProvider instances that // are hidden by @provider. func (provider *DeviceProviderInstance) GetHiddenProviders() []string { var carg0 *C.GstDeviceProvider // in, none, converted var cret **C.gchar // return, transfer: full, C Pointers: 2, Name: array[utf8], scope: , array (inner: *typesystem.StringPrimitive, zero-terminated) carg0 = (*C.GstDeviceProvider)(UnsafeDeviceProviderToGlibNone(provider)) cret = C.gst_device_provider_get_hidden_providers(carg0) runtime.KeepAlive(provider) var goret []string _ = goret _ = cret panic("unimplemented conversion of []string (gchar**)") return goret } // GetMetadata wraps gst_device_provider_get_metadata // // The function takes the following parameters: // // - key string: the key to get // // The function returns the following values: // // - goret string // // Get metadata with @key in @provider. func (provider *DeviceProviderInstance) GetMetadata(key string) string { var carg0 *C.GstDeviceProvider // in, none, converted var carg1 *C.gchar // in, none, string var cret *C.gchar // return, none, string carg0 = (*C.GstDeviceProvider)(UnsafeDeviceProviderToGlibNone(provider)) carg1 = (*C.gchar)(unsafe.Pointer(C.CString(key))) defer C.free(unsafe.Pointer(carg1)) cret = C.gst_device_provider_get_metadata(carg0, carg1) runtime.KeepAlive(provider) runtime.KeepAlive(key) var goret string goret = C.GoString((*C.char)(unsafe.Pointer(cret))) return goret } // HideProvider wraps gst_device_provider_hide_provider // // The function takes the following parameters: // // - name string: a provider factory name // // Make @provider hide the devices from the factory with @name. // // This function is used when @provider will also provide the devices reported // by provider factory @name. A monitor should stop monitoring the // device provider with @name to avoid duplicate devices. func (provider *DeviceProviderInstance) HideProvider(name string) { var carg0 *C.GstDeviceProvider // in, none, converted var carg1 *C.gchar // in, none, string carg0 = (*C.GstDeviceProvider)(UnsafeDeviceProviderToGlibNone(provider)) carg1 = (*C.gchar)(unsafe.Pointer(C.CString(name))) defer C.free(unsafe.Pointer(carg1)) C.gst_device_provider_hide_provider(carg0, carg1) runtime.KeepAlive(provider) runtime.KeepAlive(name) } // IsStarted wraps gst_device_provider_is_started // // The function returns the following values: // // - goret bool // // This function can be used to know if the @provider was successfully started. func (provider *DeviceProviderInstance) IsStarted() bool { var carg0 *C.GstDeviceProvider // in, none, converted var cret C.gboolean // return carg0 = (*C.GstDeviceProvider)(UnsafeDeviceProviderToGlibNone(provider)) cret = C.gst_device_provider_is_started(carg0) runtime.KeepAlive(provider) var goret bool if cret != 0 { goret = true } return goret } // Start wraps gst_device_provider_start // // The function returns the following values: // // - goret bool // // Starts providering the devices. This will cause #GST_MESSAGE_DEVICE_ADDED // and #GST_MESSAGE_DEVICE_REMOVED messages to be posted on the provider's bus // when devices are added or removed from the system. // // Since the #GstDeviceProvider is a singleton, // gst_device_provider_start() may already have been called by another // user of the object, gst_device_provider_stop() needs to be called the same // number of times. // // After this function has been called, gst_device_provider_get_devices() will // return the same objects that have been received from the // #GST_MESSAGE_DEVICE_ADDED messages and will no longer probe. func (provider *DeviceProviderInstance) Start() bool { var carg0 *C.GstDeviceProvider // in, none, converted var cret C.gboolean // return carg0 = (*C.GstDeviceProvider)(UnsafeDeviceProviderToGlibNone(provider)) cret = C.gst_device_provider_start(carg0) runtime.KeepAlive(provider) var goret bool if cret != 0 { goret = true } return goret } // Stop wraps gst_device_provider_stop // // Decreases the use-count by one. If the use count reaches zero, this // #GstDeviceProvider will stop providering the devices. This needs to be // called the same number of times that gst_device_provider_start() was called. func (provider *DeviceProviderInstance) Stop() { var carg0 *C.GstDeviceProvider // in, none, converted carg0 = (*C.GstDeviceProvider)(UnsafeDeviceProviderToGlibNone(provider)) C.gst_device_provider_stop(carg0) runtime.KeepAlive(provider) } // UnhideProvider wraps gst_device_provider_unhide_provider // // The function takes the following parameters: // // - name string: a provider factory name // // Make @provider unhide the devices from factory @name. // // This function is used when @provider will no longer provide the devices // reported by provider factory @name. A monitor should start // monitoring the devices from provider factory @name in order to see // all devices again. func (provider *DeviceProviderInstance) UnhideProvider(name string) { var carg0 *C.GstDeviceProvider // in, none, converted var carg1 *C.gchar // in, none, string carg0 = (*C.GstDeviceProvider)(UnsafeDeviceProviderToGlibNone(provider)) carg1 = (*C.gchar)(unsafe.Pointer(C.CString(name))) defer C.free(unsafe.Pointer(carg1)) C.gst_device_provider_unhide_provider(carg0, carg1) runtime.KeepAlive(provider) runtime.KeepAlive(name) } // ConnectProviderHidden connects the provided callback to the "provider-hidden" signal 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 PluginFeatureInstance } var _ DeviceProviderFactory = (*DeviceProviderFactoryInstance)(nil) // DeviceProviderFactory wraps GstDeviceProviderFactory // // #GstDeviceProviderFactory is used to create instances of device providers. A // GstDeviceProviderfactory can be added to a #GstPlugin as it is also a // #GstPluginFeature. // // Use the gst_device_provider_factory_find() and // gst_device_provider_factory_get() functions to create device // provider instances or use gst_device_provider_factory_get_by_name() as a // convenient shortcut. type DeviceProviderFactory interface { PluginFeature upcastToGstDeviceProviderFactory() *DeviceProviderFactoryInstance // Get wraps gst_device_provider_factory_get // // The function returns the following values: // // - goret DeviceProvider (nullable) // // Returns the device provider of the type defined by the given device // providerfactory. Get() DeviceProvider // GetDeviceProviderType wraps gst_device_provider_factory_get_device_provider_type // // The function returns the following values: // // - goret gobject.Type // // Get the #GType for device providers managed by this factory. The type can // only be retrieved if the device provider factory is loaded, which can be // assured with gst_plugin_feature_load(). GetDeviceProviderType() gobject.Type // GetMetadata wraps gst_device_provider_factory_get_metadata // // The function takes the following parameters: // // - key string: a key // // The function returns the following values: // // - goret string (nullable) // // 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) // // Get the available keys for the metadata on @factory. GetMetadataKeys() []string // HasClasses wraps gst_device_provider_factory_has_classes // // The function takes the following parameters: // // - classes string (nullable): a "/" separate list of classes to match, only match // if all classes are matched // // The function returns the following values: // // - goret bool // // Check if @factory matches all of the given @classes HasClasses(string) bool // HasClassesv wraps gst_device_provider_factory_has_classesv // // The function takes the following parameters: // // - classes []string (nullable): a %NULL terminated array // of classes to match, only match if all classes are matched // // The function returns the following values: // // - goret bool // // Check if @factory matches all of the given classes HasClassesv([]string) bool } func unsafeWrapDeviceProviderFactory(base *gobject.ObjectInstance) *DeviceProviderFactoryInstance { return &DeviceProviderFactoryInstance{ PluginFeatureInstance: PluginFeatureInstance{ ObjectInstance: ObjectInstance{ InitiallyUnownedInstance: gobject.InitiallyUnownedInstance{ ObjectInstance: *base, }, }, }, } } func marshalDeviceProviderFactoryInstance(p unsafe.Pointer) (any, error) { return unsafeWrapDeviceProviderFactory(gobject.ValueFromNative(p).Object()), nil } // UnsafeDeviceProviderFactoryFromGlibNone is used to convert raw GstDeviceProviderFactory pointers to go while taking a reference and attaching a finalizer. This is used by the bindings internally. func UnsafeDeviceProviderFactoryFromGlibNone(c unsafe.Pointer) DeviceProviderFactory { return gobject.UnsafeObjectFromGlibNone(c).(DeviceProviderFactory) } // UnsafeDeviceProviderFactoryFromGlibFull is used to convert raw GstDeviceProviderFactory pointers to go while attaching a finalizer. This is used by the bindings internally. func UnsafeDeviceProviderFactoryFromGlibFull(c unsafe.Pointer) DeviceProviderFactory { return gobject.UnsafeObjectFromGlibFull(c).(DeviceProviderFactory) } func (d *DeviceProviderFactoryInstance) upcastToGstDeviceProviderFactory() *DeviceProviderFactoryInstance { return d } // UnsafeDeviceProviderFactoryToGlibNone is used to convert the instance to it's C value GstDeviceProviderFactory. This is used by the bindings internally. func UnsafeDeviceProviderFactoryToGlibNone(c DeviceProviderFactory) unsafe.Pointer { return gobject.UnsafeObjectToGlibNone(c) } // UnsafeDeviceProviderFactoryToGlibFull is used to convert the instance to it's C value GstDeviceProviderFactory, while removeing the finalizer. This is used by the bindings internally. func UnsafeDeviceProviderFactoryToGlibFull(c DeviceProviderFactory) unsafe.Pointer { return gobject.UnsafeObjectToGlibFull(c) } // DeviceProviderFactoryFind wraps gst_device_provider_factory_find // // The function takes the following parameters: // // - name string: name of factory to find // // The function returns the following values: // // - goret DeviceProviderFactory (nullable) // // Search for an device provider factory of the given name. Refs the returned // device provider factory; caller is responsible for unreffing. func DeviceProviderFactoryFind(name string) DeviceProviderFactory { var carg1 *C.gchar // in, none, string var cret *C.GstDeviceProviderFactory // return, full, converted, nullable carg1 = (*C.gchar)(unsafe.Pointer(C.CString(name))) defer C.free(unsafe.Pointer(carg1)) cret = C.gst_device_provider_factory_find(carg1) runtime.KeepAlive(name) var goret DeviceProviderFactory if cret != nil { goret = UnsafeDeviceProviderFactoryFromGlibFull(unsafe.Pointer(cret)) } return goret } // DeviceProviderFactoryGetByName wraps gst_device_provider_factory_get_by_name // // The function takes the following parameters: // // - factoryname string: a named factory to instantiate // // The function returns the following values: // // - goret DeviceProvider (nullable) // // Returns the device provider of the type defined by the given device // provider factory. func DeviceProviderFactoryGetByName(factoryname string) DeviceProvider { var carg1 *C.gchar // in, none, string var cret *C.GstDeviceProvider // return, full, converted, nullable carg1 = (*C.gchar)(unsafe.Pointer(C.CString(factoryname))) defer C.free(unsafe.Pointer(carg1)) cret = C.gst_device_provider_factory_get_by_name(carg1) runtime.KeepAlive(factoryname) var goret DeviceProvider if cret != nil { goret = UnsafeDeviceProviderFromGlibFull(unsafe.Pointer(cret)) } return goret } // DeviceProviderFactoryListGetDeviceProviders wraps gst_device_provider_factory_list_get_device_providers // // The function takes the following parameters: // // - minrank Rank: Minimum rank // // The function returns the following values: // // - goret []DeviceProviderFactory // // Get a list of factories with a rank greater or equal to @minrank. // The list of factories is returned by decreasing rank. func DeviceProviderFactoryListGetDeviceProviders(minrank Rank) []DeviceProviderFactory { var carg1 C.GstRank // in, none, casted var cret *C.GList // container, transfer: full carg1 = C.GstRank(minrank) cret = C.gst_device_provider_factory_list_get_device_providers(carg1) runtime.KeepAlive(minrank) var goret []DeviceProviderFactory goret = glib.UnsafeListFromGlibFull( unsafe.Pointer(cret), func(v unsafe.Pointer) DeviceProviderFactory { var dst DeviceProviderFactory // converted dst = UnsafeDeviceProviderFactoryFromGlibFull(v) return dst }, ) return goret } // Get wraps gst_device_provider_factory_get // // The function returns the following values: // // - goret DeviceProvider (nullable) // // Returns the device provider of the type defined by the given device // providerfactory. func (factory *DeviceProviderFactoryInstance) Get() DeviceProvider { var carg0 *C.GstDeviceProviderFactory // in, none, converted var cret *C.GstDeviceProvider // return, full, converted, nullable carg0 = (*C.GstDeviceProviderFactory)(UnsafeDeviceProviderFactoryToGlibNone(factory)) cret = C.gst_device_provider_factory_get(carg0) runtime.KeepAlive(factory) var goret DeviceProvider if cret != nil { goret = UnsafeDeviceProviderFromGlibFull(unsafe.Pointer(cret)) } return goret } // GetDeviceProviderType wraps gst_device_provider_factory_get_device_provider_type // // The function returns the following values: // // - goret gobject.Type // // Get the #GType for device providers managed by this factory. The type can // only be retrieved if the device provider factory is loaded, which can be // assured with gst_plugin_feature_load(). func (factory *DeviceProviderFactoryInstance) GetDeviceProviderType() gobject.Type { var carg0 *C.GstDeviceProviderFactory // in, none, converted var cret C.GType // return, none, casted, alias carg0 = (*C.GstDeviceProviderFactory)(UnsafeDeviceProviderFactoryToGlibNone(factory)) cret = C.gst_device_provider_factory_get_device_provider_type(carg0) runtime.KeepAlive(factory) var goret gobject.Type goret = gobject.Type(cret) return goret } // GetMetadata wraps gst_device_provider_factory_get_metadata // // The function takes the following parameters: // // - key string: a key // // The function returns the following values: // // - goret string (nullable) // // Get the metadata on @factory with @key. func (factory *DeviceProviderFactoryInstance) GetMetadata(key string) string { var carg0 *C.GstDeviceProviderFactory // in, none, converted var carg1 *C.gchar // in, none, string var cret *C.gchar // return, none, string, nullable-string carg0 = (*C.GstDeviceProviderFactory)(UnsafeDeviceProviderFactoryToGlibNone(factory)) carg1 = (*C.gchar)(unsafe.Pointer(C.CString(key))) defer C.free(unsafe.Pointer(carg1)) cret = C.gst_device_provider_factory_get_metadata(carg0, carg1) runtime.KeepAlive(factory) runtime.KeepAlive(key) var goret string if cret != nil { goret = C.GoString((*C.char)(unsafe.Pointer(cret))) } return goret } // GetMetadataKeys wraps gst_device_provider_factory_get_metadata_keys // // The function returns the following values: // // - goret []string (nullable) // // Get the available keys for the metadata on @factory. func (factory *DeviceProviderFactoryInstance) GetMetadataKeys() []string { var carg0 *C.GstDeviceProviderFactory // in, none, converted var cret **C.gchar // return, transfer: full, C Pointers: 2, Name: array[utf8], scope: , nullable, array (inner: *typesystem.StringPrimitive, zero-terminated) carg0 = (*C.GstDeviceProviderFactory)(UnsafeDeviceProviderFactoryToGlibNone(factory)) cret = C.gst_device_provider_factory_get_metadata_keys(carg0) runtime.KeepAlive(factory) var goret []string _ = goret _ = cret panic("unimplemented conversion of []string (gchar**)") return goret } // HasClasses wraps gst_device_provider_factory_has_classes // // The function takes the following parameters: // // - classes string (nullable): a "/" separate list of classes to match, only match // if all classes are matched // // The function returns the following values: // // - goret bool // // Check if @factory matches all of the given @classes func (factory *DeviceProviderFactoryInstance) HasClasses(classes string) bool { var carg0 *C.GstDeviceProviderFactory // in, none, converted var carg1 *C.gchar // in, none, string, nullable-string var cret C.gboolean // return carg0 = (*C.GstDeviceProviderFactory)(UnsafeDeviceProviderFactoryToGlibNone(factory)) if classes != "" { carg1 = (*C.gchar)(unsafe.Pointer(C.CString(classes))) defer C.free(unsafe.Pointer(carg1)) } cret = C.gst_device_provider_factory_has_classes(carg0, carg1) runtime.KeepAlive(factory) runtime.KeepAlive(classes) var goret bool if cret != 0 { goret = true } return goret } // HasClassesv wraps gst_device_provider_factory_has_classesv // // The function takes the following parameters: // // - classes []string (nullable): a %NULL terminated array // of classes to match, only match if all classes are matched // // The function returns the following values: // // - goret bool // // Check if @factory matches all of the given classes func (factory *DeviceProviderFactoryInstance) HasClassesv(classes []string) bool { var carg0 *C.GstDeviceProviderFactory // in, none, converted var carg1 **C.gchar // in, transfer: none, C Pointers: 2, Name: array[utf8], nullable, array (inner: *typesystem.StringPrimitive, zero-terminated) var cret C.gboolean // return carg0 = (*C.GstDeviceProviderFactory)(UnsafeDeviceProviderFactoryToGlibNone(factory)) _ = classes _ = carg1 panic("unimplemented conversion of []string (gchar**)") cret = C.gst_device_provider_factory_has_classesv(carg0, carg1) runtime.KeepAlive(factory) runtime.KeepAlive(classes) var goret bool if cret != 0 { goret = true } return goret } // DynamicTypeFactoryInstance is the instance type used by all types extending GstDynamicTypeFactory. It is used internally by the bindings. Users should use the interface [DynamicTypeFactory] instead. type DynamicTypeFactoryInstance struct { _ [0]func() // equal guard PluginFeatureInstance } var _ DynamicTypeFactory = (*DynamicTypeFactoryInstance)(nil) // DynamicTypeFactory wraps GstDynamicTypeFactory // // #GstDynamicTypeFactory is used to represent a type that can be // automatically loaded the first time it is used. For example, // a non-standard type for use in caps fields. // // In general, applications and plugins don't need to use the factory // beyond registering the type in a plugin init function. Once that is // done, the type is stored in the registry, and ready as soon as the // registry is loaded. // // ## Registering a type for dynamic loading // // |[<!-- language="C" --> // // static gboolean // plugin_init (GstPlugin * plugin) // { // return gst_dynamic_type_register (plugin, GST_TYPE_CUSTOM_CAPS_FIELD); // } // ]| type DynamicTypeFactory interface { PluginFeature upcastToGstDynamicTypeFactory() *DynamicTypeFactoryInstance } func unsafeWrapDynamicTypeFactory(base *gobject.ObjectInstance) *DynamicTypeFactoryInstance { return &DynamicTypeFactoryInstance{ PluginFeatureInstance: PluginFeatureInstance{ ObjectInstance: ObjectInstance{ InitiallyUnownedInstance: gobject.InitiallyUnownedInstance{ ObjectInstance: *base, }, }, }, } } func marshalDynamicTypeFactoryInstance(p unsafe.Pointer) (any, error) { return unsafeWrapDynamicTypeFactory(gobject.ValueFromNative(p).Object()), nil } // UnsafeDynamicTypeFactoryFromGlibNone is used to convert raw GstDynamicTypeFactory pointers to go while taking a reference and attaching a finalizer. This is used by the bindings internally. func UnsafeDynamicTypeFactoryFromGlibNone(c unsafe.Pointer) DynamicTypeFactory { return gobject.UnsafeObjectFromGlibNone(c).(DynamicTypeFactory) } // UnsafeDynamicTypeFactoryFromGlibFull is used to convert raw GstDynamicTypeFactory pointers to go while attaching a finalizer. This is used by the bindings internally. func UnsafeDynamicTypeFactoryFromGlibFull(c unsafe.Pointer) DynamicTypeFactory { return gobject.UnsafeObjectFromGlibFull(c).(DynamicTypeFactory) } func (d *DynamicTypeFactoryInstance) upcastToGstDynamicTypeFactory() *DynamicTypeFactoryInstance { return d } // UnsafeDynamicTypeFactoryToGlibNone is used to convert the instance to it's C value GstDynamicTypeFactory. This is used by the bindings internally. func UnsafeDynamicTypeFactoryToGlibNone(c DynamicTypeFactory) unsafe.Pointer { return gobject.UnsafeObjectToGlibNone(c) } // UnsafeDynamicTypeFactoryToGlibFull is used to convert the instance to it's C value GstDynamicTypeFactory, while removeing the finalizer. This is used by the bindings internally. func UnsafeDynamicTypeFactoryToGlibFull(c DynamicTypeFactory) unsafe.Pointer { return gobject.UnsafeObjectToGlibFull(c) } // DynamicTypeFactoryLoad wraps gst_dynamic_type_factory_load // // The function takes the following parameters: // // - factoryname string // // The function returns the following values: // // - goret gobject.Type func DynamicTypeFactoryLoad(factoryname string) gobject.Type { var carg1 *C.gchar // in, none, string var cret C.GType // return, none, casted, alias carg1 = (*C.gchar)(unsafe.Pointer(C.CString(factoryname))) defer C.free(unsafe.Pointer(carg1)) cret = C.gst_dynamic_type_factory_load(carg1) runtime.KeepAlive(factoryname) var goret gobject.Type goret = gobject.Type(cret) return goret } // ElementInstance is the instance type used by all types extending GstElement. It is used internally by the bindings. Users should use the interface [Element] instead. type ElementInstance struct { _ [0]func() // equal guard ObjectInstance } var _ Element = (*ElementInstance)(nil) // Element wraps GstElement // // GstElement is the abstract base class needed to construct an element that // can be used in a GStreamer pipeline. Please refer to the plugin writers // guide for more information on creating #GstElement subclasses. // // The name of a #GstElement can be get with gst_element_get_name() and set with // gst_element_set_name(). For speed, GST_ELEMENT_NAME() can be used in the // core when using the appropriate locking. Do not use this in plug-ins or // applications in order to retain ABI compatibility. // // Elements can have pads (of the type #GstPad). These pads link to pads on // other elements. #GstBuffer flow between these linked pads. // A #GstElement has a #GList of #GstPad structures for all their input (or sink) // and output (or source) pads. // Core and plug-in writers can add and remove pads with gst_element_add_pad() // and gst_element_remove_pad(). // // An existing pad of an element can be retrieved by name with // gst_element_get_static_pad(). A new dynamic pad can be created using // gst_element_request_pad() with a #GstPadTemplate. // An iterator of all pads can be retrieved with gst_element_iterate_pads(). // // Elements can be linked through their pads. // If the link is straightforward, use the gst_element_link() // convenience function to link two elements, or gst_element_link_many() // for more elements in a row. // Use gst_element_link_filtered() to link two elements constrained by // a specified set of #GstCaps. // For finer control, use gst_element_link_pads() and // gst_element_link_pads_filtered() to specify the pads to link on // each element by name. // // Each element has a state (see #GstState). You can get and set the state // of an element with gst_element_get_state() and gst_element_set_state(). // Setting a state triggers a #GstStateChange. To get a string representation // of a #GstState, use gst_element_state_get_name(). // // You can get and set a #GstClock on an element using gst_element_get_clock() // and gst_element_set_clock(). // Some elements can provide a clock for the pipeline if // the #GST_ELEMENT_FLAG_PROVIDE_CLOCK flag is set. With the // gst_element_provide_clock() method one can retrieve the clock provided by // such an element. // Not all elements require a clock to operate correctly. If the // #GST_ELEMENT_FLAG_REQUIRE_CLOCK() flag is set, a clock should be set on the // element with gst_element_set_clock(). // // Note that clock selection and distribution is normally handled by the // toplevel #GstPipeline so the clock functions are only to be used in very // specific situations. type Element interface { ElementExtManual // handwritten functions Object upcastToGstElement() *ElementInstance // AbortState wraps gst_element_abort_state // // Abort the state change of the element. This function is used // by elements that do asynchronous state changes and find out // something is wrong. // // This function should be called with the STATE_LOCK held. // // MT safe. AbortState() // AddPad wraps gst_element_add_pad // // The function takes the following parameters: // // - pad Pad: the #GstPad to add to the element. // // The function returns the following values: // // - goret bool // // Adds a pad (link point) to @element. @pad's parent will be set to @element; // see gst_object_set_parent() for refcounting information. // // Pads are automatically activated when added in the PAUSED or PLAYING // state. // // The pad and the element should be unlocked when calling this function. // // This function will emit the #GstElement::pad-added signal on the element. AddPad(Pad) bool // AddPropertyDeepNotifyWatch wraps gst_element_add_property_deep_notify_watch // // The function takes the following parameters: // // - propertyName string (nullable): name of property to watch for changes, or // NULL to watch all properties // - includeValue bool: whether to include the new property value in the message // // The function returns the following values: // // - goret uint32 AddPropertyDeepNotifyWatch(string, bool) uint32 // AddPropertyNotifyWatch wraps gst_element_add_property_notify_watch // // The function takes the following parameters: // // - propertyName string (nullable): name of property to watch for changes, or // NULL to watch all properties // - includeValue bool: whether to include the new property value in the message // // The function returns the following values: // // - goret uint32 AddPropertyNotifyWatch(string, bool) uint32 // CallAsync wraps gst_element_call_async // // The function takes the following parameters: // // - fn ElementCallAsyncFunc: Function to call asynchronously from another thread // // Calls @func from another thread and passes @user_data to it. This is to be // used for cases when a state change has to be performed from a streaming // thread, directly via gst_element_set_state() or indirectly e.g. via SEEK // events. // // Calling those functions directly from the streaming thread will cause // deadlocks in many situations, as they might involve waiting for the // streaming thread to shut down from this very streaming thread. // // MT safe. CallAsync(ElementCallAsyncFunc) // ChangeState wraps gst_element_change_state // // The function takes the following parameters: // // - transition StateChange: the requested transition // // The function returns the following values: // // - goret StateChangeReturn // // Perform @transition on @element. // // This function must be called with STATE_LOCK held and is mainly used // internally. ChangeState(StateChange) StateChangeReturn // ContinueState wraps gst_element_continue_state // // The function takes the following parameters: // // - ret StateChangeReturn: The previous state return value // // The function returns the following values: // // - goret StateChangeReturn // // Commit the state change of the element and proceed to the next // pending state if any. This function is used // by elements that do asynchronous state changes. // The core will normally call this method automatically when an // element returned %GST_STATE_CHANGE_SUCCESS from the state change function. // // If after calling this method the element still has not reached // the pending state, the next state change is performed. // // This method is used internally and should normally not be called by plugins // or applications. // // This function must be called with STATE_LOCK held. ContinueState(StateChangeReturn) StateChangeReturn // CreateAllPads wraps gst_element_create_all_pads // // Creates a pad for each pad template that is always available. // This function is only useful during object initialization of // subclasses of #GstElement. CreateAllPads() // DecorateStreamID wraps gst_element_decorate_stream_id // // The function takes the following parameters: // // - streamId string: The stream-id // // The function returns the following values: // // - goret string // // Creates a stream-id for @element by combining the upstream information with // the @stream_id. // // This function generates an unique stream-id by getting the upstream // stream-start event stream ID and appending @stream_id to it. If the element // has no sinkpad it will generate an upstream stream-id by doing an URI query // on the element and in the worst case just uses a random number. Source // elements that don't implement the URI handler interface should ideally // generate a unique, deterministic stream-id manually instead. // // Since stream IDs are sorted alphabetically, any numbers in the stream ID // should be printed with a fixed number of characters, preceded by 0's, such as // by using the format \%03u instead of \%u. DecorateStreamID(string) string // ForEachPad wraps gst_element_foreach_pad // // The function takes the following parameters: // // - fn ElementForEachPadFunc: function to call for each pad // // The function returns the following values: // // - goret bool // // Call @func with @user_data for each of @element's pads. @func will be called // exactly once for each pad that exists at the time of this call, unless // one of the calls to @func returns %FALSE in which case we will stop // iterating pads and return early. If new pads are added or pads are removed // while pads are being iterated, this will not be taken into account until // next time this function is used. ForEachPad(ElementForEachPadFunc) bool // ForEachSinkPad wraps gst_element_foreach_sink_pad // // The function takes the following parameters: // // - fn ElementForEachPadFunc: function to call for each sink pad // // The function returns the following values: // // - goret bool // // Call @func with @user_data for each of @element's sink pads. @func will be // called exactly once for each sink pad that exists at the time of this call, // unless one of the calls to @func returns %FALSE in which case we will stop // iterating pads and return early. If new sink pads are added or sink pads // are removed while the sink pads are being iterated, this will not be taken // into account until next time this function is used. ForEachSinkPad(ElementForEachPadFunc) bool // ForEachSrcPad wraps gst_element_foreach_src_pad // // The function takes the following parameters: // // - fn ElementForEachPadFunc: function to call for each source pad // // The function returns the following values: // // - goret bool // // Call @func with @user_data for each of @element's source pads. @func will be // called exactly once for each source pad that exists at the time of this call, // unless one of the calls to @func returns %FALSE in which case we will stop // iterating pads and return early. If new source pads are added or source pads // are removed while the source pads are being iterated, this will not be taken // 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 // // Returns the base time of the element. The base time is the // absolute time of the clock when this element was last put to // PLAYING. Subtracting the base time from the clock time gives // the running time of the element. GetBaseTime() ClockTime // GetBus wraps gst_element_get_bus // // The function returns the following values: // // - goret Bus (nullable) // // Returns the bus of the element. Note that only a #GstPipeline will provide a // bus for the application. GetBus() Bus // GetClock wraps gst_element_get_clock // // The function returns the following values: // // - goret Clock (nullable) // // Gets the currently configured clock of the element. This is the clock as was // last set with gst_element_set_clock(). // // Elements in a pipeline will only have their clock set when the // pipeline is in the PLAYING state. GetClock() Clock // GetCompatiblePad wraps gst_element_get_compatible_pad // // The function takes the following parameters: // // - pad Pad: the #GstPad to find a compatible one for. // - caps *Caps (nullable): the #GstCaps to use as a filter. // // The function returns the following values: // // - goret Pad (nullable) // // Looks for an unlinked pad to which the given pad can link. It is not // guaranteed that linking the pads will work, though it should work in most // cases. // // This function will first attempt to find a compatible unlinked ALWAYS pad, // and if none can be found, it will request a compatible REQUEST pad by looking // at the templates of @element. GetCompatiblePad(Pad, *Caps) Pad // GetCompatiblePadTemplate wraps gst_element_get_compatible_pad_template // // The function takes the following parameters: // // - compattempl PadTemplate: the #GstPadTemplate to find a compatible // template for // // The function returns the following values: // // - goret PadTemplate (nullable) // // Retrieves a pad template from @element that is compatible with @compattempl. // Pads from compatible templates can be linked together. GetCompatiblePadTemplate(PadTemplate) PadTemplate // GetContext wraps gst_element_get_context // // The function takes the following parameters: // // - contextType string: a name of a context to retrieve // // The function returns the following values: // // - goret *Context (nullable) // // Gets the context with @context_type set on the element or NULL. // // MT safe. GetContext(string) *Context // GetContextUnlocked wraps gst_element_get_context_unlocked // // The function takes the following parameters: // // - contextType string: a name of a context to retrieve // // The function returns the following values: // // - goret *Context (nullable) // // 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 // // Gets the contexts set on the element. // // MT safe. GetContexts() []*Context // GetCurrentClockTime wraps gst_element_get_current_clock_time // // The function returns the following values: // // - goret ClockTime // // Returns the current clock time of the element, as in, the time of the // 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 // // Returns the running time of the element. The running time is the // element's clock time minus its base time. Will return GST_CLOCK_TIME_NONE // 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) // // Retrieves the factory that was used to create this element. GetFactory() ElementFactory // GetMetadata wraps gst_element_get_metadata // // The function takes the following parameters: // // - key string: the key to get // // The function returns the following values: // // - goret string // // Get metadata with @key in @klass. GetMetadata(string) string // GetPadTemplate wraps gst_element_get_pad_template // // The function takes the following parameters: // // - name string: the name of the #GstPadTemplate to get. // // The function returns the following values: // // - goret PadTemplate (nullable) // // 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 // // Retrieves a list of the pad templates associated with @element. The // list must not be modified by the calling code. GetPadTemplateList() []PadTemplate // GetRequestPad wraps gst_element_get_request_pad // // The function takes the following parameters: // // - name string: the name of the request #GstPad to retrieve. // // The function returns the following values: // // - goret Pad (nullable) // // The name of this function is confusing to people learning GStreamer. // gst_element_request_pad_simple() aims at making it more explicit it is // a simplified gst_element_request_pad(). // // Deprecated: (since 1.20.0) Prefer using gst_element_request_pad_simple() which // provides the exact same functionality. GetRequestPad(string) Pad // GetStartTime wraps gst_element_get_start_time // // The function returns the following values: // // - goret ClockTime // // Returns the start time of the element. The start time is the // running time of the clock when this element was last put to PAUSED. // // Usually the start_time is managed by a toplevel element such as // #GstPipeline. // // MT safe. GetStartTime() ClockTime // GetState wraps gst_element_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 // // Gets the state of the element. // // For elements that performed an ASYNC state change, as reported by // gst_element_set_state(), this function will block up to the // specified timeout value for the state change to complete. // If the element completes the state change or goes into // an error, this function returns immediately with a return value of // %GST_STATE_CHANGE_SUCCESS or %GST_STATE_CHANGE_FAILURE respectively. // // For elements that did not return %GST_STATE_CHANGE_ASYNC, this function // returns the current and pending state immediately. // // This function returns %GST_STATE_CHANGE_NO_PREROLL if the element // successfully changed its state but is not able to provide data yet. // This mostly happens for live sources that only produce data in // %GST_STATE_PLAYING. While the state change return is equivalent to // %GST_STATE_CHANGE_SUCCESS, it is returned to the application to signal that // some sink elements might not be able to complete their state change because // an element is not producing data to complete the preroll. When setting the // element to playing, the preroll will complete and playback will start. GetState(ClockTime) (State, State, StateChangeReturn) // GetStaticPad wraps gst_element_get_static_pad // // The function takes the following parameters: // // - name string: the name of the static #GstPad to retrieve. // // The function returns the following values: // // - goret Pad (nullable) // // Retrieves a pad from @element by name. This version only retrieves // already-existing (i.e. 'static') pads. GetStaticPad(string) Pad // IsLockedState wraps gst_element_is_locked_state // // The function returns the following values: // // - goret bool // // Checks if the state of an element is locked. // If the state of an element is locked, state changes of the parent don't // affect the element. // This way you can leave currently unused elements inside bins. Just lock their // state before changing the state from #GST_STATE_NULL. // // MT safe. IsLockedState() bool // IteratePads wraps gst_element_iterate_pads // // The function returns the following values: // // - goret *Iterator // // Retrieves an iterator of @element's pads. The iterator should // be freed after usage. Also more specialized iterators exists such as // gst_element_iterate_src_pads() or gst_element_iterate_sink_pads(). // // The order of pads returned by the iterator will be the order in which // the pads were added to the element. IteratePads() *Iterator // IterateSinkPads wraps gst_element_iterate_sink_pads // // The function returns the following values: // // - goret *Iterator // // Retrieves an iterator of @element's sink pads. // // The order of pads returned by the iterator will be the order in which // the pads were added to the element. IterateSinkPads() *Iterator // IterateSrcPads wraps gst_element_iterate_src_pads // // The function returns the following values: // // - goret *Iterator // // Retrieves an iterator of @element's source pads. // // The order of pads returned by the iterator will be the order in which // the pads were added to the element. IterateSrcPads() *Iterator // Link wraps gst_element_link // // The function takes the following parameters: // // - dest Element: the #GstElement containing the destination pad. // // The function returns the following values: // // - goret bool // // Links @src to @dest. The link must be from source to // destination; the other direction will not be tried. The function looks for // existing pads that aren't linked yet. It will request new pads if necessary. // Such pads need to be released manually when unlinking. // If multiple links are possible, only one is established. // // Make sure you have added your elements to a bin or pipeline with // gst_bin_add() before trying to link them. Link(Element) bool // LinkFiltered wraps gst_element_link_filtered // // The function takes the following parameters: // // - dest Element: the #GstElement containing the destination pad. // - filter *Caps (nullable): the #GstCaps to filter the link, // or %NULL for no filter. // // The function returns the following values: // // - goret bool // // Links @src to @dest using the given caps as filtercaps. // The link must be from source to // destination; the other direction will not be tried. The function looks for // existing pads that aren't linked yet. It will request new pads if necessary. // If multiple links are possible, only one is established. // // Make sure you have added your elements to a bin or pipeline with // gst_bin_add() before trying to link them. LinkFiltered(Element, *Caps) bool // LinkPads wraps gst_element_link_pads // // The function takes the following parameters: // // - srcpadname string (nullable): the name of the #GstPad in source element // or %NULL for any pad. // - dest Element: the #GstElement containing the destination pad. // - destpadname string (nullable): the name of the #GstPad in destination element, // or %NULL for any pad. // // The function returns the following values: // // - goret bool // // Links the two named pads of the source and destination elements. // Side effect is that if one of the pads has no parent, it becomes a // child of the parent of the other element. If they have different // parents, the link fails. LinkPads(string, Element, string) bool // LinkPadsFiltered wraps gst_element_link_pads_filtered // // The function takes the following parameters: // // - srcpadname string (nullable): the name of the #GstPad in source element // or %NULL for any pad. // - dest Element: the #GstElement containing the destination pad. // - destpadname string (nullable): the name of the #GstPad in destination element // or %NULL for any pad. // - filter *Caps (nullable): the #GstCaps to filter the link, // or %NULL for no filter. // // The function returns the following values: // // - goret bool // // Links the two named pads of the source and destination elements. Side effect // is that if one of the pads has no parent, it becomes a child of the parent of // the other element. If they have different parents, the link fails. If @caps // is not %NULL, makes sure that the caps of the link is a subset of @caps. LinkPadsFiltered(string, Element, string, *Caps) bool // LinkPadsFull wraps gst_element_link_pads_full // // The function takes the following parameters: // // - srcpadname string (nullable): the name of the #GstPad in source element // or %NULL for any pad. // - dest Element: the #GstElement containing the destination pad. // - destpadname string (nullable): the name of the #GstPad in destination element, // or %NULL for any pad. // - flags PadLinkCheck: the #GstPadLinkCheck to be performed when linking pads. // // The function returns the following values: // // - goret bool // // Links the two named pads of the source and destination elements. // Side effect is that if one of the pads has no parent, it becomes a // child of the parent of the other element. If they have different // parents, the link fails. // // Calling gst_element_link_pads_full() with @flags == %GST_PAD_LINK_CHECK_DEFAULT // is the same as calling gst_element_link_pads() and the recommended way of // linking pads with safety checks applied. // // This is a convenience function for gst_pad_link_full(). LinkPadsFull(string, Element, string, PadLinkCheck) bool // LostState wraps gst_element_lost_state // // Brings the element to the lost state. The current state of the // element is copied to the pending state so that any call to // gst_element_get_state() will return %GST_STATE_CHANGE_ASYNC. // // An ASYNC_START message is posted. If the element was PLAYING, it will // go to PAUSED. The element will be restored to its PLAYING state by // the parent pipeline when it prerolls again. // // This is mostly used for elements that lost their preroll buffer // in the %GST_STATE_PAUSED or %GST_STATE_PLAYING state after a flush, // they will go to their pending state again when a new preroll buffer is // queued. This function can only be called when the element is currently // not in error or an async state change. // // This function is used internally and should normally not be called from // plugins or applications. LostState() // MessageFull wraps gst_element_message_full // // The function takes the following parameters: // // - typ MessageType: the #GstMessageType // - domain glib.Quark: the GStreamer GError domain this message belongs to // - code int: the GError code belonging to the domain // - text string (nullable): an allocated text string to be used // as a replacement for the default message connected to code, // or %NULL // - debug string (nullable): an allocated debug message to be // used as a replacement for the default debugging information, // or %NULL // - file string: the source code file where the error was generated // - function string: the source code function where the error was generated // - line int: the source code line where the error was generated // // Post an error, warning or info message on the bus from inside an element. // // @type must be of #GST_MESSAGE_ERROR, #GST_MESSAGE_WARNING or // #GST_MESSAGE_INFO. // // MT safe. MessageFull(MessageType, glib.Quark, int, string, string, string, string, int) // MessageFullWithDetails wraps gst_element_message_full_with_details // // The function takes the following parameters: // // - typ MessageType: the #GstMessageType // - domain glib.Quark: the GStreamer GError domain this message belongs to // - code int: the GError code belonging to the domain // - text string (nullable): an allocated text string to be used // as a replacement for the default message connected to code, // or %NULL // - debug string (nullable): an allocated debug message to be // used as a replacement for the default debugging information, // or %NULL // - file string: the source code file where the error was generated // - function string: the source code function where the error was generated // - line int: the source code line where the error was generated // - structure *Structure: optional details structure // // Post an error, warning or info message on the bus from inside an element. // // @type must be of #GST_MESSAGE_ERROR, #GST_MESSAGE_WARNING or // #GST_MESSAGE_INFO. MessageFullWithDetails(MessageType, glib.Quark, int, string, string, string, string, int, *Structure) // NoMorePads wraps gst_element_no_more_pads // // Use this function to signal that the element does not expect any more pads // to show up in the current pipeline. This function should be called whenever // pads have been added by the element itself. Elements with #GST_PAD_SOMETIMES // pad templates use this in combination with autopluggers to figure out that // the element is done initializing its pads. // // This function emits the #GstElement::no-more-pads signal. // // MT safe. NoMorePads() // PostMessage wraps gst_element_post_message // // The function takes the following parameters: // // - message *Message: a #GstMessage to post // // The function returns the following values: // // - goret bool // // Post a message on the element's #GstBus. This function takes ownership of the // message; if you want to access the message after this call, you should add an // additional reference before calling. PostMessage(*Message) bool // ProvidedClock wraps gst_element_provide_clock // // The function returns the following values: // // - goret Clock (nullable) // // Get the clock provided by the given element. // > An element is only required to provide a clock in the PAUSED // > state. Some elements can provide a clock in other states. ProvidedClock() Clock // Query wraps gst_element_query // // The function takes the following parameters: // // - query *Query: the #GstQuery. // // The function returns the following values: // // - goret bool // // Performs a query on the given element. // // For elements that don't implement a query handler, this function // forwards the query to a random srcpad or to the peer of a // random linked sinkpad of this element. // // Please note that some queries might need a running pipeline to work. Query(*Query) bool // QueryConvert wraps gst_element_query_convert // // The function takes the following parameters: // // - srcFormat Format: a #GstFormat to convert from. // - srcVal int64: a value to convert. // - destFormat Format: the #GstFormat to convert to. // // The function returns the following values: // // - destVal int64: a pointer to the result. // - goret bool // // Queries an element to convert @src_val in @src_format to @dest_format. QueryConvert(Format, int64, Format) (int64, bool) // QueryDuration wraps gst_element_query_duration // // The function takes the following parameters: // // - format Format: the #GstFormat requested // // The function returns the following values: // // - duration int64: A location in which to store the total duration, or %NULL. // - goret bool // // Queries an element (usually top-level pipeline or playbin element) for the // total stream duration in nanoseconds. This query will only work once the // pipeline is prerolled (i.e. reached PAUSED or PLAYING state). The application // will receive an ASYNC_DONE message on the pipeline bus when that is the case. // // If the duration changes for some reason, you will get a DURATION_CHANGED // message on the pipeline bus, in which case you should re-query the duration // using this function. QueryDuration(Format) (int64, bool) // QueryPosition wraps gst_element_query_position // // The function takes the following parameters: // // - format Format: the #GstFormat requested // // The function returns the following values: // // - cur int64: a location in which to store the current // position, or %NULL. // - goret bool // // Queries an element (usually top-level pipeline or playbin element) for the // stream position in nanoseconds. This will be a value between 0 and the // stream duration (if the stream duration is known). This query will usually // only work once the pipeline is prerolled (i.e. reached PAUSED or PLAYING // state). The application will receive an ASYNC_DONE message on the pipeline // bus when that is the case. // // If one repeatedly calls this function one can also create a query and reuse // it in gst_element_query(). QueryPosition(Format) (int64, bool) // ReleaseRequestPad wraps gst_element_release_request_pad // // The function takes the following parameters: // // - pad Pad: the #GstPad to release. // // Makes the element free the previously requested pad as obtained // with gst_element_request_pad(). // // This does not unref the pad. If the pad was created by using // gst_element_request_pad(), gst_element_release_request_pad() needs to be // followed by gst_object_unref() to free the @pad. // // MT safe. ReleaseRequestPad(Pad) // RemovePad wraps gst_element_remove_pad // // The function takes the following parameters: // // - pad Pad: the #GstPad to remove from the element. // // The function returns the following values: // // - goret bool // // Removes @pad from @element. @pad will be destroyed if it has not been // referenced elsewhere using gst_object_unparent(). // // This function is used by plugin developers and should not be used // by applications. Pads that were dynamically requested from elements // with gst_element_request_pad() should be released with the // gst_element_release_request_pad() function instead. // // Pads are not automatically deactivated so elements should perform the needed // steps to deactivate the pad in case this pad is removed in the PAUSED or // PLAYING state. See gst_pad_set_active() for more information about // deactivating pads. // // The pad and the element should be unlocked when calling this function. // // This function will emit the #GstElement::pad-removed signal on the element. RemovePad(Pad) bool // RemovePropertyNotifyWatch wraps gst_element_remove_property_notify_watch // // The function takes the following parameters: // // - watchId uint32: watch id to remove RemovePropertyNotifyWatch(uint32) // RequestPad wraps gst_element_request_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) // // Retrieves a request pad from the element according to the provided template. // Pad templates can be looked up using // gst_element_factory_get_static_pad_templates(). // // The pad should be released with gst_element_release_request_pad(). RequestPad(PadTemplate, string, *Caps) Pad // RequestPadSimple wraps gst_element_request_pad_simple // // The function takes the following parameters: // // - name string: the name of the request #GstPad to retrieve. // // The function returns the following values: // // - goret Pad (nullable) // // Retrieves a pad from the element by name (e.g. "src_\%d"). This version only // retrieves request pads. The pad should be released with // gst_element_release_request_pad(). // // This method is slower than manually getting the pad template and calling // gst_element_request_pad() if the pads should have a specific name (e.g. // @name is "src_1" instead of "src_\%u"). // // Note that this function was introduced in GStreamer 1.20 in order to provide // a better name to gst_element_get_request_pad(). Prior to 1.20, users // should use gst_element_get_request_pad() which provides the same // functionality. RequestPadSimple(string) Pad // Seek wraps gst_element_seek // // The function takes the following parameters: // // - rate float64: The new playback rate // - format Format: The format of the seek values // - flags SeekFlags: The optional seek flags. // - startType SeekType: The type and flags for the new start position // - start int64: The value of the new start position // - stopType SeekType: The type and flags for the new stop position // - stop int64: The value of the new stop position // // The function returns the following values: // // - goret bool // // Sends a seek event to an element. See gst_event_new_seek() for the details of // the parameters. The seek event is sent to the element using // gst_element_send_event(). // // MT safe. Seek(float64, Format, SeekFlags, SeekType, int64, SeekType, int64) bool // SeekSimple wraps gst_element_seek_simple // // The function takes the following parameters: // // - format Format: a #GstFormat to execute the seek in, such as #GST_FORMAT_TIME // - seekFlags SeekFlags: seek options; playback applications will usually want to use // GST_SEEK_FLAG_FLUSH | GST_SEEK_FLAG_KEY_UNIT here // - seekPos int64: position to seek to (relative to the start); if you are doing // a seek in #GST_FORMAT_TIME this value is in nanoseconds - // multiply with #GST_SECOND to convert seconds to nanoseconds or // with #GST_MSECOND to convert milliseconds to nanoseconds. // // The function returns the following values: // // - goret bool // // Simple API to perform a seek on the given element, meaning it just seeks // to the given position relative to the start of the stream. For more complex // operations like segment seeks (e.g. for looping) or changing the playback // rate or seeking relative to the last configured playback segment you should // use gst_element_seek(). // // In a completely prerolled PAUSED or PLAYING pipeline, seeking is always // guaranteed to return %TRUE on a seekable media type or %FALSE when the media // type is certainly not seekable (such as a live stream). // // Some elements allow for seeking in the READY state, in this // case they will store the seek event and execute it when they are put to // PAUSED. If the element supports seek in READY, it will always return %TRUE when // it receives the event in the READY state. SeekSimple(Format, SeekFlags, int64) bool // SendEvent wraps gst_element_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 // // Sends an event to an element. If the element doesn't implement an // event handler, the event will be pushed on a random linked sink pad for // downstream events or a random linked source pad for upstream events. // // This function takes ownership of the provided event so you should // gst_event_ref() it if you want to reuse the event after this call. // // MT safe. SendEvent(*Event) bool // SetBaseTime wraps gst_element_set_base_time // // The function takes the following parameters: // // - time ClockTime: the base time to set. // // Set the base time of an element. See gst_element_get_base_time(). // // MT safe. SetBaseTime(ClockTime) // SetBus wraps gst_element_set_bus // // The function takes the following parameters: // // - bus Bus (nullable): the #GstBus to set. // // Sets the bus of the element. Increases the refcount on the bus. // For internal use only, unless you're testing elements. // // MT safe. SetBus(Bus) // SetClock wraps gst_element_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 // // Sets the clock for the element. This function increases the // refcount on the clock. Any previously set clock on the object // is unreffed. SetClock(Clock) bool // SetContext wraps gst_element_set_context // // The function takes the following parameters: // // - _context *Context: the #GstContext to set. // // Sets the context of the element. Increases the refcount of the context. // // MT safe. SetContext(*Context) // SetLockedState wraps gst_element_set_locked_state // // The function takes the following parameters: // // - lockedState bool: %TRUE to lock the element's state // // The function returns the following values: // // - goret bool // // Locks the state of an element, so state changes of the parent don't affect // this element anymore. // // Note that this is racy if the state lock of the parent bin is not taken. // The parent bin might've just checked the flag in another thread and as the // next step proceed to change the child element's state. // // MT safe. SetLockedState(bool) bool // SetStartTime wraps gst_element_set_start_time // // The function takes the following parameters: // // - time ClockTime: the base time to set. // // Set the start time of an element. The start time of the element is the // running time of the element when it last went to the PAUSED state. In READY // or after a flushing seek, it is set to 0. // // Toplevel elements like #GstPipeline will manage the start_time and // base_time on its children. Setting the start_time to #GST_CLOCK_TIME_NONE // on such a toplevel element will disable the distribution of the base_time to // the children and can be useful if the application manages the base_time // itself, for example if you want to synchronize capture from multiple // pipelines, and you can also ensure that the pipelines have the same clock. // // MT safe. SetStartTime(ClockTime) // SetState wraps gst_element_set_state // // The function takes the following parameters: // // - state State: the element's new #GstState. // // The function returns the following values: // // - goret StateChangeReturn // // Sets the state of the element. This function will try to set the // requested state by going through all the intermediary states and calling // the class's state change function for each. // // This function can return #GST_STATE_CHANGE_ASYNC, in which case the // element will perform the remainder of the state change asynchronously in // another thread. // An application can use gst_element_get_state() to wait for the completion // of the state change or it can wait for a %GST_MESSAGE_ASYNC_DONE or // %GST_MESSAGE_STATE_CHANGED on the bus. // // State changes to %GST_STATE_READY or %GST_STATE_NULL never return // #GST_STATE_CHANGE_ASYNC. SetState(State) StateChangeReturn // SyncStateWithParent wraps gst_element_sync_state_with_parent // // The function returns the following values: // // - goret bool // // Tries to change the state of the element to the same as its parent. // If this function returns %FALSE, the state of element is undefined. SyncStateWithParent() bool // Unlink wraps gst_element_unlink // // The function takes the following parameters: // // - dest Element: the sink #GstElement to unlink. // // Unlinks all source pads of the source element with all sink pads // of the sink element to which they are linked. // // If the link has been made using gst_element_link(), it could have created an // requestpad, which has to be released using gst_element_release_request_pad(). Unlink(Element) // UnlinkPads wraps gst_element_unlink_pads // // The function takes the following parameters: // // - srcpadname string: the name of the #GstPad in source element. // - dest Element: a #GstElement containing the destination pad. // - destpadname string: the name of the #GstPad in destination element. // // Unlinks the two named pads of the source and destination elements. // // This is a convenience function for gst_pad_unlink(). UnlinkPads(string, Element, string) // ConnectNoMorePads connects the provided callback to the "no-more-pads" signal // // This signals that the element will not generate more dynamic pads. // Note that this signal will usually be emitted from the context of // the streaming thread. ConnectNoMorePads(func(Element)) gobject.SignalHandle // ConnectPadAdded connects the provided callback to the "pad-added" signal // // a new #GstPad has been added to the element. Note that this signal will // usually be emitted from the context of the streaming thread. Also keep in // mind that if you add new elements to the pipeline in the signal handler // you will need to set them to the desired target state with // gst_element_set_state() or gst_element_sync_state_with_parent(). ConnectPadAdded(func(Element, Pad)) gobject.SignalHandle // ConnectPadRemoved connects the provided callback to the "pad-removed" signal // // a #GstPad has been removed from the element ConnectPadRemoved(func(Element, Pad)) gobject.SignalHandle } func unsafeWrapElement(base *gobject.ObjectInstance) *ElementInstance { return &ElementInstance{ ObjectInstance: ObjectInstance{ InitiallyUnownedInstance: gobject.InitiallyUnownedInstance{ ObjectInstance: *base, }, }, } } func marshalElementInstance(p unsafe.Pointer) (any, error) { return unsafeWrapElement(gobject.ValueFromNative(p).Object()), nil } // UnsafeElementFromGlibNone is used to convert raw GstElement pointers to go while taking a reference and attaching a finalizer. This is used by the bindings internally. func UnsafeElementFromGlibNone(c unsafe.Pointer) Element { return gobject.UnsafeObjectFromGlibNone(c).(Element) } // UnsafeElementFromGlibFull is used to convert raw GstElement pointers to go while attaching a finalizer. This is used by the bindings internally. func UnsafeElementFromGlibFull(c unsafe.Pointer) Element { return gobject.UnsafeObjectFromGlibFull(c).(Element) } func (e *ElementInstance) upcastToGstElement() *ElementInstance { return e } // UnsafeElementToGlibNone is used to convert the instance to it's C value GstElement. This is used by the bindings internally. func UnsafeElementToGlibNone(c Element) unsafe.Pointer { return gobject.UnsafeObjectToGlibNone(c) } // UnsafeElementToGlibFull is used to convert the instance to it's C value GstElement, while removeing the finalizer. This is used by the bindings internally. func UnsafeElementToGlibFull(c Element) unsafe.Pointer { return gobject.UnsafeObjectToGlibFull(c) } // ElementMakeFromURI wraps gst_element_make_from_uri // // The function takes the following parameters: // // - typ URIType: Whether to create a source or a sink // - uri string: URI to create an element for // - elementname string (nullable): Name of created element, can be %NULL. // // The function returns the following values: // // - goret Element // - _goerr error (nullable): an error // // Creates an element for handling the given URI. func ElementMakeFromURI(typ URIType, uri string, elementname string) (Element, error) { var carg1 C.GstURIType // in, none, casted var carg2 *C.gchar // in, none, string var carg3 *C.gchar // in, none, string, nullable-string var cret *C.GstElement // return, none, converted var _cerr *C.GError // out, full, converted, nullable carg1 = C.GstURIType(typ) carg2 = (*C.gchar)(unsafe.Pointer(C.CString(uri))) defer C.free(unsafe.Pointer(carg2)) if elementname != "" { carg3 = (*C.gchar)(unsafe.Pointer(C.CString(elementname))) defer C.free(unsafe.Pointer(carg3)) } cret = C.gst_element_make_from_uri(carg1, carg2, carg3, &_cerr) runtime.KeepAlive(typ) runtime.KeepAlive(uri) runtime.KeepAlive(elementname) var goret Element var _goerr error goret = UnsafeElementFromGlibNone(unsafe.Pointer(cret)) if _cerr != nil { _goerr = glib.UnsafeErrorFromGlibFull(unsafe.Pointer(_cerr)) } return goret, _goerr } // ElementRegister wraps gst_element_register // // The function takes the following parameters: // // - plugin Plugin (nullable): #GstPlugin to register the element with, or %NULL for // a static element. // - name string: name of elements of this type // - rank uint: rank of element (higher rank means more importance when autoplugging) // - typ gobject.Type: GType of element to register // // The function returns the following values: // // - goret bool // // Create a new elementfactory capable of instantiating objects of the // @type and add the factory to @plugin. func ElementRegister(plugin Plugin, name string, rank uint, typ gobject.Type) bool { var carg1 *C.GstPlugin // in, none, converted, nullable var carg2 *C.gchar // in, none, string var carg3 C.guint // in, none, casted var carg4 C.GType // in, none, casted, alias var cret C.gboolean // return if plugin != nil { carg1 = (*C.GstPlugin)(UnsafePluginToGlibNone(plugin)) } carg2 = (*C.gchar)(unsafe.Pointer(C.CString(name))) defer C.free(unsafe.Pointer(carg2)) carg3 = C.guint(rank) carg4 = C.GType(typ) cret = C.gst_element_register(carg1, carg2, carg3, carg4) runtime.KeepAlive(plugin) runtime.KeepAlive(name) runtime.KeepAlive(rank) runtime.KeepAlive(typ) var goret bool if cret != 0 { goret = true } return goret } // ElementStateChangeReturnGetName wraps gst_element_state_change_return_get_name // // The function takes the following parameters: // // - stateRet StateChangeReturn: a #GstStateChangeReturn to get the name of. // // The function returns the following values: // // - goret string // // Gets a string representing the given state change result. func ElementStateChangeReturnGetName(stateRet StateChangeReturn) string { var carg1 C.GstStateChangeReturn // in, none, casted var cret *C.gchar // return, none, string carg1 = C.GstStateChangeReturn(stateRet) cret = C.gst_element_state_change_return_get_name(carg1) runtime.KeepAlive(stateRet) var goret string goret = C.GoString((*C.char)(unsafe.Pointer(cret))) return goret } // ElementStateGetName wraps gst_element_state_get_name // // The function takes the following parameters: // // - state State: a #GstState to get the name of. // // The function returns the following values: // // - goret string // // Gets a string representing the given state. func ElementStateGetName(state State) string { var carg1 C.GstState // in, none, casted var cret *C.gchar // return, none, string carg1 = C.GstState(state) cret = C.gst_element_state_get_name(carg1) runtime.KeepAlive(state) var goret string goret = C.GoString((*C.char)(unsafe.Pointer(cret))) return goret } // ElementTypeSetSkipDocumentation wraps gst_element_type_set_skip_documentation // // The function takes the following parameters: // // - typ gobject.Type: a #GType of element // // Marks @type as "documentation should be skipped". // Can be useful for dynamically registered element to be excluded from // plugin documentation system. // // Example: // ```c // GType my_type; // GTypeInfo my_type_info; // // // Fill "my_type_info" // ... // // my_type = g_type_register_static (GST_TYPE_MY_ELEMENT, "my-type-name", // &my_type_info, 0); // gst_element_type_set_skip_documentation (my_type); // gst_element_register (plugin, "my-plugin-feature-name", rank, my_type); // ``` func ElementTypeSetSkipDocumentation(typ gobject.Type) { var carg1 C.GType // in, none, casted, alias carg1 = C.GType(typ) C.gst_element_type_set_skip_documentation(carg1) runtime.KeepAlive(typ) } // AbortState wraps gst_element_abort_state // // Abort the state change of the element. This function is used // by elements that do asynchronous state changes and find out // something is wrong. // // This function should be called with the STATE_LOCK held. // // MT safe. func (element *ElementInstance) AbortState() { var carg0 *C.GstElement // in, none, converted carg0 = (*C.GstElement)(UnsafeElementToGlibNone(element)) C.gst_element_abort_state(carg0) runtime.KeepAlive(element) } // AddPad wraps gst_element_add_pad // // The function takes the following parameters: // // - pad Pad: the #GstPad to add to the element. // // The function returns the following values: // // - goret bool // // Adds a pad (link point) to @element. @pad's parent will be set to @element; // see gst_object_set_parent() for refcounting information. // // Pads are automatically activated when added in the PAUSED or PLAYING // state. // // The pad and the element should be unlocked when calling this function. // // This function will emit the #GstElement::pad-added signal on the element. func (element *ElementInstance) AddPad(pad Pad) bool { var carg0 *C.GstElement // in, none, converted var carg1 *C.GstPad // in, none, converted var cret C.gboolean // return carg0 = (*C.GstElement)(UnsafeElementToGlibNone(element)) carg1 = (*C.GstPad)(UnsafePadToGlibNone(pad)) cret = C.gst_element_add_pad(carg0, carg1) runtime.KeepAlive(element) runtime.KeepAlive(pad) var goret bool if cret != 0 { goret = true } return goret } // AddPropertyDeepNotifyWatch wraps gst_element_add_property_deep_notify_watch // // The function takes the following parameters: // // - propertyName string (nullable): name of property to watch for changes, or // NULL to watch all properties // - includeValue bool: whether to include the new property value in the message // // The function returns the following values: // // - goret uint32 func (element *ElementInstance) AddPropertyDeepNotifyWatch(propertyName string, includeValue bool) uint32 { var carg0 *C.GstElement // in, none, converted var carg1 *C.gchar // in, none, string, nullable-string var carg2 C.gboolean // in var cret C.gulong // return, none, casted carg0 = (*C.GstElement)(UnsafeElementToGlibNone(element)) if propertyName != "" { carg1 = (*C.gchar)(unsafe.Pointer(C.CString(propertyName))) defer C.free(unsafe.Pointer(carg1)) } if includeValue { carg2 = C.TRUE } cret = C.gst_element_add_property_deep_notify_watch(carg0, carg1, carg2) runtime.KeepAlive(element) runtime.KeepAlive(propertyName) runtime.KeepAlive(includeValue) var goret uint32 goret = uint32(cret) return goret } // AddPropertyNotifyWatch wraps gst_element_add_property_notify_watch // // The function takes the following parameters: // // - propertyName string (nullable): name of property to watch for changes, or // NULL to watch all properties // - includeValue bool: whether to include the new property value in the message // // The function returns the following values: // // - goret uint32 func (element *ElementInstance) AddPropertyNotifyWatch(propertyName string, includeValue bool) uint32 { var carg0 *C.GstElement // in, none, converted var carg1 *C.gchar // in, none, string, nullable-string var carg2 C.gboolean // in var cret C.gulong // return, none, casted carg0 = (*C.GstElement)(UnsafeElementToGlibNone(element)) if propertyName != "" { carg1 = (*C.gchar)(unsafe.Pointer(C.CString(propertyName))) defer C.free(unsafe.Pointer(carg1)) } if includeValue { carg2 = C.TRUE } cret = C.gst_element_add_property_notify_watch(carg0, carg1, carg2) runtime.KeepAlive(element) runtime.KeepAlive(propertyName) runtime.KeepAlive(includeValue) var goret uint32 goret = uint32(cret) return goret } // CallAsync wraps gst_element_call_async // // The function takes the following parameters: // // - fn ElementCallAsyncFunc: Function to call asynchronously from another thread // // Calls @func from another thread and passes @user_data to it. This is to be // used for cases when a state change has to be performed from a streaming // thread, directly via gst_element_set_state() or indirectly e.g. via SEEK // events. // // Calling those functions directly from the streaming thread will cause // deadlocks in many situations, as they might involve waiting for the // streaming thread to shut down from this very streaming thread. // // MT safe. func (element *ElementInstance) CallAsync(fn ElementCallAsyncFunc) { var carg0 *C.GstElement // in, none, converted var carg1 C.GstElementCallAsyncFunc // callback, scope: notified, closure: carg2, destroy: carg3 var carg2 C.gpointer // implicit var carg3 C.GDestroyNotify // implicit carg0 = (*C.GstElement)(UnsafeElementToGlibNone(element)) carg1 = (*[0]byte)(C._gotk4_gst1_ElementCallAsyncFunc) carg2 = C.gpointer(userdata.Register(fn)) carg3 = (C.GDestroyNotify)((*[0]byte)(C.destroyUserdata)) C.gst_element_call_async(carg0, carg1, carg2, carg3) runtime.KeepAlive(element) runtime.KeepAlive(fn) } // ChangeState wraps gst_element_change_state // // The function takes the following parameters: // // - transition StateChange: the requested transition // // The function returns the following values: // // - goret StateChangeReturn // // Perform @transition on @element. // // This function must be called with STATE_LOCK held and is mainly used // internally. func (element *ElementInstance) ChangeState(transition StateChange) StateChangeReturn { var carg0 *C.GstElement // in, none, converted var carg1 C.GstStateChange // in, none, casted var cret C.GstStateChangeReturn // return, none, casted carg0 = (*C.GstElement)(UnsafeElementToGlibNone(element)) carg1 = C.GstStateChange(transition) cret = C.gst_element_change_state(carg0, carg1) runtime.KeepAlive(element) runtime.KeepAlive(transition) var goret StateChangeReturn goret = StateChangeReturn(cret) return goret } // ContinueState wraps gst_element_continue_state // // The function takes the following parameters: // // - ret StateChangeReturn: The previous state return value // // The function returns the following values: // // - goret StateChangeReturn // // Commit the state change of the element and proceed to the next // pending state if any. This function is used // by elements that do asynchronous state changes. // The core will normally call this method automatically when an // element returned %GST_STATE_CHANGE_SUCCESS from the state change function. // // If after calling this method the element still has not reached // the pending state, the next state change is performed. // // This method is used internally and should normally not be called by plugins // or applications. // // This function must be called with STATE_LOCK held. func (element *ElementInstance) ContinueState(ret StateChangeReturn) StateChangeReturn { var carg0 *C.GstElement // in, none, converted var carg1 C.GstStateChangeReturn // in, none, casted var cret C.GstStateChangeReturn // return, none, casted carg0 = (*C.GstElement)(UnsafeElementToGlibNone(element)) carg1 = C.GstStateChangeReturn(ret) cret = C.gst_element_continue_state(carg0, carg1) runtime.KeepAlive(element) runtime.KeepAlive(ret) var goret StateChangeReturn goret = StateChangeReturn(cret) return goret } // CreateAllPads wraps gst_element_create_all_pads // // Creates a pad for each pad template that is always available. // This function is only useful during object initialization of // subclasses of #GstElement. func (element *ElementInstance) CreateAllPads() { var carg0 *C.GstElement // in, none, converted carg0 = (*C.GstElement)(UnsafeElementToGlibNone(element)) C.gst_element_create_all_pads(carg0) runtime.KeepAlive(element) } // DecorateStreamID wraps gst_element_decorate_stream_id // // The function takes the following parameters: // // - streamId string: The stream-id // // The function returns the following values: // // - goret string // // Creates a stream-id for @element by combining the upstream information with // the @stream_id. // // This function generates an unique stream-id by getting the upstream // stream-start event stream ID and appending @stream_id to it. If the element // has no sinkpad it will generate an upstream stream-id by doing an URI query // on the element and in the worst case just uses a random number. Source // elements that don't implement the URI handler interface should ideally // generate a unique, deterministic stream-id manually instead. // // Since stream IDs are sorted alphabetically, any numbers in the stream ID // should be printed with a fixed number of characters, preceded by 0's, such as // by using the format \%03u instead of \%u. func (element *ElementInstance) DecorateStreamID(streamId string) string { var carg0 *C.GstElement // in, none, converted var carg1 *C.gchar // in, none, string var cret *C.gchar // return, full, string carg0 = (*C.GstElement)(UnsafeElementToGlibNone(element)) carg1 = (*C.gchar)(unsafe.Pointer(C.CString(streamId))) defer C.free(unsafe.Pointer(carg1)) cret = C.gst_element_decorate_stream_id(carg0, carg1) runtime.KeepAlive(element) runtime.KeepAlive(streamId) var goret string goret = C.GoString((*C.char)(unsafe.Pointer(cret))) defer C.free(unsafe.Pointer(cret)) return goret } // ForEachPad wraps gst_element_foreach_pad // // The function takes the following parameters: // // - fn ElementForEachPadFunc: function to call for each pad // // The function returns the following values: // // - goret bool // // Call @func with @user_data for each of @element's pads. @func will be called // exactly once for each pad that exists at the time of this call, unless // one of the calls to @func returns %FALSE in which case we will stop // iterating pads and return early. If new pads are added or pads are removed // while pads are being iterated, this will not be taken into account until // next time this function is used. func (element *ElementInstance) ForEachPad(fn ElementForEachPadFunc) bool { var carg0 *C.GstElement // in, none, converted var carg1 C.GstElementForeachPadFunc // callback, scope: call, closure: carg2 var carg2 C.gpointer // implicit var cret C.gboolean // return carg0 = (*C.GstElement)(UnsafeElementToGlibNone(element)) carg1 = (*[0]byte)(C._gotk4_gst1_ElementForEachPadFunc) carg2 = C.gpointer(userdata.Register(fn)) defer userdata.Delete(unsafe.Pointer(carg2)) cret = C.gst_element_foreach_pad(carg0, carg1, carg2) runtime.KeepAlive(element) runtime.KeepAlive(fn) var goret bool if cret != 0 { goret = true } return goret } // ForEachSinkPad wraps gst_element_foreach_sink_pad // // The function takes the following parameters: // // - fn ElementForEachPadFunc: function to call for each sink pad // // The function returns the following values: // // - goret bool // // Call @func with @user_data for each of @element's sink pads. @func will be // called exactly once for each sink pad that exists at the time of this call, // unless one of the calls to @func returns %FALSE in which case we will stop // iterating pads and return early. If new sink pads are added or sink pads // are removed while the sink pads are being iterated, this will not be taken // into account until next time this function is used. func (element *ElementInstance) ForEachSinkPad(fn ElementForEachPadFunc) bool { var carg0 *C.GstElement // in, none, converted var carg1 C.GstElementForeachPadFunc // callback, scope: call, closure: carg2 var carg2 C.gpointer // implicit var cret C.gboolean // return carg0 = (*C.GstElement)(UnsafeElementToGlibNone(element)) carg1 = (*[0]byte)(C._gotk4_gst1_ElementForEachPadFunc) carg2 = C.gpointer(userdata.Register(fn)) defer userdata.Delete(unsafe.Pointer(carg2)) cret = C.gst_element_foreach_sink_pad(carg0, carg1, carg2) runtime.KeepAlive(element) runtime.KeepAlive(fn) var goret bool if cret != 0 { goret = true } return goret } // ForEachSrcPad wraps gst_element_foreach_src_pad // // The function takes the following parameters: // // - fn ElementForEachPadFunc: function to call for each source pad // // The function returns the following values: // // - goret bool // // Call @func with @user_data for each of @element's source pads. @func will be // called exactly once for each source pad that exists at the time of this call, // unless one of the calls to @func returns %FALSE in which case we will stop // iterating pads and return early. If new source pads are added or source pads // are removed while the source pads are being iterated, this will not be taken // into account until next time this function is used. func (element *ElementInstance) ForEachSrcPad(fn ElementForEachPadFunc) bool { var carg0 *C.GstElement // in, none, converted var carg1 C.GstElementForeachPadFunc // callback, scope: call, closure: carg2 var carg2 C.gpointer // implicit var cret C.gboolean // return carg0 = (*C.GstElement)(UnsafeElementToGlibNone(element)) carg1 = (*[0]byte)(C._gotk4_gst1_ElementForEachPadFunc) carg2 = C.gpointer(userdata.Register(fn)) defer userdata.Delete(unsafe.Pointer(carg2)) cret = C.gst_element_foreach_src_pad(carg0, carg1, carg2) runtime.KeepAlive(element) runtime.KeepAlive(fn) var goret bool if cret != 0 { goret = true } return goret } // GetBaseTime wraps gst_element_get_base_time // // The function returns the following values: // // - goret ClockTime // // Returns the base time of the element. The base time is the // absolute time of the clock when this element was last put to // PLAYING. Subtracting the base time from the clock time gives // the running time of the element. func (element *ElementInstance) GetBaseTime() ClockTime { var carg0 *C.GstElement // in, none, converted var cret C.GstClockTime // return, none, casted, alias carg0 = (*C.GstElement)(UnsafeElementToGlibNone(element)) cret = C.gst_element_get_base_time(carg0) runtime.KeepAlive(element) var goret ClockTime goret = ClockTime(cret) return goret } // GetBus wraps gst_element_get_bus // // The function returns the following values: // // - goret Bus (nullable) // // Returns the bus of the element. Note that only a #GstPipeline will provide a // bus for the application. func (element *ElementInstance) GetBus() Bus { var carg0 *C.GstElement // in, none, converted var cret *C.GstBus // return, full, converted, nullable carg0 = (*C.GstElement)(UnsafeElementToGlibNone(element)) cret = C.gst_element_get_bus(carg0) runtime.KeepAlive(element) var goret Bus if cret != nil { goret = UnsafeBusFromGlibFull(unsafe.Pointer(cret)) } return goret } // GetClock wraps gst_element_get_clock // // The function returns the following values: // // - goret Clock (nullable) // // Gets the currently configured clock of the element. This is the clock as was // last set with gst_element_set_clock(). // // Elements in a pipeline will only have their clock set when the // pipeline is in the PLAYING state. func (element *ElementInstance) GetClock() Clock { var carg0 *C.GstElement // in, none, converted var cret *C.GstClock // return, full, converted, nullable carg0 = (*C.GstElement)(UnsafeElementToGlibNone(element)) cret = C.gst_element_get_clock(carg0) runtime.KeepAlive(element) var goret Clock if cret != nil { goret = UnsafeClockFromGlibFull(unsafe.Pointer(cret)) } return goret } // GetCompatiblePad wraps gst_element_get_compatible_pad // // The function takes the following parameters: // // - pad Pad: the #GstPad to find a compatible one for. // - caps *Caps (nullable): the #GstCaps to use as a filter. // // The function returns the following values: // // - goret Pad (nullable) // // Looks for an unlinked pad to which the given pad can link. It is not // guaranteed that linking the pads will work, though it should work in most // cases. // // This function will first attempt to find a compatible unlinked ALWAYS pad, // and if none can be found, it will request a compatible REQUEST pad by looking // at the templates of @element. func (element *ElementInstance) GetCompatiblePad(pad Pad, caps *Caps) Pad { var carg0 *C.GstElement // in, none, converted var carg1 *C.GstPad // in, none, converted var carg2 *C.GstCaps // in, none, converted, nullable var cret *C.GstPad // return, full, converted, nullable carg0 = (*C.GstElement)(UnsafeElementToGlibNone(element)) carg1 = (*C.GstPad)(UnsafePadToGlibNone(pad)) if caps != nil { carg2 = (*C.GstCaps)(UnsafeCapsToGlibNone(caps)) } cret = C.gst_element_get_compatible_pad(carg0, carg1, carg2) runtime.KeepAlive(element) runtime.KeepAlive(pad) runtime.KeepAlive(caps) var goret Pad if cret != nil { goret = UnsafePadFromGlibFull(unsafe.Pointer(cret)) } return goret } // GetCompatiblePadTemplate wraps gst_element_get_compatible_pad_template // // The function takes the following parameters: // // - compattempl PadTemplate: the #GstPadTemplate to find a compatible // template for // // The function returns the following values: // // - goret PadTemplate (nullable) // // Retrieves a pad template from @element that is compatible with @compattempl. // Pads from compatible templates can be linked together. func (element *ElementInstance) GetCompatiblePadTemplate(compattempl PadTemplate) PadTemplate { var carg0 *C.GstElement // in, none, converted var carg1 *C.GstPadTemplate // in, none, converted var cret *C.GstPadTemplate // return, none, converted, nullable carg0 = (*C.GstElement)(UnsafeElementToGlibNone(element)) carg1 = (*C.GstPadTemplate)(UnsafePadTemplateToGlibNone(compattempl)) cret = C.gst_element_get_compatible_pad_template(carg0, carg1) runtime.KeepAlive(element) runtime.KeepAlive(compattempl) var goret PadTemplate if cret != nil { goret = UnsafePadTemplateFromGlibNone(unsafe.Pointer(cret)) } return goret } // GetContext wraps gst_element_get_context // // The function takes the following parameters: // // - contextType string: a name of a context to retrieve // // The function returns the following values: // // - goret *Context (nullable) // // Gets the context with @context_type set on the element or NULL. // // MT safe. func (element *ElementInstance) GetContext(contextType string) *Context { var carg0 *C.GstElement // in, none, converted var carg1 *C.gchar // in, none, string var cret *C.GstContext // return, full, converted, nullable carg0 = (*C.GstElement)(UnsafeElementToGlibNone(element)) carg1 = (*C.gchar)(unsafe.Pointer(C.CString(contextType))) defer C.free(unsafe.Pointer(carg1)) cret = C.gst_element_get_context(carg0, carg1) runtime.KeepAlive(element) runtime.KeepAlive(contextType) var goret *Context if cret != nil { goret = UnsafeContextFromGlibFull(unsafe.Pointer(cret)) } return goret } // GetContextUnlocked wraps gst_element_get_context_unlocked // // The function takes the following parameters: // // - contextType string: a name of a context to retrieve // // The function returns the following values: // // - goret *Context (nullable) // // Gets the context with @context_type set on the element or NULL. func (element *ElementInstance) GetContextUnlocked(contextType string) *Context { var carg0 *C.GstElement // in, none, converted var carg1 *C.gchar // in, none, string var cret *C.GstContext // return, full, converted, nullable carg0 = (*C.GstElement)(UnsafeElementToGlibNone(element)) carg1 = (*C.gchar)(unsafe.Pointer(C.CString(contextType))) defer C.free(unsafe.Pointer(carg1)) cret = C.gst_element_get_context_unlocked(carg0, carg1) runtime.KeepAlive(element) runtime.KeepAlive(contextType) var goret *Context if cret != nil { goret = UnsafeContextFromGlibFull(unsafe.Pointer(cret)) } return goret } // GetContexts wraps gst_element_get_contexts // // The function returns the following values: // // - goret []*Context // // Gets the contexts set on the element. // // MT safe. func (element *ElementInstance) GetContexts() []*Context { var carg0 *C.GstElement // in, none, converted var cret *C.GList // container, transfer: full carg0 = (*C.GstElement)(UnsafeElementToGlibNone(element)) cret = C.gst_element_get_contexts(carg0) runtime.KeepAlive(element) var goret []*Context goret = glib.UnsafeListFromGlibFull( unsafe.Pointer(cret), func(v unsafe.Pointer) *Context { var dst *Context // converted dst = UnsafeContextFromGlibFull(v) return dst }, ) return goret } // GetCurrentClockTime wraps gst_element_get_current_clock_time // // The function returns the following values: // // - goret ClockTime // // Returns the current clock time of the element, as in, the time of the // element's clock, or GST_CLOCK_TIME_NONE if there is no clock. func (element *ElementInstance) GetCurrentClockTime() ClockTime { var carg0 *C.GstElement // in, none, converted var cret C.GstClockTime // return, none, casted, alias carg0 = (*C.GstElement)(UnsafeElementToGlibNone(element)) cret = C.gst_element_get_current_clock_time(carg0) runtime.KeepAlive(element) var goret ClockTime goret = ClockTime(cret) return goret } // GetCurrentRunningTime wraps gst_element_get_current_running_time // // The function returns the following values: // // - goret ClockTime // // Returns the running time of the element. The running time is the // element's clock time minus its base time. Will return GST_CLOCK_TIME_NONE // if the element has no clock, or if its base time has not been set. func (element *ElementInstance) GetCurrentRunningTime() ClockTime { var carg0 *C.GstElement // in, none, converted var cret C.GstClockTime // return, none, casted, alias carg0 = (*C.GstElement)(UnsafeElementToGlibNone(element)) cret = C.gst_element_get_current_running_time(carg0) runtime.KeepAlive(element) var goret ClockTime goret = ClockTime(cret) return goret } // GetFactory wraps gst_element_get_factory // // The function returns the following values: // // - goret ElementFactory (nullable) // // Retrieves the factory that was used to create this element. func (element *ElementInstance) GetFactory() ElementFactory { var carg0 *C.GstElement // in, none, converted var cret *C.GstElementFactory // return, none, converted, nullable carg0 = (*C.GstElement)(UnsafeElementToGlibNone(element)) cret = C.gst_element_get_factory(carg0) runtime.KeepAlive(element) var goret ElementFactory if cret != nil { goret = UnsafeElementFactoryFromGlibNone(unsafe.Pointer(cret)) } return goret } // GetMetadata wraps gst_element_get_metadata // // The function takes the following parameters: // // - key string: the key to get // // The function returns the following values: // // - goret string // // Get metadata with @key in @klass. func (element *ElementInstance) GetMetadata(key string) string { var carg0 *C.GstElement // in, none, converted var carg1 *C.gchar // in, none, string var cret *C.gchar // return, none, string carg0 = (*C.GstElement)(UnsafeElementToGlibNone(element)) carg1 = (*C.gchar)(unsafe.Pointer(C.CString(key))) defer C.free(unsafe.Pointer(carg1)) cret = C.gst_element_get_metadata(carg0, carg1) runtime.KeepAlive(element) runtime.KeepAlive(key) var goret string goret = C.GoString((*C.char)(unsafe.Pointer(cret))) return goret } // GetPadTemplate wraps gst_element_get_pad_template // // The function takes the following parameters: // // - name string: the name of the #GstPadTemplate to get. // // The function returns the following values: // // - goret PadTemplate (nullable) // // Retrieves a padtemplate from @element with the given name. func (element *ElementInstance) GetPadTemplate(name string) PadTemplate { var carg0 *C.GstElement // in, none, converted var carg1 *C.gchar // in, none, string var cret *C.GstPadTemplate // return, none, converted, nullable carg0 = (*C.GstElement)(UnsafeElementToGlibNone(element)) carg1 = (*C.gchar)(unsafe.Pointer(C.CString(name))) defer C.free(unsafe.Pointer(carg1)) cret = C.gst_element_get_pad_template(carg0, carg1) runtime.KeepAlive(element) runtime.KeepAlive(name) var goret PadTemplate if cret != nil { goret = UnsafePadTemplateFromGlibNone(unsafe.Pointer(cret)) } return goret } // GetPadTemplateList wraps gst_element_get_pad_template_list // // The function returns the following values: // // - goret []PadTemplate // // Retrieves a list of the pad templates associated with @element. The // list must not be modified by the calling code. func (element *ElementInstance) GetPadTemplateList() []PadTemplate { var carg0 *C.GstElement // in, none, converted var cret *C.GList // container, transfer: none carg0 = (*C.GstElement)(UnsafeElementToGlibNone(element)) cret = C.gst_element_get_pad_template_list(carg0) runtime.KeepAlive(element) var goret []PadTemplate goret = glib.UnsafeListFromGlibNone( unsafe.Pointer(cret), func(v unsafe.Pointer) PadTemplate { var dst PadTemplate // converted dst = UnsafePadTemplateFromGlibNone(v) return dst }, ) return goret } // GetRequestPad wraps gst_element_get_request_pad // // The function takes the following parameters: // // - name string: the name of the request #GstPad to retrieve. // // The function returns the following values: // // - goret Pad (nullable) // // The name of this function is confusing to people learning GStreamer. // gst_element_request_pad_simple() aims at making it more explicit it is // a simplified gst_element_request_pad(). // // Deprecated: (since 1.20.0) Prefer using gst_element_request_pad_simple() which // provides the exact same functionality. func (element *ElementInstance) GetRequestPad(name string) Pad { var carg0 *C.GstElement // in, none, converted var carg1 *C.gchar // in, none, string var cret *C.GstPad // return, full, converted, nullable carg0 = (*C.GstElement)(UnsafeElementToGlibNone(element)) carg1 = (*C.gchar)(unsafe.Pointer(C.CString(name))) defer C.free(unsafe.Pointer(carg1)) cret = C.gst_element_get_request_pad(carg0, carg1) runtime.KeepAlive(element) runtime.KeepAlive(name) var goret Pad if cret != nil { goret = UnsafePadFromGlibFull(unsafe.Pointer(cret)) } return goret } // GetStartTime wraps gst_element_get_start_time // // The function returns the following values: // // - goret ClockTime // // Returns the start time of the element. The start time is the // running time of the clock when this element was last put to PAUSED. // // Usually the start_time is managed by a toplevel element such as // #GstPipeline. // // MT safe. func (element *ElementInstance) GetStartTime() ClockTime { var carg0 *C.GstElement // in, none, converted var cret C.GstClockTime // return, none, casted, alias carg0 = (*C.GstElement)(UnsafeElementToGlibNone(element)) cret = C.gst_element_get_start_time(carg0) runtime.KeepAlive(element) var goret ClockTime goret = ClockTime(cret) return goret } // GetState wraps gst_element_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 // // Gets the state of the element. // // For elements that performed an ASYNC state change, as reported by // gst_element_set_state(), this function will block up to the // specified timeout value for the state change to complete. // If the element completes the state change or goes into // an error, this function returns immediately with a return value of // %GST_STATE_CHANGE_SUCCESS or %GST_STATE_CHANGE_FAILURE respectively. // // For elements that did not return %GST_STATE_CHANGE_ASYNC, this function // returns the current and pending state immediately. // // This function returns %GST_STATE_CHANGE_NO_PREROLL if the element // successfully changed its state but is not able to provide data yet. // This mostly happens for live sources that only produce data in // %GST_STATE_PLAYING. While the state change return is equivalent to // %GST_STATE_CHANGE_SUCCESS, it is returned to the application to signal that // some sink elements might not be able to complete their state change because // an element is not producing data to complete the preroll. When setting the // element to playing, the preroll will complete and playback will start. func (element *ElementInstance) GetState(timeout ClockTime) (State, State, StateChangeReturn) { var carg0 *C.GstElement // in, none, converted var carg3 C.GstClockTime // in, none, casted, alias var carg1 C.GstState // out, full, casted var carg2 C.GstState // out, full, casted var cret C.GstStateChangeReturn // return, none, casted carg0 = (*C.GstElement)(UnsafeElementToGlibNone(element)) carg3 = C.GstClockTime(timeout) cret = C.gst_element_get_state(carg0, &carg1, &carg2, carg3) runtime.KeepAlive(element) runtime.KeepAlive(timeout) var state State var pending State var goret StateChangeReturn state = State(carg1) pending = State(carg2) goret = StateChangeReturn(cret) return state, pending, goret } // GetStaticPad wraps gst_element_get_static_pad // // The function takes the following parameters: // // - name string: the name of the static #GstPad to retrieve. // // The function returns the following values: // // - goret Pad (nullable) // // Retrieves a pad from @element by name. This version only retrieves // already-existing (i.e. 'static') pads. func (element *ElementInstance) GetStaticPad(name string) Pad { var carg0 *C.GstElement // in, none, converted var carg1 *C.gchar // in, none, string var cret *C.GstPad // return, full, converted, nullable carg0 = (*C.GstElement)(UnsafeElementToGlibNone(element)) carg1 = (*C.gchar)(unsafe.Pointer(C.CString(name))) defer C.free(unsafe.Pointer(carg1)) cret = C.gst_element_get_static_pad(carg0, carg1) runtime.KeepAlive(element) runtime.KeepAlive(name) var goret Pad if cret != nil { goret = UnsafePadFromGlibFull(unsafe.Pointer(cret)) } return goret } // IsLockedState wraps gst_element_is_locked_state // // The function returns the following values: // // - goret bool // // Checks if the state of an element is locked. // If the state of an element is locked, state changes of the parent don't // affect the element. // This way you can leave currently unused elements inside bins. Just lock their // state before changing the state from #GST_STATE_NULL. // // MT safe. func (element *ElementInstance) IsLockedState() bool { var carg0 *C.GstElement // in, none, converted var cret C.gboolean // return carg0 = (*C.GstElement)(UnsafeElementToGlibNone(element)) cret = C.gst_element_is_locked_state(carg0) runtime.KeepAlive(element) var goret bool if cret != 0 { goret = true } return goret } // IteratePads wraps gst_element_iterate_pads // // The function returns the following values: // // - goret *Iterator // // Retrieves an iterator of @element's pads. The iterator should // be freed after usage. Also more specialized iterators exists such as // gst_element_iterate_src_pads() or gst_element_iterate_sink_pads(). // // The order of pads returned by the iterator will be the order in which // the pads were added to the element. func (element *ElementInstance) IteratePads() *Iterator { var carg0 *C.GstElement // in, none, converted var cret *C.GstIterator // return, full, converted carg0 = (*C.GstElement)(UnsafeElementToGlibNone(element)) cret = C.gst_element_iterate_pads(carg0) runtime.KeepAlive(element) var goret *Iterator goret = UnsafeIteratorFromGlibFull(unsafe.Pointer(cret)) return goret } // IterateSinkPads wraps gst_element_iterate_sink_pads // // The function returns the following values: // // - goret *Iterator // // Retrieves an iterator of @element's sink pads. // // The order of pads returned by the iterator will be the order in which // the pads were added to the element. func (element *ElementInstance) IterateSinkPads() *Iterator { var carg0 *C.GstElement // in, none, converted var cret *C.GstIterator // return, full, converted carg0 = (*C.GstElement)(UnsafeElementToGlibNone(element)) cret = C.gst_element_iterate_sink_pads(carg0) runtime.KeepAlive(element) var goret *Iterator goret = UnsafeIteratorFromGlibFull(unsafe.Pointer(cret)) return goret } // IterateSrcPads wraps gst_element_iterate_src_pads // // The function returns the following values: // // - goret *Iterator // // Retrieves an iterator of @element's source pads. // // The order of pads returned by the iterator will be the order in which // the pads were added to the element. func (element *ElementInstance) IterateSrcPads() *Iterator { var carg0 *C.GstElement // in, none, converted var cret *C.GstIterator // return, full, converted carg0 = (*C.GstElement)(UnsafeElementToGlibNone(element)) cret = C.gst_element_iterate_src_pads(carg0) runtime.KeepAlive(element) var goret *Iterator goret = UnsafeIteratorFromGlibFull(unsafe.Pointer(cret)) return goret } // Link wraps gst_element_link // // The function takes the following parameters: // // - dest Element: the #GstElement containing the destination pad. // // The function returns the following values: // // - goret bool // // Links @src to @dest. The link must be from source to // destination; the other direction will not be tried. The function looks for // existing pads that aren't linked yet. It will request new pads if necessary. // Such pads need to be released manually when unlinking. // If multiple links are possible, only one is established. // // Make sure you have added your elements to a bin or pipeline with // gst_bin_add() before trying to link them. func (src *ElementInstance) Link(dest Element) bool { var carg0 *C.GstElement // in, none, converted var carg1 *C.GstElement // in, none, converted var cret C.gboolean // return carg0 = (*C.GstElement)(UnsafeElementToGlibNone(src)) carg1 = (*C.GstElement)(UnsafeElementToGlibNone(dest)) cret = C.gst_element_link(carg0, carg1) runtime.KeepAlive(src) runtime.KeepAlive(dest) var goret bool if cret != 0 { goret = true } return goret } // LinkFiltered wraps gst_element_link_filtered // // The function takes the following parameters: // // - dest Element: the #GstElement containing the destination pad. // - filter *Caps (nullable): the #GstCaps to filter the link, // or %NULL for no filter. // // The function returns the following values: // // - goret bool // // Links @src to @dest using the given caps as filtercaps. // The link must be from source to // destination; the other direction will not be tried. The function looks for // existing pads that aren't linked yet. It will request new pads if necessary. // If multiple links are possible, only one is established. // // Make sure you have added your elements to a bin or pipeline with // gst_bin_add() before trying to link them. func (src *ElementInstance) LinkFiltered(dest Element, filter *Caps) bool { var carg0 *C.GstElement // in, none, converted var carg1 *C.GstElement // in, none, converted var carg2 *C.GstCaps // in, none, converted, nullable var cret C.gboolean // return carg0 = (*C.GstElement)(UnsafeElementToGlibNone(src)) carg1 = (*C.GstElement)(UnsafeElementToGlibNone(dest)) if filter != nil { carg2 = (*C.GstCaps)(UnsafeCapsToGlibNone(filter)) } cret = C.gst_element_link_filtered(carg0, carg1, carg2) runtime.KeepAlive(src) runtime.KeepAlive(dest) runtime.KeepAlive(filter) var goret bool if cret != 0 { goret = true } return goret } // LinkPads wraps gst_element_link_pads // // The function takes the following parameters: // // - srcpadname string (nullable): the name of the #GstPad in source element // or %NULL for any pad. // - dest Element: the #GstElement containing the destination pad. // - destpadname string (nullable): the name of the #GstPad in destination element, // or %NULL for any pad. // // The function returns the following values: // // - goret bool // // Links the two named pads of the source and destination elements. // Side effect is that if one of the pads has no parent, it becomes a // child of the parent of the other element. If they have different // parents, the link fails. func (src *ElementInstance) LinkPads(srcpadname string, dest Element, destpadname string) bool { var carg0 *C.GstElement // in, none, converted var carg1 *C.gchar // in, none, string, nullable-string var carg2 *C.GstElement // in, none, converted var carg3 *C.gchar // in, none, string, nullable-string var cret C.gboolean // return carg0 = (*C.GstElement)(UnsafeElementToGlibNone(src)) if srcpadname != "" { carg1 = (*C.gchar)(unsafe.Pointer(C.CString(srcpadname))) defer C.free(unsafe.Pointer(carg1)) } carg2 = (*C.GstElement)(UnsafeElementToGlibNone(dest)) if destpadname != "" { carg3 = (*C.gchar)(unsafe.Pointer(C.CString(destpadname))) defer C.free(unsafe.Pointer(carg3)) } cret = C.gst_element_link_pads(carg0, carg1, carg2, carg3) runtime.KeepAlive(src) runtime.KeepAlive(srcpadname) runtime.KeepAlive(dest) runtime.KeepAlive(destpadname) var goret bool if cret != 0 { goret = true } return goret } // LinkPadsFiltered wraps gst_element_link_pads_filtered // // The function takes the following parameters: // // - srcpadname string (nullable): the name of the #GstPad in source element // or %NULL for any pad. // - dest Element: the #GstElement containing the destination pad. // - destpadname string (nullable): the name of the #GstPad in destination element // or %NULL for any pad. // - filter *Caps (nullable): the #GstCaps to filter the link, // or %NULL for no filter. // // The function returns the following values: // // - goret bool // // Links the two named pads of the source and destination elements. Side effect // is that if one of the pads has no parent, it becomes a child of the parent of // the other element. If they have different parents, the link fails. If @caps // is not %NULL, makes sure that the caps of the link is a subset of @caps. func (src *ElementInstance) LinkPadsFiltered(srcpadname string, dest Element, destpadname string, filter *Caps) bool { var carg0 *C.GstElement // in, none, converted var carg1 *C.gchar // in, none, string, nullable-string var carg2 *C.GstElement // in, none, converted var carg3 *C.gchar // in, none, string, nullable-string var carg4 *C.GstCaps // in, none, converted, nullable var cret C.gboolean // return carg0 = (*C.GstElement)(UnsafeElementToGlibNone(src)) if srcpadname != "" { carg1 = (*C.gchar)(unsafe.Pointer(C.CString(srcpadname))) defer C.free(unsafe.Pointer(carg1)) } carg2 = (*C.GstElement)(UnsafeElementToGlibNone(dest)) if destpadname != "" { carg3 = (*C.gchar)(unsafe.Pointer(C.CString(destpadname))) defer C.free(unsafe.Pointer(carg3)) } if filter != nil { carg4 = (*C.GstCaps)(UnsafeCapsToGlibNone(filter)) } cret = C.gst_element_link_pads_filtered(carg0, carg1, carg2, carg3, carg4) runtime.KeepAlive(src) runtime.KeepAlive(srcpadname) runtime.KeepAlive(dest) runtime.KeepAlive(destpadname) runtime.KeepAlive(filter) var goret bool if cret != 0 { goret = true } return goret } // LinkPadsFull wraps gst_element_link_pads_full // // The function takes the following parameters: // // - srcpadname string (nullable): the name of the #GstPad in source element // or %NULL for any pad. // - dest Element: the #GstElement containing the destination pad. // - destpadname string (nullable): the name of the #GstPad in destination element, // or %NULL for any pad. // - flags PadLinkCheck: the #GstPadLinkCheck to be performed when linking pads. // // The function returns the following values: // // - goret bool // // Links the two named pads of the source and destination elements. // Side effect is that if one of the pads has no parent, it becomes a // child of the parent of the other element. If they have different // parents, the link fails. // // Calling gst_element_link_pads_full() with @flags == %GST_PAD_LINK_CHECK_DEFAULT // is the same as calling gst_element_link_pads() and the recommended way of // linking pads with safety checks applied. // // This is a convenience function for gst_pad_link_full(). func (src *ElementInstance) LinkPadsFull(srcpadname string, dest Element, destpadname string, flags PadLinkCheck) bool { var carg0 *C.GstElement // in, none, converted var carg1 *C.gchar // in, none, string, nullable-string var carg2 *C.GstElement // in, none, converted var carg3 *C.gchar // in, none, string, nullable-string var carg4 C.GstPadLinkCheck // in, none, casted var cret C.gboolean // return carg0 = (*C.GstElement)(UnsafeElementToGlibNone(src)) if srcpadname != "" { carg1 = (*C.gchar)(unsafe.Pointer(C.CString(srcpadname))) defer C.free(unsafe.Pointer(carg1)) } carg2 = (*C.GstElement)(UnsafeElementToGlibNone(dest)) if destpadname != "" { carg3 = (*C.gchar)(unsafe.Pointer(C.CString(destpadname))) defer C.free(unsafe.Pointer(carg3)) } carg4 = C.GstPadLinkCheck(flags) cret = C.gst_element_link_pads_full(carg0, carg1, carg2, carg3, carg4) runtime.KeepAlive(src) runtime.KeepAlive(srcpadname) runtime.KeepAlive(dest) runtime.KeepAlive(destpadname) runtime.KeepAlive(flags) var goret bool if cret != 0 { goret = true } return goret } // LostState wraps gst_element_lost_state // // Brings the element to the lost state. The current state of the // element is copied to the pending state so that any call to // gst_element_get_state() will return %GST_STATE_CHANGE_ASYNC. // // An ASYNC_START message is posted. If the element was PLAYING, it will // go to PAUSED. The element will be restored to its PLAYING state by // the parent pipeline when it prerolls again. // // This is mostly used for elements that lost their preroll buffer // in the %GST_STATE_PAUSED or %GST_STATE_PLAYING state after a flush, // they will go to their pending state again when a new preroll buffer is // queued. This function can only be called when the element is currently // not in error or an async state change. // // This function is used internally and should normally not be called from // plugins or applications. func (element *ElementInstance) LostState() { var carg0 *C.GstElement // in, none, converted carg0 = (*C.GstElement)(UnsafeElementToGlibNone(element)) C.gst_element_lost_state(carg0) runtime.KeepAlive(element) } // MessageFull wraps gst_element_message_full // // The function takes the following parameters: // // - typ MessageType: the #GstMessageType // - domain glib.Quark: the GStreamer GError domain this message belongs to // - code int: the GError code belonging to the domain // - text string (nullable): an allocated text string to be used // as a replacement for the default message connected to code, // or %NULL // - debug string (nullable): an allocated debug message to be // used as a replacement for the default debugging information, // or %NULL // - file string: the source code file where the error was generated // - function string: the source code function where the error was generated // - line int: the source code line where the error was generated // // Post an error, warning or info message on the bus from inside an element. // // @type must be of #GST_MESSAGE_ERROR, #GST_MESSAGE_WARNING or // #GST_MESSAGE_INFO. // // MT safe. func (element *ElementInstance) MessageFull(typ MessageType, domain glib.Quark, code int, text string, debug string, file string, function string, line int) { var carg0 *C.GstElement // in, none, converted var carg1 C.GstMessageType // in, none, casted var carg2 C.GQuark // in, none, casted, alias var carg3 C.gint // in, none, casted var carg4 *C.gchar // in, full, string, nullable-string var carg5 *C.gchar // in, full, string, nullable-string var carg6 *C.gchar // in, none, string var carg7 *C.gchar // in, none, string var carg8 C.gint // in, none, casted carg0 = (*C.GstElement)(UnsafeElementToGlibNone(element)) carg1 = C.GstMessageType(typ) carg2 = C.GQuark(domain) carg3 = C.gint(code) if text != "" { carg4 = (*C.gchar)(unsafe.Pointer(C.CString(text))) } if debug != "" { carg5 = (*C.gchar)(unsafe.Pointer(C.CString(debug))) } carg6 = (*C.gchar)(unsafe.Pointer(C.CString(file))) defer C.free(unsafe.Pointer(carg6)) carg7 = (*C.gchar)(unsafe.Pointer(C.CString(function))) defer C.free(unsafe.Pointer(carg7)) carg8 = C.gint(line) C.gst_element_message_full(carg0, carg1, carg2, carg3, carg4, carg5, carg6, carg7, carg8) runtime.KeepAlive(element) runtime.KeepAlive(typ) runtime.KeepAlive(domain) runtime.KeepAlive(code) runtime.KeepAlive(text) runtime.KeepAlive(debug) runtime.KeepAlive(file) runtime.KeepAlive(function) runtime.KeepAlive(line) } // MessageFullWithDetails wraps gst_element_message_full_with_details // // The function takes the following parameters: // // - typ MessageType: the #GstMessageType // - domain glib.Quark: the GStreamer GError domain this message belongs to // - code int: the GError code belonging to the domain // - text string (nullable): an allocated text string to be used // as a replacement for the default message connected to code, // or %NULL // - debug string (nullable): an allocated debug message to be // used as a replacement for the default debugging information, // or %NULL // - file string: the source code file where the error was generated // - function string: the source code function where the error was generated // - line int: the source code line where the error was generated // - structure *Structure: optional details structure // // Post an error, warning or info message on the bus from inside an element. // // @type must be of #GST_MESSAGE_ERROR, #GST_MESSAGE_WARNING or // #GST_MESSAGE_INFO. func (element *ElementInstance) MessageFullWithDetails(typ MessageType, domain glib.Quark, code int, text string, debug string, file string, function string, line int, structure *Structure) { var carg0 *C.GstElement // in, none, converted var carg1 C.GstMessageType // in, none, casted var carg2 C.GQuark // in, none, casted, alias var carg3 C.gint // in, none, casted var carg4 *C.gchar // in, full, string, nullable-string var carg5 *C.gchar // in, full, string, nullable-string var carg6 *C.gchar // in, none, string var carg7 *C.gchar // in, none, string var carg8 C.gint // in, none, casted var carg9 *C.GstStructure // in, full, converted carg0 = (*C.GstElement)(UnsafeElementToGlibNone(element)) carg1 = C.GstMessageType(typ) carg2 = C.GQuark(domain) carg3 = C.gint(code) if text != "" { carg4 = (*C.gchar)(unsafe.Pointer(C.CString(text))) } if debug != "" { carg5 = (*C.gchar)(unsafe.Pointer(C.CString(debug))) } carg6 = (*C.gchar)(unsafe.Pointer(C.CString(file))) defer C.free(unsafe.Pointer(carg6)) carg7 = (*C.gchar)(unsafe.Pointer(C.CString(function))) defer C.free(unsafe.Pointer(carg7)) carg8 = C.gint(line) carg9 = (*C.GstStructure)(UnsafeStructureToGlibFull(structure)) C.gst_element_message_full_with_details(carg0, carg1, carg2, carg3, carg4, carg5, carg6, carg7, carg8, carg9) runtime.KeepAlive(element) runtime.KeepAlive(typ) runtime.KeepAlive(domain) runtime.KeepAlive(code) runtime.KeepAlive(text) runtime.KeepAlive(debug) runtime.KeepAlive(file) runtime.KeepAlive(function) runtime.KeepAlive(line) runtime.KeepAlive(structure) } // NoMorePads wraps gst_element_no_more_pads // // Use this function to signal that the element does not expect any more pads // to show up in the current pipeline. This function should be called whenever // pads have been added by the element itself. Elements with #GST_PAD_SOMETIMES // pad templates use this in combination with autopluggers to figure out that // the element is done initializing its pads. // // This function emits the #GstElement::no-more-pads signal. // // MT safe. func (element *ElementInstance) NoMorePads() { var carg0 *C.GstElement // in, none, converted carg0 = (*C.GstElement)(UnsafeElementToGlibNone(element)) C.gst_element_no_more_pads(carg0) runtime.KeepAlive(element) } // PostMessage wraps gst_element_post_message // // The function takes the following parameters: // // - message *Message: a #GstMessage to post // // The function returns the following values: // // - goret bool // // Post a message on the element's #GstBus. This function takes ownership of the // message; if you want to access the message after this call, you should add an // additional reference before calling. func (element *ElementInstance) PostMessage(message *Message) bool { var carg0 *C.GstElement // in, none, converted var carg1 *C.GstMessage // in, full, converted var cret C.gboolean // return carg0 = (*C.GstElement)(UnsafeElementToGlibNone(element)) carg1 = (*C.GstMessage)(UnsafeMessageToGlibFull(message)) cret = C.gst_element_post_message(carg0, carg1) runtime.KeepAlive(element) runtime.KeepAlive(message) var goret bool if cret != 0 { goret = true } return goret } // ProvidedClock wraps gst_element_provide_clock // // The function returns the following values: // // - goret Clock (nullable) // // Get the clock provided by the given element. // > An element is only required to provide a clock in the PAUSED // > state. Some elements can provide a clock in other states. func (element *ElementInstance) ProvidedClock() Clock { var carg0 *C.GstElement // in, none, converted var cret *C.GstClock // return, full, converted, nullable carg0 = (*C.GstElement)(UnsafeElementToGlibNone(element)) cret = C.gst_element_provide_clock(carg0) runtime.KeepAlive(element) var goret Clock if cret != nil { goret = UnsafeClockFromGlibFull(unsafe.Pointer(cret)) } return goret } // Query wraps gst_element_query // // The function takes the following parameters: // // - query *Query: the #GstQuery. // // The function returns the following values: // // - goret bool // // Performs a query on the given element. // // For elements that don't implement a query handler, this function // forwards the query to a random srcpad or to the peer of a // random linked sinkpad of this element. // // Please note that some queries might need a running pipeline to work. func (element *ElementInstance) Query(query *Query) bool { var carg0 *C.GstElement // in, none, converted var carg1 *C.GstQuery // in, none, converted var cret C.gboolean // return carg0 = (*C.GstElement)(UnsafeElementToGlibNone(element)) carg1 = (*C.GstQuery)(UnsafeQueryToGlibNone(query)) cret = C.gst_element_query(carg0, carg1) runtime.KeepAlive(element) runtime.KeepAlive(query) var goret bool if cret != 0 { goret = true } return goret } // QueryConvert wraps gst_element_query_convert // // The function takes the following parameters: // // - srcFormat Format: a #GstFormat to convert from. // - srcVal int64: a value to convert. // - destFormat Format: the #GstFormat to convert to. // // The function returns the following values: // // - destVal int64: a pointer to the result. // - goret bool // // Queries an element to convert @src_val in @src_format to @dest_format. func (element *ElementInstance) QueryConvert(srcFormat Format, srcVal int64, destFormat Format) (int64, bool) { var carg0 *C.GstElement // in, none, converted var carg1 C.GstFormat // in, none, casted var carg2 C.gint64 // in, none, casted var carg3 C.GstFormat // in, none, casted var carg4 C.gint64 // out, full, casted var cret C.gboolean // return carg0 = (*C.GstElement)(UnsafeElementToGlibNone(element)) carg1 = C.GstFormat(srcFormat) carg2 = C.gint64(srcVal) carg3 = C.GstFormat(destFormat) cret = C.gst_element_query_convert(carg0, carg1, carg2, carg3, &carg4) runtime.KeepAlive(element) runtime.KeepAlive(srcFormat) runtime.KeepAlive(srcVal) runtime.KeepAlive(destFormat) var destVal int64 var goret bool destVal = int64(carg4) if cret != 0 { goret = true } return destVal, goret } // QueryDuration wraps gst_element_query_duration // // The function takes the following parameters: // // - format Format: the #GstFormat requested // // The function returns the following values: // // - duration int64: A location in which to store the total duration, or %NULL. // - goret bool // // Queries an element (usually top-level pipeline or playbin element) for the // total stream duration in nanoseconds. This query will only work once the // pipeline is prerolled (i.e. reached PAUSED or PLAYING state). The application // will receive an ASYNC_DONE message on the pipeline bus when that is the case. // // If the duration changes for some reason, you will get a DURATION_CHANGED // message on the pipeline bus, in which case you should re-query the duration // using this function. func (element *ElementInstance) QueryDuration(format Format) (int64, bool) { var carg0 *C.GstElement // in, none, converted var carg1 C.GstFormat // in, none, casted var carg2 C.gint64 // out, full, casted var cret C.gboolean // return carg0 = (*C.GstElement)(UnsafeElementToGlibNone(element)) carg1 = C.GstFormat(format) cret = C.gst_element_query_duration(carg0, carg1, &carg2) runtime.KeepAlive(element) runtime.KeepAlive(format) var duration int64 var goret bool duration = int64(carg2) if cret != 0 { goret = true } return duration, goret } // QueryPosition wraps gst_element_query_position // // The function takes the following parameters: // // - format Format: the #GstFormat requested // // The function returns the following values: // // - cur int64: a location in which to store the current // position, or %NULL. // - goret bool // // Queries an element (usually top-level pipeline or playbin element) for the // stream position in nanoseconds. This will be a value between 0 and the // stream duration (if the stream duration is known). This query will usually // only work once the pipeline is prerolled (i.e. reached PAUSED or PLAYING // state). The application will receive an ASYNC_DONE message on the pipeline // bus when that is the case. // // If one repeatedly calls this function one can also create a query and reuse // it in gst_element_query(). func (element *ElementInstance) QueryPosition(format Format) (int64, bool) { var carg0 *C.GstElement // in, none, converted var carg1 C.GstFormat // in, none, casted var carg2 C.gint64 // out, full, casted var cret C.gboolean // return carg0 = (*C.GstElement)(UnsafeElementToGlibNone(element)) carg1 = C.GstFormat(format) cret = C.gst_element_query_position(carg0, carg1, &carg2) runtime.KeepAlive(element) runtime.KeepAlive(format) var cur int64 var goret bool cur = int64(carg2) if cret != 0 { goret = true } return cur, goret } // ReleaseRequestPad wraps gst_element_release_request_pad // // The function takes the following parameters: // // - pad Pad: the #GstPad to release. // // Makes the element free the previously requested pad as obtained // with gst_element_request_pad(). // // This does not unref the pad. If the pad was created by using // gst_element_request_pad(), gst_element_release_request_pad() needs to be // followed by gst_object_unref() to free the @pad. // // MT safe. func (element *ElementInstance) ReleaseRequestPad(pad Pad) { var carg0 *C.GstElement // in, none, converted var carg1 *C.GstPad // in, none, converted carg0 = (*C.GstElement)(UnsafeElementToGlibNone(element)) carg1 = (*C.GstPad)(UnsafePadToGlibNone(pad)) C.gst_element_release_request_pad(carg0, carg1) runtime.KeepAlive(element) runtime.KeepAlive(pad) } // RemovePad wraps gst_element_remove_pad // // The function takes the following parameters: // // - pad Pad: the #GstPad to remove from the element. // // The function returns the following values: // // - goret bool // // Removes @pad from @element. @pad will be destroyed if it has not been // referenced elsewhere using gst_object_unparent(). // // This function is used by plugin developers and should not be used // by applications. Pads that were dynamically requested from elements // with gst_element_request_pad() should be released with the // gst_element_release_request_pad() function instead. // // Pads are not automatically deactivated so elements should perform the needed // steps to deactivate the pad in case this pad is removed in the PAUSED or // PLAYING state. See gst_pad_set_active() for more information about // deactivating pads. // // The pad and the element should be unlocked when calling this function. // // This function will emit the #GstElement::pad-removed signal on the element. func (element *ElementInstance) RemovePad(pad Pad) bool { var carg0 *C.GstElement // in, none, converted var carg1 *C.GstPad // in, none, converted var cret C.gboolean // return carg0 = (*C.GstElement)(UnsafeElementToGlibNone(element)) carg1 = (*C.GstPad)(UnsafePadToGlibNone(pad)) cret = C.gst_element_remove_pad(carg0, carg1) runtime.KeepAlive(element) runtime.KeepAlive(pad) var goret bool if cret != 0 { goret = true } return goret } // RemovePropertyNotifyWatch wraps gst_element_remove_property_notify_watch // // The function takes the following parameters: // // - watchId uint32: watch id to remove func (element *ElementInstance) RemovePropertyNotifyWatch(watchId uint32) { var carg0 *C.GstElement // in, none, converted var carg1 C.gulong // in, none, casted carg0 = (*C.GstElement)(UnsafeElementToGlibNone(element)) carg1 = C.gulong(watchId) C.gst_element_remove_property_notify_watch(carg0, carg1) runtime.KeepAlive(element) runtime.KeepAlive(watchId) } // RequestPad wraps gst_element_request_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) // // Retrieves a request pad from the element according to the provided template. // Pad templates can be looked up using // gst_element_factory_get_static_pad_templates(). // // The pad should be released with gst_element_release_request_pad(). func (element *ElementInstance) RequestPad(templ PadTemplate, name string, caps *Caps) Pad { var carg0 *C.GstElement // in, none, converted var carg1 *C.GstPadTemplate // in, none, converted var carg2 *C.gchar // in, none, string, nullable-string var carg3 *C.GstCaps // in, none, converted, nullable var cret *C.GstPad // return, full, converted, nullable carg0 = (*C.GstElement)(UnsafeElementToGlibNone(element)) carg1 = (*C.GstPadTemplate)(UnsafePadTemplateToGlibNone(templ)) if name != "" { carg2 = (*C.gchar)(unsafe.Pointer(C.CString(name))) defer C.free(unsafe.Pointer(carg2)) } if caps != nil { carg3 = (*C.GstCaps)(UnsafeCapsToGlibNone(caps)) } cret = C.gst_element_request_pad(carg0, carg1, carg2, carg3) runtime.KeepAlive(element) runtime.KeepAlive(templ) runtime.KeepAlive(name) runtime.KeepAlive(caps) var goret Pad if cret != nil { goret = UnsafePadFromGlibFull(unsafe.Pointer(cret)) } return goret } // RequestPadSimple wraps gst_element_request_pad_simple // // The function takes the following parameters: // // - name string: the name of the request #GstPad to retrieve. // // The function returns the following values: // // - goret Pad (nullable) // // Retrieves a pad from the element by name (e.g. "src_\%d"). This version only // retrieves request pads. The pad should be released with // gst_element_release_request_pad(). // // This method is slower than manually getting the pad template and calling // gst_element_request_pad() if the pads should have a specific name (e.g. // @name is "src_1" instead of "src_\%u"). // // Note that this function was introduced in GStreamer 1.20 in order to provide // a better name to gst_element_get_request_pad(). Prior to 1.20, users // should use gst_element_get_request_pad() which provides the same // functionality. func (element *ElementInstance) RequestPadSimple(name string) Pad { var carg0 *C.GstElement // in, none, converted var carg1 *C.gchar // in, none, string var cret *C.GstPad // return, full, converted, nullable carg0 = (*C.GstElement)(UnsafeElementToGlibNone(element)) carg1 = (*C.gchar)(unsafe.Pointer(C.CString(name))) defer C.free(unsafe.Pointer(carg1)) cret = C.gst_element_request_pad_simple(carg0, carg1) runtime.KeepAlive(element) runtime.KeepAlive(name) var goret Pad if cret != nil { goret = UnsafePadFromGlibFull(unsafe.Pointer(cret)) } return goret } // Seek wraps gst_element_seek // // The function takes the following parameters: // // - rate float64: The new playback rate // - format Format: The format of the seek values // - flags SeekFlags: The optional seek flags. // - startType SeekType: The type and flags for the new start position // - start int64: The value of the new start position // - stopType SeekType: The type and flags for the new stop position // - stop int64: The value of the new stop position // // The function returns the following values: // // - goret bool // // Sends a seek event to an element. See gst_event_new_seek() for the details of // the parameters. The seek event is sent to the element using // gst_element_send_event(). // // MT safe. func (element *ElementInstance) Seek(rate float64, format Format, flags SeekFlags, startType SeekType, start int64, stopType SeekType, stop int64) bool { var carg0 *C.GstElement // in, none, converted var carg1 C.gdouble // in, none, casted var carg2 C.GstFormat // in, none, casted var carg3 C.GstSeekFlags // in, none, casted var carg4 C.GstSeekType // in, none, casted var carg5 C.gint64 // in, none, casted var carg6 C.GstSeekType // in, none, casted var carg7 C.gint64 // in, none, casted var cret C.gboolean // return carg0 = (*C.GstElement)(UnsafeElementToGlibNone(element)) carg1 = C.gdouble(rate) carg2 = C.GstFormat(format) carg3 = C.GstSeekFlags(flags) carg4 = C.GstSeekType(startType) carg5 = C.gint64(start) carg6 = C.GstSeekType(stopType) carg7 = C.gint64(stop) cret = C.gst_element_seek(carg0, carg1, carg2, carg3, carg4, carg5, carg6, carg7) runtime.KeepAlive(element) runtime.KeepAlive(rate) runtime.KeepAlive(format) runtime.KeepAlive(flags) runtime.KeepAlive(startType) runtime.KeepAlive(start) runtime.KeepAlive(stopType) runtime.KeepAlive(stop) var goret bool if cret != 0 { goret = true } return goret } // SeekSimple wraps gst_element_seek_simple // // The function takes the following parameters: // // - format Format: a #GstFormat to execute the seek in, such as #GST_FORMAT_TIME // - seekFlags SeekFlags: seek options; playback applications will usually want to use // GST_SEEK_FLAG_FLUSH | GST_SEEK_FLAG_KEY_UNIT here // - seekPos int64: position to seek to (relative to the start); if you are doing // a seek in #GST_FORMAT_TIME this value is in nanoseconds - // multiply with #GST_SECOND to convert seconds to nanoseconds or // with #GST_MSECOND to convert milliseconds to nanoseconds. // // The function returns the following values: // // - goret bool // // Simple API to perform a seek on the given element, meaning it just seeks // to the given position relative to the start of the stream. For more complex // operations like segment seeks (e.g. for looping) or changing the playback // rate or seeking relative to the last configured playback segment you should // use gst_element_seek(). // // In a completely prerolled PAUSED or PLAYING pipeline, seeking is always // guaranteed to return %TRUE on a seekable media type or %FALSE when the media // type is certainly not seekable (such as a live stream). // // Some elements allow for seeking in the READY state, in this // case they will store the seek event and execute it when they are put to // PAUSED. If the element supports seek in READY, it will always return %TRUE when // it receives the event in the READY state. func (element *ElementInstance) SeekSimple(format Format, seekFlags SeekFlags, seekPos int64) bool { var carg0 *C.GstElement // in, none, converted var carg1 C.GstFormat // in, none, casted var carg2 C.GstSeekFlags // in, none, casted var carg3 C.gint64 // in, none, casted var cret C.gboolean // return carg0 = (*C.GstElement)(UnsafeElementToGlibNone(element)) carg1 = C.GstFormat(format) carg2 = C.GstSeekFlags(seekFlags) carg3 = C.gint64(seekPos) cret = C.gst_element_seek_simple(carg0, carg1, carg2, carg3) runtime.KeepAlive(element) runtime.KeepAlive(format) runtime.KeepAlive(seekFlags) runtime.KeepAlive(seekPos) var goret bool if cret != 0 { goret = true } return goret } // SendEvent wraps gst_element_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 // // Sends an event to an element. If the element doesn't implement an // event handler, the event will be pushed on a random linked sink pad for // downstream events or a random linked source pad for upstream events. // // This function takes ownership of the provided event so you should // gst_event_ref() it if you want to reuse the event after this call. // // MT safe. func (element *ElementInstance) SendEvent(event *Event) bool { var carg0 *C.GstElement // in, none, converted var carg1 *C.GstEvent // in, full, converted var cret C.gboolean // return carg0 = (*C.GstElement)(UnsafeElementToGlibNone(element)) carg1 = (*C.GstEvent)(UnsafeEventToGlibFull(event)) cret = C.gst_element_send_event(carg0, carg1) runtime.KeepAlive(element) runtime.KeepAlive(event) var goret bool if cret != 0 { goret = true } return goret } // SetBaseTime wraps gst_element_set_base_time // // The function takes the following parameters: // // - time ClockTime: the base time to set. // // Set the base time of an element. See gst_element_get_base_time(). // // MT safe. func (element *ElementInstance) SetBaseTime(time ClockTime) { var carg0 *C.GstElement // in, none, converted var carg1 C.GstClockTime // in, none, casted, alias carg0 = (*C.GstElement)(UnsafeElementToGlibNone(element)) carg1 = C.GstClockTime(time) C.gst_element_set_base_time(carg0, carg1) runtime.KeepAlive(element) runtime.KeepAlive(time) } // SetBus wraps gst_element_set_bus // // The function takes the following parameters: // // - bus Bus (nullable): the #GstBus to set. // // Sets the bus of the element. Increases the refcount on the bus. // For internal use only, unless you're testing elements. // // MT safe. func (element *ElementInstance) SetBus(bus Bus) { var carg0 *C.GstElement // in, none, converted var carg1 *C.GstBus // in, none, converted, nullable carg0 = (*C.GstElement)(UnsafeElementToGlibNone(element)) if bus != nil { carg1 = (*C.GstBus)(UnsafeBusToGlibNone(bus)) } C.gst_element_set_bus(carg0, carg1) runtime.KeepAlive(element) runtime.KeepAlive(bus) } // SetClock wraps gst_element_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 // // Sets the clock for the element. This function increases the // refcount on the clock. Any previously set clock on the object // is unreffed. func (element *ElementInstance) SetClock(clock Clock) bool { var carg0 *C.GstElement // in, none, converted var carg1 *C.GstClock // in, none, converted, nullable var cret C.gboolean // return carg0 = (*C.GstElement)(UnsafeElementToGlibNone(element)) if clock != nil { carg1 = (*C.GstClock)(UnsafeClockToGlibNone(clock)) } cret = C.gst_element_set_clock(carg0, carg1) runtime.KeepAlive(element) runtime.KeepAlive(clock) var goret bool if cret != 0 { goret = true } return goret } // SetContext wraps gst_element_set_context // // The function takes the following parameters: // // - _context *Context: the #GstContext to set. // // Sets the context of the element. Increases the refcount of the context. // // MT safe. func (element *ElementInstance) SetContext(_context *Context) { var carg0 *C.GstElement // in, none, converted var carg1 *C.GstContext // in, none, converted carg0 = (*C.GstElement)(UnsafeElementToGlibNone(element)) carg1 = (*C.GstContext)(UnsafeContextToGlibNone(_context)) C.gst_element_set_context(carg0, carg1) runtime.KeepAlive(element) runtime.KeepAlive(_context) } // SetLockedState wraps gst_element_set_locked_state // // The function takes the following parameters: // // - lockedState bool: %TRUE to lock the element's state // // The function returns the following values: // // - goret bool // // Locks the state of an element, so state changes of the parent don't affect // this element anymore. // // Note that this is racy if the state lock of the parent bin is not taken. // The parent bin might've just checked the flag in another thread and as the // next step proceed to change the child element's state. // // MT safe. func (element *ElementInstance) SetLockedState(lockedState bool) bool { var carg0 *C.GstElement // in, none, converted var carg1 C.gboolean // in var cret C.gboolean // return carg0 = (*C.GstElement)(UnsafeElementToGlibNone(element)) if lockedState { carg1 = C.TRUE } cret = C.gst_element_set_locked_state(carg0, carg1) runtime.KeepAlive(element) runtime.KeepAlive(lockedState) var goret bool if cret != 0 { goret = true } return goret } // SetStartTime wraps gst_element_set_start_time // // The function takes the following parameters: // // - time ClockTime: the base time to set. // // Set the start time of an element. The start time of the element is the // running time of the element when it last went to the PAUSED state. In READY // or after a flushing seek, it is set to 0. // // Toplevel elements like #GstPipeline will manage the start_time and // base_time on its children. Setting the start_time to #GST_CLOCK_TIME_NONE // on such a toplevel element will disable the distribution of the base_time to // the children and can be useful if the application manages the base_time // itself, for example if you want to synchronize capture from multiple // pipelines, and you can also ensure that the pipelines have the same clock. // // MT safe. func (element *ElementInstance) SetStartTime(time ClockTime) { var carg0 *C.GstElement // in, none, converted var carg1 C.GstClockTime // in, none, casted, alias carg0 = (*C.GstElement)(UnsafeElementToGlibNone(element)) carg1 = C.GstClockTime(time) C.gst_element_set_start_time(carg0, carg1) runtime.KeepAlive(element) runtime.KeepAlive(time) } // SetState wraps gst_element_set_state // // The function takes the following parameters: // // - state State: the element's new #GstState. // // The function returns the following values: // // - goret StateChangeReturn // // Sets the state of the element. This function will try to set the // requested state by going through all the intermediary states and calling // the class's state change function for each. // // This function can return #GST_STATE_CHANGE_ASYNC, in which case the // element will perform the remainder of the state change asynchronously in // another thread. // An application can use gst_element_get_state() to wait for the completion // of the state change or it can wait for a %GST_MESSAGE_ASYNC_DONE or // %GST_MESSAGE_STATE_CHANGED on the bus. // // State changes to %GST_STATE_READY or %GST_STATE_NULL never return // #GST_STATE_CHANGE_ASYNC. func (element *ElementInstance) SetState(state State) StateChangeReturn { var carg0 *C.GstElement // in, none, converted var carg1 C.GstState // in, none, casted var cret C.GstStateChangeReturn // return, none, casted carg0 = (*C.GstElement)(UnsafeElementToGlibNone(element)) carg1 = C.GstState(state) cret = C.gst_element_set_state(carg0, carg1) runtime.KeepAlive(element) runtime.KeepAlive(state) var goret StateChangeReturn goret = StateChangeReturn(cret) return goret } // SyncStateWithParent wraps gst_element_sync_state_with_parent // // The function returns the following values: // // - goret bool // // Tries to change the state of the element to the same as its parent. // If this function returns %FALSE, the state of element is undefined. func (element *ElementInstance) SyncStateWithParent() bool { var carg0 *C.GstElement // in, none, converted var cret C.gboolean // return carg0 = (*C.GstElement)(UnsafeElementToGlibNone(element)) cret = C.gst_element_sync_state_with_parent(carg0) runtime.KeepAlive(element) var goret bool if cret != 0 { goret = true } return goret } // Unlink wraps gst_element_unlink // // The function takes the following parameters: // // - dest Element: the sink #GstElement to unlink. // // Unlinks all source pads of the source element with all sink pads // of the sink element to which they are linked. // // If the link has been made using gst_element_link(), it could have created an // requestpad, which has to be released using gst_element_release_request_pad(). func (src *ElementInstance) Unlink(dest Element) { var carg0 *C.GstElement // in, none, converted var carg1 *C.GstElement // in, none, converted carg0 = (*C.GstElement)(UnsafeElementToGlibNone(src)) carg1 = (*C.GstElement)(UnsafeElementToGlibNone(dest)) C.gst_element_unlink(carg0, carg1) runtime.KeepAlive(src) runtime.KeepAlive(dest) } // UnlinkPads wraps gst_element_unlink_pads // // The function takes the following parameters: // // - srcpadname string: the name of the #GstPad in source element. // - dest Element: a #GstElement containing the destination pad. // - destpadname string: the name of the #GstPad in destination element. // // Unlinks the two named pads of the source and destination elements. // // This is a convenience function for gst_pad_unlink(). func (src *ElementInstance) UnlinkPads(srcpadname string, dest Element, destpadname string) { var carg0 *C.GstElement // in, none, converted var carg1 *C.gchar // in, none, string var carg2 *C.GstElement // in, none, converted var carg3 *C.gchar // in, none, string carg0 = (*C.GstElement)(UnsafeElementToGlibNone(src)) carg1 = (*C.gchar)(unsafe.Pointer(C.CString(srcpadname))) defer C.free(unsafe.Pointer(carg1)) carg2 = (*C.GstElement)(UnsafeElementToGlibNone(dest)) carg3 = (*C.gchar)(unsafe.Pointer(C.CString(destpadname))) defer C.free(unsafe.Pointer(carg3)) C.gst_element_unlink_pads(carg0, carg1, carg2, carg3) runtime.KeepAlive(src) runtime.KeepAlive(srcpadname) runtime.KeepAlive(dest) runtime.KeepAlive(destpadname) } // ConnectNoMorePads connects the provided callback to the "no-more-pads" signal // // This signals that the element will not generate more dynamic pads. // Note that this signal will usually be emitted from the context of // the streaming thread. 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 // usually be emitted from the context of the streaming thread. Also keep in // mind that if you add new elements to the pipeline in the signal handler // you will need to set them to the desired target state with // gst_element_set_state() or gst_element_sync_state_with_parent(). 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 PluginFeatureInstance } var _ ElementFactory = (*ElementFactoryInstance)(nil) // ElementFactory wraps GstElementFactory // // #GstElementFactory is used to create instances of elements. A // GstElementFactory can be added to a #GstPlugin as it is also a // #GstPluginFeature. // // Use the gst_element_factory_find() and gst_element_factory_create() // functions to create element instances or use gst_element_factory_make() as a // convenient shortcut. // // The following code example shows you how to create a GstFileSrc element. // // ## Using an element factory // |[<!-- language="C" --> // #include <gst/gst.h> // // GstElement *src; // GstElementFactory *srcfactory; // // gst_init (&argc, &argv); // // srcfactory = gst_element_factory_find ("filesrc"); // g_return_if_fail (srcfactory != NULL); // src = gst_element_factory_create (srcfactory, "src"); // g_return_if_fail (src != NULL); // ... // ]| type ElementFactory interface { PluginFeature upcastToGstElementFactory() *ElementFactoryInstance // CanSinkAllCaps wraps gst_element_factory_can_sink_all_caps // // The function takes the following parameters: // // - caps *Caps: the caps to check // // The function returns the following values: // // - goret bool // // Checks if the factory can sink all possible capabilities. CanSinkAllCaps(*Caps) bool // CanSinkAnyCaps wraps gst_element_factory_can_sink_any_caps // // The function takes the following parameters: // // - caps *Caps: the caps to check // // The function returns the following values: // // - goret bool // // Checks if the factory can sink any possible capability. CanSinkAnyCaps(*Caps) bool // CanSrcAllCaps wraps gst_element_factory_can_src_all_caps // // The function takes the following parameters: // // - caps *Caps: the caps to check // // The function returns the following values: // // - goret bool // // Checks if the factory can src all possible capabilities. CanSrcAllCaps(*Caps) bool // CanSrcAnyCaps wraps gst_element_factory_can_src_any_caps // // The function takes the following parameters: // // - caps *Caps: the caps to check // // The function returns the following values: // // - goret bool // // Checks if the factory can src any possible capability. CanSrcAnyCaps(*Caps) bool // Create wraps gst_element_factory_create // // 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) // // Create a new element of the type defined by the given elementfactory. // It will be given the name supplied, since all elements require a name as // their first argument. Create(string) Element // CreateWithProperties wraps gst_element_factory_create_with_properties // // The function takes the following parameters: // // - names []string (nullable): array of properties names // - values []gobject.Value (nullable): array of associated properties values // // The function returns the following values: // // - goret Element (nullable) // // Create a new element of the type defined by the given elementfactory. // 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 // // Get the #GType for elements managed by this factory. The type can // only be retrieved if the element factory is loaded, which can be // assured with gst_plugin_feature_load(). GetElementType() gobject.Type // GetMetadata wraps gst_element_factory_get_metadata // // The function takes the following parameters: // // - key string: a key // // The function returns the following values: // // - goret string (nullable) // // 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) // // 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 // // 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 // // Queries whether registered element managed by @factory needs to // 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 // // 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 // // Gets a %NULL-terminated array of protocols this element supports or %NULL if // no protocols are supported. You may not change the contents of the returned // array, as it is still owned by the element factory. Use g_strdupv() to // 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 // // Gets the type of URIs the element supports or #GST_URI_UNKNOWN if none. GetURIType() URIType // HasInterface wraps gst_element_factory_has_interface // // The function takes the following parameters: // // - interfacename string: an interface name // // The function returns the following values: // // - goret bool // // Check if @factory implements the interface with name @interfacename. HasInterface(string) bool // ListIsType wraps gst_element_factory_list_is_type // // The function takes the following parameters: // // - typ ElementFactoryListType: a #GstElementFactoryListType // // The function returns the following values: // // - goret bool // // Check if @factory is of the given types. ListIsType(ElementFactoryListType) bool } func unsafeWrapElementFactory(base *gobject.ObjectInstance) *ElementFactoryInstance { return &ElementFactoryInstance{ PluginFeatureInstance: PluginFeatureInstance{ ObjectInstance: ObjectInstance{ InitiallyUnownedInstance: gobject.InitiallyUnownedInstance{ ObjectInstance: *base, }, }, }, } } func marshalElementFactoryInstance(p unsafe.Pointer) (any, error) { return unsafeWrapElementFactory(gobject.ValueFromNative(p).Object()), nil } // UnsafeElementFactoryFromGlibNone is used to convert raw GstElementFactory pointers to go while taking a reference and attaching a finalizer. This is used by the bindings internally. func UnsafeElementFactoryFromGlibNone(c unsafe.Pointer) ElementFactory { return gobject.UnsafeObjectFromGlibNone(c).(ElementFactory) } // UnsafeElementFactoryFromGlibFull is used to convert raw GstElementFactory pointers to go while attaching a finalizer. This is used by the bindings internally. func UnsafeElementFactoryFromGlibFull(c unsafe.Pointer) ElementFactory { return gobject.UnsafeObjectFromGlibFull(c).(ElementFactory) } func (e *ElementFactoryInstance) upcastToGstElementFactory() *ElementFactoryInstance { return e } // UnsafeElementFactoryToGlibNone is used to convert the instance to it's C value GstElementFactory. This is used by the bindings internally. func UnsafeElementFactoryToGlibNone(c ElementFactory) unsafe.Pointer { return gobject.UnsafeObjectToGlibNone(c) } // UnsafeElementFactoryToGlibFull is used to convert the instance to it's C value GstElementFactory, while removeing the finalizer. This is used by the bindings internally. func UnsafeElementFactoryToGlibFull(c ElementFactory) unsafe.Pointer { return gobject.UnsafeObjectToGlibFull(c) } // ElementFactoryFind wraps gst_element_factory_find // // The function takes the following parameters: // // - name string: name of factory to find // // The function returns the following values: // // - goret ElementFactory (nullable) // // Search for an element factory of the given name. Refs the returned // element factory; caller is responsible for unreffing. func ElementFactoryFind(name string) ElementFactory { var carg1 *C.gchar // in, none, string var cret *C.GstElementFactory // return, full, converted, nullable carg1 = (*C.gchar)(unsafe.Pointer(C.CString(name))) defer C.free(unsafe.Pointer(carg1)) cret = C.gst_element_factory_find(carg1) runtime.KeepAlive(name) var goret ElementFactory if cret != nil { goret = UnsafeElementFactoryFromGlibFull(unsafe.Pointer(cret)) } return goret } // ElementFactoryListGetElements wraps gst_element_factory_list_get_elements // // The function takes the following parameters: // // - typ ElementFactoryListType: a #GstElementFactoryListType // - minrank Rank: Minimum rank // // The function returns the following values: // // - goret []ElementFactory // // Get a list of factories that match the given @type. Only elements // with a rank greater or equal to @minrank will be returned. // The list of factories is returned by decreasing rank. func ElementFactoryListGetElements(typ ElementFactoryListType, minrank Rank) []ElementFactory { var carg1 C.GstElementFactoryListType // in, none, casted, alias var carg2 C.GstRank // in, none, casted var cret *C.GList // container, transfer: full carg1 = C.GstElementFactoryListType(typ) carg2 = C.GstRank(minrank) cret = C.gst_element_factory_list_get_elements(carg1, carg2) runtime.KeepAlive(typ) runtime.KeepAlive(minrank) var goret []ElementFactory goret = glib.UnsafeListFromGlibFull( unsafe.Pointer(cret), func(v unsafe.Pointer) ElementFactory { var dst ElementFactory // converted dst = UnsafeElementFactoryFromGlibFull(v) return dst }, ) return goret } // ElementFactoryMake wraps gst_element_factory_make // // The function takes the following parameters: // // - factoryname string: a named factory to instantiate // - name string (nullable): name of new element, or %NULL to automatically create // a unique name // // The function returns the following values: // // - goret Element (nullable) // // Create a new element of the type defined by the given element factory. // If name is %NULL, then the element will receive a guaranteed unique name, // consisting of the element factory name and a number. // If name is given, it will be given the name supplied. func ElementFactoryMake(factoryname string, name string) Element { var carg1 *C.gchar // in, none, string var carg2 *C.gchar // in, none, string, nullable-string var cret *C.GstElement // return, none, converted, nullable carg1 = (*C.gchar)(unsafe.Pointer(C.CString(factoryname))) defer C.free(unsafe.Pointer(carg1)) if name != "" { carg2 = (*C.gchar)(unsafe.Pointer(C.CString(name))) defer C.free(unsafe.Pointer(carg2)) } cret = C.gst_element_factory_make(carg1, carg2) runtime.KeepAlive(factoryname) runtime.KeepAlive(name) var goret Element if cret != nil { goret = UnsafeElementFromGlibNone(unsafe.Pointer(cret)) } return goret } // CanSinkAllCaps wraps gst_element_factory_can_sink_all_caps // // The function takes the following parameters: // // - caps *Caps: the caps to check // // The function returns the following values: // // - goret bool // // Checks if the factory can sink all possible capabilities. func (factory *ElementFactoryInstance) CanSinkAllCaps(caps *Caps) bool { var carg0 *C.GstElementFactory // in, none, converted var carg1 *C.GstCaps // in, none, converted var cret C.gboolean // return carg0 = (*C.GstElementFactory)(UnsafeElementFactoryToGlibNone(factory)) carg1 = (*C.GstCaps)(UnsafeCapsToGlibNone(caps)) cret = C.gst_element_factory_can_sink_all_caps(carg0, carg1) runtime.KeepAlive(factory) runtime.KeepAlive(caps) var goret bool if cret != 0 { goret = true } return goret } // CanSinkAnyCaps wraps gst_element_factory_can_sink_any_caps // // The function takes the following parameters: // // - caps *Caps: the caps to check // // The function returns the following values: // // - goret bool // // Checks if the factory can sink any possible capability. func (factory *ElementFactoryInstance) CanSinkAnyCaps(caps *Caps) bool { var carg0 *C.GstElementFactory // in, none, converted var carg1 *C.GstCaps // in, none, converted var cret C.gboolean // return carg0 = (*C.GstElementFactory)(UnsafeElementFactoryToGlibNone(factory)) carg1 = (*C.GstCaps)(UnsafeCapsToGlibNone(caps)) cret = C.gst_element_factory_can_sink_any_caps(carg0, carg1) runtime.KeepAlive(factory) runtime.KeepAlive(caps) var goret bool if cret != 0 { goret = true } return goret } // CanSrcAllCaps wraps gst_element_factory_can_src_all_caps // // The function takes the following parameters: // // - caps *Caps: the caps to check // // The function returns the following values: // // - goret bool // // Checks if the factory can src all possible capabilities. func (factory *ElementFactoryInstance) CanSrcAllCaps(caps *Caps) bool { var carg0 *C.GstElementFactory // in, none, converted var carg1 *C.GstCaps // in, none, converted var cret C.gboolean // return carg0 = (*C.GstElementFactory)(UnsafeElementFactoryToGlibNone(factory)) carg1 = (*C.GstCaps)(UnsafeCapsToGlibNone(caps)) cret = C.gst_element_factory_can_src_all_caps(carg0, carg1) runtime.KeepAlive(factory) runtime.KeepAlive(caps) var goret bool if cret != 0 { goret = true } return goret } // CanSrcAnyCaps wraps gst_element_factory_can_src_any_caps // // The function takes the following parameters: // // - caps *Caps: the caps to check // // The function returns the following values: // // - goret bool // // Checks if the factory can src any possible capability. func (factory *ElementFactoryInstance) CanSrcAnyCaps(caps *Caps) bool { var carg0 *C.GstElementFactory // in, none, converted var carg1 *C.GstCaps // in, none, converted var cret C.gboolean // return carg0 = (*C.GstElementFactory)(UnsafeElementFactoryToGlibNone(factory)) carg1 = (*C.GstCaps)(UnsafeCapsToGlibNone(caps)) cret = C.gst_element_factory_can_src_any_caps(carg0, carg1) runtime.KeepAlive(factory) runtime.KeepAlive(caps) var goret bool if cret != 0 { goret = true } return goret } // Create wraps gst_element_factory_create // // 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) // // Create a new element of the type defined by the given elementfactory. // It will be given the name supplied, since all elements require a name as // their first argument. func (factory *ElementFactoryInstance) Create(name string) Element { var carg0 *C.GstElementFactory // in, none, converted var carg1 *C.gchar // in, none, string, nullable-string var cret *C.GstElement // return, none, converted, nullable carg0 = (*C.GstElementFactory)(UnsafeElementFactoryToGlibNone(factory)) if name != "" { carg1 = (*C.gchar)(unsafe.Pointer(C.CString(name))) defer C.free(unsafe.Pointer(carg1)) } cret = C.gst_element_factory_create(carg0, carg1) runtime.KeepAlive(factory) runtime.KeepAlive(name) var goret Element if cret != nil { goret = UnsafeElementFromGlibNone(unsafe.Pointer(cret)) } return goret } // CreateWithProperties wraps gst_element_factory_create_with_properties // // The function takes the following parameters: // // - names []string (nullable): array of properties names // - values []gobject.Value (nullable): array of associated properties values // // The function returns the following values: // // - goret Element (nullable) // // Create a new element of the type defined by the given elementfactory. // The supplied list of properties, will be passed at object construction. func (factory *ElementFactoryInstance) CreateWithProperties(names []string, values []gobject.Value) Element { var carg0 *C.GstElementFactory // in, none, converted var carg1 C.guint // implicit var carg2 **C.gchar // in, transfer: none, C Pointers: 2, Name: array[utf8], nullable, array (inner: *typesystem.StringPrimitive, length-by: carg1) var carg3 *C.GValue // in, transfer: none, C Pointers: 1, Name: array[Value], nullable, array (inner: *typesystem.Record, length-by: carg1) var cret *C.GstElement // return, none, converted, nullable carg0 = (*C.GstElementFactory)(UnsafeElementFactoryToGlibNone(factory)) _ = names _ = carg2 _ = carg1 panic("unimplemented conversion of []string (const gchar**)") _ = values _ = carg3 _ = carg1 panic("unimplemented conversion of []gobject.Value (const GValue*)") cret = C.gst_element_factory_create_with_properties(carg0, carg1, carg2, carg3) runtime.KeepAlive(factory) runtime.KeepAlive(names) runtime.KeepAlive(values) var goret Element if cret != nil { goret = UnsafeElementFromGlibNone(unsafe.Pointer(cret)) } return goret } // GetElementType wraps gst_element_factory_get_element_type // // The function returns the following values: // // - goret gobject.Type // // Get the #GType for elements managed by this factory. The type can // only be retrieved if the element factory is loaded, which can be // assured with gst_plugin_feature_load(). func (factory *ElementFactoryInstance) GetElementType() gobject.Type { var carg0 *C.GstElementFactory // in, none, converted var cret C.GType // return, none, casted, alias carg0 = (*C.GstElementFactory)(UnsafeElementFactoryToGlibNone(factory)) cret = C.gst_element_factory_get_element_type(carg0) runtime.KeepAlive(factory) var goret gobject.Type goret = gobject.Type(cret) return goret } // GetMetadata wraps gst_element_factory_get_metadata // // The function takes the following parameters: // // - key string: a key // // The function returns the following values: // // - goret string (nullable) // // Get the metadata on @factory with @key. func (factory *ElementFactoryInstance) GetMetadata(key string) string { var carg0 *C.GstElementFactory // in, none, converted var carg1 *C.gchar // in, none, string var cret *C.gchar // return, none, string, nullable-string carg0 = (*C.GstElementFactory)(UnsafeElementFactoryToGlibNone(factory)) carg1 = (*C.gchar)(unsafe.Pointer(C.CString(key))) defer C.free(unsafe.Pointer(carg1)) cret = C.gst_element_factory_get_metadata(carg0, carg1) runtime.KeepAlive(factory) runtime.KeepAlive(key) var goret string if cret != nil { goret = C.GoString((*C.char)(unsafe.Pointer(cret))) } return goret } // GetMetadataKeys wraps gst_element_factory_get_metadata_keys // // The function returns the following values: // // - goret []string (nullable) // // Get the available keys for the metadata on @factory. func (factory *ElementFactoryInstance) GetMetadataKeys() []string { var carg0 *C.GstElementFactory // in, none, converted var cret **C.gchar // return, transfer: full, C Pointers: 2, Name: array[utf8], scope: , nullable, array (inner: *typesystem.StringPrimitive, zero-terminated) carg0 = (*C.GstElementFactory)(UnsafeElementFactoryToGlibNone(factory)) cret = C.gst_element_factory_get_metadata_keys(carg0) runtime.KeepAlive(factory) var goret []string _ = goret _ = cret panic("unimplemented conversion of []string (gchar**)") return goret } // GetNumPadTemplates wraps gst_element_factory_get_num_pad_templates // // The function returns the following values: // // - goret uint // // Gets the number of pad_templates in this factory. func (factory *ElementFactoryInstance) GetNumPadTemplates() uint { var carg0 *C.GstElementFactory // in, none, converted var cret C.guint // return, none, casted carg0 = (*C.GstElementFactory)(UnsafeElementFactoryToGlibNone(factory)) cret = C.gst_element_factory_get_num_pad_templates(carg0) runtime.KeepAlive(factory) var goret uint goret = uint(cret) return goret } // GetSkipDocumentation wraps gst_element_factory_get_skip_documentation // // The function returns the following values: // // - goret bool // // Queries whether registered element managed by @factory needs to // be excluded from documentation system or not. func (factory *ElementFactoryInstance) GetSkipDocumentation() bool { var carg0 *C.GstElementFactory // in, none, converted var cret C.gboolean // return carg0 = (*C.GstElementFactory)(UnsafeElementFactoryToGlibNone(factory)) cret = C.gst_element_factory_get_skip_documentation(carg0) runtime.KeepAlive(factory) var goret bool if cret != 0 { goret = true } return goret } // GetStaticPadTemplates wraps gst_element_factory_get_static_pad_templates // // The function returns the following values: // // - goret []*StaticPadTemplate // // Gets the #GList of #GstStaticPadTemplate for this factory. func (factory *ElementFactoryInstance) GetStaticPadTemplates() []*StaticPadTemplate { var carg0 *C.GstElementFactory // in, none, converted var cret *C.GList // container, transfer: none carg0 = (*C.GstElementFactory)(UnsafeElementFactoryToGlibNone(factory)) cret = C.gst_element_factory_get_static_pad_templates(carg0) runtime.KeepAlive(factory) var goret []*StaticPadTemplate goret = glib.UnsafeListFromGlibNone( unsafe.Pointer(cret), func(v unsafe.Pointer) *StaticPadTemplate { var dst *StaticPadTemplate // converted dst = UnsafeStaticPadTemplateFromGlibNone(v) return dst }, ) return goret } // GetURIProtocols wraps gst_element_factory_get_uri_protocols // // The function returns the following values: // // - goret []string // // Gets a %NULL-terminated array of protocols this element supports or %NULL if // no protocols are supported. You may not change the contents of the returned // array, as it is still owned by the element factory. Use g_strdupv() to // make a copy of the protocol string array if you need to. func (factory *ElementFactoryInstance) GetURIProtocols() []string { var carg0 *C.GstElementFactory // in, none, converted var cret **C.gchar // return, transfer: none, C Pointers: 2, Name: array[utf8], scope: , array (inner: *typesystem.StringPrimitive, zero-terminated) carg0 = (*C.GstElementFactory)(UnsafeElementFactoryToGlibNone(factory)) cret = C.gst_element_factory_get_uri_protocols(carg0) runtime.KeepAlive(factory) var goret []string _ = goret _ = cret panic("unimplemented conversion of []string (const gchar* const*)") return goret } // GetURIType wraps gst_element_factory_get_uri_type // // The function returns the following values: // // - goret URIType // // Gets the type of URIs the element supports or #GST_URI_UNKNOWN if none. func (factory *ElementFactoryInstance) GetURIType() URIType { var carg0 *C.GstElementFactory // in, none, converted var cret C.GstURIType // return, none, casted carg0 = (*C.GstElementFactory)(UnsafeElementFactoryToGlibNone(factory)) cret = C.gst_element_factory_get_uri_type(carg0) runtime.KeepAlive(factory) var goret URIType goret = URIType(cret) return goret } // HasInterface wraps gst_element_factory_has_interface // // The function takes the following parameters: // // - interfacename string: an interface name // // The function returns the following values: // // - goret bool // // Check if @factory implements the interface with name @interfacename. func (factory *ElementFactoryInstance) HasInterface(interfacename string) bool { var carg0 *C.GstElementFactory // in, none, converted var carg1 *C.gchar // in, none, string var cret C.gboolean // return carg0 = (*C.GstElementFactory)(UnsafeElementFactoryToGlibNone(factory)) carg1 = (*C.gchar)(unsafe.Pointer(C.CString(interfacename))) defer C.free(unsafe.Pointer(carg1)) cret = C.gst_element_factory_has_interface(carg0, carg1) runtime.KeepAlive(factory) runtime.KeepAlive(interfacename) var goret bool if cret != 0 { goret = true } return goret } // ListIsType wraps gst_element_factory_list_is_type // // The function takes the following parameters: // // - typ ElementFactoryListType: a #GstElementFactoryListType // // The function returns the following values: // // - goret bool // // Check if @factory is of the given types. func (factory *ElementFactoryInstance) ListIsType(typ ElementFactoryListType) bool { var carg0 *C.GstElementFactory // in, none, converted var carg1 C.GstElementFactoryListType // in, none, casted, alias var cret C.gboolean // return carg0 = (*C.GstElementFactory)(UnsafeElementFactoryToGlibNone(factory)) carg1 = C.GstElementFactoryListType(typ) cret = C.gst_element_factory_list_is_type(carg0, carg1) runtime.KeepAlive(factory) runtime.KeepAlive(typ) var goret bool if cret != 0 { goret = true } return goret } // GhostPadInstance is the instance type used by all types extending GstGhostPad. It is used internally by the bindings. Users should use the interface [GhostPad] instead. type GhostPadInstance struct { _ [0]func() // equal guard ProxyPadInstance } var _ GhostPad = (*GhostPadInstance)(nil) // GhostPad wraps GstGhostPad // // GhostPads are useful when organizing pipelines with #GstBin like elements. // The idea here is to create hierarchical element graphs. The bin element // contains a sub-graph. Now one would like to treat the bin-element like any // other #GstElement. This is where GhostPads come into play. A GhostPad acts as // a proxy for another pad. Thus the bin can have sink and source ghost-pads // that are associated with sink and source pads of the child elements. // // If the target pad is known at creation time, gst_ghost_pad_new() is the // function to use to get a ghost-pad. Otherwise one can use gst_ghost_pad_new_no_target() // to create the ghost-pad and use gst_ghost_pad_set_target() to establish the // association later on. // // Note that GhostPads add overhead to the data processing of a pipeline. type GhostPad interface { ProxyPad upcastToGstGhostPad() *GhostPadInstance // Construct wraps gst_ghost_pad_construct // // The function returns the following values: // // - goret bool // // Finish initialization of a newly allocated ghost pad. // // This function is most useful in language bindings and when subclassing // #GstGhostPad; plugin and application developers normally will not call this // function. Call this function directly after a call to g_object_new // (GST_TYPE_GHOST_PAD, "direction", @dir, ..., NULL). // // Deprecated: This function is deprecated since 1.18 and does nothing // anymore. Construct() bool // GetTarget wraps gst_ghost_pad_get_target // // The function returns the following values: // // - goret Pad (nullable) // // Get the target pad of @gpad. Unref target pad after usage. GetTarget() Pad // SetTarget wraps gst_ghost_pad_set_target // // The function takes the following parameters: // // - newtarget Pad (nullable): the new pad target // // The function returns the following values: // // - goret bool // // Set the new target of the ghostpad @gpad. Any existing target // is unlinked and links to the new target are established. if @newtarget is // %NULL the target will be cleared. SetTarget(Pad) bool } func unsafeWrapGhostPad(base *gobject.ObjectInstance) *GhostPadInstance { return &GhostPadInstance{ ProxyPadInstance: ProxyPadInstance{ PadInstance: PadInstance{ ObjectInstance: ObjectInstance{ InitiallyUnownedInstance: gobject.InitiallyUnownedInstance{ ObjectInstance: *base, }, }, }, }, } } func marshalGhostPadInstance(p unsafe.Pointer) (any, error) { return unsafeWrapGhostPad(gobject.ValueFromNative(p).Object()), nil } // UnsafeGhostPadFromGlibNone is used to convert raw GstGhostPad pointers to go while taking a reference and attaching a finalizer. This is used by the bindings internally. func UnsafeGhostPadFromGlibNone(c unsafe.Pointer) GhostPad { return gobject.UnsafeObjectFromGlibNone(c).(GhostPad) } // UnsafeGhostPadFromGlibFull is used to convert raw GstGhostPad pointers to go while attaching a finalizer. This is used by the bindings internally. func UnsafeGhostPadFromGlibFull(c unsafe.Pointer) GhostPad { return gobject.UnsafeObjectFromGlibFull(c).(GhostPad) } func (g *GhostPadInstance) upcastToGstGhostPad() *GhostPadInstance { return g } // UnsafeGhostPadToGlibNone is used to convert the instance to it's C value GstGhostPad. This is used by the bindings internally. func UnsafeGhostPadToGlibNone(c GhostPad) unsafe.Pointer { return gobject.UnsafeObjectToGlibNone(c) } // UnsafeGhostPadToGlibFull is used to convert the instance to it's C value GstGhostPad, while removeing the finalizer. This is used by the bindings internally. func UnsafeGhostPadToGlibFull(c GhostPad) unsafe.Pointer { return gobject.UnsafeObjectToGlibFull(c) } // NewGhostPad wraps gst_ghost_pad_new // // The function takes the following parameters: // // - name string (nullable): the name of the new pad, or %NULL to assign a default name // - target Pad: the pad to ghost. // // The function returns the following values: // // - goret Pad (nullable) // // Create a new ghostpad with @target as the target. The direction will be taken // from the target pad. @target must be unlinked. // // Will ref the target. func NewGhostPad(name string, target Pad) Pad { var carg1 *C.gchar // in, none, string, nullable-string var carg2 *C.GstPad // in, none, converted var cret *C.GstPad // return, none, converted, nullable if name != "" { carg1 = (*C.gchar)(unsafe.Pointer(C.CString(name))) defer C.free(unsafe.Pointer(carg1)) } carg2 = (*C.GstPad)(UnsafePadToGlibNone(target)) cret = C.gst_ghost_pad_new(carg1, carg2) runtime.KeepAlive(name) runtime.KeepAlive(target) var goret Pad if cret != nil { goret = UnsafePadFromGlibNone(unsafe.Pointer(cret)) } return goret } // NewGhostPadFromTemplate wraps gst_ghost_pad_new_from_template // // The function takes the following parameters: // // - name string (nullable): the name of the new pad, or %NULL to assign a default name. // - target Pad: the pad to ghost. // - templ PadTemplate: the #GstPadTemplate to use on the ghostpad. // // The function returns the following values: // // - goret Pad (nullable) // // Create a new ghostpad with @target as the target. The direction will be taken // from the target pad. The template used on the ghostpad will be @template. // // Will ref the target. func NewGhostPadFromTemplate(name string, target Pad, templ PadTemplate) Pad { var carg1 *C.gchar // in, none, string, nullable-string var carg2 *C.GstPad // in, none, converted var carg3 *C.GstPadTemplate // in, none, converted var cret *C.GstPad // return, none, converted, nullable if name != "" { carg1 = (*C.gchar)(unsafe.Pointer(C.CString(name))) defer C.free(unsafe.Pointer(carg1)) } carg2 = (*C.GstPad)(UnsafePadToGlibNone(target)) carg3 = (*C.GstPadTemplate)(UnsafePadTemplateToGlibNone(templ)) cret = C.gst_ghost_pad_new_from_template(carg1, carg2, carg3) runtime.KeepAlive(name) runtime.KeepAlive(target) runtime.KeepAlive(templ) var goret Pad if cret != nil { goret = UnsafePadFromGlibNone(unsafe.Pointer(cret)) } return goret } // NewGhostPadNoTarget wraps gst_ghost_pad_new_no_target // // The function takes the following parameters: // // - name string (nullable): the name of the new pad, or %NULL to assign a default name. // - dir PadDirection: the direction of the ghostpad // // The function returns the following values: // // - goret Pad (nullable) // // Create a new ghostpad without a target with the given direction. // A target can be set on the ghostpad later with the // gst_ghost_pad_set_target() function. // // The created ghostpad will not have a padtemplate. func NewGhostPadNoTarget(name string, dir PadDirection) Pad { var carg1 *C.gchar // in, none, string, nullable-string var carg2 C.GstPadDirection // in, none, casted var cret *C.GstPad // return, none, converted, nullable if name != "" { carg1 = (*C.gchar)(unsafe.Pointer(C.CString(name))) defer C.free(unsafe.Pointer(carg1)) } carg2 = C.GstPadDirection(dir) cret = C.gst_ghost_pad_new_no_target(carg1, carg2) runtime.KeepAlive(name) runtime.KeepAlive(dir) var goret Pad if cret != nil { goret = UnsafePadFromGlibNone(unsafe.Pointer(cret)) } return goret } // NewGhostPadNoTargetFromTemplate wraps gst_ghost_pad_new_no_target_from_template // // The function takes the following parameters: // // - name string (nullable): the name of the new pad, or %NULL to assign a default name // - templ PadTemplate: the #GstPadTemplate to create the ghostpad from. // // The function returns the following values: // // - goret Pad (nullable) // // Create a new ghostpad based on @templ, without setting a target. The // direction will be taken from the @templ. func NewGhostPadNoTargetFromTemplate(name string, templ PadTemplate) Pad { var carg1 *C.gchar // in, none, string, nullable-string var carg2 *C.GstPadTemplate // in, none, converted var cret *C.GstPad // return, none, converted, nullable if name != "" { carg1 = (*C.gchar)(unsafe.Pointer(C.CString(name))) defer C.free(unsafe.Pointer(carg1)) } carg2 = (*C.GstPadTemplate)(UnsafePadTemplateToGlibNone(templ)) cret = C.gst_ghost_pad_new_no_target_from_template(carg1, carg2) runtime.KeepAlive(name) runtime.KeepAlive(templ) var goret Pad if cret != nil { goret = UnsafePadFromGlibNone(unsafe.Pointer(cret)) } return goret } // GhostPadActivateModeDefault wraps gst_ghost_pad_activate_mode_default // // The function takes the following parameters: // // - pad Pad: the #GstPad to activate or deactivate. // - parent Object (nullable): the parent of @pad or %NULL // - mode PadMode: the requested activation mode // - active bool: whether the pad should be active or not. // // The function returns the following values: // // - goret bool // // Invoke the default activate mode function of a ghost pad. func GhostPadActivateModeDefault(pad Pad, parent Object, mode PadMode, active bool) bool { var carg1 *C.GstPad // in, none, converted var carg2 *C.GstObject // in, none, converted, nullable var carg3 C.GstPadMode // in, none, casted var carg4 C.gboolean // in var cret C.gboolean // return carg1 = (*C.GstPad)(UnsafePadToGlibNone(pad)) if parent != nil { carg2 = (*C.GstObject)(UnsafeObjectToGlibNone(parent)) } carg3 = C.GstPadMode(mode) if active { carg4 = C.TRUE } cret = C.gst_ghost_pad_activate_mode_default(carg1, carg2, carg3, carg4) runtime.KeepAlive(pad) runtime.KeepAlive(parent) runtime.KeepAlive(mode) runtime.KeepAlive(active) var goret bool if cret != 0 { goret = true } return goret } // GhostPadInternalActivateModeDefault wraps gst_ghost_pad_internal_activate_mode_default // // The function takes the following parameters: // // - pad Pad: the #GstPad to activate or deactivate. // - parent Object (nullable): the parent of @pad or %NULL // - mode PadMode: the requested activation mode // - active bool: whether the pad should be active or not. // // The function returns the following values: // // - goret bool // // Invoke the default activate mode function of a proxy pad that is // owned by a ghost pad. func GhostPadInternalActivateModeDefault(pad Pad, parent Object, mode PadMode, active bool) bool { var carg1 *C.GstPad // in, none, converted var carg2 *C.GstObject // in, none, converted, nullable var carg3 C.GstPadMode // in, none, casted var carg4 C.gboolean // in var cret C.gboolean // return carg1 = (*C.GstPad)(UnsafePadToGlibNone(pad)) if parent != nil { carg2 = (*C.GstObject)(UnsafeObjectToGlibNone(parent)) } carg3 = C.GstPadMode(mode) if active { carg4 = C.TRUE } cret = C.gst_ghost_pad_internal_activate_mode_default(carg1, carg2, carg3, carg4) runtime.KeepAlive(pad) runtime.KeepAlive(parent) runtime.KeepAlive(mode) runtime.KeepAlive(active) var goret bool if cret != 0 { goret = true } return goret } // Construct wraps gst_ghost_pad_construct // // The function returns the following values: // // - goret bool // // Finish initialization of a newly allocated ghost pad. // // This function is most useful in language bindings and when subclassing // #GstGhostPad; plugin and application developers normally will not call this // function. Call this function directly after a call to g_object_new // (GST_TYPE_GHOST_PAD, "direction", @dir, ..., NULL). // // Deprecated: This function is deprecated since 1.18 and does nothing // anymore. func (gpad *GhostPadInstance) Construct() bool { var carg0 *C.GstGhostPad // in, none, converted var cret C.gboolean // return carg0 = (*C.GstGhostPad)(UnsafeGhostPadToGlibNone(gpad)) cret = C.gst_ghost_pad_construct(carg0) runtime.KeepAlive(gpad) var goret bool if cret != 0 { goret = true } return goret } // GetTarget wraps gst_ghost_pad_get_target // // The function returns the following values: // // - goret Pad (nullable) // // Get the target pad of @gpad. Unref target pad after usage. func (gpad *GhostPadInstance) GetTarget() Pad { var carg0 *C.GstGhostPad // in, none, converted var cret *C.GstPad // return, full, converted, nullable carg0 = (*C.GstGhostPad)(UnsafeGhostPadToGlibNone(gpad)) cret = C.gst_ghost_pad_get_target(carg0) runtime.KeepAlive(gpad) var goret Pad if cret != nil { goret = UnsafePadFromGlibFull(unsafe.Pointer(cret)) } return goret } // SetTarget wraps gst_ghost_pad_set_target // // The function takes the following parameters: // // - newtarget Pad (nullable): the new pad target // // The function returns the following values: // // - goret bool // // Set the new target of the ghostpad @gpad. Any existing target // is unlinked and links to the new target are established. if @newtarget is // %NULL the target will be cleared. func (gpad *GhostPadInstance) SetTarget(newtarget Pad) bool { var carg0 *C.GstGhostPad // in, none, converted var carg1 *C.GstPad // in, none, converted, nullable var cret C.gboolean // return carg0 = (*C.GstGhostPad)(UnsafeGhostPadToGlibNone(gpad)) if newtarget != nil { carg1 = (*C.GstPad)(UnsafePadToGlibNone(newtarget)) } cret = C.gst_ghost_pad_set_target(carg0, carg1) runtime.KeepAlive(gpad) runtime.KeepAlive(newtarget) var goret bool if cret != 0 { goret = true } 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 TaskPoolInstance } var _ SharedTaskPool = (*SharedTaskPoolInstance)(nil) // SharedTaskPool wraps GstSharedTaskPool // // The #GstSharedTaskPool object. type SharedTaskPool interface { TaskPool upcastToGstSharedTaskPool() *SharedTaskPoolInstance // GetMaxThreads wraps gst_shared_task_pool_get_max_threads // // The function returns the following values: // // - goret uint GetMaxThreads() uint // SetMaxThreads wraps gst_shared_task_pool_set_max_threads // // The function takes the following parameters: // // - maxThreads uint: Maximum number of threads to spawn. // // Update the maximal number of threads the @pool may spawn. When // the maximal number of threads is reduced, existing threads are not // immediately shut down, see g_thread_pool_set_max_threads(). // // Setting @max_threads to 0 effectively freezes the pool. SetMaxThreads(uint) } func unsafeWrapSharedTaskPool(base *gobject.ObjectInstance) *SharedTaskPoolInstance { return &SharedTaskPoolInstance{ TaskPoolInstance: TaskPoolInstance{ ObjectInstance: ObjectInstance{ InitiallyUnownedInstance: gobject.InitiallyUnownedInstance{ ObjectInstance: *base, }, }, }, } } func marshalSharedTaskPoolInstance(p unsafe.Pointer) (any, error) { return unsafeWrapSharedTaskPool(gobject.ValueFromNative(p).Object()), nil } // UnsafeSharedTaskPoolFromGlibNone is used to convert raw GstSharedTaskPool pointers to go while taking a reference and attaching a finalizer. This is used by the bindings internally. func UnsafeSharedTaskPoolFromGlibNone(c unsafe.Pointer) SharedTaskPool { return gobject.UnsafeObjectFromGlibNone(c).(SharedTaskPool) } // UnsafeSharedTaskPoolFromGlibFull is used to convert raw GstSharedTaskPool pointers to go while attaching a finalizer. This is used by the bindings internally. func UnsafeSharedTaskPoolFromGlibFull(c unsafe.Pointer) SharedTaskPool { return gobject.UnsafeObjectFromGlibFull(c).(SharedTaskPool) } func (s *SharedTaskPoolInstance) upcastToGstSharedTaskPool() *SharedTaskPoolInstance { return s } // UnsafeSharedTaskPoolToGlibNone is used to convert the instance to it's C value GstSharedTaskPool. This is used by the bindings internally. func UnsafeSharedTaskPoolToGlibNone(c SharedTaskPool) unsafe.Pointer { return gobject.UnsafeObjectToGlibNone(c) } // UnsafeSharedTaskPoolToGlibFull is used to convert the instance to it's C value GstSharedTaskPool, while removeing the finalizer. This is used by the bindings internally. func UnsafeSharedTaskPoolToGlibFull(c SharedTaskPool) unsafe.Pointer { return gobject.UnsafeObjectToGlibFull(c) } // NewSharedTaskPool wraps gst_shared_task_pool_new // // The function returns the following values: // // - goret TaskPool // // Create a new shared task pool. The shared task pool will queue tasks on // a maximum number of threads, 1 by default. // // Do not use a #GstSharedTaskPool to manage potentially inter-dependent tasks such // as pad tasks, as having one task waiting on another to return before returning // would cause obvious deadlocks if they happen to share the same thread. func NewSharedTaskPool() TaskPool { var cret *C.GstTaskPool // return, full, converted cret = C.gst_shared_task_pool_new() var goret TaskPool goret = UnsafeTaskPoolFromGlibFull(unsafe.Pointer(cret)) return goret } // GetMaxThreads wraps gst_shared_task_pool_get_max_threads // // The function returns the following values: // // - goret uint func (pool *SharedTaskPoolInstance) GetMaxThreads() uint { var carg0 *C.GstSharedTaskPool // in, none, converted var cret C.guint // return, none, casted carg0 = (*C.GstSharedTaskPool)(UnsafeSharedTaskPoolToGlibNone(pool)) cret = C.gst_shared_task_pool_get_max_threads(carg0) runtime.KeepAlive(pool) var goret uint goret = uint(cret) return goret } // SetMaxThreads wraps gst_shared_task_pool_set_max_threads // // The function takes the following parameters: // // - maxThreads uint: Maximum number of threads to spawn. // // Update the maximal number of threads the @pool may spawn. When // the maximal number of threads is reduced, existing threads are not // immediately shut down, see g_thread_pool_set_max_threads(). // // Setting @max_threads to 0 effectively freezes the pool. func (pool *SharedTaskPoolInstance) SetMaxThreads(maxThreads uint) { var carg0 *C.GstSharedTaskPool // in, none, converted var carg1 C.guint // in, none, casted carg0 = (*C.GstSharedTaskPool)(UnsafeSharedTaskPoolToGlibNone(pool)) carg1 = C.guint(maxThreads) C.gst_shared_task_pool_set_max_threads(carg0, carg1) runtime.KeepAlive(pool) 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 ClockInstance } var _ SystemClock = (*SystemClockInstance)(nil) // SystemClock wraps GstSystemClock // // The GStreamer core provides a GstSystemClock based on the system time. // Asynchronous callbacks are scheduled from an internal thread. // // Clock implementors are encouraged to subclass this systemclock as it // implements the async notification. // // Subclasses can however override all of the important methods for sync and // async notifications to implement their own callback methods or blocking // wait operations. type SystemClock interface { Clock upcastToGstSystemClock() *SystemClockInstance } func unsafeWrapSystemClock(base *gobject.ObjectInstance) *SystemClockInstance { return &SystemClockInstance{ ClockInstance: ClockInstance{ ObjectInstance: ObjectInstance{ InitiallyUnownedInstance: gobject.InitiallyUnownedInstance{ ObjectInstance: *base, }, }, }, } } func marshalSystemClockInstance(p unsafe.Pointer) (any, error) { return unsafeWrapSystemClock(gobject.ValueFromNative(p).Object()), nil } // UnsafeSystemClockFromGlibNone is used to convert raw GstSystemClock pointers to go while taking a reference and attaching a finalizer. This is used by the bindings internally. func UnsafeSystemClockFromGlibNone(c unsafe.Pointer) SystemClock { return gobject.UnsafeObjectFromGlibNone(c).(SystemClock) } // UnsafeSystemClockFromGlibFull is used to convert raw GstSystemClock pointers to go while attaching a finalizer. This is used by the bindings internally. func UnsafeSystemClockFromGlibFull(c unsafe.Pointer) SystemClock { return gobject.UnsafeObjectFromGlibFull(c).(SystemClock) } func (s *SystemClockInstance) upcastToGstSystemClock() *SystemClockInstance { return s } // UnsafeSystemClockToGlibNone is used to convert the instance to it's C value GstSystemClock. This is used by the bindings internally. func UnsafeSystemClockToGlibNone(c SystemClock) unsafe.Pointer { return gobject.UnsafeObjectToGlibNone(c) } // UnsafeSystemClockToGlibFull is used to convert the instance to it's C value GstSystemClock, while removeing the finalizer. This is used by the bindings internally. func UnsafeSystemClockToGlibFull(c SystemClock) unsafe.Pointer { return gobject.UnsafeObjectToGlibFull(c) } // SystemClockObtain wraps gst_system_clock_obtain // // The function returns the following values: // // - goret Clock // // Get a handle to the default system clock. The refcount of the // clock will be increased so you need to unref the clock after // usage. func SystemClockObtain() Clock { var cret *C.GstClock // return, full, converted cret = C.gst_system_clock_obtain() var goret Clock goret = UnsafeClockFromGlibFull(unsafe.Pointer(cret)) return goret } // SystemClockSetDefault wraps gst_system_clock_set_default // // The function takes the following parameters: // // - newClock Clock (nullable): a #GstClock // // Sets the default system clock that can be obtained with // gst_system_clock_obtain(). // // This is mostly used for testing and debugging purposes when you // want to have control over the time reported by the default system // clock. // // MT safe. func SystemClockSetDefault(newClock Clock) { var carg1 *C.GstClock // in, none, converted, nullable if newClock != nil { carg1 = (*C.GstClock)(UnsafeClockToGlibNone(newClock)) } C.gst_system_clock_set_default(carg1) 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 ElementInstance // implemented interfaces: ChildProxyInstance } var _ Bin = (*BinInstance)(nil) // Bin wraps GstBin // // #GstBin is an element that can contain other #GstElement, allowing them to be // managed as a group. // Pads from the child elements can be ghosted to the bin, see #GstGhostPad. // This makes the bin look like any other elements and enables creation of // higher-level abstraction elements. // // A new #GstBin is created with gst_bin_new(). Use a #GstPipeline instead if you // want to create a toplevel bin because a normal bin doesn't have a bus or // handle clock distribution of its own. // // After the bin has been created you will typically add elements to it with // gst_bin_add(). You can remove elements with gst_bin_remove(). // // An element can be retrieved from a bin with gst_bin_get_by_name(), using the // elements name. gst_bin_get_by_name_recurse_up() is mainly used for internal // purposes and will query the parent bins when the element is not found in the // current bin. // // An iterator of elements in a bin can be retrieved with // gst_bin_iterate_elements(). Various other iterators exist to retrieve the // elements in a bin. // // gst_object_unref() is used to drop your reference to the bin. // // The #GstBin::element-added signal is fired whenever a new element is added to // the bin. Likewise the #GstBin::element-removed signal is fired whenever an // element is removed from the bin. // // A #GstBin internally intercepts every #GstMessage posted by its children and // implements the following default behaviour for each of them: // // * %GST_MESSAGE_EOS: This message is only posted by sinks in the PLAYING // state. If all sinks posted the EOS message, this bin will post and EOS // message upwards. // // * %GST_MESSAGE_SEGMENT_START: Just collected and never forwarded upwards. // The messages are used to decide when all elements have completed playback // of their segment. // // * %GST_MESSAGE_SEGMENT_DONE: Is posted by #GstBin when all elements that posted // a SEGMENT_START have posted a SEGMENT_DONE. // // * %GST_MESSAGE_DURATION_CHANGED: Is posted by an element that detected a change // in the stream duration. The duration change is posted to the // application so that it can refetch the new duration with a duration // query. // // Note that these messages can be posted before the bin is prerolled, in which // case the duration query might fail. // // Note also that there might be a discrepancy (due to internal buffering/queueing) // between the stream being currently displayed and the returned duration query. // // Applications might want to also query for duration (and changes) by // listening to the %GST_MESSAGE_STREAM_START message, signaling the active start // of a (new) stream. // // * %GST_MESSAGE_CLOCK_LOST: This message is posted by an element when it // can no longer provide a clock. // // The default bin behaviour is to check if the lost clock was the one provided // by the bin. If so and the bin is currently in the PLAYING state, the message // is forwarded to the bin parent. // // This message is also generated when a clock provider is removed from // the bin. If this message is received by the application, it should // PAUSE the pipeline and set it back to PLAYING to force a new clock // distribution. // // * %GST_MESSAGE_CLOCK_PROVIDE: This message is generated when an element // can provide a clock. This mostly happens when a new clock // provider is added to the bin. // // The default behaviour of the bin is to mark the currently selected clock as // dirty, which will perform a clock recalculation the next time the bin is // asked to provide a clock. // // This message is never sent to the application but is forwarded to // the parent of the bin. // // * OTHERS: posted upwards. // // A #GstBin implements the following default behaviour for answering to a // #GstQuery: // // * %GST_QUERY_DURATION: The bin will forward the query to all sink // elements contained within and will return the maximum value. // If no sinks are available in the bin, the query fails. // // * %GST_QUERY_POSITION: The query is sent to all sink elements in the bin and the // MAXIMUM of all values is returned. If no sinks are available in the bin, // the query fails. // // * OTHERS: the query is forwarded to all sink elements, the result // of the first sink that answers the query successfully is returned. If no // sink is in the bin, the query fails. // // A #GstBin will by default forward any event sent to it to all sink // ( %GST_EVENT_TYPE_UPSTREAM ) or source ( %GST_EVENT_TYPE_DOWNSTREAM ) elements // depending on the event type. // // If all the elements return %TRUE, the bin will also return %TRUE, else %FALSE // is returned. If no elements of the required type are in the bin, the event // handler will return %TRUE. type Bin interface { BinExtManual // handwritten functions Element ChildProxy upcastToGstBin() *BinInstance // Add wraps gst_bin_add // // The function takes the following parameters: // // - element Element: the #GstElement to add // // The function returns the following values: // // - goret bool // // Adds the given element to the bin. Sets the element's parent, and thus // takes ownership of the element. An element can only be added to one bin. // // If the element's pads are linked to other pads, the pads will be unlinked // before the element is added to the bin. // // > When you add an element to an already-running pipeline, you will have to // > take care to set the state of the newly-added element to the desired // > state (usually PLAYING or PAUSED, same you set the pipeline to originally) // > with gst_element_set_state(), or use gst_element_sync_state_with_parent(). // > The bin or pipeline will not take care of this for you. Add(Element) bool // FindUnlinkedPad wraps gst_bin_find_unlinked_pad // // The function takes the following parameters: // // - direction PadDirection: whether to look for an unlinked source or sink pad // // The function returns the following values: // // - goret Pad (nullable) // // Recursively looks for elements with an unlinked pad of the given // direction within the specified bin and returns an unlinked pad // if one is found, or %NULL otherwise. If a pad is found, the caller // owns a reference to it and should use gst_object_unref() on the // pad when it is not needed any longer. FindUnlinkedPad(PadDirection) Pad // GetByInterface wraps gst_bin_get_by_interface // // The function takes the following parameters: // // - iface gobject.Type: the #GType of an interface // // The function returns the following values: // // - goret Element (nullable) // // Looks for an element inside the bin that implements the given // interface. If such an element is found, it returns the element. // You can cast this element to the given interface afterwards. If you want // all elements that implement the interface, use // gst_bin_iterate_all_by_interface(). This function recurses into child bins. GetByInterface(gobject.Type) Element // GetByName wraps gst_bin_get_by_name // // The function takes the following parameters: // // - name string: the element name to search for // // The function returns the following values: // // - goret Element (nullable) // // Gets the element with the given name from a bin. This // function recurses into child bins. GetByName(string) Element // GetByNameRecurseUp wraps gst_bin_get_by_name_recurse_up // // The function takes the following parameters: // // - name string: the element name to search for // // The function returns the following values: // // - goret Element (nullable) // // Gets the element with the given name from this bin. If the // 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 GetSuppressedFlags() ElementFlags // IterateAllByElementFactoryName wraps gst_bin_iterate_all_by_element_factory_name // // The function takes the following parameters: // // - factoryName string: the name of the #GstElementFactory // // The function returns the following values: // // - goret *Iterator (nullable) // // Looks for all elements inside the bin with the given element factory name. // The function recurses inside child bins. The iterator will yield a series of // #GstElement. IterateAllByElementFactoryName(string) *Iterator // IterateAllByInterface wraps gst_bin_iterate_all_by_interface // // The function takes the following parameters: // // - iface gobject.Type: the #GType of an interface // // The function returns the following values: // // - goret *Iterator (nullable) // // Looks for all elements inside the bin that implements the given // interface. You can safely cast all returned elements to the given interface. // The function recurses inside child bins. The iterator will yield a series // of #GstElement. IterateAllByInterface(gobject.Type) *Iterator // IterateElements wraps gst_bin_iterate_elements // // The function returns the following values: // // - goret *Iterator (nullable) // // 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) // // Gets an iterator for the elements in this bin. // This iterator recurses into GstBin children. IterateRecurse() *Iterator // IterateSinks wraps gst_bin_iterate_sinks // // The function returns the following values: // // - goret *Iterator (nullable) // // Gets an iterator for all elements in the bin that have the // #GST_ELEMENT_FLAG_SINK flag set. IterateSinks() *Iterator // IterateSorted wraps gst_bin_iterate_sorted // // The function returns the following values: // // - goret *Iterator (nullable) // // Gets an iterator for the elements in this bin in topologically // sorted order. This means that the elements are returned from // the most downstream elements (sinks) to the sources. // // This function is used internally to perform the state changes // 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) // // Gets an iterator for all elements in the bin that have the // #GST_ELEMENT_FLAG_SOURCE flag set. IterateSources() *Iterator // RecalculateLatency wraps gst_bin_recalculate_latency // // The function returns the following values: // // - goret bool // // Queries @bin for the current latency and reconfigures this latency on all the // elements using a LATENCY event. // // This method is typically called on the pipeline when a #GST_MESSAGE_LATENCY // is posted on the bus. // // This function simply emits the #GstBin::do-latency signal so any custom latency // calculations will be performed. RecalculateLatency() bool // Remove wraps gst_bin_remove // // The function takes the following parameters: // // - element Element: the #GstElement to remove // // The function returns the following values: // // - goret bool // // Removes the element from the bin, unparenting it as well. // Unparenting the element means that the element will be dereferenced, // so if the bin holds the only reference to the element, the element // will be freed in the process of removing it from the bin. If you // want the element to still exist after removing, you need to call // gst_object_ref() before removing it from the bin. // // If the element's pads are linked to other pads, the pads will be unlinked // before the element is removed from the bin. Remove(Element) bool // SetSuppressedFlags wraps gst_bin_set_suppressed_flags // // The function takes the following parameters: // // - flags ElementFlags: the #GstElementFlags to suppress // // Suppresses the given flags on the bin. #GstElementFlags of a // child element are propagated when it is added to the bin. // When suppressed flags are set, those specified flags will // not be propagated to the bin. SetSuppressedFlags(ElementFlags) // SyncChildrenStates wraps gst_bin_sync_children_states // // The function returns the following values: // // - goret bool // // Synchronizes the state of every child of @bin with the state // of @bin. See also gst_element_sync_state_with_parent(). SyncChildrenStates() bool // ConnectDeepElementAdded connects the provided callback to the "deep-element-added" signal // // Will be emitted after the element was added to @sub_bin. ConnectDeepElementAdded(func(Bin, Bin, Element)) gobject.SignalHandle // ConnectDeepElementRemoved connects the provided callback to the "deep-element-removed" signal // // Will be emitted after the element was removed from @sub_bin. ConnectDeepElementRemoved(func(Bin, Bin, Element)) gobject.SignalHandle // ConnectDoLatency connects the provided callback to the "do-latency" signal // // Will be emitted when the bin needs to perform latency calculations. This // signal is only emitted for toplevel bins or when #GstBin:async-handling is // enabled. // // Only one signal handler is invoked. If no signals are connected, the // default handler is invoked, which will query and distribute the lowest // possible latency to all sinks. // // Connect to this signal if the default latency calculations are not // sufficient, like when you need different latencies for different sinks in // the same pipeline. ConnectDoLatency(func(Bin) bool) gobject.SignalHandle // ConnectElementAdded connects the provided callback to the "element-added" signal // // Will be emitted after the element was added to the bin. ConnectElementAdded(func(Bin, Element)) gobject.SignalHandle // ConnectElementRemoved connects the provided callback to the "element-removed" signal // // Will be emitted after the element was removed from the bin. ConnectElementRemoved(func(Bin, Element)) gobject.SignalHandle } func unsafeWrapBin(base *gobject.ObjectInstance) *BinInstance { return &BinInstance{ ElementInstance: ElementInstance{ ObjectInstance: ObjectInstance{ InitiallyUnownedInstance: gobject.InitiallyUnownedInstance{ ObjectInstance: *base, }, }, }, ChildProxyInstance: ChildProxyInstance{ Instance: *base, }, } } func marshalBinInstance(p unsafe.Pointer) (any, error) { return unsafeWrapBin(gobject.ValueFromNative(p).Object()), nil } // UnsafeBinFromGlibNone is used to convert raw GstBin pointers to go while taking a reference and attaching a finalizer. This is used by the bindings internally. func UnsafeBinFromGlibNone(c unsafe.Pointer) Bin { return gobject.UnsafeObjectFromGlibNone(c).(Bin) } // UnsafeBinFromGlibFull is used to convert raw GstBin pointers to go while attaching a finalizer. This is used by the bindings internally. func UnsafeBinFromGlibFull(c unsafe.Pointer) Bin { return gobject.UnsafeObjectFromGlibFull(c).(Bin) } func (b *BinInstance) upcastToGstBin() *BinInstance { return b } // UnsafeBinToGlibNone is used to convert the instance to it's C value GstBin. This is used by the bindings internally. func UnsafeBinToGlibNone(c Bin) unsafe.Pointer { return gobject.UnsafeObjectToGlibNone(c) } // UnsafeBinToGlibFull is used to convert the instance to it's C value GstBin, while removeing the finalizer. This is used by the bindings internally. func UnsafeBinToGlibFull(c Bin) unsafe.Pointer { return gobject.UnsafeObjectToGlibFull(c) } // NewBin wraps gst_bin_new // // The function takes the following parameters: // // - name string (nullable): the name of the new bin // // The function returns the following values: // // - goret Element // // Creates a new bin with the given name. func NewBin(name string) Element { var carg1 *C.gchar // in, none, string, nullable-string var cret *C.GstElement // return, none, converted if name != "" { carg1 = (*C.gchar)(unsafe.Pointer(C.CString(name))) defer C.free(unsafe.Pointer(carg1)) } cret = C.gst_bin_new(carg1) runtime.KeepAlive(name) var goret Element goret = UnsafeElementFromGlibNone(unsafe.Pointer(cret)) return goret } // Add wraps gst_bin_add // // The function takes the following parameters: // // - element Element: the #GstElement to add // // The function returns the following values: // // - goret bool // // Adds the given element to the bin. Sets the element's parent, and thus // takes ownership of the element. An element can only be added to one bin. // // If the element's pads are linked to other pads, the pads will be unlinked // before the element is added to the bin. // // > When you add an element to an already-running pipeline, you will have to // > take care to set the state of the newly-added element to the desired // > state (usually PLAYING or PAUSED, same you set the pipeline to originally) // > with gst_element_set_state(), or use gst_element_sync_state_with_parent(). // > The bin or pipeline will not take care of this for you. func (bin *BinInstance) Add(element Element) bool { var carg0 *C.GstBin // in, none, converted var carg1 *C.GstElement // in, none, converted var cret C.gboolean // return carg0 = (*C.GstBin)(UnsafeBinToGlibNone(bin)) carg1 = (*C.GstElement)(UnsafeElementToGlibNone(element)) cret = C.gst_bin_add(carg0, carg1) runtime.KeepAlive(bin) runtime.KeepAlive(element) var goret bool if cret != 0 { goret = true } return goret } // FindUnlinkedPad wraps gst_bin_find_unlinked_pad // // The function takes the following parameters: // // - direction PadDirection: whether to look for an unlinked source or sink pad // // The function returns the following values: // // - goret Pad (nullable) // // Recursively looks for elements with an unlinked pad of the given // direction within the specified bin and returns an unlinked pad // if one is found, or %NULL otherwise. If a pad is found, the caller // owns a reference to it and should use gst_object_unref() on the // pad when it is not needed any longer. func (bin *BinInstance) FindUnlinkedPad(direction PadDirection) Pad { var carg0 *C.GstBin // in, none, converted var carg1 C.GstPadDirection // in, none, casted var cret *C.GstPad // return, full, converted, nullable carg0 = (*C.GstBin)(UnsafeBinToGlibNone(bin)) carg1 = C.GstPadDirection(direction) cret = C.gst_bin_find_unlinked_pad(carg0, carg1) runtime.KeepAlive(bin) runtime.KeepAlive(direction) var goret Pad if cret != nil { goret = UnsafePadFromGlibFull(unsafe.Pointer(cret)) } return goret } // GetByInterface wraps gst_bin_get_by_interface // // The function takes the following parameters: // // - iface gobject.Type: the #GType of an interface // // The function returns the following values: // // - goret Element (nullable) // // Looks for an element inside the bin that implements the given // interface. If such an element is found, it returns the element. // You can cast this element to the given interface afterwards. If you want // all elements that implement the interface, use // gst_bin_iterate_all_by_interface(). This function recurses into child bins. func (bin *BinInstance) GetByInterface(iface gobject.Type) Element { var carg0 *C.GstBin // in, none, converted var carg1 C.GType // in, none, casted, alias var cret *C.GstElement // return, full, converted, nullable carg0 = (*C.GstBin)(UnsafeBinToGlibNone(bin)) carg1 = C.GType(iface) cret = C.gst_bin_get_by_interface(carg0, carg1) runtime.KeepAlive(bin) runtime.KeepAlive(iface) var goret Element if cret != nil { goret = UnsafeElementFromGlibFull(unsafe.Pointer(cret)) } return goret } // GetByName wraps gst_bin_get_by_name // // The function takes the following parameters: // // - name string: the element name to search for // // The function returns the following values: // // - goret Element (nullable) // // Gets the element with the given name from a bin. This // function recurses into child bins. func (bin *BinInstance) GetByName(name string) Element { var carg0 *C.GstBin // in, none, converted var carg1 *C.gchar // in, none, string var cret *C.GstElement // return, full, converted, nullable carg0 = (*C.GstBin)(UnsafeBinToGlibNone(bin)) carg1 = (*C.gchar)(unsafe.Pointer(C.CString(name))) defer C.free(unsafe.Pointer(carg1)) cret = C.gst_bin_get_by_name(carg0, carg1) runtime.KeepAlive(bin) runtime.KeepAlive(name) var goret Element if cret != nil { goret = UnsafeElementFromGlibFull(unsafe.Pointer(cret)) } return goret } // GetByNameRecurseUp wraps gst_bin_get_by_name_recurse_up // // The function takes the following parameters: // // - name string: the element name to search for // // The function returns the following values: // // - goret Element (nullable) // // Gets the element with the given name from this bin. If the // element is not found, a recursion is performed on the parent bin. func (bin *BinInstance) GetByNameRecurseUp(name string) Element { var carg0 *C.GstBin // in, none, converted var carg1 *C.gchar // in, none, string var cret *C.GstElement // return, full, converted, nullable carg0 = (*C.GstBin)(UnsafeBinToGlibNone(bin)) carg1 = (*C.gchar)(unsafe.Pointer(C.CString(name))) defer C.free(unsafe.Pointer(carg1)) cret = C.gst_bin_get_by_name_recurse_up(carg0, carg1) runtime.KeepAlive(bin) runtime.KeepAlive(name) var goret Element if cret != nil { goret = UnsafeElementFromGlibFull(unsafe.Pointer(cret)) } return goret } // GetSuppressedFlags wraps gst_bin_get_suppressed_flags // // The function returns the following values: // // - goret ElementFlags func (bin *BinInstance) GetSuppressedFlags() ElementFlags { var carg0 *C.GstBin // in, none, converted var cret C.GstElementFlags // return, none, casted carg0 = (*C.GstBin)(UnsafeBinToGlibNone(bin)) cret = C.gst_bin_get_suppressed_flags(carg0) runtime.KeepAlive(bin) var goret ElementFlags goret = ElementFlags(cret) return goret } // IterateAllByElementFactoryName wraps gst_bin_iterate_all_by_element_factory_name // // The function takes the following parameters: // // - factoryName string: the name of the #GstElementFactory // // The function returns the following values: // // - goret *Iterator (nullable) // // Looks for all elements inside the bin with the given element factory name. // The function recurses inside child bins. The iterator will yield a series of // #GstElement. func (bin *BinInstance) IterateAllByElementFactoryName(factoryName string) *Iterator { var carg0 *C.GstBin // in, none, converted var carg1 *C.gchar // in, none, string var cret *C.GstIterator // return, full, converted, nullable carg0 = (*C.GstBin)(UnsafeBinToGlibNone(bin)) carg1 = (*C.gchar)(unsafe.Pointer(C.CString(factoryName))) defer C.free(unsafe.Pointer(carg1)) cret = C.gst_bin_iterate_all_by_element_factory_name(carg0, carg1) runtime.KeepAlive(bin) runtime.KeepAlive(factoryName) var goret *Iterator if cret != nil { goret = UnsafeIteratorFromGlibFull(unsafe.Pointer(cret)) } return goret } // IterateAllByInterface wraps gst_bin_iterate_all_by_interface // // The function takes the following parameters: // // - iface gobject.Type: the #GType of an interface // // The function returns the following values: // // - goret *Iterator (nullable) // // Looks for all elements inside the bin that implements the given // interface. You can safely cast all returned elements to the given interface. // The function recurses inside child bins. The iterator will yield a series // of #GstElement. func (bin *BinInstance) IterateAllByInterface(iface gobject.Type) *Iterator { var carg0 *C.GstBin // in, none, converted var carg1 C.GType // in, none, casted, alias var cret *C.GstIterator // return, full, converted, nullable carg0 = (*C.GstBin)(UnsafeBinToGlibNone(bin)) carg1 = C.GType(iface) cret = C.gst_bin_iterate_all_by_interface(carg0, carg1) runtime.KeepAlive(bin) runtime.KeepAlive(iface) var goret *Iterator if cret != nil { goret = UnsafeIteratorFromGlibFull(unsafe.Pointer(cret)) } return goret } // IterateElements wraps gst_bin_iterate_elements // // The function returns the following values: // // - goret *Iterator (nullable) // // Gets an iterator for the elements in this bin. func (bin *BinInstance) IterateElements() *Iterator { var carg0 *C.GstBin // in, none, converted var cret *C.GstIterator // return, full, converted, nullable carg0 = (*C.GstBin)(UnsafeBinToGlibNone(bin)) cret = C.gst_bin_iterate_elements(carg0) runtime.KeepAlive(bin) var goret *Iterator if cret != nil { goret = UnsafeIteratorFromGlibFull(unsafe.Pointer(cret)) } return goret } // IterateRecurse wraps gst_bin_iterate_recurse // // The function returns the following values: // // - goret *Iterator (nullable) // // Gets an iterator for the elements in this bin. // This iterator recurses into GstBin children. func (bin *BinInstance) IterateRecurse() *Iterator { var carg0 *C.GstBin // in, none, converted var cret *C.GstIterator // return, full, converted, nullable carg0 = (*C.GstBin)(UnsafeBinToGlibNone(bin)) cret = C.gst_bin_iterate_recurse(carg0) runtime.KeepAlive(bin) var goret *Iterator if cret != nil { goret = UnsafeIteratorFromGlibFull(unsafe.Pointer(cret)) } return goret } // IterateSinks wraps gst_bin_iterate_sinks // // The function returns the following values: // // - goret *Iterator (nullable) // // Gets an iterator for all elements in the bin that have the // #GST_ELEMENT_FLAG_SINK flag set. func (bin *BinInstance) IterateSinks() *Iterator { var carg0 *C.GstBin // in, none, converted var cret *C.GstIterator // return, full, converted, nullable carg0 = (*C.GstBin)(UnsafeBinToGlibNone(bin)) cret = C.gst_bin_iterate_sinks(carg0) runtime.KeepAlive(bin) var goret *Iterator if cret != nil { goret = UnsafeIteratorFromGlibFull(unsafe.Pointer(cret)) } return goret } // IterateSorted wraps gst_bin_iterate_sorted // // The function returns the following values: // // - goret *Iterator (nullable) // // Gets an iterator for the elements in this bin in topologically // sorted order. This means that the elements are returned from // the most downstream elements (sinks) to the sources. // // This function is used internally to perform the state changes // of the bin elements and for clock selection. func (bin *BinInstance) IterateSorted() *Iterator { var carg0 *C.GstBin // in, none, converted var cret *C.GstIterator // return, full, converted, nullable carg0 = (*C.GstBin)(UnsafeBinToGlibNone(bin)) cret = C.gst_bin_iterate_sorted(carg0) runtime.KeepAlive(bin) var goret *Iterator if cret != nil { goret = UnsafeIteratorFromGlibFull(unsafe.Pointer(cret)) } return goret } // IterateSources wraps gst_bin_iterate_sources // // The function returns the following values: // // - goret *Iterator (nullable) // // Gets an iterator for all elements in the bin that have the // #GST_ELEMENT_FLAG_SOURCE flag set. func (bin *BinInstance) IterateSources() *Iterator { var carg0 *C.GstBin // in, none, converted var cret *C.GstIterator // return, full, converted, nullable carg0 = (*C.GstBin)(UnsafeBinToGlibNone(bin)) cret = C.gst_bin_iterate_sources(carg0) runtime.KeepAlive(bin) var goret *Iterator if cret != nil { goret = UnsafeIteratorFromGlibFull(unsafe.Pointer(cret)) } return goret } // RecalculateLatency wraps gst_bin_recalculate_latency // // The function returns the following values: // // - goret bool // // Queries @bin for the current latency and reconfigures this latency on all the // elements using a LATENCY event. // // This method is typically called on the pipeline when a #GST_MESSAGE_LATENCY // is posted on the bus. // // This function simply emits the #GstBin::do-latency signal so any custom latency // calculations will be performed. func (bin *BinInstance) RecalculateLatency() bool { var carg0 *C.GstBin // in, none, converted var cret C.gboolean // return carg0 = (*C.GstBin)(UnsafeBinToGlibNone(bin)) cret = C.gst_bin_recalculate_latency(carg0) runtime.KeepAlive(bin) var goret bool if cret != 0 { goret = true } return goret } // Remove wraps gst_bin_remove // // The function takes the following parameters: // // - element Element: the #GstElement to remove // // The function returns the following values: // // - goret bool // // Removes the element from the bin, unparenting it as well. // Unparenting the element means that the element will be dereferenced, // so if the bin holds the only reference to the element, the element // will be freed in the process of removing it from the bin. If you // want the element to still exist after removing, you need to call // gst_object_ref() before removing it from the bin. // // If the element's pads are linked to other pads, the pads will be unlinked // before the element is removed from the bin. func (bin *BinInstance) Remove(element Element) bool { var carg0 *C.GstBin // in, none, converted var carg1 *C.GstElement // in, none, converted var cret C.gboolean // return carg0 = (*C.GstBin)(UnsafeBinToGlibNone(bin)) carg1 = (*C.GstElement)(UnsafeElementToGlibNone(element)) cret = C.gst_bin_remove(carg0, carg1) runtime.KeepAlive(bin) runtime.KeepAlive(element) var goret bool if cret != 0 { goret = true } return goret } // SetSuppressedFlags wraps gst_bin_set_suppressed_flags // // The function takes the following parameters: // // - flags ElementFlags: the #GstElementFlags to suppress // // Suppresses the given flags on the bin. #GstElementFlags of a // child element are propagated when it is added to the bin. // When suppressed flags are set, those specified flags will // not be propagated to the bin. func (bin *BinInstance) SetSuppressedFlags(flags ElementFlags) { var carg0 *C.GstBin // in, none, converted var carg1 C.GstElementFlags // in, none, casted carg0 = (*C.GstBin)(UnsafeBinToGlibNone(bin)) carg1 = C.GstElementFlags(flags) C.gst_bin_set_suppressed_flags(carg0, carg1) runtime.KeepAlive(bin) runtime.KeepAlive(flags) } // SyncChildrenStates wraps gst_bin_sync_children_states // // The function returns the following values: // // - goret bool // // Synchronizes the state of every child of @bin with the state // of @bin. See also gst_element_sync_state_with_parent(). func (bin *BinInstance) SyncChildrenStates() bool { var carg0 *C.GstBin // in, none, converted var cret C.gboolean // return carg0 = (*C.GstBin)(UnsafeBinToGlibNone(bin)) cret = C.gst_bin_sync_children_states(carg0) runtime.KeepAlive(bin) var goret bool if cret != 0 { goret = true } return goret } // ConnectDeepElementAdded connects the provided callback to the "deep-element-added" signal // // Will be emitted after the element was added to @sub_bin. 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 // signal is only emitted for toplevel bins or when #GstBin:async-handling is // enabled. // // Only one signal handler is invoked. If no signals are connected, the // default handler is invoked, which will query and distribute the lowest // possible latency to all sinks. // // Connect to this signal if the default latency calculations are not // sufficient, like when you need different latencies for different sinks in // the same pipeline. 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 BinInstance } var _ Pipeline = (*PipelineInstance)(nil) // Pipeline wraps GstPipeline // // A #GstPipeline is a special #GstBin used as the toplevel container for // the filter graph. The #GstPipeline will manage the selection and // distribution of a global #GstClock as well as provide a #GstBus to the // application. // // gst_pipeline_new() is used to create a pipeline. when you are done with // the pipeline, use gst_object_unref() to free its resources including all // added #GstElement objects (if not otherwise referenced). // // Elements are added and removed from the pipeline using the #GstBin // methods like gst_bin_add() and gst_bin_remove() (see #GstBin). // // Before changing the state of the #GstPipeline (see #GstElement) a #GstBus // should be retrieved with gst_pipeline_get_bus(). This #GstBus should then // be used to receive #GstMessage from the elements in the pipeline. Listening // to the #GstBus is necessary for retrieving error messages from the // #GstPipeline and otherwise the #GstPipeline might stop without any // indication, why. Furthermore, the #GstPipeline posts messages even if // nobody listens on the #GstBus, which will pile up and use up memory. // // By default, a #GstPipeline will automatically flush the pending #GstBus // messages when going to the NULL state to ensure that no circular // references exist when no messages are read from the #GstBus. This // behaviour can be changed with gst_pipeline_set_auto_flush_bus(). // // When the #GstPipeline performs the PAUSED to PLAYING state change it will // select a clock for the elements. The clock selection algorithm will by // default select a clock provided by an element that is most upstream // (closest to the source). For live pipelines (ones that return // #GST_STATE_CHANGE_NO_PREROLL from the gst_element_set_state() call) this // will select the clock provided by the live source. For normal pipelines // this will select a clock provided by the sinks (most likely the audio // sink). If no element provides a clock, a default #GstSystemClock is used. // // The clock selection can be controlled with the gst_pipeline_use_clock() // method, which will enforce a given clock on the pipeline. With // gst_pipeline_auto_clock() the default clock selection algorithm can be // restored. // // A #GstPipeline maintains a running time for the elements. The running // time is defined as the difference between the current clock time and // the base time. When the pipeline goes to READY or a flushing seek is // performed on it, the running time is reset to 0. When the pipeline is // set from PLAYING to PAUSED, the current clock time is sampled and used to // configure the base time for the elements when the pipeline is set // to PLAYING again. The effect is that the running time (as the difference // between the clock time and the base time) will count how much time was spent // in the PLAYING state. This default behaviour can be changed with the // gst_element_set_start_time() method. type Pipeline interface { Bin upcastToGstPipeline() *PipelineInstance // AutoClock wraps gst_pipeline_auto_clock // // Let @pipeline select a clock automatically. This is the default // behaviour. // // Use this function if you previous forced a fixed clock with // gst_pipeline_use_clock() and want to restore the default // pipeline clock selection algorithm. // // MT safe. AutoClock() // GetAutoFlushBus wraps gst_pipeline_get_auto_flush_bus // // The function returns the following values: // // - goret bool // // Check if @pipeline will automatically flush messages when going to // the NULL state. GetAutoFlushBus() bool // GetBus wraps gst_pipeline_get_bus // // The function returns the following values: // // - goret Bus // // Gets the #GstBus of @pipeline. The bus allows applications to receive // #GstMessage packets. GetBus() Bus // GetConfiguredLatency wraps gst_pipeline_get_configured_latency // // The function returns the following values: // // - goret ClockTime // // Return the configured latency on @pipeline. GetConfiguredLatency() ClockTime // GetDelay wraps gst_pipeline_get_delay // // The function returns the following values: // // - goret ClockTime // // 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 // // Gets the latency that should be configured on the pipeline. See // gst_pipeline_set_latency(). GetLatency() ClockTime // GetPipelineClock wraps gst_pipeline_get_pipeline_clock // // The function returns the following values: // // - goret Clock // // Gets the current clock used by @pipeline. // // Unlike gst_element_get_clock(), this function will always return a // 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 // // Check if @pipeline is live. IsLive() bool // SetAutoFlushBus wraps gst_pipeline_set_auto_flush_bus // // The function takes the following parameters: // // - autoFlush bool: whether or not to automatically flush the bus when // the pipeline goes from READY to NULL state // // Usually, when a pipeline goes from READY to NULL state, it automatically // flushes all pending messages on the bus, which is done for refcounting // purposes, to break circular references. // // This means that applications that update state using (async) bus messages // (e.g. do certain things when a pipeline goes from PAUSED to READY) might // not get to see messages when the pipeline is shut down, because they might // be flushed before they can be dispatched in the main thread. This behaviour // can be disabled using this function. // // It is important that all messages on the bus are handled when the // automatic flushing is disabled else memory leaks will be introduced. // // MT safe. SetAutoFlushBus(bool) // SetDelay wraps gst_pipeline_set_delay // // The function takes the following parameters: // // - delay ClockTime: the delay // // Set the expected delay needed for all elements to perform the // PAUSED to PLAYING state change. @delay will be added to the // base time of the elements so that they wait an additional @delay // amount of time before starting to process buffers and cannot be // #GST_CLOCK_TIME_NONE. // // This option is used for tuning purposes and should normally not be // used. // // MT safe. SetDelay(ClockTime) // SetLatency wraps gst_pipeline_set_latency // // The function takes the following parameters: // // - latency ClockTime: latency to configure // // Sets the latency that should be configured on the pipeline. Setting // GST_CLOCK_TIME_NONE will restore the default behaviour of using the minimum // latency from the LATENCY query. Setting this is usually not required and // the pipeline will figure out an appropriate latency automatically. // // Setting a too low latency, especially lower than the minimum latency from // the LATENCY query, will most likely cause the pipeline to fail. SetLatency(ClockTime) // UseClock wraps gst_pipeline_use_clock // // The function takes the following parameters: // // - clock Clock (nullable): the clock to use // // Force @pipeline to use the given @clock. The pipeline will // always use the given clock even if new clock providers are added // to this pipeline. // // If @clock is %NULL all clocking will be disabled which will make // the pipeline run as fast as possible. // // MT safe. UseClock(Clock) } func unsafeWrapPipeline(base *gobject.ObjectInstance) *PipelineInstance { return &PipelineInstance{ BinInstance: BinInstance{ ElementInstance: ElementInstance{ ObjectInstance: ObjectInstance{ InitiallyUnownedInstance: gobject.InitiallyUnownedInstance{ ObjectInstance: *base, }, }, }, ChildProxyInstance: ChildProxyInstance{ Instance: *base, }, }, } } func marshalPipelineInstance(p unsafe.Pointer) (any, error) { return unsafeWrapPipeline(gobject.ValueFromNative(p).Object()), nil } // UnsafePipelineFromGlibNone is used to convert raw GstPipeline pointers to go while taking a reference and attaching a finalizer. This is used by the bindings internally. func UnsafePipelineFromGlibNone(c unsafe.Pointer) Pipeline { return gobject.UnsafeObjectFromGlibNone(c).(Pipeline) } // UnsafePipelineFromGlibFull is used to convert raw GstPipeline pointers to go while attaching a finalizer. This is used by the bindings internally. func UnsafePipelineFromGlibFull(c unsafe.Pointer) Pipeline { return gobject.UnsafeObjectFromGlibFull(c).(Pipeline) } func (p *PipelineInstance) upcastToGstPipeline() *PipelineInstance { return p } // UnsafePipelineToGlibNone is used to convert the instance to it's C value GstPipeline. This is used by the bindings internally. func UnsafePipelineToGlibNone(c Pipeline) unsafe.Pointer { return gobject.UnsafeObjectToGlibNone(c) } // UnsafePipelineToGlibFull is used to convert the instance to it's C value GstPipeline, while removeing the finalizer. This is used by the bindings internally. func UnsafePipelineToGlibFull(c Pipeline) unsafe.Pointer { return gobject.UnsafeObjectToGlibFull(c) } // NewPipeline wraps gst_pipeline_new // // The function takes the following parameters: // // - name string (nullable): name of new pipeline // // The function returns the following values: // // - goret Element // // Create a new pipeline with the given name. func NewPipeline(name string) Element { var carg1 *C.gchar // in, none, string, nullable-string var cret *C.GstElement // return, none, converted if name != "" { carg1 = (*C.gchar)(unsafe.Pointer(C.CString(name))) defer C.free(unsafe.Pointer(carg1)) } cret = C.gst_pipeline_new(carg1) runtime.KeepAlive(name) var goret Element goret = UnsafeElementFromGlibNone(unsafe.Pointer(cret)) return goret } // AutoClock wraps gst_pipeline_auto_clock // // Let @pipeline select a clock automatically. This is the default // behaviour. // // Use this function if you previous forced a fixed clock with // gst_pipeline_use_clock() and want to restore the default // pipeline clock selection algorithm. // // MT safe. func (pipeline *PipelineInstance) AutoClock() { var carg0 *C.GstPipeline // in, none, converted carg0 = (*C.GstPipeline)(UnsafePipelineToGlibNone(pipeline)) C.gst_pipeline_auto_clock(carg0) runtime.KeepAlive(pipeline) } // GetAutoFlushBus wraps gst_pipeline_get_auto_flush_bus // // The function returns the following values: // // - goret bool // // Check if @pipeline will automatically flush messages when going to // the NULL state. func (pipeline *PipelineInstance) GetAutoFlushBus() bool { var carg0 *C.GstPipeline // in, none, converted var cret C.gboolean // return carg0 = (*C.GstPipeline)(UnsafePipelineToGlibNone(pipeline)) cret = C.gst_pipeline_get_auto_flush_bus(carg0) runtime.KeepAlive(pipeline) var goret bool if cret != 0 { goret = true } return goret } // GetBus wraps gst_pipeline_get_bus // // The function returns the following values: // // - goret Bus // // Gets the #GstBus of @pipeline. The bus allows applications to receive // #GstMessage packets. func (pipeline *PipelineInstance) GetBus() Bus { var carg0 *C.GstPipeline // in, none, converted var cret *C.GstBus // return, full, converted carg0 = (*C.GstPipeline)(UnsafePipelineToGlibNone(pipeline)) cret = C.gst_pipeline_get_bus(carg0) runtime.KeepAlive(pipeline) var goret Bus goret = UnsafeBusFromGlibFull(unsafe.Pointer(cret)) return goret } // GetConfiguredLatency wraps gst_pipeline_get_configured_latency // // The function returns the following values: // // - goret ClockTime // // Return the configured latency on @pipeline. func (pipeline *PipelineInstance) GetConfiguredLatency() ClockTime { var carg0 *C.GstPipeline // in, none, converted var cret C.GstClockTime // return, none, casted, alias carg0 = (*C.GstPipeline)(UnsafePipelineToGlibNone(pipeline)) cret = C.gst_pipeline_get_configured_latency(carg0) runtime.KeepAlive(pipeline) var goret ClockTime goret = ClockTime(cret) return goret } // GetDelay wraps gst_pipeline_get_delay // // The function returns the following values: // // - goret ClockTime // // Get the configured delay (see gst_pipeline_set_delay()). func (pipeline *PipelineInstance) GetDelay() ClockTime { var carg0 *C.GstPipeline // in, none, converted var cret C.GstClockTime // return, none, casted, alias carg0 = (*C.GstPipeline)(UnsafePipelineToGlibNone(pipeline)) cret = C.gst_pipeline_get_delay(carg0) runtime.KeepAlive(pipeline) var goret ClockTime goret = ClockTime(cret) return goret } // GetLatency wraps gst_pipeline_get_latency // // The function returns the following values: // // - goret ClockTime // // Gets the latency that should be configured on the pipeline. See // gst_pipeline_set_latency(). func (pipeline *PipelineInstance) GetLatency() ClockTime { var carg0 *C.GstPipeline // in, none, converted var cret C.GstClockTime // return, none, casted, alias carg0 = (*C.GstPipeline)(UnsafePipelineToGlibNone(pipeline)) cret = C.gst_pipeline_get_latency(carg0) runtime.KeepAlive(pipeline) var goret ClockTime goret = ClockTime(cret) return goret } // GetPipelineClock wraps gst_pipeline_get_pipeline_clock // // The function returns the following values: // // - goret Clock // // Gets the current clock used by @pipeline. // // Unlike gst_element_get_clock(), this function will always return a // clock, even if the pipeline is not in the PLAYING state. func (pipeline *PipelineInstance) GetPipelineClock() Clock { var carg0 *C.GstPipeline // in, none, converted var cret *C.GstClock // return, full, converted carg0 = (*C.GstPipeline)(UnsafePipelineToGlibNone(pipeline)) cret = C.gst_pipeline_get_pipeline_clock(carg0) runtime.KeepAlive(pipeline) var goret Clock goret = UnsafeClockFromGlibFull(unsafe.Pointer(cret)) return goret } // IsLive wraps gst_pipeline_is_live // // The function returns the following values: // // - goret bool // // Check if @pipeline is live. func (pipeline *PipelineInstance) IsLive() bool { var carg0 *C.GstPipeline // in, none, converted var cret C.gboolean // return carg0 = (*C.GstPipeline)(UnsafePipelineToGlibNone(pipeline)) cret = C.gst_pipeline_is_live(carg0) runtime.KeepAlive(pipeline) var goret bool if cret != 0 { goret = true } return goret } // SetAutoFlushBus wraps gst_pipeline_set_auto_flush_bus // // The function takes the following parameters: // // - autoFlush bool: whether or not to automatically flush the bus when // the pipeline goes from READY to NULL state // // Usually, when a pipeline goes from READY to NULL state, it automatically // flushes all pending messages on the bus, which is done for refcounting // purposes, to break circular references. // // This means that applications that update state using (async) bus messages // (e.g. do certain things when a pipeline goes from PAUSED to READY) might // not get to see messages when the pipeline is shut down, because they might // be flushed before they can be dispatched in the main thread. This behaviour // can be disabled using this function. // // It is important that all messages on the bus are handled when the // automatic flushing is disabled else memory leaks will be introduced. // // MT safe. func (pipeline *PipelineInstance) SetAutoFlushBus(autoFlush bool) { var carg0 *C.GstPipeline // in, none, converted var carg1 C.gboolean // in carg0 = (*C.GstPipeline)(UnsafePipelineToGlibNone(pipeline)) if autoFlush { carg1 = C.TRUE } C.gst_pipeline_set_auto_flush_bus(carg0, carg1) runtime.KeepAlive(pipeline) runtime.KeepAlive(autoFlush) } // SetDelay wraps gst_pipeline_set_delay // // The function takes the following parameters: // // - delay ClockTime: the delay // // Set the expected delay needed for all elements to perform the // PAUSED to PLAYING state change. @delay will be added to the // base time of the elements so that they wait an additional @delay // amount of time before starting to process buffers and cannot be // #GST_CLOCK_TIME_NONE. // // This option is used for tuning purposes and should normally not be // used. // // MT safe. func (pipeline *PipelineInstance) SetDelay(delay ClockTime) { var carg0 *C.GstPipeline // in, none, converted var carg1 C.GstClockTime // in, none, casted, alias carg0 = (*C.GstPipeline)(UnsafePipelineToGlibNone(pipeline)) carg1 = C.GstClockTime(delay) C.gst_pipeline_set_delay(carg0, carg1) runtime.KeepAlive(pipeline) runtime.KeepAlive(delay) } // SetLatency wraps gst_pipeline_set_latency // // The function takes the following parameters: // // - latency ClockTime: latency to configure // // Sets the latency that should be configured on the pipeline. Setting // GST_CLOCK_TIME_NONE will restore the default behaviour of using the minimum // latency from the LATENCY query. Setting this is usually not required and // the pipeline will figure out an appropriate latency automatically. // // Setting a too low latency, especially lower than the minimum latency from // the LATENCY query, will most likely cause the pipeline to fail. func (pipeline *PipelineInstance) SetLatency(latency ClockTime) { var carg0 *C.GstPipeline // in, none, converted var carg1 C.GstClockTime // in, none, casted, alias carg0 = (*C.GstPipeline)(UnsafePipelineToGlibNone(pipeline)) carg1 = C.GstClockTime(latency) C.gst_pipeline_set_latency(carg0, carg1) runtime.KeepAlive(pipeline) runtime.KeepAlive(latency) } // UseClock wraps gst_pipeline_use_clock // // The function takes the following parameters: // // - clock Clock (nullable): the clock to use // // Force @pipeline to use the given @clock. The pipeline will // always use the given clock even if new clock providers are added // to this pipeline. // // If @clock is %NULL all clocking will be disabled which will make // the pipeline run as fast as possible. // // MT safe. func (pipeline *PipelineInstance) UseClock(clock Clock) { var carg0 *C.GstPipeline // in, none, converted var carg1 *C.GstClock // in, none, converted, nullable carg0 = (*C.GstPipeline)(UnsafePipelineToGlibNone(pipeline)) if clock != nil { carg1 = (*C.GstClock)(UnsafeClockToGlibNone(clock)) } C.gst_pipeline_use_clock(carg0, carg1) runtime.KeepAlive(pipeline) 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 type AllocationParams struct { *allocationParams } // allocationParams is the struct that's finalized type allocationParams struct { native *C.GstAllocationParams } var _ gobject.GoValueInitializer = (*AllocationParams)(nil) func marshalAllocationParams(p unsafe.Pointer) (interface{}, error) { b := gobject.ValueFromNative(p).Boxed() return UnsafeAllocationParamsFromGlibBorrow(b), nil } func (r *AllocationParams) InitGoValue(v *gobject.Value) { v.Init(TypeAllocationParams) v.SetBoxed(unsafe.Pointer(r.native)) } // UnsafeAllocationParamsFromGlibBorrow is used to convert raw C.GstAllocationParams pointers to go. This is used by the bindings internally. func UnsafeAllocationParamsFromGlibBorrow(p unsafe.Pointer) *AllocationParams { return &AllocationParams{&allocationParams{(*C.GstAllocationParams)(p)}} } // 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) runtime.SetFinalizer( wrapped.allocationParams, func (intern *allocationParams) { C.gst_allocation_params_free(intern.native) }, ) return wrapped } // 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( wrapped.allocationParams, func (intern *allocationParams) { C.gst_allocation_params_free(intern.native) }, ) return wrapped } // UnsafeAllocationParamsFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [AllocationParams] is expected to work anymore. func UnsafeAllocationParamsFree(a *AllocationParams) { C.gst_allocation_params_free(a.native) } // UnsafeAllocationParamsToGlibNone returns the underlying C pointer. This is used by the bindings internally. func UnsafeAllocationParamsToGlibNone(a *AllocationParams) unsafe.Pointer { return unsafe.Pointer(a.native) } // UnsafeAllocationParamsToGlibFull returns the underlying C pointer and gives up ownership. // This is used by the bindings internally. func UnsafeAllocationParamsToGlibFull(a *AllocationParams) unsafe.Pointer { runtime.SetFinalizer(a.allocationParams, nil) _p := unsafe.Pointer(a.native) 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 // // Create a new #GstAllocationParams on the heap. This function is for // use in GStreamer language bindings. In your own code, you can just // declare a #GstAllocationParams on the stack or in a struct, and // call gst_allocation_params_init() to initialize it. // // You do not need to call gst_allocation_params_init() on the instance // returned by this function. func NewAllocationParams() *AllocationParams { var cret *C.GstAllocationParams // return, full, converted cret = C.gst_allocation_params_new() var goret *AllocationParams goret = UnsafeAllocationParamsFromGlibFull(unsafe.Pointer(cret)) return goret } // Copy wraps gst_allocation_params_copy // // The function returns the following values: // // - goret *AllocationParams (nullable) // // Create a copy of @params. func (params *AllocationParams) Copy() *AllocationParams { var carg0 *C.GstAllocationParams // in, none, converted var cret *C.GstAllocationParams // return, full, converted, nullable carg0 = (*C.GstAllocationParams)(UnsafeAllocationParamsToGlibNone(params)) cret = C.gst_allocation_params_copy(carg0) runtime.KeepAlive(params) var goret *AllocationParams if cret != nil { goret = UnsafeAllocationParamsFromGlibFull(unsafe.Pointer(cret)) } return goret } // Init wraps gst_allocation_params_init // // Initialize @params to its default values func (params *AllocationParams) Init() { var carg0 *C.GstAllocationParams // in, none, converted carg0 = (*C.GstAllocationParams)(UnsafeAllocationParamsToGlibNone(params)) C.gst_allocation_params_init(carg0) runtime.KeepAlive(params) } // AllocatorClass wraps GstAllocatorClass // // The #GstAllocator is used to create new memory. // // AllocatorClass is the type struct for [Allocator] type AllocatorClass struct { *allocatorClass } // allocatorClass is the struct that's finalized type allocatorClass struct { native *C.GstAllocatorClass } // UnsafeAllocatorClassFromGlibBorrow is used to convert raw C.GstAllocatorClass pointers to go. This is used by the bindings internally. func UnsafeAllocatorClassFromGlibBorrow(p unsafe.Pointer) *AllocatorClass { return &AllocatorClass{&allocatorClass{(*C.GstAllocatorClass)(p)}} } // 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. func UnsafeAllocatorClassFree(a *AllocatorClass) { C.free(unsafe.Pointer(a.native)) } // UnsafeAllocatorClassToGlibNone returns the underlying C pointer. This is used by the bindings internally. func UnsafeAllocatorClassToGlibNone(a *AllocatorClass) unsafe.Pointer { return unsafe.Pointer(a.native) } // 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 // threads without performing any blocking operations. type AtomicQueue struct { *atomicQueue } // atomicQueue is the struct that's finalized type atomicQueue struct { native *C.GstAtomicQueue } var _ gobject.GoValueInitializer = (*AtomicQueue)(nil) func marshalAtomicQueue(p unsafe.Pointer) (interface{}, error) { b := gobject.ValueFromNative(p).Boxed() return UnsafeAtomicQueueFromGlibBorrow(b), nil } func (r *AtomicQueue) InitGoValue(v *gobject.Value) { v.Init(TypeAtomicQueue) v.SetBoxed(unsafe.Pointer(r.native)) } // UnsafeAtomicQueueFromGlibBorrow is used to convert raw C.GstAtomicQueue pointers to go. This is used by the bindings internally. func UnsafeAtomicQueueFromGlibBorrow(p unsafe.Pointer) *AtomicQueue { return &AtomicQueue{&atomicQueue{(*C.GstAtomicQueue)(p)}} } // 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) runtime.SetFinalizer( wrapped.atomicQueue, func (intern *atomicQueue) { C.gst_atomic_queue_unref(intern.native) }, ) return wrapped } // 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( wrapped.atomicQueue, func (intern *atomicQueue) { C.gst_atomic_queue_unref(intern.native) }, ) return wrapped } // UnsafeAtomicQueueRef increases the refcount on the underlying resource. This is used by the bindings internally. // // When this is called without an associated call to [AtomicQueue.UnsafeAtomicQueueUnref], then [AtomicQueue] will leak memory. func UnsafeAtomicQueueRef(a *AtomicQueue) { C.gst_atomic_queue_ref(a.native) } // UnsafeAtomicQueueUnref unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [AtomicQueue] is expected to work anymore. func UnsafeAtomicQueueUnref(a *AtomicQueue) { C.gst_atomic_queue_unref(a.native) } // UnsafeAtomicQueueToGlibNone returns the underlying C pointer. This is used by the bindings internally. func UnsafeAtomicQueueToGlibNone(a *AtomicQueue) unsafe.Pointer { return unsafe.Pointer(a.native) } // UnsafeAtomicQueueToGlibFull returns the underlying C pointer and gives up ownership. // This is used by the bindings internally. func UnsafeAtomicQueueToGlibFull(a *AtomicQueue) unsafe.Pointer { runtime.SetFinalizer(a.atomicQueue, nil) _p := unsafe.Pointer(a.native) a.native = nil // AtomicQueue is invalid from here on return _p } // NewAtomicQueue wraps gst_atomic_queue_new // // The function takes the following parameters: // // - initialSize uint: initial queue size // // The function returns the following values: // // - goret *AtomicQueue // // Create a new atomic queue instance. @initial_size will be rounded up to the // nearest power of 2 and used as the initial size of the queue. func NewAtomicQueue(initialSize uint) *AtomicQueue { var carg1 C.guint // in, none, casted var cret *C.GstAtomicQueue // return, full, converted carg1 = C.guint(initialSize) cret = C.gst_atomic_queue_new(carg1) runtime.KeepAlive(initialSize) var goret *AtomicQueue goret = UnsafeAtomicQueueFromGlibFull(unsafe.Pointer(cret)) return goret } // Length wraps gst_atomic_queue_length // // The function returns the following values: // // - goret uint // // Get the amount of items in the queue. func (queue *AtomicQueue) Length() uint { var carg0 *C.GstAtomicQueue // in, none, converted var cret C.guint // return, none, casted carg0 = (*C.GstAtomicQueue)(UnsafeAtomicQueueToGlibNone(queue)) cret = C.gst_atomic_queue_length(carg0) runtime.KeepAlive(queue) var goret uint goret = uint(cret) return goret } // BinClass wraps GstBinClass // // Subclasses can override #GstBinClass::add_element and #GstBinClass::remove_element // to update the list of children in the bin. // // The #GstBinClass::handle_message method can be overridden to implement custom // message handling. // // #GstBinClass::deep_element_added will be called when a new element has been // added to any bin inside this bin, so it will also be called if a new child // 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 } // binClass is the struct that's finalized type binClass struct { native *C.GstBinClass } // UnsafeBinClassFromGlibBorrow is used to convert raw C.GstBinClass pointers to go. This is used by the bindings internally. func UnsafeBinClassFromGlibBorrow(p unsafe.Pointer) *BinClass { return &BinClass{&binClass{(*C.GstBinClass)(p)}} } // 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. func UnsafeBinClassFree(b *BinClass) { C.free(unsafe.Pointer(b.native)) } // UnsafeBinClassToGlibNone returns the underlying C pointer. This is used by the bindings internally. func UnsafeBinClassToGlibNone(b *BinClass) unsafe.Pointer { return unsafe.Pointer(b.native) } // 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 // timing and offset along with other arbitrary metadata that is associated // with the #GstMemory blocks that the buffer contains. // // Buffers are usually created with gst_buffer_new(). After a buffer has been // created one will typically allocate memory for it and add it to the buffer. // The following example creates a buffer that can hold a given video frame // with a given width, height and bits per plane. // // ``` C // GstBuffer *buffer; // GstMemory *memory; // gint size, width, height, bpp; // ... // size = width * height * bpp; // buffer = gst_buffer_new (); // memory = gst_allocator_alloc (NULL, size, NULL); // gst_buffer_insert_memory (buffer, -1, memory); // ... // ``` // // Alternatively, use gst_buffer_new_allocate() to create a buffer with // preallocated data of a given size. // // Buffers can contain a list of #GstMemory objects. You can retrieve how many // memory objects with gst_buffer_n_memory() and you can get a pointer // to memory with gst_buffer_peek_memory() // // A buffer will usually have timestamps, and a duration, but neither of these // are guaranteed (they may be set to #GST_CLOCK_TIME_NONE). Whenever a // meaningful value can be given for these, they should be set. The timestamps // and duration are measured in nanoseconds (they are #GstClockTime values). // // The buffer DTS refers to the timestamp when the buffer should be decoded and // is usually monotonically increasing. The buffer PTS refers to the timestamp when // the buffer content should be presented to the user and is not always // monotonically increasing. // // A buffer can also have one or both of a start and an end offset. These are // media-type specific. For video buffers, the start offset will generally be // the frame number. For audio buffers, it will be the number of samples // produced so far. For compressed data, it could be the byte offset in a // source or destination file. Likewise, the end offset will be the offset of // the end of the buffer. These can only be meaningfully interpreted if you // know the media type of the buffer (the preceding CAPS event). Either or both // can be set to #GST_BUFFER_OFFSET_NONE. // // gst_buffer_ref() is used to increase the refcount of a buffer. This must be // done when you want to keep a handle to the buffer after pushing it to the // next element. The buffer refcount determines the writability of the buffer, a // buffer is only writable when the refcount is exactly 1, i.e. when the caller // has the only reference to the buffer. // // To efficiently create a smaller buffer out of an existing one, you can // use gst_buffer_copy_region(). This method tries to share the memory objects // between the two buffers. // // If a plug-in wants to modify the buffer data or metadata in-place, it should // first obtain a buffer that is safe to modify by using // gst_buffer_make_writable(). This function is optimized so that a copy will // only be made when it is necessary. // // Several flags of the buffer can be set and unset with the // GST_BUFFER_FLAG_SET() and GST_BUFFER_FLAG_UNSET() macros. Use // GST_BUFFER_FLAG_IS_SET() to test if a certain #GstBufferFlags flag is set. // // Buffers can be efficiently merged into a larger buffer with // gst_buffer_append(). Copying of memory will only be done when absolutely // needed. // // Arbitrary extra metadata can be set on a buffer with gst_buffer_add_meta(). // Metadata can be retrieved with gst_buffer_get_meta(). See also #GstMeta. // // An element should either unref the buffer or push it out on a src pad // using gst_pad_push() (see #GstPad). // // Buffers are usually freed by unreffing them with gst_buffer_unref(). When // the refcount drops to 0, any memory and metadata pointed to by the buffer is // unreffed as well. Buffers allocated from a #GstBufferPool will be returned to // the pool when the refcount drops to 0. // // The #GstParentBufferMeta is a meta which can be attached to a #GstBuffer // to hold a reference to another buffer that is only released when the child // #GstBuffer is released. // // Typically, #GstParentBufferMeta is used when the child buffer is directly // using the #GstMemory of the parent buffer, and wants to prevent the parent // buffer from being returned to a buffer pool until the #GstMemory is available // for re-use. (Since: 1.6) type Buffer struct { *buffer } // buffer is the struct that's finalized type buffer struct { native *C.GstBuffer } var _ gobject.GoValueInitializer = (*Buffer)(nil) func marshalBuffer(p unsafe.Pointer) (interface{}, error) { b := gobject.ValueFromNative(p).Boxed() return UnsafeBufferFromGlibBorrow(b), nil } func (r *Buffer) InitGoValue(v *gobject.Value) { v.Init(TypeBuffer) v.SetBoxed(unsafe.Pointer(r.native)) } // UnsafeBufferFromGlibBorrow is used to convert raw C.GstBuffer pointers to go. This is used by the bindings internally. func UnsafeBufferFromGlibBorrow(p unsafe.Pointer) *Buffer { return &Buffer{&buffer{(*C.GstBuffer)(p)}} } // 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) runtime.SetFinalizer( wrapped.buffer, func (intern *buffer) { C.free(unsafe.Pointer(intern.native)) }, ) return wrapped } // 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( wrapped.buffer, func (intern *buffer) { C.free(unsafe.Pointer(intern.native)) }, ) return wrapped } // UnsafeBufferFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [Buffer] is expected to work anymore. func UnsafeBufferFree(b *Buffer) { C.free(unsafe.Pointer(b.native)) } // UnsafeBufferToGlibNone returns the underlying C pointer. This is used by the bindings internally. func UnsafeBufferToGlibNone(b *Buffer) unsafe.Pointer { return unsafe.Pointer(b.native) } // UnsafeBufferToGlibFull returns the underlying C pointer and gives up ownership. // This is used by the bindings internally. func UnsafeBufferToGlibFull(b *Buffer) unsafe.Pointer { runtime.SetFinalizer(b.buffer, nil) _p := unsafe.Pointer(b.native) b.native = nil // Buffer is invalid from here on return _p } // NewBuffer wraps gst_buffer_new // // The function returns the following values: // // - goret *Buffer // // Creates a newly allocated buffer without any data. func NewBuffer() *Buffer { var cret *C.GstBuffer // return, full, converted cret = C.gst_buffer_new() var goret *Buffer goret = UnsafeBufferFromGlibFull(unsafe.Pointer(cret)) return goret } // NewBufferAllocate wraps gst_buffer_new_allocate // // The function takes the following parameters: // // - allocator Allocator (nullable): the #GstAllocator to use, or %NULL to use the // default allocator // - size uint: the size in bytes of the new buffer's data. // - params *AllocationParams (nullable): optional parameters // // The function returns the following values: // // - goret *Buffer (nullable) // // Tries to create a newly allocated buffer with data of the given size and // extra parameters from @allocator. If the requested amount of memory can't be // allocated, %NULL will be returned. The allocated buffer memory is not cleared. // // When @allocator is %NULL, the default memory allocator will be used. // // Note that when @size == 0, the buffer will not have memory associated with it. func NewBufferAllocate(allocator Allocator, size uint, params *AllocationParams) *Buffer { var carg1 *C.GstAllocator // in, none, converted, nullable var carg2 C.gsize // in, none, casted var carg3 *C.GstAllocationParams // in, none, converted, nullable var cret *C.GstBuffer // return, full, converted, nullable if allocator != nil { carg1 = (*C.GstAllocator)(UnsafeAllocatorToGlibNone(allocator)) } carg2 = C.gsize(size) if params != nil { carg3 = (*C.GstAllocationParams)(UnsafeAllocationParamsToGlibNone(params)) } cret = C.gst_buffer_new_allocate(carg1, carg2, carg3) runtime.KeepAlive(allocator) runtime.KeepAlive(size) runtime.KeepAlive(params) var goret *Buffer if cret != nil { goret = UnsafeBufferFromGlibFull(unsafe.Pointer(cret)) } return goret } // NewBufferWrappedBytes wraps gst_buffer_new_wrapped_bytes // // The function takes the following parameters: // // - bytes *glib.Bytes: a #GBytes to wrap // // The function returns the following values: // // - goret *Buffer // // Creates a new #GstBuffer that wraps the given @bytes. The data inside // @bytes cannot be %NULL and the resulting buffer will be marked as read only. func NewBufferWrappedBytes(bytes *glib.Bytes) *Buffer { var carg1 *C.GBytes // in, none, converted var cret *C.GstBuffer // return, full, converted carg1 = (*C.GBytes)(glib.UnsafeBytesToGlibNone(bytes)) cret = C.gst_buffer_new_wrapped_bytes(carg1) runtime.KeepAlive(bytes) var goret *Buffer goret = UnsafeBufferFromGlibFull(unsafe.Pointer(cret)) return goret } // BufferGetMaxMemory wraps gst_buffer_get_max_memory // // The function returns the following values: // // - goret uint // // Gets the maximum amount of memory blocks that a buffer can hold. This is a // compile time constant that can be queried with the function. // // When more memory blocks are added, existing memory blocks will be merged // together to make room for the new block. func BufferGetMaxMemory() uint { var cret C.guint // return, none, casted cret = C.gst_buffer_get_max_memory() var goret uint goret = uint(cret) return goret } // AddCustomMeta wraps gst_buffer_add_custom_meta // // The function takes the following parameters: // // - name string: the registered name of the desired custom meta // // The function returns the following values: // // - goret *CustomMeta (nullable) // // Creates and adds a #GstCustomMeta for the desired @name. @name must have // been successfully registered with gst_meta_register_custom(). func (buffer *Buffer) AddCustomMeta(name string) *CustomMeta { var carg0 *C.GstBuffer // in, none, converted var carg1 *C.gchar // in, none, string var cret *C.GstCustomMeta // return, none, converted, nullable carg0 = (*C.GstBuffer)(UnsafeBufferToGlibNone(buffer)) carg1 = (*C.gchar)(unsafe.Pointer(C.CString(name))) defer C.free(unsafe.Pointer(carg1)) cret = C.gst_buffer_add_custom_meta(carg0, carg1) runtime.KeepAlive(buffer) runtime.KeepAlive(name) var goret *CustomMeta if cret != nil { goret = UnsafeCustomMetaFromGlibNone(unsafe.Pointer(cret)) } return goret } // AddParentBufferMeta wraps gst_buffer_add_parent_buffer_meta // // The function takes the following parameters: // // - ref *Buffer: a #GstBuffer to ref // // The function returns the following values: // // - goret *ParentBufferMeta (nullable) // // Adds a #GstParentBufferMeta to @buffer that holds a reference on // @ref until the buffer is freed. func (buffer *Buffer) AddParentBufferMeta(ref *Buffer) *ParentBufferMeta { var carg0 *C.GstBuffer // in, none, converted var carg1 *C.GstBuffer // in, none, converted var cret *C.GstParentBufferMeta // return, none, converted, nullable carg0 = (*C.GstBuffer)(UnsafeBufferToGlibNone(buffer)) carg1 = (*C.GstBuffer)(UnsafeBufferToGlibNone(ref)) cret = C.gst_buffer_add_parent_buffer_meta(carg0, carg1) runtime.KeepAlive(buffer) runtime.KeepAlive(ref) var goret *ParentBufferMeta if cret != nil { goret = UnsafeParentBufferMetaFromGlibNone(unsafe.Pointer(cret)) } return goret } // AddProtectionMeta wraps gst_buffer_add_protection_meta // // The function takes the following parameters: // // - info *Structure: a #GstStructure holding cryptographic // information relating to the sample contained in @buffer. This // function takes ownership of @info. // // The function returns the following values: // // - goret *ProtectionMeta // // Attaches protection metadata to a #GstBuffer. func (buffer *Buffer) AddProtectionMeta(info *Structure) *ProtectionMeta { var carg0 *C.GstBuffer // in, none, converted var carg1 *C.GstStructure // in, full, converted var cret *C.GstProtectionMeta // return, none, converted carg0 = (*C.GstBuffer)(UnsafeBufferToGlibNone(buffer)) carg1 = (*C.GstStructure)(UnsafeStructureToGlibFull(info)) cret = C.gst_buffer_add_protection_meta(carg0, carg1) runtime.KeepAlive(buffer) runtime.KeepAlive(info) var goret *ProtectionMeta goret = UnsafeProtectionMetaFromGlibNone(unsafe.Pointer(cret)) return goret } // AddReferenceTimestampMeta wraps gst_buffer_add_reference_timestamp_meta // // The function takes the following parameters: // // - reference *Caps: identifier for the timestamp reference. // - timestamp ClockTime: timestamp // - duration ClockTime: duration, or %GST_CLOCK_TIME_NONE // // The function returns the following values: // // - goret *ReferenceTimestampMeta (nullable) // // Adds a #GstReferenceTimestampMeta to @buffer that holds a @timestamp and // optionally @duration based on a specific timestamp @reference. See the // documentation of #GstReferenceTimestampMeta for details. func (buffer *Buffer) AddReferenceTimestampMeta(reference *Caps, timestamp ClockTime, duration ClockTime) *ReferenceTimestampMeta { var carg0 *C.GstBuffer // in, none, converted var carg1 *C.GstCaps // in, none, converted var carg2 C.GstClockTime // in, none, casted, alias var carg3 C.GstClockTime // in, none, casted, alias var cret *C.GstReferenceTimestampMeta // return, none, converted, nullable carg0 = (*C.GstBuffer)(UnsafeBufferToGlibNone(buffer)) carg1 = (*C.GstCaps)(UnsafeCapsToGlibNone(reference)) carg2 = C.GstClockTime(timestamp) carg3 = C.GstClockTime(duration) cret = C.gst_buffer_add_reference_timestamp_meta(carg0, carg1, carg2, carg3) runtime.KeepAlive(buffer) runtime.KeepAlive(reference) runtime.KeepAlive(timestamp) runtime.KeepAlive(duration) var goret *ReferenceTimestampMeta if cret != nil { goret = UnsafeReferenceTimestampMetaFromGlibNone(unsafe.Pointer(cret)) } return goret } // Append wraps gst_buffer_append // // The function takes the following parameters: // // - buf2 *Buffer: the second source #GstBuffer to append. // // The function returns the following values: // // - goret *Buffer // // Appends all the memory from @buf2 to @buf1. The result buffer will contain a // concatenation of the memory of @buf1 and @buf2. func (buf1 *Buffer) Append(buf2 *Buffer) *Buffer { var carg0 *C.GstBuffer // in, none, converted var carg1 *C.GstBuffer // in, full, converted var cret *C.GstBuffer // return, full, converted carg0 = (*C.GstBuffer)(UnsafeBufferToGlibNone(buf1)) carg1 = (*C.GstBuffer)(UnsafeBufferToGlibFull(buf2)) cret = C.gst_buffer_append(carg0, carg1) runtime.KeepAlive(buf1) runtime.KeepAlive(buf2) var goret *Buffer goret = UnsafeBufferFromGlibFull(unsafe.Pointer(cret)) return goret } // AppendMemory wraps gst_buffer_append_memory // // The function takes the following parameters: // // - mem *Memory: a #GstMemory. // // Appends the memory block @mem to @buffer. This function takes // ownership of @mem and thus doesn't increase its refcount. // // This function is identical to gst_buffer_insert_memory() with an index of -1. // See gst_buffer_insert_memory() for more details. func (buffer *Buffer) AppendMemory(mem *Memory) { var carg0 *C.GstBuffer // in, none, converted var carg1 *C.GstMemory // in, full, converted carg0 = (*C.GstBuffer)(UnsafeBufferToGlibNone(buffer)) carg1 = (*C.GstMemory)(UnsafeMemoryToGlibFull(mem)) C.gst_buffer_append_memory(carg0, carg1) runtime.KeepAlive(buffer) runtime.KeepAlive(mem) } // AppendRegion wraps gst_buffer_append_region // // The function takes the following parameters: // // - buf2 *Buffer: the second source #GstBuffer to append. // - offset int: the offset in @buf2 // - size int: the size or -1 of @buf2 // // The function returns the following values: // // - goret *Buffer // // Appends @size bytes at @offset from @buf2 to @buf1. The result buffer will // contain a concatenation of the memory of @buf1 and the requested region of // @buf2. func (buf1 *Buffer) AppendRegion(buf2 *Buffer, offset int, size int) *Buffer { var carg0 *C.GstBuffer // in, none, converted var carg1 *C.GstBuffer // in, full, converted var carg2 C.gssize // in, none, casted var carg3 C.gssize // in, none, casted var cret *C.GstBuffer // return, full, converted carg0 = (*C.GstBuffer)(UnsafeBufferToGlibNone(buf1)) carg1 = (*C.GstBuffer)(UnsafeBufferToGlibFull(buf2)) carg2 = C.gssize(offset) carg3 = C.gssize(size) cret = C.gst_buffer_append_region(carg0, carg1, carg2, carg3) runtime.KeepAlive(buf1) runtime.KeepAlive(buf2) runtime.KeepAlive(offset) runtime.KeepAlive(size) var goret *Buffer goret = UnsafeBufferFromGlibFull(unsafe.Pointer(cret)) return goret } // CopyDeep wraps gst_buffer_copy_deep // // The function returns the following values: // // - goret *Buffer (nullable) // // Creates a copy of the given buffer. This will make a newly allocated // copy of the data the source buffer contains. func (buf *Buffer) CopyDeep() *Buffer { var carg0 *C.GstBuffer // in, none, converted var cret *C.GstBuffer // return, full, converted, nullable carg0 = (*C.GstBuffer)(UnsafeBufferToGlibNone(buf)) cret = C.gst_buffer_copy_deep(carg0) runtime.KeepAlive(buf) var goret *Buffer if cret != nil { goret = UnsafeBufferFromGlibFull(unsafe.Pointer(cret)) } return goret } // CopyInto wraps gst_buffer_copy_into // // The function takes the following parameters: // // - src *Buffer: a source #GstBuffer // - flags BufferCopyFlagsType: flags indicating what metadata fields should be copied. // - offset uint: offset to copy from // - size uint: total size to copy. If -1, all data is copied. // // The function returns the following values: // // - goret bool // // Copies the information from @src into @dest. // // If @dest already contains memory and @flags contains GST_BUFFER_COPY_MEMORY, // the memory from @src will be appended to @dest. // // @flags indicate which fields will be copied. func (dest *Buffer) CopyInto(src *Buffer, flags BufferCopyFlagsType, offset uint, size uint) bool { var carg0 *C.GstBuffer // in, none, converted var carg1 *C.GstBuffer // in, none, converted var carg2 C.GstBufferCopyFlags // in, none, casted var carg3 C.gsize // in, none, casted var carg4 C.gsize // in, none, casted var cret C.gboolean // return carg0 = (*C.GstBuffer)(UnsafeBufferToGlibNone(dest)) carg1 = (*C.GstBuffer)(UnsafeBufferToGlibNone(src)) carg2 = C.GstBufferCopyFlags(flags) carg3 = C.gsize(offset) carg4 = C.gsize(size) cret = C.gst_buffer_copy_into(carg0, carg1, carg2, carg3, carg4) runtime.KeepAlive(dest) runtime.KeepAlive(src) runtime.KeepAlive(flags) runtime.KeepAlive(offset) runtime.KeepAlive(size) var goret bool if cret != 0 { goret = true } return goret } // CopyRegion wraps gst_buffer_copy_region // // The function takes the following parameters: // // - flags BufferCopyFlagsType: the #GstBufferCopyFlags // - offset uint: the offset into parent #GstBuffer at which the new sub-buffer // begins. // - size uint: the size of the new #GstBuffer sub-buffer, in bytes. If -1, all // data is copied. // // The function returns the following values: // // - goret *Buffer (nullable) // // Creates a sub-buffer from @parent at @offset and @size. // This sub-buffer uses the actual memory space of the parent buffer. // This function will copy the offset and timestamp fields when the // offset is 0. If not, they will be set to #GST_CLOCK_TIME_NONE and // #GST_BUFFER_OFFSET_NONE. // If @offset equals 0 and @size equals the total size of @buffer, the // duration and offset end fields are also copied. If not they will be set // to #GST_CLOCK_TIME_NONE and #GST_BUFFER_OFFSET_NONE. func (parent *Buffer) CopyRegion(flags BufferCopyFlagsType, offset uint, size uint) *Buffer { var carg0 *C.GstBuffer // in, none, converted var carg1 C.GstBufferCopyFlags // in, none, casted var carg2 C.gsize // in, none, casted var carg3 C.gsize // in, none, casted var cret *C.GstBuffer // return, full, converted, nullable carg0 = (*C.GstBuffer)(UnsafeBufferToGlibNone(parent)) carg1 = C.GstBufferCopyFlags(flags) carg2 = C.gsize(offset) carg3 = C.gsize(size) cret = C.gst_buffer_copy_region(carg0, carg1, carg2, carg3) runtime.KeepAlive(parent) runtime.KeepAlive(flags) runtime.KeepAlive(offset) runtime.KeepAlive(size) var goret *Buffer if cret != nil { goret = UnsafeBufferFromGlibFull(unsafe.Pointer(cret)) } return goret } // FindMemory wraps gst_buffer_find_memory // // The function takes the following parameters: // // - offset uint: an offset // - size uint: a size // // The function returns the following values: // // - idx uint: pointer to index // - length uint: pointer to length // - skip uint: pointer to skip // - goret bool // // Finds the memory blocks that span @size bytes starting from @offset // in @buffer. // // When this function returns %TRUE, @idx will contain the index of the first // memory block where the byte for @offset can be found and @length contains the // number of memory blocks containing the @size remaining bytes. @skip contains // the number of bytes to skip in the memory block at @idx to get to the byte // for @offset. // // @size can be -1 to get all the memory blocks after @idx. func (buffer *Buffer) FindMemory(offset uint, size uint) (uint, uint, uint, bool) { var carg0 *C.GstBuffer // in, none, converted var carg1 C.gsize // in, none, casted var carg2 C.gsize // in, none, casted var carg3 C.guint // out, full, casted var carg4 C.guint // out, full, casted var carg5 C.gsize // out, full, casted var cret C.gboolean // return carg0 = (*C.GstBuffer)(UnsafeBufferToGlibNone(buffer)) carg1 = C.gsize(offset) carg2 = C.gsize(size) cret = C.gst_buffer_find_memory(carg0, carg1, carg2, &carg3, &carg4, &carg5) runtime.KeepAlive(buffer) runtime.KeepAlive(offset) runtime.KeepAlive(size) var idx uint var length uint var skip uint var goret bool idx = uint(carg3) length = uint(carg4) skip = uint(carg5) if cret != 0 { goret = true } return idx, length, skip, goret } // ForEachMeta wraps gst_buffer_foreach_meta // // The function takes the following parameters: // // - fn BufferForEachMetaFunc: a #GstBufferForeachMetaFunc to call // // The function returns the following values: // // - goret bool // // Calls @func with @user_data for each meta in @buffer. // // @func can modify the passed meta pointer or its contents. The return value // of @func defines if this function returns or if the remaining metadata items // in the buffer should be skipped. func (buffer *Buffer) ForEachMeta(fn BufferForEachMetaFunc) bool { var carg0 *C.GstBuffer // in, none, converted var carg1 C.GstBufferForeachMetaFunc // callback, scope: call, closure: carg2 var carg2 C.gpointer // implicit var cret C.gboolean // return carg0 = (*C.GstBuffer)(UnsafeBufferToGlibNone(buffer)) carg1 = (*[0]byte)(C._gotk4_gst1_BufferForEachMetaFunc) carg2 = C.gpointer(userdata.Register(fn)) defer userdata.Delete(unsafe.Pointer(carg2)) cret = C.gst_buffer_foreach_meta(carg0, carg1, carg2) runtime.KeepAlive(buffer) runtime.KeepAlive(fn) var goret bool if cret != 0 { goret = true } return goret } // GetAllMemory wraps gst_buffer_get_all_memory // // The function returns the following values: // // - goret *Memory (nullable) // // Gets all the memory blocks in @buffer. The memory blocks will be merged // into one large #GstMemory. func (buffer *Buffer) GetAllMemory() *Memory { var carg0 *C.GstBuffer // in, none, converted var cret *C.GstMemory // return, full, converted, nullable carg0 = (*C.GstBuffer)(UnsafeBufferToGlibNone(buffer)) cret = C.gst_buffer_get_all_memory(carg0) runtime.KeepAlive(buffer) var goret *Memory if cret != nil { goret = UnsafeMemoryFromGlibFull(unsafe.Pointer(cret)) } return goret } // GetCustomMeta wraps gst_buffer_get_custom_meta // // The function takes the following parameters: // // - name string: the registered name of the custom meta to retrieve. // // The function returns the following values: // // - goret *CustomMeta (nullable) // // Finds the first #GstCustomMeta on @buffer for the desired @name. func (buffer *Buffer) GetCustomMeta(name string) *CustomMeta { var carg0 *C.GstBuffer // in, none, converted var carg1 *C.gchar // in, none, string var cret *C.GstCustomMeta // return, none, converted, nullable carg0 = (*C.GstBuffer)(UnsafeBufferToGlibNone(buffer)) carg1 = (*C.gchar)(unsafe.Pointer(C.CString(name))) defer C.free(unsafe.Pointer(carg1)) cret = C.gst_buffer_get_custom_meta(carg0, carg1) runtime.KeepAlive(buffer) runtime.KeepAlive(name) var goret *CustomMeta if cret != nil { goret = UnsafeCustomMetaFromGlibNone(unsafe.Pointer(cret)) } return goret } // GetFlags wraps gst_buffer_get_flags // // The function returns the following values: // // - goret BufferFlags // // Gets the #GstBufferFlags flags set on this buffer. func (buffer *Buffer) GetFlags() BufferFlags { var carg0 *C.GstBuffer // in, none, converted var cret C.GstBufferFlags // return, none, casted carg0 = (*C.GstBuffer)(UnsafeBufferToGlibNone(buffer)) cret = C.gst_buffer_get_flags(carg0) runtime.KeepAlive(buffer) var goret BufferFlags goret = BufferFlags(cret) return goret } // GetMemory wraps gst_buffer_get_memory // // The function takes the following parameters: // // - idx uint: an index // // The function returns the following values: // // - goret *Memory (nullable) // // Gets the memory block at index @idx in @buffer. func (buffer *Buffer) GetMemory(idx uint) *Memory { var carg0 *C.GstBuffer // in, none, converted var carg1 C.guint // in, none, casted var cret *C.GstMemory // return, full, converted, nullable carg0 = (*C.GstBuffer)(UnsafeBufferToGlibNone(buffer)) carg1 = C.guint(idx) cret = C.gst_buffer_get_memory(carg0, carg1) runtime.KeepAlive(buffer) runtime.KeepAlive(idx) var goret *Memory if cret != nil { goret = UnsafeMemoryFromGlibFull(unsafe.Pointer(cret)) } return goret } // GetMemoryRange wraps gst_buffer_get_memory_range // // The function takes the following parameters: // // - idx uint: an index // - length int: a length // // The function returns the following values: // // - goret *Memory (nullable) // // Gets @length memory blocks in @buffer starting at @idx. The memory blocks will // be merged into one large #GstMemory. // // If @length is -1, all memory starting from @idx is merged. func (buffer *Buffer) GetMemoryRange(idx uint, length int) *Memory { var carg0 *C.GstBuffer // in, none, converted var carg1 C.guint // in, none, casted var carg2 C.gint // in, none, casted var cret *C.GstMemory // return, full, converted, nullable carg0 = (*C.GstBuffer)(UnsafeBufferToGlibNone(buffer)) carg1 = C.guint(idx) carg2 = C.gint(length) cret = C.gst_buffer_get_memory_range(carg0, carg1, carg2) runtime.KeepAlive(buffer) runtime.KeepAlive(idx) runtime.KeepAlive(length) var goret *Memory if cret != nil { goret = UnsafeMemoryFromGlibFull(unsafe.Pointer(cret)) } return goret } // GetMeta wraps gst_buffer_get_meta // // The function takes the following parameters: // // - api gobject.Type: the #GType of an API // // The function returns the following values: // // - goret *Meta (nullable) // // Gets the metadata for @api on buffer. When there is no such metadata, %NULL is // returned. If multiple metadata with the given @api are attached to this // buffer only the first one is returned. To handle multiple metadata with a // given API use gst_buffer_iterate_meta() or gst_buffer_foreach_meta() instead // and check the `meta->info.api` member for the API type. func (buffer *Buffer) GetMeta(api gobject.Type) *Meta { var carg0 *C.GstBuffer // in, none, converted var carg1 C.GType // in, none, casted, alias var cret *C.GstMeta // return, none, converted, nullable carg0 = (*C.GstBuffer)(UnsafeBufferToGlibNone(buffer)) carg1 = C.GType(api) cret = C.gst_buffer_get_meta(carg0, carg1) runtime.KeepAlive(buffer) runtime.KeepAlive(api) var goret *Meta if cret != nil { goret = UnsafeMetaFromGlibNone(unsafe.Pointer(cret)) } return goret } // GetNMeta wraps gst_buffer_get_n_meta // // The function takes the following parameters: // // - apiType gobject.Type: the #GType of an API // // The function returns the following values: // // - goret uint func (buffer *Buffer) GetNMeta(apiType gobject.Type) uint { var carg0 *C.GstBuffer // in, none, converted var carg1 C.GType // in, none, casted, alias var cret C.guint // return, none, casted carg0 = (*C.GstBuffer)(UnsafeBufferToGlibNone(buffer)) carg1 = C.GType(apiType) cret = C.gst_buffer_get_n_meta(carg0, carg1) runtime.KeepAlive(buffer) runtime.KeepAlive(apiType) var goret uint goret = uint(cret) return goret } // GetReferenceTimestampMeta wraps gst_buffer_get_reference_timestamp_meta // // The function takes the following parameters: // // - reference *Caps (nullable): a reference #GstCaps // // The function returns the following values: // // - goret *ReferenceTimestampMeta (nullable) // // Finds the first #GstReferenceTimestampMeta on @buffer that conforms to // @reference. Conformance is tested by checking if the meta's reference is a // subset of @reference. // // Buffers can contain multiple #GstReferenceTimestampMeta metadata items. func (buffer *Buffer) GetReferenceTimestampMeta(reference *Caps) *ReferenceTimestampMeta { var carg0 *C.GstBuffer // in, none, converted var carg1 *C.GstCaps // in, none, converted, nullable var cret *C.GstReferenceTimestampMeta // return, none, converted, nullable carg0 = (*C.GstBuffer)(UnsafeBufferToGlibNone(buffer)) if reference != nil { carg1 = (*C.GstCaps)(UnsafeCapsToGlibNone(reference)) } cret = C.gst_buffer_get_reference_timestamp_meta(carg0, carg1) runtime.KeepAlive(buffer) runtime.KeepAlive(reference) var goret *ReferenceTimestampMeta if cret != nil { goret = UnsafeReferenceTimestampMetaFromGlibNone(unsafe.Pointer(cret)) } return goret } // GetSize wraps gst_buffer_get_size // // The function returns the following values: // // - goret uint // // Gets the total size of the memory blocks in @buffer. func (buffer *Buffer) GetSize() uint { var carg0 *C.GstBuffer // in, none, converted var cret C.gsize // return, none, casted carg0 = (*C.GstBuffer)(UnsafeBufferToGlibNone(buffer)) cret = C.gst_buffer_get_size(carg0) runtime.KeepAlive(buffer) var goret uint goret = uint(cret) return goret } // GetSizes wraps gst_buffer_get_sizes // // The function returns the following values: // // - offset uint: a pointer to the offset // - maxsize uint: a pointer to the maxsize // - goret uint // // Gets the total size of the memory blocks in @buffer. // // When not %NULL, @offset will contain the offset of the data in the // first memory block in @buffer and @maxsize will contain the sum of // the size and @offset and the amount of extra padding on the last // memory block. @offset and @maxsize can be used to resize the // buffer memory blocks with gst_buffer_resize(). func (buffer *Buffer) GetSizes() (uint, uint, uint) { var carg0 *C.GstBuffer // in, none, converted var carg1 C.gsize // out, full, casted var carg2 C.gsize // out, full, casted var cret C.gsize // return, none, casted carg0 = (*C.GstBuffer)(UnsafeBufferToGlibNone(buffer)) cret = C.gst_buffer_get_sizes(carg0, &carg1, &carg2) runtime.KeepAlive(buffer) var offset uint var maxsize uint var goret uint offset = uint(carg1) maxsize = uint(carg2) goret = uint(cret) return offset, maxsize, goret } // GetSizesRange wraps gst_buffer_get_sizes_range // // The function takes the following parameters: // // - idx uint: an index // - length int: a length // // The function returns the following values: // // - offset uint: a pointer to the offset // - maxsize uint: a pointer to the maxsize // - goret uint // // Gets the total size of @length memory blocks stating from @idx in @buffer. // // When not %NULL, @offset will contain the offset of the data in the // memory block in @buffer at @idx and @maxsize will contain the sum of the size // and @offset and the amount of extra padding on the memory block at @idx + // @length -1. // @offset and @maxsize can be used to resize the buffer memory blocks with // gst_buffer_resize_range(). func (buffer *Buffer) GetSizesRange(idx uint, length int) (uint, uint, uint) { var carg0 *C.GstBuffer // in, none, converted var carg1 C.guint // in, none, casted var carg2 C.gint // in, none, casted var carg3 C.gsize // out, full, casted var carg4 C.gsize // out, full, casted var cret C.gsize // return, none, casted carg0 = (*C.GstBuffer)(UnsafeBufferToGlibNone(buffer)) carg1 = C.guint(idx) carg2 = C.gint(length) cret = C.gst_buffer_get_sizes_range(carg0, carg1, carg2, &carg3, &carg4) runtime.KeepAlive(buffer) runtime.KeepAlive(idx) runtime.KeepAlive(length) var offset uint var maxsize uint var goret uint offset = uint(carg3) maxsize = uint(carg4) goret = uint(cret) return offset, maxsize, goret } // HasFlags wraps gst_buffer_has_flags // // The function takes the following parameters: // // - flags BufferFlags: the #GstBufferFlags flag to check. // // The function returns the following values: // // - goret bool // // Gives the status of a specific flag on a buffer. func (buffer *Buffer) HasFlags(flags BufferFlags) bool { var carg0 *C.GstBuffer // in, none, converted var carg1 C.GstBufferFlags // in, none, casted var cret C.gboolean // return carg0 = (*C.GstBuffer)(UnsafeBufferToGlibNone(buffer)) carg1 = C.GstBufferFlags(flags) cret = C.gst_buffer_has_flags(carg0, carg1) runtime.KeepAlive(buffer) runtime.KeepAlive(flags) var goret bool if cret != 0 { goret = true } return goret } // InsertMemory wraps gst_buffer_insert_memory // // The function takes the following parameters: // // - idx int: the index to add the memory at, or -1 to append it to the end // - mem *Memory: a #GstMemory. // // Inserts the memory block @mem into @buffer at @idx. This function takes ownership // of @mem and thus doesn't increase its refcount. // // Only gst_buffer_get_max_memory() can be added to a buffer. If more memory is // added, existing memory blocks will automatically be merged to make room for // the new memory. func (buffer *Buffer) InsertMemory(idx int, mem *Memory) { var carg0 *C.GstBuffer // in, none, converted var carg1 C.gint // in, none, casted var carg2 *C.GstMemory // in, full, converted carg0 = (*C.GstBuffer)(UnsafeBufferToGlibNone(buffer)) carg1 = C.gint(idx) carg2 = (*C.GstMemory)(UnsafeMemoryToGlibFull(mem)) C.gst_buffer_insert_memory(carg0, carg1, carg2) runtime.KeepAlive(buffer) runtime.KeepAlive(idx) runtime.KeepAlive(mem) } // IsAllMemoryWritable wraps gst_buffer_is_all_memory_writable // // The function returns the following values: // // - goret bool // // Checks if all memory blocks in @buffer are writable. // // Note that this function does not check if @buffer is writable, use // gst_buffer_is_writable() to check that if needed. func (buffer *Buffer) IsAllMemoryWritable() bool { var carg0 *C.GstBuffer // in, none, converted var cret C.gboolean // return carg0 = (*C.GstBuffer)(UnsafeBufferToGlibNone(buffer)) cret = C.gst_buffer_is_all_memory_writable(carg0) runtime.KeepAlive(buffer) var goret bool if cret != 0 { goret = true } return goret } // IsMemoryRangeWritable wraps gst_buffer_is_memory_range_writable // // The function takes the following parameters: // // - idx uint: an index // - length int: a length, should not be 0 // // The function returns the following values: // // - goret bool // // Checks if @length memory blocks in @buffer starting from @idx are writable. // // @length can be -1 to check all the memory blocks after @idx. // // Note that this function does not check if @buffer is writable, use // gst_buffer_is_writable() to check that if needed. func (buffer *Buffer) IsMemoryRangeWritable(idx uint, length int) bool { var carg0 *C.GstBuffer // in, none, converted var carg1 C.guint // in, none, casted var carg2 C.gint // in, none, casted var cret C.gboolean // return carg0 = (*C.GstBuffer)(UnsafeBufferToGlibNone(buffer)) carg1 = C.guint(idx) carg2 = C.gint(length) cret = C.gst_buffer_is_memory_range_writable(carg0, carg1, carg2) runtime.KeepAlive(buffer) runtime.KeepAlive(idx) runtime.KeepAlive(length) var goret bool if cret != 0 { goret = true } return goret } // Memset wraps gst_buffer_memset // // The function takes the following parameters: // // - offset uint: the offset in @buffer // - val uint8: the value to set // - size uint: the size to set // // The function returns the following values: // // - goret uint // // Fills @buf with @size bytes with @val starting from @offset. func (buffer *Buffer) Memset(offset uint, val uint8, size uint) uint { var carg0 *C.GstBuffer // in, none, converted var carg1 C.gsize // in, none, casted var carg2 C.guint8 // in, none, casted var carg3 C.gsize // in, none, casted var cret C.gsize // return, none, casted carg0 = (*C.GstBuffer)(UnsafeBufferToGlibNone(buffer)) carg1 = C.gsize(offset) carg2 = C.guint8(val) carg3 = C.gsize(size) cret = C.gst_buffer_memset(carg0, carg1, carg2, carg3) runtime.KeepAlive(buffer) runtime.KeepAlive(offset) runtime.KeepAlive(val) runtime.KeepAlive(size) var goret uint goret = uint(cret) return goret } // NMemory wraps gst_buffer_n_memory // // The function returns the following values: // // - goret uint // // Gets the amount of memory blocks that this buffer has. This amount is never // larger than what gst_buffer_get_max_memory() returns. func (buffer *Buffer) NMemory() uint { var carg0 *C.GstBuffer // in, none, converted var cret C.guint // return, none, casted carg0 = (*C.GstBuffer)(UnsafeBufferToGlibNone(buffer)) cret = C.gst_buffer_n_memory(carg0) runtime.KeepAlive(buffer) var goret uint goret = uint(cret) return goret } // PeekMemory wraps gst_buffer_peek_memory // // The function takes the following parameters: // // - idx uint: an index // // The function returns the following values: // // - goret *Memory (nullable) // // Gets the memory block at @idx in @buffer. The memory block stays valid until // the memory block in @buffer is removed, replaced or merged, typically with // any call that modifies the memory in @buffer. func (buffer *Buffer) PeekMemory(idx uint) *Memory { var carg0 *C.GstBuffer // in, none, converted var carg1 C.guint // in, none, casted var cret *C.GstMemory // return, borrow, converted, nullable carg0 = (*C.GstBuffer)(UnsafeBufferToGlibNone(buffer)) carg1 = C.guint(idx) cret = C.gst_buffer_peek_memory(carg0, carg1) runtime.KeepAlive(buffer) runtime.KeepAlive(idx) var goret *Memory if cret != nil { goret = UnsafeMemoryFromGlibBorrow(unsafe.Pointer(cret)) runtime.AddCleanup(goret, func(_ *Buffer) {}, buffer) } return goret } // PrependMemory wraps gst_buffer_prepend_memory // // The function takes the following parameters: // // - mem *Memory: a #GstMemory. // // Prepends the memory block @mem to @buffer. This function takes // ownership of @mem and thus doesn't increase its refcount. // // This function is identical to gst_buffer_insert_memory() with an index of 0. // See gst_buffer_insert_memory() for more details. func (buffer *Buffer) PrependMemory(mem *Memory) { var carg0 *C.GstBuffer // in, none, converted var carg1 *C.GstMemory // in, full, converted carg0 = (*C.GstBuffer)(UnsafeBufferToGlibNone(buffer)) carg1 = (*C.GstMemory)(UnsafeMemoryToGlibFull(mem)) C.gst_buffer_prepend_memory(carg0, carg1) runtime.KeepAlive(buffer) runtime.KeepAlive(mem) } // RemoveAllMemory wraps gst_buffer_remove_all_memory // // Removes all the memory blocks in @buffer. func (buffer *Buffer) RemoveAllMemory() { var carg0 *C.GstBuffer // in, none, converted carg0 = (*C.GstBuffer)(UnsafeBufferToGlibNone(buffer)) C.gst_buffer_remove_all_memory(carg0) runtime.KeepAlive(buffer) } // RemoveMemory wraps gst_buffer_remove_memory // // The function takes the following parameters: // // - idx uint: an index // // Removes the memory block in @b at index @i. func (buffer *Buffer) RemoveMemory(idx uint) { var carg0 *C.GstBuffer // in, none, converted var carg1 C.guint // in, none, casted carg0 = (*C.GstBuffer)(UnsafeBufferToGlibNone(buffer)) carg1 = C.guint(idx) C.gst_buffer_remove_memory(carg0, carg1) runtime.KeepAlive(buffer) runtime.KeepAlive(idx) } // RemoveMemoryRange wraps gst_buffer_remove_memory_range // // The function takes the following parameters: // // - idx uint: an index // - length int: a length // // Removes @length memory blocks in @buffer starting from @idx. // // @length can be -1, in which case all memory starting from @idx is removed. func (buffer *Buffer) RemoveMemoryRange(idx uint, length int) { var carg0 *C.GstBuffer // in, none, converted var carg1 C.guint // in, none, casted var carg2 C.gint // in, none, casted carg0 = (*C.GstBuffer)(UnsafeBufferToGlibNone(buffer)) carg1 = C.guint(idx) carg2 = C.gint(length) C.gst_buffer_remove_memory_range(carg0, carg1, carg2) runtime.KeepAlive(buffer) runtime.KeepAlive(idx) runtime.KeepAlive(length) } // RemoveMeta wraps gst_buffer_remove_meta // // The function takes the following parameters: // // - meta *Meta: a #GstMeta // // The function returns the following values: // // - goret bool // // Removes the metadata for @meta on @buffer. func (buffer *Buffer) RemoveMeta(meta *Meta) bool { var carg0 *C.GstBuffer // in, none, converted var carg1 *C.GstMeta // in, none, converted var cret C.gboolean // return carg0 = (*C.GstBuffer)(UnsafeBufferToGlibNone(buffer)) carg1 = (*C.GstMeta)(UnsafeMetaToGlibNone(meta)) cret = C.gst_buffer_remove_meta(carg0, carg1) runtime.KeepAlive(buffer) runtime.KeepAlive(meta) var goret bool if cret != 0 { goret = true } return goret } // ReplaceAllMemory wraps gst_buffer_replace_all_memory // // The function takes the following parameters: // // - mem *Memory: a #GstMemory // // Replaces all memory in @buffer with @mem. func (buffer *Buffer) ReplaceAllMemory(mem *Memory) { var carg0 *C.GstBuffer // in, none, converted var carg1 *C.GstMemory // in, full, converted carg0 = (*C.GstBuffer)(UnsafeBufferToGlibNone(buffer)) carg1 = (*C.GstMemory)(UnsafeMemoryToGlibFull(mem)) C.gst_buffer_replace_all_memory(carg0, carg1) runtime.KeepAlive(buffer) runtime.KeepAlive(mem) } // ReplaceMemory wraps gst_buffer_replace_memory // // The function takes the following parameters: // // - idx uint: an index // - mem *Memory: a #GstMemory // // Replaces the memory block at index @idx in @buffer with @mem. func (buffer *Buffer) ReplaceMemory(idx uint, mem *Memory) { var carg0 *C.GstBuffer // in, none, converted var carg1 C.guint // in, none, casted var carg2 *C.GstMemory // in, full, converted carg0 = (*C.GstBuffer)(UnsafeBufferToGlibNone(buffer)) carg1 = C.guint(idx) carg2 = (*C.GstMemory)(UnsafeMemoryToGlibFull(mem)) C.gst_buffer_replace_memory(carg0, carg1, carg2) runtime.KeepAlive(buffer) runtime.KeepAlive(idx) runtime.KeepAlive(mem) } // ReplaceMemoryRange wraps gst_buffer_replace_memory_range // // The function takes the following parameters: // // - idx uint: an index // - length int: a length, should not be 0 // - mem *Memory: a #GstMemory // // Replaces @length memory blocks in @buffer starting at @idx with @mem. // // If @length is -1, all memory starting from @idx will be removed and // replaced with @mem. // // @buffer should be writable. func (buffer *Buffer) ReplaceMemoryRange(idx uint, length int, mem *Memory) { var carg0 *C.GstBuffer // in, none, converted var carg1 C.guint // in, none, casted var carg2 C.gint // in, none, casted var carg3 *C.GstMemory // in, full, converted carg0 = (*C.GstBuffer)(UnsafeBufferToGlibNone(buffer)) carg1 = C.guint(idx) carg2 = C.gint(length) carg3 = (*C.GstMemory)(UnsafeMemoryToGlibFull(mem)) C.gst_buffer_replace_memory_range(carg0, carg1, carg2, carg3) runtime.KeepAlive(buffer) runtime.KeepAlive(idx) runtime.KeepAlive(length) runtime.KeepAlive(mem) } // Resize wraps gst_buffer_resize // // The function takes the following parameters: // // - offset int: the offset adjustment // - size int: the new size or -1 to just adjust the offset // // Sets the offset and total size of the memory blocks in @buffer. func (buffer *Buffer) Resize(offset int, size int) { var carg0 *C.GstBuffer // in, none, converted var carg1 C.gssize // in, none, casted var carg2 C.gssize // in, none, casted carg0 = (*C.GstBuffer)(UnsafeBufferToGlibNone(buffer)) carg1 = C.gssize(offset) carg2 = C.gssize(size) C.gst_buffer_resize(carg0, carg1, carg2) runtime.KeepAlive(buffer) runtime.KeepAlive(offset) runtime.KeepAlive(size) } // ResizeRange wraps gst_buffer_resize_range // // The function takes the following parameters: // // - idx uint: an index // - length int: a length // - offset int: the offset adjustment // - size int: the new size or -1 to just adjust the offset // // The function returns the following values: // // - goret bool // // Sets the total size of the @length memory blocks starting at @idx in // @buffer func (buffer *Buffer) ResizeRange(idx uint, length int, offset int, size int) bool { var carg0 *C.GstBuffer // in, none, converted var carg1 C.guint // in, none, casted var carg2 C.gint // in, none, casted var carg3 C.gssize // in, none, casted var carg4 C.gssize // in, none, casted var cret C.gboolean // return carg0 = (*C.GstBuffer)(UnsafeBufferToGlibNone(buffer)) carg1 = C.guint(idx) carg2 = C.gint(length) carg3 = C.gssize(offset) carg4 = C.gssize(size) cret = C.gst_buffer_resize_range(carg0, carg1, carg2, carg3, carg4) runtime.KeepAlive(buffer) runtime.KeepAlive(idx) runtime.KeepAlive(length) runtime.KeepAlive(offset) runtime.KeepAlive(size) var goret bool if cret != 0 { goret = true } return goret } // SetFlags wraps gst_buffer_set_flags // // The function takes the following parameters: // // - flags BufferFlags: the #GstBufferFlags to set. // // The function returns the following values: // // - goret bool // // Sets one or more buffer flags on a buffer. func (buffer *Buffer) SetFlags(flags BufferFlags) bool { var carg0 *C.GstBuffer // in, none, converted var carg1 C.GstBufferFlags // in, none, casted var cret C.gboolean // return carg0 = (*C.GstBuffer)(UnsafeBufferToGlibNone(buffer)) carg1 = C.GstBufferFlags(flags) cret = C.gst_buffer_set_flags(carg0, carg1) runtime.KeepAlive(buffer) runtime.KeepAlive(flags) var goret bool if cret != 0 { goret = true } return goret } // SetSize wraps gst_buffer_set_size // // The function takes the following parameters: // // - size int: the new size // // Sets the total size of the memory blocks in @buffer. func (buffer *Buffer) SetSize(size int) { var carg0 *C.GstBuffer // in, none, converted var carg1 C.gssize // in, none, casted carg0 = (*C.GstBuffer)(UnsafeBufferToGlibNone(buffer)) carg1 = C.gssize(size) C.gst_buffer_set_size(carg0, carg1) runtime.KeepAlive(buffer) runtime.KeepAlive(size) } // UnsetFlags wraps gst_buffer_unset_flags // // The function takes the following parameters: // // - flags BufferFlags: the #GstBufferFlags to clear // // The function returns the following values: // // - goret bool // // Clears one or more buffer flags. func (buffer *Buffer) UnsetFlags(flags BufferFlags) bool { var carg0 *C.GstBuffer // in, none, converted var carg1 C.GstBufferFlags // in, none, casted var cret C.gboolean // return carg0 = (*C.GstBuffer)(UnsafeBufferToGlibNone(buffer)) carg1 = C.GstBufferFlags(flags) cret = C.gst_buffer_unset_flags(carg0, carg1) runtime.KeepAlive(buffer) runtime.KeepAlive(flags) var goret bool if cret != 0 { goret = true } return goret } // BufferList wraps GstBufferList // // Buffer lists are an object containing a list of buffers. // // Buffer lists are created with gst_buffer_list_new() and filled with data // using gst_buffer_list_insert(). // // Buffer lists can be pushed on a srcpad with gst_pad_push_list(). This is // interesting when multiple buffers need to be pushed in one go because it // can reduce the amount of overhead for pushing each buffer individually. type BufferList struct { *bufferList } // bufferList is the struct that's finalized type bufferList struct { native *C.GstBufferList } var _ gobject.GoValueInitializer = (*BufferList)(nil) func marshalBufferList(p unsafe.Pointer) (interface{}, error) { b := gobject.ValueFromNative(p).Boxed() return UnsafeBufferListFromGlibBorrow(b), nil } func (r *BufferList) InitGoValue(v *gobject.Value) { v.Init(TypeBufferList) v.SetBoxed(unsafe.Pointer(r.native)) } // UnsafeBufferListFromGlibBorrow is used to convert raw C.GstBufferList pointers to go. This is used by the bindings internally. func UnsafeBufferListFromGlibBorrow(p unsafe.Pointer) *BufferList { return &BufferList{&bufferList{(*C.GstBufferList)(p)}} } // 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) runtime.SetFinalizer( wrapped.bufferList, func (intern *bufferList) { C.free(unsafe.Pointer(intern.native)) }, ) return wrapped } // 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( wrapped.bufferList, func (intern *bufferList) { C.free(unsafe.Pointer(intern.native)) }, ) return wrapped } // UnsafeBufferListFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [BufferList] is expected to work anymore. func UnsafeBufferListFree(b *BufferList) { C.free(unsafe.Pointer(b.native)) } // UnsafeBufferListToGlibNone returns the underlying C pointer. This is used by the bindings internally. func UnsafeBufferListToGlibNone(b *BufferList) unsafe.Pointer { return unsafe.Pointer(b.native) } // UnsafeBufferListToGlibFull returns the underlying C pointer and gives up ownership. // This is used by the bindings internally. func UnsafeBufferListToGlibFull(b *BufferList) unsafe.Pointer { runtime.SetFinalizer(b.bufferList, nil) _p := unsafe.Pointer(b.native) 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 // // Creates a new, empty #GstBufferList. func NewBufferList() *BufferList { var cret *C.GstBufferList // return, full, converted cret = C.gst_buffer_list_new() var goret *BufferList goret = UnsafeBufferListFromGlibFull(unsafe.Pointer(cret)) return goret } // NewBufferListSized wraps gst_buffer_list_new_sized // // The function takes the following parameters: // // - size uint: an initial reserved size // // The function returns the following values: // // - goret *BufferList // // Creates a new, empty #GstBufferList. The list will have @size space // preallocated so that memory reallocations can be avoided. func NewBufferListSized(size uint) *BufferList { var carg1 C.guint // in, none, casted var cret *C.GstBufferList // return, full, converted carg1 = C.guint(size) cret = C.gst_buffer_list_new_sized(carg1) runtime.KeepAlive(size) var goret *BufferList goret = UnsafeBufferListFromGlibFull(unsafe.Pointer(cret)) return goret } // CalculateSize wraps gst_buffer_list_calculate_size // // The function returns the following values: // // - goret uint // // Calculates the size of the data contained in @list by adding the // size of all buffers. func (list *BufferList) CalculateSize() uint { var carg0 *C.GstBufferList // in, none, converted var cret C.gsize // return, none, casted carg0 = (*C.GstBufferList)(UnsafeBufferListToGlibNone(list)) cret = C.gst_buffer_list_calculate_size(carg0) runtime.KeepAlive(list) var goret uint goret = uint(cret) return goret } // CopyDeep wraps gst_buffer_list_copy_deep // // The function returns the following values: // // - goret *BufferList // // Creates a copy of the given buffer list. This will make a newly allocated // copy of the buffers that the source buffer list contains. func (list *BufferList) CopyDeep() *BufferList { var carg0 *C.GstBufferList // in, none, converted var cret *C.GstBufferList // return, full, converted carg0 = (*C.GstBufferList)(UnsafeBufferListToGlibNone(list)) cret = C.gst_buffer_list_copy_deep(carg0) runtime.KeepAlive(list) var goret *BufferList goret = UnsafeBufferListFromGlibFull(unsafe.Pointer(cret)) return goret } // ForEach wraps gst_buffer_list_foreach // // The function takes the following parameters: // // - fn BufferListFunc: a #GstBufferListFunc to call // // The function returns the following values: // // - goret bool // // Calls @func with @data for each buffer in @list. // // @func can modify the passed buffer pointer or its contents. The return value // of @func defines if this function returns or if the remaining buffers in // the list should be skipped. func (list *BufferList) ForEach(fn BufferListFunc) bool { var carg0 *C.GstBufferList // in, none, converted var carg1 C.GstBufferListFunc // callback, scope: call, closure: carg2 var carg2 C.gpointer // implicit var cret C.gboolean // return carg0 = (*C.GstBufferList)(UnsafeBufferListToGlibNone(list)) carg1 = (*[0]byte)(C._gotk4_gst1_BufferListFunc) carg2 = C.gpointer(userdata.Register(fn)) defer userdata.Delete(unsafe.Pointer(carg2)) cret = C.gst_buffer_list_foreach(carg0, carg1, carg2) runtime.KeepAlive(list) runtime.KeepAlive(fn) var goret bool if cret != 0 { goret = true } return goret } // Get wraps gst_buffer_list_get // // The function takes the following parameters: // // - idx uint: the index // // The function returns the following values: // // - goret *Buffer (nullable) // // Gets the buffer at @idx. // // You must make sure that @idx does not exceed the number of // buffers available. func (list *BufferList) Get(idx uint) *Buffer { var carg0 *C.GstBufferList // in, none, converted var carg1 C.guint // in, none, casted var cret *C.GstBuffer // return, borrow, converted, nullable carg0 = (*C.GstBufferList)(UnsafeBufferListToGlibNone(list)) carg1 = C.guint(idx) cret = C.gst_buffer_list_get(carg0, carg1) runtime.KeepAlive(list) runtime.KeepAlive(idx) var goret *Buffer if cret != nil { goret = UnsafeBufferFromGlibBorrow(unsafe.Pointer(cret)) runtime.AddCleanup(goret, func(_ *BufferList) {}, list) } return goret } // GetWritable wraps gst_buffer_list_get_writable // // The function takes the following parameters: // // - idx uint: the index // // The function returns the following values: // // - goret *Buffer (nullable) // // Gets the buffer at @idx, ensuring it is a writable buffer. // // You must make sure that @idx does not exceed the number of // buffers available. func (list *BufferList) GetWritable(idx uint) *Buffer { var carg0 *C.GstBufferList // in, none, converted var carg1 C.guint // in, none, casted var cret *C.GstBuffer // return, borrow, converted, nullable carg0 = (*C.GstBufferList)(UnsafeBufferListToGlibNone(list)) carg1 = C.guint(idx) cret = C.gst_buffer_list_get_writable(carg0, carg1) runtime.KeepAlive(list) runtime.KeepAlive(idx) var goret *Buffer if cret != nil { goret = UnsafeBufferFromGlibBorrow(unsafe.Pointer(cret)) runtime.AddCleanup(goret, func(_ *BufferList) {}, list) } return goret } // Insert wraps gst_buffer_list_insert // // The function takes the following parameters: // // - idx int: the index // - buffer *Buffer: a #GstBuffer // // Inserts @buffer at @idx in @list. Other buffers are moved to make room for // this new buffer. // // A -1 value for @idx will append the buffer at the end. func (list *BufferList) Insert(idx int, buffer *Buffer) { var carg0 *C.GstBufferList // in, none, converted var carg1 C.gint // in, none, casted var carg2 *C.GstBuffer // in, full, converted carg0 = (*C.GstBufferList)(UnsafeBufferListToGlibNone(list)) carg1 = C.gint(idx) carg2 = (*C.GstBuffer)(UnsafeBufferToGlibFull(buffer)) C.gst_buffer_list_insert(carg0, carg1, carg2) runtime.KeepAlive(list) runtime.KeepAlive(idx) runtime.KeepAlive(buffer) } // Length wraps gst_buffer_list_length // // The function returns the following values: // // - goret uint // // Returns the number of buffers in @list. func (list *BufferList) Length() uint { var carg0 *C.GstBufferList // in, none, converted var cret C.guint // return, none, casted carg0 = (*C.GstBufferList)(UnsafeBufferListToGlibNone(list)) cret = C.gst_buffer_list_length(carg0) runtime.KeepAlive(list) var goret uint goret = uint(cret) return goret } // Remove wraps gst_buffer_list_remove // // The function takes the following parameters: // // - idx uint: the index // - length uint: the amount to remove // // Removes @length buffers starting from @idx in @list. The following buffers // are moved to close the gap. func (list *BufferList) Remove(idx uint, length uint) { var carg0 *C.GstBufferList // in, none, converted var carg1 C.guint // in, none, casted var carg2 C.guint // in, none, casted carg0 = (*C.GstBufferList)(UnsafeBufferListToGlibNone(list)) carg1 = C.guint(idx) carg2 = C.guint(length) C.gst_buffer_list_remove(carg0, carg1, carg2) runtime.KeepAlive(list) runtime.KeepAlive(idx) runtime.KeepAlive(length) } // BufferPoolAcquireParams wraps GstBufferPoolAcquireParams // // Parameters passed to the gst_buffer_pool_acquire_buffer() function to control the // allocation of the buffer. // // The default implementation ignores the @start and @stop members but other // implementations can use this extra information to decide what buffer to // return. type BufferPoolAcquireParams struct { *bufferPoolAcquireParams } // bufferPoolAcquireParams is the struct that's finalized type bufferPoolAcquireParams struct { native *C.GstBufferPoolAcquireParams } // UnsafeBufferPoolAcquireParamsFromGlibBorrow is used to convert raw C.GstBufferPoolAcquireParams pointers to go. This is used by the bindings internally. func UnsafeBufferPoolAcquireParamsFromGlibBorrow(p unsafe.Pointer) *BufferPoolAcquireParams { return &BufferPoolAcquireParams{&bufferPoolAcquireParams{(*C.GstBufferPoolAcquireParams)(p)}} } // 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) runtime.SetFinalizer( wrapped.bufferPoolAcquireParams, func (intern *bufferPoolAcquireParams) { C.free(unsafe.Pointer(intern.native)) }, ) return wrapped } // 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( wrapped.bufferPoolAcquireParams, func (intern *bufferPoolAcquireParams) { C.free(unsafe.Pointer(intern.native)) }, ) return wrapped } // UnsafeBufferPoolAcquireParamsFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [BufferPoolAcquireParams] is expected to work anymore. func UnsafeBufferPoolAcquireParamsFree(b *BufferPoolAcquireParams) { C.free(unsafe.Pointer(b.native)) } // UnsafeBufferPoolAcquireParamsToGlibNone returns the underlying C pointer. This is used by the bindings internally. func UnsafeBufferPoolAcquireParamsToGlibNone(b *BufferPoolAcquireParams) unsafe.Pointer { return unsafe.Pointer(b.native) } // UnsafeBufferPoolAcquireParamsToGlibFull returns the underlying C pointer and gives up ownership. // This is used by the bindings internally. func UnsafeBufferPoolAcquireParamsToGlibFull(b *BufferPoolAcquireParams) unsafe.Pointer { runtime.SetFinalizer(b.bufferPoolAcquireParams, nil) _p := unsafe.Pointer(b.native) 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 } // bufferPoolClass is the struct that's finalized type bufferPoolClass struct { native *C.GstBufferPoolClass } // UnsafeBufferPoolClassFromGlibBorrow is used to convert raw C.GstBufferPoolClass pointers to go. This is used by the bindings internally. func UnsafeBufferPoolClassFromGlibBorrow(p unsafe.Pointer) *BufferPoolClass { return &BufferPoolClass{&bufferPoolClass{(*C.GstBufferPoolClass)(p)}} } // 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. func UnsafeBufferPoolClassFree(b *BufferPoolClass) { C.free(unsafe.Pointer(b.native)) } // UnsafeBufferPoolClassToGlibNone returns the underlying C pointer. This is used by the bindings internally. func UnsafeBufferPoolClassToGlibNone(b *BufferPoolClass) unsafe.Pointer { return unsafe.Pointer(b.native) } // 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 } // busClass is the struct that's finalized type busClass struct { native *C.GstBusClass } // UnsafeBusClassFromGlibBorrow is used to convert raw C.GstBusClass pointers to go. This is used by the bindings internally. func UnsafeBusClassFromGlibBorrow(p unsafe.Pointer) *BusClass { return &BusClass{&busClass{(*C.GstBusClass)(p)}} } // 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. func UnsafeBusClassFree(b *BusClass) { C.free(unsafe.Pointer(b.native)) } // UnsafeBusClassToGlibNone returns the underlying C pointer. This is used by the bindings internally. func UnsafeBusClassToGlibNone(b *BusClass) unsafe.Pointer { return unsafe.Pointer(b.native) } // 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 // @resize virtual method using language native array implementation, such as // GLib's #GByteArray, C++'s `std::vector<uint8_t>` or Rust's `Vec<u8>`. // // @resize implementation could allocate more than requested to avoid repeated // reallocations. It can return %FALSE, or be set to %NULL, in the case the // array cannot grow. type ByteArrayInterface struct { *byteArrayInterface } // byteArrayInterface is the struct that's finalized type byteArrayInterface struct { native *C.GstByteArrayInterface } // UnsafeByteArrayInterfaceFromGlibBorrow is used to convert raw C.GstByteArrayInterface pointers to go. This is used by the bindings internally. func UnsafeByteArrayInterfaceFromGlibBorrow(p unsafe.Pointer) *ByteArrayInterface { return &ByteArrayInterface{&byteArrayInterface{(*C.GstByteArrayInterface)(p)}} } // 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) runtime.SetFinalizer( wrapped.byteArrayInterface, func (intern *byteArrayInterface) { C.free(unsafe.Pointer(intern.native)) }, ) return wrapped } // 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( wrapped.byteArrayInterface, func (intern *byteArrayInterface) { C.free(unsafe.Pointer(intern.native)) }, ) return wrapped } // UnsafeByteArrayInterfaceFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [ByteArrayInterface] is expected to work anymore. func UnsafeByteArrayInterfaceFree(b *ByteArrayInterface) { C.free(unsafe.Pointer(b.native)) } // UnsafeByteArrayInterfaceToGlibNone returns the underlying C pointer. This is used by the bindings internally. func UnsafeByteArrayInterfaceToGlibNone(b *ByteArrayInterface) unsafe.Pointer { return unsafe.Pointer(b.native) } // UnsafeByteArrayInterfaceToGlibFull returns the underlying C pointer and gives up ownership. // This is used by the bindings internally. func UnsafeByteArrayInterfaceToGlibFull(b *ByteArrayInterface) unsafe.Pointer { runtime.SetFinalizer(b.byteArrayInterface, nil) _p := unsafe.Pointer(b.native) b.native = nil // ByteArrayInterface is invalid from here on return _p } // Caps wraps GstCaps // // Caps (capabilities) are lightweight refcounted objects describing media types. // They are composed of an array of #GstStructure. // // Caps are exposed on #GstPadTemplate to describe all possible types a // given pad can handle. They are also stored in the #GstRegistry along with // a description of the #GstElement. // // Caps are exposed on the element pads using the gst_pad_query_caps() pad // function. This function describes the possible types that the pad can // handle or produce at runtime. // // A #GstCaps can be constructed with the following code fragment: // // ``` C // GstCaps *caps = gst_caps_new_simple ("video/x-raw", // "format", G_TYPE_STRING, "I420", // "framerate", GST_TYPE_FRACTION, 25, 1, // "pixel-aspect-ratio", GST_TYPE_FRACTION, 1, 1, // "width", G_TYPE_INT, 320, // "height", G_TYPE_INT, 240, // NULL); // ``` // // A #GstCaps is fixed when it has no fields with ranges or lists. Use // gst_caps_is_fixed() to test for fixed caps. Fixed caps can be used in a // caps event to notify downstream elements of the current media type. // // Various methods exist to work with the media types such as subtracting // or intersecting. // // Be aware that until 1.20 the #GstCaps / #GstStructure serialization into string // had limited support for nested #GstCaps / #GstStructure fields. It could only // support one level of nesting. Using more levels would lead to unexpected // behavior when using serialization features, such as gst_caps_to_string() or // gst_value_serialize() and their counterparts. type Caps struct { *caps } // caps is the struct that's finalized type caps struct { native *C.GstCaps } var _ gobject.GoValueInitializer = (*Caps)(nil) func marshalCaps(p unsafe.Pointer) (interface{}, error) { b := gobject.ValueFromNative(p).Boxed() return UnsafeCapsFromGlibBorrow(b), nil } func (r *Caps) InitGoValue(v *gobject.Value) { v.Init(TypeCaps) v.SetBoxed(unsafe.Pointer(r.native)) } // UnsafeCapsFromGlibBorrow is used to convert raw C.GstCaps pointers to go. This is used by the bindings internally. func UnsafeCapsFromGlibBorrow(p unsafe.Pointer) *Caps { return &Caps{&caps{(*C.GstCaps)(p)}} } // 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) runtime.SetFinalizer( wrapped.caps, func (intern *caps) { C.free(unsafe.Pointer(intern.native)) }, ) return wrapped } // 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( wrapped.caps, func (intern *caps) { C.free(unsafe.Pointer(intern.native)) }, ) return wrapped } // UnsafeCapsFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [Caps] is expected to work anymore. func UnsafeCapsFree(c *Caps) { C.free(unsafe.Pointer(c.native)) } // UnsafeCapsToGlibNone returns the underlying C pointer. This is used by the bindings internally. func UnsafeCapsToGlibNone(c *Caps) unsafe.Pointer { return unsafe.Pointer(c.native) } // UnsafeCapsToGlibFull returns the underlying C pointer and gives up ownership. // This is used by the bindings internally. func UnsafeCapsToGlibFull(c *Caps) unsafe.Pointer { runtime.SetFinalizer(c.caps, nil) _p := unsafe.Pointer(c.native) 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 // // Creates a new #GstCaps that indicates that it is compatible with // any media format. func NewCapsAny() *Caps { var cret *C.GstCaps // return, full, converted cret = C.gst_caps_new_any() var goret *Caps goret = UnsafeCapsFromGlibFull(unsafe.Pointer(cret)) return goret } // NewCapsEmpty wraps gst_caps_new_empty // // The function returns the following values: // // - goret *Caps // // Creates a new #GstCaps that is empty. That is, the returned // #GstCaps contains no media formats. // The #GstCaps is guaranteed to be writable. func NewCapsEmpty() *Caps { var cret *C.GstCaps // return, full, converted cret = C.gst_caps_new_empty() var goret *Caps goret = UnsafeCapsFromGlibFull(unsafe.Pointer(cret)) return goret } // NewCapsEmptySimple wraps gst_caps_new_empty_simple // // The function takes the following parameters: // // - mediaType string: the media type of the structure // // The function returns the following values: // // - goret *Caps // // Creates a new #GstCaps that contains one #GstStructure with name // @media_type. func NewCapsEmptySimple(mediaType string) *Caps { var carg1 *C.char // in, none, string, casted *C.gchar var cret *C.GstCaps // return, full, converted carg1 = (*C.char)(unsafe.Pointer(C.CString(mediaType))) defer C.free(unsafe.Pointer(carg1)) cret = C.gst_caps_new_empty_simple(carg1) runtime.KeepAlive(mediaType) var goret *Caps goret = UnsafeCapsFromGlibFull(unsafe.Pointer(cret)) return goret } // CapsFromString wraps gst_caps_from_string // // The function takes the following parameters: // // - str string: a string to convert to #GstCaps // // The function returns the following values: // // - goret *Caps (nullable) // // Converts @caps from a string representation. // // The implementation of serialization up to 1.20 would lead to unexpected results // when there were nested #GstCaps / #GstStructure deeper than one level. func CapsFromString(str string) *Caps { var carg1 *C.gchar // in, none, string var cret *C.GstCaps // return, full, converted, nullable carg1 = (*C.gchar)(unsafe.Pointer(C.CString(str))) defer C.free(unsafe.Pointer(carg1)) cret = C.gst_caps_from_string(carg1) runtime.KeepAlive(str) var goret *Caps if cret != nil { goret = UnsafeCapsFromGlibFull(unsafe.Pointer(cret)) } return goret } // Append wraps gst_caps_append // // The function takes the following parameters: // // - caps2 *Caps: the #GstCaps to append // // Appends the structures contained in @caps2 to @caps1. The structures in // @caps2 are not copied -- they are transferred to @caps1, and then @caps2 is // freed. If either caps is ANY, the resulting caps will be ANY. func (caps1 *Caps) Append(caps2 *Caps) { var carg0 *C.GstCaps // in, none, converted var carg1 *C.GstCaps // in, full, converted carg0 = (*C.GstCaps)(UnsafeCapsToGlibNone(caps1)) carg1 = (*C.GstCaps)(UnsafeCapsToGlibFull(caps2)) C.gst_caps_append(carg0, carg1) runtime.KeepAlive(caps1) runtime.KeepAlive(caps2) } // AppendStructure wraps gst_caps_append_structure // // The function takes the following parameters: // // - structure *Structure: the #GstStructure to append // // Appends @structure to @caps. The structure is not copied; @caps // becomes the owner of @structure. func (caps *Caps) AppendStructure(structure *Structure) { var carg0 *C.GstCaps // in, none, converted var carg1 *C.GstStructure // in, full, converted carg0 = (*C.GstCaps)(UnsafeCapsToGlibNone(caps)) carg1 = (*C.GstStructure)(UnsafeStructureToGlibFull(structure)) C.gst_caps_append_structure(carg0, carg1) runtime.KeepAlive(caps) runtime.KeepAlive(structure) } // AppendStructureFull wraps gst_caps_append_structure_full // // The function takes the following parameters: // // - structure *Structure: the #GstStructure to append // - features *CapsFeatures (nullable): the #GstCapsFeatures to append // // Appends @structure with @features to @caps. The structure is not copied; @caps // becomes the owner of @structure. func (caps *Caps) AppendStructureFull(structure *Structure, features *CapsFeatures) { var carg0 *C.GstCaps // in, none, converted var carg1 *C.GstStructure // in, full, converted var carg2 *C.GstCapsFeatures // in, full, converted, nullable carg0 = (*C.GstCaps)(UnsafeCapsToGlibNone(caps)) carg1 = (*C.GstStructure)(UnsafeStructureToGlibFull(structure)) if features != nil { carg2 = (*C.GstCapsFeatures)(UnsafeCapsFeaturesToGlibFull(features)) } C.gst_caps_append_structure_full(carg0, carg1, carg2) runtime.KeepAlive(caps) runtime.KeepAlive(structure) runtime.KeepAlive(features) } // CanIntersect wraps gst_caps_can_intersect // // The function takes the following parameters: // // - caps2 *Caps: a #GstCaps to intersect // // The function returns the following values: // // - goret bool // // Tries intersecting @caps1 and @caps2 and reports whether the result would not // be empty func (caps1 *Caps) CanIntersect(caps2 *Caps) bool { var carg0 *C.GstCaps // in, none, converted var carg1 *C.GstCaps // in, none, converted var cret C.gboolean // return carg0 = (*C.GstCaps)(UnsafeCapsToGlibNone(caps1)) carg1 = (*C.GstCaps)(UnsafeCapsToGlibNone(caps2)) cret = C.gst_caps_can_intersect(carg0, carg1) runtime.KeepAlive(caps1) runtime.KeepAlive(caps2) var goret bool if cret != 0 { goret = true } return goret } // Copy wraps gst_caps_copy // // The function returns the following values: // // - goret *Caps // // Creates a new #GstCaps as a copy of the old @caps. The new caps will have a // refcount of 1, owned by the caller. The structures are copied as well. // // Note that this function is the semantic equivalent of a gst_caps_ref() // followed by a gst_caps_make_writable(). If you only want to hold on to a // reference to the data, you should use gst_caps_ref(). func (caps *Caps) Copy() *Caps { var carg0 *C.GstCaps // in, none, converted var cret *C.GstCaps // return, full, converted carg0 = (*C.GstCaps)(UnsafeCapsToGlibNone(caps)) cret = C.gst_caps_copy(carg0) runtime.KeepAlive(caps) var goret *Caps goret = UnsafeCapsFromGlibFull(unsafe.Pointer(cret)) return goret } // CopyNth wraps gst_caps_copy_nth // // The function takes the following parameters: // // - nth uint: the nth structure to copy // // The function returns the following values: // // - goret *Caps // // Creates a new #GstCaps and appends a copy of the nth structure // contained in @caps. func (caps *Caps) CopyNth(nth uint) *Caps { var carg0 *C.GstCaps // in, none, converted var carg1 C.guint // in, none, casted var cret *C.GstCaps // return, full, converted carg0 = (*C.GstCaps)(UnsafeCapsToGlibNone(caps)) carg1 = C.guint(nth) cret = C.gst_caps_copy_nth(carg0, carg1) runtime.KeepAlive(caps) runtime.KeepAlive(nth) var goret *Caps goret = UnsafeCapsFromGlibFull(unsafe.Pointer(cret)) return goret } // FilterAndMapInPlace wraps gst_caps_filter_and_map_in_place // // The function takes the following parameters: // // - fn CapsFilterMapFunc: a function to call for each field // // Calls the provided function once for each structure and caps feature in the // #GstCaps. In contrast to gst_caps_foreach(), the function may modify the // structure and features. In contrast to gst_caps_map_in_place(), the structure // and features are removed from the caps if %FALSE is returned from the // function. The caps must be mutable. func (caps *Caps) FilterAndMapInPlace(fn CapsFilterMapFunc) { var carg0 *C.GstCaps // in, none, converted var carg1 C.GstCapsFilterMapFunc // callback, scope: call, closure: carg2 var carg2 C.gpointer // implicit carg0 = (*C.GstCaps)(UnsafeCapsToGlibNone(caps)) carg1 = (*[0]byte)(C._gotk4_gst1_CapsFilterMapFunc) carg2 = C.gpointer(userdata.Register(fn)) defer userdata.Delete(unsafe.Pointer(carg2)) C.gst_caps_filter_and_map_in_place(carg0, carg1, carg2) runtime.KeepAlive(caps) runtime.KeepAlive(fn) } // Fixate wraps gst_caps_fixate // // The function returns the following values: // // - goret *Caps // // Modifies the given @caps into a representation with only fixed // values. First the caps will be truncated and then the first structure will be // fixated with gst_structure_fixate(). // // This function takes ownership of @caps and will call gst_caps_make_writable() // on it so you must not use @caps afterwards unless you keep an additional // reference to it with gst_caps_ref(). // // Note that it is not guaranteed that the returned caps have exactly one // structure. If @caps are empty caps then the returned caps will be // the empty too and contain no structure at all. // // Calling this function with ANY caps is not allowed. func (caps *Caps) Fixate() *Caps { var carg0 *C.GstCaps // in, none, converted var cret *C.GstCaps // return, full, converted carg0 = (*C.GstCaps)(UnsafeCapsToGlibNone(caps)) cret = C.gst_caps_fixate(carg0) runtime.KeepAlive(caps) var goret *Caps goret = UnsafeCapsFromGlibFull(unsafe.Pointer(cret)) return goret } // ForEach wraps gst_caps_foreach // // The function takes the following parameters: // // - fn CapsForEachFunc: a function to call for each field // // The function returns the following values: // // - goret bool // // Calls the provided function once for each structure and caps feature in the // #GstCaps. The function must not modify the fields. // Also see gst_caps_map_in_place() and gst_caps_filter_and_map_in_place(). func (caps *Caps) ForEach(fn CapsForEachFunc) bool { var carg0 *C.GstCaps // in, none, converted var carg1 C.GstCapsForeachFunc // callback, scope: call, closure: carg2 var carg2 C.gpointer // implicit var cret C.gboolean // return carg0 = (*C.GstCaps)(UnsafeCapsToGlibNone(caps)) carg1 = (*[0]byte)(C._gotk4_gst1_CapsForEachFunc) carg2 = C.gpointer(userdata.Register(fn)) defer userdata.Delete(unsafe.Pointer(carg2)) cret = C.gst_caps_foreach(carg0, carg1, carg2) runtime.KeepAlive(caps) runtime.KeepAlive(fn) var goret bool if cret != 0 { goret = true } return goret } // GetFeatures wraps gst_caps_get_features // // The function takes the following parameters: // // - index uint: the index of the structure // // The function returns the following values: // // - goret *CapsFeatures (nullable) // // Finds the features in @caps at @index, and returns it. // // WARNING: This function takes a `const GstCaps *`, but returns a // non-const `GstCapsFeatures *`. This is for programming convenience -- // the caller should be aware that features inside a constant // #GstCaps should not be modified. However, if you know the caps // are writable, either because you have just copied them or made // them writable with gst_caps_make_writable(), you may modify the // features returned in the usual way, e.g. with functions like // gst_caps_features_add(). func (caps *Caps) GetFeatures(index uint) *CapsFeatures { var carg0 *C.GstCaps // in, none, converted var carg1 C.guint // in, none, casted var cret *C.GstCapsFeatures // return, none, converted, nullable carg0 = (*C.GstCaps)(UnsafeCapsToGlibNone(caps)) carg1 = C.guint(index) cret = C.gst_caps_get_features(carg0, carg1) runtime.KeepAlive(caps) runtime.KeepAlive(index) var goret *CapsFeatures if cret != nil { goret = UnsafeCapsFeaturesFromGlibNone(unsafe.Pointer(cret)) } return goret } // GetSize wraps gst_caps_get_size // // The function returns the following values: // // - goret uint // // Gets the number of structures contained in @caps. func (caps *Caps) GetSize() uint { var carg0 *C.GstCaps // in, none, converted var cret C.guint // return, none, casted carg0 = (*C.GstCaps)(UnsafeCapsToGlibNone(caps)) cret = C.gst_caps_get_size(carg0) runtime.KeepAlive(caps) var goret uint goret = uint(cret) return goret } // GetStructure wraps gst_caps_get_structure // // The function takes the following parameters: // // - index uint: the index of the structure // // The function returns the following values: // // - goret *Structure // // Finds the structure in @caps at @index, and returns it. // // WARNING: This function takes a `const GstCaps *`, but returns a // non-const `GstStructure *`. This is for programming convenience -- // the caller should be aware that structures inside a constant // #GstCaps should not be modified. However, if you know the caps // are writable, either because you have just copied them or made // them writable with gst_caps_make_writable(), you may modify the // structure returned in the usual way, e.g. with functions like // gst_structure_set(). func (caps *Caps) GetStructure(index uint) *Structure { var carg0 *C.GstCaps // in, none, converted var carg1 C.guint // in, none, casted var cret *C.GstStructure // return, borrow, converted carg0 = (*C.GstCaps)(UnsafeCapsToGlibNone(caps)) carg1 = C.guint(index) cret = C.gst_caps_get_structure(carg0, carg1) runtime.KeepAlive(caps) runtime.KeepAlive(index) var goret *Structure goret = UnsafeStructureFromGlibBorrow(unsafe.Pointer(cret)) runtime.AddCleanup(goret, func(_ *Caps) {}, caps) return goret } // Intersect wraps gst_caps_intersect // // The function takes the following parameters: // // - caps2 *Caps: a #GstCaps to intersect // // The function returns the following values: // // - goret *Caps // // Creates a new #GstCaps that contains all the formats that are common // to both @caps1 and @caps2. Defaults to %GST_CAPS_INTERSECT_ZIG_ZAG mode. func (caps1 *Caps) Intersect(caps2 *Caps) *Caps { var carg0 *C.GstCaps // in, none, converted var carg1 *C.GstCaps // in, none, converted var cret *C.GstCaps // return, full, converted carg0 = (*C.GstCaps)(UnsafeCapsToGlibNone(caps1)) carg1 = (*C.GstCaps)(UnsafeCapsToGlibNone(caps2)) cret = C.gst_caps_intersect(carg0, carg1) runtime.KeepAlive(caps1) runtime.KeepAlive(caps2) var goret *Caps goret = UnsafeCapsFromGlibFull(unsafe.Pointer(cret)) return goret } // IntersectFull wraps gst_caps_intersect_full // // The function takes the following parameters: // // - caps2 *Caps: a #GstCaps to intersect // - mode CapsIntersectMode: The intersection algorithm/mode to use // // The function returns the following values: // // - goret *Caps // // Creates a new #GstCaps that contains all the formats that are common // to both @caps1 and @caps2, the order is defined by the #GstCapsIntersectMode // used. func (caps1 *Caps) IntersectFull(caps2 *Caps, mode CapsIntersectMode) *Caps { var carg0 *C.GstCaps // in, none, converted var carg1 *C.GstCaps // in, none, converted var carg2 C.GstCapsIntersectMode // in, none, casted var cret *C.GstCaps // return, full, converted carg0 = (*C.GstCaps)(UnsafeCapsToGlibNone(caps1)) carg1 = (*C.GstCaps)(UnsafeCapsToGlibNone(caps2)) carg2 = C.GstCapsIntersectMode(mode) cret = C.gst_caps_intersect_full(carg0, carg1, carg2) runtime.KeepAlive(caps1) runtime.KeepAlive(caps2) runtime.KeepAlive(mode) var goret *Caps goret = UnsafeCapsFromGlibFull(unsafe.Pointer(cret)) return goret } // IsAlwaysCompatible wraps gst_caps_is_always_compatible // // The function takes the following parameters: // // - caps2 *Caps: the #GstCaps to test // // The function returns the following values: // // - goret bool // // A given #GstCaps structure is always compatible with another if // every media format that is in the first is also contained in the // second. That is, @caps1 is a subset of @caps2. func (caps1 *Caps) IsAlwaysCompatible(caps2 *Caps) bool { var carg0 *C.GstCaps // in, none, converted var carg1 *C.GstCaps // in, none, converted var cret C.gboolean // return carg0 = (*C.GstCaps)(UnsafeCapsToGlibNone(caps1)) carg1 = (*C.GstCaps)(UnsafeCapsToGlibNone(caps2)) cret = C.gst_caps_is_always_compatible(carg0, carg1) runtime.KeepAlive(caps1) runtime.KeepAlive(caps2) var goret bool if cret != 0 { goret = true } return goret } // IsAny wraps gst_caps_is_any // // The function returns the following values: // // - goret bool // // Determines if @caps represents any media format. func (caps *Caps) IsAny() bool { var carg0 *C.GstCaps // in, none, converted var cret C.gboolean // return carg0 = (*C.GstCaps)(UnsafeCapsToGlibNone(caps)) cret = C.gst_caps_is_any(carg0) runtime.KeepAlive(caps) var goret bool if cret != 0 { goret = true } return goret } // IsEmpty wraps gst_caps_is_empty // // The function returns the following values: // // - goret bool // // Determines if @caps represents no media formats. func (caps *Caps) IsEmpty() bool { var carg0 *C.GstCaps // in, none, converted var cret C.gboolean // return carg0 = (*C.GstCaps)(UnsafeCapsToGlibNone(caps)) cret = C.gst_caps_is_empty(carg0) runtime.KeepAlive(caps) var goret bool if cret != 0 { goret = true } return goret } // IsEqual wraps gst_caps_is_equal // // The function takes the following parameters: // // - caps2 *Caps: another #GstCaps // // The function returns the following values: // // - goret bool // // Checks if the given caps represent the same set of caps. func (caps1 *Caps) IsEqual(caps2 *Caps) bool { var carg0 *C.GstCaps // in, none, converted var carg1 *C.GstCaps // in, none, converted var cret C.gboolean // return carg0 = (*C.GstCaps)(UnsafeCapsToGlibNone(caps1)) carg1 = (*C.GstCaps)(UnsafeCapsToGlibNone(caps2)) cret = C.gst_caps_is_equal(carg0, carg1) runtime.KeepAlive(caps1) runtime.KeepAlive(caps2) var goret bool if cret != 0 { goret = true } return goret } // IsEqualFixed wraps gst_caps_is_equal_fixed // // The function takes the following parameters: // // - caps2 *Caps: the #GstCaps to test // // The function returns the following values: // // - goret bool // // Tests if two #GstCaps are equal. This function only works on fixed // #GstCaps. func (caps1 *Caps) IsEqualFixed(caps2 *Caps) bool { var carg0 *C.GstCaps // in, none, converted var carg1 *C.GstCaps // in, none, converted var cret C.gboolean // return carg0 = (*C.GstCaps)(UnsafeCapsToGlibNone(caps1)) carg1 = (*C.GstCaps)(UnsafeCapsToGlibNone(caps2)) cret = C.gst_caps_is_equal_fixed(carg0, carg1) runtime.KeepAlive(caps1) runtime.KeepAlive(caps2) var goret bool if cret != 0 { goret = true } return goret } // IsFixed wraps gst_caps_is_fixed // // The function returns the following values: // // - goret bool // // Fixed #GstCaps describe exactly one format, that is, they have exactly // one structure, and each field in the structure describes a fixed type. // Examples of non-fixed types are GST_TYPE_INT_RANGE and GST_TYPE_LIST. func (caps *Caps) IsFixed() bool { var carg0 *C.GstCaps // in, none, converted var cret C.gboolean // return carg0 = (*C.GstCaps)(UnsafeCapsToGlibNone(caps)) cret = C.gst_caps_is_fixed(carg0) runtime.KeepAlive(caps) var goret bool if cret != 0 { goret = true } return goret } // IsStrictlyEqual wraps gst_caps_is_strictly_equal // // The function takes the following parameters: // // - caps2 *Caps: another #GstCaps // // The function returns the following values: // // - goret bool // // Checks if the given caps are exactly the same set of caps. func (caps1 *Caps) IsStrictlyEqual(caps2 *Caps) bool { var carg0 *C.GstCaps // in, none, converted var carg1 *C.GstCaps // in, none, converted var cret C.gboolean // return carg0 = (*C.GstCaps)(UnsafeCapsToGlibNone(caps1)) carg1 = (*C.GstCaps)(UnsafeCapsToGlibNone(caps2)) cret = C.gst_caps_is_strictly_equal(carg0, carg1) runtime.KeepAlive(caps1) runtime.KeepAlive(caps2) var goret bool if cret != 0 { goret = true } return goret } // IsSubset wraps gst_caps_is_subset // // The function takes the following parameters: // // - superset *Caps: a potentially greater #GstCaps // // The function returns the following values: // // - goret bool // // Checks if all caps represented by @subset are also represented by @superset. func (subset *Caps) IsSubset(superset *Caps) bool { var carg0 *C.GstCaps // in, none, converted var carg1 *C.GstCaps // in, none, converted var cret C.gboolean // return carg0 = (*C.GstCaps)(UnsafeCapsToGlibNone(subset)) carg1 = (*C.GstCaps)(UnsafeCapsToGlibNone(superset)) cret = C.gst_caps_is_subset(carg0, carg1) runtime.KeepAlive(subset) runtime.KeepAlive(superset) var goret bool if cret != 0 { goret = true } return goret } // IsSubsetStructure wraps gst_caps_is_subset_structure // // The function takes the following parameters: // // - structure *Structure: a potential #GstStructure subset of @caps // // The function returns the following values: // // - goret bool // // Checks if @structure is a subset of @caps. See gst_caps_is_subset() // for more information. func (caps *Caps) IsSubsetStructure(structure *Structure) bool { var carg0 *C.GstCaps // in, none, converted var carg1 *C.GstStructure // in, none, converted var cret C.gboolean // return carg0 = (*C.GstCaps)(UnsafeCapsToGlibNone(caps)) carg1 = (*C.GstStructure)(UnsafeStructureToGlibNone(structure)) cret = C.gst_caps_is_subset_structure(carg0, carg1) runtime.KeepAlive(caps) runtime.KeepAlive(structure) var goret bool if cret != 0 { goret = true } return goret } // IsSubsetStructureFull wraps gst_caps_is_subset_structure_full // // The function takes the following parameters: // // - structure *Structure: a potential #GstStructure subset of @caps // - features *CapsFeatures (nullable): a #GstCapsFeatures for @structure // // The function returns the following values: // // - goret bool // // Checks if @structure is a subset of @caps. See gst_caps_is_subset() // for more information. func (caps *Caps) IsSubsetStructureFull(structure *Structure, features *CapsFeatures) bool { var carg0 *C.GstCaps // in, none, converted var carg1 *C.GstStructure // in, none, converted var carg2 *C.GstCapsFeatures // in, none, converted, nullable var cret C.gboolean // return carg0 = (*C.GstCaps)(UnsafeCapsToGlibNone(caps)) carg1 = (*C.GstStructure)(UnsafeStructureToGlibNone(structure)) if features != nil { carg2 = (*C.GstCapsFeatures)(UnsafeCapsFeaturesToGlibNone(features)) } cret = C.gst_caps_is_subset_structure_full(carg0, carg1, carg2) runtime.KeepAlive(caps) runtime.KeepAlive(structure) runtime.KeepAlive(features) var goret bool if cret != 0 { goret = true } return goret } // MapInPlace wraps gst_caps_map_in_place // // The function takes the following parameters: // // - fn CapsMapFunc: a function to call for each field // // The function returns the following values: // // - goret bool // // Calls the provided function once for each structure and caps feature in the // #GstCaps. In contrast to gst_caps_foreach(), the function may modify but not // delete the structures and features. The caps must be mutable. func (caps *Caps) MapInPlace(fn CapsMapFunc) bool { var carg0 *C.GstCaps // in, none, converted var carg1 C.GstCapsMapFunc // callback, scope: call, closure: carg2 var carg2 C.gpointer // implicit var cret C.gboolean // return carg0 = (*C.GstCaps)(UnsafeCapsToGlibNone(caps)) carg1 = (*[0]byte)(C._gotk4_gst1_CapsMapFunc) carg2 = C.gpointer(userdata.Register(fn)) defer userdata.Delete(unsafe.Pointer(carg2)) cret = C.gst_caps_map_in_place(carg0, carg1, carg2) runtime.KeepAlive(caps) runtime.KeepAlive(fn) var goret bool if cret != 0 { goret = true } return goret } // Merge wraps gst_caps_merge // // The function takes the following parameters: // // - caps2 *Caps: the #GstCaps to merge in // // The function returns the following values: // // - goret *Caps // // Appends the structures contained in @caps2 to @caps1 if they are not yet // expressed by @caps1. The structures in @caps2 are not copied -- they are // transferred to a writable copy of @caps1, and then @caps2 is freed. // If either caps is ANY, the resulting caps will be ANY. func (caps1 *Caps) Merge(caps2 *Caps) *Caps { var carg0 *C.GstCaps // in, none, converted var carg1 *C.GstCaps // in, full, converted var cret *C.GstCaps // return, full, converted carg0 = (*C.GstCaps)(UnsafeCapsToGlibNone(caps1)) carg1 = (*C.GstCaps)(UnsafeCapsToGlibFull(caps2)) cret = C.gst_caps_merge(carg0, carg1) runtime.KeepAlive(caps1) runtime.KeepAlive(caps2) var goret *Caps goret = UnsafeCapsFromGlibFull(unsafe.Pointer(cret)) return goret } // MergeStructure wraps gst_caps_merge_structure // // The function takes the following parameters: // // - structure *Structure: the #GstStructure to merge // // The function returns the following values: // // - goret *Caps // // Appends @structure to @caps if it is not already expressed by @caps. func (caps *Caps) MergeStructure(structure *Structure) *Caps { var carg0 *C.GstCaps // in, none, converted var carg1 *C.GstStructure // in, full, converted var cret *C.GstCaps // return, full, converted carg0 = (*C.GstCaps)(UnsafeCapsToGlibNone(caps)) carg1 = (*C.GstStructure)(UnsafeStructureToGlibFull(structure)) cret = C.gst_caps_merge_structure(carg0, carg1) runtime.KeepAlive(caps) runtime.KeepAlive(structure) var goret *Caps goret = UnsafeCapsFromGlibFull(unsafe.Pointer(cret)) return goret } // MergeStructureFull wraps gst_caps_merge_structure_full // // The function takes the following parameters: // // - structure *Structure: the #GstStructure to merge // - features *CapsFeatures (nullable): the #GstCapsFeatures to merge // // The function returns the following values: // // - goret *Caps // // Appends @structure with @features to @caps if its not already expressed by @caps. func (caps *Caps) MergeStructureFull(structure *Structure, features *CapsFeatures) *Caps { var carg0 *C.GstCaps // in, none, converted var carg1 *C.GstStructure // in, full, converted var carg2 *C.GstCapsFeatures // in, full, converted, nullable var cret *C.GstCaps // return, full, converted carg0 = (*C.GstCaps)(UnsafeCapsToGlibNone(caps)) carg1 = (*C.GstStructure)(UnsafeStructureToGlibFull(structure)) if features != nil { carg2 = (*C.GstCapsFeatures)(UnsafeCapsFeaturesToGlibFull(features)) } cret = C.gst_caps_merge_structure_full(carg0, carg1, carg2) runtime.KeepAlive(caps) runtime.KeepAlive(structure) runtime.KeepAlive(features) var goret *Caps goret = UnsafeCapsFromGlibFull(unsafe.Pointer(cret)) return goret } // Normalize wraps gst_caps_normalize // // The function returns the following values: // // - goret *Caps // // Returns a #GstCaps that represents the same set of formats as // @caps, but contains no lists. Each list is expanded into separate // #GstStructure. // // This function takes ownership of @caps and will call gst_caps_make_writable() // on it so you must not use @caps afterwards unless you keep an additional // reference to it with gst_caps_ref(). func (caps *Caps) Normalize() *Caps { var carg0 *C.GstCaps // in, none, converted var cret *C.GstCaps // return, full, converted carg0 = (*C.GstCaps)(UnsafeCapsToGlibNone(caps)) cret = C.gst_caps_normalize(carg0) runtime.KeepAlive(caps) var goret *Caps goret = UnsafeCapsFromGlibFull(unsafe.Pointer(cret)) return goret } // RemoveStructure wraps gst_caps_remove_structure // // The function takes the following parameters: // // - idx uint: Index of the structure to remove // // Removes the structure with the given index from the list of structures // contained in @caps. func (caps *Caps) RemoveStructure(idx uint) { var carg0 *C.GstCaps // in, none, converted var carg1 C.guint // in, none, casted carg0 = (*C.GstCaps)(UnsafeCapsToGlibNone(caps)) carg1 = C.guint(idx) C.gst_caps_remove_structure(carg0, carg1) runtime.KeepAlive(caps) runtime.KeepAlive(idx) } // Serialize wraps gst_caps_serialize // // The function takes the following parameters: // // - flags SerializeFlags: a #GstSerializeFlags // // The function returns the following values: // // - goret string // // Converts @caps to a string representation. This string representation can be // converted back to a #GstCaps by gst_caps_from_string(). // // This prints the caps in human readable form. // // This version of the caps serialization function introduces support for nested // structures and caps but the resulting strings won't be parsable with // GStreamer prior to 1.20 unless #GST_SERIALIZE_FLAG_BACKWARD_COMPAT is passed // as @flag. func (caps *Caps) Serialize(flags SerializeFlags) string { var carg0 *C.GstCaps // in, none, converted var carg1 C.GstSerializeFlags // in, none, casted var cret *C.gchar // return, full, string carg0 = (*C.GstCaps)(UnsafeCapsToGlibNone(caps)) carg1 = C.GstSerializeFlags(flags) cret = C.gst_caps_serialize(carg0, carg1) runtime.KeepAlive(caps) runtime.KeepAlive(flags) var goret string goret = C.GoString((*C.char)(unsafe.Pointer(cret))) defer C.free(unsafe.Pointer(cret)) return goret } // SetFeatures wraps gst_caps_set_features // // The function takes the following parameters: // // - index uint: the index of the structure // - features *CapsFeatures (nullable): the #GstCapsFeatures to set // // Sets the @features for the structure at @index. func (caps *Caps) SetFeatures(index uint, features *CapsFeatures) { var carg0 *C.GstCaps // in, none, converted var carg1 C.guint // in, none, casted var carg2 *C.GstCapsFeatures // in, full, converted, nullable carg0 = (*C.GstCaps)(UnsafeCapsToGlibNone(caps)) carg1 = C.guint(index) if features != nil { carg2 = (*C.GstCapsFeatures)(UnsafeCapsFeaturesToGlibFull(features)) } C.gst_caps_set_features(carg0, carg1, carg2) runtime.KeepAlive(caps) runtime.KeepAlive(index) runtime.KeepAlive(features) } // SetFeaturesSimple wraps gst_caps_set_features_simple // // The function takes the following parameters: // // - features *CapsFeatures (nullable): the #GstCapsFeatures to set // // Sets the @features for all the structures of @caps. func (caps *Caps) SetFeaturesSimple(features *CapsFeatures) { var carg0 *C.GstCaps // in, none, converted var carg1 *C.GstCapsFeatures // in, full, converted, nullable carg0 = (*C.GstCaps)(UnsafeCapsToGlibNone(caps)) if features != nil { carg1 = (*C.GstCapsFeatures)(UnsafeCapsFeaturesToGlibFull(features)) } C.gst_caps_set_features_simple(carg0, carg1) runtime.KeepAlive(caps) runtime.KeepAlive(features) } // SetValue wraps gst_caps_set_value // // The function takes the following parameters: // // - field string: name of the field to set // - value *gobject.Value: value to set the field to // // Sets the given @field on all structures of @caps to the given @value. // This is a convenience function for calling gst_structure_set_value() on // all structures of @caps. func (caps *Caps) SetValue(field string, value *gobject.Value) { var carg0 *C.GstCaps // in, none, converted var carg1 *C.char // in, none, string, casted *C.gchar var carg2 *C.GValue // in, none, converted carg0 = (*C.GstCaps)(UnsafeCapsToGlibNone(caps)) carg1 = (*C.char)(unsafe.Pointer(C.CString(field))) defer C.free(unsafe.Pointer(carg1)) carg2 = (*C.GValue)(gobject.UnsafeValueToGlibUseAnyInstead(value)) C.gst_caps_set_value(carg0, carg1, carg2) runtime.KeepAlive(caps) runtime.KeepAlive(field) runtime.KeepAlive(value) } // Simplify wraps gst_caps_simplify // // The function returns the following values: // // - goret *Caps // // Converts the given @caps into a representation that represents the // same set of formats, but in a simpler form. Component structures that are // identical are merged. Component structures that have values that can be // merged are also merged. // // This function takes ownership of @caps and will call gst_caps_make_writable() // on it if necessary, so you must not use @caps afterwards unless you keep an // additional reference to it with gst_caps_ref(). // // This method does not preserve the original order of @caps. func (caps *Caps) Simplify() *Caps { var carg0 *C.GstCaps // in, none, converted var cret *C.GstCaps // return, full, converted carg0 = (*C.GstCaps)(UnsafeCapsToGlibNone(caps)) cret = C.gst_caps_simplify(carg0) runtime.KeepAlive(caps) var goret *Caps goret = UnsafeCapsFromGlibFull(unsafe.Pointer(cret)) return goret } // StealStructure wraps gst_caps_steal_structure // // The function takes the following parameters: // // - index uint: Index of the structure to retrieve // // The function returns the following values: // // - goret *Structure (nullable) // // Retrieves the structure with the given index from the list of structures // contained in @caps. The caller becomes the owner of the returned structure. func (caps *Caps) StealStructure(index uint) *Structure { var carg0 *C.GstCaps // in, none, converted var carg1 C.guint // in, none, casted var cret *C.GstStructure // return, full, converted, nullable carg0 = (*C.GstCaps)(UnsafeCapsToGlibNone(caps)) carg1 = C.guint(index) cret = C.gst_caps_steal_structure(carg0, carg1) runtime.KeepAlive(caps) runtime.KeepAlive(index) var goret *Structure if cret != nil { goret = UnsafeStructureFromGlibFull(unsafe.Pointer(cret)) } return goret } // Subtract wraps gst_caps_subtract // // The function takes the following parameters: // // - subtrahend *Caps: #GstCaps to subtract // // The function returns the following values: // // - goret *Caps // // Subtracts the @subtrahend from the @minuend. // > This function does not work reliably if optional properties for caps // > are included on one caps and omitted on the other. func (minuend *Caps) Subtract(subtrahend *Caps) *Caps { var carg0 *C.GstCaps // in, none, converted var carg1 *C.GstCaps // in, none, converted var cret *C.GstCaps // return, full, converted carg0 = (*C.GstCaps)(UnsafeCapsToGlibNone(minuend)) carg1 = (*C.GstCaps)(UnsafeCapsToGlibNone(subtrahend)) cret = C.gst_caps_subtract(carg0, carg1) runtime.KeepAlive(minuend) runtime.KeepAlive(subtrahend) var goret *Caps goret = UnsafeCapsFromGlibFull(unsafe.Pointer(cret)) return goret } // String wraps gst_caps_to_string // // The function returns the following values: // // - goret string // // Converts @caps to a string representation. This string representation // can be converted back to a #GstCaps by gst_caps_from_string(). // // For debugging purposes its easier to do something like this: // // ``` C // GST_LOG ("caps are %" GST_PTR_FORMAT, caps); // ``` // // This prints the caps in human readable form. // // The implementation of serialization up to 1.20 would lead to unexpected results // when there were nested #GstCaps / #GstStructure deeper than one level. func (caps *Caps) String() string { var carg0 *C.GstCaps // in, none, converted var cret *C.gchar // return, full, string carg0 = (*C.GstCaps)(UnsafeCapsToGlibNone(caps)) cret = C.gst_caps_to_string(carg0) runtime.KeepAlive(caps) var goret string goret = C.GoString((*C.char)(unsafe.Pointer(cret))) defer C.free(unsafe.Pointer(cret)) return goret } // Truncate wraps gst_caps_truncate // // The function returns the following values: // // - goret *Caps // // Discards all but the first structure from @caps. Useful when // fixating. // // This function takes ownership of @caps and will call gst_caps_make_writable() // on it if necessary, so you must not use @caps afterwards unless you keep an // additional reference to it with gst_caps_ref(). // // Note that it is not guaranteed that the returned caps have exactly one // structure. If @caps is any or empty caps then the returned caps will be // the same and contain no structure at all. func (caps *Caps) Truncate() *Caps { var carg0 *C.GstCaps // in, none, converted var cret *C.GstCaps // return, full, converted carg0 = (*C.GstCaps)(UnsafeCapsToGlibNone(caps)) cret = C.gst_caps_truncate(carg0) runtime.KeepAlive(caps) var goret *Caps goret = UnsafeCapsFromGlibFull(unsafe.Pointer(cret)) return goret } // CapsFeatures wraps GstCapsFeatures // // #GstCapsFeatures can optionally be set on a #GstCaps to add requirements // for additional features for a specific #GstStructure. Caps structures with // the same name but with a non-equal set of caps features are not compatible. // If a pad supports multiple sets of features it has to add multiple equal // structures with different feature sets to the caps. // // Empty #GstCapsFeatures are equivalent with the #GstCapsFeatures that only // contain #GST_CAPS_FEATURE_MEMORY_SYSTEM_MEMORY. ANY #GstCapsFeatures as // created by gst_caps_features_new_any() are equal to any other #GstCapsFeatures // and can be used to specify that any #GstCapsFeatures would be supported, e.g. // for elements that don't touch buffer memory. #GstCaps with ANY #GstCapsFeatures // are considered non-fixed and during negotiation some #GstCapsFeatures have // to be selected. // // Examples for caps features would be the requirement of a specific #GstMemory // types or the requirement of having a specific #GstMeta on the buffer. Features // are given as a string of the format `memory:GstMemoryTypeName` or // `meta:GstMetaAPIName`. type CapsFeatures struct { *capsFeatures } // capsFeatures is the struct that's finalized type capsFeatures struct { native *C.GstCapsFeatures } var _ gobject.GoValueInitializer = (*CapsFeatures)(nil) func marshalCapsFeatures(p unsafe.Pointer) (interface{}, error) { b := gobject.ValueFromNative(p).Boxed() return UnsafeCapsFeaturesFromGlibBorrow(b), nil } func (r *CapsFeatures) InitGoValue(v *gobject.Value) { v.Init(TypeCapsFeatures) v.SetBoxed(unsafe.Pointer(r.native)) } // UnsafeCapsFeaturesFromGlibBorrow is used to convert raw C.GstCapsFeatures pointers to go. This is used by the bindings internally. func UnsafeCapsFeaturesFromGlibBorrow(p unsafe.Pointer) *CapsFeatures { return &CapsFeatures{&capsFeatures{(*C.GstCapsFeatures)(p)}} } // 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) runtime.SetFinalizer( wrapped.capsFeatures, func (intern *capsFeatures) { C.gst_caps_features_free(intern.native) }, ) return wrapped } // 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( wrapped.capsFeatures, func (intern *capsFeatures) { C.gst_caps_features_free(intern.native) }, ) return wrapped } // UnsafeCapsFeaturesFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [CapsFeatures] is expected to work anymore. func UnsafeCapsFeaturesFree(c *CapsFeatures) { C.gst_caps_features_free(c.native) } // UnsafeCapsFeaturesToGlibNone returns the underlying C pointer. This is used by the bindings internally. func UnsafeCapsFeaturesToGlibNone(c *CapsFeatures) unsafe.Pointer { return unsafe.Pointer(c.native) } // UnsafeCapsFeaturesToGlibFull returns the underlying C pointer and gives up ownership. // This is used by the bindings internally. func UnsafeCapsFeaturesToGlibFull(c *CapsFeatures) unsafe.Pointer { runtime.SetFinalizer(c.capsFeatures, nil) _p := unsafe.Pointer(c.native) 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 // // Creates a new, ANY #GstCapsFeatures. This will be equal // to any other #GstCapsFeatures but caps with these are // unfixed. func NewCapsFeaturesAny() *CapsFeatures { var cret *C.GstCapsFeatures // return, full, converted cret = C.gst_caps_features_new_any() var goret *CapsFeatures goret = UnsafeCapsFeaturesFromGlibFull(unsafe.Pointer(cret)) return goret } // NewCapsFeaturesEmpty wraps gst_caps_features_new_empty // // The function returns the following values: // // - goret *CapsFeatures // // Creates a new, empty #GstCapsFeatures. func NewCapsFeaturesEmpty() *CapsFeatures { var cret *C.GstCapsFeatures // return, full, converted cret = C.gst_caps_features_new_empty() var goret *CapsFeatures goret = UnsafeCapsFeaturesFromGlibFull(unsafe.Pointer(cret)) return goret } // NewCapsFeaturesSingle wraps gst_caps_features_new_single // // The function takes the following parameters: // // - feature string: The feature // // The function returns the following values: // // - goret *CapsFeatures // // Creates a new #GstCapsFeatures with a single feature. func NewCapsFeaturesSingle(feature string) *CapsFeatures { var carg1 *C.gchar // in, none, string var cret *C.GstCapsFeatures // return, full, converted carg1 = (*C.gchar)(unsafe.Pointer(C.CString(feature))) defer C.free(unsafe.Pointer(carg1)) cret = C.gst_caps_features_new_single(carg1) runtime.KeepAlive(feature) var goret *CapsFeatures goret = UnsafeCapsFeaturesFromGlibFull(unsafe.Pointer(cret)) return goret } // CapsFeaturesFromString wraps gst_caps_features_from_string // // The function takes the following parameters: // // - features string: a string representation of a #GstCapsFeatures. // // The function returns the following values: // // - goret *CapsFeatures (nullable) // // Creates a #GstCapsFeatures from a string representation. func CapsFeaturesFromString(features string) *CapsFeatures { var carg1 *C.gchar // in, none, string var cret *C.GstCapsFeatures // return, full, converted, nullable carg1 = (*C.gchar)(unsafe.Pointer(C.CString(features))) defer C.free(unsafe.Pointer(carg1)) cret = C.gst_caps_features_from_string(carg1) runtime.KeepAlive(features) var goret *CapsFeatures if cret != nil { goret = UnsafeCapsFeaturesFromGlibFull(unsafe.Pointer(cret)) } return goret } // Add wraps gst_caps_features_add // // The function takes the following parameters: // // - feature string: a feature. // // Adds @feature to @features. func (features *CapsFeatures) Add(feature string) { var carg0 *C.GstCapsFeatures // in, none, converted var carg1 *C.gchar // in, none, string carg0 = (*C.GstCapsFeatures)(UnsafeCapsFeaturesToGlibNone(features)) carg1 = (*C.gchar)(unsafe.Pointer(C.CString(feature))) defer C.free(unsafe.Pointer(carg1)) C.gst_caps_features_add(carg0, carg1) runtime.KeepAlive(features) runtime.KeepAlive(feature) } // AddID wraps gst_caps_features_add_id // // The function takes the following parameters: // // - feature glib.Quark: a feature. // // Adds @feature to @features. func (features *CapsFeatures) AddID(feature glib.Quark) { var carg0 *C.GstCapsFeatures // in, none, converted var carg1 C.GQuark // in, none, casted, alias carg0 = (*C.GstCapsFeatures)(UnsafeCapsFeaturesToGlibNone(features)) carg1 = C.GQuark(feature) C.gst_caps_features_add_id(carg0, carg1) runtime.KeepAlive(features) runtime.KeepAlive(feature) } // Contains wraps gst_caps_features_contains // // The function takes the following parameters: // // - feature string: a feature // // The function returns the following values: // // - goret bool // // Checks if @features contains @feature. func (features *CapsFeatures) Contains(feature string) bool { var carg0 *C.GstCapsFeatures // in, none, converted var carg1 *C.gchar // in, none, string var cret C.gboolean // return carg0 = (*C.GstCapsFeatures)(UnsafeCapsFeaturesToGlibNone(features)) carg1 = (*C.gchar)(unsafe.Pointer(C.CString(feature))) defer C.free(unsafe.Pointer(carg1)) cret = C.gst_caps_features_contains(carg0, carg1) runtime.KeepAlive(features) runtime.KeepAlive(feature) var goret bool if cret != 0 { goret = true } return goret } // ContainsID wraps gst_caps_features_contains_id // // The function takes the following parameters: // // - feature glib.Quark: a feature // // The function returns the following values: // // - goret bool // // Checks if @features contains @feature. func (features *CapsFeatures) ContainsID(feature glib.Quark) bool { var carg0 *C.GstCapsFeatures // in, none, converted var carg1 C.GQuark // in, none, casted, alias var cret C.gboolean // return carg0 = (*C.GstCapsFeatures)(UnsafeCapsFeaturesToGlibNone(features)) carg1 = C.GQuark(feature) cret = C.gst_caps_features_contains_id(carg0, carg1) runtime.KeepAlive(features) runtime.KeepAlive(feature) var goret bool if cret != 0 { goret = true } return goret } // Copy wraps gst_caps_features_copy // // The function returns the following values: // // - goret *CapsFeatures // // Duplicates a #GstCapsFeatures and all its values. func (features *CapsFeatures) Copy() *CapsFeatures { var carg0 *C.GstCapsFeatures // in, none, converted var cret *C.GstCapsFeatures // return, full, converted carg0 = (*C.GstCapsFeatures)(UnsafeCapsFeaturesToGlibNone(features)) cret = C.gst_caps_features_copy(carg0) runtime.KeepAlive(features) var goret *CapsFeatures goret = UnsafeCapsFeaturesFromGlibFull(unsafe.Pointer(cret)) return goret } // GetNth wraps gst_caps_features_get_nth // // The function takes the following parameters: // // - i uint: index of the feature // // The function returns the following values: // // - goret string (nullable) // // Returns the @i-th feature of @features. func (features *CapsFeatures) GetNth(i uint) string { var carg0 *C.GstCapsFeatures // in, none, converted var carg1 C.guint // in, none, casted var cret *C.gchar // return, none, string, nullable-string carg0 = (*C.GstCapsFeatures)(UnsafeCapsFeaturesToGlibNone(features)) carg1 = C.guint(i) cret = C.gst_caps_features_get_nth(carg0, carg1) runtime.KeepAlive(features) runtime.KeepAlive(i) var goret string if cret != nil { goret = C.GoString((*C.char)(unsafe.Pointer(cret))) } return goret } // GetNthID wraps gst_caps_features_get_nth_id // // The function takes the following parameters: // // - i uint: index of the feature // // The function returns the following values: // // - goret glib.Quark // // Returns the @i-th feature of @features. func (features *CapsFeatures) GetNthID(i uint) glib.Quark { var carg0 *C.GstCapsFeatures // in, none, converted var carg1 C.guint // in, none, casted var cret C.GQuark // return, none, casted, alias carg0 = (*C.GstCapsFeatures)(UnsafeCapsFeaturesToGlibNone(features)) carg1 = C.guint(i) cret = C.gst_caps_features_get_nth_id(carg0, carg1) runtime.KeepAlive(features) runtime.KeepAlive(i) var goret glib.Quark goret = glib.Quark(cret) return goret } // GetSize wraps gst_caps_features_get_size // // The function returns the following values: // // - goret uint // // Returns the number of features in @features. func (features *CapsFeatures) GetSize() uint { var carg0 *C.GstCapsFeatures // in, none, converted var cret C.guint // return, none, casted carg0 = (*C.GstCapsFeatures)(UnsafeCapsFeaturesToGlibNone(features)) cret = C.gst_caps_features_get_size(carg0) runtime.KeepAlive(features) var goret uint goret = uint(cret) return goret } // IsAny wraps gst_caps_features_is_any // // The function returns the following values: // // - goret bool // // Checks if @features is %GST_CAPS_FEATURES_ANY. func (features *CapsFeatures) IsAny() bool { var carg0 *C.GstCapsFeatures // in, none, converted var cret C.gboolean // return carg0 = (*C.GstCapsFeatures)(UnsafeCapsFeaturesToGlibNone(features)) cret = C.gst_caps_features_is_any(carg0) runtime.KeepAlive(features) var goret bool if cret != 0 { goret = true } return goret } // IsEqual wraps gst_caps_features_is_equal // // The function takes the following parameters: // // - features2 *CapsFeatures: a #GstCapsFeatures. // // The function returns the following values: // // - goret bool // // Checks if @features1 and @features2 are equal. func (features1 *CapsFeatures) IsEqual(features2 *CapsFeatures) bool { var carg0 *C.GstCapsFeatures // in, none, converted var carg1 *C.GstCapsFeatures // in, none, converted var cret C.gboolean // return carg0 = (*C.GstCapsFeatures)(UnsafeCapsFeaturesToGlibNone(features1)) carg1 = (*C.GstCapsFeatures)(UnsafeCapsFeaturesToGlibNone(features2)) cret = C.gst_caps_features_is_equal(carg0, carg1) runtime.KeepAlive(features1) runtime.KeepAlive(features2) var goret bool if cret != 0 { goret = true } return goret } // Remove wraps gst_caps_features_remove // // The function takes the following parameters: // // - feature string: a feature. // // Removes @feature from @features. func (features *CapsFeatures) Remove(feature string) { var carg0 *C.GstCapsFeatures // in, none, converted var carg1 *C.gchar // in, none, string carg0 = (*C.GstCapsFeatures)(UnsafeCapsFeaturesToGlibNone(features)) carg1 = (*C.gchar)(unsafe.Pointer(C.CString(feature))) defer C.free(unsafe.Pointer(carg1)) C.gst_caps_features_remove(carg0, carg1) runtime.KeepAlive(features) runtime.KeepAlive(feature) } // RemoveID wraps gst_caps_features_remove_id // // The function takes the following parameters: // // - feature glib.Quark: a feature. // // Removes @feature from @features. func (features *CapsFeatures) RemoveID(feature glib.Quark) { var carg0 *C.GstCapsFeatures // in, none, converted var carg1 C.GQuark // in, none, casted, alias carg0 = (*C.GstCapsFeatures)(UnsafeCapsFeaturesToGlibNone(features)) carg1 = C.GQuark(feature) C.gst_caps_features_remove_id(carg0, carg1) runtime.KeepAlive(features) runtime.KeepAlive(feature) } // SetParentRefcount wraps gst_caps_features_set_parent_refcount // // The function takes the following parameters: // // - refcount *int: a pointer to the parent's refcount // // The function returns the following values: // // - goret bool // // Sets the parent_refcount field of #GstCapsFeatures. This field is used to // determine whether a caps features is mutable or not. This function should only be // called by code implementing parent objects of #GstCapsFeatures, as described in // [the MT refcounting design document](additional/design/MT-refcounting.md). func (features *CapsFeatures) SetParentRefcount(refcount *int) bool { var carg0 *C.GstCapsFeatures // in, none, converted var carg1 *C.gint // in, transfer: none, C Pointers: 1, Name: gint var cret C.gboolean // return carg0 = (*C.GstCapsFeatures)(UnsafeCapsFeaturesToGlibNone(features)) _ = refcount _ = carg1 panic("unimplemented conversion of *int (gint*)") cret = C.gst_caps_features_set_parent_refcount(carg0, carg1) runtime.KeepAlive(features) runtime.KeepAlive(refcount) var goret bool if cret != 0 { goret = true } return goret } // ToString wraps gst_caps_features_to_string // // The function returns the following values: // // - goret string // // Converts @features to a human-readable string representation. // // For debugging purposes its easier to do something like this: // // ``` C // GST_LOG ("features is %" GST_PTR_FORMAT, features); // ``` // // This prints the features in human readable form. func (features *CapsFeatures) ToString() string { var carg0 *C.GstCapsFeatures // in, none, converted var cret *C.gchar // return, full, string carg0 = (*C.GstCapsFeatures)(UnsafeCapsFeaturesToGlibNone(features)) cret = C.gst_caps_features_to_string(carg0) runtime.KeepAlive(features) var goret string goret = C.GoString((*C.char)(unsafe.Pointer(cret))) defer C.free(unsafe.Pointer(cret)) return goret } // ChildProxyInterface wraps GstChildProxyInterface // // #GstChildProxy interface. type ChildProxyInterface struct { *childProxyInterface } // childProxyInterface is the struct that's finalized type childProxyInterface struct { native *C.GstChildProxyInterface } // UnsafeChildProxyInterfaceFromGlibBorrow is used to convert raw C.GstChildProxyInterface pointers to go. This is used by the bindings internally. func UnsafeChildProxyInterfaceFromGlibBorrow(p unsafe.Pointer) *ChildProxyInterface { return &ChildProxyInterface{&childProxyInterface{(*C.GstChildProxyInterface)(p)}} } // 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) runtime.SetFinalizer( wrapped.childProxyInterface, func (intern *childProxyInterface) { C.free(unsafe.Pointer(intern.native)) }, ) return wrapped } // 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( wrapped.childProxyInterface, func (intern *childProxyInterface) { C.free(unsafe.Pointer(intern.native)) }, ) return wrapped } // UnsafeChildProxyInterfaceFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [ChildProxyInterface] is expected to work anymore. func UnsafeChildProxyInterfaceFree(c *ChildProxyInterface) { C.free(unsafe.Pointer(c.native)) } // UnsafeChildProxyInterfaceToGlibNone returns the underlying C pointer. This is used by the bindings internally. func UnsafeChildProxyInterfaceToGlibNone(c *ChildProxyInterface) unsafe.Pointer { return unsafe.Pointer(c.native) } // UnsafeChildProxyInterfaceToGlibFull returns the underlying C pointer and gives up ownership. // This is used by the bindings internally. func UnsafeChildProxyInterfaceToGlibFull(c *ChildProxyInterface) unsafe.Pointer { runtime.SetFinalizer(c.childProxyInterface, nil) _p := unsafe.Pointer(c.native) 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 } // clockClass is the struct that's finalized type clockClass struct { native *C.GstClockClass } // UnsafeClockClassFromGlibBorrow is used to convert raw C.GstClockClass pointers to go. This is used by the bindings internally. func UnsafeClockClassFromGlibBorrow(p unsafe.Pointer) *ClockClass { return &ClockClass{&clockClass{(*C.GstClockClass)(p)}} } // 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. func UnsafeClockClassFree(c *ClockClass) { C.free(unsafe.Pointer(c.native)) } // UnsafeClockClassToGlibNone returns the underlying C pointer. This is used by the bindings internally. func UnsafeClockClassToGlibNone(c *ClockClass) unsafe.Pointer { return unsafe.Pointer(c.native) } // 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 // an entry. // Note that GstClockEntry should be treated as an opaque structure. It must // not be extended or allocated using a custom allocator. type ClockEntry struct { *clockEntry } // clockEntry is the struct that's finalized type clockEntry struct { native *C.GstClockEntry } // UnsafeClockEntryFromGlibBorrow is used to convert raw C.GstClockEntry pointers to go. This is used by the bindings internally. func UnsafeClockEntryFromGlibBorrow(p unsafe.Pointer) *ClockEntry { return &ClockEntry{&clockEntry{(*C.GstClockEntry)(p)}} } // 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) runtime.SetFinalizer( wrapped.clockEntry, func (intern *clockEntry) { C.free(unsafe.Pointer(intern.native)) }, ) return wrapped } // 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( wrapped.clockEntry, func (intern *clockEntry) { C.free(unsafe.Pointer(intern.native)) }, ) return wrapped } // UnsafeClockEntryFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [ClockEntry] is expected to work anymore. func UnsafeClockEntryFree(c *ClockEntry) { C.free(unsafe.Pointer(c.native)) } // UnsafeClockEntryToGlibNone returns the underlying C pointer. This is used by the bindings internally. func UnsafeClockEntryToGlibNone(c *ClockEntry) unsafe.Pointer { return unsafe.Pointer(c.native) } // UnsafeClockEntryToGlibFull returns the underlying C pointer and gives up ownership. // This is used by the bindings internally. func UnsafeClockEntryToGlibFull(c *ClockEntry) unsafe.Pointer { runtime.SetFinalizer(c.clockEntry, nil) _p := unsafe.Pointer(c.native) 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 // context, a display server connection and similar concepts that should // be shared between multiple elements. // // Applications can set a context on a complete pipeline by using // gst_element_set_context(), which will then be propagated to all // child elements. Elements can handle these in #GstElementClass::set_context // and merge them with the context information they already have. // // When an element needs a context it will do the following actions in this // order until one step succeeds: // // 1. Check if the element already has a context // 2. Query downstream with %GST_QUERY_CONTEXT for the context // 3. Query upstream with %GST_QUERY_CONTEXT for the context // 4. Post a %GST_MESSAGE_NEED_CONTEXT message on the bus with the required // context types and afterwards check if a usable context was set now // 5. Create a context by itself and post a %GST_MESSAGE_HAVE_CONTEXT message // on the bus. // // Bins will catch %GST_MESSAGE_NEED_CONTEXT messages and will set any previously // known context on the element that asks for it if possible. Otherwise the // application should provide one if it can. // // #GstContext can be persistent. // A persistent #GstContext is kept in elements when they reach // %GST_STATE_NULL, non-persistent ones will be removed. // Also, a non-persistent context won't override a previous persistent // context set to an element. type Context struct { *_context } // _context is the struct that's finalized type _context struct { native *C.GstContext } var _ gobject.GoValueInitializer = (*Context)(nil) func marshalContext(p unsafe.Pointer) (interface{}, error) { b := gobject.ValueFromNative(p).Boxed() return UnsafeContextFromGlibBorrow(b), nil } func (r *Context) InitGoValue(v *gobject.Value) { v.Init(TypeContext) v.SetBoxed(unsafe.Pointer(r.native)) } // UnsafeContextFromGlibBorrow is used to convert raw C.GstContext pointers to go. This is used by the bindings internally. func UnsafeContextFromGlibBorrow(p unsafe.Pointer) *Context { return &Context{&_context{(*C.GstContext)(p)}} } // 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) runtime.SetFinalizer( wrapped._context, func (intern *_context) { C.free(unsafe.Pointer(intern.native)) }, ) return wrapped } // 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( wrapped._context, func (intern *_context) { C.free(unsafe.Pointer(intern.native)) }, ) return wrapped } // UnsafeContextFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [Context] is expected to work anymore. func UnsafeContextFree(c *Context) { C.free(unsafe.Pointer(c.native)) } // UnsafeContextToGlibNone returns the underlying C pointer. This is used by the bindings internally. func UnsafeContextToGlibNone(c *Context) unsafe.Pointer { return unsafe.Pointer(c.native) } // UnsafeContextToGlibFull returns the underlying C pointer and gives up ownership. // This is used by the bindings internally. func UnsafeContextToGlibFull(c *Context) unsafe.Pointer { runtime.SetFinalizer(c._context, nil) _p := unsafe.Pointer(c.native) c.native = nil // Context is invalid from here on return _p } // NewContext wraps gst_context_new // // The function takes the following parameters: // // - contextType string: Context type // - persistent bool: Persistent context // // The function returns the following values: // // - goret *Context // // Creates a new context. func NewContext(contextType string, persistent bool) *Context { var carg1 *C.gchar // in, none, string var carg2 C.gboolean // in var cret *C.GstContext // return, full, converted carg1 = (*C.gchar)(unsafe.Pointer(C.CString(contextType))) defer C.free(unsafe.Pointer(carg1)) if persistent { carg2 = C.TRUE } cret = C.gst_context_new(carg1, carg2) runtime.KeepAlive(contextType) runtime.KeepAlive(persistent) var goret *Context goret = UnsafeContextFromGlibFull(unsafe.Pointer(cret)) return goret } // GetContextType wraps gst_context_get_context_type // // The function returns the following values: // // - goret string // // Gets the type of @context. func (_context *Context) GetContextType() string { var carg0 *C.GstContext // in, none, converted var cret *C.gchar // return, none, string carg0 = (*C.GstContext)(UnsafeContextToGlibNone(_context)) cret = C.gst_context_get_context_type(carg0) runtime.KeepAlive(_context) var goret string goret = C.GoString((*C.char)(unsafe.Pointer(cret))) return goret } // GetStructure wraps gst_context_get_structure // // The function returns the following values: // // - goret *Structure // // Accesses the structure of the context. func (_context *Context) GetStructure() *Structure { var carg0 *C.GstContext // in, none, converted var cret *C.GstStructure // return, none, converted carg0 = (*C.GstContext)(UnsafeContextToGlibNone(_context)) cret = C.gst_context_get_structure(carg0) runtime.KeepAlive(_context) var goret *Structure goret = UnsafeStructureFromGlibNone(unsafe.Pointer(cret)) return goret } // HasContextType wraps gst_context_has_context_type // // The function takes the following parameters: // // - contextType string: Context type to check. // // The function returns the following values: // // - goret bool // // Checks if @context has @context_type. func (_context *Context) HasContextType(contextType string) bool { var carg0 *C.GstContext // in, none, converted var carg1 *C.gchar // in, none, string var cret C.gboolean // return carg0 = (*C.GstContext)(UnsafeContextToGlibNone(_context)) carg1 = (*C.gchar)(unsafe.Pointer(C.CString(contextType))) defer C.free(unsafe.Pointer(carg1)) cret = C.gst_context_has_context_type(carg0, carg1) runtime.KeepAlive(_context) runtime.KeepAlive(contextType) var goret bool if cret != 0 { goret = true } return goret } // IsPersistent wraps gst_context_is_persistent // // The function returns the following values: // // - goret bool // // Checks if @context is persistent. func (_context *Context) IsPersistent() bool { var carg0 *C.GstContext // in, none, converted var cret C.gboolean // return carg0 = (*C.GstContext)(UnsafeContextToGlibNone(_context)) cret = C.gst_context_is_persistent(carg0) runtime.KeepAlive(_context) var goret bool if cret != 0 { goret = true } return goret } // WritableStructure wraps gst_context_writable_structure // // The function returns the following values: // // - goret *Structure // // Gets a writable version of the structure. func (_context *Context) WritableStructure() *Structure { var carg0 *C.GstContext // in, none, converted var cret *C.GstStructure // return, none, converted carg0 = (*C.GstContext)(UnsafeContextToGlibNone(_context)) cret = C.gst_context_writable_structure(carg0) runtime.KeepAlive(_context) var goret *Structure goret = UnsafeStructureFromGlibNone(unsafe.Pointer(cret)) return goret } // ControlBindingClass wraps GstControlBindingClass // // The class structure of #GstControlBinding. // // ControlBindingClass is the type struct for [ControlBinding] type ControlBindingClass struct { *controlBindingClass } // controlBindingClass is the struct that's finalized type controlBindingClass struct { native *C.GstControlBindingClass } // UnsafeControlBindingClassFromGlibBorrow is used to convert raw C.GstControlBindingClass pointers to go. This is used by the bindings internally. func UnsafeControlBindingClassFromGlibBorrow(p unsafe.Pointer) *ControlBindingClass { return &ControlBindingClass{&controlBindingClass{(*C.GstControlBindingClass)(p)}} } // 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. func UnsafeControlBindingClassFree(c *ControlBindingClass) { C.free(unsafe.Pointer(c.native)) } // UnsafeControlBindingClassToGlibNone returns the underlying C pointer. This is used by the bindings internally. func UnsafeControlBindingClassToGlibNone(c *ControlBindingClass) unsafe.Pointer { return unsafe.Pointer(c.native) } // 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 } // controlSourceClass is the struct that's finalized type controlSourceClass struct { native *C.GstControlSourceClass } // UnsafeControlSourceClassFromGlibBorrow is used to convert raw C.GstControlSourceClass pointers to go. This is used by the bindings internally. func UnsafeControlSourceClassFromGlibBorrow(p unsafe.Pointer) *ControlSourceClass { return &ControlSourceClass{&controlSourceClass{(*C.GstControlSourceClass)(p)}} } // 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. func UnsafeControlSourceClassFree(c *ControlSourceClass) { C.free(unsafe.Pointer(c.native)) } // UnsafeControlSourceClassToGlibNone returns the underlying C pointer. This is used by the bindings internally. func UnsafeControlSourceClassToGlibNone(c *ControlSourceClass) unsafe.Pointer { return unsafe.Pointer(c.native) } // 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 // gst_custom_meta_get_structure(). // // Since 1.24 it can be serialized using gst_meta_serialize() and // gst_meta_deserialize(), but only if the #GstStructure does not contain any // fields that cannot be serialized, see %GST_SERIALIZE_FLAG_STRICT. type CustomMeta struct { *customMeta } // customMeta is the struct that's finalized type customMeta struct { native *C.GstCustomMeta } // UnsafeCustomMetaFromGlibBorrow is used to convert raw C.GstCustomMeta pointers to go. This is used by the bindings internally. func UnsafeCustomMetaFromGlibBorrow(p unsafe.Pointer) *CustomMeta { return &CustomMeta{&customMeta{(*C.GstCustomMeta)(p)}} } // 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) runtime.SetFinalizer( wrapped.customMeta, func (intern *customMeta) { C.free(unsafe.Pointer(intern.native)) }, ) return wrapped } // 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( wrapped.customMeta, func (intern *customMeta) { C.free(unsafe.Pointer(intern.native)) }, ) return wrapped } // UnsafeCustomMetaFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [CustomMeta] is expected to work anymore. func UnsafeCustomMetaFree(c *CustomMeta) { C.free(unsafe.Pointer(c.native)) } // UnsafeCustomMetaToGlibNone returns the underlying C pointer. This is used by the bindings internally. func UnsafeCustomMetaToGlibNone(c *CustomMeta) unsafe.Pointer { return unsafe.Pointer(c.native) } // UnsafeCustomMetaToGlibFull returns the underlying C pointer and gives up ownership. // This is used by the bindings internally. func UnsafeCustomMetaToGlibFull(c *CustomMeta) unsafe.Pointer { runtime.SetFinalizer(c.customMeta, nil) _p := unsafe.Pointer(c.native) 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 // // Retrieve the #GstStructure backing a custom meta, the structure's mutability // is conditioned to the writability of the #GstBuffer @meta is attached to. func (meta *CustomMeta) GetStructure() *Structure { var carg0 *C.GstCustomMeta // in, none, converted var cret *C.GstStructure // return, none, converted carg0 = (*C.GstCustomMeta)(UnsafeCustomMetaToGlibNone(meta)) cret = C.gst_custom_meta_get_structure(carg0) runtime.KeepAlive(meta) var goret *Structure goret = UnsafeStructureFromGlibNone(unsafe.Pointer(cret)) return goret } // HasName wraps gst_custom_meta_has_name // // The function takes the following parameters: // // - name string // // The function returns the following values: // // - goret bool // // Checks whether the name of the custom meta is @name func (meta *CustomMeta) HasName(name string) bool { var carg0 *C.GstCustomMeta // in, none, converted var carg1 *C.gchar // in, none, string var cret C.gboolean // return carg0 = (*C.GstCustomMeta)(UnsafeCustomMetaToGlibNone(meta)) carg1 = (*C.gchar)(unsafe.Pointer(C.CString(name))) defer C.free(unsafe.Pointer(carg1)) cret = C.gst_custom_meta_has_name(carg0, carg1) runtime.KeepAlive(meta) runtime.KeepAlive(name) var goret bool if cret != 0 { goret = true } return goret } // DateTime wraps GstDateTime // // Struct to store date, time and timezone information altogether. // #GstDateTime is refcounted and immutable. // // Date information is handled using the [proleptic Gregorian calendar]. // // Provides basic creation functions and accessor functions to its fields. // // [proleptic Gregorian calendar]: https://en.wikipedia.org/wiki/Proleptic_Gregorian_calendar type DateTime struct { *dateTime } // dateTime is the struct that's finalized type dateTime struct { native *C.GstDateTime } var _ gobject.GoValueInitializer = (*DateTime)(nil) func marshalDateTime(p unsafe.Pointer) (interface{}, error) { b := gobject.ValueFromNative(p).Boxed() return UnsafeDateTimeFromGlibBorrow(b), nil } func (r *DateTime) InitGoValue(v *gobject.Value) { v.Init(TypeDateTime) v.SetBoxed(unsafe.Pointer(r.native)) } // UnsafeDateTimeFromGlibBorrow is used to convert raw C.GstDateTime pointers to go. This is used by the bindings internally. func UnsafeDateTimeFromGlibBorrow(p unsafe.Pointer) *DateTime { return &DateTime{&dateTime{(*C.GstDateTime)(p)}} } // 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) runtime.SetFinalizer( wrapped.dateTime, func (intern *dateTime) { C.gst_date_time_unref(intern.native) }, ) return wrapped } // 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( wrapped.dateTime, func (intern *dateTime) { C.gst_date_time_unref(intern.native) }, ) return wrapped } // UnsafeDateTimeRef increases the refcount on the underlying resource. This is used by the bindings internally. // // When this is called without an associated call to [DateTime.UnsafeDateTimeUnref], then [DateTime] will leak memory. func UnsafeDateTimeRef(d *DateTime) { C.gst_date_time_ref(d.native) } // UnsafeDateTimeUnref unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [DateTime] is expected to work anymore. func UnsafeDateTimeUnref(d *DateTime) { C.gst_date_time_unref(d.native) } // UnsafeDateTimeToGlibNone returns the underlying C pointer. This is used by the bindings internally. func UnsafeDateTimeToGlibNone(d *DateTime) unsafe.Pointer { return unsafe.Pointer(d.native) } // UnsafeDateTimeToGlibFull returns the underlying C pointer and gives up ownership. // This is used by the bindings internally. func UnsafeDateTimeToGlibFull(d *DateTime) unsafe.Pointer { runtime.SetFinalizer(d.dateTime, nil) _p := unsafe.Pointer(d.native) d.native = nil // DateTime is invalid from here on return _p } // NewDateTime wraps gst_date_time_new // // The function takes the following parameters: // // - tzoffset float32: Offset from UTC in hours. // - year int: the gregorian year // - month int: the gregorian month // - day int: the day of the gregorian month // - hour int: the hour of the day // - minute int: the minute of the hour // - seconds float64: the second of the minute // // The function returns the following values: // // - goret *DateTime (nullable) // // Creates a new #GstDateTime using the date and times in the gregorian calendar // in the supplied timezone. // // @year should be from 1 to 9999, @month should be from 1 to 12, @day from // 1 to 31, @hour from 0 to 23, @minutes and @seconds from 0 to 59. // // Note that @tzoffset is a float and was chosen so for being able to handle // some fractional timezones, while it still keeps the readability of // representing it in hours for most timezones. // // If value is -1 then all over value will be ignored. For example // if @month == -1, then #GstDateTime will be created only for @year. If // @day == -1, then #GstDateTime will be created for @year and @month and // so on. func NewDateTime(tzoffset float32, year int, month int, day int, hour int, minute int, seconds float64) *DateTime { var carg1 C.gfloat // in, none, casted var carg2 C.gint // in, none, casted var carg3 C.gint // in, none, casted var carg4 C.gint // in, none, casted var carg5 C.gint // in, none, casted var carg6 C.gint // in, none, casted var carg7 C.gdouble // in, none, casted var cret *C.GstDateTime // return, full, converted, nullable carg1 = C.gfloat(tzoffset) carg2 = C.gint(year) carg3 = C.gint(month) carg4 = C.gint(day) carg5 = C.gint(hour) carg6 = C.gint(minute) carg7 = C.gdouble(seconds) cret = C.gst_date_time_new(carg1, carg2, carg3, carg4, carg5, carg6, carg7) runtime.KeepAlive(tzoffset) runtime.KeepAlive(year) runtime.KeepAlive(month) runtime.KeepAlive(day) runtime.KeepAlive(hour) runtime.KeepAlive(minute) runtime.KeepAlive(seconds) var goret *DateTime if cret != nil { goret = UnsafeDateTimeFromGlibFull(unsafe.Pointer(cret)) } return goret } // NewDateTimeFromGDateTime wraps gst_date_time_new_from_g_date_time // // The function takes the following parameters: // // - dt *glib.DateTime (nullable): the #GDateTime. // // The function returns the following values: // // - goret *DateTime (nullable) // // Creates a new #GstDateTime from a #GDateTime object. func NewDateTimeFromGDateTime(dt *glib.DateTime) *DateTime { var carg1 *C.GDateTime // in, full, converted, nullable var cret *C.GstDateTime // return, full, converted, nullable if dt != nil { carg1 = (*C.GDateTime)(glib.UnsafeDateTimeToGlibFull(dt)) } cret = C.gst_date_time_new_from_g_date_time(carg1) runtime.KeepAlive(dt) var goret *DateTime if cret != nil { goret = UnsafeDateTimeFromGlibFull(unsafe.Pointer(cret)) } return goret } // NewDateTimeFromISO8601String wraps gst_date_time_new_from_iso8601_string // // The function takes the following parameters: // // - str string: ISO 8601-formatted datetime string. // // The function returns the following values: // // - goret *DateTime (nullable) // // Tries to parse common variants of ISO-8601 datetime strings into a // #GstDateTime. Possible input formats are (for example): // `2012-06-30T22:46:43Z`, `2012`, `2012-06`, `2012-06-30`, `2012-06-30T22:46:43-0430`, // `2012-06-30T22:46Z`, `2012-06-30T22:46-0430`, `2012-06-30 22:46`, // `2012-06-30 22:46:43`, `2012-06-00`, `2012-00-00`, `2012-00-30`, `22:46:43Z`, `22:46Z`, // `22:46:43-0430`, `22:46-0430`, `22:46:30`, `22:46` // If no date is provided, it is assumed to be "today" in the timezone // provided (if any), otherwise UTC. func NewDateTimeFromISO8601String(str string) *DateTime { var carg1 *C.gchar // in, none, string var cret *C.GstDateTime // return, full, converted, nullable carg1 = (*C.gchar)(unsafe.Pointer(C.CString(str))) defer C.free(unsafe.Pointer(carg1)) cret = C.gst_date_time_new_from_iso8601_string(carg1) runtime.KeepAlive(str) var goret *DateTime if cret != nil { goret = UnsafeDateTimeFromGlibFull(unsafe.Pointer(cret)) } return goret } // NewDateTimeFromUnixEpochLocalTime wraps gst_date_time_new_from_unix_epoch_local_time // // The function takes the following parameters: // // - secs int64: seconds from the Unix epoch // // The function returns the following values: // // - goret *DateTime (nullable) // // Creates a new #GstDateTime using the time since Jan 1, 1970 specified by // @secs. The #GstDateTime is in the local timezone. func NewDateTimeFromUnixEpochLocalTime(secs int64) *DateTime { var carg1 C.gint64 // in, none, casted var cret *C.GstDateTime // return, full, converted, nullable carg1 = C.gint64(secs) cret = C.gst_date_time_new_from_unix_epoch_local_time(carg1) runtime.KeepAlive(secs) var goret *DateTime if cret != nil { goret = UnsafeDateTimeFromGlibFull(unsafe.Pointer(cret)) } return goret } // NewDateTimeFromUnixEpochLocalTimeUsecs wraps gst_date_time_new_from_unix_epoch_local_time_usecs // // The function takes the following parameters: // // - usecs int64: microseconds from the Unix epoch // // The function returns the following values: // // - goret *DateTime (nullable) // // Creates a new #GstDateTime using the time since Jan 1, 1970 specified by // @usecs. The #GstDateTime is in the local timezone. func NewDateTimeFromUnixEpochLocalTimeUsecs(usecs int64) *DateTime { var carg1 C.gint64 // in, none, casted var cret *C.GstDateTime // return, full, converted, nullable carg1 = C.gint64(usecs) cret = C.gst_date_time_new_from_unix_epoch_local_time_usecs(carg1) runtime.KeepAlive(usecs) var goret *DateTime if cret != nil { goret = UnsafeDateTimeFromGlibFull(unsafe.Pointer(cret)) } return goret } // NewDateTimeFromUnixEpochUTC wraps gst_date_time_new_from_unix_epoch_utc // // The function takes the following parameters: // // - secs int64: seconds from the Unix epoch // // The function returns the following values: // // - goret *DateTime (nullable) // // Creates a new #GstDateTime using the time since Jan 1, 1970 specified by // @secs. The #GstDateTime is in the UTC timezone. func NewDateTimeFromUnixEpochUTC(secs int64) *DateTime { var carg1 C.gint64 // in, none, casted var cret *C.GstDateTime // return, full, converted, nullable carg1 = C.gint64(secs) cret = C.gst_date_time_new_from_unix_epoch_utc(carg1) runtime.KeepAlive(secs) var goret *DateTime if cret != nil { goret = UnsafeDateTimeFromGlibFull(unsafe.Pointer(cret)) } return goret } // NewDateTimeFromUnixEpochUTCUsecs wraps gst_date_time_new_from_unix_epoch_utc_usecs // // The function takes the following parameters: // // - usecs int64: microseconds from the Unix epoch // // The function returns the following values: // // - goret *DateTime (nullable) // // Creates a new #GstDateTime using the time since Jan 1, 1970 specified by // @usecs. The #GstDateTime is in UTC. func NewDateTimeFromUnixEpochUTCUsecs(usecs int64) *DateTime { var carg1 C.gint64 // in, none, casted var cret *C.GstDateTime // return, full, converted, nullable carg1 = C.gint64(usecs) cret = C.gst_date_time_new_from_unix_epoch_utc_usecs(carg1) runtime.KeepAlive(usecs) var goret *DateTime if cret != nil { goret = UnsafeDateTimeFromGlibFull(unsafe.Pointer(cret)) } return goret } // NewDateTimeLocalTime wraps gst_date_time_new_local_time // // The function takes the following parameters: // // - year int: the gregorian year // - month int: the gregorian month, or -1 // - day int: the day of the gregorian month, or -1 // - hour int: the hour of the day, or -1 // - minute int: the minute of the hour, or -1 // - seconds float64: the second of the minute, or -1 // // The function returns the following values: // // - goret *DateTime (nullable) // // Creates a new #GstDateTime using the date and times in the gregorian calendar // in the local timezone. // // @year should be from 1 to 9999, @month should be from 1 to 12, @day from // 1 to 31, @hour from 0 to 23, @minutes and @seconds from 0 to 59. // // If @month is -1, then the #GstDateTime created will only contain @year, // and all other fields will be considered not set. // // If @day is -1, then the #GstDateTime created will only contain @year and // @month and all other fields will be considered not set. // // If @hour is -1, then the #GstDateTime created will only contain @year and // @month and @day, and the time fields will be considered not set. In this // case @minute and @seconds should also be -1. func NewDateTimeLocalTime(year int, month int, day int, hour int, minute int, seconds float64) *DateTime { var carg1 C.gint // in, none, casted var carg2 C.gint // in, none, casted var carg3 C.gint // in, none, casted var carg4 C.gint // in, none, casted var carg5 C.gint // in, none, casted var carg6 C.gdouble // in, none, casted var cret *C.GstDateTime // return, full, converted, nullable carg1 = C.gint(year) carg2 = C.gint(month) carg3 = C.gint(day) carg4 = C.gint(hour) carg5 = C.gint(minute) carg6 = C.gdouble(seconds) cret = C.gst_date_time_new_local_time(carg1, carg2, carg3, carg4, carg5, carg6) runtime.KeepAlive(year) runtime.KeepAlive(month) runtime.KeepAlive(day) runtime.KeepAlive(hour) runtime.KeepAlive(minute) runtime.KeepAlive(seconds) var goret *DateTime if cret != nil { goret = UnsafeDateTimeFromGlibFull(unsafe.Pointer(cret)) } return goret } // NewDateTimeNowLocalTime wraps gst_date_time_new_now_local_time // // The function returns the following values: // // - goret *DateTime (nullable) // // Creates a new #GstDateTime representing the current date and time. func NewDateTimeNowLocalTime() *DateTime { var cret *C.GstDateTime // return, full, converted, nullable cret = C.gst_date_time_new_now_local_time() var goret *DateTime if cret != nil { goret = UnsafeDateTimeFromGlibFull(unsafe.Pointer(cret)) } return goret } // NewDateTimeNowUTC wraps gst_date_time_new_now_utc // // The function returns the following values: // // - goret *DateTime (nullable) // // Creates a new #GstDateTime that represents the current instant at Universal // coordinated time. func NewDateTimeNowUTC() *DateTime { var cret *C.GstDateTime // return, full, converted, nullable cret = C.gst_date_time_new_now_utc() var goret *DateTime if cret != nil { goret = UnsafeDateTimeFromGlibFull(unsafe.Pointer(cret)) } return goret } // NewDateTimeY wraps gst_date_time_new_y // // The function takes the following parameters: // // - year int: the gregorian year // // The function returns the following values: // // - goret *DateTime (nullable) // // Creates a new #GstDateTime using the date and times in the gregorian calendar // in the local timezone. // // @year should be from 1 to 9999. func NewDateTimeY(year int) *DateTime { var carg1 C.gint // in, none, casted var cret *C.GstDateTime // return, full, converted, nullable carg1 = C.gint(year) cret = C.gst_date_time_new_y(carg1) runtime.KeepAlive(year) var goret *DateTime if cret != nil { goret = UnsafeDateTimeFromGlibFull(unsafe.Pointer(cret)) } return goret } // NewDateTimeYM wraps gst_date_time_new_ym // // The function takes the following parameters: // // - year int: the gregorian year // - month int: the gregorian month // // The function returns the following values: // // - goret *DateTime (nullable) // // Creates a new #GstDateTime using the date and times in the gregorian calendar // in the local timezone. // // @year should be from 1 to 9999, @month should be from 1 to 12. // // If value is -1 then all over value will be ignored. For example // if @month == -1, then #GstDateTime will created only for @year. func NewDateTimeYM(year int, month int) *DateTime { var carg1 C.gint // in, none, casted var carg2 C.gint // in, none, casted var cret *C.GstDateTime // return, full, converted, nullable carg1 = C.gint(year) carg2 = C.gint(month) cret = C.gst_date_time_new_ym(carg1, carg2) runtime.KeepAlive(year) runtime.KeepAlive(month) var goret *DateTime if cret != nil { goret = UnsafeDateTimeFromGlibFull(unsafe.Pointer(cret)) } return goret } // NewDateTimeYmd wraps gst_date_time_new_ymd // // The function takes the following parameters: // // - year int: the gregorian year // - month int: the gregorian month // - day int: the day of the gregorian month // // The function returns the following values: // // - goret *DateTime (nullable) // // Creates a new #GstDateTime using the date and times in the gregorian calendar // in the local timezone. // // @year should be from 1 to 9999, @month should be from 1 to 12, @day from // 1 to 31. // // If value is -1 then all over value will be ignored. For example // if @month == -1, then #GstDateTime will created only for @year. If // @day == -1, then #GstDateTime will created for @year and @month and // so on. func NewDateTimeYmd(year int, month int, day int) *DateTime { var carg1 C.gint // in, none, casted var carg2 C.gint // in, none, casted var carg3 C.gint // in, none, casted var cret *C.GstDateTime // return, full, converted, nullable carg1 = C.gint(year) carg2 = C.gint(month) carg3 = C.gint(day) cret = C.gst_date_time_new_ymd(carg1, carg2, carg3) runtime.KeepAlive(year) runtime.KeepAlive(month) runtime.KeepAlive(day) var goret *DateTime if cret != nil { goret = UnsafeDateTimeFromGlibFull(unsafe.Pointer(cret)) } return goret } // GetDay wraps gst_date_time_get_day // // The function returns the following values: // // - goret int // // Returns the day of the month of this #GstDateTime. func (datetime *DateTime) GetDay() int { var carg0 *C.GstDateTime // in, none, converted var cret C.gint // return, none, casted carg0 = (*C.GstDateTime)(UnsafeDateTimeToGlibNone(datetime)) cret = C.gst_date_time_get_day(carg0) runtime.KeepAlive(datetime) var goret int goret = int(cret) return goret } // GetHour wraps gst_date_time_get_hour // // The function returns the following values: // // - goret int // // Retrieves the hour of the day represented by @datetime in the gregorian // calendar. The return is in the range of 0 to 23. func (datetime *DateTime) GetHour() int { var carg0 *C.GstDateTime // in, none, converted var cret C.gint // return, none, casted carg0 = (*C.GstDateTime)(UnsafeDateTimeToGlibNone(datetime)) cret = C.gst_date_time_get_hour(carg0) runtime.KeepAlive(datetime) var goret int goret = int(cret) return goret } // GetMicrosecond wraps gst_date_time_get_microsecond // // The function returns the following values: // // - goret int // // Retrieves the fractional part of the seconds in microseconds represented by // @datetime in the gregorian calendar. func (datetime *DateTime) GetMicrosecond() int { var carg0 *C.GstDateTime // in, none, converted var cret C.gint // return, none, casted carg0 = (*C.GstDateTime)(UnsafeDateTimeToGlibNone(datetime)) cret = C.gst_date_time_get_microsecond(carg0) runtime.KeepAlive(datetime) var goret int goret = int(cret) return goret } // GetMinute wraps gst_date_time_get_minute // // The function returns the following values: // // - goret int // // Retrieves the minute of the hour represented by @datetime in the gregorian // calendar. func (datetime *DateTime) GetMinute() int { var carg0 *C.GstDateTime // in, none, converted var cret C.gint // return, none, casted carg0 = (*C.GstDateTime)(UnsafeDateTimeToGlibNone(datetime)) cret = C.gst_date_time_get_minute(carg0) runtime.KeepAlive(datetime) var goret int goret = int(cret) return goret } // GetMonth wraps gst_date_time_get_month // // The function returns the following values: // // - goret int // // Returns the month of this #GstDateTime. January is 1, February is 2, etc.. func (datetime *DateTime) GetMonth() int { var carg0 *C.GstDateTime // in, none, converted var cret C.gint // return, none, casted carg0 = (*C.GstDateTime)(UnsafeDateTimeToGlibNone(datetime)) cret = C.gst_date_time_get_month(carg0) runtime.KeepAlive(datetime) var goret int goret = int(cret) return goret } // GetSecond wraps gst_date_time_get_second // // The function returns the following values: // // - goret int // // Retrieves the second of the minute represented by @datetime in the gregorian // calendar. func (datetime *DateTime) GetSecond() int { var carg0 *C.GstDateTime // in, none, converted var cret C.gint // return, none, casted carg0 = (*C.GstDateTime)(UnsafeDateTimeToGlibNone(datetime)) cret = C.gst_date_time_get_second(carg0) runtime.KeepAlive(datetime) var goret int goret = int(cret) return goret } // GetTimeZoneOffset wraps gst_date_time_get_time_zone_offset // // The function returns the following values: // // - goret float32 // // Retrieves the offset from UTC in hours that the timezone specified // by @datetime represents. Timezones ahead (to the east) of UTC have positive // values, timezones before (to the west) of UTC have negative values. // If @datetime represents UTC time, then the offset is zero. func (datetime *DateTime) GetTimeZoneOffset() float32 { var carg0 *C.GstDateTime // in, none, converted var cret C.gfloat // return, none, casted carg0 = (*C.GstDateTime)(UnsafeDateTimeToGlibNone(datetime)) cret = C.gst_date_time_get_time_zone_offset(carg0) runtime.KeepAlive(datetime) var goret float32 goret = float32(cret) return goret } // GetYear wraps gst_date_time_get_year // // The function returns the following values: // // - goret int // // Returns the year of this #GstDateTime. // Call gst_date_time_has_year() before, to avoid warnings. func (datetime *DateTime) GetYear() int { var carg0 *C.GstDateTime // in, none, converted var cret C.gint // return, none, casted carg0 = (*C.GstDateTime)(UnsafeDateTimeToGlibNone(datetime)) cret = C.gst_date_time_get_year(carg0) runtime.KeepAlive(datetime) var goret int goret = int(cret) return goret } // HasDay wraps gst_date_time_has_day // // The function returns the following values: // // - goret bool func (datetime *DateTime) HasDay() bool { var carg0 *C.GstDateTime // in, none, converted var cret C.gboolean // return carg0 = (*C.GstDateTime)(UnsafeDateTimeToGlibNone(datetime)) cret = C.gst_date_time_has_day(carg0) runtime.KeepAlive(datetime) var goret bool if cret != 0 { goret = true } return goret } // HasMonth wraps gst_date_time_has_month // // The function returns the following values: // // - goret bool func (datetime *DateTime) HasMonth() bool { var carg0 *C.GstDateTime // in, none, converted var cret C.gboolean // return carg0 = (*C.GstDateTime)(UnsafeDateTimeToGlibNone(datetime)) cret = C.gst_date_time_has_month(carg0) runtime.KeepAlive(datetime) var goret bool if cret != 0 { goret = true } return goret } // HasSecond wraps gst_date_time_has_second // // The function returns the following values: // // - goret bool func (datetime *DateTime) HasSecond() bool { var carg0 *C.GstDateTime // in, none, converted var cret C.gboolean // return carg0 = (*C.GstDateTime)(UnsafeDateTimeToGlibNone(datetime)) cret = C.gst_date_time_has_second(carg0) runtime.KeepAlive(datetime) var goret bool if cret != 0 { goret = true } return goret } // HasTime wraps gst_date_time_has_time // // The function returns the following values: // // - goret bool func (datetime *DateTime) HasTime() bool { var carg0 *C.GstDateTime // in, none, converted var cret C.gboolean // return carg0 = (*C.GstDateTime)(UnsafeDateTimeToGlibNone(datetime)) cret = C.gst_date_time_has_time(carg0) runtime.KeepAlive(datetime) var goret bool if cret != 0 { goret = true } return goret } // HasYear wraps gst_date_time_has_year // // The function returns the following values: // // - goret bool func (datetime *DateTime) HasYear() bool { var carg0 *C.GstDateTime // in, none, converted var cret C.gboolean // return carg0 = (*C.GstDateTime)(UnsafeDateTimeToGlibNone(datetime)) cret = C.gst_date_time_has_year(carg0) runtime.KeepAlive(datetime) var goret bool if cret != 0 { goret = true } return goret } // ToGDateTime wraps gst_date_time_to_g_date_time // // The function returns the following values: // // - goret *glib.DateTime (nullable) // // Creates a new #GDateTime from a fully defined #GstDateTime object. func (datetime *DateTime) ToGDateTime() *glib.DateTime { var carg0 *C.GstDateTime // in, none, converted var cret *C.GDateTime // return, full, converted, nullable carg0 = (*C.GstDateTime)(UnsafeDateTimeToGlibNone(datetime)) cret = C.gst_date_time_to_g_date_time(carg0) runtime.KeepAlive(datetime) var goret *glib.DateTime if cret != nil { goret = glib.UnsafeDateTimeFromGlibFull(unsafe.Pointer(cret)) } return goret } // ToISO8601String wraps gst_date_time_to_iso8601_string // // The function returns the following values: // // - goret string (nullable) // // Create a minimal string compatible with ISO-8601. Possible output formats // are (for example): `2012`, `2012-06`, `2012-06-23`, `2012-06-23T23:30Z`, // `2012-06-23T23:30+0100`, `2012-06-23T23:30:59Z`, `2012-06-23T23:30:59+0100` func (datetime *DateTime) ToISO8601String() string { var carg0 *C.GstDateTime // in, none, converted var cret *C.gchar // return, full, string, nullable-string carg0 = (*C.GstDateTime)(UnsafeDateTimeToGlibNone(datetime)) cret = C.gst_date_time_to_iso8601_string(carg0) runtime.KeepAlive(datetime) var goret string if cret != nil { goret = C.GoString((*C.char)(unsafe.Pointer(cret))) defer C.free(unsafe.Pointer(cret)) } return goret } // DebugCategory wraps GstDebugCategory // // This is the struct that describes the categories. Once initialized with // #GST_DEBUG_CATEGORY_INIT, its values can't be changed anymore. type DebugCategory struct { *debugCategory } // debugCategory is the struct that's finalized type debugCategory struct { native *C.GstDebugCategory } // UnsafeDebugCategoryFromGlibBorrow is used to convert raw C.GstDebugCategory pointers to go. This is used by the bindings internally. func UnsafeDebugCategoryFromGlibBorrow(p unsafe.Pointer) *DebugCategory { return &DebugCategory{&debugCategory{(*C.GstDebugCategory)(p)}} } // 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) runtime.SetFinalizer( wrapped.debugCategory, func (intern *debugCategory) { C.gst_debug_category_free(intern.native) }, ) return wrapped } // 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( wrapped.debugCategory, func (intern *debugCategory) { C.gst_debug_category_free(intern.native) }, ) return wrapped } // UnsafeDebugCategoryFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [DebugCategory] is expected to work anymore. func UnsafeDebugCategoryFree(d *DebugCategory) { C.gst_debug_category_free(d.native) } // UnsafeDebugCategoryToGlibNone returns the underlying C pointer. This is used by the bindings internally. func UnsafeDebugCategoryToGlibNone(d *DebugCategory) unsafe.Pointer { return unsafe.Pointer(d.native) } // UnsafeDebugCategoryToGlibFull returns the underlying C pointer and gives up ownership. // This is used by the bindings internally. func UnsafeDebugCategoryToGlibFull(d *DebugCategory) unsafe.Pointer { runtime.SetFinalizer(d.debugCategory, nil) _p := unsafe.Pointer(d.native) 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 // // Returns the color of a debug category used when printing output in this // category. func (category *DebugCategory) GetColor() uint { var carg0 *C.GstDebugCategory // in, none, converted var cret C.guint // return, none, casted carg0 = (*C.GstDebugCategory)(UnsafeDebugCategoryToGlibNone(category)) cret = C.gst_debug_category_get_color(carg0) runtime.KeepAlive(category) var goret uint goret = uint(cret) return goret } // GetDescription wraps gst_debug_category_get_description // // The function returns the following values: // // - goret string // // Returns the description of a debug category. func (category *DebugCategory) GetDescription() string { var carg0 *C.GstDebugCategory // in, none, converted var cret *C.gchar // return, none, string carg0 = (*C.GstDebugCategory)(UnsafeDebugCategoryToGlibNone(category)) cret = C.gst_debug_category_get_description(carg0) runtime.KeepAlive(category) var goret string goret = C.GoString((*C.char)(unsafe.Pointer(cret))) return goret } // GetName wraps gst_debug_category_get_name // // The function returns the following values: // // - goret string // // Returns the name of a debug category. func (category *DebugCategory) GetName() string { var carg0 *C.GstDebugCategory // in, none, converted var cret *C.gchar // return, none, string carg0 = (*C.GstDebugCategory)(UnsafeDebugCategoryToGlibNone(category)) cret = C.gst_debug_category_get_name(carg0) runtime.KeepAlive(category) var goret string goret = C.GoString((*C.char)(unsafe.Pointer(cret))) return goret } // GetThreshold wraps gst_debug_category_get_threshold // // The function returns the following values: // // - goret DebugLevel // // Returns the threshold of a #GstDebugCategory. func (category *DebugCategory) GetThreshold() DebugLevel { var carg0 *C.GstDebugCategory // in, none, converted var cret C.GstDebugLevel // return, none, casted carg0 = (*C.GstDebugCategory)(UnsafeDebugCategoryToGlibNone(category)) cret = C.gst_debug_category_get_threshold(carg0) runtime.KeepAlive(category) var goret DebugLevel goret = DebugLevel(cret) return goret } // ResetThreshold wraps gst_debug_category_reset_threshold // // Resets the threshold of the category to the default level. Debug information // will only be output if the threshold is lower or equal to the level of the // debugging message. // Use this function to set the threshold back to where it was after using // gst_debug_category_set_threshold(). func (category *DebugCategory) ResetThreshold() { var carg0 *C.GstDebugCategory // in, none, converted carg0 = (*C.GstDebugCategory)(UnsafeDebugCategoryToGlibNone(category)) C.gst_debug_category_reset_threshold(carg0) runtime.KeepAlive(category) } // SetThreshold wraps gst_debug_category_set_threshold // // The function takes the following parameters: // // - level DebugLevel: the #GstDebugLevel threshold to set. // // Sets the threshold of the category to the given level. Debug information will // only be output if the threshold is lower or equal to the level of the // debugging message. // > Do not use this function in production code, because other functions may // > change the threshold of categories as side effect. It is however a nice // > function to use when debugging (even from gdb). func (category *DebugCategory) SetThreshold(level DebugLevel) { var carg0 *C.GstDebugCategory // in, none, converted var carg1 C.GstDebugLevel // in, none, casted carg0 = (*C.GstDebugCategory)(UnsafeDebugCategoryToGlibNone(category)) carg1 = C.GstDebugLevel(level) C.gst_debug_category_set_threshold(carg0, carg1) runtime.KeepAlive(category) runtime.KeepAlive(level) } // DebugMessage wraps GstDebugMessage type DebugMessage struct { *debugMessage } // debugMessage is the struct that's finalized type debugMessage struct { native *C.GstDebugMessage } // UnsafeDebugMessageFromGlibBorrow is used to convert raw C.GstDebugMessage pointers to go. This is used by the bindings internally. func UnsafeDebugMessageFromGlibBorrow(p unsafe.Pointer) *DebugMessage { return &DebugMessage{&debugMessage{(*C.GstDebugMessage)(p)}} } // 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) runtime.SetFinalizer( wrapped.debugMessage, func (intern *debugMessage) { C.free(unsafe.Pointer(intern.native)) }, ) return wrapped } // 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( wrapped.debugMessage, func (intern *debugMessage) { C.free(unsafe.Pointer(intern.native)) }, ) return wrapped } // UnsafeDebugMessageFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [DebugMessage] is expected to work anymore. func UnsafeDebugMessageFree(d *DebugMessage) { C.free(unsafe.Pointer(d.native)) } // UnsafeDebugMessageToGlibNone returns the underlying C pointer. This is used by the bindings internally. func UnsafeDebugMessageToGlibNone(d *DebugMessage) unsafe.Pointer { return unsafe.Pointer(d.native) } // UnsafeDebugMessageToGlibFull returns the underlying C pointer and gives up ownership. // This is used by the bindings internally. func UnsafeDebugMessageToGlibFull(d *DebugMessage) unsafe.Pointer { runtime.SetFinalizer(d.debugMessage, nil) _p := unsafe.Pointer(d.native) 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) // // Gets the string representation of a #GstDebugMessage. This function is used // in debug handlers to extract the message. func (message *DebugMessage) Get() string { var carg0 *C.GstDebugMessage // in, none, converted var cret *C.gchar // return, none, string, nullable-string carg0 = (*C.GstDebugMessage)(UnsafeDebugMessageToGlibNone(message)) cret = C.gst_debug_message_get(carg0) runtime.KeepAlive(message) var goret string if cret != nil { goret = C.GoString((*C.char)(unsafe.Pointer(cret))) } return goret } // GetID wraps gst_debug_message_get_id // // The function returns the following values: // // - goret string (nullable) // // Get the id of the object that emitted this message. This function is used in // debug handlers. Can be empty. func (message *DebugMessage) GetID() string { var carg0 *C.GstDebugMessage // in, none, converted var cret *C.gchar // return, none, string, nullable-string carg0 = (*C.GstDebugMessage)(UnsafeDebugMessageToGlibNone(message)) cret = C.gst_debug_message_get_id(carg0) runtime.KeepAlive(message) var goret string if cret != nil { goret = C.GoString((*C.char)(unsafe.Pointer(cret))) } return goret } // DeviceClass wraps GstDeviceClass // // The class structure for a #GstDevice object. // // DeviceClass is the type struct for [Device] type DeviceClass struct { *deviceClass } // deviceClass is the struct that's finalized type deviceClass struct { native *C.GstDeviceClass } // UnsafeDeviceClassFromGlibBorrow is used to convert raw C.GstDeviceClass pointers to go. This is used by the bindings internally. func UnsafeDeviceClassFromGlibBorrow(p unsafe.Pointer) *DeviceClass { return &DeviceClass{&deviceClass{(*C.GstDeviceClass)(p)}} } // 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. func UnsafeDeviceClassFree(d *DeviceClass) { C.free(unsafe.Pointer(d.native)) } // UnsafeDeviceClassToGlibNone returns the underlying C pointer. This is used by the bindings internally. func UnsafeDeviceClassToGlibNone(d *DeviceClass) unsafe.Pointer { return unsafe.Pointer(d.native) } // 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 } // deviceMonitorClass is the struct that's finalized type deviceMonitorClass struct { native *C.GstDeviceMonitorClass } // UnsafeDeviceMonitorClassFromGlibBorrow is used to convert raw C.GstDeviceMonitorClass pointers to go. This is used by the bindings internally. func UnsafeDeviceMonitorClassFromGlibBorrow(p unsafe.Pointer) *DeviceMonitorClass { return &DeviceMonitorClass{&deviceMonitorClass{(*C.GstDeviceMonitorClass)(p)}} } // 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. func UnsafeDeviceMonitorClassFree(d *DeviceMonitorClass) { C.free(unsafe.Pointer(d.native)) } // UnsafeDeviceMonitorClassToGlibNone returns the underlying C pointer. This is used by the bindings internally. func UnsafeDeviceMonitorClassToGlibNone(d *DeviceMonitorClass) unsafe.Pointer { return unsafe.Pointer(d.native) } // 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 } // deviceProviderClass is the struct that's finalized type deviceProviderClass struct { native *C.GstDeviceProviderClass } // UnsafeDeviceProviderClassFromGlibBorrow is used to convert raw C.GstDeviceProviderClass pointers to go. This is used by the bindings internally. func UnsafeDeviceProviderClassFromGlibBorrow(p unsafe.Pointer) *DeviceProviderClass { return &DeviceProviderClass{&deviceProviderClass{(*C.GstDeviceProviderClass)(p)}} } // 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. func UnsafeDeviceProviderClassFree(d *DeviceProviderClass) { C.free(unsafe.Pointer(d.native)) } // UnsafeDeviceProviderClassToGlibNone returns the underlying C pointer. This is used by the bindings internally. func UnsafeDeviceProviderClassToGlibNone(d *DeviceProviderClass) unsafe.Pointer { return unsafe.Pointer(d.native) } // 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: // // - key string: the key to set // - value string: the value to set // // Set @key with @value as metadata in @klass. func (klass *DeviceProviderClass) AddMetadata(key string, value string) { var carg0 *C.GstDeviceProviderClass // in, none, converted var carg1 *C.gchar // in, none, string var carg2 *C.gchar // in, none, string carg0 = (*C.GstDeviceProviderClass)(UnsafeDeviceProviderClassToGlibNone(klass)) carg1 = (*C.gchar)(unsafe.Pointer(C.CString(key))) defer C.free(unsafe.Pointer(carg1)) carg2 = (*C.gchar)(unsafe.Pointer(C.CString(value))) defer C.free(unsafe.Pointer(carg2)) C.gst_device_provider_class_add_metadata(carg0, carg1, carg2) runtime.KeepAlive(klass) runtime.KeepAlive(key) runtime.KeepAlive(value) } // AddStaticMetadata wraps gst_device_provider_class_add_static_metadata // // The function takes the following parameters: // // - key string: the key to set // - value string: the value to set // // Set @key with @value as metadata in @klass. // // Same as gst_device_provider_class_add_metadata(), but @value must be a static string // or an inlined string, as it will not be copied. (GStreamer plugins will // be made resident once loaded, so this function can be used even from // dynamically loaded plugins.) func (klass *DeviceProviderClass) AddStaticMetadata(key string, value string) { var carg0 *C.GstDeviceProviderClass // in, none, converted var carg1 *C.gchar // in, none, string var carg2 *C.gchar // in, full, string carg0 = (*C.GstDeviceProviderClass)(UnsafeDeviceProviderClassToGlibNone(klass)) carg1 = (*C.gchar)(unsafe.Pointer(C.CString(key))) defer C.free(unsafe.Pointer(carg1)) carg2 = (*C.gchar)(unsafe.Pointer(C.CString(value))) C.gst_device_provider_class_add_static_metadata(carg0, carg1, carg2) runtime.KeepAlive(klass) runtime.KeepAlive(key) runtime.KeepAlive(value) } // GetMetadata wraps gst_device_provider_class_get_metadata // // The function takes the following parameters: // // - key string: the key to get // // The function returns the following values: // // - goret string (nullable) // // Get metadata with @key in @klass. func (klass *DeviceProviderClass) GetMetadata(key string) string { var carg0 *C.GstDeviceProviderClass // in, none, converted var carg1 *C.gchar // in, none, string var cret *C.gchar // return, none, string, nullable-string carg0 = (*C.GstDeviceProviderClass)(UnsafeDeviceProviderClassToGlibNone(klass)) carg1 = (*C.gchar)(unsafe.Pointer(C.CString(key))) defer C.free(unsafe.Pointer(carg1)) cret = C.gst_device_provider_class_get_metadata(carg0, carg1) runtime.KeepAlive(klass) runtime.KeepAlive(key) var goret string if cret != nil { goret = C.GoString((*C.char)(unsafe.Pointer(cret))) } return goret } // SetMetadata wraps gst_device_provider_class_set_metadata // // The function takes the following parameters: // // - longname string: The long English name of the device provider. E.g. "File Sink" // - classification string: String describing the type of device provider, as an // unordered list separated with slashes ('/'). See draft-klass.txt of the // design docs // for more details and common types. E.g: "Sink/File" // - description string: Sentence describing the purpose of the device provider. // E.g: "Write stream to a file" // - author string: Name and contact details of the author(s). Use \n to separate // multiple author metadata. E.g: "Joe Bloggs &lt;joe.blogs at foo.com&gt;" // // Sets the detailed information for a #GstDeviceProviderClass. // // > This function is for use in _class_init functions only. func (klass *DeviceProviderClass) SetMetadata(longname string, classification string, description string, author string) { var carg0 *C.GstDeviceProviderClass // in, none, converted var carg1 *C.gchar // in, none, string var carg2 *C.gchar // in, none, string var carg3 *C.gchar // in, none, string var carg4 *C.gchar // in, none, string carg0 = (*C.GstDeviceProviderClass)(UnsafeDeviceProviderClassToGlibNone(klass)) carg1 = (*C.gchar)(unsafe.Pointer(C.CString(longname))) defer C.free(unsafe.Pointer(carg1)) carg2 = (*C.gchar)(unsafe.Pointer(C.CString(classification))) defer C.free(unsafe.Pointer(carg2)) carg3 = (*C.gchar)(unsafe.Pointer(C.CString(description))) defer C.free(unsafe.Pointer(carg3)) carg4 = (*C.gchar)(unsafe.Pointer(C.CString(author))) defer C.free(unsafe.Pointer(carg4)) C.gst_device_provider_class_set_metadata(carg0, carg1, carg2, carg3, carg4) runtime.KeepAlive(klass) runtime.KeepAlive(longname) runtime.KeepAlive(classification) runtime.KeepAlive(description) runtime.KeepAlive(author) } // SetStaticMetadata wraps gst_device_provider_class_set_static_metadata // // The function takes the following parameters: // // - longname string: The long English name of the element. E.g. "File Sink" // - classification string: String describing the type of element, as // an unordered list separated with slashes ('/'). See draft-klass.txt of the // design docs for more details and common types. E.g: "Sink/File" // - description string: Sentence describing the purpose of the // element. E.g: "Write stream to a file" // - author string: Name and contact details of the author(s). Use \n // to separate multiple author metadata. E.g: "Joe Bloggs &lt;joe.blogs at // foo.com&gt;" // // Sets the detailed information for a #GstDeviceProviderClass. // // > This function is for use in _class_init functions only. // // Same as gst_device_provider_class_set_metadata(), but @longname, @classification, // @description, and @author must be static strings or inlined strings, as // they will not be copied. (GStreamer plugins will be made resident once // loaded, so this function can be used even from dynamically loaded plugins.) func (klass *DeviceProviderClass) SetStaticMetadata(longname string, classification string, description string, author string) { var carg0 *C.GstDeviceProviderClass // in, none, converted var carg1 *C.gchar // in, full, string var carg2 *C.gchar // in, full, string var carg3 *C.gchar // in, full, string var carg4 *C.gchar // in, full, string carg0 = (*C.GstDeviceProviderClass)(UnsafeDeviceProviderClassToGlibNone(klass)) carg1 = (*C.gchar)(unsafe.Pointer(C.CString(longname))) carg2 = (*C.gchar)(unsafe.Pointer(C.CString(classification))) carg3 = (*C.gchar)(unsafe.Pointer(C.CString(description))) carg4 = (*C.gchar)(unsafe.Pointer(C.CString(author))) C.gst_device_provider_class_set_static_metadata(carg0, carg1, carg2, carg3, carg4) runtime.KeepAlive(klass) runtime.KeepAlive(longname) runtime.KeepAlive(classification) runtime.KeepAlive(description) runtime.KeepAlive(author) } // DeviceProviderFactoryClass wraps GstDeviceProviderFactoryClass // // The opaque #GstDeviceProviderFactoryClass data structure. // // DeviceProviderFactoryClass is the type struct for [DeviceProviderFactory] type DeviceProviderFactoryClass struct { *deviceProviderFactoryClass } // deviceProviderFactoryClass is the struct that's finalized type deviceProviderFactoryClass struct { native *C.GstDeviceProviderFactoryClass } // UnsafeDeviceProviderFactoryClassFromGlibBorrow is used to convert raw C.GstDeviceProviderFactoryClass pointers to go. This is used by the bindings internally. func UnsafeDeviceProviderFactoryClassFromGlibBorrow(p unsafe.Pointer) *DeviceProviderFactoryClass { return &DeviceProviderFactoryClass{&deviceProviderFactoryClass{(*C.GstDeviceProviderFactoryClass)(p)}} } // 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. func UnsafeDeviceProviderFactoryClassFree(d *DeviceProviderFactoryClass) { C.free(unsafe.Pointer(d.native)) } // UnsafeDeviceProviderFactoryClassToGlibNone returns the underlying C pointer. This is used by the bindings internally. func UnsafeDeviceProviderFactoryClassToGlibNone(d *DeviceProviderFactoryClass) unsafe.Pointer { return unsafe.Pointer(d.native) } // 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 } // dynamicTypeFactoryClass is the struct that's finalized type dynamicTypeFactoryClass struct { native *C.GstDynamicTypeFactoryClass } // UnsafeDynamicTypeFactoryClassFromGlibBorrow is used to convert raw C.GstDynamicTypeFactoryClass pointers to go. This is used by the bindings internally. func UnsafeDynamicTypeFactoryClassFromGlibBorrow(p unsafe.Pointer) *DynamicTypeFactoryClass { return &DynamicTypeFactoryClass{&dynamicTypeFactoryClass{(*C.GstDynamicTypeFactoryClass)(p)}} } // 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. func UnsafeDynamicTypeFactoryClassFree(d *DynamicTypeFactoryClass) { C.free(unsafe.Pointer(d.native)) } // UnsafeDynamicTypeFactoryClassToGlibNone returns the underlying C pointer. This is used by the bindings internally. func UnsafeDynamicTypeFactoryClassToGlibNone(d *DynamicTypeFactoryClass) unsafe.Pointer { return unsafe.Pointer(d.native) } // 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 } // elementClass is the struct that's finalized type elementClass struct { native *C.GstElementClass } // UnsafeElementClassFromGlibBorrow is used to convert raw C.GstElementClass pointers to go. This is used by the bindings internally. func UnsafeElementClassFromGlibBorrow(p unsafe.Pointer) *ElementClass { return &ElementClass{&elementClass{(*C.GstElementClass)(p)}} } // 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. func UnsafeElementClassFree(e *ElementClass) { C.free(unsafe.Pointer(e.native)) } // UnsafeElementClassToGlibNone returns the underlying C pointer. This is used by the bindings internally. func UnsafeElementClassToGlibNone(e *ElementClass) unsafe.Pointer { return unsafe.Pointer(e.native) } // 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: // // - key string: the key to set // - value string: the value to set // // Set @key with @value as metadata in @klass. func (klass *ElementClass) AddMetadata(key string, value string) { var carg0 *C.GstElementClass // in, none, converted var carg1 *C.gchar // in, none, string var carg2 *C.gchar // in, none, string carg0 = (*C.GstElementClass)(UnsafeElementClassToGlibNone(klass)) carg1 = (*C.gchar)(unsafe.Pointer(C.CString(key))) defer C.free(unsafe.Pointer(carg1)) carg2 = (*C.gchar)(unsafe.Pointer(C.CString(value))) defer C.free(unsafe.Pointer(carg2)) C.gst_element_class_add_metadata(carg0, carg1, carg2) runtime.KeepAlive(klass) runtime.KeepAlive(key) runtime.KeepAlive(value) } // AddPadTemplate wraps gst_element_class_add_pad_template // // The function takes the following parameters: // // - templ PadTemplate: a #GstPadTemplate to add to the element class. // // Adds a padtemplate to an element class. This is mainly used in the _class_init // functions of classes. If a pad template with the same name as an already // existing one is added the old one is replaced by the new one. // // @templ's reference count will be incremented, and any floating // reference will be removed (see gst_object_ref_sink()) func (klass *ElementClass) AddPadTemplate(templ PadTemplate) { var carg0 *C.GstElementClass // in, none, converted var carg1 *C.GstPadTemplate // in, none, converted carg0 = (*C.GstElementClass)(UnsafeElementClassToGlibNone(klass)) carg1 = (*C.GstPadTemplate)(UnsafePadTemplateToGlibNone(templ)) C.gst_element_class_add_pad_template(carg0, carg1) runtime.KeepAlive(klass) runtime.KeepAlive(templ) } // AddStaticMetadata wraps gst_element_class_add_static_metadata // // The function takes the following parameters: // // - key string: the key to set // - value string: the value to set // // Set @key with @value as metadata in @klass. // // Same as gst_element_class_add_metadata(), but @value must be a static string // or an inlined string, as it will not be copied. (GStreamer plugins will // be made resident once loaded, so this function can be used even from // dynamically loaded plugins.) func (klass *ElementClass) AddStaticMetadata(key string, value string) { var carg0 *C.GstElementClass // in, none, converted var carg1 *C.gchar // in, none, string var carg2 *C.gchar // in, none, string carg0 = (*C.GstElementClass)(UnsafeElementClassToGlibNone(klass)) carg1 = (*C.gchar)(unsafe.Pointer(C.CString(key))) defer C.free(unsafe.Pointer(carg1)) carg2 = (*C.gchar)(unsafe.Pointer(C.CString(value))) defer C.free(unsafe.Pointer(carg2)) C.gst_element_class_add_static_metadata(carg0, carg1, carg2) runtime.KeepAlive(klass) runtime.KeepAlive(key) runtime.KeepAlive(value) } // AddStaticPadTemplate wraps gst_element_class_add_static_pad_template // // The function takes the following parameters: // // - staticTempl *StaticPadTemplate: #GstStaticPadTemplate to add as pad template to the element class. // // Adds a pad template to an element class based on the static pad template // @templ. This is mainly used in the _class_init functions of element // implementations. If a pad template with the same name already exists, // the old one is replaced by the new one. func (klass *ElementClass) AddStaticPadTemplate(staticTempl *StaticPadTemplate) { var carg0 *C.GstElementClass // in, none, converted var carg1 *C.GstStaticPadTemplate // in, none, converted carg0 = (*C.GstElementClass)(UnsafeElementClassToGlibNone(klass)) carg1 = (*C.GstStaticPadTemplate)(UnsafeStaticPadTemplateToGlibNone(staticTempl)) C.gst_element_class_add_static_pad_template(carg0, carg1) runtime.KeepAlive(klass) runtime.KeepAlive(staticTempl) } // AddStaticPadTemplateWithGType wraps gst_element_class_add_static_pad_template_with_gtype // // The function takes the following parameters: // // - staticTempl *StaticPadTemplate: #GstStaticPadTemplate to add as pad template to the element class. // - padType gobject.Type: The #GType of the pad to create // // Adds a pad template to an element class based on the static pad template // @templ. This is mainly used in the _class_init functions of element // implementations. If a pad template with the same name already exists, // the old one is replaced by the new one. func (klass *ElementClass) AddStaticPadTemplateWithGType(staticTempl *StaticPadTemplate, padType gobject.Type) { var carg0 *C.GstElementClass // in, none, converted var carg1 *C.GstStaticPadTemplate // in, none, converted var carg2 C.GType // in, none, casted, alias carg0 = (*C.GstElementClass)(UnsafeElementClassToGlibNone(klass)) carg1 = (*C.GstStaticPadTemplate)(UnsafeStaticPadTemplateToGlibNone(staticTempl)) carg2 = C.GType(padType) C.gst_element_class_add_static_pad_template_with_gtype(carg0, carg1, carg2) runtime.KeepAlive(klass) runtime.KeepAlive(staticTempl) runtime.KeepAlive(padType) } // GetMetadata wraps gst_element_class_get_metadata // // The function takes the following parameters: // // - key string: the key to get // // The function returns the following values: // // - goret string // // Get metadata with @key in @klass. func (klass *ElementClass) GetMetadata(key string) string { var carg0 *C.GstElementClass // in, none, converted var carg1 *C.gchar // in, none, string var cret *C.gchar // return, none, string carg0 = (*C.GstElementClass)(UnsafeElementClassToGlibNone(klass)) carg1 = (*C.gchar)(unsafe.Pointer(C.CString(key))) defer C.free(unsafe.Pointer(carg1)) cret = C.gst_element_class_get_metadata(carg0, carg1) runtime.KeepAlive(klass) runtime.KeepAlive(key) var goret string goret = C.GoString((*C.char)(unsafe.Pointer(cret))) return goret } // GetPadTemplate wraps gst_element_class_get_pad_template // // The function takes the following parameters: // // - name string: the name of the #GstPadTemplate to get. // // The function returns the following values: // // - goret PadTemplate (nullable) // // Retrieves a padtemplate from @element_class with the given name. // > If you use this function in the GInstanceInitFunc of an object class // > that has subclasses, make sure to pass the g_class parameter of the // > GInstanceInitFunc here. func (elementClass *ElementClass) GetPadTemplate(name string) PadTemplate { var carg0 *C.GstElementClass // in, none, converted var carg1 *C.gchar // in, none, string var cret *C.GstPadTemplate // return, none, converted, nullable carg0 = (*C.GstElementClass)(UnsafeElementClassToGlibNone(elementClass)) carg1 = (*C.gchar)(unsafe.Pointer(C.CString(name))) defer C.free(unsafe.Pointer(carg1)) cret = C.gst_element_class_get_pad_template(carg0, carg1) runtime.KeepAlive(elementClass) runtime.KeepAlive(name) var goret PadTemplate if cret != nil { goret = UnsafePadTemplateFromGlibNone(unsafe.Pointer(cret)) } return goret } // GetPadTemplateList wraps gst_element_class_get_pad_template_list // // The function returns the following values: // // - goret []PadTemplate // // Retrieves a list of the pad templates associated with @element_class. The // list must not be modified by the calling code. // > If you use this function in the GInstanceInitFunc of an object class // > that has subclasses, make sure to pass the g_class parameter of the // > GInstanceInitFunc here. func (elementClass *ElementClass) GetPadTemplateList() []PadTemplate { var carg0 *C.GstElementClass // in, none, converted var cret *C.GList // container, transfer: none carg0 = (*C.GstElementClass)(UnsafeElementClassToGlibNone(elementClass)) cret = C.gst_element_class_get_pad_template_list(carg0) runtime.KeepAlive(elementClass) var goret []PadTemplate goret = glib.UnsafeListFromGlibNone( unsafe.Pointer(cret), func(v unsafe.Pointer) PadTemplate { var dst PadTemplate // converted dst = UnsafePadTemplateFromGlibNone(v) return dst }, ) return goret } // SetMetadata wraps gst_element_class_set_metadata // // The function takes the following parameters: // // - longname string: The long English name of the element. E.g. "File Sink" // - classification string: String describing the type of element, as an unordered list // separated with slashes ('/'). See draft-klass.txt of the design docs // for more details and common types. E.g: "Sink/File" // - description string: Sentence describing the purpose of the element. // E.g: "Write stream to a file" // - author string: Name and contact details of the author(s). Use \n to separate // multiple author metadata. E.g: "Joe Bloggs &lt;joe.blogs at foo.com&gt;" // // Sets the detailed information for a #GstElementClass. // > This function is for use in _class_init functions only. func (klass *ElementClass) SetMetadata(longname string, classification string, description string, author string) { var carg0 *C.GstElementClass // in, none, converted var carg1 *C.gchar // in, none, string var carg2 *C.gchar // in, none, string var carg3 *C.gchar // in, none, string var carg4 *C.gchar // in, none, string carg0 = (*C.GstElementClass)(UnsafeElementClassToGlibNone(klass)) carg1 = (*C.gchar)(unsafe.Pointer(C.CString(longname))) defer C.free(unsafe.Pointer(carg1)) carg2 = (*C.gchar)(unsafe.Pointer(C.CString(classification))) defer C.free(unsafe.Pointer(carg2)) carg3 = (*C.gchar)(unsafe.Pointer(C.CString(description))) defer C.free(unsafe.Pointer(carg3)) carg4 = (*C.gchar)(unsafe.Pointer(C.CString(author))) defer C.free(unsafe.Pointer(carg4)) C.gst_element_class_set_metadata(carg0, carg1, carg2, carg3, carg4) runtime.KeepAlive(klass) runtime.KeepAlive(longname) runtime.KeepAlive(classification) runtime.KeepAlive(description) runtime.KeepAlive(author) } // SetStaticMetadata wraps gst_element_class_set_static_metadata // // The function takes the following parameters: // // - longname string: The long English name of the element. E.g. "File Sink" // - classification string: String describing the type of element, as an unordered list // separated with slashes ('/'). See draft-klass.txt of the design docs // for more details and common types. E.g: "Sink/File" // - description string: Sentence describing the purpose of the element. // E.g: "Write stream to a file" // - author string: Name and contact details of the author(s). Use \n to separate // multiple author metadata. E.g: "Joe Bloggs &lt;joe.blogs at foo.com&gt;" // // Sets the detailed information for a #GstElementClass. // // > This function is for use in _class_init functions only. // // Same as gst_element_class_set_metadata(), but @longname, @classification, // @description, and @author must be static strings or inlined strings, as // they will not be copied. (GStreamer plugins will be made resident once // loaded, so this function can be used even from dynamically loaded plugins.) func (klass *ElementClass) SetStaticMetadata(longname string, classification string, description string, author string) { var carg0 *C.GstElementClass // in, none, converted var carg1 *C.gchar // in, none, string var carg2 *C.gchar // in, none, string var carg3 *C.gchar // in, none, string var carg4 *C.gchar // in, none, string carg0 = (*C.GstElementClass)(UnsafeElementClassToGlibNone(klass)) carg1 = (*C.gchar)(unsafe.Pointer(C.CString(longname))) defer C.free(unsafe.Pointer(carg1)) carg2 = (*C.gchar)(unsafe.Pointer(C.CString(classification))) defer C.free(unsafe.Pointer(carg2)) carg3 = (*C.gchar)(unsafe.Pointer(C.CString(description))) defer C.free(unsafe.Pointer(carg3)) carg4 = (*C.gchar)(unsafe.Pointer(C.CString(author))) defer C.free(unsafe.Pointer(carg4)) C.gst_element_class_set_static_metadata(carg0, carg1, carg2, carg3, carg4) runtime.KeepAlive(klass) runtime.KeepAlive(longname) runtime.KeepAlive(classification) runtime.KeepAlive(description) runtime.KeepAlive(author) } // ElementFactoryClass wraps GstElementFactoryClass // // ElementFactoryClass is the type struct for [ElementFactory] type ElementFactoryClass struct { *elementFactoryClass } // elementFactoryClass is the struct that's finalized type elementFactoryClass struct { native *C.GstElementFactoryClass } // UnsafeElementFactoryClassFromGlibBorrow is used to convert raw C.GstElementFactoryClass pointers to go. This is used by the bindings internally. func UnsafeElementFactoryClassFromGlibBorrow(p unsafe.Pointer) *ElementFactoryClass { return &ElementFactoryClass{&elementFactoryClass{(*C.GstElementFactoryClass)(p)}} } // 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. func UnsafeElementFactoryClassFree(e *ElementFactoryClass) { C.free(unsafe.Pointer(e.native)) } // UnsafeElementFactoryClassToGlibNone returns the underlying C pointer. This is used by the bindings internally. func UnsafeElementFactoryClassToGlibNone(e *ElementFactoryClass) unsafe.Pointer { return unsafe.Pointer(e.native) } // 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 // and functions to query (parse) received events. // // Events are usually created with gst_event_new_*() which takes event-type // specific parameters as arguments. // To send an event application will usually use gst_element_send_event() and // elements will use gst_pad_send_event() or gst_pad_push_event(). // The event should be unreffed with gst_event_unref() if it has not been sent. // // Events that have been received can be parsed with their respective // gst_event_parse_*() functions. It is valid to pass %NULL for unwanted details. // // Events are passed between elements in parallel to the data stream. Some events // are serialized with buffers, others are not. Some events only travel downstream, // others only upstream. Some events can travel both upstream and downstream. // // The events are used to signal special conditions in the datastream such as // EOS (end of stream) or the start of a new stream-segment. // Events are also used to flush the pipeline of any pending data. // // Most of the event API is used inside plugins. Applications usually only // construct and use seek events. // To do that gst_event_new_seek() is used to create a seek event. It takes // the needed parameters to specify seeking time and mode. // |[<!-- language="C" --> // GstEvent *event; // gboolean result; // ... // // construct a seek event to play the media from second 2 to 5, flush // // the pipeline to decrease latency. // event = gst_event_new_seek (1.0, // GST_FORMAT_TIME, // GST_SEEK_FLAG_FLUSH, // GST_SEEK_TYPE_SET, 2 * GST_SECOND, // GST_SEEK_TYPE_SET, 5 * GST_SECOND); // ... // result = gst_element_send_event (pipeline, event); // if (!result) // g_warning ("seek failed"); // ... // ]| type Event struct { *event } // event is the struct that's finalized type event struct { native *C.GstEvent } var _ gobject.GoValueInitializer = (*Event)(nil) func marshalEvent(p unsafe.Pointer) (interface{}, error) { b := gobject.ValueFromNative(p).Boxed() return UnsafeEventFromGlibBorrow(b), nil } func (r *Event) InitGoValue(v *gobject.Value) { v.Init(TypeEvent) v.SetBoxed(unsafe.Pointer(r.native)) } // UnsafeEventFromGlibBorrow is used to convert raw C.GstEvent pointers to go. This is used by the bindings internally. func UnsafeEventFromGlibBorrow(p unsafe.Pointer) *Event { return &Event{&event{(*C.GstEvent)(p)}} } // 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) runtime.SetFinalizer( wrapped.event, func (intern *event) { C.free(unsafe.Pointer(intern.native)) }, ) return wrapped } // 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( wrapped.event, func (intern *event) { C.free(unsafe.Pointer(intern.native)) }, ) return wrapped } // UnsafeEventFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [Event] is expected to work anymore. func UnsafeEventFree(e *Event) { C.free(unsafe.Pointer(e.native)) } // UnsafeEventToGlibNone returns the underlying C pointer. This is used by the bindings internally. func UnsafeEventToGlibNone(e *Event) unsafe.Pointer { return unsafe.Pointer(e.native) } // UnsafeEventToGlibFull returns the underlying C pointer and gives up ownership. // This is used by the bindings internally. func UnsafeEventToGlibFull(e *Event) unsafe.Pointer { runtime.SetFinalizer(e.event, nil) _p := unsafe.Pointer(e.native) e.native = nil // Event is invalid from here on return _p } // NewEventBufferSize wraps gst_event_new_buffer_size // // The function takes the following parameters: // // - format Format: buffer format // - minsize int64: minimum buffer size // - maxsize int64: maximum buffer size // - async bool: thread behavior // // The function returns the following values: // // - goret *Event // // Create a new buffersize event. The event is sent downstream and notifies // elements that they should provide a buffer of the specified dimensions. // // When the @async flag is set, a thread boundary is preferred. func NewEventBufferSize(format Format, minsize int64, maxsize int64, async bool) *Event { var carg1 C.GstFormat // in, none, casted var carg2 C.gint64 // in, none, casted var carg3 C.gint64 // in, none, casted var carg4 C.gboolean // in var cret *C.GstEvent // return, full, converted carg1 = C.GstFormat(format) carg2 = C.gint64(minsize) carg3 = C.gint64(maxsize) if async { carg4 = C.TRUE } cret = C.gst_event_new_buffer_size(carg1, carg2, carg3, carg4) runtime.KeepAlive(format) runtime.KeepAlive(minsize) runtime.KeepAlive(maxsize) runtime.KeepAlive(async) var goret *Event goret = UnsafeEventFromGlibFull(unsafe.Pointer(cret)) return goret } // NewEventCaps wraps gst_event_new_caps // // The function takes the following parameters: // // - caps *Caps: a #GstCaps // // The function returns the following values: // // - goret *Event // // Create a new CAPS event for @caps. The caps event can only travel downstream // synchronized with the buffer flow and contains the format of the buffers // that will follow after the event. func NewEventCaps(caps *Caps) *Event { var carg1 *C.GstCaps // in, none, converted var cret *C.GstEvent // return, full, converted carg1 = (*C.GstCaps)(UnsafeCapsToGlibNone(caps)) cret = C.gst_event_new_caps(carg1) runtime.KeepAlive(caps) var goret *Event goret = UnsafeEventFromGlibFull(unsafe.Pointer(cret)) return goret } // NewEventCustom wraps gst_event_new_custom // // The function takes the following parameters: // // - typ EventType: The type of the new event // - structure *Structure: the structure for the event. The event will // take ownership of the structure. // // The function returns the following values: // // - goret *Event // // Create a new custom-typed event. This can be used for anything not // handled by other event-specific functions to pass an event to another // element. // // Make sure to allocate an event type with the #GST_EVENT_MAKE_TYPE macro, // assigning a free number and filling in the correct direction and // serialization flags. // // New custom events can also be created by subclassing the event type if // needed. func NewEventCustom(typ EventType, structure *Structure) *Event { var carg1 C.GstEventType // in, none, casted var carg2 *C.GstStructure // in, full, converted var cret *C.GstEvent // return, full, converted carg1 = C.GstEventType(typ) carg2 = (*C.GstStructure)(UnsafeStructureToGlibFull(structure)) cret = C.gst_event_new_custom(carg1, carg2) runtime.KeepAlive(typ) runtime.KeepAlive(structure) var goret *Event goret = UnsafeEventFromGlibFull(unsafe.Pointer(cret)) return goret } // NewEventEos wraps gst_event_new_eos // // The function returns the following values: // // - goret *Event // // Create a new EOS event. The eos event can only travel downstream // synchronized with the buffer flow. Elements that receive the EOS // event on a pad can return #GST_FLOW_EOS as a #GstFlowReturn // when data after the EOS event arrives. // // The EOS event will travel down to the sink elements in the pipeline // which will then post the #GST_MESSAGE_EOS on the bus after they have // finished playing any buffered data. // // When all sinks have posted an EOS message, an EOS message is // forwarded to the application. // // The EOS event itself will not cause any state transitions of the pipeline. func NewEventEos() *Event { var cret *C.GstEvent // return, full, converted cret = C.gst_event_new_eos() var goret *Event goret = UnsafeEventFromGlibFull(unsafe.Pointer(cret)) return goret } // NewEventFlushStart wraps gst_event_new_flush_start // // The function returns the following values: // // - goret *Event // // Allocate a new flush start event. The flush start event can be sent // upstream and downstream and travels out-of-bounds with the dataflow. // // It marks pads as being flushing and will make them return // #GST_FLOW_FLUSHING when used for data flow with gst_pad_push(), // gst_pad_chain(), gst_pad_get_range() and gst_pad_pull_range(). // Any event (except a #GST_EVENT_FLUSH_STOP) received // on a flushing pad will return %FALSE immediately. // // Elements should unlock any blocking functions and exit their streaming // functions as fast as possible when this event is received. // // This event is typically generated after a seek to flush out all queued data // in the pipeline so that the new media is played as soon as possible. func NewEventFlushStart() *Event { var cret *C.GstEvent // return, full, converted cret = C.gst_event_new_flush_start() var goret *Event goret = UnsafeEventFromGlibFull(unsafe.Pointer(cret)) return goret } // NewEventFlushStop wraps gst_event_new_flush_stop // // The function takes the following parameters: // // - resetTime bool: if time should be reset // // The function returns the following values: // // - goret *Event // // Allocate a new flush stop event. The flush stop event can be sent // upstream and downstream and travels serialized with the dataflow. // It is typically sent after sending a FLUSH_START event to make the // pads accept data again. // // Elements can process this event synchronized with the dataflow since // the preceding FLUSH_START event stopped the dataflow. // // This event is typically generated to complete a seek and to resume // dataflow. func NewEventFlushStop(resetTime bool) *Event { var carg1 C.gboolean // in var cret *C.GstEvent // return, full, converted if resetTime { carg1 = C.TRUE } cret = C.gst_event_new_flush_stop(carg1) runtime.KeepAlive(resetTime) var goret *Event goret = UnsafeEventFromGlibFull(unsafe.Pointer(cret)) return goret } // NewEventGap wraps gst_event_new_gap // // The function takes the following parameters: // // - timestamp ClockTime: the start time (pts) of the gap // - duration ClockTime: the duration of the gap // // The function returns the following values: // // - goret *Event // // Create a new GAP event. A gap event can be thought of as conceptually // equivalent to a buffer to signal that there is no data for a certain // amount of time. This is useful to signal a gap to downstream elements // which may wait for data, such as muxers or mixers or overlays, especially // for sparse streams such as subtitle streams. func NewEventGap(timestamp ClockTime, duration ClockTime) *Event { var carg1 C.GstClockTime // in, none, casted, alias var carg2 C.GstClockTime // in, none, casted, alias var cret *C.GstEvent // return, full, converted carg1 = C.GstClockTime(timestamp) carg2 = C.GstClockTime(duration) cret = C.gst_event_new_gap(carg1, carg2) runtime.KeepAlive(timestamp) runtime.KeepAlive(duration) var goret *Event goret = UnsafeEventFromGlibFull(unsafe.Pointer(cret)) return goret } // NewEventInstantRateChange wraps gst_event_new_instant_rate_change // // The function takes the following parameters: // // - rateMultiplier float64: the multiplier to be applied to the playback rate // - newFlags SegmentFlags: A new subset of segment flags to replace in segments // // The function returns the following values: // // - goret *Event // // Create a new instant-rate-change event. This event is sent by seek // handlers (e.g. demuxers) when receiving a seek with the // %GST_SEEK_FLAG_INSTANT_RATE_CHANGE and signals to downstream elements that // the playback rate in the existing segment should be immediately multiplied // by the @rate_multiplier factor. // // The flags provided replace any flags in the existing segment, for the // flags within the %GST_SEGMENT_INSTANT_FLAGS set. Other GstSegmentFlags // are ignored and not transferred in the event. func NewEventInstantRateChange(rateMultiplier float64, newFlags SegmentFlags) *Event { var carg1 C.gdouble // in, none, casted var carg2 C.GstSegmentFlags // in, none, casted var cret *C.GstEvent // return, full, converted carg1 = C.gdouble(rateMultiplier) carg2 = C.GstSegmentFlags(newFlags) cret = C.gst_event_new_instant_rate_change(carg1, carg2) runtime.KeepAlive(rateMultiplier) runtime.KeepAlive(newFlags) var goret *Event goret = UnsafeEventFromGlibFull(unsafe.Pointer(cret)) return goret } // NewEventInstantRateSyncTime wraps gst_event_new_instant_rate_sync_time // // The function takes the following parameters: // // - rateMultiplier float64: the new playback rate multiplier to be applied // - runningTime ClockTime: Running time when the rate change should be applied // - upstreamRunningTime ClockTime: The upstream-centric running-time when the // rate change should be applied. // // The function returns the following values: // // - goret *Event // // Create a new instant-rate-sync-time event. This event is sent by the // pipeline to notify elements handling the instant-rate-change event about // the running-time when the new rate should be applied. The running time // may be in the past when elements handle this event, which can lead to // switching artifacts. The magnitude of those depends on the exact timing // of event delivery to each element and the magnitude of the change in // playback rate being applied. // // The @running_time and @upstream_running_time are the same if this // is the first instant-rate adjustment, but will differ for later ones // to compensate for the accumulated offset due to playing at a rate // different to the one indicated in the playback segments. func NewEventInstantRateSyncTime(rateMultiplier float64, runningTime ClockTime, upstreamRunningTime ClockTime) *Event { var carg1 C.gdouble // in, none, casted var carg2 C.GstClockTime // in, none, casted, alias var carg3 C.GstClockTime // in, none, casted, alias var cret *C.GstEvent // return, full, converted carg1 = C.gdouble(rateMultiplier) carg2 = C.GstClockTime(runningTime) carg3 = C.GstClockTime(upstreamRunningTime) cret = C.gst_event_new_instant_rate_sync_time(carg1, carg2, carg3) runtime.KeepAlive(rateMultiplier) runtime.KeepAlive(runningTime) runtime.KeepAlive(upstreamRunningTime) var goret *Event goret = UnsafeEventFromGlibFull(unsafe.Pointer(cret)) return goret } // NewEventLatency wraps gst_event_new_latency // // The function takes the following parameters: // // - latency ClockTime: the new latency value // // The function returns the following values: // // - goret *Event // // Create a new latency event. The event is sent upstream from the sinks and // notifies elements that they should add an additional @latency to the // running time before synchronising against the clock. // // The latency is mostly used in live sinks and is always expressed in // the time format. func NewEventLatency(latency ClockTime) *Event { var carg1 C.GstClockTime // in, none, casted, alias var cret *C.GstEvent // return, full, converted carg1 = C.GstClockTime(latency) cret = C.gst_event_new_latency(carg1) runtime.KeepAlive(latency) var goret *Event goret = UnsafeEventFromGlibFull(unsafe.Pointer(cret)) return goret } // NewEventNavigation wraps gst_event_new_navigation // // The function takes the following parameters: // // - structure *Structure: description of the event. The event will take // ownership of the structure. See #GstNavigation for more specific // constructors. // // The function returns the following values: // // - goret *Event // // Create a new navigation event from the given description. func NewEventNavigation(structure *Structure) *Event { var carg1 *C.GstStructure // in, full, converted var cret *C.GstEvent // return, full, converted carg1 = (*C.GstStructure)(UnsafeStructureToGlibFull(structure)) cret = C.gst_event_new_navigation(carg1) runtime.KeepAlive(structure) var goret *Event goret = UnsafeEventFromGlibFull(unsafe.Pointer(cret)) return goret } // NewEventProtection wraps gst_event_new_protection // // The function takes the following parameters: // // - systemId string: a string holding a UUID that uniquely // identifies a protection system. // - data *Buffer: a #GstBuffer holding protection system specific // information. The reference count of the buffer will be incremented by one. // - origin string: a string indicating where the protection // information carried in the event was extracted from. The allowed values // of this string will depend upon the protection scheme. // // The function returns the following values: // // - goret *Event // // Creates a new event containing information specific to a particular // protection system (uniquely identified by @system_id), by which that // protection system can acquire key(s) to decrypt a protected stream. // // In order for a decryption element to decrypt media // protected using a specific system, it first needs all the // protection system specific information necessary to acquire the decryption // key(s) for that stream. The functions defined here enable this information // to be passed in events from elements that extract it // (e.g., ISOBMFF demuxers, MPEG DASH demuxers) to protection decrypter // elements that use it. // // Events containing protection system specific information are created using // #gst_event_new_protection, and they can be parsed by downstream elements // using #gst_event_parse_protection. // // In Common Encryption, protection system specific information may be located // within ISOBMFF files, both in movie (moov) boxes and movie fragment (moof) // boxes; it may also be contained in ContentProtection elements within MPEG // DASH MPDs. The events created by #gst_event_new_protection contain data // identifying from which of these locations the encapsulated protection system // specific information originated. This origin information is required as // some protection systems use different encodings depending upon where the // information originates. // // The events returned by gst_event_new_protection() are implemented // in such a way as to ensure that the most recently-pushed protection info // event of a particular @origin and @system_id will // be stuck to the output pad of the sending element. func NewEventProtection(systemId string, data *Buffer, origin string) *Event { var carg1 *C.gchar // in, none, string var carg2 *C.GstBuffer // in, none, converted var carg3 *C.gchar // in, none, string var cret *C.GstEvent // return, full, converted carg1 = (*C.gchar)(unsafe.Pointer(C.CString(systemId))) defer C.free(unsafe.Pointer(carg1)) carg2 = (*C.GstBuffer)(UnsafeBufferToGlibNone(data)) carg3 = (*C.gchar)(unsafe.Pointer(C.CString(origin))) defer C.free(unsafe.Pointer(carg3)) cret = C.gst_event_new_protection(carg1, carg2, carg3) runtime.KeepAlive(systemId) runtime.KeepAlive(data) runtime.KeepAlive(origin) var goret *Event goret = UnsafeEventFromGlibFull(unsafe.Pointer(cret)) return goret } // NewEventQos wraps gst_event_new_qos // // The function takes the following parameters: // // - typ QOSType: the QoS type // - proportion float64: the proportion of the qos message // - diff ClockTimeDiff: The time difference of the last Clock sync // - timestamp ClockTime: The timestamp of the buffer // // The function returns the following values: // // - goret *Event // // Allocate a new qos event with the given values. // The QOS event is generated in an element that wants an upstream // element to either reduce or increase its rate because of // high/low CPU load or other resource usage such as network performance or // throttling. Typically sinks generate these events for each buffer // they receive. // // @type indicates the reason for the QoS event. #GST_QOS_TYPE_OVERFLOW is // used when a buffer arrived in time or when the sink cannot keep up with // the upstream datarate. #GST_QOS_TYPE_UNDERFLOW is when the sink is not // receiving buffers fast enough and thus has to drop late buffers. // #GST_QOS_TYPE_THROTTLE is used when the datarate is artificially limited // by the application, for example to reduce power consumption. // // @proportion indicates the real-time performance of the streaming in the // element that generated the QoS event (usually the sink). The value is // generally computed based on more long term statistics about the streams // timestamps compared to the clock. // A value < 1.0 indicates that the upstream element is producing data faster // than real-time. A value > 1.0 indicates that the upstream element is not // producing data fast enough. 1.0 is the ideal @proportion value. The // proportion value can safely be used to lower or increase the quality of // the element. // // @diff is the difference against the clock in running time of the last // buffer that caused the element to generate the QOS event. A negative value // means that the buffer with @timestamp arrived in time. A positive value // indicates how late the buffer with @timestamp was. When throttling is // enabled, @diff will be set to the requested throttling interval. // // @timestamp is the timestamp of the last buffer that cause the element // to generate the QOS event. It is expressed in running time and thus an ever // increasing value. // // The upstream element can use the @diff and @timestamp values to decide // whether to process more buffers. For positive @diff, all buffers with // timestamp <= @timestamp + @diff will certainly arrive late in the sink // as well. A (negative) @diff value so that @timestamp + @diff would yield a // result smaller than 0 is not allowed. // // The application can use general event probes to intercept the QoS // event and implement custom application specific QoS handling. func NewEventQos(typ QOSType, proportion float64, diff ClockTimeDiff, timestamp ClockTime) *Event { var carg1 C.GstQOSType // in, none, casted var carg2 C.gdouble // in, none, casted var carg3 C.GstClockTimeDiff // in, none, casted, alias var carg4 C.GstClockTime // in, none, casted, alias var cret *C.GstEvent // return, full, converted carg1 = C.GstQOSType(typ) carg2 = C.gdouble(proportion) carg3 = C.GstClockTimeDiff(diff) carg4 = C.GstClockTime(timestamp) cret = C.gst_event_new_qos(carg1, carg2, carg3, carg4) runtime.KeepAlive(typ) runtime.KeepAlive(proportion) runtime.KeepAlive(diff) runtime.KeepAlive(timestamp) var goret *Event goret = UnsafeEventFromGlibFull(unsafe.Pointer(cret)) return goret } // NewEventReconfigure wraps gst_event_new_reconfigure // // The function returns the following values: // // - goret *Event // // Create a new reconfigure event. The purpose of the reconfigure event is // to travel upstream and make elements renegotiate their caps or reconfigure // their buffer pools. This is useful when changing properties on elements // or changing the topology of the pipeline. func NewEventReconfigure() *Event { var cret *C.GstEvent // return, full, converted cret = C.gst_event_new_reconfigure() var goret *Event goret = UnsafeEventFromGlibFull(unsafe.Pointer(cret)) return goret } // NewEventSeek wraps gst_event_new_seek // // The function takes the following parameters: // // - rate float64: The new playback rate // - format Format: The format of the seek values // - flags SeekFlags: The optional seek flags // - startType SeekType: The type and flags for the new start position // - start int64: The value of the new start position // - stopType SeekType: The type and flags for the new stop position // - stop int64: The value of the new stop position // // The function returns the following values: // // - goret *Event // // Allocate a new seek event with the given parameters. // // The seek event configures playback of the pipeline between @start to @stop // at the speed given in @rate, also called a playback segment. // The @start and @stop values are expressed in @format. // // A @rate of 1.0 means normal playback rate, 2.0 means double speed. // Negatives values means backwards playback. A value of 0.0 for the // rate is not allowed and should be accomplished instead by PAUSING the // pipeline. // // A pipeline has a default playback segment configured with a start // position of 0, a stop position of -1 and a rate of 1.0. The currently // configured playback segment can be queried with #GST_QUERY_SEGMENT. // // @start_type and @stop_type specify how to adjust the currently configured // start and stop fields in playback segment. Adjustments can be made relative // or absolute to the last configured values. A type of #GST_SEEK_TYPE_NONE // means that the position should not be updated. // // When the rate is positive and @start has been updated, playback will start // from the newly configured start position. // // For negative rates, playback will start from the newly configured stop // position (if any). If the stop position is updated, it must be different from // -1 (#GST_CLOCK_TIME_NONE) for negative rates. // // It is not possible to seek relative to the current playback position, to do // this, PAUSE the pipeline, query the current playback position with // #GST_QUERY_POSITION and update the playback segment current position with a // #GST_SEEK_TYPE_SET to the desired position. func NewEventSeek(rate float64, format Format, flags SeekFlags, startType SeekType, start int64, stopType SeekType, stop int64) *Event { var carg1 C.gdouble // in, none, casted var carg2 C.GstFormat // in, none, casted var carg3 C.GstSeekFlags // in, none, casted var carg4 C.GstSeekType // in, none, casted var carg5 C.gint64 // in, none, casted var carg6 C.GstSeekType // in, none, casted var carg7 C.gint64 // in, none, casted var cret *C.GstEvent // return, full, converted carg1 = C.gdouble(rate) carg2 = C.GstFormat(format) carg3 = C.GstSeekFlags(flags) carg4 = C.GstSeekType(startType) carg5 = C.gint64(start) carg6 = C.GstSeekType(stopType) carg7 = C.gint64(stop) cret = C.gst_event_new_seek(carg1, carg2, carg3, carg4, carg5, carg6, carg7) runtime.KeepAlive(rate) runtime.KeepAlive(format) runtime.KeepAlive(flags) runtime.KeepAlive(startType) runtime.KeepAlive(start) runtime.KeepAlive(stopType) runtime.KeepAlive(stop) var goret *Event goret = UnsafeEventFromGlibFull(unsafe.Pointer(cret)) return goret } // NewEventSegment wraps gst_event_new_segment // // The function takes the following parameters: // // - segment *Segment: a #GstSegment // // The function returns the following values: // // - goret *Event // // Create a new SEGMENT event for @segment. The segment event can only travel // downstream synchronized with the buffer flow and contains timing information // and playback properties for the buffers that will follow. // // The segment event marks the range of buffers to be processed. All // data not within the segment range is not to be processed. This can be // used intelligently by plugins to apply more efficient methods of skipping // unneeded data. The valid range is expressed with the @start and @stop // values. // // The time value of the segment is used in conjunction with the start // value to convert the buffer timestamps into the stream time. This is // usually done in sinks to report the current stream_time. // @time represents the stream_time of a buffer carrying a timestamp of // @start. @time cannot be -1. // // @start cannot be -1, @stop can be -1. If there // is a valid @stop given, it must be greater or equal the @start, including // when the indicated playback @rate is < 0. // // The @applied_rate value provides information about any rate adjustment that // has already been made to the timestamps and content on the buffers of the // stream. (@rate * @applied_rate) should always equal the rate that has been // requested for playback. For example, if an element has an input segment // with intended playback @rate of 2.0 and applied_rate of 1.0, it can adjust // incoming timestamps and buffer content by half and output a segment event // with @rate of 1.0 and @applied_rate of 2.0 // // After a segment event, the buffer stream time is calculated with: // // time + (TIMESTAMP(buf) - start) * ABS (rate * applied_rate) func NewEventSegment(segment *Segment) *Event { var carg1 *C.GstSegment // in, none, converted var cret *C.GstEvent // return, full, converted carg1 = (*C.GstSegment)(UnsafeSegmentToGlibNone(segment)) cret = C.gst_event_new_segment(carg1) runtime.KeepAlive(segment) var goret *Event goret = UnsafeEventFromGlibFull(unsafe.Pointer(cret)) return goret } // NewEventSegmentDone wraps gst_event_new_segment_done // // The function takes the following parameters: // // - format Format: The format of the position being done // - position int64: The position of the segment being done // // The function returns the following values: // // - goret *Event // // Create a new segment-done event. This event is sent by elements that // finish playback of a segment as a result of a segment seek. func NewEventSegmentDone(format Format, position int64) *Event { var carg1 C.GstFormat // in, none, casted var carg2 C.gint64 // in, none, casted var cret *C.GstEvent // return, full, converted carg1 = C.GstFormat(format) carg2 = C.gint64(position) cret = C.gst_event_new_segment_done(carg1, carg2) runtime.KeepAlive(format) runtime.KeepAlive(position) var goret *Event goret = UnsafeEventFromGlibFull(unsafe.Pointer(cret)) return goret } // NewEventSinkMessage wraps gst_event_new_sink_message // // The function takes the following parameters: // // - name string: a name for the event // - msg *Message: the #GstMessage to be posted // // The function returns the following values: // // - goret *Event // // Create a new sink-message event. The purpose of the sink-message event is // to instruct a sink to post the message contained in the event synchronized // with the stream. // // @name is used to store multiple sticky events on one pad. func NewEventSinkMessage(name string, msg *Message) *Event { var carg1 *C.gchar // in, none, string var carg2 *C.GstMessage // in, none, converted var cret *C.GstEvent // return, full, converted carg1 = (*C.gchar)(unsafe.Pointer(C.CString(name))) defer C.free(unsafe.Pointer(carg1)) carg2 = (*C.GstMessage)(UnsafeMessageToGlibNone(msg)) cret = C.gst_event_new_sink_message(carg1, carg2) runtime.KeepAlive(name) runtime.KeepAlive(msg) var goret *Event goret = UnsafeEventFromGlibFull(unsafe.Pointer(cret)) return goret } // NewEventStep wraps gst_event_new_step // // The function takes the following parameters: // // - format Format: the format of @amount // - amount uint64: the amount of data to step // - rate float64: the step rate // - flush bool: flushing steps // - intermediate bool: intermediate steps // // The function returns the following values: // // - goret *Event // // Create a new step event. The purpose of the step event is to instruct a sink // to skip @amount (expressed in @format) of media. It can be used to implement // stepping through the video frame by frame or for doing fast trick modes. // // A rate of <= 0.0 is not allowed. Pause the pipeline, for the effect of rate // = 0.0 or first reverse the direction of playback using a seek event to get // the same effect as rate < 0.0. // // The @flush flag will clear any pending data in the pipeline before starting // the step operation. // // The @intermediate flag instructs the pipeline that this step operation is // part of a larger step operation. func NewEventStep(format Format, amount uint64, rate float64, flush bool, intermediate bool) *Event { var carg1 C.GstFormat // in, none, casted var carg2 C.guint64 // in, none, casted var carg3 C.gdouble // in, none, casted var carg4 C.gboolean // in var carg5 C.gboolean // in var cret *C.GstEvent // return, full, converted carg1 = C.GstFormat(format) carg2 = C.guint64(amount) carg3 = C.gdouble(rate) if flush { carg4 = C.TRUE } if intermediate { carg5 = C.TRUE } cret = C.gst_event_new_step(carg1, carg2, carg3, carg4, carg5) runtime.KeepAlive(format) runtime.KeepAlive(amount) runtime.KeepAlive(rate) runtime.KeepAlive(flush) runtime.KeepAlive(intermediate) var goret *Event goret = UnsafeEventFromGlibFull(unsafe.Pointer(cret)) return goret } // NewEventStreamCollection wraps gst_event_new_stream_collection // // The function takes the following parameters: // // - collection StreamCollection: Active collection for this data flow // // The function returns the following values: // // - goret *Event // // Create a new STREAM_COLLECTION event. The stream collection event can only // travel downstream synchronized with the buffer flow. // // Source elements, demuxers and other elements that manage collections // of streams and post #GstStreamCollection messages on the bus also send // this event downstream on each pad involved in the collection, so that // activation of a new collection can be tracked through the downstream // data flow. func NewEventStreamCollection(collection StreamCollection) *Event { var carg1 *C.GstStreamCollection // in, none, converted var cret *C.GstEvent // return, full, converted carg1 = (*C.GstStreamCollection)(UnsafeStreamCollectionToGlibNone(collection)) cret = C.gst_event_new_stream_collection(carg1) runtime.KeepAlive(collection) var goret *Event goret = UnsafeEventFromGlibFull(unsafe.Pointer(cret)) return goret } // NewEventStreamGroupDone wraps gst_event_new_stream_group_done // // The function takes the following parameters: // // - groupId uint: the group id of the stream group which is ending // // The function returns the following values: // // - goret *Event // // Create a new Stream Group Done event. The stream-group-done event can // only travel downstream synchronized with the buffer flow. Elements // that receive the event on a pad should handle it mostly like EOS, // and emit any data or pending buffers that would depend on more data // arriving and unblock, since there won't be any more data. // // This event is followed by EOS at some point in the future, and is // generally used when switching pads - to unblock downstream so that // new pads can be exposed before sending EOS on the existing pads. func NewEventStreamGroupDone(groupId uint) *Event { var carg1 C.guint // in, none, casted var cret *C.GstEvent // return, full, converted carg1 = C.guint(groupId) cret = C.gst_event_new_stream_group_done(carg1) runtime.KeepAlive(groupId) var goret *Event goret = UnsafeEventFromGlibFull(unsafe.Pointer(cret)) return goret } // NewEventStreamStart wraps gst_event_new_stream_start // // The function takes the following parameters: // // - streamId string: Identifier for this stream // // The function returns the following values: // // - goret *Event // // Create a new STREAM_START event. The stream start event can only // travel downstream synchronized with the buffer flow. It is expected // to be the first event that is sent for a new stream. // // Source elements, demuxers and other elements that create new streams // are supposed to send this event as the first event of a new stream. It // should not be sent after a flushing seek or in similar situations // and is used to mark the beginning of a new logical stream. Elements // combining multiple streams must ensure that this event is only forwarded // downstream once and not for every single input stream. // // The @stream_id should be a unique string that consists of the upstream // stream-id, / as separator and a unique stream-id for this specific // stream. A new stream-id should only be created for a stream if the upstream // stream is split into (potentially) multiple new streams, e.g. in a demuxer, // but not for every single element in the pipeline. // gst_pad_create_stream_id() or gst_pad_create_stream_id_printf() can be // used to create a stream-id. There are no particular semantics for the // stream-id, though it should be deterministic (to support stream matching) // and it might be used to order streams (besides any information conveyed by // stream flags). func NewEventStreamStart(streamId string) *Event { var carg1 *C.gchar // in, none, string var cret *C.GstEvent // return, full, converted carg1 = (*C.gchar)(unsafe.Pointer(C.CString(streamId))) defer C.free(unsafe.Pointer(carg1)) cret = C.gst_event_new_stream_start(carg1) runtime.KeepAlive(streamId) var goret *Event goret = UnsafeEventFromGlibFull(unsafe.Pointer(cret)) return goret } // NewEventTag wraps gst_event_new_tag // // The function takes the following parameters: // // - taglist *TagList: metadata list. The event will take ownership // of the taglist. // // The function returns the following values: // // - goret *Event // // Generates a metadata tag event from the given @taglist. // // The scope of the taglist specifies if the taglist applies to the // complete medium or only to this specific stream. As the tag event // is a sticky event, elements should merge tags received from // upstream with a given scope with their own tags with the same // scope and create a new tag event from it. func NewEventTag(taglist *TagList) *Event { var carg1 *C.GstTagList // in, full, converted var cret *C.GstEvent // return, full, converted carg1 = (*C.GstTagList)(UnsafeTagListToGlibFull(taglist)) cret = C.gst_event_new_tag(carg1) runtime.KeepAlive(taglist) var goret *Event goret = UnsafeEventFromGlibFull(unsafe.Pointer(cret)) return goret } // NewEventToc wraps gst_event_new_toc // // The function takes the following parameters: // // - toc *Toc: #GstToc structure. // - updated bool: whether @toc was updated or not. // // The function returns the following values: // // - goret *Event // // Generate a TOC event from the given @toc. The purpose of the TOC event is to // inform elements that some kind of the TOC was found. func NewEventToc(toc *Toc, updated bool) *Event { var carg1 *C.GstToc // in, none, converted var carg2 C.gboolean // in var cret *C.GstEvent // return, full, converted carg1 = (*C.GstToc)(UnsafeTocToGlibNone(toc)) if updated { carg2 = C.TRUE } cret = C.gst_event_new_toc(carg1, carg2) runtime.KeepAlive(toc) runtime.KeepAlive(updated) var goret *Event goret = UnsafeEventFromGlibFull(unsafe.Pointer(cret)) return goret } // NewEventTocSelect wraps gst_event_new_toc_select // // The function takes the following parameters: // // - uid string: UID in the TOC to start playback from. // // The function returns the following values: // // - goret *Event // // Generate a TOC select event with the given @uid. The purpose of the // TOC select event is to start playback based on the TOC's entry with the // given @uid. func NewEventTocSelect(uid string) *Event { var carg1 *C.gchar // in, none, string var cret *C.GstEvent // return, full, converted carg1 = (*C.gchar)(unsafe.Pointer(C.CString(uid))) defer C.free(unsafe.Pointer(carg1)) cret = C.gst_event_new_toc_select(carg1) runtime.KeepAlive(uid) var goret *Event goret = UnsafeEventFromGlibFull(unsafe.Pointer(cret)) return goret } // CopySegment wraps gst_event_copy_segment // // The function takes the following parameters: // // - segment *Segment: a pointer to a #GstSegment // // Parses a segment @event and copies the #GstSegment into the location // given by @segment. func (event *Event) CopySegment(segment *Segment) { var carg0 *C.GstEvent // in, none, converted var carg1 *C.GstSegment // in, none, converted carg0 = (*C.GstEvent)(UnsafeEventToGlibNone(event)) carg1 = (*C.GstSegment)(UnsafeSegmentToGlibNone(segment)) C.gst_event_copy_segment(carg0, carg1) runtime.KeepAlive(event) runtime.KeepAlive(segment) } // GetRunningTimeOffset wraps gst_event_get_running_time_offset // // The function returns the following values: // // - goret int64 // // Retrieve the accumulated running time offset of the event. // // Events passing through #GstPads that have a running time // offset set via gst_pad_set_offset() will get their offset // adjusted according to the pad's offset. // // If the event contains any information that related to the // running time, this information will need to be updated // before usage with this offset. func (event *Event) GetRunningTimeOffset() int64 { var carg0 *C.GstEvent // in, none, converted var cret C.gint64 // return, none, casted carg0 = (*C.GstEvent)(UnsafeEventToGlibNone(event)) cret = C.gst_event_get_running_time_offset(carg0) runtime.KeepAlive(event) var goret int64 goret = int64(cret) return goret } // GetSeqnum wraps gst_event_get_seqnum // // The function returns the following values: // // - goret uint32 // // Retrieve the sequence number of a event. // // Events have ever-incrementing sequence numbers, which may also be set // explicitly via gst_event_set_seqnum(). Sequence numbers are typically used to // indicate that a event corresponds to some other set of events or messages, // for example an EOS event corresponding to a SEEK event. It is considered good // practice to make this correspondence when possible, though it is not // required. // // Note that events and messages share the same sequence number incrementor; // two events or messages will never have the same sequence number unless // that correspondence was made explicitly. func (event *Event) GetSeqnum() uint32 { var carg0 *C.GstEvent // in, none, converted var cret C.guint32 // return, none, casted carg0 = (*C.GstEvent)(UnsafeEventToGlibNone(event)) cret = C.gst_event_get_seqnum(carg0) runtime.KeepAlive(event) var goret uint32 goret = uint32(cret) return goret } // GetStructure wraps gst_event_get_structure // // The function returns the following values: // // - goret *Structure (nullable) // // Access the structure of the event. func (event *Event) GetStructure() *Structure { var carg0 *C.GstEvent // in, none, converted var cret *C.GstStructure // return, none, converted, nullable carg0 = (*C.GstEvent)(UnsafeEventToGlibNone(event)) cret = C.gst_event_get_structure(carg0) runtime.KeepAlive(event) var goret *Structure if cret != nil { goret = UnsafeStructureFromGlibNone(unsafe.Pointer(cret)) } return goret } // HasName wraps gst_event_has_name // // The function takes the following parameters: // // - name string: name to check // // The function returns the following values: // // - goret bool // // Checks if @event has the given @name. This function is usually used to // check the name of a custom event. func (event *Event) HasName(name string) bool { var carg0 *C.GstEvent // in, none, converted var carg1 *C.gchar // in, none, string var cret C.gboolean // return carg0 = (*C.GstEvent)(UnsafeEventToGlibNone(event)) carg1 = (*C.gchar)(unsafe.Pointer(C.CString(name))) defer C.free(unsafe.Pointer(carg1)) cret = C.gst_event_has_name(carg0, carg1) runtime.KeepAlive(event) runtime.KeepAlive(name) var goret bool if cret != 0 { goret = true } return goret } // HasNameID wraps gst_event_has_name_id // // The function takes the following parameters: // // - name glib.Quark: name to check as a GQuark // // The function returns the following values: // // - goret bool // // Checks if @event has the given @name. This function is usually used to // check the name of a custom event. func (event *Event) HasNameID(name glib.Quark) bool { var carg0 *C.GstEvent // in, none, converted var carg1 C.GQuark // in, none, casted, alias var cret C.gboolean // return carg0 = (*C.GstEvent)(UnsafeEventToGlibNone(event)) carg1 = C.GQuark(name) cret = C.gst_event_has_name_id(carg0, carg1) runtime.KeepAlive(event) runtime.KeepAlive(name) var goret bool if cret != 0 { goret = true } return goret } // ParseBufferSize wraps gst_event_parse_buffer_size // // The function returns the following values: // // - format Format: A pointer to store the format in // - minsize int64: A pointer to store the minsize in // - maxsize int64: A pointer to store the maxsize in // - async bool: A pointer to store the async-flag in // // Get the format, minsize, maxsize and async-flag in the buffersize event. func (event *Event) ParseBufferSize() (Format, int64, int64, bool) { var carg0 *C.GstEvent // in, none, converted var carg1 C.GstFormat // out, full, casted var carg2 C.gint64 // out, full, casted var carg3 C.gint64 // out, full, casted var carg4 C.gboolean // out carg0 = (*C.GstEvent)(UnsafeEventToGlibNone(event)) C.gst_event_parse_buffer_size(carg0, &carg1, &carg2, &carg3, &carg4) runtime.KeepAlive(event) var format Format var minsize int64 var maxsize int64 var async bool format = Format(carg1) minsize = int64(carg2) maxsize = int64(carg3) if carg4 != 0 { async = true } return format, minsize, maxsize, async } // ParseCaps wraps gst_event_parse_caps // // The function returns the following values: // // - caps *Caps: A pointer to the caps // // Get the caps from @event. The caps remains valid as long as @event remains // valid. func (event *Event) ParseCaps() *Caps { var carg0 *C.GstEvent // in, none, converted var carg1 *C.GstCaps // out, none, converted carg0 = (*C.GstEvent)(UnsafeEventToGlibNone(event)) C.gst_event_parse_caps(carg0, &carg1) runtime.KeepAlive(event) var caps *Caps caps = UnsafeCapsFromGlibNone(unsafe.Pointer(carg1)) return caps } // ParseFlushStop wraps gst_event_parse_flush_stop // // The function returns the following values: // // - resetTime bool: if time should be reset // // Parse the FLUSH_STOP event and retrieve the @reset_time member. func (event *Event) ParseFlushStop() bool { var carg0 *C.GstEvent // in, none, converted var carg1 C.gboolean // out carg0 = (*C.GstEvent)(UnsafeEventToGlibNone(event)) C.gst_event_parse_flush_stop(carg0, &carg1) runtime.KeepAlive(event) var resetTime bool if carg1 != 0 { resetTime = true } return resetTime } // ParseGap wraps gst_event_parse_gap // // The function returns the following values: // // - timestamp ClockTime: location where to store the // start time (pts) of the gap, or %NULL // - duration ClockTime: location where to store the duration of // the gap, or %NULL // // Extract timestamp and duration from a new GAP event. func (event *Event) ParseGap() (ClockTime, ClockTime) { var carg0 *C.GstEvent // in, none, converted var carg1 C.GstClockTime // out, full, casted, alias var carg2 C.GstClockTime // out, full, casted, alias carg0 = (*C.GstEvent)(UnsafeEventToGlibNone(event)) C.gst_event_parse_gap(carg0, &carg1, &carg2) runtime.KeepAlive(event) var timestamp ClockTime var duration ClockTime timestamp = ClockTime(carg1) duration = ClockTime(carg2) return timestamp, duration } // ParseGapFlags wraps gst_event_parse_gap_flags // // The function returns the following values: // // - flags GapFlags: a #GstGapFlags or %NULL // // Retrieve the gap flags that may have been set on a gap event with // gst_event_set_gap_flags(). func (event *Event) ParseGapFlags() GapFlags { var carg0 *C.GstEvent // in, none, converted var carg1 C.GstGapFlags // out, full, casted carg0 = (*C.GstEvent)(UnsafeEventToGlibNone(event)) C.gst_event_parse_gap_flags(carg0, &carg1) runtime.KeepAlive(event) var flags GapFlags flags = GapFlags(carg1) return flags } // ParseGroupID wraps gst_event_parse_group_id // // The function returns the following values: // // - groupId uint: address of variable where to store the group id // - goret bool func (event *Event) ParseGroupID() (uint, bool) { var carg0 *C.GstEvent // in, none, converted var carg1 C.guint // out, full, casted var cret C.gboolean // return carg0 = (*C.GstEvent)(UnsafeEventToGlibNone(event)) cret = C.gst_event_parse_group_id(carg0, &carg1) runtime.KeepAlive(event) var groupId uint var goret bool groupId = uint(carg1) if cret != 0 { goret = true } return groupId, goret } // ParseInstantRateChange wraps gst_event_parse_instant_rate_change // // The function returns the following values: // // - rateMultiplier float64: location in which to store the rate // multiplier of the instant-rate-change event, or %NULL // - newFlags SegmentFlags: location in which to store the new // segment flags of the instant-rate-change event, or %NULL // // Extract rate and flags from an instant-rate-change event. func (event *Event) ParseInstantRateChange() (float64, SegmentFlags) { var carg0 *C.GstEvent // in, none, converted var carg1 C.gdouble // out, full, casted var carg2 C.GstSegmentFlags // out, full, casted carg0 = (*C.GstEvent)(UnsafeEventToGlibNone(event)) C.gst_event_parse_instant_rate_change(carg0, &carg1, &carg2) runtime.KeepAlive(event) var rateMultiplier float64 var newFlags SegmentFlags rateMultiplier = float64(carg1) newFlags = SegmentFlags(carg2) return rateMultiplier, newFlags } // ParseInstantRateSyncTime wraps gst_event_parse_instant_rate_sync_time // // The function returns the following values: // // - rateMultiplier float64: location where to store the rate of // the instant-rate-sync-time event, or %NULL // - runningTime ClockTime: location in which to store the running time // of the instant-rate-sync-time event, or %NULL // - upstreamRunningTime ClockTime: location in which to store the // upstream running time of the instant-rate-sync-time event, or %NULL // // Extract the rate multiplier and running times from an instant-rate-sync-time event. func (event *Event) ParseInstantRateSyncTime() (float64, ClockTime, ClockTime) { var carg0 *C.GstEvent // in, none, converted var carg1 C.gdouble // out, full, casted var carg2 C.GstClockTime // out, full, casted, alias var carg3 C.GstClockTime // out, full, casted, alias carg0 = (*C.GstEvent)(UnsafeEventToGlibNone(event)) C.gst_event_parse_instant_rate_sync_time(carg0, &carg1, &carg2, &carg3) runtime.KeepAlive(event) var rateMultiplier float64 var runningTime ClockTime var upstreamRunningTime ClockTime rateMultiplier = float64(carg1) runningTime = ClockTime(carg2) upstreamRunningTime = ClockTime(carg3) return rateMultiplier, runningTime, upstreamRunningTime } // ParseLatency wraps gst_event_parse_latency // // The function returns the following values: // // - latency ClockTime: A pointer to store the latency in. // // Get the latency in the latency event. func (event *Event) ParseLatency() ClockTime { var carg0 *C.GstEvent // in, none, converted var carg1 C.GstClockTime // out, full, casted, alias carg0 = (*C.GstEvent)(UnsafeEventToGlibNone(event)) C.gst_event_parse_latency(carg0, &carg1) runtime.KeepAlive(event) var latency ClockTime latency = ClockTime(carg1) return latency } // ParseProtection wraps gst_event_parse_protection // // The function returns the following values: // // - systemId string: pointer to store the UUID // string uniquely identifying a content protection system. // - data *Buffer: pointer to store a #GstBuffer // holding protection system specific information. // - origin string: pointer to store a value that // indicates where the protection information carried by @event was extracted // from. // // Parses an event containing protection system specific information and stores // the results in @system_id, @data and @origin. The data stored in @system_id, // @origin and @data are valid until @event is released. func (event *Event) ParseProtection() (string, *Buffer, string) { var carg0 *C.GstEvent // in, none, converted var carg1 *C.gchar // out, none, string var carg2 *C.GstBuffer // out, none, converted var carg3 *C.gchar // out, none, string carg0 = (*C.GstEvent)(UnsafeEventToGlibNone(event)) C.gst_event_parse_protection(carg0, &carg1, &carg2, &carg3) runtime.KeepAlive(event) var systemId string var data *Buffer var origin string systemId = C.GoString((*C.char)(unsafe.Pointer(carg1))) data = UnsafeBufferFromGlibNone(unsafe.Pointer(carg2)) origin = C.GoString((*C.char)(unsafe.Pointer(carg3))) return systemId, data, origin } // ParseQos wraps gst_event_parse_qos // // The function returns the following values: // // - typ QOSType: A pointer to store the QoS type in // - proportion float64: A pointer to store the proportion in // - diff ClockTimeDiff: A pointer to store the diff in // - timestamp ClockTime: A pointer to store the timestamp in // // Get the type, proportion, diff and timestamp in the qos event. See // gst_event_new_qos() for more information about the different QoS values. // // @timestamp will be adjusted for any pad offsets of pads it was passing through. func (event *Event) ParseQos() (QOSType, float64, ClockTimeDiff, ClockTime) { var carg0 *C.GstEvent // in, none, converted var carg1 C.GstQOSType // out, full, casted var carg2 C.gdouble // out, full, casted var carg3 C.GstClockTimeDiff // out, full, casted, alias var carg4 C.GstClockTime // out, full, casted, alias carg0 = (*C.GstEvent)(UnsafeEventToGlibNone(event)) C.gst_event_parse_qos(carg0, &carg1, &carg2, &carg3, &carg4) runtime.KeepAlive(event) var typ QOSType var proportion float64 var diff ClockTimeDiff var timestamp ClockTime typ = QOSType(carg1) proportion = float64(carg2) diff = ClockTimeDiff(carg3) timestamp = ClockTime(carg4) return typ, proportion, diff, timestamp } // ParseSeek wraps gst_event_parse_seek // // The function returns the following values: // // - rate float64: result location for the rate // - format Format: result location for the stream format // - flags SeekFlags: result location for the #GstSeekFlags // - startType SeekType: result location for the #GstSeekType of the start position // - start int64: result location for the start position expressed in @format // - stopType SeekType: result location for the #GstSeekType of the stop position // - stop int64: result location for the stop position expressed in @format // // Parses a seek @event and stores the results in the given result locations. func (event *Event) ParseSeek() (float64, Format, SeekFlags, SeekType, int64, SeekType, int64) { var carg0 *C.GstEvent // in, none, converted var carg1 C.gdouble // out, full, casted var carg2 C.GstFormat // out, full, casted var carg3 C.GstSeekFlags // out, full, casted var carg4 C.GstSeekType // out, full, casted var carg5 C.gint64 // out, full, casted var carg6 C.GstSeekType // out, full, casted var carg7 C.gint64 // out, full, casted carg0 = (*C.GstEvent)(UnsafeEventToGlibNone(event)) C.gst_event_parse_seek(carg0, &carg1, &carg2, &carg3, &carg4, &carg5, &carg6, &carg7) runtime.KeepAlive(event) var rate float64 var format Format var flags SeekFlags var startType SeekType var start int64 var stopType SeekType var stop int64 rate = float64(carg1) format = Format(carg2) flags = SeekFlags(carg3) startType = SeekType(carg4) start = int64(carg5) stopType = SeekType(carg6) stop = int64(carg7) return rate, format, flags, startType, start, stopType, stop } // ParseSeekTrickmodeInterval wraps gst_event_parse_seek_trickmode_interval // // The function returns the following values: // // - interval ClockTime: interval // // Retrieve the trickmode interval that may have been set on a // seek event with gst_event_set_seek_trickmode_interval(). func (event *Event) ParseSeekTrickmodeInterval() ClockTime { var carg0 *C.GstEvent // in, none, converted var carg1 C.GstClockTime // out, full, casted, alias carg0 = (*C.GstEvent)(UnsafeEventToGlibNone(event)) C.gst_event_parse_seek_trickmode_interval(carg0, &carg1) runtime.KeepAlive(event) var interval ClockTime interval = ClockTime(carg1) return interval } // ParseSegment wraps gst_event_parse_segment // // The function returns the following values: // // - segment *Segment: a pointer to a #GstSegment // // Parses a segment @event and stores the result in the given @segment location. // @segment remains valid only until the @event is freed. Don't modify the segment // and make a copy if you want to modify it or store it for later use. func (event *Event) ParseSegment() *Segment { var carg0 *C.GstEvent // in, none, converted var carg1 *C.GstSegment // out, none, converted carg0 = (*C.GstEvent)(UnsafeEventToGlibNone(event)) C.gst_event_parse_segment(carg0, &carg1) runtime.KeepAlive(event) var segment *Segment segment = UnsafeSegmentFromGlibNone(unsafe.Pointer(carg1)) return segment } // ParseSegmentDone wraps gst_event_parse_segment_done // // The function returns the following values: // // - format Format: Result location for the format, or %NULL // - position int64: Result location for the position, or %NULL // // Extracts the position and format from the segment done message. func (event *Event) ParseSegmentDone() (Format, int64) { var carg0 *C.GstEvent // in, none, converted var carg1 C.GstFormat // out, full, casted var carg2 C.gint64 // out, full, casted carg0 = (*C.GstEvent)(UnsafeEventToGlibNone(event)) C.gst_event_parse_segment_done(carg0, &carg1, &carg2) runtime.KeepAlive(event) var format Format var position int64 format = Format(carg1) position = int64(carg2) return format, position } // ParseSinkMessage wraps gst_event_parse_sink_message // // The function returns the following values: // // - msg *Message: a pointer to store the #GstMessage in. // // Parse the sink-message event. Unref @msg after usage. func (event *Event) ParseSinkMessage() *Message { var carg0 *C.GstEvent // in, none, converted var carg1 *C.GstMessage // out, full, converted carg0 = (*C.GstEvent)(UnsafeEventToGlibNone(event)) C.gst_event_parse_sink_message(carg0, &carg1) runtime.KeepAlive(event) var msg *Message msg = UnsafeMessageFromGlibFull(unsafe.Pointer(carg1)) return msg } // ParseStep wraps gst_event_parse_step // // The function returns the following values: // // - format Format: a pointer to store the format in // - amount uint64: a pointer to store the amount in // - rate float64: a pointer to store the rate in // - flush bool: a pointer to store the flush boolean in // - intermediate bool: a pointer to store the intermediate // boolean in // // Parse the step event. func (event *Event) ParseStep() (Format, uint64, float64, bool, bool) { var carg0 *C.GstEvent // in, none, converted var carg1 C.GstFormat // out, full, casted var carg2 C.guint64 // out, full, casted var carg3 C.gdouble // out, full, casted var carg4 C.gboolean // out var carg5 C.gboolean // out carg0 = (*C.GstEvent)(UnsafeEventToGlibNone(event)) C.gst_event_parse_step(carg0, &carg1, &carg2, &carg3, &carg4, &carg5) runtime.KeepAlive(event) var format Format var amount uint64 var rate float64 var flush bool var intermediate bool format = Format(carg1) amount = uint64(carg2) rate = float64(carg3) if carg4 != 0 { flush = true } if carg5 != 0 { intermediate = true } return format, amount, rate, flush, intermediate } // ParseStream wraps gst_event_parse_stream // // The function returns the following values: // // - stream Stream: address of variable to store the stream // // Parse a stream-start @event and extract the #GstStream from it. func (event *Event) ParseStream() Stream { var carg0 *C.GstEvent // in, none, converted var carg1 *C.GstStream // out, full, converted carg0 = (*C.GstEvent)(UnsafeEventToGlibNone(event)) C.gst_event_parse_stream(carg0, &carg1) runtime.KeepAlive(event) var stream Stream stream = UnsafeStreamFromGlibFull(unsafe.Pointer(carg1)) return stream } // ParseStreamCollection wraps gst_event_parse_stream_collection // // The function returns the following values: // // - collection StreamCollection: pointer to store the collection. // // Retrieve new #GstStreamCollection from STREAM_COLLECTION event @event. func (event *Event) ParseStreamCollection() StreamCollection { var carg0 *C.GstEvent // in, none, converted var carg1 *C.GstStreamCollection // out, full, converted carg0 = (*C.GstEvent)(UnsafeEventToGlibNone(event)) C.gst_event_parse_stream_collection(carg0, &carg1) runtime.KeepAlive(event) var collection StreamCollection collection = UnsafeStreamCollectionFromGlibFull(unsafe.Pointer(carg1)) return collection } // ParseStreamFlags wraps gst_event_parse_stream_flags // // The function returns the following values: // // - flags StreamFlags: address of variable where to store the stream flags func (event *Event) ParseStreamFlags() StreamFlags { var carg0 *C.GstEvent // in, none, converted var carg1 C.GstStreamFlags // out, full, casted carg0 = (*C.GstEvent)(UnsafeEventToGlibNone(event)) C.gst_event_parse_stream_flags(carg0, &carg1) runtime.KeepAlive(event) var flags StreamFlags flags = StreamFlags(carg1) return flags } // 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 // // Parse a stream-group-done @event and store the result in the given // @group_id location. func (event *Event) ParseStreamGroupDone() uint { var carg0 *C.GstEvent // in, none, converted var carg1 C.guint // out, full, casted carg0 = (*C.GstEvent)(UnsafeEventToGlibNone(event)) C.gst_event_parse_stream_group_done(carg0, &carg1) runtime.KeepAlive(event) var groupId uint groupId = uint(carg1) return groupId } // ParseStreamStart wraps gst_event_parse_stream_start // // The function returns the following values: // // - streamId string: pointer to store the stream-id // // Parse a stream-id @event and store the result in the given @stream_id // location. The string stored in @stream_id must not be modified and will // remain valid only until @event gets freed. Make a copy if you want to // modify it or store it for later use. func (event *Event) ParseStreamStart() string { var carg0 *C.GstEvent // in, none, converted var carg1 *C.gchar // out, none, string carg0 = (*C.GstEvent)(UnsafeEventToGlibNone(event)) C.gst_event_parse_stream_start(carg0, &carg1) runtime.KeepAlive(event) var streamId string streamId = C.GoString((*C.char)(unsafe.Pointer(carg1))) return streamId } // ParseTag wraps gst_event_parse_tag // // The function returns the following values: // // - taglist *TagList: pointer to metadata list // // Parses a tag @event and stores the results in the given @taglist location. // No reference to the taglist will be returned, it remains valid only until // the @event is freed. Don't modify or free the taglist, make a copy if you // want to modify it or store it for later use. func (event *Event) ParseTag() *TagList { var carg0 *C.GstEvent // in, none, converted var carg1 *C.GstTagList // out, none, converted carg0 = (*C.GstEvent)(UnsafeEventToGlibNone(event)) C.gst_event_parse_tag(carg0, &carg1) runtime.KeepAlive(event) var taglist *TagList taglist = UnsafeTagListFromGlibNone(unsafe.Pointer(carg1)) return taglist } // ParseToc wraps gst_event_parse_toc // // The function returns the following values: // // - toc *Toc: pointer to #GstToc structure. // - updated bool: pointer to store TOC updated flag. // // Parse a TOC @event and store the results in the given @toc and @updated locations. func (event *Event) ParseToc() (*Toc, bool) { var carg0 *C.GstEvent // in, none, converted var carg1 *C.GstToc // out, full, converted var carg2 C.gboolean // out carg0 = (*C.GstEvent)(UnsafeEventToGlibNone(event)) C.gst_event_parse_toc(carg0, &carg1, &carg2) runtime.KeepAlive(event) var toc *Toc var updated bool toc = UnsafeTocFromGlibFull(unsafe.Pointer(carg1)) if carg2 != 0 { updated = true } return toc, updated } // ParseTocSelect wraps gst_event_parse_toc_select // // The function returns the following values: // // - uid string: storage for the selection UID. // // Parse a TOC select @event and store the results in the given @uid location. func (event *Event) ParseTocSelect() string { var carg0 *C.GstEvent // in, none, converted var carg1 *C.gchar // out, full, string carg0 = (*C.GstEvent)(UnsafeEventToGlibNone(event)) C.gst_event_parse_toc_select(carg0, &carg1) runtime.KeepAlive(event) var uid string uid = C.GoString((*C.char)(unsafe.Pointer(carg1))) defer C.free(unsafe.Pointer(carg1)) return uid } // SetGapFlags wraps gst_event_set_gap_flags // // The function takes the following parameters: // // - flags GapFlags: a #GstGapFlags // // Sets @flags on @event to give additional information about the reason for // the #GST_EVENT_GAP. func (event *Event) SetGapFlags(flags GapFlags) { var carg0 *C.GstEvent // in, none, converted var carg1 C.GstGapFlags // in, none, casted carg0 = (*C.GstEvent)(UnsafeEventToGlibNone(event)) carg1 = C.GstGapFlags(flags) C.gst_event_set_gap_flags(carg0, carg1) runtime.KeepAlive(event) runtime.KeepAlive(flags) } // SetGroupID wraps gst_event_set_group_id // // The function takes the following parameters: // // - groupId uint: the group id to set // // All streams that have the same group id are supposed to be played // together, i.e. all streams inside a container file should have the // same group id but different stream ids. The group id should change // each time the stream is started, resulting in different group ids // each time a file is played for example. // // Use gst_util_group_id_next() to get a new group id. func (event *Event) SetGroupID(groupId uint) { var carg0 *C.GstEvent // in, none, converted var carg1 C.guint // in, none, casted carg0 = (*C.GstEvent)(UnsafeEventToGlibNone(event)) carg1 = C.guint(groupId) C.gst_event_set_group_id(carg0, carg1) runtime.KeepAlive(event) runtime.KeepAlive(groupId) } // SetRunningTimeOffset wraps gst_event_set_running_time_offset // // The function takes the following parameters: // // - offset int64: A the new running time offset // // Set the running time offset of a event. See // gst_event_get_running_time_offset() for more information. // // MT safe. func (event *Event) SetRunningTimeOffset(offset int64) { var carg0 *C.GstEvent // in, none, converted var carg1 C.gint64 // in, none, casted carg0 = (*C.GstEvent)(UnsafeEventToGlibNone(event)) carg1 = C.gint64(offset) C.gst_event_set_running_time_offset(carg0, carg1) runtime.KeepAlive(event) runtime.KeepAlive(offset) } // SetSeekTrickmodeInterval wraps gst_event_set_seek_trickmode_interval // // The function takes the following parameters: // // - interval ClockTime // // Sets a trickmode interval on a (writable) seek event. Elements // that support TRICKMODE_KEY_UNITS seeks SHOULD use this as the minimal // interval between each frame they may output. func (event *Event) SetSeekTrickmodeInterval(interval ClockTime) { var carg0 *C.GstEvent // in, none, converted var carg1 C.GstClockTime // in, none, casted, alias carg0 = (*C.GstEvent)(UnsafeEventToGlibNone(event)) carg1 = C.GstClockTime(interval) C.gst_event_set_seek_trickmode_interval(carg0, carg1) runtime.KeepAlive(event) runtime.KeepAlive(interval) } // SetSeqnum wraps gst_event_set_seqnum // // The function takes the following parameters: // // - seqnum uint32: A sequence number. // // Set the sequence number of a event. // // This function might be called by the creator of a event to indicate that the // event relates to other events or messages. See gst_event_get_seqnum() for // more information. // // MT safe. func (event *Event) SetSeqnum(seqnum uint32) { var carg0 *C.GstEvent // in, none, converted var carg1 C.guint32 // in, none, casted carg0 = (*C.GstEvent)(UnsafeEventToGlibNone(event)) carg1 = C.guint32(seqnum) C.gst_event_set_seqnum(carg0, carg1) runtime.KeepAlive(event) runtime.KeepAlive(seqnum) } // SetStream wraps gst_event_set_stream // // The function takes the following parameters: // // - stream Stream: the stream object to set // // Set the @stream on the stream-start @event func (event *Event) SetStream(stream Stream) { var carg0 *C.GstEvent // in, none, converted var carg1 *C.GstStream // in, none, converted carg0 = (*C.GstEvent)(UnsafeEventToGlibNone(event)) carg1 = (*C.GstStream)(UnsafeStreamToGlibNone(stream)) C.gst_event_set_stream(carg0, carg1) runtime.KeepAlive(event) runtime.KeepAlive(stream) } // SetStreamFlags wraps gst_event_set_stream_flags // // The function takes the following parameters: // // - flags StreamFlags: the stream flags to set func (event *Event) SetStreamFlags(flags StreamFlags) { var carg0 *C.GstEvent // in, none, converted var carg1 C.GstStreamFlags // in, none, casted carg0 = (*C.GstEvent)(UnsafeEventToGlibNone(event)) carg1 = C.GstStreamFlags(flags) C.gst_event_set_stream_flags(carg0, carg1) runtime.KeepAlive(event) runtime.KeepAlive(flags) } // WritableStructure wraps gst_event_writable_structure // // The function returns the following values: // // - goret *Structure // // Get a writable version of the structure. func (event *Event) WritableStructure() *Structure { var carg0 *C.GstEvent // in, none, converted var cret *C.GstStructure // return, none, converted carg0 = (*C.GstEvent)(UnsafeEventToGlibNone(event)) cret = C.gst_event_writable_structure(carg0) runtime.KeepAlive(event) var goret *Structure goret = UnsafeStructureFromGlibNone(unsafe.Pointer(cret)) return goret } // FormatDefinition wraps GstFormatDefinition // // A format definition type FormatDefinition struct { *formatDefinition } // formatDefinition is the struct that's finalized type formatDefinition struct { native *C.GstFormatDefinition } // UnsafeFormatDefinitionFromGlibBorrow is used to convert raw C.GstFormatDefinition pointers to go. This is used by the bindings internally. func UnsafeFormatDefinitionFromGlibBorrow(p unsafe.Pointer) *FormatDefinition { return &FormatDefinition{&formatDefinition{(*C.GstFormatDefinition)(p)}} } // 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) runtime.SetFinalizer( wrapped.formatDefinition, func (intern *formatDefinition) { C.free(unsafe.Pointer(intern.native)) }, ) return wrapped } // 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( wrapped.formatDefinition, func (intern *formatDefinition) { C.free(unsafe.Pointer(intern.native)) }, ) return wrapped } // UnsafeFormatDefinitionFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [FormatDefinition] is expected to work anymore. func UnsafeFormatDefinitionFree(f *FormatDefinition) { C.free(unsafe.Pointer(f.native)) } // UnsafeFormatDefinitionToGlibNone returns the underlying C pointer. This is used by the bindings internally. func UnsafeFormatDefinitionToGlibNone(f *FormatDefinition) unsafe.Pointer { return unsafe.Pointer(f.native) } // UnsafeFormatDefinitionToGlibFull returns the underlying C pointer and gives up ownership. // This is used by the bindings internally. func UnsafeFormatDefinitionToGlibFull(f *FormatDefinition) unsafe.Pointer { runtime.SetFinalizer(f.formatDefinition, nil) _p := unsafe.Pointer(f.native) 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 } // ghostPadClass is the struct that's finalized type ghostPadClass struct { native *C.GstGhostPadClass } // UnsafeGhostPadClassFromGlibBorrow is used to convert raw C.GstGhostPadClass pointers to go. This is used by the bindings internally. func UnsafeGhostPadClassFromGlibBorrow(p unsafe.Pointer) *GhostPadClass { return &GhostPadClass{&ghostPadClass{(*C.GstGhostPadClass)(p)}} } // 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. func UnsafeGhostPadClassFree(g *GhostPadClass) { C.free(unsafe.Pointer(g.native)) } // UnsafeGhostPadClassToGlibNone returns the underlying C pointer. This is used by the bindings internally. func UnsafeGhostPadClassToGlibNone(g *GhostPadClass) unsafe.Pointer { return unsafe.Pointer(g.native) } // 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 // a threadsafe way. // // Various GStreamer objects provide access to their internal structures using // an iterator. // // Note that if calling a GstIterator function results in your code receiving // a refcounted object (with, say, g_value_get_object()), the refcount for that // object will not be increased. Your code is responsible for taking a reference // if it wants to continue using it later. // // The basic use pattern of an iterator is as follows: // |[<!-- language="C" --> // GstIterator *it = _get_iterator(object); // GValue item = G_VALUE_INIT; // done = FALSE; // while (!done) { // switch (gst_iterator_next (it, &item)) { // case GST_ITERATOR_OK: // ...get/use/change item here... // g_value_reset (&item); // break; // case GST_ITERATOR_RESYNC: // ...rollback changes to items... // gst_iterator_resync (it); // break; // case GST_ITERATOR_ERROR: // ...wrong parameters were given... // done = TRUE; // break; // case GST_ITERATOR_DONE: // done = TRUE; // break; // } // } // g_value_unset (&item); // gst_iterator_free (it); // ]| type Iterator struct { *iterator } // iterator is the struct that's finalized type iterator struct { native *C.GstIterator } var _ gobject.GoValueInitializer = (*Iterator)(nil) func marshalIterator(p unsafe.Pointer) (interface{}, error) { b := gobject.ValueFromNative(p).Boxed() return UnsafeIteratorFromGlibBorrow(b), nil } func (r *Iterator) InitGoValue(v *gobject.Value) { v.Init(TypeIterator) v.SetBoxed(unsafe.Pointer(r.native)) } // UnsafeIteratorFromGlibBorrow is used to convert raw C.GstIterator pointers to go. This is used by the bindings internally. func UnsafeIteratorFromGlibBorrow(p unsafe.Pointer) *Iterator { return &Iterator{&iterator{(*C.GstIterator)(p)}} } // 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) runtime.SetFinalizer( wrapped.iterator, func (intern *iterator) { C.gst_iterator_free(intern.native) }, ) return wrapped } // 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( wrapped.iterator, func (intern *iterator) { C.gst_iterator_free(intern.native) }, ) return wrapped } // UnsafeIteratorFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [Iterator] is expected to work anymore. func UnsafeIteratorFree(i *Iterator) { C.gst_iterator_free(i.native) } // UnsafeIteratorToGlibNone returns the underlying C pointer. This is used by the bindings internally. func UnsafeIteratorToGlibNone(i *Iterator) unsafe.Pointer { return unsafe.Pointer(i.native) } // UnsafeIteratorToGlibFull returns the underlying C pointer and gives up ownership. // This is used by the bindings internally. func UnsafeIteratorToGlibFull(i *Iterator) unsafe.Pointer { runtime.SetFinalizer(i.iterator, nil) _p := unsafe.Pointer(i.native) i.native = nil // Iterator is invalid from here on return _p } // NewIteratorSingle wraps gst_iterator_new_single // // The function takes the following parameters: // // - typ gobject.Type: #GType of the passed object // - object *gobject.Value: object that this iterator should return // // The function returns the following values: // // - goret *Iterator // // This #GstIterator is a convenient iterator for the common // case where a #GstIterator needs to be returned but only // a single object has to be considered. This happens often // for the #GstPadIterIntLinkFunction. func NewIteratorSingle(typ gobject.Type, object *gobject.Value) *Iterator { var carg1 C.GType // in, none, casted, alias var carg2 *C.GValue // in, none, converted var cret *C.GstIterator // return, full, converted carg1 = C.GType(typ) carg2 = (*C.GValue)(gobject.UnsafeValueToGlibUseAnyInstead(object)) cret = C.gst_iterator_new_single(carg1, carg2) runtime.KeepAlive(typ) runtime.KeepAlive(object) var goret *Iterator goret = UnsafeIteratorFromGlibFull(unsafe.Pointer(cret)) return goret } // Copy wraps gst_iterator_copy // // The function returns the following values: // // - goret *Iterator // // Copy the iterator and its state. func (it *Iterator) Copy() *Iterator { var carg0 *C.GstIterator // in, none, converted var cret *C.GstIterator // return, full, converted carg0 = (*C.GstIterator)(UnsafeIteratorToGlibNone(it)) cret = C.gst_iterator_copy(carg0) runtime.KeepAlive(it) var goret *Iterator goret = UnsafeIteratorFromGlibFull(unsafe.Pointer(cret)) return goret } // Fold wraps gst_iterator_fold // // The function takes the following parameters: // // - fn IteratorFoldFunction: the fold function // - ret *gobject.Value: the seed value passed to the fold function // // The function returns the following values: // // - goret IteratorResult // // Folds @func over the elements of @iter. That is to say, @func will be called // as @func (object, @ret, @user_data) for each object in @it. The normal use // of this procedure is to accumulate the results of operating on the objects in // @ret. // // This procedure can be used (and is used internally) to implement the // gst_iterator_foreach() and gst_iterator_find_custom() operations. // // The fold will proceed as long as @func returns %TRUE. When the iterator has no // more arguments, %GST_ITERATOR_DONE will be returned. If @func returns %FALSE, // the fold will stop, and %GST_ITERATOR_OK will be returned. Errors or resyncs // will cause fold to return %GST_ITERATOR_ERROR or %GST_ITERATOR_RESYNC as // appropriate. // // The iterator will not be freed. func (it *Iterator) Fold(fn IteratorFoldFunction, ret *gobject.Value) IteratorResult { var carg0 *C.GstIterator // in, none, converted var carg1 C.GstIteratorFoldFunction // callback, scope: call, closure: carg3 var carg2 *C.GValue // in, none, converted var carg3 C.gpointer // implicit var cret C.GstIteratorResult // return, none, casted carg0 = (*C.GstIterator)(UnsafeIteratorToGlibNone(it)) carg1 = (*[0]byte)(C._gotk4_gst1_IteratorFoldFunction) carg3 = C.gpointer(userdata.Register(fn)) defer userdata.Delete(unsafe.Pointer(carg3)) carg2 = (*C.GValue)(gobject.UnsafeValueToGlibUseAnyInstead(ret)) cret = C.gst_iterator_fold(carg0, carg1, carg2, carg3) runtime.KeepAlive(it) runtime.KeepAlive(fn) runtime.KeepAlive(ret) var goret IteratorResult goret = IteratorResult(cret) return goret } // ForEach wraps gst_iterator_foreach // // The function takes the following parameters: // // - fn IteratorForEachFunction: the function to call for each element. // // The function returns the following values: // // - goret IteratorResult // // Iterate over all element of @it and call the given function @func for // each element. func (it *Iterator) ForEach(fn IteratorForEachFunction) IteratorResult { var carg0 *C.GstIterator // in, none, converted var carg1 C.GstIteratorForeachFunction // callback, scope: call, closure: carg2 var carg2 C.gpointer // implicit var cret C.GstIteratorResult // return, none, casted carg0 = (*C.GstIterator)(UnsafeIteratorToGlibNone(it)) carg1 = (*[0]byte)(C._gotk4_gst1_IteratorForEachFunction) carg2 = C.gpointer(userdata.Register(fn)) defer userdata.Delete(unsafe.Pointer(carg2)) cret = C.gst_iterator_foreach(carg0, carg1, carg2) runtime.KeepAlive(it) runtime.KeepAlive(fn) var goret IteratorResult goret = IteratorResult(cret) return goret } // Push wraps gst_iterator_push // // The function takes the following parameters: // // - other *Iterator: The #GstIterator to push // // Pushes @other iterator onto @it. All calls performed on @it are // forwarded to @other. If @other returns %GST_ITERATOR_DONE, it is // popped again and calls are handled by @it again. // // This function is mainly used by objects implementing the iterator // next function to recurse into substructures. // // When gst_iterator_resync() is called on @it, @other will automatically be // popped. // // MT safe. func (it *Iterator) Push(other *Iterator) { var carg0 *C.GstIterator // in, none, converted var carg1 *C.GstIterator // in, none, converted carg0 = (*C.GstIterator)(UnsafeIteratorToGlibNone(it)) carg1 = (*C.GstIterator)(UnsafeIteratorToGlibNone(other)) C.gst_iterator_push(carg0, carg1) runtime.KeepAlive(it) runtime.KeepAlive(other) } // Resync wraps gst_iterator_resync // // Resync the iterator. this function is mostly called // after gst_iterator_next() returned %GST_ITERATOR_RESYNC. // // When an iterator was pushed on @it, it will automatically be popped again // with this function. // // MT safe. func (it *Iterator) Resync() { var carg0 *C.GstIterator // in, none, converted carg0 = (*C.GstIterator)(UnsafeIteratorToGlibNone(it)) C.gst_iterator_resync(carg0) runtime.KeepAlive(it) } // Memory wraps GstMemory // // GstMemory is a lightweight refcounted object that wraps a region of memory. // They are typically used to manage the data of a #GstBuffer. // // A GstMemory object has an allocated region of memory of maxsize. The maximum // size does not change during the lifetime of the memory object. The memory // also has an offset and size property that specifies the valid range of memory // in the allocated region. // // Memory is usually created by allocators with a gst_allocator_alloc() // method call. When %NULL is used as the allocator, the default allocator will // be used. // // New allocators can be registered with gst_allocator_register(). // Allocators are identified by name and can be retrieved with // gst_allocator_find(). gst_allocator_set_default() can be used to change the // default allocator. // // New memory can be created with gst_memory_new_wrapped() that wraps the memory // allocated elsewhere. // // Refcounting of the memory block is performed with gst_memory_ref() and // gst_memory_unref(). // // The size of the memory can be retrieved and changed with // gst_memory_get_sizes() and gst_memory_resize() respectively. // // Getting access to the data of the memory is performed with gst_memory_map(). // The call will return a pointer to offset bytes into the region of memory. // After the memory access is completed, gst_memory_unmap() should be called. // // Memory can be copied with gst_memory_copy(), which will return a writable // copy. gst_memory_share() will create a new memory block that shares the // memory with an existing memory block at a custom offset and with a custom // size. // // Memory can be efficiently merged when gst_memory_is_span() returns %TRUE. type Memory struct { *memory } // memory is the struct that's finalized type memory struct { native *C.GstMemory } var _ gobject.GoValueInitializer = (*Memory)(nil) func marshalMemory(p unsafe.Pointer) (interface{}, error) { b := gobject.ValueFromNative(p).Boxed() return UnsafeMemoryFromGlibBorrow(b), nil } func (r *Memory) InitGoValue(v *gobject.Value) { v.Init(TypeMemory) v.SetBoxed(unsafe.Pointer(r.native)) } // UnsafeMemoryFromGlibBorrow is used to convert raw C.GstMemory pointers to go. This is used by the bindings internally. func UnsafeMemoryFromGlibBorrow(p unsafe.Pointer) *Memory { return &Memory{&memory{(*C.GstMemory)(p)}} } // 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) runtime.SetFinalizer( wrapped.memory, func (intern *memory) { C.free(unsafe.Pointer(intern.native)) }, ) return wrapped } // 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( wrapped.memory, func (intern *memory) { C.free(unsafe.Pointer(intern.native)) }, ) return wrapped } // UnsafeMemoryFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [Memory] is expected to work anymore. func UnsafeMemoryFree(m *Memory) { C.free(unsafe.Pointer(m.native)) } // UnsafeMemoryToGlibNone returns the underlying C pointer. This is used by the bindings internally. func UnsafeMemoryToGlibNone(m *Memory) unsafe.Pointer { return unsafe.Pointer(m.native) } // UnsafeMemoryToGlibFull returns the underlying C pointer and gives up ownership. // This is used by the bindings internally. func UnsafeMemoryToGlibFull(m *Memory) unsafe.Pointer { runtime.SetFinalizer(m.memory, nil) _p := unsafe.Pointer(m.native) m.native = nil // Memory is invalid from here on return _p } // Copy wraps gst_memory_copy // // The function takes the following parameters: // // - offset int: offset to copy from // - size int: size to copy, or -1 to copy to the end of the memory region // // The function returns the following values: // // - goret *Memory (nullable) // // Return a copy of @size bytes from @mem starting from @offset. This copy is // guaranteed to be writable. @size can be set to -1 to return a copy // from @offset to the end of the memory region. func (mem *Memory) Copy(offset int, size int) *Memory { var carg0 *C.GstMemory // in, none, converted var carg1 C.gssize // in, none, casted var carg2 C.gssize // in, none, casted var cret *C.GstMemory // return, full, converted, nullable carg0 = (*C.GstMemory)(UnsafeMemoryToGlibNone(mem)) carg1 = C.gssize(offset) carg2 = C.gssize(size) cret = C.gst_memory_copy(carg0, carg1, carg2) runtime.KeepAlive(mem) runtime.KeepAlive(offset) runtime.KeepAlive(size) var goret *Memory if cret != nil { goret = UnsafeMemoryFromGlibFull(unsafe.Pointer(cret)) } return goret } // GetSizes wraps gst_memory_get_sizes // // The function returns the following values: // // - offset uint: pointer to offset // - maxsize uint: pointer to maxsize // - goret uint // // Get the current @size, @offset and @maxsize of @mem. func (mem *Memory) GetSizes() (uint, uint, uint) { var carg0 *C.GstMemory // in, none, converted var carg1 C.gsize // out, full, casted var carg2 C.gsize // out, full, casted var cret C.gsize // return, none, casted carg0 = (*C.GstMemory)(UnsafeMemoryToGlibNone(mem)) cret = C.gst_memory_get_sizes(carg0, &carg1, &carg2) runtime.KeepAlive(mem) var offset uint var maxsize uint var goret uint offset = uint(carg1) maxsize = uint(carg2) goret = uint(cret) return offset, maxsize, goret } // IsSpan wraps gst_memory_is_span // // The function takes the following parameters: // // - mem2 *Memory: a #GstMemory // // The function returns the following values: // // - offset uint: a pointer to a result offset // - goret bool // // Check if @mem1 and mem2 share the memory with a common parent memory object // and that the memory is contiguous. // // If this is the case, the memory of @mem1 and @mem2 can be merged // efficiently by performing gst_memory_share() on the parent object from // the returned @offset. func (mem1 *Memory) IsSpan(mem2 *Memory) (uint, bool) { var carg0 *C.GstMemory // in, none, converted var carg1 *C.GstMemory // in, none, converted var carg2 C.gsize // out, full, casted var cret C.gboolean // return carg0 = (*C.GstMemory)(UnsafeMemoryToGlibNone(mem1)) carg1 = (*C.GstMemory)(UnsafeMemoryToGlibNone(mem2)) cret = C.gst_memory_is_span(carg0, carg1, &carg2) runtime.KeepAlive(mem1) runtime.KeepAlive(mem2) var offset uint var goret bool offset = uint(carg2) if cret != 0 { goret = true } return offset, goret } // IsType wraps gst_memory_is_type // // The function takes the following parameters: // // - memType string: a memory type // // The function returns the following values: // // - goret bool // // Check if @mem if allocated with an allocator for @mem_type. func (mem *Memory) IsType(memType string) bool { var carg0 *C.GstMemory // in, none, converted var carg1 *C.gchar // in, none, string var cret C.gboolean // return carg0 = (*C.GstMemory)(UnsafeMemoryToGlibNone(mem)) carg1 = (*C.gchar)(unsafe.Pointer(C.CString(memType))) defer C.free(unsafe.Pointer(carg1)) cret = C.gst_memory_is_type(carg0, carg1) runtime.KeepAlive(mem) runtime.KeepAlive(memType) var goret bool if cret != 0 { goret = true } return goret } // Resize wraps gst_memory_resize // // The function takes the following parameters: // // - offset int: a new offset // - size uint: a new size // // Resize the memory region. @mem should be writable and offset + size should be // less than the maxsize of @mem. // // #GST_MEMORY_FLAG_ZERO_PREFIXED and #GST_MEMORY_FLAG_ZERO_PADDED will be // cleared when offset or padding is increased respectively. func (mem *Memory) Resize(offset int, size uint) { var carg0 *C.GstMemory // in, none, converted var carg1 C.gssize // in, none, casted var carg2 C.gsize // in, none, casted carg0 = (*C.GstMemory)(UnsafeMemoryToGlibNone(mem)) carg1 = C.gssize(offset) carg2 = C.gsize(size) C.gst_memory_resize(carg0, carg1, carg2) runtime.KeepAlive(mem) runtime.KeepAlive(offset) runtime.KeepAlive(size) } // Share wraps gst_memory_share // // The function takes the following parameters: // // - offset int: offset to share from // - size int: size to share, or -1 to share to the end of the memory region // // The function returns the following values: // // - goret *Memory // // Return a shared copy of @size bytes from @mem starting from @offset. No // memory copy is performed and the memory region is simply shared. The result // is guaranteed to be non-writable. @size can be set to -1 to return a shared // copy from @offset to the end of the memory region. func (mem *Memory) Share(offset int, size int) *Memory { var carg0 *C.GstMemory // in, none, converted var carg1 C.gssize // in, none, casted var carg2 C.gssize // in, none, casted var cret *C.GstMemory // return, full, converted carg0 = (*C.GstMemory)(UnsafeMemoryToGlibNone(mem)) carg1 = C.gssize(offset) carg2 = C.gssize(size) cret = C.gst_memory_share(carg0, carg1, carg2) runtime.KeepAlive(mem) runtime.KeepAlive(offset) runtime.KeepAlive(size) var goret *Memory goret = UnsafeMemoryFromGlibFull(unsafe.Pointer(cret)) return goret } // Message wraps GstMessage // // Messages are implemented as a subclass of #GstMiniObject with a generic // #GstStructure as the content. This allows for writing custom messages without // requiring an API change while allowing a wide range of different types // of messages. // // Messages are posted by objects in the pipeline and are passed to the // application using the #GstBus. // // The basic use pattern of posting a message on a #GstBus is as follows: // |[<!-- language="C" --> // gst_bus_post (bus, gst_message_new_eos()); // ]| // // A #GstElement usually posts messages on the bus provided by the parent // container using gst_element_post_message(). type Message struct { *message } // message is the struct that's finalized type message struct { native *C.GstMessage } var _ gobject.GoValueInitializer = (*Message)(nil) func marshalMessage(p unsafe.Pointer) (interface{}, error) { b := gobject.ValueFromNative(p).Boxed() return UnsafeMessageFromGlibBorrow(b), nil } func (r *Message) InitGoValue(v *gobject.Value) { v.Init(TypeMessage) v.SetBoxed(unsafe.Pointer(r.native)) } // UnsafeMessageFromGlibBorrow is used to convert raw C.GstMessage pointers to go. This is used by the bindings internally. func UnsafeMessageFromGlibBorrow(p unsafe.Pointer) *Message { return &Message{&message{(*C.GstMessage)(p)}} } // 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) runtime.SetFinalizer( wrapped.message, func (intern *message) { C.free(unsafe.Pointer(intern.native)) }, ) return wrapped } // 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( wrapped.message, func (intern *message) { C.free(unsafe.Pointer(intern.native)) }, ) return wrapped } // UnsafeMessageFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [Message] is expected to work anymore. func UnsafeMessageFree(m *Message) { C.free(unsafe.Pointer(m.native)) } // UnsafeMessageToGlibNone returns the underlying C pointer. This is used by the bindings internally. func UnsafeMessageToGlibNone(m *Message) unsafe.Pointer { return unsafe.Pointer(m.native) } // UnsafeMessageToGlibFull returns the underlying C pointer and gives up ownership. // This is used by the bindings internally. func UnsafeMessageToGlibFull(m *Message) unsafe.Pointer { runtime.SetFinalizer(m.message, nil) _p := unsafe.Pointer(m.native) m.native = nil // Message is invalid from here on return _p } // NewMessageApplication wraps gst_message_new_application // // The function takes the following parameters: // // - src Object (nullable): The object originating the message. // - structure *Structure: the structure for the message. The message // will take ownership of the structure. // // The function returns the following values: // // - goret *Message // // Create a new application-typed message. GStreamer will never create these // messages; they are a gift from us to you. Enjoy. func NewMessageApplication(src Object, structure *Structure) *Message { var carg1 *C.GstObject // in, none, converted, nullable var carg2 *C.GstStructure // in, full, converted var cret *C.GstMessage // return, full, converted if src != nil { carg1 = (*C.GstObject)(UnsafeObjectToGlibNone(src)) } carg2 = (*C.GstStructure)(UnsafeStructureToGlibFull(structure)) cret = C.gst_message_new_application(carg1, carg2) runtime.KeepAlive(src) runtime.KeepAlive(structure) var goret *Message goret = UnsafeMessageFromGlibFull(unsafe.Pointer(cret)) return goret } // NewMessageAsyncDone wraps gst_message_new_async_done // // The function takes the following parameters: // // - src Object (nullable): The object originating the message. // - runningTime ClockTime: the desired running_time // // The function returns the following values: // // - goret *Message // // The message is posted when elements completed an ASYNC state change. // @running_time contains the time of the desired running_time when this // elements goes to PLAYING. A value of #GST_CLOCK_TIME_NONE for @running_time // means that the element has no clock interaction and thus doesn't care about // the running_time of the pipeline. func NewMessageAsyncDone(src Object, runningTime ClockTime) *Message { var carg1 *C.GstObject // in, none, converted, nullable var carg2 C.GstClockTime // in, none, casted, alias var cret *C.GstMessage // return, full, converted if src != nil { carg1 = (*C.GstObject)(UnsafeObjectToGlibNone(src)) } carg2 = C.GstClockTime(runningTime) cret = C.gst_message_new_async_done(carg1, carg2) runtime.KeepAlive(src) runtime.KeepAlive(runningTime) var goret *Message goret = UnsafeMessageFromGlibFull(unsafe.Pointer(cret)) return goret } // NewMessageAsyncStart wraps gst_message_new_async_start // // The function takes the following parameters: // // - src Object (nullable): The object originating the message. // // The function returns the following values: // // - goret *Message // // This message is posted by elements when they start an ASYNC state change. func NewMessageAsyncStart(src Object) *Message { var carg1 *C.GstObject // in, none, converted, nullable var cret *C.GstMessage // return, full, converted if src != nil { carg1 = (*C.GstObject)(UnsafeObjectToGlibNone(src)) } cret = C.gst_message_new_async_start(carg1) runtime.KeepAlive(src) var goret *Message goret = UnsafeMessageFromGlibFull(unsafe.Pointer(cret)) return goret } // NewMessageBuffering wraps gst_message_new_buffering // // The function takes the following parameters: // // - src Object (nullable): The object originating the message. // - percent int: The buffering percent // // The function returns the following values: // // - goret *Message // // Create a new buffering message. This message can be posted by an element that // needs to buffer data before it can continue processing. @percent should be a // value between 0 and 100. A value of 100 means that the buffering completed. // // When @percent is < 100 the application should PAUSE a PLAYING pipeline. When // @percent is 100, the application can set the pipeline (back) to PLAYING. // The application must be prepared to receive BUFFERING messages in the // PREROLLING state and may only set the pipeline to PLAYING after receiving a // message with @percent set to 100, which can happen after the pipeline // completed prerolling. // // MT safe. func NewMessageBuffering(src Object, percent int) *Message { var carg1 *C.GstObject // in, none, converted, nullable var carg2 C.gint // in, none, casted var cret *C.GstMessage // return, full, converted if src != nil { carg1 = (*C.GstObject)(UnsafeObjectToGlibNone(src)) } carg2 = C.gint(percent) cret = C.gst_message_new_buffering(carg1, carg2) runtime.KeepAlive(src) runtime.KeepAlive(percent) var goret *Message goret = UnsafeMessageFromGlibFull(unsafe.Pointer(cret)) return goret } // NewMessageClockLost wraps gst_message_new_clock_lost // // The function takes the following parameters: // // - src Object (nullable): The object originating the message. // - clock Clock: the clock that was lost // // The function returns the following values: // // - goret *Message // // Create a clock lost message. This message is posted whenever the // clock is not valid anymore. // // If this message is posted by the pipeline, the pipeline will // select a new clock again when it goes to PLAYING. It might therefore // be needed to set the pipeline to PAUSED and PLAYING again. func NewMessageClockLost(src Object, clock Clock) *Message { var carg1 *C.GstObject // in, none, converted, nullable var carg2 *C.GstClock // in, none, converted var cret *C.GstMessage // return, full, converted if src != nil { carg1 = (*C.GstObject)(UnsafeObjectToGlibNone(src)) } carg2 = (*C.GstClock)(UnsafeClockToGlibNone(clock)) cret = C.gst_message_new_clock_lost(carg1, carg2) runtime.KeepAlive(src) runtime.KeepAlive(clock) var goret *Message goret = UnsafeMessageFromGlibFull(unsafe.Pointer(cret)) return goret } // NewMessageClockProvide wraps gst_message_new_clock_provide // // The function takes the following parameters: // // - src Object (nullable): The object originating the message. // - clock Clock: the clock it provides // - ready bool: %TRUE if the sender can provide a clock // // The function returns the following values: // // - goret *Message // // Create a clock provide message. This message is posted whenever an // element is ready to provide a clock or lost its ability to provide // a clock (maybe because it paused or became EOS). // // This message is mainly used internally to manage the clock // selection. func NewMessageClockProvide(src Object, clock Clock, ready bool) *Message { var carg1 *C.GstObject // in, none, converted, nullable var carg2 *C.GstClock // in, none, converted var carg3 C.gboolean // in var cret *C.GstMessage // return, full, converted if src != nil { carg1 = (*C.GstObject)(UnsafeObjectToGlibNone(src)) } carg2 = (*C.GstClock)(UnsafeClockToGlibNone(clock)) if ready { carg3 = C.TRUE } cret = C.gst_message_new_clock_provide(carg1, carg2, carg3) runtime.KeepAlive(src) runtime.KeepAlive(clock) runtime.KeepAlive(ready) var goret *Message goret = UnsafeMessageFromGlibFull(unsafe.Pointer(cret)) return goret } // NewMessageCustom wraps gst_message_new_custom // // The function takes the following parameters: // // - typ MessageType: The #GstMessageType to distinguish messages // - src Object (nullable): The object originating the message. // - structure *Structure (nullable): the structure for the // message. The message will take ownership of the structure. // // The function returns the following values: // // - goret *Message // // Create a new custom-typed message. This can be used for anything not // handled by other message-specific functions to pass a message to the // app. The structure field can be %NULL. func NewMessageCustom(typ MessageType, src Object, structure *Structure) *Message { var carg1 C.GstMessageType // in, none, casted var carg2 *C.GstObject // in, none, converted, nullable var carg3 *C.GstStructure // in, full, converted, nullable var cret *C.GstMessage // return, full, converted carg1 = C.GstMessageType(typ) if src != nil { carg2 = (*C.GstObject)(UnsafeObjectToGlibNone(src)) } if structure != nil { carg3 = (*C.GstStructure)(UnsafeStructureToGlibFull(structure)) } cret = C.gst_message_new_custom(carg1, carg2, carg3) runtime.KeepAlive(typ) runtime.KeepAlive(src) runtime.KeepAlive(structure) var goret *Message goret = UnsafeMessageFromGlibFull(unsafe.Pointer(cret)) return goret } // NewMessageDeviceAdded wraps gst_message_new_device_added // // The function takes the following parameters: // // - src Object (nullable): The #GstObject that created the message // - device Device: The new #GstDevice // // The function returns the following values: // // - goret *Message // // Creates a new device-added message. The device-added message is produced by // #GstDeviceProvider or a #GstDeviceMonitor. They announce the appearance // of monitored devices. func NewMessageDeviceAdded(src Object, device Device) *Message { var carg1 *C.GstObject // in, none, converted, nullable var carg2 *C.GstDevice // in, none, converted var cret *C.GstMessage // return, full, converted if src != nil { carg1 = (*C.GstObject)(UnsafeObjectToGlibNone(src)) } carg2 = (*C.GstDevice)(UnsafeDeviceToGlibNone(device)) cret = C.gst_message_new_device_added(carg1, carg2) runtime.KeepAlive(src) runtime.KeepAlive(device) var goret *Message goret = UnsafeMessageFromGlibFull(unsafe.Pointer(cret)) return goret } // NewMessageDeviceChanged wraps gst_message_new_device_changed // // The function takes the following parameters: // // - src Object (nullable): The #GstObject that created the message // - device Device: The newly created device representing @changed_device // with its new configuration. // - changedDevice Device: The old version of the device. // // The function returns the following values: // // - goret *Message // // Creates a new device-changed message. The device-changed message is produced // by #GstDeviceProvider or a #GstDeviceMonitor. They announce that a device // properties has changed and @device represent the new modified version of @changed_device. func NewMessageDeviceChanged(src Object, device Device, changedDevice Device) *Message { var carg1 *C.GstObject // in, none, converted, nullable var carg2 *C.GstDevice // in, none, converted var carg3 *C.GstDevice // in, none, converted var cret *C.GstMessage // return, full, converted if src != nil { carg1 = (*C.GstObject)(UnsafeObjectToGlibNone(src)) } carg2 = (*C.GstDevice)(UnsafeDeviceToGlibNone(device)) carg3 = (*C.GstDevice)(UnsafeDeviceToGlibNone(changedDevice)) cret = C.gst_message_new_device_changed(carg1, carg2, carg3) runtime.KeepAlive(src) runtime.KeepAlive(device) runtime.KeepAlive(changedDevice) var goret *Message goret = UnsafeMessageFromGlibFull(unsafe.Pointer(cret)) return goret } // NewMessageDeviceRemoved wraps gst_message_new_device_removed // // The function takes the following parameters: // // - src Object (nullable): The #GstObject that created the message // - device Device: The removed #GstDevice // // The function returns the following values: // // - goret *Message // // Creates a new device-removed message. The device-removed message is produced // by #GstDeviceProvider or a #GstDeviceMonitor. They announce the // disappearance of monitored devices. func NewMessageDeviceRemoved(src Object, device Device) *Message { var carg1 *C.GstObject // in, none, converted, nullable var carg2 *C.GstDevice // in, none, converted var cret *C.GstMessage // return, full, converted if src != nil { carg1 = (*C.GstObject)(UnsafeObjectToGlibNone(src)) } carg2 = (*C.GstDevice)(UnsafeDeviceToGlibNone(device)) cret = C.gst_message_new_device_removed(carg1, carg2) runtime.KeepAlive(src) runtime.KeepAlive(device) var goret *Message goret = UnsafeMessageFromGlibFull(unsafe.Pointer(cret)) return goret } // NewMessageDurationChanged wraps gst_message_new_duration_changed // // The function takes the following parameters: // // - src Object (nullable): The object originating the message. // // The function returns the following values: // // - goret *Message // // Create a new duration changed message. This message is posted by elements // that know the duration of a stream when the duration changes. This message // is received by bins and is used to calculate the total duration of a // pipeline. func NewMessageDurationChanged(src Object) *Message { var carg1 *C.GstObject // in, none, converted, nullable var cret *C.GstMessage // return, full, converted if src != nil { carg1 = (*C.GstObject)(UnsafeObjectToGlibNone(src)) } cret = C.gst_message_new_duration_changed(carg1) runtime.KeepAlive(src) var goret *Message goret = UnsafeMessageFromGlibFull(unsafe.Pointer(cret)) return goret } // NewMessageElement wraps gst_message_new_element // // The function takes the following parameters: // // - src Object (nullable): The object originating the message. // - structure *Structure: The structure for the // message. The message will take ownership of the structure. // // The function returns the following values: // // - goret *Message // // Create a new element-specific message. This is meant as a generic way of // allowing one-way communication from an element to an application, for example // "the firewire cable was unplugged". The format of the message should be // documented in the element's documentation. The structure field can be %NULL. func NewMessageElement(src Object, structure *Structure) *Message { var carg1 *C.GstObject // in, none, converted, nullable var carg2 *C.GstStructure // in, full, converted var cret *C.GstMessage // return, full, converted if src != nil { carg1 = (*C.GstObject)(UnsafeObjectToGlibNone(src)) } carg2 = (*C.GstStructure)(UnsafeStructureToGlibFull(structure)) cret = C.gst_message_new_element(carg1, carg2) runtime.KeepAlive(src) runtime.KeepAlive(structure) var goret *Message goret = UnsafeMessageFromGlibFull(unsafe.Pointer(cret)) return goret } // NewMessageEos wraps gst_message_new_eos // // The function takes the following parameters: // // - src Object (nullable): The object originating the message. // // The function returns the following values: // // - goret *Message // // Create a new eos message. This message is generated and posted in // the sink elements of a GstBin. The bin will only forward the EOS // message to the application if all sinks have posted an EOS message. func NewMessageEos(src Object) *Message { var carg1 *C.GstObject // in, none, converted, nullable var cret *C.GstMessage // return, full, converted if src != nil { carg1 = (*C.GstObject)(UnsafeObjectToGlibNone(src)) } cret = C.gst_message_new_eos(carg1) runtime.KeepAlive(src) var goret *Message goret = UnsafeMessageFromGlibFull(unsafe.Pointer(cret)) return goret } // NewMessageError wraps gst_message_new_error // // The function takes the following parameters: // // - src Object (nullable): The object originating the message. // - debug string: A debugging string. // - err error: The GError for this message. // // The function returns the following values: // // - goret *Message // // Create a new error message. The message will copy @error and // @debug. This message is posted by element when a fatal event // occurred. The pipeline will probably (partially) stop. The application // receiving this message should stop the pipeline. func NewMessageError(src Object, debug string, err error) *Message { var carg1 *C.GstObject // in, none, converted, nullable var carg3 *C.gchar // in, none, string var carg2 *C.GError // in, none, converted var cret *C.GstMessage // return, full, converted if src != nil { carg1 = (*C.GstObject)(UnsafeObjectToGlibNone(src)) } carg3 = (*C.gchar)(unsafe.Pointer(C.CString(debug))) defer C.free(unsafe.Pointer(carg3)) carg2 = (*C.GError)(glib.UnsafeErrorToGlibNone(err)) cret = C.gst_message_new_error(carg1, carg2, carg3) runtime.KeepAlive(src) runtime.KeepAlive(debug) runtime.KeepAlive(err) var goret *Message goret = UnsafeMessageFromGlibFull(unsafe.Pointer(cret)) return goret } // NewMessageErrorWithDetails wraps gst_message_new_error_with_details // // The function takes the following parameters: // // - src Object (nullable): The object originating the message. // - debug string: A debugging string. // - details *Structure (nullable): A GstStructure with details // - err error: The GError for this message. // // The function returns the following values: // // - goret *Message // // Create a new error message. The message will copy @error and // @debug. This message is posted by element when a fatal event // occurred. The pipeline will probably (partially) stop. The application // receiving this message should stop the pipeline. func NewMessageErrorWithDetails(src Object, debug string, details *Structure, err error) *Message { var carg1 *C.GstObject // in, none, converted, nullable var carg3 *C.gchar // in, none, string var carg4 *C.GstStructure // in, full, converted, nullable var carg2 *C.GError // in, none, converted var cret *C.GstMessage // return, full, converted if src != nil { carg1 = (*C.GstObject)(UnsafeObjectToGlibNone(src)) } carg3 = (*C.gchar)(unsafe.Pointer(C.CString(debug))) defer C.free(unsafe.Pointer(carg3)) if details != nil { carg4 = (*C.GstStructure)(UnsafeStructureToGlibFull(details)) } carg2 = (*C.GError)(glib.UnsafeErrorToGlibNone(err)) cret = C.gst_message_new_error_with_details(carg1, carg2, carg3, carg4) runtime.KeepAlive(src) runtime.KeepAlive(debug) runtime.KeepAlive(details) runtime.KeepAlive(err) var goret *Message goret = UnsafeMessageFromGlibFull(unsafe.Pointer(cret)) return goret } // NewMessageHaveContext wraps gst_message_new_have_context // // The function takes the following parameters: // // - src Object (nullable): The object originating the message. // - _context *Context: the context // // The function returns the following values: // // - goret *Message // // This message is posted when an element has a new local #GstContext. func NewMessageHaveContext(src Object, _context *Context) *Message { var carg1 *C.GstObject // in, none, converted, nullable var carg2 *C.GstContext // in, full, converted var cret *C.GstMessage // return, full, converted if src != nil { carg1 = (*C.GstObject)(UnsafeObjectToGlibNone(src)) } carg2 = (*C.GstContext)(UnsafeContextToGlibFull(_context)) cret = C.gst_message_new_have_context(carg1, carg2) runtime.KeepAlive(src) runtime.KeepAlive(_context) var goret *Message goret = UnsafeMessageFromGlibFull(unsafe.Pointer(cret)) return goret } // NewMessageInfo wraps gst_message_new_info // // The function takes the following parameters: // // - src Object (nullable): The object originating the message. // - debug string: A debugging string. // - err error: The GError for this message. // // The function returns the following values: // // - goret *Message // // Create a new info message. The message will make copies of @error and // @debug. func NewMessageInfo(src Object, debug string, err error) *Message { var carg1 *C.GstObject // in, none, converted, nullable var carg3 *C.gchar // in, none, string var carg2 *C.GError // in, none, converted var cret *C.GstMessage // return, full, converted if src != nil { carg1 = (*C.GstObject)(UnsafeObjectToGlibNone(src)) } carg3 = (*C.gchar)(unsafe.Pointer(C.CString(debug))) defer C.free(unsafe.Pointer(carg3)) carg2 = (*C.GError)(glib.UnsafeErrorToGlibNone(err)) cret = C.gst_message_new_info(carg1, carg2, carg3) runtime.KeepAlive(src) runtime.KeepAlive(debug) runtime.KeepAlive(err) var goret *Message goret = UnsafeMessageFromGlibFull(unsafe.Pointer(cret)) return goret } // NewMessageInfoWithDetails wraps gst_message_new_info_with_details // // The function takes the following parameters: // // - src Object (nullable): The object originating the message. // - debug string: A debugging string. // - details *Structure (nullable): A GstStructure with details // - err error: The GError for this message. // // The function returns the following values: // // - goret *Message // // Create a new info message. The message will make copies of @error and // @debug. func NewMessageInfoWithDetails(src Object, debug string, details *Structure, err error) *Message { var carg1 *C.GstObject // in, none, converted, nullable var carg3 *C.gchar // in, none, string var carg4 *C.GstStructure // in, full, converted, nullable var carg2 *C.GError // in, none, converted var cret *C.GstMessage // return, full, converted if src != nil { carg1 = (*C.GstObject)(UnsafeObjectToGlibNone(src)) } carg3 = (*C.gchar)(unsafe.Pointer(C.CString(debug))) defer C.free(unsafe.Pointer(carg3)) if details != nil { carg4 = (*C.GstStructure)(UnsafeStructureToGlibFull(details)) } carg2 = (*C.GError)(glib.UnsafeErrorToGlibNone(err)) cret = C.gst_message_new_info_with_details(carg1, carg2, carg3, carg4) runtime.KeepAlive(src) runtime.KeepAlive(debug) runtime.KeepAlive(details) runtime.KeepAlive(err) var goret *Message goret = UnsafeMessageFromGlibFull(unsafe.Pointer(cret)) return goret } // NewMessageInstantRateRequest wraps gst_message_new_instant_rate_request // // The function takes the following parameters: // // - src Object (nullable): The #GstObject that posted the message // - rateMultiplier float64: the rate multiplier factor that should be applied // // The function returns the following values: // // - goret *Message // // Creates a new instant-rate-request message. Elements handling the // instant-rate-change event must post this message. The message is // handled at the pipeline, and allows the pipeline to select the // running time when the rate change should happen and to send an // @GST_EVENT_INSTANT_RATE_SYNC_TIME event to notify the elements // in the pipeline. func NewMessageInstantRateRequest(src Object, rateMultiplier float64) *Message { var carg1 *C.GstObject // in, none, converted, nullable var carg2 C.gdouble // in, none, casted var cret *C.GstMessage // return, full, converted if src != nil { carg1 = (*C.GstObject)(UnsafeObjectToGlibNone(src)) } carg2 = C.gdouble(rateMultiplier) cret = C.gst_message_new_instant_rate_request(carg1, carg2) runtime.KeepAlive(src) runtime.KeepAlive(rateMultiplier) var goret *Message goret = UnsafeMessageFromGlibFull(unsafe.Pointer(cret)) return goret } // NewMessageLatency wraps gst_message_new_latency // // The function takes the following parameters: // // - src Object (nullable): The object originating the message. // // The function returns the following values: // // - goret *Message // // This message can be posted by elements when their latency requirements have // changed. func NewMessageLatency(src Object) *Message { var carg1 *C.GstObject // in, none, converted, nullable var cret *C.GstMessage // return, full, converted if src != nil { carg1 = (*C.GstObject)(UnsafeObjectToGlibNone(src)) } cret = C.gst_message_new_latency(carg1) runtime.KeepAlive(src) var goret *Message goret = UnsafeMessageFromGlibFull(unsafe.Pointer(cret)) return goret } // NewMessageNeedContext wraps gst_message_new_need_context // // The function takes the following parameters: // // - src Object (nullable): The object originating the message. // - contextType string: The context type that is needed // // The function returns the following values: // // - goret *Message // // This message is posted when an element needs a specific #GstContext. func NewMessageNeedContext(src Object, contextType string) *Message { var carg1 *C.GstObject // in, none, converted, nullable var carg2 *C.gchar // in, none, string var cret *C.GstMessage // return, full, converted if src != nil { carg1 = (*C.GstObject)(UnsafeObjectToGlibNone(src)) } carg2 = (*C.gchar)(unsafe.Pointer(C.CString(contextType))) defer C.free(unsafe.Pointer(carg2)) cret = C.gst_message_new_need_context(carg1, carg2) runtime.KeepAlive(src) runtime.KeepAlive(contextType) var goret *Message goret = UnsafeMessageFromGlibFull(unsafe.Pointer(cret)) return goret } // NewMessageNewClock wraps gst_message_new_new_clock // // The function takes the following parameters: // // - src Object (nullable): The object originating the message. // - clock Clock: the new selected clock // // The function returns the following values: // // - goret *Message // // Create a new clock message. This message is posted whenever the // pipeline selects a new clock for the pipeline. func NewMessageNewClock(src Object, clock Clock) *Message { var carg1 *C.GstObject // in, none, converted, nullable var carg2 *C.GstClock // in, none, converted var cret *C.GstMessage // return, full, converted if src != nil { carg1 = (*C.GstObject)(UnsafeObjectToGlibNone(src)) } carg2 = (*C.GstClock)(UnsafeClockToGlibNone(clock)) cret = C.gst_message_new_new_clock(carg1, carg2) runtime.KeepAlive(src) runtime.KeepAlive(clock) var goret *Message goret = UnsafeMessageFromGlibFull(unsafe.Pointer(cret)) return goret } // NewMessageProgress wraps gst_message_new_progress // // The function takes the following parameters: // // - src Object (nullable): The object originating the message. // - typ ProgressType: a #GstProgressType // - code string: a progress code // - text string: free, user visible text describing the progress // // The function returns the following values: // // - goret *Message // // Progress messages are posted by elements when they use an asynchronous task // to perform actions triggered by a state change. // // @code contains a well defined string describing the action. // @text should contain a user visible string detailing the current action. func NewMessageProgress(src Object, typ ProgressType, code string, text string) *Message { var carg1 *C.GstObject // in, none, converted, nullable var carg2 C.GstProgressType // in, none, casted var carg3 *C.gchar // in, none, string var carg4 *C.gchar // in, none, string var cret *C.GstMessage // return, full, converted if src != nil { carg1 = (*C.GstObject)(UnsafeObjectToGlibNone(src)) } carg2 = C.GstProgressType(typ) carg3 = (*C.gchar)(unsafe.Pointer(C.CString(code))) defer C.free(unsafe.Pointer(carg3)) carg4 = (*C.gchar)(unsafe.Pointer(C.CString(text))) defer C.free(unsafe.Pointer(carg4)) cret = C.gst_message_new_progress(carg1, carg2, carg3, carg4) runtime.KeepAlive(src) runtime.KeepAlive(typ) runtime.KeepAlive(code) runtime.KeepAlive(text) var goret *Message goret = UnsafeMessageFromGlibFull(unsafe.Pointer(cret)) return goret } // NewMessageQos wraps gst_message_new_qos // // The function takes the following parameters: // // - src Object (nullable): The object originating the message. // - live bool: if the message was generated by a live element // - runningTime uint64: the running time of the buffer that generated the message // - streamTime uint64: the stream time of the buffer that generated the message // - timestamp uint64: the timestamps of the buffer that generated the message // - duration uint64: the duration of the buffer that generated the message // // The function returns the following values: // // - goret *Message // // A QOS message is posted on the bus whenever an element decides to drop a // buffer because of QoS reasons or whenever it changes its processing strategy // because of QoS reasons (quality adjustments such as processing at lower // accuracy). // // This message can be posted by an element that performs synchronisation against the // clock (live) or it could be dropped by an element that performs QoS because of QOS // events received from a downstream element (!live). // // @running_time, @stream_time, @timestamp, @duration should be set to the // respective running-time, stream-time, timestamp and duration of the (dropped) // buffer that generated the QoS event. Values can be left to // GST_CLOCK_TIME_NONE when unknown. func NewMessageQos(src Object, live bool, runningTime uint64, streamTime uint64, timestamp uint64, duration uint64) *Message { var carg1 *C.GstObject // in, none, converted, nullable var carg2 C.gboolean // in var carg3 C.guint64 // in, none, casted var carg4 C.guint64 // in, none, casted var carg5 C.guint64 // in, none, casted var carg6 C.guint64 // in, none, casted var cret *C.GstMessage // return, full, converted if src != nil { carg1 = (*C.GstObject)(UnsafeObjectToGlibNone(src)) } if live { carg2 = C.TRUE } carg3 = C.guint64(runningTime) carg4 = C.guint64(streamTime) carg5 = C.guint64(timestamp) carg6 = C.guint64(duration) cret = C.gst_message_new_qos(carg1, carg2, carg3, carg4, carg5, carg6) runtime.KeepAlive(src) runtime.KeepAlive(live) runtime.KeepAlive(runningTime) runtime.KeepAlive(streamTime) runtime.KeepAlive(timestamp) runtime.KeepAlive(duration) var goret *Message goret = UnsafeMessageFromGlibFull(unsafe.Pointer(cret)) return goret } // NewMessageRedirect wraps gst_message_new_redirect // // The function takes the following parameters: // // - src Object (nullable): The #GstObject whose property changed (may or may not be a #GstElement) // - location string: location string for the new entry // - tagList *TagList (nullable): tag list for the new entry // - entryStruct *Structure (nullable): structure for the new entry // // The function returns the following values: // // - goret *Message // // Creates a new redirect message and adds a new entry to it. Redirect messages // are posted when an element detects that the actual data has to be retrieved // from a different location. This is useful if such a redirection cannot be // handled inside a source element, for example when HTTP 302/303 redirects // return a non-HTTP URL. // // The redirect message can hold multiple entries. The first one is added // when the redirect message is created, with the given location, tag_list, // entry_struct arguments. Use gst_message_add_redirect_entry() to add more // entries. // // Each entry has a location, a tag list, and a structure. All of these are // optional. The tag list and structure are useful for additional metadata, // such as bitrate statistics for the given location. // // By default, message recipients should treat entries in the order they are // stored. The recipient should therefore try entry \#0 first, and if this // entry is not acceptable or working, try entry \#1 etc. Senders must make // sure that they add entries in this order. However, recipients are free to // ignore the order and pick an entry that is "best" for them. One example // would be a recipient that scans the entries for the one with the highest // bitrate tag. // // The specified location string is copied. However, ownership over the tag // list and structure are transferred to the message. func NewMessageRedirect(src Object, location string, tagList *TagList, entryStruct *Structure) *Message { var carg1 *C.GstObject // in, none, converted, nullable var carg2 *C.gchar // in, none, string var carg3 *C.GstTagList // in, full, converted, nullable var carg4 *C.GstStructure // in, full, converted, nullable var cret *C.GstMessage // return, full, converted if src != nil { carg1 = (*C.GstObject)(UnsafeObjectToGlibNone(src)) } carg2 = (*C.gchar)(unsafe.Pointer(C.CString(location))) defer C.free(unsafe.Pointer(carg2)) if tagList != nil { carg3 = (*C.GstTagList)(UnsafeTagListToGlibFull(tagList)) } if entryStruct != nil { carg4 = (*C.GstStructure)(UnsafeStructureToGlibFull(entryStruct)) } cret = C.gst_message_new_redirect(carg1, carg2, carg3, carg4) runtime.KeepAlive(src) runtime.KeepAlive(location) runtime.KeepAlive(tagList) runtime.KeepAlive(entryStruct) var goret *Message goret = UnsafeMessageFromGlibFull(unsafe.Pointer(cret)) return goret } // NewMessageRequestState wraps gst_message_new_request_state // // The function takes the following parameters: // // - src Object (nullable): The object originating the message. // - state State: The new requested state // // The function returns the following values: // // - goret *Message // // This message can be posted by elements when they want to have their state // changed. A typical use case would be an audio server that wants to pause the // pipeline because a higher priority stream is being played. func NewMessageRequestState(src Object, state State) *Message { var carg1 *C.GstObject // in, none, converted, nullable var carg2 C.GstState // in, none, casted var cret *C.GstMessage // return, full, converted if src != nil { carg1 = (*C.GstObject)(UnsafeObjectToGlibNone(src)) } carg2 = C.GstState(state) cret = C.gst_message_new_request_state(carg1, carg2) runtime.KeepAlive(src) runtime.KeepAlive(state) var goret *Message goret = UnsafeMessageFromGlibFull(unsafe.Pointer(cret)) return goret } // NewMessageResetTime wraps gst_message_new_reset_time // // The function takes the following parameters: // // - src Object (nullable): The object originating the message. // - runningTime ClockTime: the requested running-time // // The function returns the following values: // // - goret *Message // // This message is posted when the pipeline running-time should be reset to // @running_time, like after a flushing seek. func NewMessageResetTime(src Object, runningTime ClockTime) *Message { var carg1 *C.GstObject // in, none, converted, nullable var carg2 C.GstClockTime // in, none, casted, alias var cret *C.GstMessage // return, full, converted if src != nil { carg1 = (*C.GstObject)(UnsafeObjectToGlibNone(src)) } carg2 = C.GstClockTime(runningTime) cret = C.gst_message_new_reset_time(carg1, carg2) runtime.KeepAlive(src) runtime.KeepAlive(runningTime) var goret *Message goret = UnsafeMessageFromGlibFull(unsafe.Pointer(cret)) return goret } // NewMessageSegmentDone wraps gst_message_new_segment_done // // The function takes the following parameters: // // - src Object (nullable): The object originating the message. // - format Format: The format of the position being done // - position int64: The position of the segment being done // // The function returns the following values: // // - goret *Message // // Create a new segment done message. This message is posted by elements that // finish playback of a segment as a result of a segment seek. This message // is received by the application after all elements that posted a segment_start // have posted the segment_done. func NewMessageSegmentDone(src Object, format Format, position int64) *Message { var carg1 *C.GstObject // in, none, converted, nullable var carg2 C.GstFormat // in, none, casted var carg3 C.gint64 // in, none, casted var cret *C.GstMessage // return, full, converted if src != nil { carg1 = (*C.GstObject)(UnsafeObjectToGlibNone(src)) } carg2 = C.GstFormat(format) carg3 = C.gint64(position) cret = C.gst_message_new_segment_done(carg1, carg2, carg3) runtime.KeepAlive(src) runtime.KeepAlive(format) runtime.KeepAlive(position) var goret *Message goret = UnsafeMessageFromGlibFull(unsafe.Pointer(cret)) return goret } // NewMessageSegmentStart wraps gst_message_new_segment_start // // The function takes the following parameters: // // - src Object (nullable): The object originating the message. // - format Format: The format of the position being played // - position int64: The position of the segment being played // // The function returns the following values: // // - goret *Message // // Create a new segment message. This message is posted by elements that // start playback of a segment as a result of a segment seek. This message // is not received by the application but is used for maintenance reasons in // container elements. func NewMessageSegmentStart(src Object, format Format, position int64) *Message { var carg1 *C.GstObject // in, none, converted, nullable var carg2 C.GstFormat // in, none, casted var carg3 C.gint64 // in, none, casted var cret *C.GstMessage // return, full, converted if src != nil { carg1 = (*C.GstObject)(UnsafeObjectToGlibNone(src)) } carg2 = C.GstFormat(format) carg3 = C.gint64(position) cret = C.gst_message_new_segment_start(carg1, carg2, carg3) runtime.KeepAlive(src) runtime.KeepAlive(format) runtime.KeepAlive(position) var goret *Message goret = UnsafeMessageFromGlibFull(unsafe.Pointer(cret)) return goret } // NewMessageStateChanged wraps gst_message_new_state_changed // // The function takes the following parameters: // // - src Object (nullable): The object originating the message. // - oldstate State: the previous state // - newstate State: the new (current) state // - pending State: the pending (target) state // // The function returns the following values: // // - goret *Message // // Create a state change message. This message is posted whenever an element // changed its state. func NewMessageStateChanged(src Object, oldstate State, newstate State, pending State) *Message { var carg1 *C.GstObject // in, none, converted, nullable var carg2 C.GstState // in, none, casted var carg3 C.GstState // in, none, casted var carg4 C.GstState // in, none, casted var cret *C.GstMessage // return, full, converted if src != nil { carg1 = (*C.GstObject)(UnsafeObjectToGlibNone(src)) } carg2 = C.GstState(oldstate) carg3 = C.GstState(newstate) carg4 = C.GstState(pending) cret = C.gst_message_new_state_changed(carg1, carg2, carg3, carg4) runtime.KeepAlive(src) runtime.KeepAlive(oldstate) runtime.KeepAlive(newstate) runtime.KeepAlive(pending) var goret *Message goret = UnsafeMessageFromGlibFull(unsafe.Pointer(cret)) return goret } // NewMessageStateDirty wraps gst_message_new_state_dirty // // The function takes the following parameters: // // - src Object (nullable): The object originating the message // // The function returns the following values: // // - goret *Message // // Create a state dirty message. This message is posted whenever an element // changed its state asynchronously and is used internally to update the // states of container objects. func NewMessageStateDirty(src Object) *Message { var carg1 *C.GstObject // in, none, converted, nullable var cret *C.GstMessage // return, full, converted if src != nil { carg1 = (*C.GstObject)(UnsafeObjectToGlibNone(src)) } cret = C.gst_message_new_state_dirty(carg1) runtime.KeepAlive(src) var goret *Message goret = UnsafeMessageFromGlibFull(unsafe.Pointer(cret)) return goret } // NewMessageStepDone wraps gst_message_new_step_done // // The function takes the following parameters: // // - src Object (nullable): The object originating the message. // - format Format: the format of @amount // - amount uint64: the amount of stepped data // - rate float64: the rate of the stepped amount // - flush bool: is this an flushing step // - intermediate bool: is this an intermediate step // - duration uint64: the duration of the data // - eos bool: the step caused EOS // // The function returns the following values: // // - goret *Message // // This message is posted by elements when they complete a part, when @intermediate set // to %TRUE, or a complete step operation. // // @duration will contain the amount of time (in GST_FORMAT_TIME) of the stepped // @amount of media in format @format. func NewMessageStepDone(src Object, format Format, amount uint64, rate float64, flush bool, intermediate bool, duration uint64, eos bool) *Message { var carg1 *C.GstObject // in, none, converted, nullable var carg2 C.GstFormat // in, none, casted var carg3 C.guint64 // in, none, casted var carg4 C.gdouble // in, none, casted var carg5 C.gboolean // in var carg6 C.gboolean // in var carg7 C.guint64 // in, none, casted var carg8 C.gboolean // in var cret *C.GstMessage // return, full, converted if src != nil { carg1 = (*C.GstObject)(UnsafeObjectToGlibNone(src)) } carg2 = C.GstFormat(format) carg3 = C.guint64(amount) carg4 = C.gdouble(rate) if flush { carg5 = C.TRUE } if intermediate { carg6 = C.TRUE } carg7 = C.guint64(duration) if eos { carg8 = C.TRUE } cret = C.gst_message_new_step_done(carg1, carg2, carg3, carg4, carg5, carg6, carg7, carg8) runtime.KeepAlive(src) runtime.KeepAlive(format) runtime.KeepAlive(amount) runtime.KeepAlive(rate) runtime.KeepAlive(flush) runtime.KeepAlive(intermediate) runtime.KeepAlive(duration) runtime.KeepAlive(eos) var goret *Message goret = UnsafeMessageFromGlibFull(unsafe.Pointer(cret)) return goret } // NewMessageStepStart wraps gst_message_new_step_start // // The function takes the following parameters: // // - src Object (nullable): The object originating the message. // - active bool: if the step is active or queued // - format Format: the format of @amount // - amount uint64: the amount of stepped data // - rate float64: the rate of the stepped amount // - flush bool: is this an flushing step // - intermediate bool: is this an intermediate step // // The function returns the following values: // // - goret *Message // // This message is posted by elements when they accept or activate a new step // event for @amount in @format. // // @active is set to %FALSE when the element accepted the new step event and has // queued it for execution in the streaming threads. // // @active is set to %TRUE when the element has activated the step operation and // is now ready to start executing the step in the streaming thread. After this // message is emitted, the application can queue a new step operation in the // element. func NewMessageStepStart(src Object, active bool, format Format, amount uint64, rate float64, flush bool, intermediate bool) *Message { var carg1 *C.GstObject // in, none, converted, nullable var carg2 C.gboolean // in var carg3 C.GstFormat // in, none, casted var carg4 C.guint64 // in, none, casted var carg5 C.gdouble // in, none, casted var carg6 C.gboolean // in var carg7 C.gboolean // in var cret *C.GstMessage // return, full, converted if src != nil { carg1 = (*C.GstObject)(UnsafeObjectToGlibNone(src)) } if active { carg2 = C.TRUE } carg3 = C.GstFormat(format) carg4 = C.guint64(amount) carg5 = C.gdouble(rate) if flush { carg6 = C.TRUE } if intermediate { carg7 = C.TRUE } cret = C.gst_message_new_step_start(carg1, carg2, carg3, carg4, carg5, carg6, carg7) runtime.KeepAlive(src) runtime.KeepAlive(active) runtime.KeepAlive(format) runtime.KeepAlive(amount) runtime.KeepAlive(rate) runtime.KeepAlive(flush) runtime.KeepAlive(intermediate) var goret *Message goret = UnsafeMessageFromGlibFull(unsafe.Pointer(cret)) return goret } // NewMessageStreamCollection wraps gst_message_new_stream_collection // // The function takes the following parameters: // // - src Object (nullable): The #GstObject that created the message // - collection StreamCollection: The #GstStreamCollection // // The function returns the following values: // // - goret *Message // // Creates a new stream-collection message. The message is used to announce new // #GstStreamCollection func NewMessageStreamCollection(src Object, collection StreamCollection) *Message { var carg1 *C.GstObject // in, none, converted, nullable var carg2 *C.GstStreamCollection // in, none, converted var cret *C.GstMessage // return, full, converted if src != nil { carg1 = (*C.GstObject)(UnsafeObjectToGlibNone(src)) } carg2 = (*C.GstStreamCollection)(UnsafeStreamCollectionToGlibNone(collection)) cret = C.gst_message_new_stream_collection(carg1, carg2) runtime.KeepAlive(src) runtime.KeepAlive(collection) var goret *Message goret = UnsafeMessageFromGlibFull(unsafe.Pointer(cret)) return goret } // NewMessageStreamStart wraps gst_message_new_stream_start // // The function takes the following parameters: // // - src Object (nullable): The object originating the message. // // The function returns the following values: // // - goret *Message // // Create a new stream_start message. This message is generated and posted in // the sink elements of a GstBin. The bin will only forward the STREAM_START // message to the application if all sinks have posted an STREAM_START message. func NewMessageStreamStart(src Object) *Message { var carg1 *C.GstObject // in, none, converted, nullable var cret *C.GstMessage // return, full, converted if src != nil { carg1 = (*C.GstObject)(UnsafeObjectToGlibNone(src)) } cret = C.gst_message_new_stream_start(carg1) runtime.KeepAlive(src) var goret *Message goret = UnsafeMessageFromGlibFull(unsafe.Pointer(cret)) return goret } // NewMessageStreamStatus wraps gst_message_new_stream_status // // The function takes the following parameters: // // - src Object (nullable): The object originating the message. // - typ StreamStatusType: The stream status type. // - owner Element: the owner element of @src. // // The function returns the following values: // // - goret *Message // // Create a new stream status message. This message is posted when a streaming // thread is created/destroyed or when the state changed. func NewMessageStreamStatus(src Object, typ StreamStatusType, owner Element) *Message { var carg1 *C.GstObject // in, none, converted, nullable var carg2 C.GstStreamStatusType // in, none, casted var carg3 *C.GstElement // in, none, converted var cret *C.GstMessage // return, full, converted if src != nil { carg1 = (*C.GstObject)(UnsafeObjectToGlibNone(src)) } carg2 = C.GstStreamStatusType(typ) carg3 = (*C.GstElement)(UnsafeElementToGlibNone(owner)) cret = C.gst_message_new_stream_status(carg1, carg2, carg3) runtime.KeepAlive(src) runtime.KeepAlive(typ) runtime.KeepAlive(owner) var goret *Message goret = UnsafeMessageFromGlibFull(unsafe.Pointer(cret)) return goret } // NewMessageStreamsSelected wraps gst_message_new_streams_selected // // The function takes the following parameters: // // - src Object (nullable): The #GstObject that created the message // - collection StreamCollection: The #GstStreamCollection // // The function returns the following values: // // - goret *Message // // Creates a new steams-selected message. The message is used to announce // that an array of streams has been selected. This is generally in response // to a #GST_EVENT_SELECT_STREAMS event, or when an element (such as decodebin3) // makes an initial selection of streams. // // The message also contains the #GstStreamCollection to which the various streams // belong to. // // Users of gst_message_new_streams_selected() can add the selected streams with // gst_message_streams_selected_add(). func NewMessageStreamsSelected(src Object, collection StreamCollection) *Message { var carg1 *C.GstObject // in, none, converted, nullable var carg2 *C.GstStreamCollection // in, none, converted var cret *C.GstMessage // return, full, converted if src != nil { carg1 = (*C.GstObject)(UnsafeObjectToGlibNone(src)) } carg2 = (*C.GstStreamCollection)(UnsafeStreamCollectionToGlibNone(collection)) cret = C.gst_message_new_streams_selected(carg1, carg2) runtime.KeepAlive(src) runtime.KeepAlive(collection) var goret *Message goret = UnsafeMessageFromGlibFull(unsafe.Pointer(cret)) return goret } // NewMessageStructureChange wraps gst_message_new_structure_change // // The function takes the following parameters: // // - src Object (nullable): The object originating the message. // - typ StructureChangeType: The change type. // - owner Element: The owner element of @src. // - busy bool: Whether the structure change is busy. // // The function returns the following values: // // - goret *Message // // Create a new structure change message. This message is posted when the // structure of a pipeline is in the process of being changed, for example // when pads are linked or unlinked. // // @src should be the sinkpad that unlinked or linked. func NewMessageStructureChange(src Object, typ StructureChangeType, owner Element, busy bool) *Message { var carg1 *C.GstObject // in, none, converted, nullable var carg2 C.GstStructureChangeType // in, none, casted var carg3 *C.GstElement // in, none, converted var carg4 C.gboolean // in var cret *C.GstMessage // return, full, converted if src != nil { carg1 = (*C.GstObject)(UnsafeObjectToGlibNone(src)) } carg2 = C.GstStructureChangeType(typ) carg3 = (*C.GstElement)(UnsafeElementToGlibNone(owner)) if busy { carg4 = C.TRUE } cret = C.gst_message_new_structure_change(carg1, carg2, carg3, carg4) runtime.KeepAlive(src) runtime.KeepAlive(typ) runtime.KeepAlive(owner) runtime.KeepAlive(busy) var goret *Message goret = UnsafeMessageFromGlibFull(unsafe.Pointer(cret)) return goret } // NewMessageTag wraps gst_message_new_tag // // The function takes the following parameters: // // - src Object (nullable): The object originating the message. // - tagList *TagList: the tag list for the message. // // The function returns the following values: // // - goret *Message // // Create a new tag message. The message will take ownership of the tag list. // The message is posted by elements that discovered a new taglist. func NewMessageTag(src Object, tagList *TagList) *Message { var carg1 *C.GstObject // in, none, converted, nullable var carg2 *C.GstTagList // in, full, converted var cret *C.GstMessage // return, full, converted if src != nil { carg1 = (*C.GstObject)(UnsafeObjectToGlibNone(src)) } carg2 = (*C.GstTagList)(UnsafeTagListToGlibFull(tagList)) cret = C.gst_message_new_tag(carg1, carg2) runtime.KeepAlive(src) runtime.KeepAlive(tagList) var goret *Message goret = UnsafeMessageFromGlibFull(unsafe.Pointer(cret)) return goret } // NewMessageToc wraps gst_message_new_toc // // The function takes the following parameters: // // - src Object (nullable): the object originating the message. // - toc *Toc: #GstToc structure for the message. // - updated bool: whether TOC was updated or not. // // The function returns the following values: // // - goret *Message // // Create a new TOC message. The message is posted by elements // that discovered or updated a TOC. func NewMessageToc(src Object, toc *Toc, updated bool) *Message { var carg1 *C.GstObject // in, none, converted, nullable var carg2 *C.GstToc // in, none, converted var carg3 C.gboolean // in var cret *C.GstMessage // return, full, converted if src != nil { carg1 = (*C.GstObject)(UnsafeObjectToGlibNone(src)) } carg2 = (*C.GstToc)(UnsafeTocToGlibNone(toc)) if updated { carg3 = C.TRUE } cret = C.gst_message_new_toc(carg1, carg2, carg3) runtime.KeepAlive(src) runtime.KeepAlive(toc) runtime.KeepAlive(updated) var goret *Message goret = UnsafeMessageFromGlibFull(unsafe.Pointer(cret)) return goret } // NewMessageWarning wraps gst_message_new_warning // // The function takes the following parameters: // // - src Object (nullable): The object originating the message. // - debug string: A debugging string. // - err error: The GError for this message. // // The function returns the following values: // // - goret *Message // // Create a new warning message. The message will make copies of @error and // @debug. func NewMessageWarning(src Object, debug string, err error) *Message { var carg1 *C.GstObject // in, none, converted, nullable var carg3 *C.gchar // in, none, string var carg2 *C.GError // in, none, converted var cret *C.GstMessage // return, full, converted if src != nil { carg1 = (*C.GstObject)(UnsafeObjectToGlibNone(src)) } carg3 = (*C.gchar)(unsafe.Pointer(C.CString(debug))) defer C.free(unsafe.Pointer(carg3)) carg2 = (*C.GError)(glib.UnsafeErrorToGlibNone(err)) cret = C.gst_message_new_warning(carg1, carg2, carg3) runtime.KeepAlive(src) runtime.KeepAlive(debug) runtime.KeepAlive(err) var goret *Message goret = UnsafeMessageFromGlibFull(unsafe.Pointer(cret)) return goret } // NewMessageWarningWithDetails wraps gst_message_new_warning_with_details // // The function takes the following parameters: // // - src Object (nullable): The object originating the message. // - debug string: A debugging string. // - details *Structure (nullable): A GstStructure with details // - err error: The GError for this message. // // The function returns the following values: // // - goret *Message // // Create a new warning message. The message will make copies of @error and // @debug. func NewMessageWarningWithDetails(src Object, debug string, details *Structure, err error) *Message { var carg1 *C.GstObject // in, none, converted, nullable var carg3 *C.gchar // in, none, string var carg4 *C.GstStructure // in, full, converted, nullable var carg2 *C.GError // in, none, converted var cret *C.GstMessage // return, full, converted if src != nil { carg1 = (*C.GstObject)(UnsafeObjectToGlibNone(src)) } carg3 = (*C.gchar)(unsafe.Pointer(C.CString(debug))) defer C.free(unsafe.Pointer(carg3)) if details != nil { carg4 = (*C.GstStructure)(UnsafeStructureToGlibFull(details)) } carg2 = (*C.GError)(glib.UnsafeErrorToGlibNone(err)) cret = C.gst_message_new_warning_with_details(carg1, carg2, carg3, carg4) runtime.KeepAlive(src) runtime.KeepAlive(debug) runtime.KeepAlive(details) runtime.KeepAlive(err) var goret *Message goret = UnsafeMessageFromGlibFull(unsafe.Pointer(cret)) return goret } // AddRedirectEntry wraps gst_message_add_redirect_entry // // The function takes the following parameters: // // - location string: location string for the new entry // - tagList *TagList (nullable): tag list for the new entry // - entryStruct *Structure (nullable): structure for the new entry // // Creates and appends a new entry. // // The specified location string is copied. However, ownership over the tag // list and structure are transferred to the message. func (message *Message) AddRedirectEntry(location string, tagList *TagList, entryStruct *Structure) { var carg0 *C.GstMessage // in, none, converted var carg1 *C.gchar // in, none, string var carg2 *C.GstTagList // in, full, converted, nullable var carg3 *C.GstStructure // in, full, converted, nullable carg0 = (*C.GstMessage)(UnsafeMessageToGlibNone(message)) carg1 = (*C.gchar)(unsafe.Pointer(C.CString(location))) defer C.free(unsafe.Pointer(carg1)) if tagList != nil { carg2 = (*C.GstTagList)(UnsafeTagListToGlibFull(tagList)) } if entryStruct != nil { carg3 = (*C.GstStructure)(UnsafeStructureToGlibFull(entryStruct)) } C.gst_message_add_redirect_entry(carg0, carg1, carg2, carg3) runtime.KeepAlive(message) runtime.KeepAlive(location) runtime.KeepAlive(tagList) runtime.KeepAlive(entryStruct) } // Copy wraps gst_message_copy // // The function returns the following values: // // - goret *Message // // Creates a copy of the message. Returns a copy of the message. func (msg *Message) Copy() *Message { var carg0 *C.GstMessage // in, none, converted var cret *C.GstMessage // return, full, converted carg0 = (*C.GstMessage)(UnsafeMessageToGlibNone(msg)) cret = C.gst_message_copy(carg0) runtime.KeepAlive(msg) var goret *Message goret = UnsafeMessageFromGlibFull(unsafe.Pointer(cret)) return goret } // GetNumRedirectEntries wraps gst_message_get_num_redirect_entries // // The function returns the following values: // // - goret uint func (message *Message) GetNumRedirectEntries() uint { var carg0 *C.GstMessage // in, none, converted var cret C.gsize // return, none, casted carg0 = (*C.GstMessage)(UnsafeMessageToGlibNone(message)) cret = C.gst_message_get_num_redirect_entries(carg0) runtime.KeepAlive(message) var goret uint goret = uint(cret) return goret } // GetSeqnum wraps gst_message_get_seqnum // // The function returns the following values: // // - goret uint32 // // Retrieve the sequence number of a message. // // Messages have ever-incrementing sequence numbers, which may also be set // explicitly via gst_message_set_seqnum(). Sequence numbers are typically used // to indicate that a message corresponds to some other set of messages or // events, for example a SEGMENT_DONE message corresponding to a SEEK event. It // is considered good practice to make this correspondence when possible, though // it is not required. // // Note that events and messages share the same sequence number incrementor; // two events or messages will never have the same sequence number unless // that correspondence was made explicitly. func (message *Message) GetSeqnum() uint32 { var carg0 *C.GstMessage // in, none, converted var cret C.guint32 // return, none, casted carg0 = (*C.GstMessage)(UnsafeMessageToGlibNone(message)) cret = C.gst_message_get_seqnum(carg0) runtime.KeepAlive(message) var goret uint32 goret = uint32(cret) return goret } // GetStructure wraps gst_message_get_structure // // The function returns the following values: // // - goret *Structure (nullable) // // Access the structure of the message. func (message *Message) GetStructure() *Structure { var carg0 *C.GstMessage // in, none, converted var cret *C.GstStructure // return, borrow, converted, nullable carg0 = (*C.GstMessage)(UnsafeMessageToGlibNone(message)) cret = C.gst_message_get_structure(carg0) runtime.KeepAlive(message) var goret *Structure if cret != nil { goret = UnsafeStructureFromGlibBorrow(unsafe.Pointer(cret)) runtime.AddCleanup(goret, func(_ *Message) {}, message) } return goret } // HasName wraps gst_message_has_name // // The function takes the following parameters: // // - name string: name to check // // The function returns the following values: // // - goret bool // // Checks if @message has the given @name. This function is usually used to // check the name of a custom message. func (message *Message) HasName(name string) bool { var carg0 *C.GstMessage // in, none, converted var carg1 *C.gchar // in, none, string var cret C.gboolean // return carg0 = (*C.GstMessage)(UnsafeMessageToGlibNone(message)) carg1 = (*C.gchar)(unsafe.Pointer(C.CString(name))) defer C.free(unsafe.Pointer(carg1)) cret = C.gst_message_has_name(carg0, carg1) runtime.KeepAlive(message) runtime.KeepAlive(name) var goret bool if cret != 0 { goret = true } return goret } // ParseAsyncDone wraps gst_message_parse_async_done // // The function returns the following values: // // - runningTime ClockTime: Result location for the running_time or %NULL // // Extract the running_time from the async_done message. // // MT safe. func (message *Message) ParseAsyncDone() ClockTime { var carg0 *C.GstMessage // in, none, converted var carg1 C.GstClockTime // out, full, casted, alias carg0 = (*C.GstMessage)(UnsafeMessageToGlibNone(message)) C.gst_message_parse_async_done(carg0, &carg1) runtime.KeepAlive(message) var runningTime ClockTime runningTime = ClockTime(carg1) return runningTime } // ParseBuffering wraps gst_message_parse_buffering // // The function returns the following values: // // - percent int: Return location for the percent. // // Extracts the buffering percent from the GstMessage. see also // gst_message_new_buffering(). // // MT safe. func (message *Message) ParseBuffering() int { var carg0 *C.GstMessage // in, none, converted var carg1 C.gint // out, full, casted carg0 = (*C.GstMessage)(UnsafeMessageToGlibNone(message)) C.gst_message_parse_buffering(carg0, &carg1) runtime.KeepAlive(message) var percent int percent = int(carg1) return percent } // ParseBufferingStats wraps gst_message_parse_buffering_stats // // The function returns the following values: // // - mode BufferingMode: a buffering mode, or %NULL // - avgIn int: the average input rate, or %NULL // - avgOut int: the average output rate, or %NULL // - bufferingLeft int64: amount of buffering time left in // milliseconds, or %NULL // // Extracts the buffering stats values from @message. func (message *Message) ParseBufferingStats() (BufferingMode, int, int, int64) { var carg0 *C.GstMessage // in, none, converted var carg1 C.GstBufferingMode // out, full, casted var carg2 C.gint // out, full, casted var carg3 C.gint // out, full, casted var carg4 C.gint64 // out, full, casted carg0 = (*C.GstMessage)(UnsafeMessageToGlibNone(message)) C.gst_message_parse_buffering_stats(carg0, &carg1, &carg2, &carg3, &carg4) runtime.KeepAlive(message) var mode BufferingMode var avgIn int var avgOut int var bufferingLeft int64 mode = BufferingMode(carg1) avgIn = int(carg2) avgOut = int(carg3) bufferingLeft = int64(carg4) return mode, avgIn, avgOut, bufferingLeft } // ParseClockLost wraps gst_message_parse_clock_lost // // The function returns the following values: // // - clock Clock: a pointer to hold the lost clock // // Extracts the lost clock from the GstMessage. // The clock object returned remains valid until the message is freed. // // MT safe. func (message *Message) ParseClockLost() Clock { var carg0 *C.GstMessage // in, none, converted var carg1 *C.GstClock // out, none, converted carg0 = (*C.GstMessage)(UnsafeMessageToGlibNone(message)) C.gst_message_parse_clock_lost(carg0, &carg1) runtime.KeepAlive(message) var clock Clock clock = UnsafeClockFromGlibNone(unsafe.Pointer(carg1)) return clock } // ParseClockProvide wraps gst_message_parse_clock_provide // // The function returns the following values: // // - clock Clock: a pointer to hold a clock // object, or %NULL // - ready bool: a pointer to hold the ready flag, or %NULL // // Extracts the clock and ready flag from the GstMessage. // The clock object returned remains valid until the message is freed. // // MT safe. func (message *Message) ParseClockProvide() (Clock, bool) { var carg0 *C.GstMessage // in, none, converted var carg1 *C.GstClock // out, none, converted var carg2 C.gboolean // out carg0 = (*C.GstMessage)(UnsafeMessageToGlibNone(message)) C.gst_message_parse_clock_provide(carg0, &carg1, &carg2) runtime.KeepAlive(message) var clock Clock var ready bool clock = UnsafeClockFromGlibNone(unsafe.Pointer(carg1)) if carg2 != 0 { ready = true } return clock, ready } // ParseContextType wraps gst_message_parse_context_type // // The function returns the following values: // // - contextType string: the context type, or %NULL // - goret bool // // Parse a context type from an existing GST_MESSAGE_NEED_CONTEXT message. func (message *Message) ParseContextType() (string, bool) { var carg0 *C.GstMessage // in, none, converted var carg1 *C.gchar // out, none, string var cret C.gboolean // return carg0 = (*C.GstMessage)(UnsafeMessageToGlibNone(message)) cret = C.gst_message_parse_context_type(carg0, &carg1) runtime.KeepAlive(message) var contextType string var goret bool contextType = C.GoString((*C.char)(unsafe.Pointer(carg1))) if cret != 0 { goret = true } return contextType, goret } // ParseDeviceAdded wraps gst_message_parse_device_added // // The function returns the following values: // // - device Device: A location where to store a // pointer to the new #GstDevice, or %NULL // // Parses a device-added message. The device-added message is produced by // #GstDeviceProvider or a #GstDeviceMonitor. It announces the appearance // of monitored devices. func (message *Message) ParseDeviceAdded() Device { var carg0 *C.GstMessage // in, none, converted var carg1 *C.GstDevice // out, full, converted carg0 = (*C.GstMessage)(UnsafeMessageToGlibNone(message)) C.gst_message_parse_device_added(carg0, &carg1) runtime.KeepAlive(message) var device Device device = UnsafeDeviceFromGlibFull(unsafe.Pointer(carg1)) return device } // ParseDeviceChanged wraps gst_message_parse_device_changed // // The function returns the following values: // // - device Device: A location where to store a // pointer to the updated version of the #GstDevice, or %NULL // - changedDevice Device: A location where to store a // pointer to the old version of the #GstDevice, or %NULL // // Parses a device-changed message. The device-changed message is produced by // #GstDeviceProvider or a #GstDeviceMonitor. It announces the // disappearance of monitored devices. * It announce that a device properties has // changed and @device represents the new modified version of @changed_device. func (message *Message) ParseDeviceChanged() (Device, Device) { var carg0 *C.GstMessage // in, none, converted var carg1 *C.GstDevice // out, full, converted var carg2 *C.GstDevice // out, full, converted carg0 = (*C.GstMessage)(UnsafeMessageToGlibNone(message)) C.gst_message_parse_device_changed(carg0, &carg1, &carg2) runtime.KeepAlive(message) var device Device var changedDevice Device device = UnsafeDeviceFromGlibFull(unsafe.Pointer(carg1)) changedDevice = UnsafeDeviceFromGlibFull(unsafe.Pointer(carg2)) return device, changedDevice } // ParseDeviceRemoved wraps gst_message_parse_device_removed // // The function returns the following values: // // - device Device: A location where to store a // pointer to the removed #GstDevice, or %NULL // // Parses a device-removed message. The device-removed message is produced by // #GstDeviceProvider or a #GstDeviceMonitor. It announces the // disappearance of monitored devices. func (message *Message) ParseDeviceRemoved() Device { var carg0 *C.GstMessage // in, none, converted var carg1 *C.GstDevice // out, full, converted carg0 = (*C.GstMessage)(UnsafeMessageToGlibNone(message)) C.gst_message_parse_device_removed(carg0, &carg1) runtime.KeepAlive(message) var device Device device = UnsafeDeviceFromGlibFull(unsafe.Pointer(carg1)) return device } // ParseError wraps gst_message_parse_error // // The function returns the following values: // // - debug string (nullable): location for the debug message, // or %NULL // - gerror error: location for the GError // // Extracts the GError and debug string from the GstMessage. The values returned // in the output arguments are copies; the caller must free them when done. // // Typical usage of this function might be: // |[<!-- language="C" --> // ... // switch (GST_MESSAGE_TYPE (msg)) { // case GST_MESSAGE_ERROR: { // GError *err = NULL; // gchar *dbg_info = NULL; // // gst_message_parse_error (msg, &err, &dbg_info); // g_printerr ("ERROR from element %s: %s\n", // GST_OBJECT_NAME (msg->src), err->message); // g_printerr ("Debugging info: %s\n", (dbg_info) ? dbg_info : "none"); // g_error_free (err); // g_free (dbg_info); // break; // } // ... // } // ... // ]| // // MT safe. func (message *Message) ParseError() (string, error) { var carg0 *C.GstMessage // in, none, converted var carg2 *C.gchar // out, full, string, nullable-string var carg1 *C.GError // out, full, converted carg0 = (*C.GstMessage)(UnsafeMessageToGlibNone(message)) C.gst_message_parse_error(carg0, &carg1, &carg2) runtime.KeepAlive(message) var debug string var gerror error if carg2 != nil { debug = C.GoString((*C.char)(unsafe.Pointer(carg2))) defer C.free(unsafe.Pointer(carg2)) } gerror = glib.UnsafeErrorFromGlibFull(unsafe.Pointer(carg1)) return debug, gerror } // ParseErrorDetails wraps gst_message_parse_error_details // // The function returns the following values: // // - structure *Structure (nullable): A pointer to the returned details // // Returns the optional details structure, may be NULL if none. // The returned structure must not be freed. func (message *Message) ParseErrorDetails() *Structure { var carg0 *C.GstMessage // in, none, converted var carg1 *C.GstStructure // out, none, converted, nullable carg0 = (*C.GstMessage)(UnsafeMessageToGlibNone(message)) C.gst_message_parse_error_details(carg0, &carg1) runtime.KeepAlive(message) var structure *Structure if carg1 != nil { structure = UnsafeStructureFromGlibNone(unsafe.Pointer(carg1)) } return structure } // ParseGroupID wraps gst_message_parse_group_id // // The function returns the following values: // // - groupId uint: Result location for the group id or // %NULL // - goret bool // // Extract the group from the STREAM_START message. func (message *Message) ParseGroupID() (uint, bool) { var carg0 *C.GstMessage // in, none, converted var carg1 C.guint // out, full, casted var cret C.gboolean // return carg0 = (*C.GstMessage)(UnsafeMessageToGlibNone(message)) cret = C.gst_message_parse_group_id(carg0, &carg1) runtime.KeepAlive(message) var groupId uint var goret bool groupId = uint(carg1) if cret != 0 { goret = true } return groupId, goret } // ParseHaveContext wraps gst_message_parse_have_context // // The function returns the following values: // // - _context *Context: Result location for the // context or %NULL // // Extract the context from the HAVE_CONTEXT message. // // MT safe. func (message *Message) ParseHaveContext() *Context { var carg0 *C.GstMessage // in, none, converted var carg1 *C.GstContext // out, full, converted carg0 = (*C.GstMessage)(UnsafeMessageToGlibNone(message)) C.gst_message_parse_have_context(carg0, &carg1) runtime.KeepAlive(message) var _context *Context _context = UnsafeContextFromGlibFull(unsafe.Pointer(carg1)) return _context } // ParseInfo wraps gst_message_parse_info // // The function returns the following values: // // - debug string (nullable): location for the debug message, // or %NULL // - gerror error: location for the GError // // Extracts the GError and debug string from the GstMessage. The values returned // in the output arguments are copies; the caller must free them when done. // // MT safe. func (message *Message) ParseInfo() (string, error) { var carg0 *C.GstMessage // in, none, converted var carg2 *C.gchar // out, full, string, nullable-string var carg1 *C.GError // out, full, converted carg0 = (*C.GstMessage)(UnsafeMessageToGlibNone(message)) C.gst_message_parse_info(carg0, &carg1, &carg2) runtime.KeepAlive(message) var debug string var gerror error if carg2 != nil { debug = C.GoString((*C.char)(unsafe.Pointer(carg2))) defer C.free(unsafe.Pointer(carg2)) } gerror = glib.UnsafeErrorFromGlibFull(unsafe.Pointer(carg1)) return debug, gerror } // ParseInfoDetails wraps gst_message_parse_info_details // // The function returns the following values: // // - structure *Structure (nullable): A pointer to the returned details // // Returns the optional details structure, may be NULL if none // The returned structure must not be freed. func (message *Message) ParseInfoDetails() *Structure { var carg0 *C.GstMessage // in, none, converted var carg1 *C.GstStructure // out, none, converted, nullable carg0 = (*C.GstMessage)(UnsafeMessageToGlibNone(message)) C.gst_message_parse_info_details(carg0, &carg1) runtime.KeepAlive(message) var structure *Structure if carg1 != nil { structure = UnsafeStructureFromGlibNone(unsafe.Pointer(carg1)) } return structure } // ParseInstantRateRequest wraps gst_message_parse_instant_rate_request // // The function returns the following values: // // - rateMultiplier float64: return location for the rate, or %NULL // // Parses the rate_multiplier from the instant-rate-request message. func (message *Message) ParseInstantRateRequest() float64 { var carg0 *C.GstMessage // in, none, converted var carg1 C.gdouble // out, full, casted carg0 = (*C.GstMessage)(UnsafeMessageToGlibNone(message)) C.gst_message_parse_instant_rate_request(carg0, &carg1) runtime.KeepAlive(message) var rateMultiplier float64 rateMultiplier = float64(carg1) return rateMultiplier } // ParseNewClock wraps gst_message_parse_new_clock // // The function returns the following values: // // - clock Clock: a pointer to hold the selected // new clock // // Extracts the new clock from the GstMessage. // The clock object returned remains valid until the message is freed. // // MT safe. func (message *Message) ParseNewClock() Clock { var carg0 *C.GstMessage // in, none, converted var carg1 *C.GstClock // out, none, converted carg0 = (*C.GstMessage)(UnsafeMessageToGlibNone(message)) C.gst_message_parse_new_clock(carg0, &carg1) runtime.KeepAlive(message) var clock Clock clock = UnsafeClockFromGlibNone(unsafe.Pointer(carg1)) return clock } // ParseProgress wraps gst_message_parse_progress // // The function returns the following values: // // - typ ProgressType: location for the type // - code string: location for the code // - text string: location for the text // // Parses the progress @type, @code and @text. func (message *Message) ParseProgress() (ProgressType, string, string) { var carg0 *C.GstMessage // in, none, converted var carg1 C.GstProgressType // out, full, casted var carg2 *C.gchar // out, full, string var carg3 *C.gchar // out, full, string carg0 = (*C.GstMessage)(UnsafeMessageToGlibNone(message)) C.gst_message_parse_progress(carg0, &carg1, &carg2, &carg3) runtime.KeepAlive(message) var typ ProgressType var code string var text string typ = ProgressType(carg1) code = C.GoString((*C.char)(unsafe.Pointer(carg2))) defer C.free(unsafe.Pointer(carg2)) text = C.GoString((*C.char)(unsafe.Pointer(carg3))) defer C.free(unsafe.Pointer(carg3)) return typ, code, text } // ParseQos wraps gst_message_parse_qos // // The function returns the following values: // // - live bool: if the message was generated by a live element // - runningTime uint64: the running time of the buffer that // generated the message // - streamTime uint64: the stream time of the buffer that // generated the message // - timestamp uint64: the timestamps of the buffer that // generated the message // - duration uint64: the duration of the buffer that // generated the message // // Extract the timestamps and live status from the QoS message. // // The returned values give the running_time, stream_time, timestamp and // duration of the dropped buffer. Values of GST_CLOCK_TIME_NONE mean unknown // values. // // MT safe. func (message *Message) ParseQos() (bool, uint64, uint64, uint64, uint64) { var carg0 *C.GstMessage // in, none, converted var carg1 C.gboolean // out var carg2 C.guint64 // out, full, casted var carg3 C.guint64 // out, full, casted var carg4 C.guint64 // out, full, casted var carg5 C.guint64 // out, full, casted carg0 = (*C.GstMessage)(UnsafeMessageToGlibNone(message)) C.gst_message_parse_qos(carg0, &carg1, &carg2, &carg3, &carg4, &carg5) runtime.KeepAlive(message) var live bool var runningTime uint64 var streamTime uint64 var timestamp uint64 var duration uint64 if carg1 != 0 { live = true } runningTime = uint64(carg2) streamTime = uint64(carg3) timestamp = uint64(carg4) duration = uint64(carg5) return live, runningTime, streamTime, timestamp, duration } // ParseQosStats wraps gst_message_parse_qos_stats // // The function returns the following values: // // - format Format: Units of the 'processed' and 'dropped' fields. // Video sinks and video filters will use GST_FORMAT_BUFFERS (frames). // Audio sinks and audio filters will likely use GST_FORMAT_DEFAULT // (samples). // - processed uint64: Total number of units correctly processed // since the last state change to READY or a flushing operation. // - dropped uint64: Total number of units dropped since the last // state change to READY or a flushing operation. // // Extract the QoS stats representing the history of the current continuous // pipeline playback period. // // When @format is @GST_FORMAT_UNDEFINED both @dropped and @processed are // invalid. Values of -1 for either @processed or @dropped mean unknown values. // // MT safe. func (message *Message) ParseQosStats() (Format, uint64, uint64) { var carg0 *C.GstMessage // in, none, converted var carg1 C.GstFormat // out, full, casted var carg2 C.guint64 // out, full, casted var carg3 C.guint64 // out, full, casted carg0 = (*C.GstMessage)(UnsafeMessageToGlibNone(message)) C.gst_message_parse_qos_stats(carg0, &carg1, &carg2, &carg3) runtime.KeepAlive(message) var format Format var processed uint64 var dropped uint64 format = Format(carg1) processed = uint64(carg2) dropped = uint64(carg3) return format, processed, dropped } // ParseQosValues wraps gst_message_parse_qos_values // // The function returns the following values: // // - jitter int64: The difference of the running-time against // the deadline. // - proportion float64: Long term prediction of the ideal rate // relative to normal rate to get optimal quality. // - quality int: An element dependent integer value that // specifies the current quality level of the element. The default // maximum quality is 1000000. // // Extract the QoS values that have been calculated/analysed from the QoS data // // MT safe. func (message *Message) ParseQosValues() (int64, float64, int) { var carg0 *C.GstMessage // in, none, converted var carg1 C.gint64 // out, full, casted var carg2 C.gdouble // out, full, casted var carg3 C.gint // out, full, casted carg0 = (*C.GstMessage)(UnsafeMessageToGlibNone(message)) C.gst_message_parse_qos_values(carg0, &carg1, &carg2, &carg3) runtime.KeepAlive(message) var jitter int64 var proportion float64 var quality int jitter = int64(carg1) proportion = float64(carg2) quality = int(carg3) return jitter, proportion, quality } // ParseRedirectEntry wraps gst_message_parse_redirect_entry // // The function takes the following parameters: // // - entryIndex uint: index of the entry to parse // // The function returns the following values: // // - location string: return location for // the pointer to the entry's location string, or %NULL // - tagList *TagList (nullable): return location for // the pointer to the entry's tag list, or %NULL // - entryStruct *Structure (nullable): return location // for the pointer to the entry's structure, or %NULL // // Parses the location and/or structure from the entry with the given index. // The index must be between 0 and gst_message_get_num_redirect_entries() - 1. // Returned pointers are valid for as long as this message exists. func (message *Message) ParseRedirectEntry(entryIndex uint) (string, *TagList, *Structure) { var carg0 *C.GstMessage // in, none, converted var carg1 C.gsize // in, none, casted var carg2 *C.gchar // out, none, string var carg3 *C.GstTagList // out, none, converted, nullable var carg4 *C.GstStructure // out, none, converted, nullable carg0 = (*C.GstMessage)(UnsafeMessageToGlibNone(message)) carg1 = C.gsize(entryIndex) C.gst_message_parse_redirect_entry(carg0, carg1, &carg2, &carg3, &carg4) runtime.KeepAlive(message) runtime.KeepAlive(entryIndex) var location string var tagList *TagList var entryStruct *Structure location = C.GoString((*C.char)(unsafe.Pointer(carg2))) if carg3 != nil { tagList = UnsafeTagListFromGlibNone(unsafe.Pointer(carg3)) } if carg4 != nil { entryStruct = UnsafeStructureFromGlibNone(unsafe.Pointer(carg4)) } return location, tagList, entryStruct } // ParseRequestState wraps gst_message_parse_request_state // // The function returns the following values: // // - state State: Result location for the requested state or %NULL // // Extract the requested state from the request_state message. // // MT safe. func (message *Message) ParseRequestState() State { var carg0 *C.GstMessage // in, none, converted var carg1 C.GstState // out, full, casted carg0 = (*C.GstMessage)(UnsafeMessageToGlibNone(message)) C.gst_message_parse_request_state(carg0, &carg1) runtime.KeepAlive(message) var state State state = State(carg1) return state } // ParseResetTime wraps gst_message_parse_reset_time // // The function returns the following values: // // - runningTime ClockTime: Result location for the running_time or // %NULL // // Extract the running-time from the RESET_TIME message. // // MT safe. func (message *Message) ParseResetTime() ClockTime { var carg0 *C.GstMessage // in, none, converted var carg1 C.GstClockTime // out, full, casted, alias carg0 = (*C.GstMessage)(UnsafeMessageToGlibNone(message)) C.gst_message_parse_reset_time(carg0, &carg1) runtime.KeepAlive(message) var runningTime ClockTime runningTime = ClockTime(carg1) return runningTime } // ParseSegmentDone wraps gst_message_parse_segment_done // // The function returns the following values: // // - format Format: Result location for the format, or %NULL // - position int64: Result location for the position, or %NULL // // Extracts the position and format from the segment done message. // // MT safe. func (message *Message) ParseSegmentDone() (Format, int64) { var carg0 *C.GstMessage // in, none, converted var carg1 C.GstFormat // out, full, casted var carg2 C.gint64 // out, full, casted carg0 = (*C.GstMessage)(UnsafeMessageToGlibNone(message)) C.gst_message_parse_segment_done(carg0, &carg1, &carg2) runtime.KeepAlive(message) var format Format var position int64 format = Format(carg1) position = int64(carg2) return format, position } // ParseSegmentStart wraps gst_message_parse_segment_start // // The function returns the following values: // // - format Format: Result location for the format, or %NULL // - position int64: Result location for the position, or %NULL // // Extracts the position and format from the segment start message. // // MT safe. func (message *Message) ParseSegmentStart() (Format, int64) { var carg0 *C.GstMessage // in, none, converted var carg1 C.GstFormat // out, full, casted var carg2 C.gint64 // out, full, casted carg0 = (*C.GstMessage)(UnsafeMessageToGlibNone(message)) C.gst_message_parse_segment_start(carg0, &carg1, &carg2) runtime.KeepAlive(message) var format Format var position int64 format = Format(carg1) position = int64(carg2) return format, position } // ParseStateChanged wraps gst_message_parse_state_changed // // The function returns the following values: // // - oldstate State: the previous state, or %NULL // - newstate State: the new (current) state, or %NULL // - pending State: the pending (target) state, or %NULL // // Extracts the old and new states from the GstMessage. // // Typical usage of this function might be: // |[<!-- language="C" --> // ... // switch (GST_MESSAGE_TYPE (msg)) { // case GST_MESSAGE_STATE_CHANGED: { // GstState old_state, new_state; // // gst_message_parse_state_changed (msg, &old_state, &new_state, NULL); // g_print ("Element %s changed state from %s to %s.\n", // GST_OBJECT_NAME (msg->src), // gst_element_state_get_name (old_state), // gst_element_state_get_name (new_state)); // break; // } // ... // } // ... // ]| // // MT safe. func (message *Message) ParseStateChanged() (State, State, State) { var carg0 *C.GstMessage // in, none, converted var carg1 C.GstState // out, full, casted var carg2 C.GstState // out, full, casted var carg3 C.GstState // out, full, casted carg0 = (*C.GstMessage)(UnsafeMessageToGlibNone(message)) C.gst_message_parse_state_changed(carg0, &carg1, &carg2, &carg3) runtime.KeepAlive(message) var oldstate State var newstate State var pending State oldstate = State(carg1) newstate = State(carg2) pending = State(carg3) return oldstate, newstate, pending } // ParseStepDone wraps gst_message_parse_step_done // // The function returns the following values: // // - format Format: result location for the format // - amount uint64: result location for the amount // - rate float64: result location for the rate // - flush bool: result location for the flush flag // - intermediate bool: result location for the intermediate flag // - duration uint64: result location for the duration // - eos bool: result location for the EOS flag // // Extract the values the step_done message. // // MT safe. func (message *Message) ParseStepDone() (Format, uint64, float64, bool, bool, uint64, bool) { var carg0 *C.GstMessage // in, none, converted var carg1 C.GstFormat // out, full, casted var carg2 C.guint64 // out, full, casted var carg3 C.gdouble // out, full, casted var carg4 C.gboolean // out var carg5 C.gboolean // out var carg6 C.guint64 // out, full, casted var carg7 C.gboolean // out carg0 = (*C.GstMessage)(UnsafeMessageToGlibNone(message)) C.gst_message_parse_step_done(carg0, &carg1, &carg2, &carg3, &carg4, &carg5, &carg6, &carg7) runtime.KeepAlive(message) var format Format var amount uint64 var rate float64 var flush bool var intermediate bool var duration uint64 var eos bool format = Format(carg1) amount = uint64(carg2) rate = float64(carg3) if carg4 != 0 { flush = true } if carg5 != 0 { intermediate = true } duration = uint64(carg6) if carg7 != 0 { eos = true } return format, amount, rate, flush, intermediate, duration, eos } // ParseStepStart wraps gst_message_parse_step_start // // The function returns the following values: // // - active bool: result location for the active flag // - format Format: result location for the format // - amount uint64: result location for the amount // - rate float64: result location for the rate // - flush bool: result location for the flush flag // - intermediate bool: result location for the intermediate flag // // Extract the values from step_start message. // // MT safe. func (message *Message) ParseStepStart() (bool, Format, uint64, float64, bool, bool) { var carg0 *C.GstMessage // in, none, converted var carg1 C.gboolean // out var carg2 C.GstFormat // out, full, casted var carg3 C.guint64 // out, full, casted var carg4 C.gdouble // out, full, casted var carg5 C.gboolean // out var carg6 C.gboolean // out carg0 = (*C.GstMessage)(UnsafeMessageToGlibNone(message)) C.gst_message_parse_step_start(carg0, &carg1, &carg2, &carg3, &carg4, &carg5, &carg6) runtime.KeepAlive(message) var active bool var format Format var amount uint64 var rate float64 var flush bool var intermediate bool if carg1 != 0 { active = true } format = Format(carg2) amount = uint64(carg3) rate = float64(carg4) if carg5 != 0 { flush = true } if carg6 != 0 { intermediate = true } return active, format, amount, rate, flush, intermediate } // ParseStreamCollection wraps gst_message_parse_stream_collection // // The function returns the following values: // // - collection StreamCollection: A location where to store a // pointer to the #GstStreamCollection, or %NULL // // Parses a stream-collection message. func (message *Message) ParseStreamCollection() StreamCollection { var carg0 *C.GstMessage // in, none, converted var carg1 *C.GstStreamCollection // out, full, converted carg0 = (*C.GstMessage)(UnsafeMessageToGlibNone(message)) C.gst_message_parse_stream_collection(carg0, &carg1) runtime.KeepAlive(message) var collection StreamCollection collection = UnsafeStreamCollectionFromGlibFull(unsafe.Pointer(carg1)) return collection } // ParseStreamStatus wraps gst_message_parse_stream_status // // The function returns the following values: // // - typ StreamStatusType: A pointer to hold the status type // - owner Element: The owner element of the message source // // Extracts the stream status type and owner the GstMessage. The returned // owner remains valid for as long as the reference to @message is valid and // should thus not be unreffed. // // MT safe. func (message *Message) ParseStreamStatus() (StreamStatusType, Element) { var carg0 *C.GstMessage // in, none, converted var carg1 C.GstStreamStatusType // out, full, casted var carg2 *C.GstElement // out, none, converted carg0 = (*C.GstMessage)(UnsafeMessageToGlibNone(message)) C.gst_message_parse_stream_status(carg0, &carg1, &carg2) runtime.KeepAlive(message) var typ StreamStatusType var owner Element typ = StreamStatusType(carg1) owner = UnsafeElementFromGlibNone(unsafe.Pointer(carg2)) return typ, owner } // ParseStreamsSelected wraps gst_message_parse_streams_selected // // The function returns the following values: // // - collection StreamCollection: A location where to store a // pointer to the #GstStreamCollection, or %NULL // // Parses a streams-selected message. func (message *Message) ParseStreamsSelected() StreamCollection { var carg0 *C.GstMessage // in, none, converted var carg1 *C.GstStreamCollection // out, full, converted carg0 = (*C.GstMessage)(UnsafeMessageToGlibNone(message)) C.gst_message_parse_streams_selected(carg0, &carg1) runtime.KeepAlive(message) var collection StreamCollection collection = UnsafeStreamCollectionFromGlibFull(unsafe.Pointer(carg1)) return collection } // ParseStructureChange wraps gst_message_parse_structure_change // // The function returns the following values: // // - typ StructureChangeType: A pointer to hold the change type // - owner Element: The owner element of the // message source // - busy bool: a pointer to hold whether the change is in // progress or has been completed // // Extracts the change type and completion status from the GstMessage. // // MT safe. func (message *Message) ParseStructureChange() (StructureChangeType, Element, bool) { var carg0 *C.GstMessage // in, none, converted var carg1 C.GstStructureChangeType // out, full, casted var carg2 *C.GstElement // out, none, converted var carg3 C.gboolean // out carg0 = (*C.GstMessage)(UnsafeMessageToGlibNone(message)) C.gst_message_parse_structure_change(carg0, &carg1, &carg2, &carg3) runtime.KeepAlive(message) var typ StructureChangeType var owner Element var busy bool typ = StructureChangeType(carg1) owner = UnsafeElementFromGlibNone(unsafe.Pointer(carg2)) if carg3 != 0 { busy = true } return typ, owner, busy } // ParseTag wraps gst_message_parse_tag // // The function returns the following values: // // - tagList *TagList: return location for the tag-list. // // Extracts the tag list from the GstMessage. The tag list returned in the // output argument is a copy; the caller must free it when done. // // Typical usage of this function might be: // |[<!-- language="C" --> // ... // switch (GST_MESSAGE_TYPE (msg)) { // case GST_MESSAGE_TAG: { // GstTagList *tags = NULL; // // gst_message_parse_tag (msg, &tags); // g_print ("Got tags from element %s\n", GST_OBJECT_NAME (msg->src)); // handle_tags (tags); // gst_tag_list_unref (tags); // break; // } // ... // } // ... // ]| // // MT safe. func (message *Message) ParseTag() *TagList { var carg0 *C.GstMessage // in, none, converted var carg1 *C.GstTagList // out, full, converted carg0 = (*C.GstMessage)(UnsafeMessageToGlibNone(message)) C.gst_message_parse_tag(carg0, &carg1) runtime.KeepAlive(message) var tagList *TagList tagList = UnsafeTagListFromGlibFull(unsafe.Pointer(carg1)) return tagList } // ParseToc wraps gst_message_parse_toc // // The function returns the following values: // // - toc *Toc: return location for the TOC. // - updated bool: return location for the updated flag. // // Extract the TOC from the #GstMessage. The TOC returned in the // output argument is a copy; the caller must free it with // gst_toc_unref() when done. // // MT safe. func (message *Message) ParseToc() (*Toc, bool) { var carg0 *C.GstMessage // in, none, converted var carg1 *C.GstToc // out, full, converted var carg2 C.gboolean // out carg0 = (*C.GstMessage)(UnsafeMessageToGlibNone(message)) C.gst_message_parse_toc(carg0, &carg1, &carg2) runtime.KeepAlive(message) var toc *Toc var updated bool toc = UnsafeTocFromGlibFull(unsafe.Pointer(carg1)) if carg2 != 0 { updated = true } return toc, updated } // ParseWarning wraps gst_message_parse_warning // // The function returns the following values: // // - debug string (nullable): location for the debug message, // or %NULL // - gerror error: location for the GError // // Extracts the GError and debug string from the GstMessage. The values returned // in the output arguments are copies; the caller must free them when done. // // MT safe. func (message *Message) ParseWarning() (string, error) { var carg0 *C.GstMessage // in, none, converted var carg2 *C.gchar // out, full, string, nullable-string var carg1 *C.GError // out, full, converted carg0 = (*C.GstMessage)(UnsafeMessageToGlibNone(message)) C.gst_message_parse_warning(carg0, &carg1, &carg2) runtime.KeepAlive(message) var debug string var gerror error if carg2 != nil { debug = C.GoString((*C.char)(unsafe.Pointer(carg2))) defer C.free(unsafe.Pointer(carg2)) } gerror = glib.UnsafeErrorFromGlibFull(unsafe.Pointer(carg1)) return debug, gerror } // ParseWarningDetails wraps gst_message_parse_warning_details // // The function returns the following values: // // - structure *Structure (nullable): A pointer to the returned details // // Returns the optional details structure, may be NULL if none // The returned structure must not be freed. func (message *Message) ParseWarningDetails() *Structure { var carg0 *C.GstMessage // in, none, converted var carg1 *C.GstStructure // out, none, converted, nullable carg0 = (*C.GstMessage)(UnsafeMessageToGlibNone(message)) C.gst_message_parse_warning_details(carg0, &carg1) runtime.KeepAlive(message) var structure *Structure if carg1 != nil { structure = UnsafeStructureFromGlibNone(unsafe.Pointer(carg1)) } return structure } // SetBufferingStats wraps gst_message_set_buffering_stats // // The function takes the following parameters: // // - mode BufferingMode: a buffering mode // - avgIn int: the average input rate // - avgOut int: the average output rate // - bufferingLeft int64: amount of buffering time left in milliseconds // // Configures the buffering stats values in @message. func (message *Message) SetBufferingStats(mode BufferingMode, avgIn int, avgOut int, bufferingLeft int64) { var carg0 *C.GstMessage // in, none, converted var carg1 C.GstBufferingMode // in, none, casted var carg2 C.gint // in, none, casted var carg3 C.gint // in, none, casted var carg4 C.gint64 // in, none, casted carg0 = (*C.GstMessage)(UnsafeMessageToGlibNone(message)) carg1 = C.GstBufferingMode(mode) carg2 = C.gint(avgIn) carg3 = C.gint(avgOut) carg4 = C.gint64(bufferingLeft) C.gst_message_set_buffering_stats(carg0, carg1, carg2, carg3, carg4) runtime.KeepAlive(message) runtime.KeepAlive(mode) runtime.KeepAlive(avgIn) runtime.KeepAlive(avgOut) runtime.KeepAlive(bufferingLeft) } // SetGroupID wraps gst_message_set_group_id // // The function takes the following parameters: // // - groupId uint: the group id // // Sets the group id on the stream-start message. // // All streams that have the same group id are supposed to be played // together, i.e. all streams inside a container file should have the // same group id but different stream ids. The group id should change // each time the stream is started, resulting in different group ids // each time a file is played for example. // // MT safe. func (message *Message) SetGroupID(groupId uint) { var carg0 *C.GstMessage // in, none, converted var carg1 C.guint // in, none, casted carg0 = (*C.GstMessage)(UnsafeMessageToGlibNone(message)) carg1 = C.guint(groupId) C.gst_message_set_group_id(carg0, carg1) runtime.KeepAlive(message) runtime.KeepAlive(groupId) } // SetQosStats wraps gst_message_set_qos_stats // // The function takes the following parameters: // // - format Format: Units of the 'processed' and 'dropped' fields. Video sinks and video // filters will use GST_FORMAT_BUFFERS (frames). Audio sinks and audio filters // will likely use GST_FORMAT_DEFAULT (samples). // - processed uint64: Total number of units correctly processed since the last state // change to READY or a flushing operation. // - dropped uint64: Total number of units dropped since the last state change to READY // or a flushing operation. // // Set the QoS stats representing the history of the current continuous pipeline // playback period. // // When @format is @GST_FORMAT_UNDEFINED both @dropped and @processed are // invalid. Values of -1 for either @processed or @dropped mean unknown values. // // MT safe. func (message *Message) SetQosStats(format Format, processed uint64, dropped uint64) { var carg0 *C.GstMessage // in, none, converted var carg1 C.GstFormat // in, none, casted var carg2 C.guint64 // in, none, casted var carg3 C.guint64 // in, none, casted carg0 = (*C.GstMessage)(UnsafeMessageToGlibNone(message)) carg1 = C.GstFormat(format) carg2 = C.guint64(processed) carg3 = C.guint64(dropped) C.gst_message_set_qos_stats(carg0, carg1, carg2, carg3) runtime.KeepAlive(message) runtime.KeepAlive(format) runtime.KeepAlive(processed) runtime.KeepAlive(dropped) } // SetQosValues wraps gst_message_set_qos_values // // The function takes the following parameters: // // - jitter int64: The difference of the running-time against the deadline. // - proportion float64: Long term prediction of the ideal rate relative to normal rate // to get optimal quality. // - quality int: An element dependent integer value that specifies the current // quality level of the element. The default maximum quality is 1000000. // // Set the QoS values that have been calculated/analysed from the QoS data // // MT safe. func (message *Message) SetQosValues(jitter int64, proportion float64, quality int) { var carg0 *C.GstMessage // in, none, converted var carg1 C.gint64 // in, none, casted var carg2 C.gdouble // in, none, casted var carg3 C.gint // in, none, casted carg0 = (*C.GstMessage)(UnsafeMessageToGlibNone(message)) carg1 = C.gint64(jitter) carg2 = C.gdouble(proportion) carg3 = C.gint(quality) C.gst_message_set_qos_values(carg0, carg1, carg2, carg3) runtime.KeepAlive(message) runtime.KeepAlive(jitter) runtime.KeepAlive(proportion) runtime.KeepAlive(quality) } // SetSeqnum wraps gst_message_set_seqnum // // The function takes the following parameters: // // - seqnum uint32: A sequence number. // // Set the sequence number of a message. // // This function might be called by the creator of a message to indicate that // the message relates to other messages or events. See gst_message_get_seqnum() // for more information. // // MT safe. func (message *Message) SetSeqnum(seqnum uint32) { var carg0 *C.GstMessage // in, none, converted var carg1 C.guint32 // in, none, casted carg0 = (*C.GstMessage)(UnsafeMessageToGlibNone(message)) carg1 = C.guint32(seqnum) C.gst_message_set_seqnum(carg0, carg1) runtime.KeepAlive(message) runtime.KeepAlive(seqnum) } // SetStreamStatusObject wraps gst_message_set_stream_status_object // // The function takes the following parameters: // // - object *gobject.Value: the object controlling the streaming // // Configures the object handling the streaming thread. This is usually a // GstTask object but other objects might be added in the future. func (message *Message) SetStreamStatusObject(object *gobject.Value) { var carg0 *C.GstMessage // in, none, converted var carg1 *C.GValue // in, none, converted carg0 = (*C.GstMessage)(UnsafeMessageToGlibNone(message)) carg1 = (*C.GValue)(gobject.UnsafeValueToGlibUseAnyInstead(object)) C.gst_message_set_stream_status_object(carg0, carg1) runtime.KeepAlive(message) runtime.KeepAlive(object) } // StreamsSelectedAdd wraps gst_message_streams_selected_add // // The function takes the following parameters: // // - stream Stream: a #GstStream to add to @message // // Adds the @stream to the @message. func (message *Message) StreamsSelectedAdd(stream Stream) { var carg0 *C.GstMessage // in, none, converted var carg1 *C.GstStream // in, none, converted carg0 = (*C.GstMessage)(UnsafeMessageToGlibNone(message)) carg1 = (*C.GstStream)(UnsafeStreamToGlibNone(stream)) C.gst_message_streams_selected_add(carg0, carg1) runtime.KeepAlive(message) runtime.KeepAlive(stream) } // StreamsSelectedGetSize wraps gst_message_streams_selected_get_size // // The function returns the following values: // // - goret uint // // Returns the number of streams contained in the @message. func (message *Message) StreamsSelectedGetSize() uint { var carg0 *C.GstMessage // in, none, converted var cret C.guint // return, none, casted carg0 = (*C.GstMessage)(UnsafeMessageToGlibNone(message)) cret = C.gst_message_streams_selected_get_size(carg0) runtime.KeepAlive(message) var goret uint goret = uint(cret) return goret } // StreamsSelectedGetStream wraps gst_message_streams_selected_get_stream // // The function takes the following parameters: // // - idx uint: Index of the stream to retrieve // // The function returns the following values: // // - goret Stream (nullable) // // Retrieves the #GstStream with index @index from the @message. func (message *Message) StreamsSelectedGetStream(idx uint) Stream { var carg0 *C.GstMessage // in, none, converted var carg1 C.guint // in, none, casted var cret *C.GstStream // return, full, converted, nullable carg0 = (*C.GstMessage)(UnsafeMessageToGlibNone(message)) carg1 = C.guint(idx) cret = C.gst_message_streams_selected_get_stream(carg0, carg1) runtime.KeepAlive(message) runtime.KeepAlive(idx) var goret Stream if cret != nil { goret = UnsafeStreamFromGlibFull(unsafe.Pointer(cret)) } return goret } // WritableStructure wraps gst_message_writable_structure // // The function returns the following values: // // - goret *Structure // // Get a writable version of the structure. func (message *Message) WritableStructure() *Structure { var carg0 *C.GstMessage // in, none, converted var cret *C.GstStructure // return, borrow, converted carg0 = (*C.GstMessage)(UnsafeMessageToGlibNone(message)) cret = C.gst_message_writable_structure(carg0) runtime.KeepAlive(message) var goret *Structure goret = UnsafeStructureFromGlibBorrow(unsafe.Pointer(cret)) runtime.AddCleanup(goret, func(_ *Message) {}, message) return goret } // Meta wraps GstMeta // // The #GstMeta structure should be included as the first member of a #GstBuffer // metadata structure. The structure defines the API of the metadata and should // be accessible to all elements using the metadata. // // A metadata API is registered with gst_meta_api_type_register() which takes a // name for the metadata API and some tags associated with the metadata. // With gst_meta_api_type_has_tag() one can check if a certain metadata API // contains a given tag. // // Multiple implementations of a metadata API can be registered. // To implement a metadata API, gst_meta_register() should be used. This // function takes all parameters needed to create, free and transform metadata // along with the size of the metadata. The function returns a #GstMetaInfo // structure that contains the information for the implementation of the API. // // A specific implementation can be retrieved by name with gst_meta_get_info(). // // See #GstBuffer for how the metadata can be added, retrieved and removed from // buffers. type Meta struct { *meta } // meta is the struct that's finalized type meta struct { native *C.GstMeta } // UnsafeMetaFromGlibBorrow is used to convert raw C.GstMeta pointers to go. This is used by the bindings internally. func UnsafeMetaFromGlibBorrow(p unsafe.Pointer) *Meta { return &Meta{&meta{(*C.GstMeta)(p)}} } // 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) runtime.SetFinalizer( wrapped.meta, func (intern *meta) { C.free(unsafe.Pointer(intern.native)) }, ) return wrapped } // 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( wrapped.meta, func (intern *meta) { C.free(unsafe.Pointer(intern.native)) }, ) return wrapped } // UnsafeMetaFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [Meta] is expected to work anymore. func UnsafeMetaFree(m *Meta) { C.free(unsafe.Pointer(m.native)) } // UnsafeMetaToGlibNone returns the underlying C pointer. This is used by the bindings internally. func UnsafeMetaToGlibNone(m *Meta) unsafe.Pointer { return unsafe.Pointer(m.native) } // UnsafeMetaToGlibFull returns the underlying C pointer and gives up ownership. // This is used by the bindings internally. func UnsafeMetaToGlibFull(m *Meta) unsafe.Pointer { runtime.SetFinalizer(m.meta, nil) _p := unsafe.Pointer(m.native) 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: // // - api gobject.Type: an API // // The function returns the following values: // // - goret []string func MetaApiTypeGetTags(api gobject.Type) []string { var carg1 C.GType // in, none, casted, alias var cret **C.gchar // return, transfer: none, C Pointers: 2, Name: array[utf8], scope: , array (inner: *typesystem.StringPrimitive, zero-terminated) carg1 = C.GType(api) cret = C.gst_meta_api_type_get_tags(carg1) runtime.KeepAlive(api) var goret []string _ = goret _ = cret panic("unimplemented conversion of []string (const gchar* const*)") return goret } // MetaApiTypeHasTag wraps gst_meta_api_type_has_tag // // The function takes the following parameters: // // - api gobject.Type: an API // - tag glib.Quark: the tag to check // // The function returns the following values: // // - goret bool // // Check if @api was registered with @tag. func MetaApiTypeHasTag(api gobject.Type, tag glib.Quark) bool { var carg1 C.GType // in, none, casted, alias var carg2 C.GQuark // in, none, casted, alias var cret C.gboolean // return carg1 = C.GType(api) carg2 = C.GQuark(tag) cret = C.gst_meta_api_type_has_tag(carg1, carg2) runtime.KeepAlive(api) runtime.KeepAlive(tag) var goret bool if cret != 0 { goret = true } return goret } // MetaApiTypeRegister wraps gst_meta_api_type_register // // The function takes the following parameters: // // - api string: an API to register // - tags []string: tags for @api // // The function returns the following values: // // - goret gobject.Type // // Register and return a GType for the @api and associate it with // @tags. func MetaApiTypeRegister(api string, tags []string) gobject.Type { var carg1 *C.gchar // in, none, string var carg2 **C.gchar // in, transfer: none, C Pointers: 2, Name: array[utf8], array (inner: *typesystem.StringPrimitive, zero-terminated) var cret C.GType // return, none, casted, alias carg1 = (*C.gchar)(unsafe.Pointer(C.CString(api))) defer C.free(unsafe.Pointer(carg1)) _ = tags _ = carg2 panic("unimplemented conversion of []string (const gchar**)") cret = C.gst_meta_api_type_register(carg1, carg2) runtime.KeepAlive(api) runtime.KeepAlive(tags) var goret gobject.Type goret = gobject.Type(cret) return goret } // MetaDeserialize wraps gst_meta_deserialize // // The function takes the following parameters: // // - buffer *Buffer: a #GstBuffer // - data *uint8: serialization data obtained from gst_meta_serialize() // - size uint: size of @data // // The function returns the following values: // // - consumed uint32: total size used by this meta, could be less than @size // - goret *Meta (nullable) // // Recreate a #GstMeta from serialized data returned by // gst_meta_serialize() and add it to @buffer. // // Note that the meta must have been previously registered by calling one of // `gst_*_meta_get_info ()` functions. // // @consumed is set to the number of bytes that can be skipped from @data to // find the next meta serialization, if any. In case of parsing error that does // not allow to determine that size, @consumed is set to 0. func MetaDeserialize(buffer *Buffer, data *uint8, size uint) (uint32, *Meta) { var carg1 *C.GstBuffer // in, none, converted var carg2 *C.guint8 // in, transfer: none, C Pointers: 1, Name: guint8 var carg3 C.gsize // in, none, casted var carg4 C.guint32 // out, full, casted var cret *C.GstMeta // return, none, converted, nullable carg1 = (*C.GstBuffer)(UnsafeBufferToGlibNone(buffer)) _ = data _ = carg2 panic("unimplemented conversion of *uint8 (guint8*)") carg3 = C.gsize(size) cret = C.gst_meta_deserialize(carg1, carg2, carg3, &carg4) runtime.KeepAlive(buffer) runtime.KeepAlive(data) runtime.KeepAlive(size) var consumed uint32 var goret *Meta consumed = uint32(carg4) if cret != nil { goret = UnsafeMetaFromGlibNone(unsafe.Pointer(cret)) } return consumed, goret } // MetaGetInfo wraps gst_meta_get_info // // The function takes the following parameters: // // - impl string: the name // // The function returns the following values: // // - goret *MetaInfo (nullable) // // Lookup a previously registered meta info structure by its implementation name // @impl. func MetaGetInfo(impl string) *MetaInfo { var carg1 *C.gchar // in, none, string var cret *C.GstMetaInfo // return, none, converted, nullable carg1 = (*C.gchar)(unsafe.Pointer(C.CString(impl))) defer C.free(unsafe.Pointer(carg1)) cret = C.gst_meta_get_info(carg1) runtime.KeepAlive(impl) var goret *MetaInfo if cret != nil { goret = UnsafeMetaInfoFromGlibNone(unsafe.Pointer(cret)) } return goret } // MetaRegisterCustomSimple wraps gst_meta_register_custom_simple // // The function takes the following parameters: // // - name string: the name of the #GstMeta implementation // // The function returns the following values: // // - goret *MetaInfo // // Simplified version of gst_meta_register_custom(), with no tags and no // transform function. func MetaRegisterCustomSimple(name string) *MetaInfo { var carg1 *C.gchar // in, none, string var cret *C.GstMetaInfo // return, none, converted carg1 = (*C.gchar)(unsafe.Pointer(C.CString(name))) defer C.free(unsafe.Pointer(carg1)) cret = C.gst_meta_register_custom_simple(carg1) runtime.KeepAlive(name) var goret *MetaInfo goret = UnsafeMetaInfoFromGlibNone(unsafe.Pointer(cret)) return goret } // CompareSeqnum wraps gst_meta_compare_seqnum // // The function takes the following parameters: // // - meta2 *Meta: a #GstMeta // // The function returns the following values: // // - goret int // // Meta sequence number compare function. Can be used as #GCompareFunc // or a #GCompareDataFunc. func (meta1 *Meta) CompareSeqnum(meta2 *Meta) int { var carg0 *C.GstMeta // in, none, converted var carg1 *C.GstMeta // in, none, converted var cret C.gint // return, none, casted carg0 = (*C.GstMeta)(UnsafeMetaToGlibNone(meta1)) carg1 = (*C.GstMeta)(UnsafeMetaToGlibNone(meta2)) cret = C.gst_meta_compare_seqnum(carg0, carg1) runtime.KeepAlive(meta1) runtime.KeepAlive(meta2) var goret int goret = int(cret) return goret } // GetSeqnum wraps gst_meta_get_seqnum // // The function returns the following values: // // - goret uint64 // // Gets seqnum for this meta. func (meta *Meta) GetSeqnum() uint64 { var carg0 *C.GstMeta // in, none, converted var cret C.guint64 // return, none, casted carg0 = (*C.GstMeta)(UnsafeMetaToGlibNone(meta)) cret = C.gst_meta_get_seqnum(carg0) runtime.KeepAlive(meta) var goret uint64 goret = uint64(cret) return goret } // Serialize wraps gst_meta_serialize // // The function takes the following parameters: // // - data *ByteArrayInterface: #GstByteArrayInterface to append serialization data // // The function returns the following values: // // - goret bool // // Serialize @meta into a format that can be stored or transmitted and later // deserialized by gst_meta_deserialize(). // // This is only supported for meta that implements #GstMetaInfo.serialize_func, // %FALSE is returned otherwise. // // Upon failure, @data->data pointer could have been reallocated, but @data->len // won't be modified. This is intended to be able to append multiple metas // into the same #GByteArray. // // Since serialization size is often the same for every buffer, caller may want // to remember the size of previous data to preallocate the next. func (meta *Meta) Serialize(data *ByteArrayInterface) bool { var carg0 *C.GstMeta // in, none, converted var carg1 *C.GstByteArrayInterface // in, none, converted var cret C.gboolean // return carg0 = (*C.GstMeta)(UnsafeMetaToGlibNone(meta)) carg1 = (*C.GstByteArrayInterface)(UnsafeByteArrayInterfaceToGlibNone(data)) cret = C.gst_meta_serialize(carg0, carg1) runtime.KeepAlive(meta) runtime.KeepAlive(data) var goret bool if cret != 0 { goret = true } return goret } // MetaInfo wraps GstMetaInfo // // The #GstMetaInfo provides information about a specific metadata // structure. type MetaInfo struct { *metaInfo } // metaInfo is the struct that's finalized type metaInfo struct { native *C.GstMetaInfo } // UnsafeMetaInfoFromGlibBorrow is used to convert raw C.GstMetaInfo pointers to go. This is used by the bindings internally. func UnsafeMetaInfoFromGlibBorrow(p unsafe.Pointer) *MetaInfo { return &MetaInfo{&metaInfo{(*C.GstMetaInfo)(p)}} } // 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) runtime.SetFinalizer( wrapped.metaInfo, func (intern *metaInfo) { C.free(unsafe.Pointer(intern.native)) }, ) return wrapped } // 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( wrapped.metaInfo, func (intern *metaInfo) { C.free(unsafe.Pointer(intern.native)) }, ) return wrapped } // UnsafeMetaInfoFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [MetaInfo] is expected to work anymore. func UnsafeMetaInfoFree(m *MetaInfo) { C.free(unsafe.Pointer(m.native)) } // UnsafeMetaInfoToGlibNone returns the underlying C pointer. This is used by the bindings internally. func UnsafeMetaInfoToGlibNone(m *MetaInfo) unsafe.Pointer { return unsafe.Pointer(m.native) } // UnsafeMetaInfoToGlibFull returns the underlying C pointer and gives up ownership. // This is used by the bindings internally. func UnsafeMetaInfoToGlibFull(m *MetaInfo) unsafe.Pointer { runtime.SetFinalizer(m.metaInfo, nil) _p := unsafe.Pointer(m.native) 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 func (info *MetaInfo) IsCustom() bool { var carg0 *C.GstMetaInfo // in, none, converted var cret C.gboolean // return carg0 = (*C.GstMetaInfo)(UnsafeMetaInfoToGlibNone(info)) cret = C.gst_meta_info_is_custom(carg0) runtime.KeepAlive(info) var goret bool if cret != 0 { goret = true } return goret } // Register wraps gst_meta_info_register // // The function returns the following values: // // - goret *MetaInfo // // Registers a new meta. // // Use the structure returned by gst_meta_info_new(), it consumes it and the // structure shouldnt be used after. The one returned by the function can be // kept. func (info *MetaInfo) Register() *MetaInfo { var carg0 *C.GstMetaInfo // in, none, converted var cret *C.GstMetaInfo // return, none, converted carg0 = (*C.GstMetaInfo)(UnsafeMetaInfoToGlibNone(info)) cret = C.gst_meta_info_register(carg0) runtime.KeepAlive(info) var goret *MetaInfo goret = UnsafeMetaInfoFromGlibNone(unsafe.Pointer(cret)) return goret } // MetaTransformCopy wraps GstMetaTransformCopy // // Extra data passed to a "gst-copy" transform #GstMetaTransformFunction. type MetaTransformCopy struct { *metaTransformCopy } // metaTransformCopy is the struct that's finalized type metaTransformCopy struct { native *C.GstMetaTransformCopy } // UnsafeMetaTransformCopyFromGlibBorrow is used to convert raw C.GstMetaTransformCopy pointers to go. This is used by the bindings internally. func UnsafeMetaTransformCopyFromGlibBorrow(p unsafe.Pointer) *MetaTransformCopy { return &MetaTransformCopy{&metaTransformCopy{(*C.GstMetaTransformCopy)(p)}} } // 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) runtime.SetFinalizer( wrapped.metaTransformCopy, func (intern *metaTransformCopy) { C.free(unsafe.Pointer(intern.native)) }, ) return wrapped } // 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( wrapped.metaTransformCopy, func (intern *metaTransformCopy) { C.free(unsafe.Pointer(intern.native)) }, ) return wrapped } // UnsafeMetaTransformCopyFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [MetaTransformCopy] is expected to work anymore. func UnsafeMetaTransformCopyFree(m *MetaTransformCopy) { C.free(unsafe.Pointer(m.native)) } // UnsafeMetaTransformCopyToGlibNone returns the underlying C pointer. This is used by the bindings internally. func UnsafeMetaTransformCopyToGlibNone(m *MetaTransformCopy) unsafe.Pointer { return unsafe.Pointer(m.native) } // UnsafeMetaTransformCopyToGlibFull returns the underlying C pointer and gives up ownership. // This is used by the bindings internally. func UnsafeMetaTransformCopyToGlibFull(m *MetaTransformCopy) unsafe.Pointer { runtime.SetFinalizer(m.metaTransformCopy, nil) _p := unsafe.Pointer(m.native) 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 // types. // // Subclasses will include #GstMiniObject as the first member in their structure // and then call gst_mini_object_init() to initialize the #GstMiniObject fields. // // gst_mini_object_ref() and gst_mini_object_unref() increment and decrement the // refcount respectively. When the refcount of a mini-object reaches 0, the // dispose function is called first and when this returns %TRUE, the free // function of the miniobject is called. // // A copy can be made with gst_mini_object_copy(). // // gst_mini_object_is_writable() will return %TRUE when the refcount of the // object is exactly 1 and there is no parent or a single parent exists and is // writable itself, meaning the current caller has the only reference to the // object. gst_mini_object_make_writable() will return a writable version of // the object, which might be a new copy when the refcount was not 1. // // Opaque data can be associated with a #GstMiniObject with // gst_mini_object_set_qdata() and gst_mini_object_get_qdata(). The data is // meant to be specific to the particular object and is not automatically copied // with gst_mini_object_copy() or similar methods. // // A weak reference can be added and remove with gst_mini_object_weak_ref() // and gst_mini_object_weak_unref() respectively. type MiniObject struct { *miniObject } // miniObject is the struct that's finalized type miniObject struct { native *C.GstMiniObject } var _ gobject.GoValueInitializer = (*MiniObject)(nil) func marshalMiniObject(p unsafe.Pointer) (interface{}, error) { b := gobject.ValueFromNative(p).Boxed() return UnsafeMiniObjectFromGlibBorrow(b), nil } func (r *MiniObject) InitGoValue(v *gobject.Value) { v.Init(TypeMiniObject) v.SetBoxed(unsafe.Pointer(r.native)) } // UnsafeMiniObjectFromGlibBorrow is used to convert raw C.GstMiniObject pointers to go. This is used by the bindings internally. func UnsafeMiniObjectFromGlibBorrow(p unsafe.Pointer) *MiniObject { return &MiniObject{&miniObject{(*C.GstMiniObject)(p)}} } // 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) runtime.SetFinalizer( wrapped.miniObject, func (intern *miniObject) { C.gst_mini_object_unref(intern.native) }, ) return wrapped } // 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( wrapped.miniObject, func (intern *miniObject) { C.gst_mini_object_unref(intern.native) }, ) return wrapped } // UnsafeMiniObjectRef increases the refcount on the underlying resource. This is used by the bindings internally. // // When this is called without an associated call to [MiniObject.UnsafeMiniObjectUnref], then [MiniObject] will leak memory. func UnsafeMiniObjectRef(m *MiniObject) { C.gst_mini_object_ref(m.native) } // UnsafeMiniObjectUnref unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [MiniObject] is expected to work anymore. func UnsafeMiniObjectUnref(m *MiniObject) { C.gst_mini_object_unref(m.native) } // UnsafeMiniObjectToGlibNone returns the underlying C pointer. This is used by the bindings internally. func UnsafeMiniObjectToGlibNone(m *MiniObject) unsafe.Pointer { return unsafe.Pointer(m.native) } // UnsafeMiniObjectToGlibFull returns the underlying C pointer and gives up ownership. // This is used by the bindings internally. func UnsafeMiniObjectToGlibFull(m *MiniObject) unsafe.Pointer { runtime.SetFinalizer(m.miniObject, nil) _p := unsafe.Pointer(m.native) m.native = nil // MiniObject is invalid from here on return _p } // AddParent wraps gst_mini_object_add_parent // // The function takes the following parameters: // // - parent *MiniObject: a parent #GstMiniObject // // This adds @parent as a parent for @object. Having one ore more parents affects the // writability of @object: if a @parent is not writable, @object is also not // writable, regardless of its refcount. @object is only writable if all // the parents are writable and its own refcount is exactly 1. // // Note: This function does not take ownership of @parent and also does not // take an additional reference. It is the responsibility of the caller to // remove the parent again at a later time. func (object *MiniObject) AddParent(parent *MiniObject) { var carg0 *C.GstMiniObject // in, none, converted var carg1 *C.GstMiniObject // in, none, converted carg0 = (*C.GstMiniObject)(UnsafeMiniObjectToGlibNone(object)) carg1 = (*C.GstMiniObject)(UnsafeMiniObjectToGlibNone(parent)) C.gst_mini_object_add_parent(carg0, carg1) runtime.KeepAlive(object) runtime.KeepAlive(parent) } // IsWritable wraps gst_mini_object_is_writable // // The function returns the following values: // // - goret bool // // If @mini_object has the LOCKABLE flag set, check if the current EXCLUSIVE // lock on @object is the only one, this means that changes to the object will // not be visible to any other object. // // If the LOCKABLE flag is not set, check if the refcount of @mini_object is // exactly 1, meaning that no other reference exists to the object and that the // object is therefore writable. // // Modification of a mini-object should only be done after verifying that it // is writable. func (miniObject *MiniObject) IsWritable() bool { var carg0 *C.GstMiniObject // in, none, converted var cret C.gboolean // return carg0 = (*C.GstMiniObject)(UnsafeMiniObjectToGlibNone(miniObject)) cret = C.gst_mini_object_is_writable(carg0) runtime.KeepAlive(miniObject) var goret bool if cret != 0 { goret = true } return goret } // Lock wraps gst_mini_object_lock // // The function takes the following parameters: // // - flags LockFlags: #GstLockFlags // // The function returns the following values: // // - goret bool // // Lock the mini-object with the specified access mode in @flags. func (object *MiniObject) Lock(flags LockFlags) bool { var carg0 *C.GstMiniObject // in, none, converted var carg1 C.GstLockFlags // in, none, casted var cret C.gboolean // return carg0 = (*C.GstMiniObject)(UnsafeMiniObjectToGlibNone(object)) carg1 = C.GstLockFlags(flags) cret = C.gst_mini_object_lock(carg0, carg1) runtime.KeepAlive(object) runtime.KeepAlive(flags) var goret bool if cret != 0 { goret = true } return goret } // RemoveParent wraps gst_mini_object_remove_parent // // The function takes the following parameters: // // - parent *MiniObject: a parent #GstMiniObject // // This removes @parent as a parent for @object. See // gst_mini_object_add_parent(). func (object *MiniObject) RemoveParent(parent *MiniObject) { var carg0 *C.GstMiniObject // in, none, converted var carg1 *C.GstMiniObject // in, none, converted carg0 = (*C.GstMiniObject)(UnsafeMiniObjectToGlibNone(object)) carg1 = (*C.GstMiniObject)(UnsafeMiniObjectToGlibNone(parent)) C.gst_mini_object_remove_parent(carg0, carg1) runtime.KeepAlive(object) runtime.KeepAlive(parent) } // Unlock wraps gst_mini_object_unlock // // The function takes the following parameters: // // - flags LockFlags: #GstLockFlags // // Unlock the mini-object with the specified access mode in @flags. func (object *MiniObject) Unlock(flags LockFlags) { var carg0 *C.GstMiniObject // in, none, converted var carg1 C.GstLockFlags // in, none, casted carg0 = (*C.GstMiniObject)(UnsafeMiniObjectToGlibNone(object)) carg1 = C.GstLockFlags(flags) C.gst_mini_object_unlock(carg0, carg1) runtime.KeepAlive(object) runtime.KeepAlive(flags) } // ObjectClass wraps GstObjectClass // // GStreamer base object class. // // ObjectClass is the type struct for [Object] type ObjectClass struct { *objectClass } // objectClass is the struct that's finalized type objectClass struct { native *C.GstObjectClass } // UnsafeObjectClassFromGlibBorrow is used to convert raw C.GstObjectClass pointers to go. This is used by the bindings internally. func UnsafeObjectClassFromGlibBorrow(p unsafe.Pointer) *ObjectClass { return &ObjectClass{&objectClass{(*C.GstObjectClass)(p)}} } // 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. func UnsafeObjectClassFree(o *ObjectClass) { C.free(unsafe.Pointer(o.native)) } // UnsafeObjectClassToGlibNone returns the underlying C pointer. This is used by the bindings internally. func UnsafeObjectClassToGlibNone(o *ObjectClass) unsafe.Pointer { return unsafe.Pointer(o.native) } // 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 } // padClass is the struct that's finalized type padClass struct { native *C.GstPadClass } // UnsafePadClassFromGlibBorrow is used to convert raw C.GstPadClass pointers to go. This is used by the bindings internally. func UnsafePadClassFromGlibBorrow(p unsafe.Pointer) *PadClass { return &PadClass{&padClass{(*C.GstPadClass)(p)}} } // 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. func UnsafePadClassFree(p *PadClass) { C.free(unsafe.Pointer(p.native)) } // UnsafePadClassToGlibNone returns the underlying C pointer. This is used by the bindings internally. func UnsafePadClassToGlibNone(p *PadClass) unsafe.Pointer { return unsafe.Pointer(p.native) } // 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. type PadProbeInfo struct { *padProbeInfo } // padProbeInfo is the struct that's finalized type padProbeInfo struct { native *C.GstPadProbeInfo } // UnsafePadProbeInfoFromGlibBorrow is used to convert raw C.GstPadProbeInfo pointers to go. This is used by the bindings internally. func UnsafePadProbeInfoFromGlibBorrow(p unsafe.Pointer) *PadProbeInfo { return &PadProbeInfo{&padProbeInfo{(*C.GstPadProbeInfo)(p)}} } // 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) runtime.SetFinalizer( wrapped.padProbeInfo, func (intern *padProbeInfo) { C.free(unsafe.Pointer(intern.native)) }, ) return wrapped } // 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( wrapped.padProbeInfo, func (intern *padProbeInfo) { C.free(unsafe.Pointer(intern.native)) }, ) return wrapped } // UnsafePadProbeInfoFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [PadProbeInfo] is expected to work anymore. func UnsafePadProbeInfoFree(p *PadProbeInfo) { C.free(unsafe.Pointer(p.native)) } // UnsafePadProbeInfoToGlibNone returns the underlying C pointer. This is used by the bindings internally. func UnsafePadProbeInfoToGlibNone(p *PadProbeInfo) unsafe.Pointer { return unsafe.Pointer(p.native) } // UnsafePadProbeInfoToGlibFull returns the underlying C pointer and gives up ownership. // This is used by the bindings internally. func UnsafePadProbeInfoToGlibFull(p *PadProbeInfo) unsafe.Pointer { runtime.SetFinalizer(p.padProbeInfo, nil) _p := unsafe.Pointer(p.native) 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) func (info *PadProbeInfo) GetBuffer() *Buffer { var carg0 *C.GstPadProbeInfo // in, none, converted var cret *C.GstBuffer // return, none, converted, nullable carg0 = (*C.GstPadProbeInfo)(UnsafePadProbeInfoToGlibNone(info)) cret = C.gst_pad_probe_info_get_buffer(carg0) runtime.KeepAlive(info) var goret *Buffer if cret != nil { goret = UnsafeBufferFromGlibNone(unsafe.Pointer(cret)) } return goret } // GetBufferList wraps gst_pad_probe_info_get_buffer_list // // The function returns the following values: // // - goret *BufferList (nullable) func (info *PadProbeInfo) GetBufferList() *BufferList { var carg0 *C.GstPadProbeInfo // in, none, converted var cret *C.GstBufferList // return, none, converted, nullable carg0 = (*C.GstPadProbeInfo)(UnsafePadProbeInfoToGlibNone(info)) cret = C.gst_pad_probe_info_get_buffer_list(carg0) runtime.KeepAlive(info) var goret *BufferList if cret != nil { goret = UnsafeBufferListFromGlibNone(unsafe.Pointer(cret)) } return goret } // GetEvent wraps gst_pad_probe_info_get_event // // The function returns the following values: // // - goret *Event (nullable) func (info *PadProbeInfo) GetEvent() *Event { var carg0 *C.GstPadProbeInfo // in, none, converted var cret *C.GstEvent // return, none, converted, nullable carg0 = (*C.GstPadProbeInfo)(UnsafePadProbeInfoToGlibNone(info)) cret = C.gst_pad_probe_info_get_event(carg0) runtime.KeepAlive(info) var goret *Event if cret != nil { goret = UnsafeEventFromGlibNone(unsafe.Pointer(cret)) } return goret } // GetQuery wraps gst_pad_probe_info_get_query // // The function returns the following values: // // - goret *Query (nullable) func (info *PadProbeInfo) GetQuery() *Query { var carg0 *C.GstPadProbeInfo // in, none, converted var cret *C.GstQuery // return, none, converted, nullable carg0 = (*C.GstPadProbeInfo)(UnsafePadProbeInfoToGlibNone(info)) cret = C.gst_pad_probe_info_get_query(carg0) runtime.KeepAlive(info) var goret *Query if cret != nil { goret = UnsafeQueryFromGlibNone(unsafe.Pointer(cret)) } return goret } // PadTemplateClass wraps GstPadTemplateClass // // PadTemplateClass is the type struct for [PadTemplate] type PadTemplateClass struct { *padTemplateClass } // padTemplateClass is the struct that's finalized type padTemplateClass struct { native *C.GstPadTemplateClass } // UnsafePadTemplateClassFromGlibBorrow is used to convert raw C.GstPadTemplateClass pointers to go. This is used by the bindings internally. func UnsafePadTemplateClassFromGlibBorrow(p unsafe.Pointer) *PadTemplateClass { return &PadTemplateClass{&padTemplateClass{(*C.GstPadTemplateClass)(p)}} } // 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. func UnsafePadTemplateClassFree(p *PadTemplateClass) { C.free(unsafe.Pointer(p.native)) } // UnsafePadTemplateClassToGlibNone returns the underlying C pointer. This is used by the bindings internally. func UnsafePadTemplateClassToGlibNone(p *PadTemplateClass) unsafe.Pointer { return unsafe.Pointer(p.native) } // 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. type ParamSpecArray struct { *paramSpecArray } // paramSpecArray is the struct that's finalized type paramSpecArray struct { native *C.GstParamSpecArray } // UnsafeParamSpecArrayFromGlibBorrow is used to convert raw C.GstParamSpecArray pointers to go. This is used by the bindings internally. func UnsafeParamSpecArrayFromGlibBorrow(p unsafe.Pointer) *ParamSpecArray { return &ParamSpecArray{¶mSpecArray{(*C.GstParamSpecArray)(p)}} } // 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) runtime.SetFinalizer( wrapped.paramSpecArray, func (intern *paramSpecArray) { C.free(unsafe.Pointer(intern.native)) }, ) return wrapped } // 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( wrapped.paramSpecArray, func (intern *paramSpecArray) { C.free(unsafe.Pointer(intern.native)) }, ) return wrapped } // UnsafeParamSpecArrayFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [ParamSpecArray] is expected to work anymore. func UnsafeParamSpecArrayFree(p *ParamSpecArray) { C.free(unsafe.Pointer(p.native)) } // UnsafeParamSpecArrayToGlibNone returns the underlying C pointer. This is used by the bindings internally. func UnsafeParamSpecArrayToGlibNone(p *ParamSpecArray) unsafe.Pointer { return unsafe.Pointer(p.native) } // UnsafeParamSpecArrayToGlibFull returns the underlying C pointer and gives up ownership. // This is used by the bindings internally. func UnsafeParamSpecArrayToGlibFull(p *ParamSpecArray) unsafe.Pointer { runtime.SetFinalizer(p.paramSpecArray, nil) _p := unsafe.Pointer(p.native) 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 // properties. type ParamSpecFraction struct { *paramSpecFraction } // paramSpecFraction is the struct that's finalized type paramSpecFraction struct { native *C.GstParamSpecFraction } // UnsafeParamSpecFractionFromGlibBorrow is used to convert raw C.GstParamSpecFraction pointers to go. This is used by the bindings internally. func UnsafeParamSpecFractionFromGlibBorrow(p unsafe.Pointer) *ParamSpecFraction { return &ParamSpecFraction{¶mSpecFraction{(*C.GstParamSpecFraction)(p)}} } // 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) runtime.SetFinalizer( wrapped.paramSpecFraction, func (intern *paramSpecFraction) { C.free(unsafe.Pointer(intern.native)) }, ) return wrapped } // 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( wrapped.paramSpecFraction, func (intern *paramSpecFraction) { C.free(unsafe.Pointer(intern.native)) }, ) return wrapped } // UnsafeParamSpecFractionFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [ParamSpecFraction] is expected to work anymore. func UnsafeParamSpecFractionFree(p *ParamSpecFraction) { C.free(unsafe.Pointer(p.native)) } // UnsafeParamSpecFractionToGlibNone returns the underlying C pointer. This is used by the bindings internally. func UnsafeParamSpecFractionToGlibNone(p *ParamSpecFraction) unsafe.Pointer { return unsafe.Pointer(p.native) } // UnsafeParamSpecFractionToGlibFull returns the underlying C pointer and gives up ownership. // This is used by the bindings internally. func UnsafeParamSpecFractionToGlibFull(p *ParamSpecFraction) unsafe.Pointer { runtime.SetFinalizer(p.paramSpecFraction, nil) _p := unsafe.Pointer(p.native) 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 // to hold a reference to another buffer that is only released when the child // #GstBuffer is released. // // Typically, #GstParentBufferMeta is used when the child buffer is directly // using the #GstMemory of the parent buffer, and wants to prevent the parent // buffer from being returned to a buffer pool until the #GstMemory is available // for re-use. type ParentBufferMeta struct { *parentBufferMeta } // parentBufferMeta is the struct that's finalized type parentBufferMeta struct { native *C.GstParentBufferMeta } // UnsafeParentBufferMetaFromGlibBorrow is used to convert raw C.GstParentBufferMeta pointers to go. This is used by the bindings internally. func UnsafeParentBufferMetaFromGlibBorrow(p unsafe.Pointer) *ParentBufferMeta { return &ParentBufferMeta{&parentBufferMeta{(*C.GstParentBufferMeta)(p)}} } // 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) runtime.SetFinalizer( wrapped.parentBufferMeta, func (intern *parentBufferMeta) { C.free(unsafe.Pointer(intern.native)) }, ) return wrapped } // 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( wrapped.parentBufferMeta, func (intern *parentBufferMeta) { C.free(unsafe.Pointer(intern.native)) }, ) return wrapped } // UnsafeParentBufferMetaFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [ParentBufferMeta] is expected to work anymore. func UnsafeParentBufferMetaFree(p *ParentBufferMeta) { C.free(unsafe.Pointer(p.native)) } // UnsafeParentBufferMetaToGlibNone returns the underlying C pointer. This is used by the bindings internally. func UnsafeParentBufferMetaToGlibNone(p *ParentBufferMeta) unsafe.Pointer { return unsafe.Pointer(p.native) } // UnsafeParentBufferMetaToGlibFull returns the underlying C pointer and gives up ownership. // This is used by the bindings internally. func UnsafeParentBufferMetaToGlibFull(p *ParentBufferMeta) unsafe.Pointer { runtime.SetFinalizer(p.parentBufferMeta, nil) _p := unsafe.Pointer(p.native) 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 // // Gets the global #GstMetaInfo describing the #GstParentBufferMeta meta. func ParentBufferMetaGetInfo() *MetaInfo { var cret *C.GstMetaInfo // return, none, converted cret = C.gst_parent_buffer_meta_get_info() var goret *MetaInfo goret = UnsafeMetaInfoFromGlibNone(unsafe.Pointer(cret)) return goret } // ParseContext wraps GstParseContext // // Opaque structure. type ParseContext struct { *parseContext } // parseContext is the struct that's finalized type parseContext struct { native *C.GstParseContext } var _ gobject.GoValueInitializer = (*ParseContext)(nil) func marshalParseContext(p unsafe.Pointer) (interface{}, error) { b := gobject.ValueFromNative(p).Boxed() return UnsafeParseContextFromGlibBorrow(b), nil } func (r *ParseContext) InitGoValue(v *gobject.Value) { v.Init(TypeParseContext) v.SetBoxed(unsafe.Pointer(r.native)) } // UnsafeParseContextFromGlibBorrow is used to convert raw C.GstParseContext pointers to go. This is used by the bindings internally. func UnsafeParseContextFromGlibBorrow(p unsafe.Pointer) *ParseContext { return &ParseContext{&parseContext{(*C.GstParseContext)(p)}} } // 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) runtime.SetFinalizer( wrapped.parseContext, func (intern *parseContext) { C.gst_parse_context_free(intern.native) }, ) return wrapped } // 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( wrapped.parseContext, func (intern *parseContext) { C.gst_parse_context_free(intern.native) }, ) return wrapped } // UnsafeParseContextFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [ParseContext] is expected to work anymore. func UnsafeParseContextFree(p *ParseContext) { C.gst_parse_context_free(p.native) } // UnsafeParseContextToGlibNone returns the underlying C pointer. This is used by the bindings internally. func UnsafeParseContextToGlibNone(p *ParseContext) unsafe.Pointer { return unsafe.Pointer(p.native) } // UnsafeParseContextToGlibFull returns the underlying C pointer and gives up ownership. // This is used by the bindings internally. func UnsafeParseContextToGlibFull(p *ParseContext) unsafe.Pointer { runtime.SetFinalizer(p.parseContext, nil) _p := unsafe.Pointer(p.native) 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) // // Allocates a parse context for use with gst_parse_launch_full() or // gst_parse_launchv_full(). // // Free-function: gst_parse_context_free func NewParseContext() *ParseContext { var cret *C.GstParseContext // return, full, converted, nullable cret = C.gst_parse_context_new() var goret *ParseContext if cret != nil { goret = UnsafeParseContextFromGlibFull(unsafe.Pointer(cret)) } return goret } // Copy wraps gst_parse_context_copy // // The function returns the following values: // // - goret *ParseContext (nullable) // // Copies the @context. func (_context *ParseContext) Copy() *ParseContext { var carg0 *C.GstParseContext // in, none, converted var cret *C.GstParseContext // return, full, converted, nullable carg0 = (*C.GstParseContext)(UnsafeParseContextToGlibNone(_context)) cret = C.gst_parse_context_copy(carg0) runtime.KeepAlive(_context) var goret *ParseContext if cret != nil { goret = UnsafeParseContextFromGlibFull(unsafe.Pointer(cret)) } return goret } // GetMissingElements wraps gst_parse_context_get_missing_elements // // The function returns the following values: // // - goret []string (nullable) // // Retrieve missing elements from a previous run of gst_parse_launch_full() // or gst_parse_launchv_full(). Will only return results if an error code // of %GST_PARSE_ERROR_NO_SUCH_ELEMENT was returned. func (_context *ParseContext) GetMissingElements() []string { var carg0 *C.GstParseContext // in, none, converted var cret **C.gchar // return, transfer: full, C Pointers: 2, Name: array[utf8], scope: , nullable, array (inner: *typesystem.StringPrimitive, zero-terminated) carg0 = (*C.GstParseContext)(UnsafeParseContextToGlibNone(_context)) cret = C.gst_parse_context_get_missing_elements(carg0) runtime.KeepAlive(_context) var goret []string _ = goret _ = cret panic("unimplemented conversion of []string (gchar**)") return goret } // PipelineClass wraps GstPipelineClass // // PipelineClass is the type struct for [Pipeline] type PipelineClass struct { *pipelineClass } // pipelineClass is the struct that's finalized type pipelineClass struct { native *C.GstPipelineClass } // UnsafePipelineClassFromGlibBorrow is used to convert raw C.GstPipelineClass pointers to go. This is used by the bindings internally. func UnsafePipelineClassFromGlibBorrow(p unsafe.Pointer) *PipelineClass { return &PipelineClass{&pipelineClass{(*C.GstPipelineClass)(p)}} } // 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. func UnsafePipelineClassFree(p *PipelineClass) { C.free(unsafe.Pointer(p.native)) } // UnsafePipelineClassToGlibNone returns the underlying C pointer. This is used by the bindings internally. func UnsafePipelineClassToGlibNone(p *PipelineClass) unsafe.Pointer { return unsafe.Pointer(p.native) } // 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 } // pluginClass is the struct that's finalized type pluginClass struct { native *C.GstPluginClass } // UnsafePluginClassFromGlibBorrow is used to convert raw C.GstPluginClass pointers to go. This is used by the bindings internally. func UnsafePluginClassFromGlibBorrow(p unsafe.Pointer) *PluginClass { return &PluginClass{&pluginClass{(*C.GstPluginClass)(p)}} } // 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. func UnsafePluginClassFree(p *PluginClass) { C.free(unsafe.Pointer(p.native)) } // UnsafePluginClassToGlibNone returns the underlying C pointer. This is used by the bindings internally. func UnsafePluginClassToGlibNone(p *PluginClass) unsafe.Pointer { return unsafe.Pointer(p.native) } // 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 // loader will use the data provided there to initialize the plugin. // // The @licence parameter must be one of: LGPL, GPL, QPL, GPL/QPL, MPL, // BSD, MIT/X11, Proprietary, unknown. type PluginDesc struct { *pluginDesc } // pluginDesc is the struct that's finalized type pluginDesc struct { native *C.GstPluginDesc } // UnsafePluginDescFromGlibBorrow is used to convert raw C.GstPluginDesc pointers to go. This is used by the bindings internally. func UnsafePluginDescFromGlibBorrow(p unsafe.Pointer) *PluginDesc { return &PluginDesc{&pluginDesc{(*C.GstPluginDesc)(p)}} } // 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) runtime.SetFinalizer( wrapped.pluginDesc, func (intern *pluginDesc) { C.free(unsafe.Pointer(intern.native)) }, ) return wrapped } // 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( wrapped.pluginDesc, func (intern *pluginDesc) { C.free(unsafe.Pointer(intern.native)) }, ) return wrapped } // UnsafePluginDescFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [PluginDesc] is expected to work anymore. func UnsafePluginDescFree(p *PluginDesc) { C.free(unsafe.Pointer(p.native)) } // UnsafePluginDescToGlibNone returns the underlying C pointer. This is used by the bindings internally. func UnsafePluginDescToGlibNone(p *PluginDesc) unsafe.Pointer { return unsafe.Pointer(p.native) } // UnsafePluginDescToGlibFull returns the underlying C pointer and gives up ownership. // This is used by the bindings internally. func UnsafePluginDescToGlibFull(p *PluginDesc) unsafe.Pointer { runtime.SetFinalizer(p.pluginDesc, nil) _p := unsafe.Pointer(p.native) 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 } // pluginFeatureClass is the struct that's finalized type pluginFeatureClass struct { native *C.GstPluginFeatureClass } // UnsafePluginFeatureClassFromGlibBorrow is used to convert raw C.GstPluginFeatureClass pointers to go. This is used by the bindings internally. func UnsafePluginFeatureClassFromGlibBorrow(p unsafe.Pointer) *PluginFeatureClass { return &PluginFeatureClass{&pluginFeatureClass{(*C.GstPluginFeatureClass)(p)}} } // 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. func UnsafePluginFeatureClassFree(p *PluginFeatureClass) { C.free(unsafe.Pointer(p.native)) } // UnsafePluginFeatureClassToGlibNone returns the underlying C pointer. This is used by the bindings internally. func UnsafePluginFeatureClassToGlibNone(p *PluginFeatureClass) unsafe.Pointer { return unsafe.Pointer(p.native) } // 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 // select ()) or a struct pollfd array (used with poll ()). Once created with // gst_poll_new(), the set can be used to wait for file descriptors to be // readable and/or writable. It is possible to make this wait be controlled // by specifying %TRUE for the @controllable flag when creating the set (or // later calling gst_poll_set_controllable()). // // New file descriptors are added to the set using gst_poll_add_fd(), and // removed using gst_poll_remove_fd(). Controlling which file descriptors // should be waited for to become readable and/or writable are done using // gst_poll_fd_ctl_read(), gst_poll_fd_ctl_write() and gst_poll_fd_ctl_pri(). // // Use gst_poll_wait() to wait for the file descriptors to actually become // readable and/or writable, or to timeout if no file descriptor is available // in time. The wait can be controlled by calling gst_poll_restart() and // gst_poll_set_flushing(). // // Once the file descriptor set has been waited for, one can use // gst_poll_fd_has_closed() to see if the file descriptor has been closed, // gst_poll_fd_has_error() to see if it has generated an error, // gst_poll_fd_can_read() to see if it is possible to read from the file // descriptor, and gst_poll_fd_can_write() to see if it is possible to // write to it. type Poll struct { *poll } // poll is the struct that's finalized type poll struct { native *C.GstPoll } // UnsafePollFromGlibBorrow is used to convert raw C.GstPoll pointers to go. This is used by the bindings internally. func UnsafePollFromGlibBorrow(p unsafe.Pointer) *Poll { return &Poll{&poll{(*C.GstPoll)(p)}} } // 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) runtime.SetFinalizer( wrapped.poll, func (intern *poll) { C.gst_poll_free(intern.native) }, ) return wrapped } // 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( wrapped.poll, func (intern *poll) { C.gst_poll_free(intern.native) }, ) return wrapped } // UnsafePollFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [Poll] is expected to work anymore. func UnsafePollFree(p *Poll) { C.gst_poll_free(p.native) } // UnsafePollToGlibNone returns the underlying C pointer. This is used by the bindings internally. func UnsafePollToGlibNone(p *Poll) unsafe.Pointer { return unsafe.Pointer(p.native) } // UnsafePollToGlibFull returns the underlying C pointer and gives up ownership. // This is used by the bindings internally. func UnsafePollToGlibFull(p *Poll) unsafe.Pointer { runtime.SetFinalizer(p.poll, nil) _p := unsafe.Pointer(p.native) p.native = nil // Poll is invalid from here on return _p } // AddFd wraps gst_poll_add_fd // // The function takes the following parameters: // // - fd *PollFD: a file descriptor. // // The function returns the following values: // // - goret bool // // Add a file descriptor to the file descriptor set. func (set *Poll) AddFd(fd *PollFD) bool { var carg0 *C.GstPoll // in, none, converted var carg1 *C.GstPollFD // in, none, converted var cret C.gboolean // return carg0 = (*C.GstPoll)(UnsafePollToGlibNone(set)) carg1 = (*C.GstPollFD)(UnsafePollFDToGlibNone(fd)) cret = C.gst_poll_add_fd(carg0, carg1) runtime.KeepAlive(set) runtime.KeepAlive(fd) var goret bool if cret != 0 { goret = true } return goret } // FdCanRead wraps gst_poll_fd_can_read // // The function takes the following parameters: // // - fd *PollFD: a file descriptor. // // The function returns the following values: // // - goret bool // // Check if @fd in @set has data to be read. func (set *Poll) FdCanRead(fd *PollFD) bool { var carg0 *C.GstPoll // in, none, converted var carg1 *C.GstPollFD // in, none, converted var cret C.gboolean // return carg0 = (*C.GstPoll)(UnsafePollToGlibNone(set)) carg1 = (*C.GstPollFD)(UnsafePollFDToGlibNone(fd)) cret = C.gst_poll_fd_can_read(carg0, carg1) runtime.KeepAlive(set) runtime.KeepAlive(fd) var goret bool if cret != 0 { goret = true } return goret } // FdCanWrite wraps gst_poll_fd_can_write // // The function takes the following parameters: // // - fd *PollFD: a file descriptor. // // The function returns the following values: // // - goret bool // // Check if @fd in @set can be used for writing. func (set *Poll) FdCanWrite(fd *PollFD) bool { var carg0 *C.GstPoll // in, none, converted var carg1 *C.GstPollFD // in, none, converted var cret C.gboolean // return carg0 = (*C.GstPoll)(UnsafePollToGlibNone(set)) carg1 = (*C.GstPollFD)(UnsafePollFDToGlibNone(fd)) cret = C.gst_poll_fd_can_write(carg0, carg1) runtime.KeepAlive(set) runtime.KeepAlive(fd) var goret bool if cret != 0 { goret = true } return goret } // FdCtlPri wraps gst_poll_fd_ctl_pri // // The function takes the following parameters: // // - fd *PollFD: a file descriptor. // - active bool: a new status. // // The function returns the following values: // // - goret bool // // Control whether the descriptor @fd in @set will be monitored for // exceptional conditions (POLLPRI). // // Not implemented on Windows (will just return %FALSE there). func (set *Poll) FdCtlPri(fd *PollFD, active bool) bool { var carg0 *C.GstPoll // in, none, converted var carg1 *C.GstPollFD // in, none, converted var carg2 C.gboolean // in var cret C.gboolean // return carg0 = (*C.GstPoll)(UnsafePollToGlibNone(set)) carg1 = (*C.GstPollFD)(UnsafePollFDToGlibNone(fd)) if active { carg2 = C.TRUE } cret = C.gst_poll_fd_ctl_pri(carg0, carg1, carg2) runtime.KeepAlive(set) runtime.KeepAlive(fd) runtime.KeepAlive(active) var goret bool if cret != 0 { goret = true } return goret } // FdCtlRead wraps gst_poll_fd_ctl_read // // The function takes the following parameters: // // - fd *PollFD: a file descriptor. // - active bool: a new status. // // The function returns the following values: // // - goret bool // // Control whether the descriptor @fd in @set will be monitored for // readability. func (set *Poll) FdCtlRead(fd *PollFD, active bool) bool { var carg0 *C.GstPoll // in, none, converted var carg1 *C.GstPollFD // in, none, converted var carg2 C.gboolean // in var cret C.gboolean // return carg0 = (*C.GstPoll)(UnsafePollToGlibNone(set)) carg1 = (*C.GstPollFD)(UnsafePollFDToGlibNone(fd)) if active { carg2 = C.TRUE } cret = C.gst_poll_fd_ctl_read(carg0, carg1, carg2) runtime.KeepAlive(set) runtime.KeepAlive(fd) runtime.KeepAlive(active) var goret bool if cret != 0 { goret = true } return goret } // FdCtlWrite wraps gst_poll_fd_ctl_write // // The function takes the following parameters: // // - fd *PollFD: a file descriptor. // - active bool: a new status. // // The function returns the following values: // // - goret bool // // Control whether the descriptor @fd in @set will be monitored for // writability. func (set *Poll) FdCtlWrite(fd *PollFD, active bool) bool { var carg0 *C.GstPoll // in, none, converted var carg1 *C.GstPollFD // in, none, converted var carg2 C.gboolean // in var cret C.gboolean // return carg0 = (*C.GstPoll)(UnsafePollToGlibNone(set)) carg1 = (*C.GstPollFD)(UnsafePollFDToGlibNone(fd)) if active { carg2 = C.TRUE } cret = C.gst_poll_fd_ctl_write(carg0, carg1, carg2) runtime.KeepAlive(set) runtime.KeepAlive(fd) runtime.KeepAlive(active) var goret bool if cret != 0 { goret = true } return goret } // FdHasClosed wraps gst_poll_fd_has_closed // // The function takes the following parameters: // // - fd *PollFD: a file descriptor. // // The function returns the following values: // // - goret bool // // Check if @fd in @set has closed the connection. func (set *Poll) FdHasClosed(fd *PollFD) bool { var carg0 *C.GstPoll // in, none, converted var carg1 *C.GstPollFD // in, none, converted var cret C.gboolean // return carg0 = (*C.GstPoll)(UnsafePollToGlibNone(set)) carg1 = (*C.GstPollFD)(UnsafePollFDToGlibNone(fd)) cret = C.gst_poll_fd_has_closed(carg0, carg1) runtime.KeepAlive(set) runtime.KeepAlive(fd) var goret bool if cret != 0 { goret = true } return goret } // FdHasError wraps gst_poll_fd_has_error // // The function takes the following parameters: // // - fd *PollFD: a file descriptor. // // The function returns the following values: // // - goret bool // // Check if @fd in @set has an error. func (set *Poll) FdHasError(fd *PollFD) bool { var carg0 *C.GstPoll // in, none, converted var carg1 *C.GstPollFD // in, none, converted var cret C.gboolean // return carg0 = (*C.GstPoll)(UnsafePollToGlibNone(set)) carg1 = (*C.GstPollFD)(UnsafePollFDToGlibNone(fd)) cret = C.gst_poll_fd_has_error(carg0, carg1) runtime.KeepAlive(set) runtime.KeepAlive(fd) var goret bool if cret != 0 { goret = true } return goret } // FdHasPri wraps gst_poll_fd_has_pri // // The function takes the following parameters: // // - fd *PollFD: a file descriptor. // // The function returns the following values: // // - goret bool // // Check if @fd in @set has an exceptional condition (POLLPRI). // // Not implemented on Windows (will just return %FALSE there). func (set *Poll) FdHasPri(fd *PollFD) bool { var carg0 *C.GstPoll // in, none, converted var carg1 *C.GstPollFD // in, none, converted var cret C.gboolean // return carg0 = (*C.GstPoll)(UnsafePollToGlibNone(set)) carg1 = (*C.GstPollFD)(UnsafePollFDToGlibNone(fd)) cret = C.gst_poll_fd_has_pri(carg0, carg1) runtime.KeepAlive(set) runtime.KeepAlive(fd) var goret bool if cret != 0 { goret = true } return goret } // FdIgnored wraps gst_poll_fd_ignored // // The function takes the following parameters: // // - fd *PollFD: a file descriptor. // // Mark @fd as ignored so that the next call to gst_poll_wait() will yield // the same result for @fd as last time. This function must be called if no // operation (read/write/recv/send/etc.) will be performed on @fd before // the next call to gst_poll_wait(). // // The reason why this is needed is because the underlying implementation // might not allow querying the fd more than once between calls to one of // the re-enabling operations. func (set *Poll) FdIgnored(fd *PollFD) { var carg0 *C.GstPoll // in, none, converted var carg1 *C.GstPollFD // in, none, converted carg0 = (*C.GstPoll)(UnsafePollToGlibNone(set)) carg1 = (*C.GstPollFD)(UnsafePollFDToGlibNone(fd)) C.gst_poll_fd_ignored(carg0, carg1) runtime.KeepAlive(set) runtime.KeepAlive(fd) } // GetReadGpollfd wraps gst_poll_get_read_gpollfd // // The function takes the following parameters: // // - fd *glib.PollFD: a #GPollFD // // Get a GPollFD for the reading part of the control socket. This is useful when // integrating with a GSource and GMainLoop. func (set *Poll) GetReadGpollfd(fd *glib.PollFD) { var carg0 *C.GstPoll // in, none, converted var carg1 *C.GPollFD // in, none, converted carg0 = (*C.GstPoll)(UnsafePollToGlibNone(set)) carg1 = (*C.GPollFD)(glib.UnsafePollFDToGlibNone(fd)) C.gst_poll_get_read_gpollfd(carg0, carg1) runtime.KeepAlive(set) runtime.KeepAlive(fd) } // ReadControl wraps gst_poll_read_control // // The function returns the following values: // // - goret bool // // Read a byte from the control socket of the controllable @set. // // This function only works for timer #GstPoll objects created with // gst_poll_new_timer(). func (set *Poll) ReadControl() bool { var carg0 *C.GstPoll // in, none, converted var cret C.gboolean // return carg0 = (*C.GstPoll)(UnsafePollToGlibNone(set)) cret = C.gst_poll_read_control(carg0) runtime.KeepAlive(set) var goret bool if cret != 0 { goret = true } return goret } // RemoveFd wraps gst_poll_remove_fd // // The function takes the following parameters: // // - fd *PollFD: a file descriptor. // // The function returns the following values: // // - goret bool // // Remove a file descriptor from the file descriptor set. func (set *Poll) RemoveFd(fd *PollFD) bool { var carg0 *C.GstPoll // in, none, converted var carg1 *C.GstPollFD // in, none, converted var cret C.gboolean // return carg0 = (*C.GstPoll)(UnsafePollToGlibNone(set)) carg1 = (*C.GstPollFD)(UnsafePollFDToGlibNone(fd)) cret = C.gst_poll_remove_fd(carg0, carg1) runtime.KeepAlive(set) runtime.KeepAlive(fd) var goret bool if cret != 0 { goret = true } return goret } // Restart wraps gst_poll_restart // // Restart any gst_poll_wait() that is in progress. This function is typically // used after adding or removing descriptors to @set. // // If @set is not controllable, then this call will have no effect. // // This function only works for non-timer #GstPoll objects created with // gst_poll_new(). func (set *Poll) Restart() { var carg0 *C.GstPoll // in, none, converted carg0 = (*C.GstPoll)(UnsafePollToGlibNone(set)) C.gst_poll_restart(carg0) runtime.KeepAlive(set) } // SetControllable wraps gst_poll_set_controllable // // The function takes the following parameters: // // - controllable bool: new controllable state. // // The function returns the following values: // // - goret bool // // When @controllable is %TRUE, this function ensures that future calls to // gst_poll_wait() will be affected by gst_poll_restart() and // gst_poll_set_flushing(). // // This function only works for non-timer #GstPoll objects created with // gst_poll_new(). func (set *Poll) SetControllable(controllable bool) bool { var carg0 *C.GstPoll // in, none, converted var carg1 C.gboolean // in var cret C.gboolean // return carg0 = (*C.GstPoll)(UnsafePollToGlibNone(set)) if controllable { carg1 = C.TRUE } cret = C.gst_poll_set_controllable(carg0, carg1) runtime.KeepAlive(set) runtime.KeepAlive(controllable) var goret bool if cret != 0 { goret = true } return goret } // SetFlushing wraps gst_poll_set_flushing // // The function takes the following parameters: // // - flushing bool: new flushing state. // // When @flushing is %TRUE, this function ensures that current and future calls // to gst_poll_wait() will return -1, with errno set to EBUSY. // // Unsetting the flushing state will restore normal operation of @set. // // This function only works for non-timer #GstPoll objects created with // gst_poll_new(). func (set *Poll) SetFlushing(flushing bool) { var carg0 *C.GstPoll // in, none, converted var carg1 C.gboolean // in carg0 = (*C.GstPoll)(UnsafePollToGlibNone(set)) if flushing { carg1 = C.TRUE } C.gst_poll_set_flushing(carg0, carg1) runtime.KeepAlive(set) runtime.KeepAlive(flushing) } // Wait wraps gst_poll_wait // // The function takes the following parameters: // // - timeout ClockTime: a timeout in nanoseconds. // // The function returns the following values: // // - goret int // // Wait for activity on the file descriptors in @set. This function waits up to // the specified @timeout. A timeout of #GST_CLOCK_TIME_NONE waits forever. // // For #GstPoll objects created with gst_poll_new(), this function can only be // called from a single thread at a time. If called from multiple threads, // -1 will be returned with errno set to EPERM. // // This is not true for timer #GstPoll objects created with // gst_poll_new_timer(), where it is allowed to have multiple threads waiting // simultaneously. func (set *Poll) Wait(timeout ClockTime) int { var carg0 *C.GstPoll // in, none, converted var carg1 C.GstClockTime // in, none, casted, alias var cret C.gint // return, none, casted carg0 = (*C.GstPoll)(UnsafePollToGlibNone(set)) carg1 = C.GstClockTime(timeout) cret = C.gst_poll_wait(carg0, carg1) runtime.KeepAlive(set) runtime.KeepAlive(timeout) var goret int goret = int(cret) return goret } // WriteControl wraps gst_poll_write_control // // The function returns the following values: // // - goret bool // // Write a byte to the control socket of the controllable @set. // This function is mostly useful for timer #GstPoll objects created with // gst_poll_new_timer(). // // It will make any current and future gst_poll_wait() function return with // 1, meaning the control socket is set. After an equal amount of calls to // gst_poll_read_control() have been performed, calls to gst_poll_wait() will // block again until their timeout expired. // // This function only works for timer #GstPoll objects created with // gst_poll_new_timer(). func (set *Poll) WriteControl() bool { var carg0 *C.GstPoll // in, none, converted var cret C.gboolean // return carg0 = (*C.GstPoll)(UnsafePollToGlibNone(set)) cret = C.gst_poll_write_control(carg0) runtime.KeepAlive(set) var goret bool if cret != 0 { goret = true } return goret } // PollFD wraps GstPollFD // // A file descriptor object. type PollFD struct { *pollFD } // pollFD is the struct that's finalized type pollFD struct { native *C.GstPollFD } // UnsafePollFDFromGlibBorrow is used to convert raw C.GstPollFD pointers to go. This is used by the bindings internally. func UnsafePollFDFromGlibBorrow(p unsafe.Pointer) *PollFD { return &PollFD{&pollFD{(*C.GstPollFD)(p)}} } // 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) runtime.SetFinalizer( wrapped.pollFD, func (intern *pollFD) { C.free(unsafe.Pointer(intern.native)) }, ) return wrapped } // 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( wrapped.pollFD, func (intern *pollFD) { C.free(unsafe.Pointer(intern.native)) }, ) return wrapped } // UnsafePollFDFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [PollFD] is expected to work anymore. func UnsafePollFDFree(p *PollFD) { C.free(unsafe.Pointer(p.native)) } // UnsafePollFDToGlibNone returns the underlying C pointer. This is used by the bindings internally. func UnsafePollFDToGlibNone(p *PollFD) unsafe.Pointer { return unsafe.Pointer(p.native) } // UnsafePollFDToGlibFull returns the underlying C pointer and gives up ownership. // This is used by the bindings internally. func UnsafePollFDToGlibFull(p *PollFD) unsafe.Pointer { runtime.SetFinalizer(p.pollFD, nil) _p := unsafe.Pointer(p.native) 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 // #GST_POLL_FD_INIT. func (fd *PollFD) Init() { var carg0 *C.GstPollFD // in, none, converted carg0 = (*C.GstPollFD)(UnsafePollFDToGlibNone(fd)) C.gst_poll_fd_init(carg0) runtime.KeepAlive(fd) } // PresetInterface wraps GstPresetInterface // // #GstPreset interface. type PresetInterface struct { *presetInterface } // presetInterface is the struct that's finalized type presetInterface struct { native *C.GstPresetInterface } // UnsafePresetInterfaceFromGlibBorrow is used to convert raw C.GstPresetInterface pointers to go. This is used by the bindings internally. func UnsafePresetInterfaceFromGlibBorrow(p unsafe.Pointer) *PresetInterface { return &PresetInterface{&presetInterface{(*C.GstPresetInterface)(p)}} } // 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) runtime.SetFinalizer( wrapped.presetInterface, func (intern *presetInterface) { C.free(unsafe.Pointer(intern.native)) }, ) return wrapped } // 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( wrapped.presetInterface, func (intern *presetInterface) { C.free(unsafe.Pointer(intern.native)) }, ) return wrapped } // UnsafePresetInterfaceFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [PresetInterface] is expected to work anymore. func UnsafePresetInterfaceFree(p *PresetInterface) { C.free(unsafe.Pointer(p.native)) } // UnsafePresetInterfaceToGlibNone returns the underlying C pointer. This is used by the bindings internally. func UnsafePresetInterfaceToGlibNone(p *PresetInterface) unsafe.Pointer { return unsafe.Pointer(p.native) } // UnsafePresetInterfaceToGlibFull returns the underlying C pointer and gives up ownership. // This is used by the bindings internally. func UnsafePresetInterfaceToGlibFull(p *PresetInterface) unsafe.Pointer { runtime.SetFinalizer(p.presetInterface, nil) _p := unsafe.Pointer(p.native) p.native = nil // PresetInterface is invalid from here on return _p } // Promise wraps GstPromise // // The #GstPromise object implements the container for values that may // be available later. i.e. a Future or a Promise in // <https://en.wikipedia.org/wiki/Futures_and_promises>. // As with all Future/Promise-like functionality, there is the concept of the // producer of the value and the consumer of the value. // // A #GstPromise is created with gst_promise_new() by the consumer and passed // to the producer to avoid thread safety issues with the change callback. // A #GstPromise can be replied to with a value (or an error) by the producer // with gst_promise_reply(). The exact value returned is defined by the API // contract of the producer and %NULL may be a valid reply. // gst_promise_interrupt() is for the consumer to // indicate to the producer that the value is not needed anymore and producing // that value can stop. The @GST_PROMISE_RESULT_EXPIRED state set by a call // to gst_promise_expire() indicates to the consumer that a value will never // be produced and is intended to be called by a third party that implements // some notion of message handling such as #GstBus. // A callback can also be installed at #GstPromise creation for // result changes with gst_promise_new_with_change_func(). // The change callback can be used to chain #GstPromises's together as in the // following example. // |[<!-- language="C" --> // const GstStructure *reply; // GstPromise *p; // if (gst_promise_wait (promise) != GST_PROMISE_RESULT_REPLIED) // return; // interrupted or expired value // reply = gst_promise_get_reply (promise); // if (error in reply) // return; // propagate error // p = gst_promise_new_with_change_func (another_promise_change_func, user_data, notify); // pass p to promise-using API // ]| // // Each #GstPromise starts out with a #GstPromiseResult of // %GST_PROMISE_RESULT_PENDING and only ever transitions once // into one of the other #GstPromiseResult's. // // In order to support multi-threaded code, gst_promise_reply(), // gst_promise_interrupt() and gst_promise_expire() may all be from // different threads with some restrictions and the final result of the promise // is whichever call is made first. There are two restrictions on ordering: // // 1. That gst_promise_reply() and gst_promise_interrupt() cannot be called // after gst_promise_expire() // 2. That gst_promise_reply() and gst_promise_interrupt() // cannot be called twice. // // The change function set with gst_promise_new_with_change_func() is // called directly from either the gst_promise_reply(), // gst_promise_interrupt() or gst_promise_expire() and can be called // from an arbitrary thread. #GstPromise using APIs can restrict this to // a single thread or a subset of threads but that is entirely up to the API // that uses #GstPromise. type Promise struct { *promise } // promise is the struct that's finalized type promise struct { native *C.GstPromise } var _ gobject.GoValueInitializer = (*Promise)(nil) func marshalPromise(p unsafe.Pointer) (interface{}, error) { b := gobject.ValueFromNative(p).Boxed() return UnsafePromiseFromGlibBorrow(b), nil } func (r *Promise) InitGoValue(v *gobject.Value) { v.Init(TypePromise) v.SetBoxed(unsafe.Pointer(r.native)) } // UnsafePromiseFromGlibBorrow is used to convert raw C.GstPromise pointers to go. This is used by the bindings internally. func UnsafePromiseFromGlibBorrow(p unsafe.Pointer) *Promise { return &Promise{&promise{(*C.GstPromise)(p)}} } // 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) runtime.SetFinalizer( wrapped.promise, func (intern *promise) { C.free(unsafe.Pointer(intern.native)) }, ) return wrapped } // 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( wrapped.promise, func (intern *promise) { C.free(unsafe.Pointer(intern.native)) }, ) return wrapped } // UnsafePromiseFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [Promise] is expected to work anymore. func UnsafePromiseFree(p *Promise) { C.free(unsafe.Pointer(p.native)) } // UnsafePromiseToGlibNone returns the underlying C pointer. This is used by the bindings internally. func UnsafePromiseToGlibNone(p *Promise) unsafe.Pointer { return unsafe.Pointer(p.native) } // UnsafePromiseToGlibFull returns the underlying C pointer and gives up ownership. // This is used by the bindings internally. func UnsafePromiseToGlibFull(p *Promise) unsafe.Pointer { runtime.SetFinalizer(p.promise, nil) _p := unsafe.Pointer(p.native) p.native = nil // Promise is invalid from here on return _p } // NewPromise wraps gst_promise_new // // The function returns the following values: // // - goret *Promise func NewPromise() *Promise { var cret *C.GstPromise // return, full, converted cret = C.gst_promise_new() var goret *Promise goret = UnsafePromiseFromGlibFull(unsafe.Pointer(cret)) return goret } // NewPromiseWithChangeFunc wraps gst_promise_new_with_change_func // // The function takes the following parameters: // // - fn PromiseChangeFunc: a #GstPromiseChangeFunc to call // // The function returns the following values: // // - goret *Promise // // @func will be called exactly once when transitioning out of // %GST_PROMISE_RESULT_PENDING into any of the other #GstPromiseResult // states. func NewPromiseWithChangeFunc(fn PromiseChangeFunc) *Promise { var carg1 C.GstPromiseChangeFunc // callback, scope: notified, closure: carg2, destroy: carg3 var carg2 C.gpointer // implicit var carg3 C.GDestroyNotify // implicit var cret *C.GstPromise // return, full, converted carg1 = (*[0]byte)(C._gotk4_gst1_PromiseChangeFunc) carg2 = C.gpointer(userdata.Register(fn)) carg3 = (C.GDestroyNotify)((*[0]byte)(C.destroyUserdata)) cret = C.gst_promise_new_with_change_func(carg1, carg2, carg3) runtime.KeepAlive(fn) var goret *Promise goret = UnsafePromiseFromGlibFull(unsafe.Pointer(cret)) return goret } // Expire wraps gst_promise_expire // // Expire a @promise. This will wake up any waiters with // %GST_PROMISE_RESULT_EXPIRED. Called by a message loop when the parent // message is handled and/or destroyed (possibly unanswered). func (promise *Promise) Expire() { var carg0 *C.GstPromise // in, none, converted carg0 = (*C.GstPromise)(UnsafePromiseToGlibNone(promise)) C.gst_promise_expire(carg0) runtime.KeepAlive(promise) } // GetReply wraps gst_promise_get_reply // // The function returns the following values: // // - goret *Structure (nullable) // // Retrieve the reply set on @promise. @promise must be in // %GST_PROMISE_RESULT_REPLIED and the returned structure is owned by @promise func (promise *Promise) GetReply() *Structure { var carg0 *C.GstPromise // in, none, converted var cret *C.GstStructure // return, none, converted, nullable carg0 = (*C.GstPromise)(UnsafePromiseToGlibNone(promise)) cret = C.gst_promise_get_reply(carg0) runtime.KeepAlive(promise) var goret *Structure if cret != nil { goret = UnsafeStructureFromGlibNone(unsafe.Pointer(cret)) } return goret } // Interrupt wraps gst_promise_interrupt // // Interrupt waiting for a @promise. This will wake up any waiters with // %GST_PROMISE_RESULT_INTERRUPTED. Called when the consumer does not want // the value produced anymore. func (promise *Promise) Interrupt() { var carg0 *C.GstPromise // in, none, converted carg0 = (*C.GstPromise)(UnsafePromiseToGlibNone(promise)) C.gst_promise_interrupt(carg0) runtime.KeepAlive(promise) } // Reply wraps gst_promise_reply // // The function takes the following parameters: // // - s *Structure (nullable): a #GstStructure with the the reply contents // // Set a reply on @promise. This will wake up any waiters with // %GST_PROMISE_RESULT_REPLIED. Called by the producer of the value to // indicate success (or failure). // // If @promise has already been interrupted by the consumer, then this reply // is not visible to the consumer. func (promise *Promise) Reply(s *Structure) { var carg0 *C.GstPromise // in, none, converted var carg1 *C.GstStructure // in, full, converted, nullable carg0 = (*C.GstPromise)(UnsafePromiseToGlibNone(promise)) if s != nil { carg1 = (*C.GstStructure)(UnsafeStructureToGlibFull(s)) } C.gst_promise_reply(carg0, carg1) runtime.KeepAlive(promise) runtime.KeepAlive(s) } // Wait wraps gst_promise_wait // // The function returns the following values: // // - goret PromiseResult // // Wait for @promise to move out of the %GST_PROMISE_RESULT_PENDING state. // If @promise is not in %GST_PROMISE_RESULT_PENDING then it will return // immediately with the current result. func (promise *Promise) Wait() PromiseResult { var carg0 *C.GstPromise // in, none, converted var cret C.GstPromiseResult // return, none, casted carg0 = (*C.GstPromise)(UnsafePromiseToGlibNone(promise)) cret = C.gst_promise_wait(carg0) runtime.KeepAlive(promise) var goret PromiseResult goret = PromiseResult(cret) return goret } // ProtectionMeta wraps GstProtectionMeta // // Metadata type that holds information about a sample from a protection-protected // track, including the information needed to decrypt it (if it is encrypted). type ProtectionMeta struct { *protectionMeta } // protectionMeta is the struct that's finalized type protectionMeta struct { native *C.GstProtectionMeta } // UnsafeProtectionMetaFromGlibBorrow is used to convert raw C.GstProtectionMeta pointers to go. This is used by the bindings internally. func UnsafeProtectionMetaFromGlibBorrow(p unsafe.Pointer) *ProtectionMeta { return &ProtectionMeta{&protectionMeta{(*C.GstProtectionMeta)(p)}} } // 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) runtime.SetFinalizer( wrapped.protectionMeta, func (intern *protectionMeta) { C.free(unsafe.Pointer(intern.native)) }, ) return wrapped } // 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( wrapped.protectionMeta, func (intern *protectionMeta) { C.free(unsafe.Pointer(intern.native)) }, ) return wrapped } // UnsafeProtectionMetaFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [ProtectionMeta] is expected to work anymore. func UnsafeProtectionMetaFree(p *ProtectionMeta) { C.free(unsafe.Pointer(p.native)) } // UnsafeProtectionMetaToGlibNone returns the underlying C pointer. This is used by the bindings internally. func UnsafeProtectionMetaToGlibNone(p *ProtectionMeta) unsafe.Pointer { return unsafe.Pointer(p.native) } // UnsafeProtectionMetaToGlibFull returns the underlying C pointer and gives up ownership. // This is used by the bindings internally. func UnsafeProtectionMetaToGlibFull(p *ProtectionMeta) unsafe.Pointer { runtime.SetFinalizer(p.protectionMeta, nil) _p := unsafe.Pointer(p.native) 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 func ProtectionMetaGetInfo() *MetaInfo { var cret *C.GstMetaInfo // return, none, converted cret = C.gst_protection_meta_get_info() var goret *MetaInfo goret = UnsafeMetaInfoFromGlibNone(unsafe.Pointer(cret)) return goret } // ProxyPadClass wraps GstProxyPadClass // // ProxyPadClass is the type struct for [ProxyPad] type ProxyPadClass struct { *proxyPadClass } // proxyPadClass is the struct that's finalized type proxyPadClass struct { native *C.GstProxyPadClass } // UnsafeProxyPadClassFromGlibBorrow is used to convert raw C.GstProxyPadClass pointers to go. This is used by the bindings internally. func UnsafeProxyPadClassFromGlibBorrow(p unsafe.Pointer) *ProxyPadClass { return &ProxyPadClass{&proxyPadClass{(*C.GstProxyPadClass)(p)}} } // 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. func UnsafeProxyPadClassFree(p *ProxyPadClass) { C.free(unsafe.Pointer(p.native)) } // UnsafeProxyPadClassToGlibNone returns the underlying C pointer. This is used by the bindings internally. func UnsafeProxyPadClassToGlibNone(p *ProxyPadClass) unsafe.Pointer { return unsafe.Pointer(p.native) } // 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 // (gst_element_query()). Please note that some queries might need a running // pipeline to work. // // Queries can be created using the gst_query_new_*() functions. // Query values can be set using gst_query_set_*(), and parsed using // gst_query_parse_*() helpers. // // The following example shows how to query the duration of a pipeline: // |[<!-- language="C" --> // GstQuery *query; // gboolean res; // query = gst_query_new_duration (GST_FORMAT_TIME); // res = gst_element_query (pipeline, query); // if (res) { // gint64 duration; // gst_query_parse_duration (query, NULL, &duration); // g_print ("duration = %"GST_TIME_FORMAT, GST_TIME_ARGS (duration)); // } else { // g_print ("duration query failed..."); // } // gst_query_unref (query); // ]| type Query struct { *query } // query is the struct that's finalized type query struct { native *C.GstQuery } var _ gobject.GoValueInitializer = (*Query)(nil) func marshalQuery(p unsafe.Pointer) (interface{}, error) { b := gobject.ValueFromNative(p).Boxed() return UnsafeQueryFromGlibBorrow(b), nil } func (r *Query) InitGoValue(v *gobject.Value) { v.Init(TypeQuery) v.SetBoxed(unsafe.Pointer(r.native)) } // UnsafeQueryFromGlibBorrow is used to convert raw C.GstQuery pointers to go. This is used by the bindings internally. func UnsafeQueryFromGlibBorrow(p unsafe.Pointer) *Query { return &Query{&query{(*C.GstQuery)(p)}} } // 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) runtime.SetFinalizer( wrapped.query, func (intern *query) { C.free(unsafe.Pointer(intern.native)) }, ) return wrapped } // 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( wrapped.query, func (intern *query) { C.free(unsafe.Pointer(intern.native)) }, ) return wrapped } // UnsafeQueryFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [Query] is expected to work anymore. func UnsafeQueryFree(q *Query) { C.free(unsafe.Pointer(q.native)) } // UnsafeQueryToGlibNone returns the underlying C pointer. This is used by the bindings internally. func UnsafeQueryToGlibNone(q *Query) unsafe.Pointer { return unsafe.Pointer(q.native) } // UnsafeQueryToGlibFull returns the underlying C pointer and gives up ownership. // This is used by the bindings internally. func UnsafeQueryToGlibFull(q *Query) unsafe.Pointer { runtime.SetFinalizer(q.query, nil) _p := unsafe.Pointer(q.native) q.native = nil // Query is invalid from here on return _p } // NewQueryAcceptCaps wraps gst_query_new_accept_caps // // The function takes the following parameters: // // - caps *Caps: a fixed #GstCaps // // The function returns the following values: // // - goret *Query // // Constructs a new query object for querying if @caps are accepted. // // Free-function: gst_query_unref() func NewQueryAcceptCaps(caps *Caps) *Query { var carg1 *C.GstCaps // in, none, converted var cret *C.GstQuery // return, full, converted carg1 = (*C.GstCaps)(UnsafeCapsToGlibNone(caps)) cret = C.gst_query_new_accept_caps(carg1) runtime.KeepAlive(caps) var goret *Query goret = UnsafeQueryFromGlibFull(unsafe.Pointer(cret)) return goret } // NewQueryAllocation wraps gst_query_new_allocation // // The function takes the following parameters: // // - caps *Caps (nullable): the negotiated caps // - needPool bool: return a pool // // The function returns the following values: // // - goret *Query // // Constructs a new query object for querying the allocation properties. // // Free-function: gst_query_unref() func NewQueryAllocation(caps *Caps, needPool bool) *Query { var carg1 *C.GstCaps // in, none, converted, nullable var carg2 C.gboolean // in var cret *C.GstQuery // return, full, converted if caps != nil { carg1 = (*C.GstCaps)(UnsafeCapsToGlibNone(caps)) } if needPool { carg2 = C.TRUE } cret = C.gst_query_new_allocation(carg1, carg2) runtime.KeepAlive(caps) runtime.KeepAlive(needPool) var goret *Query goret = UnsafeQueryFromGlibFull(unsafe.Pointer(cret)) return goret } // NewQueryBitrate wraps gst_query_new_bitrate // // The function returns the following values: // // - goret *Query // // Constructs a new query object for querying the bitrate. // // Free-function: gst_query_unref() func NewQueryBitrate() *Query { var cret *C.GstQuery // return, full, converted cret = C.gst_query_new_bitrate() var goret *Query goret = UnsafeQueryFromGlibFull(unsafe.Pointer(cret)) return goret } // NewQueryBuffering wraps gst_query_new_buffering // // The function takes the following parameters: // // - format Format: the default #GstFormat for the new query // // The function returns the following values: // // - goret *Query // // Constructs a new query object for querying the buffering status of // a stream. // // Free-function: gst_query_unref() func NewQueryBuffering(format Format) *Query { var carg1 C.GstFormat // in, none, casted var cret *C.GstQuery // return, full, converted carg1 = C.GstFormat(format) cret = C.gst_query_new_buffering(carg1) runtime.KeepAlive(format) var goret *Query goret = UnsafeQueryFromGlibFull(unsafe.Pointer(cret)) return goret } // NewQueryCaps wraps gst_query_new_caps // // The function takes the following parameters: // // - filter *Caps: a filter // // The function returns the following values: // // - goret *Query // // Constructs a new query object for querying the caps. // // The CAPS query should return the allowable caps for a pad in the context // of the element's state, its link to other elements, and the devices or files // it has opened. These caps must be a subset of the pad template caps. In the // NULL state with no links, the CAPS query should ideally return the same caps // as the pad template. In rare circumstances, an object property can affect // the caps returned by the CAPS query, but this is discouraged. // // For most filters, the caps returned by CAPS query is directly affected by the // allowed caps on other pads. For demuxers and decoders, the caps returned by // the srcpad's getcaps function is directly related to the stream data. Again, // the CAPS query should return the most specific caps it reasonably can, since this // helps with autoplugging. // // The @filter is used to restrict the result caps, only the caps matching // @filter should be returned from the CAPS query. Specifying a filter might // greatly reduce the amount of processing an element needs to do. // // Free-function: gst_query_unref() func NewQueryCaps(filter *Caps) *Query { var carg1 *C.GstCaps // in, none, converted var cret *C.GstQuery // return, full, converted carg1 = (*C.GstCaps)(UnsafeCapsToGlibNone(filter)) cret = C.gst_query_new_caps(carg1) runtime.KeepAlive(filter) var goret *Query goret = UnsafeQueryFromGlibFull(unsafe.Pointer(cret)) return goret } // NewQueryContext wraps gst_query_new_context // // The function takes the following parameters: // // - contextType string: Context type to query // // The function returns the following values: // // - goret *Query // // Constructs a new query object for querying the pipeline-local context. // // Free-function: gst_query_unref() func NewQueryContext(contextType string) *Query { var carg1 *C.gchar // in, none, string var cret *C.GstQuery // return, full, converted carg1 = (*C.gchar)(unsafe.Pointer(C.CString(contextType))) defer C.free(unsafe.Pointer(carg1)) cret = C.gst_query_new_context(carg1) runtime.KeepAlive(contextType) var goret *Query goret = UnsafeQueryFromGlibFull(unsafe.Pointer(cret)) return goret } // NewQueryConvert wraps gst_query_new_convert // // The function takes the following parameters: // // - srcFormat Format: the source #GstFormat for the new query // - value int64: the value to convert // - destFormat Format: the target #GstFormat // // The function returns the following values: // // - goret *Query // // Constructs a new convert query object. Use gst_query_unref() // when done with it. A convert query is used to ask for a conversion between // one format and another. // // Free-function: gst_query_unref() func NewQueryConvert(srcFormat Format, value int64, destFormat Format) *Query { var carg1 C.GstFormat // in, none, casted var carg2 C.gint64 // in, none, casted var carg3 C.GstFormat // in, none, casted var cret *C.GstQuery // return, full, converted carg1 = C.GstFormat(srcFormat) carg2 = C.gint64(value) carg3 = C.GstFormat(destFormat) cret = C.gst_query_new_convert(carg1, carg2, carg3) runtime.KeepAlive(srcFormat) runtime.KeepAlive(value) runtime.KeepAlive(destFormat) var goret *Query goret = UnsafeQueryFromGlibFull(unsafe.Pointer(cret)) return goret } // NewQueryCustom wraps gst_query_new_custom // // The function takes the following parameters: // // - typ QueryType: the query type // - structure *Structure (nullable): a structure for the query // // The function returns the following values: // // - goret *Query // // Constructs a new custom query object. Use gst_query_unref() // when done with it. // // Free-function: gst_query_unref() func NewQueryCustom(typ QueryType, structure *Structure) *Query { var carg1 C.GstQueryType // in, none, casted var carg2 *C.GstStructure // in, full, converted, nullable var cret *C.GstQuery // return, full, converted carg1 = C.GstQueryType(typ) if structure != nil { carg2 = (*C.GstStructure)(UnsafeStructureToGlibFull(structure)) } cret = C.gst_query_new_custom(carg1, carg2) runtime.KeepAlive(typ) runtime.KeepAlive(structure) var goret *Query goret = UnsafeQueryFromGlibFull(unsafe.Pointer(cret)) return goret } // NewQueryDrain wraps gst_query_new_drain // // The function returns the following values: // // - goret *Query // // Constructs a new query object for querying the drain state. // // Free-function: gst_query_unref() func NewQueryDrain() *Query { var cret *C.GstQuery // return, full, converted cret = C.gst_query_new_drain() var goret *Query goret = UnsafeQueryFromGlibFull(unsafe.Pointer(cret)) return goret } // NewQueryDuration wraps gst_query_new_duration // // The function takes the following parameters: // // - format Format: the #GstFormat for this duration query // // The function returns the following values: // // - goret *Query // // Constructs a new stream duration query object to query in the given format. // Use gst_query_unref() when done with it. A duration query will give the // total length of the stream. // // Free-function: gst_query_unref() func NewQueryDuration(format Format) *Query { var carg1 C.GstFormat // in, none, casted var cret *C.GstQuery // return, full, converted carg1 = C.GstFormat(format) cret = C.gst_query_new_duration(carg1) runtime.KeepAlive(format) var goret *Query goret = UnsafeQueryFromGlibFull(unsafe.Pointer(cret)) return goret } // NewQueryFormats wraps gst_query_new_formats // // The function returns the following values: // // - goret *Query // // Constructs a new query object for querying formats of // the stream. // // Free-function: gst_query_unref() func NewQueryFormats() *Query { var cret *C.GstQuery // return, full, converted cret = C.gst_query_new_formats() var goret *Query goret = UnsafeQueryFromGlibFull(unsafe.Pointer(cret)) return goret } // NewQueryLatency wraps gst_query_new_latency // // The function returns the following values: // // - goret *Query // // Constructs a new latency query object. // Use gst_query_unref() when done with it. A latency query is usually performed // by sinks to compensate for additional latency introduced by elements in the // pipeline. // // Free-function: gst_query_unref() func NewQueryLatency() *Query { var cret *C.GstQuery // return, full, converted cret = C.gst_query_new_latency() var goret *Query goret = UnsafeQueryFromGlibFull(unsafe.Pointer(cret)) return goret } // NewQueryPosition wraps gst_query_new_position // // The function takes the following parameters: // // - format Format: the default #GstFormat for the new query // // The function returns the following values: // // - goret *Query // // Constructs a new query stream position query object. Use gst_query_unref() // when done with it. A position query is used to query the current position // of playback in the streams, in some format. // // Free-function: gst_query_unref() func NewQueryPosition(format Format) *Query { var carg1 C.GstFormat // in, none, casted var cret *C.GstQuery // return, full, converted carg1 = C.GstFormat(format) cret = C.gst_query_new_position(carg1) runtime.KeepAlive(format) var goret *Query goret = UnsafeQueryFromGlibFull(unsafe.Pointer(cret)) return goret } // NewQueryScheduling wraps gst_query_new_scheduling // // The function returns the following values: // // - goret *Query // // Constructs a new query object for querying the scheduling properties. // // Free-function: gst_query_unref() func NewQueryScheduling() *Query { var cret *C.GstQuery // return, full, converted cret = C.gst_query_new_scheduling() var goret *Query goret = UnsafeQueryFromGlibFull(unsafe.Pointer(cret)) return goret } // NewQuerySeeking wraps gst_query_new_seeking // // The function takes the following parameters: // // - format Format: the default #GstFormat for the new query // // The function returns the following values: // // - goret *Query // // Constructs a new query object for querying seeking properties of // the stream. // // Free-function: gst_query_unref() func NewQuerySeeking(format Format) *Query { var carg1 C.GstFormat // in, none, casted var cret *C.GstQuery // return, full, converted carg1 = C.GstFormat(format) cret = C.gst_query_new_seeking(carg1) runtime.KeepAlive(format) var goret *Query goret = UnsafeQueryFromGlibFull(unsafe.Pointer(cret)) return goret } // NewQuerySegment wraps gst_query_new_segment // // The function takes the following parameters: // // - format Format: the #GstFormat for the new query // // The function returns the following values: // // - goret *Query // // Constructs a new segment query object. Use gst_query_unref() // when done with it. A segment query is used to discover information about the // currently configured segment for playback. // // Free-function: gst_query_unref() func NewQuerySegment(format Format) *Query { var carg1 C.GstFormat // in, none, casted var cret *C.GstQuery // return, full, converted carg1 = C.GstFormat(format) cret = C.gst_query_new_segment(carg1) runtime.KeepAlive(format) var goret *Query goret = UnsafeQueryFromGlibFull(unsafe.Pointer(cret)) return goret } // NewQuerySelectable wraps gst_query_new_selectable // // The function returns the following values: // // - goret *Query // // Constructs a new query object for querying the stream selection capability. // // Free-function: gst_query_unref() func NewQuerySelectable() *Query { var cret *C.GstQuery // return, full, converted cret = C.gst_query_new_selectable() var goret *Query goret = UnsafeQueryFromGlibFull(unsafe.Pointer(cret)) return goret } // NewQueryURI wraps gst_query_new_uri // // The function returns the following values: // // - goret *Query // // Constructs a new query URI query object. Use gst_query_unref() // when done with it. An URI query is used to query the current URI // that is used by the source or sink. // // Free-function: gst_query_unref() func NewQueryURI() *Query { var cret *C.GstQuery // return, full, converted cret = C.gst_query_new_uri() var goret *Query goret = UnsafeQueryFromGlibFull(unsafe.Pointer(cret)) return goret } // AddAllocationMeta wraps gst_query_add_allocation_meta // // The function takes the following parameters: // // - api gobject.Type: the metadata API // - params *Structure (nullable): API specific parameters // // Add @api with @params as one of the supported metadata API to @query. func (query *Query) AddAllocationMeta(api gobject.Type, params *Structure) { var carg0 *C.GstQuery // in, none, converted var carg1 C.GType // in, none, casted, alias var carg2 *C.GstStructure // in, none, converted, nullable carg0 = (*C.GstQuery)(UnsafeQueryToGlibNone(query)) carg1 = C.GType(api) if params != nil { carg2 = (*C.GstStructure)(UnsafeStructureToGlibNone(params)) } C.gst_query_add_allocation_meta(carg0, carg1, carg2) runtime.KeepAlive(query) runtime.KeepAlive(api) runtime.KeepAlive(params) } // AddAllocationParam wraps gst_query_add_allocation_param // // The function takes the following parameters: // // - allocator Allocator (nullable): the memory allocator // - params *AllocationParams (nullable): a #GstAllocationParams // // Add @allocator and its @params as a supported memory allocator. func (query *Query) AddAllocationParam(allocator Allocator, params *AllocationParams) { var carg0 *C.GstQuery // in, none, converted var carg1 *C.GstAllocator // in, none, converted, nullable var carg2 *C.GstAllocationParams // in, none, converted, nullable carg0 = (*C.GstQuery)(UnsafeQueryToGlibNone(query)) if allocator != nil { carg1 = (*C.GstAllocator)(UnsafeAllocatorToGlibNone(allocator)) } if params != nil { carg2 = (*C.GstAllocationParams)(UnsafeAllocationParamsToGlibNone(params)) } C.gst_query_add_allocation_param(carg0, carg1, carg2) runtime.KeepAlive(query) runtime.KeepAlive(allocator) runtime.KeepAlive(params) } // AddAllocationPool wraps gst_query_add_allocation_pool // // The function takes the following parameters: // // - pool BufferPool (nullable): the #GstBufferPool // - size uint: the buffer size // - minBuffers uint: the min buffers // - maxBuffers uint: the max buffers // // Set the pool parameters in @query. func (query *Query) AddAllocationPool(pool BufferPool, size uint, minBuffers uint, maxBuffers uint) { var carg0 *C.GstQuery // in, none, converted var carg1 *C.GstBufferPool // in, none, converted, nullable var carg2 C.guint // in, none, casted var carg3 C.guint // in, none, casted var carg4 C.guint // in, none, casted carg0 = (*C.GstQuery)(UnsafeQueryToGlibNone(query)) if pool != nil { carg1 = (*C.GstBufferPool)(UnsafeBufferPoolToGlibNone(pool)) } carg2 = C.guint(size) carg3 = C.guint(minBuffers) carg4 = C.guint(maxBuffers) C.gst_query_add_allocation_pool(carg0, carg1, carg2, carg3, carg4) runtime.KeepAlive(query) runtime.KeepAlive(pool) runtime.KeepAlive(size) runtime.KeepAlive(minBuffers) runtime.KeepAlive(maxBuffers) } // AddBufferingRange wraps gst_query_add_buffering_range // // The function takes the following parameters: // // - start int64: start position of the range // - stop int64: stop position of the range // // The function returns the following values: // // - goret bool // // Set the buffering-ranges array field in @query. The current last // start position of the array should be inferior to @start. func (query *Query) AddBufferingRange(start int64, stop int64) bool { var carg0 *C.GstQuery // in, none, converted var carg1 C.gint64 // in, none, casted var carg2 C.gint64 // in, none, casted var cret C.gboolean // return carg0 = (*C.GstQuery)(UnsafeQueryToGlibNone(query)) carg1 = C.gint64(start) carg2 = C.gint64(stop) cret = C.gst_query_add_buffering_range(carg0, carg1, carg2) runtime.KeepAlive(query) runtime.KeepAlive(start) runtime.KeepAlive(stop) var goret bool if cret != 0 { goret = true } return goret } // AddSchedulingMode wraps gst_query_add_scheduling_mode // // The function takes the following parameters: // // - mode PadMode: a #GstPadMode // // Add @mode as one of the supported scheduling modes to @query. func (query *Query) AddSchedulingMode(mode PadMode) { var carg0 *C.GstQuery // in, none, converted var carg1 C.GstPadMode // in, none, casted carg0 = (*C.GstQuery)(UnsafeQueryToGlibNone(query)) carg1 = C.GstPadMode(mode) C.gst_query_add_scheduling_mode(carg0, carg1) runtime.KeepAlive(query) runtime.KeepAlive(mode) } // FindAllocationMeta wraps gst_query_find_allocation_meta // // The function takes the following parameters: // // - api gobject.Type: the metadata API // // The function returns the following values: // // - index uint: the index // - goret bool // // Check if @query has metadata @api set. When this function returns %TRUE, // @index will contain the index where the requested API and the parameters // can be found. func (query *Query) FindAllocationMeta(api gobject.Type) (uint, bool) { var carg0 *C.GstQuery // in, none, converted var carg1 C.GType // in, none, casted, alias var carg2 C.guint // out, none, casted var cret C.gboolean // return carg0 = (*C.GstQuery)(UnsafeQueryToGlibNone(query)) carg1 = C.GType(api) cret = C.gst_query_find_allocation_meta(carg0, carg1, &carg2) runtime.KeepAlive(query) runtime.KeepAlive(api) var index uint var goret bool index = uint(carg2) if cret != 0 { goret = true } return index, goret } // GetNAllocationMetas wraps gst_query_get_n_allocation_metas // // The function returns the following values: // // - goret uint // // Retrieve the number of values currently stored in the // meta API array of the query's structure. func (query *Query) GetNAllocationMetas() uint { var carg0 *C.GstQuery // in, none, converted var cret C.guint // return, none, casted carg0 = (*C.GstQuery)(UnsafeQueryToGlibNone(query)) cret = C.gst_query_get_n_allocation_metas(carg0) runtime.KeepAlive(query) var goret uint goret = uint(cret) return goret } // GetNAllocationParams wraps gst_query_get_n_allocation_params // // The function returns the following values: // // - goret uint // // Retrieve the number of values currently stored in the // allocator params array of the query's structure. // // If no memory allocator is specified, the downstream element can handle // the default memory allocator. The first memory allocator in the query // should be generic and allow mapping to system memory, all following // allocators should be ordered by preference with the preferred one first. func (query *Query) GetNAllocationParams() uint { var carg0 *C.GstQuery // in, none, converted var cret C.guint // return, none, casted carg0 = (*C.GstQuery)(UnsafeQueryToGlibNone(query)) cret = C.gst_query_get_n_allocation_params(carg0) runtime.KeepAlive(query) var goret uint goret = uint(cret) return goret } // GetNAllocationPools wraps gst_query_get_n_allocation_pools // // The function returns the following values: // // - goret uint // // Retrieve the number of values currently stored in the // pool array of the query's structure. func (query *Query) GetNAllocationPools() uint { var carg0 *C.GstQuery // in, none, converted var cret C.guint // return, none, casted carg0 = (*C.GstQuery)(UnsafeQueryToGlibNone(query)) cret = C.gst_query_get_n_allocation_pools(carg0) runtime.KeepAlive(query) var goret uint goret = uint(cret) return goret } // GetNBufferingRanges wraps gst_query_get_n_buffering_ranges // // The function returns the following values: // // - goret uint // // Retrieve the number of values currently stored in the // buffered-ranges array of the query's structure. func (query *Query) GetNBufferingRanges() uint { var carg0 *C.GstQuery // in, none, converted var cret C.guint // return, none, casted carg0 = (*C.GstQuery)(UnsafeQueryToGlibNone(query)) cret = C.gst_query_get_n_buffering_ranges(carg0) runtime.KeepAlive(query) var goret uint goret = uint(cret) return goret } // GetNSchedulingModes wraps gst_query_get_n_scheduling_modes // // The function returns the following values: // // - goret uint // // Retrieve the number of values currently stored in the // scheduling mode array of the query's structure. func (query *Query) GetNSchedulingModes() uint { var carg0 *C.GstQuery // in, none, converted var cret C.guint // return, none, casted carg0 = (*C.GstQuery)(UnsafeQueryToGlibNone(query)) cret = C.gst_query_get_n_scheduling_modes(carg0) runtime.KeepAlive(query) var goret uint goret = uint(cret) return goret } // GetStructure wraps gst_query_get_structure // // The function returns the following values: // // - goret *Structure (nullable) // // Get the structure of a query. func (query *Query) GetStructure() *Structure { var carg0 *C.GstQuery // in, none, converted var cret *C.GstStructure // return, borrow, converted, nullable carg0 = (*C.GstQuery)(UnsafeQueryToGlibNone(query)) cret = C.gst_query_get_structure(carg0) runtime.KeepAlive(query) var goret *Structure if cret != nil { goret = UnsafeStructureFromGlibBorrow(unsafe.Pointer(cret)) runtime.AddCleanup(goret, func(_ *Query) {}, query) } return goret } // HasSchedulingMode wraps gst_query_has_scheduling_mode // // The function takes the following parameters: // // - mode PadMode: the scheduling mode // // The function returns the following values: // // - goret bool // // Check if @query has scheduling mode set. // // > When checking if upstream supports pull mode, it is usually not // > enough to just check for GST_PAD_MODE_PULL with this function, you // > also want to check whether the scheduling flags returned by // > gst_query_parse_scheduling() have the seeking flag set (meaning // > random access is supported, not only sequential pulls). func (query *Query) HasSchedulingMode(mode PadMode) bool { var carg0 *C.GstQuery // in, none, converted var carg1 C.GstPadMode // in, none, casted var cret C.gboolean // return carg0 = (*C.GstQuery)(UnsafeQueryToGlibNone(query)) carg1 = C.GstPadMode(mode) cret = C.gst_query_has_scheduling_mode(carg0, carg1) runtime.KeepAlive(query) runtime.KeepAlive(mode) var goret bool if cret != 0 { goret = true } return goret } // HasSchedulingModeWithFlags wraps gst_query_has_scheduling_mode_with_flags // // The function takes the following parameters: // // - mode PadMode: the scheduling mode // - flags SchedulingFlags: #GstSchedulingFlags // // The function returns the following values: // // - goret bool // // Check if @query has scheduling mode set and @flags is set in // query scheduling flags. func (query *Query) HasSchedulingModeWithFlags(mode PadMode, flags SchedulingFlags) bool { var carg0 *C.GstQuery // in, none, converted var carg1 C.GstPadMode // in, none, casted var carg2 C.GstSchedulingFlags // in, none, casted var cret C.gboolean // return carg0 = (*C.GstQuery)(UnsafeQueryToGlibNone(query)) carg1 = C.GstPadMode(mode) carg2 = C.GstSchedulingFlags(flags) cret = C.gst_query_has_scheduling_mode_with_flags(carg0, carg1, carg2) runtime.KeepAlive(query) runtime.KeepAlive(mode) runtime.KeepAlive(flags) var goret bool if cret != 0 { goret = true } return goret } // ParseAcceptCaps wraps gst_query_parse_accept_caps // // The function returns the following values: // // - caps *Caps: A pointer to the caps // // Get the caps from @query. The caps remains valid as long as @query remains // valid. func (query *Query) ParseAcceptCaps() *Caps { var carg0 *C.GstQuery // in, none, converted var carg1 *C.GstCaps // out, none, converted carg0 = (*C.GstQuery)(UnsafeQueryToGlibNone(query)) C.gst_query_parse_accept_caps(carg0, &carg1) runtime.KeepAlive(query) var caps *Caps caps = UnsafeCapsFromGlibNone(unsafe.Pointer(carg1)) return caps } // ParseAcceptCapsResult wraps gst_query_parse_accept_caps_result // // The function returns the following values: // // - result bool: location for the result // // Parse the result from @query and store in @result. func (query *Query) ParseAcceptCapsResult() bool { var carg0 *C.GstQuery // in, none, converted var carg1 C.gboolean // out carg0 = (*C.GstQuery)(UnsafeQueryToGlibNone(query)) C.gst_query_parse_accept_caps_result(carg0, &carg1) runtime.KeepAlive(query) var result bool if carg1 != 0 { result = true } return result } // ParseAllocation wraps gst_query_parse_allocation // // The function returns the following values: // // - caps *Caps (nullable): The #GstCaps // - needPool bool: Whether a #GstBufferPool is needed // // Parse an allocation query, writing the requested caps in @caps and // whether a pool is needed in @need_pool, if the respective parameters // are non-%NULL. // // Pool details can be retrieved using gst_query_get_n_allocation_pools() and // gst_query_parse_nth_allocation_pool(). func (query *Query) ParseAllocation() (*Caps, bool) { var carg0 *C.GstQuery // in, none, converted var carg1 *C.GstCaps // out, none, converted, nullable var carg2 C.gboolean // out carg0 = (*C.GstQuery)(UnsafeQueryToGlibNone(query)) C.gst_query_parse_allocation(carg0, &carg1, &carg2) runtime.KeepAlive(query) var caps *Caps var needPool bool if carg1 != nil { caps = UnsafeCapsFromGlibNone(unsafe.Pointer(carg1)) } if carg2 != 0 { needPool = true } return caps, needPool } // ParseBitrate wraps gst_query_parse_bitrate // // The function returns the following values: // // - nominalBitrate uint: The resulting bitrate in bits per second // // Get the results of a bitrate query. See also gst_query_set_bitrate(). func (query *Query) ParseBitrate() uint { var carg0 *C.GstQuery // in, none, converted var carg1 C.guint // out, full, casted carg0 = (*C.GstQuery)(UnsafeQueryToGlibNone(query)) C.gst_query_parse_bitrate(carg0, &carg1) runtime.KeepAlive(query) var nominalBitrate uint nominalBitrate = uint(carg1) return nominalBitrate } // ParseBufferingPercent wraps gst_query_parse_buffering_percent // // The function returns the following values: // // - busy bool: if buffering is busy, or %NULL // - percent int: a buffering percent, or %NULL // // Get the percentage of buffered data. This is a value between 0 and 100. // The @busy indicator is %TRUE when the buffering is in progress. func (query *Query) ParseBufferingPercent() (bool, int) { var carg0 *C.GstQuery // in, none, converted var carg1 C.gboolean // out var carg2 C.gint // out, full, casted carg0 = (*C.GstQuery)(UnsafeQueryToGlibNone(query)) C.gst_query_parse_buffering_percent(carg0, &carg1, &carg2) runtime.KeepAlive(query) var busy bool var percent int if carg1 != 0 { busy = true } percent = int(carg2) return busy, percent } // ParseBufferingRange wraps gst_query_parse_buffering_range // // The function returns the following values: // // - format Format: the format to set for the @segment_start // and @segment_end values, or %NULL // - start int64: the start to set, or %NULL // - stop int64: the stop to set, or %NULL // - estimatedTotal int64: estimated total amount of download // time remaining in milliseconds, or %NULL // // Parse an available query, writing the format into @format, and // other results into the passed parameters, if the respective parameters // are non-%NULL func (query *Query) ParseBufferingRange() (Format, int64, int64, int64) { var carg0 *C.GstQuery // in, none, converted var carg1 C.GstFormat // out, full, casted var carg2 C.gint64 // out, full, casted var carg3 C.gint64 // out, full, casted var carg4 C.gint64 // out, full, casted carg0 = (*C.GstQuery)(UnsafeQueryToGlibNone(query)) C.gst_query_parse_buffering_range(carg0, &carg1, &carg2, &carg3, &carg4) runtime.KeepAlive(query) var format Format var start int64 var stop int64 var estimatedTotal int64 format = Format(carg1) start = int64(carg2) stop = int64(carg3) estimatedTotal = int64(carg4) return format, start, stop, estimatedTotal } // ParseBufferingStats wraps gst_query_parse_buffering_stats // // The function returns the following values: // // - mode BufferingMode: a buffering mode, or %NULL // - avgIn int: the average input rate, or %NULL // - avgOut int: the average output rat, or %NULL // - bufferingLeft int64: amount of buffering time left in // milliseconds, or %NULL // // Extracts the buffering stats values from @query. func (query *Query) ParseBufferingStats() (BufferingMode, int, int, int64) { var carg0 *C.GstQuery // in, none, converted var carg1 C.GstBufferingMode // out, full, casted var carg2 C.gint // out, full, casted var carg3 C.gint // out, full, casted var carg4 C.gint64 // out, full, casted carg0 = (*C.GstQuery)(UnsafeQueryToGlibNone(query)) C.gst_query_parse_buffering_stats(carg0, &carg1, &carg2, &carg3, &carg4) runtime.KeepAlive(query) var mode BufferingMode var avgIn int var avgOut int var bufferingLeft int64 mode = BufferingMode(carg1) avgIn = int(carg2) avgOut = int(carg3) bufferingLeft = int64(carg4) return mode, avgIn, avgOut, bufferingLeft } // ParseCaps wraps gst_query_parse_caps // // The function returns the following values: // // - filter *Caps: A pointer to the caps filter // // Get the filter from the caps @query. The caps remains valid as long as // @query remains valid. func (query *Query) ParseCaps() *Caps { var carg0 *C.GstQuery // in, none, converted var carg1 *C.GstCaps // out, none, converted carg0 = (*C.GstQuery)(UnsafeQueryToGlibNone(query)) C.gst_query_parse_caps(carg0, &carg1) runtime.KeepAlive(query) var filter *Caps filter = UnsafeCapsFromGlibNone(unsafe.Pointer(carg1)) return filter } // ParseCapsResult wraps gst_query_parse_caps_result // // The function returns the following values: // // - caps *Caps (nullable): A pointer to the caps // // Get the caps result from @query. The caps remains valid as long as // @query remains valid. func (query *Query) ParseCapsResult() *Caps { var carg0 *C.GstQuery // in, none, converted var carg1 *C.GstCaps // out, none, converted, nullable carg0 = (*C.GstQuery)(UnsafeQueryToGlibNone(query)) C.gst_query_parse_caps_result(carg0, &carg1) runtime.KeepAlive(query) var caps *Caps if carg1 != nil { caps = UnsafeCapsFromGlibNone(unsafe.Pointer(carg1)) } return caps } // ParseContext wraps gst_query_parse_context // // The function returns the following values: // // - _context *Context (nullable): A pointer to store the #GstContext // // Get the context from the context @query. The context remains valid as long as // @query remains valid. func (query *Query) ParseContext() *Context { var carg0 *C.GstQuery // in, none, converted var carg1 *C.GstContext // out, none, converted, nullable carg0 = (*C.GstQuery)(UnsafeQueryToGlibNone(query)) C.gst_query_parse_context(carg0, &carg1) runtime.KeepAlive(query) var _context *Context if carg1 != nil { _context = UnsafeContextFromGlibNone(unsafe.Pointer(carg1)) } return _context } // ParseContextType wraps gst_query_parse_context_type // // The function returns the following values: // // - contextType string: the context type, or %NULL // - goret bool // // Parse a context type from an existing GST_QUERY_CONTEXT query. func (query *Query) ParseContextType() (string, bool) { var carg0 *C.GstQuery // in, none, converted var carg1 *C.gchar // out, none, string var cret C.gboolean // return carg0 = (*C.GstQuery)(UnsafeQueryToGlibNone(query)) cret = C.gst_query_parse_context_type(carg0, &carg1) runtime.KeepAlive(query) var contextType string var goret bool contextType = C.GoString((*C.char)(unsafe.Pointer(carg1))) if cret != 0 { goret = true } return contextType, goret } // ParseConvert wraps gst_query_parse_convert // // The function returns the following values: // // - srcFormat Format: the storage for the #GstFormat of the // source value, or %NULL // - srcValue int64: the storage for the source value, or %NULL // - destFormat Format: the storage for the #GstFormat of the // destination value, or %NULL // - destValue int64: the storage for the destination value, // or %NULL // // Parse a convert query answer. Any of @src_format, @src_value, @dest_format, // and @dest_value may be %NULL, in which case that value is omitted. func (query *Query) ParseConvert() (Format, int64, Format, int64) { var carg0 *C.GstQuery // in, none, converted var carg1 C.GstFormat // out, full, casted var carg2 C.gint64 // out, full, casted var carg3 C.GstFormat // out, full, casted var carg4 C.gint64 // out, full, casted carg0 = (*C.GstQuery)(UnsafeQueryToGlibNone(query)) C.gst_query_parse_convert(carg0, &carg1, &carg2, &carg3, &carg4) runtime.KeepAlive(query) var srcFormat Format var srcValue int64 var destFormat Format var destValue int64 srcFormat = Format(carg1) srcValue = int64(carg2) destFormat = Format(carg3) destValue = int64(carg4) return srcFormat, srcValue, destFormat, destValue } // ParseDuration wraps gst_query_parse_duration // // The function returns the following values: // // - format Format: the storage for the #GstFormat of the duration // value, or %NULL. // - duration int64: the storage for the total duration, or %NULL. // // Parse a duration query answer. Write the format of the duration into @format, // and the value into @duration, if the respective variables are non-%NULL. func (query *Query) ParseDuration() (Format, int64) { var carg0 *C.GstQuery // in, none, converted var carg1 C.GstFormat // out, full, casted var carg2 C.gint64 // out, full, casted carg0 = (*C.GstQuery)(UnsafeQueryToGlibNone(query)) C.gst_query_parse_duration(carg0, &carg1, &carg2) runtime.KeepAlive(query) var format Format var duration int64 format = Format(carg1) duration = int64(carg2) return format, duration } // ParseLatency wraps gst_query_parse_latency // // The function returns the following values: // // - live bool: storage for live or %NULL // - minLatency ClockTime: the storage for the min latency or %NULL // - maxLatency ClockTime: the storage for the max latency or %NULL // // Parse a latency query answer. func (query *Query) ParseLatency() (bool, ClockTime, ClockTime) { var carg0 *C.GstQuery // in, none, converted var carg1 C.gboolean // out var carg2 C.GstClockTime // out, full, casted, alias var carg3 C.GstClockTime // out, full, casted, alias carg0 = (*C.GstQuery)(UnsafeQueryToGlibNone(query)) C.gst_query_parse_latency(carg0, &carg1, &carg2, &carg3) runtime.KeepAlive(query) var live bool var minLatency ClockTime var maxLatency ClockTime if carg1 != 0 { live = true } minLatency = ClockTime(carg2) maxLatency = ClockTime(carg3) return live, minLatency, maxLatency } // ParseNFormats wraps gst_query_parse_n_formats // // The function returns the following values: // // - nFormats uint: the number of formats in this query. // // Parse the number of formats in the formats @query. func (query *Query) ParseNFormats() uint { var carg0 *C.GstQuery // in, none, converted var carg1 C.guint // out, full, casted carg0 = (*C.GstQuery)(UnsafeQueryToGlibNone(query)) C.gst_query_parse_n_formats(carg0, &carg1) runtime.KeepAlive(query) var nFormats uint nFormats = uint(carg1) return nFormats } // ParseNthAllocationMeta wraps gst_query_parse_nth_allocation_meta // // The function takes the following parameters: // // - index uint: position in the metadata API array to read // // The function returns the following values: // // - params *Structure: API specific parameters // - goret gobject.Type // // Parse an available query and get the metadata API // at @index of the metadata API array. func (query *Query) ParseNthAllocationMeta(index uint) (*Structure, gobject.Type) { var carg0 *C.GstQuery // in, none, converted var carg1 C.guint // in, none, casted var carg2 *C.GstStructure // out, none, converted var cret C.GType // return, none, casted, alias carg0 = (*C.GstQuery)(UnsafeQueryToGlibNone(query)) carg1 = C.guint(index) cret = C.gst_query_parse_nth_allocation_meta(carg0, carg1, &carg2) runtime.KeepAlive(query) runtime.KeepAlive(index) var params *Structure var goret gobject.Type params = UnsafeStructureFromGlibNone(unsafe.Pointer(carg2)) goret = gobject.Type(cret) return params, goret } // ParseNthAllocationParam wraps gst_query_parse_nth_allocation_param // // The function takes the following parameters: // // - index uint: position in the allocator array to read // // The function returns the following values: // // - allocator Allocator (nullable): variable to hold the result // - params AllocationParams: parameters for the allocator // // Parse an available query and get the allocator and its params // at @index of the allocator array. func (query *Query) ParseNthAllocationParam(index uint) (Allocator, AllocationParams) { var carg0 *C.GstQuery // in, none, converted var carg1 C.guint // in, none, casted var carg2 *C.GstAllocator // out, full, converted, nullable var carg3 C.GstAllocationParams // out, transfer: none, C Pointers: 0, Name: AllocationParams, optional, caller-allocates carg0 = (*C.GstQuery)(UnsafeQueryToGlibNone(query)) carg1 = C.guint(index) C.gst_query_parse_nth_allocation_param(carg0, carg1, &carg2, &carg3) runtime.KeepAlive(query) runtime.KeepAlive(index) var allocator Allocator var params AllocationParams if carg2 != nil { allocator = UnsafeAllocatorFromGlibFull(unsafe.Pointer(carg2)) } _ = params _ = carg3 panic("unimplemented conversion of AllocationParams (GstAllocationParams)") return allocator, params } // ParseNthAllocationPool wraps gst_query_parse_nth_allocation_pool // // The function takes the following parameters: // // - index uint: index to parse // // The function returns the following values: // // - pool BufferPool (nullable): the #GstBufferPool // - size uint: the buffer size // - minBuffers uint: the min buffers // - maxBuffers uint: the max buffers // // Get the pool parameters in @query. // // Unref @pool with gst_object_unref() when it's not needed any more. func (query *Query) ParseNthAllocationPool(index uint) (BufferPool, uint, uint, uint) { var carg0 *C.GstQuery // in, none, converted var carg1 C.guint // in, none, casted var carg2 *C.GstBufferPool // out, full, converted, nullable var carg3 C.guint // out, full, casted var carg4 C.guint // out, full, casted var carg5 C.guint // out, full, casted carg0 = (*C.GstQuery)(UnsafeQueryToGlibNone(query)) carg1 = C.guint(index) C.gst_query_parse_nth_allocation_pool(carg0, carg1, &carg2, &carg3, &carg4, &carg5) runtime.KeepAlive(query) runtime.KeepAlive(index) var pool BufferPool var size uint var minBuffers uint var maxBuffers uint if carg2 != nil { pool = UnsafeBufferPoolFromGlibFull(unsafe.Pointer(carg2)) } size = uint(carg3) minBuffers = uint(carg4) maxBuffers = uint(carg5) return pool, size, minBuffers, maxBuffers } // ParseNthBufferingRange wraps gst_query_parse_nth_buffering_range // // The function takes the following parameters: // // - index uint: position in the buffered-ranges array to read // // The function returns the following values: // // - start int64: the start position to set, or %NULL // - stop int64: the stop position to set, or %NULL // - goret bool // // Parse an available query and get the start and stop values stored // at the @index of the buffered ranges array. func (query *Query) ParseNthBufferingRange(index uint) (int64, int64, bool) { var carg0 *C.GstQuery // in, none, converted var carg1 C.guint // in, none, casted var carg2 C.gint64 // out, full, casted var carg3 C.gint64 // out, full, casted var cret C.gboolean // return carg0 = (*C.GstQuery)(UnsafeQueryToGlibNone(query)) carg1 = C.guint(index) cret = C.gst_query_parse_nth_buffering_range(carg0, carg1, &carg2, &carg3) runtime.KeepAlive(query) runtime.KeepAlive(index) var start int64 var stop int64 var goret bool start = int64(carg2) stop = int64(carg3) if cret != 0 { goret = true } return start, stop, goret } // ParseNthFormat wraps gst_query_parse_nth_format // // The function takes the following parameters: // // - nth uint: the nth format to retrieve. // // The function returns the following values: // // - format Format: a pointer to store the nth format // // Parse the format query and retrieve the @nth format from it into // @format. If the list contains less elements than @nth, @format will be // set to GST_FORMAT_UNDEFINED. func (query *Query) ParseNthFormat(nth uint) Format { var carg0 *C.GstQuery // in, none, converted var carg1 C.guint // in, none, casted var carg2 C.GstFormat // out, full, casted carg0 = (*C.GstQuery)(UnsafeQueryToGlibNone(query)) carg1 = C.guint(nth) C.gst_query_parse_nth_format(carg0, carg1, &carg2) runtime.KeepAlive(query) runtime.KeepAlive(nth) var format Format format = Format(carg2) return format } // ParseNthSchedulingMode wraps gst_query_parse_nth_scheduling_mode // // The function takes the following parameters: // // - index uint: position in the scheduling modes array to read // // The function returns the following values: // // - goret PadMode // // Parse an available query and get the scheduling mode // at @index of the scheduling modes array. func (query *Query) ParseNthSchedulingMode(index uint) PadMode { var carg0 *C.GstQuery // in, none, converted var carg1 C.guint // in, none, casted var cret C.GstPadMode // return, none, casted carg0 = (*C.GstQuery)(UnsafeQueryToGlibNone(query)) carg1 = C.guint(index) cret = C.gst_query_parse_nth_scheduling_mode(carg0, carg1) runtime.KeepAlive(query) runtime.KeepAlive(index) var goret PadMode goret = PadMode(cret) return goret } // ParsePosition wraps gst_query_parse_position // // The function returns the following values: // // - format Format: the storage for the #GstFormat of the // position values (may be %NULL) // - cur int64: the storage for the current position (may be %NULL) // // Parse a position query, writing the format into @format, and the position // into @cur, if the respective parameters are non-%NULL. func (query *Query) ParsePosition() (Format, int64) { var carg0 *C.GstQuery // in, none, converted var carg1 C.GstFormat // out, full, casted var carg2 C.gint64 // out, full, casted carg0 = (*C.GstQuery)(UnsafeQueryToGlibNone(query)) C.gst_query_parse_position(carg0, &carg1, &carg2) runtime.KeepAlive(query) var format Format var cur int64 format = Format(carg1) cur = int64(carg2) return format, cur } // ParseScheduling wraps gst_query_parse_scheduling // // The function returns the following values: // // - flags SchedulingFlags: #GstSchedulingFlags // - minsize int: the suggested minimum size of pull requests // - maxsize int: the suggested maximum size of pull requests: // - align int: the suggested alignment of pull requests // // Set the scheduling properties. func (query *Query) ParseScheduling() (SchedulingFlags, int, int, int) { var carg0 *C.GstQuery // in, none, converted var carg1 C.GstSchedulingFlags // out, full, casted var carg2 C.gint // out, full, casted var carg3 C.gint // out, full, casted var carg4 C.gint // out, full, casted carg0 = (*C.GstQuery)(UnsafeQueryToGlibNone(query)) C.gst_query_parse_scheduling(carg0, &carg1, &carg2, &carg3, &carg4) runtime.KeepAlive(query) var flags SchedulingFlags var minsize int var maxsize int var align int flags = SchedulingFlags(carg1) minsize = int(carg2) maxsize = int(carg3) align = int(carg4) return flags, minsize, maxsize, align } // ParseSeeking wraps gst_query_parse_seeking // // The function returns the following values: // // - format Format: the format to set for the @segment_start // and @segment_end values, or %NULL // - seekable bool: the seekable flag to set, or %NULL // - segmentStart int64: the segment_start to set, or %NULL // - segmentEnd int64: the segment_end to set, or %NULL // // Parse a seeking query, writing the format into @format, and // other results into the passed parameters, if the respective parameters // are non-%NULL func (query *Query) ParseSeeking() (Format, bool, int64, int64) { var carg0 *C.GstQuery // in, none, converted var carg1 C.GstFormat // out, full, casted var carg2 C.gboolean // out var carg3 C.gint64 // out, full, casted var carg4 C.gint64 // out, full, casted carg0 = (*C.GstQuery)(UnsafeQueryToGlibNone(query)) C.gst_query_parse_seeking(carg0, &carg1, &carg2, &carg3, &carg4) runtime.KeepAlive(query) var format Format var seekable bool var segmentStart int64 var segmentEnd int64 format = Format(carg1) if carg2 != 0 { seekable = true } segmentStart = int64(carg3) segmentEnd = int64(carg4) return format, seekable, segmentStart, segmentEnd } // ParseSegment wraps gst_query_parse_segment // // The function returns the following values: // // - rate float64: the storage for the rate of the segment, or %NULL // - format Format: the storage for the #GstFormat of the values, // or %NULL // - startValue int64: the storage for the start value, or %NULL // - stopValue int64: the storage for the stop value, or %NULL // // Parse a segment query answer. Any of @rate, @format, @start_value, and // @stop_value may be %NULL, which will cause this value to be omitted. // // See gst_query_set_segment() for an explanation of the function arguments. func (query *Query) ParseSegment() (float64, Format, int64, int64) { var carg0 *C.GstQuery // in, none, converted var carg1 C.gdouble // out, full, casted var carg2 C.GstFormat // out, full, casted var carg3 C.gint64 // out, full, casted var carg4 C.gint64 // out, full, casted carg0 = (*C.GstQuery)(UnsafeQueryToGlibNone(query)) C.gst_query_parse_segment(carg0, &carg1, &carg2, &carg3, &carg4) runtime.KeepAlive(query) var rate float64 var format Format var startValue int64 var stopValue int64 rate = float64(carg1) format = Format(carg2) startValue = int64(carg3) stopValue = int64(carg4) return rate, format, startValue, stopValue } // ParseSelectable wraps gst_query_parse_selectable // // The function returns the following values: // // - selectable bool: The resulting stream selection capability // // Get the results of a selectable query. See also gst_query_set_selectable(). func (query *Query) ParseSelectable() bool { var carg0 *C.GstQuery // in, none, converted var carg1 C.gboolean // out carg0 = (*C.GstQuery)(UnsafeQueryToGlibNone(query)) C.gst_query_parse_selectable(carg0, &carg1) runtime.KeepAlive(query) var selectable bool if carg1 != 0 { selectable = true } return selectable } // ParseURI wraps gst_query_parse_uri // // The function returns the following values: // // - uri string (nullable): the storage for the current URI // (may be %NULL) // // Parse an URI query, writing the URI into @uri as a newly // allocated string, if the respective parameters are non-%NULL. // Free the string with g_free() after usage. func (query *Query) ParseURI() string { var carg0 *C.GstQuery // in, none, converted var carg1 *C.gchar // out, full, string, nullable-string carg0 = (*C.GstQuery)(UnsafeQueryToGlibNone(query)) C.gst_query_parse_uri(carg0, &carg1) runtime.KeepAlive(query) var uri string if carg1 != nil { uri = C.GoString((*C.char)(unsafe.Pointer(carg1))) defer C.free(unsafe.Pointer(carg1)) } return uri } // ParseURIRedirection wraps gst_query_parse_uri_redirection // // The function returns the following values: // // - uri string (nullable): the storage for the redirect URI // (may be %NULL) // // Parse an URI query, writing the URI into @uri as a newly // allocated string, if the respective parameters are non-%NULL. // Free the string with g_free() after usage. func (query *Query) ParseURIRedirection() string { var carg0 *C.GstQuery // in, none, converted var carg1 *C.gchar // out, full, string, nullable-string carg0 = (*C.GstQuery)(UnsafeQueryToGlibNone(query)) C.gst_query_parse_uri_redirection(carg0, &carg1) runtime.KeepAlive(query) var uri string if carg1 != nil { uri = C.GoString((*C.char)(unsafe.Pointer(carg1))) defer C.free(unsafe.Pointer(carg1)) } return uri } // ParseURIRedirectionPermanent wraps gst_query_parse_uri_redirection_permanent // // The function returns the following values: // // - permanent bool: if the URI redirection is permanent // (may be %NULL) // // Parse an URI query, and set @permanent to %TRUE if there is a redirection // and it should be considered permanent. If a redirection is permanent, // applications should update their internal storage of the URI, otherwise // they should make all future requests to the original URI. func (query *Query) ParseURIRedirectionPermanent() bool { var carg0 *C.GstQuery // in, none, converted var carg1 C.gboolean // out carg0 = (*C.GstQuery)(UnsafeQueryToGlibNone(query)) C.gst_query_parse_uri_redirection_permanent(carg0, &carg1) runtime.KeepAlive(query) var permanent bool if carg1 != 0 { permanent = true } return permanent } // RemoveNthAllocationMeta wraps gst_query_remove_nth_allocation_meta // // The function takes the following parameters: // // - index uint: position in the metadata API array to remove // // Remove the metadata API at @index of the metadata API array. func (query *Query) RemoveNthAllocationMeta(index uint) { var carg0 *C.GstQuery // in, none, converted var carg1 C.guint // in, none, casted carg0 = (*C.GstQuery)(UnsafeQueryToGlibNone(query)) carg1 = C.guint(index) C.gst_query_remove_nth_allocation_meta(carg0, carg1) runtime.KeepAlive(query) runtime.KeepAlive(index) } // RemoveNthAllocationParam wraps gst_query_remove_nth_allocation_param // // The function takes the following parameters: // // - index uint: position in the allocation param array to remove // // Remove the allocation param at @index of the allocation param array. func (query *Query) RemoveNthAllocationParam(index uint) { var carg0 *C.GstQuery // in, none, converted var carg1 C.guint // in, none, casted carg0 = (*C.GstQuery)(UnsafeQueryToGlibNone(query)) carg1 = C.guint(index) C.gst_query_remove_nth_allocation_param(carg0, carg1) runtime.KeepAlive(query) runtime.KeepAlive(index) } // RemoveNthAllocationPool wraps gst_query_remove_nth_allocation_pool // // The function takes the following parameters: // // - index uint: position in the allocation pool array to remove // // Remove the allocation pool at @index of the allocation pool array. func (query *Query) RemoveNthAllocationPool(index uint) { var carg0 *C.GstQuery // in, none, converted var carg1 C.guint // in, none, casted carg0 = (*C.GstQuery)(UnsafeQueryToGlibNone(query)) carg1 = C.guint(index) C.gst_query_remove_nth_allocation_pool(carg0, carg1) runtime.KeepAlive(query) runtime.KeepAlive(index) } // SetAcceptCapsResult wraps gst_query_set_accept_caps_result // // The function takes the following parameters: // // - result bool: the result to set // // Set @result as the result for the @query. func (query *Query) SetAcceptCapsResult(result bool) { var carg0 *C.GstQuery // in, none, converted var carg1 C.gboolean // in carg0 = (*C.GstQuery)(UnsafeQueryToGlibNone(query)) if result { carg1 = C.TRUE } C.gst_query_set_accept_caps_result(carg0, carg1) runtime.KeepAlive(query) runtime.KeepAlive(result) } // SetBitrate wraps gst_query_set_bitrate // // The function takes the following parameters: // // - nominalBitrate uint: the nominal bitrate in bits per second // // Set the results of a bitrate query. The nominal bitrate is the average // bitrate expected over the length of the stream as advertised in file // headers (or similar). func (query *Query) SetBitrate(nominalBitrate uint) { var carg0 *C.GstQuery // in, none, converted var carg1 C.guint // in, none, casted carg0 = (*C.GstQuery)(UnsafeQueryToGlibNone(query)) carg1 = C.guint(nominalBitrate) C.gst_query_set_bitrate(carg0, carg1) runtime.KeepAlive(query) runtime.KeepAlive(nominalBitrate) } // SetBufferingPercent wraps gst_query_set_buffering_percent // // The function takes the following parameters: // // - busy bool: if buffering is busy // - percent int: a buffering percent // // Set the percentage of buffered data. This is a value between 0 and 100. // The @busy indicator is %TRUE when the buffering is in progress. func (query *Query) SetBufferingPercent(busy bool, percent int) { var carg0 *C.GstQuery // in, none, converted var carg1 C.gboolean // in var carg2 C.gint // in, none, casted carg0 = (*C.GstQuery)(UnsafeQueryToGlibNone(query)) if busy { carg1 = C.TRUE } carg2 = C.gint(percent) C.gst_query_set_buffering_percent(carg0, carg1, carg2) runtime.KeepAlive(query) runtime.KeepAlive(busy) runtime.KeepAlive(percent) } // SetBufferingRange wraps gst_query_set_buffering_range // // The function takes the following parameters: // // - format Format: the format to set for the @start and @stop values // - start int64: the start to set // - stop int64: the stop to set // - estimatedTotal int64: estimated total amount of download time remaining in // milliseconds // // Set the available query result fields in @query. func (query *Query) SetBufferingRange(format Format, start int64, stop int64, estimatedTotal int64) { var carg0 *C.GstQuery // in, none, converted var carg1 C.GstFormat // in, none, casted var carg2 C.gint64 // in, none, casted var carg3 C.gint64 // in, none, casted var carg4 C.gint64 // in, none, casted carg0 = (*C.GstQuery)(UnsafeQueryToGlibNone(query)) carg1 = C.GstFormat(format) carg2 = C.gint64(start) carg3 = C.gint64(stop) carg4 = C.gint64(estimatedTotal) C.gst_query_set_buffering_range(carg0, carg1, carg2, carg3, carg4) runtime.KeepAlive(query) runtime.KeepAlive(format) runtime.KeepAlive(start) runtime.KeepAlive(stop) runtime.KeepAlive(estimatedTotal) } // SetBufferingStats wraps gst_query_set_buffering_stats // // The function takes the following parameters: // // - mode BufferingMode: a buffering mode // - avgIn int: the average input rate // - avgOut int: the average output rate // - bufferingLeft int64: amount of buffering time left in milliseconds // // Configures the buffering stats values in @query. func (query *Query) SetBufferingStats(mode BufferingMode, avgIn int, avgOut int, bufferingLeft int64) { var carg0 *C.GstQuery // in, none, converted var carg1 C.GstBufferingMode // in, none, casted var carg2 C.gint // in, none, casted var carg3 C.gint // in, none, casted var carg4 C.gint64 // in, none, casted carg0 = (*C.GstQuery)(UnsafeQueryToGlibNone(query)) carg1 = C.GstBufferingMode(mode) carg2 = C.gint(avgIn) carg3 = C.gint(avgOut) carg4 = C.gint64(bufferingLeft) C.gst_query_set_buffering_stats(carg0, carg1, carg2, carg3, carg4) runtime.KeepAlive(query) runtime.KeepAlive(mode) runtime.KeepAlive(avgIn) runtime.KeepAlive(avgOut) runtime.KeepAlive(bufferingLeft) } // SetCapsResult wraps gst_query_set_caps_result // // The function takes the following parameters: // // - caps *Caps (nullable): A pointer to the caps // // Set the @caps result in @query. func (query *Query) SetCapsResult(caps *Caps) { var carg0 *C.GstQuery // in, none, converted var carg1 *C.GstCaps // in, none, converted, nullable carg0 = (*C.GstQuery)(UnsafeQueryToGlibNone(query)) if caps != nil { carg1 = (*C.GstCaps)(UnsafeCapsToGlibNone(caps)) } C.gst_query_set_caps_result(carg0, carg1) runtime.KeepAlive(query) runtime.KeepAlive(caps) } // SetContext wraps gst_query_set_context // // The function takes the following parameters: // // - _context *Context (nullable): the requested #GstContext // // Answer a context query by setting the requested context. func (query *Query) SetContext(_context *Context) { var carg0 *C.GstQuery // in, none, converted var carg1 *C.GstContext // in, none, converted, nullable carg0 = (*C.GstQuery)(UnsafeQueryToGlibNone(query)) if _context != nil { carg1 = (*C.GstContext)(UnsafeContextToGlibNone(_context)) } C.gst_query_set_context(carg0, carg1) runtime.KeepAlive(query) runtime.KeepAlive(_context) } // SetConvert wraps gst_query_set_convert // // The function takes the following parameters: // // - srcFormat Format: the source #GstFormat // - srcValue int64: the source value // - destFormat Format: the destination #GstFormat // - destValue int64: the destination value // // Answer a convert query by setting the requested values. func (query *Query) SetConvert(srcFormat Format, srcValue int64, destFormat Format, destValue int64) { var carg0 *C.GstQuery // in, none, converted var carg1 C.GstFormat // in, none, casted var carg2 C.gint64 // in, none, casted var carg3 C.GstFormat // in, none, casted var carg4 C.gint64 // in, none, casted carg0 = (*C.GstQuery)(UnsafeQueryToGlibNone(query)) carg1 = C.GstFormat(srcFormat) carg2 = C.gint64(srcValue) carg3 = C.GstFormat(destFormat) carg4 = C.gint64(destValue) C.gst_query_set_convert(carg0, carg1, carg2, carg3, carg4) runtime.KeepAlive(query) runtime.KeepAlive(srcFormat) runtime.KeepAlive(srcValue) runtime.KeepAlive(destFormat) runtime.KeepAlive(destValue) } // SetDuration wraps gst_query_set_duration // // The function takes the following parameters: // // - format Format: the #GstFormat for the duration // - duration int64: the duration of the stream // // Answer a duration query by setting the requested value in the given format. func (query *Query) SetDuration(format Format, duration int64) { var carg0 *C.GstQuery // in, none, converted var carg1 C.GstFormat // in, none, casted var carg2 C.gint64 // in, none, casted carg0 = (*C.GstQuery)(UnsafeQueryToGlibNone(query)) carg1 = C.GstFormat(format) carg2 = C.gint64(duration) C.gst_query_set_duration(carg0, carg1, carg2) runtime.KeepAlive(query) runtime.KeepAlive(format) runtime.KeepAlive(duration) } // SetFormatsv wraps gst_query_set_formatsv // // The function takes the following parameters: // // - formats []Format: an array containing @n_formats // @GstFormat values. // // Set the formats query result fields in @query. The number of formats passed // in the @formats array must be equal to @n_formats. func (query *Query) SetFormatsv(formats []Format) { var carg0 *C.GstQuery // in, none, converted var carg1 C.gint // implicit var carg2 *C.GstFormat // in, transfer: none, C Pointers: 1, Name: array[Format], array (inner: *typesystem.Enum, length-by: carg1) carg0 = (*C.GstQuery)(UnsafeQueryToGlibNone(query)) _ = formats _ = carg2 _ = carg1 panic("unimplemented conversion of []Format (const GstFormat*)") C.gst_query_set_formatsv(carg0, carg1, carg2) runtime.KeepAlive(query) runtime.KeepAlive(formats) } // SetLatency wraps gst_query_set_latency // // The function takes the following parameters: // // - live bool: if there is a live element upstream // - minLatency ClockTime: the minimal latency of the upstream elements // - maxLatency ClockTime: the maximal latency of the upstream elements // // Answer a latency query by setting the requested values in the given format. func (query *Query) SetLatency(live bool, minLatency ClockTime, maxLatency ClockTime) { var carg0 *C.GstQuery // in, none, converted var carg1 C.gboolean // in var carg2 C.GstClockTime // in, none, casted, alias var carg3 C.GstClockTime // in, none, casted, alias carg0 = (*C.GstQuery)(UnsafeQueryToGlibNone(query)) if live { carg1 = C.TRUE } carg2 = C.GstClockTime(minLatency) carg3 = C.GstClockTime(maxLatency) C.gst_query_set_latency(carg0, carg1, carg2, carg3) runtime.KeepAlive(query) runtime.KeepAlive(live) runtime.KeepAlive(minLatency) runtime.KeepAlive(maxLatency) } // SetNthAllocationParam wraps gst_query_set_nth_allocation_param // // The function takes the following parameters: // // - index uint: position in the allocator array to set // - allocator Allocator (nullable): new allocator to set // - params *AllocationParams (nullable): parameters for the allocator // // Parse an available query and get the allocator and its params // at @index of the allocator array. func (query *Query) SetNthAllocationParam(index uint, allocator Allocator, params *AllocationParams) { var carg0 *C.GstQuery // in, none, converted var carg1 C.guint // in, none, casted var carg2 *C.GstAllocator // in, none, converted, nullable var carg3 *C.GstAllocationParams // in, none, converted, nullable carg0 = (*C.GstQuery)(UnsafeQueryToGlibNone(query)) carg1 = C.guint(index) if allocator != nil { carg2 = (*C.GstAllocator)(UnsafeAllocatorToGlibNone(allocator)) } if params != nil { carg3 = (*C.GstAllocationParams)(UnsafeAllocationParamsToGlibNone(params)) } C.gst_query_set_nth_allocation_param(carg0, carg1, carg2, carg3) runtime.KeepAlive(query) runtime.KeepAlive(index) runtime.KeepAlive(allocator) runtime.KeepAlive(params) } // SetNthAllocationPool wraps gst_query_set_nth_allocation_pool // // The function takes the following parameters: // // - index uint: index to modify // - pool BufferPool (nullable): the #GstBufferPool // - size uint: the buffer size // - minBuffers uint: the min buffers // - maxBuffers uint: the max buffers // // Set the pool parameters in @query. func (query *Query) SetNthAllocationPool(index uint, pool BufferPool, size uint, minBuffers uint, maxBuffers uint) { var carg0 *C.GstQuery // in, none, converted var carg1 C.guint // in, none, casted var carg2 *C.GstBufferPool // in, none, converted, nullable var carg3 C.guint // in, none, casted var carg4 C.guint // in, none, casted var carg5 C.guint // in, none, casted carg0 = (*C.GstQuery)(UnsafeQueryToGlibNone(query)) carg1 = C.guint(index) if pool != nil { carg2 = (*C.GstBufferPool)(UnsafeBufferPoolToGlibNone(pool)) } carg3 = C.guint(size) carg4 = C.guint(minBuffers) carg5 = C.guint(maxBuffers) C.gst_query_set_nth_allocation_pool(carg0, carg1, carg2, carg3, carg4, carg5) runtime.KeepAlive(query) runtime.KeepAlive(index) runtime.KeepAlive(pool) runtime.KeepAlive(size) runtime.KeepAlive(minBuffers) runtime.KeepAlive(maxBuffers) } // SetPosition wraps gst_query_set_position // // The function takes the following parameters: // // - format Format: the requested #GstFormat // - cur int64: the position to set // // Answer a position query by setting the requested value in the given format. func (query *Query) SetPosition(format Format, cur int64) { var carg0 *C.GstQuery // in, none, converted var carg1 C.GstFormat // in, none, casted var carg2 C.gint64 // in, none, casted carg0 = (*C.GstQuery)(UnsafeQueryToGlibNone(query)) carg1 = C.GstFormat(format) carg2 = C.gint64(cur) C.gst_query_set_position(carg0, carg1, carg2) runtime.KeepAlive(query) runtime.KeepAlive(format) runtime.KeepAlive(cur) } // SetScheduling wraps gst_query_set_scheduling // // The function takes the following parameters: // // - flags SchedulingFlags: #GstSchedulingFlags // - minsize int: the suggested minimum size of pull requests // - maxsize int: the suggested maximum size of pull requests // - align int: the suggested alignment of pull requests // // Set the scheduling properties. func (query *Query) SetScheduling(flags SchedulingFlags, minsize int, maxsize int, align int) { var carg0 *C.GstQuery // in, none, converted var carg1 C.GstSchedulingFlags // in, none, casted var carg2 C.gint // in, none, casted var carg3 C.gint // in, none, casted var carg4 C.gint // in, none, casted carg0 = (*C.GstQuery)(UnsafeQueryToGlibNone(query)) carg1 = C.GstSchedulingFlags(flags) carg2 = C.gint(minsize) carg3 = C.gint(maxsize) carg4 = C.gint(align) C.gst_query_set_scheduling(carg0, carg1, carg2, carg3, carg4) runtime.KeepAlive(query) runtime.KeepAlive(flags) runtime.KeepAlive(minsize) runtime.KeepAlive(maxsize) runtime.KeepAlive(align) } // SetSeeking wraps gst_query_set_seeking // // The function takes the following parameters: // // - format Format: the format to set for the @segment_start and @segment_end values // - seekable bool: the seekable flag to set // - segmentStart int64: the segment_start to set // - segmentEnd int64: the segment_end to set // // Set the seeking query result fields in @query. func (query *Query) SetSeeking(format Format, seekable bool, segmentStart int64, segmentEnd int64) { var carg0 *C.GstQuery // in, none, converted var carg1 C.GstFormat // in, none, casted var carg2 C.gboolean // in var carg3 C.gint64 // in, none, casted var carg4 C.gint64 // in, none, casted carg0 = (*C.GstQuery)(UnsafeQueryToGlibNone(query)) carg1 = C.GstFormat(format) if seekable { carg2 = C.TRUE } carg3 = C.gint64(segmentStart) carg4 = C.gint64(segmentEnd) C.gst_query_set_seeking(carg0, carg1, carg2, carg3, carg4) runtime.KeepAlive(query) runtime.KeepAlive(format) runtime.KeepAlive(seekable) runtime.KeepAlive(segmentStart) runtime.KeepAlive(segmentEnd) } // SetSegment wraps gst_query_set_segment // // The function takes the following parameters: // // - rate float64: the rate of the segment // - format Format: the #GstFormat of the segment values (@start_value and @stop_value) // - startValue int64: the start value // - stopValue int64: the stop value // // Answer a segment query by setting the requested values. The normal // playback segment of a pipeline is 0 to duration at the default rate of // 1.0. If a seek was performed on the pipeline to play a different // segment, this query will return the range specified in the last seek. // // @start_value and @stop_value will respectively contain the configured // playback range start and stop values expressed in @format. // The values are always between 0 and the duration of the media and // @start_value <= @stop_value. @rate will contain the playback rate. For // negative rates, playback will actually happen from @stop_value to // @start_value. func (query *Query) SetSegment(rate float64, format Format, startValue int64, stopValue int64) { var carg0 *C.GstQuery // in, none, converted var carg1 C.gdouble // in, none, casted var carg2 C.GstFormat // in, none, casted var carg3 C.gint64 // in, none, casted var carg4 C.gint64 // in, none, casted carg0 = (*C.GstQuery)(UnsafeQueryToGlibNone(query)) carg1 = C.gdouble(rate) carg2 = C.GstFormat(format) carg3 = C.gint64(startValue) carg4 = C.gint64(stopValue) C.gst_query_set_segment(carg0, carg1, carg2, carg3, carg4) runtime.KeepAlive(query) runtime.KeepAlive(rate) runtime.KeepAlive(format) runtime.KeepAlive(startValue) runtime.KeepAlive(stopValue) } // SetSelectable wraps gst_query_set_selectable // // The function takes the following parameters: // // - selectable bool: Whether the element can handle stream selection. // // Set the results of a selectable query. If the element answering the query can // handle stream selection, @selectable should be set to %TRUE. func (query *Query) SetSelectable(selectable bool) { var carg0 *C.GstQuery // in, none, converted var carg1 C.gboolean // in carg0 = (*C.GstQuery)(UnsafeQueryToGlibNone(query)) if selectable { carg1 = C.TRUE } C.gst_query_set_selectable(carg0, carg1) runtime.KeepAlive(query) runtime.KeepAlive(selectable) } // SetURI wraps gst_query_set_uri // // The function takes the following parameters: // // - uri string (nullable): the URI to set // // Answer a URI query by setting the requested URI. func (query *Query) SetURI(uri string) { var carg0 *C.GstQuery // in, none, converted var carg1 *C.gchar // in, none, string, nullable-string carg0 = (*C.GstQuery)(UnsafeQueryToGlibNone(query)) if uri != "" { carg1 = (*C.gchar)(unsafe.Pointer(C.CString(uri))) defer C.free(unsafe.Pointer(carg1)) } C.gst_query_set_uri(carg0, carg1) runtime.KeepAlive(query) runtime.KeepAlive(uri) } // SetURIRedirection wraps gst_query_set_uri_redirection // // The function takes the following parameters: // // - uri string (nullable): the URI to set // // Answer a URI query by setting the requested URI redirection. func (query *Query) SetURIRedirection(uri string) { var carg0 *C.GstQuery // in, none, converted var carg1 *C.gchar // in, none, string, nullable-string carg0 = (*C.GstQuery)(UnsafeQueryToGlibNone(query)) if uri != "" { carg1 = (*C.gchar)(unsafe.Pointer(C.CString(uri))) defer C.free(unsafe.Pointer(carg1)) } C.gst_query_set_uri_redirection(carg0, carg1) runtime.KeepAlive(query) runtime.KeepAlive(uri) } // SetURIRedirectionPermanent wraps gst_query_set_uri_redirection_permanent // // The function takes the following parameters: // // - permanent bool: whether the redirect is permanent or not // // Answer a URI query by setting the requested URI redirection // to permanent or not. func (query *Query) SetURIRedirectionPermanent(permanent bool) { var carg0 *C.GstQuery // in, none, converted var carg1 C.gboolean // in carg0 = (*C.GstQuery)(UnsafeQueryToGlibNone(query)) if permanent { carg1 = C.TRUE } C.gst_query_set_uri_redirection_permanent(carg0, carg1) runtime.KeepAlive(query) runtime.KeepAlive(permanent) } // WritableStructure wraps gst_query_writable_structure // // The function returns the following values: // // - goret *Structure // // Get the structure of a query. This method should be called with a writable // @query so that the returned structure is guaranteed to be writable. func (query *Query) WritableStructure() *Structure { var carg0 *C.GstQuery // in, none, converted var cret *C.GstStructure // return, borrow, converted carg0 = (*C.GstQuery)(UnsafeQueryToGlibNone(query)) cret = C.gst_query_writable_structure(carg0) runtime.KeepAlive(query) var goret *Structure goret = UnsafeStructureFromGlibBorrow(unsafe.Pointer(cret)) runtime.AddCleanup(goret, func(_ *Query) {}, query) return goret } // ReferenceTimestampMeta wraps GstReferenceTimestampMeta // // #GstReferenceTimestampMeta can be used to attach alternative timestamps and // possibly durations to a #GstBuffer. These are generally not according to // the pipeline clock and could be e.g. the NTP timestamp when the media was // captured. // // The reference is stored as a #GstCaps in @reference. Examples of valid // references would be // // * `timestamp/x-drivername-stream`: for timestamps that are locally // generated by some driver named `drivername` when generating the stream, // e.g. based on a frame counter // * `timestamp/x-ntp, host=pool.ntp.org, port=123`: for timestamps based on a // specific NTP server. Note that the host/port parameters might not always // be given. // * `timestamp/x-ptp, version=IEEE1588-2008, domain=1`: for timestamps based // on a given PTP clock. // * `timestamp/x-unix`: for timestamps based on the UNIX epoch according to // the local clock. // // Since 1.24 it can be serialized using gst_meta_serialize() and // gst_meta_deserialize(). type ReferenceTimestampMeta struct { *referenceTimestampMeta } // referenceTimestampMeta is the struct that's finalized type referenceTimestampMeta struct { native *C.GstReferenceTimestampMeta } // UnsafeReferenceTimestampMetaFromGlibBorrow is used to convert raw C.GstReferenceTimestampMeta pointers to go. This is used by the bindings internally. func UnsafeReferenceTimestampMetaFromGlibBorrow(p unsafe.Pointer) *ReferenceTimestampMeta { return &ReferenceTimestampMeta{&referenceTimestampMeta{(*C.GstReferenceTimestampMeta)(p)}} } // 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) runtime.SetFinalizer( wrapped.referenceTimestampMeta, func (intern *referenceTimestampMeta) { C.free(unsafe.Pointer(intern.native)) }, ) return wrapped } // 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( wrapped.referenceTimestampMeta, func (intern *referenceTimestampMeta) { C.free(unsafe.Pointer(intern.native)) }, ) return wrapped } // UnsafeReferenceTimestampMetaFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [ReferenceTimestampMeta] is expected to work anymore. func UnsafeReferenceTimestampMetaFree(r *ReferenceTimestampMeta) { C.free(unsafe.Pointer(r.native)) } // UnsafeReferenceTimestampMetaToGlibNone returns the underlying C pointer. This is used by the bindings internally. func UnsafeReferenceTimestampMetaToGlibNone(r *ReferenceTimestampMeta) unsafe.Pointer { return unsafe.Pointer(r.native) } // UnsafeReferenceTimestampMetaToGlibFull returns the underlying C pointer and gives up ownership. // This is used by the bindings internally. func UnsafeReferenceTimestampMetaToGlibFull(r *ReferenceTimestampMeta) unsafe.Pointer { runtime.SetFinalizer(r.referenceTimestampMeta, nil) _p := unsafe.Pointer(r.native) 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 // // Gets the global #GstMetaInfo describing the #GstReferenceTimestampMeta meta. func ReferenceTimestampMetaGetInfo() *MetaInfo { var cret *C.GstMetaInfo // return, none, converted cret = C.gst_reference_timestamp_meta_get_info() var goret *MetaInfo goret = UnsafeMetaInfoFromGlibNone(unsafe.Pointer(cret)) return goret } // RegistryClass wraps GstRegistryClass // // RegistryClass is the type struct for [Registry] type RegistryClass struct { *registryClass } // registryClass is the struct that's finalized type registryClass struct { native *C.GstRegistryClass } // UnsafeRegistryClassFromGlibBorrow is used to convert raw C.GstRegistryClass pointers to go. This is used by the bindings internally. func UnsafeRegistryClassFromGlibBorrow(p unsafe.Pointer) *RegistryClass { return &RegistryClass{®istryClass{(*C.GstRegistryClass)(p)}} } // 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. func UnsafeRegistryClassFree(r *RegistryClass) { C.free(unsafe.Pointer(r.native)) } // UnsafeRegistryClassToGlibNone returns the underlying C pointer. This is used by the bindings internally. func UnsafeRegistryClassToGlibNone(r *RegistryClass) unsafe.Pointer { return unsafe.Pointer(r.native) } // 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 // extra arbitrary information. type Sample struct { *sample } // sample is the struct that's finalized type sample struct { native *C.GstSample } var _ gobject.GoValueInitializer = (*Sample)(nil) func marshalSample(p unsafe.Pointer) (interface{}, error) { b := gobject.ValueFromNative(p).Boxed() return UnsafeSampleFromGlibBorrow(b), nil } func (r *Sample) InitGoValue(v *gobject.Value) { v.Init(TypeSample) v.SetBoxed(unsafe.Pointer(r.native)) } // UnsafeSampleFromGlibBorrow is used to convert raw C.GstSample pointers to go. This is used by the bindings internally. func UnsafeSampleFromGlibBorrow(p unsafe.Pointer) *Sample { return &Sample{&sample{(*C.GstSample)(p)}} } // 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) runtime.SetFinalizer( wrapped.sample, func (intern *sample) { C.free(unsafe.Pointer(intern.native)) }, ) return wrapped } // 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( wrapped.sample, func (intern *sample) { C.free(unsafe.Pointer(intern.native)) }, ) return wrapped } // UnsafeSampleFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [Sample] is expected to work anymore. func UnsafeSampleFree(s *Sample) { C.free(unsafe.Pointer(s.native)) } // UnsafeSampleToGlibNone returns the underlying C pointer. This is used by the bindings internally. func UnsafeSampleToGlibNone(s *Sample) unsafe.Pointer { return unsafe.Pointer(s.native) } // UnsafeSampleToGlibFull returns the underlying C pointer and gives up ownership. // This is used by the bindings internally. func UnsafeSampleToGlibFull(s *Sample) unsafe.Pointer { runtime.SetFinalizer(s.sample, nil) _p := unsafe.Pointer(s.native) s.native = nil // Sample is invalid from here on return _p } // NewSample wraps gst_sample_new // // The function takes the following parameters: // // - buffer *Buffer (nullable): a #GstBuffer, or %NULL // - caps *Caps (nullable): a #GstCaps, or %NULL // - segment *Segment (nullable): a #GstSegment, or %NULL // - info *Structure (nullable): a #GstStructure, or %NULL // // The function returns the following values: // // - goret *Sample // // Create a new #GstSample with the provided details. // // Free-function: gst_sample_unref func NewSample(buffer *Buffer, caps *Caps, segment *Segment, info *Structure) *Sample { var carg1 *C.GstBuffer // in, none, converted, nullable var carg2 *C.GstCaps // in, none, converted, nullable var carg3 *C.GstSegment // in, none, converted, nullable var carg4 *C.GstStructure // in, full, converted, nullable var cret *C.GstSample // return, full, converted if buffer != nil { carg1 = (*C.GstBuffer)(UnsafeBufferToGlibNone(buffer)) } if caps != nil { carg2 = (*C.GstCaps)(UnsafeCapsToGlibNone(caps)) } if segment != nil { carg3 = (*C.GstSegment)(UnsafeSegmentToGlibNone(segment)) } if info != nil { carg4 = (*C.GstStructure)(UnsafeStructureToGlibFull(info)) } cret = C.gst_sample_new(carg1, carg2, carg3, carg4) runtime.KeepAlive(buffer) runtime.KeepAlive(caps) runtime.KeepAlive(segment) runtime.KeepAlive(info) var goret *Sample goret = UnsafeSampleFromGlibFull(unsafe.Pointer(cret)) return goret } // GetBuffer wraps gst_sample_get_buffer // // The function returns the following values: // // - goret *Buffer (nullable) // // Get the buffer associated with @sample func (sample *Sample) GetBuffer() *Buffer { var carg0 *C.GstSample // in, none, converted var cret *C.GstBuffer // return, borrow, converted, nullable carg0 = (*C.GstSample)(UnsafeSampleToGlibNone(sample)) cret = C.gst_sample_get_buffer(carg0) runtime.KeepAlive(sample) var goret *Buffer if cret != nil { goret = UnsafeBufferFromGlibBorrow(unsafe.Pointer(cret)) runtime.AddCleanup(goret, func(_ *Sample) {}, sample) } return goret } // GetBufferList wraps gst_sample_get_buffer_list // // The function returns the following values: // // - goret *BufferList (nullable) // // Get the buffer list associated with @sample func (sample *Sample) GetBufferList() *BufferList { var carg0 *C.GstSample // in, none, converted var cret *C.GstBufferList // return, borrow, converted, nullable carg0 = (*C.GstSample)(UnsafeSampleToGlibNone(sample)) cret = C.gst_sample_get_buffer_list(carg0) runtime.KeepAlive(sample) var goret *BufferList if cret != nil { goret = UnsafeBufferListFromGlibBorrow(unsafe.Pointer(cret)) runtime.AddCleanup(goret, func(_ *Sample) {}, sample) } return goret } // GetCaps wraps gst_sample_get_caps // // The function returns the following values: // // - goret *Caps (nullable) // // Get the caps associated with @sample func (sample *Sample) GetCaps() *Caps { var carg0 *C.GstSample // in, none, converted var cret *C.GstCaps // return, borrow, converted, nullable carg0 = (*C.GstSample)(UnsafeSampleToGlibNone(sample)) cret = C.gst_sample_get_caps(carg0) runtime.KeepAlive(sample) var goret *Caps if cret != nil { goret = UnsafeCapsFromGlibBorrow(unsafe.Pointer(cret)) runtime.AddCleanup(goret, func(_ *Sample) {}, sample) } return goret } // GetInfo wraps gst_sample_get_info // // The function returns the following values: // // - goret *Structure (nullable) // // Get extra information associated with @sample. func (sample *Sample) GetInfo() *Structure { var carg0 *C.GstSample // in, none, converted var cret *C.GstStructure // return, borrow, converted, nullable carg0 = (*C.GstSample)(UnsafeSampleToGlibNone(sample)) cret = C.gst_sample_get_info(carg0) runtime.KeepAlive(sample) var goret *Structure if cret != nil { goret = UnsafeStructureFromGlibBorrow(unsafe.Pointer(cret)) runtime.AddCleanup(goret, func(_ *Sample) {}, sample) } return goret } // GetSegment wraps gst_sample_get_segment // // The function returns the following values: // // - goret *Segment // // Get the segment associated with @sample func (sample *Sample) GetSegment() *Segment { var carg0 *C.GstSample // in, none, converted var cret *C.GstSegment // return, none, converted carg0 = (*C.GstSample)(UnsafeSampleToGlibNone(sample)) cret = C.gst_sample_get_segment(carg0) runtime.KeepAlive(sample) var goret *Segment goret = UnsafeSegmentFromGlibNone(unsafe.Pointer(cret)) return goret } // SetBuffer wraps gst_sample_set_buffer // // The function takes the following parameters: // // - buffer *Buffer: A #GstBuffer // // Set the buffer associated with @sample. @sample must be writable. func (sample *Sample) SetBuffer(buffer *Buffer) { var carg0 *C.GstSample // in, none, converted var carg1 *C.GstBuffer // in, none, converted carg0 = (*C.GstSample)(UnsafeSampleToGlibNone(sample)) carg1 = (*C.GstBuffer)(UnsafeBufferToGlibNone(buffer)) C.gst_sample_set_buffer(carg0, carg1) runtime.KeepAlive(sample) runtime.KeepAlive(buffer) } // SetBufferList wraps gst_sample_set_buffer_list // // The function takes the following parameters: // // - bufferList *BufferList: a #GstBufferList // // Set the buffer list associated with @sample. @sample must be writable. func (sample *Sample) SetBufferList(bufferList *BufferList) { var carg0 *C.GstSample // in, none, converted var carg1 *C.GstBufferList // in, none, converted carg0 = (*C.GstSample)(UnsafeSampleToGlibNone(sample)) carg1 = (*C.GstBufferList)(UnsafeBufferListToGlibNone(bufferList)) C.gst_sample_set_buffer_list(carg0, carg1) runtime.KeepAlive(sample) runtime.KeepAlive(bufferList) } // SetCaps wraps gst_sample_set_caps // // The function takes the following parameters: // // - caps *Caps: A #GstCaps // // Set the caps associated with @sample. @sample must be writable. func (sample *Sample) SetCaps(caps *Caps) { var carg0 *C.GstSample // in, none, converted var carg1 *C.GstCaps // in, none, converted carg0 = (*C.GstSample)(UnsafeSampleToGlibNone(sample)) carg1 = (*C.GstCaps)(UnsafeCapsToGlibNone(caps)) C.gst_sample_set_caps(carg0, carg1) runtime.KeepAlive(sample) runtime.KeepAlive(caps) } // SetInfo wraps gst_sample_set_info // // The function takes the following parameters: // // - info *Structure: A #GstStructure // // The function returns the following values: // // - goret bool // // Set the info structure associated with @sample. @sample must be writable, // and @info must not have a parent set already. func (sample *Sample) SetInfo(info *Structure) bool { var carg0 *C.GstSample // in, none, converted var carg1 *C.GstStructure // in, full, converted var cret C.gboolean // return carg0 = (*C.GstSample)(UnsafeSampleToGlibNone(sample)) carg1 = (*C.GstStructure)(UnsafeStructureToGlibFull(info)) cret = C.gst_sample_set_info(carg0, carg1) runtime.KeepAlive(sample) runtime.KeepAlive(info) var goret bool if cret != 0 { goret = true } return goret } // SetSegment wraps gst_sample_set_segment // // The function takes the following parameters: // // - segment *Segment: A #GstSegment // // Set the segment associated with @sample. @sample must be writable. func (sample *Sample) SetSegment(segment *Segment) { var carg0 *C.GstSample // in, none, converted var carg1 *C.GstSegment // in, none, converted carg0 = (*C.GstSample)(UnsafeSampleToGlibNone(sample)) carg1 = (*C.GstSegment)(UnsafeSegmentToGlibNone(segment)) C.gst_sample_set_segment(carg0, carg1) runtime.KeepAlive(sample) runtime.KeepAlive(segment) } // Segment wraps GstSegment // // This helper structure holds the relevant values for tracking the region of // interest in a media file, called a segment. // // The structure can be used for two purposes: // // * performing seeks (handling seek events) // * tracking playback regions (handling newsegment events) // // The segment is usually configured by the application with a seek event which // is propagated upstream and eventually handled by an element that performs the seek. // // The configured segment is then propagated back downstream with a newsegment event. // This information is then used to clip media to the segment boundaries. // // A segment structure is initialized with gst_segment_init(), which takes a #GstFormat // that will be used as the format of the segment values. The segment will be configured // with a start value of 0 and a stop/duration of -1, which is undefined. The default // rate and applied_rate is 1.0. // // The public duration field contains the duration of the segment. When using // the segment for seeking, the start and time members should normally be left // to their default 0 value. The stop position is left to -1 unless explicitly // configured to a different value after a seek event. // // The current position in the segment should be set by changing the position // member in the structure. // // For elements that perform seeks, the current segment should be updated with the // gst_segment_do_seek() and the values from the seek event. This method will update // all the segment fields. The position field will contain the new playback position. // If the start_type was different from GST_SEEK_TYPE_NONE, playback continues from // the position position, possibly with updated flags or rate. // // For elements that want to use #GstSegment to track the playback region, // update the segment fields with the information from the newsegment event. // The gst_segment_clip() method can be used to check and clip // the media data to the segment boundaries. // // For elements that want to synchronize to the pipeline clock, gst_segment_to_running_time() // can be used to convert a timestamp to a value that can be used to synchronize // to the clock. This function takes into account the base as well as // any rate or applied_rate conversions. // // For elements that need to perform operations on media data in stream_time, // gst_segment_to_stream_time() can be used to convert a timestamp and the segment // info to stream time (which is always between 0 and the duration of the stream). type Segment struct { *segment } // segment is the struct that's finalized type segment struct { native *C.GstSegment } var _ gobject.GoValueInitializer = (*Segment)(nil) func marshalSegment(p unsafe.Pointer) (interface{}, error) { b := gobject.ValueFromNative(p).Boxed() return UnsafeSegmentFromGlibBorrow(b), nil } func (r *Segment) InitGoValue(v *gobject.Value) { v.Init(TypeSegment) v.SetBoxed(unsafe.Pointer(r.native)) } // UnsafeSegmentFromGlibBorrow is used to convert raw C.GstSegment pointers to go. This is used by the bindings internally. func UnsafeSegmentFromGlibBorrow(p unsafe.Pointer) *Segment { return &Segment{&segment{(*C.GstSegment)(p)}} } // 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) runtime.SetFinalizer( wrapped.segment, func (intern *segment) { C.gst_segment_free(intern.native) }, ) return wrapped } // 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( wrapped.segment, func (intern *segment) { C.gst_segment_free(intern.native) }, ) return wrapped } // UnsafeSegmentFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [Segment] is expected to work anymore. func UnsafeSegmentFree(s *Segment) { C.gst_segment_free(s.native) } // UnsafeSegmentToGlibNone returns the underlying C pointer. This is used by the bindings internally. func UnsafeSegmentToGlibNone(s *Segment) unsafe.Pointer { return unsafe.Pointer(s.native) } // UnsafeSegmentToGlibFull returns the underlying C pointer and gives up ownership. // This is used by the bindings internally. func UnsafeSegmentToGlibFull(s *Segment) unsafe.Pointer { runtime.SetFinalizer(s.segment, nil) _p := unsafe.Pointer(s.native) s.native = nil // Segment is invalid from here on return _p } // NewSegment wraps gst_segment_new // // The function returns the following values: // // - goret *Segment // // Allocate a new #GstSegment structure and initialize it using // gst_segment_init(). // // Free-function: gst_segment_free func NewSegment() *Segment { var cret *C.GstSegment // return, full, converted cret = C.gst_segment_new() var goret *Segment goret = UnsafeSegmentFromGlibFull(unsafe.Pointer(cret)) return goret } // Clip wraps gst_segment_clip // // The function takes the following parameters: // // - format Format: the format of the segment. // - start uint64: the start position in the segment // - stop uint64: the stop position in the segment // // The function returns the following values: // // - clipStart uint64: the clipped start position in the segment // - clipStop uint64: the clipped stop position in the segment // - goret bool // // Clip the given @start and @stop values to the segment boundaries given // in @segment. @start and @stop are compared and clipped to @segment // start and stop values. // // If the function returns %FALSE, @start and @stop are known to fall // outside of @segment and @clip_start and @clip_stop are not updated. // // When the function returns %TRUE, @clip_start and @clip_stop will be // updated. If @clip_start or @clip_stop are different from @start or @stop // respectively, the region fell partially in the segment. // // Note that when @stop is -1, @clip_stop will be set to the end of the // segment. Depending on the use case, this may or may not be what you want. func (segment *Segment) Clip(format Format, start uint64, stop uint64) (uint64, uint64, bool) { var carg0 *C.GstSegment // in, none, converted var carg1 C.GstFormat // in, none, casted var carg2 C.guint64 // in, none, casted var carg3 C.guint64 // in, none, casted var carg4 C.guint64 // out, full, casted var carg5 C.guint64 // out, full, casted var cret C.gboolean // return carg0 = (*C.GstSegment)(UnsafeSegmentToGlibNone(segment)) carg1 = C.GstFormat(format) carg2 = C.guint64(start) carg3 = C.guint64(stop) cret = C.gst_segment_clip(carg0, carg1, carg2, carg3, &carg4, &carg5) runtime.KeepAlive(segment) runtime.KeepAlive(format) runtime.KeepAlive(start) runtime.KeepAlive(stop) var clipStart uint64 var clipStop uint64 var goret bool clipStart = uint64(carg4) clipStop = uint64(carg5) if cret != 0 { goret = true } return clipStart, clipStop, goret } // Copy wraps gst_segment_copy // // The function returns the following values: // // - goret *Segment // // Create a copy of given @segment. // // Free-function: gst_segment_free func (segment *Segment) Copy() *Segment { var carg0 *C.GstSegment // in, none, converted var cret *C.GstSegment // return, full, converted carg0 = (*C.GstSegment)(UnsafeSegmentToGlibNone(segment)) cret = C.gst_segment_copy(carg0) runtime.KeepAlive(segment) var goret *Segment goret = UnsafeSegmentFromGlibFull(unsafe.Pointer(cret)) return goret } // CopyInto wraps gst_segment_copy_into // // The function takes the following parameters: // // - dest *Segment: a #GstSegment // // Copy the contents of @src into @dest. func (src *Segment) CopyInto(dest *Segment) { var carg0 *C.GstSegment // in, none, converted var carg1 *C.GstSegment // in, none, converted carg0 = (*C.GstSegment)(UnsafeSegmentToGlibNone(src)) carg1 = (*C.GstSegment)(UnsafeSegmentToGlibNone(dest)) C.gst_segment_copy_into(carg0, carg1) runtime.KeepAlive(src) runtime.KeepAlive(dest) } // DoSeek wraps gst_segment_do_seek // // The function takes the following parameters: // // - rate float64: the rate of the segment. // - format Format: the format of the segment. // - flags SeekFlags: the segment flags for the segment // - startType SeekType: the seek method // - start uint64: the seek start value // - stopType SeekType: the seek method // - stop uint64: the seek stop value // // The function returns the following values: // // - update bool: boolean holding whether position was updated. // - goret bool // // Update the segment structure with the field values of a seek event (see // gst_event_new_seek()). // // After calling this method, the segment field position and time will // contain the requested new position in the segment. The new requested // position in the segment depends on @rate and @start_type and @stop_type. // // For positive @rate, the new position in the segment is the new @segment // start field when it was updated with a @start_type different from // #GST_SEEK_TYPE_NONE. If no update was performed on @segment start position // (#GST_SEEK_TYPE_NONE), @start is ignored and @segment position is // unmodified. // // For negative @rate, the new position in the segment is the new @segment // stop field when it was updated with a @stop_type different from // #GST_SEEK_TYPE_NONE. If no stop was previously configured in the segment, the // duration of the segment will be used to update the stop position. // If no update was performed on @segment stop position (#GST_SEEK_TYPE_NONE), // @stop is ignored and @segment position is unmodified. // // The applied rate of the segment will be set to 1.0 by default. // If the caller can apply a rate change, it should update @segment // rate and applied_rate after calling this function. // // @update will be set to %TRUE if a seek should be performed to the segment // position field. This field can be %FALSE if, for example, only the @rate // has been changed but not the playback position. func (segment *Segment) DoSeek(rate float64, format Format, flags SeekFlags, startType SeekType, start uint64, stopType SeekType, stop uint64) (bool, bool) { var carg0 *C.GstSegment // in, none, converted var carg1 C.gdouble // in, none, casted var carg2 C.GstFormat // in, none, casted var carg3 C.GstSeekFlags // in, none, casted var carg4 C.GstSeekType // in, none, casted var carg5 C.guint64 // in, none, casted var carg6 C.GstSeekType // in, none, casted var carg7 C.guint64 // in, none, casted var carg8 C.gboolean // out var cret C.gboolean // return carg0 = (*C.GstSegment)(UnsafeSegmentToGlibNone(segment)) carg1 = C.gdouble(rate) carg2 = C.GstFormat(format) carg3 = C.GstSeekFlags(flags) carg4 = C.GstSeekType(startType) carg5 = C.guint64(start) carg6 = C.GstSeekType(stopType) carg7 = C.guint64(stop) cret = C.gst_segment_do_seek(carg0, carg1, carg2, carg3, carg4, carg5, carg6, carg7, &carg8) runtime.KeepAlive(segment) runtime.KeepAlive(rate) runtime.KeepAlive(format) runtime.KeepAlive(flags) runtime.KeepAlive(startType) runtime.KeepAlive(start) runtime.KeepAlive(stopType) runtime.KeepAlive(stop) var update bool var goret bool if carg8 != 0 { update = true } if cret != 0 { goret = true } return update, goret } // Init wraps gst_segment_init // // The function takes the following parameters: // // - format Format: the format of the segment. // // The start/position fields are set to 0 and the stop/duration // fields are set to -1 (unknown). The default rate of 1.0 and no // flags are set. // // Initialize @segment to its default values. func (segment *Segment) Init(format Format) { var carg0 *C.GstSegment // in, none, converted var carg1 C.GstFormat // in, none, casted carg0 = (*C.GstSegment)(UnsafeSegmentToGlibNone(segment)) carg1 = C.GstFormat(format) C.gst_segment_init(carg0, carg1) runtime.KeepAlive(segment) runtime.KeepAlive(format) } // IsEqual wraps gst_segment_is_equal // // The function takes the following parameters: // // - s1 *Segment: a #GstSegment structure. // // The function returns the following values: // // - goret bool // // Checks for two segments being equal. Equality here is defined // as perfect equality, including floating point values. func (s0 *Segment) IsEqual(s1 *Segment) bool { var carg0 *C.GstSegment // in, none, converted var carg1 *C.GstSegment // in, none, converted var cret C.gboolean // return carg0 = (*C.GstSegment)(UnsafeSegmentToGlibNone(s0)) carg1 = (*C.GstSegment)(UnsafeSegmentToGlibNone(s1)) cret = C.gst_segment_is_equal(carg0, carg1) runtime.KeepAlive(s0) runtime.KeepAlive(s1) var goret bool if cret != 0 { goret = true } return goret } // OffsetRunningTime wraps gst_segment_offset_running_time // // The function takes the following parameters: // // - format Format: the format of the segment. // - offset int64: the offset to apply in the segment // // The function returns the following values: // // - goret bool // // Adjust the values in @segment so that @offset is applied to all // future running-time calculations. func (segment *Segment) OffsetRunningTime(format Format, offset int64) bool { var carg0 *C.GstSegment // in, none, converted var carg1 C.GstFormat // in, none, casted var carg2 C.gint64 // in, none, casted var cret C.gboolean // return carg0 = (*C.GstSegment)(UnsafeSegmentToGlibNone(segment)) carg1 = C.GstFormat(format) carg2 = C.gint64(offset) cret = C.gst_segment_offset_running_time(carg0, carg1, carg2) runtime.KeepAlive(segment) runtime.KeepAlive(format) runtime.KeepAlive(offset) var goret bool if cret != 0 { goret = true } return goret } // PositionFromRunningTime wraps gst_segment_position_from_running_time // // The function takes the following parameters: // // - format Format: the format of the segment. // - runningTime uint64: the running_time in the segment // // The function returns the following values: // // - goret uint64 // // Convert @running_time into a position in the segment so that // gst_segment_to_running_time() with that position returns @running_time. func (segment *Segment) PositionFromRunningTime(format Format, runningTime uint64) uint64 { var carg0 *C.GstSegment // in, none, converted var carg1 C.GstFormat // in, none, casted var carg2 C.guint64 // in, none, casted var cret C.guint64 // return, none, casted carg0 = (*C.GstSegment)(UnsafeSegmentToGlibNone(segment)) carg1 = C.GstFormat(format) carg2 = C.guint64(runningTime) cret = C.gst_segment_position_from_running_time(carg0, carg1, carg2) runtime.KeepAlive(segment) runtime.KeepAlive(format) runtime.KeepAlive(runningTime) var goret uint64 goret = uint64(cret) return goret } // PositionFromRunningTimeFull wraps gst_segment_position_from_running_time_full // // The function takes the following parameters: // // - format Format: the format of the segment. // - runningTime uint64: the running-time // // The function returns the following values: // // - position uint64: the resulting position in the segment // - goret int // // Translate @running_time to the segment position using the currently configured // segment. Compared to gst_segment_position_from_running_time() this function can // return negative segment position. // // This function is typically used by elements that need to synchronize buffers // against the clock or each other. // // @running_time can be any value and the result of this function for values // outside of the segment is extrapolated. // // When 1 is returned, @running_time resulted in a positive position returned // in @position. // // When this function returns -1, the returned @position was < 0, and the value // in the position variable should be negated to get the real negative segment // position. func (segment *Segment) PositionFromRunningTimeFull(format Format, runningTime uint64) (uint64, int) { var carg0 *C.GstSegment // in, none, converted var carg1 C.GstFormat // in, none, casted var carg2 C.guint64 // in, none, casted var carg3 C.guint64 // out, full, casted var cret C.gint // return, none, casted carg0 = (*C.GstSegment)(UnsafeSegmentToGlibNone(segment)) carg1 = C.GstFormat(format) carg2 = C.guint64(runningTime) cret = C.gst_segment_position_from_running_time_full(carg0, carg1, carg2, &carg3) runtime.KeepAlive(segment) runtime.KeepAlive(format) runtime.KeepAlive(runningTime) var position uint64 var goret int position = uint64(carg3) goret = int(cret) return position, goret } // PositionFromStreamTime wraps gst_segment_position_from_stream_time // // The function takes the following parameters: // // - format Format: the format of the segment. // - streamTime uint64: the stream_time in the segment // // The function returns the following values: // // - goret uint64 // // Convert @stream_time into a position in the segment so that // gst_segment_to_stream_time() with that position returns @stream_time. func (segment *Segment) PositionFromStreamTime(format Format, streamTime uint64) uint64 { var carg0 *C.GstSegment // in, none, converted var carg1 C.GstFormat // in, none, casted var carg2 C.guint64 // in, none, casted var cret C.guint64 // return, none, casted carg0 = (*C.GstSegment)(UnsafeSegmentToGlibNone(segment)) carg1 = C.GstFormat(format) carg2 = C.guint64(streamTime) cret = C.gst_segment_position_from_stream_time(carg0, carg1, carg2) runtime.KeepAlive(segment) runtime.KeepAlive(format) runtime.KeepAlive(streamTime) var goret uint64 goret = uint64(cret) return goret } // PositionFromStreamTimeFull wraps gst_segment_position_from_stream_time_full // // The function takes the following parameters: // // - format Format: the format of the segment. // - streamTime uint64: the stream-time // // The function returns the following values: // // - position uint64: the resulting position in the segment // - goret int // // Translate @stream_time to the segment position using the currently configured // segment. Compared to gst_segment_position_from_stream_time() this function can // return negative segment position. // // This function is typically used by elements that need to synchronize buffers // against the clock or each other. // // @stream_time can be any value and the result of this function for values outside // of the segment is extrapolated. // // When 1 is returned, @stream_time resulted in a positive position returned // in @position. // // When this function returns -1, the returned @position should be negated // to get the real negative segment position. func (segment *Segment) PositionFromStreamTimeFull(format Format, streamTime uint64) (uint64, int) { var carg0 *C.GstSegment // in, none, converted var carg1 C.GstFormat // in, none, casted var carg2 C.guint64 // in, none, casted var carg3 C.guint64 // out, full, casted var cret C.gint // return, none, casted carg0 = (*C.GstSegment)(UnsafeSegmentToGlibNone(segment)) carg1 = C.GstFormat(format) carg2 = C.guint64(streamTime) cret = C.gst_segment_position_from_stream_time_full(carg0, carg1, carg2, &carg3) runtime.KeepAlive(segment) runtime.KeepAlive(format) runtime.KeepAlive(streamTime) var position uint64 var goret int position = uint64(carg3) goret = int(cret) return position, goret } // SetRunningTime wraps gst_segment_set_running_time // // The function takes the following parameters: // // - format Format: the format of the segment. // - runningTime uint64: the running_time in the segment // // The function returns the following values: // // - goret bool // // Adjust the start/stop and base values of @segment such that the next valid // buffer will be one with @running_time. func (segment *Segment) SetRunningTime(format Format, runningTime uint64) bool { var carg0 *C.GstSegment // in, none, converted var carg1 C.GstFormat // in, none, casted var carg2 C.guint64 // in, none, casted var cret C.gboolean // return carg0 = (*C.GstSegment)(UnsafeSegmentToGlibNone(segment)) carg1 = C.GstFormat(format) carg2 = C.guint64(runningTime) cret = C.gst_segment_set_running_time(carg0, carg1, carg2) runtime.KeepAlive(segment) runtime.KeepAlive(format) runtime.KeepAlive(runningTime) var goret bool if cret != 0 { goret = true } return goret } // ToPosition wraps gst_segment_to_position // // The function takes the following parameters: // // - format Format: the format of the segment. // - runningTime uint64: the running_time in the segment // // The function returns the following values: // // - goret uint64 // // Convert @running_time into a position in the segment so that // gst_segment_to_running_time() with that position returns @running_time. // // Deprecated: Use gst_segment_position_from_running_time() instead. func (segment *Segment) ToPosition(format Format, runningTime uint64) uint64 { var carg0 *C.GstSegment // in, none, converted var carg1 C.GstFormat // in, none, casted var carg2 C.guint64 // in, none, casted var cret C.guint64 // return, none, casted carg0 = (*C.GstSegment)(UnsafeSegmentToGlibNone(segment)) carg1 = C.GstFormat(format) carg2 = C.guint64(runningTime) cret = C.gst_segment_to_position(carg0, carg1, carg2) runtime.KeepAlive(segment) runtime.KeepAlive(format) runtime.KeepAlive(runningTime) var goret uint64 goret = uint64(cret) return goret } // ToRunningTime wraps gst_segment_to_running_time // // The function takes the following parameters: // // - format Format: the format of the segment. // - position uint64: the position in the segment // // The function returns the following values: // // - goret uint64 // // Translate @position to the total running time using the currently configured // segment. Position is a value between @segment start and stop time. // // This function is typically used by elements that need to synchronize to the // global clock in a pipeline. The running time is a constantly increasing value // starting from 0. When gst_segment_init() is called, this value will reset to // 0. // // This function returns -1 if the position is outside of @segment start and stop. func (segment *Segment) ToRunningTime(format Format, position uint64) uint64 { var carg0 *C.GstSegment // in, none, converted var carg1 C.GstFormat // in, none, casted var carg2 C.guint64 // in, none, casted var cret C.guint64 // return, none, casted carg0 = (*C.GstSegment)(UnsafeSegmentToGlibNone(segment)) carg1 = C.GstFormat(format) carg2 = C.guint64(position) cret = C.gst_segment_to_running_time(carg0, carg1, carg2) runtime.KeepAlive(segment) runtime.KeepAlive(format) runtime.KeepAlive(position) var goret uint64 goret = uint64(cret) return goret } // ToRunningTimeFull wraps gst_segment_to_running_time_full // // The function takes the following parameters: // // - format Format: the format of the segment. // - position uint64: the position in the segment // // The function returns the following values: // // - runningTime uint64: result running-time // - goret int // // Translate @position to the total running time using the currently configured // segment. Compared to gst_segment_to_running_time() this function can return // negative running-time. // // This function is typically used by elements that need to synchronize buffers // against the clock or each other. // // @position can be any value and the result of this function for values outside // of the segment is extrapolated. // // When 1 is returned, @position resulted in a positive running-time returned // in @running_time. // // When this function returns -1, the returned @running_time should be negated // to get the real negative running time. func (segment *Segment) ToRunningTimeFull(format Format, position uint64) (uint64, int) { var carg0 *C.GstSegment // in, none, converted var carg1 C.GstFormat // in, none, casted var carg2 C.guint64 // in, none, casted var carg3 C.guint64 // out, full, casted var cret C.gint // return, none, casted carg0 = (*C.GstSegment)(UnsafeSegmentToGlibNone(segment)) carg1 = C.GstFormat(format) carg2 = C.guint64(position) cret = C.gst_segment_to_running_time_full(carg0, carg1, carg2, &carg3) runtime.KeepAlive(segment) runtime.KeepAlive(format) runtime.KeepAlive(position) var runningTime uint64 var goret int runningTime = uint64(carg3) goret = int(cret) return runningTime, goret } // ToStreamTime wraps gst_segment_to_stream_time // // The function takes the following parameters: // // - format Format: the format of the segment. // - position uint64: the position in the segment // // The function returns the following values: // // - goret uint64 // // Translate @position to stream time using the currently configured // segment. The @position value must be between @segment start and // stop value. // // This function is typically used by elements that need to operate on // the stream time of the buffers it receives, such as effect plugins. // In those use cases, @position is typically the buffer timestamp or // clock time that one wants to convert to the stream time. // The stream time is always between 0 and the total duration of the // media stream. func (segment *Segment) ToStreamTime(format Format, position uint64) uint64 { var carg0 *C.GstSegment // in, none, converted var carg1 C.GstFormat // in, none, casted var carg2 C.guint64 // in, none, casted var cret C.guint64 // return, none, casted carg0 = (*C.GstSegment)(UnsafeSegmentToGlibNone(segment)) carg1 = C.GstFormat(format) carg2 = C.guint64(position) cret = C.gst_segment_to_stream_time(carg0, carg1, carg2) runtime.KeepAlive(segment) runtime.KeepAlive(format) runtime.KeepAlive(position) var goret uint64 goret = uint64(cret) return goret } // ToStreamTimeFull wraps gst_segment_to_stream_time_full // // The function takes the following parameters: // // - format Format: the format of the segment. // - position uint64: the position in the segment // // The function returns the following values: // // - streamTime uint64: result stream-time // - goret int // // Translate @position to the total stream time using the currently configured // segment. Compared to gst_segment_to_stream_time() this function can return // negative stream-time. // // This function is typically used by elements that need to synchronize buffers // against the clock or each other. // // @position can be any value and the result of this function for values outside // of the segment is extrapolated. // // When 1 is returned, @position resulted in a positive stream-time returned // in @stream_time. // // When this function returns -1, the returned @stream_time should be negated // to get the real negative stream time. func (segment *Segment) ToStreamTimeFull(format Format, position uint64) (uint64, int) { var carg0 *C.GstSegment // in, none, converted var carg1 C.GstFormat // in, none, casted var carg2 C.guint64 // in, none, casted var carg3 C.guint64 // out, full, casted var cret C.gint // return, none, casted carg0 = (*C.GstSegment)(UnsafeSegmentToGlibNone(segment)) carg1 = C.GstFormat(format) carg2 = C.guint64(position) cret = C.gst_segment_to_stream_time_full(carg0, carg1, carg2, &carg3) runtime.KeepAlive(segment) runtime.KeepAlive(format) runtime.KeepAlive(position) var streamTime uint64 var goret int streamTime = uint64(carg3) goret = int(cret) return streamTime, goret } // SharedTaskPoolClass wraps GstSharedTaskPoolClass // // The #GstSharedTaskPoolClass object. // // SharedTaskPoolClass is the type struct for [SharedTaskPool] type SharedTaskPoolClass struct { *sharedTaskPoolClass } // sharedTaskPoolClass is the struct that's finalized type sharedTaskPoolClass struct { native *C.GstSharedTaskPoolClass } // UnsafeSharedTaskPoolClassFromGlibBorrow is used to convert raw C.GstSharedTaskPoolClass pointers to go. This is used by the bindings internally. func UnsafeSharedTaskPoolClassFromGlibBorrow(p unsafe.Pointer) *SharedTaskPoolClass { return &SharedTaskPoolClass{&sharedTaskPoolClass{(*C.GstSharedTaskPoolClass)(p)}} } // 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. func UnsafeSharedTaskPoolClassFree(s *SharedTaskPoolClass) { C.free(unsafe.Pointer(s.native)) } // UnsafeSharedTaskPoolClassToGlibNone returns the underlying C pointer. This is used by the bindings internally. func UnsafeSharedTaskPoolClassToGlibNone(s *SharedTaskPoolClass) unsafe.Pointer { return unsafe.Pointer(s.native) } // 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 // used in conjunction with GST_STATIC_CAPS() and gst_static_caps_get() to // instantiate a #GstCaps. type StaticCaps struct { *staticCaps } // staticCaps is the struct that's finalized type staticCaps struct { native *C.GstStaticCaps } var _ gobject.GoValueInitializer = (*StaticCaps)(nil) func marshalStaticCaps(p unsafe.Pointer) (interface{}, error) { b := gobject.ValueFromNative(p).Boxed() return UnsafeStaticCapsFromGlibBorrow(b), nil } func (r *StaticCaps) InitGoValue(v *gobject.Value) { v.Init(TypeStaticCaps) v.SetBoxed(unsafe.Pointer(r.native)) } // UnsafeStaticCapsFromGlibBorrow is used to convert raw C.GstStaticCaps pointers to go. This is used by the bindings internally. func UnsafeStaticCapsFromGlibBorrow(p unsafe.Pointer) *StaticCaps { return &StaticCaps{&staticCaps{(*C.GstStaticCaps)(p)}} } // 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) runtime.SetFinalizer( wrapped.staticCaps, func (intern *staticCaps) { C.free(unsafe.Pointer(intern.native)) }, ) return wrapped } // 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( wrapped.staticCaps, func (intern *staticCaps) { C.free(unsafe.Pointer(intern.native)) }, ) return wrapped } // UnsafeStaticCapsFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [StaticCaps] is expected to work anymore. func UnsafeStaticCapsFree(s *StaticCaps) { C.free(unsafe.Pointer(s.native)) } // UnsafeStaticCapsToGlibNone returns the underlying C pointer. This is used by the bindings internally. func UnsafeStaticCapsToGlibNone(s *StaticCaps) unsafe.Pointer { return unsafe.Pointer(s.native) } // UnsafeStaticCapsToGlibFull returns the underlying C pointer and gives up ownership. // This is used by the bindings internally. func UnsafeStaticCapsToGlibFull(s *StaticCaps) unsafe.Pointer { runtime.SetFinalizer(s.staticCaps, nil) _p := unsafe.Pointer(s.native) 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. func (staticCaps *StaticCaps) Cleanup() { var carg0 *C.GstStaticCaps // in, none, converted carg0 = (*C.GstStaticCaps)(UnsafeStaticCapsToGlibNone(staticCaps)) C.gst_static_caps_cleanup(carg0) runtime.KeepAlive(staticCaps) } // Get wraps gst_static_caps_get // // The function returns the following values: // // - goret *Caps (nullable) // // Converts a #GstStaticCaps to a #GstCaps. func (staticCaps *StaticCaps) Get() *Caps { var carg0 *C.GstStaticCaps // in, none, converted var cret *C.GstCaps // return, full, converted, nullable carg0 = (*C.GstStaticCaps)(UnsafeStaticCapsToGlibNone(staticCaps)) cret = C.gst_static_caps_get(carg0) runtime.KeepAlive(staticCaps) var goret *Caps if cret != nil { goret = UnsafeCapsFromGlibFull(unsafe.Pointer(cret)) } return goret } // StaticPadTemplate wraps GstStaticPadTemplate // // Structure describing the #GstStaticPadTemplate. type StaticPadTemplate struct { *staticPadTemplate } // staticPadTemplate is the struct that's finalized type staticPadTemplate struct { native *C.GstStaticPadTemplate } var _ gobject.GoValueInitializer = (*StaticPadTemplate)(nil) func marshalStaticPadTemplate(p unsafe.Pointer) (interface{}, error) { b := gobject.ValueFromNative(p).Boxed() return UnsafeStaticPadTemplateFromGlibBorrow(b), nil } func (r *StaticPadTemplate) InitGoValue(v *gobject.Value) { v.Init(TypeStaticPadTemplate) v.SetBoxed(unsafe.Pointer(r.native)) } // UnsafeStaticPadTemplateFromGlibBorrow is used to convert raw C.GstStaticPadTemplate pointers to go. This is used by the bindings internally. func UnsafeStaticPadTemplateFromGlibBorrow(p unsafe.Pointer) *StaticPadTemplate { return &StaticPadTemplate{&staticPadTemplate{(*C.GstStaticPadTemplate)(p)}} } // 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) runtime.SetFinalizer( wrapped.staticPadTemplate, func (intern *staticPadTemplate) { C.free(unsafe.Pointer(intern.native)) }, ) return wrapped } // 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( wrapped.staticPadTemplate, func (intern *staticPadTemplate) { C.free(unsafe.Pointer(intern.native)) }, ) return wrapped } // UnsafeStaticPadTemplateFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [StaticPadTemplate] is expected to work anymore. func UnsafeStaticPadTemplateFree(s *StaticPadTemplate) { C.free(unsafe.Pointer(s.native)) } // UnsafeStaticPadTemplateToGlibNone returns the underlying C pointer. This is used by the bindings internally. func UnsafeStaticPadTemplateToGlibNone(s *StaticPadTemplate) unsafe.Pointer { return unsafe.Pointer(s.native) } // UnsafeStaticPadTemplateToGlibFull returns the underlying C pointer and gives up ownership. // This is used by the bindings internally. func UnsafeStaticPadTemplateToGlibFull(s *StaticPadTemplate) unsafe.Pointer { runtime.SetFinalizer(s.staticPadTemplate, nil) _p := unsafe.Pointer(s.native) 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) // // Converts a #GstStaticPadTemplate into a #GstPadTemplate. func (padTemplate *StaticPadTemplate) Get() PadTemplate { var carg0 *C.GstStaticPadTemplate // in, none, converted var cret *C.GstPadTemplate // return, none, converted, nullable carg0 = (*C.GstStaticPadTemplate)(UnsafeStaticPadTemplateToGlibNone(padTemplate)) cret = C.gst_static_pad_template_get(carg0) runtime.KeepAlive(padTemplate) var goret PadTemplate if cret != nil { goret = UnsafePadTemplateFromGlibNone(unsafe.Pointer(cret)) } return goret } // GetCaps wraps gst_static_pad_template_get_caps // // The function returns the following values: // // - goret *Caps // // Gets the capabilities of the static pad template. func (templ *StaticPadTemplate) GetCaps() *Caps { var carg0 *C.GstStaticPadTemplate // in, none, converted var cret *C.GstCaps // return, full, converted carg0 = (*C.GstStaticPadTemplate)(UnsafeStaticPadTemplateToGlibNone(templ)) cret = C.gst_static_pad_template_get_caps(carg0) runtime.KeepAlive(templ) var goret *Caps goret = UnsafeCapsFromGlibFull(unsafe.Pointer(cret)) return goret } // StreamClass wraps GstStreamClass // // GstStream class structure // // StreamClass is the type struct for [Stream] type StreamClass struct { *streamClass } // streamClass is the struct that's finalized type streamClass struct { native *C.GstStreamClass } // UnsafeStreamClassFromGlibBorrow is used to convert raw C.GstStreamClass pointers to go. This is used by the bindings internally. func UnsafeStreamClassFromGlibBorrow(p unsafe.Pointer) *StreamClass { return &StreamClass{&streamClass{(*C.GstStreamClass)(p)}} } // 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. func UnsafeStreamClassFree(s *StreamClass) { C.free(unsafe.Pointer(s.native)) } // UnsafeStreamClassToGlibNone returns the underlying C pointer. This is used by the bindings internally. func UnsafeStreamClassToGlibNone(s *StreamClass) unsafe.Pointer { return unsafe.Pointer(s.native) } // 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 } // streamCollectionClass is the struct that's finalized type streamCollectionClass struct { native *C.GstStreamCollectionClass } // UnsafeStreamCollectionClassFromGlibBorrow is used to convert raw C.GstStreamCollectionClass pointers to go. This is used by the bindings internally. func UnsafeStreamCollectionClassFromGlibBorrow(p unsafe.Pointer) *StreamCollectionClass { return &StreamCollectionClass{&streamCollectionClass{(*C.GstStreamCollectionClass)(p)}} } // 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. func UnsafeStreamCollectionClassFree(s *StreamCollectionClass) { C.free(unsafe.Pointer(s.native)) } // UnsafeStreamCollectionClassToGlibNone returns the underlying C pointer. This is used by the bindings internally. func UnsafeStreamCollectionClassToGlibNone(s *StreamCollectionClass) unsafe.Pointer { return unsafe.Pointer(s.native) } // 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 // GQuarks and the values can be of any GType. // // In addition to the key/value pairs, a #GstStructure also has a name. The name // starts with a letter and can be filled by letters, numbers and any of // "/-_.:". // // #GstStructure is used by various GStreamer subsystems to store information in // a flexible and extensible way. A #GstStructure does not have a refcount // because it usually is part of a higher level object such as #GstCaps, // #GstMessage, #GstEvent, #GstQuery. It provides a means to enforce mutability // using the refcount of the parent with the gst_structure_set_parent_refcount() // method. // // A #GstStructure can be created with gst_structure_new_empty() or // gst_structure_new(), which both take a name and an optional set of key/value // pairs along with the types of the values. // // Field values can be changed with gst_structure_set_value() or // gst_structure_set(). // // Field values can be retrieved with gst_structure_get_value() or the more // convenient gst_structure_get_*() functions. // // Fields can be removed with gst_structure_remove_field() or // gst_structure_remove_fields(). // // Strings in structures must be ASCII or UTF-8 encoded. Other encodings are not // allowed. Strings may be %NULL however. // // ## The serialization format // // GstStructure serialization format serialize the GstStructure name, // keys/GType/values in a comma separated list with the structure name as first // field without value followed by separated key/value pairs in the form // `key=value`, for example: // // ``` // a-structure, key=value // ```` // // The values type will be inferred if not explicitly specified with the // `(GTypeName)value` syntax, for example the following struct will have one // field called 'is-string' which has the string 'true' as a value: // // ``` // a-struct, field-is-string=(string)true, field-is-boolean=true // ``` // // *Note*: without specifying `(string), `field-is-string` type would have been // inferred as boolean. // // *Note*: we specified `(string)` as a type even if `gchararray` is the actual // GType name as for convenience some well known types have been aliased or // abbreviated. // // To avoid specifying the type, you can give some hints to the "type system". // For example to specify a value as a double, you should add a decimal (ie. `1` // is an `int` while `1.0` is a `double`). // // *Note*: when a structure is serialized with #gst_structure_to_string, all // values are explicitly typed. // // Some types have special delimiters: // // - [GstValueArray](GST_TYPE_ARRAY) are inside curly brackets (`{` and `}`). // For example `a-structure, array={1, 2, 3}` // - Ranges are inside brackets (`[` and `]`). For example `a-structure, // range=[1, 6, 2]` 1 being the min value, 6 the maximum and 2 the step. To // specify a #GST_TYPE_INT64_RANGE you need to explicitly specify it like: // `a-structure, a-int64-range=(gint64) [1, 5]` // - [GstValueList](GST_TYPE_LIST) are inside "less and greater than" (`<` and // `>`). For example `a-structure, list=<1, 2, 3> // // Structures are delimited either by a null character `\0` or a semicolon `;` // the latter allowing to store multiple structures in the same string (see // #GstCaps). // // Quotes are used as "default" delimiters and can be used around any types that // don't use other delimiters (for example `a-struct, i=(int)"1"`). They are use // to allow adding spaces or special characters (such as delimiters, // semicolumns, etc..) inside strings and you can use backslashes `\` to escape // characters inside them, for example: // // ``` // a-struct, special="\"{[(;)]}\" can be used inside quotes" // ``` // // They also allow for nested structure, such as: // // ``` // a-struct, nested=(GstStructure)"nested-struct, nested=true" // ``` // // Since 1.20, nested structures and caps can be specified using brackets (`[` // and `]`), for example: // // ``` // a-struct, nested=[nested-struct, nested=true] // ``` // // > *note*: gst_structure_to_string() won't use that syntax for backward // > compatibility reason, gst_structure_serialize_full() has been added for // > that purpose. type Structure struct { *structure } // structure is the struct that's finalized type structure struct { native *C.GstStructure } var _ gobject.GoValueInitializer = (*Structure)(nil) func marshalStructure(p unsafe.Pointer) (interface{}, error) { b := gobject.ValueFromNative(p).Boxed() return UnsafeStructureFromGlibBorrow(b), nil } func (r *Structure) InitGoValue(v *gobject.Value) { v.Init(TypeStructure) v.SetBoxed(unsafe.Pointer(r.native)) } // UnsafeStructureFromGlibBorrow is used to convert raw C.GstStructure pointers to go. This is used by the bindings internally. func UnsafeStructureFromGlibBorrow(p unsafe.Pointer) *Structure { return &Structure{&structure{(*C.GstStructure)(p)}} } // 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) runtime.SetFinalizer( wrapped.structure, func (intern *structure) { C.gst_structure_free(intern.native) }, ) return wrapped } // 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( wrapped.structure, func (intern *structure) { C.gst_structure_free(intern.native) }, ) return wrapped } // UnsafeStructureFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [Structure] is expected to work anymore. func UnsafeStructureFree(s *Structure) { C.gst_structure_free(s.native) } // UnsafeStructureToGlibNone returns the underlying C pointer. This is used by the bindings internally. func UnsafeStructureToGlibNone(s *Structure) unsafe.Pointer { return unsafe.Pointer(s.native) } // UnsafeStructureToGlibFull returns the underlying C pointer and gives up ownership. // This is used by the bindings internally. func UnsafeStructureToGlibFull(s *Structure) unsafe.Pointer { runtime.SetFinalizer(s.structure, nil) _p := unsafe.Pointer(s.native) s.native = nil // Structure is invalid from here on return _p } // StructureFromString wraps gst_structure_from_string // // The function takes the following parameters: // // - str string: a string representation of a #GstStructure. // // The function returns the following values: // // - goret *Structure (nullable) // // Creates a #GstStructure from a string representation. // If end is not %NULL, a pointer to the place inside the given string // where parsing ended will be returned. // // Free-function: gst_structure_free func StructureFromString(str string) *Structure { var carg1 *C.gchar // in, none, string var carg2 *C.gchar // skipped var cret *C.GstStructure // return, full, converted, nullable carg1 = (*C.gchar)(unsafe.Pointer(C.CString(str))) defer C.free(unsafe.Pointer(carg1)) cret = C.gst_structure_from_string(carg1, &carg2) runtime.KeepAlive(str) var goret *Structure if cret != nil { goret = UnsafeStructureFromGlibFull(unsafe.Pointer(cret)) } return goret } // NewStructureEmpty wraps gst_structure_new_empty // // The function takes the following parameters: // // - name string: name of new structure // // The function returns the following values: // // - goret *Structure // // Creates a new, empty #GstStructure with the given @name. // // See gst_structure_set_name() for constraints on the @name parameter. // // Free-function: gst_structure_free func NewStructureEmpty(name string) *Structure { var carg1 *C.gchar // in, none, string var cret *C.GstStructure // return, full, converted carg1 = (*C.gchar)(unsafe.Pointer(C.CString(name))) defer C.free(unsafe.Pointer(carg1)) cret = C.gst_structure_new_empty(carg1) runtime.KeepAlive(name) var goret *Structure goret = UnsafeStructureFromGlibFull(unsafe.Pointer(cret)) return goret } // NewStructureFromString wraps gst_structure_new_from_string // // The function takes the following parameters: // // - str string: a string representation of a #GstStructure // // The function returns the following values: // // - goret *Structure (nullable) // // Creates a #GstStructure from a string representation. // If end is not %NULL, a pointer to the place inside the given string // where parsing ended will be returned. // // The current implementation of serialization will lead to unexpected results // when there are nested #GstCaps / #GstStructure deeper than one level unless // the gst_structure_serialize() function is used (without // #GST_SERIALIZE_FLAG_BACKWARD_COMPAT) // // Free-function: gst_structure_free func NewStructureFromString(str string) *Structure { var carg1 *C.gchar // in, none, string var cret *C.GstStructure // return, full, converted, nullable carg1 = (*C.gchar)(unsafe.Pointer(C.CString(str))) defer C.free(unsafe.Pointer(carg1)) cret = C.gst_structure_new_from_string(carg1) runtime.KeepAlive(str) var goret *Structure if cret != nil { goret = UnsafeStructureFromGlibFull(unsafe.Pointer(cret)) } return goret } // NewStructureIDEmpty wraps gst_structure_new_id_empty // // The function takes the following parameters: // // - quark glib.Quark: name of new structure // // The function returns the following values: // // - goret *Structure // // Creates a new, empty #GstStructure with the given name as a GQuark. // // Free-function: gst_structure_free func NewStructureIDEmpty(quark glib.Quark) *Structure { var carg1 C.GQuark // in, none, casted, alias var cret *C.GstStructure // return, full, converted carg1 = C.GQuark(quark) cret = C.gst_structure_new_id_empty(carg1) runtime.KeepAlive(quark) var goret *Structure goret = UnsafeStructureFromGlibFull(unsafe.Pointer(cret)) return goret } // CanIntersect wraps gst_structure_can_intersect // // The function takes the following parameters: // // - struct2 *Structure: a #GstStructure // // The function returns the following values: // // - goret bool // // Tries intersecting @struct1 and @struct2 and reports whether the result // would not be empty. func (struct1 *Structure) CanIntersect(struct2 *Structure) bool { var carg0 *C.GstStructure // in, none, converted var carg1 *C.GstStructure // in, none, converted var cret C.gboolean // return carg0 = (*C.GstStructure)(UnsafeStructureToGlibNone(struct1)) carg1 = (*C.GstStructure)(UnsafeStructureToGlibNone(struct2)) cret = C.gst_structure_can_intersect(carg0, carg1) runtime.KeepAlive(struct1) runtime.KeepAlive(struct2) var goret bool if cret != 0 { goret = true } return goret } // Copy wraps gst_structure_copy // // The function returns the following values: // // - goret *Structure // // Duplicates a #GstStructure and all its fields and values. // // Free-function: gst_structure_free func (structure *Structure) Copy() *Structure { var carg0 *C.GstStructure // in, none, converted var cret *C.GstStructure // return, full, converted carg0 = (*C.GstStructure)(UnsafeStructureToGlibNone(structure)) cret = C.gst_structure_copy(carg0) runtime.KeepAlive(structure) var goret *Structure goret = UnsafeStructureFromGlibFull(unsafe.Pointer(cret)) return goret } // FilterAndMapInPlace wraps gst_structure_filter_and_map_in_place // // The function takes the following parameters: // // - fn StructureFilterMapFunc: a function to call for each field // // Calls the provided function once for each field in the #GstStructure. In // contrast to gst_structure_foreach(), the function may modify the fields. // In contrast to gst_structure_map_in_place(), the field is removed from // the structure if %FALSE is returned from the function. // The structure must be mutable. func (structure *Structure) FilterAndMapInPlace(fn StructureFilterMapFunc) { var carg0 *C.GstStructure // in, none, converted var carg1 C.GstStructureFilterMapFunc // callback, scope: call, closure: carg2 var carg2 C.gpointer // implicit carg0 = (*C.GstStructure)(UnsafeStructureToGlibNone(structure)) carg1 = (*[0]byte)(C._gotk4_gst1_StructureFilterMapFunc) carg2 = C.gpointer(userdata.Register(fn)) defer userdata.Delete(unsafe.Pointer(carg2)) C.gst_structure_filter_and_map_in_place(carg0, carg1, carg2) runtime.KeepAlive(structure) runtime.KeepAlive(fn) } // Fixate wraps gst_structure_fixate // // Fixate all values in @structure using gst_value_fixate(). // @structure will be modified in-place and should be writable. func (structure *Structure) Fixate() { var carg0 *C.GstStructure // in, none, converted carg0 = (*C.GstStructure)(UnsafeStructureToGlibNone(structure)) C.gst_structure_fixate(carg0) runtime.KeepAlive(structure) } // FixateField wraps gst_structure_fixate_field // // The function takes the following parameters: // // - fieldName string: a field in @structure // // The function returns the following values: // // - goret bool // // Fixates a #GstStructure by changing the given field with its fixated value. func (structure *Structure) FixateField(fieldName string) bool { var carg0 *C.GstStructure // in, none, converted var carg1 *C.char // in, none, string, casted *C.gchar var cret C.gboolean // return carg0 = (*C.GstStructure)(UnsafeStructureToGlibNone(structure)) carg1 = (*C.char)(unsafe.Pointer(C.CString(fieldName))) defer C.free(unsafe.Pointer(carg1)) cret = C.gst_structure_fixate_field(carg0, carg1) runtime.KeepAlive(structure) runtime.KeepAlive(fieldName) var goret bool if cret != 0 { goret = true } return goret } // FixateFieldBoolean wraps gst_structure_fixate_field_boolean // // The function takes the following parameters: // // - fieldName string: a field in @structure // - target bool: the target value of the fixation // // The function returns the following values: // // - goret bool // // Fixates a #GstStructure by changing the given @field_name field to the given // @target boolean if that field is not fixed yet. func (structure *Structure) FixateFieldBoolean(fieldName string, target bool) bool { var carg0 *C.GstStructure // in, none, converted var carg1 *C.char // in, none, string, casted *C.gchar var carg2 C.gboolean // in var cret C.gboolean // return carg0 = (*C.GstStructure)(UnsafeStructureToGlibNone(structure)) carg1 = (*C.char)(unsafe.Pointer(C.CString(fieldName))) defer C.free(unsafe.Pointer(carg1)) if target { carg2 = C.TRUE } cret = C.gst_structure_fixate_field_boolean(carg0, carg1, carg2) runtime.KeepAlive(structure) runtime.KeepAlive(fieldName) runtime.KeepAlive(target) var goret bool if cret != 0 { goret = true } return goret } // FixateFieldNearestDouble wraps gst_structure_fixate_field_nearest_double // // The function takes the following parameters: // // - fieldName string: a field in @structure // - target float64: the target value of the fixation // // The function returns the following values: // // - goret bool // // Fixates a #GstStructure by changing the given field to the nearest // double to @target that is a subset of the existing field. func (structure *Structure) FixateFieldNearestDouble(fieldName string, target float64) bool { var carg0 *C.GstStructure // in, none, converted var carg1 *C.char // in, none, string, casted *C.gchar var carg2 C.double // in, none, casted, casted C.gdouble var cret C.gboolean // return carg0 = (*C.GstStructure)(UnsafeStructureToGlibNone(structure)) carg1 = (*C.char)(unsafe.Pointer(C.CString(fieldName))) defer C.free(unsafe.Pointer(carg1)) carg2 = C.double(target) cret = C.gst_structure_fixate_field_nearest_double(carg0, carg1, carg2) runtime.KeepAlive(structure) runtime.KeepAlive(fieldName) runtime.KeepAlive(target) var goret bool if cret != 0 { goret = true } return goret } // FixateFieldNearestFraction wraps gst_structure_fixate_field_nearest_fraction // // The function takes the following parameters: // // - fieldName string: a field in @structure // - targetNumerator int: The numerator of the target value of the fixation // - targetDenominator int: The denominator of the target value of the fixation // // The function returns the following values: // // - goret bool // // Fixates a #GstStructure by changing the given field to the nearest // fraction to @target_numerator/@target_denominator that is a subset // of the existing field. func (structure *Structure) FixateFieldNearestFraction(fieldName string, targetNumerator int, targetDenominator int) bool { var carg0 *C.GstStructure // in, none, converted var carg1 *C.char // in, none, string, casted *C.gchar var carg2 C.gint // in, none, casted var carg3 C.gint // in, none, casted var cret C.gboolean // return carg0 = (*C.GstStructure)(UnsafeStructureToGlibNone(structure)) carg1 = (*C.char)(unsafe.Pointer(C.CString(fieldName))) defer C.free(unsafe.Pointer(carg1)) carg2 = C.gint(targetNumerator) carg3 = C.gint(targetDenominator) cret = C.gst_structure_fixate_field_nearest_fraction(carg0, carg1, carg2, carg3) runtime.KeepAlive(structure) runtime.KeepAlive(fieldName) runtime.KeepAlive(targetNumerator) runtime.KeepAlive(targetDenominator) var goret bool if cret != 0 { goret = true } return goret } // FixateFieldNearestInt wraps gst_structure_fixate_field_nearest_int // // The function takes the following parameters: // // - fieldName string: a field in @structure // - target int: the target value of the fixation // // The function returns the following values: // // - goret bool // // Fixates a #GstStructure by changing the given field to the nearest // integer to @target that is a subset of the existing field. func (structure *Structure) FixateFieldNearestInt(fieldName string, target int) bool { var carg0 *C.GstStructure // in, none, converted var carg1 *C.char // in, none, string, casted *C.gchar var carg2 C.int // in, none, casted, casted C.gint var cret C.gboolean // return carg0 = (*C.GstStructure)(UnsafeStructureToGlibNone(structure)) carg1 = (*C.char)(unsafe.Pointer(C.CString(fieldName))) defer C.free(unsafe.Pointer(carg1)) carg2 = C.int(target) cret = C.gst_structure_fixate_field_nearest_int(carg0, carg1, carg2) runtime.KeepAlive(structure) runtime.KeepAlive(fieldName) runtime.KeepAlive(target) var goret bool if cret != 0 { goret = true } return goret } // FixateFieldString wraps gst_structure_fixate_field_string // // The function takes the following parameters: // // - fieldName string: a field in @structure // - target string: the target value of the fixation // // The function returns the following values: // // - goret bool // // Fixates a #GstStructure by changing the given @field_name field to the given // @target string if that field is not fixed yet. func (structure *Structure) FixateFieldString(fieldName string, target string) bool { var carg0 *C.GstStructure // in, none, converted var carg1 *C.char // in, none, string, casted *C.gchar var carg2 *C.gchar // in, none, string var cret C.gboolean // return carg0 = (*C.GstStructure)(UnsafeStructureToGlibNone(structure)) carg1 = (*C.char)(unsafe.Pointer(C.CString(fieldName))) defer C.free(unsafe.Pointer(carg1)) carg2 = (*C.gchar)(unsafe.Pointer(C.CString(target))) defer C.free(unsafe.Pointer(carg2)) cret = C.gst_structure_fixate_field_string(carg0, carg1, carg2) runtime.KeepAlive(structure) runtime.KeepAlive(fieldName) runtime.KeepAlive(target) var goret bool if cret != 0 { goret = true } return goret } // ForEach wraps gst_structure_foreach // // The function takes the following parameters: // // - fn StructureForEachFunc: a function to call for each field // // The function returns the following values: // // - goret bool // // Calls the provided function once for each field in the #GstStructure. The // function must not modify the fields. Also see gst_structure_map_in_place() // and gst_structure_filter_and_map_in_place(). func (structure *Structure) ForEach(fn StructureForEachFunc) bool { var carg0 *C.GstStructure // in, none, converted var carg1 C.GstStructureForeachFunc // callback, scope: call, closure: carg2 var carg2 C.gpointer // implicit var cret C.gboolean // return carg0 = (*C.GstStructure)(UnsafeStructureToGlibNone(structure)) carg1 = (*[0]byte)(C._gotk4_gst1_StructureForEachFunc) carg2 = C.gpointer(userdata.Register(fn)) defer userdata.Delete(unsafe.Pointer(carg2)) cret = C.gst_structure_foreach(carg0, carg1, carg2) runtime.KeepAlive(structure) runtime.KeepAlive(fn) var goret bool if cret != 0 { goret = true } return goret } // GetBoolean wraps gst_structure_get_boolean // // The function takes the following parameters: // // - fieldname string: the name of a field // // The function returns the following values: // // - value bool: a pointer to a #gboolean to set // - goret bool // // Sets the boolean pointed to by @value corresponding to the value of the // given field. Caller is responsible for making sure the field exists // and has the correct type. func (structure *Structure) GetBoolean(fieldname string) (bool, bool) { var carg0 *C.GstStructure // in, none, converted var carg1 *C.gchar // in, none, string var carg2 C.gboolean // out var cret C.gboolean // return carg0 = (*C.GstStructure)(UnsafeStructureToGlibNone(structure)) carg1 = (*C.gchar)(unsafe.Pointer(C.CString(fieldname))) defer C.free(unsafe.Pointer(carg1)) cret = C.gst_structure_get_boolean(carg0, carg1, &carg2) runtime.KeepAlive(structure) runtime.KeepAlive(fieldname) var value bool var goret bool if carg2 != 0 { value = true } if cret != 0 { goret = true } return value, goret } // GetClockTime wraps gst_structure_get_clock_time // // The function takes the following parameters: // // - fieldname string: the name of a field // // The function returns the following values: // // - value ClockTime: a pointer to a #GstClockTime to set // - goret bool // // Sets the clock time pointed to by @value corresponding to the clock time // of the given field. Caller is responsible for making sure the field exists // and has the correct type. func (structure *Structure) GetClockTime(fieldname string) (ClockTime, bool) { var carg0 *C.GstStructure // in, none, converted var carg1 *C.gchar // in, none, string var carg2 C.GstClockTime // out, full, casted, alias var cret C.gboolean // return carg0 = (*C.GstStructure)(UnsafeStructureToGlibNone(structure)) carg1 = (*C.gchar)(unsafe.Pointer(C.CString(fieldname))) defer C.free(unsafe.Pointer(carg1)) cret = C.gst_structure_get_clock_time(carg0, carg1, &carg2) runtime.KeepAlive(structure) runtime.KeepAlive(fieldname) var value ClockTime var goret bool value = ClockTime(carg2) if cret != 0 { goret = true } return value, goret } // GetDateTime wraps gst_structure_get_date_time // // The function takes the following parameters: // // - fieldname string: the name of a field // // The function returns the following values: // // - value *DateTime: a pointer to a #GstDateTime to set // - goret bool // // Sets the datetime pointed to by @value corresponding to the datetime of the // given field. Caller is responsible for making sure the field exists // and has the correct type. // // On success @value will point to a reference of the datetime which // should be unreffed with gst_date_time_unref() when no longer needed // (note: this is inconsistent with e.g. gst_structure_get_string() // which doesn't return a copy of the string). func (structure *Structure) GetDateTime(fieldname string) (*DateTime, bool) { var carg0 *C.GstStructure // in, none, converted var carg1 *C.gchar // in, none, string var carg2 *C.GstDateTime // out, full, converted var cret C.gboolean // return carg0 = (*C.GstStructure)(UnsafeStructureToGlibNone(structure)) carg1 = (*C.gchar)(unsafe.Pointer(C.CString(fieldname))) defer C.free(unsafe.Pointer(carg1)) cret = C.gst_structure_get_date_time(carg0, carg1, &carg2) runtime.KeepAlive(structure) runtime.KeepAlive(fieldname) var value *DateTime var goret bool value = UnsafeDateTimeFromGlibFull(unsafe.Pointer(carg2)) if cret != 0 { goret = true } return value, goret } // GetDouble wraps gst_structure_get_double // // The function takes the following parameters: // // - fieldname string: the name of a field // // The function returns the following values: // // - value float64: a pointer to a gdouble to set // - goret bool // // Sets the double pointed to by @value corresponding to the value of the // given field. Caller is responsible for making sure the field exists // and has the correct type. func (structure *Structure) GetDouble(fieldname string) (float64, bool) { var carg0 *C.GstStructure // in, none, converted var carg1 *C.gchar // in, none, string var carg2 C.gdouble // out, full, casted var cret C.gboolean // return carg0 = (*C.GstStructure)(UnsafeStructureToGlibNone(structure)) carg1 = (*C.gchar)(unsafe.Pointer(C.CString(fieldname))) defer C.free(unsafe.Pointer(carg1)) cret = C.gst_structure_get_double(carg0, carg1, &carg2) runtime.KeepAlive(structure) runtime.KeepAlive(fieldname) var value float64 var goret bool value = float64(carg2) if cret != 0 { goret = true } return value, goret } // GetEnum wraps gst_structure_get_enum // // The function takes the following parameters: // // - fieldname string: the name of a field // - enumtype gobject.Type: the enum type of a field // // The function returns the following values: // // - value int: a pointer to an int to set // - goret bool // // Sets the int pointed to by @value corresponding to the value of the // given field. Caller is responsible for making sure the field exists, // has the correct type and that the enumtype is correct. func (structure *Structure) GetEnum(fieldname string, enumtype gobject.Type) (int, bool) { var carg0 *C.GstStructure // in, none, converted var carg1 *C.gchar // in, none, string var carg2 C.GType // in, none, casted, alias var carg3 C.gint // out, full, casted var cret C.gboolean // return carg0 = (*C.GstStructure)(UnsafeStructureToGlibNone(structure)) carg1 = (*C.gchar)(unsafe.Pointer(C.CString(fieldname))) defer C.free(unsafe.Pointer(carg1)) carg2 = C.GType(enumtype) cret = C.gst_structure_get_enum(carg0, carg1, carg2, &carg3) runtime.KeepAlive(structure) runtime.KeepAlive(fieldname) runtime.KeepAlive(enumtype) var value int var goret bool value = int(carg3) if cret != 0 { goret = true } return value, goret } // GetFieldType wraps gst_structure_get_field_type // // The function takes the following parameters: // // - fieldname string: the name of the field // // The function returns the following values: // // - goret gobject.Type // // Finds the field with the given name, and returns the type of the // value it contains. If the field is not found, G_TYPE_INVALID is // returned. func (structure *Structure) GetFieldType(fieldname string) gobject.Type { var carg0 *C.GstStructure // in, none, converted var carg1 *C.gchar // in, none, string var cret C.GType // return, none, casted, alias carg0 = (*C.GstStructure)(UnsafeStructureToGlibNone(structure)) carg1 = (*C.gchar)(unsafe.Pointer(C.CString(fieldname))) defer C.free(unsafe.Pointer(carg1)) cret = C.gst_structure_get_field_type(carg0, carg1) runtime.KeepAlive(structure) runtime.KeepAlive(fieldname) var goret gobject.Type goret = gobject.Type(cret) return goret } // GetFlags wraps gst_structure_get_flags // // The function takes the following parameters: // // - fieldname string: the name of a field // - flagsType gobject.Type: the flags type of a field // // The function returns the following values: // // - value uint: a pointer to an unsigned int to set // - goret bool // // Sets the unsigned int pointed to by @value corresponding to the value of the // given field. Caller is responsible for making sure the field exists, // has the correct type and that the flagstype is correct. func (structure *Structure) GetFlags(fieldname string, flagsType gobject.Type) (uint, bool) { var carg0 *C.GstStructure // in, none, converted var carg1 *C.gchar // in, none, string var carg2 C.GType // in, none, casted, alias var carg3 C.guint // out, full, casted var cret C.gboolean // return carg0 = (*C.GstStructure)(UnsafeStructureToGlibNone(structure)) carg1 = (*C.gchar)(unsafe.Pointer(C.CString(fieldname))) defer C.free(unsafe.Pointer(carg1)) carg2 = C.GType(flagsType) cret = C.gst_structure_get_flags(carg0, carg1, carg2, &carg3) runtime.KeepAlive(structure) runtime.KeepAlive(fieldname) runtime.KeepAlive(flagsType) var value uint var goret bool value = uint(carg3) if cret != 0 { goret = true } return value, goret } // GetFlagset wraps gst_structure_get_flagset // // The function takes the following parameters: // // - fieldname string: the name of a field // // The function returns the following values: // // - valueFlags uint: a pointer to a guint for the flags field // - valueMask uint: a pointer to a guint for the mask field // - goret bool // // Read the GstFlagSet flags and mask out of the structure into the // provided pointers. func (structure *Structure) GetFlagset(fieldname string) (uint, uint, bool) { var carg0 *C.GstStructure // in, none, converted var carg1 *C.gchar // in, none, string var carg2 C.guint // out, full, casted var carg3 C.guint // out, full, casted var cret C.gboolean // return carg0 = (*C.GstStructure)(UnsafeStructureToGlibNone(structure)) carg1 = (*C.gchar)(unsafe.Pointer(C.CString(fieldname))) defer C.free(unsafe.Pointer(carg1)) cret = C.gst_structure_get_flagset(carg0, carg1, &carg2, &carg3) runtime.KeepAlive(structure) runtime.KeepAlive(fieldname) var valueFlags uint var valueMask uint var goret bool valueFlags = uint(carg2) valueMask = uint(carg3) if cret != 0 { goret = true } return valueFlags, valueMask, goret } // GetFraction wraps gst_structure_get_fraction // // The function takes the following parameters: // // - fieldname string: the name of a field // // The function returns the following values: // // - valueNumerator int: a pointer to an int to set // - valueDenominator int: a pointer to an int to set // - goret bool // // Sets the integers pointed to by @value_numerator and @value_denominator // corresponding to the value of the given field. Caller is responsible // for making sure the field exists and has the correct type. func (structure *Structure) GetFraction(fieldname string) (int, int, bool) { var carg0 *C.GstStructure // in, none, converted var carg1 *C.gchar // in, none, string var carg2 C.gint // out, full, casted var carg3 C.gint // out, full, casted var cret C.gboolean // return carg0 = (*C.GstStructure)(UnsafeStructureToGlibNone(structure)) carg1 = (*C.gchar)(unsafe.Pointer(C.CString(fieldname))) defer C.free(unsafe.Pointer(carg1)) cret = C.gst_structure_get_fraction(carg0, carg1, &carg2, &carg3) runtime.KeepAlive(structure) runtime.KeepAlive(fieldname) var valueNumerator int var valueDenominator int var goret bool valueNumerator = int(carg2) valueDenominator = int(carg3) if cret != 0 { goret = true } return valueNumerator, valueDenominator, goret } // GetInt wraps gst_structure_get_int // // The function takes the following parameters: // // - fieldname string: the name of a field // // The function returns the following values: // // - value int: a pointer to an int to set // - goret bool // // Sets the int pointed to by @value corresponding to the value of the // given field. Caller is responsible for making sure the field exists // and has the correct type. func (structure *Structure) GetInt(fieldname string) (int, bool) { var carg0 *C.GstStructure // in, none, converted var carg1 *C.gchar // in, none, string var carg2 C.gint // out, full, casted var cret C.gboolean // return carg0 = (*C.GstStructure)(UnsafeStructureToGlibNone(structure)) carg1 = (*C.gchar)(unsafe.Pointer(C.CString(fieldname))) defer C.free(unsafe.Pointer(carg1)) cret = C.gst_structure_get_int(carg0, carg1, &carg2) runtime.KeepAlive(structure) runtime.KeepAlive(fieldname) var value int var goret bool value = int(carg2) if cret != 0 { goret = true } return value, goret } // GetInt64 wraps gst_structure_get_int64 // // The function takes the following parameters: // // - fieldname string: the name of a field // // The function returns the following values: // // - value int64: a pointer to a #gint64 to set // - goret bool // // Sets the #gint64 pointed to by @value corresponding to the value of the // given field. Caller is responsible for making sure the field exists // and has the correct type. func (structure *Structure) GetInt64(fieldname string) (int64, bool) { var carg0 *C.GstStructure // in, none, converted var carg1 *C.gchar // in, none, string var carg2 C.gint64 // out, full, casted var cret C.gboolean // return carg0 = (*C.GstStructure)(UnsafeStructureToGlibNone(structure)) carg1 = (*C.gchar)(unsafe.Pointer(C.CString(fieldname))) defer C.free(unsafe.Pointer(carg1)) cret = C.gst_structure_get_int64(carg0, carg1, &carg2) runtime.KeepAlive(structure) runtime.KeepAlive(fieldname) var value int64 var goret bool value = int64(carg2) if cret != 0 { goret = true } return value, goret } // GetName wraps gst_structure_get_name // // The function returns the following values: // // - goret string // // Get the name of @structure as a string. func (structure *Structure) GetName() string { var carg0 *C.GstStructure // in, none, converted var cret *C.gchar // return, none, string carg0 = (*C.GstStructure)(UnsafeStructureToGlibNone(structure)) cret = C.gst_structure_get_name(carg0) runtime.KeepAlive(structure) var goret string goret = C.GoString((*C.char)(unsafe.Pointer(cret))) return goret } // GetNameID wraps gst_structure_get_name_id // // The function returns the following values: // // - goret glib.Quark // // Get the name of @structure as a GQuark. func (structure *Structure) GetNameID() glib.Quark { var carg0 *C.GstStructure // in, none, converted var cret C.GQuark // return, none, casted, alias carg0 = (*C.GstStructure)(UnsafeStructureToGlibNone(structure)) cret = C.gst_structure_get_name_id(carg0) runtime.KeepAlive(structure) var goret glib.Quark goret = glib.Quark(cret) return goret } // GetString wraps gst_structure_get_string // // The function takes the following parameters: // // - fieldname string: the name of a field // // The function returns the following values: // // - goret string (nullable) // // Finds the field corresponding to @fieldname, and returns the string // contained in the field's value. Caller is responsible for making // sure the field exists and has the correct type. // // The string should not be modified, and remains valid until the next // call to a gst_structure_*() function with the given structure. func (structure *Structure) GetString(fieldname string) string { var carg0 *C.GstStructure // in, none, converted var carg1 *C.gchar // in, none, string var cret *C.gchar // return, none, string, nullable-string carg0 = (*C.GstStructure)(UnsafeStructureToGlibNone(structure)) carg1 = (*C.gchar)(unsafe.Pointer(C.CString(fieldname))) defer C.free(unsafe.Pointer(carg1)) cret = C.gst_structure_get_string(carg0, carg1) runtime.KeepAlive(structure) runtime.KeepAlive(fieldname) var goret string if cret != nil { goret = C.GoString((*C.char)(unsafe.Pointer(cret))) } return goret } // GetUint wraps gst_structure_get_uint // // The function takes the following parameters: // // - fieldname string: the name of a field // // The function returns the following values: // // - value uint: a pointer to a uint to set // - goret bool // // Sets the uint pointed to by @value corresponding to the value of the // given field. Caller is responsible for making sure the field exists // and has the correct type. func (structure *Structure) GetUint(fieldname string) (uint, bool) { var carg0 *C.GstStructure // in, none, converted var carg1 *C.gchar // in, none, string var carg2 C.guint // out, full, casted var cret C.gboolean // return carg0 = (*C.GstStructure)(UnsafeStructureToGlibNone(structure)) carg1 = (*C.gchar)(unsafe.Pointer(C.CString(fieldname))) defer C.free(unsafe.Pointer(carg1)) cret = C.gst_structure_get_uint(carg0, carg1, &carg2) runtime.KeepAlive(structure) runtime.KeepAlive(fieldname) var value uint var goret bool value = uint(carg2) if cret != 0 { goret = true } return value, goret } // GetUint64 wraps gst_structure_get_uint64 // // The function takes the following parameters: // // - fieldname string: the name of a field // // The function returns the following values: // // - value uint64: a pointer to a #guint64 to set // - goret bool // // Sets the #guint64 pointed to by @value corresponding to the value of the // given field. Caller is responsible for making sure the field exists // and has the correct type. func (structure *Structure) GetUint64(fieldname string) (uint64, bool) { var carg0 *C.GstStructure // in, none, converted var carg1 *C.gchar // in, none, string var carg2 C.guint64 // out, full, casted var cret C.gboolean // return carg0 = (*C.GstStructure)(UnsafeStructureToGlibNone(structure)) carg1 = (*C.gchar)(unsafe.Pointer(C.CString(fieldname))) defer C.free(unsafe.Pointer(carg1)) cret = C.gst_structure_get_uint64(carg0, carg1, &carg2) runtime.KeepAlive(structure) runtime.KeepAlive(fieldname) var value uint64 var goret bool value = uint64(carg2) if cret != 0 { goret = true } return value, goret } // HasField wraps gst_structure_has_field // // The function takes the following parameters: // // - fieldname string: the name of a field // // The function returns the following values: // // - goret bool // // Check if @structure contains a field named @fieldname. func (structure *Structure) HasField(fieldname string) bool { var carg0 *C.GstStructure // in, none, converted var carg1 *C.gchar // in, none, string var cret C.gboolean // return carg0 = (*C.GstStructure)(UnsafeStructureToGlibNone(structure)) carg1 = (*C.gchar)(unsafe.Pointer(C.CString(fieldname))) defer C.free(unsafe.Pointer(carg1)) cret = C.gst_structure_has_field(carg0, carg1) runtime.KeepAlive(structure) runtime.KeepAlive(fieldname) var goret bool if cret != 0 { goret = true } return goret } // HasFieldTyped wraps gst_structure_has_field_typed // // The function takes the following parameters: // // - fieldname string: the name of a field // - typ gobject.Type: the type of a value // // The function returns the following values: // // - goret bool // // Check if @structure contains a field named @fieldname and with GType @type. func (structure *Structure) HasFieldTyped(fieldname string, typ gobject.Type) bool { var carg0 *C.GstStructure // in, none, converted var carg1 *C.gchar // in, none, string var carg2 C.GType // in, none, casted, alias var cret C.gboolean // return carg0 = (*C.GstStructure)(UnsafeStructureToGlibNone(structure)) carg1 = (*C.gchar)(unsafe.Pointer(C.CString(fieldname))) defer C.free(unsafe.Pointer(carg1)) carg2 = C.GType(typ) cret = C.gst_structure_has_field_typed(carg0, carg1, carg2) runtime.KeepAlive(structure) runtime.KeepAlive(fieldname) runtime.KeepAlive(typ) var goret bool if cret != 0 { goret = true } return goret } // HasName wraps gst_structure_has_name // // The function takes the following parameters: // // - name string: structure name to check for // // The function returns the following values: // // - goret bool // // Checks if the structure has the given name func (structure *Structure) HasName(name string) bool { var carg0 *C.GstStructure // in, none, converted var carg1 *C.gchar // in, none, string var cret C.gboolean // return carg0 = (*C.GstStructure)(UnsafeStructureToGlibNone(structure)) carg1 = (*C.gchar)(unsafe.Pointer(C.CString(name))) defer C.free(unsafe.Pointer(carg1)) cret = C.gst_structure_has_name(carg0, carg1) runtime.KeepAlive(structure) runtime.KeepAlive(name) var goret bool if cret != 0 { goret = true } return goret } // IDHasField wraps gst_structure_id_has_field // // The function takes the following parameters: // // - field glib.Quark: #GQuark of the field name // // The function returns the following values: // // - goret bool // // Check if @structure contains a field named @field. func (structure *Structure) IDHasField(field glib.Quark) bool { var carg0 *C.GstStructure // in, none, converted var carg1 C.GQuark // in, none, casted, alias var cret C.gboolean // return carg0 = (*C.GstStructure)(UnsafeStructureToGlibNone(structure)) carg1 = C.GQuark(field) cret = C.gst_structure_id_has_field(carg0, carg1) runtime.KeepAlive(structure) runtime.KeepAlive(field) var goret bool if cret != 0 { goret = true } return goret } // IDHasFieldTyped wraps gst_structure_id_has_field_typed // // The function takes the following parameters: // // - field glib.Quark: #GQuark of the field name // - typ gobject.Type: the type of a value // // The function returns the following values: // // - goret bool // // Check if @structure contains a field named @field and with GType @type. func (structure *Structure) IDHasFieldTyped(field glib.Quark, typ gobject.Type) bool { var carg0 *C.GstStructure // in, none, converted var carg1 C.GQuark // in, none, casted, alias var carg2 C.GType // in, none, casted, alias var cret C.gboolean // return carg0 = (*C.GstStructure)(UnsafeStructureToGlibNone(structure)) carg1 = C.GQuark(field) carg2 = C.GType(typ) cret = C.gst_structure_id_has_field_typed(carg0, carg1, carg2) runtime.KeepAlive(structure) runtime.KeepAlive(field) runtime.KeepAlive(typ) var goret bool if cret != 0 { goret = true } return goret } // IDSetValue wraps gst_structure_id_set_value // // The function takes the following parameters: // // - field glib.Quark: a #GQuark representing a field // - value *gobject.Value: the new value of the field // // Sets the field with the given GQuark @field to @value. If the field // does not exist, it is created. If the field exists, the previous // value is replaced and freed. func (structure *Structure) IDSetValue(field glib.Quark, value *gobject.Value) { var carg0 *C.GstStructure // in, none, converted var carg1 C.GQuark // in, none, casted, alias var carg2 *C.GValue // in, none, converted carg0 = (*C.GstStructure)(UnsafeStructureToGlibNone(structure)) carg1 = C.GQuark(field) carg2 = (*C.GValue)(gobject.UnsafeValueToGlibUseAnyInstead(value)) C.gst_structure_id_set_value(carg0, carg1, carg2) runtime.KeepAlive(structure) runtime.KeepAlive(field) runtime.KeepAlive(value) } // Intersect wraps gst_structure_intersect // // The function takes the following parameters: // // - struct2 *Structure: a #GstStructure // // The function returns the following values: // // - goret *Structure (nullable) // // Intersects @struct1 and @struct2 and returns the intersection. func (struct1 *Structure) Intersect(struct2 *Structure) *Structure { var carg0 *C.GstStructure // in, none, converted var carg1 *C.GstStructure // in, none, converted var cret *C.GstStructure // return, full, converted, nullable carg0 = (*C.GstStructure)(UnsafeStructureToGlibNone(struct1)) carg1 = (*C.GstStructure)(UnsafeStructureToGlibNone(struct2)) cret = C.gst_structure_intersect(carg0, carg1) runtime.KeepAlive(struct1) runtime.KeepAlive(struct2) var goret *Structure if cret != nil { goret = UnsafeStructureFromGlibFull(unsafe.Pointer(cret)) } return goret } // IsEqual wraps gst_structure_is_equal // // The function takes the following parameters: // // - structure2 *Structure: a #GstStructure. // // The function returns the following values: // // - goret bool // // Tests if the two #GstStructure are equal. func (structure1 *Structure) IsEqual(structure2 *Structure) bool { var carg0 *C.GstStructure // in, none, converted var carg1 *C.GstStructure // in, none, converted var cret C.gboolean // return carg0 = (*C.GstStructure)(UnsafeStructureToGlibNone(structure1)) carg1 = (*C.GstStructure)(UnsafeStructureToGlibNone(structure2)) cret = C.gst_structure_is_equal(carg0, carg1) runtime.KeepAlive(structure1) runtime.KeepAlive(structure2) var goret bool if cret != 0 { goret = true } return goret } // IsSubset wraps gst_structure_is_subset // // The function takes the following parameters: // // - superset *Structure: a potentially greater #GstStructure // // The function returns the following values: // // - goret bool // // Checks if @subset is a subset of @superset, i.e. has the same // structure name and for all fields that are existing in @superset, // @subset has a value that is a subset of the value in @superset. func (subset *Structure) IsSubset(superset *Structure) bool { var carg0 *C.GstStructure // in, none, converted var carg1 *C.GstStructure // in, none, converted var cret C.gboolean // return carg0 = (*C.GstStructure)(UnsafeStructureToGlibNone(subset)) carg1 = (*C.GstStructure)(UnsafeStructureToGlibNone(superset)) cret = C.gst_structure_is_subset(carg0, carg1) runtime.KeepAlive(subset) runtime.KeepAlive(superset) var goret bool if cret != 0 { goret = true } return goret } // MapInPlace wraps gst_structure_map_in_place // // The function takes the following parameters: // // - fn StructureMapFunc: a function to call for each field // // The function returns the following values: // // - goret bool // // Calls the provided function once for each field in the #GstStructure. In // contrast to gst_structure_foreach(), the function may modify but not delete the // fields. The structure must be mutable. func (structure *Structure) MapInPlace(fn StructureMapFunc) bool { var carg0 *C.GstStructure // in, none, converted var carg1 C.GstStructureMapFunc // callback, scope: call, closure: carg2 var carg2 C.gpointer // implicit var cret C.gboolean // return carg0 = (*C.GstStructure)(UnsafeStructureToGlibNone(structure)) carg1 = (*[0]byte)(C._gotk4_gst1_StructureMapFunc) carg2 = C.gpointer(userdata.Register(fn)) defer userdata.Delete(unsafe.Pointer(carg2)) cret = C.gst_structure_map_in_place(carg0, carg1, carg2) runtime.KeepAlive(structure) runtime.KeepAlive(fn) var goret bool if cret != 0 { goret = true } return goret } // NFields wraps gst_structure_n_fields // // The function returns the following values: // // - goret int // // Get the number of fields in the structure. func (structure *Structure) NFields() int { var carg0 *C.GstStructure // in, none, converted var cret C.gint // return, none, casted carg0 = (*C.GstStructure)(UnsafeStructureToGlibNone(structure)) cret = C.gst_structure_n_fields(carg0) runtime.KeepAlive(structure) var goret int goret = int(cret) return goret } // NthFieldName wraps gst_structure_nth_field_name // // The function takes the following parameters: // // - index uint: the index to get the name of // // The function returns the following values: // // - goret string // // Get the name of the given field number, counting from 0 onwards. func (structure *Structure) NthFieldName(index uint) string { var carg0 *C.GstStructure // in, none, converted var carg1 C.guint // in, none, casted var cret *C.gchar // return, none, string carg0 = (*C.GstStructure)(UnsafeStructureToGlibNone(structure)) carg1 = C.guint(index) cret = C.gst_structure_nth_field_name(carg0, carg1) runtime.KeepAlive(structure) runtime.KeepAlive(index) var goret string goret = C.GoString((*C.char)(unsafe.Pointer(cret))) return goret } // RemoveAllFields wraps gst_structure_remove_all_fields // // Removes all fields in a GstStructure. func (structure *Structure) RemoveAllFields() { var carg0 *C.GstStructure // in, none, converted carg0 = (*C.GstStructure)(UnsafeStructureToGlibNone(structure)) C.gst_structure_remove_all_fields(carg0) runtime.KeepAlive(structure) } // RemoveField wraps gst_structure_remove_field // // The function takes the following parameters: // // - fieldname string: the name of the field to remove // // Removes the field with the given name. If the field with the given // name does not exist, the structure is unchanged. func (structure *Structure) RemoveField(fieldname string) { var carg0 *C.GstStructure // in, none, converted var carg1 *C.gchar // in, none, string carg0 = (*C.GstStructure)(UnsafeStructureToGlibNone(structure)) carg1 = (*C.gchar)(unsafe.Pointer(C.CString(fieldname))) defer C.free(unsafe.Pointer(carg1)) C.gst_structure_remove_field(carg0, carg1) runtime.KeepAlive(structure) runtime.KeepAlive(fieldname) } // Serialize wraps gst_structure_serialize // // The function takes the following parameters: // // - flags SerializeFlags: The flags to use to serialize structure // // The function returns the following values: // // - goret string // // Converts @structure to a human-readable string representation. // // This version of the caps serialization function introduces support for nested // structures and caps but the resulting strings won't be parsable with // GStreamer prior to 1.20 unless #GST_SERIALIZE_FLAG_BACKWARD_COMPAT is passed // as @flag. // // %GST_SERIALIZE_FLAG_STRICT flags is not allowed because it would make this // function nullable which is an API break for bindings. // Use gst_structure_serialize_full() instead. // // Free-function: g_free // // Deprecated: Use gst_structure_serialize_full() instead. func (structure *Structure) Serialize(flags SerializeFlags) string { var carg0 *C.GstStructure // in, none, converted var carg1 C.GstSerializeFlags // in, none, casted var cret *C.gchar // return, full, string carg0 = (*C.GstStructure)(UnsafeStructureToGlibNone(structure)) carg1 = C.GstSerializeFlags(flags) cret = C.gst_structure_serialize(carg0, carg1) runtime.KeepAlive(structure) runtime.KeepAlive(flags) var goret string goret = C.GoString((*C.char)(unsafe.Pointer(cret))) defer C.free(unsafe.Pointer(cret)) return goret } // SerializeFull wraps gst_structure_serialize_full // // The function takes the following parameters: // // - flags SerializeFlags: The flags to use to serialize structure // // The function returns the following values: // // - goret string (nullable) // // Alias for gst_structure_serialize() but with nullable annotation because it // can return %NULL when %GST_SERIALIZE_FLAG_STRICT flag is set. func (structure *Structure) SerializeFull(flags SerializeFlags) string { var carg0 *C.GstStructure // in, none, converted var carg1 C.GstSerializeFlags // in, none, casted var cret *C.gchar // return, full, string, nullable-string carg0 = (*C.GstStructure)(UnsafeStructureToGlibNone(structure)) carg1 = C.GstSerializeFlags(flags) cret = C.gst_structure_serialize_full(carg0, carg1) runtime.KeepAlive(structure) runtime.KeepAlive(flags) var goret string if cret != nil { goret = C.GoString((*C.char)(unsafe.Pointer(cret))) defer C.free(unsafe.Pointer(cret)) } return goret } // SetName wraps gst_structure_set_name // // The function takes the following parameters: // // - name string: the new name of the structure // // Sets the name of the structure to the given @name. The string // provided is copied before being used. It must not be empty, start with a // letter and can be followed by letters, numbers and any of "/-_.:". func (structure *Structure) SetName(name string) { var carg0 *C.GstStructure // in, none, converted var carg1 *C.gchar // in, none, string carg0 = (*C.GstStructure)(UnsafeStructureToGlibNone(structure)) carg1 = (*C.gchar)(unsafe.Pointer(C.CString(name))) defer C.free(unsafe.Pointer(carg1)) C.gst_structure_set_name(carg0, carg1) runtime.KeepAlive(structure) runtime.KeepAlive(name) } // SetParentRefcount wraps gst_structure_set_parent_refcount // // The function takes the following parameters: // // - refcount *int: a pointer to the parent's refcount // // The function returns the following values: // // - goret bool // // Sets the parent_refcount field of #GstStructure. This field is used to // determine whether a structure is mutable or not. This function should only be // called by code implementing parent objects of #GstStructure, as described in // the MT Refcounting section of the design documents. func (structure *Structure) SetParentRefcount(refcount *int) bool { var carg0 *C.GstStructure // in, none, converted var carg1 *C.gint // in, transfer: none, C Pointers: 1, Name: gint var cret C.gboolean // return carg0 = (*C.GstStructure)(UnsafeStructureToGlibNone(structure)) _ = refcount _ = carg1 panic("unimplemented conversion of *int (gint*)") cret = C.gst_structure_set_parent_refcount(carg0, carg1) runtime.KeepAlive(structure) runtime.KeepAlive(refcount) var goret bool if cret != 0 { goret = true } return goret } // ToString wraps gst_structure_to_string // // The function returns the following values: // // - goret string // // Converts @structure to a human-readable string representation. // // For debugging purposes its easier to do something like this: |[<!-- // language="C" --> GST_LOG ("structure is %" GST_PTR_FORMAT, structure); // ]| // This prints the structure in human readable form. // // This function will lead to unexpected results when there are nested #GstCaps // / #GstStructure deeper than one level, you should user // gst_structure_serialize_full() instead for those cases. // // Free-function: g_free func (structure *Structure) ToString() string { var carg0 *C.GstStructure // in, none, converted var cret *C.gchar // return, full, string carg0 = (*C.GstStructure)(UnsafeStructureToGlibNone(structure)) cret = C.gst_structure_to_string(carg0) runtime.KeepAlive(structure) var goret string goret = C.GoString((*C.char)(unsafe.Pointer(cret))) defer C.free(unsafe.Pointer(cret)) return goret } // SystemClockClass wraps GstSystemClockClass // // SystemClockClass is the type struct for [SystemClock] type SystemClockClass struct { *systemClockClass } // systemClockClass is the struct that's finalized type systemClockClass struct { native *C.GstSystemClockClass } // UnsafeSystemClockClassFromGlibBorrow is used to convert raw C.GstSystemClockClass pointers to go. This is used by the bindings internally. func UnsafeSystemClockClassFromGlibBorrow(p unsafe.Pointer) *SystemClockClass { return &SystemClockClass{&systemClockClass{(*C.GstSystemClockClass)(p)}} } // 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. func UnsafeSystemClockClassFree(s *SystemClockClass) { C.free(unsafe.Pointer(s.native)) } // UnsafeSystemClockClassToGlibNone returns the underlying C pointer. This is used by the bindings internally. func UnsafeSystemClockClassToGlibNone(s *SystemClockClass) unsafe.Pointer { return unsafe.Pointer(s.native) } // 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. // // Strings in structures must be ASCII or UTF-8 encoded. Other encodings are // not allowed. Strings must not be empty or %NULL. type TagList struct { *tagList } // tagList is the struct that's finalized type tagList struct { native *C.GstTagList } var _ gobject.GoValueInitializer = (*TagList)(nil) func marshalTagList(p unsafe.Pointer) (interface{}, error) { b := gobject.ValueFromNative(p).Boxed() return UnsafeTagListFromGlibBorrow(b), nil } func (r *TagList) InitGoValue(v *gobject.Value) { v.Init(TypeTagList) v.SetBoxed(unsafe.Pointer(r.native)) } // UnsafeTagListFromGlibBorrow is used to convert raw C.GstTagList pointers to go. This is used by the bindings internally. func UnsafeTagListFromGlibBorrow(p unsafe.Pointer) *TagList { return &TagList{&tagList{(*C.GstTagList)(p)}} } // 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) runtime.SetFinalizer( wrapped.tagList, func (intern *tagList) { C.free(unsafe.Pointer(intern.native)) }, ) return wrapped } // 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( wrapped.tagList, func (intern *tagList) { C.free(unsafe.Pointer(intern.native)) }, ) return wrapped } // UnsafeTagListFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [TagList] is expected to work anymore. func UnsafeTagListFree(t *TagList) { C.free(unsafe.Pointer(t.native)) } // UnsafeTagListToGlibNone returns the underlying C pointer. This is used by the bindings internally. func UnsafeTagListToGlibNone(t *TagList) unsafe.Pointer { return unsafe.Pointer(t.native) } // UnsafeTagListToGlibFull returns the underlying C pointer and gives up ownership. // This is used by the bindings internally. func UnsafeTagListToGlibFull(t *TagList) unsafe.Pointer { runtime.SetFinalizer(t.tagList, nil) _p := unsafe.Pointer(t.native) 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 // // Creates a new empty GstTagList. // // Free-function: gst_tag_list_unref func NewTagListEmpty() *TagList { var cret *C.GstTagList // return, full, converted cret = C.gst_tag_list_new_empty() var goret *TagList goret = UnsafeTagListFromGlibFull(unsafe.Pointer(cret)) return goret } // NewTagListFromString wraps gst_tag_list_new_from_string // // The function takes the following parameters: // // - str string: a string created with gst_tag_list_to_string() // // The function returns the following values: // // - goret *TagList (nullable) // // Deserializes a tag list. func NewTagListFromString(str string) *TagList { var carg1 *C.gchar // in, none, string var cret *C.GstTagList // return, full, converted, nullable carg1 = (*C.gchar)(unsafe.Pointer(C.CString(str))) defer C.free(unsafe.Pointer(carg1)) cret = C.gst_tag_list_new_from_string(carg1) runtime.KeepAlive(str) var goret *TagList if cret != nil { goret = UnsafeTagListFromGlibFull(unsafe.Pointer(cret)) } return goret } // TagListCopyValue wraps gst_tag_list_copy_value // // The function takes the following parameters: // // - list *TagList: list to get the tag from // - tag string: tag to read out // // The function returns the following values: // // - dest gobject.Value: uninitialized #GValue to copy into // - goret bool // // Copies the contents for the given tag into the value, // merging multiple values into one if multiple values are associated // with the tag. // You must g_value_unset() the value after use. func TagListCopyValue(list *TagList, tag string) (gobject.Value, bool) { var carg2 *C.GstTagList // in, none, converted var carg3 *C.gchar // in, none, string var carg1 C.GValue // out, transfer: none, C Pointers: 0, Name: Value, caller-allocates var cret C.gboolean // return carg2 = (*C.GstTagList)(UnsafeTagListToGlibNone(list)) carg3 = (*C.gchar)(unsafe.Pointer(C.CString(tag))) defer C.free(unsafe.Pointer(carg3)) cret = C.gst_tag_list_copy_value(&carg1, carg2, carg3) runtime.KeepAlive(list) runtime.KeepAlive(tag) var dest gobject.Value var goret bool _ = dest _ = carg1 panic("unimplemented conversion of gobject.Value (GValue)") if cret != 0 { goret = true } return dest, goret } // AddValue wraps gst_tag_list_add_value // // The function takes the following parameters: // // - mode TagMergeMode: the mode to use // - tag string: tag // - value *gobject.Value: GValue for this tag // // Sets the GValue for a given tag using the specified mode. func (list *TagList) AddValue(mode TagMergeMode, tag string, value *gobject.Value) { var carg0 *C.GstTagList // in, none, converted var carg1 C.GstTagMergeMode // in, none, casted var carg2 *C.gchar // in, none, string var carg3 *C.GValue // in, none, converted carg0 = (*C.GstTagList)(UnsafeTagListToGlibNone(list)) carg1 = C.GstTagMergeMode(mode) carg2 = (*C.gchar)(unsafe.Pointer(C.CString(tag))) defer C.free(unsafe.Pointer(carg2)) carg3 = (*C.GValue)(gobject.UnsafeValueToGlibUseAnyInstead(value)) C.gst_tag_list_add_value(carg0, carg1, carg2, carg3) runtime.KeepAlive(list) runtime.KeepAlive(mode) runtime.KeepAlive(tag) runtime.KeepAlive(value) } // Copy wraps gst_tag_list_copy // // The function returns the following values: // // - goret *TagList // // Creates a new #GstTagList as a copy of the old @taglist. The new taglist // will have a refcount of 1, owned by the caller, and will be writable as // a result. // // Note that this function is the semantic equivalent of a gst_tag_list_ref() // followed by a gst_tag_list_make_writable(). If you only want to hold on to a // reference to the data, you should use gst_tag_list_ref(). // // When you are finished with the taglist, call gst_tag_list_unref() on it. func (taglist *TagList) Copy() *TagList { var carg0 *C.GstTagList // in, none, converted var cret *C.GstTagList // return, full, converted carg0 = (*C.GstTagList)(UnsafeTagListToGlibNone(taglist)) cret = C.gst_tag_list_copy(carg0) runtime.KeepAlive(taglist) var goret *TagList goret = UnsafeTagListFromGlibFull(unsafe.Pointer(cret)) return goret } // ForEach wraps gst_tag_list_foreach // // The function takes the following parameters: // // - fn TagForEachFunc: function to be called for each tag // // Calls the given function for each tag inside the tag list. Note that if there // is no tag, the function won't be called at all. func (list *TagList) ForEach(fn TagForEachFunc) { var carg0 *C.GstTagList // in, none, converted var carg1 C.GstTagForeachFunc // callback, scope: call, closure: carg2 var carg2 C.gpointer // implicit carg0 = (*C.GstTagList)(UnsafeTagListToGlibNone(list)) carg1 = (*[0]byte)(C._gotk4_gst1_TagForEachFunc) carg2 = C.gpointer(userdata.Register(fn)) defer userdata.Delete(unsafe.Pointer(carg2)) C.gst_tag_list_foreach(carg0, carg1, carg2) runtime.KeepAlive(list) runtime.KeepAlive(fn) } // GetBoolean wraps gst_tag_list_get_boolean // // The function takes the following parameters: // // - tag string: tag to read out // // The function returns the following values: // // - value bool: location for the result // - goret bool // // Copies the contents for the given tag into the value, merging multiple values // into one if multiple values are associated with the tag. func (list *TagList) GetBoolean(tag string) (bool, bool) { var carg0 *C.GstTagList // in, none, converted var carg1 *C.gchar // in, none, string var carg2 C.gboolean // out var cret C.gboolean // return carg0 = (*C.GstTagList)(UnsafeTagListToGlibNone(list)) carg1 = (*C.gchar)(unsafe.Pointer(C.CString(tag))) defer C.free(unsafe.Pointer(carg1)) cret = C.gst_tag_list_get_boolean(carg0, carg1, &carg2) runtime.KeepAlive(list) runtime.KeepAlive(tag) var value bool var goret bool if carg2 != 0 { value = true } if cret != 0 { goret = true } return value, goret } // GetBooleanIndex wraps gst_tag_list_get_boolean_index // // The function takes the following parameters: // // - tag string: tag to read out // - index uint: number of entry to read out // // The function returns the following values: // // - value bool: location for the result // - goret bool // // Gets the value that is at the given index for the given tag in the given // list. func (list *TagList) GetBooleanIndex(tag string, index uint) (bool, bool) { var carg0 *C.GstTagList // in, none, converted var carg1 *C.gchar // in, none, string var carg2 C.guint // in, none, casted var carg3 C.gboolean // out var cret C.gboolean // return carg0 = (*C.GstTagList)(UnsafeTagListToGlibNone(list)) carg1 = (*C.gchar)(unsafe.Pointer(C.CString(tag))) defer C.free(unsafe.Pointer(carg1)) carg2 = C.guint(index) cret = C.gst_tag_list_get_boolean_index(carg0, carg1, carg2, &carg3) runtime.KeepAlive(list) runtime.KeepAlive(tag) runtime.KeepAlive(index) var value bool var goret bool if carg3 != 0 { value = true } if cret != 0 { goret = true } return value, goret } // GetDateTime wraps gst_tag_list_get_date_time // // The function takes the following parameters: // // - tag string: tag to read out // // The function returns the following values: // // - value *DateTime: address of a #GstDateTime // pointer variable to store the result into // - goret bool // // Copies the first datetime for the given tag in the taglist into the variable // pointed to by @value. Unref the date with gst_date_time_unref() when // it is no longer needed. // // Free-function: gst_date_time_unref func (list *TagList) GetDateTime(tag string) (*DateTime, bool) { var carg0 *C.GstTagList // in, none, converted var carg1 *C.gchar // in, none, string var carg2 *C.GstDateTime // out, full, converted var cret C.gboolean // return carg0 = (*C.GstTagList)(UnsafeTagListToGlibNone(list)) carg1 = (*C.gchar)(unsafe.Pointer(C.CString(tag))) defer C.free(unsafe.Pointer(carg1)) cret = C.gst_tag_list_get_date_time(carg0, carg1, &carg2) runtime.KeepAlive(list) runtime.KeepAlive(tag) var value *DateTime var goret bool value = UnsafeDateTimeFromGlibFull(unsafe.Pointer(carg2)) if cret != 0 { goret = true } return value, goret } // GetDateTimeIndex wraps gst_tag_list_get_date_time_index // // The function takes the following parameters: // // - tag string: tag to read out // - index uint: number of entry to read out // // The function returns the following values: // // - value *DateTime: location for the result // - goret bool // // Gets the datetime that is at the given index for the given tag in the given // list and copies it into the variable pointed to by @value. Unref the datetime // with gst_date_time_unref() when it is no longer needed. // // Free-function: gst_date_time_unref func (list *TagList) GetDateTimeIndex(tag string, index uint) (*DateTime, bool) { var carg0 *C.GstTagList // in, none, converted var carg1 *C.gchar // in, none, string var carg2 C.guint // in, none, casted var carg3 *C.GstDateTime // out, full, converted var cret C.gboolean // return carg0 = (*C.GstTagList)(UnsafeTagListToGlibNone(list)) carg1 = (*C.gchar)(unsafe.Pointer(C.CString(tag))) defer C.free(unsafe.Pointer(carg1)) carg2 = C.guint(index) cret = C.gst_tag_list_get_date_time_index(carg0, carg1, carg2, &carg3) runtime.KeepAlive(list) runtime.KeepAlive(tag) runtime.KeepAlive(index) var value *DateTime var goret bool value = UnsafeDateTimeFromGlibFull(unsafe.Pointer(carg3)) if cret != 0 { goret = true } return value, goret } // GetDouble wraps gst_tag_list_get_double // // The function takes the following parameters: // // - tag string: tag to read out // // The function returns the following values: // // - value float64: location for the result // - goret bool // // Copies the contents for the given tag into the value, merging multiple values // into one if multiple values are associated with the tag. func (list *TagList) GetDouble(tag string) (float64, bool) { var carg0 *C.GstTagList // in, none, converted var carg1 *C.gchar // in, none, string var carg2 C.gdouble // out, full, casted var cret C.gboolean // return carg0 = (*C.GstTagList)(UnsafeTagListToGlibNone(list)) carg1 = (*C.gchar)(unsafe.Pointer(C.CString(tag))) defer C.free(unsafe.Pointer(carg1)) cret = C.gst_tag_list_get_double(carg0, carg1, &carg2) runtime.KeepAlive(list) runtime.KeepAlive(tag) var value float64 var goret bool value = float64(carg2) if cret != 0 { goret = true } return value, goret } // GetDoubleIndex wraps gst_tag_list_get_double_index // // The function takes the following parameters: // // - tag string: tag to read out // - index uint: number of entry to read out // // The function returns the following values: // // - value float64: location for the result // - goret bool // // Gets the value that is at the given index for the given tag in the given // list. func (list *TagList) GetDoubleIndex(tag string, index uint) (float64, bool) { var carg0 *C.GstTagList // in, none, converted var carg1 *C.gchar // in, none, string var carg2 C.guint // in, none, casted var carg3 C.gdouble // out, full, casted var cret C.gboolean // return carg0 = (*C.GstTagList)(UnsafeTagListToGlibNone(list)) carg1 = (*C.gchar)(unsafe.Pointer(C.CString(tag))) defer C.free(unsafe.Pointer(carg1)) carg2 = C.guint(index) cret = C.gst_tag_list_get_double_index(carg0, carg1, carg2, &carg3) runtime.KeepAlive(list) runtime.KeepAlive(tag) runtime.KeepAlive(index) var value float64 var goret bool value = float64(carg3) if cret != 0 { goret = true } return value, goret } // GetFloat wraps gst_tag_list_get_float // // The function takes the following parameters: // // - tag string: tag to read out // // The function returns the following values: // // - value float32: location for the result // - goret bool // // Copies the contents for the given tag into the value, merging multiple values // into one if multiple values are associated with the tag. func (list *TagList) GetFloat(tag string) (float32, bool) { var carg0 *C.GstTagList // in, none, converted var carg1 *C.gchar // in, none, string var carg2 C.gfloat // out, full, casted var cret C.gboolean // return carg0 = (*C.GstTagList)(UnsafeTagListToGlibNone(list)) carg1 = (*C.gchar)(unsafe.Pointer(C.CString(tag))) defer C.free(unsafe.Pointer(carg1)) cret = C.gst_tag_list_get_float(carg0, carg1, &carg2) runtime.KeepAlive(list) runtime.KeepAlive(tag) var value float32 var goret bool value = float32(carg2) if cret != 0 { goret = true } return value, goret } // GetFloatIndex wraps gst_tag_list_get_float_index // // The function takes the following parameters: // // - tag string: tag to read out // - index uint: number of entry to read out // // The function returns the following values: // // - value float32: location for the result // - goret bool // // Gets the value that is at the given index for the given tag in the given // list. func (list *TagList) GetFloatIndex(tag string, index uint) (float32, bool) { var carg0 *C.GstTagList // in, none, converted var carg1 *C.gchar // in, none, string var carg2 C.guint // in, none, casted var carg3 C.gfloat // out, full, casted var cret C.gboolean // return carg0 = (*C.GstTagList)(UnsafeTagListToGlibNone(list)) carg1 = (*C.gchar)(unsafe.Pointer(C.CString(tag))) defer C.free(unsafe.Pointer(carg1)) carg2 = C.guint(index) cret = C.gst_tag_list_get_float_index(carg0, carg1, carg2, &carg3) runtime.KeepAlive(list) runtime.KeepAlive(tag) runtime.KeepAlive(index) var value float32 var goret bool value = float32(carg3) if cret != 0 { goret = true } return value, goret } // GetInt wraps gst_tag_list_get_int // // The function takes the following parameters: // // - tag string: tag to read out // // The function returns the following values: // // - value int: location for the result // - goret bool // // Copies the contents for the given tag into the value, merging multiple values // into one if multiple values are associated with the tag. func (list *TagList) GetInt(tag string) (int, bool) { var carg0 *C.GstTagList // in, none, converted var carg1 *C.gchar // in, none, string var carg2 C.gint // out, full, casted var cret C.gboolean // return carg0 = (*C.GstTagList)(UnsafeTagListToGlibNone(list)) carg1 = (*C.gchar)(unsafe.Pointer(C.CString(tag))) defer C.free(unsafe.Pointer(carg1)) cret = C.gst_tag_list_get_int(carg0, carg1, &carg2) runtime.KeepAlive(list) runtime.KeepAlive(tag) var value int var goret bool value = int(carg2) if cret != 0 { goret = true } return value, goret } // GetInt64 wraps gst_tag_list_get_int64 // // The function takes the following parameters: // // - tag string: tag to read out // // The function returns the following values: // // - value int64: location for the result // - goret bool // // Copies the contents for the given tag into the value, merging multiple values // into one if multiple values are associated with the tag. func (list *TagList) GetInt64(tag string) (int64, bool) { var carg0 *C.GstTagList // in, none, converted var carg1 *C.gchar // in, none, string var carg2 C.gint64 // out, full, casted var cret C.gboolean // return carg0 = (*C.GstTagList)(UnsafeTagListToGlibNone(list)) carg1 = (*C.gchar)(unsafe.Pointer(C.CString(tag))) defer C.free(unsafe.Pointer(carg1)) cret = C.gst_tag_list_get_int64(carg0, carg1, &carg2) runtime.KeepAlive(list) runtime.KeepAlive(tag) var value int64 var goret bool value = int64(carg2) if cret != 0 { goret = true } return value, goret } // GetInt64Index wraps gst_tag_list_get_int64_index // // The function takes the following parameters: // // - tag string: tag to read out // - index uint: number of entry to read out // // The function returns the following values: // // - value int64: location for the result // - goret bool // // Gets the value that is at the given index for the given tag in the given // list. func (list *TagList) GetInt64Index(tag string, index uint) (int64, bool) { var carg0 *C.GstTagList // in, none, converted var carg1 *C.gchar // in, none, string var carg2 C.guint // in, none, casted var carg3 C.gint64 // out, full, casted var cret C.gboolean // return carg0 = (*C.GstTagList)(UnsafeTagListToGlibNone(list)) carg1 = (*C.gchar)(unsafe.Pointer(C.CString(tag))) defer C.free(unsafe.Pointer(carg1)) carg2 = C.guint(index) cret = C.gst_tag_list_get_int64_index(carg0, carg1, carg2, &carg3) runtime.KeepAlive(list) runtime.KeepAlive(tag) runtime.KeepAlive(index) var value int64 var goret bool value = int64(carg3) if cret != 0 { goret = true } return value, goret } // GetIntIndex wraps gst_tag_list_get_int_index // // The function takes the following parameters: // // - tag string: tag to read out // - index uint: number of entry to read out // // The function returns the following values: // // - value int: location for the result // - goret bool // // Gets the value that is at the given index for the given tag in the given // list. func (list *TagList) GetIntIndex(tag string, index uint) (int, bool) { var carg0 *C.GstTagList // in, none, converted var carg1 *C.gchar // in, none, string var carg2 C.guint // in, none, casted var carg3 C.gint // out, full, casted var cret C.gboolean // return carg0 = (*C.GstTagList)(UnsafeTagListToGlibNone(list)) carg1 = (*C.gchar)(unsafe.Pointer(C.CString(tag))) defer C.free(unsafe.Pointer(carg1)) carg2 = C.guint(index) cret = C.gst_tag_list_get_int_index(carg0, carg1, carg2, &carg3) runtime.KeepAlive(list) runtime.KeepAlive(tag) runtime.KeepAlive(index) var value int var goret bool value = int(carg3) if cret != 0 { goret = true } return value, goret } // GetSample wraps gst_tag_list_get_sample // // The function takes the following parameters: // // - tag string: tag to read out // // The function returns the following values: // // - sample *Sample: address of a GstSample // pointer variable to store the result into // - goret bool // // Copies the first sample for the given tag in the taglist into the variable // pointed to by @sample. Free the sample with gst_sample_unref() when it is // no longer needed. You can retrieve the buffer from the sample using // gst_sample_get_buffer() and the associated caps (if any) with // gst_sample_get_caps(). // // Free-function: gst_sample_unref func (list *TagList) GetSample(tag string) (*Sample, bool) { var carg0 *C.GstTagList // in, none, converted var carg1 *C.gchar // in, none, string var carg2 *C.GstSample // out, full, converted var cret C.gboolean // return carg0 = (*C.GstTagList)(UnsafeTagListToGlibNone(list)) carg1 = (*C.gchar)(unsafe.Pointer(C.CString(tag))) defer C.free(unsafe.Pointer(carg1)) cret = C.gst_tag_list_get_sample(carg0, carg1, &carg2) runtime.KeepAlive(list) runtime.KeepAlive(tag) var sample *Sample var goret bool sample = UnsafeSampleFromGlibFull(unsafe.Pointer(carg2)) if cret != 0 { goret = true } return sample, goret } // GetSampleIndex wraps gst_tag_list_get_sample_index // // The function takes the following parameters: // // - tag string: tag to read out // - index uint: number of entry to read out // // The function returns the following values: // // - sample *Sample: address of a GstSample // pointer variable to store the result into // - goret bool // // Gets the sample that is at the given index for the given tag in the given // list and copies it into the variable pointed to by @sample. Free the sample // with gst_sample_unref() when it is no longer needed. You can retrieve the // buffer from the sample using gst_sample_get_buffer() and the associated // caps (if any) with gst_sample_get_caps(). // // Free-function: gst_sample_unref func (list *TagList) GetSampleIndex(tag string, index uint) (*Sample, bool) { var carg0 *C.GstTagList // in, none, converted var carg1 *C.gchar // in, none, string var carg2 C.guint // in, none, casted var carg3 *C.GstSample // out, full, converted var cret C.gboolean // return carg0 = (*C.GstTagList)(UnsafeTagListToGlibNone(list)) carg1 = (*C.gchar)(unsafe.Pointer(C.CString(tag))) defer C.free(unsafe.Pointer(carg1)) carg2 = C.guint(index) cret = C.gst_tag_list_get_sample_index(carg0, carg1, carg2, &carg3) runtime.KeepAlive(list) runtime.KeepAlive(tag) runtime.KeepAlive(index) var sample *Sample var goret bool sample = UnsafeSampleFromGlibFull(unsafe.Pointer(carg3)) if cret != 0 { goret = true } return sample, goret } // GetScope wraps gst_tag_list_get_scope // // The function returns the following values: // // - goret TagScope // // Gets the scope of @list. func (list *TagList) GetScope() TagScope { var carg0 *C.GstTagList // in, none, converted var cret C.GstTagScope // return, none, casted carg0 = (*C.GstTagList)(UnsafeTagListToGlibNone(list)) cret = C.gst_tag_list_get_scope(carg0) runtime.KeepAlive(list) var goret TagScope goret = TagScope(cret) return goret } // GetString wraps gst_tag_list_get_string // // The function takes the following parameters: // // - tag string: tag to read out // // The function returns the following values: // // - value string: location for the result // - goret bool // // Copies the contents for the given tag into the value, possibly merging // multiple values into one if multiple values are associated with the tag. // // Use gst_tag_list_get_string_index (list, tag, 0, value) if you want // to retrieve the first string associated with this tag unmodified. // // The resulting string in @value will be in UTF-8 encoding and should be // freed by the caller using g_free when no longer needed. The // returned string is also guaranteed to be non-%NULL and non-empty. // // Free-function: g_free func (list *TagList) GetString(tag string) (string, bool) { var carg0 *C.GstTagList // in, none, converted var carg1 *C.gchar // in, none, string var carg2 *C.gchar // out, full, string var cret C.gboolean // return carg0 = (*C.GstTagList)(UnsafeTagListToGlibNone(list)) carg1 = (*C.gchar)(unsafe.Pointer(C.CString(tag))) defer C.free(unsafe.Pointer(carg1)) cret = C.gst_tag_list_get_string(carg0, carg1, &carg2) runtime.KeepAlive(list) runtime.KeepAlive(tag) var value string var goret bool value = C.GoString((*C.char)(unsafe.Pointer(carg2))) defer C.free(unsafe.Pointer(carg2)) if cret != 0 { goret = true } return value, goret } // GetStringIndex wraps gst_tag_list_get_string_index // // The function takes the following parameters: // // - tag string: tag to read out // - index uint: number of entry to read out // // The function returns the following values: // // - value string: location for the result // - goret bool // // Gets the value that is at the given index for the given tag in the given // list. // // The resulting string in @value will be in UTF-8 encoding and should be // freed by the caller using g_free when no longer needed. The // returned string is also guaranteed to be non-%NULL and non-empty. // // Free-function: g_free func (list *TagList) GetStringIndex(tag string, index uint) (string, bool) { var carg0 *C.GstTagList // in, none, converted var carg1 *C.gchar // in, none, string var carg2 C.guint // in, none, casted var carg3 *C.gchar // out, full, string var cret C.gboolean // return carg0 = (*C.GstTagList)(UnsafeTagListToGlibNone(list)) carg1 = (*C.gchar)(unsafe.Pointer(C.CString(tag))) defer C.free(unsafe.Pointer(carg1)) carg2 = C.guint(index) cret = C.gst_tag_list_get_string_index(carg0, carg1, carg2, &carg3) runtime.KeepAlive(list) runtime.KeepAlive(tag) runtime.KeepAlive(index) var value string var goret bool value = C.GoString((*C.char)(unsafe.Pointer(carg3))) defer C.free(unsafe.Pointer(carg3)) if cret != 0 { goret = true } return value, goret } // GetTagSize wraps gst_tag_list_get_tag_size // // The function takes the following parameters: // // - tag string: the tag to query // // The function returns the following values: // // - goret uint // // Checks how many value are stored in this tag list for the given tag. func (list *TagList) GetTagSize(tag string) uint { var carg0 *C.GstTagList // in, none, converted var carg1 *C.gchar // in, none, string var cret C.guint // return, none, casted carg0 = (*C.GstTagList)(UnsafeTagListToGlibNone(list)) carg1 = (*C.gchar)(unsafe.Pointer(C.CString(tag))) defer C.free(unsafe.Pointer(carg1)) cret = C.gst_tag_list_get_tag_size(carg0, carg1) runtime.KeepAlive(list) runtime.KeepAlive(tag) var goret uint goret = uint(cret) return goret } // GetUint wraps gst_tag_list_get_uint // // The function takes the following parameters: // // - tag string: tag to read out // // The function returns the following values: // // - value uint: location for the result // - goret bool // // Copies the contents for the given tag into the value, merging multiple values // into one if multiple values are associated with the tag. func (list *TagList) GetUint(tag string) (uint, bool) { var carg0 *C.GstTagList // in, none, converted var carg1 *C.gchar // in, none, string var carg2 C.guint // out, full, casted var cret C.gboolean // return carg0 = (*C.GstTagList)(UnsafeTagListToGlibNone(list)) carg1 = (*C.gchar)(unsafe.Pointer(C.CString(tag))) defer C.free(unsafe.Pointer(carg1)) cret = C.gst_tag_list_get_uint(carg0, carg1, &carg2) runtime.KeepAlive(list) runtime.KeepAlive(tag) var value uint var goret bool value = uint(carg2) if cret != 0 { goret = true } return value, goret } // GetUint64 wraps gst_tag_list_get_uint64 // // The function takes the following parameters: // // - tag string: tag to read out // // The function returns the following values: // // - value uint64: location for the result // - goret bool // // Copies the contents for the given tag into the value, merging multiple values // into one if multiple values are associated with the tag. func (list *TagList) GetUint64(tag string) (uint64, bool) { var carg0 *C.GstTagList // in, none, converted var carg1 *C.gchar // in, none, string var carg2 C.guint64 // out, full, casted var cret C.gboolean // return carg0 = (*C.GstTagList)(UnsafeTagListToGlibNone(list)) carg1 = (*C.gchar)(unsafe.Pointer(C.CString(tag))) defer C.free(unsafe.Pointer(carg1)) cret = C.gst_tag_list_get_uint64(carg0, carg1, &carg2) runtime.KeepAlive(list) runtime.KeepAlive(tag) var value uint64 var goret bool value = uint64(carg2) if cret != 0 { goret = true } return value, goret } // GetUint64Index wraps gst_tag_list_get_uint64_index // // The function takes the following parameters: // // - tag string: tag to read out // - index uint: number of entry to read out // // The function returns the following values: // // - value uint64: location for the result // - goret bool // // Gets the value that is at the given index for the given tag in the given // list. func (list *TagList) GetUint64Index(tag string, index uint) (uint64, bool) { var carg0 *C.GstTagList // in, none, converted var carg1 *C.gchar // in, none, string var carg2 C.guint // in, none, casted var carg3 C.guint64 // out, full, casted var cret C.gboolean // return carg0 = (*C.GstTagList)(UnsafeTagListToGlibNone(list)) carg1 = (*C.gchar)(unsafe.Pointer(C.CString(tag))) defer C.free(unsafe.Pointer(carg1)) carg2 = C.guint(index) cret = C.gst_tag_list_get_uint64_index(carg0, carg1, carg2, &carg3) runtime.KeepAlive(list) runtime.KeepAlive(tag) runtime.KeepAlive(index) var value uint64 var goret bool value = uint64(carg3) if cret != 0 { goret = true } return value, goret } // GetUintIndex wraps gst_tag_list_get_uint_index // // The function takes the following parameters: // // - tag string: tag to read out // - index uint: number of entry to read out // // The function returns the following values: // // - value uint: location for the result // - goret bool // // Gets the value that is at the given index for the given tag in the given // list. func (list *TagList) GetUintIndex(tag string, index uint) (uint, bool) { var carg0 *C.GstTagList // in, none, converted var carg1 *C.gchar // in, none, string var carg2 C.guint // in, none, casted var carg3 C.guint // out, full, casted var cret C.gboolean // return carg0 = (*C.GstTagList)(UnsafeTagListToGlibNone(list)) carg1 = (*C.gchar)(unsafe.Pointer(C.CString(tag))) defer C.free(unsafe.Pointer(carg1)) carg2 = C.guint(index) cret = C.gst_tag_list_get_uint_index(carg0, carg1, carg2, &carg3) runtime.KeepAlive(list) runtime.KeepAlive(tag) runtime.KeepAlive(index) var value uint var goret bool value = uint(carg3) if cret != 0 { goret = true } return value, goret } // Insert wraps gst_tag_list_insert // // The function takes the following parameters: // // - from *TagList: list to merge from // - mode TagMergeMode: the mode to use // // Inserts the tags of the @from list into the first list using the given mode. func (into *TagList) Insert(from *TagList, mode TagMergeMode) { var carg0 *C.GstTagList // in, none, converted var carg1 *C.GstTagList // in, none, converted var carg2 C.GstTagMergeMode // in, none, casted carg0 = (*C.GstTagList)(UnsafeTagListToGlibNone(into)) carg1 = (*C.GstTagList)(UnsafeTagListToGlibNone(from)) carg2 = C.GstTagMergeMode(mode) C.gst_tag_list_insert(carg0, carg1, carg2) runtime.KeepAlive(into) runtime.KeepAlive(from) runtime.KeepAlive(mode) } // IsEmpty wraps gst_tag_list_is_empty // // The function returns the following values: // // - goret bool // // Checks if the given taglist is empty. func (list *TagList) IsEmpty() bool { var carg0 *C.GstTagList // in, none, converted var cret C.gboolean // return carg0 = (*C.GstTagList)(UnsafeTagListToGlibNone(list)) cret = C.gst_tag_list_is_empty(carg0) runtime.KeepAlive(list) var goret bool if cret != 0 { goret = true } return goret } // IsEqual wraps gst_tag_list_is_equal // // The function takes the following parameters: // // - list2 *TagList: a #GstTagList. // // The function returns the following values: // // - goret bool // // Checks if the two given taglists are equal. func (list1 *TagList) IsEqual(list2 *TagList) bool { var carg0 *C.GstTagList // in, none, converted var carg1 *C.GstTagList // in, none, converted var cret C.gboolean // return carg0 = (*C.GstTagList)(UnsafeTagListToGlibNone(list1)) carg1 = (*C.GstTagList)(UnsafeTagListToGlibNone(list2)) cret = C.gst_tag_list_is_equal(carg0, carg1) runtime.KeepAlive(list1) runtime.KeepAlive(list2) var goret bool if cret != 0 { goret = true } return goret } // Merge wraps gst_tag_list_merge // // The function takes the following parameters: // // - list2 *TagList (nullable): second list to merge // - mode TagMergeMode: the mode to use // // The function returns the following values: // // - goret *TagList (nullable) // // Merges the two given lists into a new list. If one of the lists is %NULL, a // copy of the other is returned. If both lists are %NULL, %NULL is returned. // // Free-function: gst_tag_list_unref func (list1 *TagList) Merge(list2 *TagList, mode TagMergeMode) *TagList { var carg0 *C.GstTagList // in, none, converted var carg1 *C.GstTagList // in, none, converted, nullable var carg2 C.GstTagMergeMode // in, none, casted var cret *C.GstTagList // return, full, converted, nullable carg0 = (*C.GstTagList)(UnsafeTagListToGlibNone(list1)) if list2 != nil { carg1 = (*C.GstTagList)(UnsafeTagListToGlibNone(list2)) } carg2 = C.GstTagMergeMode(mode) cret = C.gst_tag_list_merge(carg0, carg1, carg2) runtime.KeepAlive(list1) runtime.KeepAlive(list2) runtime.KeepAlive(mode) var goret *TagList if cret != nil { goret = UnsafeTagListFromGlibFull(unsafe.Pointer(cret)) } return goret } // NTags wraps gst_tag_list_n_tags // // The function returns the following values: // // - goret int // // Get the number of tags in @list. func (list *TagList) NTags() int { var carg0 *C.GstTagList // in, none, converted var cret C.gint // return, none, casted carg0 = (*C.GstTagList)(UnsafeTagListToGlibNone(list)) cret = C.gst_tag_list_n_tags(carg0) runtime.KeepAlive(list) var goret int goret = int(cret) return goret } // NthTagName wraps gst_tag_list_nth_tag_name // // The function takes the following parameters: // // - index uint: the index // // The function returns the following values: // // - goret string // // Get the name of the tag in @list at @index. func (list *TagList) NthTagName(index uint) string { var carg0 *C.GstTagList // in, none, converted var carg1 C.guint // in, none, casted var cret *C.gchar // return, none, string carg0 = (*C.GstTagList)(UnsafeTagListToGlibNone(list)) carg1 = C.guint(index) cret = C.gst_tag_list_nth_tag_name(carg0, carg1) runtime.KeepAlive(list) runtime.KeepAlive(index) var goret string goret = C.GoString((*C.char)(unsafe.Pointer(cret))) return goret } // PeekStringIndex wraps gst_tag_list_peek_string_index // // The function takes the following parameters: // // - tag string: tag to read out // - index uint: number of entry to read out // // The function returns the following values: // // - value string: location for the result // - goret bool // // Peeks at the value that is at the given index for the given tag in the given // list. // // The resulting string in @value will be in UTF-8 encoding and doesn't need // to be freed by the caller. The returned string is also guaranteed to // be non-%NULL and non-empty. func (list *TagList) PeekStringIndex(tag string, index uint) (string, bool) { var carg0 *C.GstTagList // in, none, converted var carg1 *C.gchar // in, none, string var carg2 C.guint // in, none, casted var carg3 *C.gchar // out, none, string var cret C.gboolean // return carg0 = (*C.GstTagList)(UnsafeTagListToGlibNone(list)) carg1 = (*C.gchar)(unsafe.Pointer(C.CString(tag))) defer C.free(unsafe.Pointer(carg1)) carg2 = C.guint(index) cret = C.gst_tag_list_peek_string_index(carg0, carg1, carg2, &carg3) runtime.KeepAlive(list) runtime.KeepAlive(tag) runtime.KeepAlive(index) var value string var goret bool value = C.GoString((*C.char)(unsafe.Pointer(carg3))) if cret != 0 { goret = true } return value, goret } // RemoveTag wraps gst_tag_list_remove_tag // // The function takes the following parameters: // // - tag string: tag to remove // // Removes the given tag from the taglist. func (list *TagList) RemoveTag(tag string) { var carg0 *C.GstTagList // in, none, converted var carg1 *C.gchar // in, none, string carg0 = (*C.GstTagList)(UnsafeTagListToGlibNone(list)) carg1 = (*C.gchar)(unsafe.Pointer(C.CString(tag))) defer C.free(unsafe.Pointer(carg1)) C.gst_tag_list_remove_tag(carg0, carg1) runtime.KeepAlive(list) runtime.KeepAlive(tag) } // SetScope wraps gst_tag_list_set_scope // // The function takes the following parameters: // // - scope TagScope: new scope for @list // // Sets the scope of @list to @scope. By default the scope // of a taglist is stream scope. func (list *TagList) SetScope(scope TagScope) { var carg0 *C.GstTagList // in, none, converted var carg1 C.GstTagScope // in, none, casted carg0 = (*C.GstTagList)(UnsafeTagListToGlibNone(list)) carg1 = C.GstTagScope(scope) C.gst_tag_list_set_scope(carg0, carg1) runtime.KeepAlive(list) runtime.KeepAlive(scope) } // ToString wraps gst_tag_list_to_string // // The function returns the following values: // // - goret string // // Serializes a tag list to a string. func (list *TagList) ToString() string { var carg0 *C.GstTagList // in, none, converted var cret *C.gchar // return, full, string carg0 = (*C.GstTagList)(UnsafeTagListToGlibNone(list)) cret = C.gst_tag_list_to_string(carg0) runtime.KeepAlive(list) var goret string goret = C.GoString((*C.char)(unsafe.Pointer(cret))) defer C.free(unsafe.Pointer(cret)) return goret } // TagSetterInterface wraps GstTagSetterInterface // // #GstTagSetterInterface interface. type TagSetterInterface struct { *tagSetterInterface } // tagSetterInterface is the struct that's finalized type tagSetterInterface struct { native *C.GstTagSetterInterface } // UnsafeTagSetterInterfaceFromGlibBorrow is used to convert raw C.GstTagSetterInterface pointers to go. This is used by the bindings internally. func UnsafeTagSetterInterfaceFromGlibBorrow(p unsafe.Pointer) *TagSetterInterface { return &TagSetterInterface{&tagSetterInterface{(*C.GstTagSetterInterface)(p)}} } // 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) runtime.SetFinalizer( wrapped.tagSetterInterface, func (intern *tagSetterInterface) { C.free(unsafe.Pointer(intern.native)) }, ) return wrapped } // 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( wrapped.tagSetterInterface, func (intern *tagSetterInterface) { C.free(unsafe.Pointer(intern.native)) }, ) return wrapped } // UnsafeTagSetterInterfaceFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [TagSetterInterface] is expected to work anymore. func UnsafeTagSetterInterfaceFree(t *TagSetterInterface) { C.free(unsafe.Pointer(t.native)) } // UnsafeTagSetterInterfaceToGlibNone returns the underlying C pointer. This is used by the bindings internally. func UnsafeTagSetterInterfaceToGlibNone(t *TagSetterInterface) unsafe.Pointer { return unsafe.Pointer(t.native) } // UnsafeTagSetterInterfaceToGlibFull returns the underlying C pointer and gives up ownership. // This is used by the bindings internally. func UnsafeTagSetterInterfaceToGlibFull(t *TagSetterInterface) unsafe.Pointer { runtime.SetFinalizer(t.tagSetterInterface, nil) _p := unsafe.Pointer(t.native) 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 } // taskClass is the struct that's finalized type taskClass struct { native *C.GstTaskClass } // UnsafeTaskClassFromGlibBorrow is used to convert raw C.GstTaskClass pointers to go. This is used by the bindings internally. func UnsafeTaskClassFromGlibBorrow(p unsafe.Pointer) *TaskClass { return &TaskClass{&taskClass{(*C.GstTaskClass)(p)}} } // 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. func UnsafeTaskClassFree(t *TaskClass) { C.free(unsafe.Pointer(t.native)) } // UnsafeTaskClassToGlibNone returns the underlying C pointer. This is used by the bindings internally. func UnsafeTaskClassToGlibNone(t *TaskClass) unsafe.Pointer { return unsafe.Pointer(t.native) } // 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 } // taskPoolClass is the struct that's finalized type taskPoolClass struct { native *C.GstTaskPoolClass } // UnsafeTaskPoolClassFromGlibBorrow is used to convert raw C.GstTaskPoolClass pointers to go. This is used by the bindings internally. func UnsafeTaskPoolClassFromGlibBorrow(p unsafe.Pointer) *TaskPoolClass { return &TaskPoolClass{&taskPoolClass{(*C.GstTaskPoolClass)(p)}} } // 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. func UnsafeTaskPoolClassFree(t *TaskPoolClass) { C.free(unsafe.Pointer(t.native)) } // UnsafeTaskPoolClassToGlibNone returns the underlying C pointer. This is used by the bindings internally. func UnsafeTaskPoolClassToGlibNone(t *TaskPoolClass) unsafe.Pointer { return unsafe.Pointer(t.native) } // 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. type TimedValue struct { *timedValue } // timedValue is the struct that's finalized type timedValue struct { native *C.GstTimedValue } // UnsafeTimedValueFromGlibBorrow is used to convert raw C.GstTimedValue pointers to go. This is used by the bindings internally. func UnsafeTimedValueFromGlibBorrow(p unsafe.Pointer) *TimedValue { return &TimedValue{&timedValue{(*C.GstTimedValue)(p)}} } // 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) runtime.SetFinalizer( wrapped.timedValue, func (intern *timedValue) { C.free(unsafe.Pointer(intern.native)) }, ) return wrapped } // 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( wrapped.timedValue, func (intern *timedValue) { C.free(unsafe.Pointer(intern.native)) }, ) return wrapped } // UnsafeTimedValueFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [TimedValue] is expected to work anymore. func UnsafeTimedValueFree(t *TimedValue) { C.free(unsafe.Pointer(t.native)) } // UnsafeTimedValueToGlibNone returns the underlying C pointer. This is used by the bindings internally. func UnsafeTimedValueToGlibNone(t *TimedValue) unsafe.Pointer { return unsafe.Pointer(t.native) } // UnsafeTimedValueToGlibFull returns the underlying C pointer and gives up ownership. // This is used by the bindings internally. func UnsafeTimedValueToGlibFull(t *TimedValue) unsafe.Pointer { runtime.SetFinalizer(t.timedValue, nil) _p := unsafe.Pointer(t.native) 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. // Also they are used to convert #GstToc into #GstStructure and vice versa. // // #GstToc lets you to inform other elements in pipeline or application that playing // source has some kind of table of contents (TOC). These may be chapters, editions, // angles or other types. For example: DVD chapters, Matroska chapters or cue sheet // TOC. Such TOC will be useful for applications to display instead of just a // playlist. // // Using TOC is very easy. Firstly, create #GstToc structure which represents root // contents of the source. You can also attach TOC-specific tags to it. Then fill // it with #GstTocEntry entries by appending them to the #GstToc using // gst_toc_append_entry(), and appending subentries to a #GstTocEntry using // gst_toc_entry_append_sub_entry(). // // Note that root level of the TOC can contain only either editions or chapters. You // should not mix them together at the same level. Otherwise you will get serialization // /deserialization errors. Make sure that no one of the entries has negative start and // stop values. // // Use gst_event_new_toc() to create a new TOC #GstEvent, and gst_event_parse_toc() to // parse received TOC event. Use gst_event_new_toc_select() to create a new TOC select #GstEvent, // and gst_event_parse_toc_select() to parse received TOC select event. The same rule for // the #GstMessage: gst_message_new_toc() to create new TOC #GstMessage, and // gst_message_parse_toc() to parse received TOC message. // // TOCs can have global scope or current scope. Global scope TOCs contain // all entries that can possibly be selected using a toc select event, and // are what an application is usually interested in. TOCs with current scope // only contain the parts of the TOC relevant to the currently selected/playing // stream; the current scope TOC is used by downstream elements such as muxers // to write correct TOC entries when transcoding files, for example. When // playing a DVD, the global TOC would contain a hierarchy of all titles, // chapters and angles, for example, while the current TOC would only contain // the chapters for the currently playing title if playback of a specific // title was requested. // // Applications and plugins should not rely on TOCs having a certain kind of // structure, but should allow for different alternatives. For example, a // simple CUE sheet embedded in a file may be presented as a flat list of // track entries, or could have a top-level edition node (or some other // alternative type entry) with track entries underneath that node; or even // multiple top-level edition nodes (or some other alternative type entries) // each with track entries underneath, in case the source file has extracted // a track listing from different sources). type Toc struct { *toc } // toc is the struct that's finalized type toc struct { native *C.GstToc } var _ gobject.GoValueInitializer = (*Toc)(nil) func marshalToc(p unsafe.Pointer) (interface{}, error) { b := gobject.ValueFromNative(p).Boxed() return UnsafeTocFromGlibBorrow(b), nil } func (r *Toc) InitGoValue(v *gobject.Value) { v.Init(TypeToc) v.SetBoxed(unsafe.Pointer(r.native)) } // UnsafeTocFromGlibBorrow is used to convert raw C.GstToc pointers to go. This is used by the bindings internally. func UnsafeTocFromGlibBorrow(p unsafe.Pointer) *Toc { return &Toc{&toc{(*C.GstToc)(p)}} } // 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) runtime.SetFinalizer( wrapped.toc, func (intern *toc) { C.free(unsafe.Pointer(intern.native)) }, ) return wrapped } // 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( wrapped.toc, func (intern *toc) { C.free(unsafe.Pointer(intern.native)) }, ) return wrapped } // UnsafeTocFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [Toc] is expected to work anymore. func UnsafeTocFree(t *Toc) { C.free(unsafe.Pointer(t.native)) } // UnsafeTocToGlibNone returns the underlying C pointer. This is used by the bindings internally. func UnsafeTocToGlibNone(t *Toc) unsafe.Pointer { return unsafe.Pointer(t.native) } // UnsafeTocToGlibFull returns the underlying C pointer and gives up ownership. // This is used by the bindings internally. func UnsafeTocToGlibFull(t *Toc) unsafe.Pointer { runtime.SetFinalizer(t.toc, nil) _p := unsafe.Pointer(t.native) t.native = nil // Toc is invalid from here on return _p } // NewToc wraps gst_toc_new // // The function takes the following parameters: // // - scope TocScope: scope of this TOC // // The function returns the following values: // // - goret *Toc // // Create a new #GstToc structure. func NewToc(scope TocScope) *Toc { var carg1 C.GstTocScope // in, none, casted var cret *C.GstToc // return, full, converted carg1 = C.GstTocScope(scope) cret = C.gst_toc_new(carg1) runtime.KeepAlive(scope) var goret *Toc goret = UnsafeTocFromGlibFull(unsafe.Pointer(cret)) return goret } // AppendEntry wraps gst_toc_append_entry // // The function takes the following parameters: // // - entry *TocEntry: A #GstTocEntry // // Appends the #GstTocEntry @entry to @toc. func (toc *Toc) AppendEntry(entry *TocEntry) { var carg0 *C.GstToc // in, none, converted var carg1 *C.GstTocEntry // in, full, converted carg0 = (*C.GstToc)(UnsafeTocToGlibNone(toc)) carg1 = (*C.GstTocEntry)(UnsafeTocEntryToGlibFull(entry)) C.gst_toc_append_entry(carg0, carg1) runtime.KeepAlive(toc) runtime.KeepAlive(entry) } // Dump wraps gst_toc_dump func (toc *Toc) Dump() { var carg0 *C.GstToc // in, none, converted carg0 = (*C.GstToc)(UnsafeTocToGlibNone(toc)) C.gst_toc_dump(carg0) runtime.KeepAlive(toc) } // FindEntry wraps gst_toc_find_entry // // The function takes the following parameters: // // - uid string: UID to find #GstTocEntry with. // // The function returns the following values: // // - goret *TocEntry (nullable) // // Find #GstTocEntry with given @uid in the @toc. func (toc *Toc) FindEntry(uid string) *TocEntry { var carg0 *C.GstToc // in, none, converted var carg1 *C.gchar // in, none, string var cret *C.GstTocEntry // return, none, converted, nullable carg0 = (*C.GstToc)(UnsafeTocToGlibNone(toc)) carg1 = (*C.gchar)(unsafe.Pointer(C.CString(uid))) defer C.free(unsafe.Pointer(carg1)) cret = C.gst_toc_find_entry(carg0, carg1) runtime.KeepAlive(toc) runtime.KeepAlive(uid) var goret *TocEntry if cret != nil { goret = UnsafeTocEntryFromGlibNone(unsafe.Pointer(cret)) } return goret } // GetEntries wraps gst_toc_get_entries // // The function returns the following values: // // - goret []*TocEntry // // Gets the list of #GstTocEntry of @toc. func (toc *Toc) GetEntries() []*TocEntry { var carg0 *C.GstToc // in, none, converted var cret *C.GList // container, transfer: none carg0 = (*C.GstToc)(UnsafeTocToGlibNone(toc)) cret = C.gst_toc_get_entries(carg0) runtime.KeepAlive(toc) var goret []*TocEntry goret = glib.UnsafeListFromGlibNone( unsafe.Pointer(cret), func(v unsafe.Pointer) *TocEntry { var dst *TocEntry // converted dst = UnsafeTocEntryFromGlibNone(v) return dst }, ) return goret } // GetScope wraps gst_toc_get_scope // // The function returns the following values: // // - goret TocScope func (toc *Toc) GetScope() TocScope { var carg0 *C.GstToc // in, none, converted var cret C.GstTocScope // return, none, casted carg0 = (*C.GstToc)(UnsafeTocToGlibNone(toc)) cret = C.gst_toc_get_scope(carg0) runtime.KeepAlive(toc) var goret TocScope goret = TocScope(cret) return goret } // GetTags wraps gst_toc_get_tags // // The function returns the following values: // // - goret *TagList (nullable) // // Gets the tags for @toc. func (toc *Toc) GetTags() *TagList { var carg0 *C.GstToc // in, none, converted var cret *C.GstTagList // return, none, converted, nullable carg0 = (*C.GstToc)(UnsafeTocToGlibNone(toc)) cret = C.gst_toc_get_tags(carg0) runtime.KeepAlive(toc) var goret *TagList if cret != nil { goret = UnsafeTagListFromGlibNone(unsafe.Pointer(cret)) } return goret } // MergeTags wraps gst_toc_merge_tags // // The function takes the following parameters: // // - tags *TagList (nullable): A #GstTagList or %NULL // - mode TagMergeMode: A #GstTagMergeMode // // Merge @tags into the existing tags of @toc using @mode. func (toc *Toc) MergeTags(tags *TagList, mode TagMergeMode) { var carg0 *C.GstToc // in, none, converted var carg1 *C.GstTagList // in, none, converted, nullable var carg2 C.GstTagMergeMode // in, none, casted carg0 = (*C.GstToc)(UnsafeTocToGlibNone(toc)) if tags != nil { carg1 = (*C.GstTagList)(UnsafeTagListToGlibNone(tags)) } carg2 = C.GstTagMergeMode(mode) C.gst_toc_merge_tags(carg0, carg1, carg2) runtime.KeepAlive(toc) runtime.KeepAlive(tags) runtime.KeepAlive(mode) } // SetTags wraps gst_toc_set_tags // // The function takes the following parameters: // // - tags *TagList (nullable): A #GstTagList or %NULL // // Set a #GstTagList with tags for the complete @toc. func (toc *Toc) SetTags(tags *TagList) { var carg0 *C.GstToc // in, none, converted var carg1 *C.GstTagList // in, full, converted, nullable carg0 = (*C.GstToc)(UnsafeTocToGlibNone(toc)) if tags != nil { carg1 = (*C.GstTagList)(UnsafeTagListToGlibFull(tags)) } C.gst_toc_set_tags(carg0, carg1) runtime.KeepAlive(toc) runtime.KeepAlive(tags) } // TocEntry wraps GstTocEntry type TocEntry struct { *tocEntry } // tocEntry is the struct that's finalized type tocEntry struct { native *C.GstTocEntry } var _ gobject.GoValueInitializer = (*TocEntry)(nil) func marshalTocEntry(p unsafe.Pointer) (interface{}, error) { b := gobject.ValueFromNative(p).Boxed() return UnsafeTocEntryFromGlibBorrow(b), nil } func (r *TocEntry) InitGoValue(v *gobject.Value) { v.Init(TypeTocEntry) v.SetBoxed(unsafe.Pointer(r.native)) } // UnsafeTocEntryFromGlibBorrow is used to convert raw C.GstTocEntry pointers to go. This is used by the bindings internally. func UnsafeTocEntryFromGlibBorrow(p unsafe.Pointer) *TocEntry { return &TocEntry{&tocEntry{(*C.GstTocEntry)(p)}} } // 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) runtime.SetFinalizer( wrapped.tocEntry, func (intern *tocEntry) { C.free(unsafe.Pointer(intern.native)) }, ) return wrapped } // 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( wrapped.tocEntry, func (intern *tocEntry) { C.free(unsafe.Pointer(intern.native)) }, ) return wrapped } // UnsafeTocEntryFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [TocEntry] is expected to work anymore. func UnsafeTocEntryFree(t *TocEntry) { C.free(unsafe.Pointer(t.native)) } // UnsafeTocEntryToGlibNone returns the underlying C pointer. This is used by the bindings internally. func UnsafeTocEntryToGlibNone(t *TocEntry) unsafe.Pointer { return unsafe.Pointer(t.native) } // UnsafeTocEntryToGlibFull returns the underlying C pointer and gives up ownership. // This is used by the bindings internally. func UnsafeTocEntryToGlibFull(t *TocEntry) unsafe.Pointer { runtime.SetFinalizer(t.tocEntry, nil) _p := unsafe.Pointer(t.native) t.native = nil // TocEntry is invalid from here on return _p } // NewTocEntry wraps gst_toc_entry_new // // The function takes the following parameters: // // - typ TocEntryType: entry type. // - uid string: unique ID (UID) in the whole TOC. // // The function returns the following values: // // - goret *TocEntry // // Create new #GstTocEntry structure. func NewTocEntry(typ TocEntryType, uid string) *TocEntry { var carg1 C.GstTocEntryType // in, none, casted var carg2 *C.gchar // in, none, string var cret *C.GstTocEntry // return, full, converted carg1 = C.GstTocEntryType(typ) carg2 = (*C.gchar)(unsafe.Pointer(C.CString(uid))) defer C.free(unsafe.Pointer(carg2)) cret = C.gst_toc_entry_new(carg1, carg2) runtime.KeepAlive(typ) runtime.KeepAlive(uid) var goret *TocEntry goret = UnsafeTocEntryFromGlibFull(unsafe.Pointer(cret)) return goret } // AppendSubEntry wraps gst_toc_entry_append_sub_entry // // The function takes the following parameters: // // - subentry *TocEntry: A #GstTocEntry // // Appends the #GstTocEntry @subentry to @entry. func (entry *TocEntry) AppendSubEntry(subentry *TocEntry) { var carg0 *C.GstTocEntry // in, none, converted var carg1 *C.GstTocEntry // in, full, converted carg0 = (*C.GstTocEntry)(UnsafeTocEntryToGlibNone(entry)) carg1 = (*C.GstTocEntry)(UnsafeTocEntryToGlibFull(subentry)) C.gst_toc_entry_append_sub_entry(carg0, carg1) runtime.KeepAlive(entry) runtime.KeepAlive(subentry) } // GetEntryType wraps gst_toc_entry_get_entry_type // // The function returns the following values: // // - goret TocEntryType func (entry *TocEntry) GetEntryType() TocEntryType { var carg0 *C.GstTocEntry // in, none, converted var cret C.GstTocEntryType // return, none, casted carg0 = (*C.GstTocEntry)(UnsafeTocEntryToGlibNone(entry)) cret = C.gst_toc_entry_get_entry_type(carg0) runtime.KeepAlive(entry) var goret TocEntryType goret = TocEntryType(cret) return goret } // GetLoop wraps gst_toc_entry_get_loop // // The function returns the following values: // // - loopType TocLoopType: the storage for the loop_type // value, leave %NULL if not need. // - repeatCount int: the storage for the repeat_count // value, leave %NULL if not need. // - goret bool // // Get @loop_type and @repeat_count values from the @entry and write them into // appropriate storages. Loops are e.g. used by sampled instruments. GStreamer // is not automatically applying the loop. The application can process this // meta data and use it e.g. to send a seek-event to loop a section. func (entry *TocEntry) GetLoop() (TocLoopType, int, bool) { var carg0 *C.GstTocEntry // in, none, converted var carg1 C.GstTocLoopType // out, full, casted var carg2 C.gint // out, full, casted var cret C.gboolean // return carg0 = (*C.GstTocEntry)(UnsafeTocEntryToGlibNone(entry)) cret = C.gst_toc_entry_get_loop(carg0, &carg1, &carg2) runtime.KeepAlive(entry) var loopType TocLoopType var repeatCount int var goret bool loopType = TocLoopType(carg1) repeatCount = int(carg2) if cret != 0 { goret = true } return loopType, repeatCount, goret } // GetParent wraps gst_toc_entry_get_parent // // The function returns the following values: // // - goret *TocEntry (nullable) // // Gets the parent #GstTocEntry of @entry. func (entry *TocEntry) GetParent() *TocEntry { var carg0 *C.GstTocEntry // in, none, converted var cret *C.GstTocEntry // return, none, converted, nullable carg0 = (*C.GstTocEntry)(UnsafeTocEntryToGlibNone(entry)) cret = C.gst_toc_entry_get_parent(carg0) runtime.KeepAlive(entry) var goret *TocEntry if cret != nil { goret = UnsafeTocEntryFromGlibNone(unsafe.Pointer(cret)) } return goret } // GetStartStopTimes wraps gst_toc_entry_get_start_stop_times // // The function returns the following values: // // - start int64: the storage for the start value, leave // %NULL if not need. // - stop int64: the storage for the stop value, leave // %NULL if not need. // - goret bool // // Get @start and @stop values from the @entry and write them into appropriate // storages. func (entry *TocEntry) GetStartStopTimes() (int64, int64, bool) { var carg0 *C.GstTocEntry // in, none, converted var carg1 C.gint64 // out, full, casted var carg2 C.gint64 // out, full, casted var cret C.gboolean // return carg0 = (*C.GstTocEntry)(UnsafeTocEntryToGlibNone(entry)) cret = C.gst_toc_entry_get_start_stop_times(carg0, &carg1, &carg2) runtime.KeepAlive(entry) var start int64 var stop int64 var goret bool start = int64(carg1) stop = int64(carg2) if cret != 0 { goret = true } return start, stop, goret } // GetSubEntries wraps gst_toc_entry_get_sub_entries // // The function returns the following values: // // - goret []*TocEntry // // Gets the sub-entries of @entry. func (entry *TocEntry) GetSubEntries() []*TocEntry { var carg0 *C.GstTocEntry // in, none, converted var cret *C.GList // container, transfer: none carg0 = (*C.GstTocEntry)(UnsafeTocEntryToGlibNone(entry)) cret = C.gst_toc_entry_get_sub_entries(carg0) runtime.KeepAlive(entry) var goret []*TocEntry goret = glib.UnsafeListFromGlibNone( unsafe.Pointer(cret), func(v unsafe.Pointer) *TocEntry { var dst *TocEntry // converted dst = UnsafeTocEntryFromGlibNone(v) return dst }, ) return goret } // GetTags wraps gst_toc_entry_get_tags // // The function returns the following values: // // - goret *TagList (nullable) // // Gets the tags for @entry. func (entry *TocEntry) GetTags() *TagList { var carg0 *C.GstTocEntry // in, none, converted var cret *C.GstTagList // return, none, converted, nullable carg0 = (*C.GstTocEntry)(UnsafeTocEntryToGlibNone(entry)) cret = C.gst_toc_entry_get_tags(carg0) runtime.KeepAlive(entry) var goret *TagList if cret != nil { goret = UnsafeTagListFromGlibNone(unsafe.Pointer(cret)) } return goret } // GetToc wraps gst_toc_entry_get_toc // // The function returns the following values: // // - goret *Toc (nullable) // // Gets the parent #GstToc of @entry. func (entry *TocEntry) GetToc() *Toc { var carg0 *C.GstTocEntry // in, none, converted var cret *C.GstToc // return, none, converted, nullable carg0 = (*C.GstTocEntry)(UnsafeTocEntryToGlibNone(entry)) cret = C.gst_toc_entry_get_toc(carg0) runtime.KeepAlive(entry) var goret *Toc if cret != nil { goret = UnsafeTocFromGlibNone(unsafe.Pointer(cret)) } return goret } // GetUid wraps gst_toc_entry_get_uid // // The function returns the following values: // // - goret string // // Gets the UID of @entry. func (entry *TocEntry) GetUid() string { var carg0 *C.GstTocEntry // in, none, converted var cret *C.gchar // return, none, string carg0 = (*C.GstTocEntry)(UnsafeTocEntryToGlibNone(entry)) cret = C.gst_toc_entry_get_uid(carg0) runtime.KeepAlive(entry) var goret string goret = C.GoString((*C.char)(unsafe.Pointer(cret))) return goret } // IsAlternative wraps gst_toc_entry_is_alternative // // The function returns the following values: // // - goret bool func (entry *TocEntry) IsAlternative() bool { var carg0 *C.GstTocEntry // in, none, converted var cret C.gboolean // return carg0 = (*C.GstTocEntry)(UnsafeTocEntryToGlibNone(entry)) cret = C.gst_toc_entry_is_alternative(carg0) runtime.KeepAlive(entry) var goret bool if cret != 0 { goret = true } return goret } // IsSequence wraps gst_toc_entry_is_sequence // // The function returns the following values: // // - goret bool func (entry *TocEntry) IsSequence() bool { var carg0 *C.GstTocEntry // in, none, converted var cret C.gboolean // return carg0 = (*C.GstTocEntry)(UnsafeTocEntryToGlibNone(entry)) cret = C.gst_toc_entry_is_sequence(carg0) runtime.KeepAlive(entry) var goret bool if cret != 0 { goret = true } return goret } // MergeTags wraps gst_toc_entry_merge_tags // // The function takes the following parameters: // // - tags *TagList (nullable): A #GstTagList or %NULL // - mode TagMergeMode: A #GstTagMergeMode // // Merge @tags into the existing tags of @entry using @mode. func (entry *TocEntry) MergeTags(tags *TagList, mode TagMergeMode) { var carg0 *C.GstTocEntry // in, none, converted var carg1 *C.GstTagList // in, none, converted, nullable var carg2 C.GstTagMergeMode // in, none, casted carg0 = (*C.GstTocEntry)(UnsafeTocEntryToGlibNone(entry)) if tags != nil { carg1 = (*C.GstTagList)(UnsafeTagListToGlibNone(tags)) } carg2 = C.GstTagMergeMode(mode) C.gst_toc_entry_merge_tags(carg0, carg1, carg2) runtime.KeepAlive(entry) runtime.KeepAlive(tags) runtime.KeepAlive(mode) } // SetLoop wraps gst_toc_entry_set_loop // // The function takes the following parameters: // // - loopType TocLoopType: loop_type value to set. // - repeatCount int: repeat_count value to set. // // Set @loop_type and @repeat_count values for the @entry. func (entry *TocEntry) SetLoop(loopType TocLoopType, repeatCount int) { var carg0 *C.GstTocEntry // in, none, converted var carg1 C.GstTocLoopType // in, none, casted var carg2 C.gint // in, none, casted carg0 = (*C.GstTocEntry)(UnsafeTocEntryToGlibNone(entry)) carg1 = C.GstTocLoopType(loopType) carg2 = C.gint(repeatCount) C.gst_toc_entry_set_loop(carg0, carg1, carg2) runtime.KeepAlive(entry) runtime.KeepAlive(loopType) runtime.KeepAlive(repeatCount) } // SetStartStopTimes wraps gst_toc_entry_set_start_stop_times // // The function takes the following parameters: // // - start int64: start value to set. // - stop int64: stop value to set. // // Set @start and @stop values for the @entry. func (entry *TocEntry) SetStartStopTimes(start int64, stop int64) { var carg0 *C.GstTocEntry // in, none, converted var carg1 C.gint64 // in, none, casted var carg2 C.gint64 // in, none, casted carg0 = (*C.GstTocEntry)(UnsafeTocEntryToGlibNone(entry)) carg1 = C.gint64(start) carg2 = C.gint64(stop) C.gst_toc_entry_set_start_stop_times(carg0, carg1, carg2) runtime.KeepAlive(entry) runtime.KeepAlive(start) runtime.KeepAlive(stop) } // SetTags wraps gst_toc_entry_set_tags // // The function takes the following parameters: // // - tags *TagList (nullable): A #GstTagList or %NULL // // Set a #GstTagList with tags for the complete @entry. func (entry *TocEntry) SetTags(tags *TagList) { var carg0 *C.GstTocEntry // in, none, converted var carg1 *C.GstTagList // in, full, converted, nullable carg0 = (*C.GstTocEntry)(UnsafeTocEntryToGlibNone(entry)) if tags != nil { carg1 = (*C.GstTagList)(UnsafeTagListToGlibFull(tags)) } C.gst_toc_entry_set_tags(carg0, carg1) runtime.KeepAlive(entry) runtime.KeepAlive(tags) } // TocSetterInterface wraps GstTocSetterInterface // // #GstTocSetterInterface interface. type TocSetterInterface struct { *tocSetterInterface } // tocSetterInterface is the struct that's finalized type tocSetterInterface struct { native *C.GstTocSetterInterface } // UnsafeTocSetterInterfaceFromGlibBorrow is used to convert raw C.GstTocSetterInterface pointers to go. This is used by the bindings internally. func UnsafeTocSetterInterfaceFromGlibBorrow(p unsafe.Pointer) *TocSetterInterface { return &TocSetterInterface{&tocSetterInterface{(*C.GstTocSetterInterface)(p)}} } // 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) runtime.SetFinalizer( wrapped.tocSetterInterface, func (intern *tocSetterInterface) { C.free(unsafe.Pointer(intern.native)) }, ) return wrapped } // 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( wrapped.tocSetterInterface, func (intern *tocSetterInterface) { C.free(unsafe.Pointer(intern.native)) }, ) return wrapped } // UnsafeTocSetterInterfaceFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [TocSetterInterface] is expected to work anymore. func UnsafeTocSetterInterfaceFree(t *TocSetterInterface) { C.free(unsafe.Pointer(t.native)) } // UnsafeTocSetterInterfaceToGlibNone returns the underlying C pointer. This is used by the bindings internally. func UnsafeTocSetterInterfaceToGlibNone(t *TocSetterInterface) unsafe.Pointer { return unsafe.Pointer(t.native) } // UnsafeTocSetterInterfaceToGlibFull returns the underlying C pointer and gives up ownership. // This is used by the bindings internally. func UnsafeTocSetterInterfaceToGlibFull(t *TocSetterInterface) unsafe.Pointer { runtime.SetFinalizer(t.tocSetterInterface, nil) _p := unsafe.Pointer(t.native) 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 } // tracerClass is the struct that's finalized type tracerClass struct { native *C.GstTracerClass } // UnsafeTracerClassFromGlibBorrow is used to convert raw C.GstTracerClass pointers to go. This is used by the bindings internally. func UnsafeTracerClassFromGlibBorrow(p unsafe.Pointer) *TracerClass { return &TracerClass{&tracerClass{(*C.GstTracerClass)(p)}} } // 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. func UnsafeTracerClassFree(t *TracerClass) { C.free(unsafe.Pointer(t.native)) } // UnsafeTracerClassToGlibNone returns the underlying C pointer. This is used by the bindings internally. func UnsafeTracerClassToGlibNone(t *TracerClass) unsafe.Pointer { return unsafe.Pointer(t.native) } // 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 } // tracerFactoryClass is the struct that's finalized type tracerFactoryClass struct { native *C.GstTracerFactoryClass } // UnsafeTracerFactoryClassFromGlibBorrow is used to convert raw C.GstTracerFactoryClass pointers to go. This is used by the bindings internally. func UnsafeTracerFactoryClassFromGlibBorrow(p unsafe.Pointer) *TracerFactoryClass { return &TracerFactoryClass{&tracerFactoryClass{(*C.GstTracerFactoryClass)(p)}} } // 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. func UnsafeTracerFactoryClassFree(t *TracerFactoryClass) { C.free(unsafe.Pointer(t.native)) } // UnsafeTracerFactoryClassToGlibNone returns the underlying C pointer. This is used by the bindings internally. func UnsafeTracerFactoryClassToGlibNone(t *TracerFactoryClass) unsafe.Pointer { return unsafe.Pointer(t.native) } // 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 } // tracerRecordClass is the struct that's finalized type tracerRecordClass struct { native *C.GstTracerRecordClass } // UnsafeTracerRecordClassFromGlibBorrow is used to convert raw C.GstTracerRecordClass pointers to go. This is used by the bindings internally. func UnsafeTracerRecordClassFromGlibBorrow(p unsafe.Pointer) *TracerRecordClass { return &TracerRecordClass{&tracerRecordClass{(*C.GstTracerRecordClass)(p)}} } // 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. func UnsafeTracerRecordClassFree(t *TracerRecordClass) { C.free(unsafe.Pointer(t.native)) } // UnsafeTracerRecordClassToGlibNone returns the underlying C pointer. This is used by the bindings internally. func UnsafeTracerRecordClassToGlibNone(t *TracerRecordClass) unsafe.Pointer { return unsafe.Pointer(t.native) } // 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 // stream. type TypeFind struct { *typeFind } // typeFind is the struct that's finalized type typeFind struct { native *C.GstTypeFind } var _ gobject.GoValueInitializer = (*TypeFind)(nil) func marshalTypeFind(p unsafe.Pointer) (interface{}, error) { b := gobject.ValueFromNative(p).Boxed() return UnsafeTypeFindFromGlibBorrow(b), nil } func (r *TypeFind) InitGoValue(v *gobject.Value) { v.Init(TypeTypeFind) v.SetBoxed(unsafe.Pointer(r.native)) } // UnsafeTypeFindFromGlibBorrow is used to convert raw C.GstTypeFind pointers to go. This is used by the bindings internally. func UnsafeTypeFindFromGlibBorrow(p unsafe.Pointer) *TypeFind { return &TypeFind{&typeFind{(*C.GstTypeFind)(p)}} } // 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) runtime.SetFinalizer( wrapped.typeFind, func (intern *typeFind) { C.free(unsafe.Pointer(intern.native)) }, ) return wrapped } // 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( wrapped.typeFind, func (intern *typeFind) { C.free(unsafe.Pointer(intern.native)) }, ) return wrapped } // UnsafeTypeFindFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [TypeFind] is expected to work anymore. func UnsafeTypeFindFree(t *TypeFind) { C.free(unsafe.Pointer(t.native)) } // UnsafeTypeFindToGlibNone returns the underlying C pointer. This is used by the bindings internally. func UnsafeTypeFindToGlibNone(t *TypeFind) unsafe.Pointer { return unsafe.Pointer(t.native) } // UnsafeTypeFindToGlibFull returns the underlying C pointer and gives up ownership. // This is used by the bindings internally. func UnsafeTypeFindToGlibFull(t *TypeFind) unsafe.Pointer { runtime.SetFinalizer(t.typeFind, nil) _p := unsafe.Pointer(t.native) t.native = nil // TypeFind is invalid from here on return _p } // TypeFindRegister wraps gst_type_find_register // // The function takes the following parameters: // // - plugin Plugin (nullable): A #GstPlugin, or %NULL for a static typefind function // - name string: The name for registering // - rank uint: The rank (or importance) of this typefind function // - fn TypeFindFunction: The #GstTypeFindFunction to use // - extensions string (nullable): Optional comma-separated list of extensions // that could belong to this type // - possibleCaps *Caps (nullable): Optionally the caps that could be returned when typefinding // succeeds // // The function returns the following values: // // - goret bool // // Registers a new typefind function to be used for typefinding. After // registering this function will be available for typefinding. // This function is typically called during an element's plugin initialization. func TypeFindRegister(plugin Plugin, name string, rank uint, fn TypeFindFunction, extensions string, possibleCaps *Caps) bool { var carg1 *C.GstPlugin // in, none, converted, nullable var carg2 *C.gchar // in, none, string var carg3 C.guint // in, none, casted var carg4 C.GstTypeFindFunction // callback, scope: notified, closure: carg7, destroy: carg8 var carg5 *C.gchar // in, none, string, nullable-string var carg6 *C.GstCaps // in, none, converted, nullable var carg7 C.gpointer // implicit var carg8 C.GDestroyNotify // implicit var cret C.gboolean // return if plugin != nil { carg1 = (*C.GstPlugin)(UnsafePluginToGlibNone(plugin)) } carg2 = (*C.gchar)(unsafe.Pointer(C.CString(name))) defer C.free(unsafe.Pointer(carg2)) carg3 = C.guint(rank) carg4 = (*[0]byte)(C._gotk4_gst1_TypeFindFunction) carg7 = C.gpointer(userdata.Register(fn)) carg8 = (C.GDestroyNotify)((*[0]byte)(C.destroyUserdata)) if extensions != "" { carg5 = (*C.gchar)(unsafe.Pointer(C.CString(extensions))) defer C.free(unsafe.Pointer(carg5)) } if possibleCaps != nil { carg6 = (*C.GstCaps)(UnsafeCapsToGlibNone(possibleCaps)) } cret = C.gst_type_find_register(carg1, carg2, carg3, carg4, carg5, carg6, carg7, carg8) runtime.KeepAlive(plugin) runtime.KeepAlive(name) runtime.KeepAlive(rank) runtime.KeepAlive(fn) runtime.KeepAlive(extensions) runtime.KeepAlive(possibleCaps) var goret bool if cret != 0 { goret = true } return goret } // GetLength wraps gst_type_find_get_length // // The function returns the following values: // // - goret uint64 // // Get the length of the data stream. func (find *TypeFind) GetLength() uint64 { var carg0 *C.GstTypeFind // in, none, converted var cret C.guint64 // return, none, casted carg0 = (*C.GstTypeFind)(UnsafeTypeFindToGlibNone(find)) cret = C.gst_type_find_get_length(carg0) runtime.KeepAlive(find) var goret uint64 goret = uint64(cret) return goret } // Peek wraps gst_type_find_peek // // The function takes the following parameters: // // - offset int64: The offset // - size uint: The number of bytes to return // // The function returns the following values: // // - goret *uint8 (nullable) // // Returns the @size bytes of the stream to identify beginning at offset. If // offset is a positive number, the offset is relative to the beginning of the // stream, if offset is a negative number the offset is relative to the end of // the stream. The returned memory is valid until the typefinding function // returns and must not be freed. func (find *TypeFind) Peek(offset int64, size uint) *uint8 { var carg0 *C.GstTypeFind // in, none, converted var carg1 C.gint64 // in, none, casted var carg2 C.guint // in, none, casted var cret *C.guint8 // return, transfer: none, C Pointers: 1, Name: guint8, scope: , nullable, nullable carg0 = (*C.GstTypeFind)(UnsafeTypeFindToGlibNone(find)) carg1 = C.gint64(offset) carg2 = C.guint(size) cret = C.gst_type_find_peek(carg0, carg1, carg2) runtime.KeepAlive(find) runtime.KeepAlive(offset) runtime.KeepAlive(size) var goret *uint8 if cret != nil { _ = goret _ = cret panic("unimplemented conversion of *uint8 (guint8*)") } return goret } // Suggest wraps gst_type_find_suggest // // The function takes the following parameters: // // - probability uint: The probability in percent that the suggestion is right // - caps *Caps: The fixed #GstCaps to suggest // // If a #GstTypeFindFunction calls this function it suggests the caps with the // given probability. A #GstTypeFindFunction may supply different suggestions // in one call. // It is up to the caller of the #GstTypeFindFunction to interpret these values. func (find *TypeFind) Suggest(probability uint, caps *Caps) { var carg0 *C.GstTypeFind // in, none, converted var carg1 C.guint // in, none, casted var carg2 *C.GstCaps // in, none, converted carg0 = (*C.GstTypeFind)(UnsafeTypeFindToGlibNone(find)) carg1 = C.guint(probability) carg2 = (*C.GstCaps)(UnsafeCapsToGlibNone(caps)) C.gst_type_find_suggest(carg0, carg1, carg2) runtime.KeepAlive(find) runtime.KeepAlive(probability) runtime.KeepAlive(caps) } // SuggestEmptySimple wraps gst_type_find_suggest_empty_simple // // The function takes the following parameters: // // - probability uint: The probability in percent that the suggestion is right // - mediaType string: the media type of the suggested caps // // If a #GstTypeFindFunction calls this function it suggests caps of the // given @media_type with the given @probability. // // This function is similar to gst_type_find_suggest_simple(), but uses // a #GstCaps with no fields. func (find *TypeFind) SuggestEmptySimple(probability uint, mediaType string) { var carg0 *C.GstTypeFind // in, none, converted var carg1 C.guint // in, none, casted var carg2 *C.char // in, none, string, casted *C.gchar carg0 = (*C.GstTypeFind)(UnsafeTypeFindToGlibNone(find)) carg1 = C.guint(probability) carg2 = (*C.char)(unsafe.Pointer(C.CString(mediaType))) defer C.free(unsafe.Pointer(carg2)) C.gst_type_find_suggest_empty_simple(carg0, carg1, carg2) runtime.KeepAlive(find) runtime.KeepAlive(probability) runtime.KeepAlive(mediaType) } // TypeFindFactoryClass wraps GstTypeFindFactoryClass // // TypeFindFactoryClass is the type struct for [TypeFindFactory] type TypeFindFactoryClass struct { *typeFindFactoryClass } // typeFindFactoryClass is the struct that's finalized type typeFindFactoryClass struct { native *C.GstTypeFindFactoryClass } // UnsafeTypeFindFactoryClassFromGlibBorrow is used to convert raw C.GstTypeFindFactoryClass pointers to go. This is used by the bindings internally. func UnsafeTypeFindFactoryClassFromGlibBorrow(p unsafe.Pointer) *TypeFindFactoryClass { return &TypeFindFactoryClass{&typeFindFactoryClass{(*C.GstTypeFindFactoryClass)(p)}} } // 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. func UnsafeTypeFindFactoryClassFree(t *TypeFindFactoryClass) { C.free(unsafe.Pointer(t.native)) } // UnsafeTypeFindFactoryClassToGlibNone returns the underlying C pointer. This is used by the bindings internally. func UnsafeTypeFindFactoryClassToGlibNone(t *TypeFindFactoryClass) unsafe.Pointer { return unsafe.Pointer(t.native) } // 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. type URIHandlerInterface struct { *uriHandlerInterface } // uriHandlerInterface is the struct that's finalized type uriHandlerInterface struct { native *C.GstURIHandlerInterface } // UnsafeURIHandlerInterfaceFromGlibBorrow is used to convert raw C.GstURIHandlerInterface pointers to go. This is used by the bindings internally. func UnsafeURIHandlerInterfaceFromGlibBorrow(p unsafe.Pointer) *URIHandlerInterface { return &URIHandlerInterface{&uriHandlerInterface{(*C.GstURIHandlerInterface)(p)}} } // 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) runtime.SetFinalizer( wrapped.uriHandlerInterface, func (intern *uriHandlerInterface) { C.free(unsafe.Pointer(intern.native)) }, ) return wrapped } // 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( wrapped.uriHandlerInterface, func (intern *uriHandlerInterface) { C.free(unsafe.Pointer(intern.native)) }, ) return wrapped } // UnsafeURIHandlerInterfaceFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [URIHandlerInterface] is expected to work anymore. func UnsafeURIHandlerInterfaceFree(u *URIHandlerInterface) { C.free(unsafe.Pointer(u.native)) } // UnsafeURIHandlerInterfaceToGlibNone returns the underlying C pointer. This is used by the bindings internally. func UnsafeURIHandlerInterfaceToGlibNone(u *URIHandlerInterface) unsafe.Pointer { return unsafe.Pointer(u.native) } // UnsafeURIHandlerInterfaceToGlibFull returns the underlying C pointer and gives up ownership. // This is used by the bindings internally. func UnsafeURIHandlerInterfaceToGlibFull(u *URIHandlerInterface) unsafe.Pointer { runtime.SetFinalizer(u.uriHandlerInterface, nil) _p := unsafe.Pointer(u.native) 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 // constituent parts. Two #GstUri objects can be joined to make a new #GstUri // using the algorithm described in RFC3986. type Uri struct { *uri } // uri is the struct that's finalized type uri struct { native *C.GstUri } var _ gobject.GoValueInitializer = (*Uri)(nil) func marshalUri(p unsafe.Pointer) (interface{}, error) { b := gobject.ValueFromNative(p).Boxed() return UnsafeUriFromGlibBorrow(b), nil } func (r *Uri) InitGoValue(v *gobject.Value) { v.Init(TypeUri) v.SetBoxed(unsafe.Pointer(r.native)) } // UnsafeUriFromGlibBorrow is used to convert raw C.GstUri pointers to go. This is used by the bindings internally. func UnsafeUriFromGlibBorrow(p unsafe.Pointer) *Uri { return &Uri{&uri{(*C.GstUri)(p)}} } // 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) runtime.SetFinalizer( wrapped.uri, func (intern *uri) { C.free(unsafe.Pointer(intern.native)) }, ) return wrapped } // 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( wrapped.uri, func (intern *uri) { C.free(unsafe.Pointer(intern.native)) }, ) return wrapped } // UnsafeUriFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [Uri] is expected to work anymore. func UnsafeUriFree(u *Uri) { C.free(unsafe.Pointer(u.native)) } // UnsafeUriToGlibNone returns the underlying C pointer. This is used by the bindings internally. func UnsafeUriToGlibNone(u *Uri) unsafe.Pointer { return unsafe.Pointer(u.native) } // UnsafeUriToGlibFull returns the underlying C pointer and gives up ownership. // This is used by the bindings internally. func UnsafeUriToGlibFull(u *Uri) unsafe.Pointer { runtime.SetFinalizer(u.uri, nil) _p := unsafe.Pointer(u.native) u.native = nil // Uri is invalid from here on return _p } // NewUri wraps gst_uri_new // // The function takes the following parameters: // // - scheme string (nullable): The scheme for the new URI. // - userinfo string (nullable): The user-info for the new URI. // - host string (nullable): The host name for the new URI. // - port uint: The port number for the new URI or %GST_URI_NO_PORT. // - path string (nullable): The path for the new URI with '/' separating path // elements. // - query string (nullable): The query string for the new URI with '&' separating // query elements. Elements containing '&' characters // should encode them as "&percnt;26". // - fragment string (nullable): The fragment name for the new URI. // // The function returns the following values: // // - goret *Uri // // Creates a new #GstUri object with the given URI parts. The path and query // strings will be broken down into their elements. All strings should not be // escaped except where indicated. func NewUri(scheme string, userinfo string, host string, port uint, path string, query string, fragment string) *Uri { var carg1 *C.gchar // in, none, string, nullable-string var carg2 *C.gchar // in, none, string, nullable-string var carg3 *C.gchar // in, none, string, nullable-string var carg4 C.guint // in, none, casted var carg5 *C.gchar // in, none, string, nullable-string var carg6 *C.gchar // in, none, string, nullable-string var carg7 *C.gchar // in, none, string, nullable-string var cret *C.GstUri // return, full, converted if scheme != "" { carg1 = (*C.gchar)(unsafe.Pointer(C.CString(scheme))) defer C.free(unsafe.Pointer(carg1)) } if userinfo != "" { carg2 = (*C.gchar)(unsafe.Pointer(C.CString(userinfo))) defer C.free(unsafe.Pointer(carg2)) } if host != "" { carg3 = (*C.gchar)(unsafe.Pointer(C.CString(host))) defer C.free(unsafe.Pointer(carg3)) } carg4 = C.guint(port) if path != "" { carg5 = (*C.gchar)(unsafe.Pointer(C.CString(path))) defer C.free(unsafe.Pointer(carg5)) } if query != "" { carg6 = (*C.gchar)(unsafe.Pointer(C.CString(query))) defer C.free(unsafe.Pointer(carg6)) } if fragment != "" { carg7 = (*C.gchar)(unsafe.Pointer(C.CString(fragment))) defer C.free(unsafe.Pointer(carg7)) } cret = C.gst_uri_new(carg1, carg2, carg3, carg4, carg5, carg6, carg7) runtime.KeepAlive(scheme) runtime.KeepAlive(userinfo) runtime.KeepAlive(host) runtime.KeepAlive(port) runtime.KeepAlive(path) runtime.KeepAlive(query) runtime.KeepAlive(fragment) var goret *Uri goret = UnsafeUriFromGlibFull(unsafe.Pointer(cret)) return goret } // UriConstruct wraps gst_uri_construct // // The function takes the following parameters: // // - protocol string: Protocol for URI // - location string: Location for URI // // The function returns the following values: // // - goret string // // Constructs a URI for a given valid protocol and location. // // Free-function: g_free // // Deprecated: Use GstURI instead. func UriConstruct(protocol string, location string) string { var carg1 *C.gchar // in, none, string var carg2 *C.gchar // in, none, string var cret *C.gchar // return, full, string carg1 = (*C.gchar)(unsafe.Pointer(C.CString(protocol))) defer C.free(unsafe.Pointer(carg1)) carg2 = (*C.gchar)(unsafe.Pointer(C.CString(location))) defer C.free(unsafe.Pointer(carg2)) cret = C.gst_uri_construct(carg1, carg2) runtime.KeepAlive(protocol) runtime.KeepAlive(location) var goret string goret = C.GoString((*C.char)(unsafe.Pointer(cret))) defer C.free(unsafe.Pointer(cret)) return goret } // UriFromString wraps gst_uri_from_string // // The function takes the following parameters: // // - uri string: The URI string to parse. // // The function returns the following values: // // - goret *Uri (nullable) // // Parses a URI string into a new #GstUri object. Will return NULL if the URI // cannot be parsed. func UriFromString(uri string) *Uri { var carg1 *C.gchar // in, none, string var cret *C.GstUri // return, full, converted, nullable carg1 = (*C.gchar)(unsafe.Pointer(C.CString(uri))) defer C.free(unsafe.Pointer(carg1)) cret = C.gst_uri_from_string(carg1) runtime.KeepAlive(uri) var goret *Uri if cret != nil { goret = UnsafeUriFromGlibFull(unsafe.Pointer(cret)) } return goret } // UriFromStringEscaped wraps gst_uri_from_string_escaped // // The function takes the following parameters: // // - uri string: The URI string to parse. // // The function returns the following values: // // - goret *Uri (nullable) // // Parses a URI string into a new #GstUri object. Will return NULL if the URI // cannot be parsed. This is identical to gst_uri_from_string() except that // the userinfo and fragment components of the URI will not be unescaped while // parsing. // // Use this when you need to extract a username and password from the userinfo // such as https://user:password@example.com since either may contain // a URI-escaped ':' character. gst_uri_from_string() will unescape the entire // userinfo component, which will make it impossible to know which ':' // delineates the username and password. // // The same applies to the fragment component of the URI, such as // https://example.com/path#fragment which may contain a URI-escaped '#'. func UriFromStringEscaped(uri string) *Uri { var carg1 *C.gchar // in, none, string var cret *C.GstUri // return, full, converted, nullable carg1 = (*C.gchar)(unsafe.Pointer(C.CString(uri))) defer C.free(unsafe.Pointer(carg1)) cret = C.gst_uri_from_string_escaped(carg1) runtime.KeepAlive(uri) var goret *Uri if cret != nil { goret = UnsafeUriFromGlibFull(unsafe.Pointer(cret)) } return goret } // UriGetLocation wraps gst_uri_get_location // // The function takes the following parameters: // // - uri string: A URI string // // The function returns the following values: // // - goret string (nullable) // // Extracts the location out of a given valid URI, ie. the protocol and "://" // are stripped from the URI, which means that the location returned includes // the hostname if one is specified. The returned string must be freed using // g_free(). // // Free-function: g_free func UriGetLocation(uri string) string { var carg1 *C.gchar // in, none, string var cret *C.gchar // return, full, string, nullable-string carg1 = (*C.gchar)(unsafe.Pointer(C.CString(uri))) defer C.free(unsafe.Pointer(carg1)) cret = C.gst_uri_get_location(carg1) runtime.KeepAlive(uri) var goret string if cret != nil { goret = C.GoString((*C.char)(unsafe.Pointer(cret))) defer C.free(unsafe.Pointer(cret)) } return goret } // UriGetProtocol wraps gst_uri_get_protocol // // The function takes the following parameters: // // - uri string: A URI string // // The function returns the following values: // // - goret string (nullable) // // Extracts the protocol out of a given valid URI. The returned string must be // freed using g_free(). func UriGetProtocol(uri string) string { var carg1 *C.gchar // in, none, string var cret *C.gchar // return, full, string, nullable-string carg1 = (*C.gchar)(unsafe.Pointer(C.CString(uri))) defer C.free(unsafe.Pointer(carg1)) cret = C.gst_uri_get_protocol(carg1) runtime.KeepAlive(uri) var goret string if cret != nil { goret = C.GoString((*C.char)(unsafe.Pointer(cret))) defer C.free(unsafe.Pointer(cret)) } return goret } // UriHasProtocol wraps gst_uri_has_protocol // // The function takes the following parameters: // // - uri string: a URI string // - protocol string: a protocol string (e.g. "http") // // The function returns the following values: // // - goret bool // // Checks if the protocol of a given valid URI matches @protocol. func UriHasProtocol(uri string, protocol string) bool { var carg1 *C.gchar // in, none, string var carg2 *C.gchar // in, none, string var cret C.gboolean // return carg1 = (*C.gchar)(unsafe.Pointer(C.CString(uri))) defer C.free(unsafe.Pointer(carg1)) carg2 = (*C.gchar)(unsafe.Pointer(C.CString(protocol))) defer C.free(unsafe.Pointer(carg2)) cret = C.gst_uri_has_protocol(carg1, carg2) runtime.KeepAlive(uri) runtime.KeepAlive(protocol) var goret bool if cret != 0 { goret = true } return goret } // UriIsValid wraps gst_uri_is_valid // // The function takes the following parameters: // // - uri string: A URI string // // The function returns the following values: // // - goret bool // // Tests if the given string is a valid URI identifier. URIs start with a valid // scheme followed by ":" and maybe a string identifying the location. func UriIsValid(uri string) bool { var carg1 *C.gchar // in, none, string var cret C.gboolean // return carg1 = (*C.gchar)(unsafe.Pointer(C.CString(uri))) defer C.free(unsafe.Pointer(carg1)) cret = C.gst_uri_is_valid(carg1) runtime.KeepAlive(uri) var goret bool if cret != 0 { goret = true } return goret } // UriJoinStrings wraps gst_uri_join_strings // // The function takes the following parameters: // // - baseUri string: The percent-encoded base URI. // - refUri string: The percent-encoded reference URI to join to the @base_uri. // // The function returns the following values: // // - goret string (nullable) // // This is a convenience function to join two URI strings and return the result. // The returned string should be g_free()'d after use. func UriJoinStrings(baseUri string, refUri string) string { var carg1 *C.gchar // in, none, string var carg2 *C.gchar // in, none, string var cret *C.gchar // return, full, string, nullable-string carg1 = (*C.gchar)(unsafe.Pointer(C.CString(baseUri))) defer C.free(unsafe.Pointer(carg1)) carg2 = (*C.gchar)(unsafe.Pointer(C.CString(refUri))) defer C.free(unsafe.Pointer(carg2)) cret = C.gst_uri_join_strings(carg1, carg2) runtime.KeepAlive(baseUri) runtime.KeepAlive(refUri) var goret string if cret != nil { goret = C.GoString((*C.char)(unsafe.Pointer(cret))) defer C.free(unsafe.Pointer(cret)) } return goret } // UriProtocolIsSupported wraps gst_uri_protocol_is_supported // // The function takes the following parameters: // // - typ URIType: Whether to check for a source or a sink // - protocol string: Protocol that should be checked for (e.g. "http" or "smb") // // The function returns the following values: // // - goret bool // // Checks if an element exists that supports the given URI protocol. Note // that a positive return value does not imply that a subsequent call to // gst_element_make_from_uri() is guaranteed to work. func UriProtocolIsSupported(typ URIType, protocol string) bool { var carg1 C.GstURIType // in, none, casted var carg2 *C.gchar // in, none, string var cret C.gboolean // return carg1 = C.GstURIType(typ) carg2 = (*C.gchar)(unsafe.Pointer(C.CString(protocol))) defer C.free(unsafe.Pointer(carg2)) cret = C.gst_uri_protocol_is_supported(carg1, carg2) runtime.KeepAlive(typ) runtime.KeepAlive(protocol) var goret bool if cret != 0 { goret = true } return goret } // UriProtocolIsValid wraps gst_uri_protocol_is_valid // // The function takes the following parameters: // // - protocol string: A string // // The function returns the following values: // // - goret bool // // Tests if the given string is a valid protocol identifier. Protocols // must consist of alphanumeric characters, '+', '-' and '.' and must // start with a alphabetic character. See RFC 3986 Section 3.1. func UriProtocolIsValid(protocol string) bool { var carg1 *C.gchar // in, none, string var cret C.gboolean // return carg1 = (*C.gchar)(unsafe.Pointer(C.CString(protocol))) defer C.free(unsafe.Pointer(carg1)) cret = C.gst_uri_protocol_is_valid(carg1) runtime.KeepAlive(protocol) var goret bool if cret != 0 { goret = true } return goret } // AppendPath wraps gst_uri_append_path // // The function takes the following parameters: // // - relativePath string (nullable): Relative path to append to the end of the current path. // // The function returns the following values: // // - goret bool // // Append a path onto the end of the path in the URI. The path is not // normalized, call #gst_uri_normalize() to normalize the path. func (uri *Uri) AppendPath(relativePath string) bool { var carg0 *C.GstUri // in, none, converted var carg1 *C.gchar // in, none, string, nullable-string var cret C.gboolean // return carg0 = (*C.GstUri)(UnsafeUriToGlibNone(uri)) if relativePath != "" { carg1 = (*C.gchar)(unsafe.Pointer(C.CString(relativePath))) defer C.free(unsafe.Pointer(carg1)) } cret = C.gst_uri_append_path(carg0, carg1) runtime.KeepAlive(uri) runtime.KeepAlive(relativePath) var goret bool if cret != 0 { goret = true } return goret } // AppendPathSegment wraps gst_uri_append_path_segment // // The function takes the following parameters: // // - pathSegment string (nullable): The path segment string to append to the URI path. // // The function returns the following values: // // - goret bool // // Append a single path segment onto the end of the URI path. func (uri *Uri) AppendPathSegment(pathSegment string) bool { var carg0 *C.GstUri // in, none, converted var carg1 *C.gchar // in, none, string, nullable-string var cret C.gboolean // return carg0 = (*C.GstUri)(UnsafeUriToGlibNone(uri)) if pathSegment != "" { carg1 = (*C.gchar)(unsafe.Pointer(C.CString(pathSegment))) defer C.free(unsafe.Pointer(carg1)) } cret = C.gst_uri_append_path_segment(carg0, carg1) runtime.KeepAlive(uri) runtime.KeepAlive(pathSegment) var goret bool if cret != 0 { goret = true } return goret } // Equal wraps gst_uri_equal // // The function takes the following parameters: // // - second *Uri: Second #GstUri to compare. // // The function returns the following values: // // - goret bool // // Compares two #GstUri objects to see if they represent the same normalized // URI. func (first *Uri) Equal(second *Uri) bool { var carg0 *C.GstUri // in, none, converted var carg1 *C.GstUri // in, none, converted var cret C.gboolean // return carg0 = (*C.GstUri)(UnsafeUriToGlibNone(first)) carg1 = (*C.GstUri)(UnsafeUriToGlibNone(second)) cret = C.gst_uri_equal(carg0, carg1) runtime.KeepAlive(first) runtime.KeepAlive(second) var goret bool if cret != 0 { goret = true } return goret } // FromStringWithBase wraps gst_uri_from_string_with_base // // The function takes the following parameters: // // - uri string: The URI string to parse. // // The function returns the following values: // // - goret *Uri (nullable) // // Like gst_uri_from_string() but also joins with a base URI. func (base *Uri) FromStringWithBase(uri string) *Uri { var carg0 *C.GstUri // in, none, converted var carg1 *C.gchar // in, none, string var cret *C.GstUri // return, full, converted, nullable carg0 = (*C.GstUri)(UnsafeUriToGlibNone(base)) carg1 = (*C.gchar)(unsafe.Pointer(C.CString(uri))) defer C.free(unsafe.Pointer(carg1)) cret = C.gst_uri_from_string_with_base(carg0, carg1) runtime.KeepAlive(base) runtime.KeepAlive(uri) var goret *Uri if cret != nil { goret = UnsafeUriFromGlibFull(unsafe.Pointer(cret)) } return goret } // GetFragment wraps gst_uri_get_fragment // // The function returns the following values: // // - goret string (nullable) // // Get the fragment name from the URI or %NULL if it doesn't exist. // If @uri is %NULL then returns %NULL. func (uri *Uri) GetFragment() string { var carg0 *C.GstUri // in, none, converted var cret *C.gchar // return, none, string, nullable-string carg0 = (*C.GstUri)(UnsafeUriToGlibNone(uri)) cret = C.gst_uri_get_fragment(carg0) runtime.KeepAlive(uri) var goret string if cret != nil { goret = C.GoString((*C.char)(unsafe.Pointer(cret))) } return goret } // GetHost wraps gst_uri_get_host // // The function returns the following values: // // - goret string (nullable) // // Get the host name from the URI or %NULL if it doesn't exist. // If @uri is %NULL then returns %NULL. func (uri *Uri) GetHost() string { var carg0 *C.GstUri // in, none, converted var cret *C.gchar // return, none, string, nullable-string carg0 = (*C.GstUri)(UnsafeUriToGlibNone(uri)) cret = C.gst_uri_get_host(carg0) runtime.KeepAlive(uri) var goret string if cret != nil { goret = C.GoString((*C.char)(unsafe.Pointer(cret))) } return goret } // GetPath wraps gst_uri_get_path // // The function returns the following values: // // - goret string (nullable) // // Extract the path string from the URI object. func (uri *Uri) GetPath() string { var carg0 *C.GstUri // in, none, converted var cret *C.gchar // return, full, string, nullable-string carg0 = (*C.GstUri)(UnsafeUriToGlibNone(uri)) cret = C.gst_uri_get_path(carg0) runtime.KeepAlive(uri) var goret string if cret != nil { goret = C.GoString((*C.char)(unsafe.Pointer(cret))) defer C.free(unsafe.Pointer(cret)) } return goret } // GetPathSegments wraps gst_uri_get_path_segments // // The function returns the following values: // // - goret []string // // Get a list of path segments from the URI. func (uri *Uri) GetPathSegments() []string { var carg0 *C.GstUri // in, none, converted var cret *C.GList // container, transfer: full carg0 = (*C.GstUri)(UnsafeUriToGlibNone(uri)) cret = C.gst_uri_get_path_segments(carg0) runtime.KeepAlive(uri) var goret []string goret = glib.UnsafeListFromGlibFull( unsafe.Pointer(cret), func(v unsafe.Pointer) string { var dst string // string dst = C.GoString((*C.char)(v)) defer C.free(v) return dst }, ) return goret } // GetPathString wraps gst_uri_get_path_string // // The function returns the following values: // // - goret string (nullable) // // Extract the path string from the URI object as a percent encoded URI path. func (uri *Uri) GetPathString() string { var carg0 *C.GstUri // in, none, converted var cret *C.gchar // return, full, string, nullable-string carg0 = (*C.GstUri)(UnsafeUriToGlibNone(uri)) cret = C.gst_uri_get_path_string(carg0) runtime.KeepAlive(uri) var goret string if cret != nil { goret = C.GoString((*C.char)(unsafe.Pointer(cret))) defer C.free(unsafe.Pointer(cret)) } return goret } // GetPort wraps gst_uri_get_port // // The function returns the following values: // // - goret uint // // Get the port number from the URI or %GST_URI_NO_PORT if it doesn't exist. // If @uri is %NULL then returns %GST_URI_NO_PORT. func (uri *Uri) GetPort() uint { var carg0 *C.GstUri // in, none, converted var cret C.guint // return, none, casted carg0 = (*C.GstUri)(UnsafeUriToGlibNone(uri)) cret = C.gst_uri_get_port(carg0) runtime.KeepAlive(uri) var goret uint goret = uint(cret) return goret } // GetQueryKeys wraps gst_uri_get_query_keys // // The function returns the following values: // // - goret []string // // Get a list of the query keys from the URI. func (uri *Uri) GetQueryKeys() []string { var carg0 *C.GstUri // in, none, converted var cret *C.GList // container, transfer: container carg0 = (*C.GstUri)(UnsafeUriToGlibNone(uri)) cret = C.gst_uri_get_query_keys(carg0) runtime.KeepAlive(uri) var goret []string goret = glib.UnsafeListFromGlibFull( unsafe.Pointer(cret), func(v unsafe.Pointer) string { var dst string // string dst = C.GoString((*C.char)(v)) return dst }, ) return goret } // GetQueryString wraps gst_uri_get_query_string // // The function returns the following values: // // - goret string (nullable) // // Get a percent encoded URI query string from the @uri. func (uri *Uri) GetQueryString() string { var carg0 *C.GstUri // in, none, converted var cret *C.gchar // return, full, string, nullable-string carg0 = (*C.GstUri)(UnsafeUriToGlibNone(uri)) cret = C.gst_uri_get_query_string(carg0) runtime.KeepAlive(uri) var goret string if cret != nil { goret = C.GoString((*C.char)(unsafe.Pointer(cret))) defer C.free(unsafe.Pointer(cret)) } return goret } // GetQueryValue wraps gst_uri_get_query_value // // The function takes the following parameters: // // - queryKey string: The key to lookup. // // The function returns the following values: // // - goret string (nullable) // // Get the value associated with the @query_key key. Will return %NULL if the // key has no value or if the key does not exist in the URI query table. Because // %NULL is returned for both missing keys and keys with no value, you should // use gst_uri_query_has_key() to determine if a key is present in the URI // query. func (uri *Uri) GetQueryValue(queryKey string) string { var carg0 *C.GstUri // in, none, converted var carg1 *C.gchar // in, none, string var cret *C.gchar // return, none, string, nullable-string carg0 = (*C.GstUri)(UnsafeUriToGlibNone(uri)) carg1 = (*C.gchar)(unsafe.Pointer(C.CString(queryKey))) defer C.free(unsafe.Pointer(carg1)) cret = C.gst_uri_get_query_value(carg0, carg1) runtime.KeepAlive(uri) runtime.KeepAlive(queryKey) var goret string if cret != nil { goret = C.GoString((*C.char)(unsafe.Pointer(cret))) } return goret } // GetScheme wraps gst_uri_get_scheme // // The function returns the following values: // // - goret string (nullable) // // Get the scheme name from the URI or %NULL if it doesn't exist. // If @uri is %NULL then returns %NULL. func (uri *Uri) GetScheme() string { var carg0 *C.GstUri // in, none, converted var cret *C.gchar // return, none, string, nullable-string carg0 = (*C.GstUri)(UnsafeUriToGlibNone(uri)) cret = C.gst_uri_get_scheme(carg0) runtime.KeepAlive(uri) var goret string if cret != nil { goret = C.GoString((*C.char)(unsafe.Pointer(cret))) } return goret } // GetUserinfo wraps gst_uri_get_userinfo // // The function returns the following values: // // - goret string (nullable) // // Get the userinfo (usually in the form "username:password") from the URI // or %NULL if it doesn't exist. If @uri is %NULL then returns %NULL. func (uri *Uri) GetUserinfo() string { var carg0 *C.GstUri // in, none, converted var cret *C.gchar // return, none, string, nullable-string carg0 = (*C.GstUri)(UnsafeUriToGlibNone(uri)) cret = C.gst_uri_get_userinfo(carg0) runtime.KeepAlive(uri) var goret string if cret != nil { goret = C.GoString((*C.char)(unsafe.Pointer(cret))) } return goret } // IsNormalized wraps gst_uri_is_normalized // // The function returns the following values: // // - goret bool // // Tests the @uri to see if it is normalized. A %NULL @uri is considered to be // normalized. func (uri *Uri) IsNormalized() bool { var carg0 *C.GstUri // in, none, converted var cret C.gboolean // return carg0 = (*C.GstUri)(UnsafeUriToGlibNone(uri)) cret = C.gst_uri_is_normalized(carg0) runtime.KeepAlive(uri) var goret bool if cret != 0 { goret = true } return goret } // IsWritable wraps gst_uri_is_writable // // The function returns the following values: // // - goret bool // // Check if it is safe to write to this #GstUri. // // Check if the refcount of @uri is exactly 1, meaning that no other // reference exists to the #GstUri and that the #GstUri is therefore writable. // // Modification of a #GstUri should only be done after verifying that it is // writable. func (uri *Uri) IsWritable() bool { var carg0 *C.GstUri // in, none, converted var cret C.gboolean // return carg0 = (*C.GstUri)(UnsafeUriToGlibNone(uri)) cret = C.gst_uri_is_writable(carg0) runtime.KeepAlive(uri) var goret bool if cret != 0 { goret = true } return goret } // Join wraps gst_uri_join // // The function takes the following parameters: // // - refUri *Uri (nullable): The reference URI to join onto the // base URI. // // The function returns the following values: // // - goret *Uri (nullable) // // Join a reference URI onto a base URI using the method from RFC 3986. // If either URI is %NULL then the other URI will be returned with the ref count // increased. func (baseUri *Uri) Join(refUri *Uri) *Uri { var carg0 *C.GstUri // in, none, converted var carg1 *C.GstUri // in, none, converted, nullable var cret *C.GstUri // return, full, converted, nullable carg0 = (*C.GstUri)(UnsafeUriToGlibNone(baseUri)) if refUri != nil { carg1 = (*C.GstUri)(UnsafeUriToGlibNone(refUri)) } cret = C.gst_uri_join(carg0, carg1) runtime.KeepAlive(baseUri) runtime.KeepAlive(refUri) var goret *Uri if cret != nil { goret = UnsafeUriFromGlibFull(unsafe.Pointer(cret)) } return goret } // MakeWritable wraps gst_uri_make_writable // // The function returns the following values: // // - goret *Uri // // Make the #GstUri writable. // // Checks if @uri is writable, and if so the original object is returned. If // not, then a writable copy is made and returned. This gives away the // reference to @uri and returns a reference to the new #GstUri. // If @uri is %NULL then %NULL is returned. func (uri *Uri) MakeWritable() *Uri { var carg0 *C.GstUri // in, none, converted var cret *C.GstUri // return, full, converted carg0 = (*C.GstUri)(UnsafeUriToGlibNone(uri)) cret = C.gst_uri_make_writable(carg0) runtime.KeepAlive(uri) var goret *Uri goret = UnsafeUriFromGlibFull(unsafe.Pointer(cret)) return goret } // NewWithBase wraps gst_uri_new_with_base // // The function takes the following parameters: // // - scheme string (nullable): The scheme for the new URI. // - userinfo string (nullable): The user-info for the new URI. // - host string (nullable): The host name for the new URI. // - port uint: The port number for the new URI or %GST_URI_NO_PORT. // - path string (nullable): The path for the new URI with '/' separating path // elements. // - query string (nullable): The query string for the new URI with '&' separating // query elements. Elements containing '&' characters // should encode them as "&percnt;26". // - fragment string (nullable): The fragment name for the new URI. // // The function returns the following values: // // - goret *Uri // // Like gst_uri_new(), but joins the new URI onto a base URI. func (base *Uri) NewWithBase(scheme string, userinfo string, host string, port uint, path string, query string, fragment string) *Uri { var carg0 *C.GstUri // in, none, converted var carg1 *C.gchar // in, none, string, nullable-string var carg2 *C.gchar // in, none, string, nullable-string var carg3 *C.gchar // in, none, string, nullable-string var carg4 C.guint // in, none, casted var carg5 *C.gchar // in, none, string, nullable-string var carg6 *C.gchar // in, none, string, nullable-string var carg7 *C.gchar // in, none, string, nullable-string var cret *C.GstUri // return, full, converted carg0 = (*C.GstUri)(UnsafeUriToGlibNone(base)) if scheme != "" { carg1 = (*C.gchar)(unsafe.Pointer(C.CString(scheme))) defer C.free(unsafe.Pointer(carg1)) } if userinfo != "" { carg2 = (*C.gchar)(unsafe.Pointer(C.CString(userinfo))) defer C.free(unsafe.Pointer(carg2)) } if host != "" { carg3 = (*C.gchar)(unsafe.Pointer(C.CString(host))) defer C.free(unsafe.Pointer(carg3)) } carg4 = C.guint(port) if path != "" { carg5 = (*C.gchar)(unsafe.Pointer(C.CString(path))) defer C.free(unsafe.Pointer(carg5)) } if query != "" { carg6 = (*C.gchar)(unsafe.Pointer(C.CString(query))) defer C.free(unsafe.Pointer(carg6)) } if fragment != "" { carg7 = (*C.gchar)(unsafe.Pointer(C.CString(fragment))) defer C.free(unsafe.Pointer(carg7)) } cret = C.gst_uri_new_with_base(carg0, carg1, carg2, carg3, carg4, carg5, carg6, carg7) runtime.KeepAlive(base) runtime.KeepAlive(scheme) runtime.KeepAlive(userinfo) runtime.KeepAlive(host) runtime.KeepAlive(port) runtime.KeepAlive(path) runtime.KeepAlive(query) runtime.KeepAlive(fragment) var goret *Uri goret = UnsafeUriFromGlibFull(unsafe.Pointer(cret)) return goret } // Normalize wraps gst_uri_normalize // // The function returns the following values: // // - goret bool // // Normalization will remove extra path segments ("." and "..") from the URI. It // will also convert the scheme and host name to lower case and any // percent-encoded values to uppercase. // // The #GstUri object must be writable. Check with gst_uri_is_writable() or use // gst_uri_make_writable() first. func (uri *Uri) Normalize() bool { var carg0 *C.GstUri // in, none, converted var cret C.gboolean // return carg0 = (*C.GstUri)(UnsafeUriToGlibNone(uri)) cret = C.gst_uri_normalize(carg0) runtime.KeepAlive(uri) var goret bool if cret != 0 { goret = true } return goret } // QueryHasKey wraps gst_uri_query_has_key // // The function takes the following parameters: // // - queryKey string: The key to lookup. // // The function returns the following values: // // - goret bool // // Check if there is a query table entry for the @query_key key. func (uri *Uri) QueryHasKey(queryKey string) bool { var carg0 *C.GstUri // in, none, converted var carg1 *C.gchar // in, none, string var cret C.gboolean // return carg0 = (*C.GstUri)(UnsafeUriToGlibNone(uri)) carg1 = (*C.gchar)(unsafe.Pointer(C.CString(queryKey))) defer C.free(unsafe.Pointer(carg1)) cret = C.gst_uri_query_has_key(carg0, carg1) runtime.KeepAlive(uri) runtime.KeepAlive(queryKey) var goret bool if cret != 0 { goret = true } return goret } // RemoveQueryKey wraps gst_uri_remove_query_key // // The function takes the following parameters: // // - queryKey string: The key to remove. // // The function returns the following values: // // - goret bool // // Remove an entry from the query table by key. func (uri *Uri) RemoveQueryKey(queryKey string) bool { var carg0 *C.GstUri // in, none, converted var carg1 *C.gchar // in, none, string var cret C.gboolean // return carg0 = (*C.GstUri)(UnsafeUriToGlibNone(uri)) carg1 = (*C.gchar)(unsafe.Pointer(C.CString(queryKey))) defer C.free(unsafe.Pointer(carg1)) cret = C.gst_uri_remove_query_key(carg0, carg1) runtime.KeepAlive(uri) runtime.KeepAlive(queryKey) var goret bool if cret != 0 { goret = true } return goret } // SetFragment wraps gst_uri_set_fragment // // The function takes the following parameters: // // - fragment string (nullable): The fragment string to set. // // The function returns the following values: // // - goret bool // // Sets the fragment string in the URI. Use a value of %NULL in @fragment to // unset the fragment string. func (uri *Uri) SetFragment(fragment string) bool { var carg0 *C.GstUri // in, none, converted var carg1 *C.gchar // in, none, string, nullable-string var cret C.gboolean // return carg0 = (*C.GstUri)(UnsafeUriToGlibNone(uri)) if fragment != "" { carg1 = (*C.gchar)(unsafe.Pointer(C.CString(fragment))) defer C.free(unsafe.Pointer(carg1)) } cret = C.gst_uri_set_fragment(carg0, carg1) runtime.KeepAlive(uri) runtime.KeepAlive(fragment) var goret bool if cret != 0 { goret = true } return goret } // SetHost wraps gst_uri_set_host // // The function takes the following parameters: // // - host string: The new host string to set or %NULL to unset. // // The function returns the following values: // // - goret bool // // Set or unset the host for the URI. func (uri *Uri) SetHost(host string) bool { var carg0 *C.GstUri // in, none, converted var carg1 *C.gchar // in, none, string var cret C.gboolean // return carg0 = (*C.GstUri)(UnsafeUriToGlibNone(uri)) carg1 = (*C.gchar)(unsafe.Pointer(C.CString(host))) defer C.free(unsafe.Pointer(carg1)) cret = C.gst_uri_set_host(carg0, carg1) runtime.KeepAlive(uri) runtime.KeepAlive(host) var goret bool if cret != 0 { goret = true } return goret } // SetPath wraps gst_uri_set_path // // The function takes the following parameters: // // - path string (nullable): The new path to set with path segments separated by '/', or use %NULL // to unset the path. // // The function returns the following values: // // - goret bool // // Sets or unsets the path in the URI. func (uri *Uri) SetPath(path string) bool { var carg0 *C.GstUri // in, none, converted var carg1 *C.gchar // in, none, string, nullable-string var cret C.gboolean // return carg0 = (*C.GstUri)(UnsafeUriToGlibNone(uri)) if path != "" { carg1 = (*C.gchar)(unsafe.Pointer(C.CString(path))) defer C.free(unsafe.Pointer(carg1)) } cret = C.gst_uri_set_path(carg0, carg1) runtime.KeepAlive(uri) runtime.KeepAlive(path) var goret bool if cret != 0 { goret = true } return goret } // SetPathString wraps gst_uri_set_path_string // // The function takes the following parameters: // // - path string: The new percent encoded path to set with path segments separated by // '/', or use %NULL to unset the path. // // The function returns the following values: // // - goret bool // // Sets or unsets the path in the URI. func (uri *Uri) SetPathString(path string) bool { var carg0 *C.GstUri // in, none, converted var carg1 *C.gchar // in, none, string var cret C.gboolean // return carg0 = (*C.GstUri)(UnsafeUriToGlibNone(uri)) carg1 = (*C.gchar)(unsafe.Pointer(C.CString(path))) defer C.free(unsafe.Pointer(carg1)) cret = C.gst_uri_set_path_string(carg0, carg1) runtime.KeepAlive(uri) runtime.KeepAlive(path) var goret bool if cret != 0 { goret = true } return goret } // SetPort wraps gst_uri_set_port // // The function takes the following parameters: // // - port uint: The new port number to set or %GST_URI_NO_PORT to unset. // // The function returns the following values: // // - goret bool // // Set or unset the port number for the URI. func (uri *Uri) SetPort(port uint) bool { var carg0 *C.GstUri // in, none, converted var carg1 C.guint // in, none, casted var cret C.gboolean // return carg0 = (*C.GstUri)(UnsafeUriToGlibNone(uri)) carg1 = C.guint(port) cret = C.gst_uri_set_port(carg0, carg1) runtime.KeepAlive(uri) runtime.KeepAlive(port) var goret bool if cret != 0 { goret = true } return goret } // SetQueryString wraps gst_uri_set_query_string // // The function takes the following parameters: // // - query string (nullable): The new percent encoded query string to use to populate the query // table, or use %NULL to unset the query table. // // The function returns the following values: // // - goret bool // // Sets or unsets the query table in the URI. func (uri *Uri) SetQueryString(query string) bool { var carg0 *C.GstUri // in, none, converted var carg1 *C.gchar // in, none, string, nullable-string var cret C.gboolean // return carg0 = (*C.GstUri)(UnsafeUriToGlibNone(uri)) if query != "" { carg1 = (*C.gchar)(unsafe.Pointer(C.CString(query))) defer C.free(unsafe.Pointer(carg1)) } cret = C.gst_uri_set_query_string(carg0, carg1) runtime.KeepAlive(uri) runtime.KeepAlive(query) var goret bool if cret != 0 { goret = true } return goret } // SetQueryValue wraps gst_uri_set_query_value // // The function takes the following parameters: // // - queryKey string: The key for the query entry. // - queryValue string (nullable): The value for the key. // // The function returns the following values: // // - goret bool // // This inserts or replaces a key in the query table. A @query_value of %NULL // indicates that the key has no associated value, but will still be present in // the query string. func (uri *Uri) SetQueryValue(queryKey string, queryValue string) bool { var carg0 *C.GstUri // in, none, converted var carg1 *C.gchar // in, none, string var carg2 *C.gchar // in, none, string, nullable-string var cret C.gboolean // return carg0 = (*C.GstUri)(UnsafeUriToGlibNone(uri)) carg1 = (*C.gchar)(unsafe.Pointer(C.CString(queryKey))) defer C.free(unsafe.Pointer(carg1)) if queryValue != "" { carg2 = (*C.gchar)(unsafe.Pointer(C.CString(queryValue))) defer C.free(unsafe.Pointer(carg2)) } cret = C.gst_uri_set_query_value(carg0, carg1, carg2) runtime.KeepAlive(uri) runtime.KeepAlive(queryKey) runtime.KeepAlive(queryValue) var goret bool if cret != 0 { goret = true } return goret } // SetScheme wraps gst_uri_set_scheme // // The function takes the following parameters: // // - scheme string: The new scheme to set or %NULL to unset the scheme. // // The function returns the following values: // // - goret bool // // Set or unset the scheme for the URI. func (uri *Uri) SetScheme(scheme string) bool { var carg0 *C.GstUri // in, none, converted var carg1 *C.gchar // in, none, string var cret C.gboolean // return carg0 = (*C.GstUri)(UnsafeUriToGlibNone(uri)) carg1 = (*C.gchar)(unsafe.Pointer(C.CString(scheme))) defer C.free(unsafe.Pointer(carg1)) cret = C.gst_uri_set_scheme(carg0, carg1) runtime.KeepAlive(uri) runtime.KeepAlive(scheme) var goret bool if cret != 0 { goret = true } return goret } // SetUserinfo wraps gst_uri_set_userinfo // // The function takes the following parameters: // // - userinfo string: The new user-information string to set or %NULL to unset. // // The function returns the following values: // // - goret bool // // Set or unset the user information for the URI. func (uri *Uri) SetUserinfo(userinfo string) bool { var carg0 *C.GstUri // in, none, converted var carg1 *C.gchar // in, none, string var cret C.gboolean // return carg0 = (*C.GstUri)(UnsafeUriToGlibNone(uri)) carg1 = (*C.gchar)(unsafe.Pointer(C.CString(userinfo))) defer C.free(unsafe.Pointer(carg1)) cret = C.gst_uri_set_userinfo(carg0, carg1) runtime.KeepAlive(uri) runtime.KeepAlive(userinfo) var goret bool if cret != 0 { goret = true } return goret } // ToString wraps gst_uri_to_string // // The function returns the following values: // // - goret string // // Convert the URI to a string. // // Returns the URI as held in this object as a #gchar* nul-terminated string. // The caller should g_free() the string once they are finished with it. // The string is put together as described in RFC 3986. func (uri *Uri) ToString() string { var carg0 *C.GstUri // in, none, converted var cret *C.gchar // return, full, string carg0 = (*C.GstUri)(UnsafeUriToGlibNone(uri)) cret = C.gst_uri_to_string(carg0) runtime.KeepAlive(uri) var goret string goret = C.GoString((*C.char)(unsafe.Pointer(cret))) defer C.free(unsafe.Pointer(cret)) return goret } // ValueTable wraps GstValueTable // // VTable for the #GValue @type. type ValueTable struct { *valueTable } // valueTable is the struct that's finalized type valueTable struct { native *C.GstValueTable } // UnsafeValueTableFromGlibBorrow is used to convert raw C.GstValueTable pointers to go. This is used by the bindings internally. func UnsafeValueTableFromGlibBorrow(p unsafe.Pointer) *ValueTable { return &ValueTable{&valueTable{(*C.GstValueTable)(p)}} } // 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) runtime.SetFinalizer( wrapped.valueTable, func (intern *valueTable) { C.free(unsafe.Pointer(intern.native)) }, ) return wrapped } // 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( wrapped.valueTable, func (intern *valueTable) { C.free(unsafe.Pointer(intern.native)) }, ) return wrapped } // UnsafeValueTableFree unrefs/frees the underlying resource. This is used by the bindings internally. // // After this is called, no other method on [ValueTable] is expected to work anymore. func UnsafeValueTableFree(v *ValueTable) { C.free(unsafe.Pointer(v.native)) } // UnsafeValueTableToGlibNone returns the underlying C pointer. This is used by the bindings internally. func UnsafeValueTableToGlibNone(v *ValueTable) unsafe.Pointer { return unsafe.Pointer(v.native) } // UnsafeValueTableToGlibFull returns the underlying C pointer and gives up ownership. // This is used by the bindings internally. func UnsafeValueTableToGlibFull(v *ValueTable) unsafe.Pointer { runtime.SetFinalizer(v.valueTable, nil) _p := unsafe.Pointer(v.native) v.native = nil // ValueTable is invalid from here on return _p }