From e6ad9ab977335558252d1bef0752241ed5532b9a Mon Sep 17 00:00:00 2001 From: Avi Zimmerman Date: Wed, 20 Jan 2021 15:39:17 +0200 Subject: [PATCH] more vmethod ref counting fixes --- gst/base/gst_base_sink.go | 5 - gst/base/gst_base_sink_exports.go | 177 ++++++++++----- gst/base/gst_base_src.go | 5 - gst/base/gst_base_src_exports.go | 225 +++++++++++------- gst/base/gst_base_transform.go | 5 - gst/base/gst_base_transform_exports.go | 301 +++++++++++++------------ gst/base/gst_push_src.go | 7 - gst/base/gst_push_src_exports.go | 40 ++-- gst/gst_buffer.go | 19 +- gst/gst_buffer_list.go | 14 +- gst/gst_caps.go | 10 +- gst/gst_event.go | 10 +- gst/gst_message.go | 8 +- gst/gst_query.go | 8 +- gst/gst_segment.go | 6 + 15 files changed, 502 insertions(+), 338 deletions(-) diff --git a/gst/base/gst_base_sink.go b/gst/base/gst_base_sink.go index f7f73dd..a738b36 100644 --- a/gst/base/gst_base_sink.go +++ b/gst/base/gst_base_sink.go @@ -35,11 +35,6 @@ func ToGstBaseSink(obj interface{}) *GstBaseSink { return nil } -// wrapGstBaseSink wraps the given unsafe.Pointer in a GstBaseSink instance. -func wrapGstBaseSink(obj *C.GstBaseSink) *GstBaseSink { - return &GstBaseSink{gst.FromGstElementUnsafeNone(unsafe.Pointer(obj))} -} - // Instance returns the underlying C GstBaseSrc instance func (g *GstBaseSink) Instance() *C.GstBaseSink { return C.toGstBaseSink(g.Unsafe()) diff --git a/gst/base/gst_base_sink_exports.go b/gst/base/gst_base_sink_exports.go index 933fd0f..7e67520 100644 --- a/gst/base/gst_base_sink_exports.go +++ b/gst/base/gst_base_sink_exports.go @@ -15,26 +15,37 @@ import ( //export goGstBaseSinkActivatePull func goGstBaseSinkActivatePull(sink *C.GstBaseSink, active C.gboolean) C.gboolean { - iface := glib.FromObjectUnsafePrivate(unsafe.Pointer(sink)).(interface { - ActivatePull(self *GstBaseSink, active bool) bool + var ret C.gboolean + glib.WithPointerTransferOriginal(unsafe.Pointer(sink), func(gObject *glib.Object, goObject glib.GoObjectSubclass) { + iface := goObject.(interface { + ActivatePull(self *GstBaseSink, active bool) bool + }) + ret = gboolean(iface.ActivatePull(ToGstBaseSink(gObject), gobool(active))) }) - return gboolean(iface.ActivatePull(wrapGstBaseSink(sink), gobool(active))) + return ret } //export goGstBaseSinkEvent func goGstBaseSinkEvent(sink *C.GstBaseSink, event *C.GstEvent) C.gboolean { - iface := glib.FromObjectUnsafePrivate(unsafe.Pointer(sink)).(interface { - Event(self *GstBaseSink, event *gst.Event) bool + var ret C.gboolean + glib.WithPointerTransferOriginal(unsafe.Pointer(sink), func(gObject *glib.Object, goObject glib.GoObjectSubclass) { + iface := goObject.(interface { + Event(self *GstBaseSink, event *gst.Event) bool + }) + ret = gboolean(iface.Event(ToGstBaseSink(gObject), gst.ToGstEvent(unsafe.Pointer(event)))) }) - return gboolean(iface.Event(wrapGstBaseSink(sink), gst.FromGstEventUnsafeNone(unsafe.Pointer(event)))) + return ret } //export goGstBaseSinkFixate func goGstBaseSinkFixate(sink *C.GstBaseSink, caps *C.GstCaps) *C.GstCaps { - iface := glib.FromObjectUnsafePrivate(unsafe.Pointer(sink)).(interface { - Fixate(self *GstBaseSink, caps *gst.Caps) *gst.Caps + var fixated *gst.Caps + glib.WithPointerTransferOriginal(unsafe.Pointer(sink), func(gObject *glib.Object, goObject glib.GoObjectSubclass) { + iface := goObject.(interface { + Fixate(self *GstBaseSink, caps *gst.Caps) *gst.Caps + }) + fixated = iface.Fixate(ToGstBaseSink(gObject), gst.ToGstCaps(unsafe.Pointer(caps))) }) - fixated := iface.Fixate(wrapGstBaseSink(sink), gst.FromGstCapsUnsafeNone(unsafe.Pointer(caps))) if fixated == nil { return nil } @@ -43,10 +54,13 @@ func goGstBaseSinkFixate(sink *C.GstBaseSink, caps *C.GstCaps) *C.GstCaps { //export goGstBaseSinkGetCaps func goGstBaseSinkGetCaps(sink *C.GstBaseSink, filter *C.GstCaps) *C.GstCaps { - iface := glib.FromObjectUnsafePrivate(unsafe.Pointer(sink)).(interface { - GetCaps(self *GstBaseSink, filter *gst.Caps) *gst.Caps + var filtered *gst.Caps + glib.WithPointerTransferOriginal(unsafe.Pointer(sink), func(gObject *glib.Object, goObject glib.GoObjectSubclass) { + iface := goObject.(interface { + GetCaps(self *GstBaseSink, filter *gst.Caps) *gst.Caps + }) + filtered = iface.GetCaps(ToGstBaseSink(gObject), gst.ToGstCaps(unsafe.Pointer(filter))) }) - filtered := iface.GetCaps(wrapGstBaseSink(sink), gst.FromGstCapsUnsafeNone(unsafe.Pointer(filter))) if filtered == nil { return nil } @@ -55,114 +69,169 @@ func goGstBaseSinkGetCaps(sink *C.GstBaseSink, filter *C.GstCaps) *C.GstCaps { //export goGstBaseSinkGetTimes func goGstBaseSinkGetTimes(sink *C.GstBaseSink, buf *C.GstBuffer, start, end *C.GstClockTime) { - iface := glib.FromObjectUnsafePrivate(unsafe.Pointer(sink)).(interface { - GetTimes(self *GstBaseSink, buffer *gst.Buffer) (start, end time.Duration) + var retStart, retEnd time.Duration + glib.WithPointerTransferOriginal(unsafe.Pointer(sink), func(gObject *glib.Object, goObject glib.GoObjectSubclass) { + iface := goObject.(interface { + GetTimes(self *GstBaseSink, buffer *gst.Buffer) (start, end time.Duration) + }) + retStart, retEnd = iface.GetTimes(ToGstBaseSink(gObject), gst.ToGstBuffer(unsafe.Pointer(buf))) }) - retStart, retEnd := iface.GetTimes(wrapGstBaseSink(sink), gst.FromGstBufferUnsafeNone(unsafe.Pointer(buf))) *start = C.GstClockTime(retStart.Nanoseconds()) *end = C.GstClockTime(retEnd.Nanoseconds()) } //export goGstBaseSinkPrepare func goGstBaseSinkPrepare(sink *C.GstBaseSink, buf *C.GstBuffer) C.GstFlowReturn { - iface := glib.FromObjectUnsafePrivate(unsafe.Pointer(sink)).(interface { - Prepare(self *GstBaseSink, buffer *gst.Buffer) gst.FlowReturn + var ret gst.FlowReturn + glib.WithPointerTransferOriginal(unsafe.Pointer(sink), func(gObject *glib.Object, goObject glib.GoObjectSubclass) { + iface := goObject.(interface { + Prepare(self *GstBaseSink, buffer *gst.Buffer) gst.FlowReturn + }) + ret = iface.Prepare(ToGstBaseSink(gObject), gst.ToGstBuffer(unsafe.Pointer(buf))) }) - return C.GstFlowReturn(iface.Prepare(wrapGstBaseSink(sink), gst.FromGstBufferUnsafeNone(unsafe.Pointer(buf)))) + return C.GstFlowReturn(ret) } //export goGstBaseSinkPrepareList func goGstBaseSinkPrepareList(sink *C.GstBaseSink, list *C.GstBufferList) C.GstFlowReturn { - iface := glib.FromObjectUnsafePrivate(unsafe.Pointer(sink)).(interface { - PrepareList(self *GstBaseSink, bufferList *gst.BufferList) gst.FlowReturn + var ret gst.FlowReturn + glib.WithPointerTransferOriginal(unsafe.Pointer(sink), func(gObject *glib.Object, goObject glib.GoObjectSubclass) { + iface := goObject.(interface { + PrepareList(self *GstBaseSink, bufferList *gst.BufferList) gst.FlowReturn + }) + ret = iface.PrepareList(ToGstBaseSink(gObject), gst.ToGstBufferList(unsafe.Pointer(list))) }) - return C.GstFlowReturn(iface.PrepareList(wrapGstBaseSink(sink), gst.FromGstBufferListUnsafeNone(unsafe.Pointer(list)))) + return C.GstFlowReturn(ret) } //export goGstBaseSinkPreroll func goGstBaseSinkPreroll(sink *C.GstBaseSink, buf *C.GstBuffer) C.GstFlowReturn { - iface := glib.FromObjectUnsafePrivate(unsafe.Pointer(sink)).(interface { - Preroll(self *GstBaseSink, buffer *gst.Buffer) gst.FlowReturn + var ret gst.FlowReturn + glib.WithPointerTransferOriginal(unsafe.Pointer(sink), func(gObject *glib.Object, goObject glib.GoObjectSubclass) { + iface := goObject.(interface { + Preroll(self *GstBaseSink, buffer *gst.Buffer) gst.FlowReturn + }) + ret = iface.Preroll(ToGstBaseSink(gObject), gst.ToGstBuffer(unsafe.Pointer(buf))) }) - return C.GstFlowReturn(iface.Preroll(wrapGstBaseSink(sink), gst.FromGstBufferUnsafeNone(unsafe.Pointer(buf)))) + return C.GstFlowReturn(ret) } //export goGstBaseSinkProposeAllocation func goGstBaseSinkProposeAllocation(sink *C.GstBaseSink, query *C.GstQuery) C.gboolean { - iface := glib.FromObjectUnsafePrivate(unsafe.Pointer(sink)).(interface { - ProposeAllocation(self *GstBaseSink, query *gst.Query) bool + var ret bool + glib.WithPointerTransferOriginal(unsafe.Pointer(sink), func(gObject *glib.Object, goObject glib.GoObjectSubclass) { + iface := goObject.(interface { + ProposeAllocation(self *GstBaseSink, query *gst.Query) bool + }) + ret = iface.ProposeAllocation(ToGstBaseSink(gObject), gst.ToGstQuery(unsafe.Pointer(query))) }) - return gboolean(iface.ProposeAllocation(wrapGstBaseSink(sink), gst.FromGstQueryUnsafeNone(unsafe.Pointer(query)))) + return gboolean(ret) } //export goGstBaseSinkQuery func goGstBaseSinkQuery(sink *C.GstBaseSink, query *C.GstQuery) C.gboolean { - iface := glib.FromObjectUnsafePrivate(unsafe.Pointer(sink)).(interface { - Query(self *GstBaseSink, query *gst.Query) bool + var ret bool + glib.WithPointerTransferOriginal(unsafe.Pointer(sink), func(gObject *glib.Object, goObject glib.GoObjectSubclass) { + iface := goObject.(interface { + Query(self *GstBaseSink, query *gst.Query) bool + }) + ret = iface.Query(ToGstBaseSink(gObject), gst.ToGstQuery(unsafe.Pointer(query))) }) - return gboolean(iface.Query(wrapGstBaseSink(sink), gst.FromGstQueryUnsafeNone(unsafe.Pointer(query)))) + return gboolean(ret) } //export goGstBaseSinkRender func goGstBaseSinkRender(sink *C.GstBaseSink, buf *C.GstBuffer) C.GstFlowReturn { - iface := glib.FromObjectUnsafePrivate(unsafe.Pointer(sink)).(interface { - Render(self *GstBaseSink, buffer *gst.Buffer) gst.FlowReturn + var ret gst.FlowReturn + glib.WithPointerTransferOriginal(unsafe.Pointer(sink), func(gObject *glib.Object, goObject glib.GoObjectSubclass) { + iface := goObject.(interface { + Render(self *GstBaseSink, buffer *gst.Buffer) gst.FlowReturn + }) + ret = iface.Render(ToGstBaseSink(gObject), gst.ToGstBuffer(unsafe.Pointer(buf))) }) - return C.GstFlowReturn(iface.Render(wrapGstBaseSink(sink), gst.FromGstBufferUnsafeNone(unsafe.Pointer(buf)))) + return C.GstFlowReturn(ret) } //export goGstBaseSinkRenderList func goGstBaseSinkRenderList(sink *C.GstBaseSink, buf *C.GstBufferList) C.GstFlowReturn { - iface := glib.FromObjectUnsafePrivate(unsafe.Pointer(sink)).(interface { - RenderList(self *GstBaseSink, bufferList *gst.BufferList) gst.FlowReturn + var ret gst.FlowReturn + glib.WithPointerTransferOriginal(unsafe.Pointer(sink), func(gObject *glib.Object, goObject glib.GoObjectSubclass) { + iface := goObject.(interface { + RenderList(self *GstBaseSink, bufferList *gst.BufferList) gst.FlowReturn + }) + ret = iface.RenderList(ToGstBaseSink(gObject), gst.ToGstBufferList(unsafe.Pointer(buf))) }) - return C.GstFlowReturn(iface.RenderList(wrapGstBaseSink(sink), gst.FromGstBufferListUnsafeNone(unsafe.Pointer(buf)))) + return C.GstFlowReturn(ret) } //export goGstBaseSinkSetCaps func goGstBaseSinkSetCaps(sink *C.GstBaseSink, caps *C.GstCaps) C.gboolean { - iface := glib.FromObjectUnsafePrivate(unsafe.Pointer(sink)).(interface { - SetCaps(self *GstBaseSink, caps *gst.Caps) bool + var ret bool + glib.WithPointerTransferOriginal(unsafe.Pointer(sink), func(gObject *glib.Object, goObject glib.GoObjectSubclass) { + iface := goObject.(interface { + SetCaps(self *GstBaseSink, caps *gst.Caps) bool + }) + ret = iface.SetCaps(ToGstBaseSink(gObject), gst.ToGstCaps(unsafe.Pointer(caps))) }) - return gboolean(iface.SetCaps(wrapGstBaseSink(sink), gst.FromGstCapsUnsafeNone(unsafe.Pointer(caps)))) + return gboolean(ret) } //export goGstBaseSinkStart func goGstBaseSinkStart(sink *C.GstBaseSink) C.gboolean { - iface := glib.FromObjectUnsafePrivate(unsafe.Pointer(sink)).(interface { - Start(self *GstBaseSink) bool + var ret bool + glib.WithPointerTransferOriginal(unsafe.Pointer(sink), func(gObject *glib.Object, goObject glib.GoObjectSubclass) { + iface := goObject.(interface { + Start(self *GstBaseSink) bool + }) + ret = iface.Start(ToGstBaseSink(gObject)) }) - return gboolean(iface.Start(wrapGstBaseSink(sink))) + return gboolean(ret) } //export goGstBaseSinkStop func goGstBaseSinkStop(sink *C.GstBaseSink) C.gboolean { - iface := glib.FromObjectUnsafePrivate(unsafe.Pointer(sink)).(interface { - Stop(self *GstBaseSink) bool + var ret bool + glib.WithPointerTransferOriginal(unsafe.Pointer(sink), func(gObject *glib.Object, goObject glib.GoObjectSubclass) { + iface := goObject.(interface { + Stop(self *GstBaseSink) bool + }) + ret = iface.Stop(ToGstBaseSink(gObject)) }) - return gboolean(iface.Stop(wrapGstBaseSink(sink))) + return gboolean(ret) } //export goGstBaseSinkUnlock func goGstBaseSinkUnlock(sink *C.GstBaseSink) C.gboolean { - iface := glib.FromObjectUnsafePrivate(unsafe.Pointer(sink)).(interface { - Unlock(self *GstBaseSink) bool + var ret bool + glib.WithPointerTransferOriginal(unsafe.Pointer(sink), func(gObject *glib.Object, goObject glib.GoObjectSubclass) { + iface := goObject.(interface { + Unlock(self *GstBaseSink) bool + }) + ret = iface.Unlock(ToGstBaseSink(gObject)) }) - return gboolean(iface.Unlock(wrapGstBaseSink(sink))) + return gboolean(ret) } //export goGstBaseSinkUnlockStop func goGstBaseSinkUnlockStop(sink *C.GstBaseSink) C.gboolean { - iface := glib.FromObjectUnsafePrivate(unsafe.Pointer(sink)).(interface { - UnlockStop(self *GstBaseSink) bool + var ret bool + glib.WithPointerTransferOriginal(unsafe.Pointer(sink), func(gObject *glib.Object, goObject glib.GoObjectSubclass) { + iface := goObject.(interface { + UnlockStop(self *GstBaseSink) bool + }) + ret = iface.UnlockStop(ToGstBaseSink(gObject)) }) - return gboolean(iface.UnlockStop(wrapGstBaseSink(sink))) + return gboolean(ret) } //export goGstBaseSinkWaitEvent func goGstBaseSinkWaitEvent(sink *C.GstBaseSink, event *C.GstEvent) C.GstFlowReturn { - iface := glib.FromObjectUnsafePrivate(unsafe.Pointer(sink)).(interface { - WaitEvent(self *GstBaseSink, event *gst.Event) gst.FlowReturn + var ret gst.FlowReturn + glib.WithPointerTransferOriginal(unsafe.Pointer(sink), func(gObject *glib.Object, goObject glib.GoObjectSubclass) { + iface := goObject.(interface { + WaitEvent(self *GstBaseSink, event *gst.Event) gst.FlowReturn + }) + ret = iface.WaitEvent(ToGstBaseSink(gObject), gst.ToGstEvent(unsafe.Pointer(event))) }) - return C.GstFlowReturn(iface.WaitEvent(wrapGstBaseSink(sink), gst.FromGstEventUnsafeNone(unsafe.Pointer(event)))) + return C.GstFlowReturn(ret) } diff --git a/gst/base/gst_base_src.go b/gst/base/gst_base_src.go index 4630ef2..346fe43 100644 --- a/gst/base/gst_base_src.go +++ b/gst/base/gst_base_src.go @@ -28,11 +28,6 @@ func ToGstBaseSrc(obj interface{}) *GstBaseSrc { return nil } -// wrapGstBaseSrc wraps the given unsafe.Pointer in a GstBaseSrc instance. -func wrapGstBaseSrc(obj *C.GstBaseSrc) *GstBaseSrc { - return &GstBaseSrc{gst.FromGstElementUnsafeNone(unsafe.Pointer(obj))} -} - // Instance returns the underlying C GstBaseSrc instance func (g *GstBaseSrc) Instance() *C.GstBaseSrc { return C.toGstBaseSrc(g.Unsafe()) diff --git a/gst/base/gst_base_src_exports.go b/gst/base/gst_base_src_exports.go index b094553..ffe58ab 100644 --- a/gst/base/gst_base_src_exports.go +++ b/gst/base/gst_base_src_exports.go @@ -13,164 +13,217 @@ import ( //export goGstBaseSrcGetCaps func goGstBaseSrcGetCaps(src *C.GstBaseSrc, filter *C.GstCaps) *C.GstCaps { - elem := glib.FromObjectUnsafePrivate(unsafe.Pointer(src)) - caller := elem.(interface { - GetCaps(*GstBaseSrc, *gst.Caps) *gst.Caps + var caps *gst.Caps + glib.WithPointerTransferOriginal(unsafe.Pointer(src), func(gObject *glib.Object, goObject glib.GoObjectSubclass) { + iface := goObject.(interface { + GetCaps(*GstBaseSrc, *gst.Caps) *gst.Caps + }) + caps = iface.GetCaps(ToGstBaseSrc(gObject), gst.ToGstCaps(unsafe.Pointer(filter))) }) - res := caller.GetCaps(wrapGstBaseSrc(src), gst.FromGstCapsUnsafeNone(unsafe.Pointer(filter))) - return (*C.GstCaps)(unsafe.Pointer(res.Instance())) + if caps == nil { + return nil + } + return (*C.GstCaps)(unsafe.Pointer(caps.Instance())) } //export goGstBaseSrcNegotiate func goGstBaseSrcNegotiate(src *C.GstBaseSrc) C.gboolean { - elem := glib.FromObjectUnsafePrivate(unsafe.Pointer(src)) - caller := elem.(interface { - Negotiate(*GstBaseSrc) bool + var ret bool + glib.WithPointerTransferOriginal(unsafe.Pointer(src), func(gObject *glib.Object, goObject glib.GoObjectSubclass) { + iface := goObject.(interface { + Negotiate(*GstBaseSrc) bool + }) + ret = iface.Negotiate(ToGstBaseSrc(gObject)) }) - return gboolean(caller.Negotiate(wrapGstBaseSrc(src))) + return gboolean(ret) } //export goGstBaseSrcFixate -func goGstBaseSrcFixate(src *C.GstBaseSrc, caps *C.GstCaps) *C.GstCaps { - elem := glib.FromObjectUnsafePrivate(unsafe.Pointer(src)) - caller := elem.(interface { - Fixate(*GstBaseSrc, *gst.Caps) *gst.Caps +func goGstBaseSrcFixate(src *C.GstBaseSrc, filter *C.GstCaps) *C.GstCaps { + var caps *gst.Caps + glib.WithPointerTransferOriginal(unsafe.Pointer(src), func(gObject *glib.Object, goObject glib.GoObjectSubclass) { + iface := goObject.(interface { + Fixate(*GstBaseSrc, *gst.Caps) *gst.Caps + }) + caps = iface.Fixate(ToGstBaseSrc(gObject), gst.ToGstCaps(unsafe.Pointer(filter))) }) - res := caller.Fixate(wrapGstBaseSrc(src), gst.FromGstCapsUnsafeNone(unsafe.Pointer(caps))) - return (*C.GstCaps)(unsafe.Pointer(res.Instance())) + if caps == nil { + return nil + } + return (*C.GstCaps)(unsafe.Pointer(caps.Instance())) } //export goGstBaseSrcSetCaps -func goGstBaseSrcSetCaps(src *C.GstBaseSrc, filter *C.GstCaps) C.gboolean { - elem := glib.FromObjectUnsafePrivate(unsafe.Pointer(src)) - caller := elem.(interface { - SetCaps(*GstBaseSrc, *gst.Caps) bool +func goGstBaseSrcSetCaps(src *C.GstBaseSrc, caps *C.GstCaps) C.gboolean { + var ret bool + glib.WithPointerTransferOriginal(unsafe.Pointer(src), func(gObject *glib.Object, goObject glib.GoObjectSubclass) { + iface := goObject.(interface { + SetCaps(*GstBaseSrc, *gst.Caps) bool + }) + ret = iface.SetCaps(ToGstBaseSrc(gObject), gst.ToGstCaps(unsafe.Pointer(caps))) }) - return gboolean(caller.SetCaps(wrapGstBaseSrc(src), gst.FromGstCapsUnsafeNone(unsafe.Pointer(filter)))) + return gboolean(ret) } //export goGstBaseSrcDecideAllocation func goGstBaseSrcDecideAllocation(src *C.GstBaseSrc, query *C.GstQuery) C.gboolean { - elem := glib.FromObjectUnsafePrivate(unsafe.Pointer(src)) - caller := elem.(interface { - DecideAllocation(*GstBaseSrc, *gst.Query) bool + var ret bool + glib.WithPointerTransferOriginal(unsafe.Pointer(src), func(gObject *glib.Object, goObject glib.GoObjectSubclass) { + iface := goObject.(interface { + DecideAllocation(*GstBaseSrc, *gst.Query) bool + }) + ret = iface.DecideAllocation(ToGstBaseSrc(gObject), gst.ToGstQuery(unsafe.Pointer(query))) }) - return gboolean(caller.DecideAllocation(wrapGstBaseSrc(src), gst.FromGstQueryUnsafeNone(unsafe.Pointer(query)))) + return gboolean(ret) } //export goGstBaseSrcStart func goGstBaseSrcStart(src *C.GstBaseSrc) C.gboolean { - elem := glib.FromObjectUnsafePrivate(unsafe.Pointer(src)) - caller := elem.(interface { - Start(*GstBaseSrc) bool + var ret bool + glib.WithPointerTransferOriginal(unsafe.Pointer(src), func(gObject *glib.Object, goObject glib.GoObjectSubclass) { + iface := goObject.(interface { + Start(*GstBaseSrc) bool + }) + ret = iface.Start(ToGstBaseSrc(gObject)) }) - return gboolean(caller.Start(wrapGstBaseSrc(src))) + return gboolean(ret) } //export goGstBaseSrcStop func goGstBaseSrcStop(src *C.GstBaseSrc) C.gboolean { - elem := glib.FromObjectUnsafePrivate(unsafe.Pointer(src)) - caller := elem.(interface { - Stop(*GstBaseSrc) bool + var ret bool + glib.WithPointerTransferOriginal(unsafe.Pointer(src), func(gObject *glib.Object, goObject glib.GoObjectSubclass) { + iface := goObject.(interface { + Stop(*GstBaseSrc) bool + }) + ret = iface.Stop(ToGstBaseSrc(gObject)) }) - return gboolean(caller.Stop(wrapGstBaseSrc(src))) + return gboolean(ret) } //export goGstBaseSrcGetTimes func goGstBaseSrcGetTimes(src *C.GstBaseSrc, buf *C.GstBuffer, start *C.GstClockTime, end *C.GstClockTime) { - elem := glib.FromObjectUnsafePrivate(unsafe.Pointer(src)) - caller := elem.(interface { - GetTimes(*GstBaseSrc, *gst.Buffer) (start, end time.Duration) + var gostart, goend time.Duration + glib.WithPointerTransferOriginal(unsafe.Pointer(src), func(gObject *glib.Object, goObject glib.GoObjectSubclass) { + iface := goObject.(interface { + GetTimes(*GstBaseSrc, *gst.Buffer) (start, end time.Duration) + }) + gostart, goend = iface.GetTimes(ToGstBaseSrc(gObject), gst.ToGstBuffer(unsafe.Pointer(buf))) }) - gostart, goend := caller.GetTimes(wrapGstBaseSrc(src), gst.FromGstBufferUnsafeNone(unsafe.Pointer(buf))) *start = C.GstClockTime(gostart.Nanoseconds()) *end = C.GstClockTime(goend.Nanoseconds()) } //export goGstBaseSrcGetSize func goGstBaseSrcGetSize(src *C.GstBaseSrc, size *C.guint64) C.gboolean { - elem := glib.FromObjectUnsafePrivate(unsafe.Pointer(src)) - caller := elem.(interface { - GetSize(*GstBaseSrc) (bool, int64) + var gosize int64 + var ok bool + glib.WithPointerTransferOriginal(unsafe.Pointer(src), func(gObject *glib.Object, goObject glib.GoObjectSubclass) { + iface := goObject.(interface { + GetSize(*GstBaseSrc) (bool, int64) + }) + ok, gosize = iface.GetSize(ToGstBaseSrc(gObject)) }) - ok, gosize := caller.GetSize(wrapGstBaseSrc(src)) - if !ok { - return gboolean(ok) + if ok { + *size = C.guint64(gosize) } - *size = C.guint64(gosize) return gboolean(ok) } //export goGstBaseSrcIsSeekable func goGstBaseSrcIsSeekable(src *C.GstBaseSrc) C.gboolean { - elem := glib.FromObjectUnsafePrivate(unsafe.Pointer(src)) - caller := elem.(interface { - IsSeekable(*GstBaseSrc) bool + var ok bool + glib.WithPointerTransferOriginal(unsafe.Pointer(src), func(gObject *glib.Object, goObject glib.GoObjectSubclass) { + iface := goObject.(interface { + IsSeekable(*GstBaseSrc) bool + }) + ok = iface.IsSeekable(ToGstBaseSrc(gObject)) }) - return gboolean(caller.IsSeekable(wrapGstBaseSrc(src))) + return gboolean(ok) } //export goGstBaseSrcPrepareSeekSegment func goGstBaseSrcPrepareSeekSegment(src *C.GstBaseSrc, seek *C.GstEvent, segment *C.GstSegment) C.gboolean { - elem := glib.FromObjectUnsafePrivate(unsafe.Pointer(src)) - caller := elem.(interface { - PrepareSeekSegment(*GstBaseSrc, *gst.Event, *gst.Segment) bool + var ok bool + glib.WithPointerTransferOriginal(unsafe.Pointer(src), func(gObject *glib.Object, goObject glib.GoObjectSubclass) { + iface := goObject.(interface { + PrepareSeekSegment(*GstBaseSrc, *gst.Event, *gst.Segment) bool + }) + ok = iface.PrepareSeekSegment(ToGstBaseSrc(gObject), gst.ToGstEvent(unsafe.Pointer(seek)), gst.FromGstSegmentUnsafe(unsafe.Pointer(segment))) }) - return gboolean(caller.PrepareSeekSegment(wrapGstBaseSrc(src), gst.FromGstEventUnsafeNone(unsafe.Pointer(seek)), gst.FromGstSegmentUnsafe(unsafe.Pointer(segment)))) + return gboolean(ok) } //export goGstBaseSrcDoSeek func goGstBaseSrcDoSeek(src *C.GstBaseSrc, segment *C.GstSegment) C.gboolean { - elem := glib.FromObjectUnsafePrivate(unsafe.Pointer(src)) - caller := elem.(interface { - DoSeek(*GstBaseSrc, *gst.Segment) bool + var ok bool + glib.WithPointerTransferOriginal(unsafe.Pointer(src), func(gObject *glib.Object, goObject glib.GoObjectSubclass) { + iface := goObject.(interface { + DoSeek(*GstBaseSrc, *gst.Segment) bool + }) + ok = iface.DoSeek(ToGstBaseSrc(gObject), gst.ToGstSegment(unsafe.Pointer(segment))) }) - return gboolean(caller.DoSeek(wrapGstBaseSrc(src), gst.FromGstSegmentUnsafe(unsafe.Pointer(segment)))) + return gboolean(ok) } //export goGstBaseSrcUnlock func goGstBaseSrcUnlock(src *C.GstBaseSrc) C.gboolean { - elem := glib.FromObjectUnsafePrivate(unsafe.Pointer(src)) - caller := elem.(interface { - Unlock(*GstBaseSrc) bool + var ok bool + glib.WithPointerTransferOriginal(unsafe.Pointer(src), func(gObject *glib.Object, goObject glib.GoObjectSubclass) { + iface := goObject.(interface { + Unlock(*GstBaseSrc) bool + }) + ok = iface.Unlock(ToGstBaseSrc(gObject)) }) - return gboolean(caller.Unlock(wrapGstBaseSrc(src))) + return gboolean(ok) } //export goGstBaseSrcUnlockStop func goGstBaseSrcUnlockStop(src *C.GstBaseSrc) C.gboolean { - elem := glib.FromObjectUnsafePrivate(unsafe.Pointer(src)) - caller := elem.(interface { - UnlockStop(*GstBaseSrc) bool + var ok bool + glib.WithPointerTransferOriginal(unsafe.Pointer(src), func(gObject *glib.Object, goObject glib.GoObjectSubclass) { + iface := goObject.(interface { + UnlockStop(*GstBaseSrc) bool + }) + ok = iface.UnlockStop(ToGstBaseSrc(gObject)) }) - return gboolean(caller.UnlockStop(wrapGstBaseSrc(src))) + return gboolean(ok) } //export goGstBaseSrcQuery func goGstBaseSrcQuery(src *C.GstBaseSrc, query *C.GstQuery) C.gboolean { - elem := glib.FromObjectUnsafePrivate(unsafe.Pointer(src)) - caller := elem.(interface { - Query(*GstBaseSrc, *gst.Query) bool + var ok bool + glib.WithPointerTransferOriginal(unsafe.Pointer(src), func(gObject *glib.Object, goObject glib.GoObjectSubclass) { + iface := goObject.(interface { + Query(*GstBaseSrc, *gst.Query) bool + }) + ok = iface.Query(ToGstBaseSrc(gObject), gst.ToGstQuery(unsafe.Pointer(query))) }) - return gboolean(caller.Query(wrapGstBaseSrc(src), gst.FromGstQueryUnsafeNone(unsafe.Pointer(query)))) + return gboolean(ok) } //export goGstBaseSrcEvent func goGstBaseSrcEvent(src *C.GstBaseSrc, event *C.GstEvent) C.gboolean { - elem := glib.FromObjectUnsafePrivate(unsafe.Pointer(src)) - caller := elem.(interface { - Event(*GstBaseSrc, *gst.Event) bool + var ok bool + glib.WithPointerTransferOriginal(unsafe.Pointer(src), func(gObject *glib.Object, goObject glib.GoObjectSubclass) { + iface := goObject.(interface { + Event(*GstBaseSrc, *gst.Event) bool + }) + ok = iface.Event(ToGstBaseSrc(gObject), gst.ToGstEvent(unsafe.Pointer(event))) }) - return gboolean(caller.Event(wrapGstBaseSrc(src), gst.FromGstEventUnsafeNone(unsafe.Pointer(event)))) + return gboolean(ok) } //export goGstBaseSrcCreate func goGstBaseSrcCreate(src *C.GstBaseSrc, offset C.guint64, size C.guint, buf **C.GstBuffer) C.GstFlowReturn { - elem := glib.FromObjectUnsafePrivate(unsafe.Pointer(src)) - caller := elem.(interface { - Create(*GstBaseSrc, uint64, uint) (gst.FlowReturn, *gst.Buffer) + var ret gst.FlowReturn + var gobuf *gst.Buffer + glib.WithPointerTransferOriginal(unsafe.Pointer(src), func(gObject *glib.Object, goObject glib.GoObjectSubclass) { + iface := goObject.(interface { + Create(*GstBaseSrc, uint64, uint) (gst.FlowReturn, *gst.Buffer) + }) + ret, gobuf = iface.Create(ToGstBaseSrc(gObject), uint64(offset), uint(size)) }) - ret, gobuf := caller.Create(wrapGstBaseSrc(src), uint64(offset), uint(size)) if ret == gst.FlowOK { C.memcpy(unsafe.Pointer(*buf), unsafe.Pointer(gobuf.Instance()), C.sizeof_GstBuffer) } @@ -179,11 +232,14 @@ func goGstBaseSrcCreate(src *C.GstBaseSrc, offset C.guint64, size C.guint, buf * //export goGstBaseSrcAlloc func goGstBaseSrcAlloc(src *C.GstBaseSrc, offset C.guint64, size C.guint, buf **C.GstBuffer) C.GstFlowReturn { - elem := glib.FromObjectUnsafePrivate(unsafe.Pointer(src)) - caller := elem.(interface { - Alloc(*GstBaseSrc, uint64, uint) (gst.FlowReturn, *gst.Buffer) + var ret gst.FlowReturn + var gobuf *gst.Buffer + glib.WithPointerTransferOriginal(unsafe.Pointer(src), func(gObject *glib.Object, goObject glib.GoObjectSubclass) { + iface := goObject.(interface { + Alloc(*GstBaseSrc, uint64, uint) (gst.FlowReturn, *gst.Buffer) + }) + ret, gobuf = iface.Alloc(ToGstBaseSrc(gObject), uint64(offset), uint(size)) }) - ret, gobuf := caller.Alloc(wrapGstBaseSrc(src), uint64(offset), uint(size)) if ret == gst.FlowOK { C.memcpy(unsafe.Pointer(*buf), unsafe.Pointer(gobuf.Instance()), C.sizeof_GstBuffer) } @@ -192,9 +248,12 @@ func goGstBaseSrcAlloc(src *C.GstBaseSrc, offset C.guint64, size C.guint, buf ** //export goGstBaseSrcFill func goGstBaseSrcFill(src *C.GstBaseSrc, offset C.guint64, size C.guint, buf *C.GstBuffer) C.GstFlowReturn { - elem := glib.FromObjectUnsafePrivate(unsafe.Pointer(src)) - caller := elem.(interface { - Fill(*GstBaseSrc, uint64, uint, *gst.Buffer) gst.FlowReturn + var ret gst.FlowReturn + glib.WithPointerTransferOriginal(unsafe.Pointer(src), func(gObject *glib.Object, goObject glib.GoObjectSubclass) { + iface := goObject.(interface { + Fill(*GstBaseSrc, uint64, uint, *gst.Buffer) gst.FlowReturn + }) + ret = iface.Fill(ToGstBaseSrc(gObject), uint64(offset), uint(size), gst.ToGstBuffer(unsafe.Pointer(buf))) }) - return C.GstFlowReturn(caller.Fill(wrapGstBaseSrc(src), uint64(offset), uint(size), gst.FromGstBufferUnsafeNone(unsafe.Pointer(buf)))) + return C.GstFlowReturn(ret) } diff --git a/gst/base/gst_base_transform.go b/gst/base/gst_base_transform.go index f25c39c..13caf2c 100644 --- a/gst/base/gst_base_transform.go +++ b/gst/base/gst_base_transform.go @@ -48,11 +48,6 @@ func ToGstBaseTransform(obj interface{}) *GstBaseTransform { return nil } -// wrapGstBaseTransform wraps the given unsafe.Pointer in a GstBaseSrc instance. -func wrapGstBaseTransform(obj *C.GstBaseTransform) *GstBaseTransform { - return &GstBaseTransform{gst.FromGstElementUnsafeNone(unsafe.Pointer(obj))} -} - // Instance returns the underlying C GstBaseTransform instance func (g *GstBaseTransform) Instance() *C.GstBaseTransform { return C.toGstBaseTransform(g.Unsafe()) diff --git a/gst/base/gst_base_transform_exports.go b/gst/base/gst_base_transform_exports.go index c719c45..ef90fb6 100644 --- a/gst/base/gst_base_transform_exports.go +++ b/gst/base/gst_base_transform_exports.go @@ -14,79 +14,87 @@ import ( //export goGstBaseTransformAcceptCaps func goGstBaseTransformAcceptCaps(self *C.GstBaseTransform, direction C.GstPadDirection, caps *C.GstCaps) C.gboolean { - elem := glib.FromObjectUnsafePrivate(unsafe.Pointer(self)) - caller := elem.(interface { - AcceptCaps(self *GstBaseTransform, direction gst.PadDirection, caps *gst.Caps) bool + var ret bool + glib.WithPointerTransferOriginal(unsafe.Pointer(self), func(gObject *glib.Object, goObject glib.GoObjectSubclass) { + iface := goObject.(interface { + AcceptCaps(*GstBaseTransform, gst.PadDirection, *gst.Caps) bool + }) + ret = iface.AcceptCaps(ToGstBaseTransform(self), gst.PadDirection(direction), gst.ToGstCaps(unsafe.Pointer(caps))) }) - return gboolean(caller.AcceptCaps(wrapGstBaseTransform(self), gst.PadDirection(direction), gst.FromGstCapsUnsafeNone(unsafe.Pointer(caps)))) + return gboolean(ret) } //export goGstBaseTransformBeforeTransform func goGstBaseTransformBeforeTransform(self *C.GstBaseTransform, buffer *C.GstBuffer) { - elem := glib.FromObjectUnsafePrivate(unsafe.Pointer(self)) - caller := elem.(interface { - BeforeTransform(self *GstBaseTransform, buffer *gst.Buffer) + glib.WithPointerTransferOriginal(unsafe.Pointer(self), func(gObject *glib.Object, goObject glib.GoObjectSubclass) { + iface := goObject.(interface { + BeforeTransform(*GstBaseTransform, *gst.Buffer) + }) + iface.BeforeTransform(ToGstBaseTransform(self), gst.ToGstBuffer(unsafe.Pointer(buffer))) }) - caller.BeforeTransform(wrapGstBaseTransform(self), gst.FromGstBufferUnsafeNone(unsafe.Pointer(buffer))) } //export goGstBaseTransformCopyMetadata -func goGstBaseTransformCopyMetadata(self *C.GstBaseTransform, input, outbuf *C.GstBuffer) C.gboolean { - elem := glib.FromObjectUnsafePrivate(unsafe.Pointer(self)) - caller := elem.(interface { - CopyMetadata(self *GstBaseTransform, input, output *gst.Buffer) bool +func goGstBaseTransformCopyMetadata(self *C.GstBaseTransform, input, output *C.GstBuffer) C.gboolean { + var ret bool + glib.WithPointerTransferOriginal(unsafe.Pointer(self), func(gObject *glib.Object, goObject glib.GoObjectSubclass) { + iface := goObject.(interface { + CopyMetadata(self *GstBaseTransform, input, output *gst.Buffer) bool + }) + ret = iface.CopyMetadata(ToGstBaseTransform(self), gst.ToGstBuffer(unsafe.Pointer(input)), gst.ToGstBuffer(unsafe.Pointer(output))) }) - return gboolean(caller.CopyMetadata(wrapGstBaseTransform(self), gst.FromGstBufferUnsafeNone(unsafe.Pointer(input)), gst.FromGstBufferUnsafeNone(unsafe.Pointer(outbuf)))) + return gboolean(ret) } //export goGstBaseTransformDecideAllocation func goGstBaseTransformDecideAllocation(self *C.GstBaseTransform, query *C.GstQuery) C.gboolean { - elem := glib.FromObjectUnsafePrivate(unsafe.Pointer(self)) - caller := elem.(interface { - DecideAllocation(self *GstBaseTransform, query *gst.Query) bool + var ret bool + glib.WithPointerTransferOriginal(unsafe.Pointer(self), func(gObject *glib.Object, goObject glib.GoObjectSubclass) { + iface := goObject.(interface { + DecideAllocation(self *GstBaseTransform, query *gst.Query) bool + }) + ret = iface.DecideAllocation(ToGstBaseTransform(self), gst.ToGstQuery(unsafe.Pointer(query))) }) - return gboolean(caller.DecideAllocation(wrapGstBaseTransform(self), gst.FromGstQueryUnsafeNone(unsafe.Pointer(query)))) + return gboolean(ret) } //export goGstBaseTransformFilterMeta func goGstBaseTransformFilterMeta(self *C.GstBaseTransform, query *C.GstQuery, api C.GType, params *C.GstStructure) C.gboolean { - elem := glib.FromObjectUnsafePrivate(unsafe.Pointer(self)) - caller := elem.(interface { - FilterMeta(self *GstBaseTransform, query *gst.Query, api glib.Type, params *gst.Structure) bool + var ret bool + glib.WithPointerTransferOriginal(unsafe.Pointer(self), func(gObject *glib.Object, goObject glib.GoObjectSubclass) { + iface := goObject.(interface { + FilterMeta(self *GstBaseTransform, query *gst.Query, api glib.Type, params *gst.Structure) bool + }) + ret = iface.FilterMeta(ToGstBaseTransform(self), gst.ToGstQuery(unsafe.Pointer(query)), glib.Type(api), gst.FromGstStructureUnsafe(unsafe.Pointer(params))) }) - return gboolean(caller.FilterMeta( - wrapGstBaseTransform(self), - gst.FromGstQueryUnsafeNone(unsafe.Pointer(query)), - glib.Type(api), - gst.FromGstStructureUnsafe(unsafe.Pointer(params)), - )) + return gboolean(ret) } //export goGstBaseTransformFixateCaps func goGstBaseTransformFixateCaps(self *C.GstBaseTransform, direction C.GstPadDirection, caps, othercaps *C.GstCaps) *C.GstCaps { - elem := glib.FromObjectUnsafePrivate(unsafe.Pointer(self)) - caller := elem.(interface { - FixateCaps(self *GstBaseTransform, directon gst.PadDirection, caps *gst.Caps, othercaps *gst.Caps) *gst.Caps + var ret *gst.Caps + glib.WithPointerTransferOriginal(unsafe.Pointer(self), func(gObject *glib.Object, goObject glib.GoObjectSubclass) { + iface := goObject.(interface { + FixateCaps(self *GstBaseTransform, directon gst.PadDirection, caps *gst.Caps, othercaps *gst.Caps) *gst.Caps + }) + ret = iface.FixateCaps(ToGstBaseTransform(self), gst.PadDirection(direction), gst.ToGstCaps(unsafe.Pointer(caps)), gst.ToGstCaps(unsafe.Pointer(othercaps))) }) - - wrappedCaps := gst.FromGstCapsUnsafeNone(unsafe.Pointer(caps)) - wrappedOther := gst.FromGstCapsUnsafeNone(unsafe.Pointer(othercaps)) - defer wrappedOther.Unref() - - fixated := caller.FixateCaps(wrapGstBaseTransform(self), gst.PadDirection(direction), wrappedCaps, wrappedOther) - if fixated != nil { - return (*C.GstCaps)(unsafe.Pointer(fixated.Instance())) + if ret == nil { + return nil } - return nil + return (*C.GstCaps)(unsafe.Pointer(ret.Instance())) } //export goGstBaseTransformGenerateOutput func goGstBaseTransformGenerateOutput(self *C.GstBaseTransform, buf **C.GstBuffer) C.GstFlowReturn { - elem := glib.FromObjectUnsafePrivate(unsafe.Pointer(self)) - caller := elem.(interface { - GenerateOutput(self *GstBaseTransform) (gst.FlowReturn, *gst.Buffer) + var ret gst.FlowReturn + var out *gst.Buffer + glib.WithPointerTransferOriginal(unsafe.Pointer(self), func(gObject *glib.Object, goObject glib.GoObjectSubclass) { + iface := goObject.(interface { + GenerateOutput(self *GstBaseTransform) (gst.FlowReturn, *gst.Buffer) + }) + ret, out = iface.GenerateOutput(ToGstBaseTransform(self)) }) - ret, out := caller.GenerateOutput(wrapGstBaseTransform(self)) if out != nil { C.memcpy(unsafe.Pointer(*buf), unsafe.Pointer(out.Instance()), C.sizeof_GstBuffer) } @@ -95,24 +103,30 @@ func goGstBaseTransformGenerateOutput(self *C.GstBaseTransform, buf **C.GstBuffe //export goGstBaseTransformGetUnitSize func goGstBaseTransformGetUnitSize(self *C.GstBaseTransform, caps *C.GstCaps, size *C.gsize) C.gboolean { - elem := glib.FromObjectUnsafePrivate(unsafe.Pointer(self)) - caller := elem.(interface { - GetUnitSize(self *GstBaseTransform, caps *gst.Caps) (ok bool, size int64) + var ret bool + var out int64 + glib.WithPointerTransferOriginal(unsafe.Pointer(self), func(gObject *glib.Object, goObject glib.GoObjectSubclass) { + iface := goObject.(interface { + GetUnitSize(self *GstBaseTransform, caps *gst.Caps) (ok bool, size int64) + }) + ret, out = iface.GetUnitSize(ToGstBaseTransform(self), gst.ToGstCaps(unsafe.Pointer(caps))) }) - ok, retsize := caller.GetUnitSize(wrapGstBaseTransform(self), gst.FromGstCapsUnsafeNone(unsafe.Pointer(caps))) - if ok { - *size = C.gsize(retsize) + if ret { + *size = C.gsize(out) } - return gboolean(ok) + return gboolean(ret) } //export goGstBaseTransformPrepareOutputBuffer func goGstBaseTransformPrepareOutputBuffer(self *C.GstBaseTransform, input *C.GstBuffer, outbuf **C.GstBuffer) C.GstFlowReturn { - elem := glib.FromObjectUnsafePrivate(unsafe.Pointer(self)) - caller := elem.(interface { - PrepareOutputBuffer(self *GstBaseTransform, input *gst.Buffer) (gst.FlowReturn, *gst.Buffer) + var ret gst.FlowReturn + var out *gst.Buffer + glib.WithPointerTransferOriginal(unsafe.Pointer(self), func(gObject *glib.Object, goObject glib.GoObjectSubclass) { + iface := goObject.(interface { + PrepareOutputBuffer(self *GstBaseTransform, input *gst.Buffer) (gst.FlowReturn, *gst.Buffer) + }) + ret, out = iface.PrepareOutputBuffer(ToGstBaseTransform(self), gst.ToGstBuffer(unsafe.Pointer(input))) }) - ret, out := caller.PrepareOutputBuffer(wrapGstBaseTransform(self), gst.FromGstBufferUnsafeNone(unsafe.Pointer(input))) if out != nil { C.memcpy(unsafe.Pointer(*outbuf), unsafe.Pointer(out.Instance()), C.sizeof_GstBuffer) } @@ -121,156 +135,163 @@ func goGstBaseTransformPrepareOutputBuffer(self *C.GstBaseTransform, input *C.Gs //export goGstBaseTransformProposeAllocation func goGstBaseTransformProposeAllocation(self *C.GstBaseTransform, decide, query *C.GstQuery) C.gboolean { - elem := glib.FromObjectUnsafePrivate(unsafe.Pointer(self)) - caller := elem.(interface { - ProposeAllocation(self *GstBaseTransform, decideQuery, query *gst.Query) bool + var ret bool + glib.WithPointerTransferOriginal(unsafe.Pointer(self), func(gObject *glib.Object, goObject glib.GoObjectSubclass) { + iface := goObject.(interface { + ProposeAllocation(self *GstBaseTransform, decideQuery, query *gst.Query) bool + }) + ret = iface.ProposeAllocation(ToGstBaseTransform(self), gst.ToGstQuery(unsafe.Pointer(decide)), gst.ToGstQuery(unsafe.Pointer(query))) }) - return gboolean(caller.ProposeAllocation(wrapGstBaseTransform(self), gst.FromGstQueryUnsafeNone(unsafe.Pointer(decide)), gst.FromGstQueryUnsafeNone(unsafe.Pointer(query)))) + return gboolean(ret) } //export goGstBaseTransformQuery func goGstBaseTransformQuery(self *C.GstBaseTransform, direction C.GstPadDirection, query *C.GstQuery) C.gboolean { - elem := glib.FromObjectUnsafePrivate(unsafe.Pointer(self)) - caller := elem.(interface { - Query(self *GstBaseTransform, direction gst.PadDirection, query *gst.Query) bool + var ret bool + glib.WithPointerTransferOriginal(unsafe.Pointer(self), func(gObject *glib.Object, goObject glib.GoObjectSubclass) { + iface := goObject.(interface { + Query(self *GstBaseTransform, direction gst.PadDirection, query *gst.Query) bool + }) + ret = iface.Query(ToGstBaseTransform(self), gst.PadDirection(direction), gst.ToGstQuery(unsafe.Pointer(query))) }) - return gboolean(caller.Query(wrapGstBaseTransform(self), gst.PadDirection(direction), gst.FromGstQueryUnsafeNone(unsafe.Pointer(query)))) + return gboolean(ret) } //export goGstBaseTransformSetCaps func goGstBaseTransformSetCaps(self *C.GstBaseTransform, incaps, outcaps *C.GstCaps) C.gboolean { - elem := glib.FromObjectUnsafePrivate(unsafe.Pointer(self)) - caller := elem.(interface { - SetCaps(self *GstBaseTransform, incaps, outcaps *gst.Caps) bool + var ret bool + glib.WithPointerTransferOriginal(unsafe.Pointer(self), func(gObject *glib.Object, goObject glib.GoObjectSubclass) { + iface := goObject.(interface { + SetCaps(self *GstBaseTransform, incaps, outcaps *gst.Caps) bool + }) + ret = iface.SetCaps(ToGstBaseTransform(self), gst.ToGstCaps(unsafe.Pointer(incaps)), gst.ToGstCaps(unsafe.Pointer(outcaps))) }) - return gboolean(caller.SetCaps( - wrapGstBaseTransform(self), - gst.FromGstCapsUnsafeNone(unsafe.Pointer(incaps)), - gst.FromGstCapsUnsafeNone(unsafe.Pointer(outcaps)), - )) + return gboolean(ret) } //export goGstBaseTransformSinkEvent func goGstBaseTransformSinkEvent(self *C.GstBaseTransform, event *C.GstEvent) C.gboolean { - elem := glib.FromObjectUnsafePrivate(unsafe.Pointer(self)) - caller := elem.(interface { - SinkEvent(self *GstBaseTransform, event *gst.Event) bool + var ret bool + glib.WithPointerTransferOriginal(unsafe.Pointer(self), func(gObject *glib.Object, goObject glib.GoObjectSubclass) { + iface := goObject.(interface { + SinkEvent(self *GstBaseTransform, event *gst.Event) bool + }) + ret = iface.SinkEvent(ToGstBaseTransform(self), gst.ToGstEvent(unsafe.Pointer(event))) }) - return gboolean(caller.SinkEvent(wrapGstBaseTransform(self), gst.FromGstEventUnsafeNone(unsafe.Pointer(event)))) + return gboolean(ret) } //export goGstBaseTransformSrcEvent func goGstBaseTransformSrcEvent(self *C.GstBaseTransform, event *C.GstEvent) C.gboolean { - elem := glib.FromObjectUnsafePrivate(unsafe.Pointer(self)) - caller := elem.(interface { - SrcEvent(self *GstBaseTransform, event *gst.Event) bool + var ret bool + glib.WithPointerTransferOriginal(unsafe.Pointer(self), func(gObject *glib.Object, goObject glib.GoObjectSubclass) { + iface := goObject.(interface { + SrcEvent(self *GstBaseTransform, event *gst.Event) bool + }) + ret = iface.SrcEvent(ToGstBaseTransform(self), gst.ToGstEvent(unsafe.Pointer(event))) }) - return gboolean(caller.SrcEvent(wrapGstBaseTransform(self), gst.FromGstEventUnsafeNone(unsafe.Pointer(event)))) + return gboolean(ret) } //export goGstBaseTransformStart func goGstBaseTransformStart(self *C.GstBaseTransform) C.gboolean { - elem := glib.FromObjectUnsafePrivate(unsafe.Pointer(self)) - caller := elem.(interface { - Start(self *GstBaseTransform) bool + var ret bool + glib.WithPointerTransferOriginal(unsafe.Pointer(self), func(gObject *glib.Object, goObject glib.GoObjectSubclass) { + iface := goObject.(interface { + Start(self *GstBaseTransform) bool + }) + ret = iface.Start(ToGstBaseTransform(self)) }) - return gboolean(caller.Start(wrapGstBaseTransform(self))) + return gboolean(ret) } //export goGstBaseTransformStop func goGstBaseTransformStop(self *C.GstBaseTransform) C.gboolean { - elem := glib.FromObjectUnsafePrivate(unsafe.Pointer(self)) - caller := elem.(interface { - Stop(self *GstBaseTransform) bool + var ret bool + glib.WithPointerTransferOriginal(unsafe.Pointer(self), func(gObject *glib.Object, goObject glib.GoObjectSubclass) { + iface := goObject.(interface { + Stop(self *GstBaseTransform) bool + }) + ret = iface.Stop(ToGstBaseTransform(self)) }) - return gboolean(caller.Stop(wrapGstBaseTransform(self))) + return gboolean(ret) } //export goGstBaseTransformSubmitInputBuffer func goGstBaseTransformSubmitInputBuffer(self *C.GstBaseTransform, isDiscont C.gboolean, input *C.GstBuffer) C.GstFlowReturn { - elem := glib.FromObjectUnsafePrivate(unsafe.Pointer(self)) - caller := elem.(interface { - SubmitInputBuffer(self *GstBaseTransform, isDiscont bool, input *gst.Buffer) gst.FlowReturn + var ret gst.FlowReturn + glib.WithPointerTransferOriginal(unsafe.Pointer(self), func(gObject *glib.Object, goObject glib.GoObjectSubclass) { + iface := goObject.(interface { + SubmitInputBuffer(self *GstBaseTransform, isDiscont bool, input *gst.Buffer) gst.FlowReturn + }) + ret = iface.SubmitInputBuffer(ToGstBaseTransform(self), gobool(isDiscont), gst.ToGstBuffer(unsafe.Pointer(input))) }) - return C.GstFlowReturn(caller.SubmitInputBuffer( - wrapGstBaseTransform(self), - gobool(isDiscont), - gst.FromGstBufferUnsafeNone(unsafe.Pointer(input)), - )) + return C.GstFlowReturn(ret) } //export goGstBaseTransformTransform func goGstBaseTransformTransform(self *C.GstBaseTransform, inbuf, outbuf *C.GstBuffer) C.GstFlowReturn { - elem := glib.FromObjectUnsafePrivate(unsafe.Pointer(self)) - caller := elem.(interface { - Transform(self *GstBaseTransform, inbuf, outbuf *gst.Buffer) gst.FlowReturn + var ret gst.FlowReturn + glib.WithPointerTransferOriginal(unsafe.Pointer(self), func(gObject *glib.Object, goObject glib.GoObjectSubclass) { + iface := goObject.(interface { + Transform(self *GstBaseTransform, inbuf, outbuf *gst.Buffer) gst.FlowReturn + }) + ret = iface.Transform(ToGstBaseTransform(self), gst.ToGstBuffer(unsafe.Pointer(inbuf)), gst.ToGstBuffer(unsafe.Pointer(outbuf))) }) - return C.GstFlowReturn(caller.Transform( - wrapGstBaseTransform(self), - gst.FromGstBufferUnsafeNone(unsafe.Pointer(inbuf)), - gst.FromGstBufferUnsafeNone(unsafe.Pointer(outbuf)), - )) + return C.GstFlowReturn(ret) } //export goGstBaseTransformTransformCaps func goGstBaseTransformTransformCaps(self *C.GstBaseTransform, direction C.GstPadDirection, caps, filter *C.GstCaps) *C.GstCaps { - elem := glib.FromObjectUnsafePrivate(unsafe.Pointer(self)) - caller := elem.(interface { - TransformCaps(self *GstBaseTransform, direction gst.PadDirection, caps, filter *gst.Caps) *gst.Caps + var ret *gst.Caps + glib.WithPointerTransferOriginal(unsafe.Pointer(self), func(gObject *glib.Object, goObject glib.GoObjectSubclass) { + iface := goObject.(interface { + TransformCaps(self *GstBaseTransform, direction gst.PadDirection, caps, filter *gst.Caps) *gst.Caps + }) + ret = iface.TransformCaps(ToGstBaseTransform(self), gst.PadDirection(direction), gst.ToGstCaps(unsafe.Pointer(caps)), gst.ToGstCaps(unsafe.Pointer(filter))) }) - out := caller.TransformCaps( - wrapGstBaseTransform(self), - gst.PadDirection(direction), - gst.FromGstCapsUnsafeNone(unsafe.Pointer(caps)), - gst.FromGstCapsUnsafeNone(unsafe.Pointer(filter)), - ) - if out == nil { + if ret == nil { return nil } - return (*C.GstCaps)(unsafe.Pointer(out.Instance())) + return (*C.GstCaps)(unsafe.Pointer(ret.Instance())) } //export goGstBaseTransformTransformIP func goGstBaseTransformTransformIP(self *C.GstBaseTransform, buf *C.GstBuffer) C.GstFlowReturn { - elem := glib.FromObjectUnsafePrivate(unsafe.Pointer(self)) - caller := elem.(interface { - TransformIP(self *GstBaseTransform, buf *gst.Buffer) gst.FlowReturn + var ret gst.FlowReturn + glib.WithPointerTransferOriginal(unsafe.Pointer(self), func(gObject *glib.Object, goObject glib.GoObjectSubclass) { + iface := goObject.(interface { + TransformIP(self *GstBaseTransform, buf *gst.Buffer) gst.FlowReturn + }) + ret = iface.TransformIP(ToGstBaseTransform(self), gst.ToGstBuffer(unsafe.Pointer(buf))) }) - return C.GstFlowReturn(caller.TransformIP( - wrapGstBaseTransform(self), - gst.FromGstBufferUnsafeNone(unsafe.Pointer(buf)), - )) + return C.GstFlowReturn(ret) } //export goGstBaseTransformTransformMeta func goGstBaseTransformTransformMeta(self *C.GstBaseTransform, outbuf *C.GstBuffer, meta *C.GstMeta, inbuf *C.GstBuffer) C.gboolean { - elem := glib.FromObjectUnsafePrivate(unsafe.Pointer(self)) - caller := elem.(interface { - TransformMeta(self *GstBaseTransform, outbuf *gst.Buffer, meta *gst.Meta, inbuf *gst.Buffer) bool + var ret bool + glib.WithPointerTransferOriginal(unsafe.Pointer(self), func(gObject *glib.Object, goObject glib.GoObjectSubclass) { + iface := goObject.(interface { + TransformMeta(self *GstBaseTransform, outbuf *gst.Buffer, meta *gst.Meta, inbuf *gst.Buffer) bool + }) + ret = iface.TransformMeta(ToGstBaseTransform(self), gst.ToGstBuffer(unsafe.Pointer(outbuf)), gst.FromGstMetaUnsafe(unsafe.Pointer(meta)), gst.ToGstBuffer(unsafe.Pointer(inbuf))) }) - return gboolean(caller.TransformMeta( - wrapGstBaseTransform(self), - gst.FromGstBufferUnsafeNone(unsafe.Pointer(outbuf)), - gst.FromGstMetaUnsafe(unsafe.Pointer(meta)), - gst.FromGstBufferUnsafeNone(unsafe.Pointer(inbuf)), - )) + return gboolean(ret) } //export goGstBaseTransformTransformSize func goGstBaseTransformTransformSize(self *C.GstBaseTransform, direction C.GstPadDirection, caps *C.GstCaps, size C.gsize, othercaps *C.GstCaps, outsize *C.gsize) C.gboolean { - elem := glib.FromObjectUnsafePrivate(unsafe.Pointer(self)) - caller := elem.(interface { - TransformSize(self *GstBaseTransform, direction gst.PadDirection, caps *gst.Caps, size int64, othercaps *gst.Caps) (ok bool, othersize int64) + var ret bool + var othersize int64 + glib.WithPointerTransferOriginal(unsafe.Pointer(self), func(gObject *glib.Object, goObject glib.GoObjectSubclass) { + iface := goObject.(interface { + TransformSize(self *GstBaseTransform, direction gst.PadDirection, caps *gst.Caps, size int64, othercaps *gst.Caps) (ok bool, othersize int64) + }) + ret, othersize = iface.TransformSize(ToGstBaseTransform(self), gst.PadDirection(direction), gst.ToGstCaps(unsafe.Pointer(caps)), int64(size), gst.ToGstCaps(unsafe.Pointer(othercaps))) }) - ok, othersize := caller.TransformSize( - wrapGstBaseTransform(self), - gst.PadDirection(direction), - gst.FromGstCapsUnsafeNone(unsafe.Pointer(caps)), - int64(size), - gst.FromGstCapsUnsafeNone(unsafe.Pointer(othercaps)), - ) - if ok { + if ret { *outsize = C.gsize(othersize) } - return gboolean(ok) + return gboolean(ret) } diff --git a/gst/base/gst_push_src.go b/gst/base/gst_push_src.go index c0ffae1..980f989 100644 --- a/gst/base/gst_push_src.go +++ b/gst/base/gst_push_src.go @@ -6,8 +6,6 @@ package base import "C" import ( - "unsafe" - "github.com/tinyzimmer/go-glib/glib" "github.com/tinyzimmer/go-gst/gst" ) @@ -26,11 +24,6 @@ func ToGstPushSrc(obj interface{}) *GstPushSrc { return nil } -// wrapGstPushSrc wraps the given unsafe.Pointer in a GstPushSrc instance. -func wrapGstPushSrc(obj *C.GstPushSrc) *GstPushSrc { - return &GstPushSrc{&GstBaseSrc{gst.FromGstElementUnsafeNone(unsafe.Pointer(obj))}} -} - // Instance returns the underlying C GstBaseSrc instance func (g *GstPushSrc) Instance() *C.GstPushSrc { return C.toGstPushSrc(g.Unsafe()) diff --git a/gst/base/gst_push_src_exports.go b/gst/base/gst_push_src_exports.go index 69d313c..1c2fd28 100644 --- a/gst/base/gst_push_src_exports.go +++ b/gst/base/gst_push_src_exports.go @@ -14,34 +14,44 @@ import ( //export goGstPushSrcAlloc func goGstPushSrcAlloc(src *C.GstPushSrc, buf **C.GstBuffer) C.GstFlowReturn { - caller := glib.FromObjectUnsafePrivate(unsafe.Pointer(src)).(interface { - Alloc(*GstPushSrc) (gst.FlowReturn, *gst.Buffer) + var ret gst.FlowReturn + var outbuf *gst.Buffer + glib.WithPointerTransferOriginal(unsafe.Pointer(src), func(gObject *glib.Object, goObject glib.GoObjectSubclass) { + iface := goObject.(interface { + Alloc(*GstPushSrc) (gst.FlowReturn, *gst.Buffer) + }) + ret, outbuf = iface.Alloc(ToGstPushSrc(gObject)) }) - ret, buffer := caller.Alloc(wrapGstPushSrc(src)) - if ret != gst.FlowOK { - return C.GstFlowReturn(ret) + if outbuf != nil { + C.memcpy(unsafe.Pointer(*buf), unsafe.Pointer(outbuf.Instance()), C.sizeof_GstBuffer) } - C.memcpy(unsafe.Pointer(*buf), unsafe.Pointer(buffer.Instance()), C.sizeof_GstBuffer) return C.GstFlowReturn(ret) } //export goGstPushSrcCreate func goGstPushSrcCreate(src *C.GstPushSrc, buf **C.GstBuffer) C.GstFlowReturn { - caller := glib.FromObjectUnsafePrivate(unsafe.Pointer(src)).(interface { - Create(*GstPushSrc) (gst.FlowReturn, *gst.Buffer) + var ret gst.FlowReturn + var outbuf *gst.Buffer + glib.WithPointerTransferOriginal(unsafe.Pointer(src), func(gObject *glib.Object, goObject glib.GoObjectSubclass) { + iface := goObject.(interface { + Create(*GstPushSrc) (gst.FlowReturn, *gst.Buffer) + }) + ret, outbuf = iface.Create(ToGstPushSrc(gObject)) }) - ret, buffer := caller.Create(wrapGstPushSrc(src)) - if ret != gst.FlowOK { - return C.GstFlowReturn(ret) + if outbuf != nil { + C.memcpy(unsafe.Pointer(*buf), unsafe.Pointer(outbuf.Instance()), C.sizeof_GstBuffer) } - C.memcpy(unsafe.Pointer(*buf), unsafe.Pointer(buffer.Instance()), C.sizeof_GstBuffer) return C.GstFlowReturn(ret) } //export goGstPushSrcFill func goGstPushSrcFill(src *C.GstPushSrc, buf *C.GstBuffer) C.GstFlowReturn { - caller := glib.FromObjectUnsafePrivate(unsafe.Pointer(src)).(interface { - Fill(*GstPushSrc, *gst.Buffer) gst.FlowReturn + var ret gst.FlowReturn + glib.WithPointerTransferOriginal(unsafe.Pointer(src), func(gObject *glib.Object, goObject glib.GoObjectSubclass) { + iface := goObject.(interface { + Fill(*GstPushSrc, *gst.Buffer) gst.FlowReturn + }) + ret = iface.Fill(ToGstPushSrc(gObject), gst.ToGstBuffer(unsafe.Pointer(buf))) }) - return C.GstFlowReturn(caller.Fill(wrapGstPushSrc(src), gst.FromGstBufferUnsafeNone(unsafe.Pointer(buf)))) + return C.GstFlowReturn(ret) } diff --git a/gst/gst_buffer.go b/gst/gst_buffer.go index bb75278..15ea9e8 100644 --- a/gst/gst_buffer.go +++ b/gst/gst_buffer.go @@ -40,15 +40,10 @@ type Buffer struct { mapInfo *MapInfo } -// // FromGstBufferUnsafe wraps the given C GstBuffer in the go type. It is meant for internal usage -// // and exported for visibility to other packages. -// func FromGstBufferUnsafe(buf unsafe.Pointer) *Buffer { -// return FromGstBufferUnsafeNone(buf) -// } - -// FromGstBufferUnsafeNone is an alias to FromGstBufferUnsafe. +// FromGstBufferUnsafeNone wraps the given buffer, sinking any floating references, and places +// a finalizer on the wrapped Buffer. func FromGstBufferUnsafeNone(buf unsafe.Pointer) *Buffer { - wrapped := wrapBuffer((*C.GstBuffer)(buf)) + wrapped := ToGstBuffer(buf) wrapped.Ref() runtime.SetFinalizer(wrapped, (*Buffer).Unref) return wrapped @@ -56,11 +51,17 @@ func FromGstBufferUnsafeNone(buf unsafe.Pointer) *Buffer { // FromGstBufferUnsafeFull wraps the given buffer without taking an additional reference. func FromGstBufferUnsafeFull(buf unsafe.Pointer) *Buffer { - wrapped := wrapBuffer((*C.GstBuffer)(buf)) + wrapped := ToGstBuffer(buf) runtime.SetFinalizer(wrapped, (*Buffer).Unref) return wrapped } +// ToGstBuffer converts the given pointer into a Buffer without affecting the ref count or +// placing finalizers. +func ToGstBuffer(buf unsafe.Pointer) *Buffer { + return wrapBuffer((*C.GstBuffer)(buf)) +} + // NewEmptyBuffer returns a new empty buffer. func NewEmptyBuffer() *Buffer { return FromGstBufferUnsafeFull(unsafe.Pointer(C.gst_buffer_new())) diff --git a/gst/gst_buffer_list.go b/gst/gst_buffer_list.go index e53be4d..345975f 100644 --- a/gst/gst_buffer_list.go +++ b/gst/gst_buffer_list.go @@ -41,13 +41,7 @@ func NewBufferListSized(size uint) *BufferList { return FromGstBufferListUnsafeFull(unsafe.Pointer(C.gst_buffer_list_new_sized(C.guint(size)))) } -// // FromGstBufferListUnsafe wraps the given C GstBufferList in the go type. It is meant for internal usage -// // and exported for visibility to other packages. -// func FromGstBufferListUnsafe(buf unsafe.Pointer) *BufferList { -// return FromGstBufferListUnsafeNone(buf) -// } - -// FromGstBufferListUnsafeNone is an alias to FromGstBufferListUnsafe. +// FromGstBufferListUnsafeNone is used for returns from transfer-none methods. func FromGstBufferListUnsafeNone(buf unsafe.Pointer) *BufferList { wrapped := wrapBufferList((*C.GstBufferList)(buf)) wrapped.Ref() @@ -62,6 +56,12 @@ func FromGstBufferListUnsafeFull(buf unsafe.Pointer) *BufferList { return wrapped } +// ToGstBufferList converts the given pointer into a BufferList without affecting the ref count or +// placing finalizers. +func ToGstBufferList(buf unsafe.Pointer) *BufferList { + return wrapBufferList((*C.GstBufferList)(buf)) +} + // Instance returns the underlying GstBufferList. func (b *BufferList) Instance() *C.GstBufferList { return C.toGstBufferList(unsafe.Pointer(b.ptr)) } diff --git a/gst/gst_caps.go b/gst/gst_caps.go index f7b162d..ebaa248 100644 --- a/gst/gst_caps.go +++ b/gst/gst_caps.go @@ -36,7 +36,7 @@ func FromGstCapsUnsafeNone(caps unsafe.Pointer) *Caps { if caps == nil { return nil } - gocaps := wrapCaps(C.toGstCaps(caps)) + gocaps := ToGstCaps(caps) gocaps.Ref() runtime.SetFinalizer(gocaps, (*Caps).Unref) return gocaps @@ -54,11 +54,17 @@ func FromGstCapsUnsafeFull(caps unsafe.Pointer) *Caps { if caps == nil { return nil } - gocaps := wrapCaps(C.toGstCaps(caps)) + gocaps := ToGstCaps(caps) runtime.SetFinalizer(gocaps, (*Caps).Unref) return gocaps } +// ToGstCaps converts the given pointer into a Caps without affecting the ref count or +// placing finalizers. +func ToGstCaps(caps unsafe.Pointer) *Caps { + return wrapCaps(C.toGstCaps(caps)) +} + // CapsMapFunc represents a function passed to the Caps MapInPlace, ForEach, and FilterAndMapInPlace methods. type CapsMapFunc func(features *CapsFeatures, structure *Structure) bool diff --git a/gst/gst_event.go b/gst/gst_event.go index cb55af3..b112c6d 100644 --- a/gst/gst_event.go +++ b/gst/gst_event.go @@ -20,7 +20,7 @@ type Event struct { // FromGstEventUnsafeNone wraps the pointer to the given C GstEvent with the go type. // A ref is taken and finalizer applied. func FromGstEventUnsafeNone(ev unsafe.Pointer) *Event { - event := &Event{ptr: (*C.GstEvent)(ev)} + event := ToGstEvent(ev) event.Ref() runtime.SetFinalizer(event, (*Event).Unref) return event @@ -29,11 +29,17 @@ func FromGstEventUnsafeNone(ev unsafe.Pointer) *Event { // FromGstEventUnsafeFull wraps the pointer to the given C GstEvent without taking a ref. // A finalizer is applied. func FromGstEventUnsafeFull(ev unsafe.Pointer) *Event { - event := &Event{ptr: (*C.GstEvent)(ev)} + event := ToGstEvent(ev) runtime.SetFinalizer(event, (*Event).Unref) return event } +// ToGstEvent converts the given pointer into an Event without affecting the ref count or +// placing finalizers. +func ToGstEvent(ev unsafe.Pointer) *Event { + return wrapEvent((*C.GstEvent)(ev)) +} + // Instance returns the underlying GstEvent instance. func (e *Event) Instance() *C.GstEvent { return C.toGstEvent(unsafe.Pointer(e.ptr)) } diff --git a/gst/gst_message.go b/gst/gst_message.go index 3128873..4d1c486 100644 --- a/gst/gst_message.go +++ b/gst/gst_message.go @@ -21,7 +21,7 @@ type Message struct { // FromGstMessageUnsafeNone wraps the given unsafe.Pointer in a message. A ref is taken // on the message and a runtime finalizer placed on the object. func FromGstMessageUnsafeNone(msg unsafe.Pointer) *Message { - gomsg := wrapMessage((*C.GstMessage)(msg)) + gomsg := ToGstMessage(msg) gomsg.Ref() runtime.SetFinalizer(gomsg, (*Message).Unref) return gomsg @@ -30,11 +30,15 @@ func FromGstMessageUnsafeNone(msg unsafe.Pointer) *Message { // FromGstMessageUnsafeFull wraps the given unsafe.Pointer in a message. No ref is taken // and a finalizer is placed on the resulting object. func FromGstMessageUnsafeFull(msg unsafe.Pointer) *Message { - gomsg := wrapMessage((*C.GstMessage)(msg)) + gomsg := ToGstMessage(msg) runtime.SetFinalizer(gomsg, (*Message).Unref) return gomsg } +// ToGstMessage converts the given pointer into a Message without affecting the ref count or +// placing finalizers. +func ToGstMessage(msg unsafe.Pointer) *Message { return wrapMessage((*C.GstMessage)(msg)) } + // Instance returns the underlying GstMessage object. func (m *Message) Instance() *C.GstMessage { return C.toGstMessage(unsafe.Pointer(m.msg)) } diff --git a/gst/gst_query.go b/gst/gst_query.go index 6de329d..c7f22b2 100644 --- a/gst/gst_query.go +++ b/gst/gst_query.go @@ -21,7 +21,7 @@ func (q *Query) Type() QueryType { return QueryType(q.ptr._type) } // FromGstQueryUnsafeNone wraps the pointer to the given C GstQuery with the go type. // This is meant for internal usage and is exported for visibility to other packages. func FromGstQueryUnsafeNone(query unsafe.Pointer) *Query { - q := wrapQuery((*C.GstQuery)(query)) + q := ToGstQuery(query) q.Ref() runtime.SetFinalizer(q, (*Query).Unref) return q @@ -30,11 +30,15 @@ func FromGstQueryUnsafeNone(query unsafe.Pointer) *Query { // FromGstQueryUnsafeFull wraps the pointer to the given C GstQuery with the go type. // This is meant for internal usage and is exported for visibility to other packages. func FromGstQueryUnsafeFull(query unsafe.Pointer) *Query { - q := wrapQuery((*C.GstQuery)(query)) + q := ToGstQuery(query) runtime.SetFinalizer(q, (*Query).Unref) return q } +// ToGstQuery converts the given pointer into a Message without affecting the ref count or +// placing finalizers. +func ToGstQuery(query unsafe.Pointer) *Query { return wrapQuery((*C.GstQuery)(query)) } + // NewAcceptCapsQuery constructs a new query object for querying if caps are accepted. func NewAcceptCapsQuery(caps *Caps) *Query { return FromGstQueryUnsafeFull(unsafe.Pointer(C.gst_query_new_accept_caps(caps.Instance()))) diff --git a/gst/gst_segment.go b/gst/gst_segment.go index 1030127..db72f04 100644 --- a/gst/gst_segment.go +++ b/gst/gst_segment.go @@ -15,6 +15,12 @@ func FromGstSegmentUnsafe(segment unsafe.Pointer) *Segment { return wrapSegment((*C.GstSegment)(segment)) } +// ToGstSegment converts the given pointer into a Segment without affecting the ref count or +// placing finalizers. +func ToGstSegment(segment unsafe.Pointer) *Segment { + return wrapSegment((*C.GstSegment)(segment)) +} + // NewSegment allocates and initializes a new Segment. Free when you are finished. func NewSegment() *Segment { return wrapSegment(C.gst_segment_new())