package/go-gst
1
0
Fork 0
mirror of https://github.com/go-gst/go-gst.git synced 2025-09-26 20:11:18 +08:00
Code Issues Packages Projects Releases Wiki Activity

remove calls of WithPointerTransferOriginal from bins and elements since it was a possible source of mem leaks

Browse Source 
TODO: other usages include base_src/sink/transform push_src and URI handler
This commit is contained in:
RSWilli
2024-11-15 17:40:45 +01:00
parent 72543a2372
commit 05f691e32c
2 changed files with 183 additions and 129 deletions
Download Patch File Download Diff File Expand all files Collapse all files

123
gst/gst_bin_exports.go
View File

@@ -10,96 +10,119 @@ import (
"github.com/go-gst/go-glib/glib"
)
func cbWrapBin(bin *C.GstBin) *Bin {
return wrapBin(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(bin))})
}
func cbWrapElement(elem *C.GstElement) *Element {
return wrapElement(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(elem))})
}
//export goGstBinAddElement
func goGstBinAddElement(bin *C.GstBin, element *C.GstElement) C.gboolean {
func goGstBinAddElement(bin *C.GstBin, child *C.GstElement) C.gboolean {
var ret bool
glib.WithPointerTransferOriginal(unsafe.Pointer(bin), func(gobj *glib.Object, obj glib.GoObjectSubclass) {
caller := obj.(interface {
AddElement(self *Bin, element *Element) bool
})
ret = caller.AddElement(wrapBin(gobj), cbWrapElement(element))
goBin := wrapBin(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(bin))})
subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(bin))
gochild := wrapElement(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(child))})
caller := subclass.(interface {
AddElement(self *Bin, element *Element) bool
})
ret = caller.AddElement(goBin, gochild)
return gboolean(ret)
}
//export goGstBinDeepElementAdded
func goGstBinDeepElementAdded(bin *C.GstBin, subbin *C.GstBin, child *C.GstElement) {
glib.WithPointerTransferOriginal(unsafe.Pointer(bin), func(gobj *glib.Object, obj glib.GoObjectSubclass) {
caller := obj.(interface {
DeepElementAdded(self *Bin, subbin *Bin, child *Element)
})
caller.DeepElementAdded(wrapBin(gobj), cbWrapBin(subbin), cbWrapElement(child))
goBin := wrapBin(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(bin))})
subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(bin))
gosubbin := wrapBin(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(subbin))})
gochild := wrapElement(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(child))})
caller := subclass.(interface {
DeepElementAdded(self *Bin, subbin *Bin, child *Element)
})
caller.DeepElementAdded(goBin, gosubbin, gochild)
}
//export goGstBinDeepElementRemoved
func goGstBinDeepElementRemoved(bin *C.GstBin, subbin *C.GstBin, child *C.GstElement) {
glib.WithPointerTransferOriginal(unsafe.Pointer(bin), func(gobj *glib.Object, obj glib.GoObjectSubclass) {
caller := obj.(interface {
DeepElementRemoved(self *Bin, subbin *Bin, child *Element)
})
caller.DeepElementRemoved(wrapBin(gobj), cbWrapBin(subbin), cbWrapElement(child))
goBin := wrapBin(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(bin))})
subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(bin))
gosubbin := wrapBin(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(subbin))})
gochild := wrapElement(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(child))})
caller := subclass.(interface {
DeepElementRemoved(self *Bin, subbin *Bin, child *Element)
})
caller.DeepElementRemoved(goBin, gosubbin, gochild)
}
//export goGstBinDoLatency
func goGstBinDoLatency(bin *C.GstBin) C.gboolean {
var ret bool
glib.WithPointerTransferOriginal(unsafe.Pointer(bin), func(gobj *glib.Object, obj glib.GoObjectSubclass) {
caller := obj.(interface {
DoLatency(self *Bin) bool
})
ret = caller.DoLatency(wrapBin(gobj))
goBin := wrapBin(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(bin))})
subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(bin))
caller := subclass.(interface {
DoLatency(self *Bin) bool
})
ret = caller.DoLatency(goBin)
return gboolean(ret)
}
//export goGstBinElementAdded
func goGstBinElementAdded(bin *C.GstBin, child *C.GstElement) {
glib.WithPointerTransferOriginal(unsafe.Pointer(bin), func(gobj *glib.Object, obj glib.GoObjectSubclass) {
caller := obj.(interface {
ElementAdded(self *Bin, child *Element)
})
caller.ElementAdded(wrapBin(gobj), cbWrapElement(child))
goBin := wrapBin(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(bin))})
subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(bin))
gochild := wrapElement(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(child))})
caller := subclass.(interface {
ElementAdded(self *Bin, child *Element)
})
caller.ElementAdded(goBin, gochild)
}
//export goGstBinElementRemoved
func goGstBinElementRemoved(bin *C.GstBin, child *C.GstElement) {
glib.WithPointerTransferOriginal(unsafe.Pointer(bin), func(gobj *glib.Object, obj glib.GoObjectSubclass) {
caller := obj.(interface {
ElementRemoved(self *Bin, child *Element)
})
caller.ElementRemoved(wrapBin(gobj), cbWrapElement(child))
goBin := wrapBin(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(bin))})
subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(bin))
gochild := wrapElement(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(child))})
caller := subclass.(interface {
ElementRemoved(self *Bin, child *Element)
})
caller.ElementRemoved(goBin, gochild)
}
//export goGstBinHandleMessage
func goGstBinHandleMessage(bin *C.GstBin, message *C.GstMessage) {
glib.WithPointerTransferOriginal(unsafe.Pointer(bin), func(gobj *glib.Object, obj glib.GoObjectSubclass) {
caller := obj.(interface {
HandleMessage(self *Bin, msg *Message)
})
caller.HandleMessage(wrapBin(gobj), wrapMessage(message))
goBin := wrapBin(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(bin))})
subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(bin))
caller := subclass.(interface {
HandleMessage(self *Bin, msg *Message)
})
caller.HandleMessage(goBin, wrapMessage(message))
}
//export goGstBinRemoveElement
func goGstBinRemoveElement(bin *C.GstBin, element *C.GstElement) C.gboolean {
func goGstBinRemoveElement(bin *C.GstBin, child *C.GstElement) C.gboolean {
var ret bool
glib.WithPointerTransferOriginal(unsafe.Pointer(bin), func(gobj *glib.Object, obj glib.GoObjectSubclass) {
caller := obj.(interface {
RemoveElement(self *Bin, child *Element) bool
})
ret = caller.RemoveElement(wrapBin(gobj), cbWrapElement(element))
goBin := wrapBin(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(bin))})
subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(bin))
gochild := wrapElement(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(child))})
caller := subclass.(interface {
RemoveElement(self *Bin, child *Element) bool
})
ret = caller.RemoveElement(goBin, gochild)
return gboolean(ret)
}

