From 74ba1ec9b019f7304b0ef14361e822098ef25dea Mon Sep 17 00:00:00 2001 From: RSWilli Date: Tue, 16 Sep 2025 22:36:07 +0200 Subject: [PATCH] regenerate with new virtual method code --- pkg/gst/gst.gen.go | 1857 +++++++++++++++++++ pkg/gst/gst_export.gen.go | 631 ++++++- pkg/gstallocators/gstallocators.gen.go | 105 ++ pkg/gstapp/gstapp.gen.go | 286 +++ pkg/gstapp/gstapp_export.gen.go | 131 +- pkg/gstaudio/gstaudio.gen.go | 1601 +++++++++++++++++ pkg/gstaudio/gstaudio_export.gen.go | 631 ++++++- pkg/gstbase/gstbase.gen.go | 2152 +++++++++++++++++++++++ pkg/gstbase/gstbase_export.gen.go | 883 ++++++++-- pkg/gstcheck/gstcheck.gen.go | 27 + pkg/gstcontroller/gstcontroller.gen.go | 183 ++ pkg/gstgl/gstgl.gen.go | 1266 +++++++++++++ pkg/gstgl/gstgl_export.gen.go | 352 +++- pkg/gstnet/gstnet.gen.go | 105 ++ pkg/gstpbutils/gstpbutils.gen.go | 181 ++ pkg/gstpbutils/gstpbutils_export.gen.go | 73 +- pkg/gstplay/gstplay.gen.go | 1 + pkg/gstplayer/gstplayer.gen.go | 1 + pkg/gstrtp/gstrtp.gen.go | 491 ++++++ pkg/gstrtp/gstrtp_export.gen.go | 176 +- pkg/gstrtsp/gstrtsp.gen.go | 173 ++ pkg/gstrtsp/gstrtsp_export.gen.go | 82 +- pkg/gsttag/gsttag.gen.go | 137 ++ pkg/gsttag/gsttag_export.gen.go | 41 +- pkg/gstvideo/gstvideo.gen.go | 1620 +++++++++++++++++ pkg/gstvideo/gstvideo_export.gen.go | 658 ++++++- pkg/gstwebrtc/gstwebrtc.gen.go | 485 +++++ pkg/gstwebrtc/gstwebrtc_export.gen.go | 199 ++- 28 files changed, 14102 insertions(+), 426 deletions(-) diff --git a/pkg/gst/gst.gen.go b/pkg/gst/gst.gen.go index 915431d..2b702ad 100644 --- a/pkg/gst/gst.gen.go +++ b/pkg/gst/gst.gen.go @@ -8,6 +8,7 @@ import ( "strings" "unsafe" + "github.com/diamondburned/gotk4/pkg/core/classdata" "github.com/diamondburned/gotk4/pkg/core/userdata" "github.com/diamondburned/gotk4/pkg/glib/v2" "github.com/diamondburned/gotk4/pkg/gobject/v2" @@ -12192,22 +12193,108 @@ func UnsafeApplyChildProxyOverrides[Instance ChildProxy](gclass unsafe.Pointer, if overrides.ChildAdded != nil { pclass.child_added = (*[0]byte)(C._gotk4_gst1_ChildProxy_child_added) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gst1_ChildProxy_child_added", + func(carg0 *C.GstChildProxy, carg1 *C.GObject, carg2 *C.gchar) { + var parent Instance // go GstChildProxy subclass + var child gobject.Object // in, none, converted + var name string // in, none, string + + parent = UnsafeChildProxyFromGlibNone(unsafe.Pointer(carg0)).(Instance) + child = gobject.UnsafeObjectFromGlibNone(unsafe.Pointer(carg1)) + name = C.GoString((*C.char)(unsafe.Pointer(carg2))) + + overrides.ChildAdded(parent, child, name) + }, + ) } if overrides.ChildRemoved != nil { pclass.child_removed = (*[0]byte)(C._gotk4_gst1_ChildProxy_child_removed) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gst1_ChildProxy_child_removed", + func(carg0 *C.GstChildProxy, carg1 *C.GObject, carg2 *C.gchar) { + var parent Instance // go GstChildProxy subclass + var child gobject.Object // in, none, converted + var name string // in, none, string + + parent = UnsafeChildProxyFromGlibNone(unsafe.Pointer(carg0)).(Instance) + child = gobject.UnsafeObjectFromGlibNone(unsafe.Pointer(carg1)) + name = C.GoString((*C.char)(unsafe.Pointer(carg2))) + + overrides.ChildRemoved(parent, child, name) + }, + ) } if overrides.GetChildByIndex != nil { pclass.get_child_by_index = (*[0]byte)(C._gotk4_gst1_ChildProxy_get_child_by_index) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gst1_ChildProxy_get_child_by_index", + func(carg0 *C.GstChildProxy, carg1 C.guint) (cret *C.GObject) { + var parent Instance // go GstChildProxy subclass + var index uint // in, none, casted + var goret gobject.Object // return, full, converted, nullable + + parent = UnsafeChildProxyFromGlibNone(unsafe.Pointer(carg0)).(Instance) + index = uint(carg1) + + goret = overrides.GetChildByIndex(parent, index) + + if goret != nil { + cret = (*C.GObject)(gobject.UnsafeObjectToGlibFull(goret)) + } + + return cret + }, + ) } if overrides.GetChildByName != nil { pclass.get_child_by_name = (*[0]byte)(C._gotk4_gst1_ChildProxy_get_child_by_name) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gst1_ChildProxy_get_child_by_name", + func(carg0 *C.GstChildProxy, carg1 *C.gchar) (cret *C.GObject) { + var parent Instance // go GstChildProxy subclass + var name string // in, none, string + var goret gobject.Object // return, full, converted, nullable + + parent = UnsafeChildProxyFromGlibNone(unsafe.Pointer(carg0)).(Instance) + name = C.GoString((*C.char)(unsafe.Pointer(carg1))) + + goret = overrides.GetChildByName(parent, name) + + if goret != nil { + cret = (*C.GObject)(gobject.UnsafeObjectToGlibFull(goret)) + } + + return cret + }, + ) } if overrides.GetChildrenCount != nil { pclass.get_children_count = (*[0]byte)(C._gotk4_gst1_ChildProxy_get_children_count) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gst1_ChildProxy_get_children_count", + func(carg0 *C.GstChildProxy) (cret C.guint) { + var parent Instance // go GstChildProxy subclass + var goret uint // return, none, casted + + parent = UnsafeChildProxyFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + goret = overrides.GetChildrenCount(parent) + + cret = C.guint(goret) + + return cret + }, + ) } } @@ -12833,34 +12920,202 @@ func UnsafeApplyPresetOverrides[Instance Preset](gclass unsafe.Pointer, override if overrides.DeletePreset != nil { pclass.delete_preset = (*[0]byte)(C._gotk4_gst1_Preset_delete_preset) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gst1_Preset_delete_preset", + func(carg0 *C.GstPreset, carg1 *C.gchar) (cret C.gboolean) { + var preset Instance // go GstPreset subclass + var name string // in, none, string + var goret bool // return + + preset = UnsafePresetFromGlibNone(unsafe.Pointer(carg0)).(Instance) + name = C.GoString((*C.char)(unsafe.Pointer(carg1))) + + goret = overrides.DeletePreset(preset, name) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.GetMeta != nil { pclass.get_meta = (*[0]byte)(C._gotk4_gst1_Preset_get_meta) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gst1_Preset_get_meta", + func(carg0 *C.GstPreset, carg1 *C.gchar, carg2 *C.gchar, carg3 **C.gchar) (cret C.gboolean) { + var preset Instance // go GstPreset subclass + var name string // in, none, string + var tag string // in, none, string + var value string // out, full, string + var goret bool // return + + preset = UnsafePresetFromGlibNone(unsafe.Pointer(carg0)).(Instance) + name = C.GoString((*C.char)(unsafe.Pointer(carg1))) + tag = C.GoString((*C.char)(unsafe.Pointer(carg2))) + + value, goret = overrides.GetMeta(preset, name, tag) + + carg3 = (*C.gchar)(unsafe.Pointer(C.CString(value))) + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.GetPresetNames != nil { pclass.get_preset_names = (*[0]byte)(C._gotk4_gst1_Preset_get_preset_names) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gst1_Preset_get_preset_names", + func(carg0 *C.GstPreset) (cret **C.gchar) { + var preset Instance // go GstPreset subclass + var goret []string // return, transfer: full, C Pointers: 2, Name: array[utf8], scope: , array (inner: *typesystem.StringPrimitive, zero-terminated) + + preset = UnsafePresetFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + goret = overrides.GetPresetNames(preset) + + _ = goret + _ = cret + panic("unimplemented conversion of []string (gchar**)") + + return cret + }, + ) } if overrides.GetPropertyNames != nil { pclass.get_property_names = (*[0]byte)(C._gotk4_gst1_Preset_get_property_names) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gst1_Preset_get_property_names", + func(carg0 *C.GstPreset) (cret **C.gchar) { + var preset Instance // go GstPreset subclass + var goret []string // return, transfer: full, C Pointers: 2, Name: array[utf8], scope: , array (inner: *typesystem.StringPrimitive, zero-terminated) + + preset = UnsafePresetFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + goret = overrides.GetPropertyNames(preset) + + _ = goret + _ = cret + panic("unimplemented conversion of []string (gchar**)") + + return cret + }, + ) } if overrides.LoadPreset != nil { pclass.load_preset = (*[0]byte)(C._gotk4_gst1_Preset_load_preset) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gst1_Preset_load_preset", + func(carg0 *C.GstPreset, carg1 *C.gchar) (cret C.gboolean) { + var preset Instance // go GstPreset subclass + var name string // in, none, string + var goret bool // return + + preset = UnsafePresetFromGlibNone(unsafe.Pointer(carg0)).(Instance) + name = C.GoString((*C.char)(unsafe.Pointer(carg1))) + + goret = overrides.LoadPreset(preset, name) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.RenamePreset != nil { pclass.rename_preset = (*[0]byte)(C._gotk4_gst1_Preset_rename_preset) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gst1_Preset_rename_preset", + func(carg0 *C.GstPreset, carg1 *C.gchar, carg2 *C.gchar) (cret C.gboolean) { + var preset Instance // go GstPreset subclass + var oldName string // in, none, string + var newName string // in, none, string + var goret bool // return + + preset = UnsafePresetFromGlibNone(unsafe.Pointer(carg0)).(Instance) + oldName = C.GoString((*C.char)(unsafe.Pointer(carg1))) + newName = C.GoString((*C.char)(unsafe.Pointer(carg2))) + + goret = overrides.RenamePreset(preset, oldName, newName) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.SavePreset != nil { pclass.save_preset = (*[0]byte)(C._gotk4_gst1_Preset_save_preset) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gst1_Preset_save_preset", + func(carg0 *C.GstPreset, carg1 *C.gchar) (cret C.gboolean) { + var preset Instance // go GstPreset subclass + var name string // in, none, string + var goret bool // return + + preset = UnsafePresetFromGlibNone(unsafe.Pointer(carg0)).(Instance) + name = C.GoString((*C.char)(unsafe.Pointer(carg1))) + + goret = overrides.SavePreset(preset, name) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.SetMeta != nil { pclass.set_meta = (*[0]byte)(C._gotk4_gst1_Preset_set_meta) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gst1_Preset_set_meta", + func(carg0 *C.GstPreset, carg1 *C.gchar, carg2 *C.gchar, carg3 *C.gchar) (cret C.gboolean) { + var preset Instance // go GstPreset subclass + var name string // in, none, string + var tag string // in, none, string + var value string // in, none, string, nullable-string + var goret bool // return + + preset = UnsafePresetFromGlibNone(unsafe.Pointer(carg0)).(Instance) + name = C.GoString((*C.char)(unsafe.Pointer(carg1))) + tag = C.GoString((*C.char)(unsafe.Pointer(carg2))) + if carg3 != nil { + value = C.GoString((*C.char)(unsafe.Pointer(carg3))) + } + + goret = overrides.SetMeta(preset, name, tag, value) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } } @@ -13104,10 +13359,50 @@ func UnsafeApplyURIHandlerOverrides[Instance URIHandler](gclass unsafe.Pointer, if overrides.GetURI != nil { pclass.get_uri = (*[0]byte)(C._gotk4_gst1_URIHandler_get_uri) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gst1_URIHandler_get_uri", + func(carg0 *C.GstURIHandler) (cret *C.gchar) { + var handler Instance // go GstURIHandler subclass + var goret string // return, full, string, nullable-string + + handler = UnsafeURIHandlerFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + goret = overrides.GetURI(handler) + + if goret != "" { + cret = (*C.gchar)(unsafe.Pointer(C.CString(goret))) + } + + return cret + }, + ) } if overrides.SetURI != nil { pclass.set_uri = (*[0]byte)(C._gotk4_gst1_URIHandler_set_uri) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gst1_URIHandler_set_uri", + func(carg0 *C.GstURIHandler, carg1 *C.gchar, _cerr **C.GError) (cret C.gboolean) { + var handler Instance // go GstURIHandler subclass + var uri string // in, none, string + var goret bool // return + var _goerr error // out, full, converted + + handler = UnsafeURIHandlerFromGlibNone(unsafe.Pointer(carg0)).(Instance) + uri = C.GoString((*C.char)(unsafe.Pointer(carg1))) + + goret, _goerr = overrides.SetURI(handler, uri) + + if goret { + cret = C.TRUE + } + *_cerr = (*C.GError)(glib.UnsafeErrorToGlibFull(_goerr)) + + return cret + }, + ) } } @@ -14495,6 +14790,32 @@ func UnsafeApplyObjectOverrides[Instance Object](gclass unsafe.Pointer, override gobject.UnsafeApplyInitiallyUnownedOverrides(gclass, overrides.InitiallyUnownedOverrides) } +// RegisterObjectSubClass is used to register a go subclass of GstObject. For this to work safely please implement the +// virtual methods required by the implementation. +func RegisterObjectSubClass[InstanceT Object]( + name string, + classInit func(class *ObjectClass), + constructor func() InstanceT, + overrides ObjectOverrides[InstanceT], + signals map[string]gobject.SignalDefinition, + interfaceInits ...gobject.SubClassInterfaceInit[InstanceT], +) gobject.Type { + return gobject.UnsafeRegisterSubClass( + name, + classInit, + constructor, + overrides, + signals, + TypeObject, + UnsafeObjectClassFromGlibBorrow, + UnsafeApplyObjectOverrides, + func (obj *gobject.ObjectInstance) gobject.Object { + return unsafeWrapObject(obj) + }, + interfaceInits..., + ) +} + // 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 @@ -18092,13 +18413,65 @@ func UnsafeApplyPadOverrides[Instance Pad](gclass unsafe.Pointer, overrides PadO if overrides.Linked != nil { pclass.linked = (*[0]byte)(C._gotk4_gst1_Pad_linked) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gst1_Pad_linked", + func(carg0 *C.GstPad, carg1 *C.GstPad) { + var pad Instance // go GstPad subclass + var peer Pad // in, none, converted + + pad = UnsafePadFromGlibNone(unsafe.Pointer(carg0)).(Instance) + peer = UnsafePadFromGlibNone(unsafe.Pointer(carg1)) + + overrides.Linked(pad, peer) + }, + ) } if overrides.Unlinked != nil { pclass.unlinked = (*[0]byte)(C._gotk4_gst1_Pad_unlinked) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gst1_Pad_unlinked", + func(carg0 *C.GstPad, carg1 *C.GstPad) { + var pad Instance // go GstPad subclass + var peer Pad // in, none, converted + + pad = UnsafePadFromGlibNone(unsafe.Pointer(carg0)).(Instance) + peer = UnsafePadFromGlibNone(unsafe.Pointer(carg1)) + + overrides.Unlinked(pad, peer) + }, + ) } } +// RegisterPadSubClass is used to register a go subclass of GstPad. For this to work safely please implement the +// virtual methods required by the implementation. +func RegisterPadSubClass[InstanceT Pad]( + name string, + classInit func(class *PadClass), + constructor func() InstanceT, + overrides PadOverrides[InstanceT], + signals map[string]gobject.SignalDefinition, + interfaceInits ...gobject.SubClassInterfaceInit[InstanceT], +) gobject.Type { + return gobject.UnsafeRegisterSubClass( + name, + classInit, + constructor, + overrides, + signals, + TypePad, + UnsafePadClassFromGlibBorrow, + UnsafeApplyPadOverrides, + func (obj *gobject.ObjectInstance) gobject.Object { + return unsafeWrapPad(obj) + }, + interfaceInits..., + ) +} + // 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 @@ -18491,9 +18864,48 @@ func UnsafeApplyPadTemplateOverrides[Instance PadTemplate](gclass unsafe.Pointer if overrides.PadCreated != nil { pclass.pad_created = (*[0]byte)(C._gotk4_gst1_PadTemplate_pad_created) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gst1_PadTemplate_pad_created", + func(carg0 *C.GstPadTemplate, carg1 *C.GstPad) { + var templ Instance // go GstPadTemplate subclass + var pad Pad // in, none, converted + + templ = UnsafePadTemplateFromGlibNone(unsafe.Pointer(carg0)).(Instance) + pad = UnsafePadFromGlibNone(unsafe.Pointer(carg1)) + + overrides.PadCreated(templ, pad) + }, + ) } } +// RegisterPadTemplateSubClass is used to register a go subclass of GstPadTemplate. For this to work safely please implement the +// virtual methods required by the implementation. +func RegisterPadTemplateSubClass[InstanceT PadTemplate]( + name string, + classInit func(class *PadTemplateClass), + constructor func() InstanceT, + overrides PadTemplateOverrides[InstanceT], + signals map[string]gobject.SignalDefinition, + interfaceInits ...gobject.SubClassInterfaceInit[InstanceT], +) gobject.Type { + return gobject.UnsafeRegisterSubClass( + name, + classInit, + constructor, + overrides, + signals, + TypePadTemplate, + UnsafePadTemplateClassFromGlibBorrow, + UnsafeApplyPadTemplateOverrides, + func (obj *gobject.ObjectInstance) gobject.Object { + return unsafeWrapPadTemplate(obj) + }, + interfaceInits..., + ) +} + // 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 @@ -20095,6 +20507,32 @@ func UnsafeApplyProxyPadOverrides[Instance ProxyPad](gclass unsafe.Pointer, over UnsafeApplyPadOverrides(gclass, overrides.PadOverrides) } +// RegisterProxyPadSubClass is used to register a go subclass of GstProxyPad. For this to work safely please implement the +// virtual methods required by the implementation. +func RegisterProxyPadSubClass[InstanceT ProxyPad]( + name string, + classInit func(class *ProxyPadClass), + constructor func() InstanceT, + overrides ProxyPadOverrides[InstanceT], + signals map[string]gobject.SignalDefinition, + interfaceInits ...gobject.SubClassInterfaceInit[InstanceT], +) gobject.Type { + return gobject.UnsafeRegisterSubClass( + name, + classInit, + constructor, + overrides, + signals, + TypeProxyPad, + UnsafeProxyPadClassFromGlibBorrow, + UnsafeApplyProxyPadOverrides, + func (obj *gobject.ObjectInstance) gobject.Object { + return unsafeWrapProxyPad(obj) + }, + interfaceInits..., + ) +} + // 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 @@ -21080,6 +21518,32 @@ func UnsafeApplyRegistryOverrides[Instance Registry](gclass unsafe.Pointer, over UnsafeApplyObjectOverrides(gclass, overrides.ObjectOverrides) } +// RegisterRegistrySubClass is used to register a go subclass of GstRegistry. For this to work safely please implement the +// virtual methods required by the implementation. +func RegisterRegistrySubClass[InstanceT Registry]( + name string, + classInit func(class *RegistryClass), + constructor func() InstanceT, + overrides RegistryOverrides[InstanceT], + signals map[string]gobject.SignalDefinition, + interfaceInits ...gobject.SubClassInterfaceInit[InstanceT], +) gobject.Type { + return gobject.UnsafeRegisterSubClass( + name, + classInit, + constructor, + overrides, + signals, + TypeRegistry, + UnsafeRegistryClassFromGlibBorrow, + UnsafeApplyRegistryOverrides, + func (obj *gobject.ObjectInstance) gobject.Object { + return unsafeWrapRegistry(obj) + }, + interfaceInits..., + ) +} + // 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 @@ -21479,6 +21943,32 @@ func UnsafeApplyStreamOverrides[Instance Stream](gclass unsafe.Pointer, override UnsafeApplyObjectOverrides(gclass, overrides.ObjectOverrides) } +// RegisterStreamSubClass is used to register a go subclass of GstStream. For this to work safely please implement the +// virtual methods required by the implementation. +func RegisterStreamSubClass[InstanceT Stream]( + name string, + classInit func(class *StreamClass), + constructor func() InstanceT, + overrides StreamOverrides[InstanceT], + signals map[string]gobject.SignalDefinition, + interfaceInits ...gobject.SubClassInterfaceInit[InstanceT], +) gobject.Type { + return gobject.UnsafeRegisterSubClass( + name, + classInit, + constructor, + overrides, + signals, + TypeStream, + UnsafeStreamClassFromGlibBorrow, + UnsafeApplyStreamOverrides, + func (obj *gobject.ObjectInstance) gobject.Object { + return unsafeWrapStream(obj) + }, + interfaceInits..., + ) +} + // 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 @@ -21749,6 +22239,32 @@ func UnsafeApplyStreamCollectionOverrides[Instance StreamCollection](gclass unsa UnsafeApplyObjectOverrides(gclass, overrides.ObjectOverrides) } +// RegisterStreamCollectionSubClass is used to register a go subclass of GstStreamCollection. For this to work safely please implement the +// virtual methods required by the implementation. +func RegisterStreamCollectionSubClass[InstanceT StreamCollection]( + name string, + classInit func(class *StreamCollectionClass), + constructor func() InstanceT, + overrides StreamCollectionOverrides[InstanceT], + signals map[string]gobject.SignalDefinition, + interfaceInits ...gobject.SubClassInterfaceInit[InstanceT], +) gobject.Type { + return gobject.UnsafeRegisterSubClass( + name, + classInit, + constructor, + overrides, + signals, + TypeStreamCollection, + UnsafeStreamCollectionClassFromGlibBorrow, + UnsafeApplyStreamCollectionOverrides, + func (obj *gobject.ObjectInstance) gobject.Object { + return unsafeWrapStreamCollection(obj) + }, + interfaceInits..., + ) +} + // 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 @@ -22260,6 +22776,32 @@ func UnsafeApplyTaskOverrides[Instance Task](gclass unsafe.Pointer, overrides Ta UnsafeApplyObjectOverrides(gclass, overrides.ObjectOverrides) } +// RegisterTaskSubClass is used to register a go subclass of GstTask. For this to work safely please implement the +// virtual methods required by the implementation. +func RegisterTaskSubClass[InstanceT Task]( + name string, + classInit func(class *TaskClass), + constructor func() InstanceT, + overrides TaskOverrides[InstanceT], + signals map[string]gobject.SignalDefinition, + interfaceInits ...gobject.SubClassInterfaceInit[InstanceT], +) gobject.Type { + return gobject.UnsafeRegisterSubClass( + name, + classInit, + constructor, + overrides, + signals, + TypeTask, + UnsafeTaskClassFromGlibBorrow, + UnsafeApplyTaskOverrides, + func (obj *gobject.ObjectInstance) gobject.Object { + return unsafeWrapTask(obj) + }, + interfaceInits..., + ) +} + // 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 @@ -22421,13 +22963,64 @@ func UnsafeApplyTaskPoolOverrides[Instance TaskPool](gclass unsafe.Pointer, over if overrides.Cleanup != nil { pclass.cleanup = (*[0]byte)(C._gotk4_gst1_TaskPool_cleanup) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gst1_TaskPool_cleanup", + func(carg0 *C.GstTaskPool) { + var pool Instance // go GstTaskPool subclass + + pool = UnsafeTaskPoolFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + overrides.Cleanup(pool) + }, + ) } if overrides.Prepare != nil { pclass.prepare = (*[0]byte)(C._gotk4_gst1_TaskPool_prepare) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gst1_TaskPool_prepare", + func(carg0 *C.GstTaskPool, _cerr **C.GError) { + var pool Instance // go GstTaskPool subclass + var _goerr error // out, full, converted + + pool = UnsafeTaskPoolFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + _goerr = overrides.Prepare(pool) + + *_cerr = (*C.GError)(glib.UnsafeErrorToGlibFull(_goerr)) + }, + ) } } +// RegisterTaskPoolSubClass is used to register a go subclass of GstTaskPool. For this to work safely please implement the +// virtual methods required by the implementation. +func RegisterTaskPoolSubClass[InstanceT TaskPool]( + name string, + classInit func(class *TaskPoolClass), + constructor func() InstanceT, + overrides TaskPoolOverrides[InstanceT], + signals map[string]gobject.SignalDefinition, + interfaceInits ...gobject.SubClassInterfaceInit[InstanceT], +) gobject.Type { + return gobject.UnsafeRegisterSubClass( + name, + classInit, + constructor, + overrides, + signals, + TypeTaskPool, + UnsafeTaskPoolClassFromGlibBorrow, + UnsafeApplyTaskPoolOverrides, + func (obj *gobject.ObjectInstance) gobject.Object { + return unsafeWrapTaskPool(obj) + }, + interfaceInits..., + ) +} + // 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 @@ -22540,6 +23133,32 @@ func UnsafeApplyTracerOverrides[Instance Tracer](gclass unsafe.Pointer, override UnsafeApplyObjectOverrides(gclass, overrides.ObjectOverrides) } +// RegisterTracerSubClass is used to register a go subclass of GstTracer. For this to work safely please implement the +// virtual methods required by the implementation. +func RegisterTracerSubClass[InstanceT Tracer]( + name string, + classInit func(class *TracerClass), + constructor func() InstanceT, + overrides TracerOverrides[InstanceT], + signals map[string]gobject.SignalDefinition, + interfaceInits ...gobject.SubClassInterfaceInit[InstanceT], +) gobject.Type { + return gobject.UnsafeRegisterSubClass( + name, + classInit, + constructor, + overrides, + signals, + TypeTracer, + UnsafeTracerClassFromGlibBorrow, + UnsafeApplyTracerOverrides, + func (obj *gobject.ObjectInstance) gobject.Object { + return unsafeWrapTracer(obj) + }, + interfaceInits..., + ) +} + // 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 @@ -23267,13 +23886,76 @@ func UnsafeApplyAllocatorOverrides[Instance Allocator](gclass unsafe.Pointer, ov if overrides.Alloc != nil { pclass.alloc = (*[0]byte)(C._gotk4_gst1_Allocator_alloc) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gst1_Allocator_alloc", + func(carg0 *C.GstAllocator, carg1 C.gsize, carg2 *C.GstAllocationParams) (cret *C.GstMemory) { + var allocator Instance // go GstAllocator subclass + var size uint // in, none, casted + var params *AllocationParams // in, none, converted, nullable + var goret *Memory // return, full, converted, nullable + + allocator = UnsafeAllocatorFromGlibNone(unsafe.Pointer(carg0)).(Instance) + size = uint(carg1) + if carg2 != nil { + params = UnsafeAllocationParamsFromGlibNone(unsafe.Pointer(carg2)) + } + + goret = overrides.Alloc(allocator, size, params) + + if goret != nil { + cret = (*C.GstMemory)(UnsafeMemoryToGlibFull(goret)) + } + + return cret + }, + ) } if overrides.Free != nil { pclass.free = (*[0]byte)(C._gotk4_gst1_Allocator_free) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gst1_Allocator_free", + func(carg0 *C.GstAllocator, carg1 *C.GstMemory) { + var allocator Instance // go GstAllocator subclass + var memory *Memory // in, full, converted + + allocator = UnsafeAllocatorFromGlibNone(unsafe.Pointer(carg0)).(Instance) + memory = UnsafeMemoryFromGlibFull(unsafe.Pointer(carg1)) + + overrides.Free(allocator, memory) + }, + ) } } +// RegisterAllocatorSubClass is used to register a go subclass of GstAllocator. For this to work safely please implement the +// virtual methods required by the implementation. +func RegisterAllocatorSubClass[InstanceT Allocator]( + name string, + classInit func(class *AllocatorClass), + constructor func() InstanceT, + overrides AllocatorOverrides[InstanceT], + signals map[string]gobject.SignalDefinition, + interfaceInits ...gobject.SubClassInterfaceInit[InstanceT], +) gobject.Type { + return gobject.UnsafeRegisterSubClass( + name, + classInit, + constructor, + overrides, + signals, + TypeAllocator, + UnsafeAllocatorClassFromGlibBorrow, + UnsafeApplyAllocatorOverrides, + func (obj *gobject.ObjectInstance) gobject.Object { + return unsafeWrapAllocator(obj) + }, + interfaceInits..., + ) +} + // 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 @@ -24209,49 +24891,254 @@ func UnsafeApplyBufferPoolOverrides[Instance BufferPool](gclass unsafe.Pointer, if overrides.AcquireBuffer != nil { pclass.acquire_buffer = (*[0]byte)(C._gotk4_gst1_BufferPool_acquire_buffer) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gst1_BufferPool_acquire_buffer", + func(carg0 *C.GstBufferPool, carg1 **C.GstBuffer, carg2 *C.GstBufferPoolAcquireParams) (cret C.GstFlowReturn) { + var pool Instance // go GstBufferPool subclass + var params *BufferPoolAcquireParams // in, none, converted, nullable + var buffer *Buffer // out, full, converted + var goret FlowReturn // return, none, casted + + pool = UnsafeBufferPoolFromGlibNone(unsafe.Pointer(carg0)).(Instance) + if carg2 != nil { + params = UnsafeBufferPoolAcquireParamsFromGlibNone(unsafe.Pointer(carg2)) + } + + buffer, goret = overrides.AcquireBuffer(pool, params) + + *carg1 = (*C.GstBuffer)(UnsafeBufferToGlibFull(buffer)) + cret = C.GstFlowReturn(goret) + + return cret + }, + ) } if overrides.AllocBuffer != nil { pclass.alloc_buffer = (*[0]byte)(C._gotk4_gst1_BufferPool_alloc_buffer) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gst1_BufferPool_alloc_buffer", + func(carg0 *C.GstBufferPool, carg1 **C.GstBuffer, carg2 *C.GstBufferPoolAcquireParams) (cret C.GstFlowReturn) { + var pool Instance // go GstBufferPool subclass + var params *BufferPoolAcquireParams // in, none, converted, nullable + var buffer *Buffer // out, full, converted + var goret FlowReturn // return, none, casted + + pool = UnsafeBufferPoolFromGlibNone(unsafe.Pointer(carg0)).(Instance) + if carg2 != nil { + params = UnsafeBufferPoolAcquireParamsFromGlibNone(unsafe.Pointer(carg2)) + } + + buffer, goret = overrides.AllocBuffer(pool, params) + + *carg1 = (*C.GstBuffer)(UnsafeBufferToGlibFull(buffer)) + cret = C.GstFlowReturn(goret) + + return cret + }, + ) } if overrides.FlushStart != nil { pclass.flush_start = (*[0]byte)(C._gotk4_gst1_BufferPool_flush_start) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gst1_BufferPool_flush_start", + func(carg0 *C.GstBufferPool) { + var pool Instance // go GstBufferPool subclass + + pool = UnsafeBufferPoolFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + overrides.FlushStart(pool) + }, + ) } if overrides.FlushStop != nil { pclass.flush_stop = (*[0]byte)(C._gotk4_gst1_BufferPool_flush_stop) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gst1_BufferPool_flush_stop", + func(carg0 *C.GstBufferPool) { + var pool Instance // go GstBufferPool subclass + + pool = UnsafeBufferPoolFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + overrides.FlushStop(pool) + }, + ) } if overrides.FreeBuffer != nil { pclass.free_buffer = (*[0]byte)(C._gotk4_gst1_BufferPool_free_buffer) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gst1_BufferPool_free_buffer", + func(carg0 *C.GstBufferPool, carg1 *C.GstBuffer) { + var pool Instance // go GstBufferPool subclass + var buffer *Buffer // in, none, converted + + pool = UnsafeBufferPoolFromGlibNone(unsafe.Pointer(carg0)).(Instance) + buffer = UnsafeBufferFromGlibNone(unsafe.Pointer(carg1)) + + overrides.FreeBuffer(pool, buffer) + }, + ) } if overrides.GetOptions != nil { pclass.get_options = (*[0]byte)(C._gotk4_gst1_BufferPool_get_options) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gst1_BufferPool_get_options", + func(carg0 *C.GstBufferPool) (cret **C.gchar) { + var pool Instance // go GstBufferPool subclass + var goret []string // return, transfer: none, C Pointers: 2, Name: array[utf8], scope: , array (inner: *typesystem.StringPrimitive, zero-terminated) + + pool = UnsafeBufferPoolFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + goret = overrides.GetOptions(pool) + + _ = goret + _ = cret + panic("unimplemented conversion of []string (const gchar**)") + + return cret + }, + ) } if overrides.ReleaseBuffer != nil { pclass.release_buffer = (*[0]byte)(C._gotk4_gst1_BufferPool_release_buffer) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gst1_BufferPool_release_buffer", + func(carg0 *C.GstBufferPool, carg1 *C.GstBuffer) { + var pool Instance // go GstBufferPool subclass + var buffer *Buffer // in, full, converted + + pool = UnsafeBufferPoolFromGlibNone(unsafe.Pointer(carg0)).(Instance) + buffer = UnsafeBufferFromGlibFull(unsafe.Pointer(carg1)) + + overrides.ReleaseBuffer(pool, buffer) + }, + ) } if overrides.ResetBuffer != nil { pclass.reset_buffer = (*[0]byte)(C._gotk4_gst1_BufferPool_reset_buffer) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gst1_BufferPool_reset_buffer", + func(carg0 *C.GstBufferPool, carg1 *C.GstBuffer) { + var pool Instance // go GstBufferPool subclass + var buffer *Buffer // in, none, converted + + pool = UnsafeBufferPoolFromGlibNone(unsafe.Pointer(carg0)).(Instance) + buffer = UnsafeBufferFromGlibNone(unsafe.Pointer(carg1)) + + overrides.ResetBuffer(pool, buffer) + }, + ) } if overrides.SetConfig != nil { pclass.set_config = (*[0]byte)(C._gotk4_gst1_BufferPool_set_config) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gst1_BufferPool_set_config", + func(carg0 *C.GstBufferPool, carg1 *C.GstStructure) (cret C.gboolean) { + var pool Instance // go GstBufferPool subclass + var config *Structure // in, full, converted + var goret bool // return + + pool = UnsafeBufferPoolFromGlibNone(unsafe.Pointer(carg0)).(Instance) + config = UnsafeStructureFromGlibFull(unsafe.Pointer(carg1)) + + goret = overrides.SetConfig(pool, config) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.Start != nil { pclass.start = (*[0]byte)(C._gotk4_gst1_BufferPool_start) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gst1_BufferPool_start", + func(carg0 *C.GstBufferPool) (cret C.gboolean) { + var pool Instance // go GstBufferPool subclass + var goret bool // return + + pool = UnsafeBufferPoolFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + goret = overrides.Start(pool) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.Stop != nil { pclass.stop = (*[0]byte)(C._gotk4_gst1_BufferPool_stop) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gst1_BufferPool_stop", + func(carg0 *C.GstBufferPool) (cret C.gboolean) { + var pool Instance // go GstBufferPool subclass + var goret bool // return + + pool = UnsafeBufferPoolFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + goret = overrides.Stop(pool) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } } +// RegisterBufferPoolSubClass is used to register a go subclass of GstBufferPool. For this to work safely please implement the +// virtual methods required by the implementation. +func RegisterBufferPoolSubClass[InstanceT BufferPool]( + name string, + classInit func(class *BufferPoolClass), + constructor func() InstanceT, + overrides BufferPoolOverrides[InstanceT], + signals map[string]gobject.SignalDefinition, + interfaceInits ...gobject.SubClassInterfaceInit[InstanceT], +) gobject.Type { + return gobject.UnsafeRegisterSubClass( + name, + classInit, + constructor, + overrides, + signals, + TypeBufferPool, + UnsafeBufferPoolClassFromGlibBorrow, + UnsafeApplyBufferPoolOverrides, + func (obj *gobject.ObjectInstance) gobject.Object { + return unsafeWrapBufferPool(obj) + }, + interfaceInits..., + ) +} + // 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 @@ -25338,13 +26225,65 @@ func UnsafeApplyBusOverrides[Instance Bus](gclass unsafe.Pointer, overrides BusO if overrides.Message != nil { pclass.message = (*[0]byte)(C._gotk4_gst1_Bus_message) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gst1_Bus_message", + func(carg0 *C.GstBus, carg1 *C.GstMessage) { + var bus Instance // go GstBus subclass + var message *Message // in, none, converted + + bus = UnsafeBusFromGlibNone(unsafe.Pointer(carg0)).(Instance) + message = UnsafeMessageFromGlibNone(unsafe.Pointer(carg1)) + + overrides.Message(bus, message) + }, + ) } if overrides.SyncMessage != nil { pclass.sync_message = (*[0]byte)(C._gotk4_gst1_Bus_sync_message) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gst1_Bus_sync_message", + func(carg0 *C.GstBus, carg1 *C.GstMessage) { + var bus Instance // go GstBus subclass + var message *Message // in, none, converted + + bus = UnsafeBusFromGlibNone(unsafe.Pointer(carg0)).(Instance) + message = UnsafeMessageFromGlibNone(unsafe.Pointer(carg1)) + + overrides.SyncMessage(bus, message) + }, + ) } } +// RegisterBusSubClass is used to register a go subclass of GstBus. For this to work safely please implement the +// virtual methods required by the implementation. +func RegisterBusSubClass[InstanceT Bus]( + name string, + classInit func(class *BusClass), + constructor func() InstanceT, + overrides BusOverrides[InstanceT], + signals map[string]gobject.SignalDefinition, + interfaceInits ...gobject.SubClassInterfaceInit[InstanceT], +) gobject.Type { + return gobject.UnsafeRegisterSubClass( + name, + classInit, + constructor, + overrides, + signals, + TypeBus, + UnsafeBusClassFromGlibBorrow, + UnsafeApplyBusOverrides, + func (obj *gobject.ObjectInstance) gobject.Object { + return unsafeWrapBus(obj) + }, + interfaceInits..., + ) +} + // 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 @@ -27020,29 +27959,158 @@ func UnsafeApplyClockOverrides[Instance Clock](gclass unsafe.Pointer, overrides if overrides.ChangeResolution != nil { pclass.change_resolution = (*[0]byte)(C._gotk4_gst1_Clock_change_resolution) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gst1_Clock_change_resolution", + func(carg0 *C.GstClock, carg1 C.GstClockTime, carg2 C.GstClockTime) (cret C.GstClockTime) { + var clock Instance // go GstClock subclass + var oldResolution ClockTime // in, none, casted, alias + var newResolution ClockTime // in, none, casted, alias + var goret ClockTime // return, none, casted, alias + + clock = UnsafeClockFromGlibNone(unsafe.Pointer(carg0)).(Instance) + oldResolution = ClockTime(carg1) + newResolution = ClockTime(carg2) + + goret = overrides.ChangeResolution(clock, oldResolution, newResolution) + + cret = C.GstClockTime(goret) + + return cret + }, + ) } if overrides.GetInternalTime != nil { pclass.get_internal_time = (*[0]byte)(C._gotk4_gst1_Clock_get_internal_time) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gst1_Clock_get_internal_time", + func(carg0 *C.GstClock) (cret C.GstClockTime) { + var clock Instance // go GstClock subclass + var goret ClockTime // return, none, casted, alias + + clock = UnsafeClockFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + goret = overrides.GetInternalTime(clock) + + cret = C.GstClockTime(goret) + + return cret + }, + ) } if overrides.GetResolution != nil { pclass.get_resolution = (*[0]byte)(C._gotk4_gst1_Clock_get_resolution) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gst1_Clock_get_resolution", + func(carg0 *C.GstClock) (cret C.GstClockTime) { + var clock Instance // go GstClock subclass + var goret ClockTime // return, none, casted, alias + + clock = UnsafeClockFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + goret = overrides.GetResolution(clock) + + cret = C.GstClockTime(goret) + + return cret + }, + ) } if overrides.Unschedule != nil { pclass.unschedule = (*[0]byte)(C._gotk4_gst1_Clock_unschedule) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gst1_Clock_unschedule", + func(carg0 *C.GstClock, carg1 *C.GstClockEntry) { + var clock Instance // go GstClock subclass + var entry *ClockEntry // in, none, converted + + clock = UnsafeClockFromGlibNone(unsafe.Pointer(carg0)).(Instance) + entry = UnsafeClockEntryFromGlibNone(unsafe.Pointer(carg1)) + + overrides.Unschedule(clock, entry) + }, + ) } if overrides.Wait != nil { pclass.wait = (*[0]byte)(C._gotk4_gst1_Clock_wait) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gst1_Clock_wait", + func(carg0 *C.GstClock, carg1 *C.GstClockEntry, carg2 *C.GstClockTimeDiff) (cret C.GstClockReturn) { + var clock Instance // go GstClock subclass + var entry *ClockEntry // in, none, converted + var jitter ClockTimeDiff // out, full, casted, alias + var goret ClockReturn // return, none, casted + + clock = UnsafeClockFromGlibNone(unsafe.Pointer(carg0)).(Instance) + entry = UnsafeClockEntryFromGlibNone(unsafe.Pointer(carg1)) + + jitter, goret = overrides.Wait(clock, entry) + + *carg2 = C.GstClockTimeDiff(jitter) + cret = C.GstClockReturn(goret) + + return cret + }, + ) } if overrides.WaitAsync != nil { pclass.wait_async = (*[0]byte)(C._gotk4_gst1_Clock_wait_async) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gst1_Clock_wait_async", + func(carg0 *C.GstClock, carg1 *C.GstClockEntry) (cret C.GstClockReturn) { + var clock Instance // go GstClock subclass + var entry *ClockEntry // in, none, converted + var goret ClockReturn // return, none, casted + + clock = UnsafeClockFromGlibNone(unsafe.Pointer(carg0)).(Instance) + entry = UnsafeClockEntryFromGlibNone(unsafe.Pointer(carg1)) + + goret = overrides.WaitAsync(clock, entry) + + cret = C.GstClockReturn(goret) + + return cret + }, + ) } } +// RegisterClockSubClass is used to register a go subclass of GstClock. For this to work safely please implement the +// virtual methods required by the implementation. +func RegisterClockSubClass[InstanceT Clock]( + name string, + classInit func(class *ClockClass), + constructor func() InstanceT, + overrides ClockOverrides[InstanceT], + signals map[string]gobject.SignalDefinition, + interfaceInits ...gobject.SubClassInterfaceInit[InstanceT], +) gobject.Type { + return gobject.UnsafeRegisterSubClass( + name, + classInit, + constructor, + overrides, + signals, + TypeClock, + UnsafeClockClassFromGlibBorrow, + UnsafeApplyClockOverrides, + func (obj *gobject.ObjectInstance) gobject.Object { + return unsafeWrapClock(obj) + }, + interfaceInits..., + ) +} + // 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 @@ -27257,9 +28325,59 @@ func UnsafeApplyControlBindingOverrides[Instance ControlBinding](gclass unsafe.P if overrides.SyncValues != nil { pclass.sync_values = (*[0]byte)(C._gotk4_gst1_ControlBinding_sync_values) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gst1_ControlBinding_sync_values", + func(carg0 *C.GstControlBinding, carg1 *C.GstObject, carg2 C.GstClockTime, carg3 C.GstClockTime) (cret C.gboolean) { + var binding Instance // go GstControlBinding subclass + var object Object // in, none, converted + var timestamp ClockTime // in, none, casted, alias + var lastSync ClockTime // in, none, casted, alias + var goret bool // return + + binding = UnsafeControlBindingFromGlibNone(unsafe.Pointer(carg0)).(Instance) + object = UnsafeObjectFromGlibNone(unsafe.Pointer(carg1)) + timestamp = ClockTime(carg2) + lastSync = ClockTime(carg3) + + goret = overrides.SyncValues(binding, object, timestamp, lastSync) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } } +// RegisterControlBindingSubClass is used to register a go subclass of GstControlBinding. For this to work safely please implement the +// virtual methods required by the implementation. +func RegisterControlBindingSubClass[InstanceT ControlBinding]( + name string, + classInit func(class *ControlBindingClass), + constructor func() InstanceT, + overrides ControlBindingOverrides[InstanceT], + signals map[string]gobject.SignalDefinition, + interfaceInits ...gobject.SubClassInterfaceInit[InstanceT], +) gobject.Type { + return gobject.UnsafeRegisterSubClass( + name, + classInit, + constructor, + overrides, + signals, + TypeControlBinding, + UnsafeControlBindingClassFromGlibBorrow, + UnsafeApplyControlBindingOverrides, + func (obj *gobject.ObjectInstance) gobject.Object { + return unsafeWrapControlBinding(obj) + }, + interfaceInits..., + ) +} + // 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 @@ -27450,6 +28568,32 @@ func UnsafeApplyControlSourceOverrides[Instance ControlSource](gclass unsafe.Poi UnsafeApplyObjectOverrides(gclass, overrides.ObjectOverrides) } +// RegisterControlSourceSubClass is used to register a go subclass of GstControlSource. For this to work safely please implement the +// virtual methods required by the implementation. +func RegisterControlSourceSubClass[InstanceT ControlSource]( + name string, + classInit func(class *ControlSourceClass), + constructor func() InstanceT, + overrides ControlSourceOverrides[InstanceT], + signals map[string]gobject.SignalDefinition, + interfaceInits ...gobject.SubClassInterfaceInit[InstanceT], +) gobject.Type { + return gobject.UnsafeRegisterSubClass( + name, + classInit, + constructor, + overrides, + signals, + TypeControlSource, + UnsafeControlSourceClassFromGlibBorrow, + UnsafeApplyControlSourceOverrides, + func (obj *gobject.ObjectInstance) gobject.Object { + return unsafeWrapControlSource(obj) + }, + interfaceInits..., + ) +} + // 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 @@ -27887,13 +29031,81 @@ func UnsafeApplyDeviceOverrides[Instance Device](gclass unsafe.Pointer, override if overrides.CreateElement != nil { pclass.create_element = (*[0]byte)(C._gotk4_gst1_Device_create_element) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gst1_Device_create_element", + func(carg0 *C.GstDevice, carg1 *C.gchar) (cret *C.GstElement) { + var device Instance // go GstDevice subclass + var name string // in, none, string, nullable-string + var goret Element // return, none, converted, nullable + + device = UnsafeDeviceFromGlibNone(unsafe.Pointer(carg0)).(Instance) + if carg1 != nil { + name = C.GoString((*C.char)(unsafe.Pointer(carg1))) + } + + goret = overrides.CreateElement(device, name) + + if goret != nil { + cret = (*C.GstElement)(UnsafeElementToGlibNone(goret)) + } + + return cret + }, + ) } if overrides.ReconfigureElement != nil { pclass.reconfigure_element = (*[0]byte)(C._gotk4_gst1_Device_reconfigure_element) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gst1_Device_reconfigure_element", + func(carg0 *C.GstDevice, carg1 *C.GstElement) (cret C.gboolean) { + var device Instance // go GstDevice subclass + var element Element // in, none, converted + var goret bool // return + + device = UnsafeDeviceFromGlibNone(unsafe.Pointer(carg0)).(Instance) + element = UnsafeElementFromGlibNone(unsafe.Pointer(carg1)) + + goret = overrides.ReconfigureElement(device, element) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } } +// RegisterDeviceSubClass is used to register a go subclass of GstDevice. For this to work safely please implement the +// virtual methods required by the implementation. +func RegisterDeviceSubClass[InstanceT Device]( + name string, + classInit func(class *DeviceClass), + constructor func() InstanceT, + overrides DeviceOverrides[InstanceT], + signals map[string]gobject.SignalDefinition, + interfaceInits ...gobject.SubClassInterfaceInit[InstanceT], +) gobject.Type { + return gobject.UnsafeRegisterSubClass( + name, + classInit, + constructor, + overrides, + signals, + TypeDevice, + UnsafeDeviceClassFromGlibBorrow, + UnsafeApplyDeviceOverrides, + func (obj *gobject.ObjectInstance) gobject.Object { + return unsafeWrapDevice(obj) + }, + interfaceInits..., + ) +} + // 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 @@ -28387,6 +29599,32 @@ func UnsafeApplyDeviceMonitorOverrides[Instance DeviceMonitor](gclass unsafe.Poi UnsafeApplyObjectOverrides(gclass, overrides.ObjectOverrides) } +// RegisterDeviceMonitorSubClass is used to register a go subclass of GstDeviceMonitor. For this to work safely please implement the +// virtual methods required by the implementation. +func RegisterDeviceMonitorSubClass[InstanceT DeviceMonitor]( + name string, + classInit func(class *DeviceMonitorClass), + constructor func() InstanceT, + overrides DeviceMonitorOverrides[InstanceT], + signals map[string]gobject.SignalDefinition, + interfaceInits ...gobject.SubClassInterfaceInit[InstanceT], +) gobject.Type { + return gobject.UnsafeRegisterSubClass( + name, + classInit, + constructor, + overrides, + signals, + TypeDeviceMonitor, + UnsafeDeviceMonitorClassFromGlibBorrow, + UnsafeApplyDeviceMonitorOverrides, + func (obj *gobject.ObjectInstance) gobject.Object { + return unsafeWrapDeviceMonitor(obj) + }, + interfaceInits..., + ) +} + // 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 @@ -29045,13 +30283,68 @@ func UnsafeApplyDeviceProviderOverrides[Instance DeviceProvider](gclass unsafe.P if overrides.Start != nil { pclass.start = (*[0]byte)(C._gotk4_gst1_DeviceProvider_start) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gst1_DeviceProvider_start", + func(carg0 *C.GstDeviceProvider) (cret C.gboolean) { + var provider Instance // go GstDeviceProvider subclass + var goret bool // return + + provider = UnsafeDeviceProviderFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + goret = overrides.Start(provider) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.Stop != nil { pclass.stop = (*[0]byte)(C._gotk4_gst1_DeviceProvider_stop) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gst1_DeviceProvider_stop", + func(carg0 *C.GstDeviceProvider) { + var provider Instance // go GstDeviceProvider subclass + + provider = UnsafeDeviceProviderFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + overrides.Stop(provider) + }, + ) } } +// RegisterDeviceProviderSubClass is used to register a go subclass of GstDeviceProvider. For this to work safely please implement the +// virtual methods required by the implementation. +func RegisterDeviceProviderSubClass[InstanceT DeviceProvider]( + name string, + classInit func(class *DeviceProviderClass), + constructor func() InstanceT, + overrides DeviceProviderOverrides[InstanceT], + signals map[string]gobject.SignalDefinition, + interfaceInits ...gobject.SubClassInterfaceInit[InstanceT], +) gobject.Type { + return gobject.UnsafeRegisterSubClass( + name, + classInit, + constructor, + overrides, + signals, + TypeDeviceProvider, + UnsafeDeviceProviderClassFromGlibBorrow, + UnsafeApplyDeviceProviderOverrides, + func (obj *gobject.ObjectInstance) gobject.Object { + return unsafeWrapDeviceProvider(obj) + }, + interfaceInits..., + ) +} + // 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 @@ -33502,69 +34795,376 @@ func UnsafeApplyElementOverrides[Instance Element](gclass unsafe.Pointer, overri if overrides.ChangeState != nil { pclass.change_state = (*[0]byte)(C._gotk4_gst1_Element_change_state) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gst1_Element_change_state", + func(carg0 *C.GstElement, carg1 C.GstStateChange) (cret C.GstStateChangeReturn) { + var element Instance // go GstElement subclass + var transition StateChange // in, none, casted + var goret StateChangeReturn // return, none, casted + + element = UnsafeElementFromGlibNone(unsafe.Pointer(carg0)).(Instance) + transition = StateChange(carg1) + + goret = overrides.ChangeState(element, transition) + + cret = C.GstStateChangeReturn(goret) + + return cret + }, + ) } if overrides.GetState != nil { pclass.get_state = (*[0]byte)(C._gotk4_gst1_Element_get_state) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gst1_Element_get_state", + func(carg0 *C.GstElement, carg1 *C.GstState, carg2 *C.GstState, carg3 C.GstClockTime) (cret C.GstStateChangeReturn) { + var element Instance // go GstElement subclass + var timeout ClockTime // in, none, casted, alias + var state State // out, full, casted + var pending State // out, full, casted + var goret StateChangeReturn // return, none, casted + + element = UnsafeElementFromGlibNone(unsafe.Pointer(carg0)).(Instance) + timeout = ClockTime(carg3) + + state, pending, goret = overrides.GetState(element, timeout) + + *carg1 = C.GstState(state) + *carg2 = C.GstState(pending) + cret = C.GstStateChangeReturn(goret) + + return cret + }, + ) } if overrides.NoMorePads != nil { pclass.no_more_pads = (*[0]byte)(C._gotk4_gst1_Element_no_more_pads) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gst1_Element_no_more_pads", + func(carg0 *C.GstElement) { + var element Instance // go GstElement subclass + + element = UnsafeElementFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + overrides.NoMorePads(element) + }, + ) } if overrides.PadAdded != nil { pclass.pad_added = (*[0]byte)(C._gotk4_gst1_Element_pad_added) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gst1_Element_pad_added", + func(carg0 *C.GstElement, carg1 *C.GstPad) { + var element Instance // go GstElement subclass + var pad Pad // in, none, converted + + element = UnsafeElementFromGlibNone(unsafe.Pointer(carg0)).(Instance) + pad = UnsafePadFromGlibNone(unsafe.Pointer(carg1)) + + overrides.PadAdded(element, pad) + }, + ) } if overrides.PadRemoved != nil { pclass.pad_removed = (*[0]byte)(C._gotk4_gst1_Element_pad_removed) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gst1_Element_pad_removed", + func(carg0 *C.GstElement, carg1 *C.GstPad) { + var element Instance // go GstElement subclass + var pad Pad // in, none, converted + + element = UnsafeElementFromGlibNone(unsafe.Pointer(carg0)).(Instance) + pad = UnsafePadFromGlibNone(unsafe.Pointer(carg1)) + + overrides.PadRemoved(element, pad) + }, + ) } if overrides.PostMessage != nil { pclass.post_message = (*[0]byte)(C._gotk4_gst1_Element_post_message) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gst1_Element_post_message", + func(carg0 *C.GstElement, carg1 *C.GstMessage) (cret C.gboolean) { + var element Instance // go GstElement subclass + var message *Message // in, full, converted + var goret bool // return + + element = UnsafeElementFromGlibNone(unsafe.Pointer(carg0)).(Instance) + message = UnsafeMessageFromGlibFull(unsafe.Pointer(carg1)) + + goret = overrides.PostMessage(element, message) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.ProvideClock != nil { pclass.provide_clock = (*[0]byte)(C._gotk4_gst1_Element_provide_clock) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gst1_Element_provide_clock", + func(carg0 *C.GstElement) (cret *C.GstClock) { + var element Instance // go GstElement subclass + var goret Clock // return, full, converted, nullable + + element = UnsafeElementFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + goret = overrides.ProvideClock(element) + + if goret != nil { + cret = (*C.GstClock)(UnsafeClockToGlibFull(goret)) + } + + return cret + }, + ) } if overrides.Query != nil { pclass.query = (*[0]byte)(C._gotk4_gst1_Element_query) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gst1_Element_query", + func(carg0 *C.GstElement, carg1 *C.GstQuery) (cret C.gboolean) { + var element Instance // go GstElement subclass + var query *Query // in, none, converted + var goret bool // return + + element = UnsafeElementFromGlibNone(unsafe.Pointer(carg0)).(Instance) + query = UnsafeQueryFromGlibNone(unsafe.Pointer(carg1)) + + goret = overrides.Query(element, query) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.ReleasePad != nil { pclass.release_pad = (*[0]byte)(C._gotk4_gst1_Element_release_pad) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gst1_Element_release_pad", + func(carg0 *C.GstElement, carg1 *C.GstPad) { + var element Instance // go GstElement subclass + var pad Pad // in, none, converted + + element = UnsafeElementFromGlibNone(unsafe.Pointer(carg0)).(Instance) + pad = UnsafePadFromGlibNone(unsafe.Pointer(carg1)) + + overrides.ReleasePad(element, pad) + }, + ) } if overrides.RequestNewPad != nil { pclass.request_new_pad = (*[0]byte)(C._gotk4_gst1_Element_request_new_pad) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gst1_Element_request_new_pad", + func(carg0 *C.GstElement, carg1 *C.GstPadTemplate, carg2 *C.gchar, carg3 *C.GstCaps) (cret *C.GstPad) { + var element Instance // go GstElement subclass + var templ PadTemplate // in, none, converted + var name string // in, none, string, nullable-string + var caps *Caps // in, none, converted, nullable + var goret Pad // return, full, converted, nullable + + element = UnsafeElementFromGlibNone(unsafe.Pointer(carg0)).(Instance) + templ = UnsafePadTemplateFromGlibNone(unsafe.Pointer(carg1)) + if carg2 != nil { + name = C.GoString((*C.char)(unsafe.Pointer(carg2))) + } + if carg3 != nil { + caps = UnsafeCapsFromGlibNone(unsafe.Pointer(carg3)) + } + + goret = overrides.RequestNewPad(element, templ, name, caps) + + if goret != nil { + cret = (*C.GstPad)(UnsafePadToGlibFull(goret)) + } + + return cret + }, + ) } if overrides.SendEvent != nil { pclass.send_event = (*[0]byte)(C._gotk4_gst1_Element_send_event) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gst1_Element_send_event", + func(carg0 *C.GstElement, carg1 *C.GstEvent) (cret C.gboolean) { + var element Instance // go GstElement subclass + var event *Event // in, full, converted + var goret bool // return + + element = UnsafeElementFromGlibNone(unsafe.Pointer(carg0)).(Instance) + event = UnsafeEventFromGlibFull(unsafe.Pointer(carg1)) + + goret = overrides.SendEvent(element, event) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.SetBus != nil { pclass.set_bus = (*[0]byte)(C._gotk4_gst1_Element_set_bus) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gst1_Element_set_bus", + func(carg0 *C.GstElement, carg1 *C.GstBus) { + var element Instance // go GstElement subclass + var bus Bus // in, none, converted, nullable + + element = UnsafeElementFromGlibNone(unsafe.Pointer(carg0)).(Instance) + if carg1 != nil { + bus = UnsafeBusFromGlibNone(unsafe.Pointer(carg1)) + } + + overrides.SetBus(element, bus) + }, + ) } if overrides.SetClock != nil { pclass.set_clock = (*[0]byte)(C._gotk4_gst1_Element_set_clock) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gst1_Element_set_clock", + func(carg0 *C.GstElement, carg1 *C.GstClock) (cret C.gboolean) { + var element Instance // go GstElement subclass + var clock Clock // in, none, converted, nullable + var goret bool // return + + element = UnsafeElementFromGlibNone(unsafe.Pointer(carg0)).(Instance) + if carg1 != nil { + clock = UnsafeClockFromGlibNone(unsafe.Pointer(carg1)) + } + + goret = overrides.SetClock(element, clock) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.SetContext != nil { pclass.set_context = (*[0]byte)(C._gotk4_gst1_Element_set_context) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gst1_Element_set_context", + func(carg0 *C.GstElement, carg1 *C.GstContext) { + var element Instance // go GstElement subclass + var _context *Context // in, none, converted + + element = UnsafeElementFromGlibNone(unsafe.Pointer(carg0)).(Instance) + _context = UnsafeContextFromGlibNone(unsafe.Pointer(carg1)) + + overrides.SetContext(element, _context) + }, + ) } if overrides.SetState != nil { pclass.set_state = (*[0]byte)(C._gotk4_gst1_Element_set_state) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gst1_Element_set_state", + func(carg0 *C.GstElement, carg1 C.GstState) (cret C.GstStateChangeReturn) { + var element Instance // go GstElement subclass + var state State // in, none, casted + var goret StateChangeReturn // return, none, casted + + element = UnsafeElementFromGlibNone(unsafe.Pointer(carg0)).(Instance) + state = State(carg1) + + goret = overrides.SetState(element, state) + + cret = C.GstStateChangeReturn(goret) + + return cret + }, + ) } if overrides.StateChanged != nil { pclass.state_changed = (*[0]byte)(C._gotk4_gst1_Element_state_changed) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gst1_Element_state_changed", + func(carg0 *C.GstElement, carg1 C.GstState, carg2 C.GstState, carg3 C.GstState) { + var element Instance // go GstElement subclass + var oldstate State // in, none, casted + var newstate State // in, none, casted + var pending State // in, none, casted + + element = UnsafeElementFromGlibNone(unsafe.Pointer(carg0)).(Instance) + oldstate = State(carg1) + newstate = State(carg2) + pending = State(carg3) + + overrides.StateChanged(element, oldstate, newstate, pending) + }, + ) } } +// RegisterElementSubClass is used to register a go subclass of GstElement. For this to work safely please implement the +// virtual methods required by the implementation. +func RegisterElementSubClass[InstanceT Element]( + name string, + classInit func(class *ElementClass), + constructor func() InstanceT, + overrides ElementOverrides[InstanceT], + signals map[string]gobject.SignalDefinition, + interfaceInits ...gobject.SubClassInterfaceInit[InstanceT], +) gobject.Type { + return gobject.UnsafeRegisterSubClass( + name, + classInit, + constructor, + overrides, + signals, + TypeElement, + UnsafeElementClassFromGlibBorrow, + UnsafeApplyElementOverrides, + func (obj *gobject.ObjectInstance) gobject.Object { + return unsafeWrapElement(obj) + }, + interfaceInits..., + ) +} + // 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 @@ -34888,6 +36488,32 @@ func UnsafeApplyGhostPadOverrides[Instance GhostPad](gclass unsafe.Pointer, over UnsafeApplyProxyPadOverrides(gclass, overrides.ProxyPadOverrides) } +// RegisterGhostPadSubClass is used to register a go subclass of GstGhostPad. For this to work safely please implement the +// virtual methods required by the implementation. +func RegisterGhostPadSubClass[InstanceT GhostPad]( + name string, + classInit func(class *GhostPadClass), + constructor func() InstanceT, + overrides GhostPadOverrides[InstanceT], + signals map[string]gobject.SignalDefinition, + interfaceInits ...gobject.SubClassInterfaceInit[InstanceT], +) gobject.Type { + return gobject.UnsafeRegisterSubClass( + name, + classInit, + constructor, + overrides, + signals, + TypeGhostPad, + UnsafeGhostPadClassFromGlibBorrow, + UnsafeApplyGhostPadOverrides, + func (obj *gobject.ObjectInstance) gobject.Object { + return unsafeWrapGhostPad(obj) + }, + interfaceInits..., + ) +} + // 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 @@ -35045,6 +36671,32 @@ func UnsafeApplySharedTaskPoolOverrides[Instance SharedTaskPool](gclass unsafe.P UnsafeApplyTaskPoolOverrides(gclass, overrides.TaskPoolOverrides) } +// RegisterSharedTaskPoolSubClass is used to register a go subclass of GstSharedTaskPool. For this to work safely please implement the +// virtual methods required by the implementation. +func RegisterSharedTaskPoolSubClass[InstanceT SharedTaskPool]( + name string, + classInit func(class *SharedTaskPoolClass), + constructor func() InstanceT, + overrides SharedTaskPoolOverrides[InstanceT], + signals map[string]gobject.SignalDefinition, + interfaceInits ...gobject.SubClassInterfaceInit[InstanceT], +) gobject.Type { + return gobject.UnsafeRegisterSubClass( + name, + classInit, + constructor, + overrides, + signals, + TypeSharedTaskPool, + UnsafeSharedTaskPoolClassFromGlibBorrow, + UnsafeApplySharedTaskPoolOverrides, + func (obj *gobject.ObjectInstance) gobject.Object { + return unsafeWrapSharedTaskPool(obj) + }, + interfaceInits..., + ) +} + // 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 @@ -35169,6 +36821,32 @@ func UnsafeApplySystemClockOverrides[Instance SystemClock](gclass unsafe.Pointer UnsafeApplyClockOverrides(gclass, overrides.ClockOverrides) } +// RegisterSystemClockSubClass is used to register a go subclass of GstSystemClock. For this to work safely please implement the +// virtual methods required by the implementation. +func RegisterSystemClockSubClass[InstanceT SystemClock]( + name string, + classInit func(class *SystemClockClass), + constructor func() InstanceT, + overrides SystemClockOverrides[InstanceT], + signals map[string]gobject.SignalDefinition, + interfaceInits ...gobject.SubClassInterfaceInit[InstanceT], +) gobject.Type { + return gobject.UnsafeRegisterSubClass( + name, + classInit, + constructor, + overrides, + signals, + TypeSystemClock, + UnsafeSystemClockClassFromGlibBorrow, + UnsafeApplySystemClockOverrides, + func (obj *gobject.ObjectInstance) gobject.Object { + return unsafeWrapSystemClock(obj) + }, + interfaceInits..., + ) +} + // 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 @@ -36252,37 +37930,190 @@ func UnsafeApplyBinOverrides[Instance Bin](gclass unsafe.Pointer, overrides BinO if overrides.AddElement != nil { pclass.add_element = (*[0]byte)(C._gotk4_gst1_Bin_add_element) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gst1_Bin_add_element", + func(carg0 *C.GstBin, carg1 *C.GstElement) (cret C.gboolean) { + var bin Instance // go GstBin subclass + var element Element // in, none, converted + var goret bool // return + + bin = UnsafeBinFromGlibNone(unsafe.Pointer(carg0)).(Instance) + element = UnsafeElementFromGlibNone(unsafe.Pointer(carg1)) + + goret = overrides.AddElement(bin, element) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.DeepElementAdded != nil { pclass.deep_element_added = (*[0]byte)(C._gotk4_gst1_Bin_deep_element_added) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gst1_Bin_deep_element_added", + func(carg0 *C.GstBin, carg1 *C.GstBin, carg2 *C.GstElement) { + var bin Instance // go GstBin subclass + var subBin Bin // in, none, converted + var child Element // in, none, converted + + bin = UnsafeBinFromGlibNone(unsafe.Pointer(carg0)).(Instance) + subBin = UnsafeBinFromGlibNone(unsafe.Pointer(carg1)) + child = UnsafeElementFromGlibNone(unsafe.Pointer(carg2)) + + overrides.DeepElementAdded(bin, subBin, child) + }, + ) } if overrides.DeepElementRemoved != nil { pclass.deep_element_removed = (*[0]byte)(C._gotk4_gst1_Bin_deep_element_removed) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gst1_Bin_deep_element_removed", + func(carg0 *C.GstBin, carg1 *C.GstBin, carg2 *C.GstElement) { + var bin Instance // go GstBin subclass + var subBin Bin // in, none, converted + var child Element // in, none, converted + + bin = UnsafeBinFromGlibNone(unsafe.Pointer(carg0)).(Instance) + subBin = UnsafeBinFromGlibNone(unsafe.Pointer(carg1)) + child = UnsafeElementFromGlibNone(unsafe.Pointer(carg2)) + + overrides.DeepElementRemoved(bin, subBin, child) + }, + ) } if overrides.DoLatency != nil { pclass.do_latency = (*[0]byte)(C._gotk4_gst1_Bin_do_latency) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gst1_Bin_do_latency", + func(carg0 *C.GstBin) (cret C.gboolean) { + var bin Instance // go GstBin subclass + var goret bool // return + + bin = UnsafeBinFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + goret = overrides.DoLatency(bin) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.ElementAdded != nil { pclass.element_added = (*[0]byte)(C._gotk4_gst1_Bin_element_added) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gst1_Bin_element_added", + func(carg0 *C.GstBin, carg1 *C.GstElement) { + var bin Instance // go GstBin subclass + var child Element // in, none, converted + + bin = UnsafeBinFromGlibNone(unsafe.Pointer(carg0)).(Instance) + child = UnsafeElementFromGlibNone(unsafe.Pointer(carg1)) + + overrides.ElementAdded(bin, child) + }, + ) } if overrides.ElementRemoved != nil { pclass.element_removed = (*[0]byte)(C._gotk4_gst1_Bin_element_removed) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gst1_Bin_element_removed", + func(carg0 *C.GstBin, carg1 *C.GstElement) { + var bin Instance // go GstBin subclass + var child Element // in, none, converted + + bin = UnsafeBinFromGlibNone(unsafe.Pointer(carg0)).(Instance) + child = UnsafeElementFromGlibNone(unsafe.Pointer(carg1)) + + overrides.ElementRemoved(bin, child) + }, + ) } if overrides.HandleMessage != nil { pclass.handle_message = (*[0]byte)(C._gotk4_gst1_Bin_handle_message) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gst1_Bin_handle_message", + func(carg0 *C.GstBin, carg1 *C.GstMessage) { + var bin Instance // go GstBin subclass + var message *Message // in, full, converted + + bin = UnsafeBinFromGlibNone(unsafe.Pointer(carg0)).(Instance) + message = UnsafeMessageFromGlibFull(unsafe.Pointer(carg1)) + + overrides.HandleMessage(bin, message) + }, + ) } if overrides.RemoveElement != nil { pclass.remove_element = (*[0]byte)(C._gotk4_gst1_Bin_remove_element) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gst1_Bin_remove_element", + func(carg0 *C.GstBin, carg1 *C.GstElement) (cret C.gboolean) { + var bin Instance // go GstBin subclass + var element Element // in, none, converted + var goret bool // return + + bin = UnsafeBinFromGlibNone(unsafe.Pointer(carg0)).(Instance) + element = UnsafeElementFromGlibNone(unsafe.Pointer(carg1)) + + goret = overrides.RemoveElement(bin, element) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } } +// RegisterBinSubClass is used to register a go subclass of GstBin. For this to work safely please implement the +// virtual methods required by the implementation. +func RegisterBinSubClass[InstanceT Bin]( + name string, + classInit func(class *BinClass), + constructor func() InstanceT, + overrides BinOverrides[InstanceT], + signals map[string]gobject.SignalDefinition, + interfaceInits ...gobject.SubClassInterfaceInit[InstanceT], +) gobject.Type { + return gobject.UnsafeRegisterSubClass( + name, + classInit, + constructor, + overrides, + signals, + TypeBin, + UnsafeBinClassFromGlibBorrow, + UnsafeApplyBinOverrides, + func (obj *gobject.ObjectInstance) gobject.Object { + return unsafeWrapBin(obj) + }, + interfaceInits..., + ) +} + // 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 @@ -36884,6 +38715,32 @@ func UnsafeApplyPipelineOverrides[Instance Pipeline](gclass unsafe.Pointer, over UnsafeApplyBinOverrides(gclass, overrides.BinOverrides) } +// RegisterPipelineSubClass is used to register a go subclass of GstPipeline. For this to work safely please implement the +// virtual methods required by the implementation. +func RegisterPipelineSubClass[InstanceT Pipeline]( + name string, + classInit func(class *PipelineClass), + constructor func() InstanceT, + overrides PipelineOverrides[InstanceT], + signals map[string]gobject.SignalDefinition, + interfaceInits ...gobject.SubClassInterfaceInit[InstanceT], +) gobject.Type { + return gobject.UnsafeRegisterSubClass( + name, + classInit, + constructor, + overrides, + signals, + TypePipeline, + UnsafePipelineClassFromGlibBorrow, + UnsafeApplyPipelineOverrides, + func (obj *gobject.ObjectInstance) gobject.Object { + return unsafeWrapPipeline(obj) + }, + interfaceInits..., + ) +} + // AllocationParams wraps GstAllocationParams // // Parameters to control the allocation of memory diff --git a/pkg/gst/gst_export.gen.go b/pkg/gst/gst_export.gen.go index 7af03ff..6dcc4e9 100644 --- a/pkg/gst/gst_export.gen.go +++ b/pkg/gst/gst_export.gen.go @@ -5,6 +5,7 @@ package gst import ( "unsafe" + "github.com/diamondburned/gotk4/pkg/core/classdata" "github.com/diamondburned/gotk4/pkg/core/userdata" "github.com/diamondburned/gotk4/pkg/glib/v2" "github.com/diamondburned/gotk4/pkg/gobject/v2" @@ -659,351 +660,841 @@ func _gotk4_gst1_ElementForEachPadFunc(carg1 *C.GstElement, carg2 *C.GstPad, car //export _gotk4_gst1_ChildProxy_child_added func _gotk4_gst1_ChildProxy_child_added(carg0 *C.GstChildProxy, carg1 *C.GObject, carg2 *C.gchar) { - panic("unimplemented") + var fn func(carg0 *C.GstChildProxy, carg1 *C.GObject, carg2 *C.gchar) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gst1_ChildProxy_child_added").(func(carg0 *C.GstChildProxy, carg1 *C.GObject, carg2 *C.gchar)) + if fn == nil { + panic("_gotk4_gst1_ChildProxy_child_added: no function pointer found") + } + } + fn(carg0, carg1, carg2) } //export _gotk4_gst1_ChildProxy_child_removed func _gotk4_gst1_ChildProxy_child_removed(carg0 *C.GstChildProxy, carg1 *C.GObject, carg2 *C.gchar) { - panic("unimplemented") + var fn func(carg0 *C.GstChildProxy, carg1 *C.GObject, carg2 *C.gchar) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gst1_ChildProxy_child_removed").(func(carg0 *C.GstChildProxy, carg1 *C.GObject, carg2 *C.gchar)) + if fn == nil { + panic("_gotk4_gst1_ChildProxy_child_removed: no function pointer found") + } + } + fn(carg0, carg1, carg2) } //export _gotk4_gst1_ChildProxy_get_child_by_index func _gotk4_gst1_ChildProxy_get_child_by_index(carg0 *C.GstChildProxy, carg1 C.guint) (cret *C.GObject) { - panic("unimplemented") + var fn func(carg0 *C.GstChildProxy, carg1 C.guint) (cret *C.GObject) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gst1_ChildProxy_get_child_by_index").(func(carg0 *C.GstChildProxy, carg1 C.guint) (cret *C.GObject)) + if fn == nil { + panic("_gotk4_gst1_ChildProxy_get_child_by_index: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gst1_ChildProxy_get_child_by_name func _gotk4_gst1_ChildProxy_get_child_by_name(carg0 *C.GstChildProxy, carg1 *C.gchar) (cret *C.GObject) { - panic("unimplemented") + var fn func(carg0 *C.GstChildProxy, carg1 *C.gchar) (cret *C.GObject) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gst1_ChildProxy_get_child_by_name").(func(carg0 *C.GstChildProxy, carg1 *C.gchar) (cret *C.GObject)) + if fn == nil { + panic("_gotk4_gst1_ChildProxy_get_child_by_name: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gst1_ChildProxy_get_children_count func _gotk4_gst1_ChildProxy_get_children_count(carg0 *C.GstChildProxy) (cret C.guint) { - panic("unimplemented") + var fn func(carg0 *C.GstChildProxy) (cret C.guint) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gst1_ChildProxy_get_children_count").(func(carg0 *C.GstChildProxy) (cret C.guint)) + if fn == nil { + panic("_gotk4_gst1_ChildProxy_get_children_count: no function pointer found") + } + } + return fn(carg0) } //export _gotk4_gst1_Preset_delete_preset func _gotk4_gst1_Preset_delete_preset(carg0 *C.GstPreset, carg1 *C.gchar) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstPreset, carg1 *C.gchar) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gst1_Preset_delete_preset").(func(carg0 *C.GstPreset, carg1 *C.gchar) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gst1_Preset_delete_preset: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gst1_Preset_get_meta func _gotk4_gst1_Preset_get_meta(carg0 *C.GstPreset, carg1 *C.gchar, carg2 *C.gchar, carg3 **C.gchar) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstPreset, carg1 *C.gchar, carg2 *C.gchar, carg3 **C.gchar) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gst1_Preset_get_meta").(func(carg0 *C.GstPreset, carg1 *C.gchar, carg2 *C.gchar, carg3 **C.gchar) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gst1_Preset_get_meta: no function pointer found") + } + } + return fn(carg0, carg1, carg2, carg3) } //export _gotk4_gst1_Preset_get_preset_names func _gotk4_gst1_Preset_get_preset_names(carg0 *C.GstPreset) (cret **C.gchar) { - panic("unimplemented") + var fn func(carg0 *C.GstPreset) (cret **C.gchar) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gst1_Preset_get_preset_names").(func(carg0 *C.GstPreset) (cret **C.gchar)) + if fn == nil { + panic("_gotk4_gst1_Preset_get_preset_names: no function pointer found") + } + } + return fn(carg0) } //export _gotk4_gst1_Preset_get_property_names func _gotk4_gst1_Preset_get_property_names(carg0 *C.GstPreset) (cret **C.gchar) { - panic("unimplemented") + var fn func(carg0 *C.GstPreset) (cret **C.gchar) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gst1_Preset_get_property_names").(func(carg0 *C.GstPreset) (cret **C.gchar)) + if fn == nil { + panic("_gotk4_gst1_Preset_get_property_names: no function pointer found") + } + } + return fn(carg0) } //export _gotk4_gst1_Preset_load_preset func _gotk4_gst1_Preset_load_preset(carg0 *C.GstPreset, carg1 *C.gchar) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstPreset, carg1 *C.gchar) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gst1_Preset_load_preset").(func(carg0 *C.GstPreset, carg1 *C.gchar) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gst1_Preset_load_preset: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gst1_Preset_rename_preset func _gotk4_gst1_Preset_rename_preset(carg0 *C.GstPreset, carg1 *C.gchar, carg2 *C.gchar) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstPreset, carg1 *C.gchar, carg2 *C.gchar) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gst1_Preset_rename_preset").(func(carg0 *C.GstPreset, carg1 *C.gchar, carg2 *C.gchar) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gst1_Preset_rename_preset: no function pointer found") + } + } + return fn(carg0, carg1, carg2) } //export _gotk4_gst1_Preset_save_preset func _gotk4_gst1_Preset_save_preset(carg0 *C.GstPreset, carg1 *C.gchar) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstPreset, carg1 *C.gchar) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gst1_Preset_save_preset").(func(carg0 *C.GstPreset, carg1 *C.gchar) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gst1_Preset_save_preset: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gst1_Preset_set_meta func _gotk4_gst1_Preset_set_meta(carg0 *C.GstPreset, carg1 *C.gchar, carg2 *C.gchar, carg3 *C.gchar) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstPreset, carg1 *C.gchar, carg2 *C.gchar, carg3 *C.gchar) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gst1_Preset_set_meta").(func(carg0 *C.GstPreset, carg1 *C.gchar, carg2 *C.gchar, carg3 *C.gchar) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gst1_Preset_set_meta: no function pointer found") + } + } + return fn(carg0, carg1, carg2, carg3) } //export _gotk4_gst1_URIHandler_get_uri func _gotk4_gst1_URIHandler_get_uri(carg0 *C.GstURIHandler) (cret *C.gchar) { - panic("unimplemented") + var fn func(carg0 *C.GstURIHandler) (cret *C.gchar) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gst1_URIHandler_get_uri").(func(carg0 *C.GstURIHandler) (cret *C.gchar)) + if fn == nil { + panic("_gotk4_gst1_URIHandler_get_uri: no function pointer found") + } + } + return fn(carg0) } //export _gotk4_gst1_URIHandler_set_uri func _gotk4_gst1_URIHandler_set_uri(carg0 *C.GstURIHandler, carg1 *C.gchar, _cerr **C.GError) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstURIHandler, carg1 *C.gchar, _cerr **C.GError) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gst1_URIHandler_set_uri").(func(carg0 *C.GstURIHandler, carg1 *C.gchar, _cerr **C.GError) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gst1_URIHandler_set_uri: no function pointer found") + } + } + return fn(carg0, carg1, _cerr) } //export _gotk4_gst1_Pad_linked func _gotk4_gst1_Pad_linked(carg0 *C.GstPad, carg1 *C.GstPad) { - panic("unimplemented") + var fn func(carg0 *C.GstPad, carg1 *C.GstPad) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gst1_Pad_linked").(func(carg0 *C.GstPad, carg1 *C.GstPad)) + if fn == nil { + panic("_gotk4_gst1_Pad_linked: no function pointer found") + } + } + fn(carg0, carg1) } //export _gotk4_gst1_Pad_unlinked func _gotk4_gst1_Pad_unlinked(carg0 *C.GstPad, carg1 *C.GstPad) { - panic("unimplemented") + var fn func(carg0 *C.GstPad, carg1 *C.GstPad) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gst1_Pad_unlinked").(func(carg0 *C.GstPad, carg1 *C.GstPad)) + if fn == nil { + panic("_gotk4_gst1_Pad_unlinked: no function pointer found") + } + } + fn(carg0, carg1) } //export _gotk4_gst1_PadTemplate_pad_created func _gotk4_gst1_PadTemplate_pad_created(carg0 *C.GstPadTemplate, carg1 *C.GstPad) { - panic("unimplemented") + var fn func(carg0 *C.GstPadTemplate, carg1 *C.GstPad) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gst1_PadTemplate_pad_created").(func(carg0 *C.GstPadTemplate, carg1 *C.GstPad)) + if fn == nil { + panic("_gotk4_gst1_PadTemplate_pad_created: no function pointer found") + } + } + fn(carg0, carg1) } //export _gotk4_gst1_TaskPool_cleanup func _gotk4_gst1_TaskPool_cleanup(carg0 *C.GstTaskPool) { - panic("unimplemented") + var fn func(carg0 *C.GstTaskPool) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gst1_TaskPool_cleanup").(func(carg0 *C.GstTaskPool)) + if fn == nil { + panic("_gotk4_gst1_TaskPool_cleanup: no function pointer found") + } + } + fn(carg0) } //export _gotk4_gst1_TaskPool_prepare func _gotk4_gst1_TaskPool_prepare(carg0 *C.GstTaskPool, _cerr **C.GError) { - panic("unimplemented") + var fn func(carg0 *C.GstTaskPool, _cerr **C.GError) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gst1_TaskPool_prepare").(func(carg0 *C.GstTaskPool, _cerr **C.GError)) + if fn == nil { + panic("_gotk4_gst1_TaskPool_prepare: no function pointer found") + } + } + fn(carg0, _cerr) } //export _gotk4_gst1_Allocator_alloc func _gotk4_gst1_Allocator_alloc(carg0 *C.GstAllocator, carg1 C.gsize, carg2 *C.GstAllocationParams) (cret *C.GstMemory) { - panic("unimplemented") + var fn func(carg0 *C.GstAllocator, carg1 C.gsize, carg2 *C.GstAllocationParams) (cret *C.GstMemory) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gst1_Allocator_alloc").(func(carg0 *C.GstAllocator, carg1 C.gsize, carg2 *C.GstAllocationParams) (cret *C.GstMemory)) + if fn == nil { + panic("_gotk4_gst1_Allocator_alloc: no function pointer found") + } + } + return fn(carg0, carg1, carg2) } //export _gotk4_gst1_Allocator_free func _gotk4_gst1_Allocator_free(carg0 *C.GstAllocator, carg1 *C.GstMemory) { - panic("unimplemented") + var fn func(carg0 *C.GstAllocator, carg1 *C.GstMemory) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gst1_Allocator_free").(func(carg0 *C.GstAllocator, carg1 *C.GstMemory)) + if fn == nil { + panic("_gotk4_gst1_Allocator_free: no function pointer found") + } + } + fn(carg0, carg1) } //export _gotk4_gst1_BufferPool_acquire_buffer func _gotk4_gst1_BufferPool_acquire_buffer(carg0 *C.GstBufferPool, carg1 **C.GstBuffer, carg2 *C.GstBufferPoolAcquireParams) (cret C.GstFlowReturn) { - panic("unimplemented") + var fn func(carg0 *C.GstBufferPool, carg1 **C.GstBuffer, carg2 *C.GstBufferPoolAcquireParams) (cret C.GstFlowReturn) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gst1_BufferPool_acquire_buffer").(func(carg0 *C.GstBufferPool, carg1 **C.GstBuffer, carg2 *C.GstBufferPoolAcquireParams) (cret C.GstFlowReturn)) + if fn == nil { + panic("_gotk4_gst1_BufferPool_acquire_buffer: no function pointer found") + } + } + return fn(carg0, carg1, carg2) } //export _gotk4_gst1_BufferPool_alloc_buffer func _gotk4_gst1_BufferPool_alloc_buffer(carg0 *C.GstBufferPool, carg1 **C.GstBuffer, carg2 *C.GstBufferPoolAcquireParams) (cret C.GstFlowReturn) { - panic("unimplemented") + var fn func(carg0 *C.GstBufferPool, carg1 **C.GstBuffer, carg2 *C.GstBufferPoolAcquireParams) (cret C.GstFlowReturn) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gst1_BufferPool_alloc_buffer").(func(carg0 *C.GstBufferPool, carg1 **C.GstBuffer, carg2 *C.GstBufferPoolAcquireParams) (cret C.GstFlowReturn)) + if fn == nil { + panic("_gotk4_gst1_BufferPool_alloc_buffer: no function pointer found") + } + } + return fn(carg0, carg1, carg2) } //export _gotk4_gst1_BufferPool_flush_start func _gotk4_gst1_BufferPool_flush_start(carg0 *C.GstBufferPool) { - panic("unimplemented") + var fn func(carg0 *C.GstBufferPool) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gst1_BufferPool_flush_start").(func(carg0 *C.GstBufferPool)) + if fn == nil { + panic("_gotk4_gst1_BufferPool_flush_start: no function pointer found") + } + } + fn(carg0) } //export _gotk4_gst1_BufferPool_flush_stop func _gotk4_gst1_BufferPool_flush_stop(carg0 *C.GstBufferPool) { - panic("unimplemented") + var fn func(carg0 *C.GstBufferPool) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gst1_BufferPool_flush_stop").(func(carg0 *C.GstBufferPool)) + if fn == nil { + panic("_gotk4_gst1_BufferPool_flush_stop: no function pointer found") + } + } + fn(carg0) } //export _gotk4_gst1_BufferPool_free_buffer func _gotk4_gst1_BufferPool_free_buffer(carg0 *C.GstBufferPool, carg1 *C.GstBuffer) { - panic("unimplemented") + var fn func(carg0 *C.GstBufferPool, carg1 *C.GstBuffer) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gst1_BufferPool_free_buffer").(func(carg0 *C.GstBufferPool, carg1 *C.GstBuffer)) + if fn == nil { + panic("_gotk4_gst1_BufferPool_free_buffer: no function pointer found") + } + } + fn(carg0, carg1) } //export _gotk4_gst1_BufferPool_get_options func _gotk4_gst1_BufferPool_get_options(carg0 *C.GstBufferPool) (cret **C.gchar) { - panic("unimplemented") + var fn func(carg0 *C.GstBufferPool) (cret **C.gchar) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gst1_BufferPool_get_options").(func(carg0 *C.GstBufferPool) (cret **C.gchar)) + if fn == nil { + panic("_gotk4_gst1_BufferPool_get_options: no function pointer found") + } + } + return fn(carg0) } //export _gotk4_gst1_BufferPool_release_buffer func _gotk4_gst1_BufferPool_release_buffer(carg0 *C.GstBufferPool, carg1 *C.GstBuffer) { - panic("unimplemented") + var fn func(carg0 *C.GstBufferPool, carg1 *C.GstBuffer) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gst1_BufferPool_release_buffer").(func(carg0 *C.GstBufferPool, carg1 *C.GstBuffer)) + if fn == nil { + panic("_gotk4_gst1_BufferPool_release_buffer: no function pointer found") + } + } + fn(carg0, carg1) } //export _gotk4_gst1_BufferPool_reset_buffer func _gotk4_gst1_BufferPool_reset_buffer(carg0 *C.GstBufferPool, carg1 *C.GstBuffer) { - panic("unimplemented") + var fn func(carg0 *C.GstBufferPool, carg1 *C.GstBuffer) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gst1_BufferPool_reset_buffer").(func(carg0 *C.GstBufferPool, carg1 *C.GstBuffer)) + if fn == nil { + panic("_gotk4_gst1_BufferPool_reset_buffer: no function pointer found") + } + } + fn(carg0, carg1) } //export _gotk4_gst1_BufferPool_set_config func _gotk4_gst1_BufferPool_set_config(carg0 *C.GstBufferPool, carg1 *C.GstStructure) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstBufferPool, carg1 *C.GstStructure) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gst1_BufferPool_set_config").(func(carg0 *C.GstBufferPool, carg1 *C.GstStructure) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gst1_BufferPool_set_config: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gst1_BufferPool_start func _gotk4_gst1_BufferPool_start(carg0 *C.GstBufferPool) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstBufferPool) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gst1_BufferPool_start").(func(carg0 *C.GstBufferPool) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gst1_BufferPool_start: no function pointer found") + } + } + return fn(carg0) } //export _gotk4_gst1_BufferPool_stop func _gotk4_gst1_BufferPool_stop(carg0 *C.GstBufferPool) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstBufferPool) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gst1_BufferPool_stop").(func(carg0 *C.GstBufferPool) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gst1_BufferPool_stop: no function pointer found") + } + } + return fn(carg0) } //export _gotk4_gst1_Bus_message func _gotk4_gst1_Bus_message(carg0 *C.GstBus, carg1 *C.GstMessage) { - panic("unimplemented") + var fn func(carg0 *C.GstBus, carg1 *C.GstMessage) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gst1_Bus_message").(func(carg0 *C.GstBus, carg1 *C.GstMessage)) + if fn == nil { + panic("_gotk4_gst1_Bus_message: no function pointer found") + } + } + fn(carg0, carg1) } //export _gotk4_gst1_Bus_sync_message func _gotk4_gst1_Bus_sync_message(carg0 *C.GstBus, carg1 *C.GstMessage) { - panic("unimplemented") + var fn func(carg0 *C.GstBus, carg1 *C.GstMessage) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gst1_Bus_sync_message").(func(carg0 *C.GstBus, carg1 *C.GstMessage)) + if fn == nil { + panic("_gotk4_gst1_Bus_sync_message: no function pointer found") + } + } + fn(carg0, carg1) } //export _gotk4_gst1_Clock_change_resolution func _gotk4_gst1_Clock_change_resolution(carg0 *C.GstClock, carg1 C.GstClockTime, carg2 C.GstClockTime) (cret C.GstClockTime) { - panic("unimplemented") + var fn func(carg0 *C.GstClock, carg1 C.GstClockTime, carg2 C.GstClockTime) (cret C.GstClockTime) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gst1_Clock_change_resolution").(func(carg0 *C.GstClock, carg1 C.GstClockTime, carg2 C.GstClockTime) (cret C.GstClockTime)) + if fn == nil { + panic("_gotk4_gst1_Clock_change_resolution: no function pointer found") + } + } + return fn(carg0, carg1, carg2) } //export _gotk4_gst1_Clock_get_internal_time func _gotk4_gst1_Clock_get_internal_time(carg0 *C.GstClock) (cret C.GstClockTime) { - panic("unimplemented") + var fn func(carg0 *C.GstClock) (cret C.GstClockTime) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gst1_Clock_get_internal_time").(func(carg0 *C.GstClock) (cret C.GstClockTime)) + if fn == nil { + panic("_gotk4_gst1_Clock_get_internal_time: no function pointer found") + } + } + return fn(carg0) } //export _gotk4_gst1_Clock_get_resolution func _gotk4_gst1_Clock_get_resolution(carg0 *C.GstClock) (cret C.GstClockTime) { - panic("unimplemented") + var fn func(carg0 *C.GstClock) (cret C.GstClockTime) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gst1_Clock_get_resolution").(func(carg0 *C.GstClock) (cret C.GstClockTime)) + if fn == nil { + panic("_gotk4_gst1_Clock_get_resolution: no function pointer found") + } + } + return fn(carg0) } //export _gotk4_gst1_Clock_unschedule func _gotk4_gst1_Clock_unschedule(carg0 *C.GstClock, carg1 *C.GstClockEntry) { - panic("unimplemented") + var fn func(carg0 *C.GstClock, carg1 *C.GstClockEntry) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gst1_Clock_unschedule").(func(carg0 *C.GstClock, carg1 *C.GstClockEntry)) + if fn == nil { + panic("_gotk4_gst1_Clock_unschedule: no function pointer found") + } + } + fn(carg0, carg1) } //export _gotk4_gst1_Clock_wait func _gotk4_gst1_Clock_wait(carg0 *C.GstClock, carg1 *C.GstClockEntry, carg2 *C.GstClockTimeDiff) (cret C.GstClockReturn) { - panic("unimplemented") + var fn func(carg0 *C.GstClock, carg1 *C.GstClockEntry, carg2 *C.GstClockTimeDiff) (cret C.GstClockReturn) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gst1_Clock_wait").(func(carg0 *C.GstClock, carg1 *C.GstClockEntry, carg2 *C.GstClockTimeDiff) (cret C.GstClockReturn)) + if fn == nil { + panic("_gotk4_gst1_Clock_wait: no function pointer found") + } + } + return fn(carg0, carg1, carg2) } //export _gotk4_gst1_Clock_wait_async func _gotk4_gst1_Clock_wait_async(carg0 *C.GstClock, carg1 *C.GstClockEntry) (cret C.GstClockReturn) { - panic("unimplemented") + var fn func(carg0 *C.GstClock, carg1 *C.GstClockEntry) (cret C.GstClockReturn) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gst1_Clock_wait_async").(func(carg0 *C.GstClock, carg1 *C.GstClockEntry) (cret C.GstClockReturn)) + if fn == nil { + panic("_gotk4_gst1_Clock_wait_async: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gst1_ControlBinding_sync_values func _gotk4_gst1_ControlBinding_sync_values(carg0 *C.GstControlBinding, carg1 *C.GstObject, carg2 C.GstClockTime, carg3 C.GstClockTime) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstControlBinding, carg1 *C.GstObject, carg2 C.GstClockTime, carg3 C.GstClockTime) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gst1_ControlBinding_sync_values").(func(carg0 *C.GstControlBinding, carg1 *C.GstObject, carg2 C.GstClockTime, carg3 C.GstClockTime) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gst1_ControlBinding_sync_values: no function pointer found") + } + } + return fn(carg0, carg1, carg2, carg3) } //export _gotk4_gst1_Device_create_element func _gotk4_gst1_Device_create_element(carg0 *C.GstDevice, carg1 *C.gchar) (cret *C.GstElement) { - panic("unimplemented") + var fn func(carg0 *C.GstDevice, carg1 *C.gchar) (cret *C.GstElement) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gst1_Device_create_element").(func(carg0 *C.GstDevice, carg1 *C.gchar) (cret *C.GstElement)) + if fn == nil { + panic("_gotk4_gst1_Device_create_element: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gst1_Device_reconfigure_element func _gotk4_gst1_Device_reconfigure_element(carg0 *C.GstDevice, carg1 *C.GstElement) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstDevice, carg1 *C.GstElement) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gst1_Device_reconfigure_element").(func(carg0 *C.GstDevice, carg1 *C.GstElement) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gst1_Device_reconfigure_element: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gst1_DeviceProvider_start func _gotk4_gst1_DeviceProvider_start(carg0 *C.GstDeviceProvider) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstDeviceProvider) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gst1_DeviceProvider_start").(func(carg0 *C.GstDeviceProvider) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gst1_DeviceProvider_start: no function pointer found") + } + } + return fn(carg0) } //export _gotk4_gst1_DeviceProvider_stop func _gotk4_gst1_DeviceProvider_stop(carg0 *C.GstDeviceProvider) { - panic("unimplemented") + var fn func(carg0 *C.GstDeviceProvider) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gst1_DeviceProvider_stop").(func(carg0 *C.GstDeviceProvider)) + if fn == nil { + panic("_gotk4_gst1_DeviceProvider_stop: no function pointer found") + } + } + fn(carg0) } //export _gotk4_gst1_Element_change_state func _gotk4_gst1_Element_change_state(carg0 *C.GstElement, carg1 C.GstStateChange) (cret C.GstStateChangeReturn) { - panic("unimplemented") + var fn func(carg0 *C.GstElement, carg1 C.GstStateChange) (cret C.GstStateChangeReturn) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gst1_Element_change_state").(func(carg0 *C.GstElement, carg1 C.GstStateChange) (cret C.GstStateChangeReturn)) + if fn == nil { + panic("_gotk4_gst1_Element_change_state: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gst1_Element_get_state func _gotk4_gst1_Element_get_state(carg0 *C.GstElement, carg1 *C.GstState, carg2 *C.GstState, carg3 C.GstClockTime) (cret C.GstStateChangeReturn) { - panic("unimplemented") + var fn func(carg0 *C.GstElement, carg1 *C.GstState, carg2 *C.GstState, carg3 C.GstClockTime) (cret C.GstStateChangeReturn) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gst1_Element_get_state").(func(carg0 *C.GstElement, carg1 *C.GstState, carg2 *C.GstState, carg3 C.GstClockTime) (cret C.GstStateChangeReturn)) + if fn == nil { + panic("_gotk4_gst1_Element_get_state: no function pointer found") + } + } + return fn(carg0, carg1, carg2, carg3) } //export _gotk4_gst1_Element_no_more_pads func _gotk4_gst1_Element_no_more_pads(carg0 *C.GstElement) { - panic("unimplemented") + var fn func(carg0 *C.GstElement) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gst1_Element_no_more_pads").(func(carg0 *C.GstElement)) + if fn == nil { + panic("_gotk4_gst1_Element_no_more_pads: no function pointer found") + } + } + fn(carg0) } //export _gotk4_gst1_Element_pad_added func _gotk4_gst1_Element_pad_added(carg0 *C.GstElement, carg1 *C.GstPad) { - panic("unimplemented") + var fn func(carg0 *C.GstElement, carg1 *C.GstPad) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gst1_Element_pad_added").(func(carg0 *C.GstElement, carg1 *C.GstPad)) + if fn == nil { + panic("_gotk4_gst1_Element_pad_added: no function pointer found") + } + } + fn(carg0, carg1) } //export _gotk4_gst1_Element_pad_removed func _gotk4_gst1_Element_pad_removed(carg0 *C.GstElement, carg1 *C.GstPad) { - panic("unimplemented") + var fn func(carg0 *C.GstElement, carg1 *C.GstPad) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gst1_Element_pad_removed").(func(carg0 *C.GstElement, carg1 *C.GstPad)) + if fn == nil { + panic("_gotk4_gst1_Element_pad_removed: no function pointer found") + } + } + fn(carg0, carg1) } //export _gotk4_gst1_Element_post_message func _gotk4_gst1_Element_post_message(carg0 *C.GstElement, carg1 *C.GstMessage) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstElement, carg1 *C.GstMessage) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gst1_Element_post_message").(func(carg0 *C.GstElement, carg1 *C.GstMessage) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gst1_Element_post_message: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gst1_Element_provide_clock func _gotk4_gst1_Element_provide_clock(carg0 *C.GstElement) (cret *C.GstClock) { - panic("unimplemented") + var fn func(carg0 *C.GstElement) (cret *C.GstClock) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gst1_Element_provide_clock").(func(carg0 *C.GstElement) (cret *C.GstClock)) + if fn == nil { + panic("_gotk4_gst1_Element_provide_clock: no function pointer found") + } + } + return fn(carg0) } //export _gotk4_gst1_Element_query func _gotk4_gst1_Element_query(carg0 *C.GstElement, carg1 *C.GstQuery) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstElement, carg1 *C.GstQuery) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gst1_Element_query").(func(carg0 *C.GstElement, carg1 *C.GstQuery) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gst1_Element_query: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gst1_Element_release_pad func _gotk4_gst1_Element_release_pad(carg0 *C.GstElement, carg1 *C.GstPad) { - panic("unimplemented") + var fn func(carg0 *C.GstElement, carg1 *C.GstPad) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gst1_Element_release_pad").(func(carg0 *C.GstElement, carg1 *C.GstPad)) + if fn == nil { + panic("_gotk4_gst1_Element_release_pad: no function pointer found") + } + } + fn(carg0, carg1) } //export _gotk4_gst1_Element_request_new_pad func _gotk4_gst1_Element_request_new_pad(carg0 *C.GstElement, carg1 *C.GstPadTemplate, carg2 *C.gchar, carg3 *C.GstCaps) (cret *C.GstPad) { - panic("unimplemented") + var fn func(carg0 *C.GstElement, carg1 *C.GstPadTemplate, carg2 *C.gchar, carg3 *C.GstCaps) (cret *C.GstPad) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gst1_Element_request_new_pad").(func(carg0 *C.GstElement, carg1 *C.GstPadTemplate, carg2 *C.gchar, carg3 *C.GstCaps) (cret *C.GstPad)) + if fn == nil { + panic("_gotk4_gst1_Element_request_new_pad: no function pointer found") + } + } + return fn(carg0, carg1, carg2, carg3) } //export _gotk4_gst1_Element_send_event func _gotk4_gst1_Element_send_event(carg0 *C.GstElement, carg1 *C.GstEvent) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstElement, carg1 *C.GstEvent) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gst1_Element_send_event").(func(carg0 *C.GstElement, carg1 *C.GstEvent) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gst1_Element_send_event: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gst1_Element_set_bus func _gotk4_gst1_Element_set_bus(carg0 *C.GstElement, carg1 *C.GstBus) { - panic("unimplemented") + var fn func(carg0 *C.GstElement, carg1 *C.GstBus) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gst1_Element_set_bus").(func(carg0 *C.GstElement, carg1 *C.GstBus)) + if fn == nil { + panic("_gotk4_gst1_Element_set_bus: no function pointer found") + } + } + fn(carg0, carg1) } //export _gotk4_gst1_Element_set_clock func _gotk4_gst1_Element_set_clock(carg0 *C.GstElement, carg1 *C.GstClock) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstElement, carg1 *C.GstClock) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gst1_Element_set_clock").(func(carg0 *C.GstElement, carg1 *C.GstClock) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gst1_Element_set_clock: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gst1_Element_set_context func _gotk4_gst1_Element_set_context(carg0 *C.GstElement, carg1 *C.GstContext) { - panic("unimplemented") + var fn func(carg0 *C.GstElement, carg1 *C.GstContext) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gst1_Element_set_context").(func(carg0 *C.GstElement, carg1 *C.GstContext)) + if fn == nil { + panic("_gotk4_gst1_Element_set_context: no function pointer found") + } + } + fn(carg0, carg1) } //export _gotk4_gst1_Element_set_state func _gotk4_gst1_Element_set_state(carg0 *C.GstElement, carg1 C.GstState) (cret C.GstStateChangeReturn) { - panic("unimplemented") + var fn func(carg0 *C.GstElement, carg1 C.GstState) (cret C.GstStateChangeReturn) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gst1_Element_set_state").(func(carg0 *C.GstElement, carg1 C.GstState) (cret C.GstStateChangeReturn)) + if fn == nil { + panic("_gotk4_gst1_Element_set_state: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gst1_Element_state_changed func _gotk4_gst1_Element_state_changed(carg0 *C.GstElement, carg1 C.GstState, carg2 C.GstState, carg3 C.GstState) { - panic("unimplemented") + var fn func(carg0 *C.GstElement, carg1 C.GstState, carg2 C.GstState, carg3 C.GstState) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gst1_Element_state_changed").(func(carg0 *C.GstElement, carg1 C.GstState, carg2 C.GstState, carg3 C.GstState)) + if fn == nil { + panic("_gotk4_gst1_Element_state_changed: no function pointer found") + } + } + fn(carg0, carg1, carg2, carg3) } //export _gotk4_gst1_Bin_add_element func _gotk4_gst1_Bin_add_element(carg0 *C.GstBin, carg1 *C.GstElement) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstBin, carg1 *C.GstElement) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gst1_Bin_add_element").(func(carg0 *C.GstBin, carg1 *C.GstElement) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gst1_Bin_add_element: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gst1_Bin_deep_element_added func _gotk4_gst1_Bin_deep_element_added(carg0 *C.GstBin, carg1 *C.GstBin, carg2 *C.GstElement) { - panic("unimplemented") + var fn func(carg0 *C.GstBin, carg1 *C.GstBin, carg2 *C.GstElement) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gst1_Bin_deep_element_added").(func(carg0 *C.GstBin, carg1 *C.GstBin, carg2 *C.GstElement)) + if fn == nil { + panic("_gotk4_gst1_Bin_deep_element_added: no function pointer found") + } + } + fn(carg0, carg1, carg2) } //export _gotk4_gst1_Bin_deep_element_removed func _gotk4_gst1_Bin_deep_element_removed(carg0 *C.GstBin, carg1 *C.GstBin, carg2 *C.GstElement) { - panic("unimplemented") + var fn func(carg0 *C.GstBin, carg1 *C.GstBin, carg2 *C.GstElement) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gst1_Bin_deep_element_removed").(func(carg0 *C.GstBin, carg1 *C.GstBin, carg2 *C.GstElement)) + if fn == nil { + panic("_gotk4_gst1_Bin_deep_element_removed: no function pointer found") + } + } + fn(carg0, carg1, carg2) } //export _gotk4_gst1_Bin_do_latency func _gotk4_gst1_Bin_do_latency(carg0 *C.GstBin) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstBin) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gst1_Bin_do_latency").(func(carg0 *C.GstBin) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gst1_Bin_do_latency: no function pointer found") + } + } + return fn(carg0) } //export _gotk4_gst1_Bin_element_added func _gotk4_gst1_Bin_element_added(carg0 *C.GstBin, carg1 *C.GstElement) { - panic("unimplemented") + var fn func(carg0 *C.GstBin, carg1 *C.GstElement) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gst1_Bin_element_added").(func(carg0 *C.GstBin, carg1 *C.GstElement)) + if fn == nil { + panic("_gotk4_gst1_Bin_element_added: no function pointer found") + } + } + fn(carg0, carg1) } //export _gotk4_gst1_Bin_element_removed func _gotk4_gst1_Bin_element_removed(carg0 *C.GstBin, carg1 *C.GstElement) { - panic("unimplemented") + var fn func(carg0 *C.GstBin, carg1 *C.GstElement) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gst1_Bin_element_removed").(func(carg0 *C.GstBin, carg1 *C.GstElement)) + if fn == nil { + panic("_gotk4_gst1_Bin_element_removed: no function pointer found") + } + } + fn(carg0, carg1) } //export _gotk4_gst1_Bin_handle_message func _gotk4_gst1_Bin_handle_message(carg0 *C.GstBin, carg1 *C.GstMessage) { - panic("unimplemented") + var fn func(carg0 *C.GstBin, carg1 *C.GstMessage) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gst1_Bin_handle_message").(func(carg0 *C.GstBin, carg1 *C.GstMessage)) + if fn == nil { + panic("_gotk4_gst1_Bin_handle_message: no function pointer found") + } + } + fn(carg0, carg1) } //export _gotk4_gst1_Bin_remove_element func _gotk4_gst1_Bin_remove_element(carg0 *C.GstBin, carg1 *C.GstElement) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstBin, carg1 *C.GstElement) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gst1_Bin_remove_element").(func(carg0 *C.GstBin, carg1 *C.GstElement) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gst1_Bin_remove_element: no function pointer found") + } + } + return fn(carg0, carg1) } diff --git a/pkg/gstallocators/gstallocators.gen.go b/pkg/gstallocators/gstallocators.gen.go index b02e92e..e4f6377 100644 --- a/pkg/gstallocators/gstallocators.gen.go +++ b/pkg/gstallocators/gstallocators.gen.go @@ -7,6 +7,7 @@ import ( "strings" "unsafe" + "github.com/diamondburned/gotk4/pkg/core/classdata" "github.com/diamondburned/gotk4/pkg/gobject/v2" "github.com/go-gst/go-gst/pkg/gst" ) @@ -601,6 +602,32 @@ func UnsafeApplyDRMDumbAllocatorOverrides[Instance DRMDumbAllocator](gclass unsa gst.UnsafeApplyAllocatorOverrides(gclass, overrides.AllocatorOverrides) } +// RegisterDRMDumbAllocatorSubClass is used to register a go subclass of GstDRMDumbAllocator. For this to work safely please implement the +// virtual methods required by the implementation. +func RegisterDRMDumbAllocatorSubClass[InstanceT DRMDumbAllocator]( + name string, + classInit func(class *DRMDumbAllocatorClass), + constructor func() InstanceT, + overrides DRMDumbAllocatorOverrides[InstanceT], + signals map[string]gobject.SignalDefinition, + interfaceInits ...gobject.SubClassInterfaceInit[InstanceT], +) gobject.Type { + return gobject.UnsafeRegisterSubClass( + name, + classInit, + constructor, + overrides, + signals, + TypeDRMDumbAllocator, + UnsafeDRMDumbAllocatorClassFromGlibBorrow, + UnsafeApplyDRMDumbAllocatorOverrides, + func (obj *gobject.ObjectInstance) gobject.Object { + return unsafeWrapDRMDumbAllocator(obj) + }, + interfaceInits..., + ) +} + // FdAllocatorInstance is the instance type used by all types extending GstFdAllocator. It is used internally by the bindings. Users should use the interface [FdAllocator] instead. type FdAllocatorInstance struct { _ [0]func() // equal guard @@ -731,6 +758,32 @@ func UnsafeApplyFdAllocatorOverrides[Instance FdAllocator](gclass unsafe.Pointer gst.UnsafeApplyAllocatorOverrides(gclass, overrides.AllocatorOverrides) } +// RegisterFdAllocatorSubClass is used to register a go subclass of GstFdAllocator. For this to work safely please implement the +// virtual methods required by the implementation. +func RegisterFdAllocatorSubClass[InstanceT FdAllocator]( + name string, + classInit func(class *FdAllocatorClass), + constructor func() InstanceT, + overrides FdAllocatorOverrides[InstanceT], + signals map[string]gobject.SignalDefinition, + interfaceInits ...gobject.SubClassInterfaceInit[InstanceT], +) gobject.Type { + return gobject.UnsafeRegisterSubClass( + name, + classInit, + constructor, + overrides, + signals, + TypeFdAllocator, + UnsafeFdAllocatorClassFromGlibBorrow, + UnsafeApplyFdAllocatorOverrides, + func (obj *gobject.ObjectInstance) gobject.Object { + return unsafeWrapFdAllocator(obj) + }, + interfaceInits..., + ) +} + // ShmAllocatorInstance is the instance type used by all types extending GstShmAllocator. It is used internally by the bindings. Users should use the interface [ShmAllocator] instead. type ShmAllocatorInstance struct { _ [0]func() // equal guard @@ -842,6 +895,32 @@ func UnsafeApplyShmAllocatorOverrides[Instance ShmAllocator](gclass unsafe.Point UnsafeApplyFdAllocatorOverrides(gclass, overrides.FdAllocatorOverrides) } +// RegisterShmAllocatorSubClass is used to register a go subclass of GstShmAllocator. For this to work safely please implement the +// virtual methods required by the implementation. +func RegisterShmAllocatorSubClass[InstanceT ShmAllocator]( + name string, + classInit func(class *ShmAllocatorClass), + constructor func() InstanceT, + overrides ShmAllocatorOverrides[InstanceT], + signals map[string]gobject.SignalDefinition, + interfaceInits ...gobject.SubClassInterfaceInit[InstanceT], +) gobject.Type { + return gobject.UnsafeRegisterSubClass( + name, + classInit, + constructor, + overrides, + signals, + TypeShmAllocator, + UnsafeShmAllocatorClassFromGlibBorrow, + UnsafeApplyShmAllocatorOverrides, + func (obj *gobject.ObjectInstance) gobject.Object { + return unsafeWrapShmAllocator(obj) + }, + interfaceInits..., + ) +} + // DmaBufAllocatorInstance is the instance type used by all types extending GstDmaBufAllocator. It is used internally by the bindings. Users should use the interface [DmaBufAllocator] instead. type DmaBufAllocatorInstance struct { _ [0]func() // equal guard @@ -1011,6 +1090,32 @@ func UnsafeApplyDmaBufAllocatorOverrides[Instance DmaBufAllocator](gclass unsafe UnsafeApplyFdAllocatorOverrides(gclass, overrides.FdAllocatorOverrides) } +// RegisterDmaBufAllocatorSubClass is used to register a go subclass of GstDmaBufAllocator. For this to work safely please implement the +// virtual methods required by the implementation. +func RegisterDmaBufAllocatorSubClass[InstanceT DmaBufAllocator]( + name string, + classInit func(class *DmaBufAllocatorClass), + constructor func() InstanceT, + overrides DmaBufAllocatorOverrides[InstanceT], + signals map[string]gobject.SignalDefinition, + interfaceInits ...gobject.SubClassInterfaceInit[InstanceT], +) gobject.Type { + return gobject.UnsafeRegisterSubClass( + name, + classInit, + constructor, + overrides, + signals, + TypeDmaBufAllocator, + UnsafeDmaBufAllocatorClassFromGlibBorrow, + UnsafeApplyDmaBufAllocatorOverrides, + func (obj *gobject.ObjectInstance) gobject.Object { + return unsafeWrapDmaBufAllocator(obj) + }, + interfaceInits..., + ) +} + // DRMDumbAllocatorClass wraps GstDRMDumbAllocatorClass // // DRMDumbAllocatorClass is the type struct for [DRMDumbAllocator] diff --git a/pkg/gstapp/gstapp.gen.go b/pkg/gstapp/gstapp.gen.go index 5cf4d35..0abf92e 100644 --- a/pkg/gstapp/gstapp.gen.go +++ b/pkg/gstapp/gstapp.gen.go @@ -7,6 +7,7 @@ import ( "runtime" "unsafe" + "github.com/diamondburned/gotk4/pkg/core/classdata" "github.com/diamondburned/gotk4/pkg/gobject/v2" "github.com/go-gst/go-gst/pkg/gst" "github.com/go-gst/go-gst/pkg/gstbase" @@ -1518,33 +1519,178 @@ func UnsafeApplyAppSinkOverrides[Instance AppSink](gclass unsafe.Pointer, overri if overrides.Eos != nil { pclass.eos = (*[0]byte)(C._gotk4_gstapp1_AppSink_eos) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstapp1_AppSink_eos", + func(carg0 *C.GstAppSink) { + var appsink Instance // go GstAppSink subclass + + appsink = UnsafeAppSinkFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + overrides.Eos(appsink) + }, + ) } if overrides.NewPreroll != nil { pclass.new_preroll = (*[0]byte)(C._gotk4_gstapp1_AppSink_new_preroll) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstapp1_AppSink_new_preroll", + func(carg0 *C.GstAppSink) (cret C.GstFlowReturn) { + var appsink Instance // go GstAppSink subclass + var goret gst.FlowReturn // return, none, casted + + appsink = UnsafeAppSinkFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + goret = overrides.NewPreroll(appsink) + + cret = C.GstFlowReturn(goret) + + return cret + }, + ) } if overrides.NewSample != nil { pclass.new_sample = (*[0]byte)(C._gotk4_gstapp1_AppSink_new_sample) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstapp1_AppSink_new_sample", + func(carg0 *C.GstAppSink) (cret C.GstFlowReturn) { + var appsink Instance // go GstAppSink subclass + var goret gst.FlowReturn // return, none, casted + + appsink = UnsafeAppSinkFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + goret = overrides.NewSample(appsink) + + cret = C.GstFlowReturn(goret) + + return cret + }, + ) } if overrides.PullPreroll != nil { pclass.pull_preroll = (*[0]byte)(C._gotk4_gstapp1_AppSink_pull_preroll) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstapp1_AppSink_pull_preroll", + func(carg0 *C.GstAppSink) (cret *C.GstSample) { + var appsink Instance // go GstAppSink subclass + var goret *gst.Sample // return, full, converted, nullable + + appsink = UnsafeAppSinkFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + goret = overrides.PullPreroll(appsink) + + if goret != nil { + cret = (*C.GstSample)(gst.UnsafeSampleToGlibFull(goret)) + } + + return cret + }, + ) } if overrides.PullSample != nil { pclass.pull_sample = (*[0]byte)(C._gotk4_gstapp1_AppSink_pull_sample) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstapp1_AppSink_pull_sample", + func(carg0 *C.GstAppSink) (cret *C.GstSample) { + var appsink Instance // go GstAppSink subclass + var goret *gst.Sample // return, full, converted, nullable + + appsink = UnsafeAppSinkFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + goret = overrides.PullSample(appsink) + + if goret != nil { + cret = (*C.GstSample)(gst.UnsafeSampleToGlibFull(goret)) + } + + return cret + }, + ) } if overrides.TryPullPreroll != nil { pclass.try_pull_preroll = (*[0]byte)(C._gotk4_gstapp1_AppSink_try_pull_preroll) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstapp1_AppSink_try_pull_preroll", + func(carg0 *C.GstAppSink, carg1 C.GstClockTime) (cret *C.GstSample) { + var appsink Instance // go GstAppSink subclass + var timeout gst.ClockTime // in, none, casted, alias + var goret *gst.Sample // return, full, converted, nullable + + appsink = UnsafeAppSinkFromGlibNone(unsafe.Pointer(carg0)).(Instance) + timeout = gst.ClockTime(carg1) + + goret = overrides.TryPullPreroll(appsink, timeout) + + if goret != nil { + cret = (*C.GstSample)(gst.UnsafeSampleToGlibFull(goret)) + } + + return cret + }, + ) } if overrides.TryPullSample != nil { pclass.try_pull_sample = (*[0]byte)(C._gotk4_gstapp1_AppSink_try_pull_sample) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstapp1_AppSink_try_pull_sample", + func(carg0 *C.GstAppSink, carg1 C.GstClockTime) (cret *C.GstSample) { + var appsink Instance // go GstAppSink subclass + var timeout gst.ClockTime // in, none, casted, alias + var goret *gst.Sample // return, full, converted, nullable + + appsink = UnsafeAppSinkFromGlibNone(unsafe.Pointer(carg0)).(Instance) + timeout = gst.ClockTime(carg1) + + goret = overrides.TryPullSample(appsink, timeout) + + if goret != nil { + cret = (*C.GstSample)(gst.UnsafeSampleToGlibFull(goret)) + } + + return cret + }, + ) } } +// RegisterAppSinkSubClass is used to register a go subclass of GstAppSink. For this to work safely please implement the +// virtual methods required by the implementation. +func RegisterAppSinkSubClass[InstanceT AppSink]( + name string, + classInit func(class *AppSinkClass), + constructor func() InstanceT, + overrides AppSinkOverrides[InstanceT], + signals map[string]gobject.SignalDefinition, + interfaceInits ...gobject.SubClassInterfaceInit[InstanceT], +) gobject.Type { + return gobject.UnsafeRegisterSubClass( + name, + classInit, + constructor, + overrides, + signals, + TypeAppSink, + UnsafeAppSinkClassFromGlibBorrow, + UnsafeApplyAppSinkOverrides, + func (obj *gobject.ObjectInstance) gobject.Object { + return unsafeWrapAppSink(obj) + }, + interfaceInits..., + ) +} + // AppSrcInstance is the instance type used by all types extending GstAppSrc. It is used internally by the bindings. Users should use the interface [AppSrc] instead. type AppSrcInstance struct { _ [0]func() // equal guard @@ -2831,33 +2977,173 @@ func UnsafeApplyAppSrcOverrides[Instance AppSrc](gclass unsafe.Pointer, override if overrides.EndOfStream != nil { pclass.end_of_stream = (*[0]byte)(C._gotk4_gstapp1_AppSrc_end_of_stream) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstapp1_AppSrc_end_of_stream", + func(carg0 *C.GstAppSrc) (cret C.GstFlowReturn) { + var appsrc Instance // go GstAppSrc subclass + var goret gst.FlowReturn // return, none, casted + + appsrc = UnsafeAppSrcFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + goret = overrides.EndOfStream(appsrc) + + cret = C.GstFlowReturn(goret) + + return cret + }, + ) } if overrides.EnoughData != nil { pclass.enough_data = (*[0]byte)(C._gotk4_gstapp1_AppSrc_enough_data) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstapp1_AppSrc_enough_data", + func(carg0 *C.GstAppSrc) { + var appsrc Instance // go GstAppSrc subclass + + appsrc = UnsafeAppSrcFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + overrides.EnoughData(appsrc) + }, + ) } if overrides.NeedData != nil { pclass.need_data = (*[0]byte)(C._gotk4_gstapp1_AppSrc_need_data) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstapp1_AppSrc_need_data", + func(carg0 *C.GstAppSrc, carg1 C.guint) { + var appsrc Instance // go GstAppSrc subclass + var length uint // in, none, casted + + appsrc = UnsafeAppSrcFromGlibNone(unsafe.Pointer(carg0)).(Instance) + length = uint(carg1) + + overrides.NeedData(appsrc, length) + }, + ) } if overrides.PushBuffer != nil { pclass.push_buffer = (*[0]byte)(C._gotk4_gstapp1_AppSrc_push_buffer) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstapp1_AppSrc_push_buffer", + func(carg0 *C.GstAppSrc, carg1 *C.GstBuffer) (cret C.GstFlowReturn) { + var appsrc Instance // go GstAppSrc subclass + var buffer *gst.Buffer // in, full, converted + var goret gst.FlowReturn // return, none, casted + + appsrc = UnsafeAppSrcFromGlibNone(unsafe.Pointer(carg0)).(Instance) + buffer = gst.UnsafeBufferFromGlibFull(unsafe.Pointer(carg1)) + + goret = overrides.PushBuffer(appsrc, buffer) + + cret = C.GstFlowReturn(goret) + + return cret + }, + ) } if overrides.PushBufferList != nil { pclass.push_buffer_list = (*[0]byte)(C._gotk4_gstapp1_AppSrc_push_buffer_list) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstapp1_AppSrc_push_buffer_list", + func(carg0 *C.GstAppSrc, carg1 *C.GstBufferList) (cret C.GstFlowReturn) { + var appsrc Instance // go GstAppSrc subclass + var bufferList *gst.BufferList // in, full, converted + var goret gst.FlowReturn // return, none, casted + + appsrc = UnsafeAppSrcFromGlibNone(unsafe.Pointer(carg0)).(Instance) + bufferList = gst.UnsafeBufferListFromGlibFull(unsafe.Pointer(carg1)) + + goret = overrides.PushBufferList(appsrc, bufferList) + + cret = C.GstFlowReturn(goret) + + return cret + }, + ) } if overrides.PushSample != nil { pclass.push_sample = (*[0]byte)(C._gotk4_gstapp1_AppSrc_push_sample) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstapp1_AppSrc_push_sample", + func(carg0 *C.GstAppSrc, carg1 *C.GstSample) (cret C.GstFlowReturn) { + var appsrc Instance // go GstAppSrc subclass + var sample *gst.Sample // in, none, converted + var goret gst.FlowReturn // return, none, casted + + appsrc = UnsafeAppSrcFromGlibNone(unsafe.Pointer(carg0)).(Instance) + sample = gst.UnsafeSampleFromGlibNone(unsafe.Pointer(carg1)) + + goret = overrides.PushSample(appsrc, sample) + + cret = C.GstFlowReturn(goret) + + return cret + }, + ) } if overrides.SeekData != nil { pclass.seek_data = (*[0]byte)(C._gotk4_gstapp1_AppSrc_seek_data) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstapp1_AppSrc_seek_data", + func(carg0 *C.GstAppSrc, carg1 C.guint64) (cret C.gboolean) { + var appsrc Instance // go GstAppSrc subclass + var offset uint64 // in, none, casted + var goret bool // return + + appsrc = UnsafeAppSrcFromGlibNone(unsafe.Pointer(carg0)).(Instance) + offset = uint64(carg1) + + goret = overrides.SeekData(appsrc, offset) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } } +// RegisterAppSrcSubClass is used to register a go subclass of GstAppSrc. For this to work safely please implement the +// virtual methods required by the implementation. +func RegisterAppSrcSubClass[InstanceT AppSrc]( + name string, + classInit func(class *AppSrcClass), + constructor func() InstanceT, + overrides AppSrcOverrides[InstanceT], + signals map[string]gobject.SignalDefinition, + interfaceInits ...gobject.SubClassInterfaceInit[InstanceT], +) gobject.Type { + return gobject.UnsafeRegisterSubClass( + name, + classInit, + constructor, + overrides, + signals, + TypeAppSrc, + UnsafeAppSrcClassFromGlibBorrow, + UnsafeApplyAppSrcOverrides, + func (obj *gobject.ObjectInstance) gobject.Object { + return unsafeWrapAppSrc(obj) + }, + interfaceInits..., + ) +} + // AppSinkClass wraps GstAppSinkClass // // AppSinkClass is the type struct for [AppSink] diff --git a/pkg/gstapp/gstapp_export.gen.go b/pkg/gstapp/gstapp_export.gen.go index 40bf8de..7b898be 100644 --- a/pkg/gstapp/gstapp_export.gen.go +++ b/pkg/gstapp/gstapp_export.gen.go @@ -2,77 +2,180 @@ package gstapp +import ( + "unsafe" + + "github.com/diamondburned/gotk4/pkg/core/classdata" +) // #include import "C" //export _gotk4_gstapp1_AppSink_eos func _gotk4_gstapp1_AppSink_eos(carg0 *C.GstAppSink) { - panic("unimplemented") + var fn func(carg0 *C.GstAppSink) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstapp1_AppSink_eos").(func(carg0 *C.GstAppSink)) + if fn == nil { + panic("_gotk4_gstapp1_AppSink_eos: no function pointer found") + } + } + fn(carg0) } //export _gotk4_gstapp1_AppSink_new_preroll func _gotk4_gstapp1_AppSink_new_preroll(carg0 *C.GstAppSink) (cret C.GstFlowReturn) { - panic("unimplemented") + var fn func(carg0 *C.GstAppSink) (cret C.GstFlowReturn) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstapp1_AppSink_new_preroll").(func(carg0 *C.GstAppSink) (cret C.GstFlowReturn)) + if fn == nil { + panic("_gotk4_gstapp1_AppSink_new_preroll: no function pointer found") + } + } + return fn(carg0) } //export _gotk4_gstapp1_AppSink_new_sample func _gotk4_gstapp1_AppSink_new_sample(carg0 *C.GstAppSink) (cret C.GstFlowReturn) { - panic("unimplemented") + var fn func(carg0 *C.GstAppSink) (cret C.GstFlowReturn) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstapp1_AppSink_new_sample").(func(carg0 *C.GstAppSink) (cret C.GstFlowReturn)) + if fn == nil { + panic("_gotk4_gstapp1_AppSink_new_sample: no function pointer found") + } + } + return fn(carg0) } //export _gotk4_gstapp1_AppSink_pull_preroll func _gotk4_gstapp1_AppSink_pull_preroll(carg0 *C.GstAppSink) (cret *C.GstSample) { - panic("unimplemented") + var fn func(carg0 *C.GstAppSink) (cret *C.GstSample) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstapp1_AppSink_pull_preroll").(func(carg0 *C.GstAppSink) (cret *C.GstSample)) + if fn == nil { + panic("_gotk4_gstapp1_AppSink_pull_preroll: no function pointer found") + } + } + return fn(carg0) } //export _gotk4_gstapp1_AppSink_pull_sample func _gotk4_gstapp1_AppSink_pull_sample(carg0 *C.GstAppSink) (cret *C.GstSample) { - panic("unimplemented") + var fn func(carg0 *C.GstAppSink) (cret *C.GstSample) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstapp1_AppSink_pull_sample").(func(carg0 *C.GstAppSink) (cret *C.GstSample)) + if fn == nil { + panic("_gotk4_gstapp1_AppSink_pull_sample: no function pointer found") + } + } + return fn(carg0) } //export _gotk4_gstapp1_AppSink_try_pull_preroll func _gotk4_gstapp1_AppSink_try_pull_preroll(carg0 *C.GstAppSink, carg1 C.GstClockTime) (cret *C.GstSample) { - panic("unimplemented") + var fn func(carg0 *C.GstAppSink, carg1 C.GstClockTime) (cret *C.GstSample) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstapp1_AppSink_try_pull_preroll").(func(carg0 *C.GstAppSink, carg1 C.GstClockTime) (cret *C.GstSample)) + if fn == nil { + panic("_gotk4_gstapp1_AppSink_try_pull_preroll: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstapp1_AppSink_try_pull_sample func _gotk4_gstapp1_AppSink_try_pull_sample(carg0 *C.GstAppSink, carg1 C.GstClockTime) (cret *C.GstSample) { - panic("unimplemented") + var fn func(carg0 *C.GstAppSink, carg1 C.GstClockTime) (cret *C.GstSample) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstapp1_AppSink_try_pull_sample").(func(carg0 *C.GstAppSink, carg1 C.GstClockTime) (cret *C.GstSample)) + if fn == nil { + panic("_gotk4_gstapp1_AppSink_try_pull_sample: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstapp1_AppSrc_end_of_stream func _gotk4_gstapp1_AppSrc_end_of_stream(carg0 *C.GstAppSrc) (cret C.GstFlowReturn) { - panic("unimplemented") + var fn func(carg0 *C.GstAppSrc) (cret C.GstFlowReturn) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstapp1_AppSrc_end_of_stream").(func(carg0 *C.GstAppSrc) (cret C.GstFlowReturn)) + if fn == nil { + panic("_gotk4_gstapp1_AppSrc_end_of_stream: no function pointer found") + } + } + return fn(carg0) } //export _gotk4_gstapp1_AppSrc_enough_data func _gotk4_gstapp1_AppSrc_enough_data(carg0 *C.GstAppSrc) { - panic("unimplemented") + var fn func(carg0 *C.GstAppSrc) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstapp1_AppSrc_enough_data").(func(carg0 *C.GstAppSrc)) + if fn == nil { + panic("_gotk4_gstapp1_AppSrc_enough_data: no function pointer found") + } + } + fn(carg0) } //export _gotk4_gstapp1_AppSrc_need_data func _gotk4_gstapp1_AppSrc_need_data(carg0 *C.GstAppSrc, carg1 C.guint) { - panic("unimplemented") + var fn func(carg0 *C.GstAppSrc, carg1 C.guint) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstapp1_AppSrc_need_data").(func(carg0 *C.GstAppSrc, carg1 C.guint)) + if fn == nil { + panic("_gotk4_gstapp1_AppSrc_need_data: no function pointer found") + } + } + fn(carg0, carg1) } //export _gotk4_gstapp1_AppSrc_push_buffer func _gotk4_gstapp1_AppSrc_push_buffer(carg0 *C.GstAppSrc, carg1 *C.GstBuffer) (cret C.GstFlowReturn) { - panic("unimplemented") + var fn func(carg0 *C.GstAppSrc, carg1 *C.GstBuffer) (cret C.GstFlowReturn) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstapp1_AppSrc_push_buffer").(func(carg0 *C.GstAppSrc, carg1 *C.GstBuffer) (cret C.GstFlowReturn)) + if fn == nil { + panic("_gotk4_gstapp1_AppSrc_push_buffer: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstapp1_AppSrc_push_buffer_list func _gotk4_gstapp1_AppSrc_push_buffer_list(carg0 *C.GstAppSrc, carg1 *C.GstBufferList) (cret C.GstFlowReturn) { - panic("unimplemented") + var fn func(carg0 *C.GstAppSrc, carg1 *C.GstBufferList) (cret C.GstFlowReturn) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstapp1_AppSrc_push_buffer_list").(func(carg0 *C.GstAppSrc, carg1 *C.GstBufferList) (cret C.GstFlowReturn)) + if fn == nil { + panic("_gotk4_gstapp1_AppSrc_push_buffer_list: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstapp1_AppSrc_push_sample func _gotk4_gstapp1_AppSrc_push_sample(carg0 *C.GstAppSrc, carg1 *C.GstSample) (cret C.GstFlowReturn) { - panic("unimplemented") + var fn func(carg0 *C.GstAppSrc, carg1 *C.GstSample) (cret C.GstFlowReturn) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstapp1_AppSrc_push_sample").(func(carg0 *C.GstAppSrc, carg1 *C.GstSample) (cret C.GstFlowReturn)) + if fn == nil { + panic("_gotk4_gstapp1_AppSrc_push_sample: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstapp1_AppSrc_seek_data func _gotk4_gstapp1_AppSrc_seek_data(carg0 *C.GstAppSrc, carg1 C.guint64) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstAppSrc, carg1 C.guint64) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstapp1_AppSrc_seek_data").(func(carg0 *C.GstAppSrc, carg1 C.guint64) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstapp1_AppSrc_seek_data: no function pointer found") + } + } + return fn(carg0, carg1) } diff --git a/pkg/gstaudio/gstaudio.gen.go b/pkg/gstaudio/gstaudio.gen.go index dbd2c7e..9cabb2c 100644 --- a/pkg/gstaudio/gstaudio.gen.go +++ b/pkg/gstaudio/gstaudio.gen.go @@ -8,6 +8,7 @@ import ( "strings" "unsafe" + "github.com/diamondburned/gotk4/pkg/core/classdata" "github.com/diamondburned/gotk4/pkg/core/userdata" "github.com/diamondburned/gotk4/pkg/gobject/v2" "github.com/go-gst/go-gst/pkg/gst" @@ -3541,13 +3542,87 @@ func UnsafeApplyAudioAggregatorOverrides[Instance AudioAggregator](gclass unsafe if overrides.AggregateOneBuffer != nil { pclass.aggregate_one_buffer = (*[0]byte)(C._gotk4_gstaudio1_AudioAggregator_aggregate_one_buffer) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstaudio1_AudioAggregator_aggregate_one_buffer", + func(carg0 *C.GstAudioAggregator, carg1 *C.GstAudioAggregatorPad, carg2 *C.GstBuffer, carg3 C.guint, carg4 *C.GstBuffer, carg5 C.guint, carg6 C.guint) (cret C.gboolean) { + var aagg Instance // go GstAudioAggregator subclass + var pad AudioAggregatorPad // in, none, converted + var inbuf *gst.Buffer // in, none, converted + var inOffset uint // in, none, casted + var outbuf *gst.Buffer // in, none, converted + var outOffset uint // in, none, casted + var numFrames uint // in, none, casted + var goret bool // return + + aagg = UnsafeAudioAggregatorFromGlibNone(unsafe.Pointer(carg0)).(Instance) + pad = UnsafeAudioAggregatorPadFromGlibNone(unsafe.Pointer(carg1)) + inbuf = gst.UnsafeBufferFromGlibNone(unsafe.Pointer(carg2)) + inOffset = uint(carg3) + outbuf = gst.UnsafeBufferFromGlibNone(unsafe.Pointer(carg4)) + outOffset = uint(carg5) + numFrames = uint(carg6) + + goret = overrides.AggregateOneBuffer(aagg, pad, inbuf, inOffset, outbuf, outOffset, numFrames) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.CreateOutputBuffer != nil { pclass.create_output_buffer = (*[0]byte)(C._gotk4_gstaudio1_AudioAggregator_create_output_buffer) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstaudio1_AudioAggregator_create_output_buffer", + func(carg0 *C.GstAudioAggregator, carg1 C.guint) (cret *C.GstBuffer) { + var aagg Instance // go GstAudioAggregator subclass + var numFrames uint // in, none, casted + var goret *gst.Buffer // return, full, converted + + aagg = UnsafeAudioAggregatorFromGlibNone(unsafe.Pointer(carg0)).(Instance) + numFrames = uint(carg1) + + goret = overrides.CreateOutputBuffer(aagg, numFrames) + + cret = (*C.GstBuffer)(gst.UnsafeBufferToGlibFull(goret)) + + return cret + }, + ) } } +// RegisterAudioAggregatorSubClass is used to register a go subclass of GstAudioAggregator. For this to work safely please implement the +// virtual methods required by the implementation. +func RegisterAudioAggregatorSubClass[InstanceT AudioAggregator]( + name string, + classInit func(class *AudioAggregatorClass), + constructor func() InstanceT, + overrides AudioAggregatorOverrides[InstanceT], + signals map[string]gobject.SignalDefinition, + interfaceInits ...gobject.SubClassInterfaceInit[InstanceT], +) gobject.Type { + return gobject.UnsafeRegisterSubClass( + name, + classInit, + constructor, + overrides, + signals, + TypeAudioAggregator, + UnsafeAudioAggregatorClassFromGlibBorrow, + UnsafeApplyAudioAggregatorOverrides, + func (obj *gobject.ObjectInstance) gobject.Object { + return unsafeWrapAudioAggregator(obj) + }, + interfaceInits..., + ) +} + // AudioAggregatorPadInstance is the instance type used by all types extending GstAudioAggregatorPad. It is used internally by the bindings. Users should use the interface [AudioAggregatorPad] instead. type AudioAggregatorPadInstance struct { _ [0]func() // equal guard @@ -3636,13 +3711,72 @@ func UnsafeApplyAudioAggregatorPadOverrides[Instance AudioAggregatorPad](gclass if overrides.ConvertBuffer != nil { pclass.convert_buffer = (*[0]byte)(C._gotk4_gstaudio1_AudioAggregatorPad_convert_buffer) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstaudio1_AudioAggregatorPad_convert_buffer", + func(carg0 *C.GstAudioAggregatorPad, carg1 *C.GstAudioInfo, carg2 *C.GstAudioInfo, carg3 *C.GstBuffer) (cret *C.GstBuffer) { + var pad Instance // go GstAudioAggregatorPad subclass + var inInfo *AudioInfo // in, none, converted + var outInfo *AudioInfo // in, none, converted + var buffer *gst.Buffer // in, none, converted + var goret *gst.Buffer // return, full, converted + + pad = UnsafeAudioAggregatorPadFromGlibNone(unsafe.Pointer(carg0)).(Instance) + inInfo = UnsafeAudioInfoFromGlibNone(unsafe.Pointer(carg1)) + outInfo = UnsafeAudioInfoFromGlibNone(unsafe.Pointer(carg2)) + buffer = gst.UnsafeBufferFromGlibNone(unsafe.Pointer(carg3)) + + goret = overrides.ConvertBuffer(pad, inInfo, outInfo, buffer) + + cret = (*C.GstBuffer)(gst.UnsafeBufferToGlibFull(goret)) + + return cret + }, + ) } if overrides.UpdateConversionInfo != nil { pclass.update_conversion_info = (*[0]byte)(C._gotk4_gstaudio1_AudioAggregatorPad_update_conversion_info) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstaudio1_AudioAggregatorPad_update_conversion_info", + func(carg0 *C.GstAudioAggregatorPad) { + var pad Instance // go GstAudioAggregatorPad subclass + + pad = UnsafeAudioAggregatorPadFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + overrides.UpdateConversionInfo(pad) + }, + ) } } +// RegisterAudioAggregatorPadSubClass is used to register a go subclass of GstAudioAggregatorPad. For this to work safely please implement the +// virtual methods required by the implementation. +func RegisterAudioAggregatorPadSubClass[InstanceT AudioAggregatorPad]( + name string, + classInit func(class *AudioAggregatorPadClass), + constructor func() InstanceT, + overrides AudioAggregatorPadOverrides[InstanceT], + signals map[string]gobject.SignalDefinition, + interfaceInits ...gobject.SubClassInterfaceInit[InstanceT], +) gobject.Type { + return gobject.UnsafeRegisterSubClass( + name, + classInit, + constructor, + overrides, + signals, + TypeAudioAggregatorPad, + UnsafeAudioAggregatorPadClassFromGlibBorrow, + UnsafeApplyAudioAggregatorPadOverrides, + func (obj *gobject.ObjectInstance) gobject.Object { + return unsafeWrapAudioAggregatorPad(obj) + }, + interfaceInits..., + ) +} + // AudioBaseSinkInstance is the instance type used by all types extending GstAudioBaseSink. It is used internally by the bindings. Users should use the interface [AudioBaseSink] instead. type AudioBaseSinkInstance struct { _ [0]func() // equal guard @@ -4143,13 +4277,75 @@ func UnsafeApplyAudioBaseSinkOverrides[Instance AudioBaseSink](gclass unsafe.Poi if overrides.CreateRingbuffer != nil { pclass.create_ringbuffer = (*[0]byte)(C._gotk4_gstaudio1_AudioBaseSink_create_ringbuffer) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstaudio1_AudioBaseSink_create_ringbuffer", + func(carg0 *C.GstAudioBaseSink) (cret *C.GstAudioRingBuffer) { + var sink Instance // go GstAudioBaseSink subclass + var goret AudioRingBuffer // return, none, converted, nullable + + sink = UnsafeAudioBaseSinkFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + goret = overrides.CreateRingbuffer(sink) + + if goret != nil { + cret = (*C.GstAudioRingBuffer)(UnsafeAudioRingBufferToGlibNone(goret)) + } + + return cret + }, + ) } if overrides.Payload != nil { pclass.payload = (*[0]byte)(C._gotk4_gstaudio1_AudioBaseSink_payload) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstaudio1_AudioBaseSink_payload", + func(carg0 *C.GstAudioBaseSink, carg1 *C.GstBuffer) (cret *C.GstBuffer) { + var sink Instance // go GstAudioBaseSink subclass + var buffer *gst.Buffer // in, none, converted + var goret *gst.Buffer // return, full, converted + + sink = UnsafeAudioBaseSinkFromGlibNone(unsafe.Pointer(carg0)).(Instance) + buffer = gst.UnsafeBufferFromGlibNone(unsafe.Pointer(carg1)) + + goret = overrides.Payload(sink, buffer) + + cret = (*C.GstBuffer)(gst.UnsafeBufferToGlibFull(goret)) + + return cret + }, + ) } } +// RegisterAudioBaseSinkSubClass is used to register a go subclass of GstAudioBaseSink. For this to work safely please implement the +// virtual methods required by the implementation. +func RegisterAudioBaseSinkSubClass[InstanceT AudioBaseSink]( + name string, + classInit func(class *AudioBaseSinkClass), + constructor func() InstanceT, + overrides AudioBaseSinkOverrides[InstanceT], + signals map[string]gobject.SignalDefinition, + interfaceInits ...gobject.SubClassInterfaceInit[InstanceT], +) gobject.Type { + return gobject.UnsafeRegisterSubClass( + name, + classInit, + constructor, + overrides, + signals, + TypeAudioBaseSink, + UnsafeAudioBaseSinkClassFromGlibBorrow, + UnsafeApplyAudioBaseSinkOverrides, + func (obj *gobject.ObjectInstance) gobject.Object { + return unsafeWrapAudioBaseSink(obj) + }, + interfaceInits..., + ) +} + // AudioBaseSrcInstance is the instance type used by all types extending GstAudioBaseSrc. It is used internally by the bindings. Users should use the interface [AudioBaseSrc] instead. type AudioBaseSrcInstance struct { _ [0]func() // equal guard @@ -4398,9 +4594,53 @@ func UnsafeApplyAudioBaseSrcOverrides[Instance AudioBaseSrc](gclass unsafe.Point if overrides.CreateRingbuffer != nil { pclass.create_ringbuffer = (*[0]byte)(C._gotk4_gstaudio1_AudioBaseSrc_create_ringbuffer) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstaudio1_AudioBaseSrc_create_ringbuffer", + func(carg0 *C.GstAudioBaseSrc) (cret *C.GstAudioRingBuffer) { + var src Instance // go GstAudioBaseSrc subclass + var goret AudioRingBuffer // return, none, converted, nullable + + src = UnsafeAudioBaseSrcFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + goret = overrides.CreateRingbuffer(src) + + if goret != nil { + cret = (*C.GstAudioRingBuffer)(UnsafeAudioRingBufferToGlibNone(goret)) + } + + return cret + }, + ) } } +// RegisterAudioBaseSrcSubClass is used to register a go subclass of GstAudioBaseSrc. For this to work safely please implement the +// virtual methods required by the implementation. +func RegisterAudioBaseSrcSubClass[InstanceT AudioBaseSrc]( + name string, + classInit func(class *AudioBaseSrcClass), + constructor func() InstanceT, + overrides AudioBaseSrcOverrides[InstanceT], + signals map[string]gobject.SignalDefinition, + interfaceInits ...gobject.SubClassInterfaceInit[InstanceT], +) gobject.Type { + return gobject.UnsafeRegisterSubClass( + name, + classInit, + constructor, + overrides, + signals, + TypeAudioBaseSrc, + UnsafeAudioBaseSrcClassFromGlibBorrow, + UnsafeApplyAudioBaseSrcOverrides, + func (obj *gobject.ObjectInstance) gobject.Object { + return unsafeWrapAudioBaseSrc(obj) + }, + interfaceInits..., + ) +} + // AudioCdSrcInstance is the instance type used by all types extending GstAudioCdSrc. It is used internally by the bindings. Users should use the interface [AudioCdSrc] instead. type AudioCdSrcInstance struct { _ [0]func() // equal guard @@ -4597,17 +4837,92 @@ func UnsafeApplyAudioCdSrcOverrides[Instance AudioCdSrc](gclass unsafe.Pointer, if overrides.Close != nil { pclass.close = (*[0]byte)(C._gotk4_gstaudio1_AudioCdSrc_close) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstaudio1_AudioCdSrc_close", + func(carg0 *C.GstAudioCdSrc) { + var src Instance // go GstAudioCdSrc subclass + + src = UnsafeAudioCdSrcFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + overrides.Close(src) + }, + ) } if overrides.Open != nil { pclass.open = (*[0]byte)(C._gotk4_gstaudio1_AudioCdSrc_open) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstaudio1_AudioCdSrc_open", + func(carg0 *C.GstAudioCdSrc, carg1 *C.gchar) (cret C.gboolean) { + var src Instance // go GstAudioCdSrc subclass + var device string // in, none, string + var goret bool // return + + src = UnsafeAudioCdSrcFromGlibNone(unsafe.Pointer(carg0)).(Instance) + device = C.GoString((*C.char)(unsafe.Pointer(carg1))) + + goret = overrides.Open(src, device) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.ReadSector != nil { pclass.read_sector = (*[0]byte)(C._gotk4_gstaudio1_AudioCdSrc_read_sector) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstaudio1_AudioCdSrc_read_sector", + func(carg0 *C.GstAudioCdSrc, carg1 C.gint) (cret *C.GstBuffer) { + var src Instance // go GstAudioCdSrc subclass + var sector int // in, none, casted + var goret *gst.Buffer // return, full, converted + + src = UnsafeAudioCdSrcFromGlibNone(unsafe.Pointer(carg0)).(Instance) + sector = int(carg1) + + goret = overrides.ReadSector(src, sector) + + cret = (*C.GstBuffer)(gst.UnsafeBufferToGlibFull(goret)) + + return cret + }, + ) } } +// RegisterAudioCdSrcSubClass is used to register a go subclass of GstAudioCdSrc. For this to work safely please implement the +// virtual methods required by the implementation. +func RegisterAudioCdSrcSubClass[InstanceT AudioCdSrc]( + name string, + classInit func(class *AudioCdSrcClass), + constructor func() InstanceT, + overrides AudioCdSrcOverrides[InstanceT], + signals map[string]gobject.SignalDefinition, + interfaceInits ...gobject.SubClassInterfaceInit[InstanceT], +) gobject.Type { + return gobject.UnsafeRegisterSubClass( + name, + classInit, + constructor, + overrides, + signals, + TypeAudioCdSrc, + UnsafeAudioCdSrcClassFromGlibBorrow, + UnsafeApplyAudioCdSrcOverrides, + func (obj *gobject.ObjectInstance) gobject.Object { + return unsafeWrapAudioCdSrc(obj) + }, + interfaceInits..., + ) +} + // AudioClockInstance is the instance type used by all types extending GstAudioClock. It is used internally by the bindings. Users should use the interface [AudioClock] instead. type AudioClockInstance struct { _ [0]func() // equal guard @@ -4856,6 +5171,32 @@ func UnsafeApplyAudioClockOverrides[Instance AudioClock](gclass unsafe.Pointer, gst.UnsafeApplySystemClockOverrides(gclass, overrides.SystemClockOverrides) } +// RegisterAudioClockSubClass is used to register a go subclass of GstAudioClock. For this to work safely please implement the +// virtual methods required by the implementation. +func RegisterAudioClockSubClass[InstanceT AudioClock]( + name string, + classInit func(class *AudioClockClass), + constructor func() InstanceT, + overrides AudioClockOverrides[InstanceT], + signals map[string]gobject.SignalDefinition, + interfaceInits ...gobject.SubClassInterfaceInit[InstanceT], +) gobject.Type { + return gobject.UnsafeRegisterSubClass( + name, + classInit, + constructor, + overrides, + signals, + TypeAudioClock, + UnsafeAudioClockClassFromGlibBorrow, + UnsafeApplyAudioClockOverrides, + func (obj *gobject.ObjectInstance) gobject.Object { + return unsafeWrapAudioClock(obj) + }, + interfaceInits..., + ) +} + // AudioDecoderInstance is the instance type used by all types extending GstAudioDecoder. It is used internally by the bindings. Users should use the interface [AudioDecoder] instead. type AudioDecoderInstance struct { _ [0]func() // equal guard @@ -6364,73 +6705,426 @@ func UnsafeApplyAudioDecoderOverrides[Instance AudioDecoder](gclass unsafe.Point if overrides.Close != nil { pclass.close = (*[0]byte)(C._gotk4_gstaudio1_AudioDecoder_close) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstaudio1_AudioDecoder_close", + func(carg0 *C.GstAudioDecoder) (cret C.gboolean) { + var dec Instance // go GstAudioDecoder subclass + var goret bool // return + + dec = UnsafeAudioDecoderFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + goret = overrides.Close(dec) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.DecideAllocation != nil { pclass.decide_allocation = (*[0]byte)(C._gotk4_gstaudio1_AudioDecoder_decide_allocation) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstaudio1_AudioDecoder_decide_allocation", + func(carg0 *C.GstAudioDecoder, carg1 *C.GstQuery) (cret C.gboolean) { + var dec Instance // go GstAudioDecoder subclass + var query *gst.Query // in, none, converted + var goret bool // return + + dec = UnsafeAudioDecoderFromGlibNone(unsafe.Pointer(carg0)).(Instance) + query = gst.UnsafeQueryFromGlibNone(unsafe.Pointer(carg1)) + + goret = overrides.DecideAllocation(dec, query) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.Flush != nil { pclass.flush = (*[0]byte)(C._gotk4_gstaudio1_AudioDecoder_flush) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstaudio1_AudioDecoder_flush", + func(carg0 *C.GstAudioDecoder, carg1 C.gboolean) { + var dec Instance // go GstAudioDecoder subclass + var hard bool // in + + dec = UnsafeAudioDecoderFromGlibNone(unsafe.Pointer(carg0)).(Instance) + if carg1 != 0 { + hard = true + } + + overrides.Flush(dec, hard) + }, + ) } if overrides.Getcaps != nil { pclass.getcaps = (*[0]byte)(C._gotk4_gstaudio1_AudioDecoder_getcaps) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstaudio1_AudioDecoder_getcaps", + func(carg0 *C.GstAudioDecoder, carg1 *C.GstCaps) (cret *C.GstCaps) { + var dec Instance // go GstAudioDecoder subclass + var filter *gst.Caps // in, none, converted + var goret *gst.Caps // return, full, converted + + dec = UnsafeAudioDecoderFromGlibNone(unsafe.Pointer(carg0)).(Instance) + filter = gst.UnsafeCapsFromGlibNone(unsafe.Pointer(carg1)) + + goret = overrides.Getcaps(dec, filter) + + cret = (*C.GstCaps)(gst.UnsafeCapsToGlibFull(goret)) + + return cret + }, + ) } if overrides.HandleFrame != nil { pclass.handle_frame = (*[0]byte)(C._gotk4_gstaudio1_AudioDecoder_handle_frame) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstaudio1_AudioDecoder_handle_frame", + func(carg0 *C.GstAudioDecoder, carg1 *C.GstBuffer) (cret C.GstFlowReturn) { + var dec Instance // go GstAudioDecoder subclass + var buffer *gst.Buffer // in, none, converted + var goret gst.FlowReturn // return, none, casted + + dec = UnsafeAudioDecoderFromGlibNone(unsafe.Pointer(carg0)).(Instance) + buffer = gst.UnsafeBufferFromGlibNone(unsafe.Pointer(carg1)) + + goret = overrides.HandleFrame(dec, buffer) + + cret = C.GstFlowReturn(goret) + + return cret + }, + ) } if overrides.Negotiate != nil { pclass.negotiate = (*[0]byte)(C._gotk4_gstaudio1_AudioDecoder_negotiate) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstaudio1_AudioDecoder_negotiate", + func(carg0 *C.GstAudioDecoder) (cret C.gboolean) { + var dec Instance // go GstAudioDecoder subclass + var goret bool // return + + dec = UnsafeAudioDecoderFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + goret = overrides.Negotiate(dec) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.Open != nil { pclass.open = (*[0]byte)(C._gotk4_gstaudio1_AudioDecoder_open) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstaudio1_AudioDecoder_open", + func(carg0 *C.GstAudioDecoder) (cret C.gboolean) { + var dec Instance // go GstAudioDecoder subclass + var goret bool // return + + dec = UnsafeAudioDecoderFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + goret = overrides.Open(dec) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.Parse != nil { pclass.parse = (*[0]byte)(C._gotk4_gstaudio1_AudioDecoder_parse) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstaudio1_AudioDecoder_parse", + func(carg0 *C.GstAudioDecoder, carg1 *C.GstAdapter, carg2 *C.gint, carg3 *C.gint) (cret C.GstFlowReturn) { + var dec Instance // go GstAudioDecoder subclass + var adapter gstbase.Adapter // in, none, converted + var offset int // out, full, casted + var length int // out, full, casted + var goret gst.FlowReturn // return, none, casted + + dec = UnsafeAudioDecoderFromGlibNone(unsafe.Pointer(carg0)).(Instance) + adapter = gstbase.UnsafeAdapterFromGlibNone(unsafe.Pointer(carg1)) + + offset, length, goret = overrides.Parse(dec, adapter) + + *carg2 = C.gint(offset) + *carg3 = C.gint(length) + cret = C.GstFlowReturn(goret) + + return cret + }, + ) } if overrides.ProposeAllocation != nil { pclass.propose_allocation = (*[0]byte)(C._gotk4_gstaudio1_AudioDecoder_propose_allocation) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstaudio1_AudioDecoder_propose_allocation", + func(carg0 *C.GstAudioDecoder, carg1 *C.GstQuery) (cret C.gboolean) { + var dec Instance // go GstAudioDecoder subclass + var query *gst.Query // in, none, converted + var goret bool // return + + dec = UnsafeAudioDecoderFromGlibNone(unsafe.Pointer(carg0)).(Instance) + query = gst.UnsafeQueryFromGlibNone(unsafe.Pointer(carg1)) + + goret = overrides.ProposeAllocation(dec, query) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.SetFormat != nil { pclass.set_format = (*[0]byte)(C._gotk4_gstaudio1_AudioDecoder_set_format) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstaudio1_AudioDecoder_set_format", + func(carg0 *C.GstAudioDecoder, carg1 *C.GstCaps) (cret C.gboolean) { + var dec Instance // go GstAudioDecoder subclass + var caps *gst.Caps // in, none, converted + var goret bool // return + + dec = UnsafeAudioDecoderFromGlibNone(unsafe.Pointer(carg0)).(Instance) + caps = gst.UnsafeCapsFromGlibNone(unsafe.Pointer(carg1)) + + goret = overrides.SetFormat(dec, caps) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.SinkEvent != nil { pclass.sink_event = (*[0]byte)(C._gotk4_gstaudio1_AudioDecoder_sink_event) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstaudio1_AudioDecoder_sink_event", + func(carg0 *C.GstAudioDecoder, carg1 *C.GstEvent) (cret C.gboolean) { + var dec Instance // go GstAudioDecoder subclass + var event *gst.Event // in, none, converted + var goret bool // return + + dec = UnsafeAudioDecoderFromGlibNone(unsafe.Pointer(carg0)).(Instance) + event = gst.UnsafeEventFromGlibNone(unsafe.Pointer(carg1)) + + goret = overrides.SinkEvent(dec, event) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.SinkQuery != nil { pclass.sink_query = (*[0]byte)(C._gotk4_gstaudio1_AudioDecoder_sink_query) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstaudio1_AudioDecoder_sink_query", + func(carg0 *C.GstAudioDecoder, carg1 *C.GstQuery) (cret C.gboolean) { + var dec Instance // go GstAudioDecoder subclass + var query *gst.Query // in, none, converted + var goret bool // return + + dec = UnsafeAudioDecoderFromGlibNone(unsafe.Pointer(carg0)).(Instance) + query = gst.UnsafeQueryFromGlibNone(unsafe.Pointer(carg1)) + + goret = overrides.SinkQuery(dec, query) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.SrcEvent != nil { pclass.src_event = (*[0]byte)(C._gotk4_gstaudio1_AudioDecoder_src_event) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstaudio1_AudioDecoder_src_event", + func(carg0 *C.GstAudioDecoder, carg1 *C.GstEvent) (cret C.gboolean) { + var dec Instance // go GstAudioDecoder subclass + var event *gst.Event // in, none, converted + var goret bool // return + + dec = UnsafeAudioDecoderFromGlibNone(unsafe.Pointer(carg0)).(Instance) + event = gst.UnsafeEventFromGlibNone(unsafe.Pointer(carg1)) + + goret = overrides.SrcEvent(dec, event) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.SrcQuery != nil { pclass.src_query = (*[0]byte)(C._gotk4_gstaudio1_AudioDecoder_src_query) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstaudio1_AudioDecoder_src_query", + func(carg0 *C.GstAudioDecoder, carg1 *C.GstQuery) (cret C.gboolean) { + var dec Instance // go GstAudioDecoder subclass + var query *gst.Query // in, none, converted + var goret bool // return + + dec = UnsafeAudioDecoderFromGlibNone(unsafe.Pointer(carg0)).(Instance) + query = gst.UnsafeQueryFromGlibNone(unsafe.Pointer(carg1)) + + goret = overrides.SrcQuery(dec, query) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.Start != nil { pclass.start = (*[0]byte)(C._gotk4_gstaudio1_AudioDecoder_start) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstaudio1_AudioDecoder_start", + func(carg0 *C.GstAudioDecoder) (cret C.gboolean) { + var dec Instance // go GstAudioDecoder subclass + var goret bool // return + + dec = UnsafeAudioDecoderFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + goret = overrides.Start(dec) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.Stop != nil { pclass.stop = (*[0]byte)(C._gotk4_gstaudio1_AudioDecoder_stop) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstaudio1_AudioDecoder_stop", + func(carg0 *C.GstAudioDecoder) (cret C.gboolean) { + var dec Instance // go GstAudioDecoder subclass + var goret bool // return + + dec = UnsafeAudioDecoderFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + goret = overrides.Stop(dec) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.TransformMeta != nil { pclass.transform_meta = (*[0]byte)(C._gotk4_gstaudio1_AudioDecoder_transform_meta) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstaudio1_AudioDecoder_transform_meta", + func(carg0 *C.GstAudioDecoder, carg1 *C.GstBuffer, carg2 *C.GstMeta, carg3 *C.GstBuffer) (cret C.gboolean) { + var enc Instance // go GstAudioDecoder subclass + var outbuf *gst.Buffer // in, none, converted + var meta *gst.Meta // in, none, converted + var inbuf *gst.Buffer // in, none, converted + var goret bool // return + + enc = UnsafeAudioDecoderFromGlibNone(unsafe.Pointer(carg0)).(Instance) + outbuf = gst.UnsafeBufferFromGlibNone(unsafe.Pointer(carg1)) + meta = gst.UnsafeMetaFromGlibNone(unsafe.Pointer(carg2)) + inbuf = gst.UnsafeBufferFromGlibNone(unsafe.Pointer(carg3)) + + goret = overrides.TransformMeta(enc, outbuf, meta, inbuf) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } } +// RegisterAudioDecoderSubClass is used to register a go subclass of GstAudioDecoder. For this to work safely please implement the +// virtual methods required by the implementation. +func RegisterAudioDecoderSubClass[InstanceT AudioDecoder]( + name string, + classInit func(class *AudioDecoderClass), + constructor func() InstanceT, + overrides AudioDecoderOverrides[InstanceT], + signals map[string]gobject.SignalDefinition, + interfaceInits ...gobject.SubClassInterfaceInit[InstanceT], +) gobject.Type { + return gobject.UnsafeRegisterSubClass( + name, + classInit, + constructor, + overrides, + signals, + TypeAudioDecoder, + UnsafeAudioDecoderClassFromGlibBorrow, + UnsafeApplyAudioDecoderOverrides, + func (obj *gobject.ObjectInstance) gobject.Object { + return unsafeWrapAudioDecoder(obj) + }, + interfaceInits..., + ) +} + // AudioEncoderInstance is the instance type used by all types extending GstAudioEncoder. It is used internally by the bindings. Users should use the interface [AudioEncoder] instead. type AudioEncoderInstance struct { _ [0]func() // equal guard @@ -7854,69 +8548,396 @@ func UnsafeApplyAudioEncoderOverrides[Instance AudioEncoder](gclass unsafe.Point if overrides.Close != nil { pclass.close = (*[0]byte)(C._gotk4_gstaudio1_AudioEncoder_close) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstaudio1_AudioEncoder_close", + func(carg0 *C.GstAudioEncoder) (cret C.gboolean) { + var enc Instance // go GstAudioEncoder subclass + var goret bool // return + + enc = UnsafeAudioEncoderFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + goret = overrides.Close(enc) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.DecideAllocation != nil { pclass.decide_allocation = (*[0]byte)(C._gotk4_gstaudio1_AudioEncoder_decide_allocation) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstaudio1_AudioEncoder_decide_allocation", + func(carg0 *C.GstAudioEncoder, carg1 *C.GstQuery) (cret C.gboolean) { + var enc Instance // go GstAudioEncoder subclass + var query *gst.Query // in, none, converted + var goret bool // return + + enc = UnsafeAudioEncoderFromGlibNone(unsafe.Pointer(carg0)).(Instance) + query = gst.UnsafeQueryFromGlibNone(unsafe.Pointer(carg1)) + + goret = overrides.DecideAllocation(enc, query) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.Flush != nil { pclass.flush = (*[0]byte)(C._gotk4_gstaudio1_AudioEncoder_flush) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstaudio1_AudioEncoder_flush", + func(carg0 *C.GstAudioEncoder) { + var enc Instance // go GstAudioEncoder subclass + + enc = UnsafeAudioEncoderFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + overrides.Flush(enc) + }, + ) } if overrides.Getcaps != nil { pclass.getcaps = (*[0]byte)(C._gotk4_gstaudio1_AudioEncoder_getcaps) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstaudio1_AudioEncoder_getcaps", + func(carg0 *C.GstAudioEncoder, carg1 *C.GstCaps) (cret *C.GstCaps) { + var enc Instance // go GstAudioEncoder subclass + var filter *gst.Caps // in, none, converted + var goret *gst.Caps // return, full, converted + + enc = UnsafeAudioEncoderFromGlibNone(unsafe.Pointer(carg0)).(Instance) + filter = gst.UnsafeCapsFromGlibNone(unsafe.Pointer(carg1)) + + goret = overrides.Getcaps(enc, filter) + + cret = (*C.GstCaps)(gst.UnsafeCapsToGlibFull(goret)) + + return cret + }, + ) } if overrides.HandleFrame != nil { pclass.handle_frame = (*[0]byte)(C._gotk4_gstaudio1_AudioEncoder_handle_frame) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstaudio1_AudioEncoder_handle_frame", + func(carg0 *C.GstAudioEncoder, carg1 *C.GstBuffer) (cret C.GstFlowReturn) { + var enc Instance // go GstAudioEncoder subclass + var buffer *gst.Buffer // in, none, converted + var goret gst.FlowReturn // return, none, casted + + enc = UnsafeAudioEncoderFromGlibNone(unsafe.Pointer(carg0)).(Instance) + buffer = gst.UnsafeBufferFromGlibNone(unsafe.Pointer(carg1)) + + goret = overrides.HandleFrame(enc, buffer) + + cret = C.GstFlowReturn(goret) + + return cret + }, + ) } if overrides.Negotiate != nil { pclass.negotiate = (*[0]byte)(C._gotk4_gstaudio1_AudioEncoder_negotiate) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstaudio1_AudioEncoder_negotiate", + func(carg0 *C.GstAudioEncoder) (cret C.gboolean) { + var enc Instance // go GstAudioEncoder subclass + var goret bool // return + + enc = UnsafeAudioEncoderFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + goret = overrides.Negotiate(enc) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.Open != nil { pclass.open = (*[0]byte)(C._gotk4_gstaudio1_AudioEncoder_open) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstaudio1_AudioEncoder_open", + func(carg0 *C.GstAudioEncoder) (cret C.gboolean) { + var enc Instance // go GstAudioEncoder subclass + var goret bool // return + + enc = UnsafeAudioEncoderFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + goret = overrides.Open(enc) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.ProposeAllocation != nil { pclass.propose_allocation = (*[0]byte)(C._gotk4_gstaudio1_AudioEncoder_propose_allocation) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstaudio1_AudioEncoder_propose_allocation", + func(carg0 *C.GstAudioEncoder, carg1 *C.GstQuery) (cret C.gboolean) { + var enc Instance // go GstAudioEncoder subclass + var query *gst.Query // in, none, converted + var goret bool // return + + enc = UnsafeAudioEncoderFromGlibNone(unsafe.Pointer(carg0)).(Instance) + query = gst.UnsafeQueryFromGlibNone(unsafe.Pointer(carg1)) + + goret = overrides.ProposeAllocation(enc, query) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.SetFormat != nil { pclass.set_format = (*[0]byte)(C._gotk4_gstaudio1_AudioEncoder_set_format) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstaudio1_AudioEncoder_set_format", + func(carg0 *C.GstAudioEncoder, carg1 *C.GstAudioInfo) (cret C.gboolean) { + var enc Instance // go GstAudioEncoder subclass + var info *AudioInfo // in, none, converted + var goret bool // return + + enc = UnsafeAudioEncoderFromGlibNone(unsafe.Pointer(carg0)).(Instance) + info = UnsafeAudioInfoFromGlibNone(unsafe.Pointer(carg1)) + + goret = overrides.SetFormat(enc, info) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.SinkEvent != nil { pclass.sink_event = (*[0]byte)(C._gotk4_gstaudio1_AudioEncoder_sink_event) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstaudio1_AudioEncoder_sink_event", + func(carg0 *C.GstAudioEncoder, carg1 *C.GstEvent) (cret C.gboolean) { + var enc Instance // go GstAudioEncoder subclass + var event *gst.Event // in, none, converted + var goret bool // return + + enc = UnsafeAudioEncoderFromGlibNone(unsafe.Pointer(carg0)).(Instance) + event = gst.UnsafeEventFromGlibNone(unsafe.Pointer(carg1)) + + goret = overrides.SinkEvent(enc, event) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.SinkQuery != nil { pclass.sink_query = (*[0]byte)(C._gotk4_gstaudio1_AudioEncoder_sink_query) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstaudio1_AudioEncoder_sink_query", + func(carg0 *C.GstAudioEncoder, carg1 *C.GstQuery) (cret C.gboolean) { + var encoder Instance // go GstAudioEncoder subclass + var query *gst.Query // in, none, converted + var goret bool // return + + encoder = UnsafeAudioEncoderFromGlibNone(unsafe.Pointer(carg0)).(Instance) + query = gst.UnsafeQueryFromGlibNone(unsafe.Pointer(carg1)) + + goret = overrides.SinkQuery(encoder, query) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.SrcEvent != nil { pclass.src_event = (*[0]byte)(C._gotk4_gstaudio1_AudioEncoder_src_event) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstaudio1_AudioEncoder_src_event", + func(carg0 *C.GstAudioEncoder, carg1 *C.GstEvent) (cret C.gboolean) { + var enc Instance // go GstAudioEncoder subclass + var event *gst.Event // in, none, converted + var goret bool // return + + enc = UnsafeAudioEncoderFromGlibNone(unsafe.Pointer(carg0)).(Instance) + event = gst.UnsafeEventFromGlibNone(unsafe.Pointer(carg1)) + + goret = overrides.SrcEvent(enc, event) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.SrcQuery != nil { pclass.src_query = (*[0]byte)(C._gotk4_gstaudio1_AudioEncoder_src_query) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstaudio1_AudioEncoder_src_query", + func(carg0 *C.GstAudioEncoder, carg1 *C.GstQuery) (cret C.gboolean) { + var encoder Instance // go GstAudioEncoder subclass + var query *gst.Query // in, none, converted + var goret bool // return + + encoder = UnsafeAudioEncoderFromGlibNone(unsafe.Pointer(carg0)).(Instance) + query = gst.UnsafeQueryFromGlibNone(unsafe.Pointer(carg1)) + + goret = overrides.SrcQuery(encoder, query) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.Start != nil { pclass.start = (*[0]byte)(C._gotk4_gstaudio1_AudioEncoder_start) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstaudio1_AudioEncoder_start", + func(carg0 *C.GstAudioEncoder) (cret C.gboolean) { + var enc Instance // go GstAudioEncoder subclass + var goret bool // return + + enc = UnsafeAudioEncoderFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + goret = overrides.Start(enc) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.Stop != nil { pclass.stop = (*[0]byte)(C._gotk4_gstaudio1_AudioEncoder_stop) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstaudio1_AudioEncoder_stop", + func(carg0 *C.GstAudioEncoder) (cret C.gboolean) { + var enc Instance // go GstAudioEncoder subclass + var goret bool // return + + enc = UnsafeAudioEncoderFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + goret = overrides.Stop(enc) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.TransformMeta != nil { pclass.transform_meta = (*[0]byte)(C._gotk4_gstaudio1_AudioEncoder_transform_meta) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstaudio1_AudioEncoder_transform_meta", + func(carg0 *C.GstAudioEncoder, carg1 *C.GstBuffer, carg2 *C.GstMeta, carg3 *C.GstBuffer) (cret C.gboolean) { + var enc Instance // go GstAudioEncoder subclass + var outbuf *gst.Buffer // in, none, converted + var meta *gst.Meta // in, none, converted + var inbuf *gst.Buffer // in, none, converted + var goret bool // return + + enc = UnsafeAudioEncoderFromGlibNone(unsafe.Pointer(carg0)).(Instance) + outbuf = gst.UnsafeBufferFromGlibNone(unsafe.Pointer(carg1)) + meta = gst.UnsafeMetaFromGlibNone(unsafe.Pointer(carg2)) + inbuf = gst.UnsafeBufferFromGlibNone(unsafe.Pointer(carg3)) + + goret = overrides.TransformMeta(enc, outbuf, meta, inbuf) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } } +// RegisterAudioEncoderSubClass is used to register a go subclass of GstAudioEncoder. For this to work safely please implement the +// virtual methods required by the implementation. +func RegisterAudioEncoderSubClass[InstanceT AudioEncoder]( + name string, + classInit func(class *AudioEncoderClass), + constructor func() InstanceT, + overrides AudioEncoderOverrides[InstanceT], + signals map[string]gobject.SignalDefinition, + interfaceInits ...gobject.SubClassInterfaceInit[InstanceT], +) gobject.Type { + return gobject.UnsafeRegisterSubClass( + name, + classInit, + constructor, + overrides, + signals, + TypeAudioEncoder, + UnsafeAudioEncoderClassFromGlibBorrow, + UnsafeApplyAudioEncoderOverrides, + func (obj *gobject.ObjectInstance) gobject.Object { + return unsafeWrapAudioEncoder(obj) + }, + interfaceInits..., + ) +} + // AudioFilterInstance is the instance type used by all types extending GstAudioFilter. It is used internally by the bindings. Users should use the interface [AudioFilter] instead. type AudioFilterInstance struct { _ [0]func() // equal guard @@ -8013,9 +9034,55 @@ func UnsafeApplyAudioFilterOverrides[Instance AudioFilter](gclass unsafe.Pointer if overrides.Setup != nil { pclass.setup = (*[0]byte)(C._gotk4_gstaudio1_AudioFilter_setup) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstaudio1_AudioFilter_setup", + func(carg0 *C.GstAudioFilter, carg1 *C.GstAudioInfo) (cret C.gboolean) { + var filter Instance // go GstAudioFilter subclass + var info *AudioInfo // in, none, converted + var goret bool // return + + filter = UnsafeAudioFilterFromGlibNone(unsafe.Pointer(carg0)).(Instance) + info = UnsafeAudioInfoFromGlibNone(unsafe.Pointer(carg1)) + + goret = overrides.Setup(filter, info) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } } +// RegisterAudioFilterSubClass is used to register a go subclass of GstAudioFilter. For this to work safely please implement the +// virtual methods required by the implementation. +func RegisterAudioFilterSubClass[InstanceT AudioFilter]( + name string, + classInit func(class *AudioFilterClass), + constructor func() InstanceT, + overrides AudioFilterOverrides[InstanceT], + signals map[string]gobject.SignalDefinition, + interfaceInits ...gobject.SubClassInterfaceInit[InstanceT], +) gobject.Type { + return gobject.UnsafeRegisterSubClass( + name, + classInit, + constructor, + overrides, + signals, + TypeAudioFilter, + UnsafeAudioFilterClassFromGlibBorrow, + UnsafeApplyAudioFilterOverrides, + func (obj *gobject.ObjectInstance) gobject.Object { + return unsafeWrapAudioFilter(obj) + }, + interfaceInits..., + ) +} + // AudioRingBufferInstance is the instance type used by all types extending GstAudioRingBuffer. It is used internally by the bindings. Users should use the interface [AudioRingBuffer] instead. type AudioRingBufferInstance struct { _ [0]func() // equal guard @@ -9161,49 +10228,270 @@ func UnsafeApplyAudioRingBufferOverrides[Instance AudioRingBuffer](gclass unsafe if overrides.Acquire != nil { pclass.acquire = (*[0]byte)(C._gotk4_gstaudio1_AudioRingBuffer_acquire) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstaudio1_AudioRingBuffer_acquire", + func(carg0 *C.GstAudioRingBuffer, carg1 *C.GstAudioRingBufferSpec) (cret C.gboolean) { + var buf Instance // go GstAudioRingBuffer subclass + var spec *AudioRingBufferSpec // in, none, converted + var goret bool // return + + buf = UnsafeAudioRingBufferFromGlibNone(unsafe.Pointer(carg0)).(Instance) + spec = UnsafeAudioRingBufferSpecFromGlibNone(unsafe.Pointer(carg1)) + + goret = overrides.Acquire(buf, spec) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.Activate != nil { pclass.activate = (*[0]byte)(C._gotk4_gstaudio1_AudioRingBuffer_activate) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstaudio1_AudioRingBuffer_activate", + func(carg0 *C.GstAudioRingBuffer, carg1 C.gboolean) (cret C.gboolean) { + var buf Instance // go GstAudioRingBuffer subclass + var active bool // in + var goret bool // return + + buf = UnsafeAudioRingBufferFromGlibNone(unsafe.Pointer(carg0)).(Instance) + if carg1 != 0 { + active = true + } + + goret = overrides.Activate(buf, active) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.ClearAll != nil { pclass.clear_all = (*[0]byte)(C._gotk4_gstaudio1_AudioRingBuffer_clear_all) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstaudio1_AudioRingBuffer_clear_all", + func(carg0 *C.GstAudioRingBuffer) { + var buf Instance // go GstAudioRingBuffer subclass + + buf = UnsafeAudioRingBufferFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + overrides.ClearAll(buf) + }, + ) } if overrides.CloseDevice != nil { pclass.close_device = (*[0]byte)(C._gotk4_gstaudio1_AudioRingBuffer_close_device) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstaudio1_AudioRingBuffer_close_device", + func(carg0 *C.GstAudioRingBuffer) (cret C.gboolean) { + var buf Instance // go GstAudioRingBuffer subclass + var goret bool // return + + buf = UnsafeAudioRingBufferFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + goret = overrides.CloseDevice(buf) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.Delay != nil { pclass.delay = (*[0]byte)(C._gotk4_gstaudio1_AudioRingBuffer_delay) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstaudio1_AudioRingBuffer_delay", + func(carg0 *C.GstAudioRingBuffer) (cret C.guint) { + var buf Instance // go GstAudioRingBuffer subclass + var goret uint // return, none, casted + + buf = UnsafeAudioRingBufferFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + goret = overrides.Delay(buf) + + cret = C.guint(goret) + + return cret + }, + ) } if overrides.OpenDevice != nil { pclass.open_device = (*[0]byte)(C._gotk4_gstaudio1_AudioRingBuffer_open_device) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstaudio1_AudioRingBuffer_open_device", + func(carg0 *C.GstAudioRingBuffer) (cret C.gboolean) { + var buf Instance // go GstAudioRingBuffer subclass + var goret bool // return + + buf = UnsafeAudioRingBufferFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + goret = overrides.OpenDevice(buf) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.Pause != nil { pclass.pause = (*[0]byte)(C._gotk4_gstaudio1_AudioRingBuffer_pause) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstaudio1_AudioRingBuffer_pause", + func(carg0 *C.GstAudioRingBuffer) (cret C.gboolean) { + var buf Instance // go GstAudioRingBuffer subclass + var goret bool // return + + buf = UnsafeAudioRingBufferFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + goret = overrides.Pause(buf) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.Release != nil { pclass.release = (*[0]byte)(C._gotk4_gstaudio1_AudioRingBuffer_release) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstaudio1_AudioRingBuffer_release", + func(carg0 *C.GstAudioRingBuffer) (cret C.gboolean) { + var buf Instance // go GstAudioRingBuffer subclass + var goret bool // return + + buf = UnsafeAudioRingBufferFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + goret = overrides.Release(buf) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.Resume != nil { pclass.resume = (*[0]byte)(C._gotk4_gstaudio1_AudioRingBuffer_resume) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstaudio1_AudioRingBuffer_resume", + func(carg0 *C.GstAudioRingBuffer) (cret C.gboolean) { + var buf Instance // go GstAudioRingBuffer subclass + var goret bool // return + + buf = UnsafeAudioRingBufferFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + goret = overrides.Resume(buf) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.Start != nil { pclass.start = (*[0]byte)(C._gotk4_gstaudio1_AudioRingBuffer_start) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstaudio1_AudioRingBuffer_start", + func(carg0 *C.GstAudioRingBuffer) (cret C.gboolean) { + var buf Instance // go GstAudioRingBuffer subclass + var goret bool // return + + buf = UnsafeAudioRingBufferFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + goret = overrides.Start(buf) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.Stop != nil { pclass.stop = (*[0]byte)(C._gotk4_gstaudio1_AudioRingBuffer_stop) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstaudio1_AudioRingBuffer_stop", + func(carg0 *C.GstAudioRingBuffer) (cret C.gboolean) { + var buf Instance // go GstAudioRingBuffer subclass + var goret bool // return + + buf = UnsafeAudioRingBufferFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + goret = overrides.Stop(buf) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } } +// RegisterAudioRingBufferSubClass is used to register a go subclass of GstAudioRingBuffer. For this to work safely please implement the +// virtual methods required by the implementation. +func RegisterAudioRingBufferSubClass[InstanceT AudioRingBuffer]( + name string, + classInit func(class *AudioRingBufferClass), + constructor func() InstanceT, + overrides AudioRingBufferOverrides[InstanceT], + signals map[string]gobject.SignalDefinition, + interfaceInits ...gobject.SubClassInterfaceInit[InstanceT], +) gobject.Type { + return gobject.UnsafeRegisterSubClass( + name, + classInit, + constructor, + overrides, + signals, + TypeAudioRingBuffer, + UnsafeAudioRingBufferClassFromGlibBorrow, + UnsafeApplyAudioRingBufferOverrides, + func (obj *gobject.ObjectInstance) gobject.Object { + return unsafeWrapAudioRingBuffer(obj) + }, + interfaceInits..., + ) +} + // AudioSinkInstance is the instance type used by all types extending GstAudioSink. It is used internally by the bindings. Users should use the interface [AudioSink] instead. type AudioSinkInstance struct { _ [0]func() // equal guard @@ -9338,41 +10626,201 @@ func UnsafeApplyAudioSinkOverrides[Instance AudioSink](gclass unsafe.Pointer, ov if overrides.Close != nil { pclass.close = (*[0]byte)(C._gotk4_gstaudio1_AudioSink_close) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstaudio1_AudioSink_close", + func(carg0 *C.GstAudioSink) (cret C.gboolean) { + var sink Instance // go GstAudioSink subclass + var goret bool // return + + sink = UnsafeAudioSinkFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + goret = overrides.Close(sink) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.Delay != nil { pclass.delay = (*[0]byte)(C._gotk4_gstaudio1_AudioSink_delay) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstaudio1_AudioSink_delay", + func(carg0 *C.GstAudioSink) (cret C.guint) { + var sink Instance // go GstAudioSink subclass + var goret uint // return, none, casted + + sink = UnsafeAudioSinkFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + goret = overrides.Delay(sink) + + cret = C.guint(goret) + + return cret + }, + ) } if overrides.Open != nil { pclass.open = (*[0]byte)(C._gotk4_gstaudio1_AudioSink_open) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstaudio1_AudioSink_open", + func(carg0 *C.GstAudioSink) (cret C.gboolean) { + var sink Instance // go GstAudioSink subclass + var goret bool // return + + sink = UnsafeAudioSinkFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + goret = overrides.Open(sink) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.Pause != nil { pclass.pause = (*[0]byte)(C._gotk4_gstaudio1_AudioSink_pause) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstaudio1_AudioSink_pause", + func(carg0 *C.GstAudioSink) { + var sink Instance // go GstAudioSink subclass + + sink = UnsafeAudioSinkFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + overrides.Pause(sink) + }, + ) } if overrides.Prepare != nil { pclass.prepare = (*[0]byte)(C._gotk4_gstaudio1_AudioSink_prepare) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstaudio1_AudioSink_prepare", + func(carg0 *C.GstAudioSink, carg1 *C.GstAudioRingBufferSpec) (cret C.gboolean) { + var sink Instance // go GstAudioSink subclass + var spec *AudioRingBufferSpec // in, none, converted + var goret bool // return + + sink = UnsafeAudioSinkFromGlibNone(unsafe.Pointer(carg0)).(Instance) + spec = UnsafeAudioRingBufferSpecFromGlibNone(unsafe.Pointer(carg1)) + + goret = overrides.Prepare(sink, spec) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.Reset != nil { pclass.reset = (*[0]byte)(C._gotk4_gstaudio1_AudioSink_reset) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstaudio1_AudioSink_reset", + func(carg0 *C.GstAudioSink) { + var sink Instance // go GstAudioSink subclass + + sink = UnsafeAudioSinkFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + overrides.Reset(sink) + }, + ) } if overrides.Resume != nil { pclass.resume = (*[0]byte)(C._gotk4_gstaudio1_AudioSink_resume) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstaudio1_AudioSink_resume", + func(carg0 *C.GstAudioSink) { + var sink Instance // go GstAudioSink subclass + + sink = UnsafeAudioSinkFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + overrides.Resume(sink) + }, + ) } if overrides.Stop != nil { pclass.stop = (*[0]byte)(C._gotk4_gstaudio1_AudioSink_stop) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstaudio1_AudioSink_stop", + func(carg0 *C.GstAudioSink) { + var sink Instance // go GstAudioSink subclass + + sink = UnsafeAudioSinkFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + overrides.Stop(sink) + }, + ) } if overrides.Unprepare != nil { pclass.unprepare = (*[0]byte)(C._gotk4_gstaudio1_AudioSink_unprepare) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstaudio1_AudioSink_unprepare", + func(carg0 *C.GstAudioSink) (cret C.gboolean) { + var sink Instance // go GstAudioSink subclass + var goret bool // return + + sink = UnsafeAudioSinkFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + goret = overrides.Unprepare(sink) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } } +// RegisterAudioSinkSubClass is used to register a go subclass of GstAudioSink. For this to work safely please implement the +// virtual methods required by the implementation. +func RegisterAudioSinkSubClass[InstanceT AudioSink]( + name string, + classInit func(class *AudioSinkClass), + constructor func() InstanceT, + overrides AudioSinkOverrides[InstanceT], + signals map[string]gobject.SignalDefinition, + interfaceInits ...gobject.SubClassInterfaceInit[InstanceT], +) gobject.Type { + return gobject.UnsafeRegisterSubClass( + name, + classInit, + constructor, + overrides, + signals, + TypeAudioSink, + UnsafeAudioSinkClassFromGlibBorrow, + UnsafeApplyAudioSinkOverrides, + func (obj *gobject.ObjectInstance) gobject.Object { + return unsafeWrapAudioSink(obj) + }, + interfaceInits..., + ) +} + // AudioSrcInstance is the instance type used by all types extending GstAudioSrc. It is used internally by the bindings. Users should use the interface [AudioSrc] instead. type AudioSrcInstance struct { _ [0]func() // equal guard @@ -9496,29 +10944,156 @@ func UnsafeApplyAudioSrcOverrides[Instance AudioSrc](gclass unsafe.Pointer, over if overrides.Close != nil { pclass.close = (*[0]byte)(C._gotk4_gstaudio1_AudioSrc_close) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstaudio1_AudioSrc_close", + func(carg0 *C.GstAudioSrc) (cret C.gboolean) { + var src Instance // go GstAudioSrc subclass + var goret bool // return + + src = UnsafeAudioSrcFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + goret = overrides.Close(src) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.Delay != nil { pclass.delay = (*[0]byte)(C._gotk4_gstaudio1_AudioSrc_delay) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstaudio1_AudioSrc_delay", + func(carg0 *C.GstAudioSrc) (cret C.guint) { + var src Instance // go GstAudioSrc subclass + var goret uint // return, none, casted + + src = UnsafeAudioSrcFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + goret = overrides.Delay(src) + + cret = C.guint(goret) + + return cret + }, + ) } if overrides.Open != nil { pclass.open = (*[0]byte)(C._gotk4_gstaudio1_AudioSrc_open) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstaudio1_AudioSrc_open", + func(carg0 *C.GstAudioSrc) (cret C.gboolean) { + var src Instance // go GstAudioSrc subclass + var goret bool // return + + src = UnsafeAudioSrcFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + goret = overrides.Open(src) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.Prepare != nil { pclass.prepare = (*[0]byte)(C._gotk4_gstaudio1_AudioSrc_prepare) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstaudio1_AudioSrc_prepare", + func(carg0 *C.GstAudioSrc, carg1 *C.GstAudioRingBufferSpec) (cret C.gboolean) { + var src Instance // go GstAudioSrc subclass + var spec *AudioRingBufferSpec // in, none, converted + var goret bool // return + + src = UnsafeAudioSrcFromGlibNone(unsafe.Pointer(carg0)).(Instance) + spec = UnsafeAudioRingBufferSpecFromGlibNone(unsafe.Pointer(carg1)) + + goret = overrides.Prepare(src, spec) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.Reset != nil { pclass.reset = (*[0]byte)(C._gotk4_gstaudio1_AudioSrc_reset) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstaudio1_AudioSrc_reset", + func(carg0 *C.GstAudioSrc) { + var src Instance // go GstAudioSrc subclass + + src = UnsafeAudioSrcFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + overrides.Reset(src) + }, + ) } if overrides.Unprepare != nil { pclass.unprepare = (*[0]byte)(C._gotk4_gstaudio1_AudioSrc_unprepare) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstaudio1_AudioSrc_unprepare", + func(carg0 *C.GstAudioSrc) (cret C.gboolean) { + var src Instance // go GstAudioSrc subclass + var goret bool // return + + src = UnsafeAudioSrcFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + goret = overrides.Unprepare(src) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } } +// RegisterAudioSrcSubClass is used to register a go subclass of GstAudioSrc. For this to work safely please implement the +// virtual methods required by the implementation. +func RegisterAudioSrcSubClass[InstanceT AudioSrc]( + name string, + classInit func(class *AudioSrcClass), + constructor func() InstanceT, + overrides AudioSrcOverrides[InstanceT], + signals map[string]gobject.SignalDefinition, + interfaceInits ...gobject.SubClassInterfaceInit[InstanceT], +) gobject.Type { + return gobject.UnsafeRegisterSubClass( + name, + classInit, + constructor, + overrides, + signals, + TypeAudioSrc, + UnsafeAudioSrcClassFromGlibBorrow, + UnsafeApplyAudioSrcOverrides, + func (obj *gobject.ObjectInstance) gobject.Object { + return unsafeWrapAudioSrc(obj) + }, + interfaceInits..., + ) +} + // AudioAggregatorConvertPadInstance is the instance type used by all types extending GstAudioAggregatorConvertPad. It is used internally by the bindings. Users should use the interface [AudioAggregatorConvertPad] instead. type AudioAggregatorConvertPadInstance struct { _ [0]func() // equal guard @@ -9595,6 +11170,32 @@ func UnsafeApplyAudioAggregatorConvertPadOverrides[Instance AudioAggregatorConve UnsafeApplyAudioAggregatorPadOverrides(gclass, overrides.AudioAggregatorPadOverrides) } +// RegisterAudioAggregatorConvertPadSubClass is used to register a go subclass of GstAudioAggregatorConvertPad. For this to work safely please implement the +// virtual methods required by the implementation. +func RegisterAudioAggregatorConvertPadSubClass[InstanceT AudioAggregatorConvertPad]( + name string, + classInit func(class *AudioAggregatorConvertPadClass), + constructor func() InstanceT, + overrides AudioAggregatorConvertPadOverrides[InstanceT], + signals map[string]gobject.SignalDefinition, + interfaceInits ...gobject.SubClassInterfaceInit[InstanceT], +) gobject.Type { + return gobject.UnsafeRegisterSubClass( + name, + classInit, + constructor, + overrides, + signals, + TypeAudioAggregatorConvertPad, + UnsafeAudioAggregatorConvertPadClassFromGlibBorrow, + UnsafeApplyAudioAggregatorConvertPadOverrides, + func (obj *gobject.ObjectInstance) gobject.Object { + return unsafeWrapAudioAggregatorConvertPad(obj) + }, + interfaceInits..., + ) +} + // AudioAggregatorClass wraps GstAudioAggregatorClass // // AudioAggregatorClass is the type struct for [AudioAggregator] diff --git a/pkg/gstaudio/gstaudio_export.gen.go b/pkg/gstaudio/gstaudio_export.gen.go index de8f6cd..e3e12d9 100644 --- a/pkg/gstaudio/gstaudio_export.gen.go +++ b/pkg/gstaudio/gstaudio_export.gen.go @@ -5,6 +5,7 @@ package gstaudio import ( "unsafe" + "github.com/diamondburned/gotk4/pkg/core/classdata" "github.com/diamondburned/gotk4/pkg/core/userdata" "github.com/go-gst/go-gst/pkg/gst" ) @@ -88,351 +89,841 @@ func _gotk4_gstaudio1_AudioRingBufferCallback(carg1 *C.GstAudioRingBuffer, carg2 //export _gotk4_gstaudio1_AudioAggregator_aggregate_one_buffer func _gotk4_gstaudio1_AudioAggregator_aggregate_one_buffer(carg0 *C.GstAudioAggregator, carg1 *C.GstAudioAggregatorPad, carg2 *C.GstBuffer, carg3 C.guint, carg4 *C.GstBuffer, carg5 C.guint, carg6 C.guint) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstAudioAggregator, carg1 *C.GstAudioAggregatorPad, carg2 *C.GstBuffer, carg3 C.guint, carg4 *C.GstBuffer, carg5 C.guint, carg6 C.guint) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstaudio1_AudioAggregator_aggregate_one_buffer").(func(carg0 *C.GstAudioAggregator, carg1 *C.GstAudioAggregatorPad, carg2 *C.GstBuffer, carg3 C.guint, carg4 *C.GstBuffer, carg5 C.guint, carg6 C.guint) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstaudio1_AudioAggregator_aggregate_one_buffer: no function pointer found") + } + } + return fn(carg0, carg1, carg2, carg3, carg4, carg5, carg6) } //export _gotk4_gstaudio1_AudioAggregator_create_output_buffer func _gotk4_gstaudio1_AudioAggregator_create_output_buffer(carg0 *C.GstAudioAggregator, carg1 C.guint) (cret *C.GstBuffer) { - panic("unimplemented") + var fn func(carg0 *C.GstAudioAggregator, carg1 C.guint) (cret *C.GstBuffer) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstaudio1_AudioAggregator_create_output_buffer").(func(carg0 *C.GstAudioAggregator, carg1 C.guint) (cret *C.GstBuffer)) + if fn == nil { + panic("_gotk4_gstaudio1_AudioAggregator_create_output_buffer: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstaudio1_AudioAggregatorPad_convert_buffer func _gotk4_gstaudio1_AudioAggregatorPad_convert_buffer(carg0 *C.GstAudioAggregatorPad, carg1 *C.GstAudioInfo, carg2 *C.GstAudioInfo, carg3 *C.GstBuffer) (cret *C.GstBuffer) { - panic("unimplemented") + var fn func(carg0 *C.GstAudioAggregatorPad, carg1 *C.GstAudioInfo, carg2 *C.GstAudioInfo, carg3 *C.GstBuffer) (cret *C.GstBuffer) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstaudio1_AudioAggregatorPad_convert_buffer").(func(carg0 *C.GstAudioAggregatorPad, carg1 *C.GstAudioInfo, carg2 *C.GstAudioInfo, carg3 *C.GstBuffer) (cret *C.GstBuffer)) + if fn == nil { + panic("_gotk4_gstaudio1_AudioAggregatorPad_convert_buffer: no function pointer found") + } + } + return fn(carg0, carg1, carg2, carg3) } //export _gotk4_gstaudio1_AudioAggregatorPad_update_conversion_info func _gotk4_gstaudio1_AudioAggregatorPad_update_conversion_info(carg0 *C.GstAudioAggregatorPad) { - panic("unimplemented") + var fn func(carg0 *C.GstAudioAggregatorPad) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstaudio1_AudioAggregatorPad_update_conversion_info").(func(carg0 *C.GstAudioAggregatorPad)) + if fn == nil { + panic("_gotk4_gstaudio1_AudioAggregatorPad_update_conversion_info: no function pointer found") + } + } + fn(carg0) } //export _gotk4_gstaudio1_AudioBaseSink_create_ringbuffer func _gotk4_gstaudio1_AudioBaseSink_create_ringbuffer(carg0 *C.GstAudioBaseSink) (cret *C.GstAudioRingBuffer) { - panic("unimplemented") + var fn func(carg0 *C.GstAudioBaseSink) (cret *C.GstAudioRingBuffer) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstaudio1_AudioBaseSink_create_ringbuffer").(func(carg0 *C.GstAudioBaseSink) (cret *C.GstAudioRingBuffer)) + if fn == nil { + panic("_gotk4_gstaudio1_AudioBaseSink_create_ringbuffer: no function pointer found") + } + } + return fn(carg0) } //export _gotk4_gstaudio1_AudioBaseSink_payload func _gotk4_gstaudio1_AudioBaseSink_payload(carg0 *C.GstAudioBaseSink, carg1 *C.GstBuffer) (cret *C.GstBuffer) { - panic("unimplemented") + var fn func(carg0 *C.GstAudioBaseSink, carg1 *C.GstBuffer) (cret *C.GstBuffer) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstaudio1_AudioBaseSink_payload").(func(carg0 *C.GstAudioBaseSink, carg1 *C.GstBuffer) (cret *C.GstBuffer)) + if fn == nil { + panic("_gotk4_gstaudio1_AudioBaseSink_payload: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstaudio1_AudioBaseSrc_create_ringbuffer func _gotk4_gstaudio1_AudioBaseSrc_create_ringbuffer(carg0 *C.GstAudioBaseSrc) (cret *C.GstAudioRingBuffer) { - panic("unimplemented") + var fn func(carg0 *C.GstAudioBaseSrc) (cret *C.GstAudioRingBuffer) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstaudio1_AudioBaseSrc_create_ringbuffer").(func(carg0 *C.GstAudioBaseSrc) (cret *C.GstAudioRingBuffer)) + if fn == nil { + panic("_gotk4_gstaudio1_AudioBaseSrc_create_ringbuffer: no function pointer found") + } + } + return fn(carg0) } //export _gotk4_gstaudio1_AudioCdSrc_close func _gotk4_gstaudio1_AudioCdSrc_close(carg0 *C.GstAudioCdSrc) { - panic("unimplemented") + var fn func(carg0 *C.GstAudioCdSrc) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstaudio1_AudioCdSrc_close").(func(carg0 *C.GstAudioCdSrc)) + if fn == nil { + panic("_gotk4_gstaudio1_AudioCdSrc_close: no function pointer found") + } + } + fn(carg0) } //export _gotk4_gstaudio1_AudioCdSrc_open func _gotk4_gstaudio1_AudioCdSrc_open(carg0 *C.GstAudioCdSrc, carg1 *C.gchar) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstAudioCdSrc, carg1 *C.gchar) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstaudio1_AudioCdSrc_open").(func(carg0 *C.GstAudioCdSrc, carg1 *C.gchar) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstaudio1_AudioCdSrc_open: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstaudio1_AudioCdSrc_read_sector func _gotk4_gstaudio1_AudioCdSrc_read_sector(carg0 *C.GstAudioCdSrc, carg1 C.gint) (cret *C.GstBuffer) { - panic("unimplemented") + var fn func(carg0 *C.GstAudioCdSrc, carg1 C.gint) (cret *C.GstBuffer) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstaudio1_AudioCdSrc_read_sector").(func(carg0 *C.GstAudioCdSrc, carg1 C.gint) (cret *C.GstBuffer)) + if fn == nil { + panic("_gotk4_gstaudio1_AudioCdSrc_read_sector: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstaudio1_AudioDecoder_close func _gotk4_gstaudio1_AudioDecoder_close(carg0 *C.GstAudioDecoder) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstAudioDecoder) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstaudio1_AudioDecoder_close").(func(carg0 *C.GstAudioDecoder) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstaudio1_AudioDecoder_close: no function pointer found") + } + } + return fn(carg0) } //export _gotk4_gstaudio1_AudioDecoder_decide_allocation func _gotk4_gstaudio1_AudioDecoder_decide_allocation(carg0 *C.GstAudioDecoder, carg1 *C.GstQuery) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstAudioDecoder, carg1 *C.GstQuery) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstaudio1_AudioDecoder_decide_allocation").(func(carg0 *C.GstAudioDecoder, carg1 *C.GstQuery) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstaudio1_AudioDecoder_decide_allocation: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstaudio1_AudioDecoder_flush func _gotk4_gstaudio1_AudioDecoder_flush(carg0 *C.GstAudioDecoder, carg1 C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstAudioDecoder, carg1 C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstaudio1_AudioDecoder_flush").(func(carg0 *C.GstAudioDecoder, carg1 C.gboolean)) + if fn == nil { + panic("_gotk4_gstaudio1_AudioDecoder_flush: no function pointer found") + } + } + fn(carg0, carg1) } //export _gotk4_gstaudio1_AudioDecoder_getcaps func _gotk4_gstaudio1_AudioDecoder_getcaps(carg0 *C.GstAudioDecoder, carg1 *C.GstCaps) (cret *C.GstCaps) { - panic("unimplemented") + var fn func(carg0 *C.GstAudioDecoder, carg1 *C.GstCaps) (cret *C.GstCaps) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstaudio1_AudioDecoder_getcaps").(func(carg0 *C.GstAudioDecoder, carg1 *C.GstCaps) (cret *C.GstCaps)) + if fn == nil { + panic("_gotk4_gstaudio1_AudioDecoder_getcaps: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstaudio1_AudioDecoder_handle_frame func _gotk4_gstaudio1_AudioDecoder_handle_frame(carg0 *C.GstAudioDecoder, carg1 *C.GstBuffer) (cret C.GstFlowReturn) { - panic("unimplemented") + var fn func(carg0 *C.GstAudioDecoder, carg1 *C.GstBuffer) (cret C.GstFlowReturn) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstaudio1_AudioDecoder_handle_frame").(func(carg0 *C.GstAudioDecoder, carg1 *C.GstBuffer) (cret C.GstFlowReturn)) + if fn == nil { + panic("_gotk4_gstaudio1_AudioDecoder_handle_frame: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstaudio1_AudioDecoder_negotiate func _gotk4_gstaudio1_AudioDecoder_negotiate(carg0 *C.GstAudioDecoder) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstAudioDecoder) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstaudio1_AudioDecoder_negotiate").(func(carg0 *C.GstAudioDecoder) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstaudio1_AudioDecoder_negotiate: no function pointer found") + } + } + return fn(carg0) } //export _gotk4_gstaudio1_AudioDecoder_open func _gotk4_gstaudio1_AudioDecoder_open(carg0 *C.GstAudioDecoder) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstAudioDecoder) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstaudio1_AudioDecoder_open").(func(carg0 *C.GstAudioDecoder) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstaudio1_AudioDecoder_open: no function pointer found") + } + } + return fn(carg0) } //export _gotk4_gstaudio1_AudioDecoder_parse func _gotk4_gstaudio1_AudioDecoder_parse(carg0 *C.GstAudioDecoder, carg1 *C.GstAdapter, carg2 *C.gint, carg3 *C.gint) (cret C.GstFlowReturn) { - panic("unimplemented") + var fn func(carg0 *C.GstAudioDecoder, carg1 *C.GstAdapter, carg2 *C.gint, carg3 *C.gint) (cret C.GstFlowReturn) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstaudio1_AudioDecoder_parse").(func(carg0 *C.GstAudioDecoder, carg1 *C.GstAdapter, carg2 *C.gint, carg3 *C.gint) (cret C.GstFlowReturn)) + if fn == nil { + panic("_gotk4_gstaudio1_AudioDecoder_parse: no function pointer found") + } + } + return fn(carg0, carg1, carg2, carg3) } //export _gotk4_gstaudio1_AudioDecoder_propose_allocation func _gotk4_gstaudio1_AudioDecoder_propose_allocation(carg0 *C.GstAudioDecoder, carg1 *C.GstQuery) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstAudioDecoder, carg1 *C.GstQuery) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstaudio1_AudioDecoder_propose_allocation").(func(carg0 *C.GstAudioDecoder, carg1 *C.GstQuery) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstaudio1_AudioDecoder_propose_allocation: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstaudio1_AudioDecoder_set_format func _gotk4_gstaudio1_AudioDecoder_set_format(carg0 *C.GstAudioDecoder, carg1 *C.GstCaps) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstAudioDecoder, carg1 *C.GstCaps) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstaudio1_AudioDecoder_set_format").(func(carg0 *C.GstAudioDecoder, carg1 *C.GstCaps) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstaudio1_AudioDecoder_set_format: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstaudio1_AudioDecoder_sink_event func _gotk4_gstaudio1_AudioDecoder_sink_event(carg0 *C.GstAudioDecoder, carg1 *C.GstEvent) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstAudioDecoder, carg1 *C.GstEvent) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstaudio1_AudioDecoder_sink_event").(func(carg0 *C.GstAudioDecoder, carg1 *C.GstEvent) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstaudio1_AudioDecoder_sink_event: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstaudio1_AudioDecoder_sink_query func _gotk4_gstaudio1_AudioDecoder_sink_query(carg0 *C.GstAudioDecoder, carg1 *C.GstQuery) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstAudioDecoder, carg1 *C.GstQuery) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstaudio1_AudioDecoder_sink_query").(func(carg0 *C.GstAudioDecoder, carg1 *C.GstQuery) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstaudio1_AudioDecoder_sink_query: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstaudio1_AudioDecoder_src_event func _gotk4_gstaudio1_AudioDecoder_src_event(carg0 *C.GstAudioDecoder, carg1 *C.GstEvent) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstAudioDecoder, carg1 *C.GstEvent) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstaudio1_AudioDecoder_src_event").(func(carg0 *C.GstAudioDecoder, carg1 *C.GstEvent) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstaudio1_AudioDecoder_src_event: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstaudio1_AudioDecoder_src_query func _gotk4_gstaudio1_AudioDecoder_src_query(carg0 *C.GstAudioDecoder, carg1 *C.GstQuery) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstAudioDecoder, carg1 *C.GstQuery) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstaudio1_AudioDecoder_src_query").(func(carg0 *C.GstAudioDecoder, carg1 *C.GstQuery) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstaudio1_AudioDecoder_src_query: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstaudio1_AudioDecoder_start func _gotk4_gstaudio1_AudioDecoder_start(carg0 *C.GstAudioDecoder) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstAudioDecoder) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstaudio1_AudioDecoder_start").(func(carg0 *C.GstAudioDecoder) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstaudio1_AudioDecoder_start: no function pointer found") + } + } + return fn(carg0) } //export _gotk4_gstaudio1_AudioDecoder_stop func _gotk4_gstaudio1_AudioDecoder_stop(carg0 *C.GstAudioDecoder) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstAudioDecoder) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstaudio1_AudioDecoder_stop").(func(carg0 *C.GstAudioDecoder) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstaudio1_AudioDecoder_stop: no function pointer found") + } + } + return fn(carg0) } //export _gotk4_gstaudio1_AudioDecoder_transform_meta func _gotk4_gstaudio1_AudioDecoder_transform_meta(carg0 *C.GstAudioDecoder, carg1 *C.GstBuffer, carg2 *C.GstMeta, carg3 *C.GstBuffer) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstAudioDecoder, carg1 *C.GstBuffer, carg2 *C.GstMeta, carg3 *C.GstBuffer) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstaudio1_AudioDecoder_transform_meta").(func(carg0 *C.GstAudioDecoder, carg1 *C.GstBuffer, carg2 *C.GstMeta, carg3 *C.GstBuffer) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstaudio1_AudioDecoder_transform_meta: no function pointer found") + } + } + return fn(carg0, carg1, carg2, carg3) } //export _gotk4_gstaudio1_AudioEncoder_close func _gotk4_gstaudio1_AudioEncoder_close(carg0 *C.GstAudioEncoder) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstAudioEncoder) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstaudio1_AudioEncoder_close").(func(carg0 *C.GstAudioEncoder) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstaudio1_AudioEncoder_close: no function pointer found") + } + } + return fn(carg0) } //export _gotk4_gstaudio1_AudioEncoder_decide_allocation func _gotk4_gstaudio1_AudioEncoder_decide_allocation(carg0 *C.GstAudioEncoder, carg1 *C.GstQuery) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstAudioEncoder, carg1 *C.GstQuery) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstaudio1_AudioEncoder_decide_allocation").(func(carg0 *C.GstAudioEncoder, carg1 *C.GstQuery) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstaudio1_AudioEncoder_decide_allocation: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstaudio1_AudioEncoder_flush func _gotk4_gstaudio1_AudioEncoder_flush(carg0 *C.GstAudioEncoder) { - panic("unimplemented") + var fn func(carg0 *C.GstAudioEncoder) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstaudio1_AudioEncoder_flush").(func(carg0 *C.GstAudioEncoder)) + if fn == nil { + panic("_gotk4_gstaudio1_AudioEncoder_flush: no function pointer found") + } + } + fn(carg0) } //export _gotk4_gstaudio1_AudioEncoder_getcaps func _gotk4_gstaudio1_AudioEncoder_getcaps(carg0 *C.GstAudioEncoder, carg1 *C.GstCaps) (cret *C.GstCaps) { - panic("unimplemented") + var fn func(carg0 *C.GstAudioEncoder, carg1 *C.GstCaps) (cret *C.GstCaps) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstaudio1_AudioEncoder_getcaps").(func(carg0 *C.GstAudioEncoder, carg1 *C.GstCaps) (cret *C.GstCaps)) + if fn == nil { + panic("_gotk4_gstaudio1_AudioEncoder_getcaps: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstaudio1_AudioEncoder_handle_frame func _gotk4_gstaudio1_AudioEncoder_handle_frame(carg0 *C.GstAudioEncoder, carg1 *C.GstBuffer) (cret C.GstFlowReturn) { - panic("unimplemented") + var fn func(carg0 *C.GstAudioEncoder, carg1 *C.GstBuffer) (cret C.GstFlowReturn) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstaudio1_AudioEncoder_handle_frame").(func(carg0 *C.GstAudioEncoder, carg1 *C.GstBuffer) (cret C.GstFlowReturn)) + if fn == nil { + panic("_gotk4_gstaudio1_AudioEncoder_handle_frame: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstaudio1_AudioEncoder_negotiate func _gotk4_gstaudio1_AudioEncoder_negotiate(carg0 *C.GstAudioEncoder) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstAudioEncoder) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstaudio1_AudioEncoder_negotiate").(func(carg0 *C.GstAudioEncoder) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstaudio1_AudioEncoder_negotiate: no function pointer found") + } + } + return fn(carg0) } //export _gotk4_gstaudio1_AudioEncoder_open func _gotk4_gstaudio1_AudioEncoder_open(carg0 *C.GstAudioEncoder) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstAudioEncoder) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstaudio1_AudioEncoder_open").(func(carg0 *C.GstAudioEncoder) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstaudio1_AudioEncoder_open: no function pointer found") + } + } + return fn(carg0) } //export _gotk4_gstaudio1_AudioEncoder_propose_allocation func _gotk4_gstaudio1_AudioEncoder_propose_allocation(carg0 *C.GstAudioEncoder, carg1 *C.GstQuery) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstAudioEncoder, carg1 *C.GstQuery) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstaudio1_AudioEncoder_propose_allocation").(func(carg0 *C.GstAudioEncoder, carg1 *C.GstQuery) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstaudio1_AudioEncoder_propose_allocation: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstaudio1_AudioEncoder_set_format func _gotk4_gstaudio1_AudioEncoder_set_format(carg0 *C.GstAudioEncoder, carg1 *C.GstAudioInfo) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstAudioEncoder, carg1 *C.GstAudioInfo) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstaudio1_AudioEncoder_set_format").(func(carg0 *C.GstAudioEncoder, carg1 *C.GstAudioInfo) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstaudio1_AudioEncoder_set_format: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstaudio1_AudioEncoder_sink_event func _gotk4_gstaudio1_AudioEncoder_sink_event(carg0 *C.GstAudioEncoder, carg1 *C.GstEvent) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstAudioEncoder, carg1 *C.GstEvent) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstaudio1_AudioEncoder_sink_event").(func(carg0 *C.GstAudioEncoder, carg1 *C.GstEvent) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstaudio1_AudioEncoder_sink_event: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstaudio1_AudioEncoder_sink_query func _gotk4_gstaudio1_AudioEncoder_sink_query(carg0 *C.GstAudioEncoder, carg1 *C.GstQuery) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstAudioEncoder, carg1 *C.GstQuery) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstaudio1_AudioEncoder_sink_query").(func(carg0 *C.GstAudioEncoder, carg1 *C.GstQuery) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstaudio1_AudioEncoder_sink_query: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstaudio1_AudioEncoder_src_event func _gotk4_gstaudio1_AudioEncoder_src_event(carg0 *C.GstAudioEncoder, carg1 *C.GstEvent) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstAudioEncoder, carg1 *C.GstEvent) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstaudio1_AudioEncoder_src_event").(func(carg0 *C.GstAudioEncoder, carg1 *C.GstEvent) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstaudio1_AudioEncoder_src_event: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstaudio1_AudioEncoder_src_query func _gotk4_gstaudio1_AudioEncoder_src_query(carg0 *C.GstAudioEncoder, carg1 *C.GstQuery) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstAudioEncoder, carg1 *C.GstQuery) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstaudio1_AudioEncoder_src_query").(func(carg0 *C.GstAudioEncoder, carg1 *C.GstQuery) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstaudio1_AudioEncoder_src_query: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstaudio1_AudioEncoder_start func _gotk4_gstaudio1_AudioEncoder_start(carg0 *C.GstAudioEncoder) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstAudioEncoder) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstaudio1_AudioEncoder_start").(func(carg0 *C.GstAudioEncoder) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstaudio1_AudioEncoder_start: no function pointer found") + } + } + return fn(carg0) } //export _gotk4_gstaudio1_AudioEncoder_stop func _gotk4_gstaudio1_AudioEncoder_stop(carg0 *C.GstAudioEncoder) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstAudioEncoder) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstaudio1_AudioEncoder_stop").(func(carg0 *C.GstAudioEncoder) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstaudio1_AudioEncoder_stop: no function pointer found") + } + } + return fn(carg0) } //export _gotk4_gstaudio1_AudioEncoder_transform_meta func _gotk4_gstaudio1_AudioEncoder_transform_meta(carg0 *C.GstAudioEncoder, carg1 *C.GstBuffer, carg2 *C.GstMeta, carg3 *C.GstBuffer) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstAudioEncoder, carg1 *C.GstBuffer, carg2 *C.GstMeta, carg3 *C.GstBuffer) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstaudio1_AudioEncoder_transform_meta").(func(carg0 *C.GstAudioEncoder, carg1 *C.GstBuffer, carg2 *C.GstMeta, carg3 *C.GstBuffer) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstaudio1_AudioEncoder_transform_meta: no function pointer found") + } + } + return fn(carg0, carg1, carg2, carg3) } //export _gotk4_gstaudio1_AudioFilter_setup func _gotk4_gstaudio1_AudioFilter_setup(carg0 *C.GstAudioFilter, carg1 *C.GstAudioInfo) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstAudioFilter, carg1 *C.GstAudioInfo) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstaudio1_AudioFilter_setup").(func(carg0 *C.GstAudioFilter, carg1 *C.GstAudioInfo) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstaudio1_AudioFilter_setup: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstaudio1_AudioRingBuffer_acquire func _gotk4_gstaudio1_AudioRingBuffer_acquire(carg0 *C.GstAudioRingBuffer, carg1 *C.GstAudioRingBufferSpec) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstAudioRingBuffer, carg1 *C.GstAudioRingBufferSpec) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstaudio1_AudioRingBuffer_acquire").(func(carg0 *C.GstAudioRingBuffer, carg1 *C.GstAudioRingBufferSpec) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstaudio1_AudioRingBuffer_acquire: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstaudio1_AudioRingBuffer_activate func _gotk4_gstaudio1_AudioRingBuffer_activate(carg0 *C.GstAudioRingBuffer, carg1 C.gboolean) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstAudioRingBuffer, carg1 C.gboolean) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstaudio1_AudioRingBuffer_activate").(func(carg0 *C.GstAudioRingBuffer, carg1 C.gboolean) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstaudio1_AudioRingBuffer_activate: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstaudio1_AudioRingBuffer_clear_all func _gotk4_gstaudio1_AudioRingBuffer_clear_all(carg0 *C.GstAudioRingBuffer) { - panic("unimplemented") + var fn func(carg0 *C.GstAudioRingBuffer) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstaudio1_AudioRingBuffer_clear_all").(func(carg0 *C.GstAudioRingBuffer)) + if fn == nil { + panic("_gotk4_gstaudio1_AudioRingBuffer_clear_all: no function pointer found") + } + } + fn(carg0) } //export _gotk4_gstaudio1_AudioRingBuffer_close_device func _gotk4_gstaudio1_AudioRingBuffer_close_device(carg0 *C.GstAudioRingBuffer) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstAudioRingBuffer) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstaudio1_AudioRingBuffer_close_device").(func(carg0 *C.GstAudioRingBuffer) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstaudio1_AudioRingBuffer_close_device: no function pointer found") + } + } + return fn(carg0) } //export _gotk4_gstaudio1_AudioRingBuffer_delay func _gotk4_gstaudio1_AudioRingBuffer_delay(carg0 *C.GstAudioRingBuffer) (cret C.guint) { - panic("unimplemented") + var fn func(carg0 *C.GstAudioRingBuffer) (cret C.guint) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstaudio1_AudioRingBuffer_delay").(func(carg0 *C.GstAudioRingBuffer) (cret C.guint)) + if fn == nil { + panic("_gotk4_gstaudio1_AudioRingBuffer_delay: no function pointer found") + } + } + return fn(carg0) } //export _gotk4_gstaudio1_AudioRingBuffer_open_device func _gotk4_gstaudio1_AudioRingBuffer_open_device(carg0 *C.GstAudioRingBuffer) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstAudioRingBuffer) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstaudio1_AudioRingBuffer_open_device").(func(carg0 *C.GstAudioRingBuffer) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstaudio1_AudioRingBuffer_open_device: no function pointer found") + } + } + return fn(carg0) } //export _gotk4_gstaudio1_AudioRingBuffer_pause func _gotk4_gstaudio1_AudioRingBuffer_pause(carg0 *C.GstAudioRingBuffer) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstAudioRingBuffer) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstaudio1_AudioRingBuffer_pause").(func(carg0 *C.GstAudioRingBuffer) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstaudio1_AudioRingBuffer_pause: no function pointer found") + } + } + return fn(carg0) } //export _gotk4_gstaudio1_AudioRingBuffer_release func _gotk4_gstaudio1_AudioRingBuffer_release(carg0 *C.GstAudioRingBuffer) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstAudioRingBuffer) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstaudio1_AudioRingBuffer_release").(func(carg0 *C.GstAudioRingBuffer) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstaudio1_AudioRingBuffer_release: no function pointer found") + } + } + return fn(carg0) } //export _gotk4_gstaudio1_AudioRingBuffer_resume func _gotk4_gstaudio1_AudioRingBuffer_resume(carg0 *C.GstAudioRingBuffer) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstAudioRingBuffer) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstaudio1_AudioRingBuffer_resume").(func(carg0 *C.GstAudioRingBuffer) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstaudio1_AudioRingBuffer_resume: no function pointer found") + } + } + return fn(carg0) } //export _gotk4_gstaudio1_AudioRingBuffer_start func _gotk4_gstaudio1_AudioRingBuffer_start(carg0 *C.GstAudioRingBuffer) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstAudioRingBuffer) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstaudio1_AudioRingBuffer_start").(func(carg0 *C.GstAudioRingBuffer) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstaudio1_AudioRingBuffer_start: no function pointer found") + } + } + return fn(carg0) } //export _gotk4_gstaudio1_AudioRingBuffer_stop func _gotk4_gstaudio1_AudioRingBuffer_stop(carg0 *C.GstAudioRingBuffer) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstAudioRingBuffer) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstaudio1_AudioRingBuffer_stop").(func(carg0 *C.GstAudioRingBuffer) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstaudio1_AudioRingBuffer_stop: no function pointer found") + } + } + return fn(carg0) } //export _gotk4_gstaudio1_AudioSink_close func _gotk4_gstaudio1_AudioSink_close(carg0 *C.GstAudioSink) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstAudioSink) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstaudio1_AudioSink_close").(func(carg0 *C.GstAudioSink) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstaudio1_AudioSink_close: no function pointer found") + } + } + return fn(carg0) } //export _gotk4_gstaudio1_AudioSink_delay func _gotk4_gstaudio1_AudioSink_delay(carg0 *C.GstAudioSink) (cret C.guint) { - panic("unimplemented") + var fn func(carg0 *C.GstAudioSink) (cret C.guint) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstaudio1_AudioSink_delay").(func(carg0 *C.GstAudioSink) (cret C.guint)) + if fn == nil { + panic("_gotk4_gstaudio1_AudioSink_delay: no function pointer found") + } + } + return fn(carg0) } //export _gotk4_gstaudio1_AudioSink_open func _gotk4_gstaudio1_AudioSink_open(carg0 *C.GstAudioSink) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstAudioSink) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstaudio1_AudioSink_open").(func(carg0 *C.GstAudioSink) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstaudio1_AudioSink_open: no function pointer found") + } + } + return fn(carg0) } //export _gotk4_gstaudio1_AudioSink_pause func _gotk4_gstaudio1_AudioSink_pause(carg0 *C.GstAudioSink) { - panic("unimplemented") + var fn func(carg0 *C.GstAudioSink) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstaudio1_AudioSink_pause").(func(carg0 *C.GstAudioSink)) + if fn == nil { + panic("_gotk4_gstaudio1_AudioSink_pause: no function pointer found") + } + } + fn(carg0) } //export _gotk4_gstaudio1_AudioSink_prepare func _gotk4_gstaudio1_AudioSink_prepare(carg0 *C.GstAudioSink, carg1 *C.GstAudioRingBufferSpec) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstAudioSink, carg1 *C.GstAudioRingBufferSpec) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstaudio1_AudioSink_prepare").(func(carg0 *C.GstAudioSink, carg1 *C.GstAudioRingBufferSpec) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstaudio1_AudioSink_prepare: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstaudio1_AudioSink_reset func _gotk4_gstaudio1_AudioSink_reset(carg0 *C.GstAudioSink) { - panic("unimplemented") + var fn func(carg0 *C.GstAudioSink) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstaudio1_AudioSink_reset").(func(carg0 *C.GstAudioSink)) + if fn == nil { + panic("_gotk4_gstaudio1_AudioSink_reset: no function pointer found") + } + } + fn(carg0) } //export _gotk4_gstaudio1_AudioSink_resume func _gotk4_gstaudio1_AudioSink_resume(carg0 *C.GstAudioSink) { - panic("unimplemented") + var fn func(carg0 *C.GstAudioSink) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstaudio1_AudioSink_resume").(func(carg0 *C.GstAudioSink)) + if fn == nil { + panic("_gotk4_gstaudio1_AudioSink_resume: no function pointer found") + } + } + fn(carg0) } //export _gotk4_gstaudio1_AudioSink_stop func _gotk4_gstaudio1_AudioSink_stop(carg0 *C.GstAudioSink) { - panic("unimplemented") + var fn func(carg0 *C.GstAudioSink) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstaudio1_AudioSink_stop").(func(carg0 *C.GstAudioSink)) + if fn == nil { + panic("_gotk4_gstaudio1_AudioSink_stop: no function pointer found") + } + } + fn(carg0) } //export _gotk4_gstaudio1_AudioSink_unprepare func _gotk4_gstaudio1_AudioSink_unprepare(carg0 *C.GstAudioSink) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstAudioSink) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstaudio1_AudioSink_unprepare").(func(carg0 *C.GstAudioSink) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstaudio1_AudioSink_unprepare: no function pointer found") + } + } + return fn(carg0) } //export _gotk4_gstaudio1_AudioSrc_close func _gotk4_gstaudio1_AudioSrc_close(carg0 *C.GstAudioSrc) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstAudioSrc) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstaudio1_AudioSrc_close").(func(carg0 *C.GstAudioSrc) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstaudio1_AudioSrc_close: no function pointer found") + } + } + return fn(carg0) } //export _gotk4_gstaudio1_AudioSrc_delay func _gotk4_gstaudio1_AudioSrc_delay(carg0 *C.GstAudioSrc) (cret C.guint) { - panic("unimplemented") + var fn func(carg0 *C.GstAudioSrc) (cret C.guint) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstaudio1_AudioSrc_delay").(func(carg0 *C.GstAudioSrc) (cret C.guint)) + if fn == nil { + panic("_gotk4_gstaudio1_AudioSrc_delay: no function pointer found") + } + } + return fn(carg0) } //export _gotk4_gstaudio1_AudioSrc_open func _gotk4_gstaudio1_AudioSrc_open(carg0 *C.GstAudioSrc) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstAudioSrc) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstaudio1_AudioSrc_open").(func(carg0 *C.GstAudioSrc) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstaudio1_AudioSrc_open: no function pointer found") + } + } + return fn(carg0) } //export _gotk4_gstaudio1_AudioSrc_prepare func _gotk4_gstaudio1_AudioSrc_prepare(carg0 *C.GstAudioSrc, carg1 *C.GstAudioRingBufferSpec) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstAudioSrc, carg1 *C.GstAudioRingBufferSpec) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstaudio1_AudioSrc_prepare").(func(carg0 *C.GstAudioSrc, carg1 *C.GstAudioRingBufferSpec) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstaudio1_AudioSrc_prepare: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstaudio1_AudioSrc_reset func _gotk4_gstaudio1_AudioSrc_reset(carg0 *C.GstAudioSrc) { - panic("unimplemented") + var fn func(carg0 *C.GstAudioSrc) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstaudio1_AudioSrc_reset").(func(carg0 *C.GstAudioSrc)) + if fn == nil { + panic("_gotk4_gstaudio1_AudioSrc_reset: no function pointer found") + } + } + fn(carg0) } //export _gotk4_gstaudio1_AudioSrc_unprepare func _gotk4_gstaudio1_AudioSrc_unprepare(carg0 *C.GstAudioSrc) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstAudioSrc) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstaudio1_AudioSrc_unprepare").(func(carg0 *C.GstAudioSrc) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstaudio1_AudioSrc_unprepare: no function pointer found") + } + } + return fn(carg0) } diff --git a/pkg/gstbase/gstbase.gen.go b/pkg/gstbase/gstbase.gen.go index 94ae1f3..775fdc7 100644 --- a/pkg/gstbase/gstbase.gen.go +++ b/pkg/gstbase/gstbase.gen.go @@ -8,6 +8,7 @@ import ( "strings" "unsafe" + "github.com/diamondburned/gotk4/pkg/core/classdata" "github.com/diamondburned/gotk4/pkg/core/userdata" "github.com/diamondburned/gotk4/pkg/glib/v2" "github.com/diamondburned/gotk4/pkg/gobject/v2" @@ -3640,93 +3641,553 @@ func UnsafeApplyAggregatorOverrides[Instance Aggregator](gclass unsafe.Pointer, if overrides.Aggregate != nil { pclass.aggregate = (*[0]byte)(C._gotk4_gstbase1_Aggregator_aggregate) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstbase1_Aggregator_aggregate", + func(carg0 *C.GstAggregator, carg1 C.gboolean) (cret C.GstFlowReturn) { + var aggregator Instance // go GstAggregator subclass + var timeout bool // in + var goret gst.FlowReturn // return, none, casted + + aggregator = UnsafeAggregatorFromGlibNone(unsafe.Pointer(carg0)).(Instance) + if carg1 != 0 { + timeout = true + } + + goret = overrides.Aggregate(aggregator, timeout) + + cret = C.GstFlowReturn(goret) + + return cret + }, + ) } if overrides.Clip != nil { pclass.clip = (*[0]byte)(C._gotk4_gstbase1_Aggregator_clip) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstbase1_Aggregator_clip", + func(carg0 *C.GstAggregator, carg1 *C.GstAggregatorPad, carg2 *C.GstBuffer) (cret *C.GstBuffer) { + var aggregator Instance // go GstAggregator subclass + var aggregatorPad AggregatorPad // in, none, converted + var buf *gst.Buffer // in, none, converted + var goret *gst.Buffer // return, full, converted + + aggregator = UnsafeAggregatorFromGlibNone(unsafe.Pointer(carg0)).(Instance) + aggregatorPad = UnsafeAggregatorPadFromGlibNone(unsafe.Pointer(carg1)) + buf = gst.UnsafeBufferFromGlibNone(unsafe.Pointer(carg2)) + + goret = overrides.Clip(aggregator, aggregatorPad, buf) + + cret = (*C.GstBuffer)(gst.UnsafeBufferToGlibFull(goret)) + + return cret + }, + ) } if overrides.DecideAllocation != nil { pclass.decide_allocation = (*[0]byte)(C._gotk4_gstbase1_Aggregator_decide_allocation) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstbase1_Aggregator_decide_allocation", + func(carg0 *C.GstAggregator, carg1 *C.GstQuery) (cret C.gboolean) { + var self Instance // go GstAggregator subclass + var query *gst.Query // in, none, converted + var goret bool // return + + self = UnsafeAggregatorFromGlibNone(unsafe.Pointer(carg0)).(Instance) + query = gst.UnsafeQueryFromGlibNone(unsafe.Pointer(carg1)) + + goret = overrides.DecideAllocation(self, query) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.FinishBuffer != nil { pclass.finish_buffer = (*[0]byte)(C._gotk4_gstbase1_Aggregator_finish_buffer) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstbase1_Aggregator_finish_buffer", + func(carg0 *C.GstAggregator, carg1 *C.GstBuffer) (cret C.GstFlowReturn) { + var aggregator Instance // go GstAggregator subclass + var buffer *gst.Buffer // in, full, converted + var goret gst.FlowReturn // return, none, casted + + aggregator = UnsafeAggregatorFromGlibNone(unsafe.Pointer(carg0)).(Instance) + buffer = gst.UnsafeBufferFromGlibFull(unsafe.Pointer(carg1)) + + goret = overrides.FinishBuffer(aggregator, buffer) + + cret = C.GstFlowReturn(goret) + + return cret + }, + ) } if overrides.FinishBufferList != nil { pclass.finish_buffer_list = (*[0]byte)(C._gotk4_gstbase1_Aggregator_finish_buffer_list) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstbase1_Aggregator_finish_buffer_list", + func(carg0 *C.GstAggregator, carg1 *C.GstBufferList) (cret C.GstFlowReturn) { + var aggregator Instance // go GstAggregator subclass + var bufferlist *gst.BufferList // in, full, converted + var goret gst.FlowReturn // return, none, casted + + aggregator = UnsafeAggregatorFromGlibNone(unsafe.Pointer(carg0)).(Instance) + bufferlist = gst.UnsafeBufferListFromGlibFull(unsafe.Pointer(carg1)) + + goret = overrides.FinishBufferList(aggregator, bufferlist) + + cret = C.GstFlowReturn(goret) + + return cret + }, + ) } if overrides.FixateSrcCaps != nil { pclass.fixate_src_caps = (*[0]byte)(C._gotk4_gstbase1_Aggregator_fixate_src_caps) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstbase1_Aggregator_fixate_src_caps", + func(carg0 *C.GstAggregator, carg1 *C.GstCaps) (cret *C.GstCaps) { + var self Instance // go GstAggregator subclass + var caps *gst.Caps // in, none, converted + var goret *gst.Caps // return, full, converted + + self = UnsafeAggregatorFromGlibNone(unsafe.Pointer(carg0)).(Instance) + caps = gst.UnsafeCapsFromGlibNone(unsafe.Pointer(carg1)) + + goret = overrides.FixateSrcCaps(self, caps) + + cret = (*C.GstCaps)(gst.UnsafeCapsToGlibFull(goret)) + + return cret + }, + ) } if overrides.Flush != nil { pclass.flush = (*[0]byte)(C._gotk4_gstbase1_Aggregator_flush) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstbase1_Aggregator_flush", + func(carg0 *C.GstAggregator) (cret C.GstFlowReturn) { + var aggregator Instance // go GstAggregator subclass + var goret gst.FlowReturn // return, none, casted + + aggregator = UnsafeAggregatorFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + goret = overrides.Flush(aggregator) + + cret = C.GstFlowReturn(goret) + + return cret + }, + ) } if overrides.GetNextTime != nil { pclass.get_next_time = (*[0]byte)(C._gotk4_gstbase1_Aggregator_get_next_time) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstbase1_Aggregator_get_next_time", + func(carg0 *C.GstAggregator) (cret C.GstClockTime) { + var aggregator Instance // go GstAggregator subclass + var goret gst.ClockTime // return, none, casted, alias + + aggregator = UnsafeAggregatorFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + goret = overrides.GetNextTime(aggregator) + + cret = C.GstClockTime(goret) + + return cret + }, + ) } if overrides.Negotiate != nil { pclass.negotiate = (*[0]byte)(C._gotk4_gstbase1_Aggregator_negotiate) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstbase1_Aggregator_negotiate", + func(carg0 *C.GstAggregator) (cret C.gboolean) { + var self Instance // go GstAggregator subclass + var goret bool // return + + self = UnsafeAggregatorFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + goret = overrides.Negotiate(self) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.NegotiatedSrcCaps != nil { pclass.negotiated_src_caps = (*[0]byte)(C._gotk4_gstbase1_Aggregator_negotiated_src_caps) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstbase1_Aggregator_negotiated_src_caps", + func(carg0 *C.GstAggregator, carg1 *C.GstCaps) (cret C.gboolean) { + var self Instance // go GstAggregator subclass + var caps *gst.Caps // in, none, converted + var goret bool // return + + self = UnsafeAggregatorFromGlibNone(unsafe.Pointer(carg0)).(Instance) + caps = gst.UnsafeCapsFromGlibNone(unsafe.Pointer(carg1)) + + goret = overrides.NegotiatedSrcCaps(self, caps) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.PeekNextSample != nil { pclass.peek_next_sample = (*[0]byte)(C._gotk4_gstbase1_Aggregator_peek_next_sample) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstbase1_Aggregator_peek_next_sample", + func(carg0 *C.GstAggregator, carg1 *C.GstAggregatorPad) (cret *C.GstSample) { + var aggregator Instance // go GstAggregator subclass + var aggregatorPad AggregatorPad // in, none, converted + var goret *gst.Sample // return, full, converted, nullable + + aggregator = UnsafeAggregatorFromGlibNone(unsafe.Pointer(carg0)).(Instance) + aggregatorPad = UnsafeAggregatorPadFromGlibNone(unsafe.Pointer(carg1)) + + goret = overrides.PeekNextSample(aggregator, aggregatorPad) + + if goret != nil { + cret = (*C.GstSample)(gst.UnsafeSampleToGlibFull(goret)) + } + + return cret + }, + ) } if overrides.ProposeAllocation != nil { pclass.propose_allocation = (*[0]byte)(C._gotk4_gstbase1_Aggregator_propose_allocation) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstbase1_Aggregator_propose_allocation", + func(carg0 *C.GstAggregator, carg1 *C.GstAggregatorPad, carg2 *C.GstQuery, carg3 *C.GstQuery) (cret C.gboolean) { + var self Instance // go GstAggregator subclass + var pad AggregatorPad // in, none, converted + var decideQuery *gst.Query // in, none, converted + var query *gst.Query // in, none, converted + var goret bool // return + + self = UnsafeAggregatorFromGlibNone(unsafe.Pointer(carg0)).(Instance) + pad = UnsafeAggregatorPadFromGlibNone(unsafe.Pointer(carg1)) + decideQuery = gst.UnsafeQueryFromGlibNone(unsafe.Pointer(carg2)) + query = gst.UnsafeQueryFromGlibNone(unsafe.Pointer(carg3)) + + goret = overrides.ProposeAllocation(self, pad, decideQuery, query) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.SinkEvent != nil { pclass.sink_event = (*[0]byte)(C._gotk4_gstbase1_Aggregator_sink_event) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstbase1_Aggregator_sink_event", + func(carg0 *C.GstAggregator, carg1 *C.GstAggregatorPad, carg2 *C.GstEvent) (cret C.gboolean) { + var aggregator Instance // go GstAggregator subclass + var aggregatorPad AggregatorPad // in, none, converted + var event *gst.Event // in, none, converted + var goret bool // return + + aggregator = UnsafeAggregatorFromGlibNone(unsafe.Pointer(carg0)).(Instance) + aggregatorPad = UnsafeAggregatorPadFromGlibNone(unsafe.Pointer(carg1)) + event = gst.UnsafeEventFromGlibNone(unsafe.Pointer(carg2)) + + goret = overrides.SinkEvent(aggregator, aggregatorPad, event) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.SinkEventPreQueue != nil { pclass.sink_event_pre_queue = (*[0]byte)(C._gotk4_gstbase1_Aggregator_sink_event_pre_queue) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstbase1_Aggregator_sink_event_pre_queue", + func(carg0 *C.GstAggregator, carg1 *C.GstAggregatorPad, carg2 *C.GstEvent) (cret C.GstFlowReturn) { + var aggregator Instance // go GstAggregator subclass + var aggregatorPad AggregatorPad // in, none, converted + var event *gst.Event // in, none, converted + var goret gst.FlowReturn // return, none, casted + + aggregator = UnsafeAggregatorFromGlibNone(unsafe.Pointer(carg0)).(Instance) + aggregatorPad = UnsafeAggregatorPadFromGlibNone(unsafe.Pointer(carg1)) + event = gst.UnsafeEventFromGlibNone(unsafe.Pointer(carg2)) + + goret = overrides.SinkEventPreQueue(aggregator, aggregatorPad, event) + + cret = C.GstFlowReturn(goret) + + return cret + }, + ) } if overrides.SinkQuery != nil { pclass.sink_query = (*[0]byte)(C._gotk4_gstbase1_Aggregator_sink_query) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstbase1_Aggregator_sink_query", + func(carg0 *C.GstAggregator, carg1 *C.GstAggregatorPad, carg2 *C.GstQuery) (cret C.gboolean) { + var aggregator Instance // go GstAggregator subclass + var aggregatorPad AggregatorPad // in, none, converted + var query *gst.Query // in, none, converted + var goret bool // return + + aggregator = UnsafeAggregatorFromGlibNone(unsafe.Pointer(carg0)).(Instance) + aggregatorPad = UnsafeAggregatorPadFromGlibNone(unsafe.Pointer(carg1)) + query = gst.UnsafeQueryFromGlibNone(unsafe.Pointer(carg2)) + + goret = overrides.SinkQuery(aggregator, aggregatorPad, query) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.SinkQueryPreQueue != nil { pclass.sink_query_pre_queue = (*[0]byte)(C._gotk4_gstbase1_Aggregator_sink_query_pre_queue) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstbase1_Aggregator_sink_query_pre_queue", + func(carg0 *C.GstAggregator, carg1 *C.GstAggregatorPad, carg2 *C.GstQuery) (cret C.gboolean) { + var aggregator Instance // go GstAggregator subclass + var aggregatorPad AggregatorPad // in, none, converted + var query *gst.Query // in, none, converted + var goret bool // return + + aggregator = UnsafeAggregatorFromGlibNone(unsafe.Pointer(carg0)).(Instance) + aggregatorPad = UnsafeAggregatorPadFromGlibNone(unsafe.Pointer(carg1)) + query = gst.UnsafeQueryFromGlibNone(unsafe.Pointer(carg2)) + + goret = overrides.SinkQueryPreQueue(aggregator, aggregatorPad, query) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.SrcActivate != nil { pclass.src_activate = (*[0]byte)(C._gotk4_gstbase1_Aggregator_src_activate) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstbase1_Aggregator_src_activate", + func(carg0 *C.GstAggregator, carg1 C.GstPadMode, carg2 C.gboolean) (cret C.gboolean) { + var aggregator Instance // go GstAggregator subclass + var mode gst.PadMode // in, none, casted + var active bool // in + var goret bool // return + + aggregator = UnsafeAggregatorFromGlibNone(unsafe.Pointer(carg0)).(Instance) + mode = gst.PadMode(carg1) + if carg2 != 0 { + active = true + } + + goret = overrides.SrcActivate(aggregator, mode, active) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.SrcEvent != nil { pclass.src_event = (*[0]byte)(C._gotk4_gstbase1_Aggregator_src_event) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstbase1_Aggregator_src_event", + func(carg0 *C.GstAggregator, carg1 *C.GstEvent) (cret C.gboolean) { + var aggregator Instance // go GstAggregator subclass + var event *gst.Event // in, none, converted + var goret bool // return + + aggregator = UnsafeAggregatorFromGlibNone(unsafe.Pointer(carg0)).(Instance) + event = gst.UnsafeEventFromGlibNone(unsafe.Pointer(carg1)) + + goret = overrides.SrcEvent(aggregator, event) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.SrcQuery != nil { pclass.src_query = (*[0]byte)(C._gotk4_gstbase1_Aggregator_src_query) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstbase1_Aggregator_src_query", + func(carg0 *C.GstAggregator, carg1 *C.GstQuery) (cret C.gboolean) { + var aggregator Instance // go GstAggregator subclass + var query *gst.Query // in, none, converted + var goret bool // return + + aggregator = UnsafeAggregatorFromGlibNone(unsafe.Pointer(carg0)).(Instance) + query = gst.UnsafeQueryFromGlibNone(unsafe.Pointer(carg1)) + + goret = overrides.SrcQuery(aggregator, query) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.Start != nil { pclass.start = (*[0]byte)(C._gotk4_gstbase1_Aggregator_start) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstbase1_Aggregator_start", + func(carg0 *C.GstAggregator) (cret C.gboolean) { + var aggregator Instance // go GstAggregator subclass + var goret bool // return + + aggregator = UnsafeAggregatorFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + goret = overrides.Start(aggregator) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.Stop != nil { pclass.stop = (*[0]byte)(C._gotk4_gstbase1_Aggregator_stop) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstbase1_Aggregator_stop", + func(carg0 *C.GstAggregator) (cret C.gboolean) { + var aggregator Instance // go GstAggregator subclass + var goret bool // return + + aggregator = UnsafeAggregatorFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + goret = overrides.Stop(aggregator) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.UpdateSrcCaps != nil { pclass.update_src_caps = (*[0]byte)(C._gotk4_gstbase1_Aggregator_update_src_caps) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstbase1_Aggregator_update_src_caps", + func(carg0 *C.GstAggregator, carg1 *C.GstCaps, carg2 **C.GstCaps) (cret C.GstFlowReturn) { + var self Instance // go GstAggregator subclass + var caps *gst.Caps // in, none, converted + var ret *gst.Caps // out, full, converted + var goret gst.FlowReturn // return, none, casted + + self = UnsafeAggregatorFromGlibNone(unsafe.Pointer(carg0)).(Instance) + caps = gst.UnsafeCapsFromGlibNone(unsafe.Pointer(carg1)) + + ret, goret = overrides.UpdateSrcCaps(self, caps) + + *carg2 = (*C.GstCaps)(gst.UnsafeCapsToGlibFull(ret)) + cret = C.GstFlowReturn(goret) + + return cret + }, + ) } } +// RegisterAggregatorSubClass is used to register a go subclass of GstAggregator. For this to work safely please implement the +// virtual methods required by the implementation. +func RegisterAggregatorSubClass[InstanceT Aggregator]( + name string, + classInit func(class *AggregatorClass), + constructor func() InstanceT, + overrides AggregatorOverrides[InstanceT], + signals map[string]gobject.SignalDefinition, + interfaceInits ...gobject.SubClassInterfaceInit[InstanceT], +) gobject.Type { + return gobject.UnsafeRegisterSubClass( + name, + classInit, + constructor, + overrides, + signals, + TypeAggregator, + UnsafeAggregatorClassFromGlibBorrow, + UnsafeApplyAggregatorOverrides, + func (obj *gobject.ObjectInstance) gobject.Object { + return unsafeWrapAggregator(obj) + }, + interfaceInits..., + ) +} + // AggregatorPadInstance is the instance type used by all types extending GstAggregatorPad. It is used internally by the bindings. Users should use the interface [AggregatorPad] instead. type AggregatorPadInstance struct { _ [0]func() // equal guard @@ -4023,13 +4484,79 @@ func UnsafeApplyAggregatorPadOverrides[Instance AggregatorPad](gclass unsafe.Poi if overrides.Flush != nil { pclass.flush = (*[0]byte)(C._gotk4_gstbase1_AggregatorPad_flush) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstbase1_AggregatorPad_flush", + func(carg0 *C.GstAggregatorPad, carg1 *C.GstAggregator) (cret C.GstFlowReturn) { + var aggpad Instance // go GstAggregatorPad subclass + var aggregator Aggregator // in, none, converted + var goret gst.FlowReturn // return, none, casted + + aggpad = UnsafeAggregatorPadFromGlibNone(unsafe.Pointer(carg0)).(Instance) + aggregator = UnsafeAggregatorFromGlibNone(unsafe.Pointer(carg1)) + + goret = overrides.Flush(aggpad, aggregator) + + cret = C.GstFlowReturn(goret) + + return cret + }, + ) } if overrides.SkipBuffer != nil { pclass.skip_buffer = (*[0]byte)(C._gotk4_gstbase1_AggregatorPad_skip_buffer) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstbase1_AggregatorPad_skip_buffer", + func(carg0 *C.GstAggregatorPad, carg1 *C.GstAggregator, carg2 *C.GstBuffer) (cret C.gboolean) { + var aggpad Instance // go GstAggregatorPad subclass + var aggregator Aggregator // in, none, converted + var buffer *gst.Buffer // in, none, converted + var goret bool // return + + aggpad = UnsafeAggregatorPadFromGlibNone(unsafe.Pointer(carg0)).(Instance) + aggregator = UnsafeAggregatorFromGlibNone(unsafe.Pointer(carg1)) + buffer = gst.UnsafeBufferFromGlibNone(unsafe.Pointer(carg2)) + + goret = overrides.SkipBuffer(aggpad, aggregator, buffer) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } } +// RegisterAggregatorPadSubClass is used to register a go subclass of GstAggregatorPad. For this to work safely please implement the +// virtual methods required by the implementation. +func RegisterAggregatorPadSubClass[InstanceT AggregatorPad]( + name string, + classInit func(class *AggregatorPadClass), + constructor func() InstanceT, + overrides AggregatorPadOverrides[InstanceT], + signals map[string]gobject.SignalDefinition, + interfaceInits ...gobject.SubClassInterfaceInit[InstanceT], +) gobject.Type { + return gobject.UnsafeRegisterSubClass( + name, + classInit, + constructor, + overrides, + signals, + TypeAggregatorPad, + UnsafeAggregatorPadClassFromGlibBorrow, + UnsafeApplyAggregatorPadOverrides, + func (obj *gobject.ObjectInstance) gobject.Object { + return unsafeWrapAggregatorPad(obj) + }, + interfaceInits..., + ) +} + // BaseParseInstance is the instance type used by all types extending GstBaseParse. It is used internally by the bindings. Users should use the interface [BaseParse] instead. type BaseParseInstance struct { _ [0]func() // equal guard @@ -5086,53 +5613,317 @@ func UnsafeApplyBaseParseOverrides[Instance BaseParse](gclass unsafe.Pointer, ov if overrides.Convert != nil { pclass.convert = (*[0]byte)(C._gotk4_gstbase1_BaseParse_convert) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstbase1_BaseParse_convert", + func(carg0 *C.GstBaseParse, carg1 C.GstFormat, carg2 C.gint64, carg3 C.GstFormat, carg4 *C.gint64) (cret C.gboolean) { + var parse Instance // go GstBaseParse subclass + var srcFormat gst.Format // in, none, casted + var srcValue int64 // in, none, casted + var destFormat gst.Format // in, none, casted + var destValue *int64 // in, transfer: none, C Pointers: 1, Name: gint64 + var goret bool // return + + parse = UnsafeBaseParseFromGlibNone(unsafe.Pointer(carg0)).(Instance) + srcFormat = gst.Format(carg1) + srcValue = int64(carg2) + destFormat = gst.Format(carg3) + _ = destValue + _ = carg4 + panic("unimplemented conversion of *int64 (gint64*)") + + goret = overrides.Convert(parse, srcFormat, srcValue, destFormat, destValue) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.Detect != nil { pclass.detect = (*[0]byte)(C._gotk4_gstbase1_BaseParse_detect) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstbase1_BaseParse_detect", + func(carg0 *C.GstBaseParse, carg1 *C.GstBuffer) (cret C.GstFlowReturn) { + var parse Instance // go GstBaseParse subclass + var buffer *gst.Buffer // in, none, converted + var goret gst.FlowReturn // return, none, casted + + parse = UnsafeBaseParseFromGlibNone(unsafe.Pointer(carg0)).(Instance) + buffer = gst.UnsafeBufferFromGlibNone(unsafe.Pointer(carg1)) + + goret = overrides.Detect(parse, buffer) + + cret = C.GstFlowReturn(goret) + + return cret + }, + ) } if overrides.GetSinkCaps != nil { pclass.get_sink_caps = (*[0]byte)(C._gotk4_gstbase1_BaseParse_get_sink_caps) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstbase1_BaseParse_get_sink_caps", + func(carg0 *C.GstBaseParse, carg1 *C.GstCaps) (cret *C.GstCaps) { + var parse Instance // go GstBaseParse subclass + var filter *gst.Caps // in, none, converted + var goret *gst.Caps // return, full, converted + + parse = UnsafeBaseParseFromGlibNone(unsafe.Pointer(carg0)).(Instance) + filter = gst.UnsafeCapsFromGlibNone(unsafe.Pointer(carg1)) + + goret = overrides.GetSinkCaps(parse, filter) + + cret = (*C.GstCaps)(gst.UnsafeCapsToGlibFull(goret)) + + return cret + }, + ) } if overrides.HandleFrame != nil { pclass.handle_frame = (*[0]byte)(C._gotk4_gstbase1_BaseParse_handle_frame) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstbase1_BaseParse_handle_frame", + func(carg0 *C.GstBaseParse, carg1 *C.GstBaseParseFrame, carg2 *C.gint) (cret C.GstFlowReturn) { + var parse Instance // go GstBaseParse subclass + var frame *BaseParseFrame // in, none, converted + var skipsize int // out, full, casted + var goret gst.FlowReturn // return, none, casted + + parse = UnsafeBaseParseFromGlibNone(unsafe.Pointer(carg0)).(Instance) + frame = UnsafeBaseParseFrameFromGlibNone(unsafe.Pointer(carg1)) + + skipsize, goret = overrides.HandleFrame(parse, frame) + + *carg2 = C.gint(skipsize) + cret = C.GstFlowReturn(goret) + + return cret + }, + ) } if overrides.PrePushFrame != nil { pclass.pre_push_frame = (*[0]byte)(C._gotk4_gstbase1_BaseParse_pre_push_frame) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstbase1_BaseParse_pre_push_frame", + func(carg0 *C.GstBaseParse, carg1 *C.GstBaseParseFrame) (cret C.GstFlowReturn) { + var parse Instance // go GstBaseParse subclass + var frame *BaseParseFrame // in, none, converted + var goret gst.FlowReturn // return, none, casted + + parse = UnsafeBaseParseFromGlibNone(unsafe.Pointer(carg0)).(Instance) + frame = UnsafeBaseParseFrameFromGlibNone(unsafe.Pointer(carg1)) + + goret = overrides.PrePushFrame(parse, frame) + + cret = C.GstFlowReturn(goret) + + return cret + }, + ) } if overrides.SetSinkCaps != nil { pclass.set_sink_caps = (*[0]byte)(C._gotk4_gstbase1_BaseParse_set_sink_caps) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstbase1_BaseParse_set_sink_caps", + func(carg0 *C.GstBaseParse, carg1 *C.GstCaps) (cret C.gboolean) { + var parse Instance // go GstBaseParse subclass + var caps *gst.Caps // in, none, converted + var goret bool // return + + parse = UnsafeBaseParseFromGlibNone(unsafe.Pointer(carg0)).(Instance) + caps = gst.UnsafeCapsFromGlibNone(unsafe.Pointer(carg1)) + + goret = overrides.SetSinkCaps(parse, caps) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.SinkEvent != nil { pclass.sink_event = (*[0]byte)(C._gotk4_gstbase1_BaseParse_sink_event) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstbase1_BaseParse_sink_event", + func(carg0 *C.GstBaseParse, carg1 *C.GstEvent) (cret C.gboolean) { + var parse Instance // go GstBaseParse subclass + var event *gst.Event // in, none, converted + var goret bool // return + + parse = UnsafeBaseParseFromGlibNone(unsafe.Pointer(carg0)).(Instance) + event = gst.UnsafeEventFromGlibNone(unsafe.Pointer(carg1)) + + goret = overrides.SinkEvent(parse, event) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.SinkQuery != nil { pclass.sink_query = (*[0]byte)(C._gotk4_gstbase1_BaseParse_sink_query) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstbase1_BaseParse_sink_query", + func(carg0 *C.GstBaseParse, carg1 *C.GstQuery) (cret C.gboolean) { + var parse Instance // go GstBaseParse subclass + var query *gst.Query // in, none, converted + var goret bool // return + + parse = UnsafeBaseParseFromGlibNone(unsafe.Pointer(carg0)).(Instance) + query = gst.UnsafeQueryFromGlibNone(unsafe.Pointer(carg1)) + + goret = overrides.SinkQuery(parse, query) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.SrcEvent != nil { pclass.src_event = (*[0]byte)(C._gotk4_gstbase1_BaseParse_src_event) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstbase1_BaseParse_src_event", + func(carg0 *C.GstBaseParse, carg1 *C.GstEvent) (cret C.gboolean) { + var parse Instance // go GstBaseParse subclass + var event *gst.Event // in, none, converted + var goret bool // return + + parse = UnsafeBaseParseFromGlibNone(unsafe.Pointer(carg0)).(Instance) + event = gst.UnsafeEventFromGlibNone(unsafe.Pointer(carg1)) + + goret = overrides.SrcEvent(parse, event) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.SrcQuery != nil { pclass.src_query = (*[0]byte)(C._gotk4_gstbase1_BaseParse_src_query) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstbase1_BaseParse_src_query", + func(carg0 *C.GstBaseParse, carg1 *C.GstQuery) (cret C.gboolean) { + var parse Instance // go GstBaseParse subclass + var query *gst.Query // in, none, converted + var goret bool // return + + parse = UnsafeBaseParseFromGlibNone(unsafe.Pointer(carg0)).(Instance) + query = gst.UnsafeQueryFromGlibNone(unsafe.Pointer(carg1)) + + goret = overrides.SrcQuery(parse, query) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.Start != nil { pclass.start = (*[0]byte)(C._gotk4_gstbase1_BaseParse_start) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstbase1_BaseParse_start", + func(carg0 *C.GstBaseParse) (cret C.gboolean) { + var parse Instance // go GstBaseParse subclass + var goret bool // return + + parse = UnsafeBaseParseFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + goret = overrides.Start(parse) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.Stop != nil { pclass.stop = (*[0]byte)(C._gotk4_gstbase1_BaseParse_stop) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstbase1_BaseParse_stop", + func(carg0 *C.GstBaseParse) (cret C.gboolean) { + var parse Instance // go GstBaseParse subclass + var goret bool // return + + parse = UnsafeBaseParseFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + goret = overrides.Stop(parse) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } } +// RegisterBaseParseSubClass is used to register a go subclass of GstBaseParse. For this to work safely please implement the +// virtual methods required by the implementation. +func RegisterBaseParseSubClass[InstanceT BaseParse]( + name string, + classInit func(class *BaseParseClass), + constructor func() InstanceT, + overrides BaseParseOverrides[InstanceT], + signals map[string]gobject.SignalDefinition, + interfaceInits ...gobject.SubClassInterfaceInit[InstanceT], +) gobject.Type { + return gobject.UnsafeRegisterSubClass( + name, + classInit, + constructor, + overrides, + signals, + TypeBaseParse, + UnsafeBaseParseClassFromGlibBorrow, + UnsafeApplyBaseParseOverrides, + func (obj *gobject.ObjectInstance) gobject.Object { + return unsafeWrapBaseParse(obj) + }, + interfaceInits..., + ) +} + // BaseSinkInstance is the instance type used by all types extending GstBaseSink. It is used internally by the bindings. Users should use the interface [BaseSink] instead. type BaseSinkInstance struct { _ [0]func() // equal guard @@ -6711,77 +7502,441 @@ func UnsafeApplyBaseSinkOverrides[Instance BaseSink](gclass unsafe.Pointer, over if overrides.ActivatePull != nil { pclass.activate_pull = (*[0]byte)(C._gotk4_gstbase1_BaseSink_activate_pull) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstbase1_BaseSink_activate_pull", + func(carg0 *C.GstBaseSink, carg1 C.gboolean) (cret C.gboolean) { + var sink Instance // go GstBaseSink subclass + var active bool // in + var goret bool // return + + sink = UnsafeBaseSinkFromGlibNone(unsafe.Pointer(carg0)).(Instance) + if carg1 != 0 { + active = true + } + + goret = overrides.ActivatePull(sink, active) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.Event != nil { pclass.event = (*[0]byte)(C._gotk4_gstbase1_BaseSink_event) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstbase1_BaseSink_event", + func(carg0 *C.GstBaseSink, carg1 *C.GstEvent) (cret C.gboolean) { + var sink Instance // go GstBaseSink subclass + var event *gst.Event // in, none, converted + var goret bool // return + + sink = UnsafeBaseSinkFromGlibNone(unsafe.Pointer(carg0)).(Instance) + event = gst.UnsafeEventFromGlibNone(unsafe.Pointer(carg1)) + + goret = overrides.Event(sink, event) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.Fixate != nil { pclass.fixate = (*[0]byte)(C._gotk4_gstbase1_BaseSink_fixate) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstbase1_BaseSink_fixate", + func(carg0 *C.GstBaseSink, carg1 *C.GstCaps) (cret *C.GstCaps) { + var sink Instance // go GstBaseSink subclass + var caps *gst.Caps // in, none, converted + var goret *gst.Caps // return, full, converted + + sink = UnsafeBaseSinkFromGlibNone(unsafe.Pointer(carg0)).(Instance) + caps = gst.UnsafeCapsFromGlibNone(unsafe.Pointer(carg1)) + + goret = overrides.Fixate(sink, caps) + + cret = (*C.GstCaps)(gst.UnsafeCapsToGlibFull(goret)) + + return cret + }, + ) } if overrides.GetCaps != nil { pclass.get_caps = (*[0]byte)(C._gotk4_gstbase1_BaseSink_get_caps) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstbase1_BaseSink_get_caps", + func(carg0 *C.GstBaseSink, carg1 *C.GstCaps) (cret *C.GstCaps) { + var sink Instance // go GstBaseSink subclass + var filter *gst.Caps // in, none, converted, nullable + var goret *gst.Caps // return, full, converted + + sink = UnsafeBaseSinkFromGlibNone(unsafe.Pointer(carg0)).(Instance) + if carg1 != nil { + filter = gst.UnsafeCapsFromGlibNone(unsafe.Pointer(carg1)) + } + + goret = overrides.GetCaps(sink, filter) + + cret = (*C.GstCaps)(gst.UnsafeCapsToGlibFull(goret)) + + return cret + }, + ) } if overrides.GetTimes != nil { pclass.get_times = (*[0]byte)(C._gotk4_gstbase1_BaseSink_get_times) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstbase1_BaseSink_get_times", + func(carg0 *C.GstBaseSink, carg1 *C.GstBuffer, carg2 *C.GstClockTime, carg3 *C.GstClockTime) { + var sink Instance // go GstBaseSink subclass + var buffer *gst.Buffer // in, none, converted + var start gst.ClockTime // out, full, casted, alias + var end gst.ClockTime // out, full, casted, alias + + sink = UnsafeBaseSinkFromGlibNone(unsafe.Pointer(carg0)).(Instance) + buffer = gst.UnsafeBufferFromGlibNone(unsafe.Pointer(carg1)) + + start, end = overrides.GetTimes(sink, buffer) + + *carg2 = C.GstClockTime(start) + *carg3 = C.GstClockTime(end) + }, + ) } if overrides.Prepare != nil { pclass.prepare = (*[0]byte)(C._gotk4_gstbase1_BaseSink_prepare) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstbase1_BaseSink_prepare", + func(carg0 *C.GstBaseSink, carg1 *C.GstBuffer) (cret C.GstFlowReturn) { + var sink Instance // go GstBaseSink subclass + var buffer *gst.Buffer // in, none, converted + var goret gst.FlowReturn // return, none, casted + + sink = UnsafeBaseSinkFromGlibNone(unsafe.Pointer(carg0)).(Instance) + buffer = gst.UnsafeBufferFromGlibNone(unsafe.Pointer(carg1)) + + goret = overrides.Prepare(sink, buffer) + + cret = C.GstFlowReturn(goret) + + return cret + }, + ) } if overrides.PrepareList != nil { pclass.prepare_list = (*[0]byte)(C._gotk4_gstbase1_BaseSink_prepare_list) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstbase1_BaseSink_prepare_list", + func(carg0 *C.GstBaseSink, carg1 *C.GstBufferList) (cret C.GstFlowReturn) { + var sink Instance // go GstBaseSink subclass + var bufferList *gst.BufferList // in, none, converted + var goret gst.FlowReturn // return, none, casted + + sink = UnsafeBaseSinkFromGlibNone(unsafe.Pointer(carg0)).(Instance) + bufferList = gst.UnsafeBufferListFromGlibNone(unsafe.Pointer(carg1)) + + goret = overrides.PrepareList(sink, bufferList) + + cret = C.GstFlowReturn(goret) + + return cret + }, + ) } if overrides.Preroll != nil { pclass.preroll = (*[0]byte)(C._gotk4_gstbase1_BaseSink_preroll) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstbase1_BaseSink_preroll", + func(carg0 *C.GstBaseSink, carg1 *C.GstBuffer) (cret C.GstFlowReturn) { + var sink Instance // go GstBaseSink subclass + var buffer *gst.Buffer // in, none, converted + var goret gst.FlowReturn // return, none, casted + + sink = UnsafeBaseSinkFromGlibNone(unsafe.Pointer(carg0)).(Instance) + buffer = gst.UnsafeBufferFromGlibNone(unsafe.Pointer(carg1)) + + goret = overrides.Preroll(sink, buffer) + + cret = C.GstFlowReturn(goret) + + return cret + }, + ) } if overrides.ProposeAllocation != nil { pclass.propose_allocation = (*[0]byte)(C._gotk4_gstbase1_BaseSink_propose_allocation) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstbase1_BaseSink_propose_allocation", + func(carg0 *C.GstBaseSink, carg1 *C.GstQuery) (cret C.gboolean) { + var sink Instance // go GstBaseSink subclass + var query *gst.Query // in, none, converted + var goret bool // return + + sink = UnsafeBaseSinkFromGlibNone(unsafe.Pointer(carg0)).(Instance) + query = gst.UnsafeQueryFromGlibNone(unsafe.Pointer(carg1)) + + goret = overrides.ProposeAllocation(sink, query) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.Query != nil { pclass.query = (*[0]byte)(C._gotk4_gstbase1_BaseSink_query) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstbase1_BaseSink_query", + func(carg0 *C.GstBaseSink, carg1 *C.GstQuery) (cret C.gboolean) { + var sink Instance // go GstBaseSink subclass + var query *gst.Query // in, none, converted + var goret bool // return + + sink = UnsafeBaseSinkFromGlibNone(unsafe.Pointer(carg0)).(Instance) + query = gst.UnsafeQueryFromGlibNone(unsafe.Pointer(carg1)) + + goret = overrides.Query(sink, query) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.Render != nil { pclass.render = (*[0]byte)(C._gotk4_gstbase1_BaseSink_render) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstbase1_BaseSink_render", + func(carg0 *C.GstBaseSink, carg1 *C.GstBuffer) (cret C.GstFlowReturn) { + var sink Instance // go GstBaseSink subclass + var buffer *gst.Buffer // in, none, converted + var goret gst.FlowReturn // return, none, casted + + sink = UnsafeBaseSinkFromGlibNone(unsafe.Pointer(carg0)).(Instance) + buffer = gst.UnsafeBufferFromGlibNone(unsafe.Pointer(carg1)) + + goret = overrides.Render(sink, buffer) + + cret = C.GstFlowReturn(goret) + + return cret + }, + ) } if overrides.RenderList != nil { pclass.render_list = (*[0]byte)(C._gotk4_gstbase1_BaseSink_render_list) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstbase1_BaseSink_render_list", + func(carg0 *C.GstBaseSink, carg1 *C.GstBufferList) (cret C.GstFlowReturn) { + var sink Instance // go GstBaseSink subclass + var bufferList *gst.BufferList // in, none, converted + var goret gst.FlowReturn // return, none, casted + + sink = UnsafeBaseSinkFromGlibNone(unsafe.Pointer(carg0)).(Instance) + bufferList = gst.UnsafeBufferListFromGlibNone(unsafe.Pointer(carg1)) + + goret = overrides.RenderList(sink, bufferList) + + cret = C.GstFlowReturn(goret) + + return cret + }, + ) } if overrides.SetCaps != nil { pclass.set_caps = (*[0]byte)(C._gotk4_gstbase1_BaseSink_set_caps) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstbase1_BaseSink_set_caps", + func(carg0 *C.GstBaseSink, carg1 *C.GstCaps) (cret C.gboolean) { + var sink Instance // go GstBaseSink subclass + var caps *gst.Caps // in, none, converted + var goret bool // return + + sink = UnsafeBaseSinkFromGlibNone(unsafe.Pointer(carg0)).(Instance) + caps = gst.UnsafeCapsFromGlibNone(unsafe.Pointer(carg1)) + + goret = overrides.SetCaps(sink, caps) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.Start != nil { pclass.start = (*[0]byte)(C._gotk4_gstbase1_BaseSink_start) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstbase1_BaseSink_start", + func(carg0 *C.GstBaseSink) (cret C.gboolean) { + var sink Instance // go GstBaseSink subclass + var goret bool // return + + sink = UnsafeBaseSinkFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + goret = overrides.Start(sink) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.Stop != nil { pclass.stop = (*[0]byte)(C._gotk4_gstbase1_BaseSink_stop) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstbase1_BaseSink_stop", + func(carg0 *C.GstBaseSink) (cret C.gboolean) { + var sink Instance // go GstBaseSink subclass + var goret bool // return + + sink = UnsafeBaseSinkFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + goret = overrides.Stop(sink) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.Unlock != nil { pclass.unlock = (*[0]byte)(C._gotk4_gstbase1_BaseSink_unlock) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstbase1_BaseSink_unlock", + func(carg0 *C.GstBaseSink) (cret C.gboolean) { + var sink Instance // go GstBaseSink subclass + var goret bool // return + + sink = UnsafeBaseSinkFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + goret = overrides.Unlock(sink) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.UnlockStop != nil { pclass.unlock_stop = (*[0]byte)(C._gotk4_gstbase1_BaseSink_unlock_stop) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstbase1_BaseSink_unlock_stop", + func(carg0 *C.GstBaseSink) (cret C.gboolean) { + var sink Instance // go GstBaseSink subclass + var goret bool // return + + sink = UnsafeBaseSinkFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + goret = overrides.UnlockStop(sink) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.WaitEvent != nil { pclass.wait_event = (*[0]byte)(C._gotk4_gstbase1_BaseSink_wait_event) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstbase1_BaseSink_wait_event", + func(carg0 *C.GstBaseSink, carg1 *C.GstEvent) (cret C.GstFlowReturn) { + var sink Instance // go GstBaseSink subclass + var event *gst.Event // in, none, converted + var goret gst.FlowReturn // return, none, casted + + sink = UnsafeBaseSinkFromGlibNone(unsafe.Pointer(carg0)).(Instance) + event = gst.UnsafeEventFromGlibNone(unsafe.Pointer(carg1)) + + goret = overrides.WaitEvent(sink, event) + + cret = C.GstFlowReturn(goret) + + return cret + }, + ) } } +// RegisterBaseSinkSubClass is used to register a go subclass of GstBaseSink. For this to work safely please implement the +// virtual methods required by the implementation. +func RegisterBaseSinkSubClass[InstanceT BaseSink]( + name string, + classInit func(class *BaseSinkClass), + constructor func() InstanceT, + overrides BaseSinkOverrides[InstanceT], + signals map[string]gobject.SignalDefinition, + interfaceInits ...gobject.SubClassInterfaceInit[InstanceT], +) gobject.Type { + return gobject.UnsafeRegisterSubClass( + name, + classInit, + constructor, + overrides, + signals, + TypeBaseSink, + UnsafeBaseSinkClassFromGlibBorrow, + UnsafeApplyBaseSinkOverrides, + func (obj *gobject.ObjectInstance) gobject.Object { + return unsafeWrapBaseSink(obj) + }, + interfaceInits..., + ) +} + // BaseSrcInstance is the instance type used by all types extending GstBaseSrc. It is used internally by the bindings. Users should use the interface [BaseSrc] instead. type BaseSrcInstance struct { _ [0]func() // equal guard @@ -8087,77 +9242,453 @@ func UnsafeApplyBaseSrcOverrides[Instance BaseSrc](gclass unsafe.Pointer, overri if overrides.Alloc != nil { pclass.alloc = (*[0]byte)(C._gotk4_gstbase1_BaseSrc_alloc) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstbase1_BaseSrc_alloc", + func(carg0 *C.GstBaseSrc, carg1 C.guint64, carg2 C.guint, carg3 **C.GstBuffer) (cret C.GstFlowReturn) { + var src Instance // go GstBaseSrc subclass + var offset uint64 // in, none, casted + var size uint // in, none, casted + var buf *gst.Buffer // out, full, converted + var goret gst.FlowReturn // return, none, casted + + src = UnsafeBaseSrcFromGlibNone(unsafe.Pointer(carg0)).(Instance) + offset = uint64(carg1) + size = uint(carg2) + + buf, goret = overrides.Alloc(src, offset, size) + + *carg3 = (*C.GstBuffer)(gst.UnsafeBufferToGlibFull(buf)) + cret = C.GstFlowReturn(goret) + + return cret + }, + ) } if overrides.DecideAllocation != nil { pclass.decide_allocation = (*[0]byte)(C._gotk4_gstbase1_BaseSrc_decide_allocation) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstbase1_BaseSrc_decide_allocation", + func(carg0 *C.GstBaseSrc, carg1 *C.GstQuery) (cret C.gboolean) { + var src Instance // go GstBaseSrc subclass + var query *gst.Query // in, none, converted + var goret bool // return + + src = UnsafeBaseSrcFromGlibNone(unsafe.Pointer(carg0)).(Instance) + query = gst.UnsafeQueryFromGlibNone(unsafe.Pointer(carg1)) + + goret = overrides.DecideAllocation(src, query) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.DoSeek != nil { pclass.do_seek = (*[0]byte)(C._gotk4_gstbase1_BaseSrc_do_seek) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstbase1_BaseSrc_do_seek", + func(carg0 *C.GstBaseSrc, carg1 *C.GstSegment) (cret C.gboolean) { + var src Instance // go GstBaseSrc subclass + var segment *gst.Segment // in, none, converted + var goret bool // return + + src = UnsafeBaseSrcFromGlibNone(unsafe.Pointer(carg0)).(Instance) + segment = gst.UnsafeSegmentFromGlibNone(unsafe.Pointer(carg1)) + + goret = overrides.DoSeek(src, segment) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.Event != nil { pclass.event = (*[0]byte)(C._gotk4_gstbase1_BaseSrc_event) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstbase1_BaseSrc_event", + func(carg0 *C.GstBaseSrc, carg1 *C.GstEvent) (cret C.gboolean) { + var src Instance // go GstBaseSrc subclass + var event *gst.Event // in, none, converted + var goret bool // return + + src = UnsafeBaseSrcFromGlibNone(unsafe.Pointer(carg0)).(Instance) + event = gst.UnsafeEventFromGlibNone(unsafe.Pointer(carg1)) + + goret = overrides.Event(src, event) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.Fill != nil { pclass.fill = (*[0]byte)(C._gotk4_gstbase1_BaseSrc_fill) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstbase1_BaseSrc_fill", + func(carg0 *C.GstBaseSrc, carg1 C.guint64, carg2 C.guint, carg3 *C.GstBuffer) (cret C.GstFlowReturn) { + var src Instance // go GstBaseSrc subclass + var offset uint64 // in, none, casted + var size uint // in, none, casted + var buf *gst.Buffer // in, none, converted + var goret gst.FlowReturn // return, none, casted + + src = UnsafeBaseSrcFromGlibNone(unsafe.Pointer(carg0)).(Instance) + offset = uint64(carg1) + size = uint(carg2) + buf = gst.UnsafeBufferFromGlibNone(unsafe.Pointer(carg3)) + + goret = overrides.Fill(src, offset, size, buf) + + cret = C.GstFlowReturn(goret) + + return cret + }, + ) } if overrides.Fixate != nil { pclass.fixate = (*[0]byte)(C._gotk4_gstbase1_BaseSrc_fixate) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstbase1_BaseSrc_fixate", + func(carg0 *C.GstBaseSrc, carg1 *C.GstCaps) (cret *C.GstCaps) { + var src Instance // go GstBaseSrc subclass + var caps *gst.Caps // in, full, converted + var goret *gst.Caps // return, full, converted + + src = UnsafeBaseSrcFromGlibNone(unsafe.Pointer(carg0)).(Instance) + caps = gst.UnsafeCapsFromGlibFull(unsafe.Pointer(carg1)) + + goret = overrides.Fixate(src, caps) + + cret = (*C.GstCaps)(gst.UnsafeCapsToGlibFull(goret)) + + return cret + }, + ) } if overrides.GetCaps != nil { pclass.get_caps = (*[0]byte)(C._gotk4_gstbase1_BaseSrc_get_caps) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstbase1_BaseSrc_get_caps", + func(carg0 *C.GstBaseSrc, carg1 *C.GstCaps) (cret *C.GstCaps) { + var src Instance // go GstBaseSrc subclass + var filter *gst.Caps // in, none, converted, nullable + var goret *gst.Caps // return, full, converted + + src = UnsafeBaseSrcFromGlibNone(unsafe.Pointer(carg0)).(Instance) + if carg1 != nil { + filter = gst.UnsafeCapsFromGlibNone(unsafe.Pointer(carg1)) + } + + goret = overrides.GetCaps(src, filter) + + cret = (*C.GstCaps)(gst.UnsafeCapsToGlibFull(goret)) + + return cret + }, + ) } if overrides.GetSize != nil { pclass.get_size = (*[0]byte)(C._gotk4_gstbase1_BaseSrc_get_size) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstbase1_BaseSrc_get_size", + func(carg0 *C.GstBaseSrc, carg1 *C.guint64) (cret C.gboolean) { + var src Instance // go GstBaseSrc subclass + var size uint64 // out, full, casted + var goret bool // return + + src = UnsafeBaseSrcFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + size, goret = overrides.GetSize(src) + + *carg1 = C.guint64(size) + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.GetTimes != nil { pclass.get_times = (*[0]byte)(C._gotk4_gstbase1_BaseSrc_get_times) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstbase1_BaseSrc_get_times", + func(carg0 *C.GstBaseSrc, carg1 *C.GstBuffer, carg2 *C.GstClockTime, carg3 *C.GstClockTime) { + var src Instance // go GstBaseSrc subclass + var buffer *gst.Buffer // in, none, converted + var start gst.ClockTime // out, full, casted, alias + var end gst.ClockTime // out, full, casted, alias + + src = UnsafeBaseSrcFromGlibNone(unsafe.Pointer(carg0)).(Instance) + buffer = gst.UnsafeBufferFromGlibNone(unsafe.Pointer(carg1)) + + start, end = overrides.GetTimes(src, buffer) + + *carg2 = C.GstClockTime(start) + *carg3 = C.GstClockTime(end) + }, + ) } if overrides.IsSeekable != nil { pclass.is_seekable = (*[0]byte)(C._gotk4_gstbase1_BaseSrc_is_seekable) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstbase1_BaseSrc_is_seekable", + func(carg0 *C.GstBaseSrc) (cret C.gboolean) { + var src Instance // go GstBaseSrc subclass + var goret bool // return + + src = UnsafeBaseSrcFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + goret = overrides.IsSeekable(src) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.Negotiate != nil { pclass.negotiate = (*[0]byte)(C._gotk4_gstbase1_BaseSrc_negotiate) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstbase1_BaseSrc_negotiate", + func(carg0 *C.GstBaseSrc) (cret C.gboolean) { + var src Instance // go GstBaseSrc subclass + var goret bool // return + + src = UnsafeBaseSrcFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + goret = overrides.Negotiate(src) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.PrepareSeekSegment != nil { pclass.prepare_seek_segment = (*[0]byte)(C._gotk4_gstbase1_BaseSrc_prepare_seek_segment) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstbase1_BaseSrc_prepare_seek_segment", + func(carg0 *C.GstBaseSrc, carg1 *C.GstEvent, carg2 *C.GstSegment) (cret C.gboolean) { + var src Instance // go GstBaseSrc subclass + var seek *gst.Event // in, none, converted + var segment *gst.Segment // in, none, converted + var goret bool // return + + src = UnsafeBaseSrcFromGlibNone(unsafe.Pointer(carg0)).(Instance) + seek = gst.UnsafeEventFromGlibNone(unsafe.Pointer(carg1)) + segment = gst.UnsafeSegmentFromGlibNone(unsafe.Pointer(carg2)) + + goret = overrides.PrepareSeekSegment(src, seek, segment) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.Query != nil { pclass.query = (*[0]byte)(C._gotk4_gstbase1_BaseSrc_query) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstbase1_BaseSrc_query", + func(carg0 *C.GstBaseSrc, carg1 *C.GstQuery) (cret C.gboolean) { + var src Instance // go GstBaseSrc subclass + var query *gst.Query // in, none, converted + var goret bool // return + + src = UnsafeBaseSrcFromGlibNone(unsafe.Pointer(carg0)).(Instance) + query = gst.UnsafeQueryFromGlibNone(unsafe.Pointer(carg1)) + + goret = overrides.Query(src, query) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.SetCaps != nil { pclass.set_caps = (*[0]byte)(C._gotk4_gstbase1_BaseSrc_set_caps) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstbase1_BaseSrc_set_caps", + func(carg0 *C.GstBaseSrc, carg1 *C.GstCaps) (cret C.gboolean) { + var src Instance // go GstBaseSrc subclass + var caps *gst.Caps // in, none, converted + var goret bool // return + + src = UnsafeBaseSrcFromGlibNone(unsafe.Pointer(carg0)).(Instance) + caps = gst.UnsafeCapsFromGlibNone(unsafe.Pointer(carg1)) + + goret = overrides.SetCaps(src, caps) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.Start != nil { pclass.start = (*[0]byte)(C._gotk4_gstbase1_BaseSrc_start) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstbase1_BaseSrc_start", + func(carg0 *C.GstBaseSrc) (cret C.gboolean) { + var src Instance // go GstBaseSrc subclass + var goret bool // return + + src = UnsafeBaseSrcFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + goret = overrides.Start(src) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.Stop != nil { pclass.stop = (*[0]byte)(C._gotk4_gstbase1_BaseSrc_stop) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstbase1_BaseSrc_stop", + func(carg0 *C.GstBaseSrc) (cret C.gboolean) { + var src Instance // go GstBaseSrc subclass + var goret bool // return + + src = UnsafeBaseSrcFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + goret = overrides.Stop(src) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.Unlock != nil { pclass.unlock = (*[0]byte)(C._gotk4_gstbase1_BaseSrc_unlock) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstbase1_BaseSrc_unlock", + func(carg0 *C.GstBaseSrc) (cret C.gboolean) { + var src Instance // go GstBaseSrc subclass + var goret bool // return + + src = UnsafeBaseSrcFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + goret = overrides.Unlock(src) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.UnlockStop != nil { pclass.unlock_stop = (*[0]byte)(C._gotk4_gstbase1_BaseSrc_unlock_stop) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstbase1_BaseSrc_unlock_stop", + func(carg0 *C.GstBaseSrc) (cret C.gboolean) { + var src Instance // go GstBaseSrc subclass + var goret bool // return + + src = UnsafeBaseSrcFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + goret = overrides.UnlockStop(src) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } } +// RegisterBaseSrcSubClass is used to register a go subclass of GstBaseSrc. For this to work safely please implement the +// virtual methods required by the implementation. +func RegisterBaseSrcSubClass[InstanceT BaseSrc]( + name string, + classInit func(class *BaseSrcClass), + constructor func() InstanceT, + overrides BaseSrcOverrides[InstanceT], + signals map[string]gobject.SignalDefinition, + interfaceInits ...gobject.SubClassInterfaceInit[InstanceT], +) gobject.Type { + return gobject.UnsafeRegisterSubClass( + name, + classInit, + constructor, + overrides, + signals, + TypeBaseSrc, + UnsafeBaseSrcClassFromGlibBorrow, + UnsafeApplyBaseSrcOverrides, + func (obj *gobject.ObjectInstance) gobject.Object { + return unsafeWrapBaseSrc(obj) + }, + interfaceInits..., + ) +} + // BaseTransformInstance is the instance type used by all types extending GstBaseTransform. It is used internally by the bindings. Users should use the interface [BaseTransform] instead. type BaseTransformInstance struct { _ [0]func() // equal guard @@ -9124,93 +10655,578 @@ func UnsafeApplyBaseTransformOverrides[Instance BaseTransform](gclass unsafe.Poi if overrides.AcceptCaps != nil { pclass.accept_caps = (*[0]byte)(C._gotk4_gstbase1_BaseTransform_accept_caps) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstbase1_BaseTransform_accept_caps", + func(carg0 *C.GstBaseTransform, carg1 C.GstPadDirection, carg2 *C.GstCaps) (cret C.gboolean) { + var trans Instance // go GstBaseTransform subclass + var direction gst.PadDirection // in, none, casted + var caps *gst.Caps // in, none, converted + var goret bool // return + + trans = UnsafeBaseTransformFromGlibNone(unsafe.Pointer(carg0)).(Instance) + direction = gst.PadDirection(carg1) + caps = gst.UnsafeCapsFromGlibNone(unsafe.Pointer(carg2)) + + goret = overrides.AcceptCaps(trans, direction, caps) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.BeforeTransform != nil { pclass.before_transform = (*[0]byte)(C._gotk4_gstbase1_BaseTransform_before_transform) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstbase1_BaseTransform_before_transform", + func(carg0 *C.GstBaseTransform, carg1 *C.GstBuffer) { + var trans Instance // go GstBaseTransform subclass + var buffer *gst.Buffer // in, none, converted + + trans = UnsafeBaseTransformFromGlibNone(unsafe.Pointer(carg0)).(Instance) + buffer = gst.UnsafeBufferFromGlibNone(unsafe.Pointer(carg1)) + + overrides.BeforeTransform(trans, buffer) + }, + ) } if overrides.CopyMetadata != nil { pclass.copy_metadata = (*[0]byte)(C._gotk4_gstbase1_BaseTransform_copy_metadata) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstbase1_BaseTransform_copy_metadata", + func(carg0 *C.GstBaseTransform, carg1 *C.GstBuffer, carg2 *C.GstBuffer) (cret C.gboolean) { + var trans Instance // go GstBaseTransform subclass + var input *gst.Buffer // in, none, converted + var outbuf *gst.Buffer // in, none, converted + var goret bool // return + + trans = UnsafeBaseTransformFromGlibNone(unsafe.Pointer(carg0)).(Instance) + input = gst.UnsafeBufferFromGlibNone(unsafe.Pointer(carg1)) + outbuf = gst.UnsafeBufferFromGlibNone(unsafe.Pointer(carg2)) + + goret = overrides.CopyMetadata(trans, input, outbuf) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.DecideAllocation != nil { pclass.decide_allocation = (*[0]byte)(C._gotk4_gstbase1_BaseTransform_decide_allocation) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstbase1_BaseTransform_decide_allocation", + func(carg0 *C.GstBaseTransform, carg1 *C.GstQuery) (cret C.gboolean) { + var trans Instance // go GstBaseTransform subclass + var query *gst.Query // in, none, converted + var goret bool // return + + trans = UnsafeBaseTransformFromGlibNone(unsafe.Pointer(carg0)).(Instance) + query = gst.UnsafeQueryFromGlibNone(unsafe.Pointer(carg1)) + + goret = overrides.DecideAllocation(trans, query) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.FilterMeta != nil { pclass.filter_meta = (*[0]byte)(C._gotk4_gstbase1_BaseTransform_filter_meta) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstbase1_BaseTransform_filter_meta", + func(carg0 *C.GstBaseTransform, carg1 *C.GstQuery, carg2 C.GType, carg3 *C.GstStructure) (cret C.gboolean) { + var trans Instance // go GstBaseTransform subclass + var query *gst.Query // in, none, converted + var api gobject.Type // in, none, casted, alias + var params *gst.Structure // in, none, converted + var goret bool // return + + trans = UnsafeBaseTransformFromGlibNone(unsafe.Pointer(carg0)).(Instance) + query = gst.UnsafeQueryFromGlibNone(unsafe.Pointer(carg1)) + api = gobject.Type(carg2) + params = gst.UnsafeStructureFromGlibNone(unsafe.Pointer(carg3)) + + goret = overrides.FilterMeta(trans, query, api, params) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.FixateCaps != nil { pclass.fixate_caps = (*[0]byte)(C._gotk4_gstbase1_BaseTransform_fixate_caps) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstbase1_BaseTransform_fixate_caps", + func(carg0 *C.GstBaseTransform, carg1 C.GstPadDirection, carg2 *C.GstCaps, carg3 *C.GstCaps) (cret *C.GstCaps) { + var trans Instance // go GstBaseTransform subclass + var direction gst.PadDirection // in, none, casted + var caps *gst.Caps // in, none, converted + var othercaps *gst.Caps // in, full, converted + var goret *gst.Caps // return, full, converted + + trans = UnsafeBaseTransformFromGlibNone(unsafe.Pointer(carg0)).(Instance) + direction = gst.PadDirection(carg1) + caps = gst.UnsafeCapsFromGlibNone(unsafe.Pointer(carg2)) + othercaps = gst.UnsafeCapsFromGlibFull(unsafe.Pointer(carg3)) + + goret = overrides.FixateCaps(trans, direction, caps, othercaps) + + cret = (*C.GstCaps)(gst.UnsafeCapsToGlibFull(goret)) + + return cret + }, + ) } if overrides.GenerateOutput != nil { pclass.generate_output = (*[0]byte)(C._gotk4_gstbase1_BaseTransform_generate_output) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstbase1_BaseTransform_generate_output", + func(carg0 *C.GstBaseTransform, carg1 **C.GstBuffer) (cret C.GstFlowReturn) { + var trans Instance // go GstBaseTransform subclass + var outbuf *gst.Buffer // out, full, converted + var goret gst.FlowReturn // return, none, casted + + trans = UnsafeBaseTransformFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + outbuf, goret = overrides.GenerateOutput(trans) + + *carg1 = (*C.GstBuffer)(gst.UnsafeBufferToGlibFull(outbuf)) + cret = C.GstFlowReturn(goret) + + return cret + }, + ) } if overrides.GetUnitSize != nil { pclass.get_unit_size = (*[0]byte)(C._gotk4_gstbase1_BaseTransform_get_unit_size) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstbase1_BaseTransform_get_unit_size", + func(carg0 *C.GstBaseTransform, carg1 *C.GstCaps, carg2 *C.gsize) (cret C.gboolean) { + var trans Instance // go GstBaseTransform subclass + var caps *gst.Caps // in, none, converted + var size uint // out, full, casted + var goret bool // return + + trans = UnsafeBaseTransformFromGlibNone(unsafe.Pointer(carg0)).(Instance) + caps = gst.UnsafeCapsFromGlibNone(unsafe.Pointer(carg1)) + + size, goret = overrides.GetUnitSize(trans, caps) + + *carg2 = C.gsize(size) + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.PrepareOutputBuffer != nil { pclass.prepare_output_buffer = (*[0]byte)(C._gotk4_gstbase1_BaseTransform_prepare_output_buffer) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstbase1_BaseTransform_prepare_output_buffer", + func(carg0 *C.GstBaseTransform, carg1 *C.GstBuffer, carg2 **C.GstBuffer) (cret C.GstFlowReturn) { + var trans Instance // go GstBaseTransform subclass + var input *gst.Buffer // in, none, converted + var outbuf *gst.Buffer // out, full, converted + var goret gst.FlowReturn // return, none, casted + + trans = UnsafeBaseTransformFromGlibNone(unsafe.Pointer(carg0)).(Instance) + input = gst.UnsafeBufferFromGlibNone(unsafe.Pointer(carg1)) + + outbuf, goret = overrides.PrepareOutputBuffer(trans, input) + + *carg2 = (*C.GstBuffer)(gst.UnsafeBufferToGlibFull(outbuf)) + cret = C.GstFlowReturn(goret) + + return cret + }, + ) } if overrides.ProposeAllocation != nil { pclass.propose_allocation = (*[0]byte)(C._gotk4_gstbase1_BaseTransform_propose_allocation) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstbase1_BaseTransform_propose_allocation", + func(carg0 *C.GstBaseTransform, carg1 *C.GstQuery, carg2 *C.GstQuery) (cret C.gboolean) { + var trans Instance // go GstBaseTransform subclass + var decideQuery *gst.Query // in, none, converted + var query *gst.Query // in, none, converted + var goret bool // return + + trans = UnsafeBaseTransformFromGlibNone(unsafe.Pointer(carg0)).(Instance) + decideQuery = gst.UnsafeQueryFromGlibNone(unsafe.Pointer(carg1)) + query = gst.UnsafeQueryFromGlibNone(unsafe.Pointer(carg2)) + + goret = overrides.ProposeAllocation(trans, decideQuery, query) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.Query != nil { pclass.query = (*[0]byte)(C._gotk4_gstbase1_BaseTransform_query) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstbase1_BaseTransform_query", + func(carg0 *C.GstBaseTransform, carg1 C.GstPadDirection, carg2 *C.GstQuery) (cret C.gboolean) { + var trans Instance // go GstBaseTransform subclass + var direction gst.PadDirection // in, none, casted + var query *gst.Query // in, none, converted + var goret bool // return + + trans = UnsafeBaseTransformFromGlibNone(unsafe.Pointer(carg0)).(Instance) + direction = gst.PadDirection(carg1) + query = gst.UnsafeQueryFromGlibNone(unsafe.Pointer(carg2)) + + goret = overrides.Query(trans, direction, query) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.SetCaps != nil { pclass.set_caps = (*[0]byte)(C._gotk4_gstbase1_BaseTransform_set_caps) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstbase1_BaseTransform_set_caps", + func(carg0 *C.GstBaseTransform, carg1 *C.GstCaps, carg2 *C.GstCaps) (cret C.gboolean) { + var trans Instance // go GstBaseTransform subclass + var incaps *gst.Caps // in, none, converted + var outcaps *gst.Caps // in, none, converted + var goret bool // return + + trans = UnsafeBaseTransformFromGlibNone(unsafe.Pointer(carg0)).(Instance) + incaps = gst.UnsafeCapsFromGlibNone(unsafe.Pointer(carg1)) + outcaps = gst.UnsafeCapsFromGlibNone(unsafe.Pointer(carg2)) + + goret = overrides.SetCaps(trans, incaps, outcaps) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.SinkEvent != nil { pclass.sink_event = (*[0]byte)(C._gotk4_gstbase1_BaseTransform_sink_event) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstbase1_BaseTransform_sink_event", + func(carg0 *C.GstBaseTransform, carg1 *C.GstEvent) (cret C.gboolean) { + var trans Instance // go GstBaseTransform subclass + var event *gst.Event // in, full, converted + var goret bool // return + + trans = UnsafeBaseTransformFromGlibNone(unsafe.Pointer(carg0)).(Instance) + event = gst.UnsafeEventFromGlibFull(unsafe.Pointer(carg1)) + + goret = overrides.SinkEvent(trans, event) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.SrcEvent != nil { pclass.src_event = (*[0]byte)(C._gotk4_gstbase1_BaseTransform_src_event) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstbase1_BaseTransform_src_event", + func(carg0 *C.GstBaseTransform, carg1 *C.GstEvent) (cret C.gboolean) { + var trans Instance // go GstBaseTransform subclass + var event *gst.Event // in, full, converted + var goret bool // return + + trans = UnsafeBaseTransformFromGlibNone(unsafe.Pointer(carg0)).(Instance) + event = gst.UnsafeEventFromGlibFull(unsafe.Pointer(carg1)) + + goret = overrides.SrcEvent(trans, event) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.Start != nil { pclass.start = (*[0]byte)(C._gotk4_gstbase1_BaseTransform_start) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstbase1_BaseTransform_start", + func(carg0 *C.GstBaseTransform) (cret C.gboolean) { + var trans Instance // go GstBaseTransform subclass + var goret bool // return + + trans = UnsafeBaseTransformFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + goret = overrides.Start(trans) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.Stop != nil { pclass.stop = (*[0]byte)(C._gotk4_gstbase1_BaseTransform_stop) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstbase1_BaseTransform_stop", + func(carg0 *C.GstBaseTransform) (cret C.gboolean) { + var trans Instance // go GstBaseTransform subclass + var goret bool // return + + trans = UnsafeBaseTransformFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + goret = overrides.Stop(trans) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.SubmitInputBuffer != nil { pclass.submit_input_buffer = (*[0]byte)(C._gotk4_gstbase1_BaseTransform_submit_input_buffer) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstbase1_BaseTransform_submit_input_buffer", + func(carg0 *C.GstBaseTransform, carg1 C.gboolean, carg2 *C.GstBuffer) (cret C.GstFlowReturn) { + var trans Instance // go GstBaseTransform subclass + var isDiscont bool // in + var input *gst.Buffer // in, none, converted + var goret gst.FlowReturn // return, none, casted + + trans = UnsafeBaseTransformFromGlibNone(unsafe.Pointer(carg0)).(Instance) + if carg1 != 0 { + isDiscont = true + } + input = gst.UnsafeBufferFromGlibNone(unsafe.Pointer(carg2)) + + goret = overrides.SubmitInputBuffer(trans, isDiscont, input) + + cret = C.GstFlowReturn(goret) + + return cret + }, + ) } if overrides.Transform != nil { pclass.transform = (*[0]byte)(C._gotk4_gstbase1_BaseTransform_transform) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstbase1_BaseTransform_transform", + func(carg0 *C.GstBaseTransform, carg1 *C.GstBuffer, carg2 *C.GstBuffer) (cret C.GstFlowReturn) { + var trans Instance // go GstBaseTransform subclass + var inbuf *gst.Buffer // in, none, converted + var outbuf *gst.Buffer // in, none, converted + var goret gst.FlowReturn // return, none, casted + + trans = UnsafeBaseTransformFromGlibNone(unsafe.Pointer(carg0)).(Instance) + inbuf = gst.UnsafeBufferFromGlibNone(unsafe.Pointer(carg1)) + outbuf = gst.UnsafeBufferFromGlibNone(unsafe.Pointer(carg2)) + + goret = overrides.Transform(trans, inbuf, outbuf) + + cret = C.GstFlowReturn(goret) + + return cret + }, + ) } if overrides.TransformCaps != nil { pclass.transform_caps = (*[0]byte)(C._gotk4_gstbase1_BaseTransform_transform_caps) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstbase1_BaseTransform_transform_caps", + func(carg0 *C.GstBaseTransform, carg1 C.GstPadDirection, carg2 *C.GstCaps, carg3 *C.GstCaps) (cret *C.GstCaps) { + var trans Instance // go GstBaseTransform subclass + var direction gst.PadDirection // in, none, casted + var caps *gst.Caps // in, none, converted + var filter *gst.Caps // in, none, converted + var goret *gst.Caps // return, full, converted + + trans = UnsafeBaseTransformFromGlibNone(unsafe.Pointer(carg0)).(Instance) + direction = gst.PadDirection(carg1) + caps = gst.UnsafeCapsFromGlibNone(unsafe.Pointer(carg2)) + filter = gst.UnsafeCapsFromGlibNone(unsafe.Pointer(carg3)) + + goret = overrides.TransformCaps(trans, direction, caps, filter) + + cret = (*C.GstCaps)(gst.UnsafeCapsToGlibFull(goret)) + + return cret + }, + ) } if overrides.TransformIP != nil { pclass.transform_ip = (*[0]byte)(C._gotk4_gstbase1_BaseTransform_transform_ip) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstbase1_BaseTransform_transform_ip", + func(carg0 *C.GstBaseTransform, carg1 *C.GstBuffer) (cret C.GstFlowReturn) { + var trans Instance // go GstBaseTransform subclass + var buf *gst.Buffer // in, none, converted + var goret gst.FlowReturn // return, none, casted + + trans = UnsafeBaseTransformFromGlibNone(unsafe.Pointer(carg0)).(Instance) + buf = gst.UnsafeBufferFromGlibNone(unsafe.Pointer(carg1)) + + goret = overrides.TransformIP(trans, buf) + + cret = C.GstFlowReturn(goret) + + return cret + }, + ) } if overrides.TransformMeta != nil { pclass.transform_meta = (*[0]byte)(C._gotk4_gstbase1_BaseTransform_transform_meta) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstbase1_BaseTransform_transform_meta", + func(carg0 *C.GstBaseTransform, carg1 *C.GstBuffer, carg2 *C.GstMeta, carg3 *C.GstBuffer) (cret C.gboolean) { + var trans Instance // go GstBaseTransform subclass + var outbuf *gst.Buffer // in, none, converted + var meta *gst.Meta // in, none, converted + var inbuf *gst.Buffer // in, none, converted + var goret bool // return + + trans = UnsafeBaseTransformFromGlibNone(unsafe.Pointer(carg0)).(Instance) + outbuf = gst.UnsafeBufferFromGlibNone(unsafe.Pointer(carg1)) + meta = gst.UnsafeMetaFromGlibNone(unsafe.Pointer(carg2)) + inbuf = gst.UnsafeBufferFromGlibNone(unsafe.Pointer(carg3)) + + goret = overrides.TransformMeta(trans, outbuf, meta, inbuf) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.TransformSize != nil { pclass.transform_size = (*[0]byte)(C._gotk4_gstbase1_BaseTransform_transform_size) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstbase1_BaseTransform_transform_size", + func(carg0 *C.GstBaseTransform, carg1 C.GstPadDirection, carg2 *C.GstCaps, carg3 C.gsize, carg4 *C.GstCaps, carg5 *C.gsize) (cret C.gboolean) { + var trans Instance // go GstBaseTransform subclass + var direction gst.PadDirection // in, none, casted + var caps *gst.Caps // in, none, converted + var size uint // in, none, casted + var othercaps *gst.Caps // in, none, converted + var othersize uint // out, full, casted + var goret bool // return + + trans = UnsafeBaseTransformFromGlibNone(unsafe.Pointer(carg0)).(Instance) + direction = gst.PadDirection(carg1) + caps = gst.UnsafeCapsFromGlibNone(unsafe.Pointer(carg2)) + size = uint(carg3) + othercaps = gst.UnsafeCapsFromGlibNone(unsafe.Pointer(carg4)) + + othersize, goret = overrides.TransformSize(trans, direction, caps, size, othercaps) + + *carg5 = C.gsize(othersize) + if goret { + cret = C.TRUE + } + + return cret + }, + ) } } +// RegisterBaseTransformSubClass is used to register a go subclass of GstBaseTransform. For this to work safely please implement the +// virtual methods required by the implementation. +func RegisterBaseTransformSubClass[InstanceT BaseTransform]( + name string, + classInit func(class *BaseTransformClass), + constructor func() InstanceT, + overrides BaseTransformOverrides[InstanceT], + signals map[string]gobject.SignalDefinition, + interfaceInits ...gobject.SubClassInterfaceInit[InstanceT], +) gobject.Type { + return gobject.UnsafeRegisterSubClass( + name, + classInit, + constructor, + overrides, + signals, + TypeBaseTransform, + UnsafeBaseTransformClassFromGlibBorrow, + UnsafeApplyBaseTransformOverrides, + func (obj *gobject.ObjectInstance) gobject.Object { + return unsafeWrapBaseTransform(obj) + }, + interfaceInits..., + ) +} + // CollectPadsInstance is the instance type used by all types extending GstCollectPads. It is used internally by the bindings. Users should use the interface [CollectPads] instead. type CollectPadsInstance struct { _ [0]func() // equal guard @@ -10302,6 +12318,32 @@ func UnsafeApplyCollectPadsOverrides[Instance CollectPads](gclass unsafe.Pointer gst.UnsafeApplyObjectOverrides(gclass, overrides.ObjectOverrides) } +// RegisterCollectPadsSubClass is used to register a go subclass of GstCollectPads. For this to work safely please implement the +// virtual methods required by the implementation. +func RegisterCollectPadsSubClass[InstanceT CollectPads]( + name string, + classInit func(class *CollectPadsClass), + constructor func() InstanceT, + overrides CollectPadsOverrides[InstanceT], + signals map[string]gobject.SignalDefinition, + interfaceInits ...gobject.SubClassInterfaceInit[InstanceT], +) gobject.Type { + return gobject.UnsafeRegisterSubClass( + name, + classInit, + constructor, + overrides, + signals, + TypeCollectPads, + UnsafeCollectPadsClassFromGlibBorrow, + UnsafeApplyCollectPadsOverrides, + func (obj *gobject.ObjectInstance) gobject.Object { + return unsafeWrapCollectPads(obj) + }, + interfaceInits..., + ) +} + // DataQueueInstance is the instance type used by all types extending GstDataQueue. It is used internally by the bindings. Users should use the interface [DataQueue] instead. type DataQueueInstance struct { _ [0]func() // equal guard @@ -10410,13 +12452,61 @@ func UnsafeApplyDataQueueOverrides[Instance DataQueue](gclass unsafe.Pointer, ov if overrides.Empty != nil { pclass.empty = (*[0]byte)(C._gotk4_gstbase1_DataQueue_empty) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstbase1_DataQueue_empty", + func(carg0 *C.GstDataQueue) { + var queue Instance // go GstDataQueue subclass + + queue = UnsafeDataQueueFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + overrides.Empty(queue) + }, + ) } if overrides.Full != nil { pclass.full = (*[0]byte)(C._gotk4_gstbase1_DataQueue_full) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstbase1_DataQueue_full", + func(carg0 *C.GstDataQueue) { + var queue Instance // go GstDataQueue subclass + + queue = UnsafeDataQueueFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + overrides.Full(queue) + }, + ) } } +// RegisterDataQueueSubClass is used to register a go subclass of GstDataQueue. For this to work safely please implement the +// virtual methods required by the implementation. +func RegisterDataQueueSubClass[InstanceT DataQueue]( + name string, + classInit func(class *DataQueueClass), + constructor func() InstanceT, + overrides DataQueueOverrides[InstanceT], + signals map[string]gobject.SignalDefinition, + interfaceInits ...gobject.SubClassInterfaceInit[InstanceT], +) gobject.Type { + return gobject.UnsafeRegisterSubClass( + name, + classInit, + constructor, + overrides, + signals, + TypeDataQueue, + UnsafeDataQueueClassFromGlibBorrow, + UnsafeApplyDataQueueOverrides, + func (obj *gobject.ObjectInstance) gobject.Object { + return unsafeWrapDataQueue(obj) + }, + interfaceInits..., + ) +} + // PushSrcInstance is the instance type used by all types extending GstPushSrc. It is used internally by the bindings. Users should use the interface [PushSrc] instead. type PushSrcInstance struct { _ [0]func() // equal guard @@ -10525,13 +12615,75 @@ func UnsafeApplyPushSrcOverrides[Instance PushSrc](gclass unsafe.Pointer, overri if overrides.Alloc != nil { pclass.alloc = (*[0]byte)(C._gotk4_gstbase1_PushSrc_alloc) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstbase1_PushSrc_alloc", + func(carg0 *C.GstPushSrc, carg1 **C.GstBuffer) (cret C.GstFlowReturn) { + var src Instance // go GstPushSrc subclass + var buf *gst.Buffer // out, full, converted + var goret gst.FlowReturn // return, none, casted + + src = UnsafePushSrcFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + buf, goret = overrides.Alloc(src) + + *carg1 = (*C.GstBuffer)(gst.UnsafeBufferToGlibFull(buf)) + cret = C.GstFlowReturn(goret) + + return cret + }, + ) } if overrides.Fill != nil { pclass.fill = (*[0]byte)(C._gotk4_gstbase1_PushSrc_fill) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstbase1_PushSrc_fill", + func(carg0 *C.GstPushSrc, carg1 *C.GstBuffer) (cret C.GstFlowReturn) { + var src Instance // go GstPushSrc subclass + var buf *gst.Buffer // in, none, converted + var goret gst.FlowReturn // return, none, casted + + src = UnsafePushSrcFromGlibNone(unsafe.Pointer(carg0)).(Instance) + buf = gst.UnsafeBufferFromGlibNone(unsafe.Pointer(carg1)) + + goret = overrides.Fill(src, buf) + + cret = C.GstFlowReturn(goret) + + return cret + }, + ) } } +// RegisterPushSrcSubClass is used to register a go subclass of GstPushSrc. For this to work safely please implement the +// virtual methods required by the implementation. +func RegisterPushSrcSubClass[InstanceT PushSrc]( + name string, + classInit func(class *PushSrcClass), + constructor func() InstanceT, + overrides PushSrcOverrides[InstanceT], + signals map[string]gobject.SignalDefinition, + interfaceInits ...gobject.SubClassInterfaceInit[InstanceT], +) gobject.Type { + return gobject.UnsafeRegisterSubClass( + name, + classInit, + constructor, + overrides, + signals, + TypePushSrc, + UnsafePushSrcClassFromGlibBorrow, + UnsafeApplyPushSrcOverrides, + func (obj *gobject.ObjectInstance) gobject.Object { + return unsafeWrapPushSrc(obj) + }, + interfaceInits..., + ) +} + // AdapterClass wraps GstAdapterClass // // AdapterClass is the type struct for [Adapter] diff --git a/pkg/gstbase/gstbase_export.gen.go b/pkg/gstbase/gstbase_export.gen.go index b3f20b2..fdbf84f 100644 --- a/pkg/gstbase/gstbase_export.gen.go +++ b/pkg/gstbase/gstbase_export.gen.go @@ -5,6 +5,7 @@ package gstbase import ( "unsafe" + "github.com/diamondburned/gotk4/pkg/core/classdata" "github.com/diamondburned/gotk4/pkg/core/userdata" "github.com/go-gst/go-gst/pkg/gst" ) @@ -200,491 +201,1177 @@ func _gotk4_gstbase1_CollectPadsQueryFunction(carg1 *C.GstCollectPads, carg2 *C. //export _gotk4_gstbase1_Aggregator_aggregate func _gotk4_gstbase1_Aggregator_aggregate(carg0 *C.GstAggregator, carg1 C.gboolean) (cret C.GstFlowReturn) { - panic("unimplemented") + var fn func(carg0 *C.GstAggregator, carg1 C.gboolean) (cret C.GstFlowReturn) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstbase1_Aggregator_aggregate").(func(carg0 *C.GstAggregator, carg1 C.gboolean) (cret C.GstFlowReturn)) + if fn == nil { + panic("_gotk4_gstbase1_Aggregator_aggregate: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstbase1_Aggregator_clip func _gotk4_gstbase1_Aggregator_clip(carg0 *C.GstAggregator, carg1 *C.GstAggregatorPad, carg2 *C.GstBuffer) (cret *C.GstBuffer) { - panic("unimplemented") + var fn func(carg0 *C.GstAggregator, carg1 *C.GstAggregatorPad, carg2 *C.GstBuffer) (cret *C.GstBuffer) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstbase1_Aggregator_clip").(func(carg0 *C.GstAggregator, carg1 *C.GstAggregatorPad, carg2 *C.GstBuffer) (cret *C.GstBuffer)) + if fn == nil { + panic("_gotk4_gstbase1_Aggregator_clip: no function pointer found") + } + } + return fn(carg0, carg1, carg2) } //export _gotk4_gstbase1_Aggregator_decide_allocation func _gotk4_gstbase1_Aggregator_decide_allocation(carg0 *C.GstAggregator, carg1 *C.GstQuery) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstAggregator, carg1 *C.GstQuery) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstbase1_Aggregator_decide_allocation").(func(carg0 *C.GstAggregator, carg1 *C.GstQuery) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstbase1_Aggregator_decide_allocation: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstbase1_Aggregator_finish_buffer func _gotk4_gstbase1_Aggregator_finish_buffer(carg0 *C.GstAggregator, carg1 *C.GstBuffer) (cret C.GstFlowReturn) { - panic("unimplemented") + var fn func(carg0 *C.GstAggregator, carg1 *C.GstBuffer) (cret C.GstFlowReturn) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstbase1_Aggregator_finish_buffer").(func(carg0 *C.GstAggregator, carg1 *C.GstBuffer) (cret C.GstFlowReturn)) + if fn == nil { + panic("_gotk4_gstbase1_Aggregator_finish_buffer: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstbase1_Aggregator_finish_buffer_list func _gotk4_gstbase1_Aggregator_finish_buffer_list(carg0 *C.GstAggregator, carg1 *C.GstBufferList) (cret C.GstFlowReturn) { - panic("unimplemented") + var fn func(carg0 *C.GstAggregator, carg1 *C.GstBufferList) (cret C.GstFlowReturn) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstbase1_Aggregator_finish_buffer_list").(func(carg0 *C.GstAggregator, carg1 *C.GstBufferList) (cret C.GstFlowReturn)) + if fn == nil { + panic("_gotk4_gstbase1_Aggregator_finish_buffer_list: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstbase1_Aggregator_fixate_src_caps func _gotk4_gstbase1_Aggregator_fixate_src_caps(carg0 *C.GstAggregator, carg1 *C.GstCaps) (cret *C.GstCaps) { - panic("unimplemented") + var fn func(carg0 *C.GstAggregator, carg1 *C.GstCaps) (cret *C.GstCaps) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstbase1_Aggregator_fixate_src_caps").(func(carg0 *C.GstAggregator, carg1 *C.GstCaps) (cret *C.GstCaps)) + if fn == nil { + panic("_gotk4_gstbase1_Aggregator_fixate_src_caps: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstbase1_Aggregator_flush func _gotk4_gstbase1_Aggregator_flush(carg0 *C.GstAggregator) (cret C.GstFlowReturn) { - panic("unimplemented") + var fn func(carg0 *C.GstAggregator) (cret C.GstFlowReturn) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstbase1_Aggregator_flush").(func(carg0 *C.GstAggregator) (cret C.GstFlowReturn)) + if fn == nil { + panic("_gotk4_gstbase1_Aggregator_flush: no function pointer found") + } + } + return fn(carg0) } //export _gotk4_gstbase1_Aggregator_get_next_time func _gotk4_gstbase1_Aggregator_get_next_time(carg0 *C.GstAggregator) (cret C.GstClockTime) { - panic("unimplemented") + var fn func(carg0 *C.GstAggregator) (cret C.GstClockTime) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstbase1_Aggregator_get_next_time").(func(carg0 *C.GstAggregator) (cret C.GstClockTime)) + if fn == nil { + panic("_gotk4_gstbase1_Aggregator_get_next_time: no function pointer found") + } + } + return fn(carg0) } //export _gotk4_gstbase1_Aggregator_negotiate func _gotk4_gstbase1_Aggregator_negotiate(carg0 *C.GstAggregator) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstAggregator) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstbase1_Aggregator_negotiate").(func(carg0 *C.GstAggregator) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstbase1_Aggregator_negotiate: no function pointer found") + } + } + return fn(carg0) } //export _gotk4_gstbase1_Aggregator_negotiated_src_caps func _gotk4_gstbase1_Aggregator_negotiated_src_caps(carg0 *C.GstAggregator, carg1 *C.GstCaps) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstAggregator, carg1 *C.GstCaps) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstbase1_Aggregator_negotiated_src_caps").(func(carg0 *C.GstAggregator, carg1 *C.GstCaps) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstbase1_Aggregator_negotiated_src_caps: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstbase1_Aggregator_peek_next_sample func _gotk4_gstbase1_Aggregator_peek_next_sample(carg0 *C.GstAggregator, carg1 *C.GstAggregatorPad) (cret *C.GstSample) { - panic("unimplemented") + var fn func(carg0 *C.GstAggregator, carg1 *C.GstAggregatorPad) (cret *C.GstSample) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstbase1_Aggregator_peek_next_sample").(func(carg0 *C.GstAggregator, carg1 *C.GstAggregatorPad) (cret *C.GstSample)) + if fn == nil { + panic("_gotk4_gstbase1_Aggregator_peek_next_sample: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstbase1_Aggregator_propose_allocation func _gotk4_gstbase1_Aggregator_propose_allocation(carg0 *C.GstAggregator, carg1 *C.GstAggregatorPad, carg2 *C.GstQuery, carg3 *C.GstQuery) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstAggregator, carg1 *C.GstAggregatorPad, carg2 *C.GstQuery, carg3 *C.GstQuery) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstbase1_Aggregator_propose_allocation").(func(carg0 *C.GstAggregator, carg1 *C.GstAggregatorPad, carg2 *C.GstQuery, carg3 *C.GstQuery) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstbase1_Aggregator_propose_allocation: no function pointer found") + } + } + return fn(carg0, carg1, carg2, carg3) } //export _gotk4_gstbase1_Aggregator_sink_event func _gotk4_gstbase1_Aggregator_sink_event(carg0 *C.GstAggregator, carg1 *C.GstAggregatorPad, carg2 *C.GstEvent) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstAggregator, carg1 *C.GstAggregatorPad, carg2 *C.GstEvent) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstbase1_Aggregator_sink_event").(func(carg0 *C.GstAggregator, carg1 *C.GstAggregatorPad, carg2 *C.GstEvent) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstbase1_Aggregator_sink_event: no function pointer found") + } + } + return fn(carg0, carg1, carg2) } //export _gotk4_gstbase1_Aggregator_sink_event_pre_queue func _gotk4_gstbase1_Aggregator_sink_event_pre_queue(carg0 *C.GstAggregator, carg1 *C.GstAggregatorPad, carg2 *C.GstEvent) (cret C.GstFlowReturn) { - panic("unimplemented") + var fn func(carg0 *C.GstAggregator, carg1 *C.GstAggregatorPad, carg2 *C.GstEvent) (cret C.GstFlowReturn) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstbase1_Aggregator_sink_event_pre_queue").(func(carg0 *C.GstAggregator, carg1 *C.GstAggregatorPad, carg2 *C.GstEvent) (cret C.GstFlowReturn)) + if fn == nil { + panic("_gotk4_gstbase1_Aggregator_sink_event_pre_queue: no function pointer found") + } + } + return fn(carg0, carg1, carg2) } //export _gotk4_gstbase1_Aggregator_sink_query func _gotk4_gstbase1_Aggregator_sink_query(carg0 *C.GstAggregator, carg1 *C.GstAggregatorPad, carg2 *C.GstQuery) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstAggregator, carg1 *C.GstAggregatorPad, carg2 *C.GstQuery) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstbase1_Aggregator_sink_query").(func(carg0 *C.GstAggregator, carg1 *C.GstAggregatorPad, carg2 *C.GstQuery) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstbase1_Aggregator_sink_query: no function pointer found") + } + } + return fn(carg0, carg1, carg2) } //export _gotk4_gstbase1_Aggregator_sink_query_pre_queue func _gotk4_gstbase1_Aggregator_sink_query_pre_queue(carg0 *C.GstAggregator, carg1 *C.GstAggregatorPad, carg2 *C.GstQuery) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstAggregator, carg1 *C.GstAggregatorPad, carg2 *C.GstQuery) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstbase1_Aggregator_sink_query_pre_queue").(func(carg0 *C.GstAggregator, carg1 *C.GstAggregatorPad, carg2 *C.GstQuery) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstbase1_Aggregator_sink_query_pre_queue: no function pointer found") + } + } + return fn(carg0, carg1, carg2) } //export _gotk4_gstbase1_Aggregator_src_activate func _gotk4_gstbase1_Aggregator_src_activate(carg0 *C.GstAggregator, carg1 C.GstPadMode, carg2 C.gboolean) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstAggregator, carg1 C.GstPadMode, carg2 C.gboolean) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstbase1_Aggregator_src_activate").(func(carg0 *C.GstAggregator, carg1 C.GstPadMode, carg2 C.gboolean) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstbase1_Aggregator_src_activate: no function pointer found") + } + } + return fn(carg0, carg1, carg2) } //export _gotk4_gstbase1_Aggregator_src_event func _gotk4_gstbase1_Aggregator_src_event(carg0 *C.GstAggregator, carg1 *C.GstEvent) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstAggregator, carg1 *C.GstEvent) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstbase1_Aggregator_src_event").(func(carg0 *C.GstAggregator, carg1 *C.GstEvent) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstbase1_Aggregator_src_event: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstbase1_Aggregator_src_query func _gotk4_gstbase1_Aggregator_src_query(carg0 *C.GstAggregator, carg1 *C.GstQuery) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstAggregator, carg1 *C.GstQuery) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstbase1_Aggregator_src_query").(func(carg0 *C.GstAggregator, carg1 *C.GstQuery) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstbase1_Aggregator_src_query: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstbase1_Aggregator_start func _gotk4_gstbase1_Aggregator_start(carg0 *C.GstAggregator) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstAggregator) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstbase1_Aggregator_start").(func(carg0 *C.GstAggregator) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstbase1_Aggregator_start: no function pointer found") + } + } + return fn(carg0) } //export _gotk4_gstbase1_Aggregator_stop func _gotk4_gstbase1_Aggregator_stop(carg0 *C.GstAggregator) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstAggregator) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstbase1_Aggregator_stop").(func(carg0 *C.GstAggregator) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstbase1_Aggregator_stop: no function pointer found") + } + } + return fn(carg0) } //export _gotk4_gstbase1_Aggregator_update_src_caps func _gotk4_gstbase1_Aggregator_update_src_caps(carg0 *C.GstAggregator, carg1 *C.GstCaps, carg2 **C.GstCaps) (cret C.GstFlowReturn) { - panic("unimplemented") + var fn func(carg0 *C.GstAggregator, carg1 *C.GstCaps, carg2 **C.GstCaps) (cret C.GstFlowReturn) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstbase1_Aggregator_update_src_caps").(func(carg0 *C.GstAggregator, carg1 *C.GstCaps, carg2 **C.GstCaps) (cret C.GstFlowReturn)) + if fn == nil { + panic("_gotk4_gstbase1_Aggregator_update_src_caps: no function pointer found") + } + } + return fn(carg0, carg1, carg2) } //export _gotk4_gstbase1_AggregatorPad_flush func _gotk4_gstbase1_AggregatorPad_flush(carg0 *C.GstAggregatorPad, carg1 *C.GstAggregator) (cret C.GstFlowReturn) { - panic("unimplemented") + var fn func(carg0 *C.GstAggregatorPad, carg1 *C.GstAggregator) (cret C.GstFlowReturn) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstbase1_AggregatorPad_flush").(func(carg0 *C.GstAggregatorPad, carg1 *C.GstAggregator) (cret C.GstFlowReturn)) + if fn == nil { + panic("_gotk4_gstbase1_AggregatorPad_flush: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstbase1_AggregatorPad_skip_buffer func _gotk4_gstbase1_AggregatorPad_skip_buffer(carg0 *C.GstAggregatorPad, carg1 *C.GstAggregator, carg2 *C.GstBuffer) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstAggregatorPad, carg1 *C.GstAggregator, carg2 *C.GstBuffer) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstbase1_AggregatorPad_skip_buffer").(func(carg0 *C.GstAggregatorPad, carg1 *C.GstAggregator, carg2 *C.GstBuffer) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstbase1_AggregatorPad_skip_buffer: no function pointer found") + } + } + return fn(carg0, carg1, carg2) } //export _gotk4_gstbase1_BaseParse_convert func _gotk4_gstbase1_BaseParse_convert(carg0 *C.GstBaseParse, carg1 C.GstFormat, carg2 C.gint64, carg3 C.GstFormat, carg4 *C.gint64) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstBaseParse, carg1 C.GstFormat, carg2 C.gint64, carg3 C.GstFormat, carg4 *C.gint64) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstbase1_BaseParse_convert").(func(carg0 *C.GstBaseParse, carg1 C.GstFormat, carg2 C.gint64, carg3 C.GstFormat, carg4 *C.gint64) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstbase1_BaseParse_convert: no function pointer found") + } + } + return fn(carg0, carg1, carg2, carg3, carg4) } //export _gotk4_gstbase1_BaseParse_detect func _gotk4_gstbase1_BaseParse_detect(carg0 *C.GstBaseParse, carg1 *C.GstBuffer) (cret C.GstFlowReturn) { - panic("unimplemented") + var fn func(carg0 *C.GstBaseParse, carg1 *C.GstBuffer) (cret C.GstFlowReturn) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstbase1_BaseParse_detect").(func(carg0 *C.GstBaseParse, carg1 *C.GstBuffer) (cret C.GstFlowReturn)) + if fn == nil { + panic("_gotk4_gstbase1_BaseParse_detect: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstbase1_BaseParse_get_sink_caps func _gotk4_gstbase1_BaseParse_get_sink_caps(carg0 *C.GstBaseParse, carg1 *C.GstCaps) (cret *C.GstCaps) { - panic("unimplemented") + var fn func(carg0 *C.GstBaseParse, carg1 *C.GstCaps) (cret *C.GstCaps) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstbase1_BaseParse_get_sink_caps").(func(carg0 *C.GstBaseParse, carg1 *C.GstCaps) (cret *C.GstCaps)) + if fn == nil { + panic("_gotk4_gstbase1_BaseParse_get_sink_caps: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstbase1_BaseParse_handle_frame func _gotk4_gstbase1_BaseParse_handle_frame(carg0 *C.GstBaseParse, carg1 *C.GstBaseParseFrame, carg2 *C.gint) (cret C.GstFlowReturn) { - panic("unimplemented") + var fn func(carg0 *C.GstBaseParse, carg1 *C.GstBaseParseFrame, carg2 *C.gint) (cret C.GstFlowReturn) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstbase1_BaseParse_handle_frame").(func(carg0 *C.GstBaseParse, carg1 *C.GstBaseParseFrame, carg2 *C.gint) (cret C.GstFlowReturn)) + if fn == nil { + panic("_gotk4_gstbase1_BaseParse_handle_frame: no function pointer found") + } + } + return fn(carg0, carg1, carg2) } //export _gotk4_gstbase1_BaseParse_pre_push_frame func _gotk4_gstbase1_BaseParse_pre_push_frame(carg0 *C.GstBaseParse, carg1 *C.GstBaseParseFrame) (cret C.GstFlowReturn) { - panic("unimplemented") + var fn func(carg0 *C.GstBaseParse, carg1 *C.GstBaseParseFrame) (cret C.GstFlowReturn) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstbase1_BaseParse_pre_push_frame").(func(carg0 *C.GstBaseParse, carg1 *C.GstBaseParseFrame) (cret C.GstFlowReturn)) + if fn == nil { + panic("_gotk4_gstbase1_BaseParse_pre_push_frame: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstbase1_BaseParse_set_sink_caps func _gotk4_gstbase1_BaseParse_set_sink_caps(carg0 *C.GstBaseParse, carg1 *C.GstCaps) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstBaseParse, carg1 *C.GstCaps) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstbase1_BaseParse_set_sink_caps").(func(carg0 *C.GstBaseParse, carg1 *C.GstCaps) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstbase1_BaseParse_set_sink_caps: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstbase1_BaseParse_sink_event func _gotk4_gstbase1_BaseParse_sink_event(carg0 *C.GstBaseParse, carg1 *C.GstEvent) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstBaseParse, carg1 *C.GstEvent) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstbase1_BaseParse_sink_event").(func(carg0 *C.GstBaseParse, carg1 *C.GstEvent) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstbase1_BaseParse_sink_event: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstbase1_BaseParse_sink_query func _gotk4_gstbase1_BaseParse_sink_query(carg0 *C.GstBaseParse, carg1 *C.GstQuery) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstBaseParse, carg1 *C.GstQuery) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstbase1_BaseParse_sink_query").(func(carg0 *C.GstBaseParse, carg1 *C.GstQuery) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstbase1_BaseParse_sink_query: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstbase1_BaseParse_src_event func _gotk4_gstbase1_BaseParse_src_event(carg0 *C.GstBaseParse, carg1 *C.GstEvent) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstBaseParse, carg1 *C.GstEvent) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstbase1_BaseParse_src_event").(func(carg0 *C.GstBaseParse, carg1 *C.GstEvent) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstbase1_BaseParse_src_event: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstbase1_BaseParse_src_query func _gotk4_gstbase1_BaseParse_src_query(carg0 *C.GstBaseParse, carg1 *C.GstQuery) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstBaseParse, carg1 *C.GstQuery) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstbase1_BaseParse_src_query").(func(carg0 *C.GstBaseParse, carg1 *C.GstQuery) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstbase1_BaseParse_src_query: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstbase1_BaseParse_start func _gotk4_gstbase1_BaseParse_start(carg0 *C.GstBaseParse) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstBaseParse) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstbase1_BaseParse_start").(func(carg0 *C.GstBaseParse) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstbase1_BaseParse_start: no function pointer found") + } + } + return fn(carg0) } //export _gotk4_gstbase1_BaseParse_stop func _gotk4_gstbase1_BaseParse_stop(carg0 *C.GstBaseParse) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstBaseParse) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstbase1_BaseParse_stop").(func(carg0 *C.GstBaseParse) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstbase1_BaseParse_stop: no function pointer found") + } + } + return fn(carg0) } //export _gotk4_gstbase1_BaseSink_activate_pull func _gotk4_gstbase1_BaseSink_activate_pull(carg0 *C.GstBaseSink, carg1 C.gboolean) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstBaseSink, carg1 C.gboolean) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstbase1_BaseSink_activate_pull").(func(carg0 *C.GstBaseSink, carg1 C.gboolean) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstbase1_BaseSink_activate_pull: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstbase1_BaseSink_event func _gotk4_gstbase1_BaseSink_event(carg0 *C.GstBaseSink, carg1 *C.GstEvent) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstBaseSink, carg1 *C.GstEvent) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstbase1_BaseSink_event").(func(carg0 *C.GstBaseSink, carg1 *C.GstEvent) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstbase1_BaseSink_event: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstbase1_BaseSink_fixate func _gotk4_gstbase1_BaseSink_fixate(carg0 *C.GstBaseSink, carg1 *C.GstCaps) (cret *C.GstCaps) { - panic("unimplemented") + var fn func(carg0 *C.GstBaseSink, carg1 *C.GstCaps) (cret *C.GstCaps) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstbase1_BaseSink_fixate").(func(carg0 *C.GstBaseSink, carg1 *C.GstCaps) (cret *C.GstCaps)) + if fn == nil { + panic("_gotk4_gstbase1_BaseSink_fixate: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstbase1_BaseSink_get_caps func _gotk4_gstbase1_BaseSink_get_caps(carg0 *C.GstBaseSink, carg1 *C.GstCaps) (cret *C.GstCaps) { - panic("unimplemented") + var fn func(carg0 *C.GstBaseSink, carg1 *C.GstCaps) (cret *C.GstCaps) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstbase1_BaseSink_get_caps").(func(carg0 *C.GstBaseSink, carg1 *C.GstCaps) (cret *C.GstCaps)) + if fn == nil { + panic("_gotk4_gstbase1_BaseSink_get_caps: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstbase1_BaseSink_get_times func _gotk4_gstbase1_BaseSink_get_times(carg0 *C.GstBaseSink, carg1 *C.GstBuffer, carg2 *C.GstClockTime, carg3 *C.GstClockTime) { - panic("unimplemented") + var fn func(carg0 *C.GstBaseSink, carg1 *C.GstBuffer, carg2 *C.GstClockTime, carg3 *C.GstClockTime) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstbase1_BaseSink_get_times").(func(carg0 *C.GstBaseSink, carg1 *C.GstBuffer, carg2 *C.GstClockTime, carg3 *C.GstClockTime)) + if fn == nil { + panic("_gotk4_gstbase1_BaseSink_get_times: no function pointer found") + } + } + fn(carg0, carg1, carg2, carg3) } //export _gotk4_gstbase1_BaseSink_prepare func _gotk4_gstbase1_BaseSink_prepare(carg0 *C.GstBaseSink, carg1 *C.GstBuffer) (cret C.GstFlowReturn) { - panic("unimplemented") + var fn func(carg0 *C.GstBaseSink, carg1 *C.GstBuffer) (cret C.GstFlowReturn) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstbase1_BaseSink_prepare").(func(carg0 *C.GstBaseSink, carg1 *C.GstBuffer) (cret C.GstFlowReturn)) + if fn == nil { + panic("_gotk4_gstbase1_BaseSink_prepare: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstbase1_BaseSink_prepare_list func _gotk4_gstbase1_BaseSink_prepare_list(carg0 *C.GstBaseSink, carg1 *C.GstBufferList) (cret C.GstFlowReturn) { - panic("unimplemented") + var fn func(carg0 *C.GstBaseSink, carg1 *C.GstBufferList) (cret C.GstFlowReturn) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstbase1_BaseSink_prepare_list").(func(carg0 *C.GstBaseSink, carg1 *C.GstBufferList) (cret C.GstFlowReturn)) + if fn == nil { + panic("_gotk4_gstbase1_BaseSink_prepare_list: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstbase1_BaseSink_preroll func _gotk4_gstbase1_BaseSink_preroll(carg0 *C.GstBaseSink, carg1 *C.GstBuffer) (cret C.GstFlowReturn) { - panic("unimplemented") + var fn func(carg0 *C.GstBaseSink, carg1 *C.GstBuffer) (cret C.GstFlowReturn) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstbase1_BaseSink_preroll").(func(carg0 *C.GstBaseSink, carg1 *C.GstBuffer) (cret C.GstFlowReturn)) + if fn == nil { + panic("_gotk4_gstbase1_BaseSink_preroll: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstbase1_BaseSink_propose_allocation func _gotk4_gstbase1_BaseSink_propose_allocation(carg0 *C.GstBaseSink, carg1 *C.GstQuery) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstBaseSink, carg1 *C.GstQuery) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstbase1_BaseSink_propose_allocation").(func(carg0 *C.GstBaseSink, carg1 *C.GstQuery) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstbase1_BaseSink_propose_allocation: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstbase1_BaseSink_query func _gotk4_gstbase1_BaseSink_query(carg0 *C.GstBaseSink, carg1 *C.GstQuery) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstBaseSink, carg1 *C.GstQuery) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstbase1_BaseSink_query").(func(carg0 *C.GstBaseSink, carg1 *C.GstQuery) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstbase1_BaseSink_query: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstbase1_BaseSink_render func _gotk4_gstbase1_BaseSink_render(carg0 *C.GstBaseSink, carg1 *C.GstBuffer) (cret C.GstFlowReturn) { - panic("unimplemented") + var fn func(carg0 *C.GstBaseSink, carg1 *C.GstBuffer) (cret C.GstFlowReturn) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstbase1_BaseSink_render").(func(carg0 *C.GstBaseSink, carg1 *C.GstBuffer) (cret C.GstFlowReturn)) + if fn == nil { + panic("_gotk4_gstbase1_BaseSink_render: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstbase1_BaseSink_render_list func _gotk4_gstbase1_BaseSink_render_list(carg0 *C.GstBaseSink, carg1 *C.GstBufferList) (cret C.GstFlowReturn) { - panic("unimplemented") + var fn func(carg0 *C.GstBaseSink, carg1 *C.GstBufferList) (cret C.GstFlowReturn) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstbase1_BaseSink_render_list").(func(carg0 *C.GstBaseSink, carg1 *C.GstBufferList) (cret C.GstFlowReturn)) + if fn == nil { + panic("_gotk4_gstbase1_BaseSink_render_list: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstbase1_BaseSink_set_caps func _gotk4_gstbase1_BaseSink_set_caps(carg0 *C.GstBaseSink, carg1 *C.GstCaps) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstBaseSink, carg1 *C.GstCaps) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstbase1_BaseSink_set_caps").(func(carg0 *C.GstBaseSink, carg1 *C.GstCaps) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstbase1_BaseSink_set_caps: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstbase1_BaseSink_start func _gotk4_gstbase1_BaseSink_start(carg0 *C.GstBaseSink) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstBaseSink) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstbase1_BaseSink_start").(func(carg0 *C.GstBaseSink) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstbase1_BaseSink_start: no function pointer found") + } + } + return fn(carg0) } //export _gotk4_gstbase1_BaseSink_stop func _gotk4_gstbase1_BaseSink_stop(carg0 *C.GstBaseSink) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstBaseSink) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstbase1_BaseSink_stop").(func(carg0 *C.GstBaseSink) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstbase1_BaseSink_stop: no function pointer found") + } + } + return fn(carg0) } //export _gotk4_gstbase1_BaseSink_unlock func _gotk4_gstbase1_BaseSink_unlock(carg0 *C.GstBaseSink) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstBaseSink) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstbase1_BaseSink_unlock").(func(carg0 *C.GstBaseSink) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstbase1_BaseSink_unlock: no function pointer found") + } + } + return fn(carg0) } //export _gotk4_gstbase1_BaseSink_unlock_stop func _gotk4_gstbase1_BaseSink_unlock_stop(carg0 *C.GstBaseSink) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstBaseSink) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstbase1_BaseSink_unlock_stop").(func(carg0 *C.GstBaseSink) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstbase1_BaseSink_unlock_stop: no function pointer found") + } + } + return fn(carg0) } //export _gotk4_gstbase1_BaseSink_wait_event func _gotk4_gstbase1_BaseSink_wait_event(carg0 *C.GstBaseSink, carg1 *C.GstEvent) (cret C.GstFlowReturn) { - panic("unimplemented") + var fn func(carg0 *C.GstBaseSink, carg1 *C.GstEvent) (cret C.GstFlowReturn) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstbase1_BaseSink_wait_event").(func(carg0 *C.GstBaseSink, carg1 *C.GstEvent) (cret C.GstFlowReturn)) + if fn == nil { + panic("_gotk4_gstbase1_BaseSink_wait_event: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstbase1_BaseSrc_alloc func _gotk4_gstbase1_BaseSrc_alloc(carg0 *C.GstBaseSrc, carg1 C.guint64, carg2 C.guint, carg3 **C.GstBuffer) (cret C.GstFlowReturn) { - panic("unimplemented") + var fn func(carg0 *C.GstBaseSrc, carg1 C.guint64, carg2 C.guint, carg3 **C.GstBuffer) (cret C.GstFlowReturn) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstbase1_BaseSrc_alloc").(func(carg0 *C.GstBaseSrc, carg1 C.guint64, carg2 C.guint, carg3 **C.GstBuffer) (cret C.GstFlowReturn)) + if fn == nil { + panic("_gotk4_gstbase1_BaseSrc_alloc: no function pointer found") + } + } + return fn(carg0, carg1, carg2, carg3) } //export _gotk4_gstbase1_BaseSrc_decide_allocation func _gotk4_gstbase1_BaseSrc_decide_allocation(carg0 *C.GstBaseSrc, carg1 *C.GstQuery) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstBaseSrc, carg1 *C.GstQuery) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstbase1_BaseSrc_decide_allocation").(func(carg0 *C.GstBaseSrc, carg1 *C.GstQuery) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstbase1_BaseSrc_decide_allocation: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstbase1_BaseSrc_do_seek func _gotk4_gstbase1_BaseSrc_do_seek(carg0 *C.GstBaseSrc, carg1 *C.GstSegment) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstBaseSrc, carg1 *C.GstSegment) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstbase1_BaseSrc_do_seek").(func(carg0 *C.GstBaseSrc, carg1 *C.GstSegment) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstbase1_BaseSrc_do_seek: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstbase1_BaseSrc_event func _gotk4_gstbase1_BaseSrc_event(carg0 *C.GstBaseSrc, carg1 *C.GstEvent) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstBaseSrc, carg1 *C.GstEvent) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstbase1_BaseSrc_event").(func(carg0 *C.GstBaseSrc, carg1 *C.GstEvent) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstbase1_BaseSrc_event: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstbase1_BaseSrc_fill func _gotk4_gstbase1_BaseSrc_fill(carg0 *C.GstBaseSrc, carg1 C.guint64, carg2 C.guint, carg3 *C.GstBuffer) (cret C.GstFlowReturn) { - panic("unimplemented") + var fn func(carg0 *C.GstBaseSrc, carg1 C.guint64, carg2 C.guint, carg3 *C.GstBuffer) (cret C.GstFlowReturn) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstbase1_BaseSrc_fill").(func(carg0 *C.GstBaseSrc, carg1 C.guint64, carg2 C.guint, carg3 *C.GstBuffer) (cret C.GstFlowReturn)) + if fn == nil { + panic("_gotk4_gstbase1_BaseSrc_fill: no function pointer found") + } + } + return fn(carg0, carg1, carg2, carg3) } //export _gotk4_gstbase1_BaseSrc_fixate func _gotk4_gstbase1_BaseSrc_fixate(carg0 *C.GstBaseSrc, carg1 *C.GstCaps) (cret *C.GstCaps) { - panic("unimplemented") + var fn func(carg0 *C.GstBaseSrc, carg1 *C.GstCaps) (cret *C.GstCaps) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstbase1_BaseSrc_fixate").(func(carg0 *C.GstBaseSrc, carg1 *C.GstCaps) (cret *C.GstCaps)) + if fn == nil { + panic("_gotk4_gstbase1_BaseSrc_fixate: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstbase1_BaseSrc_get_caps func _gotk4_gstbase1_BaseSrc_get_caps(carg0 *C.GstBaseSrc, carg1 *C.GstCaps) (cret *C.GstCaps) { - panic("unimplemented") + var fn func(carg0 *C.GstBaseSrc, carg1 *C.GstCaps) (cret *C.GstCaps) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstbase1_BaseSrc_get_caps").(func(carg0 *C.GstBaseSrc, carg1 *C.GstCaps) (cret *C.GstCaps)) + if fn == nil { + panic("_gotk4_gstbase1_BaseSrc_get_caps: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstbase1_BaseSrc_get_size func _gotk4_gstbase1_BaseSrc_get_size(carg0 *C.GstBaseSrc, carg1 *C.guint64) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstBaseSrc, carg1 *C.guint64) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstbase1_BaseSrc_get_size").(func(carg0 *C.GstBaseSrc, carg1 *C.guint64) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstbase1_BaseSrc_get_size: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstbase1_BaseSrc_get_times func _gotk4_gstbase1_BaseSrc_get_times(carg0 *C.GstBaseSrc, carg1 *C.GstBuffer, carg2 *C.GstClockTime, carg3 *C.GstClockTime) { - panic("unimplemented") + var fn func(carg0 *C.GstBaseSrc, carg1 *C.GstBuffer, carg2 *C.GstClockTime, carg3 *C.GstClockTime) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstbase1_BaseSrc_get_times").(func(carg0 *C.GstBaseSrc, carg1 *C.GstBuffer, carg2 *C.GstClockTime, carg3 *C.GstClockTime)) + if fn == nil { + panic("_gotk4_gstbase1_BaseSrc_get_times: no function pointer found") + } + } + fn(carg0, carg1, carg2, carg3) } //export _gotk4_gstbase1_BaseSrc_is_seekable func _gotk4_gstbase1_BaseSrc_is_seekable(carg0 *C.GstBaseSrc) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstBaseSrc) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstbase1_BaseSrc_is_seekable").(func(carg0 *C.GstBaseSrc) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstbase1_BaseSrc_is_seekable: no function pointer found") + } + } + return fn(carg0) } //export _gotk4_gstbase1_BaseSrc_negotiate func _gotk4_gstbase1_BaseSrc_negotiate(carg0 *C.GstBaseSrc) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstBaseSrc) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstbase1_BaseSrc_negotiate").(func(carg0 *C.GstBaseSrc) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstbase1_BaseSrc_negotiate: no function pointer found") + } + } + return fn(carg0) } //export _gotk4_gstbase1_BaseSrc_prepare_seek_segment func _gotk4_gstbase1_BaseSrc_prepare_seek_segment(carg0 *C.GstBaseSrc, carg1 *C.GstEvent, carg2 *C.GstSegment) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstBaseSrc, carg1 *C.GstEvent, carg2 *C.GstSegment) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstbase1_BaseSrc_prepare_seek_segment").(func(carg0 *C.GstBaseSrc, carg1 *C.GstEvent, carg2 *C.GstSegment) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstbase1_BaseSrc_prepare_seek_segment: no function pointer found") + } + } + return fn(carg0, carg1, carg2) } //export _gotk4_gstbase1_BaseSrc_query func _gotk4_gstbase1_BaseSrc_query(carg0 *C.GstBaseSrc, carg1 *C.GstQuery) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstBaseSrc, carg1 *C.GstQuery) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstbase1_BaseSrc_query").(func(carg0 *C.GstBaseSrc, carg1 *C.GstQuery) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstbase1_BaseSrc_query: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstbase1_BaseSrc_set_caps func _gotk4_gstbase1_BaseSrc_set_caps(carg0 *C.GstBaseSrc, carg1 *C.GstCaps) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstBaseSrc, carg1 *C.GstCaps) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstbase1_BaseSrc_set_caps").(func(carg0 *C.GstBaseSrc, carg1 *C.GstCaps) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstbase1_BaseSrc_set_caps: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstbase1_BaseSrc_start func _gotk4_gstbase1_BaseSrc_start(carg0 *C.GstBaseSrc) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstBaseSrc) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstbase1_BaseSrc_start").(func(carg0 *C.GstBaseSrc) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstbase1_BaseSrc_start: no function pointer found") + } + } + return fn(carg0) } //export _gotk4_gstbase1_BaseSrc_stop func _gotk4_gstbase1_BaseSrc_stop(carg0 *C.GstBaseSrc) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstBaseSrc) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstbase1_BaseSrc_stop").(func(carg0 *C.GstBaseSrc) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstbase1_BaseSrc_stop: no function pointer found") + } + } + return fn(carg0) } //export _gotk4_gstbase1_BaseSrc_unlock func _gotk4_gstbase1_BaseSrc_unlock(carg0 *C.GstBaseSrc) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstBaseSrc) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstbase1_BaseSrc_unlock").(func(carg0 *C.GstBaseSrc) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstbase1_BaseSrc_unlock: no function pointer found") + } + } + return fn(carg0) } //export _gotk4_gstbase1_BaseSrc_unlock_stop func _gotk4_gstbase1_BaseSrc_unlock_stop(carg0 *C.GstBaseSrc) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstBaseSrc) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstbase1_BaseSrc_unlock_stop").(func(carg0 *C.GstBaseSrc) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstbase1_BaseSrc_unlock_stop: no function pointer found") + } + } + return fn(carg0) } //export _gotk4_gstbase1_BaseTransform_accept_caps func _gotk4_gstbase1_BaseTransform_accept_caps(carg0 *C.GstBaseTransform, carg1 C.GstPadDirection, carg2 *C.GstCaps) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstBaseTransform, carg1 C.GstPadDirection, carg2 *C.GstCaps) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstbase1_BaseTransform_accept_caps").(func(carg0 *C.GstBaseTransform, carg1 C.GstPadDirection, carg2 *C.GstCaps) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstbase1_BaseTransform_accept_caps: no function pointer found") + } + } + return fn(carg0, carg1, carg2) } //export _gotk4_gstbase1_BaseTransform_before_transform func _gotk4_gstbase1_BaseTransform_before_transform(carg0 *C.GstBaseTransform, carg1 *C.GstBuffer) { - panic("unimplemented") + var fn func(carg0 *C.GstBaseTransform, carg1 *C.GstBuffer) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstbase1_BaseTransform_before_transform").(func(carg0 *C.GstBaseTransform, carg1 *C.GstBuffer)) + if fn == nil { + panic("_gotk4_gstbase1_BaseTransform_before_transform: no function pointer found") + } + } + fn(carg0, carg1) } //export _gotk4_gstbase1_BaseTransform_copy_metadata func _gotk4_gstbase1_BaseTransform_copy_metadata(carg0 *C.GstBaseTransform, carg1 *C.GstBuffer, carg2 *C.GstBuffer) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstBaseTransform, carg1 *C.GstBuffer, carg2 *C.GstBuffer) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstbase1_BaseTransform_copy_metadata").(func(carg0 *C.GstBaseTransform, carg1 *C.GstBuffer, carg2 *C.GstBuffer) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstbase1_BaseTransform_copy_metadata: no function pointer found") + } + } + return fn(carg0, carg1, carg2) } //export _gotk4_gstbase1_BaseTransform_decide_allocation func _gotk4_gstbase1_BaseTransform_decide_allocation(carg0 *C.GstBaseTransform, carg1 *C.GstQuery) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstBaseTransform, carg1 *C.GstQuery) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstbase1_BaseTransform_decide_allocation").(func(carg0 *C.GstBaseTransform, carg1 *C.GstQuery) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstbase1_BaseTransform_decide_allocation: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstbase1_BaseTransform_filter_meta func _gotk4_gstbase1_BaseTransform_filter_meta(carg0 *C.GstBaseTransform, carg1 *C.GstQuery, carg2 C.GType, carg3 *C.GstStructure) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstBaseTransform, carg1 *C.GstQuery, carg2 C.GType, carg3 *C.GstStructure) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstbase1_BaseTransform_filter_meta").(func(carg0 *C.GstBaseTransform, carg1 *C.GstQuery, carg2 C.GType, carg3 *C.GstStructure) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstbase1_BaseTransform_filter_meta: no function pointer found") + } + } + return fn(carg0, carg1, carg2, carg3) } //export _gotk4_gstbase1_BaseTransform_fixate_caps func _gotk4_gstbase1_BaseTransform_fixate_caps(carg0 *C.GstBaseTransform, carg1 C.GstPadDirection, carg2 *C.GstCaps, carg3 *C.GstCaps) (cret *C.GstCaps) { - panic("unimplemented") + var fn func(carg0 *C.GstBaseTransform, carg1 C.GstPadDirection, carg2 *C.GstCaps, carg3 *C.GstCaps) (cret *C.GstCaps) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstbase1_BaseTransform_fixate_caps").(func(carg0 *C.GstBaseTransform, carg1 C.GstPadDirection, carg2 *C.GstCaps, carg3 *C.GstCaps) (cret *C.GstCaps)) + if fn == nil { + panic("_gotk4_gstbase1_BaseTransform_fixate_caps: no function pointer found") + } + } + return fn(carg0, carg1, carg2, carg3) } //export _gotk4_gstbase1_BaseTransform_generate_output func _gotk4_gstbase1_BaseTransform_generate_output(carg0 *C.GstBaseTransform, carg1 **C.GstBuffer) (cret C.GstFlowReturn) { - panic("unimplemented") + var fn func(carg0 *C.GstBaseTransform, carg1 **C.GstBuffer) (cret C.GstFlowReturn) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstbase1_BaseTransform_generate_output").(func(carg0 *C.GstBaseTransform, carg1 **C.GstBuffer) (cret C.GstFlowReturn)) + if fn == nil { + panic("_gotk4_gstbase1_BaseTransform_generate_output: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstbase1_BaseTransform_get_unit_size func _gotk4_gstbase1_BaseTransform_get_unit_size(carg0 *C.GstBaseTransform, carg1 *C.GstCaps, carg2 *C.gsize) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstBaseTransform, carg1 *C.GstCaps, carg2 *C.gsize) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstbase1_BaseTransform_get_unit_size").(func(carg0 *C.GstBaseTransform, carg1 *C.GstCaps, carg2 *C.gsize) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstbase1_BaseTransform_get_unit_size: no function pointer found") + } + } + return fn(carg0, carg1, carg2) } //export _gotk4_gstbase1_BaseTransform_prepare_output_buffer func _gotk4_gstbase1_BaseTransform_prepare_output_buffer(carg0 *C.GstBaseTransform, carg1 *C.GstBuffer, carg2 **C.GstBuffer) (cret C.GstFlowReturn) { - panic("unimplemented") + var fn func(carg0 *C.GstBaseTransform, carg1 *C.GstBuffer, carg2 **C.GstBuffer) (cret C.GstFlowReturn) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstbase1_BaseTransform_prepare_output_buffer").(func(carg0 *C.GstBaseTransform, carg1 *C.GstBuffer, carg2 **C.GstBuffer) (cret C.GstFlowReturn)) + if fn == nil { + panic("_gotk4_gstbase1_BaseTransform_prepare_output_buffer: no function pointer found") + } + } + return fn(carg0, carg1, carg2) } //export _gotk4_gstbase1_BaseTransform_propose_allocation func _gotk4_gstbase1_BaseTransform_propose_allocation(carg0 *C.GstBaseTransform, carg1 *C.GstQuery, carg2 *C.GstQuery) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstBaseTransform, carg1 *C.GstQuery, carg2 *C.GstQuery) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstbase1_BaseTransform_propose_allocation").(func(carg0 *C.GstBaseTransform, carg1 *C.GstQuery, carg2 *C.GstQuery) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstbase1_BaseTransform_propose_allocation: no function pointer found") + } + } + return fn(carg0, carg1, carg2) } //export _gotk4_gstbase1_BaseTransform_query func _gotk4_gstbase1_BaseTransform_query(carg0 *C.GstBaseTransform, carg1 C.GstPadDirection, carg2 *C.GstQuery) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstBaseTransform, carg1 C.GstPadDirection, carg2 *C.GstQuery) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstbase1_BaseTransform_query").(func(carg0 *C.GstBaseTransform, carg1 C.GstPadDirection, carg2 *C.GstQuery) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstbase1_BaseTransform_query: no function pointer found") + } + } + return fn(carg0, carg1, carg2) } //export _gotk4_gstbase1_BaseTransform_set_caps func _gotk4_gstbase1_BaseTransform_set_caps(carg0 *C.GstBaseTransform, carg1 *C.GstCaps, carg2 *C.GstCaps) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstBaseTransform, carg1 *C.GstCaps, carg2 *C.GstCaps) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstbase1_BaseTransform_set_caps").(func(carg0 *C.GstBaseTransform, carg1 *C.GstCaps, carg2 *C.GstCaps) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstbase1_BaseTransform_set_caps: no function pointer found") + } + } + return fn(carg0, carg1, carg2) } //export _gotk4_gstbase1_BaseTransform_sink_event func _gotk4_gstbase1_BaseTransform_sink_event(carg0 *C.GstBaseTransform, carg1 *C.GstEvent) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstBaseTransform, carg1 *C.GstEvent) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstbase1_BaseTransform_sink_event").(func(carg0 *C.GstBaseTransform, carg1 *C.GstEvent) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstbase1_BaseTransform_sink_event: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstbase1_BaseTransform_src_event func _gotk4_gstbase1_BaseTransform_src_event(carg0 *C.GstBaseTransform, carg1 *C.GstEvent) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstBaseTransform, carg1 *C.GstEvent) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstbase1_BaseTransform_src_event").(func(carg0 *C.GstBaseTransform, carg1 *C.GstEvent) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstbase1_BaseTransform_src_event: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstbase1_BaseTransform_start func _gotk4_gstbase1_BaseTransform_start(carg0 *C.GstBaseTransform) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstBaseTransform) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstbase1_BaseTransform_start").(func(carg0 *C.GstBaseTransform) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstbase1_BaseTransform_start: no function pointer found") + } + } + return fn(carg0) } //export _gotk4_gstbase1_BaseTransform_stop func _gotk4_gstbase1_BaseTransform_stop(carg0 *C.GstBaseTransform) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstBaseTransform) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstbase1_BaseTransform_stop").(func(carg0 *C.GstBaseTransform) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstbase1_BaseTransform_stop: no function pointer found") + } + } + return fn(carg0) } //export _gotk4_gstbase1_BaseTransform_submit_input_buffer func _gotk4_gstbase1_BaseTransform_submit_input_buffer(carg0 *C.GstBaseTransform, carg1 C.gboolean, carg2 *C.GstBuffer) (cret C.GstFlowReturn) { - panic("unimplemented") + var fn func(carg0 *C.GstBaseTransform, carg1 C.gboolean, carg2 *C.GstBuffer) (cret C.GstFlowReturn) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstbase1_BaseTransform_submit_input_buffer").(func(carg0 *C.GstBaseTransform, carg1 C.gboolean, carg2 *C.GstBuffer) (cret C.GstFlowReturn)) + if fn == nil { + panic("_gotk4_gstbase1_BaseTransform_submit_input_buffer: no function pointer found") + } + } + return fn(carg0, carg1, carg2) } //export _gotk4_gstbase1_BaseTransform_transform func _gotk4_gstbase1_BaseTransform_transform(carg0 *C.GstBaseTransform, carg1 *C.GstBuffer, carg2 *C.GstBuffer) (cret C.GstFlowReturn) { - panic("unimplemented") + var fn func(carg0 *C.GstBaseTransform, carg1 *C.GstBuffer, carg2 *C.GstBuffer) (cret C.GstFlowReturn) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstbase1_BaseTransform_transform").(func(carg0 *C.GstBaseTransform, carg1 *C.GstBuffer, carg2 *C.GstBuffer) (cret C.GstFlowReturn)) + if fn == nil { + panic("_gotk4_gstbase1_BaseTransform_transform: no function pointer found") + } + } + return fn(carg0, carg1, carg2) } //export _gotk4_gstbase1_BaseTransform_transform_caps func _gotk4_gstbase1_BaseTransform_transform_caps(carg0 *C.GstBaseTransform, carg1 C.GstPadDirection, carg2 *C.GstCaps, carg3 *C.GstCaps) (cret *C.GstCaps) { - panic("unimplemented") + var fn func(carg0 *C.GstBaseTransform, carg1 C.GstPadDirection, carg2 *C.GstCaps, carg3 *C.GstCaps) (cret *C.GstCaps) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstbase1_BaseTransform_transform_caps").(func(carg0 *C.GstBaseTransform, carg1 C.GstPadDirection, carg2 *C.GstCaps, carg3 *C.GstCaps) (cret *C.GstCaps)) + if fn == nil { + panic("_gotk4_gstbase1_BaseTransform_transform_caps: no function pointer found") + } + } + return fn(carg0, carg1, carg2, carg3) } //export _gotk4_gstbase1_BaseTransform_transform_ip func _gotk4_gstbase1_BaseTransform_transform_ip(carg0 *C.GstBaseTransform, carg1 *C.GstBuffer) (cret C.GstFlowReturn) { - panic("unimplemented") + var fn func(carg0 *C.GstBaseTransform, carg1 *C.GstBuffer) (cret C.GstFlowReturn) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstbase1_BaseTransform_transform_ip").(func(carg0 *C.GstBaseTransform, carg1 *C.GstBuffer) (cret C.GstFlowReturn)) + if fn == nil { + panic("_gotk4_gstbase1_BaseTransform_transform_ip: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstbase1_BaseTransform_transform_meta func _gotk4_gstbase1_BaseTransform_transform_meta(carg0 *C.GstBaseTransform, carg1 *C.GstBuffer, carg2 *C.GstMeta, carg3 *C.GstBuffer) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstBaseTransform, carg1 *C.GstBuffer, carg2 *C.GstMeta, carg3 *C.GstBuffer) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstbase1_BaseTransform_transform_meta").(func(carg0 *C.GstBaseTransform, carg1 *C.GstBuffer, carg2 *C.GstMeta, carg3 *C.GstBuffer) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstbase1_BaseTransform_transform_meta: no function pointer found") + } + } + return fn(carg0, carg1, carg2, carg3) } //export _gotk4_gstbase1_BaseTransform_transform_size func _gotk4_gstbase1_BaseTransform_transform_size(carg0 *C.GstBaseTransform, carg1 C.GstPadDirection, carg2 *C.GstCaps, carg3 C.gsize, carg4 *C.GstCaps, carg5 *C.gsize) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstBaseTransform, carg1 C.GstPadDirection, carg2 *C.GstCaps, carg3 C.gsize, carg4 *C.GstCaps, carg5 *C.gsize) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstbase1_BaseTransform_transform_size").(func(carg0 *C.GstBaseTransform, carg1 C.GstPadDirection, carg2 *C.GstCaps, carg3 C.gsize, carg4 *C.GstCaps, carg5 *C.gsize) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstbase1_BaseTransform_transform_size: no function pointer found") + } + } + return fn(carg0, carg1, carg2, carg3, carg4, carg5) } //export _gotk4_gstbase1_DataQueue_empty func _gotk4_gstbase1_DataQueue_empty(carg0 *C.GstDataQueue) { - panic("unimplemented") + var fn func(carg0 *C.GstDataQueue) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstbase1_DataQueue_empty").(func(carg0 *C.GstDataQueue)) + if fn == nil { + panic("_gotk4_gstbase1_DataQueue_empty: no function pointer found") + } + } + fn(carg0) } //export _gotk4_gstbase1_DataQueue_full func _gotk4_gstbase1_DataQueue_full(carg0 *C.GstDataQueue) { - panic("unimplemented") + var fn func(carg0 *C.GstDataQueue) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstbase1_DataQueue_full").(func(carg0 *C.GstDataQueue)) + if fn == nil { + panic("_gotk4_gstbase1_DataQueue_full: no function pointer found") + } + } + fn(carg0) } //export _gotk4_gstbase1_PushSrc_alloc func _gotk4_gstbase1_PushSrc_alloc(carg0 *C.GstPushSrc, carg1 **C.GstBuffer) (cret C.GstFlowReturn) { - panic("unimplemented") + var fn func(carg0 *C.GstPushSrc, carg1 **C.GstBuffer) (cret C.GstFlowReturn) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstbase1_PushSrc_alloc").(func(carg0 *C.GstPushSrc, carg1 **C.GstBuffer) (cret C.GstFlowReturn)) + if fn == nil { + panic("_gotk4_gstbase1_PushSrc_alloc: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstbase1_PushSrc_fill func _gotk4_gstbase1_PushSrc_fill(carg0 *C.GstPushSrc, carg1 *C.GstBuffer) (cret C.GstFlowReturn) { - panic("unimplemented") + var fn func(carg0 *C.GstPushSrc, carg1 *C.GstBuffer) (cret C.GstFlowReturn) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstbase1_PushSrc_fill").(func(carg0 *C.GstPushSrc, carg1 *C.GstBuffer) (cret C.GstFlowReturn)) + if fn == nil { + panic("_gotk4_gstbase1_PushSrc_fill: no function pointer found") + } + } + return fn(carg0, carg1) } diff --git a/pkg/gstcheck/gstcheck.gen.go b/pkg/gstcheck/gstcheck.gen.go index 168bc79..c1c68e1 100644 --- a/pkg/gstcheck/gstcheck.gen.go +++ b/pkg/gstcheck/gstcheck.gen.go @@ -6,6 +6,7 @@ import ( "runtime" "unsafe" + "github.com/diamondburned/gotk4/pkg/core/classdata" "github.com/diamondburned/gotk4/pkg/core/userdata" "github.com/diamondburned/gotk4/pkg/glib/v2" "github.com/diamondburned/gotk4/pkg/gobject/v2" @@ -1562,6 +1563,32 @@ func UnsafeApplyTestClockOverrides[Instance TestClock](gclass unsafe.Pointer, ov gst.UnsafeApplyClockOverrides(gclass, overrides.ClockOverrides) } +// RegisterTestClockSubClass is used to register a go subclass of GstTestClock. For this to work safely please implement the +// virtual methods required by the implementation. +func RegisterTestClockSubClass[InstanceT TestClock]( + name string, + classInit func(class *TestClockClass), + constructor func() InstanceT, + overrides TestClockOverrides[InstanceT], + signals map[string]gobject.SignalDefinition, + interfaceInits ...gobject.SubClassInterfaceInit[InstanceT], +) gobject.Type { + return gobject.UnsafeRegisterSubClass( + name, + classInit, + constructor, + overrides, + signals, + TypeTestClock, + UnsafeTestClockClassFromGlibBorrow, + UnsafeApplyTestClockOverrides, + func (obj *gobject.ObjectInstance) gobject.Object { + return unsafeWrapTestClock(obj) + }, + interfaceInits..., + ) +} + // CheckABIStruct wraps GstCheckABIStruct type CheckABIStruct struct { *checkABIStruct diff --git a/pkg/gstcontroller/gstcontroller.gen.go b/pkg/gstcontroller/gstcontroller.gen.go index b3c8b0b..bfd29ca 100644 --- a/pkg/gstcontroller/gstcontroller.gen.go +++ b/pkg/gstcontroller/gstcontroller.gen.go @@ -7,6 +7,7 @@ import ( "runtime" "unsafe" + "github.com/diamondburned/gotk4/pkg/core/classdata" "github.com/diamondburned/gotk4/pkg/glib/v2" "github.com/diamondburned/gotk4/pkg/gobject/v2" "github.com/go-gst/go-gst/pkg/gst" @@ -281,6 +282,32 @@ func UnsafeApplyARGBControlBindingOverrides[Instance ARGBControlBinding](gclass gst.UnsafeApplyControlBindingOverrides(gclass, overrides.ControlBindingOverrides) } +// RegisterARGBControlBindingSubClass is used to register a go subclass of GstARGBControlBinding. For this to work safely please implement the +// virtual methods required by the implementation. +func RegisterARGBControlBindingSubClass[InstanceT ARGBControlBinding]( + name string, + classInit func(class *ARGBControlBindingClass), + constructor func() InstanceT, + overrides ARGBControlBindingOverrides[InstanceT], + signals map[string]gobject.SignalDefinition, + interfaceInits ...gobject.SubClassInterfaceInit[InstanceT], +) gobject.Type { + return gobject.UnsafeRegisterSubClass( + name, + classInit, + constructor, + overrides, + signals, + TypeARGBControlBinding, + UnsafeARGBControlBindingClassFromGlibBorrow, + UnsafeApplyARGBControlBindingOverrides, + func (obj *gobject.ObjectInstance) gobject.Object { + return unsafeWrapARGBControlBinding(obj) + }, + interfaceInits..., + ) +} + // DirectControlBindingInstance is the instance type used by all types extending GstDirectControlBinding. It is used internally by the bindings. Users should use the interface [DirectControlBinding] instead. type DirectControlBindingInstance struct { _ [0]func() // equal guard @@ -432,6 +459,32 @@ func UnsafeApplyDirectControlBindingOverrides[Instance DirectControlBinding](gcl gst.UnsafeApplyControlBindingOverrides(gclass, overrides.ControlBindingOverrides) } +// RegisterDirectControlBindingSubClass is used to register a go subclass of GstDirectControlBinding. For this to work safely please implement the +// virtual methods required by the implementation. +func RegisterDirectControlBindingSubClass[InstanceT DirectControlBinding]( + name string, + classInit func(class *DirectControlBindingClass), + constructor func() InstanceT, + overrides DirectControlBindingOverrides[InstanceT], + signals map[string]gobject.SignalDefinition, + interfaceInits ...gobject.SubClassInterfaceInit[InstanceT], +) gobject.Type { + return gobject.UnsafeRegisterSubClass( + name, + classInit, + constructor, + overrides, + signals, + TypeDirectControlBinding, + UnsafeDirectControlBindingClassFromGlibBorrow, + UnsafeApplyDirectControlBindingOverrides, + func (obj *gobject.ObjectInstance) gobject.Object { + return unsafeWrapDirectControlBinding(obj) + }, + interfaceInits..., + ) +} + // LFOControlSourceInstance is the instance type used by all types extending GstLFOControlSource. It is used internally by the bindings. Users should use the interface [LFOControlSource] instead. type LFOControlSourceInstance struct { _ [0]func() // equal guard @@ -528,6 +581,32 @@ func UnsafeApplyLFOControlSourceOverrides[Instance LFOControlSource](gclass unsa gst.UnsafeApplyControlSourceOverrides(gclass, overrides.ControlSourceOverrides) } +// RegisterLFOControlSourceSubClass is used to register a go subclass of GstLFOControlSource. For this to work safely please implement the +// virtual methods required by the implementation. +func RegisterLFOControlSourceSubClass[InstanceT LFOControlSource]( + name string, + classInit func(class *LFOControlSourceClass), + constructor func() InstanceT, + overrides LFOControlSourceOverrides[InstanceT], + signals map[string]gobject.SignalDefinition, + interfaceInits ...gobject.SubClassInterfaceInit[InstanceT], +) gobject.Type { + return gobject.UnsafeRegisterSubClass( + name, + classInit, + constructor, + overrides, + signals, + TypeLFOControlSource, + UnsafeLFOControlSourceClassFromGlibBorrow, + UnsafeApplyLFOControlSourceOverrides, + func (obj *gobject.ObjectInstance) gobject.Object { + return unsafeWrapLFOControlSource(obj) + }, + interfaceInits..., + ) +} + // ProxyControlBindingInstance is the instance type used by all types extending GstProxyControlBinding. It is used internally by the bindings. Users should use the interface [ProxyControlBinding] instead. type ProxyControlBindingInstance struct { _ [0]func() // equal guard @@ -642,6 +721,32 @@ func UnsafeApplyProxyControlBindingOverrides[Instance ProxyControlBinding](gclas gst.UnsafeApplyControlBindingOverrides(gclass, overrides.ControlBindingOverrides) } +// RegisterProxyControlBindingSubClass is used to register a go subclass of GstProxyControlBinding. For this to work safely please implement the +// virtual methods required by the implementation. +func RegisterProxyControlBindingSubClass[InstanceT ProxyControlBinding]( + name string, + classInit func(class *ProxyControlBindingClass), + constructor func() InstanceT, + overrides ProxyControlBindingOverrides[InstanceT], + signals map[string]gobject.SignalDefinition, + interfaceInits ...gobject.SubClassInterfaceInit[InstanceT], +) gobject.Type { + return gobject.UnsafeRegisterSubClass( + name, + classInit, + constructor, + overrides, + signals, + TypeProxyControlBinding, + UnsafeProxyControlBindingClassFromGlibBorrow, + UnsafeApplyProxyControlBindingOverrides, + func (obj *gobject.ObjectInstance) gobject.Object { + return unsafeWrapProxyControlBinding(obj) + }, + interfaceInits..., + ) +} + // TimedValueControlSourceInstance is the instance type used by all types extending GstTimedValueControlSource. It is used internally by the bindings. Users should use the interface [TimedValueControlSource] instead. type TimedValueControlSourceInstance struct { _ [0]func() // equal guard @@ -985,6 +1090,32 @@ func UnsafeApplyTimedValueControlSourceOverrides[Instance TimedValueControlSourc gst.UnsafeApplyControlSourceOverrides(gclass, overrides.ControlSourceOverrides) } +// RegisterTimedValueControlSourceSubClass is used to register a go subclass of GstTimedValueControlSource. For this to work safely please implement the +// virtual methods required by the implementation. +func RegisterTimedValueControlSourceSubClass[InstanceT TimedValueControlSource]( + name string, + classInit func(class *TimedValueControlSourceClass), + constructor func() InstanceT, + overrides TimedValueControlSourceOverrides[InstanceT], + signals map[string]gobject.SignalDefinition, + interfaceInits ...gobject.SubClassInterfaceInit[InstanceT], +) gobject.Type { + return gobject.UnsafeRegisterSubClass( + name, + classInit, + constructor, + overrides, + signals, + TypeTimedValueControlSource, + UnsafeTimedValueControlSourceClassFromGlibBorrow, + UnsafeApplyTimedValueControlSourceOverrides, + func (obj *gobject.ObjectInstance) gobject.Object { + return unsafeWrapTimedValueControlSource(obj) + }, + interfaceInits..., + ) +} + // TriggerControlSourceInstance is the instance type used by all types extending GstTriggerControlSource. It is used internally by the bindings. Users should use the interface [TriggerControlSource] instead. type TriggerControlSourceInstance struct { _ [0]func() // equal guard @@ -1083,6 +1214,32 @@ func UnsafeApplyTriggerControlSourceOverrides[Instance TriggerControlSource](gcl UnsafeApplyTimedValueControlSourceOverrides(gclass, overrides.TimedValueControlSourceOverrides) } +// RegisterTriggerControlSourceSubClass is used to register a go subclass of GstTriggerControlSource. For this to work safely please implement the +// virtual methods required by the implementation. +func RegisterTriggerControlSourceSubClass[InstanceT TriggerControlSource]( + name string, + classInit func(class *TriggerControlSourceClass), + constructor func() InstanceT, + overrides TriggerControlSourceOverrides[InstanceT], + signals map[string]gobject.SignalDefinition, + interfaceInits ...gobject.SubClassInterfaceInit[InstanceT], +) gobject.Type { + return gobject.UnsafeRegisterSubClass( + name, + classInit, + constructor, + overrides, + signals, + TypeTriggerControlSource, + UnsafeTriggerControlSourceClassFromGlibBorrow, + UnsafeApplyTriggerControlSourceOverrides, + func (obj *gobject.ObjectInstance) gobject.Object { + return unsafeWrapTriggerControlSource(obj) + }, + interfaceInits..., + ) +} + // InterpolationControlSourceInstance is the instance type used by all types extending GstInterpolationControlSource. It is used internally by the bindings. Users should use the interface [InterpolationControlSource] instead. type InterpolationControlSourceInstance struct { _ [0]func() // equal guard @@ -1181,6 +1338,32 @@ func UnsafeApplyInterpolationControlSourceOverrides[Instance InterpolationContro UnsafeApplyTimedValueControlSourceOverrides(gclass, overrides.TimedValueControlSourceOverrides) } +// RegisterInterpolationControlSourceSubClass is used to register a go subclass of GstInterpolationControlSource. For this to work safely please implement the +// virtual methods required by the implementation. +func RegisterInterpolationControlSourceSubClass[InstanceT InterpolationControlSource]( + name string, + classInit func(class *InterpolationControlSourceClass), + constructor func() InstanceT, + overrides InterpolationControlSourceOverrides[InstanceT], + signals map[string]gobject.SignalDefinition, + interfaceInits ...gobject.SubClassInterfaceInit[InstanceT], +) gobject.Type { + return gobject.UnsafeRegisterSubClass( + name, + classInit, + constructor, + overrides, + signals, + TypeInterpolationControlSource, + UnsafeInterpolationControlSourceClassFromGlibBorrow, + UnsafeApplyInterpolationControlSourceOverrides, + func (obj *gobject.ObjectInstance) gobject.Object { + return unsafeWrapInterpolationControlSource(obj) + }, + interfaceInits..., + ) +} + // ARGBControlBindingClass wraps GstARGBControlBindingClass // // The class structure of #GstARGBControlBinding. diff --git a/pkg/gstgl/gstgl.gen.go b/pkg/gstgl/gstgl.gen.go index 41ac05e..826cd84 100644 --- a/pkg/gstgl/gstgl.gen.go +++ b/pkg/gstgl/gstgl.gen.go @@ -8,6 +8,7 @@ import ( "strings" "unsafe" + "github.com/diamondburned/gotk4/pkg/core/classdata" "github.com/diamondburned/gotk4/pkg/core/userdata" "github.com/diamondburned/gotk4/pkg/glib/v2" "github.com/diamondburned/gotk4/pkg/gobject/v2" @@ -3035,17 +3036,94 @@ func UnsafeApplyGLBaseFilterOverrides[Instance GLBaseFilter](gclass unsafe.Point if overrides.GLSetCaps != nil { pclass.gl_set_caps = (*[0]byte)(C._gotk4_gstgl1_GLBaseFilter_gl_set_caps) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstgl1_GLBaseFilter_gl_set_caps", + func(carg0 *C.GstGLBaseFilter, carg1 *C.GstCaps, carg2 *C.GstCaps) (cret C.gboolean) { + var filter Instance // go GstGLBaseFilter subclass + var incaps *gst.Caps // in, none, converted + var outcaps *gst.Caps // in, none, converted + var goret bool // return + + filter = UnsafeGLBaseFilterFromGlibNone(unsafe.Pointer(carg0)).(Instance) + incaps = gst.UnsafeCapsFromGlibNone(unsafe.Pointer(carg1)) + outcaps = gst.UnsafeCapsFromGlibNone(unsafe.Pointer(carg2)) + + goret = overrides.GLSetCaps(filter, incaps, outcaps) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.GLStart != nil { pclass.gl_start = (*[0]byte)(C._gotk4_gstgl1_GLBaseFilter_gl_start) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstgl1_GLBaseFilter_gl_start", + func(carg0 *C.GstGLBaseFilter) (cret C.gboolean) { + var filter Instance // go GstGLBaseFilter subclass + var goret bool // return + + filter = UnsafeGLBaseFilterFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + goret = overrides.GLStart(filter) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.GLStop != nil { pclass.gl_stop = (*[0]byte)(C._gotk4_gstgl1_GLBaseFilter_gl_stop) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstgl1_GLBaseFilter_gl_stop", + func(carg0 *C.GstGLBaseFilter) { + var filter Instance // go GstGLBaseFilter subclass + + filter = UnsafeGLBaseFilterFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + overrides.GLStop(filter) + }, + ) } } +// RegisterGLBaseFilterSubClass is used to register a go subclass of GstGLBaseFilter. For this to work safely please implement the +// virtual methods required by the implementation. +func RegisterGLBaseFilterSubClass[InstanceT GLBaseFilter]( + name string, + classInit func(class *GLBaseFilterClass), + constructor func() InstanceT, + overrides GLBaseFilterOverrides[InstanceT], + signals map[string]gobject.SignalDefinition, + interfaceInits ...gobject.SubClassInterfaceInit[InstanceT], +) gobject.Type { + return gobject.UnsafeRegisterSubClass( + name, + classInit, + constructor, + overrides, + signals, + TypeGLBaseFilter, + UnsafeGLBaseFilterClassFromGlibBorrow, + UnsafeApplyGLBaseFilterOverrides, + func (obj *gobject.ObjectInstance) gobject.Object { + return unsafeWrapGLBaseFilter(obj) + }, + interfaceInits..., + ) +} + // GLBaseMemoryAllocatorInstance is the instance type used by all types extending GstGLBaseMemoryAllocator. It is used internally by the bindings. Users should use the interface [GLBaseMemoryAllocator] instead. type GLBaseMemoryAllocatorInstance struct { _ [0]func() // equal guard @@ -3116,6 +3194,32 @@ func UnsafeApplyGLBaseMemoryAllocatorOverrides[Instance GLBaseMemoryAllocator](g gst.UnsafeApplyAllocatorOverrides(gclass, overrides.AllocatorOverrides) } +// RegisterGLBaseMemoryAllocatorSubClass is used to register a go subclass of GstGLBaseMemoryAllocator. For this to work safely please implement the +// virtual methods required by the implementation. +func RegisterGLBaseMemoryAllocatorSubClass[InstanceT GLBaseMemoryAllocator]( + name string, + classInit func(class *GLBaseMemoryAllocatorClass), + constructor func() InstanceT, + overrides GLBaseMemoryAllocatorOverrides[InstanceT], + signals map[string]gobject.SignalDefinition, + interfaceInits ...gobject.SubClassInterfaceInit[InstanceT], +) gobject.Type { + return gobject.UnsafeRegisterSubClass( + name, + classInit, + constructor, + overrides, + signals, + TypeGLBaseMemoryAllocator, + UnsafeGLBaseMemoryAllocatorClassFromGlibBorrow, + UnsafeApplyGLBaseMemoryAllocatorOverrides, + func (obj *gobject.ObjectInstance) gobject.Object { + return unsafeWrapGLBaseMemoryAllocator(obj) + }, + interfaceInits..., + ) +} + // GLBaseMixerInstance is the instance type used by all types extending GstGLBaseMixer. It is used internally by the bindings. Users should use the interface [GLBaseMixer] instead. type GLBaseMixerInstance struct { _ [0]func() // equal guard @@ -3232,13 +3336,68 @@ func UnsafeApplyGLBaseMixerOverrides[Instance GLBaseMixer](gclass unsafe.Pointer if overrides.GLStart != nil { pclass.gl_start = (*[0]byte)(C._gotk4_gstgl1_GLBaseMixer_gl_start) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstgl1_GLBaseMixer_gl_start", + func(carg0 *C.GstGLBaseMixer) (cret C.gboolean) { + var mix Instance // go GstGLBaseMixer subclass + var goret bool // return + + mix = UnsafeGLBaseMixerFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + goret = overrides.GLStart(mix) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.GLStop != nil { pclass.gl_stop = (*[0]byte)(C._gotk4_gstgl1_GLBaseMixer_gl_stop) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstgl1_GLBaseMixer_gl_stop", + func(carg0 *C.GstGLBaseMixer) { + var mix Instance // go GstGLBaseMixer subclass + + mix = UnsafeGLBaseMixerFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + overrides.GLStop(mix) + }, + ) } } +// RegisterGLBaseMixerSubClass is used to register a go subclass of GstGLBaseMixer. For this to work safely please implement the +// virtual methods required by the implementation. +func RegisterGLBaseMixerSubClass[InstanceT GLBaseMixer]( + name string, + classInit func(class *GLBaseMixerClass), + constructor func() InstanceT, + overrides GLBaseMixerOverrides[InstanceT], + signals map[string]gobject.SignalDefinition, + interfaceInits ...gobject.SubClassInterfaceInit[InstanceT], +) gobject.Type { + return gobject.UnsafeRegisterSubClass( + name, + classInit, + constructor, + overrides, + signals, + TypeGLBaseMixer, + UnsafeGLBaseMixerClassFromGlibBorrow, + UnsafeApplyGLBaseMixerOverrides, + func (obj *gobject.ObjectInstance) gobject.Object { + return unsafeWrapGLBaseMixer(obj) + }, + interfaceInits..., + ) +} + // GLBaseMixerPadInstance is the instance type used by all types extending GstGLBaseMixerPad. It is used internally by the bindings. Users should use the interface [GLBaseMixerPad] instead. type GLBaseMixerPadInstance struct { _ [0]func() // equal guard @@ -3311,6 +3470,32 @@ func UnsafeApplyGLBaseMixerPadOverrides[Instance GLBaseMixerPad](gclass unsafe.P gstvideo.UnsafeApplyVideoAggregatorPadOverrides(gclass, overrides.VideoAggregatorPadOverrides) } +// RegisterGLBaseMixerPadSubClass is used to register a go subclass of GstGLBaseMixerPad. For this to work safely please implement the +// virtual methods required by the implementation. +func RegisterGLBaseMixerPadSubClass[InstanceT GLBaseMixerPad]( + name string, + classInit func(class *GLBaseMixerPadClass), + constructor func() InstanceT, + overrides GLBaseMixerPadOverrides[InstanceT], + signals map[string]gobject.SignalDefinition, + interfaceInits ...gobject.SubClassInterfaceInit[InstanceT], +) gobject.Type { + return gobject.UnsafeRegisterSubClass( + name, + classInit, + constructor, + overrides, + signals, + TypeGLBaseMixerPad, + UnsafeGLBaseMixerPadClassFromGlibBorrow, + UnsafeApplyGLBaseMixerPadOverrides, + func (obj *gobject.ObjectInstance) gobject.Object { + return unsafeWrapGLBaseMixerPad(obj) + }, + interfaceInits..., + ) +} + // GLBaseSrcInstance is the instance type used by all types extending GstGLBaseSrc. It is used internally by the bindings. Users should use the interface [GLBaseSrc] instead. type GLBaseSrcInstance struct { _ [0]func() // equal guard @@ -3407,17 +3592,92 @@ func UnsafeApplyGLBaseSrcOverrides[Instance GLBaseSrc](gclass unsafe.Pointer, ov if overrides.FillGLMemory != nil { pclass.fill_gl_memory = (*[0]byte)(C._gotk4_gstgl1_GLBaseSrc_fill_gl_memory) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstgl1_GLBaseSrc_fill_gl_memory", + func(carg0 *C.GstGLBaseSrc, carg1 *C.GstGLMemory) (cret C.gboolean) { + var src Instance // go GstGLBaseSrc subclass + var mem *GLMemory // in, none, converted + var goret bool // return + + src = UnsafeGLBaseSrcFromGlibNone(unsafe.Pointer(carg0)).(Instance) + mem = UnsafeGLMemoryFromGlibNone(unsafe.Pointer(carg1)) + + goret = overrides.FillGLMemory(src, mem) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.GLStart != nil { pclass.gl_start = (*[0]byte)(C._gotk4_gstgl1_GLBaseSrc_gl_start) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstgl1_GLBaseSrc_gl_start", + func(carg0 *C.GstGLBaseSrc) (cret C.gboolean) { + var src Instance // go GstGLBaseSrc subclass + var goret bool // return + + src = UnsafeGLBaseSrcFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + goret = overrides.GLStart(src) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.GLStop != nil { pclass.gl_stop = (*[0]byte)(C._gotk4_gstgl1_GLBaseSrc_gl_stop) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstgl1_GLBaseSrc_gl_stop", + func(carg0 *C.GstGLBaseSrc) { + var src Instance // go GstGLBaseSrc subclass + + src = UnsafeGLBaseSrcFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + overrides.GLStop(src) + }, + ) } } +// RegisterGLBaseSrcSubClass is used to register a go subclass of GstGLBaseSrc. For this to work safely please implement the +// virtual methods required by the implementation. +func RegisterGLBaseSrcSubClass[InstanceT GLBaseSrc]( + name string, + classInit func(class *GLBaseSrcClass), + constructor func() InstanceT, + overrides GLBaseSrcOverrides[InstanceT], + signals map[string]gobject.SignalDefinition, + interfaceInits ...gobject.SubClassInterfaceInit[InstanceT], +) gobject.Type { + return gobject.UnsafeRegisterSubClass( + name, + classInit, + constructor, + overrides, + signals, + TypeGLBaseSrc, + UnsafeGLBaseSrcClassFromGlibBorrow, + UnsafeApplyGLBaseSrcOverrides, + func (obj *gobject.ObjectInstance) gobject.Object { + return unsafeWrapGLBaseSrc(obj) + }, + interfaceInits..., + ) +} + // GLBufferAllocatorInstance is the instance type used by all types extending GstGLBufferAllocator. It is used internally by the bindings. Users should use the interface [GLBufferAllocator] instead. type GLBufferAllocatorInstance struct { _ [0]func() // equal guard @@ -3490,6 +3750,32 @@ func UnsafeApplyGLBufferAllocatorOverrides[Instance GLBufferAllocator](gclass un UnsafeApplyGLBaseMemoryAllocatorOverrides(gclass, overrides.GLBaseMemoryAllocatorOverrides) } +// RegisterGLBufferAllocatorSubClass is used to register a go subclass of GstGLBufferAllocator. For this to work safely please implement the +// virtual methods required by the implementation. +func RegisterGLBufferAllocatorSubClass[InstanceT GLBufferAllocator]( + name string, + classInit func(class *GLBufferAllocatorClass), + constructor func() InstanceT, + overrides GLBufferAllocatorOverrides[InstanceT], + signals map[string]gobject.SignalDefinition, + interfaceInits ...gobject.SubClassInterfaceInit[InstanceT], +) gobject.Type { + return gobject.UnsafeRegisterSubClass( + name, + classInit, + constructor, + overrides, + signals, + TypeGLBufferAllocator, + UnsafeGLBufferAllocatorClassFromGlibBorrow, + UnsafeApplyGLBufferAllocatorOverrides, + func (obj *gobject.ObjectInstance) gobject.Object { + return unsafeWrapGLBufferAllocator(obj) + }, + interfaceInits..., + ) +} + // GLBufferPoolInstance is the instance type used by all types extending GstGLBufferPool. It is used internally by the bindings. Users should use the interface [GLBufferPool] instead. type GLBufferPoolInstance struct { _ [0]func() // equal guard @@ -3632,6 +3918,32 @@ func UnsafeApplyGLBufferPoolOverrides[Instance GLBufferPool](gclass unsafe.Point gst.UnsafeApplyBufferPoolOverrides(gclass, overrides.BufferPoolOverrides) } +// RegisterGLBufferPoolSubClass is used to register a go subclass of GstGLBufferPool. For this to work safely please implement the +// virtual methods required by the implementation. +func RegisterGLBufferPoolSubClass[InstanceT GLBufferPool]( + name string, + classInit func(class *GLBufferPoolClass), + constructor func() InstanceT, + overrides GLBufferPoolOverrides[InstanceT], + signals map[string]gobject.SignalDefinition, + interfaceInits ...gobject.SubClassInterfaceInit[InstanceT], +) gobject.Type { + return gobject.UnsafeRegisterSubClass( + name, + classInit, + constructor, + overrides, + signals, + TypeGLBufferPool, + UnsafeGLBufferPoolClassFromGlibBorrow, + UnsafeApplyGLBufferPoolOverrides, + func (obj *gobject.ObjectInstance) gobject.Object { + return unsafeWrapGLBufferPool(obj) + }, + interfaceInits..., + ) +} + // GLColorConvertInstance is the instance type used by all types extending GstGLColorConvert. It is used internally by the bindings. Users should use the interface [GLColorConvert] instead. type GLColorConvertInstance struct { _ [0]func() // equal guard @@ -4011,6 +4323,32 @@ func UnsafeApplyGLColorConvertOverrides[Instance GLColorConvert](gclass unsafe.P gst.UnsafeApplyObjectOverrides(gclass, overrides.ObjectOverrides) } +// RegisterGLColorConvertSubClass is used to register a go subclass of GstGLColorConvert. For this to work safely please implement the +// virtual methods required by the implementation. +func RegisterGLColorConvertSubClass[InstanceT GLColorConvert]( + name string, + classInit func(class *GLColorConvertClass), + constructor func() InstanceT, + overrides GLColorConvertOverrides[InstanceT], + signals map[string]gobject.SignalDefinition, + interfaceInits ...gobject.SubClassInterfaceInit[InstanceT], +) gobject.Type { + return gobject.UnsafeRegisterSubClass( + name, + classInit, + constructor, + overrides, + signals, + TypeGLColorConvert, + UnsafeGLColorConvertClassFromGlibBorrow, + UnsafeApplyGLColorConvertOverrides, + func (obj *gobject.ObjectInstance) gobject.Object { + return unsafeWrapGLColorConvert(obj) + }, + interfaceInits..., + ) +} + // GLContextInstance is the instance type used by all types extending GstGLContext. It is used internally by the bindings. Users should use the interface [GLContext] instead. type GLContextInstance struct { _ [0]func() // equal guard @@ -5261,49 +5599,271 @@ func UnsafeApplyGLContextOverrides[Instance GLContext](gclass unsafe.Pointer, ov if overrides.Activate != nil { pclass.activate = (*[0]byte)(C._gotk4_gstgl1_GLContext_activate) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstgl1_GLContext_activate", + func(carg0 *C.GstGLContext, carg1 C.gboolean) (cret C.gboolean) { + var _context Instance // go GstGLContext subclass + var activate bool // in + var goret bool // return + + _context = UnsafeGLContextFromGlibNone(unsafe.Pointer(carg0)).(Instance) + if carg1 != 0 { + activate = true + } + + goret = overrides.Activate(_context, activate) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.CheckFeature != nil { pclass.check_feature = (*[0]byte)(C._gotk4_gstgl1_GLContext_check_feature) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstgl1_GLContext_check_feature", + func(carg0 *C.GstGLContext, carg1 *C.gchar) (cret C.gboolean) { + var _context Instance // go GstGLContext subclass + var feature string // in, none, string + var goret bool // return + + _context = UnsafeGLContextFromGlibNone(unsafe.Pointer(carg0)).(Instance) + feature = C.GoString((*C.char)(unsafe.Pointer(carg1))) + + goret = overrides.CheckFeature(_context, feature) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.ChooseFormat != nil { pclass.choose_format = (*[0]byte)(C._gotk4_gstgl1_GLContext_choose_format) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstgl1_GLContext_choose_format", + func(carg0 *C.GstGLContext, _cerr **C.GError) (cret C.gboolean) { + var _context Instance // go GstGLContext subclass + var goret bool // return + var _goerr error // out, full, converted + + _context = UnsafeGLContextFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + goret, _goerr = overrides.ChooseFormat(_context) + + if goret { + cret = C.TRUE + } + *_cerr = (*C.GError)(glib.UnsafeErrorToGlibFull(_goerr)) + + return cret + }, + ) } if overrides.CreateContext != nil { pclass.create_context = (*[0]byte)(C._gotk4_gstgl1_GLContext_create_context) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstgl1_GLContext_create_context", + func(carg0 *C.GstGLContext, carg1 C.GstGLAPI, carg2 *C.GstGLContext, _cerr **C.GError) (cret C.gboolean) { + var _context Instance // go GstGLContext subclass + var glApi GLAPI // in, none, casted + var otherContext GLContext // in, none, converted + var goret bool // return + var _goerr error // out, full, converted + + _context = UnsafeGLContextFromGlibNone(unsafe.Pointer(carg0)).(Instance) + glApi = GLAPI(carg1) + otherContext = UnsafeGLContextFromGlibNone(unsafe.Pointer(carg2)) + + goret, _goerr = overrides.CreateContext(_context, glApi, otherContext) + + if goret { + cret = C.TRUE + } + *_cerr = (*C.GError)(glib.UnsafeErrorToGlibFull(_goerr)) + + return cret + }, + ) } if overrides.DestroyContext != nil { pclass.destroy_context = (*[0]byte)(C._gotk4_gstgl1_GLContext_destroy_context) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstgl1_GLContext_destroy_context", + func(carg0 *C.GstGLContext) { + var _context Instance // go GstGLContext subclass + + _context = UnsafeGLContextFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + overrides.DestroyContext(_context) + }, + ) } if overrides.GetConfig != nil { pclass.get_config = (*[0]byte)(C._gotk4_gstgl1_GLContext_get_config) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstgl1_GLContext_get_config", + func(carg0 *C.GstGLContext) (cret *C.GstStructure) { + var _context Instance // go GstGLContext subclass + var goret *gst.Structure // return, full, converted, nullable + + _context = UnsafeGLContextFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + goret = overrides.GetConfig(_context) + + if goret != nil { + cret = (*C.GstStructure)(gst.UnsafeStructureToGlibFull(goret)) + } + + return cret + }, + ) } if overrides.GetGLApi != nil { pclass.get_gl_api = (*[0]byte)(C._gotk4_gstgl1_GLContext_get_gl_api) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstgl1_GLContext_get_gl_api", + func(carg0 *C.GstGLContext) (cret C.GstGLAPI) { + var _context Instance // go GstGLContext subclass + var goret GLAPI // return, none, casted + + _context = UnsafeGLContextFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + goret = overrides.GetGLApi(_context) + + cret = C.GstGLAPI(goret) + + return cret + }, + ) } if overrides.GetGLPlatform != nil { pclass.get_gl_platform = (*[0]byte)(C._gotk4_gstgl1_GLContext_get_gl_platform) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstgl1_GLContext_get_gl_platform", + func(carg0 *C.GstGLContext) (cret C.GstGLPlatform) { + var _context Instance // go GstGLContext subclass + var goret GLPlatform // return, none, casted + + _context = UnsafeGLContextFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + goret = overrides.GetGLPlatform(_context) + + cret = C.GstGLPlatform(goret) + + return cret + }, + ) } if overrides.GetGLPlatformVersion != nil { pclass.get_gl_platform_version = (*[0]byte)(C._gotk4_gstgl1_GLContext_get_gl_platform_version) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstgl1_GLContext_get_gl_platform_version", + func(carg0 *C.GstGLContext, carg1 *C.gint, carg2 *C.gint) { + var _context Instance // go GstGLContext subclass + var major int // out, full, casted + var minor int // out, full, casted + + _context = UnsafeGLContextFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + major, minor = overrides.GetGLPlatformVersion(_context) + + *carg1 = C.gint(major) + *carg2 = C.gint(minor) + }, + ) } if overrides.RequestConfig != nil { pclass.request_config = (*[0]byte)(C._gotk4_gstgl1_GLContext_request_config) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstgl1_GLContext_request_config", + func(carg0 *C.GstGLContext, carg1 *C.GstStructure) (cret C.gboolean) { + var _context Instance // go GstGLContext subclass + var glConfig *gst.Structure // in, full, converted, nullable + var goret bool // return + + _context = UnsafeGLContextFromGlibNone(unsafe.Pointer(carg0)).(Instance) + if carg1 != nil { + glConfig = gst.UnsafeStructureFromGlibFull(unsafe.Pointer(carg1)) + } + + goret = overrides.RequestConfig(_context, glConfig) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.SwapBuffers != nil { pclass.swap_buffers = (*[0]byte)(C._gotk4_gstgl1_GLContext_swap_buffers) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstgl1_GLContext_swap_buffers", + func(carg0 *C.GstGLContext) { + var _context Instance // go GstGLContext subclass + + _context = UnsafeGLContextFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + overrides.SwapBuffers(_context) + }, + ) } } +// RegisterGLContextSubClass is used to register a go subclass of GstGLContext. For this to work safely please implement the +// virtual methods required by the implementation. +func RegisterGLContextSubClass[InstanceT GLContext]( + name string, + classInit func(class *GLContextClass), + constructor func() InstanceT, + overrides GLContextOverrides[InstanceT], + signals map[string]gobject.SignalDefinition, + interfaceInits ...gobject.SubClassInterfaceInit[InstanceT], +) gobject.Type { + return gobject.UnsafeRegisterSubClass( + name, + classInit, + constructor, + overrides, + signals, + TypeGLContext, + UnsafeGLContextClassFromGlibBorrow, + UnsafeApplyGLContextOverrides, + func (obj *gobject.ObjectInstance) gobject.Object { + return unsafeWrapGLContext(obj) + }, + interfaceInits..., + ) +} + // GLDisplayInstance is the instance type used by all types extending GstGLDisplay. It is used internally by the bindings. Users should use the interface [GLDisplay] instead. type GLDisplayInstance struct { _ [0]func() // equal guard @@ -5776,9 +6336,53 @@ func UnsafeApplyGLDisplayOverrides[Instance GLDisplay](gclass unsafe.Pointer, ov if overrides.CreateWindow != nil { pclass.create_window = (*[0]byte)(C._gotk4_gstgl1_GLDisplay_create_window) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstgl1_GLDisplay_create_window", + func(carg0 *C.GstGLDisplay) (cret *C.GstGLWindow) { + var display Instance // go GstGLDisplay subclass + var goret GLWindow // return, full, converted, nullable + + display = UnsafeGLDisplayFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + goret = overrides.CreateWindow(display) + + if goret != nil { + cret = (*C.GstGLWindow)(UnsafeGLWindowToGlibFull(goret)) + } + + return cret + }, + ) } } +// RegisterGLDisplaySubClass is used to register a go subclass of GstGLDisplay. For this to work safely please implement the +// virtual methods required by the implementation. +func RegisterGLDisplaySubClass[InstanceT GLDisplay]( + name string, + classInit func(class *GLDisplayClass), + constructor func() InstanceT, + overrides GLDisplayOverrides[InstanceT], + signals map[string]gobject.SignalDefinition, + interfaceInits ...gobject.SubClassInterfaceInit[InstanceT], +) gobject.Type { + return gobject.UnsafeRegisterSubClass( + name, + classInit, + constructor, + overrides, + signals, + TypeGLDisplay, + UnsafeGLDisplayClassFromGlibBorrow, + UnsafeApplyGLDisplayOverrides, + func (obj *gobject.ObjectInstance) gobject.Object { + return unsafeWrapGLDisplay(obj) + }, + interfaceInits..., + ) +} + // GLFilterInstance is the instance type used by all types extending GstGLFilter. It is used internally by the bindings. Users should use the interface [GLFilter] instead. type GLFilterInstance struct { _ [0]func() // equal guard @@ -6087,25 +6691,157 @@ func UnsafeApplyGLFilterOverrides[Instance GLFilter](gclass unsafe.Pointer, over if overrides.Filter != nil { pclass.filter = (*[0]byte)(C._gotk4_gstgl1_GLFilter_filter) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstgl1_GLFilter_filter", + func(carg0 *C.GstGLFilter, carg1 *C.GstBuffer, carg2 *C.GstBuffer) (cret C.gboolean) { + var filter Instance // go GstGLFilter subclass + var inbuf *gst.Buffer // in, none, converted + var outbuf *gst.Buffer // in, none, converted + var goret bool // return + + filter = UnsafeGLFilterFromGlibNone(unsafe.Pointer(carg0)).(Instance) + inbuf = gst.UnsafeBufferFromGlibNone(unsafe.Pointer(carg1)) + outbuf = gst.UnsafeBufferFromGlibNone(unsafe.Pointer(carg2)) + + goret = overrides.Filter(filter, inbuf, outbuf) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.FilterTexture != nil { pclass.filter_texture = (*[0]byte)(C._gotk4_gstgl1_GLFilter_filter_texture) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstgl1_GLFilter_filter_texture", + func(carg0 *C.GstGLFilter, carg1 *C.GstGLMemory, carg2 *C.GstGLMemory) (cret C.gboolean) { + var filter Instance // go GstGLFilter subclass + var input *GLMemory // in, none, converted + var output *GLMemory // in, none, converted + var goret bool // return + + filter = UnsafeGLFilterFromGlibNone(unsafe.Pointer(carg0)).(Instance) + input = UnsafeGLMemoryFromGlibNone(unsafe.Pointer(carg1)) + output = UnsafeGLMemoryFromGlibNone(unsafe.Pointer(carg2)) + + goret = overrides.FilterTexture(filter, input, output) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.InitFbo != nil { pclass.init_fbo = (*[0]byte)(C._gotk4_gstgl1_GLFilter_init_fbo) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstgl1_GLFilter_init_fbo", + func(carg0 *C.GstGLFilter) (cret C.gboolean) { + var filter Instance // go GstGLFilter subclass + var goret bool // return + + filter = UnsafeGLFilterFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + goret = overrides.InitFbo(filter) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.SetCaps != nil { pclass.set_caps = (*[0]byte)(C._gotk4_gstgl1_GLFilter_set_caps) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstgl1_GLFilter_set_caps", + func(carg0 *C.GstGLFilter, carg1 *C.GstCaps, carg2 *C.GstCaps) (cret C.gboolean) { + var filter Instance // go GstGLFilter subclass + var incaps *gst.Caps // in, none, converted + var outcaps *gst.Caps // in, none, converted + var goret bool // return + + filter = UnsafeGLFilterFromGlibNone(unsafe.Pointer(carg0)).(Instance) + incaps = gst.UnsafeCapsFromGlibNone(unsafe.Pointer(carg1)) + outcaps = gst.UnsafeCapsFromGlibNone(unsafe.Pointer(carg2)) + + goret = overrides.SetCaps(filter, incaps, outcaps) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.TransformInternalCaps != nil { pclass.transform_internal_caps = (*[0]byte)(C._gotk4_gstgl1_GLFilter_transform_internal_caps) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstgl1_GLFilter_transform_internal_caps", + func(carg0 *C.GstGLFilter, carg1 C.GstPadDirection, carg2 *C.GstCaps, carg3 *C.GstCaps) (cret *C.GstCaps) { + var filter Instance // go GstGLFilter subclass + var direction gst.PadDirection // in, none, casted + var caps *gst.Caps // in, none, converted + var filterCaps *gst.Caps // in, none, converted + var goret *gst.Caps // return, full, converted + + filter = UnsafeGLFilterFromGlibNone(unsafe.Pointer(carg0)).(Instance) + direction = gst.PadDirection(carg1) + caps = gst.UnsafeCapsFromGlibNone(unsafe.Pointer(carg2)) + filterCaps = gst.UnsafeCapsFromGlibNone(unsafe.Pointer(carg3)) + + goret = overrides.TransformInternalCaps(filter, direction, caps, filterCaps) + + cret = (*C.GstCaps)(gst.UnsafeCapsToGlibFull(goret)) + + return cret + }, + ) } } +// RegisterGLFilterSubClass is used to register a go subclass of GstGLFilter. For this to work safely please implement the +// virtual methods required by the implementation. +func RegisterGLFilterSubClass[InstanceT GLFilter]( + name string, + classInit func(class *GLFilterClass), + constructor func() InstanceT, + overrides GLFilterOverrides[InstanceT], + signals map[string]gobject.SignalDefinition, + interfaceInits ...gobject.SubClassInterfaceInit[InstanceT], +) gobject.Type { + return gobject.UnsafeRegisterSubClass( + name, + classInit, + constructor, + overrides, + signals, + TypeGLFilter, + UnsafeGLFilterClassFromGlibBorrow, + UnsafeApplyGLFilterOverrides, + func (obj *gobject.ObjectInstance) gobject.Object { + return unsafeWrapGLFilter(obj) + }, + interfaceInits..., + ) +} + // GLFramebufferInstance is the instance type used by all types extending GstGLFramebuffer. It is used internally by the bindings. Users should use the interface [GLFramebuffer] instead. type GLFramebufferInstance struct { _ [0]func() // equal guard @@ -6373,6 +7109,32 @@ func UnsafeApplyGLFramebufferOverrides[Instance GLFramebuffer](gclass unsafe.Poi gst.UnsafeApplyObjectOverrides(gclass, overrides.ObjectOverrides) } +// RegisterGLFramebufferSubClass is used to register a go subclass of GstGLFramebuffer. For this to work safely please implement the +// virtual methods required by the implementation. +func RegisterGLFramebufferSubClass[InstanceT GLFramebuffer]( + name string, + classInit func(class *GLFramebufferClass), + constructor func() InstanceT, + overrides GLFramebufferOverrides[InstanceT], + signals map[string]gobject.SignalDefinition, + interfaceInits ...gobject.SubClassInterfaceInit[InstanceT], +) gobject.Type { + return gobject.UnsafeRegisterSubClass( + name, + classInit, + constructor, + overrides, + signals, + TypeGLFramebuffer, + UnsafeGLFramebufferClassFromGlibBorrow, + UnsafeApplyGLFramebufferOverrides, + func (obj *gobject.ObjectInstance) gobject.Object { + return unsafeWrapGLFramebuffer(obj) + }, + interfaceInits..., + ) +} + // GLMemoryAllocatorInstance is the instance type used by all types extending GstGLMemoryAllocator. It is used internally by the bindings. Users should use the interface [GLMemoryAllocator] instead. type GLMemoryAllocatorInstance struct { _ [0]func() // equal guard @@ -6470,6 +7232,32 @@ func UnsafeApplyGLMemoryAllocatorOverrides[Instance GLMemoryAllocator](gclass un UnsafeApplyGLBaseMemoryAllocatorOverrides(gclass, overrides.GLBaseMemoryAllocatorOverrides) } +// RegisterGLMemoryAllocatorSubClass is used to register a go subclass of GstGLMemoryAllocator. For this to work safely please implement the +// virtual methods required by the implementation. +func RegisterGLMemoryAllocatorSubClass[InstanceT GLMemoryAllocator]( + name string, + classInit func(class *GLMemoryAllocatorClass), + constructor func() InstanceT, + overrides GLMemoryAllocatorOverrides[InstanceT], + signals map[string]gobject.SignalDefinition, + interfaceInits ...gobject.SubClassInterfaceInit[InstanceT], +) gobject.Type { + return gobject.UnsafeRegisterSubClass( + name, + classInit, + constructor, + overrides, + signals, + TypeGLMemoryAllocator, + UnsafeGLMemoryAllocatorClassFromGlibBorrow, + UnsafeApplyGLMemoryAllocatorOverrides, + func (obj *gobject.ObjectInstance) gobject.Object { + return unsafeWrapGLMemoryAllocator(obj) + }, + interfaceInits..., + ) +} + // GLMemoryPBOAllocatorInstance is the instance type used by all types extending GstGLMemoryPBOAllocator. It is used internally by the bindings. Users should use the interface [GLMemoryPBOAllocator] instead. type GLMemoryPBOAllocatorInstance struct { _ [0]func() // equal guard @@ -6544,6 +7332,32 @@ func UnsafeApplyGLMemoryPBOAllocatorOverrides[Instance GLMemoryPBOAllocator](gcl UnsafeApplyGLMemoryAllocatorOverrides(gclass, overrides.GLMemoryAllocatorOverrides) } +// RegisterGLMemoryPBOAllocatorSubClass is used to register a go subclass of GstGLMemoryPBOAllocator. For this to work safely please implement the +// virtual methods required by the implementation. +func RegisterGLMemoryPBOAllocatorSubClass[InstanceT GLMemoryPBOAllocator]( + name string, + classInit func(class *GLMemoryPBOAllocatorClass), + constructor func() InstanceT, + overrides GLMemoryPBOAllocatorOverrides[InstanceT], + signals map[string]gobject.SignalDefinition, + interfaceInits ...gobject.SubClassInterfaceInit[InstanceT], +) gobject.Type { + return gobject.UnsafeRegisterSubClass( + name, + classInit, + constructor, + overrides, + signals, + TypeGLMemoryPBOAllocator, + UnsafeGLMemoryPBOAllocatorClassFromGlibBorrow, + UnsafeApplyGLMemoryPBOAllocatorOverrides, + func (obj *gobject.ObjectInstance) gobject.Object { + return unsafeWrapGLMemoryPBOAllocator(obj) + }, + interfaceInits..., + ) +} + // GLMixerInstance is the instance type used by all types extending GstGLMixer. It is used internally by the bindings. Users should use the interface [GLMixer] instead. type GLMixerInstance struct { _ [0]func() // equal guard @@ -6717,13 +7531,79 @@ func UnsafeApplyGLMixerOverrides[Instance GLMixer](gclass unsafe.Pointer, overri if overrides.ProcessBuffers != nil { pclass.process_buffers = (*[0]byte)(C._gotk4_gstgl1_GLMixer_process_buffers) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstgl1_GLMixer_process_buffers", + func(carg0 *C.GstGLMixer, carg1 *C.GstBuffer) (cret C.gboolean) { + var mix Instance // go GstGLMixer subclass + var outbuf *gst.Buffer // in, none, converted + var goret bool // return + + mix = UnsafeGLMixerFromGlibNone(unsafe.Pointer(carg0)).(Instance) + outbuf = gst.UnsafeBufferFromGlibNone(unsafe.Pointer(carg1)) + + goret = overrides.ProcessBuffers(mix, outbuf) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.ProcessTextures != nil { pclass.process_textures = (*[0]byte)(C._gotk4_gstgl1_GLMixer_process_textures) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstgl1_GLMixer_process_textures", + func(carg0 *C.GstGLMixer, carg1 *C.GstGLMemory) (cret C.gboolean) { + var mix Instance // go GstGLMixer subclass + var outTex *GLMemory // in, none, converted + var goret bool // return + + mix = UnsafeGLMixerFromGlibNone(unsafe.Pointer(carg0)).(Instance) + outTex = UnsafeGLMemoryFromGlibNone(unsafe.Pointer(carg1)) + + goret = overrides.ProcessTextures(mix, outTex) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } } +// RegisterGLMixerSubClass is used to register a go subclass of GstGLMixer. For this to work safely please implement the +// virtual methods required by the implementation. +func RegisterGLMixerSubClass[InstanceT GLMixer]( + name string, + classInit func(class *GLMixerClass), + constructor func() InstanceT, + overrides GLMixerOverrides[InstanceT], + signals map[string]gobject.SignalDefinition, + interfaceInits ...gobject.SubClassInterfaceInit[InstanceT], +) gobject.Type { + return gobject.UnsafeRegisterSubClass( + name, + classInit, + constructor, + overrides, + signals, + TypeGLMixer, + UnsafeGLMixerClassFromGlibBorrow, + UnsafeApplyGLMixerOverrides, + func (obj *gobject.ObjectInstance) gobject.Object { + return unsafeWrapGLMixer(obj) + }, + interfaceInits..., + ) +} + // GLMixerPadInstance is the instance type used by all types extending GstGLMixerPad. It is used internally by the bindings. Users should use the interface [GLMixerPad] instead. type GLMixerPadInstance struct { _ [0]func() // equal guard @@ -6798,6 +7678,32 @@ func UnsafeApplyGLMixerPadOverrides[Instance GLMixerPad](gclass unsafe.Pointer, UnsafeApplyGLBaseMixerPadOverrides(gclass, overrides.GLBaseMixerPadOverrides) } +// RegisterGLMixerPadSubClass is used to register a go subclass of GstGLMixerPad. For this to work safely please implement the +// virtual methods required by the implementation. +func RegisterGLMixerPadSubClass[InstanceT GLMixerPad]( + name string, + classInit func(class *GLMixerPadClass), + constructor func() InstanceT, + overrides GLMixerPadOverrides[InstanceT], + signals map[string]gobject.SignalDefinition, + interfaceInits ...gobject.SubClassInterfaceInit[InstanceT], +) gobject.Type { + return gobject.UnsafeRegisterSubClass( + name, + classInit, + constructor, + overrides, + signals, + TypeGLMixerPad, + UnsafeGLMixerPadClassFromGlibBorrow, + UnsafeApplyGLMixerPadOverrides, + func (obj *gobject.ObjectInstance) gobject.Object { + return unsafeWrapGLMixerPad(obj) + }, + interfaceInits..., + ) +} + // GLOverlayCompositorInstance is the instance type used by all types extending GstGLOverlayCompositor. It is used internally by the bindings. Users should use the interface [GLOverlayCompositor] instead. type GLOverlayCompositorInstance struct { _ [0]func() // equal guard @@ -6964,6 +7870,32 @@ func UnsafeApplyGLOverlayCompositorOverrides[Instance GLOverlayCompositor](gclas gst.UnsafeApplyObjectOverrides(gclass, overrides.ObjectOverrides) } +// RegisterGLOverlayCompositorSubClass is used to register a go subclass of GstGLOverlayCompositor. For this to work safely please implement the +// virtual methods required by the implementation. +func RegisterGLOverlayCompositorSubClass[InstanceT GLOverlayCompositor]( + name string, + classInit func(class *GLOverlayCompositorClass), + constructor func() InstanceT, + overrides GLOverlayCompositorOverrides[InstanceT], + signals map[string]gobject.SignalDefinition, + interfaceInits ...gobject.SubClassInterfaceInit[InstanceT], +) gobject.Type { + return gobject.UnsafeRegisterSubClass( + name, + classInit, + constructor, + overrides, + signals, + TypeGLOverlayCompositor, + UnsafeGLOverlayCompositorClassFromGlibBorrow, + UnsafeApplyGLOverlayCompositorOverrides, + func (obj *gobject.ObjectInstance) gobject.Object { + return unsafeWrapGLOverlayCompositor(obj) + }, + interfaceInits..., + ) +} + // GLRenderbufferAllocatorInstance is the instance type used by all types extending GstGLRenderbufferAllocator. It is used internally by the bindings. Users should use the interface [GLRenderbufferAllocator] instead. type GLRenderbufferAllocatorInstance struct { _ [0]func() // equal guard @@ -7036,6 +7968,32 @@ func UnsafeApplyGLRenderbufferAllocatorOverrides[Instance GLRenderbufferAllocato UnsafeApplyGLBaseMemoryAllocatorOverrides(gclass, overrides.GLBaseMemoryAllocatorOverrides) } +// RegisterGLRenderbufferAllocatorSubClass is used to register a go subclass of GstGLRenderbufferAllocator. For this to work safely please implement the +// virtual methods required by the implementation. +func RegisterGLRenderbufferAllocatorSubClass[InstanceT GLRenderbufferAllocator]( + name string, + classInit func(class *GLRenderbufferAllocatorClass), + constructor func() InstanceT, + overrides GLRenderbufferAllocatorOverrides[InstanceT], + signals map[string]gobject.SignalDefinition, + interfaceInits ...gobject.SubClassInterfaceInit[InstanceT], +) gobject.Type { + return gobject.UnsafeRegisterSubClass( + name, + classInit, + constructor, + overrides, + signals, + TypeGLRenderbufferAllocator, + UnsafeGLRenderbufferAllocatorClassFromGlibBorrow, + UnsafeApplyGLRenderbufferAllocatorOverrides, + func (obj *gobject.ObjectInstance) gobject.Object { + return unsafeWrapGLRenderbufferAllocator(obj) + }, + interfaceInits..., + ) +} + // GLSLStageInstance is the instance type used by all types extending GstGLSLStage. It is used internally by the bindings. Users should use the interface [GLSLStage] instead. type GLSLStageInstance struct { _ [0]func() // equal guard @@ -7474,6 +8432,32 @@ func UnsafeApplyGLSLStageOverrides[Instance GLSLStage](gclass unsafe.Pointer, ov gst.UnsafeApplyObjectOverrides(gclass, overrides.ObjectOverrides) } +// RegisterGLSLStageSubClass is used to register a go subclass of GstGLSLStage. For this to work safely please implement the +// virtual methods required by the implementation. +func RegisterGLSLStageSubClass[InstanceT GLSLStage]( + name string, + classInit func(class *GLSLStageClass), + constructor func() InstanceT, + overrides GLSLStageOverrides[InstanceT], + signals map[string]gobject.SignalDefinition, + interfaceInits ...gobject.SubClassInterfaceInit[InstanceT], +) gobject.Type { + return gobject.UnsafeRegisterSubClass( + name, + classInit, + constructor, + overrides, + signals, + TypeGLSLStage, + UnsafeGLSLStageClassFromGlibBorrow, + UnsafeApplyGLSLStageOverrides, + func (obj *gobject.ObjectInstance) gobject.Object { + return unsafeWrapGLSLStage(obj) + }, + interfaceInits..., + ) +} + // GLShaderInstance is the instance type used by all types extending GstGLShader. It is used internally by the bindings. Users should use the interface [GLShader] instead. type GLShaderInstance struct { _ [0]func() // equal guard @@ -9247,6 +10231,32 @@ func UnsafeApplyGLShaderOverrides[Instance GLShader](gclass unsafe.Pointer, over gst.UnsafeApplyObjectOverrides(gclass, overrides.ObjectOverrides) } +// RegisterGLShaderSubClass is used to register a go subclass of GstGLShader. For this to work safely please implement the +// virtual methods required by the implementation. +func RegisterGLShaderSubClass[InstanceT GLShader]( + name string, + classInit func(class *GLShaderClass), + constructor func() InstanceT, + overrides GLShaderOverrides[InstanceT], + signals map[string]gobject.SignalDefinition, + interfaceInits ...gobject.SubClassInterfaceInit[InstanceT], +) gobject.Type { + return gobject.UnsafeRegisterSubClass( + name, + classInit, + constructor, + overrides, + signals, + TypeGLShader, + UnsafeGLShaderClassFromGlibBorrow, + UnsafeApplyGLShaderOverrides, + func (obj *gobject.ObjectInstance) gobject.Object { + return unsafeWrapGLShader(obj) + }, + interfaceInits..., + ) +} + // GLUploadInstance is the instance type used by all types extending GstGLUpload. It is used internally by the bindings. Users should use the interface [GLUpload] instead. type GLUploadInstance struct { _ [0]func() // equal guard @@ -9652,6 +10662,32 @@ func UnsafeApplyGLUploadOverrides[Instance GLUpload](gclass unsafe.Pointer, over gst.UnsafeApplyObjectOverrides(gclass, overrides.ObjectOverrides) } +// RegisterGLUploadSubClass is used to register a go subclass of GstGLUpload. For this to work safely please implement the +// virtual methods required by the implementation. +func RegisterGLUploadSubClass[InstanceT GLUpload]( + name string, + classInit func(class *GLUploadClass), + constructor func() InstanceT, + overrides GLUploadOverrides[InstanceT], + signals map[string]gobject.SignalDefinition, + interfaceInits ...gobject.SubClassInterfaceInit[InstanceT], +) gobject.Type { + return gobject.UnsafeRegisterSubClass( + name, + classInit, + constructor, + overrides, + signals, + TypeGLUpload, + UnsafeGLUploadClassFromGlibBorrow, + UnsafeApplyGLUploadOverrides, + func (obj *gobject.ObjectInstance) gobject.Object { + return unsafeWrapGLUpload(obj) + }, + interfaceInits..., + ) +} + // GLViewConvertInstance is the instance type used by all types extending GstGLViewConvert. It is used internally by the bindings. Users should use the interface [GLViewConvert] instead. type GLViewConvertInstance struct { _ [0]func() // equal guard @@ -10067,6 +11103,32 @@ func UnsafeApplyGLViewConvertOverrides[Instance GLViewConvert](gclass unsafe.Poi gst.UnsafeApplyObjectOverrides(gclass, overrides.ObjectOverrides) } +// RegisterGLViewConvertSubClass is used to register a go subclass of GstGLViewConvert. For this to work safely please implement the +// virtual methods required by the implementation. +func RegisterGLViewConvertSubClass[InstanceT GLViewConvert]( + name string, + classInit func(class *GLViewConvertClass), + constructor func() InstanceT, + overrides GLViewConvertOverrides[InstanceT], + signals map[string]gobject.SignalDefinition, + interfaceInits ...gobject.SubClassInterfaceInit[InstanceT], +) gobject.Type { + return gobject.UnsafeRegisterSubClass( + name, + classInit, + constructor, + overrides, + signals, + TypeGLViewConvert, + UnsafeGLViewConvertClassFromGlibBorrow, + UnsafeApplyGLViewConvertOverrides, + func (obj *gobject.ObjectInstance) gobject.Object { + return unsafeWrapGLViewConvert(obj) + }, + interfaceInits..., + ) +} + // GLWindowInstance is the instance type used by all types extending GstGLWindow. It is used internally by the bindings. Users should use the interface [GLWindow] instead. type GLWindowInstance struct { _ [0]func() // equal guard @@ -10748,53 +11810,257 @@ func UnsafeApplyGLWindowOverrides[Instance GLWindow](gclass unsafe.Pointer, over if overrides.Close != nil { pclass.close = (*[0]byte)(C._gotk4_gstgl1_GLWindow_close) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstgl1_GLWindow_close", + func(carg0 *C.GstGLWindow) { + var window Instance // go GstGLWindow subclass + + window = UnsafeGLWindowFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + overrides.Close(window) + }, + ) } if overrides.ControlsViewport != nil { pclass.controls_viewport = (*[0]byte)(C._gotk4_gstgl1_GLWindow_controls_viewport) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstgl1_GLWindow_controls_viewport", + func(carg0 *C.GstGLWindow) (cret C.gboolean) { + var window Instance // go GstGLWindow subclass + var goret bool // return + + window = UnsafeGLWindowFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + goret = overrides.ControlsViewport(window) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.Draw != nil { pclass.draw = (*[0]byte)(C._gotk4_gstgl1_GLWindow_draw) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstgl1_GLWindow_draw", + func(carg0 *C.GstGLWindow) { + var window Instance // go GstGLWindow subclass + + window = UnsafeGLWindowFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + overrides.Draw(window) + }, + ) } if overrides.HandleEvents != nil { pclass.handle_events = (*[0]byte)(C._gotk4_gstgl1_GLWindow_handle_events) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstgl1_GLWindow_handle_events", + func(carg0 *C.GstGLWindow, carg1 C.gboolean) { + var window Instance // go GstGLWindow subclass + var handleEvents bool // in + + window = UnsafeGLWindowFromGlibNone(unsafe.Pointer(carg0)).(Instance) + if carg1 != 0 { + handleEvents = true + } + + overrides.HandleEvents(window, handleEvents) + }, + ) } if overrides.HasOutputSurface != nil { pclass.has_output_surface = (*[0]byte)(C._gotk4_gstgl1_GLWindow_has_output_surface) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstgl1_GLWindow_has_output_surface", + func(carg0 *C.GstGLWindow) (cret C.gboolean) { + var window Instance // go GstGLWindow subclass + var goret bool // return + + window = UnsafeGLWindowFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + goret = overrides.HasOutputSurface(window) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.Open != nil { pclass.open = (*[0]byte)(C._gotk4_gstgl1_GLWindow_open) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstgl1_GLWindow_open", + func(carg0 *C.GstGLWindow, _cerr **C.GError) (cret C.gboolean) { + var window Instance // go GstGLWindow subclass + var goret bool // return + var _goerr error // out, full, converted + + window = UnsafeGLWindowFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + goret, _goerr = overrides.Open(window) + + if goret { + cret = C.TRUE + } + *_cerr = (*C.GError)(glib.UnsafeErrorToGlibFull(_goerr)) + + return cret + }, + ) } if overrides.QueueResize != nil { pclass.queue_resize = (*[0]byte)(C._gotk4_gstgl1_GLWindow_queue_resize) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstgl1_GLWindow_queue_resize", + func(carg0 *C.GstGLWindow) { + var window Instance // go GstGLWindow subclass + + window = UnsafeGLWindowFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + overrides.QueueResize(window) + }, + ) } if overrides.Quit != nil { pclass.quit = (*[0]byte)(C._gotk4_gstgl1_GLWindow_quit) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstgl1_GLWindow_quit", + func(carg0 *C.GstGLWindow) { + var window Instance // go GstGLWindow subclass + + window = UnsafeGLWindowFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + overrides.Quit(window) + }, + ) } if overrides.Run != nil { pclass.run = (*[0]byte)(C._gotk4_gstgl1_GLWindow_run) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstgl1_GLWindow_run", + func(carg0 *C.GstGLWindow) { + var window Instance // go GstGLWindow subclass + + window = UnsafeGLWindowFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + overrides.Run(window) + }, + ) } if overrides.SetPreferredSize != nil { pclass.set_preferred_size = (*[0]byte)(C._gotk4_gstgl1_GLWindow_set_preferred_size) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstgl1_GLWindow_set_preferred_size", + func(carg0 *C.GstGLWindow, carg1 C.gint, carg2 C.gint) { + var window Instance // go GstGLWindow subclass + var width int // in, none, casted + var height int // in, none, casted + + window = UnsafeGLWindowFromGlibNone(unsafe.Pointer(carg0)).(Instance) + width = int(carg1) + height = int(carg2) + + overrides.SetPreferredSize(window, width, height) + }, + ) } if overrides.SetRenderRectangle != nil { pclass.set_render_rectangle = (*[0]byte)(C._gotk4_gstgl1_GLWindow_set_render_rectangle) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstgl1_GLWindow_set_render_rectangle", + func(carg0 *C.GstGLWindow, carg1 C.gint, carg2 C.gint, carg3 C.gint, carg4 C.gint) (cret C.gboolean) { + var window Instance // go GstGLWindow subclass + var x int // in, none, casted + var y int // in, none, casted + var width int // in, none, casted + var height int // in, none, casted + var goret bool // return + + window = UnsafeGLWindowFromGlibNone(unsafe.Pointer(carg0)).(Instance) + x = int(carg1) + y = int(carg2) + width = int(carg3) + height = int(carg4) + + goret = overrides.SetRenderRectangle(window, x, y, width, height) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.Show != nil { pclass.show = (*[0]byte)(C._gotk4_gstgl1_GLWindow_show) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstgl1_GLWindow_show", + func(carg0 *C.GstGLWindow) { + var window Instance // go GstGLWindow subclass + + window = UnsafeGLWindowFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + overrides.Show(window) + }, + ) } } +// RegisterGLWindowSubClass is used to register a go subclass of GstGLWindow. For this to work safely please implement the +// virtual methods required by the implementation. +func RegisterGLWindowSubClass[InstanceT GLWindow]( + name string, + classInit func(class *GLWindowClass), + constructor func() InstanceT, + overrides GLWindowOverrides[InstanceT], + signals map[string]gobject.SignalDefinition, + interfaceInits ...gobject.SubClassInterfaceInit[InstanceT], +) gobject.Type { + return gobject.UnsafeRegisterSubClass( + name, + classInit, + constructor, + overrides, + signals, + TypeGLWindow, + UnsafeGLWindowClassFromGlibBorrow, + UnsafeApplyGLWindowOverrides, + func (obj *gobject.ObjectInstance) gobject.Object { + return unsafeWrapGLWindow(obj) + }, + interfaceInits..., + ) +} + // GLAllocationParams wraps GstGLAllocationParams type GLAllocationParams struct { *glAllocationParams diff --git a/pkg/gstgl/gstgl_export.gen.go b/pkg/gstgl/gstgl_export.gen.go index 3183518..278e6af 100644 --- a/pkg/gstgl/gstgl_export.gen.go +++ b/pkg/gstgl/gstgl_export.gen.go @@ -5,6 +5,7 @@ package gstgl import ( "unsafe" + "github.com/diamondburned/gotk4/pkg/core/classdata" "github.com/diamondburned/gotk4/pkg/core/userdata" ) @@ -60,196 +61,469 @@ func _gotk4_gstgl1_GLFilterRenderFunc(carg1 *C.GstGLFilter, carg2 *C.GstGLMemory //export _gotk4_gstgl1_GLBaseFilter_gl_set_caps func _gotk4_gstgl1_GLBaseFilter_gl_set_caps(carg0 *C.GstGLBaseFilter, carg1 *C.GstCaps, carg2 *C.GstCaps) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstGLBaseFilter, carg1 *C.GstCaps, carg2 *C.GstCaps) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstgl1_GLBaseFilter_gl_set_caps").(func(carg0 *C.GstGLBaseFilter, carg1 *C.GstCaps, carg2 *C.GstCaps) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstgl1_GLBaseFilter_gl_set_caps: no function pointer found") + } + } + return fn(carg0, carg1, carg2) } //export _gotk4_gstgl1_GLBaseFilter_gl_start func _gotk4_gstgl1_GLBaseFilter_gl_start(carg0 *C.GstGLBaseFilter) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstGLBaseFilter) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstgl1_GLBaseFilter_gl_start").(func(carg0 *C.GstGLBaseFilter) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstgl1_GLBaseFilter_gl_start: no function pointer found") + } + } + return fn(carg0) } //export _gotk4_gstgl1_GLBaseFilter_gl_stop func _gotk4_gstgl1_GLBaseFilter_gl_stop(carg0 *C.GstGLBaseFilter) { - panic("unimplemented") + var fn func(carg0 *C.GstGLBaseFilter) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstgl1_GLBaseFilter_gl_stop").(func(carg0 *C.GstGLBaseFilter)) + if fn == nil { + panic("_gotk4_gstgl1_GLBaseFilter_gl_stop: no function pointer found") + } + } + fn(carg0) } //export _gotk4_gstgl1_GLBaseMixer_gl_start func _gotk4_gstgl1_GLBaseMixer_gl_start(carg0 *C.GstGLBaseMixer) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstGLBaseMixer) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstgl1_GLBaseMixer_gl_start").(func(carg0 *C.GstGLBaseMixer) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstgl1_GLBaseMixer_gl_start: no function pointer found") + } + } + return fn(carg0) } //export _gotk4_gstgl1_GLBaseMixer_gl_stop func _gotk4_gstgl1_GLBaseMixer_gl_stop(carg0 *C.GstGLBaseMixer) { - panic("unimplemented") + var fn func(carg0 *C.GstGLBaseMixer) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstgl1_GLBaseMixer_gl_stop").(func(carg0 *C.GstGLBaseMixer)) + if fn == nil { + panic("_gotk4_gstgl1_GLBaseMixer_gl_stop: no function pointer found") + } + } + fn(carg0) } //export _gotk4_gstgl1_GLBaseSrc_fill_gl_memory func _gotk4_gstgl1_GLBaseSrc_fill_gl_memory(carg0 *C.GstGLBaseSrc, carg1 *C.GstGLMemory) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstGLBaseSrc, carg1 *C.GstGLMemory) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstgl1_GLBaseSrc_fill_gl_memory").(func(carg0 *C.GstGLBaseSrc, carg1 *C.GstGLMemory) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstgl1_GLBaseSrc_fill_gl_memory: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstgl1_GLBaseSrc_gl_start func _gotk4_gstgl1_GLBaseSrc_gl_start(carg0 *C.GstGLBaseSrc) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstGLBaseSrc) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstgl1_GLBaseSrc_gl_start").(func(carg0 *C.GstGLBaseSrc) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstgl1_GLBaseSrc_gl_start: no function pointer found") + } + } + return fn(carg0) } //export _gotk4_gstgl1_GLBaseSrc_gl_stop func _gotk4_gstgl1_GLBaseSrc_gl_stop(carg0 *C.GstGLBaseSrc) { - panic("unimplemented") + var fn func(carg0 *C.GstGLBaseSrc) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstgl1_GLBaseSrc_gl_stop").(func(carg0 *C.GstGLBaseSrc)) + if fn == nil { + panic("_gotk4_gstgl1_GLBaseSrc_gl_stop: no function pointer found") + } + } + fn(carg0) } //export _gotk4_gstgl1_GLContext_activate func _gotk4_gstgl1_GLContext_activate(carg0 *C.GstGLContext, carg1 C.gboolean) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstGLContext, carg1 C.gboolean) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstgl1_GLContext_activate").(func(carg0 *C.GstGLContext, carg1 C.gboolean) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstgl1_GLContext_activate: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstgl1_GLContext_check_feature func _gotk4_gstgl1_GLContext_check_feature(carg0 *C.GstGLContext, carg1 *C.gchar) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstGLContext, carg1 *C.gchar) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstgl1_GLContext_check_feature").(func(carg0 *C.GstGLContext, carg1 *C.gchar) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstgl1_GLContext_check_feature: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstgl1_GLContext_choose_format func _gotk4_gstgl1_GLContext_choose_format(carg0 *C.GstGLContext, _cerr **C.GError) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstGLContext, _cerr **C.GError) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstgl1_GLContext_choose_format").(func(carg0 *C.GstGLContext, _cerr **C.GError) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstgl1_GLContext_choose_format: no function pointer found") + } + } + return fn(carg0, _cerr) } //export _gotk4_gstgl1_GLContext_create_context func _gotk4_gstgl1_GLContext_create_context(carg0 *C.GstGLContext, carg1 C.GstGLAPI, carg2 *C.GstGLContext, _cerr **C.GError) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstGLContext, carg1 C.GstGLAPI, carg2 *C.GstGLContext, _cerr **C.GError) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstgl1_GLContext_create_context").(func(carg0 *C.GstGLContext, carg1 C.GstGLAPI, carg2 *C.GstGLContext, _cerr **C.GError) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstgl1_GLContext_create_context: no function pointer found") + } + } + return fn(carg0, carg1, carg2, _cerr) } //export _gotk4_gstgl1_GLContext_destroy_context func _gotk4_gstgl1_GLContext_destroy_context(carg0 *C.GstGLContext) { - panic("unimplemented") + var fn func(carg0 *C.GstGLContext) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstgl1_GLContext_destroy_context").(func(carg0 *C.GstGLContext)) + if fn == nil { + panic("_gotk4_gstgl1_GLContext_destroy_context: no function pointer found") + } + } + fn(carg0) } //export _gotk4_gstgl1_GLContext_get_config func _gotk4_gstgl1_GLContext_get_config(carg0 *C.GstGLContext) (cret *C.GstStructure) { - panic("unimplemented") + var fn func(carg0 *C.GstGLContext) (cret *C.GstStructure) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstgl1_GLContext_get_config").(func(carg0 *C.GstGLContext) (cret *C.GstStructure)) + if fn == nil { + panic("_gotk4_gstgl1_GLContext_get_config: no function pointer found") + } + } + return fn(carg0) } //export _gotk4_gstgl1_GLContext_get_gl_api func _gotk4_gstgl1_GLContext_get_gl_api(carg0 *C.GstGLContext) (cret C.GstGLAPI) { - panic("unimplemented") + var fn func(carg0 *C.GstGLContext) (cret C.GstGLAPI) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstgl1_GLContext_get_gl_api").(func(carg0 *C.GstGLContext) (cret C.GstGLAPI)) + if fn == nil { + panic("_gotk4_gstgl1_GLContext_get_gl_api: no function pointer found") + } + } + return fn(carg0) } //export _gotk4_gstgl1_GLContext_get_gl_platform func _gotk4_gstgl1_GLContext_get_gl_platform(carg0 *C.GstGLContext) (cret C.GstGLPlatform) { - panic("unimplemented") + var fn func(carg0 *C.GstGLContext) (cret C.GstGLPlatform) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstgl1_GLContext_get_gl_platform").(func(carg0 *C.GstGLContext) (cret C.GstGLPlatform)) + if fn == nil { + panic("_gotk4_gstgl1_GLContext_get_gl_platform: no function pointer found") + } + } + return fn(carg0) } //export _gotk4_gstgl1_GLContext_get_gl_platform_version func _gotk4_gstgl1_GLContext_get_gl_platform_version(carg0 *C.GstGLContext, carg1 *C.gint, carg2 *C.gint) { - panic("unimplemented") + var fn func(carg0 *C.GstGLContext, carg1 *C.gint, carg2 *C.gint) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstgl1_GLContext_get_gl_platform_version").(func(carg0 *C.GstGLContext, carg1 *C.gint, carg2 *C.gint)) + if fn == nil { + panic("_gotk4_gstgl1_GLContext_get_gl_platform_version: no function pointer found") + } + } + fn(carg0, carg1, carg2) } //export _gotk4_gstgl1_GLContext_request_config func _gotk4_gstgl1_GLContext_request_config(carg0 *C.GstGLContext, carg1 *C.GstStructure) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstGLContext, carg1 *C.GstStructure) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstgl1_GLContext_request_config").(func(carg0 *C.GstGLContext, carg1 *C.GstStructure) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstgl1_GLContext_request_config: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstgl1_GLContext_swap_buffers func _gotk4_gstgl1_GLContext_swap_buffers(carg0 *C.GstGLContext) { - panic("unimplemented") + var fn func(carg0 *C.GstGLContext) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstgl1_GLContext_swap_buffers").(func(carg0 *C.GstGLContext)) + if fn == nil { + panic("_gotk4_gstgl1_GLContext_swap_buffers: no function pointer found") + } + } + fn(carg0) } //export _gotk4_gstgl1_GLDisplay_create_window func _gotk4_gstgl1_GLDisplay_create_window(carg0 *C.GstGLDisplay) (cret *C.GstGLWindow) { - panic("unimplemented") + var fn func(carg0 *C.GstGLDisplay) (cret *C.GstGLWindow) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstgl1_GLDisplay_create_window").(func(carg0 *C.GstGLDisplay) (cret *C.GstGLWindow)) + if fn == nil { + panic("_gotk4_gstgl1_GLDisplay_create_window: no function pointer found") + } + } + return fn(carg0) } //export _gotk4_gstgl1_GLFilter_filter func _gotk4_gstgl1_GLFilter_filter(carg0 *C.GstGLFilter, carg1 *C.GstBuffer, carg2 *C.GstBuffer) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstGLFilter, carg1 *C.GstBuffer, carg2 *C.GstBuffer) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstgl1_GLFilter_filter").(func(carg0 *C.GstGLFilter, carg1 *C.GstBuffer, carg2 *C.GstBuffer) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstgl1_GLFilter_filter: no function pointer found") + } + } + return fn(carg0, carg1, carg2) } //export _gotk4_gstgl1_GLFilter_filter_texture func _gotk4_gstgl1_GLFilter_filter_texture(carg0 *C.GstGLFilter, carg1 *C.GstGLMemory, carg2 *C.GstGLMemory) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstGLFilter, carg1 *C.GstGLMemory, carg2 *C.GstGLMemory) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstgl1_GLFilter_filter_texture").(func(carg0 *C.GstGLFilter, carg1 *C.GstGLMemory, carg2 *C.GstGLMemory) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstgl1_GLFilter_filter_texture: no function pointer found") + } + } + return fn(carg0, carg1, carg2) } //export _gotk4_gstgl1_GLFilter_init_fbo func _gotk4_gstgl1_GLFilter_init_fbo(carg0 *C.GstGLFilter) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstGLFilter) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstgl1_GLFilter_init_fbo").(func(carg0 *C.GstGLFilter) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstgl1_GLFilter_init_fbo: no function pointer found") + } + } + return fn(carg0) } //export _gotk4_gstgl1_GLFilter_set_caps func _gotk4_gstgl1_GLFilter_set_caps(carg0 *C.GstGLFilter, carg1 *C.GstCaps, carg2 *C.GstCaps) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstGLFilter, carg1 *C.GstCaps, carg2 *C.GstCaps) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstgl1_GLFilter_set_caps").(func(carg0 *C.GstGLFilter, carg1 *C.GstCaps, carg2 *C.GstCaps) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstgl1_GLFilter_set_caps: no function pointer found") + } + } + return fn(carg0, carg1, carg2) } //export _gotk4_gstgl1_GLFilter_transform_internal_caps func _gotk4_gstgl1_GLFilter_transform_internal_caps(carg0 *C.GstGLFilter, carg1 C.GstPadDirection, carg2 *C.GstCaps, carg3 *C.GstCaps) (cret *C.GstCaps) { - panic("unimplemented") + var fn func(carg0 *C.GstGLFilter, carg1 C.GstPadDirection, carg2 *C.GstCaps, carg3 *C.GstCaps) (cret *C.GstCaps) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstgl1_GLFilter_transform_internal_caps").(func(carg0 *C.GstGLFilter, carg1 C.GstPadDirection, carg2 *C.GstCaps, carg3 *C.GstCaps) (cret *C.GstCaps)) + if fn == nil { + panic("_gotk4_gstgl1_GLFilter_transform_internal_caps: no function pointer found") + } + } + return fn(carg0, carg1, carg2, carg3) } //export _gotk4_gstgl1_GLMixer_process_buffers func _gotk4_gstgl1_GLMixer_process_buffers(carg0 *C.GstGLMixer, carg1 *C.GstBuffer) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstGLMixer, carg1 *C.GstBuffer) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstgl1_GLMixer_process_buffers").(func(carg0 *C.GstGLMixer, carg1 *C.GstBuffer) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstgl1_GLMixer_process_buffers: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstgl1_GLMixer_process_textures func _gotk4_gstgl1_GLMixer_process_textures(carg0 *C.GstGLMixer, carg1 *C.GstGLMemory) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstGLMixer, carg1 *C.GstGLMemory) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstgl1_GLMixer_process_textures").(func(carg0 *C.GstGLMixer, carg1 *C.GstGLMemory) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstgl1_GLMixer_process_textures: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstgl1_GLWindow_close func _gotk4_gstgl1_GLWindow_close(carg0 *C.GstGLWindow) { - panic("unimplemented") + var fn func(carg0 *C.GstGLWindow) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstgl1_GLWindow_close").(func(carg0 *C.GstGLWindow)) + if fn == nil { + panic("_gotk4_gstgl1_GLWindow_close: no function pointer found") + } + } + fn(carg0) } //export _gotk4_gstgl1_GLWindow_controls_viewport func _gotk4_gstgl1_GLWindow_controls_viewport(carg0 *C.GstGLWindow) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstGLWindow) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstgl1_GLWindow_controls_viewport").(func(carg0 *C.GstGLWindow) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstgl1_GLWindow_controls_viewport: no function pointer found") + } + } + return fn(carg0) } //export _gotk4_gstgl1_GLWindow_draw func _gotk4_gstgl1_GLWindow_draw(carg0 *C.GstGLWindow) { - panic("unimplemented") + var fn func(carg0 *C.GstGLWindow) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstgl1_GLWindow_draw").(func(carg0 *C.GstGLWindow)) + if fn == nil { + panic("_gotk4_gstgl1_GLWindow_draw: no function pointer found") + } + } + fn(carg0) } //export _gotk4_gstgl1_GLWindow_handle_events func _gotk4_gstgl1_GLWindow_handle_events(carg0 *C.GstGLWindow, carg1 C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstGLWindow, carg1 C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstgl1_GLWindow_handle_events").(func(carg0 *C.GstGLWindow, carg1 C.gboolean)) + if fn == nil { + panic("_gotk4_gstgl1_GLWindow_handle_events: no function pointer found") + } + } + fn(carg0, carg1) } //export _gotk4_gstgl1_GLWindow_has_output_surface func _gotk4_gstgl1_GLWindow_has_output_surface(carg0 *C.GstGLWindow) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstGLWindow) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstgl1_GLWindow_has_output_surface").(func(carg0 *C.GstGLWindow) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstgl1_GLWindow_has_output_surface: no function pointer found") + } + } + return fn(carg0) } //export _gotk4_gstgl1_GLWindow_open func _gotk4_gstgl1_GLWindow_open(carg0 *C.GstGLWindow, _cerr **C.GError) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstGLWindow, _cerr **C.GError) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstgl1_GLWindow_open").(func(carg0 *C.GstGLWindow, _cerr **C.GError) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstgl1_GLWindow_open: no function pointer found") + } + } + return fn(carg0, _cerr) } //export _gotk4_gstgl1_GLWindow_queue_resize func _gotk4_gstgl1_GLWindow_queue_resize(carg0 *C.GstGLWindow) { - panic("unimplemented") + var fn func(carg0 *C.GstGLWindow) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstgl1_GLWindow_queue_resize").(func(carg0 *C.GstGLWindow)) + if fn == nil { + panic("_gotk4_gstgl1_GLWindow_queue_resize: no function pointer found") + } + } + fn(carg0) } //export _gotk4_gstgl1_GLWindow_quit func _gotk4_gstgl1_GLWindow_quit(carg0 *C.GstGLWindow) { - panic("unimplemented") + var fn func(carg0 *C.GstGLWindow) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstgl1_GLWindow_quit").(func(carg0 *C.GstGLWindow)) + if fn == nil { + panic("_gotk4_gstgl1_GLWindow_quit: no function pointer found") + } + } + fn(carg0) } //export _gotk4_gstgl1_GLWindow_run func _gotk4_gstgl1_GLWindow_run(carg0 *C.GstGLWindow) { - panic("unimplemented") + var fn func(carg0 *C.GstGLWindow) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstgl1_GLWindow_run").(func(carg0 *C.GstGLWindow)) + if fn == nil { + panic("_gotk4_gstgl1_GLWindow_run: no function pointer found") + } + } + fn(carg0) } //export _gotk4_gstgl1_GLWindow_set_preferred_size func _gotk4_gstgl1_GLWindow_set_preferred_size(carg0 *C.GstGLWindow, carg1 C.gint, carg2 C.gint) { - panic("unimplemented") + var fn func(carg0 *C.GstGLWindow, carg1 C.gint, carg2 C.gint) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstgl1_GLWindow_set_preferred_size").(func(carg0 *C.GstGLWindow, carg1 C.gint, carg2 C.gint)) + if fn == nil { + panic("_gotk4_gstgl1_GLWindow_set_preferred_size: no function pointer found") + } + } + fn(carg0, carg1, carg2) } //export _gotk4_gstgl1_GLWindow_set_render_rectangle func _gotk4_gstgl1_GLWindow_set_render_rectangle(carg0 *C.GstGLWindow, carg1 C.gint, carg2 C.gint, carg3 C.gint, carg4 C.gint) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstGLWindow, carg1 C.gint, carg2 C.gint, carg3 C.gint, carg4 C.gint) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstgl1_GLWindow_set_render_rectangle").(func(carg0 *C.GstGLWindow, carg1 C.gint, carg2 C.gint, carg3 C.gint, carg4 C.gint) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstgl1_GLWindow_set_render_rectangle: no function pointer found") + } + } + return fn(carg0, carg1, carg2, carg3, carg4) } //export _gotk4_gstgl1_GLWindow_show func _gotk4_gstgl1_GLWindow_show(carg0 *C.GstGLWindow) { - panic("unimplemented") + var fn func(carg0 *C.GstGLWindow) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstgl1_GLWindow_show").(func(carg0 *C.GstGLWindow)) + if fn == nil { + panic("_gotk4_gstgl1_GLWindow_show: no function pointer found") + } + } + fn(carg0) } diff --git a/pkg/gstnet/gstnet.gen.go b/pkg/gstnet/gstnet.gen.go index 9e09807..d30a3cb 100644 --- a/pkg/gstnet/gstnet.gen.go +++ b/pkg/gstnet/gstnet.gen.go @@ -6,6 +6,7 @@ import ( "runtime" "unsafe" + "github.com/diamondburned/gotk4/pkg/core/classdata" "github.com/diamondburned/gotk4/pkg/core/userdata" "github.com/diamondburned/gotk4/pkg/gio/v2" "github.com/diamondburned/gotk4/pkg/glib/v2" @@ -572,6 +573,32 @@ func UnsafeApplyNetClientClockOverrides[Instance NetClientClock](gclass unsafe.P gst.UnsafeApplySystemClockOverrides(gclass, overrides.SystemClockOverrides) } +// RegisterNetClientClockSubClass is used to register a go subclass of GstNetClientClock. For this to work safely please implement the +// virtual methods required by the implementation. +func RegisterNetClientClockSubClass[InstanceT NetClientClock]( + name string, + classInit func(class *NetClientClockClass), + constructor func() InstanceT, + overrides NetClientClockOverrides[InstanceT], + signals map[string]gobject.SignalDefinition, + interfaceInits ...gobject.SubClassInterfaceInit[InstanceT], +) gobject.Type { + return gobject.UnsafeRegisterSubClass( + name, + classInit, + constructor, + overrides, + signals, + TypeNetClientClock, + UnsafeNetClientClockClassFromGlibBorrow, + UnsafeApplyNetClientClockOverrides, + func (obj *gobject.ObjectInstance) gobject.Object { + return unsafeWrapNetClientClock(obj) + }, + interfaceInits..., + ) +} + // NetTimeProviderInstance is the instance type used by all types extending GstNetTimeProvider. It is used internally by the bindings. Users should use the interface [NetTimeProvider] instead. type NetTimeProviderInstance struct { _ [0]func() // equal guard @@ -695,6 +722,32 @@ func UnsafeApplyNetTimeProviderOverrides[Instance NetTimeProvider](gclass unsafe gst.UnsafeApplyObjectOverrides(gclass, overrides.ObjectOverrides) } +// RegisterNetTimeProviderSubClass is used to register a go subclass of GstNetTimeProvider. For this to work safely please implement the +// virtual methods required by the implementation. +func RegisterNetTimeProviderSubClass[InstanceT NetTimeProvider]( + name string, + classInit func(class *NetTimeProviderClass), + constructor func() InstanceT, + overrides NetTimeProviderOverrides[InstanceT], + signals map[string]gobject.SignalDefinition, + interfaceInits ...gobject.SubClassInterfaceInit[InstanceT], +) gobject.Type { + return gobject.UnsafeRegisterSubClass( + name, + classInit, + constructor, + overrides, + signals, + TypeNetTimeProvider, + UnsafeNetTimeProviderClassFromGlibBorrow, + UnsafeApplyNetTimeProviderOverrides, + func (obj *gobject.ObjectInstance) gobject.Object { + return unsafeWrapNetTimeProvider(obj) + }, + interfaceInits..., + ) +} + // NtpClockInstance is the instance type used by all types extending GstNtpClock. It is used internally by the bindings. Users should use the interface [NtpClock] instead. type NtpClockInstance struct { _ [0]func() // equal guard @@ -811,6 +864,32 @@ func UnsafeApplyNtpClockOverrides[Instance NtpClock](gclass unsafe.Pointer, over UnsafeApplyNetClientClockOverrides(gclass, overrides.NetClientClockOverrides) } +// RegisterNtpClockSubClass is used to register a go subclass of GstNtpClock. For this to work safely please implement the +// virtual methods required by the implementation. +func RegisterNtpClockSubClass[InstanceT NtpClock]( + name string, + classInit func(class *NtpClockClass), + constructor func() InstanceT, + overrides NtpClockOverrides[InstanceT], + signals map[string]gobject.SignalDefinition, + interfaceInits ...gobject.SubClassInterfaceInit[InstanceT], +) gobject.Type { + return gobject.UnsafeRegisterSubClass( + name, + classInit, + constructor, + overrides, + signals, + TypeNtpClock, + UnsafeNtpClockClassFromGlibBorrow, + UnsafeApplyNtpClockOverrides, + func (obj *gobject.ObjectInstance) gobject.Object { + return unsafeWrapNtpClock(obj) + }, + interfaceInits..., + ) +} + // PtpClockInstance is the instance type used by all types extending GstPtpClock. It is used internally by the bindings. Users should use the interface [PtpClock] instead. type PtpClockInstance struct { _ [0]func() // equal guard @@ -945,6 +1024,32 @@ func UnsafeApplyPtpClockOverrides[Instance PtpClock](gclass unsafe.Pointer, over gst.UnsafeApplySystemClockOverrides(gclass, overrides.SystemClockOverrides) } +// RegisterPtpClockSubClass is used to register a go subclass of GstPtpClock. For this to work safely please implement the +// virtual methods required by the implementation. +func RegisterPtpClockSubClass[InstanceT PtpClock]( + name string, + classInit func(class *PtpClockClass), + constructor func() InstanceT, + overrides PtpClockOverrides[InstanceT], + signals map[string]gobject.SignalDefinition, + interfaceInits ...gobject.SubClassInterfaceInit[InstanceT], +) gobject.Type { + return gobject.UnsafeRegisterSubClass( + name, + classInit, + constructor, + overrides, + signals, + TypePtpClock, + UnsafePtpClockClassFromGlibBorrow, + UnsafeApplyPtpClockOverrides, + func (obj *gobject.ObjectInstance) gobject.Object { + return unsafeWrapPtpClock(obj) + }, + interfaceInits..., + ) +} + // NetAddressMeta wraps GstNetAddressMeta // // #GstNetAddressMeta can be used to store a network address (a #GSocketAddress) diff --git a/pkg/gstpbutils/gstpbutils.gen.go b/pkg/gstpbutils/gstpbutils.gen.go index 5eec57b..80eb27a 100644 --- a/pkg/gstpbutils/gstpbutils.gen.go +++ b/pkg/gstpbutils/gstpbutils.gen.go @@ -8,6 +8,7 @@ import ( "strings" "unsafe" + "github.com/diamondburned/gotk4/pkg/core/classdata" "github.com/diamondburned/gotk4/pkg/core/userdata" "github.com/diamondburned/gotk4/pkg/glib/v2" "github.com/diamondburned/gotk4/pkg/gobject/v2" @@ -2541,17 +2542,103 @@ func UnsafeApplyAudioVisualizerOverrides[Instance AudioVisualizer](gclass unsafe if overrides.DecideAllocation != nil { pclass.decide_allocation = (*[0]byte)(C._gotk4_gstpbutils1_AudioVisualizer_decide_allocation) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstpbutils1_AudioVisualizer_decide_allocation", + func(carg0 *C.GstAudioVisualizer, carg1 *C.GstQuery) (cret C.gboolean) { + var scope Instance // go GstAudioVisualizer subclass + var query *gst.Query // in, none, converted + var goret bool // return + + scope = UnsafeAudioVisualizerFromGlibNone(unsafe.Pointer(carg0)).(Instance) + query = gst.UnsafeQueryFromGlibNone(unsafe.Pointer(carg1)) + + goret = overrides.DecideAllocation(scope, query) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.Render != nil { pclass.render = (*[0]byte)(C._gotk4_gstpbutils1_AudioVisualizer_render) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstpbutils1_AudioVisualizer_render", + func(carg0 *C.GstAudioVisualizer, carg1 *C.GstBuffer, carg2 *C.GstVideoFrame) (cret C.gboolean) { + var scope Instance // go GstAudioVisualizer subclass + var audio *gst.Buffer // in, none, converted + var video *gstvideo.VideoFrame // in, none, converted + var goret bool // return + + scope = UnsafeAudioVisualizerFromGlibNone(unsafe.Pointer(carg0)).(Instance) + audio = gst.UnsafeBufferFromGlibNone(unsafe.Pointer(carg1)) + video = gstvideo.UnsafeVideoFrameFromGlibNone(unsafe.Pointer(carg2)) + + goret = overrides.Render(scope, audio, video) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.Setup != nil { pclass.setup = (*[0]byte)(C._gotk4_gstpbutils1_AudioVisualizer_setup) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstpbutils1_AudioVisualizer_setup", + func(carg0 *C.GstAudioVisualizer) (cret C.gboolean) { + var scope Instance // go GstAudioVisualizer subclass + var goret bool // return + + scope = UnsafeAudioVisualizerFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + goret = overrides.Setup(scope) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } } +// RegisterAudioVisualizerSubClass is used to register a go subclass of GstAudioVisualizer. For this to work safely please implement the +// virtual methods required by the implementation. +func RegisterAudioVisualizerSubClass[InstanceT AudioVisualizer]( + name string, + classInit func(class *AudioVisualizerClass), + constructor func() InstanceT, + overrides AudioVisualizerOverrides[InstanceT], + signals map[string]gobject.SignalDefinition, + interfaceInits ...gobject.SubClassInterfaceInit[InstanceT], +) gobject.Type { + return gobject.UnsafeRegisterSubClass( + name, + classInit, + constructor, + overrides, + signals, + TypeAudioVisualizer, + UnsafeAudioVisualizerClassFromGlibBorrow, + UnsafeApplyAudioVisualizerOverrides, + func (obj *gobject.ObjectInstance) gobject.Object { + return unsafeWrapAudioVisualizer(obj) + }, + interfaceInits..., + ) +} + // DiscovererInstance is the instance type used by all types extending GstDiscoverer. It is used internally by the bindings. Users should use the interface [Discoverer] instead. type DiscovererInstance struct { _ [0]func() // equal guard @@ -2921,25 +3008,119 @@ func UnsafeApplyDiscovererOverrides[Instance Discoverer](gclass unsafe.Pointer, if overrides.Discovered != nil { pclass.discovered = (*[0]byte)(C._gotk4_gstpbutils1_Discoverer_discovered) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstpbutils1_Discoverer_discovered", + func(carg0 *C.GstDiscoverer, carg1 *C.GstDiscovererInfo, carg2 *C.GError) { + var discoverer Instance // go GstDiscoverer subclass + var info DiscovererInfo // in, none, converted + var err error // in, none, converted + + discoverer = UnsafeDiscovererFromGlibNone(unsafe.Pointer(carg0)).(Instance) + info = UnsafeDiscovererInfoFromGlibNone(unsafe.Pointer(carg1)) + err = glib.UnsafeErrorFromGlibNone(unsafe.Pointer(carg2)) + + overrides.Discovered(discoverer, info, err) + }, + ) } if overrides.Finished != nil { pclass.finished = (*[0]byte)(C._gotk4_gstpbutils1_Discoverer_finished) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstpbutils1_Discoverer_finished", + func(carg0 *C.GstDiscoverer) { + var discoverer Instance // go GstDiscoverer subclass + + discoverer = UnsafeDiscovererFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + overrides.Finished(discoverer) + }, + ) } if overrides.LoadSerializeInfo != nil { pclass.load_serialize_info = (*[0]byte)(C._gotk4_gstpbutils1_Discoverer_load_serialize_info) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstpbutils1_Discoverer_load_serialize_info", + func(carg0 *C.GstDiscoverer, carg1 *C.gchar) (cret *C.GstDiscovererInfo) { + var dc Instance // go GstDiscoverer subclass + var uri string // in, none, string + var goret DiscovererInfo // return, full, converted + + dc = UnsafeDiscovererFromGlibNone(unsafe.Pointer(carg0)).(Instance) + uri = C.GoString((*C.char)(unsafe.Pointer(carg1))) + + goret = overrides.LoadSerializeInfo(dc, uri) + + cret = (*C.GstDiscovererInfo)(UnsafeDiscovererInfoToGlibFull(goret)) + + return cret + }, + ) } if overrides.SourceSetup != nil { pclass.source_setup = (*[0]byte)(C._gotk4_gstpbutils1_Discoverer_source_setup) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstpbutils1_Discoverer_source_setup", + func(carg0 *C.GstDiscoverer, carg1 *C.GstElement) { + var discoverer Instance // go GstDiscoverer subclass + var source gst.Element // in, none, converted + + discoverer = UnsafeDiscovererFromGlibNone(unsafe.Pointer(carg0)).(Instance) + source = gst.UnsafeElementFromGlibNone(unsafe.Pointer(carg1)) + + overrides.SourceSetup(discoverer, source) + }, + ) } if overrides.Starting != nil { pclass.starting = (*[0]byte)(C._gotk4_gstpbutils1_Discoverer_starting) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstpbutils1_Discoverer_starting", + func(carg0 *C.GstDiscoverer) { + var discoverer Instance // go GstDiscoverer subclass + + discoverer = UnsafeDiscovererFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + overrides.Starting(discoverer) + }, + ) } } +// RegisterDiscovererSubClass is used to register a go subclass of GstDiscoverer. For this to work safely please implement the +// virtual methods required by the implementation. +func RegisterDiscovererSubClass[InstanceT Discoverer]( + name string, + classInit func(class *DiscovererClass), + constructor func() InstanceT, + overrides DiscovererOverrides[InstanceT], + signals map[string]gobject.SignalDefinition, + interfaceInits ...gobject.SubClassInterfaceInit[InstanceT], +) gobject.Type { + return gobject.UnsafeRegisterSubClass( + name, + classInit, + constructor, + overrides, + signals, + TypeDiscoverer, + UnsafeDiscovererClassFromGlibBorrow, + UnsafeApplyDiscovererOverrides, + func (obj *gobject.ObjectInstance) gobject.Object { + return unsafeWrapDiscoverer(obj) + }, + interfaceInits..., + ) +} + // DiscovererInfoInstance is the instance type used by all types extending GstDiscovererInfo. It is used internally by the bindings. Users should use the interface [DiscovererInfo] instead. type DiscovererInfoInstance struct { _ [0]func() // equal guard diff --git a/pkg/gstpbutils/gstpbutils_export.gen.go b/pkg/gstpbutils/gstpbutils_export.gen.go index fb3e4f4..a83872e 100644 --- a/pkg/gstpbutils/gstpbutils_export.gen.go +++ b/pkg/gstpbutils/gstpbutils_export.gen.go @@ -5,6 +5,7 @@ package gstpbutils import ( "unsafe" + "github.com/diamondburned/gotk4/pkg/core/classdata" "github.com/diamondburned/gotk4/pkg/core/userdata" ) @@ -31,41 +32,97 @@ func _gotk4_gstpbutils1_InstallPluginsResultFunc(carg1 C.GstInstallPluginsReturn //export _gotk4_gstpbutils1_AudioVisualizer_decide_allocation func _gotk4_gstpbutils1_AudioVisualizer_decide_allocation(carg0 *C.GstAudioVisualizer, carg1 *C.GstQuery) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstAudioVisualizer, carg1 *C.GstQuery) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstpbutils1_AudioVisualizer_decide_allocation").(func(carg0 *C.GstAudioVisualizer, carg1 *C.GstQuery) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstpbutils1_AudioVisualizer_decide_allocation: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstpbutils1_AudioVisualizer_render func _gotk4_gstpbutils1_AudioVisualizer_render(carg0 *C.GstAudioVisualizer, carg1 *C.GstBuffer, carg2 *C.GstVideoFrame) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstAudioVisualizer, carg1 *C.GstBuffer, carg2 *C.GstVideoFrame) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstpbutils1_AudioVisualizer_render").(func(carg0 *C.GstAudioVisualizer, carg1 *C.GstBuffer, carg2 *C.GstVideoFrame) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstpbutils1_AudioVisualizer_render: no function pointer found") + } + } + return fn(carg0, carg1, carg2) } //export _gotk4_gstpbutils1_AudioVisualizer_setup func _gotk4_gstpbutils1_AudioVisualizer_setup(carg0 *C.GstAudioVisualizer) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstAudioVisualizer) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstpbutils1_AudioVisualizer_setup").(func(carg0 *C.GstAudioVisualizer) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstpbutils1_AudioVisualizer_setup: no function pointer found") + } + } + return fn(carg0) } //export _gotk4_gstpbutils1_Discoverer_discovered func _gotk4_gstpbutils1_Discoverer_discovered(carg0 *C.GstDiscoverer, carg1 *C.GstDiscovererInfo, carg2 *C.GError) { - panic("unimplemented") + var fn func(carg0 *C.GstDiscoverer, carg1 *C.GstDiscovererInfo, carg2 *C.GError) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstpbutils1_Discoverer_discovered").(func(carg0 *C.GstDiscoverer, carg1 *C.GstDiscovererInfo, carg2 *C.GError)) + if fn == nil { + panic("_gotk4_gstpbutils1_Discoverer_discovered: no function pointer found") + } + } + fn(carg0, carg1, carg2) } //export _gotk4_gstpbutils1_Discoverer_finished func _gotk4_gstpbutils1_Discoverer_finished(carg0 *C.GstDiscoverer) { - panic("unimplemented") + var fn func(carg0 *C.GstDiscoverer) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstpbutils1_Discoverer_finished").(func(carg0 *C.GstDiscoverer)) + if fn == nil { + panic("_gotk4_gstpbutils1_Discoverer_finished: no function pointer found") + } + } + fn(carg0) } //export _gotk4_gstpbutils1_Discoverer_load_serialize_info func _gotk4_gstpbutils1_Discoverer_load_serialize_info(carg0 *C.GstDiscoverer, carg1 *C.gchar) (cret *C.GstDiscovererInfo) { - panic("unimplemented") + var fn func(carg0 *C.GstDiscoverer, carg1 *C.gchar) (cret *C.GstDiscovererInfo) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstpbutils1_Discoverer_load_serialize_info").(func(carg0 *C.GstDiscoverer, carg1 *C.gchar) (cret *C.GstDiscovererInfo)) + if fn == nil { + panic("_gotk4_gstpbutils1_Discoverer_load_serialize_info: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstpbutils1_Discoverer_source_setup func _gotk4_gstpbutils1_Discoverer_source_setup(carg0 *C.GstDiscoverer, carg1 *C.GstElement) { - panic("unimplemented") + var fn func(carg0 *C.GstDiscoverer, carg1 *C.GstElement) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstpbutils1_Discoverer_source_setup").(func(carg0 *C.GstDiscoverer, carg1 *C.GstElement)) + if fn == nil { + panic("_gotk4_gstpbutils1_Discoverer_source_setup: no function pointer found") + } + } + fn(carg0, carg1) } //export _gotk4_gstpbutils1_Discoverer_starting func _gotk4_gstpbutils1_Discoverer_starting(carg0 *C.GstDiscoverer) { - panic("unimplemented") + var fn func(carg0 *C.GstDiscoverer) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstpbutils1_Discoverer_starting").(func(carg0 *C.GstDiscoverer)) + if fn == nil { + panic("_gotk4_gstpbutils1_Discoverer_starting: no function pointer found") + } + } + fn(carg0) } diff --git a/pkg/gstplay/gstplay.gen.go b/pkg/gstplay/gstplay.gen.go index 7fee5d9..90417bf 100644 --- a/pkg/gstplay/gstplay.gen.go +++ b/pkg/gstplay/gstplay.gen.go @@ -7,6 +7,7 @@ import ( "runtime" "unsafe" + "github.com/diamondburned/gotk4/pkg/core/classdata" "github.com/diamondburned/gotk4/pkg/glib/v2" "github.com/diamondburned/gotk4/pkg/gobject/v2" "github.com/go-gst/go-gst/pkg/gst" diff --git a/pkg/gstplayer/gstplayer.gen.go b/pkg/gstplayer/gstplayer.gen.go index 4ee7e4a..527dc54 100644 --- a/pkg/gstplayer/gstplayer.gen.go +++ b/pkg/gstplayer/gstplayer.gen.go @@ -7,6 +7,7 @@ import ( "runtime" "unsafe" + "github.com/diamondburned/gotk4/pkg/core/classdata" "github.com/diamondburned/gotk4/pkg/glib/v2" "github.com/diamondburned/gotk4/pkg/gobject/v2" "github.com/go-gst/go-gst/pkg/gst" diff --git a/pkg/gstrtp/gstrtp.gen.go b/pkg/gstrtp/gstrtp.gen.go index a0f56a2..8d895c9 100644 --- a/pkg/gstrtp/gstrtp.gen.go +++ b/pkg/gstrtp/gstrtp.gen.go @@ -8,6 +8,7 @@ import ( "strings" "unsafe" + "github.com/diamondburned/gotk4/pkg/core/classdata" "github.com/diamondburned/gotk4/pkg/glib/v2" "github.com/diamondburned/gotk4/pkg/gobject/v2" "github.com/go-gst/go-gst/pkg/gst" @@ -1741,25 +1742,147 @@ func UnsafeApplyRTPBaseDepayloadOverrides[Instance RTPBaseDepayload](gclass unsa if overrides.HandleEvent != nil { pclass.handle_event = (*[0]byte)(C._gotk4_gstrtp1_RTPBaseDepayload_handle_event) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstrtp1_RTPBaseDepayload_handle_event", + func(carg0 *C.GstRTPBaseDepayload, carg1 *C.GstEvent) (cret C.gboolean) { + var filter Instance // go GstRTPBaseDepayload subclass + var event *gst.Event // in, none, converted + var goret bool // return + + filter = UnsafeRTPBaseDepayloadFromGlibNone(unsafe.Pointer(carg0)).(Instance) + event = gst.UnsafeEventFromGlibNone(unsafe.Pointer(carg1)) + + goret = overrides.HandleEvent(filter, event) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.PacketLost != nil { pclass.packet_lost = (*[0]byte)(C._gotk4_gstrtp1_RTPBaseDepayload_packet_lost) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstrtp1_RTPBaseDepayload_packet_lost", + func(carg0 *C.GstRTPBaseDepayload, carg1 *C.GstEvent) (cret C.gboolean) { + var filter Instance // go GstRTPBaseDepayload subclass + var event *gst.Event // in, none, converted + var goret bool // return + + filter = UnsafeRTPBaseDepayloadFromGlibNone(unsafe.Pointer(carg0)).(Instance) + event = gst.UnsafeEventFromGlibNone(unsafe.Pointer(carg1)) + + goret = overrides.PacketLost(filter, event) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.Process != nil { pclass.process = (*[0]byte)(C._gotk4_gstrtp1_RTPBaseDepayload_process) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstrtp1_RTPBaseDepayload_process", + func(carg0 *C.GstRTPBaseDepayload, carg1 *C.GstBuffer) (cret *C.GstBuffer) { + var base Instance // go GstRTPBaseDepayload subclass + var in *gst.Buffer // in, none, converted + var goret *gst.Buffer // return, full, converted + + base = UnsafeRTPBaseDepayloadFromGlibNone(unsafe.Pointer(carg0)).(Instance) + in = gst.UnsafeBufferFromGlibNone(unsafe.Pointer(carg1)) + + goret = overrides.Process(base, in) + + cret = (*C.GstBuffer)(gst.UnsafeBufferToGlibFull(goret)) + + return cret + }, + ) } if overrides.ProcessRtpPacket != nil { pclass.process_rtp_packet = (*[0]byte)(C._gotk4_gstrtp1_RTPBaseDepayload_process_rtp_packet) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstrtp1_RTPBaseDepayload_process_rtp_packet", + func(carg0 *C.GstRTPBaseDepayload, carg1 *C.GstRTPBuffer) (cret *C.GstBuffer) { + var base Instance // go GstRTPBaseDepayload subclass + var rtpBuffer *RTPBuffer // in, none, converted + var goret *gst.Buffer // return, full, converted + + base = UnsafeRTPBaseDepayloadFromGlibNone(unsafe.Pointer(carg0)).(Instance) + rtpBuffer = UnsafeRTPBufferFromGlibNone(unsafe.Pointer(carg1)) + + goret = overrides.ProcessRtpPacket(base, rtpBuffer) + + cret = (*C.GstBuffer)(gst.UnsafeBufferToGlibFull(goret)) + + return cret + }, + ) } if overrides.SetCaps != nil { pclass.set_caps = (*[0]byte)(C._gotk4_gstrtp1_RTPBaseDepayload_set_caps) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstrtp1_RTPBaseDepayload_set_caps", + func(carg0 *C.GstRTPBaseDepayload, carg1 *C.GstCaps) (cret C.gboolean) { + var filter Instance // go GstRTPBaseDepayload subclass + var caps *gst.Caps // in, none, converted + var goret bool // return + + filter = UnsafeRTPBaseDepayloadFromGlibNone(unsafe.Pointer(carg0)).(Instance) + caps = gst.UnsafeCapsFromGlibNone(unsafe.Pointer(carg1)) + + goret = overrides.SetCaps(filter, caps) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } } +// RegisterRTPBaseDepayloadSubClass is used to register a go subclass of GstRTPBaseDepayload. For this to work safely please implement the +// virtual methods required by the implementation. +func RegisterRTPBaseDepayloadSubClass[InstanceT RTPBaseDepayload]( + name string, + classInit func(class *RTPBaseDepayloadClass), + constructor func() InstanceT, + overrides RTPBaseDepayloadOverrides[InstanceT], + signals map[string]gobject.SignalDefinition, + interfaceInits ...gobject.SubClassInterfaceInit[InstanceT], +) gobject.Type { + return gobject.UnsafeRegisterSubClass( + name, + classInit, + constructor, + overrides, + signals, + TypeRTPBaseDepayload, + UnsafeRTPBaseDepayloadClassFromGlibBorrow, + UnsafeApplyRTPBaseDepayloadOverrides, + func (obj *gobject.ObjectInstance) gobject.Object { + return unsafeWrapRTPBaseDepayload(obj) + }, + interfaceInits..., + ) +} + // RTPBasePayloadInstance is the instance type used by all types extending GstRTPBasePayload. It is used internally by the bindings. Users should use the interface [RTPBasePayload] instead. type RTPBasePayloadInstance struct { _ [0]func() // equal guard @@ -2340,29 +2463,175 @@ func UnsafeApplyRTPBasePayloadOverrides[Instance RTPBasePayload](gclass unsafe.P if overrides.GetCaps != nil { pclass.get_caps = (*[0]byte)(C._gotk4_gstrtp1_RTPBasePayload_get_caps) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstrtp1_RTPBasePayload_get_caps", + func(carg0 *C.GstRTPBasePayload, carg1 *C.GstPad, carg2 *C.GstCaps) (cret *C.GstCaps) { + var payload Instance // go GstRTPBasePayload subclass + var pad gst.Pad // in, none, converted + var filter *gst.Caps // in, none, converted + var goret *gst.Caps // return, full, converted + + payload = UnsafeRTPBasePayloadFromGlibNone(unsafe.Pointer(carg0)).(Instance) + pad = gst.UnsafePadFromGlibNone(unsafe.Pointer(carg1)) + filter = gst.UnsafeCapsFromGlibNone(unsafe.Pointer(carg2)) + + goret = overrides.GetCaps(payload, pad, filter) + + cret = (*C.GstCaps)(gst.UnsafeCapsToGlibFull(goret)) + + return cret + }, + ) } if overrides.HandleBuffer != nil { pclass.handle_buffer = (*[0]byte)(C._gotk4_gstrtp1_RTPBasePayload_handle_buffer) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstrtp1_RTPBasePayload_handle_buffer", + func(carg0 *C.GstRTPBasePayload, carg1 *C.GstBuffer) (cret C.GstFlowReturn) { + var payload Instance // go GstRTPBasePayload subclass + var buffer *gst.Buffer // in, none, converted + var goret gst.FlowReturn // return, none, casted + + payload = UnsafeRTPBasePayloadFromGlibNone(unsafe.Pointer(carg0)).(Instance) + buffer = gst.UnsafeBufferFromGlibNone(unsafe.Pointer(carg1)) + + goret = overrides.HandleBuffer(payload, buffer) + + cret = C.GstFlowReturn(goret) + + return cret + }, + ) } if overrides.Query != nil { pclass.query = (*[0]byte)(C._gotk4_gstrtp1_RTPBasePayload_query) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstrtp1_RTPBasePayload_query", + func(carg0 *C.GstRTPBasePayload, carg1 *C.GstPad, carg2 *C.GstQuery) (cret C.gboolean) { + var payload Instance // go GstRTPBasePayload subclass + var pad gst.Pad // in, none, converted + var query *gst.Query // in, none, converted + var goret bool // return + + payload = UnsafeRTPBasePayloadFromGlibNone(unsafe.Pointer(carg0)).(Instance) + pad = gst.UnsafePadFromGlibNone(unsafe.Pointer(carg1)) + query = gst.UnsafeQueryFromGlibNone(unsafe.Pointer(carg2)) + + goret = overrides.Query(payload, pad, query) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.SetCaps != nil { pclass.set_caps = (*[0]byte)(C._gotk4_gstrtp1_RTPBasePayload_set_caps) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstrtp1_RTPBasePayload_set_caps", + func(carg0 *C.GstRTPBasePayload, carg1 *C.GstCaps) (cret C.gboolean) { + var payload Instance // go GstRTPBasePayload subclass + var caps *gst.Caps // in, none, converted + var goret bool // return + + payload = UnsafeRTPBasePayloadFromGlibNone(unsafe.Pointer(carg0)).(Instance) + caps = gst.UnsafeCapsFromGlibNone(unsafe.Pointer(carg1)) + + goret = overrides.SetCaps(payload, caps) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.SinkEvent != nil { pclass.sink_event = (*[0]byte)(C._gotk4_gstrtp1_RTPBasePayload_sink_event) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstrtp1_RTPBasePayload_sink_event", + func(carg0 *C.GstRTPBasePayload, carg1 *C.GstEvent) (cret C.gboolean) { + var payload Instance // go GstRTPBasePayload subclass + var event *gst.Event // in, none, converted + var goret bool // return + + payload = UnsafeRTPBasePayloadFromGlibNone(unsafe.Pointer(carg0)).(Instance) + event = gst.UnsafeEventFromGlibNone(unsafe.Pointer(carg1)) + + goret = overrides.SinkEvent(payload, event) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.SrcEvent != nil { pclass.src_event = (*[0]byte)(C._gotk4_gstrtp1_RTPBasePayload_src_event) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstrtp1_RTPBasePayload_src_event", + func(carg0 *C.GstRTPBasePayload, carg1 *C.GstEvent) (cret C.gboolean) { + var payload Instance // go GstRTPBasePayload subclass + var event *gst.Event // in, none, converted + var goret bool // return + + payload = UnsafeRTPBasePayloadFromGlibNone(unsafe.Pointer(carg0)).(Instance) + event = gst.UnsafeEventFromGlibNone(unsafe.Pointer(carg1)) + + goret = overrides.SrcEvent(payload, event) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } } +// RegisterRTPBasePayloadSubClass is used to register a go subclass of GstRTPBasePayload. For this to work safely please implement the +// virtual methods required by the implementation. +func RegisterRTPBasePayloadSubClass[InstanceT RTPBasePayload]( + name string, + classInit func(class *RTPBasePayloadClass), + constructor func() InstanceT, + overrides RTPBasePayloadOverrides[InstanceT], + signals map[string]gobject.SignalDefinition, + interfaceInits ...gobject.SubClassInterfaceInit[InstanceT], +) gobject.Type { + return gobject.UnsafeRegisterSubClass( + name, + classInit, + constructor, + overrides, + signals, + TypeRTPBasePayload, + UnsafeRTPBasePayloadClassFromGlibBorrow, + UnsafeApplyRTPBasePayloadOverrides, + func (obj *gobject.ObjectInstance) gobject.Object { + return unsafeWrapRTPBasePayload(obj) + }, + interfaceInits..., + ) +} + // RTPHeaderExtensionInstance is the instance type used by all types extending GstRTPHeaderExtension. It is used internally by the bindings. Users should use the interface [RTPHeaderExtension] instead. type RTPHeaderExtensionInstance struct { _ [0]func() // equal guard @@ -3254,37 +3523,233 @@ func UnsafeApplyRTPHeaderExtensionOverrides[Instance RTPHeaderExtension](gclass if overrides.GetMaxSize != nil { pclass.get_max_size = (*[0]byte)(C._gotk4_gstrtp1_RTPHeaderExtension_get_max_size) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstrtp1_RTPHeaderExtension_get_max_size", + func(carg0 *C.GstRTPHeaderExtension, carg1 *C.GstBuffer) (cret C.gsize) { + var ext Instance // go GstRTPHeaderExtension subclass + var inputMeta *gst.Buffer // in, none, converted + var goret uint // return, none, casted + + ext = UnsafeRTPHeaderExtensionFromGlibNone(unsafe.Pointer(carg0)).(Instance) + inputMeta = gst.UnsafeBufferFromGlibNone(unsafe.Pointer(carg1)) + + goret = overrides.GetMaxSize(ext, inputMeta) + + cret = C.gsize(goret) + + return cret + }, + ) } if overrides.GetSupportedFlags != nil { pclass.get_supported_flags = (*[0]byte)(C._gotk4_gstrtp1_RTPHeaderExtension_get_supported_flags) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstrtp1_RTPHeaderExtension_get_supported_flags", + func(carg0 *C.GstRTPHeaderExtension) (cret C.GstRTPHeaderExtensionFlags) { + var ext Instance // go GstRTPHeaderExtension subclass + var goret RTPHeaderExtensionFlags // return, none, casted + + ext = UnsafeRTPHeaderExtensionFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + goret = overrides.GetSupportedFlags(ext) + + cret = C.GstRTPHeaderExtensionFlags(goret) + + return cret + }, + ) } if overrides.Read != nil { pclass.read = (*[0]byte)(C._gotk4_gstrtp1_RTPHeaderExtension_read) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstrtp1_RTPHeaderExtension_read", + func(carg0 *C.GstRTPHeaderExtension, carg1 C.GstRTPHeaderExtensionFlags, carg2 *C.guint8, carg3 C.gsize, carg4 *C.GstBuffer) (cret C.gboolean) { + var ext Instance // go GstRTPHeaderExtension subclass + var readFlags RTPHeaderExtensionFlags // in, none, casted + var data []uint8 // in, transfer: none, C Pointers: 1, Name: array[guint8], array (inner: *typesystem.CastablePrimitive, length-by: carg3) + var buffer *gst.Buffer // in, none, converted + var goret bool // return + + ext = UnsafeRTPHeaderExtensionFromGlibNone(unsafe.Pointer(carg0)).(Instance) + readFlags = RTPHeaderExtensionFlags(carg1) + _ = data + _ = carg2 + _ = carg3 + panic("unimplemented conversion of []uint8 (const guint8*)") + buffer = gst.UnsafeBufferFromGlibNone(unsafe.Pointer(carg4)) + + goret = overrides.Read(ext, readFlags, data, buffer) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.SetAttributes != nil { pclass.set_attributes = (*[0]byte)(C._gotk4_gstrtp1_RTPHeaderExtension_set_attributes) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstrtp1_RTPHeaderExtension_set_attributes", + func(carg0 *C.GstRTPHeaderExtension, carg1 C.GstRTPHeaderExtensionDirection, carg2 *C.gchar) (cret C.gboolean) { + var ext Instance // go GstRTPHeaderExtension subclass + var direction RTPHeaderExtensionDirection // in, none, casted + var attributes string // in, none, string + var goret bool // return + + ext = UnsafeRTPHeaderExtensionFromGlibNone(unsafe.Pointer(carg0)).(Instance) + direction = RTPHeaderExtensionDirection(carg1) + attributes = C.GoString((*C.char)(unsafe.Pointer(carg2))) + + goret = overrides.SetAttributes(ext, direction, attributes) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.SetCapsFromAttributes != nil { pclass.set_caps_from_attributes = (*[0]byte)(C._gotk4_gstrtp1_RTPHeaderExtension_set_caps_from_attributes) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstrtp1_RTPHeaderExtension_set_caps_from_attributes", + func(carg0 *C.GstRTPHeaderExtension, carg1 *C.GstCaps) (cret C.gboolean) { + var ext Instance // go GstRTPHeaderExtension subclass + var caps *gst.Caps // in, none, converted + var goret bool // return + + ext = UnsafeRTPHeaderExtensionFromGlibNone(unsafe.Pointer(carg0)).(Instance) + caps = gst.UnsafeCapsFromGlibNone(unsafe.Pointer(carg1)) + + goret = overrides.SetCapsFromAttributes(ext, caps) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.SetNonRtpSinkCaps != nil { pclass.set_non_rtp_sink_caps = (*[0]byte)(C._gotk4_gstrtp1_RTPHeaderExtension_set_non_rtp_sink_caps) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstrtp1_RTPHeaderExtension_set_non_rtp_sink_caps", + func(carg0 *C.GstRTPHeaderExtension, carg1 *C.GstCaps) (cret C.gboolean) { + var ext Instance // go GstRTPHeaderExtension subclass + var caps *gst.Caps // in, none, converted + var goret bool // return + + ext = UnsafeRTPHeaderExtensionFromGlibNone(unsafe.Pointer(carg0)).(Instance) + caps = gst.UnsafeCapsFromGlibNone(unsafe.Pointer(carg1)) + + goret = overrides.SetNonRtpSinkCaps(ext, caps) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.UpdateNonRtpSrcCaps != nil { pclass.update_non_rtp_src_caps = (*[0]byte)(C._gotk4_gstrtp1_RTPHeaderExtension_update_non_rtp_src_caps) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstrtp1_RTPHeaderExtension_update_non_rtp_src_caps", + func(carg0 *C.GstRTPHeaderExtension, carg1 *C.GstCaps) (cret C.gboolean) { + var ext Instance // go GstRTPHeaderExtension subclass + var caps *gst.Caps // in, none, converted + var goret bool // return + + ext = UnsafeRTPHeaderExtensionFromGlibNone(unsafe.Pointer(carg0)).(Instance) + caps = gst.UnsafeCapsFromGlibNone(unsafe.Pointer(carg1)) + + goret = overrides.UpdateNonRtpSrcCaps(ext, caps) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.Write != nil { pclass.write = (*[0]byte)(C._gotk4_gstrtp1_RTPHeaderExtension_write) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstrtp1_RTPHeaderExtension_write", + func(carg0 *C.GstRTPHeaderExtension, carg1 *C.GstBuffer, carg2 C.GstRTPHeaderExtensionFlags, carg3 *C.GstBuffer, carg4 *C.guint8, carg5 C.gsize) (cret C.gssize) { + var ext Instance // go GstRTPHeaderExtension subclass + var inputMeta *gst.Buffer // in, none, converted + var writeFlags RTPHeaderExtensionFlags // in, none, casted + var output *gst.Buffer // in, none, converted + var data []uint8 // in, transfer: none, C Pointers: 1, Name: array[guint8], array (inner: *typesystem.CastablePrimitive, length-by: carg5) + var goret int // return, none, casted + + ext = UnsafeRTPHeaderExtensionFromGlibNone(unsafe.Pointer(carg0)).(Instance) + inputMeta = gst.UnsafeBufferFromGlibNone(unsafe.Pointer(carg1)) + writeFlags = RTPHeaderExtensionFlags(carg2) + output = gst.UnsafeBufferFromGlibNone(unsafe.Pointer(carg3)) + _ = data + _ = carg4 + _ = carg5 + panic("unimplemented conversion of []uint8 (guint8*)") + + goret = overrides.Write(ext, inputMeta, writeFlags, output, data) + + cret = C.gssize(goret) + + return cret + }, + ) } } +// RegisterRTPHeaderExtensionSubClass is used to register a go subclass of GstRTPHeaderExtension. For this to work safely please implement the +// virtual methods required by the implementation. +func RegisterRTPHeaderExtensionSubClass[InstanceT RTPHeaderExtension]( + name string, + classInit func(class *RTPHeaderExtensionClass), + constructor func() InstanceT, + overrides RTPHeaderExtensionOverrides[InstanceT], + signals map[string]gobject.SignalDefinition, + interfaceInits ...gobject.SubClassInterfaceInit[InstanceT], +) gobject.Type { + return gobject.UnsafeRegisterSubClass( + name, + classInit, + constructor, + overrides, + signals, + TypeRTPHeaderExtension, + UnsafeRTPHeaderExtensionClassFromGlibBorrow, + UnsafeApplyRTPHeaderExtensionOverrides, + func (obj *gobject.ObjectInstance) gobject.Object { + return unsafeWrapRTPHeaderExtension(obj) + }, + interfaceInits..., + ) +} + // RTPBaseAudioPayloadInstance is the instance type used by all types extending GstRTPBaseAudioPayload. It is used internally by the bindings. Users should use the interface [RTPBaseAudioPayload] instead. type RTPBaseAudioPayloadInstance struct { _ [0]func() // equal guard @@ -3650,6 +4115,32 @@ func UnsafeApplyRTPBaseAudioPayloadOverrides[Instance RTPBaseAudioPayload](gclas UnsafeApplyRTPBasePayloadOverrides(gclass, overrides.RTPBasePayloadOverrides) } +// RegisterRTPBaseAudioPayloadSubClass is used to register a go subclass of GstRTPBaseAudioPayload. For this to work safely please implement the +// virtual methods required by the implementation. +func RegisterRTPBaseAudioPayloadSubClass[InstanceT RTPBaseAudioPayload]( + name string, + classInit func(class *RTPBaseAudioPayloadClass), + constructor func() InstanceT, + overrides RTPBaseAudioPayloadOverrides[InstanceT], + signals map[string]gobject.SignalDefinition, + interfaceInits ...gobject.SubClassInterfaceInit[InstanceT], +) gobject.Type { + return gobject.UnsafeRegisterSubClass( + name, + classInit, + constructor, + overrides, + signals, + TypeRTPBaseAudioPayload, + UnsafeRTPBaseAudioPayloadClassFromGlibBorrow, + UnsafeApplyRTPBaseAudioPayloadOverrides, + func (obj *gobject.ObjectInstance) gobject.Object { + return unsafeWrapRTPBaseAudioPayload(obj) + }, + interfaceInits..., + ) +} + // RTCPBuffer wraps GstRTCPBuffer // // Note: The API in this module is not yet declared stable. diff --git a/pkg/gstrtp/gstrtp_export.gen.go b/pkg/gstrtp/gstrtp_export.gen.go index 3ebdae3..f453280 100644 --- a/pkg/gstrtp/gstrtp_export.gen.go +++ b/pkg/gstrtp/gstrtp_export.gen.go @@ -2,102 +2,240 @@ package gstrtp +import ( + "unsafe" + + "github.com/diamondburned/gotk4/pkg/core/classdata" +) // #include import "C" //export _gotk4_gstrtp1_RTPBaseDepayload_handle_event func _gotk4_gstrtp1_RTPBaseDepayload_handle_event(carg0 *C.GstRTPBaseDepayload, carg1 *C.GstEvent) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstRTPBaseDepayload, carg1 *C.GstEvent) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstrtp1_RTPBaseDepayload_handle_event").(func(carg0 *C.GstRTPBaseDepayload, carg1 *C.GstEvent) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstrtp1_RTPBaseDepayload_handle_event: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstrtp1_RTPBaseDepayload_packet_lost func _gotk4_gstrtp1_RTPBaseDepayload_packet_lost(carg0 *C.GstRTPBaseDepayload, carg1 *C.GstEvent) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstRTPBaseDepayload, carg1 *C.GstEvent) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstrtp1_RTPBaseDepayload_packet_lost").(func(carg0 *C.GstRTPBaseDepayload, carg1 *C.GstEvent) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstrtp1_RTPBaseDepayload_packet_lost: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstrtp1_RTPBaseDepayload_process func _gotk4_gstrtp1_RTPBaseDepayload_process(carg0 *C.GstRTPBaseDepayload, carg1 *C.GstBuffer) (cret *C.GstBuffer) { - panic("unimplemented") + var fn func(carg0 *C.GstRTPBaseDepayload, carg1 *C.GstBuffer) (cret *C.GstBuffer) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstrtp1_RTPBaseDepayload_process").(func(carg0 *C.GstRTPBaseDepayload, carg1 *C.GstBuffer) (cret *C.GstBuffer)) + if fn == nil { + panic("_gotk4_gstrtp1_RTPBaseDepayload_process: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstrtp1_RTPBaseDepayload_process_rtp_packet func _gotk4_gstrtp1_RTPBaseDepayload_process_rtp_packet(carg0 *C.GstRTPBaseDepayload, carg1 *C.GstRTPBuffer) (cret *C.GstBuffer) { - panic("unimplemented") + var fn func(carg0 *C.GstRTPBaseDepayload, carg1 *C.GstRTPBuffer) (cret *C.GstBuffer) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstrtp1_RTPBaseDepayload_process_rtp_packet").(func(carg0 *C.GstRTPBaseDepayload, carg1 *C.GstRTPBuffer) (cret *C.GstBuffer)) + if fn == nil { + panic("_gotk4_gstrtp1_RTPBaseDepayload_process_rtp_packet: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstrtp1_RTPBaseDepayload_set_caps func _gotk4_gstrtp1_RTPBaseDepayload_set_caps(carg0 *C.GstRTPBaseDepayload, carg1 *C.GstCaps) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstRTPBaseDepayload, carg1 *C.GstCaps) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstrtp1_RTPBaseDepayload_set_caps").(func(carg0 *C.GstRTPBaseDepayload, carg1 *C.GstCaps) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstrtp1_RTPBaseDepayload_set_caps: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstrtp1_RTPBasePayload_get_caps func _gotk4_gstrtp1_RTPBasePayload_get_caps(carg0 *C.GstRTPBasePayload, carg1 *C.GstPad, carg2 *C.GstCaps) (cret *C.GstCaps) { - panic("unimplemented") + var fn func(carg0 *C.GstRTPBasePayload, carg1 *C.GstPad, carg2 *C.GstCaps) (cret *C.GstCaps) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstrtp1_RTPBasePayload_get_caps").(func(carg0 *C.GstRTPBasePayload, carg1 *C.GstPad, carg2 *C.GstCaps) (cret *C.GstCaps)) + if fn == nil { + panic("_gotk4_gstrtp1_RTPBasePayload_get_caps: no function pointer found") + } + } + return fn(carg0, carg1, carg2) } //export _gotk4_gstrtp1_RTPBasePayload_handle_buffer func _gotk4_gstrtp1_RTPBasePayload_handle_buffer(carg0 *C.GstRTPBasePayload, carg1 *C.GstBuffer) (cret C.GstFlowReturn) { - panic("unimplemented") + var fn func(carg0 *C.GstRTPBasePayload, carg1 *C.GstBuffer) (cret C.GstFlowReturn) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstrtp1_RTPBasePayload_handle_buffer").(func(carg0 *C.GstRTPBasePayload, carg1 *C.GstBuffer) (cret C.GstFlowReturn)) + if fn == nil { + panic("_gotk4_gstrtp1_RTPBasePayload_handle_buffer: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstrtp1_RTPBasePayload_query func _gotk4_gstrtp1_RTPBasePayload_query(carg0 *C.GstRTPBasePayload, carg1 *C.GstPad, carg2 *C.GstQuery) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstRTPBasePayload, carg1 *C.GstPad, carg2 *C.GstQuery) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstrtp1_RTPBasePayload_query").(func(carg0 *C.GstRTPBasePayload, carg1 *C.GstPad, carg2 *C.GstQuery) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstrtp1_RTPBasePayload_query: no function pointer found") + } + } + return fn(carg0, carg1, carg2) } //export _gotk4_gstrtp1_RTPBasePayload_set_caps func _gotk4_gstrtp1_RTPBasePayload_set_caps(carg0 *C.GstRTPBasePayload, carg1 *C.GstCaps) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstRTPBasePayload, carg1 *C.GstCaps) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstrtp1_RTPBasePayload_set_caps").(func(carg0 *C.GstRTPBasePayload, carg1 *C.GstCaps) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstrtp1_RTPBasePayload_set_caps: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstrtp1_RTPBasePayload_sink_event func _gotk4_gstrtp1_RTPBasePayload_sink_event(carg0 *C.GstRTPBasePayload, carg1 *C.GstEvent) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstRTPBasePayload, carg1 *C.GstEvent) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstrtp1_RTPBasePayload_sink_event").(func(carg0 *C.GstRTPBasePayload, carg1 *C.GstEvent) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstrtp1_RTPBasePayload_sink_event: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstrtp1_RTPBasePayload_src_event func _gotk4_gstrtp1_RTPBasePayload_src_event(carg0 *C.GstRTPBasePayload, carg1 *C.GstEvent) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstRTPBasePayload, carg1 *C.GstEvent) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstrtp1_RTPBasePayload_src_event").(func(carg0 *C.GstRTPBasePayload, carg1 *C.GstEvent) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstrtp1_RTPBasePayload_src_event: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstrtp1_RTPHeaderExtension_get_max_size func _gotk4_gstrtp1_RTPHeaderExtension_get_max_size(carg0 *C.GstRTPHeaderExtension, carg1 *C.GstBuffer) (cret C.gsize) { - panic("unimplemented") + var fn func(carg0 *C.GstRTPHeaderExtension, carg1 *C.GstBuffer) (cret C.gsize) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstrtp1_RTPHeaderExtension_get_max_size").(func(carg0 *C.GstRTPHeaderExtension, carg1 *C.GstBuffer) (cret C.gsize)) + if fn == nil { + panic("_gotk4_gstrtp1_RTPHeaderExtension_get_max_size: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstrtp1_RTPHeaderExtension_get_supported_flags func _gotk4_gstrtp1_RTPHeaderExtension_get_supported_flags(carg0 *C.GstRTPHeaderExtension) (cret C.GstRTPHeaderExtensionFlags) { - panic("unimplemented") + var fn func(carg0 *C.GstRTPHeaderExtension) (cret C.GstRTPHeaderExtensionFlags) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstrtp1_RTPHeaderExtension_get_supported_flags").(func(carg0 *C.GstRTPHeaderExtension) (cret C.GstRTPHeaderExtensionFlags)) + if fn == nil { + panic("_gotk4_gstrtp1_RTPHeaderExtension_get_supported_flags: no function pointer found") + } + } + return fn(carg0) } //export _gotk4_gstrtp1_RTPHeaderExtension_read func _gotk4_gstrtp1_RTPHeaderExtension_read(carg0 *C.GstRTPHeaderExtension, carg1 C.GstRTPHeaderExtensionFlags, carg2 *C.guint8, carg3 C.gsize, carg4 *C.GstBuffer) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstRTPHeaderExtension, carg1 C.GstRTPHeaderExtensionFlags, carg2 *C.guint8, carg3 C.gsize, carg4 *C.GstBuffer) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstrtp1_RTPHeaderExtension_read").(func(carg0 *C.GstRTPHeaderExtension, carg1 C.GstRTPHeaderExtensionFlags, carg2 *C.guint8, carg3 C.gsize, carg4 *C.GstBuffer) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstrtp1_RTPHeaderExtension_read: no function pointer found") + } + } + return fn(carg0, carg1, carg2, carg3, carg4) } //export _gotk4_gstrtp1_RTPHeaderExtension_set_attributes func _gotk4_gstrtp1_RTPHeaderExtension_set_attributes(carg0 *C.GstRTPHeaderExtension, carg1 C.GstRTPHeaderExtensionDirection, carg2 *C.gchar) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstRTPHeaderExtension, carg1 C.GstRTPHeaderExtensionDirection, carg2 *C.gchar) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstrtp1_RTPHeaderExtension_set_attributes").(func(carg0 *C.GstRTPHeaderExtension, carg1 C.GstRTPHeaderExtensionDirection, carg2 *C.gchar) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstrtp1_RTPHeaderExtension_set_attributes: no function pointer found") + } + } + return fn(carg0, carg1, carg2) } //export _gotk4_gstrtp1_RTPHeaderExtension_set_caps_from_attributes func _gotk4_gstrtp1_RTPHeaderExtension_set_caps_from_attributes(carg0 *C.GstRTPHeaderExtension, carg1 *C.GstCaps) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstRTPHeaderExtension, carg1 *C.GstCaps) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstrtp1_RTPHeaderExtension_set_caps_from_attributes").(func(carg0 *C.GstRTPHeaderExtension, carg1 *C.GstCaps) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstrtp1_RTPHeaderExtension_set_caps_from_attributes: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstrtp1_RTPHeaderExtension_set_non_rtp_sink_caps func _gotk4_gstrtp1_RTPHeaderExtension_set_non_rtp_sink_caps(carg0 *C.GstRTPHeaderExtension, carg1 *C.GstCaps) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstRTPHeaderExtension, carg1 *C.GstCaps) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstrtp1_RTPHeaderExtension_set_non_rtp_sink_caps").(func(carg0 *C.GstRTPHeaderExtension, carg1 *C.GstCaps) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstrtp1_RTPHeaderExtension_set_non_rtp_sink_caps: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstrtp1_RTPHeaderExtension_update_non_rtp_src_caps func _gotk4_gstrtp1_RTPHeaderExtension_update_non_rtp_src_caps(carg0 *C.GstRTPHeaderExtension, carg1 *C.GstCaps) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstRTPHeaderExtension, carg1 *C.GstCaps) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstrtp1_RTPHeaderExtension_update_non_rtp_src_caps").(func(carg0 *C.GstRTPHeaderExtension, carg1 *C.GstCaps) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstrtp1_RTPHeaderExtension_update_non_rtp_src_caps: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstrtp1_RTPHeaderExtension_write func _gotk4_gstrtp1_RTPHeaderExtension_write(carg0 *C.GstRTPHeaderExtension, carg1 *C.GstBuffer, carg2 C.GstRTPHeaderExtensionFlags, carg3 *C.GstBuffer, carg4 *C.guint8, carg5 C.gsize) (cret C.gssize) { - panic("unimplemented") + var fn func(carg0 *C.GstRTPHeaderExtension, carg1 *C.GstBuffer, carg2 C.GstRTPHeaderExtensionFlags, carg3 *C.GstBuffer, carg4 *C.guint8, carg5 C.gsize) (cret C.gssize) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstrtp1_RTPHeaderExtension_write").(func(carg0 *C.GstRTPHeaderExtension, carg1 *C.GstBuffer, carg2 C.GstRTPHeaderExtensionFlags, carg3 *C.GstBuffer, carg4 *C.guint8, carg5 C.gsize) (cret C.gssize)) + if fn == nil { + panic("_gotk4_gstrtp1_RTPHeaderExtension_write: no function pointer found") + } + } + return fn(carg0, carg1, carg2, carg3, carg4, carg5) } diff --git a/pkg/gstrtsp/gstrtsp.gen.go b/pkg/gstrtsp/gstrtsp.gen.go index 12c5437..c0f5113 100644 --- a/pkg/gstrtsp/gstrtsp.gen.go +++ b/pkg/gstrtsp/gstrtsp.gen.go @@ -9,6 +9,7 @@ import ( "strings" "unsafe" + "github.com/diamondburned/gotk4/pkg/core/classdata" "github.com/diamondburned/gotk4/pkg/core/userdata" "github.com/diamondburned/gotk4/pkg/gio/v2" "github.com/diamondburned/gotk4/pkg/glib/v2" @@ -2477,38 +2478,210 @@ func UnsafeApplyRTSPExtensionOverrides[Instance RTSPExtension](gclass unsafe.Poi if overrides.AfterSend != nil { pclass.after_send = (*[0]byte)(C._gotk4_gstrtsp1_RTSPExtension_after_send) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstrtsp1_RTSPExtension_after_send", + func(carg0 *C.GstRTSPExtension, carg1 *C.GstRTSPMessage, carg2 *C.GstRTSPMessage) (cret C.GstRTSPResult) { + var ext Instance // go GstRTSPExtension subclass + var req *RTSPMessage // in, none, converted + var resp *RTSPMessage // in, none, converted + var goret RTSPResult // return, none, casted + + ext = UnsafeRTSPExtensionFromGlibNone(unsafe.Pointer(carg0)).(Instance) + req = UnsafeRTSPMessageFromGlibNone(unsafe.Pointer(carg1)) + resp = UnsafeRTSPMessageFromGlibNone(unsafe.Pointer(carg2)) + + goret = overrides.AfterSend(ext, req, resp) + + cret = C.GstRTSPResult(goret) + + return cret + }, + ) } if overrides.BeforeSend != nil { pclass.before_send = (*[0]byte)(C._gotk4_gstrtsp1_RTSPExtension_before_send) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstrtsp1_RTSPExtension_before_send", + func(carg0 *C.GstRTSPExtension, carg1 *C.GstRTSPMessage) (cret C.GstRTSPResult) { + var ext Instance // go GstRTSPExtension subclass + var req *RTSPMessage // in, none, converted + var goret RTSPResult // return, none, casted + + ext = UnsafeRTSPExtensionFromGlibNone(unsafe.Pointer(carg0)).(Instance) + req = UnsafeRTSPMessageFromGlibNone(unsafe.Pointer(carg1)) + + goret = overrides.BeforeSend(ext, req) + + cret = C.GstRTSPResult(goret) + + return cret + }, + ) } if overrides.ConfigureStream != nil { pclass.configure_stream = (*[0]byte)(C._gotk4_gstrtsp1_RTSPExtension_configure_stream) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstrtsp1_RTSPExtension_configure_stream", + func(carg0 *C.GstRTSPExtension, carg1 *C.GstCaps) (cret C.gboolean) { + var ext Instance // go GstRTSPExtension subclass + var caps *gst.Caps // in, none, converted + var goret bool // return + + ext = UnsafeRTSPExtensionFromGlibNone(unsafe.Pointer(carg0)).(Instance) + caps = gst.UnsafeCapsFromGlibNone(unsafe.Pointer(carg1)) + + goret = overrides.ConfigureStream(ext, caps) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.DetectServer != nil { pclass.detect_server = (*[0]byte)(C._gotk4_gstrtsp1_RTSPExtension_detect_server) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstrtsp1_RTSPExtension_detect_server", + func(carg0 *C.GstRTSPExtension, carg1 *C.GstRTSPMessage) (cret C.gboolean) { + var ext Instance // go GstRTSPExtension subclass + var resp *RTSPMessage // in, none, converted + var goret bool // return + + ext = UnsafeRTSPExtensionFromGlibNone(unsafe.Pointer(carg0)).(Instance) + resp = UnsafeRTSPMessageFromGlibNone(unsafe.Pointer(carg1)) + + goret = overrides.DetectServer(ext, resp) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.ParseSdp != nil { pclass.parse_sdp = (*[0]byte)(C._gotk4_gstrtsp1_RTSPExtension_parse_sdp) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstrtsp1_RTSPExtension_parse_sdp", + func(carg0 *C.GstRTSPExtension, carg1 *C.GstSDPMessage, carg2 *C.GstStructure) (cret C.GstRTSPResult) { + var ext Instance // go GstRTSPExtension subclass + var sdp *gstsdp.SDPMessage // in, none, converted + var s *gst.Structure // in, none, converted + var goret RTSPResult // return, none, casted + + ext = UnsafeRTSPExtensionFromGlibNone(unsafe.Pointer(carg0)).(Instance) + sdp = gstsdp.UnsafeSDPMessageFromGlibNone(unsafe.Pointer(carg1)) + s = gst.UnsafeStructureFromGlibNone(unsafe.Pointer(carg2)) + + goret = overrides.ParseSdp(ext, sdp, s) + + cret = C.GstRTSPResult(goret) + + return cret + }, + ) } if overrides.ReceiveRequest != nil { pclass.receive_request = (*[0]byte)(C._gotk4_gstrtsp1_RTSPExtension_receive_request) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstrtsp1_RTSPExtension_receive_request", + func(carg0 *C.GstRTSPExtension, carg1 *C.GstRTSPMessage) (cret C.GstRTSPResult) { + var ext Instance // go GstRTSPExtension subclass + var req *RTSPMessage // in, none, converted + var goret RTSPResult // return, none, casted + + ext = UnsafeRTSPExtensionFromGlibNone(unsafe.Pointer(carg0)).(Instance) + req = UnsafeRTSPMessageFromGlibNone(unsafe.Pointer(carg1)) + + goret = overrides.ReceiveRequest(ext, req) + + cret = C.GstRTSPResult(goret) + + return cret + }, + ) } if overrides.Send != nil { pclass.send = (*[0]byte)(C._gotk4_gstrtsp1_RTSPExtension_send) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstrtsp1_RTSPExtension_send", + func(carg0 *C.GstRTSPExtension, carg1 *C.GstRTSPMessage, carg2 *C.GstRTSPMessage) (cret C.GstRTSPResult) { + var ext Instance // go GstRTSPExtension subclass + var req *RTSPMessage // in, none, converted + var resp *RTSPMessage // in, none, converted + var goret RTSPResult // return, none, casted + + ext = UnsafeRTSPExtensionFromGlibNone(unsafe.Pointer(carg0)).(Instance) + req = UnsafeRTSPMessageFromGlibNone(unsafe.Pointer(carg1)) + resp = UnsafeRTSPMessageFromGlibNone(unsafe.Pointer(carg2)) + + goret = overrides.Send(ext, req, resp) + + cret = C.GstRTSPResult(goret) + + return cret + }, + ) } if overrides.SetupMedia != nil { pclass.setup_media = (*[0]byte)(C._gotk4_gstrtsp1_RTSPExtension_setup_media) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstrtsp1_RTSPExtension_setup_media", + func(carg0 *C.GstRTSPExtension, carg1 *C.GstSDPMedia) (cret C.GstRTSPResult) { + var ext Instance // go GstRTSPExtension subclass + var media *gstsdp.SDPMedia // in, none, converted + var goret RTSPResult // return, none, casted + + ext = UnsafeRTSPExtensionFromGlibNone(unsafe.Pointer(carg0)).(Instance) + media = gstsdp.UnsafeSDPMediaFromGlibNone(unsafe.Pointer(carg1)) + + goret = overrides.SetupMedia(ext, media) + + cret = C.GstRTSPResult(goret) + + return cret + }, + ) } if overrides.StreamSelect != nil { pclass.stream_select = (*[0]byte)(C._gotk4_gstrtsp1_RTSPExtension_stream_select) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstrtsp1_RTSPExtension_stream_select", + func(carg0 *C.GstRTSPExtension, carg1 *C.GstRTSPUrl) (cret C.GstRTSPResult) { + var ext Instance // go GstRTSPExtension subclass + var url *RTSPUrl // in, none, converted + var goret RTSPResult // return, none, casted + + ext = UnsafeRTSPExtensionFromGlibNone(unsafe.Pointer(carg0)).(Instance) + url = UnsafeRTSPUrlFromGlibNone(unsafe.Pointer(carg1)) + + goret = overrides.StreamSelect(ext, url) + + cret = C.GstRTSPResult(goret) + + return cret + }, + ) } } diff --git a/pkg/gstrtsp/gstrtsp_export.gen.go b/pkg/gstrtsp/gstrtsp_export.gen.go index 0066989..0909566 100644 --- a/pkg/gstrtsp/gstrtsp_export.gen.go +++ b/pkg/gstrtsp/gstrtsp_export.gen.go @@ -5,6 +5,7 @@ package gstrtsp import ( "unsafe" + "github.com/diamondburned/gotk4/pkg/core/classdata" "github.com/diamondburned/gotk4/pkg/core/userdata" "github.com/diamondburned/gotk4/pkg/gio/v2" ) @@ -43,46 +44,109 @@ func _gotk4_gstrtsp1_RTSPConnectionAcceptCertificateFunc(carg1 *C.GTlsConnection //export _gotk4_gstrtsp1_RTSPExtension_after_send func _gotk4_gstrtsp1_RTSPExtension_after_send(carg0 *C.GstRTSPExtension, carg1 *C.GstRTSPMessage, carg2 *C.GstRTSPMessage) (cret C.GstRTSPResult) { - panic("unimplemented") + var fn func(carg0 *C.GstRTSPExtension, carg1 *C.GstRTSPMessage, carg2 *C.GstRTSPMessage) (cret C.GstRTSPResult) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstrtsp1_RTSPExtension_after_send").(func(carg0 *C.GstRTSPExtension, carg1 *C.GstRTSPMessage, carg2 *C.GstRTSPMessage) (cret C.GstRTSPResult)) + if fn == nil { + panic("_gotk4_gstrtsp1_RTSPExtension_after_send: no function pointer found") + } + } + return fn(carg0, carg1, carg2) } //export _gotk4_gstrtsp1_RTSPExtension_before_send func _gotk4_gstrtsp1_RTSPExtension_before_send(carg0 *C.GstRTSPExtension, carg1 *C.GstRTSPMessage) (cret C.GstRTSPResult) { - panic("unimplemented") + var fn func(carg0 *C.GstRTSPExtension, carg1 *C.GstRTSPMessage) (cret C.GstRTSPResult) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstrtsp1_RTSPExtension_before_send").(func(carg0 *C.GstRTSPExtension, carg1 *C.GstRTSPMessage) (cret C.GstRTSPResult)) + if fn == nil { + panic("_gotk4_gstrtsp1_RTSPExtension_before_send: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstrtsp1_RTSPExtension_configure_stream func _gotk4_gstrtsp1_RTSPExtension_configure_stream(carg0 *C.GstRTSPExtension, carg1 *C.GstCaps) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstRTSPExtension, carg1 *C.GstCaps) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstrtsp1_RTSPExtension_configure_stream").(func(carg0 *C.GstRTSPExtension, carg1 *C.GstCaps) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstrtsp1_RTSPExtension_configure_stream: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstrtsp1_RTSPExtension_detect_server func _gotk4_gstrtsp1_RTSPExtension_detect_server(carg0 *C.GstRTSPExtension, carg1 *C.GstRTSPMessage) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstRTSPExtension, carg1 *C.GstRTSPMessage) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstrtsp1_RTSPExtension_detect_server").(func(carg0 *C.GstRTSPExtension, carg1 *C.GstRTSPMessage) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstrtsp1_RTSPExtension_detect_server: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstrtsp1_RTSPExtension_parse_sdp func _gotk4_gstrtsp1_RTSPExtension_parse_sdp(carg0 *C.GstRTSPExtension, carg1 *C.GstSDPMessage, carg2 *C.GstStructure) (cret C.GstRTSPResult) { - panic("unimplemented") + var fn func(carg0 *C.GstRTSPExtension, carg1 *C.GstSDPMessage, carg2 *C.GstStructure) (cret C.GstRTSPResult) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstrtsp1_RTSPExtension_parse_sdp").(func(carg0 *C.GstRTSPExtension, carg1 *C.GstSDPMessage, carg2 *C.GstStructure) (cret C.GstRTSPResult)) + if fn == nil { + panic("_gotk4_gstrtsp1_RTSPExtension_parse_sdp: no function pointer found") + } + } + return fn(carg0, carg1, carg2) } //export _gotk4_gstrtsp1_RTSPExtension_receive_request func _gotk4_gstrtsp1_RTSPExtension_receive_request(carg0 *C.GstRTSPExtension, carg1 *C.GstRTSPMessage) (cret C.GstRTSPResult) { - panic("unimplemented") + var fn func(carg0 *C.GstRTSPExtension, carg1 *C.GstRTSPMessage) (cret C.GstRTSPResult) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstrtsp1_RTSPExtension_receive_request").(func(carg0 *C.GstRTSPExtension, carg1 *C.GstRTSPMessage) (cret C.GstRTSPResult)) + if fn == nil { + panic("_gotk4_gstrtsp1_RTSPExtension_receive_request: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstrtsp1_RTSPExtension_send func _gotk4_gstrtsp1_RTSPExtension_send(carg0 *C.GstRTSPExtension, carg1 *C.GstRTSPMessage, carg2 *C.GstRTSPMessage) (cret C.GstRTSPResult) { - panic("unimplemented") + var fn func(carg0 *C.GstRTSPExtension, carg1 *C.GstRTSPMessage, carg2 *C.GstRTSPMessage) (cret C.GstRTSPResult) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstrtsp1_RTSPExtension_send").(func(carg0 *C.GstRTSPExtension, carg1 *C.GstRTSPMessage, carg2 *C.GstRTSPMessage) (cret C.GstRTSPResult)) + if fn == nil { + panic("_gotk4_gstrtsp1_RTSPExtension_send: no function pointer found") + } + } + return fn(carg0, carg1, carg2) } //export _gotk4_gstrtsp1_RTSPExtension_setup_media func _gotk4_gstrtsp1_RTSPExtension_setup_media(carg0 *C.GstRTSPExtension, carg1 *C.GstSDPMedia) (cret C.GstRTSPResult) { - panic("unimplemented") + var fn func(carg0 *C.GstRTSPExtension, carg1 *C.GstSDPMedia) (cret C.GstRTSPResult) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstrtsp1_RTSPExtension_setup_media").(func(carg0 *C.GstRTSPExtension, carg1 *C.GstSDPMedia) (cret C.GstRTSPResult)) + if fn == nil { + panic("_gotk4_gstrtsp1_RTSPExtension_setup_media: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstrtsp1_RTSPExtension_stream_select func _gotk4_gstrtsp1_RTSPExtension_stream_select(carg0 *C.GstRTSPExtension, carg1 *C.GstRTSPUrl) (cret C.GstRTSPResult) { - panic("unimplemented") + var fn func(carg0 *C.GstRTSPExtension, carg1 *C.GstRTSPUrl) (cret C.GstRTSPResult) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstrtsp1_RTSPExtension_stream_select").(func(carg0 *C.GstRTSPExtension, carg1 *C.GstRTSPUrl) (cret C.GstRTSPResult)) + if fn == nil { + panic("_gotk4_gstrtsp1_RTSPExtension_stream_select: no function pointer found") + } + } + return fn(carg0, carg1) } diff --git a/pkg/gsttag/gsttag.gen.go b/pkg/gsttag/gsttag.gen.go index 641018f..2d812a6 100644 --- a/pkg/gsttag/gsttag.gen.go +++ b/pkg/gsttag/gsttag.gen.go @@ -8,6 +8,7 @@ import ( "strings" "unsafe" + "github.com/diamondburned/gotk4/pkg/core/classdata" "github.com/diamondburned/gotk4/pkg/glib/v2" "github.com/diamondburned/gotk4/pkg/gobject/v2" "github.com/go-gst/go-gst/pkg/gst" @@ -2122,13 +2123,87 @@ func UnsafeApplyTagDemuxOverrides[Instance TagDemux](gclass unsafe.Pointer, over if overrides.IdentifyTag != nil { pclass.identify_tag = (*[0]byte)(C._gotk4_gsttag1_TagDemux_identify_tag) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gsttag1_TagDemux_identify_tag", + func(carg0 *C.GstTagDemux, carg1 *C.GstBuffer, carg2 C.gboolean, carg3 *C.guint) (cret C.gboolean) { + var demux Instance // go GstTagDemux subclass + var buffer *gst.Buffer // in, none, converted + var startTag bool // in + var tagSize *uint // in, transfer: none, C Pointers: 1, Name: guint + var goret bool // return + + demux = UnsafeTagDemuxFromGlibNone(unsafe.Pointer(carg0)).(Instance) + buffer = gst.UnsafeBufferFromGlibNone(unsafe.Pointer(carg1)) + if carg2 != 0 { + startTag = true + } + _ = tagSize + _ = carg3 + panic("unimplemented conversion of *uint (guint*)") + + goret = overrides.IdentifyTag(demux, buffer, startTag, tagSize) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.MergeTags != nil { pclass.merge_tags = (*[0]byte)(C._gotk4_gsttag1_TagDemux_merge_tags) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gsttag1_TagDemux_merge_tags", + func(carg0 *C.GstTagDemux, carg1 *C.GstTagList, carg2 *C.GstTagList) (cret *C.GstTagList) { + var demux Instance // go GstTagDemux subclass + var startTags *gst.TagList // in, none, converted + var endTags *gst.TagList // in, none, converted + var goret *gst.TagList // return, full, converted + + demux = UnsafeTagDemuxFromGlibNone(unsafe.Pointer(carg0)).(Instance) + startTags = gst.UnsafeTagListFromGlibNone(unsafe.Pointer(carg1)) + endTags = gst.UnsafeTagListFromGlibNone(unsafe.Pointer(carg2)) + + goret = overrides.MergeTags(demux, startTags, endTags) + + cret = (*C.GstTagList)(gst.UnsafeTagListToGlibFull(goret)) + + return cret + }, + ) } } +// RegisterTagDemuxSubClass is used to register a go subclass of GstTagDemux. For this to work safely please implement the +// virtual methods required by the implementation. +func RegisterTagDemuxSubClass[InstanceT TagDemux]( + name string, + classInit func(class *TagDemuxClass), + constructor func() InstanceT, + overrides TagDemuxOverrides[InstanceT], + signals map[string]gobject.SignalDefinition, + interfaceInits ...gobject.SubClassInterfaceInit[InstanceT], +) gobject.Type { + return gobject.UnsafeRegisterSubClass( + name, + classInit, + constructor, + overrides, + signals, + TypeTagDemux, + UnsafeTagDemuxClassFromGlibBorrow, + UnsafeApplyTagDemuxOverrides, + func (obj *gobject.ObjectInstance) gobject.Object { + return unsafeWrapTagDemux(obj) + }, + interfaceInits..., + ) +} + // TagMuxInstance is the instance type used by all types extending GstTagMux. It is used internally by the bindings. Users should use the interface [TagMux] instead. type TagMuxInstance struct { _ [0]func() // equal guard @@ -2239,13 +2314,75 @@ func UnsafeApplyTagMuxOverrides[Instance TagMux](gclass unsafe.Pointer, override if overrides.RenderEndTag != nil { pclass.render_end_tag = (*[0]byte)(C._gotk4_gsttag1_TagMux_render_end_tag) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gsttag1_TagMux_render_end_tag", + func(carg0 *C.GstTagMux, carg1 *C.GstTagList) (cret *C.GstBuffer) { + var mux Instance // go GstTagMux subclass + var tagList *gst.TagList // in, none, converted + var goret *gst.Buffer // return, full, converted + + mux = UnsafeTagMuxFromGlibNone(unsafe.Pointer(carg0)).(Instance) + tagList = gst.UnsafeTagListFromGlibNone(unsafe.Pointer(carg1)) + + goret = overrides.RenderEndTag(mux, tagList) + + cret = (*C.GstBuffer)(gst.UnsafeBufferToGlibFull(goret)) + + return cret + }, + ) } if overrides.RenderStartTag != nil { pclass.render_start_tag = (*[0]byte)(C._gotk4_gsttag1_TagMux_render_start_tag) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gsttag1_TagMux_render_start_tag", + func(carg0 *C.GstTagMux, carg1 *C.GstTagList) (cret *C.GstBuffer) { + var mux Instance // go GstTagMux subclass + var tagList *gst.TagList // in, none, converted + var goret *gst.Buffer // return, full, converted + + mux = UnsafeTagMuxFromGlibNone(unsafe.Pointer(carg0)).(Instance) + tagList = gst.UnsafeTagListFromGlibNone(unsafe.Pointer(carg1)) + + goret = overrides.RenderStartTag(mux, tagList) + + cret = (*C.GstBuffer)(gst.UnsafeBufferToGlibFull(goret)) + + return cret + }, + ) } } +// RegisterTagMuxSubClass is used to register a go subclass of GstTagMux. For this to work safely please implement the +// virtual methods required by the implementation. +func RegisterTagMuxSubClass[InstanceT TagMux]( + name string, + classInit func(class *TagMuxClass), + constructor func() InstanceT, + overrides TagMuxOverrides[InstanceT], + signals map[string]gobject.SignalDefinition, + interfaceInits ...gobject.SubClassInterfaceInit[InstanceT], +) gobject.Type { + return gobject.UnsafeRegisterSubClass( + name, + classInit, + constructor, + overrides, + signals, + TypeTagMux, + UnsafeTagMuxClassFromGlibBorrow, + UnsafeApplyTagMuxOverrides, + func (obj *gobject.ObjectInstance) gobject.Object { + return unsafeWrapTagMux(obj) + }, + interfaceInits..., + ) +} + // TagDemuxClass wraps GstTagDemuxClass // // The #GstTagDemuxClass structure. See documentation at beginning of section diff --git a/pkg/gsttag/gsttag_export.gen.go b/pkg/gsttag/gsttag_export.gen.go index 9fa36a3..f3160c8 100644 --- a/pkg/gsttag/gsttag_export.gen.go +++ b/pkg/gsttag/gsttag_export.gen.go @@ -2,27 +2,60 @@ package gsttag +import ( + "unsafe" + + "github.com/diamondburned/gotk4/pkg/core/classdata" +) // #include import "C" //export _gotk4_gsttag1_TagDemux_identify_tag func _gotk4_gsttag1_TagDemux_identify_tag(carg0 *C.GstTagDemux, carg1 *C.GstBuffer, carg2 C.gboolean, carg3 *C.guint) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstTagDemux, carg1 *C.GstBuffer, carg2 C.gboolean, carg3 *C.guint) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gsttag1_TagDemux_identify_tag").(func(carg0 *C.GstTagDemux, carg1 *C.GstBuffer, carg2 C.gboolean, carg3 *C.guint) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gsttag1_TagDemux_identify_tag: no function pointer found") + } + } + return fn(carg0, carg1, carg2, carg3) } //export _gotk4_gsttag1_TagDemux_merge_tags func _gotk4_gsttag1_TagDemux_merge_tags(carg0 *C.GstTagDemux, carg1 *C.GstTagList, carg2 *C.GstTagList) (cret *C.GstTagList) { - panic("unimplemented") + var fn func(carg0 *C.GstTagDemux, carg1 *C.GstTagList, carg2 *C.GstTagList) (cret *C.GstTagList) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gsttag1_TagDemux_merge_tags").(func(carg0 *C.GstTagDemux, carg1 *C.GstTagList, carg2 *C.GstTagList) (cret *C.GstTagList)) + if fn == nil { + panic("_gotk4_gsttag1_TagDemux_merge_tags: no function pointer found") + } + } + return fn(carg0, carg1, carg2) } //export _gotk4_gsttag1_TagMux_render_end_tag func _gotk4_gsttag1_TagMux_render_end_tag(carg0 *C.GstTagMux, carg1 *C.GstTagList) (cret *C.GstBuffer) { - panic("unimplemented") + var fn func(carg0 *C.GstTagMux, carg1 *C.GstTagList) (cret *C.GstBuffer) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gsttag1_TagMux_render_end_tag").(func(carg0 *C.GstTagMux, carg1 *C.GstTagList) (cret *C.GstBuffer)) + if fn == nil { + panic("_gotk4_gsttag1_TagMux_render_end_tag: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gsttag1_TagMux_render_start_tag func _gotk4_gsttag1_TagMux_render_start_tag(carg0 *C.GstTagMux, carg1 *C.GstTagList) (cret *C.GstBuffer) { - panic("unimplemented") + var fn func(carg0 *C.GstTagMux, carg1 *C.GstTagList) (cret *C.GstBuffer) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gsttag1_TagMux_render_start_tag").(func(carg0 *C.GstTagMux, carg1 *C.GstTagList) (cret *C.GstBuffer)) + if fn == nil { + panic("_gotk4_gsttag1_TagMux_render_start_tag: no function pointer found") + } + } + return fn(carg0, carg1) } diff --git a/pkg/gstvideo/gstvideo.gen.go b/pkg/gstvideo/gstvideo.gen.go index cc97588..6ccabe4 100644 --- a/pkg/gstvideo/gstvideo.gen.go +++ b/pkg/gstvideo/gstvideo.gen.go @@ -8,6 +8,7 @@ import ( "strings" "unsafe" + "github.com/diamondburned/gotk4/pkg/core/classdata" "github.com/diamondburned/gotk4/pkg/core/userdata" "github.com/diamondburned/gotk4/pkg/glib/v2" "github.com/diamondburned/gotk4/pkg/gobject/v2" @@ -8101,22 +8102,104 @@ func UnsafeApplyColorBalanceOverrides[Instance ColorBalance](gclass unsafe.Point if overrides.GetBalanceType != nil { pclass.get_balance_type = (*[0]byte)(C._gotk4_gstvideo1_ColorBalance_get_balance_type) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstvideo1_ColorBalance_get_balance_type", + func(carg0 *C.GstColorBalance) (cret C.GstColorBalanceType) { + var balance Instance // go GstColorBalance subclass + var goret ColorBalanceType // return, none, casted + + balance = UnsafeColorBalanceFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + goret = overrides.GetBalanceType(balance) + + cret = C.GstColorBalanceType(goret) + + return cret + }, + ) } if overrides.GetValue != nil { pclass.get_value = (*[0]byte)(C._gotk4_gstvideo1_ColorBalance_get_value) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstvideo1_ColorBalance_get_value", + func(carg0 *C.GstColorBalance, carg1 *C.GstColorBalanceChannel) (cret C.gint) { + var balance Instance // go GstColorBalance subclass + var channel ColorBalanceChannel // in, none, converted + var goret int // return, none, casted + + balance = UnsafeColorBalanceFromGlibNone(unsafe.Pointer(carg0)).(Instance) + channel = UnsafeColorBalanceChannelFromGlibNone(unsafe.Pointer(carg1)) + + goret = overrides.GetValue(balance, channel) + + cret = C.gint(goret) + + return cret + }, + ) } if overrides.ListChannels != nil { pclass.list_channels = (*[0]byte)(C._gotk4_gstvideo1_ColorBalance_list_channels) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstvideo1_ColorBalance_list_channels", + func(carg0 *C.GstColorBalance) (cret *C.GList) { + var balance Instance // go GstColorBalance subclass + var goret []ColorBalanceChannel // return, transfer: none, C Pointers: 1, Name: List, scope: + + balance = UnsafeColorBalanceFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + goret = overrides.ListChannels(balance) + + _ = goret + _ = cret + panic("unimplemented conversion of []ColorBalanceChannel (GList*)") + + return cret + }, + ) } if overrides.SetValue != nil { pclass.set_value = (*[0]byte)(C._gotk4_gstvideo1_ColorBalance_set_value) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstvideo1_ColorBalance_set_value", + func(carg0 *C.GstColorBalance, carg1 *C.GstColorBalanceChannel, carg2 C.gint) { + var balance Instance // go GstColorBalance subclass + var channel ColorBalanceChannel // in, none, converted + var value int // in, none, casted + + balance = UnsafeColorBalanceFromGlibNone(unsafe.Pointer(carg0)).(Instance) + channel = UnsafeColorBalanceChannelFromGlibNone(unsafe.Pointer(carg1)) + value = int(carg2) + + overrides.SetValue(balance, channel, value) + }, + ) } if overrides.ValueChanged != nil { pclass.value_changed = (*[0]byte)(C._gotk4_gstvideo1_ColorBalance_value_changed) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstvideo1_ColorBalance_value_changed", + func(carg0 *C.GstColorBalance, carg1 *C.GstColorBalanceChannel, carg2 C.gint) { + var balance Instance // go GstColorBalance subclass + var channel ColorBalanceChannel // in, none, converted + var value int // in, none, casted + + balance = UnsafeColorBalanceFromGlibNone(unsafe.Pointer(carg0)).(Instance) + channel = UnsafeColorBalanceChannelFromGlibNone(unsafe.Pointer(carg1)) + value = int(carg2) + + overrides.ValueChanged(balance, channel, value) + }, + ) } } @@ -9796,10 +9879,36 @@ func UnsafeApplyNavigationOverrides[Instance Navigation](gclass unsafe.Pointer, if overrides.SendEvent != nil { pclass.send_event = (*[0]byte)(C._gotk4_gstvideo1_Navigation_send_event) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstvideo1_Navigation_send_event", + func(carg0 *C.GstNavigation, carg1 *C.GstStructure) { + var navigation Instance // go GstNavigation subclass + var structure *gst.Structure // in, none, converted + + navigation = UnsafeNavigationFromGlibNone(unsafe.Pointer(carg0)).(Instance) + structure = gst.UnsafeStructureFromGlibNone(unsafe.Pointer(carg1)) + + overrides.SendEvent(navigation, structure) + }, + ) } if overrides.SendEventSimple != nil { pclass.send_event_simple = (*[0]byte)(C._gotk4_gstvideo1_Navigation_send_event_simple) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstvideo1_Navigation_send_event_simple", + func(carg0 *C.GstNavigation, carg1 *C.GstEvent) { + var navigation Instance // go GstNavigation subclass + var event *gst.Event // in, full, converted + + navigation = UnsafeNavigationFromGlibNone(unsafe.Pointer(carg0)).(Instance) + event = gst.UnsafeEventFromGlibFull(unsafe.Pointer(carg1)) + + overrides.SendEventSimple(navigation, event) + }, + ) } } @@ -10364,34 +10473,202 @@ func UnsafeApplyVideoOrientationOverrides[Instance VideoOrientation](gclass unsa if overrides.GetHcenter != nil { pclass.get_hcenter = (*[0]byte)(C._gotk4_gstvideo1_VideoOrientation_get_hcenter) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstvideo1_VideoOrientation_get_hcenter", + func(carg0 *C.GstVideoOrientation, carg1 *C.gint) (cret C.gboolean) { + var videoOrientation Instance // go GstVideoOrientation subclass + var center int // out, full, casted + var goret bool // return + + videoOrientation = UnsafeVideoOrientationFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + center, goret = overrides.GetHcenter(videoOrientation) + + *carg1 = C.gint(center) + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.GetHflip != nil { pclass.get_hflip = (*[0]byte)(C._gotk4_gstvideo1_VideoOrientation_get_hflip) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstvideo1_VideoOrientation_get_hflip", + func(carg0 *C.GstVideoOrientation, carg1 *C.gboolean) (cret C.gboolean) { + var videoOrientation Instance // go GstVideoOrientation subclass + var flip bool // out + var goret bool // return + + videoOrientation = UnsafeVideoOrientationFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + flip, goret = overrides.GetHflip(videoOrientation) + + if flip { + carg1 = C.TRUE + } + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.GetVcenter != nil { pclass.get_vcenter = (*[0]byte)(C._gotk4_gstvideo1_VideoOrientation_get_vcenter) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstvideo1_VideoOrientation_get_vcenter", + func(carg0 *C.GstVideoOrientation, carg1 *C.gint) (cret C.gboolean) { + var videoOrientation Instance // go GstVideoOrientation subclass + var center int // out, full, casted + var goret bool // return + + videoOrientation = UnsafeVideoOrientationFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + center, goret = overrides.GetVcenter(videoOrientation) + + *carg1 = C.gint(center) + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.GetVflip != nil { pclass.get_vflip = (*[0]byte)(C._gotk4_gstvideo1_VideoOrientation_get_vflip) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstvideo1_VideoOrientation_get_vflip", + func(carg0 *C.GstVideoOrientation, carg1 *C.gboolean) (cret C.gboolean) { + var videoOrientation Instance // go GstVideoOrientation subclass + var flip bool // out + var goret bool // return + + videoOrientation = UnsafeVideoOrientationFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + flip, goret = overrides.GetVflip(videoOrientation) + + if flip { + carg1 = C.TRUE + } + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.SetHcenter != nil { pclass.set_hcenter = (*[0]byte)(C._gotk4_gstvideo1_VideoOrientation_set_hcenter) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstvideo1_VideoOrientation_set_hcenter", + func(carg0 *C.GstVideoOrientation, carg1 C.gint) (cret C.gboolean) { + var videoOrientation Instance // go GstVideoOrientation subclass + var center int // in, none, casted + var goret bool // return + + videoOrientation = UnsafeVideoOrientationFromGlibNone(unsafe.Pointer(carg0)).(Instance) + center = int(carg1) + + goret = overrides.SetHcenter(videoOrientation, center) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.SetHflip != nil { pclass.set_hflip = (*[0]byte)(C._gotk4_gstvideo1_VideoOrientation_set_hflip) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstvideo1_VideoOrientation_set_hflip", + func(carg0 *C.GstVideoOrientation, carg1 C.gboolean) (cret C.gboolean) { + var videoOrientation Instance // go GstVideoOrientation subclass + var flip bool // in + var goret bool // return + + videoOrientation = UnsafeVideoOrientationFromGlibNone(unsafe.Pointer(carg0)).(Instance) + if carg1 != 0 { + flip = true + } + + goret = overrides.SetHflip(videoOrientation, flip) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.SetVcenter != nil { pclass.set_vcenter = (*[0]byte)(C._gotk4_gstvideo1_VideoOrientation_set_vcenter) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstvideo1_VideoOrientation_set_vcenter", + func(carg0 *C.GstVideoOrientation, carg1 C.gint) (cret C.gboolean) { + var videoOrientation Instance // go GstVideoOrientation subclass + var center int // in, none, casted + var goret bool // return + + videoOrientation = UnsafeVideoOrientationFromGlibNone(unsafe.Pointer(carg0)).(Instance) + center = int(carg1) + + goret = overrides.SetVcenter(videoOrientation, center) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.SetVflip != nil { pclass.set_vflip = (*[0]byte)(C._gotk4_gstvideo1_VideoOrientation_set_vflip) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstvideo1_VideoOrientation_set_vflip", + func(carg0 *C.GstVideoOrientation, carg1 C.gboolean) (cret C.gboolean) { + var videoOrientation Instance // go GstVideoOrientation subclass + var flip bool // in + var goret bool // return + + videoOrientation = UnsafeVideoOrientationFromGlibNone(unsafe.Pointer(carg0)).(Instance) + if carg1 != 0 { + flip = true + } + + goret = overrides.SetVflip(videoOrientation, flip) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } } @@ -10935,14 +11212,59 @@ func UnsafeApplyVideoOverlayOverrides[Instance VideoOverlay](gclass unsafe.Point if overrides.Expose != nil { pclass.expose = (*[0]byte)(C._gotk4_gstvideo1_VideoOverlay_expose) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstvideo1_VideoOverlay_expose", + func(carg0 *C.GstVideoOverlay) { + var overlay Instance // go GstVideoOverlay subclass + + overlay = UnsafeVideoOverlayFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + overrides.Expose(overlay) + }, + ) } if overrides.HandleEvents != nil { pclass.handle_events = (*[0]byte)(C._gotk4_gstvideo1_VideoOverlay_handle_events) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstvideo1_VideoOverlay_handle_events", + func(carg0 *C.GstVideoOverlay, carg1 C.gboolean) { + var overlay Instance // go GstVideoOverlay subclass + var handleEvents bool // in + + overlay = UnsafeVideoOverlayFromGlibNone(unsafe.Pointer(carg0)).(Instance) + if carg1 != 0 { + handleEvents = true + } + + overrides.HandleEvents(overlay, handleEvents) + }, + ) } if overrides.SetRenderRectangle != nil { pclass.set_render_rectangle = (*[0]byte)(C._gotk4_gstvideo1_VideoOverlay_set_render_rectangle) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstvideo1_VideoOverlay_set_render_rectangle", + func(carg0 *C.GstVideoOverlay, carg1 C.gint, carg2 C.gint, carg3 C.gint, carg4 C.gint) { + var overlay Instance // go GstVideoOverlay subclass + var x int // in, none, casted + var y int // in, none, casted + var width int // in, none, casted + var height int // in, none, casted + + overlay = UnsafeVideoOverlayFromGlibNone(unsafe.Pointer(carg0)).(Instance) + x = int(carg1) + y = int(carg2) + width = int(carg3) + height = int(carg4) + + overrides.SetRenderRectangle(overlay, x, y, width, height) + }, + ) } } @@ -11032,9 +11354,48 @@ func UnsafeApplyColorBalanceChannelOverrides[Instance ColorBalanceChannel](gclas if overrides.ValueChanged != nil { pclass.value_changed = (*[0]byte)(C._gotk4_gstvideo1_ColorBalanceChannel_value_changed) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstvideo1_ColorBalanceChannel_value_changed", + func(carg0 *C.GstColorBalanceChannel, carg1 C.gint) { + var channel Instance // go GstColorBalanceChannel subclass + var value int // in, none, casted + + channel = UnsafeColorBalanceChannelFromGlibNone(unsafe.Pointer(carg0)).(Instance) + value = int(carg1) + + overrides.ValueChanged(channel, value) + }, + ) } } +// RegisterColorBalanceChannelSubClass is used to register a go subclass of GstColorBalanceChannel. For this to work safely please implement the +// virtual methods required by the implementation. +func RegisterColorBalanceChannelSubClass[InstanceT ColorBalanceChannel]( + name string, + classInit func(class *ColorBalanceChannelClass), + constructor func() InstanceT, + overrides ColorBalanceChannelOverrides[InstanceT], + signals map[string]gobject.SignalDefinition, + interfaceInits ...gobject.SubClassInterfaceInit[InstanceT], +) gobject.Type { + return gobject.UnsafeRegisterSubClass( + name, + classInit, + constructor, + overrides, + signals, + TypeColorBalanceChannel, + UnsafeColorBalanceChannelClassFromGlibBorrow, + UnsafeApplyColorBalanceChannelOverrides, + func (obj *gobject.ObjectInstance) gobject.Object { + return unsafeWrapColorBalanceChannel(obj) + }, + interfaceInits..., + ) +} + // VideoAggregatorInstance is the instance type used by all types extending GstVideoAggregator. It is used internally by the bindings. Users should use the interface [VideoAggregator] instead. type VideoAggregatorInstance struct { _ [0]func() // equal guard @@ -11186,17 +11547,99 @@ func UnsafeApplyVideoAggregatorOverrides[Instance VideoAggregator](gclass unsafe if overrides.AggregateFrames != nil { pclass.aggregate_frames = (*[0]byte)(C._gotk4_gstvideo1_VideoAggregator_aggregate_frames) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstvideo1_VideoAggregator_aggregate_frames", + func(carg0 *C.GstVideoAggregator, carg1 *C.GstBuffer) (cret C.GstFlowReturn) { + var videoaggregator Instance // go GstVideoAggregator subclass + var outbuffer *gst.Buffer // in, none, converted + var goret gst.FlowReturn // return, none, casted + + videoaggregator = UnsafeVideoAggregatorFromGlibNone(unsafe.Pointer(carg0)).(Instance) + outbuffer = gst.UnsafeBufferFromGlibNone(unsafe.Pointer(carg1)) + + goret = overrides.AggregateFrames(videoaggregator, outbuffer) + + cret = C.GstFlowReturn(goret) + + return cret + }, + ) } if overrides.FindBestFormat != nil { pclass.find_best_format = (*[0]byte)(C._gotk4_gstvideo1_VideoAggregator_find_best_format) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstvideo1_VideoAggregator_find_best_format", + func(carg0 *C.GstVideoAggregator, carg1 *C.GstCaps, carg2 *C.GstVideoInfo, carg3 *C.gboolean) { + var vagg Instance // go GstVideoAggregator subclass + var downstreamCaps *gst.Caps // in, none, converted + var bestInfo *VideoInfo // in, none, converted + var atLeastOneAlpha bool // out + + vagg = UnsafeVideoAggregatorFromGlibNone(unsafe.Pointer(carg0)).(Instance) + downstreamCaps = gst.UnsafeCapsFromGlibNone(unsafe.Pointer(carg1)) + bestInfo = UnsafeVideoInfoFromGlibNone(unsafe.Pointer(carg2)) + + atLeastOneAlpha = overrides.FindBestFormat(vagg, downstreamCaps, bestInfo) + + if atLeastOneAlpha { + carg3 = C.TRUE + } + }, + ) } if overrides.UpdateCaps != nil { pclass.update_caps = (*[0]byte)(C._gotk4_gstvideo1_VideoAggregator_update_caps) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstvideo1_VideoAggregator_update_caps", + func(carg0 *C.GstVideoAggregator, carg1 *C.GstCaps) (cret *C.GstCaps) { + var videoaggregator Instance // go GstVideoAggregator subclass + var caps *gst.Caps // in, none, converted + var goret *gst.Caps // return, full, converted + + videoaggregator = UnsafeVideoAggregatorFromGlibNone(unsafe.Pointer(carg0)).(Instance) + caps = gst.UnsafeCapsFromGlibNone(unsafe.Pointer(carg1)) + + goret = overrides.UpdateCaps(videoaggregator, caps) + + cret = (*C.GstCaps)(gst.UnsafeCapsToGlibFull(goret)) + + return cret + }, + ) } } +// RegisterVideoAggregatorSubClass is used to register a go subclass of GstVideoAggregator. For this to work safely please implement the +// virtual methods required by the implementation. +func RegisterVideoAggregatorSubClass[InstanceT VideoAggregator]( + name string, + classInit func(class *VideoAggregatorClass), + constructor func() InstanceT, + overrides VideoAggregatorOverrides[InstanceT], + signals map[string]gobject.SignalDefinition, + interfaceInits ...gobject.SubClassInterfaceInit[InstanceT], +) gobject.Type { + return gobject.UnsafeRegisterSubClass( + name, + classInit, + constructor, + overrides, + signals, + TypeVideoAggregator, + UnsafeVideoAggregatorClassFromGlibBorrow, + UnsafeApplyVideoAggregatorOverrides, + func (obj *gobject.ObjectInstance) gobject.Object { + return unsafeWrapVideoAggregator(obj) + }, + interfaceInits..., + ) +} + // VideoAggregatorPadInstance is the instance type used by all types extending GstVideoAggregatorPad. It is used internally by the bindings. Users should use the interface [VideoAggregatorPad] instead. type VideoAggregatorPadInstance struct { _ [0]func() // equal guard @@ -11463,25 +11906,133 @@ func UnsafeApplyVideoAggregatorPadOverrides[Instance VideoAggregatorPad](gclass if overrides.CleanFrame != nil { pclass.clean_frame = (*[0]byte)(C._gotk4_gstvideo1_VideoAggregatorPad_clean_frame) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstvideo1_VideoAggregatorPad_clean_frame", + func(carg0 *C.GstVideoAggregatorPad, carg1 *C.GstVideoAggregator, carg2 *C.GstVideoFrame) { + var pad Instance // go GstVideoAggregatorPad subclass + var videoaggregator VideoAggregator // in, none, converted + var preparedFrame *VideoFrame // in, none, converted + + pad = UnsafeVideoAggregatorPadFromGlibNone(unsafe.Pointer(carg0)).(Instance) + videoaggregator = UnsafeVideoAggregatorFromGlibNone(unsafe.Pointer(carg1)) + preparedFrame = UnsafeVideoFrameFromGlibNone(unsafe.Pointer(carg2)) + + overrides.CleanFrame(pad, videoaggregator, preparedFrame) + }, + ) } if overrides.PrepareFrame != nil { pclass.prepare_frame = (*[0]byte)(C._gotk4_gstvideo1_VideoAggregatorPad_prepare_frame) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstvideo1_VideoAggregatorPad_prepare_frame", + func(carg0 *C.GstVideoAggregatorPad, carg1 *C.GstVideoAggregator, carg2 *C.GstBuffer, carg3 *C.GstVideoFrame) (cret C.gboolean) { + var pad Instance // go GstVideoAggregatorPad subclass + var videoaggregator VideoAggregator // in, none, converted + var buffer *gst.Buffer // in, none, converted + var preparedFrame *VideoFrame // in, none, converted + var goret bool // return + + pad = UnsafeVideoAggregatorPadFromGlibNone(unsafe.Pointer(carg0)).(Instance) + videoaggregator = UnsafeVideoAggregatorFromGlibNone(unsafe.Pointer(carg1)) + buffer = gst.UnsafeBufferFromGlibNone(unsafe.Pointer(carg2)) + preparedFrame = UnsafeVideoFrameFromGlibNone(unsafe.Pointer(carg3)) + + goret = overrides.PrepareFrame(pad, videoaggregator, buffer, preparedFrame) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.PrepareFrameFinish != nil { pclass.prepare_frame_finish = (*[0]byte)(C._gotk4_gstvideo1_VideoAggregatorPad_prepare_frame_finish) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstvideo1_VideoAggregatorPad_prepare_frame_finish", + func(carg0 *C.GstVideoAggregatorPad, carg1 *C.GstVideoAggregator, carg2 *C.GstVideoFrame) { + var pad Instance // go GstVideoAggregatorPad subclass + var videoaggregator VideoAggregator // in, none, converted + var preparedFrame *VideoFrame // in, none, converted + + pad = UnsafeVideoAggregatorPadFromGlibNone(unsafe.Pointer(carg0)).(Instance) + videoaggregator = UnsafeVideoAggregatorFromGlibNone(unsafe.Pointer(carg1)) + preparedFrame = UnsafeVideoFrameFromGlibNone(unsafe.Pointer(carg2)) + + overrides.PrepareFrameFinish(pad, videoaggregator, preparedFrame) + }, + ) } if overrides.PrepareFrameStart != nil { pclass.prepare_frame_start = (*[0]byte)(C._gotk4_gstvideo1_VideoAggregatorPad_prepare_frame_start) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstvideo1_VideoAggregatorPad_prepare_frame_start", + func(carg0 *C.GstVideoAggregatorPad, carg1 *C.GstVideoAggregator, carg2 *C.GstBuffer, carg3 *C.GstVideoFrame) { + var pad Instance // go GstVideoAggregatorPad subclass + var videoaggregator VideoAggregator // in, none, converted + var buffer *gst.Buffer // in, none, converted + var preparedFrame *VideoFrame // in, none, converted + + pad = UnsafeVideoAggregatorPadFromGlibNone(unsafe.Pointer(carg0)).(Instance) + videoaggregator = UnsafeVideoAggregatorFromGlibNone(unsafe.Pointer(carg1)) + buffer = gst.UnsafeBufferFromGlibNone(unsafe.Pointer(carg2)) + preparedFrame = UnsafeVideoFrameFromGlibNone(unsafe.Pointer(carg3)) + + overrides.PrepareFrameStart(pad, videoaggregator, buffer, preparedFrame) + }, + ) } if overrides.UpdateConversionInfo != nil { pclass.update_conversion_info = (*[0]byte)(C._gotk4_gstvideo1_VideoAggregatorPad_update_conversion_info) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstvideo1_VideoAggregatorPad_update_conversion_info", + func(carg0 *C.GstVideoAggregatorPad) { + var pad Instance // go GstVideoAggregatorPad subclass + + pad = UnsafeVideoAggregatorPadFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + overrides.UpdateConversionInfo(pad) + }, + ) } } +// RegisterVideoAggregatorPadSubClass is used to register a go subclass of GstVideoAggregatorPad. For this to work safely please implement the +// virtual methods required by the implementation. +func RegisterVideoAggregatorPadSubClass[InstanceT VideoAggregatorPad]( + name string, + classInit func(class *VideoAggregatorPadClass), + constructor func() InstanceT, + overrides VideoAggregatorPadOverrides[InstanceT], + signals map[string]gobject.SignalDefinition, + interfaceInits ...gobject.SubClassInterfaceInit[InstanceT], +) gobject.Type { + return gobject.UnsafeRegisterSubClass( + name, + classInit, + constructor, + overrides, + signals, + TypeVideoAggregatorPad, + UnsafeVideoAggregatorPadClassFromGlibBorrow, + UnsafeApplyVideoAggregatorPadOverrides, + func (obj *gobject.ObjectInstance) gobject.Object { + return unsafeWrapVideoAggregatorPad(obj) + }, + interfaceInits..., + ) +} + // VideoBufferPoolInstance is the instance type used by all types extending GstVideoBufferPool. It is used internally by the bindings. Users should use the interface [VideoBufferPool] instead. type VideoBufferPoolInstance struct { _ [0]func() // equal guard @@ -11570,6 +12121,32 @@ func UnsafeApplyVideoBufferPoolOverrides[Instance VideoBufferPool](gclass unsafe gst.UnsafeApplyBufferPoolOverrides(gclass, overrides.BufferPoolOverrides) } +// RegisterVideoBufferPoolSubClass is used to register a go subclass of GstVideoBufferPool. For this to work safely please implement the +// virtual methods required by the implementation. +func RegisterVideoBufferPoolSubClass[InstanceT VideoBufferPool]( + name string, + classInit func(class *VideoBufferPoolClass), + constructor func() InstanceT, + overrides VideoBufferPoolOverrides[InstanceT], + signals map[string]gobject.SignalDefinition, + interfaceInits ...gobject.SubClassInterfaceInit[InstanceT], +) gobject.Type { + return gobject.UnsafeRegisterSubClass( + name, + classInit, + constructor, + overrides, + signals, + TypeVideoBufferPool, + UnsafeVideoBufferPoolClassFromGlibBorrow, + UnsafeApplyVideoBufferPoolOverrides, + func (obj *gobject.ObjectInstance) gobject.Object { + return unsafeWrapVideoBufferPool(obj) + }, + interfaceInits..., + ) +} + // VideoDecoderInstance is the instance type used by all types extending GstVideoDecoder. It is used internally by the bindings. Users should use the interface [VideoDecoder] instead. type VideoDecoderInstance struct { _ [0]func() // equal guard @@ -13742,89 +14319,521 @@ func UnsafeApplyVideoDecoderOverrides[Instance VideoDecoder](gclass unsafe.Point if overrides.Close != nil { pclass.close = (*[0]byte)(C._gotk4_gstvideo1_VideoDecoder_close) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstvideo1_VideoDecoder_close", + func(carg0 *C.GstVideoDecoder) (cret C.gboolean) { + var decoder Instance // go GstVideoDecoder subclass + var goret bool // return + + decoder = UnsafeVideoDecoderFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + goret = overrides.Close(decoder) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.DecideAllocation != nil { pclass.decide_allocation = (*[0]byte)(C._gotk4_gstvideo1_VideoDecoder_decide_allocation) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstvideo1_VideoDecoder_decide_allocation", + func(carg0 *C.GstVideoDecoder, carg1 *C.GstQuery) (cret C.gboolean) { + var decoder Instance // go GstVideoDecoder subclass + var query *gst.Query // in, none, converted + var goret bool // return + + decoder = UnsafeVideoDecoderFromGlibNone(unsafe.Pointer(carg0)).(Instance) + query = gst.UnsafeQueryFromGlibNone(unsafe.Pointer(carg1)) + + goret = overrides.DecideAllocation(decoder, query) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.Drain != nil { pclass.drain = (*[0]byte)(C._gotk4_gstvideo1_VideoDecoder_drain) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstvideo1_VideoDecoder_drain", + func(carg0 *C.GstVideoDecoder) (cret C.GstFlowReturn) { + var decoder Instance // go GstVideoDecoder subclass + var goret gst.FlowReturn // return, none, casted + + decoder = UnsafeVideoDecoderFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + goret = overrides.Drain(decoder) + + cret = C.GstFlowReturn(goret) + + return cret + }, + ) } if overrides.Finish != nil { pclass.finish = (*[0]byte)(C._gotk4_gstvideo1_VideoDecoder_finish) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstvideo1_VideoDecoder_finish", + func(carg0 *C.GstVideoDecoder) (cret C.GstFlowReturn) { + var decoder Instance // go GstVideoDecoder subclass + var goret gst.FlowReturn // return, none, casted + + decoder = UnsafeVideoDecoderFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + goret = overrides.Finish(decoder) + + cret = C.GstFlowReturn(goret) + + return cret + }, + ) } if overrides.Flush != nil { pclass.flush = (*[0]byte)(C._gotk4_gstvideo1_VideoDecoder_flush) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstvideo1_VideoDecoder_flush", + func(carg0 *C.GstVideoDecoder) (cret C.gboolean) { + var decoder Instance // go GstVideoDecoder subclass + var goret bool // return + + decoder = UnsafeVideoDecoderFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + goret = overrides.Flush(decoder) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.Getcaps != nil { pclass.getcaps = (*[0]byte)(C._gotk4_gstvideo1_VideoDecoder_getcaps) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstvideo1_VideoDecoder_getcaps", + func(carg0 *C.GstVideoDecoder, carg1 *C.GstCaps) (cret *C.GstCaps) { + var decoder Instance // go GstVideoDecoder subclass + var filter *gst.Caps // in, none, converted + var goret *gst.Caps // return, full, converted + + decoder = UnsafeVideoDecoderFromGlibNone(unsafe.Pointer(carg0)).(Instance) + filter = gst.UnsafeCapsFromGlibNone(unsafe.Pointer(carg1)) + + goret = overrides.Getcaps(decoder, filter) + + cret = (*C.GstCaps)(gst.UnsafeCapsToGlibFull(goret)) + + return cret + }, + ) } if overrides.HandleFrame != nil { pclass.handle_frame = (*[0]byte)(C._gotk4_gstvideo1_VideoDecoder_handle_frame) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstvideo1_VideoDecoder_handle_frame", + func(carg0 *C.GstVideoDecoder, carg1 *C.GstVideoCodecFrame) (cret C.GstFlowReturn) { + var decoder Instance // go GstVideoDecoder subclass + var frame *VideoCodecFrame // in, full, converted + var goret gst.FlowReturn // return, none, casted + + decoder = UnsafeVideoDecoderFromGlibNone(unsafe.Pointer(carg0)).(Instance) + frame = UnsafeVideoCodecFrameFromGlibFull(unsafe.Pointer(carg1)) + + goret = overrides.HandleFrame(decoder, frame) + + cret = C.GstFlowReturn(goret) + + return cret + }, + ) } if overrides.HandleMissingData != nil { pclass.handle_missing_data = (*[0]byte)(C._gotk4_gstvideo1_VideoDecoder_handle_missing_data) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstvideo1_VideoDecoder_handle_missing_data", + func(carg0 *C.GstVideoDecoder, carg1 C.GstClockTime, carg2 C.GstClockTime) (cret C.gboolean) { + var decoder Instance // go GstVideoDecoder subclass + var timestamp gst.ClockTime // in, none, casted, alias + var duration gst.ClockTime // in, none, casted, alias + var goret bool // return + + decoder = UnsafeVideoDecoderFromGlibNone(unsafe.Pointer(carg0)).(Instance) + timestamp = gst.ClockTime(carg1) + duration = gst.ClockTime(carg2) + + goret = overrides.HandleMissingData(decoder, timestamp, duration) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.Negotiate != nil { pclass.negotiate = (*[0]byte)(C._gotk4_gstvideo1_VideoDecoder_negotiate) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstvideo1_VideoDecoder_negotiate", + func(carg0 *C.GstVideoDecoder) (cret C.gboolean) { + var decoder Instance // go GstVideoDecoder subclass + var goret bool // return + + decoder = UnsafeVideoDecoderFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + goret = overrides.Negotiate(decoder) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.Open != nil { pclass.open = (*[0]byte)(C._gotk4_gstvideo1_VideoDecoder_open) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstvideo1_VideoDecoder_open", + func(carg0 *C.GstVideoDecoder) (cret C.gboolean) { + var decoder Instance // go GstVideoDecoder subclass + var goret bool // return + + decoder = UnsafeVideoDecoderFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + goret = overrides.Open(decoder) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.Parse != nil { pclass.parse = (*[0]byte)(C._gotk4_gstvideo1_VideoDecoder_parse) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstvideo1_VideoDecoder_parse", + func(carg0 *C.GstVideoDecoder, carg1 *C.GstVideoCodecFrame, carg2 *C.GstAdapter, carg3 C.gboolean) (cret C.GstFlowReturn) { + var decoder Instance // go GstVideoDecoder subclass + var frame *VideoCodecFrame // in, none, converted + var adapter gstbase.Adapter // in, none, converted + var atEos bool // in + var goret gst.FlowReturn // return, none, casted + + decoder = UnsafeVideoDecoderFromGlibNone(unsafe.Pointer(carg0)).(Instance) + frame = UnsafeVideoCodecFrameFromGlibNone(unsafe.Pointer(carg1)) + adapter = gstbase.UnsafeAdapterFromGlibNone(unsafe.Pointer(carg2)) + if carg3 != 0 { + atEos = true + } + + goret = overrides.Parse(decoder, frame, adapter, atEos) + + cret = C.GstFlowReturn(goret) + + return cret + }, + ) } if overrides.ProposeAllocation != nil { pclass.propose_allocation = (*[0]byte)(C._gotk4_gstvideo1_VideoDecoder_propose_allocation) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstvideo1_VideoDecoder_propose_allocation", + func(carg0 *C.GstVideoDecoder, carg1 *C.GstQuery) (cret C.gboolean) { + var decoder Instance // go GstVideoDecoder subclass + var query *gst.Query // in, none, converted + var goret bool // return + + decoder = UnsafeVideoDecoderFromGlibNone(unsafe.Pointer(carg0)).(Instance) + query = gst.UnsafeQueryFromGlibNone(unsafe.Pointer(carg1)) + + goret = overrides.ProposeAllocation(decoder, query) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.Reset != nil { pclass.reset = (*[0]byte)(C._gotk4_gstvideo1_VideoDecoder_reset) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstvideo1_VideoDecoder_reset", + func(carg0 *C.GstVideoDecoder, carg1 C.gboolean) (cret C.gboolean) { + var decoder Instance // go GstVideoDecoder subclass + var hard bool // in + var goret bool // return + + decoder = UnsafeVideoDecoderFromGlibNone(unsafe.Pointer(carg0)).(Instance) + if carg1 != 0 { + hard = true + } + + goret = overrides.Reset(decoder, hard) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.SetFormat != nil { pclass.set_format = (*[0]byte)(C._gotk4_gstvideo1_VideoDecoder_set_format) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstvideo1_VideoDecoder_set_format", + func(carg0 *C.GstVideoDecoder, carg1 *C.GstVideoCodecState) (cret C.gboolean) { + var decoder Instance // go GstVideoDecoder subclass + var state *VideoCodecState // in, none, converted + var goret bool // return + + decoder = UnsafeVideoDecoderFromGlibNone(unsafe.Pointer(carg0)).(Instance) + state = UnsafeVideoCodecStateFromGlibNone(unsafe.Pointer(carg1)) + + goret = overrides.SetFormat(decoder, state) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.SinkEvent != nil { pclass.sink_event = (*[0]byte)(C._gotk4_gstvideo1_VideoDecoder_sink_event) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstvideo1_VideoDecoder_sink_event", + func(carg0 *C.GstVideoDecoder, carg1 *C.GstEvent) (cret C.gboolean) { + var decoder Instance // go GstVideoDecoder subclass + var event *gst.Event // in, none, converted + var goret bool // return + + decoder = UnsafeVideoDecoderFromGlibNone(unsafe.Pointer(carg0)).(Instance) + event = gst.UnsafeEventFromGlibNone(unsafe.Pointer(carg1)) + + goret = overrides.SinkEvent(decoder, event) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.SinkQuery != nil { pclass.sink_query = (*[0]byte)(C._gotk4_gstvideo1_VideoDecoder_sink_query) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstvideo1_VideoDecoder_sink_query", + func(carg0 *C.GstVideoDecoder, carg1 *C.GstQuery) (cret C.gboolean) { + var decoder Instance // go GstVideoDecoder subclass + var query *gst.Query // in, none, converted + var goret bool // return + + decoder = UnsafeVideoDecoderFromGlibNone(unsafe.Pointer(carg0)).(Instance) + query = gst.UnsafeQueryFromGlibNone(unsafe.Pointer(carg1)) + + goret = overrides.SinkQuery(decoder, query) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.SrcEvent != nil { pclass.src_event = (*[0]byte)(C._gotk4_gstvideo1_VideoDecoder_src_event) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstvideo1_VideoDecoder_src_event", + func(carg0 *C.GstVideoDecoder, carg1 *C.GstEvent) (cret C.gboolean) { + var decoder Instance // go GstVideoDecoder subclass + var event *gst.Event // in, none, converted + var goret bool // return + + decoder = UnsafeVideoDecoderFromGlibNone(unsafe.Pointer(carg0)).(Instance) + event = gst.UnsafeEventFromGlibNone(unsafe.Pointer(carg1)) + + goret = overrides.SrcEvent(decoder, event) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.SrcQuery != nil { pclass.src_query = (*[0]byte)(C._gotk4_gstvideo1_VideoDecoder_src_query) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstvideo1_VideoDecoder_src_query", + func(carg0 *C.GstVideoDecoder, carg1 *C.GstQuery) (cret C.gboolean) { + var decoder Instance // go GstVideoDecoder subclass + var query *gst.Query // in, none, converted + var goret bool // return + + decoder = UnsafeVideoDecoderFromGlibNone(unsafe.Pointer(carg0)).(Instance) + query = gst.UnsafeQueryFromGlibNone(unsafe.Pointer(carg1)) + + goret = overrides.SrcQuery(decoder, query) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.Start != nil { pclass.start = (*[0]byte)(C._gotk4_gstvideo1_VideoDecoder_start) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstvideo1_VideoDecoder_start", + func(carg0 *C.GstVideoDecoder) (cret C.gboolean) { + var decoder Instance // go GstVideoDecoder subclass + var goret bool // return + + decoder = UnsafeVideoDecoderFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + goret = overrides.Start(decoder) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.Stop != nil { pclass.stop = (*[0]byte)(C._gotk4_gstvideo1_VideoDecoder_stop) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstvideo1_VideoDecoder_stop", + func(carg0 *C.GstVideoDecoder) (cret C.gboolean) { + var decoder Instance // go GstVideoDecoder subclass + var goret bool // return + + decoder = UnsafeVideoDecoderFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + goret = overrides.Stop(decoder) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.TransformMeta != nil { pclass.transform_meta = (*[0]byte)(C._gotk4_gstvideo1_VideoDecoder_transform_meta) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstvideo1_VideoDecoder_transform_meta", + func(carg0 *C.GstVideoDecoder, carg1 *C.GstVideoCodecFrame, carg2 *C.GstMeta) (cret C.gboolean) { + var decoder Instance // go GstVideoDecoder subclass + var frame *VideoCodecFrame // in, none, converted + var meta *gst.Meta // in, none, converted + var goret bool // return + + decoder = UnsafeVideoDecoderFromGlibNone(unsafe.Pointer(carg0)).(Instance) + frame = UnsafeVideoCodecFrameFromGlibNone(unsafe.Pointer(carg1)) + meta = gst.UnsafeMetaFromGlibNone(unsafe.Pointer(carg2)) + + goret = overrides.TransformMeta(decoder, frame, meta) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } } +// RegisterVideoDecoderSubClass is used to register a go subclass of GstVideoDecoder. For this to work safely please implement the +// virtual methods required by the implementation. +func RegisterVideoDecoderSubClass[InstanceT VideoDecoder]( + name string, + classInit func(class *VideoDecoderClass), + constructor func() InstanceT, + overrides VideoDecoderOverrides[InstanceT], + signals map[string]gobject.SignalDefinition, + interfaceInits ...gobject.SubClassInterfaceInit[InstanceT], +) gobject.Type { + return gobject.UnsafeRegisterSubClass( + name, + classInit, + constructor, + overrides, + signals, + TypeVideoDecoder, + UnsafeVideoDecoderClassFromGlibBorrow, + UnsafeApplyVideoDecoderOverrides, + func (obj *gobject.ObjectInstance) gobject.Object { + return unsafeWrapVideoDecoder(obj) + }, + interfaceInits..., + ) +} + // VideoEncoderInstance is the instance type used by all types extending GstVideoEncoder. It is used internally by the bindings. Users should use the interface [VideoEncoder] instead. type VideoEncoderInstance struct { _ [0]func() // equal guard @@ -15041,81 +16050,469 @@ func UnsafeApplyVideoEncoderOverrides[Instance VideoEncoder](gclass unsafe.Point if overrides.Close != nil { pclass.close = (*[0]byte)(C._gotk4_gstvideo1_VideoEncoder_close) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstvideo1_VideoEncoder_close", + func(carg0 *C.GstVideoEncoder) (cret C.gboolean) { + var encoder Instance // go GstVideoEncoder subclass + var goret bool // return + + encoder = UnsafeVideoEncoderFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + goret = overrides.Close(encoder) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.DecideAllocation != nil { pclass.decide_allocation = (*[0]byte)(C._gotk4_gstvideo1_VideoEncoder_decide_allocation) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstvideo1_VideoEncoder_decide_allocation", + func(carg0 *C.GstVideoEncoder, carg1 *C.GstQuery) (cret C.gboolean) { + var encoder Instance // go GstVideoEncoder subclass + var query *gst.Query // in, none, converted + var goret bool // return + + encoder = UnsafeVideoEncoderFromGlibNone(unsafe.Pointer(carg0)).(Instance) + query = gst.UnsafeQueryFromGlibNone(unsafe.Pointer(carg1)) + + goret = overrides.DecideAllocation(encoder, query) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.Finish != nil { pclass.finish = (*[0]byte)(C._gotk4_gstvideo1_VideoEncoder_finish) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstvideo1_VideoEncoder_finish", + func(carg0 *C.GstVideoEncoder) (cret C.GstFlowReturn) { + var encoder Instance // go GstVideoEncoder subclass + var goret gst.FlowReturn // return, none, casted + + encoder = UnsafeVideoEncoderFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + goret = overrides.Finish(encoder) + + cret = C.GstFlowReturn(goret) + + return cret + }, + ) } if overrides.Flush != nil { pclass.flush = (*[0]byte)(C._gotk4_gstvideo1_VideoEncoder_flush) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstvideo1_VideoEncoder_flush", + func(carg0 *C.GstVideoEncoder) (cret C.gboolean) { + var encoder Instance // go GstVideoEncoder subclass + var goret bool // return + + encoder = UnsafeVideoEncoderFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + goret = overrides.Flush(encoder) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.Getcaps != nil { pclass.getcaps = (*[0]byte)(C._gotk4_gstvideo1_VideoEncoder_getcaps) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstvideo1_VideoEncoder_getcaps", + func(carg0 *C.GstVideoEncoder, carg1 *C.GstCaps) (cret *C.GstCaps) { + var enc Instance // go GstVideoEncoder subclass + var filter *gst.Caps // in, none, converted + var goret *gst.Caps // return, full, converted + + enc = UnsafeVideoEncoderFromGlibNone(unsafe.Pointer(carg0)).(Instance) + filter = gst.UnsafeCapsFromGlibNone(unsafe.Pointer(carg1)) + + goret = overrides.Getcaps(enc, filter) + + cret = (*C.GstCaps)(gst.UnsafeCapsToGlibFull(goret)) + + return cret + }, + ) } if overrides.HandleFrame != nil { pclass.handle_frame = (*[0]byte)(C._gotk4_gstvideo1_VideoEncoder_handle_frame) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstvideo1_VideoEncoder_handle_frame", + func(carg0 *C.GstVideoEncoder, carg1 *C.GstVideoCodecFrame) (cret C.GstFlowReturn) { + var encoder Instance // go GstVideoEncoder subclass + var frame *VideoCodecFrame // in, none, converted + var goret gst.FlowReturn // return, none, casted + + encoder = UnsafeVideoEncoderFromGlibNone(unsafe.Pointer(carg0)).(Instance) + frame = UnsafeVideoCodecFrameFromGlibNone(unsafe.Pointer(carg1)) + + goret = overrides.HandleFrame(encoder, frame) + + cret = C.GstFlowReturn(goret) + + return cret + }, + ) } if overrides.Negotiate != nil { pclass.negotiate = (*[0]byte)(C._gotk4_gstvideo1_VideoEncoder_negotiate) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstvideo1_VideoEncoder_negotiate", + func(carg0 *C.GstVideoEncoder) (cret C.gboolean) { + var encoder Instance // go GstVideoEncoder subclass + var goret bool // return + + encoder = UnsafeVideoEncoderFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + goret = overrides.Negotiate(encoder) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.Open != nil { pclass.open = (*[0]byte)(C._gotk4_gstvideo1_VideoEncoder_open) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstvideo1_VideoEncoder_open", + func(carg0 *C.GstVideoEncoder) (cret C.gboolean) { + var encoder Instance // go GstVideoEncoder subclass + var goret bool // return + + encoder = UnsafeVideoEncoderFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + goret = overrides.Open(encoder) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.PrePush != nil { pclass.pre_push = (*[0]byte)(C._gotk4_gstvideo1_VideoEncoder_pre_push) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstvideo1_VideoEncoder_pre_push", + func(carg0 *C.GstVideoEncoder, carg1 *C.GstVideoCodecFrame) (cret C.GstFlowReturn) { + var encoder Instance // go GstVideoEncoder subclass + var frame *VideoCodecFrame // in, none, converted + var goret gst.FlowReturn // return, none, casted + + encoder = UnsafeVideoEncoderFromGlibNone(unsafe.Pointer(carg0)).(Instance) + frame = UnsafeVideoCodecFrameFromGlibNone(unsafe.Pointer(carg1)) + + goret = overrides.PrePush(encoder, frame) + + cret = C.GstFlowReturn(goret) + + return cret + }, + ) } if overrides.ProposeAllocation != nil { pclass.propose_allocation = (*[0]byte)(C._gotk4_gstvideo1_VideoEncoder_propose_allocation) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstvideo1_VideoEncoder_propose_allocation", + func(carg0 *C.GstVideoEncoder, carg1 *C.GstQuery) (cret C.gboolean) { + var encoder Instance // go GstVideoEncoder subclass + var query *gst.Query // in, none, converted + var goret bool // return + + encoder = UnsafeVideoEncoderFromGlibNone(unsafe.Pointer(carg0)).(Instance) + query = gst.UnsafeQueryFromGlibNone(unsafe.Pointer(carg1)) + + goret = overrides.ProposeAllocation(encoder, query) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.Reset != nil { pclass.reset = (*[0]byte)(C._gotk4_gstvideo1_VideoEncoder_reset) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstvideo1_VideoEncoder_reset", + func(carg0 *C.GstVideoEncoder, carg1 C.gboolean) (cret C.gboolean) { + var encoder Instance // go GstVideoEncoder subclass + var hard bool // in + var goret bool // return + + encoder = UnsafeVideoEncoderFromGlibNone(unsafe.Pointer(carg0)).(Instance) + if carg1 != 0 { + hard = true + } + + goret = overrides.Reset(encoder, hard) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.SetFormat != nil { pclass.set_format = (*[0]byte)(C._gotk4_gstvideo1_VideoEncoder_set_format) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstvideo1_VideoEncoder_set_format", + func(carg0 *C.GstVideoEncoder, carg1 *C.GstVideoCodecState) (cret C.gboolean) { + var encoder Instance // go GstVideoEncoder subclass + var state *VideoCodecState // in, none, converted + var goret bool // return + + encoder = UnsafeVideoEncoderFromGlibNone(unsafe.Pointer(carg0)).(Instance) + state = UnsafeVideoCodecStateFromGlibNone(unsafe.Pointer(carg1)) + + goret = overrides.SetFormat(encoder, state) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.SinkEvent != nil { pclass.sink_event = (*[0]byte)(C._gotk4_gstvideo1_VideoEncoder_sink_event) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstvideo1_VideoEncoder_sink_event", + func(carg0 *C.GstVideoEncoder, carg1 *C.GstEvent) (cret C.gboolean) { + var encoder Instance // go GstVideoEncoder subclass + var event *gst.Event // in, none, converted + var goret bool // return + + encoder = UnsafeVideoEncoderFromGlibNone(unsafe.Pointer(carg0)).(Instance) + event = gst.UnsafeEventFromGlibNone(unsafe.Pointer(carg1)) + + goret = overrides.SinkEvent(encoder, event) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.SinkQuery != nil { pclass.sink_query = (*[0]byte)(C._gotk4_gstvideo1_VideoEncoder_sink_query) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstvideo1_VideoEncoder_sink_query", + func(carg0 *C.GstVideoEncoder, carg1 *C.GstQuery) (cret C.gboolean) { + var encoder Instance // go GstVideoEncoder subclass + var query *gst.Query // in, none, converted + var goret bool // return + + encoder = UnsafeVideoEncoderFromGlibNone(unsafe.Pointer(carg0)).(Instance) + query = gst.UnsafeQueryFromGlibNone(unsafe.Pointer(carg1)) + + goret = overrides.SinkQuery(encoder, query) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.SrcEvent != nil { pclass.src_event = (*[0]byte)(C._gotk4_gstvideo1_VideoEncoder_src_event) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstvideo1_VideoEncoder_src_event", + func(carg0 *C.GstVideoEncoder, carg1 *C.GstEvent) (cret C.gboolean) { + var encoder Instance // go GstVideoEncoder subclass + var event *gst.Event // in, none, converted + var goret bool // return + + encoder = UnsafeVideoEncoderFromGlibNone(unsafe.Pointer(carg0)).(Instance) + event = gst.UnsafeEventFromGlibNone(unsafe.Pointer(carg1)) + + goret = overrides.SrcEvent(encoder, event) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.SrcQuery != nil { pclass.src_query = (*[0]byte)(C._gotk4_gstvideo1_VideoEncoder_src_query) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstvideo1_VideoEncoder_src_query", + func(carg0 *C.GstVideoEncoder, carg1 *C.GstQuery) (cret C.gboolean) { + var encoder Instance // go GstVideoEncoder subclass + var query *gst.Query // in, none, converted + var goret bool // return + + encoder = UnsafeVideoEncoderFromGlibNone(unsafe.Pointer(carg0)).(Instance) + query = gst.UnsafeQueryFromGlibNone(unsafe.Pointer(carg1)) + + goret = overrides.SrcQuery(encoder, query) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.Start != nil { pclass.start = (*[0]byte)(C._gotk4_gstvideo1_VideoEncoder_start) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstvideo1_VideoEncoder_start", + func(carg0 *C.GstVideoEncoder) (cret C.gboolean) { + var encoder Instance // go GstVideoEncoder subclass + var goret bool // return + + encoder = UnsafeVideoEncoderFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + goret = overrides.Start(encoder) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.Stop != nil { pclass.stop = (*[0]byte)(C._gotk4_gstvideo1_VideoEncoder_stop) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstvideo1_VideoEncoder_stop", + func(carg0 *C.GstVideoEncoder) (cret C.gboolean) { + var encoder Instance // go GstVideoEncoder subclass + var goret bool // return + + encoder = UnsafeVideoEncoderFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + goret = overrides.Stop(encoder) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.TransformMeta != nil { pclass.transform_meta = (*[0]byte)(C._gotk4_gstvideo1_VideoEncoder_transform_meta) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstvideo1_VideoEncoder_transform_meta", + func(carg0 *C.GstVideoEncoder, carg1 *C.GstVideoCodecFrame, carg2 *C.GstMeta) (cret C.gboolean) { + var encoder Instance // go GstVideoEncoder subclass + var frame *VideoCodecFrame // in, none, converted + var meta *gst.Meta // in, none, converted + var goret bool // return + + encoder = UnsafeVideoEncoderFromGlibNone(unsafe.Pointer(carg0)).(Instance) + frame = UnsafeVideoCodecFrameFromGlibNone(unsafe.Pointer(carg1)) + meta = gst.UnsafeMetaFromGlibNone(unsafe.Pointer(carg2)) + + goret = overrides.TransformMeta(encoder, frame, meta) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } } +// RegisterVideoEncoderSubClass is used to register a go subclass of GstVideoEncoder. For this to work safely please implement the +// virtual methods required by the implementation. +func RegisterVideoEncoderSubClass[InstanceT VideoEncoder]( + name string, + classInit func(class *VideoEncoderClass), + constructor func() InstanceT, + overrides VideoEncoderOverrides[InstanceT], + signals map[string]gobject.SignalDefinition, + interfaceInits ...gobject.SubClassInterfaceInit[InstanceT], +) gobject.Type { + return gobject.UnsafeRegisterSubClass( + name, + classInit, + constructor, + overrides, + signals, + TypeVideoEncoder, + UnsafeVideoEncoderClassFromGlibBorrow, + UnsafeApplyVideoEncoderOverrides, + func (obj *gobject.ObjectInstance) gobject.Object { + return unsafeWrapVideoEncoder(obj) + }, + interfaceInits..., + ) +} + // VideoFilterInstance is the instance type used by all types extending GstVideoFilter. It is used internally by the bindings. Users should use the interface [VideoFilter] instead. type VideoFilterInstance struct { _ [0]func() // equal guard @@ -15225,17 +16622,107 @@ func UnsafeApplyVideoFilterOverrides[Instance VideoFilter](gclass unsafe.Pointer if overrides.SetInfo != nil { pclass.set_info = (*[0]byte)(C._gotk4_gstvideo1_VideoFilter_set_info) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstvideo1_VideoFilter_set_info", + func(carg0 *C.GstVideoFilter, carg1 *C.GstCaps, carg2 *C.GstVideoInfo, carg3 *C.GstCaps, carg4 *C.GstVideoInfo) (cret C.gboolean) { + var filter Instance // go GstVideoFilter subclass + var incaps *gst.Caps // in, none, converted + var inInfo *VideoInfo // in, none, converted + var outcaps *gst.Caps // in, none, converted + var outInfo *VideoInfo // in, none, converted + var goret bool // return + + filter = UnsafeVideoFilterFromGlibNone(unsafe.Pointer(carg0)).(Instance) + incaps = gst.UnsafeCapsFromGlibNone(unsafe.Pointer(carg1)) + inInfo = UnsafeVideoInfoFromGlibNone(unsafe.Pointer(carg2)) + outcaps = gst.UnsafeCapsFromGlibNone(unsafe.Pointer(carg3)) + outInfo = UnsafeVideoInfoFromGlibNone(unsafe.Pointer(carg4)) + + goret = overrides.SetInfo(filter, incaps, inInfo, outcaps, outInfo) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.TransformFrame != nil { pclass.transform_frame = (*[0]byte)(C._gotk4_gstvideo1_VideoFilter_transform_frame) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstvideo1_VideoFilter_transform_frame", + func(carg0 *C.GstVideoFilter, carg1 *C.GstVideoFrame, carg2 *C.GstVideoFrame) (cret C.GstFlowReturn) { + var filter Instance // go GstVideoFilter subclass + var inframe *VideoFrame // in, none, converted + var outframe *VideoFrame // in, none, converted + var goret gst.FlowReturn // return, none, casted + + filter = UnsafeVideoFilterFromGlibNone(unsafe.Pointer(carg0)).(Instance) + inframe = UnsafeVideoFrameFromGlibNone(unsafe.Pointer(carg1)) + outframe = UnsafeVideoFrameFromGlibNone(unsafe.Pointer(carg2)) + + goret = overrides.TransformFrame(filter, inframe, outframe) + + cret = C.GstFlowReturn(goret) + + return cret + }, + ) } if overrides.TransformFrameIP != nil { pclass.transform_frame_ip = (*[0]byte)(C._gotk4_gstvideo1_VideoFilter_transform_frame_ip) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstvideo1_VideoFilter_transform_frame_ip", + func(carg0 *C.GstVideoFilter, carg1 *C.GstVideoFrame) (cret C.GstFlowReturn) { + var trans Instance // go GstVideoFilter subclass + var frame *VideoFrame // in, none, converted + var goret gst.FlowReturn // return, none, casted + + trans = UnsafeVideoFilterFromGlibNone(unsafe.Pointer(carg0)).(Instance) + frame = UnsafeVideoFrameFromGlibNone(unsafe.Pointer(carg1)) + + goret = overrides.TransformFrameIP(trans, frame) + + cret = C.GstFlowReturn(goret) + + return cret + }, + ) } } +// RegisterVideoFilterSubClass is used to register a go subclass of GstVideoFilter. For this to work safely please implement the +// virtual methods required by the implementation. +func RegisterVideoFilterSubClass[InstanceT VideoFilter]( + name string, + classInit func(class *VideoFilterClass), + constructor func() InstanceT, + overrides VideoFilterOverrides[InstanceT], + signals map[string]gobject.SignalDefinition, + interfaceInits ...gobject.SubClassInterfaceInit[InstanceT], +) gobject.Type { + return gobject.UnsafeRegisterSubClass( + name, + classInit, + constructor, + overrides, + signals, + TypeVideoFilter, + UnsafeVideoFilterClassFromGlibBorrow, + UnsafeApplyVideoFilterOverrides, + func (obj *gobject.ObjectInstance) gobject.Object { + return unsafeWrapVideoFilter(obj) + }, + interfaceInits..., + ) +} + // VideoSinkInstance is the instance type used by all types extending GstVideoSink. It is used internally by the bindings. Users should use the interface [VideoSink] instead. type VideoSinkInstance struct { _ [0]func() // equal guard @@ -15378,13 +16865,79 @@ func UnsafeApplyVideoSinkOverrides[Instance VideoSink](gclass unsafe.Pointer, ov if overrides.SetInfo != nil { pclass.set_info = (*[0]byte)(C._gotk4_gstvideo1_VideoSink_set_info) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstvideo1_VideoSink_set_info", + func(carg0 *C.GstVideoSink, carg1 *C.GstCaps, carg2 *C.GstVideoInfo) (cret C.gboolean) { + var videoSink Instance // go GstVideoSink subclass + var caps *gst.Caps // in, none, converted + var info *VideoInfo // in, none, converted + var goret bool // return + + videoSink = UnsafeVideoSinkFromGlibNone(unsafe.Pointer(carg0)).(Instance) + caps = gst.UnsafeCapsFromGlibNone(unsafe.Pointer(carg1)) + info = UnsafeVideoInfoFromGlibNone(unsafe.Pointer(carg2)) + + goret = overrides.SetInfo(videoSink, caps, info) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.ShowFrame != nil { pclass.show_frame = (*[0]byte)(C._gotk4_gstvideo1_VideoSink_show_frame) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstvideo1_VideoSink_show_frame", + func(carg0 *C.GstVideoSink, carg1 *C.GstBuffer) (cret C.GstFlowReturn) { + var videoSink Instance // go GstVideoSink subclass + var buf *gst.Buffer // in, none, converted + var goret gst.FlowReturn // return, none, casted + + videoSink = UnsafeVideoSinkFromGlibNone(unsafe.Pointer(carg0)).(Instance) + buf = gst.UnsafeBufferFromGlibNone(unsafe.Pointer(carg1)) + + goret = overrides.ShowFrame(videoSink, buf) + + cret = C.GstFlowReturn(goret) + + return cret + }, + ) } } +// RegisterVideoSinkSubClass is used to register a go subclass of GstVideoSink. For this to work safely please implement the +// virtual methods required by the implementation. +func RegisterVideoSinkSubClass[InstanceT VideoSink]( + name string, + classInit func(class *VideoSinkClass), + constructor func() InstanceT, + overrides VideoSinkOverrides[InstanceT], + signals map[string]gobject.SignalDefinition, + interfaceInits ...gobject.SubClassInterfaceInit[InstanceT], +) gobject.Type { + return gobject.UnsafeRegisterSubClass( + name, + classInit, + constructor, + overrides, + signals, + TypeVideoSink, + UnsafeVideoSinkClassFromGlibBorrow, + UnsafeApplyVideoSinkOverrides, + func (obj *gobject.ObjectInstance) gobject.Object { + return unsafeWrapVideoSink(obj) + }, + interfaceInits..., + ) +} + // VideoAggregatorConvertPadInstance is the instance type used by all types extending GstVideoAggregatorConvertPad. It is used internally by the bindings. Users should use the interface [VideoAggregatorConvertPad] instead. type VideoAggregatorConvertPadInstance struct { _ [0]func() // equal guard @@ -15489,9 +17042,50 @@ func UnsafeApplyVideoAggregatorConvertPadOverrides[Instance VideoAggregatorConve if overrides.CreateConversionInfo != nil { pclass.create_conversion_info = (*[0]byte)(C._gotk4_gstvideo1_VideoAggregatorConvertPad_create_conversion_info) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstvideo1_VideoAggregatorConvertPad_create_conversion_info", + func(carg0 *C.GstVideoAggregatorConvertPad, carg1 *C.GstVideoAggregator, carg2 *C.GstVideoInfo) { + var pad Instance // go GstVideoAggregatorConvertPad subclass + var agg VideoAggregator // in, none, converted + var conversionInfo *VideoInfo // in, none, converted + + pad = UnsafeVideoAggregatorConvertPadFromGlibNone(unsafe.Pointer(carg0)).(Instance) + agg = UnsafeVideoAggregatorFromGlibNone(unsafe.Pointer(carg1)) + conversionInfo = UnsafeVideoInfoFromGlibNone(unsafe.Pointer(carg2)) + + overrides.CreateConversionInfo(pad, agg, conversionInfo) + }, + ) } } +// RegisterVideoAggregatorConvertPadSubClass is used to register a go subclass of GstVideoAggregatorConvertPad. For this to work safely please implement the +// virtual methods required by the implementation. +func RegisterVideoAggregatorConvertPadSubClass[InstanceT VideoAggregatorConvertPad]( + name string, + classInit func(class *VideoAggregatorConvertPadClass), + constructor func() InstanceT, + overrides VideoAggregatorConvertPadOverrides[InstanceT], + signals map[string]gobject.SignalDefinition, + interfaceInits ...gobject.SubClassInterfaceInit[InstanceT], +) gobject.Type { + return gobject.UnsafeRegisterSubClass( + name, + classInit, + constructor, + overrides, + signals, + TypeVideoAggregatorConvertPad, + UnsafeVideoAggregatorConvertPadClassFromGlibBorrow, + UnsafeApplyVideoAggregatorConvertPadOverrides, + func (obj *gobject.ObjectInstance) gobject.Object { + return unsafeWrapVideoAggregatorConvertPad(obj) + }, + interfaceInits..., + ) +} + // VideoAggregatorParallelConvertPadInstance is the instance type used by all types extending GstVideoAggregatorParallelConvertPad. It is used internally by the bindings. Users should use the interface [VideoAggregatorParallelConvertPad] instead. type VideoAggregatorParallelConvertPadInstance struct { _ [0]func() // equal guard @@ -15570,6 +17164,32 @@ func UnsafeApplyVideoAggregatorParallelConvertPadOverrides[Instance VideoAggrega UnsafeApplyVideoAggregatorConvertPadOverrides(gclass, overrides.VideoAggregatorConvertPadOverrides) } +// RegisterVideoAggregatorParallelConvertPadSubClass is used to register a go subclass of GstVideoAggregatorParallelConvertPad. For this to work safely please implement the +// virtual methods required by the implementation. +func RegisterVideoAggregatorParallelConvertPadSubClass[InstanceT VideoAggregatorParallelConvertPad]( + name string, + classInit func(class *VideoAggregatorParallelConvertPadClass), + constructor func() InstanceT, + overrides VideoAggregatorParallelConvertPadOverrides[InstanceT], + signals map[string]gobject.SignalDefinition, + interfaceInits ...gobject.SubClassInterfaceInit[InstanceT], +) gobject.Type { + return gobject.UnsafeRegisterSubClass( + name, + classInit, + constructor, + overrides, + signals, + TypeVideoAggregatorParallelConvertPad, + UnsafeVideoAggregatorParallelConvertPadClassFromGlibBorrow, + UnsafeApplyVideoAggregatorParallelConvertPadOverrides, + func (obj *gobject.ObjectInstance) gobject.Object { + return unsafeWrapVideoAggregatorParallelConvertPad(obj) + }, + interfaceInits..., + ) +} + // AncillaryMeta wraps GstAncillaryMeta // // #GstMeta for carrying SMPTE-291M Ancillary data. Note that all the ADF fields diff --git a/pkg/gstvideo/gstvideo_export.gen.go b/pkg/gstvideo/gstvideo_export.gen.go index 1712028..5ca5644 100644 --- a/pkg/gstvideo/gstvideo_export.gen.go +++ b/pkg/gstvideo/gstvideo_export.gen.go @@ -5,6 +5,7 @@ package gstvideo import ( "unsafe" + "github.com/diamondburned/gotk4/pkg/core/classdata" "github.com/diamondburned/gotk4/pkg/core/userdata" "github.com/diamondburned/gotk4/pkg/glib/v2" "github.com/go-gst/go-gst/pkg/gst" @@ -35,366 +36,877 @@ func _gotk4_gstvideo1_VideoConvertSampleCallback(carg1 *C.GstSample, carg2 *C.GE //export _gotk4_gstvideo1_ColorBalance_get_balance_type func _gotk4_gstvideo1_ColorBalance_get_balance_type(carg0 *C.GstColorBalance) (cret C.GstColorBalanceType) { - panic("unimplemented") + var fn func(carg0 *C.GstColorBalance) (cret C.GstColorBalanceType) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstvideo1_ColorBalance_get_balance_type").(func(carg0 *C.GstColorBalance) (cret C.GstColorBalanceType)) + if fn == nil { + panic("_gotk4_gstvideo1_ColorBalance_get_balance_type: no function pointer found") + } + } + return fn(carg0) } //export _gotk4_gstvideo1_ColorBalance_get_value func _gotk4_gstvideo1_ColorBalance_get_value(carg0 *C.GstColorBalance, carg1 *C.GstColorBalanceChannel) (cret C.gint) { - panic("unimplemented") + var fn func(carg0 *C.GstColorBalance, carg1 *C.GstColorBalanceChannel) (cret C.gint) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstvideo1_ColorBalance_get_value").(func(carg0 *C.GstColorBalance, carg1 *C.GstColorBalanceChannel) (cret C.gint)) + if fn == nil { + panic("_gotk4_gstvideo1_ColorBalance_get_value: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstvideo1_ColorBalance_list_channels func _gotk4_gstvideo1_ColorBalance_list_channels(carg0 *C.GstColorBalance) (cret *C.GList) { - panic("unimplemented") + var fn func(carg0 *C.GstColorBalance) (cret *C.GList) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstvideo1_ColorBalance_list_channels").(func(carg0 *C.GstColorBalance) (cret *C.GList)) + if fn == nil { + panic("_gotk4_gstvideo1_ColorBalance_list_channels: no function pointer found") + } + } + return fn(carg0) } //export _gotk4_gstvideo1_ColorBalance_set_value func _gotk4_gstvideo1_ColorBalance_set_value(carg0 *C.GstColorBalance, carg1 *C.GstColorBalanceChannel, carg2 C.gint) { - panic("unimplemented") + var fn func(carg0 *C.GstColorBalance, carg1 *C.GstColorBalanceChannel, carg2 C.gint) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstvideo1_ColorBalance_set_value").(func(carg0 *C.GstColorBalance, carg1 *C.GstColorBalanceChannel, carg2 C.gint)) + if fn == nil { + panic("_gotk4_gstvideo1_ColorBalance_set_value: no function pointer found") + } + } + fn(carg0, carg1, carg2) } //export _gotk4_gstvideo1_ColorBalance_value_changed func _gotk4_gstvideo1_ColorBalance_value_changed(carg0 *C.GstColorBalance, carg1 *C.GstColorBalanceChannel, carg2 C.gint) { - panic("unimplemented") + var fn func(carg0 *C.GstColorBalance, carg1 *C.GstColorBalanceChannel, carg2 C.gint) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstvideo1_ColorBalance_value_changed").(func(carg0 *C.GstColorBalance, carg1 *C.GstColorBalanceChannel, carg2 C.gint)) + if fn == nil { + panic("_gotk4_gstvideo1_ColorBalance_value_changed: no function pointer found") + } + } + fn(carg0, carg1, carg2) } //export _gotk4_gstvideo1_Navigation_send_event func _gotk4_gstvideo1_Navigation_send_event(carg0 *C.GstNavigation, carg1 *C.GstStructure) { - panic("unimplemented") + var fn func(carg0 *C.GstNavigation, carg1 *C.GstStructure) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstvideo1_Navigation_send_event").(func(carg0 *C.GstNavigation, carg1 *C.GstStructure)) + if fn == nil { + panic("_gotk4_gstvideo1_Navigation_send_event: no function pointer found") + } + } + fn(carg0, carg1) } //export _gotk4_gstvideo1_Navigation_send_event_simple func _gotk4_gstvideo1_Navigation_send_event_simple(carg0 *C.GstNavigation, carg1 *C.GstEvent) { - panic("unimplemented") + var fn func(carg0 *C.GstNavigation, carg1 *C.GstEvent) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstvideo1_Navigation_send_event_simple").(func(carg0 *C.GstNavigation, carg1 *C.GstEvent)) + if fn == nil { + panic("_gotk4_gstvideo1_Navigation_send_event_simple: no function pointer found") + } + } + fn(carg0, carg1) } //export _gotk4_gstvideo1_VideoOrientation_get_hcenter func _gotk4_gstvideo1_VideoOrientation_get_hcenter(carg0 *C.GstVideoOrientation, carg1 *C.gint) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstVideoOrientation, carg1 *C.gint) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstvideo1_VideoOrientation_get_hcenter").(func(carg0 *C.GstVideoOrientation, carg1 *C.gint) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstvideo1_VideoOrientation_get_hcenter: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstvideo1_VideoOrientation_get_hflip func _gotk4_gstvideo1_VideoOrientation_get_hflip(carg0 *C.GstVideoOrientation, carg1 *C.gboolean) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstVideoOrientation, carg1 *C.gboolean) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstvideo1_VideoOrientation_get_hflip").(func(carg0 *C.GstVideoOrientation, carg1 *C.gboolean) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstvideo1_VideoOrientation_get_hflip: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstvideo1_VideoOrientation_get_vcenter func _gotk4_gstvideo1_VideoOrientation_get_vcenter(carg0 *C.GstVideoOrientation, carg1 *C.gint) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstVideoOrientation, carg1 *C.gint) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstvideo1_VideoOrientation_get_vcenter").(func(carg0 *C.GstVideoOrientation, carg1 *C.gint) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstvideo1_VideoOrientation_get_vcenter: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstvideo1_VideoOrientation_get_vflip func _gotk4_gstvideo1_VideoOrientation_get_vflip(carg0 *C.GstVideoOrientation, carg1 *C.gboolean) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstVideoOrientation, carg1 *C.gboolean) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstvideo1_VideoOrientation_get_vflip").(func(carg0 *C.GstVideoOrientation, carg1 *C.gboolean) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstvideo1_VideoOrientation_get_vflip: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstvideo1_VideoOrientation_set_hcenter func _gotk4_gstvideo1_VideoOrientation_set_hcenter(carg0 *C.GstVideoOrientation, carg1 C.gint) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstVideoOrientation, carg1 C.gint) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstvideo1_VideoOrientation_set_hcenter").(func(carg0 *C.GstVideoOrientation, carg1 C.gint) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstvideo1_VideoOrientation_set_hcenter: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstvideo1_VideoOrientation_set_hflip func _gotk4_gstvideo1_VideoOrientation_set_hflip(carg0 *C.GstVideoOrientation, carg1 C.gboolean) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstVideoOrientation, carg1 C.gboolean) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstvideo1_VideoOrientation_set_hflip").(func(carg0 *C.GstVideoOrientation, carg1 C.gboolean) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstvideo1_VideoOrientation_set_hflip: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstvideo1_VideoOrientation_set_vcenter func _gotk4_gstvideo1_VideoOrientation_set_vcenter(carg0 *C.GstVideoOrientation, carg1 C.gint) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstVideoOrientation, carg1 C.gint) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstvideo1_VideoOrientation_set_vcenter").(func(carg0 *C.GstVideoOrientation, carg1 C.gint) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstvideo1_VideoOrientation_set_vcenter: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstvideo1_VideoOrientation_set_vflip func _gotk4_gstvideo1_VideoOrientation_set_vflip(carg0 *C.GstVideoOrientation, carg1 C.gboolean) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstVideoOrientation, carg1 C.gboolean) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstvideo1_VideoOrientation_set_vflip").(func(carg0 *C.GstVideoOrientation, carg1 C.gboolean) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstvideo1_VideoOrientation_set_vflip: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstvideo1_VideoOverlay_expose func _gotk4_gstvideo1_VideoOverlay_expose(carg0 *C.GstVideoOverlay) { - panic("unimplemented") + var fn func(carg0 *C.GstVideoOverlay) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstvideo1_VideoOverlay_expose").(func(carg0 *C.GstVideoOverlay)) + if fn == nil { + panic("_gotk4_gstvideo1_VideoOverlay_expose: no function pointer found") + } + } + fn(carg0) } //export _gotk4_gstvideo1_VideoOverlay_handle_events func _gotk4_gstvideo1_VideoOverlay_handle_events(carg0 *C.GstVideoOverlay, carg1 C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstVideoOverlay, carg1 C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstvideo1_VideoOverlay_handle_events").(func(carg0 *C.GstVideoOverlay, carg1 C.gboolean)) + if fn == nil { + panic("_gotk4_gstvideo1_VideoOverlay_handle_events: no function pointer found") + } + } + fn(carg0, carg1) } //export _gotk4_gstvideo1_VideoOverlay_set_render_rectangle func _gotk4_gstvideo1_VideoOverlay_set_render_rectangle(carg0 *C.GstVideoOverlay, carg1 C.gint, carg2 C.gint, carg3 C.gint, carg4 C.gint) { - panic("unimplemented") + var fn func(carg0 *C.GstVideoOverlay, carg1 C.gint, carg2 C.gint, carg3 C.gint, carg4 C.gint) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstvideo1_VideoOverlay_set_render_rectangle").(func(carg0 *C.GstVideoOverlay, carg1 C.gint, carg2 C.gint, carg3 C.gint, carg4 C.gint)) + if fn == nil { + panic("_gotk4_gstvideo1_VideoOverlay_set_render_rectangle: no function pointer found") + } + } + fn(carg0, carg1, carg2, carg3, carg4) } //export _gotk4_gstvideo1_ColorBalanceChannel_value_changed func _gotk4_gstvideo1_ColorBalanceChannel_value_changed(carg0 *C.GstColorBalanceChannel, carg1 C.gint) { - panic("unimplemented") + var fn func(carg0 *C.GstColorBalanceChannel, carg1 C.gint) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstvideo1_ColorBalanceChannel_value_changed").(func(carg0 *C.GstColorBalanceChannel, carg1 C.gint)) + if fn == nil { + panic("_gotk4_gstvideo1_ColorBalanceChannel_value_changed: no function pointer found") + } + } + fn(carg0, carg1) } //export _gotk4_gstvideo1_VideoAggregator_aggregate_frames func _gotk4_gstvideo1_VideoAggregator_aggregate_frames(carg0 *C.GstVideoAggregator, carg1 *C.GstBuffer) (cret C.GstFlowReturn) { - panic("unimplemented") + var fn func(carg0 *C.GstVideoAggregator, carg1 *C.GstBuffer) (cret C.GstFlowReturn) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstvideo1_VideoAggregator_aggregate_frames").(func(carg0 *C.GstVideoAggregator, carg1 *C.GstBuffer) (cret C.GstFlowReturn)) + if fn == nil { + panic("_gotk4_gstvideo1_VideoAggregator_aggregate_frames: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstvideo1_VideoAggregator_find_best_format func _gotk4_gstvideo1_VideoAggregator_find_best_format(carg0 *C.GstVideoAggregator, carg1 *C.GstCaps, carg2 *C.GstVideoInfo, carg3 *C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstVideoAggregator, carg1 *C.GstCaps, carg2 *C.GstVideoInfo, carg3 *C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstvideo1_VideoAggregator_find_best_format").(func(carg0 *C.GstVideoAggregator, carg1 *C.GstCaps, carg2 *C.GstVideoInfo, carg3 *C.gboolean)) + if fn == nil { + panic("_gotk4_gstvideo1_VideoAggregator_find_best_format: no function pointer found") + } + } + fn(carg0, carg1, carg2, carg3) } //export _gotk4_gstvideo1_VideoAggregator_update_caps func _gotk4_gstvideo1_VideoAggregator_update_caps(carg0 *C.GstVideoAggregator, carg1 *C.GstCaps) (cret *C.GstCaps) { - panic("unimplemented") + var fn func(carg0 *C.GstVideoAggregator, carg1 *C.GstCaps) (cret *C.GstCaps) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstvideo1_VideoAggregator_update_caps").(func(carg0 *C.GstVideoAggregator, carg1 *C.GstCaps) (cret *C.GstCaps)) + if fn == nil { + panic("_gotk4_gstvideo1_VideoAggregator_update_caps: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstvideo1_VideoAggregatorPad_clean_frame func _gotk4_gstvideo1_VideoAggregatorPad_clean_frame(carg0 *C.GstVideoAggregatorPad, carg1 *C.GstVideoAggregator, carg2 *C.GstVideoFrame) { - panic("unimplemented") + var fn func(carg0 *C.GstVideoAggregatorPad, carg1 *C.GstVideoAggregator, carg2 *C.GstVideoFrame) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstvideo1_VideoAggregatorPad_clean_frame").(func(carg0 *C.GstVideoAggregatorPad, carg1 *C.GstVideoAggregator, carg2 *C.GstVideoFrame)) + if fn == nil { + panic("_gotk4_gstvideo1_VideoAggregatorPad_clean_frame: no function pointer found") + } + } + fn(carg0, carg1, carg2) } //export _gotk4_gstvideo1_VideoAggregatorPad_prepare_frame func _gotk4_gstvideo1_VideoAggregatorPad_prepare_frame(carg0 *C.GstVideoAggregatorPad, carg1 *C.GstVideoAggregator, carg2 *C.GstBuffer, carg3 *C.GstVideoFrame) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstVideoAggregatorPad, carg1 *C.GstVideoAggregator, carg2 *C.GstBuffer, carg3 *C.GstVideoFrame) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstvideo1_VideoAggregatorPad_prepare_frame").(func(carg0 *C.GstVideoAggregatorPad, carg1 *C.GstVideoAggregator, carg2 *C.GstBuffer, carg3 *C.GstVideoFrame) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstvideo1_VideoAggregatorPad_prepare_frame: no function pointer found") + } + } + return fn(carg0, carg1, carg2, carg3) } //export _gotk4_gstvideo1_VideoAggregatorPad_prepare_frame_finish func _gotk4_gstvideo1_VideoAggregatorPad_prepare_frame_finish(carg0 *C.GstVideoAggregatorPad, carg1 *C.GstVideoAggregator, carg2 *C.GstVideoFrame) { - panic("unimplemented") + var fn func(carg0 *C.GstVideoAggregatorPad, carg1 *C.GstVideoAggregator, carg2 *C.GstVideoFrame) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstvideo1_VideoAggregatorPad_prepare_frame_finish").(func(carg0 *C.GstVideoAggregatorPad, carg1 *C.GstVideoAggregator, carg2 *C.GstVideoFrame)) + if fn == nil { + panic("_gotk4_gstvideo1_VideoAggregatorPad_prepare_frame_finish: no function pointer found") + } + } + fn(carg0, carg1, carg2) } //export _gotk4_gstvideo1_VideoAggregatorPad_prepare_frame_start func _gotk4_gstvideo1_VideoAggregatorPad_prepare_frame_start(carg0 *C.GstVideoAggregatorPad, carg1 *C.GstVideoAggregator, carg2 *C.GstBuffer, carg3 *C.GstVideoFrame) { - panic("unimplemented") + var fn func(carg0 *C.GstVideoAggregatorPad, carg1 *C.GstVideoAggregator, carg2 *C.GstBuffer, carg3 *C.GstVideoFrame) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstvideo1_VideoAggregatorPad_prepare_frame_start").(func(carg0 *C.GstVideoAggregatorPad, carg1 *C.GstVideoAggregator, carg2 *C.GstBuffer, carg3 *C.GstVideoFrame)) + if fn == nil { + panic("_gotk4_gstvideo1_VideoAggregatorPad_prepare_frame_start: no function pointer found") + } + } + fn(carg0, carg1, carg2, carg3) } //export _gotk4_gstvideo1_VideoAggregatorPad_update_conversion_info func _gotk4_gstvideo1_VideoAggregatorPad_update_conversion_info(carg0 *C.GstVideoAggregatorPad) { - panic("unimplemented") + var fn func(carg0 *C.GstVideoAggregatorPad) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstvideo1_VideoAggregatorPad_update_conversion_info").(func(carg0 *C.GstVideoAggregatorPad)) + if fn == nil { + panic("_gotk4_gstvideo1_VideoAggregatorPad_update_conversion_info: no function pointer found") + } + } + fn(carg0) } //export _gotk4_gstvideo1_VideoDecoder_close func _gotk4_gstvideo1_VideoDecoder_close(carg0 *C.GstVideoDecoder) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstVideoDecoder) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstvideo1_VideoDecoder_close").(func(carg0 *C.GstVideoDecoder) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstvideo1_VideoDecoder_close: no function pointer found") + } + } + return fn(carg0) } //export _gotk4_gstvideo1_VideoDecoder_decide_allocation func _gotk4_gstvideo1_VideoDecoder_decide_allocation(carg0 *C.GstVideoDecoder, carg1 *C.GstQuery) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstVideoDecoder, carg1 *C.GstQuery) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstvideo1_VideoDecoder_decide_allocation").(func(carg0 *C.GstVideoDecoder, carg1 *C.GstQuery) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstvideo1_VideoDecoder_decide_allocation: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstvideo1_VideoDecoder_drain func _gotk4_gstvideo1_VideoDecoder_drain(carg0 *C.GstVideoDecoder) (cret C.GstFlowReturn) { - panic("unimplemented") + var fn func(carg0 *C.GstVideoDecoder) (cret C.GstFlowReturn) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstvideo1_VideoDecoder_drain").(func(carg0 *C.GstVideoDecoder) (cret C.GstFlowReturn)) + if fn == nil { + panic("_gotk4_gstvideo1_VideoDecoder_drain: no function pointer found") + } + } + return fn(carg0) } //export _gotk4_gstvideo1_VideoDecoder_finish func _gotk4_gstvideo1_VideoDecoder_finish(carg0 *C.GstVideoDecoder) (cret C.GstFlowReturn) { - panic("unimplemented") + var fn func(carg0 *C.GstVideoDecoder) (cret C.GstFlowReturn) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstvideo1_VideoDecoder_finish").(func(carg0 *C.GstVideoDecoder) (cret C.GstFlowReturn)) + if fn == nil { + panic("_gotk4_gstvideo1_VideoDecoder_finish: no function pointer found") + } + } + return fn(carg0) } //export _gotk4_gstvideo1_VideoDecoder_flush func _gotk4_gstvideo1_VideoDecoder_flush(carg0 *C.GstVideoDecoder) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstVideoDecoder) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstvideo1_VideoDecoder_flush").(func(carg0 *C.GstVideoDecoder) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstvideo1_VideoDecoder_flush: no function pointer found") + } + } + return fn(carg0) } //export _gotk4_gstvideo1_VideoDecoder_getcaps func _gotk4_gstvideo1_VideoDecoder_getcaps(carg0 *C.GstVideoDecoder, carg1 *C.GstCaps) (cret *C.GstCaps) { - panic("unimplemented") + var fn func(carg0 *C.GstVideoDecoder, carg1 *C.GstCaps) (cret *C.GstCaps) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstvideo1_VideoDecoder_getcaps").(func(carg0 *C.GstVideoDecoder, carg1 *C.GstCaps) (cret *C.GstCaps)) + if fn == nil { + panic("_gotk4_gstvideo1_VideoDecoder_getcaps: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstvideo1_VideoDecoder_handle_frame func _gotk4_gstvideo1_VideoDecoder_handle_frame(carg0 *C.GstVideoDecoder, carg1 *C.GstVideoCodecFrame) (cret C.GstFlowReturn) { - panic("unimplemented") + var fn func(carg0 *C.GstVideoDecoder, carg1 *C.GstVideoCodecFrame) (cret C.GstFlowReturn) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstvideo1_VideoDecoder_handle_frame").(func(carg0 *C.GstVideoDecoder, carg1 *C.GstVideoCodecFrame) (cret C.GstFlowReturn)) + if fn == nil { + panic("_gotk4_gstvideo1_VideoDecoder_handle_frame: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstvideo1_VideoDecoder_handle_missing_data func _gotk4_gstvideo1_VideoDecoder_handle_missing_data(carg0 *C.GstVideoDecoder, carg1 C.GstClockTime, carg2 C.GstClockTime) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstVideoDecoder, carg1 C.GstClockTime, carg2 C.GstClockTime) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstvideo1_VideoDecoder_handle_missing_data").(func(carg0 *C.GstVideoDecoder, carg1 C.GstClockTime, carg2 C.GstClockTime) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstvideo1_VideoDecoder_handle_missing_data: no function pointer found") + } + } + return fn(carg0, carg1, carg2) } //export _gotk4_gstvideo1_VideoDecoder_negotiate func _gotk4_gstvideo1_VideoDecoder_negotiate(carg0 *C.GstVideoDecoder) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstVideoDecoder) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstvideo1_VideoDecoder_negotiate").(func(carg0 *C.GstVideoDecoder) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstvideo1_VideoDecoder_negotiate: no function pointer found") + } + } + return fn(carg0) } //export _gotk4_gstvideo1_VideoDecoder_open func _gotk4_gstvideo1_VideoDecoder_open(carg0 *C.GstVideoDecoder) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstVideoDecoder) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstvideo1_VideoDecoder_open").(func(carg0 *C.GstVideoDecoder) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstvideo1_VideoDecoder_open: no function pointer found") + } + } + return fn(carg0) } //export _gotk4_gstvideo1_VideoDecoder_parse func _gotk4_gstvideo1_VideoDecoder_parse(carg0 *C.GstVideoDecoder, carg1 *C.GstVideoCodecFrame, carg2 *C.GstAdapter, carg3 C.gboolean) (cret C.GstFlowReturn) { - panic("unimplemented") + var fn func(carg0 *C.GstVideoDecoder, carg1 *C.GstVideoCodecFrame, carg2 *C.GstAdapter, carg3 C.gboolean) (cret C.GstFlowReturn) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstvideo1_VideoDecoder_parse").(func(carg0 *C.GstVideoDecoder, carg1 *C.GstVideoCodecFrame, carg2 *C.GstAdapter, carg3 C.gboolean) (cret C.GstFlowReturn)) + if fn == nil { + panic("_gotk4_gstvideo1_VideoDecoder_parse: no function pointer found") + } + } + return fn(carg0, carg1, carg2, carg3) } //export _gotk4_gstvideo1_VideoDecoder_propose_allocation func _gotk4_gstvideo1_VideoDecoder_propose_allocation(carg0 *C.GstVideoDecoder, carg1 *C.GstQuery) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstVideoDecoder, carg1 *C.GstQuery) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstvideo1_VideoDecoder_propose_allocation").(func(carg0 *C.GstVideoDecoder, carg1 *C.GstQuery) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstvideo1_VideoDecoder_propose_allocation: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstvideo1_VideoDecoder_reset func _gotk4_gstvideo1_VideoDecoder_reset(carg0 *C.GstVideoDecoder, carg1 C.gboolean) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstVideoDecoder, carg1 C.gboolean) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstvideo1_VideoDecoder_reset").(func(carg0 *C.GstVideoDecoder, carg1 C.gboolean) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstvideo1_VideoDecoder_reset: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstvideo1_VideoDecoder_set_format func _gotk4_gstvideo1_VideoDecoder_set_format(carg0 *C.GstVideoDecoder, carg1 *C.GstVideoCodecState) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstVideoDecoder, carg1 *C.GstVideoCodecState) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstvideo1_VideoDecoder_set_format").(func(carg0 *C.GstVideoDecoder, carg1 *C.GstVideoCodecState) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstvideo1_VideoDecoder_set_format: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstvideo1_VideoDecoder_sink_event func _gotk4_gstvideo1_VideoDecoder_sink_event(carg0 *C.GstVideoDecoder, carg1 *C.GstEvent) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstVideoDecoder, carg1 *C.GstEvent) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstvideo1_VideoDecoder_sink_event").(func(carg0 *C.GstVideoDecoder, carg1 *C.GstEvent) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstvideo1_VideoDecoder_sink_event: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstvideo1_VideoDecoder_sink_query func _gotk4_gstvideo1_VideoDecoder_sink_query(carg0 *C.GstVideoDecoder, carg1 *C.GstQuery) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstVideoDecoder, carg1 *C.GstQuery) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstvideo1_VideoDecoder_sink_query").(func(carg0 *C.GstVideoDecoder, carg1 *C.GstQuery) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstvideo1_VideoDecoder_sink_query: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstvideo1_VideoDecoder_src_event func _gotk4_gstvideo1_VideoDecoder_src_event(carg0 *C.GstVideoDecoder, carg1 *C.GstEvent) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstVideoDecoder, carg1 *C.GstEvent) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstvideo1_VideoDecoder_src_event").(func(carg0 *C.GstVideoDecoder, carg1 *C.GstEvent) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstvideo1_VideoDecoder_src_event: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstvideo1_VideoDecoder_src_query func _gotk4_gstvideo1_VideoDecoder_src_query(carg0 *C.GstVideoDecoder, carg1 *C.GstQuery) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstVideoDecoder, carg1 *C.GstQuery) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstvideo1_VideoDecoder_src_query").(func(carg0 *C.GstVideoDecoder, carg1 *C.GstQuery) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstvideo1_VideoDecoder_src_query: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstvideo1_VideoDecoder_start func _gotk4_gstvideo1_VideoDecoder_start(carg0 *C.GstVideoDecoder) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstVideoDecoder) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstvideo1_VideoDecoder_start").(func(carg0 *C.GstVideoDecoder) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstvideo1_VideoDecoder_start: no function pointer found") + } + } + return fn(carg0) } //export _gotk4_gstvideo1_VideoDecoder_stop func _gotk4_gstvideo1_VideoDecoder_stop(carg0 *C.GstVideoDecoder) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstVideoDecoder) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstvideo1_VideoDecoder_stop").(func(carg0 *C.GstVideoDecoder) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstvideo1_VideoDecoder_stop: no function pointer found") + } + } + return fn(carg0) } //export _gotk4_gstvideo1_VideoDecoder_transform_meta func _gotk4_gstvideo1_VideoDecoder_transform_meta(carg0 *C.GstVideoDecoder, carg1 *C.GstVideoCodecFrame, carg2 *C.GstMeta) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstVideoDecoder, carg1 *C.GstVideoCodecFrame, carg2 *C.GstMeta) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstvideo1_VideoDecoder_transform_meta").(func(carg0 *C.GstVideoDecoder, carg1 *C.GstVideoCodecFrame, carg2 *C.GstMeta) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstvideo1_VideoDecoder_transform_meta: no function pointer found") + } + } + return fn(carg0, carg1, carg2) } //export _gotk4_gstvideo1_VideoEncoder_close func _gotk4_gstvideo1_VideoEncoder_close(carg0 *C.GstVideoEncoder) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstVideoEncoder) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstvideo1_VideoEncoder_close").(func(carg0 *C.GstVideoEncoder) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstvideo1_VideoEncoder_close: no function pointer found") + } + } + return fn(carg0) } //export _gotk4_gstvideo1_VideoEncoder_decide_allocation func _gotk4_gstvideo1_VideoEncoder_decide_allocation(carg0 *C.GstVideoEncoder, carg1 *C.GstQuery) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstVideoEncoder, carg1 *C.GstQuery) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstvideo1_VideoEncoder_decide_allocation").(func(carg0 *C.GstVideoEncoder, carg1 *C.GstQuery) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstvideo1_VideoEncoder_decide_allocation: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstvideo1_VideoEncoder_finish func _gotk4_gstvideo1_VideoEncoder_finish(carg0 *C.GstVideoEncoder) (cret C.GstFlowReturn) { - panic("unimplemented") + var fn func(carg0 *C.GstVideoEncoder) (cret C.GstFlowReturn) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstvideo1_VideoEncoder_finish").(func(carg0 *C.GstVideoEncoder) (cret C.GstFlowReturn)) + if fn == nil { + panic("_gotk4_gstvideo1_VideoEncoder_finish: no function pointer found") + } + } + return fn(carg0) } //export _gotk4_gstvideo1_VideoEncoder_flush func _gotk4_gstvideo1_VideoEncoder_flush(carg0 *C.GstVideoEncoder) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstVideoEncoder) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstvideo1_VideoEncoder_flush").(func(carg0 *C.GstVideoEncoder) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstvideo1_VideoEncoder_flush: no function pointer found") + } + } + return fn(carg0) } //export _gotk4_gstvideo1_VideoEncoder_getcaps func _gotk4_gstvideo1_VideoEncoder_getcaps(carg0 *C.GstVideoEncoder, carg1 *C.GstCaps) (cret *C.GstCaps) { - panic("unimplemented") + var fn func(carg0 *C.GstVideoEncoder, carg1 *C.GstCaps) (cret *C.GstCaps) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstvideo1_VideoEncoder_getcaps").(func(carg0 *C.GstVideoEncoder, carg1 *C.GstCaps) (cret *C.GstCaps)) + if fn == nil { + panic("_gotk4_gstvideo1_VideoEncoder_getcaps: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstvideo1_VideoEncoder_handle_frame func _gotk4_gstvideo1_VideoEncoder_handle_frame(carg0 *C.GstVideoEncoder, carg1 *C.GstVideoCodecFrame) (cret C.GstFlowReturn) { - panic("unimplemented") + var fn func(carg0 *C.GstVideoEncoder, carg1 *C.GstVideoCodecFrame) (cret C.GstFlowReturn) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstvideo1_VideoEncoder_handle_frame").(func(carg0 *C.GstVideoEncoder, carg1 *C.GstVideoCodecFrame) (cret C.GstFlowReturn)) + if fn == nil { + panic("_gotk4_gstvideo1_VideoEncoder_handle_frame: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstvideo1_VideoEncoder_negotiate func _gotk4_gstvideo1_VideoEncoder_negotiate(carg0 *C.GstVideoEncoder) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstVideoEncoder) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstvideo1_VideoEncoder_negotiate").(func(carg0 *C.GstVideoEncoder) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstvideo1_VideoEncoder_negotiate: no function pointer found") + } + } + return fn(carg0) } //export _gotk4_gstvideo1_VideoEncoder_open func _gotk4_gstvideo1_VideoEncoder_open(carg0 *C.GstVideoEncoder) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstVideoEncoder) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstvideo1_VideoEncoder_open").(func(carg0 *C.GstVideoEncoder) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstvideo1_VideoEncoder_open: no function pointer found") + } + } + return fn(carg0) } //export _gotk4_gstvideo1_VideoEncoder_pre_push func _gotk4_gstvideo1_VideoEncoder_pre_push(carg0 *C.GstVideoEncoder, carg1 *C.GstVideoCodecFrame) (cret C.GstFlowReturn) { - panic("unimplemented") + var fn func(carg0 *C.GstVideoEncoder, carg1 *C.GstVideoCodecFrame) (cret C.GstFlowReturn) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstvideo1_VideoEncoder_pre_push").(func(carg0 *C.GstVideoEncoder, carg1 *C.GstVideoCodecFrame) (cret C.GstFlowReturn)) + if fn == nil { + panic("_gotk4_gstvideo1_VideoEncoder_pre_push: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstvideo1_VideoEncoder_propose_allocation func _gotk4_gstvideo1_VideoEncoder_propose_allocation(carg0 *C.GstVideoEncoder, carg1 *C.GstQuery) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstVideoEncoder, carg1 *C.GstQuery) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstvideo1_VideoEncoder_propose_allocation").(func(carg0 *C.GstVideoEncoder, carg1 *C.GstQuery) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstvideo1_VideoEncoder_propose_allocation: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstvideo1_VideoEncoder_reset func _gotk4_gstvideo1_VideoEncoder_reset(carg0 *C.GstVideoEncoder, carg1 C.gboolean) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstVideoEncoder, carg1 C.gboolean) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstvideo1_VideoEncoder_reset").(func(carg0 *C.GstVideoEncoder, carg1 C.gboolean) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstvideo1_VideoEncoder_reset: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstvideo1_VideoEncoder_set_format func _gotk4_gstvideo1_VideoEncoder_set_format(carg0 *C.GstVideoEncoder, carg1 *C.GstVideoCodecState) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstVideoEncoder, carg1 *C.GstVideoCodecState) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstvideo1_VideoEncoder_set_format").(func(carg0 *C.GstVideoEncoder, carg1 *C.GstVideoCodecState) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstvideo1_VideoEncoder_set_format: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstvideo1_VideoEncoder_sink_event func _gotk4_gstvideo1_VideoEncoder_sink_event(carg0 *C.GstVideoEncoder, carg1 *C.GstEvent) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstVideoEncoder, carg1 *C.GstEvent) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstvideo1_VideoEncoder_sink_event").(func(carg0 *C.GstVideoEncoder, carg1 *C.GstEvent) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstvideo1_VideoEncoder_sink_event: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstvideo1_VideoEncoder_sink_query func _gotk4_gstvideo1_VideoEncoder_sink_query(carg0 *C.GstVideoEncoder, carg1 *C.GstQuery) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstVideoEncoder, carg1 *C.GstQuery) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstvideo1_VideoEncoder_sink_query").(func(carg0 *C.GstVideoEncoder, carg1 *C.GstQuery) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstvideo1_VideoEncoder_sink_query: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstvideo1_VideoEncoder_src_event func _gotk4_gstvideo1_VideoEncoder_src_event(carg0 *C.GstVideoEncoder, carg1 *C.GstEvent) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstVideoEncoder, carg1 *C.GstEvent) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstvideo1_VideoEncoder_src_event").(func(carg0 *C.GstVideoEncoder, carg1 *C.GstEvent) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstvideo1_VideoEncoder_src_event: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstvideo1_VideoEncoder_src_query func _gotk4_gstvideo1_VideoEncoder_src_query(carg0 *C.GstVideoEncoder, carg1 *C.GstQuery) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstVideoEncoder, carg1 *C.GstQuery) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstvideo1_VideoEncoder_src_query").(func(carg0 *C.GstVideoEncoder, carg1 *C.GstQuery) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstvideo1_VideoEncoder_src_query: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstvideo1_VideoEncoder_start func _gotk4_gstvideo1_VideoEncoder_start(carg0 *C.GstVideoEncoder) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstVideoEncoder) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstvideo1_VideoEncoder_start").(func(carg0 *C.GstVideoEncoder) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstvideo1_VideoEncoder_start: no function pointer found") + } + } + return fn(carg0) } //export _gotk4_gstvideo1_VideoEncoder_stop func _gotk4_gstvideo1_VideoEncoder_stop(carg0 *C.GstVideoEncoder) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstVideoEncoder) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstvideo1_VideoEncoder_stop").(func(carg0 *C.GstVideoEncoder) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstvideo1_VideoEncoder_stop: no function pointer found") + } + } + return fn(carg0) } //export _gotk4_gstvideo1_VideoEncoder_transform_meta func _gotk4_gstvideo1_VideoEncoder_transform_meta(carg0 *C.GstVideoEncoder, carg1 *C.GstVideoCodecFrame, carg2 *C.GstMeta) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstVideoEncoder, carg1 *C.GstVideoCodecFrame, carg2 *C.GstMeta) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstvideo1_VideoEncoder_transform_meta").(func(carg0 *C.GstVideoEncoder, carg1 *C.GstVideoCodecFrame, carg2 *C.GstMeta) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstvideo1_VideoEncoder_transform_meta: no function pointer found") + } + } + return fn(carg0, carg1, carg2) } //export _gotk4_gstvideo1_VideoFilter_set_info func _gotk4_gstvideo1_VideoFilter_set_info(carg0 *C.GstVideoFilter, carg1 *C.GstCaps, carg2 *C.GstVideoInfo, carg3 *C.GstCaps, carg4 *C.GstVideoInfo) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstVideoFilter, carg1 *C.GstCaps, carg2 *C.GstVideoInfo, carg3 *C.GstCaps, carg4 *C.GstVideoInfo) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstvideo1_VideoFilter_set_info").(func(carg0 *C.GstVideoFilter, carg1 *C.GstCaps, carg2 *C.GstVideoInfo, carg3 *C.GstCaps, carg4 *C.GstVideoInfo) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstvideo1_VideoFilter_set_info: no function pointer found") + } + } + return fn(carg0, carg1, carg2, carg3, carg4) } //export _gotk4_gstvideo1_VideoFilter_transform_frame func _gotk4_gstvideo1_VideoFilter_transform_frame(carg0 *C.GstVideoFilter, carg1 *C.GstVideoFrame, carg2 *C.GstVideoFrame) (cret C.GstFlowReturn) { - panic("unimplemented") + var fn func(carg0 *C.GstVideoFilter, carg1 *C.GstVideoFrame, carg2 *C.GstVideoFrame) (cret C.GstFlowReturn) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstvideo1_VideoFilter_transform_frame").(func(carg0 *C.GstVideoFilter, carg1 *C.GstVideoFrame, carg2 *C.GstVideoFrame) (cret C.GstFlowReturn)) + if fn == nil { + panic("_gotk4_gstvideo1_VideoFilter_transform_frame: no function pointer found") + } + } + return fn(carg0, carg1, carg2) } //export _gotk4_gstvideo1_VideoFilter_transform_frame_ip func _gotk4_gstvideo1_VideoFilter_transform_frame_ip(carg0 *C.GstVideoFilter, carg1 *C.GstVideoFrame) (cret C.GstFlowReturn) { - panic("unimplemented") + var fn func(carg0 *C.GstVideoFilter, carg1 *C.GstVideoFrame) (cret C.GstFlowReturn) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstvideo1_VideoFilter_transform_frame_ip").(func(carg0 *C.GstVideoFilter, carg1 *C.GstVideoFrame) (cret C.GstFlowReturn)) + if fn == nil { + panic("_gotk4_gstvideo1_VideoFilter_transform_frame_ip: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstvideo1_VideoSink_set_info func _gotk4_gstvideo1_VideoSink_set_info(carg0 *C.GstVideoSink, carg1 *C.GstCaps, carg2 *C.GstVideoInfo) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstVideoSink, carg1 *C.GstCaps, carg2 *C.GstVideoInfo) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstvideo1_VideoSink_set_info").(func(carg0 *C.GstVideoSink, carg1 *C.GstCaps, carg2 *C.GstVideoInfo) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstvideo1_VideoSink_set_info: no function pointer found") + } + } + return fn(carg0, carg1, carg2) } //export _gotk4_gstvideo1_VideoSink_show_frame func _gotk4_gstvideo1_VideoSink_show_frame(carg0 *C.GstVideoSink, carg1 *C.GstBuffer) (cret C.GstFlowReturn) { - panic("unimplemented") + var fn func(carg0 *C.GstVideoSink, carg1 *C.GstBuffer) (cret C.GstFlowReturn) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstvideo1_VideoSink_show_frame").(func(carg0 *C.GstVideoSink, carg1 *C.GstBuffer) (cret C.GstFlowReturn)) + if fn == nil { + panic("_gotk4_gstvideo1_VideoSink_show_frame: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstvideo1_VideoAggregatorConvertPad_create_conversion_info func _gotk4_gstvideo1_VideoAggregatorConvertPad_create_conversion_info(carg0 *C.GstVideoAggregatorConvertPad, carg1 *C.GstVideoAggregator, carg2 *C.GstVideoInfo) { - panic("unimplemented") + var fn func(carg0 *C.GstVideoAggregatorConvertPad, carg1 *C.GstVideoAggregator, carg2 *C.GstVideoInfo) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstvideo1_VideoAggregatorConvertPad_create_conversion_info").(func(carg0 *C.GstVideoAggregatorConvertPad, carg1 *C.GstVideoAggregator, carg2 *C.GstVideoInfo)) + if fn == nil { + panic("_gotk4_gstvideo1_VideoAggregatorConvertPad_create_conversion_info: no function pointer found") + } + } + fn(carg0, carg1, carg2) } diff --git a/pkg/gstwebrtc/gstwebrtc.gen.go b/pkg/gstwebrtc/gstwebrtc.gen.go index 7f5fed7..419131d 100644 --- a/pkg/gstwebrtc/gstwebrtc.gen.go +++ b/pkg/gstwebrtc/gstwebrtc.gen.go @@ -8,6 +8,7 @@ import ( "runtime" "unsafe" + "github.com/diamondburned/gotk4/pkg/core/classdata" "github.com/diamondburned/gotk4/pkg/core/userdata" "github.com/diamondburned/gotk4/pkg/glib/v2" "github.com/diamondburned/gotk4/pkg/gobject/v2" @@ -2462,81 +2463,457 @@ func UnsafeApplyWebRTCICEOverrides[Instance WebRTCICE](gclass unsafe.Pointer, ov if overrides.AddCandidate != nil { pclass.add_candidate = (*[0]byte)(C._gotk4_gstwebrtc1_WebRTCICE_add_candidate) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstwebrtc1_WebRTCICE_add_candidate", + func(carg0 *C.GstWebRTCICE, carg1 *C.GstWebRTCICEStream, carg2 *C.gchar, carg3 *C.GstPromise) { + var ice Instance // go GstWebRTCICE subclass + var stream WebRTCICEStream // in, none, converted + var candidate string // in, none, string + var promise *gst.Promise // in, none, converted, nullable + + ice = UnsafeWebRTCICEFromGlibNone(unsafe.Pointer(carg0)).(Instance) + stream = UnsafeWebRTCICEStreamFromGlibNone(unsafe.Pointer(carg1)) + candidate = C.GoString((*C.char)(unsafe.Pointer(carg2))) + if carg3 != nil { + promise = gst.UnsafePromiseFromGlibNone(unsafe.Pointer(carg3)) + } + + overrides.AddCandidate(ice, stream, candidate, promise) + }, + ) } if overrides.AddStream != nil { pclass.add_stream = (*[0]byte)(C._gotk4_gstwebrtc1_WebRTCICE_add_stream) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstwebrtc1_WebRTCICE_add_stream", + func(carg0 *C.GstWebRTCICE, carg1 C.guint) (cret *C.GstWebRTCICEStream) { + var ice Instance // go GstWebRTCICE subclass + var sessionId uint // in, none, casted + var goret WebRTCICEStream // return, full, converted, nullable + + ice = UnsafeWebRTCICEFromGlibNone(unsafe.Pointer(carg0)).(Instance) + sessionId = uint(carg1) + + goret = overrides.AddStream(ice, sessionId) + + if goret != nil { + cret = (*C.GstWebRTCICEStream)(UnsafeWebRTCICEStreamToGlibFull(goret)) + } + + return cret + }, + ) } if overrides.AddTurnServer != nil { pclass.add_turn_server = (*[0]byte)(C._gotk4_gstwebrtc1_WebRTCICE_add_turn_server) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstwebrtc1_WebRTCICE_add_turn_server", + func(carg0 *C.GstWebRTCICE, carg1 *C.gchar) (cret C.gboolean) { + var ice Instance // go GstWebRTCICE subclass + var uri string // in, none, string + var goret bool // return + + ice = UnsafeWebRTCICEFromGlibNone(unsafe.Pointer(carg0)).(Instance) + uri = C.GoString((*C.char)(unsafe.Pointer(carg1))) + + goret = overrides.AddTurnServer(ice, uri) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.FindTransport != nil { pclass.find_transport = (*[0]byte)(C._gotk4_gstwebrtc1_WebRTCICE_find_transport) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstwebrtc1_WebRTCICE_find_transport", + func(carg0 *C.GstWebRTCICE, carg1 *C.GstWebRTCICEStream, carg2 C.GstWebRTCICEComponent) (cret *C.GstWebRTCICETransport) { + var ice Instance // go GstWebRTCICE subclass + var stream WebRTCICEStream // in, none, converted + var component WebRTCICEComponent // in, none, casted + var goret WebRTCICETransport // return, full, converted, nullable + + ice = UnsafeWebRTCICEFromGlibNone(unsafe.Pointer(carg0)).(Instance) + stream = UnsafeWebRTCICEStreamFromGlibNone(unsafe.Pointer(carg1)) + component = WebRTCICEComponent(carg2) + + goret = overrides.FindTransport(ice, stream, component) + + if goret != nil { + cret = (*C.GstWebRTCICETransport)(UnsafeWebRTCICETransportToGlibFull(goret)) + } + + return cret + }, + ) } if overrides.GatherCandidates != nil { pclass.gather_candidates = (*[0]byte)(C._gotk4_gstwebrtc1_WebRTCICE_gather_candidates) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstwebrtc1_WebRTCICE_gather_candidates", + func(carg0 *C.GstWebRTCICE, carg1 *C.GstWebRTCICEStream) (cret C.gboolean) { + var ice Instance // go GstWebRTCICE subclass + var stream WebRTCICEStream // in, none, converted + var goret bool // return + + ice = UnsafeWebRTCICEFromGlibNone(unsafe.Pointer(carg0)).(Instance) + stream = UnsafeWebRTCICEStreamFromGlibNone(unsafe.Pointer(carg1)) + + goret = overrides.GatherCandidates(ice, stream) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.GetHTTPProxy != nil { pclass.get_http_proxy = (*[0]byte)(C._gotk4_gstwebrtc1_WebRTCICE_get_http_proxy) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstwebrtc1_WebRTCICE_get_http_proxy", + func(carg0 *C.GstWebRTCICE) (cret *C.gchar) { + var ice Instance // go GstWebRTCICE subclass + var goret string // return, full, string + + ice = UnsafeWebRTCICEFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + goret = overrides.GetHTTPProxy(ice) + + cret = (*C.gchar)(unsafe.Pointer(C.CString(goret))) + + return cret + }, + ) } if overrides.GetIsController != nil { pclass.get_is_controller = (*[0]byte)(C._gotk4_gstwebrtc1_WebRTCICE_get_is_controller) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstwebrtc1_WebRTCICE_get_is_controller", + func(carg0 *C.GstWebRTCICE) (cret C.gboolean) { + var ice Instance // go GstWebRTCICE subclass + var goret bool // return + + ice = UnsafeWebRTCICEFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + goret = overrides.GetIsController(ice) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.GetSelectedPair != nil { pclass.get_selected_pair = (*[0]byte)(C._gotk4_gstwebrtc1_WebRTCICE_get_selected_pair) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstwebrtc1_WebRTCICE_get_selected_pair", + func(carg0 *C.GstWebRTCICE, carg1 *C.GstWebRTCICEStream, carg2 **C.GstWebRTCICECandidateStats, carg3 **C.GstWebRTCICECandidateStats) (cret C.gboolean) { + var ice Instance // go GstWebRTCICE subclass + var stream WebRTCICEStream // in, none, converted + var localStats *WebRTCICECandidateStats // out, full, converted + var remoteStats *WebRTCICECandidateStats // out, full, converted + var goret bool // return + + ice = UnsafeWebRTCICEFromGlibNone(unsafe.Pointer(carg0)).(Instance) + stream = UnsafeWebRTCICEStreamFromGlibNone(unsafe.Pointer(carg1)) + + localStats, remoteStats, goret = overrides.GetSelectedPair(ice, stream) + + *carg2 = (*C.GstWebRTCICECandidateStats)(UnsafeWebRTCICECandidateStatsToGlibFull(localStats)) + *carg3 = (*C.GstWebRTCICECandidateStats)(UnsafeWebRTCICECandidateStatsToGlibFull(remoteStats)) + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.GetStunServer != nil { pclass.get_stun_server = (*[0]byte)(C._gotk4_gstwebrtc1_WebRTCICE_get_stun_server) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstwebrtc1_WebRTCICE_get_stun_server", + func(carg0 *C.GstWebRTCICE) (cret *C.gchar) { + var ice Instance // go GstWebRTCICE subclass + var goret string // return, full, string, nullable-string + + ice = UnsafeWebRTCICEFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + goret = overrides.GetStunServer(ice) + + if goret != "" { + cret = (*C.gchar)(unsafe.Pointer(C.CString(goret))) + } + + return cret + }, + ) } if overrides.GetTurnServer != nil { pclass.get_turn_server = (*[0]byte)(C._gotk4_gstwebrtc1_WebRTCICE_get_turn_server) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstwebrtc1_WebRTCICE_get_turn_server", + func(carg0 *C.GstWebRTCICE) (cret *C.gchar) { + var ice Instance // go GstWebRTCICE subclass + var goret string // return, full, string, nullable-string + + ice = UnsafeWebRTCICEFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + goret = overrides.GetTurnServer(ice) + + if goret != "" { + cret = (*C.gchar)(unsafe.Pointer(C.CString(goret))) + } + + return cret + }, + ) } if overrides.SetForceRelay != nil { pclass.set_force_relay = (*[0]byte)(C._gotk4_gstwebrtc1_WebRTCICE_set_force_relay) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstwebrtc1_WebRTCICE_set_force_relay", + func(carg0 *C.GstWebRTCICE, carg1 C.gboolean) { + var ice Instance // go GstWebRTCICE subclass + var forceRelay bool // in + + ice = UnsafeWebRTCICEFromGlibNone(unsafe.Pointer(carg0)).(Instance) + if carg1 != 0 { + forceRelay = true + } + + overrides.SetForceRelay(ice, forceRelay) + }, + ) } if overrides.SetHTTPProxy != nil { pclass.set_http_proxy = (*[0]byte)(C._gotk4_gstwebrtc1_WebRTCICE_set_http_proxy) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstwebrtc1_WebRTCICE_set_http_proxy", + func(carg0 *C.GstWebRTCICE, carg1 *C.gchar) { + var ice Instance // go GstWebRTCICE subclass + var uri string // in, none, string + + ice = UnsafeWebRTCICEFromGlibNone(unsafe.Pointer(carg0)).(Instance) + uri = C.GoString((*C.char)(unsafe.Pointer(carg1))) + + overrides.SetHTTPProxy(ice, uri) + }, + ) } if overrides.SetIsController != nil { pclass.set_is_controller = (*[0]byte)(C._gotk4_gstwebrtc1_WebRTCICE_set_is_controller) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstwebrtc1_WebRTCICE_set_is_controller", + func(carg0 *C.GstWebRTCICE, carg1 C.gboolean) { + var ice Instance // go GstWebRTCICE subclass + var controller bool // in + + ice = UnsafeWebRTCICEFromGlibNone(unsafe.Pointer(carg0)).(Instance) + if carg1 != 0 { + controller = true + } + + overrides.SetIsController(ice, controller) + }, + ) } if overrides.SetLocalCredentials != nil { pclass.set_local_credentials = (*[0]byte)(C._gotk4_gstwebrtc1_WebRTCICE_set_local_credentials) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstwebrtc1_WebRTCICE_set_local_credentials", + func(carg0 *C.GstWebRTCICE, carg1 *C.GstWebRTCICEStream, carg2 *C.gchar, carg3 *C.gchar) (cret C.gboolean) { + var ice Instance // go GstWebRTCICE subclass + var stream WebRTCICEStream // in, none, converted + var ufrag string // in, none, string + var pwd string // in, none, string + var goret bool // return + + ice = UnsafeWebRTCICEFromGlibNone(unsafe.Pointer(carg0)).(Instance) + stream = UnsafeWebRTCICEStreamFromGlibNone(unsafe.Pointer(carg1)) + ufrag = C.GoString((*C.char)(unsafe.Pointer(carg2))) + pwd = C.GoString((*C.char)(unsafe.Pointer(carg3))) + + goret = overrides.SetLocalCredentials(ice, stream, ufrag, pwd) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.SetOnIceCandidate != nil { pclass.set_on_ice_candidate = (*[0]byte)(C._gotk4_gstwebrtc1_WebRTCICE_set_on_ice_candidate) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstwebrtc1_WebRTCICE_set_on_ice_candidate", + func(carg0 *C.GstWebRTCICE, carg1 C.GstWebRTCICEOnCandidateFunc, carg2 C.gpointer, carg3 C.GDestroyNotify) { + var ice Instance // go GstWebRTCICE subclass + var fn WebRTCICEOnCandidateFunc // in, transfer: none, C Pointers: 0, Name: WebRTCICEOnCandidateFunc, scope: notified, closure: carg2, destroy: carg3 + + ice = UnsafeWebRTCICEFromGlibNone(unsafe.Pointer(carg0)).(Instance) + _ = fn + _ = carg1 + _ = _ + _ = carg2 + _ = notify + _ = carg3 + panic("unimplemented conversion of WebRTCICEOnCandidateFunc (GstWebRTCICEOnCandidateFunc)") + + overrides.SetOnIceCandidate(ice, fn) + }, + ) } if overrides.SetRemoteCredentials != nil { pclass.set_remote_credentials = (*[0]byte)(C._gotk4_gstwebrtc1_WebRTCICE_set_remote_credentials) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstwebrtc1_WebRTCICE_set_remote_credentials", + func(carg0 *C.GstWebRTCICE, carg1 *C.GstWebRTCICEStream, carg2 *C.gchar, carg3 *C.gchar) (cret C.gboolean) { + var ice Instance // go GstWebRTCICE subclass + var stream WebRTCICEStream // in, none, converted + var ufrag string // in, none, string + var pwd string // in, none, string + var goret bool // return + + ice = UnsafeWebRTCICEFromGlibNone(unsafe.Pointer(carg0)).(Instance) + stream = UnsafeWebRTCICEStreamFromGlibNone(unsafe.Pointer(carg1)) + ufrag = C.GoString((*C.char)(unsafe.Pointer(carg2))) + pwd = C.GoString((*C.char)(unsafe.Pointer(carg3))) + + goret = overrides.SetRemoteCredentials(ice, stream, ufrag, pwd) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } if overrides.SetStunServer != nil { pclass.set_stun_server = (*[0]byte)(C._gotk4_gstwebrtc1_WebRTCICE_set_stun_server) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstwebrtc1_WebRTCICE_set_stun_server", + func(carg0 *C.GstWebRTCICE, carg1 *C.gchar) { + var ice Instance // go GstWebRTCICE subclass + var uri string // in, none, string, nullable-string + + ice = UnsafeWebRTCICEFromGlibNone(unsafe.Pointer(carg0)).(Instance) + if carg1 != nil { + uri = C.GoString((*C.char)(unsafe.Pointer(carg1))) + } + + overrides.SetStunServer(ice, uri) + }, + ) } if overrides.SetTos != nil { pclass.set_tos = (*[0]byte)(C._gotk4_gstwebrtc1_WebRTCICE_set_tos) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstwebrtc1_WebRTCICE_set_tos", + func(carg0 *C.GstWebRTCICE, carg1 *C.GstWebRTCICEStream, carg2 C.guint) { + var ice Instance // go GstWebRTCICE subclass + var stream WebRTCICEStream // in, none, converted + var tos uint // in, none, casted + + ice = UnsafeWebRTCICEFromGlibNone(unsafe.Pointer(carg0)).(Instance) + stream = UnsafeWebRTCICEStreamFromGlibNone(unsafe.Pointer(carg1)) + tos = uint(carg2) + + overrides.SetTos(ice, stream, tos) + }, + ) } if overrides.SetTurnServer != nil { pclass.set_turn_server = (*[0]byte)(C._gotk4_gstwebrtc1_WebRTCICE_set_turn_server) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstwebrtc1_WebRTCICE_set_turn_server", + func(carg0 *C.GstWebRTCICE, carg1 *C.gchar) { + var ice Instance // go GstWebRTCICE subclass + var uri string // in, none, string, nullable-string + + ice = UnsafeWebRTCICEFromGlibNone(unsafe.Pointer(carg0)).(Instance) + if carg1 != nil { + uri = C.GoString((*C.char)(unsafe.Pointer(carg1))) + } + + overrides.SetTurnServer(ice, uri) + }, + ) } } +// RegisterWebRTCICESubClass is used to register a go subclass of GstWebRTCICE. For this to work safely please implement the +// virtual methods required by the implementation. +func RegisterWebRTCICESubClass[InstanceT WebRTCICE]( + name string, + classInit func(class *WebRTCICEClass), + constructor func() InstanceT, + overrides WebRTCICEOverrides[InstanceT], + signals map[string]gobject.SignalDefinition, + interfaceInits ...gobject.SubClassInterfaceInit[InstanceT], +) gobject.Type { + return gobject.UnsafeRegisterSubClass( + name, + classInit, + constructor, + overrides, + signals, + TypeWebRTCICE, + UnsafeWebRTCICEClassFromGlibBorrow, + UnsafeApplyWebRTCICEOverrides, + func (obj *gobject.ObjectInstance) gobject.Object { + return unsafeWrapWebRTCICE(obj) + }, + interfaceInits..., + ) +} + // WebRTCICEStreamInstance is the instance type used by all types extending GstWebRTCICEStream. It is used internally by the bindings. Users should use the interface [WebRTCICEStream] instead. type WebRTCICEStreamInstance struct { _ [0]func() // equal guard @@ -2690,13 +3067,77 @@ func UnsafeApplyWebRTCICEStreamOverrides[Instance WebRTCICEStream](gclass unsafe if overrides.FindTransport != nil { pclass.find_transport = (*[0]byte)(C._gotk4_gstwebrtc1_WebRTCICEStream_find_transport) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstwebrtc1_WebRTCICEStream_find_transport", + func(carg0 *C.GstWebRTCICEStream, carg1 C.GstWebRTCICEComponent) (cret *C.GstWebRTCICETransport) { + var stream Instance // go GstWebRTCICEStream subclass + var component WebRTCICEComponent // in, none, casted + var goret WebRTCICETransport // return, full, converted, nullable + + stream = UnsafeWebRTCICEStreamFromGlibNone(unsafe.Pointer(carg0)).(Instance) + component = WebRTCICEComponent(carg1) + + goret = overrides.FindTransport(stream, component) + + if goret != nil { + cret = (*C.GstWebRTCICETransport)(UnsafeWebRTCICETransportToGlibFull(goret)) + } + + return cret + }, + ) } if overrides.GatherCandidates != nil { pclass.gather_candidates = (*[0]byte)(C._gotk4_gstwebrtc1_WebRTCICEStream_gather_candidates) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstwebrtc1_WebRTCICEStream_gather_candidates", + func(carg0 *C.GstWebRTCICEStream) (cret C.gboolean) { + var ice Instance // go GstWebRTCICEStream subclass + var goret bool // return + + ice = UnsafeWebRTCICEStreamFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + goret = overrides.GatherCandidates(ice) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } } +// RegisterWebRTCICEStreamSubClass is used to register a go subclass of GstWebRTCICEStream. For this to work safely please implement the +// virtual methods required by the implementation. +func RegisterWebRTCICEStreamSubClass[InstanceT WebRTCICEStream]( + name string, + classInit func(class *WebRTCICEStreamClass), + constructor func() InstanceT, + overrides WebRTCICEStreamOverrides[InstanceT], + signals map[string]gobject.SignalDefinition, + interfaceInits ...gobject.SubClassInterfaceInit[InstanceT], +) gobject.Type { + return gobject.UnsafeRegisterSubClass( + name, + classInit, + constructor, + overrides, + signals, + TypeWebRTCICEStream, + UnsafeWebRTCICEStreamClassFromGlibBorrow, + UnsafeApplyWebRTCICEStreamOverrides, + func (obj *gobject.ObjectInstance) gobject.Object { + return unsafeWrapWebRTCICEStream(obj) + }, + interfaceInits..., + ) +} + // WebRTCICETransportInstance is the instance type used by all types extending GstWebRTCICETransport. It is used internally by the bindings. Users should use the interface [WebRTCICETransport] instead. type WebRTCICETransportInstance struct { _ [0]func() // equal guard @@ -2878,9 +3319,53 @@ func UnsafeApplyWebRTCICETransportOverrides[Instance WebRTCICETransport](gclass if overrides.GatherCandidates != nil { pclass.gather_candidates = (*[0]byte)(C._gotk4_gstwebrtc1_WebRTCICETransport_gather_candidates) + classdata.StoreVirtualMethod( + unsafe.Pointer(pclass), + "_gotk4_gstwebrtc1_WebRTCICETransport_gather_candidates", + func(carg0 *C.GstWebRTCICETransport) (cret C.gboolean) { + var transport Instance // go GstWebRTCICETransport subclass + var goret bool // return + + transport = UnsafeWebRTCICETransportFromGlibNone(unsafe.Pointer(carg0)).(Instance) + + goret = overrides.GatherCandidates(transport) + + if goret { + cret = C.TRUE + } + + return cret + }, + ) } } +// RegisterWebRTCICETransportSubClass is used to register a go subclass of GstWebRTCICETransport. For this to work safely please implement the +// virtual methods required by the implementation. +func RegisterWebRTCICETransportSubClass[InstanceT WebRTCICETransport]( + name string, + classInit func(class *WebRTCICETransportClass), + constructor func() InstanceT, + overrides WebRTCICETransportOverrides[InstanceT], + signals map[string]gobject.SignalDefinition, + interfaceInits ...gobject.SubClassInterfaceInit[InstanceT], +) gobject.Type { + return gobject.UnsafeRegisterSubClass( + name, + classInit, + constructor, + overrides, + signals, + TypeWebRTCICETransport, + UnsafeWebRTCICETransportClassFromGlibBorrow, + UnsafeApplyWebRTCICETransportOverrides, + func (obj *gobject.ObjectInstance) gobject.Object { + return unsafeWrapWebRTCICETransport(obj) + }, + interfaceInits..., + ) +} + // WebRTCRTPReceiverInstance is the instance type used by all types extending GstWebRTCRTPReceiver. It is used internally by the bindings. Users should use the interface [WebRTCRTPReceiver] instead. type WebRTCRTPReceiverInstance struct { _ [0]func() // equal guard diff --git a/pkg/gstwebrtc/gstwebrtc_export.gen.go b/pkg/gstwebrtc/gstwebrtc_export.gen.go index 8b1622f..ec6f318 100644 --- a/pkg/gstwebrtc/gstwebrtc_export.gen.go +++ b/pkg/gstwebrtc/gstwebrtc_export.gen.go @@ -5,6 +5,7 @@ package gstwebrtc import ( "unsafe" + "github.com/diamondburned/gotk4/pkg/core/classdata" "github.com/diamondburned/gotk4/pkg/core/userdata" ) @@ -36,111 +37,265 @@ func _gotk4_gstwebrtc1_WebRTCICEOnCandidateFunc(carg1 *C.GstWebRTCICE, carg2 C.g //export _gotk4_gstwebrtc1_WebRTCICE_add_candidate func _gotk4_gstwebrtc1_WebRTCICE_add_candidate(carg0 *C.GstWebRTCICE, carg1 *C.GstWebRTCICEStream, carg2 *C.gchar, carg3 *C.GstPromise) { - panic("unimplemented") + var fn func(carg0 *C.GstWebRTCICE, carg1 *C.GstWebRTCICEStream, carg2 *C.gchar, carg3 *C.GstPromise) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstwebrtc1_WebRTCICE_add_candidate").(func(carg0 *C.GstWebRTCICE, carg1 *C.GstWebRTCICEStream, carg2 *C.gchar, carg3 *C.GstPromise)) + if fn == nil { + panic("_gotk4_gstwebrtc1_WebRTCICE_add_candidate: no function pointer found") + } + } + fn(carg0, carg1, carg2, carg3) } //export _gotk4_gstwebrtc1_WebRTCICE_add_stream func _gotk4_gstwebrtc1_WebRTCICE_add_stream(carg0 *C.GstWebRTCICE, carg1 C.guint) (cret *C.GstWebRTCICEStream) { - panic("unimplemented") + var fn func(carg0 *C.GstWebRTCICE, carg1 C.guint) (cret *C.GstWebRTCICEStream) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstwebrtc1_WebRTCICE_add_stream").(func(carg0 *C.GstWebRTCICE, carg1 C.guint) (cret *C.GstWebRTCICEStream)) + if fn == nil { + panic("_gotk4_gstwebrtc1_WebRTCICE_add_stream: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstwebrtc1_WebRTCICE_add_turn_server func _gotk4_gstwebrtc1_WebRTCICE_add_turn_server(carg0 *C.GstWebRTCICE, carg1 *C.gchar) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstWebRTCICE, carg1 *C.gchar) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstwebrtc1_WebRTCICE_add_turn_server").(func(carg0 *C.GstWebRTCICE, carg1 *C.gchar) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstwebrtc1_WebRTCICE_add_turn_server: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstwebrtc1_WebRTCICE_find_transport func _gotk4_gstwebrtc1_WebRTCICE_find_transport(carg0 *C.GstWebRTCICE, carg1 *C.GstWebRTCICEStream, carg2 C.GstWebRTCICEComponent) (cret *C.GstWebRTCICETransport) { - panic("unimplemented") + var fn func(carg0 *C.GstWebRTCICE, carg1 *C.GstWebRTCICEStream, carg2 C.GstWebRTCICEComponent) (cret *C.GstWebRTCICETransport) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstwebrtc1_WebRTCICE_find_transport").(func(carg0 *C.GstWebRTCICE, carg1 *C.GstWebRTCICEStream, carg2 C.GstWebRTCICEComponent) (cret *C.GstWebRTCICETransport)) + if fn == nil { + panic("_gotk4_gstwebrtc1_WebRTCICE_find_transport: no function pointer found") + } + } + return fn(carg0, carg1, carg2) } //export _gotk4_gstwebrtc1_WebRTCICE_gather_candidates func _gotk4_gstwebrtc1_WebRTCICE_gather_candidates(carg0 *C.GstWebRTCICE, carg1 *C.GstWebRTCICEStream) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstWebRTCICE, carg1 *C.GstWebRTCICEStream) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstwebrtc1_WebRTCICE_gather_candidates").(func(carg0 *C.GstWebRTCICE, carg1 *C.GstWebRTCICEStream) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstwebrtc1_WebRTCICE_gather_candidates: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstwebrtc1_WebRTCICE_get_http_proxy func _gotk4_gstwebrtc1_WebRTCICE_get_http_proxy(carg0 *C.GstWebRTCICE) (cret *C.gchar) { - panic("unimplemented") + var fn func(carg0 *C.GstWebRTCICE) (cret *C.gchar) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstwebrtc1_WebRTCICE_get_http_proxy").(func(carg0 *C.GstWebRTCICE) (cret *C.gchar)) + if fn == nil { + panic("_gotk4_gstwebrtc1_WebRTCICE_get_http_proxy: no function pointer found") + } + } + return fn(carg0) } //export _gotk4_gstwebrtc1_WebRTCICE_get_is_controller func _gotk4_gstwebrtc1_WebRTCICE_get_is_controller(carg0 *C.GstWebRTCICE) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstWebRTCICE) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstwebrtc1_WebRTCICE_get_is_controller").(func(carg0 *C.GstWebRTCICE) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstwebrtc1_WebRTCICE_get_is_controller: no function pointer found") + } + } + return fn(carg0) } //export _gotk4_gstwebrtc1_WebRTCICE_get_selected_pair func _gotk4_gstwebrtc1_WebRTCICE_get_selected_pair(carg0 *C.GstWebRTCICE, carg1 *C.GstWebRTCICEStream, carg2 **C.GstWebRTCICECandidateStats, carg3 **C.GstWebRTCICECandidateStats) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstWebRTCICE, carg1 *C.GstWebRTCICEStream, carg2 **C.GstWebRTCICECandidateStats, carg3 **C.GstWebRTCICECandidateStats) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstwebrtc1_WebRTCICE_get_selected_pair").(func(carg0 *C.GstWebRTCICE, carg1 *C.GstWebRTCICEStream, carg2 **C.GstWebRTCICECandidateStats, carg3 **C.GstWebRTCICECandidateStats) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstwebrtc1_WebRTCICE_get_selected_pair: no function pointer found") + } + } + return fn(carg0, carg1, carg2, carg3) } //export _gotk4_gstwebrtc1_WebRTCICE_get_stun_server func _gotk4_gstwebrtc1_WebRTCICE_get_stun_server(carg0 *C.GstWebRTCICE) (cret *C.gchar) { - panic("unimplemented") + var fn func(carg0 *C.GstWebRTCICE) (cret *C.gchar) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstwebrtc1_WebRTCICE_get_stun_server").(func(carg0 *C.GstWebRTCICE) (cret *C.gchar)) + if fn == nil { + panic("_gotk4_gstwebrtc1_WebRTCICE_get_stun_server: no function pointer found") + } + } + return fn(carg0) } //export _gotk4_gstwebrtc1_WebRTCICE_get_turn_server func _gotk4_gstwebrtc1_WebRTCICE_get_turn_server(carg0 *C.GstWebRTCICE) (cret *C.gchar) { - panic("unimplemented") + var fn func(carg0 *C.GstWebRTCICE) (cret *C.gchar) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstwebrtc1_WebRTCICE_get_turn_server").(func(carg0 *C.GstWebRTCICE) (cret *C.gchar)) + if fn == nil { + panic("_gotk4_gstwebrtc1_WebRTCICE_get_turn_server: no function pointer found") + } + } + return fn(carg0) } //export _gotk4_gstwebrtc1_WebRTCICE_set_force_relay func _gotk4_gstwebrtc1_WebRTCICE_set_force_relay(carg0 *C.GstWebRTCICE, carg1 C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstWebRTCICE, carg1 C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstwebrtc1_WebRTCICE_set_force_relay").(func(carg0 *C.GstWebRTCICE, carg1 C.gboolean)) + if fn == nil { + panic("_gotk4_gstwebrtc1_WebRTCICE_set_force_relay: no function pointer found") + } + } + fn(carg0, carg1) } //export _gotk4_gstwebrtc1_WebRTCICE_set_http_proxy func _gotk4_gstwebrtc1_WebRTCICE_set_http_proxy(carg0 *C.GstWebRTCICE, carg1 *C.gchar) { - panic("unimplemented") + var fn func(carg0 *C.GstWebRTCICE, carg1 *C.gchar) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstwebrtc1_WebRTCICE_set_http_proxy").(func(carg0 *C.GstWebRTCICE, carg1 *C.gchar)) + if fn == nil { + panic("_gotk4_gstwebrtc1_WebRTCICE_set_http_proxy: no function pointer found") + } + } + fn(carg0, carg1) } //export _gotk4_gstwebrtc1_WebRTCICE_set_is_controller func _gotk4_gstwebrtc1_WebRTCICE_set_is_controller(carg0 *C.GstWebRTCICE, carg1 C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstWebRTCICE, carg1 C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstwebrtc1_WebRTCICE_set_is_controller").(func(carg0 *C.GstWebRTCICE, carg1 C.gboolean)) + if fn == nil { + panic("_gotk4_gstwebrtc1_WebRTCICE_set_is_controller: no function pointer found") + } + } + fn(carg0, carg1) } //export _gotk4_gstwebrtc1_WebRTCICE_set_local_credentials func _gotk4_gstwebrtc1_WebRTCICE_set_local_credentials(carg0 *C.GstWebRTCICE, carg1 *C.GstWebRTCICEStream, carg2 *C.gchar, carg3 *C.gchar) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstWebRTCICE, carg1 *C.GstWebRTCICEStream, carg2 *C.gchar, carg3 *C.gchar) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstwebrtc1_WebRTCICE_set_local_credentials").(func(carg0 *C.GstWebRTCICE, carg1 *C.GstWebRTCICEStream, carg2 *C.gchar, carg3 *C.gchar) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstwebrtc1_WebRTCICE_set_local_credentials: no function pointer found") + } + } + return fn(carg0, carg1, carg2, carg3) } //export _gotk4_gstwebrtc1_WebRTCICE_set_on_ice_candidate func _gotk4_gstwebrtc1_WebRTCICE_set_on_ice_candidate(carg0 *C.GstWebRTCICE, carg1 C.GstWebRTCICEOnCandidateFunc, carg2 C.gpointer, carg3 C.GDestroyNotify) { - panic("unimplemented") + var fn func(carg0 *C.GstWebRTCICE, carg1 C.GstWebRTCICEOnCandidateFunc, carg2 C.gpointer, carg3 C.GDestroyNotify) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstwebrtc1_WebRTCICE_set_on_ice_candidate").(func(carg0 *C.GstWebRTCICE, carg1 C.GstWebRTCICEOnCandidateFunc, carg2 C.gpointer, carg3 C.GDestroyNotify)) + if fn == nil { + panic("_gotk4_gstwebrtc1_WebRTCICE_set_on_ice_candidate: no function pointer found") + } + } + fn(carg0, carg1, carg2, carg3) } //export _gotk4_gstwebrtc1_WebRTCICE_set_remote_credentials func _gotk4_gstwebrtc1_WebRTCICE_set_remote_credentials(carg0 *C.GstWebRTCICE, carg1 *C.GstWebRTCICEStream, carg2 *C.gchar, carg3 *C.gchar) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstWebRTCICE, carg1 *C.GstWebRTCICEStream, carg2 *C.gchar, carg3 *C.gchar) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstwebrtc1_WebRTCICE_set_remote_credentials").(func(carg0 *C.GstWebRTCICE, carg1 *C.GstWebRTCICEStream, carg2 *C.gchar, carg3 *C.gchar) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstwebrtc1_WebRTCICE_set_remote_credentials: no function pointer found") + } + } + return fn(carg0, carg1, carg2, carg3) } //export _gotk4_gstwebrtc1_WebRTCICE_set_stun_server func _gotk4_gstwebrtc1_WebRTCICE_set_stun_server(carg0 *C.GstWebRTCICE, carg1 *C.gchar) { - panic("unimplemented") + var fn func(carg0 *C.GstWebRTCICE, carg1 *C.gchar) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstwebrtc1_WebRTCICE_set_stun_server").(func(carg0 *C.GstWebRTCICE, carg1 *C.gchar)) + if fn == nil { + panic("_gotk4_gstwebrtc1_WebRTCICE_set_stun_server: no function pointer found") + } + } + fn(carg0, carg1) } //export _gotk4_gstwebrtc1_WebRTCICE_set_tos func _gotk4_gstwebrtc1_WebRTCICE_set_tos(carg0 *C.GstWebRTCICE, carg1 *C.GstWebRTCICEStream, carg2 C.guint) { - panic("unimplemented") + var fn func(carg0 *C.GstWebRTCICE, carg1 *C.GstWebRTCICEStream, carg2 C.guint) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstwebrtc1_WebRTCICE_set_tos").(func(carg0 *C.GstWebRTCICE, carg1 *C.GstWebRTCICEStream, carg2 C.guint)) + if fn == nil { + panic("_gotk4_gstwebrtc1_WebRTCICE_set_tos: no function pointer found") + } + } + fn(carg0, carg1, carg2) } //export _gotk4_gstwebrtc1_WebRTCICE_set_turn_server func _gotk4_gstwebrtc1_WebRTCICE_set_turn_server(carg0 *C.GstWebRTCICE, carg1 *C.gchar) { - panic("unimplemented") + var fn func(carg0 *C.GstWebRTCICE, carg1 *C.gchar) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstwebrtc1_WebRTCICE_set_turn_server").(func(carg0 *C.GstWebRTCICE, carg1 *C.gchar)) + if fn == nil { + panic("_gotk4_gstwebrtc1_WebRTCICE_set_turn_server: no function pointer found") + } + } + fn(carg0, carg1) } //export _gotk4_gstwebrtc1_WebRTCICEStream_find_transport func _gotk4_gstwebrtc1_WebRTCICEStream_find_transport(carg0 *C.GstWebRTCICEStream, carg1 C.GstWebRTCICEComponent) (cret *C.GstWebRTCICETransport) { - panic("unimplemented") + var fn func(carg0 *C.GstWebRTCICEStream, carg1 C.GstWebRTCICEComponent) (cret *C.GstWebRTCICETransport) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstwebrtc1_WebRTCICEStream_find_transport").(func(carg0 *C.GstWebRTCICEStream, carg1 C.GstWebRTCICEComponent) (cret *C.GstWebRTCICETransport)) + if fn == nil { + panic("_gotk4_gstwebrtc1_WebRTCICEStream_find_transport: no function pointer found") + } + } + return fn(carg0, carg1) } //export _gotk4_gstwebrtc1_WebRTCICEStream_gather_candidates func _gotk4_gstwebrtc1_WebRTCICEStream_gather_candidates(carg0 *C.GstWebRTCICEStream) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstWebRTCICEStream) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstwebrtc1_WebRTCICEStream_gather_candidates").(func(carg0 *C.GstWebRTCICEStream) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstwebrtc1_WebRTCICEStream_gather_candidates: no function pointer found") + } + } + return fn(carg0) } //export _gotk4_gstwebrtc1_WebRTCICETransport_gather_candidates func _gotk4_gstwebrtc1_WebRTCICETransport_gather_candidates(carg0 *C.GstWebRTCICETransport) (cret C.gboolean) { - panic("unimplemented") + var fn func(carg0 *C.GstWebRTCICETransport) (cret C.gboolean) + { + fn = classdata.LoadVirtualMethodFromInstance(unsafe.Pointer(carg0), "_gotk4_gstwebrtc1_WebRTCICETransport_gather_candidates").(func(carg0 *C.GstWebRTCICETransport) (cret C.gboolean)) + if fn == nil { + panic("_gotk4_gstwebrtc1_WebRTCICETransport_gather_candidates: no function pointer found") + } + } + return fn(carg0) }