189
gst/gst_element_exports.go
View File

@@ -15,73 +15,85 @@ import (
//export goGstElementClassChangeState
func goGstElementClassChangeState(elem *C.GstElement, change C.GstStateChange) C.GstStateChangeReturn {
var ret StateChangeReturn
glib.WithPointerTransferOriginal(unsafe.Pointer(elem), func(gobj *glib.Object, obj glib.GoObjectSubclass) {
iface := obj.(interface {
ChangeState(*Element, StateChange) StateChangeReturn
})
ret = iface.ChangeState(wrapElement(gobj), StateChange(change))
goElem := wrapElement(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(elem))})
subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(elem))
iface := subclass.(interface {
ChangeState(*Element, StateChange) StateChangeReturn
})
ret = iface.ChangeState(goElem, StateChange(change))
return C.GstStateChangeReturn(ret)
}
//export goGstElementClassGetState
func goGstElementClassGetState(elem *C.GstElement, state, pending *C.GstState, timeout C.GstClockTime) C.GstStateChangeReturn {
var ret StateChangeReturn
glib.WithPointerTransferOriginal(unsafe.Pointer(elem), func(gobj *glib.Object, obj glib.GoObjectSubclass) {
iface := obj.(interface {
GetState(*Element, time.Duration) (ret StateChangeReturn, current, pending State) // should this be a ClockTime?
})
var cur, pend State
ret, cur, pend = iface.GetState(wrapElement(gobj), time.Duration(timeout)*time.Nanosecond)
if ret != StateChangeFailure {
*state = C.GstState(cur)
*pending = C.GstState(pend)
}
goElem := wrapElement(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(elem))})
subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(elem))
iface := subclass.(interface {
GetState(*Element, time.Duration) (ret StateChangeReturn, current, pending State) // should this be a ClockTime?
})
var cur, pend State
ret, cur, pend = iface.GetState(goElem, time.Duration(timeout)*time.Nanosecond)
if ret != StateChangeFailure {
*state = C.GstState(cur)
*pending = C.GstState(pend)
}
return C.GstStateChangeReturn(ret)
}
//export goGstElementClassNoMorePads
func goGstElementClassNoMorePads(elem *C.GstElement) {
glib.WithPointerTransferOriginal(unsafe.Pointer(elem), func(gobj *glib.Object, obj glib.GoObjectSubclass) {
iface := obj.(interface{ NoMorePads(*Element) })
iface.NoMorePads(wrapElement(gobj))
})
goElem := wrapElement(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(elem))})
subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(elem))
iface := subclass.(interface{ NoMorePads(*Element) })
iface.NoMorePads(goElem)
}
//export goGstElementClassPadAdded
func goGstElementClassPadAdded(elem *C.GstElement, pad *C.GstPad) {
glib.WithPointerTransferOriginal(unsafe.Pointer(elem), func(gobj *glib.Object, obj glib.GoObjectSubclass) {
iface := obj.(interface{ PadAdded(*Element, *Pad) })
iface.PadAdded(wrapElement(gobj), wrapPad(toGObject(unsafe.Pointer(pad))))
})
goElem := wrapElement(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(elem))})
subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(elem))
iface := subclass.(interface{ PadAdded(*Element, *Pad) })
iface.PadAdded(goElem, wrapPad(toGObject(unsafe.Pointer(pad))))
}
//export goGstElementClassPadRemoved
func goGstElementClassPadRemoved(elem *C.GstElement, pad *C.GstPad) {
glib.WithPointerTransferOriginal(unsafe.Pointer(elem), func(gobj *glib.Object, obj glib.GoObjectSubclass) {
iface := obj.(interface{ PadRemoved(*Element, *Pad) })
iface.PadRemoved(wrapElement(gobj), wrapPad(toGObject(unsafe.Pointer(pad))))
})
goElem := wrapElement(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(elem))})
subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(elem))
iface := subclass.(interface{ PadRemoved(*Element, *Pad) })
iface.PadRemoved(goElem, wrapPad(toGObject(unsafe.Pointer(pad))))
}
//export goGstElementClassPostMessage
func goGstElementClassPostMessage(elem *C.GstElement, msg *C.GstMessage) C.gboolean {
var ret C.gboolean
glib.WithPointerTransferOriginal(unsafe.Pointer(elem), func(gobj *glib.Object, obj glib.GoObjectSubclass) {
iface := obj.(interface{ PostMessage(*Element, *Message) bool })
ret = gboolean(iface.PostMessage(wrapElement(gobj), wrapMessage(msg)))
})
goElem := wrapElement(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(elem))})
subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(elem))
iface := subclass.(interface{ PostMessage(*Element, *Message) bool })
ret = gboolean(iface.PostMessage(goElem, wrapMessage(msg)))
return ret
}
//export goGstElementClassProvideClock
func goGstElementClassProvideClock(elem *C.GstElement) *C.GstClock {
var clock *Clock
glib.WithPointerTransferOriginal(unsafe.Pointer(elem), func(gobj *glib.Object, obj glib.GoObjectSubclass) {
iface := obj.(interface{ ProvideClock(*Element) *Clock })
clock = iface.ProvideClock(wrapElement(gobj))
})
goElem := wrapElement(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(elem))})
subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(elem))
iface := subclass.(interface{ ProvideClock(*Element) *Clock })
clock = iface.ProvideClock(goElem)
if clock == nil {
return nil
}
@@ -91,35 +103,41 @@ func goGstElementClassProvideClock(elem *C.GstElement) *C.GstClock {
//export goGstElementClassQuery
func goGstElementClassQuery(elem *C.GstElement, query *C.GstQuery) C.gboolean {
var ret C.gboolean
glib.WithPointerTransferOriginal(unsafe.Pointer(elem), func(gobj *glib.Object, obj glib.GoObjectSubclass) {
iface := obj.(interface{ Query(*Element, *Query) bool })
ret = gboolean(iface.Query(wrapElement(gobj), wrapQuery(query)))
})
goElem := wrapElement(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(elem))})
subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(elem))
iface := subclass.(interface{ Query(*Element, *Query) bool })
ret = gboolean(iface.Query(goElem, wrapQuery(query)))
return ret
}
//export goGstElementClassReleasePad
func goGstElementClassReleasePad(elem *C.GstElement, pad *C.GstPad) {
glib.WithPointerTransferOriginal(unsafe.Pointer(elem), func(gobj *glib.Object, obj glib.GoObjectSubclass) {
iface := obj.(interface{ ReleasePad(*Element, *Pad) })
iface.ReleasePad(wrapElement(gobj), wrapPad(toGObject(unsafe.Pointer(pad))))
})
goElem := wrapElement(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(elem))})
subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(elem))
iface := subclass.(interface{ ReleasePad(*Element, *Pad) })
iface.ReleasePad(goElem, wrapPad(toGObject(unsafe.Pointer(pad))))
}
//export goGstElementClassRequestNewPad
func goGstElementClassRequestNewPad(elem *C.GstElement, templ *C.GstPadTemplate, name *C.gchar, caps *C.GstCaps) *C.GstPad {
var pad *Pad
glib.WithPointerTransferOriginal(unsafe.Pointer(elem), func(gobj *glib.Object, obj glib.GoObjectSubclass) {
iface := obj.(interface {
RequestNewPad(self *Element, templ *PadTemplate, name string, caps *Caps) *Pad
})
pad = iface.RequestNewPad(
wrapElement(gobj),
wrapPadTemplate(toGObject(unsafe.Pointer(templ))),
C.GoString(name),
wrapCaps(caps),
)
goElem := wrapElement(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(elem))})
subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(elem))
iface := subclass.(interface {
RequestNewPad(self *Element, templ *PadTemplate, name string, caps *Caps) *Pad
})
pad = iface.RequestNewPad(
goElem,
wrapPadTemplate(toGObject(unsafe.Pointer(templ))),
C.GoString(name),
wrapCaps(caps),
)
if pad == nil {
return nil
}
@@ -129,57 +147,70 @@ func goGstElementClassRequestNewPad(elem *C.GstElement, templ *C.GstPadTemplate,
//export goGstElementClassSendEvent
func goGstElementClassSendEvent(elem *C.GstElement, event *C.GstEvent) C.gboolean {
var ret C.gboolean
glib.WithPointerTransferOriginal(unsafe.Pointer(elem), func(gobj *glib.Object, obj glib.GoObjectSubclass) {
iface := obj.(interface{ SendEvent(*Element, *Event) bool })
ret = gboolean(iface.SendEvent(wrapElement(gobj), wrapEvent(event)))
})
goElem := wrapElement(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(elem))})
subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(elem))
iface := subclass.(interface{ SendEvent(*Element, *Event) bool })
ret = gboolean(iface.SendEvent(goElem, wrapEvent(event)))
return ret
}
//export goGstElementClassSetBus
func goGstElementClassSetBus(elem *C.GstElement, bus *C.GstBus) {
glib.WithPointerTransferOriginal(unsafe.Pointer(elem), func(gobj *glib.Object, obj glib.GoObjectSubclass) {
iface := obj.(interface{ SetBus(*Element, *Bus) })
iface.SetBus(wrapElement(gobj), wrapBus(toGObject(unsafe.Pointer(bus))))
})
goElem := wrapElement(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(elem))})
subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(elem))
iface := subclass.(interface{ SetBus(*Element, *Bus) })
iface.SetBus(goElem, wrapBus(toGObject(unsafe.Pointer(bus))))
}
//export goGstElementClassSetClock
func goGstElementClassSetClock(elem *C.GstElement, clock *C.GstClock) C.gboolean {
var ret C.gboolean
glib.WithPointerTransferOriginal(unsafe.Pointer(elem), func(gobj *glib.Object, obj glib.GoObjectSubclass) {
iface := obj.(interface{ SetClock(*Element, *Clock) bool })
ret = gboolean(iface.SetClock(wrapElement(gobj), wrapClock(toGObject(unsafe.Pointer(clock)))))
})
goElem := wrapElement(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(elem))})
subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(elem))
iface := subclass.(interface{ SetClock(*Element, *Clock) bool })
ret = gboolean(iface.SetClock(goElem, wrapClock(toGObject(unsafe.Pointer(clock)))))
return ret
}
//export goGstElementClassSetContext
func goGstElementClassSetContext(elem *C.GstElement, ctx *C.GstContext) {
glib.WithPointerTransferOriginal(unsafe.Pointer(elem), func(gobj *glib.Object, obj glib.GoObjectSubclass) {
iface := obj.(interface{ SetContext(*Element, *Context) })
iface.SetContext(wrapElement(gobj), wrapContext(ctx))
})
goElem := wrapElement(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(elem))})
subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(elem))
iface := subclass.(interface{ SetContext(*Element, *Context) })
iface.SetContext(goElem, wrapContext(ctx))
}
//export goGstElementClassSetState
func goGstElementClassSetState(elem *C.GstElement, state C.GstState) C.GstStateChangeReturn {
var ret C.GstStateChangeReturn
glib.WithPointerTransferOriginal(unsafe.Pointer(elem), func(gobj *glib.Object, obj glib.GoObjectSubclass) {
iface := obj.(interface {
SetState(*Element, State) StateChangeReturn
})
ret = C.GstStateChangeReturn(iface.SetState(wrapElement(gobj), State(state)))
goElem := wrapElement(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(elem))})
subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(elem))
iface := subclass.(interface {
SetState(*Element, State) StateChangeReturn
})
ret = C.GstStateChangeReturn(iface.SetState(goElem, State(state)))
return ret
}
//export goGstElementClassStateChanged
func goGstElementClassStateChanged(elem *C.GstElement, old, new, pending C.GstState) {
glib.WithPointerTransferOriginal(unsafe.Pointer(elem), func(gobj *glib.Object, obj glib.GoObjectSubclass) {
iface := obj.(interface {
StateChanged(self *Element, old, new, pending State)
})
iface.StateChanged(wrapElement(gobj), State(old), State(new), State(pending))
goElem := wrapElement(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(elem))})
subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(elem))
iface := subclass.(interface {
StateChanged(self *Element, old, new, pending State)
})
iface.StateChanged(goElem, State(old), State(new), State(pending))
}