add custom transform example and remove calls to deprecated methods

examples/plugins/basetransform/internal/customtransform/element.go

@@ -0,0 +1,68 @@
+package customtransform
+
+import (
+	"github.com/go-gst/go-glib/glib"
+	"github.com/go-gst/go-gst/gst"
+	"github.com/go-gst/go-gst/gst/base"
+)
+
+type customBaseTransform struct{}
+
+// ClassInit is the place where you define pads and properties
+func (*customBaseTransform) ClassInit(klass *glib.ObjectClass) {
+	class := gst.ToElementClass(klass)
+	class.SetMetadata(
+		"custom base transform",
+		"Transform/demo",
+		"custom base transform",
+		"Wilhelm Bartel <bartel.wilhelm@gmail.com>",
+	)
+	class.AddPadTemplate(gst.NewPadTemplate(
+		"src",
+		gst.PadDirectionSource,
+		gst.PadPresenceAlways,
+		gst.NewCapsFromString("audio/x-raw,channels=2,rate=48000"),
+	))
+	class.AddPadTemplate(gst.NewPadTemplate(
+		"sink",
+		gst.PadDirectionSink,
+		gst.PadPresenceAlways,
+		gst.NewCapsFromString("audio/x-raw,channels=2,rate=48000"),
+	))
+}
+
+// SetProperty gets called for every property. The id is the index in the slice defined above.
+func (s *customBaseTransform) SetProperty(self *glib.Object, id uint, value *glib.Value) {}
+
+// GetProperty is called to retrieve the value of the property at index `id` in the properties
+// slice provided at ClassInit.
+func (o *customBaseTransform) GetProperty(self *glib.Object, id uint) *glib.Value {
+	return nil
+}
+
+// New is called by the bindings to create a new instance of your go element. Use this to initialize channels, maps, etc.
+//
+// Think of New like the constructor of your struct
+func (*customBaseTransform) New() glib.GoObjectSubclass {
+	return &customBaseTransform{}
+}
+
+// InstanceInit should initialize the element. Keep in mind that the properties are not yet present. When this is called.
+func (s *customBaseTransform) InstanceInit(instance *glib.Object) {}
+
+func (s *customBaseTransform) Constructed(o *glib.Object) {}
+
+func (s *customBaseTransform) Finalize(o *glib.Object) {}
+
+// see base.GstBaseTransformImpl interface for the method signatures of the virtual methods
+//
+// it is not required to implement all methods
+var _ base.GstBaseTransformImpl = nil
+
+func (s *customBaseTransform) SinkEvent(self *base.GstBaseTransform, event *gst.Event) bool {
+	return self.ParentSinkEvent(event)
+}
+
+func (s *customBaseTransform) SrcEvent(self *base.GstBaseTransform, event *gst.Event) bool {
+	return self.ParentSrcEvent(event)
+}

examples/plugins/basetransform/internal/customtransform/register.go

@@ -0,0 +1,23 @@
+package customtransform
+
+import (
+	"github.com/go-gst/go-gst/gst"
+	"github.com/go-gst/go-gst/gst/base"
+)
+
+// Register needs to be called after gst.Init() to make the gocustombin available in the standard
+// gst element registry. After this call the element can be used like any other gstreamer element
+func Register() bool {
+	return gst.RegisterElement(
+		// no plugin:
+		nil,
+		// The name of the element
+		"gocustomtransform",
+		// The rank of the element
+		gst.RankNone,
+		// The GoElement implementation for the element
+		&customBaseTransform{},
+		// The base subclass this element extends
+		base.ExtendsBaseTransform,
+	)
+}

examples/plugins/basetransform/main.go

@@ -0,0 +1,46 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"os/signal"
+
+	"github.com/go-gst/go-gst/examples/plugins/basetransform/internal/customtransform"
+	"github.com/go-gst/go-gst/gst"
+)
+
+func run(ctx context.Context) error {
+	ctx, cancel := signal.NotifyContext(ctx, os.Interrupt)
+	defer cancel()
+
+	gst.Init(nil)
+
+	customtransform.Register()
+
+	pipeline, err := gst.NewPipelineFromString("audiotestsrc ! gocustomtransform ! fakesink")
+
+	if err != nil {
+		return err
+	}
+
+	pipeline.SetState(gst.StatePlaying)
+
+	<-ctx.Done()
+
+	pipeline.BlockSetState(gst.StateNull)
+
+	gst.Deinit()
+
+	return ctx.Err()
+}
+
+func main() {
+	ctx := context.Background()
+
+	err := run(ctx)
+
+	if err != nil {
+		fmt.Fprintln(os.Stderr, err)
+	}
+}

gst/app/cgo_exports.go

@@ -64,7 +64,8 @@ func goNeedDataCb(src *C.GstAppSrc, length C.guint, userData C.gpointer) {
 		return
 	}
 	gosrc := wrapCSource(src)
-	gosrc.WithTransferOriginal(func() { cbs.NeedDataFunc(gosrc, uint(length)) })
+
+	cbs.NeedDataFunc(gosrc, uint(length))
 }
 
 //export goEnoughDataDb
@@ -77,7 +78,7 @@ func goEnoughDataDb(src *C.GstAppSrc, userData C.gpointer) {
 		return
 	}
 	gosrc := wrapCSource(src)
-	gosrc.WithTransferOriginal(func() { cbs.EnoughDataFunc(gosrc) })
+	cbs.EnoughDataFunc(gosrc)
 }
 
 //export goSeekDataCb
@@ -91,7 +92,7 @@ func goSeekDataCb(src *C.GstAppSrc, offset C.guint64, userData C.gpointer) C.gbo
 	}
 	gosrc := wrapCSource(src)
 	var ret C.gboolean
-	gosrc.WithTransferOriginal(func() { ret = gboolean(cbs.SeekDataFunc(gosrc, uint64(offset))) })
+	ret = gboolean(cbs.SeekDataFunc(gosrc, uint64(offset)))
 	return ret
 }
 

gst/base/gst_base_sink_exports.go

@@ -16,36 +16,42 @@ import (
 //export goGstBaseSinkActivatePull
 func goGstBaseSinkActivatePull(sink *C.GstBaseSink, active C.gboolean) C.gboolean {
 	var ret C.gboolean
-	glib.WithPointerTransferOriginal(unsafe.Pointer(sink), func(gObject *glib.Object, goObject glib.GoObjectSubclass) {
+	goBaseSink := ToGstBaseSink(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(sink))})
-		iface := goObject.(interface {
+	subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(sink))
-			ActivatePull(self *GstBaseSink, active bool) bool
+
-		})
+	iface := subclass.(interface {
-		ret = gboolean(iface.ActivatePull(ToGstBaseSink(gObject), gobool(active)))
+		ActivatePull(self *GstBaseSink, active bool) bool
 	})
+	ret = gboolean(iface.ActivatePull(goBaseSink, gobool(active)))
+
 	return ret
 }
 
 //export goGstBaseSinkEvent
 func goGstBaseSinkEvent(sink *C.GstBaseSink, event *C.GstEvent) C.gboolean {
 	var ret C.gboolean
-	glib.WithPointerTransferOriginal(unsafe.Pointer(sink), func(gObject *glib.Object, goObject glib.GoObjectSubclass) {
+	goBaseSink := ToGstBaseSink(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(sink))})
-		iface := goObject.(interface {
+	subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(sink))
-			Event(self *GstBaseSink, event *gst.Event) bool
+
-		})
+	iface := subclass.(interface {
-		ret = gboolean(iface.Event(ToGstBaseSink(gObject), gst.ToGstEvent(unsafe.Pointer(event))))
+		Event(self *GstBaseSink, event *gst.Event) bool
 	})
+	ret = gboolean(iface.Event(goBaseSink, gst.ToGstEvent(unsafe.Pointer(event))))
+
 	return ret
 }
 
 //export goGstBaseSinkFixate
 func goGstBaseSinkFixate(sink *C.GstBaseSink, caps *C.GstCaps) *C.GstCaps {
 	var fixated *gst.Caps
-	glib.WithPointerTransferOriginal(unsafe.Pointer(sink), func(gObject *glib.Object, goObject glib.GoObjectSubclass) {
+	goBaseSink := ToGstBaseSink(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(sink))})
-		iface := goObject.(interface {
+	subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(sink))
-			Fixate(self *GstBaseSink, caps *gst.Caps) *gst.Caps
+
-		})
+	iface := subclass.(interface {
-		fixated = iface.Fixate(ToGstBaseSink(gObject), gst.ToGstCaps(unsafe.Pointer(caps)))
+		Fixate(self *GstBaseSink, caps *gst.Caps) *gst.Caps
 	})
+	fixated = iface.Fixate(goBaseSink, gst.ToGstCaps(unsafe.Pointer(caps)))
+
 	if fixated == nil {
 		return nil
 	}
@@ -55,12 +61,14 @@ func goGstBaseSinkFixate(sink *C.GstBaseSink, caps *C.GstCaps) *C.GstCaps {
 //export goGstBaseSinkGetCaps
 func goGstBaseSinkGetCaps(sink *C.GstBaseSink, filter *C.GstCaps) *C.GstCaps {
 	var filtered *gst.Caps
-	glib.WithPointerTransferOriginal(unsafe.Pointer(sink), func(gObject *glib.Object, goObject glib.GoObjectSubclass) {
+	goBaseSink := ToGstBaseSink(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(sink))})
-		iface := goObject.(interface {
+	subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(sink))
-			GetCaps(self *GstBaseSink, filter *gst.Caps) *gst.Caps
+
-		})
+	iface := subclass.(interface {
-		filtered = iface.GetCaps(ToGstBaseSink(gObject), gst.ToGstCaps(unsafe.Pointer(filter)))
+		GetCaps(self *GstBaseSink, filter *gst.Caps) *gst.Caps
 	})
+	filtered = iface.GetCaps(goBaseSink, gst.ToGstCaps(unsafe.Pointer(filter)))
+
 	if filtered == nil {
 		return nil
 	}
@@ -70,12 +78,14 @@ func goGstBaseSinkGetCaps(sink *C.GstBaseSink, filter *C.GstCaps) *C.GstCaps {
 //export goGstBaseSinkGetTimes
 func goGstBaseSinkGetTimes(sink *C.GstBaseSink, buf *C.GstBuffer, start, end *C.GstClockTime) {
 	var retStart, retEnd time.Duration
-	glib.WithPointerTransferOriginal(unsafe.Pointer(sink), func(gObject *glib.Object, goObject glib.GoObjectSubclass) {
+	goBaseSink := ToGstBaseSink(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(sink))})
-		iface := goObject.(interface {
+	subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(sink))
-			GetTimes(self *GstBaseSink, buffer *gst.Buffer) (start, end time.Duration) // should this be a ClockTime?
+
-		})
+	iface := subclass.(interface {
-		retStart, retEnd = iface.GetTimes(ToGstBaseSink(gObject), gst.ToGstBuffer(unsafe.Pointer(buf)))
+		GetTimes(self *GstBaseSink, buffer *gst.Buffer) (start, end time.Duration) // should this be a ClockTime?
 	})
+	retStart, retEnd = iface.GetTimes(goBaseSink, gst.ToGstBuffer(unsafe.Pointer(buf)))
+
 	*start = C.GstClockTime(retStart.Nanoseconds())
 	*end = C.GstClockTime(retEnd.Nanoseconds())
 }
@@ -83,155 +93,181 @@ func goGstBaseSinkGetTimes(sink *C.GstBaseSink, buf *C.GstBuffer, start, end *C.
 //export goGstBaseSinkPrepare
 func goGstBaseSinkPrepare(sink *C.GstBaseSink, buf *C.GstBuffer) C.GstFlowReturn {
 	var ret gst.FlowReturn
-	glib.WithPointerTransferOriginal(unsafe.Pointer(sink), func(gObject *glib.Object, goObject glib.GoObjectSubclass) {
+	goBaseSink := ToGstBaseSink(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(sink))})
-		iface := goObject.(interface {
+	subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(sink))
-			Prepare(self *GstBaseSink, buffer *gst.Buffer) gst.FlowReturn
+
-		})
+	iface := subclass.(interface {
-		ret = iface.Prepare(ToGstBaseSink(gObject), gst.ToGstBuffer(unsafe.Pointer(buf)))
+		Prepare(self *GstBaseSink, buffer *gst.Buffer) gst.FlowReturn
 	})
+	ret = iface.Prepare(goBaseSink, gst.ToGstBuffer(unsafe.Pointer(buf)))
+
 	return C.GstFlowReturn(ret)
 }
 
 //export goGstBaseSinkPrepareList
 func goGstBaseSinkPrepareList(sink *C.GstBaseSink, list *C.GstBufferList) C.GstFlowReturn {
 	var ret gst.FlowReturn
-	glib.WithPointerTransferOriginal(unsafe.Pointer(sink), func(gObject *glib.Object, goObject glib.GoObjectSubclass) {
+	goBaseSink := ToGstBaseSink(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(sink))})
-		iface := goObject.(interface {
+	subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(sink))
-			PrepareList(self *GstBaseSink, bufferList *gst.BufferList) gst.FlowReturn
+
-		})
+	iface := subclass.(interface {
-		ret = iface.PrepareList(ToGstBaseSink(gObject), gst.ToGstBufferList(unsafe.Pointer(list)))
+		PrepareList(self *GstBaseSink, bufferList *gst.BufferList) gst.FlowReturn
 	})
+	ret = iface.PrepareList(goBaseSink, gst.ToGstBufferList(unsafe.Pointer(list)))
+
 	return C.GstFlowReturn(ret)
 }
 
 //export goGstBaseSinkPreroll
 func goGstBaseSinkPreroll(sink *C.GstBaseSink, buf *C.GstBuffer) C.GstFlowReturn {
 	var ret gst.FlowReturn
-	glib.WithPointerTransferOriginal(unsafe.Pointer(sink), func(gObject *glib.Object, goObject glib.GoObjectSubclass) {
+	goBaseSink := ToGstBaseSink(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(sink))})
-		iface := goObject.(interface {
+	subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(sink))
-			Preroll(self *GstBaseSink, buffer *gst.Buffer) gst.FlowReturn
+
-		})
+	iface := subclass.(interface {
-		ret = iface.Preroll(ToGstBaseSink(gObject), gst.ToGstBuffer(unsafe.Pointer(buf)))
+		Preroll(self *GstBaseSink, buffer *gst.Buffer) gst.FlowReturn
 	})
+	ret = iface.Preroll(goBaseSink, gst.ToGstBuffer(unsafe.Pointer(buf)))
+
 	return C.GstFlowReturn(ret)
 }
 
 //export goGstBaseSinkProposeAllocation
 func goGstBaseSinkProposeAllocation(sink *C.GstBaseSink, query *C.GstQuery) C.gboolean {
 	var ret bool
-	glib.WithPointerTransferOriginal(unsafe.Pointer(sink), func(gObject *glib.Object, goObject glib.GoObjectSubclass) {
+	goBaseSink := ToGstBaseSink(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(sink))})
-		iface := goObject.(interface {
+	subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(sink))
-			ProposeAllocation(self *GstBaseSink, query *gst.Query) bool
+
-		})
+	iface := subclass.(interface {
-		ret = iface.ProposeAllocation(ToGstBaseSink(gObject), gst.ToGstQuery(unsafe.Pointer(query)))
+		ProposeAllocation(self *GstBaseSink, query *gst.Query) bool
 	})
+	ret = iface.ProposeAllocation(goBaseSink, gst.ToGstQuery(unsafe.Pointer(query)))
+
 	return gboolean(ret)
 }
 
 //export goGstBaseSinkQuery
 func goGstBaseSinkQuery(sink *C.GstBaseSink, query *C.GstQuery) C.gboolean {
 	var ret bool
-	glib.WithPointerTransferOriginal(unsafe.Pointer(sink), func(gObject *glib.Object, goObject glib.GoObjectSubclass) {
+	goBaseSink := ToGstBaseSink(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(sink))})
-		iface := goObject.(interface {
+	subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(sink))
-			Query(self *GstBaseSink, query *gst.Query) bool
+
-		})
+	iface := subclass.(interface {
-		ret = iface.Query(ToGstBaseSink(gObject), gst.ToGstQuery(unsafe.Pointer(query)))
+		Query(self *GstBaseSink, query *gst.Query) bool
 	})
+	ret = iface.Query(goBaseSink, gst.ToGstQuery(unsafe.Pointer(query)))
+
 	return gboolean(ret)
 }
 
 //export goGstBaseSinkRender
 func goGstBaseSinkRender(sink *C.GstBaseSink, buf *C.GstBuffer) C.GstFlowReturn {
 	var ret gst.FlowReturn
-	glib.WithPointerTransferOriginal(unsafe.Pointer(sink), func(gObject *glib.Object, goObject glib.GoObjectSubclass) {
+	goBaseSink := ToGstBaseSink(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(sink))})
-		iface := goObject.(interface {
+	subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(sink))
-			Render(self *GstBaseSink, buffer *gst.Buffer) gst.FlowReturn
+
-		})
+	iface := subclass.(interface {
-		ret = iface.Render(ToGstBaseSink(gObject), gst.ToGstBuffer(unsafe.Pointer(buf)))
+		Render(self *GstBaseSink, buffer *gst.Buffer) gst.FlowReturn
 	})
+	ret = iface.Render(goBaseSink, gst.ToGstBuffer(unsafe.Pointer(buf)))
+
 	return C.GstFlowReturn(ret)
 }
 
 //export goGstBaseSinkRenderList
 func goGstBaseSinkRenderList(sink *C.GstBaseSink, buf *C.GstBufferList) C.GstFlowReturn {
 	var ret gst.FlowReturn
-	glib.WithPointerTransferOriginal(unsafe.Pointer(sink), func(gObject *glib.Object, goObject glib.GoObjectSubclass) {
+	goBaseSink := ToGstBaseSink(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(sink))})
-		iface := goObject.(interface {
+	subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(sink))
-			RenderList(self *GstBaseSink, bufferList *gst.BufferList) gst.FlowReturn
+
-		})
+	iface := subclass.(interface {
-		ret = iface.RenderList(ToGstBaseSink(gObject), gst.ToGstBufferList(unsafe.Pointer(buf)))
+		RenderList(self *GstBaseSink, bufferList *gst.BufferList) gst.FlowReturn
 	})
+	ret = iface.RenderList(goBaseSink, gst.ToGstBufferList(unsafe.Pointer(buf)))
+
 	return C.GstFlowReturn(ret)
 }
 
 //export goGstBaseSinkSetCaps
 func goGstBaseSinkSetCaps(sink *C.GstBaseSink, caps *C.GstCaps) C.gboolean {
 	var ret bool
-	glib.WithPointerTransferOriginal(unsafe.Pointer(sink), func(gObject *glib.Object, goObject glib.GoObjectSubclass) {
+	goBaseSink := ToGstBaseSink(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(sink))})
-		iface := goObject.(interface {
+	subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(sink))
-			SetCaps(self *GstBaseSink, caps *gst.Caps) bool
+
-		})
+	iface := subclass.(interface {
-		ret = iface.SetCaps(ToGstBaseSink(gObject), gst.ToGstCaps(unsafe.Pointer(caps)))
+		SetCaps(self *GstBaseSink, caps *gst.Caps) bool
 	})
+	ret = iface.SetCaps(goBaseSink, gst.ToGstCaps(unsafe.Pointer(caps)))
+
 	return gboolean(ret)
 }
 
 //export goGstBaseSinkStart
 func goGstBaseSinkStart(sink *C.GstBaseSink) C.gboolean {
 	var ret bool
-	glib.WithPointerTransferOriginal(unsafe.Pointer(sink), func(gObject *glib.Object, goObject glib.GoObjectSubclass) {
+	goBaseSink := ToGstBaseSink(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(sink))})
-		iface := goObject.(interface {
+	subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(sink))
-			Start(self *GstBaseSink) bool
+
-		})
+	iface := subclass.(interface {
-		ret = iface.Start(ToGstBaseSink(gObject))
+		Start(self *GstBaseSink) bool
 	})
+	ret = iface.Start(goBaseSink)
+
 	return gboolean(ret)
 }
 
 //export goGstBaseSinkStop
 func goGstBaseSinkStop(sink *C.GstBaseSink) C.gboolean {
 	var ret bool
-	glib.WithPointerTransferOriginal(unsafe.Pointer(sink), func(gObject *glib.Object, goObject glib.GoObjectSubclass) {
+	goBaseSink := ToGstBaseSink(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(sink))})
-		iface := goObject.(interface {
+	subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(sink))
-			Stop(self *GstBaseSink) bool
+
-		})
+	iface := subclass.(interface {
-		ret = iface.Stop(ToGstBaseSink(gObject))
+		Stop(self *GstBaseSink) bool
 	})
+	ret = iface.Stop(goBaseSink)
+
 	return gboolean(ret)
 }
 
 //export goGstBaseSinkUnlock
 func goGstBaseSinkUnlock(sink *C.GstBaseSink) C.gboolean {
 	var ret bool
-	glib.WithPointerTransferOriginal(unsafe.Pointer(sink), func(gObject *glib.Object, goObject glib.GoObjectSubclass) {
+	goBaseSink := ToGstBaseSink(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(sink))})
-		iface := goObject.(interface {
+	subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(sink))
-			Unlock(self *GstBaseSink) bool
+
-		})
+	iface := subclass.(interface {
-		ret = iface.Unlock(ToGstBaseSink(gObject))
+		Unlock(self *GstBaseSink) bool
 	})
+	ret = iface.Unlock(goBaseSink)
+
 	return gboolean(ret)
 }
 
 //export goGstBaseSinkUnlockStop
 func goGstBaseSinkUnlockStop(sink *C.GstBaseSink) C.gboolean {
 	var ret bool
-	glib.WithPointerTransferOriginal(unsafe.Pointer(sink), func(gObject *glib.Object, goObject glib.GoObjectSubclass) {
+	goBaseSink := ToGstBaseSink(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(sink))})
-		iface := goObject.(interface {
+	subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(sink))
-			UnlockStop(self *GstBaseSink) bool
+
-		})
+	iface := subclass.(interface {
-		ret = iface.UnlockStop(ToGstBaseSink(gObject))
+		UnlockStop(self *GstBaseSink) bool
 	})
+	ret = iface.UnlockStop(goBaseSink)
+
 	return gboolean(ret)
 }
 
 //export goGstBaseSinkWaitEvent
 func goGstBaseSinkWaitEvent(sink *C.GstBaseSink, event *C.GstEvent) C.GstFlowReturn {
 	var ret gst.FlowReturn
-	glib.WithPointerTransferOriginal(unsafe.Pointer(sink), func(gObject *glib.Object, goObject glib.GoObjectSubclass) {
+	goBaseSink := ToGstBaseSink(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(sink))})
-		iface := goObject.(interface {
+	subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(sink))
-			WaitEvent(self *GstBaseSink, event *gst.Event) gst.FlowReturn
+
-		})
+	iface := subclass.(interface {
-		ret = iface.WaitEvent(ToGstBaseSink(gObject), gst.ToGstEvent(unsafe.Pointer(event)))
+		WaitEvent(self *GstBaseSink, event *gst.Event) gst.FlowReturn
 	})
+	ret = iface.WaitEvent(goBaseSink, gst.ToGstEvent(unsafe.Pointer(event)))
+
 	return C.GstFlowReturn(ret)
 }

gst/base/gst_base_src_exports.go

@@ -14,12 +14,15 @@ import (
 //export goGstBaseSrcGetCaps
 func goGstBaseSrcGetCaps(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 {
+	goBaseSrc := ToGstBaseSrc(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(src))})
-			GetCaps(*GstBaseSrc, *gst.Caps) *gst.Caps
+	subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(src))
-		})
+
-		caps = iface.GetCaps(ToGstBaseSrc(gObject), gst.ToGstCaps(unsafe.Pointer(filter)))
+	iface := subclass.(interface {
+		GetCaps(*GstBaseSrc, *gst.Caps) *gst.Caps
 	})
+	caps = iface.GetCaps(goBaseSrc, gst.ToGstCaps(unsafe.Pointer(filter)))
+
 	if caps == nil {
 		return nil
 	}
@@ -29,24 +32,28 @@ func goGstBaseSrcGetCaps(src *C.GstBaseSrc, filter *C.GstCaps) *C.GstCaps {
 //export goGstBaseSrcNegotiate
 func goGstBaseSrcNegotiate(src *C.GstBaseSrc) C.gboolean {
 	var ret bool
-	glib.WithPointerTransferOriginal(unsafe.Pointer(src), func(gObject *glib.Object, goObject glib.GoObjectSubclass) {
+	goBaseSrc := ToGstBaseSrc(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(src))})
-		iface := goObject.(interface {
+	subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(src))
-			Negotiate(*GstBaseSrc) bool
+
-		})
+	iface := subclass.(interface {
-		ret = iface.Negotiate(ToGstBaseSrc(gObject))
+		Negotiate(*GstBaseSrc) bool
 	})
+	ret = iface.Negotiate(goBaseSrc)
+
 	return gboolean(ret)
 }
 
 //export goGstBaseSrcFixate
 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) {
+	goBaseSrc := ToGstBaseSrc(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(src))})
-		iface := goObject.(interface {
+	subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(src))
-			Fixate(*GstBaseSrc, *gst.Caps) *gst.Caps
+
-		})
+	iface := subclass.(interface {
-		caps = iface.Fixate(ToGstBaseSrc(gObject), gst.ToGstCaps(unsafe.Pointer(filter)))
+		Fixate(*GstBaseSrc, *gst.Caps) *gst.Caps
 	})
+	caps = iface.Fixate(goBaseSrc, gst.ToGstCaps(unsafe.Pointer(filter)))
+
 	if caps == nil {
 		return nil
 	}
@@ -56,60 +63,70 @@ func goGstBaseSrcFixate(src *C.GstBaseSrc, filter *C.GstCaps) *C.GstCaps {
 //export goGstBaseSrcSetCaps
 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) {
+	goBaseSrc := ToGstBaseSrc(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(src))})
-		iface := goObject.(interface {
+	subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(src))
-			SetCaps(*GstBaseSrc, *gst.Caps) bool
+
-		})
+	iface := subclass.(interface {
-		ret = iface.SetCaps(ToGstBaseSrc(gObject), gst.ToGstCaps(unsafe.Pointer(caps)))
+		SetCaps(*GstBaseSrc, *gst.Caps) bool
 	})
+	ret = iface.SetCaps(goBaseSrc, gst.ToGstCaps(unsafe.Pointer(caps)))
+
 	return gboolean(ret)
 }
 
 //export goGstBaseSrcDecideAllocation
 func goGstBaseSrcDecideAllocation(src *C.GstBaseSrc, query *C.GstQuery) C.gboolean {
 	var ret bool
-	glib.WithPointerTransferOriginal(unsafe.Pointer(src), func(gObject *glib.Object, goObject glib.GoObjectSubclass) {
+	goBaseSrc := ToGstBaseSrc(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(src))})
-		iface := goObject.(interface {
+	subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(src))
-			DecideAllocation(*GstBaseSrc, *gst.Query) bool
+
-		})
+	iface := subclass.(interface {
-		ret = iface.DecideAllocation(ToGstBaseSrc(gObject), gst.ToGstQuery(unsafe.Pointer(query)))
+		DecideAllocation(*GstBaseSrc, *gst.Query) bool
 	})
+	ret = iface.DecideAllocation(goBaseSrc, gst.ToGstQuery(unsafe.Pointer(query)))
+
 	return gboolean(ret)
 }
 
 //export goGstBaseSrcStart
 func goGstBaseSrcStart(src *C.GstBaseSrc) C.gboolean {
 	var ret bool
-	glib.WithPointerTransferOriginal(unsafe.Pointer(src), func(gObject *glib.Object, goObject glib.GoObjectSubclass) {
+	goBaseSrc := ToGstBaseSrc(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(src))})
-		iface := goObject.(interface {
+	subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(src))
-			Start(*GstBaseSrc) bool
+
-		})
+	iface := subclass.(interface {
-		ret = iface.Start(ToGstBaseSrc(gObject))
+		Start(*GstBaseSrc) bool
 	})
+	ret = iface.Start(goBaseSrc)
+
 	return gboolean(ret)
 }
 
 //export goGstBaseSrcStop
 func goGstBaseSrcStop(src *C.GstBaseSrc) C.gboolean {
 	var ret bool
-	glib.WithPointerTransferOriginal(unsafe.Pointer(src), func(gObject *glib.Object, goObject glib.GoObjectSubclass) {
+	goBaseSrc := ToGstBaseSrc(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(src))})
-		iface := goObject.(interface {
+	subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(src))
-			Stop(*GstBaseSrc) bool
+
-		})
+	iface := subclass.(interface {
-		ret = iface.Stop(ToGstBaseSrc(gObject))
+		Stop(*GstBaseSrc) bool
 	})
+	ret = iface.Stop(goBaseSrc)
+
 	return gboolean(ret)
 }
 
 //export goGstBaseSrcGetTimes
 func goGstBaseSrcGetTimes(src *C.GstBaseSrc, buf *C.GstBuffer, start *C.GstClockTime, end *C.GstClockTime) {
 	var gostart, goend time.Duration
-	glib.WithPointerTransferOriginal(unsafe.Pointer(src), func(gObject *glib.Object, goObject glib.GoObjectSubclass) {
+	goBaseSrc := ToGstBaseSrc(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(src))})
-		iface := goObject.(interface {
+	subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(src))
-			GetTimes(*GstBaseSrc, *gst.Buffer) (start, end time.Duration) // should this be a ClockTime?
+
-		})
+	iface := subclass.(interface {
-		gostart, goend = iface.GetTimes(ToGstBaseSrc(gObject), gst.ToGstBuffer(unsafe.Pointer(buf)))
+		GetTimes(*GstBaseSrc, *gst.Buffer) (start, end time.Duration) // should this be a ClockTime?
 	})
+	gostart, goend = iface.GetTimes(goBaseSrc, gst.ToGstBuffer(unsafe.Pointer(buf)))
+
 	*start = C.GstClockTime(gostart.Nanoseconds())
 	*end = C.GstClockTime(goend.Nanoseconds())
 }
@@ -118,12 +135,14 @@ func goGstBaseSrcGetTimes(src *C.GstBaseSrc, buf *C.GstBuffer, start *C.GstClock
 func goGstBaseSrcGetSize(src *C.GstBaseSrc, size *C.guint64) C.gboolean {
 	var gosize int64
 	var ok bool
-	glib.WithPointerTransferOriginal(unsafe.Pointer(src), func(gObject *glib.Object, goObject glib.GoObjectSubclass) {
+	goBaseSrc := ToGstBaseSrc(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(src))})
-		iface := goObject.(interface {
+	subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(src))
-			GetSize(*GstBaseSrc) (bool, int64)
+
-		})
+	iface := subclass.(interface {
-		ok, gosize = iface.GetSize(ToGstBaseSrc(gObject))
+		GetSize(*GstBaseSrc) (bool, int64)
 	})
+	ok, gosize = iface.GetSize(goBaseSrc)
+
 	if ok {
 		*size = C.guint64(gosize)
 	}
@@ -133,84 +152,98 @@ func goGstBaseSrcGetSize(src *C.GstBaseSrc, size *C.guint64) C.gboolean {
 //export goGstBaseSrcIsSeekable
 func goGstBaseSrcIsSeekable(src *C.GstBaseSrc) C.gboolean {
 	var ok bool
-	glib.WithPointerTransferOriginal(unsafe.Pointer(src), func(gObject *glib.Object, goObject glib.GoObjectSubclass) {
+	goBaseSrc := ToGstBaseSrc(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(src))})
-		iface := goObject.(interface {
+	subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(src))
-			IsSeekable(*GstBaseSrc) bool
+
-		})
+	iface := subclass.(interface {
-		ok = iface.IsSeekable(ToGstBaseSrc(gObject))
+		IsSeekable(*GstBaseSrc) bool
 	})
+	ok = iface.IsSeekable(goBaseSrc)
+
 	return gboolean(ok)
 }
 
 //export goGstBaseSrcPrepareSeekSegment
 func goGstBaseSrcPrepareSeekSegment(src *C.GstBaseSrc, seek *C.GstEvent, segment *C.GstSegment) C.gboolean {
 	var ok bool
-	glib.WithPointerTransferOriginal(unsafe.Pointer(src), func(gObject *glib.Object, goObject glib.GoObjectSubclass) {
+	goBaseSrc := ToGstBaseSrc(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(src))})
-		iface := goObject.(interface {
+	subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(src))
-			PrepareSeekSegment(*GstBaseSrc, *gst.Event, *gst.Segment) bool
+
-		})
+	iface := subclass.(interface {
-		ok = iface.PrepareSeekSegment(ToGstBaseSrc(gObject), gst.ToGstEvent(unsafe.Pointer(seek)), gst.FromGstSegmentUnsafe(unsafe.Pointer(segment)))
+		PrepareSeekSegment(*GstBaseSrc, *gst.Event, *gst.Segment) bool
 	})
+	ok = iface.PrepareSeekSegment(goBaseSrc, gst.ToGstEvent(unsafe.Pointer(seek)), gst.FromGstSegmentUnsafe(unsafe.Pointer(segment)))
+
 	return gboolean(ok)
 }
 
 //export goGstBaseSrcDoSeek
 func goGstBaseSrcDoSeek(src *C.GstBaseSrc, segment *C.GstSegment) C.gboolean {
 	var ok bool
-	glib.WithPointerTransferOriginal(unsafe.Pointer(src), func(gObject *glib.Object, goObject glib.GoObjectSubclass) {
+	goBaseSrc := ToGstBaseSrc(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(src))})
-		iface := goObject.(interface {
+	subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(src))
-			DoSeek(*GstBaseSrc, *gst.Segment) bool
+
-		})
+	iface := subclass.(interface {
-		ok = iface.DoSeek(ToGstBaseSrc(gObject), gst.ToGstSegment(unsafe.Pointer(segment)))
+		DoSeek(*GstBaseSrc, *gst.Segment) bool
 	})
+	ok = iface.DoSeek(goBaseSrc, gst.ToGstSegment(unsafe.Pointer(segment)))
+
 	return gboolean(ok)
 }
 
 //export goGstBaseSrcUnlock
 func goGstBaseSrcUnlock(src *C.GstBaseSrc) C.gboolean {
 	var ok bool
-	glib.WithPointerTransferOriginal(unsafe.Pointer(src), func(gObject *glib.Object, goObject glib.GoObjectSubclass) {
+	goBaseSrc := ToGstBaseSrc(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(src))})
-		iface := goObject.(interface {
+	subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(src))
-			Unlock(*GstBaseSrc) bool
+
-		})
+	iface := subclass.(interface {
-		ok = iface.Unlock(ToGstBaseSrc(gObject))
+		Unlock(*GstBaseSrc) bool
 	})
+	ok = iface.Unlock(goBaseSrc)
+
 	return gboolean(ok)
 }
 
 //export goGstBaseSrcUnlockStop
 func goGstBaseSrcUnlockStop(src *C.GstBaseSrc) C.gboolean {
 	var ok bool
-	glib.WithPointerTransferOriginal(unsafe.Pointer(src), func(gObject *glib.Object, goObject glib.GoObjectSubclass) {
+	goBaseSrc := ToGstBaseSrc(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(src))})
-		iface := goObject.(interface {
+	subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(src))
-			UnlockStop(*GstBaseSrc) bool
+
-		})
+	iface := subclass.(interface {
-		ok = iface.UnlockStop(ToGstBaseSrc(gObject))
+		UnlockStop(*GstBaseSrc) bool
 	})
+	ok = iface.UnlockStop(goBaseSrc)
+
 	return gboolean(ok)
 }
 
 //export goGstBaseSrcQuery
 func goGstBaseSrcQuery(src *C.GstBaseSrc, query *C.GstQuery) C.gboolean {
 	var ok bool
-	glib.WithPointerTransferOriginal(unsafe.Pointer(src), func(gObject *glib.Object, goObject glib.GoObjectSubclass) {
+	goBaseSrc := ToGstBaseSrc(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(src))})
-		iface := goObject.(interface {
+	subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(src))
-			Query(*GstBaseSrc, *gst.Query) bool
+
-		})
+	iface := subclass.(interface {
-		ok = iface.Query(ToGstBaseSrc(gObject), gst.ToGstQuery(unsafe.Pointer(query)))
+		Query(*GstBaseSrc, *gst.Query) bool
 	})
+	ok = iface.Query(goBaseSrc, gst.ToGstQuery(unsafe.Pointer(query)))
+
 	return gboolean(ok)
 }
 
 //export goGstBaseSrcEvent
 func goGstBaseSrcEvent(src *C.GstBaseSrc, event *C.GstEvent) C.gboolean {
 	var ok bool
-	glib.WithPointerTransferOriginal(unsafe.Pointer(src), func(gObject *glib.Object, goObject glib.GoObjectSubclass) {
+	goBaseSrc := ToGstBaseSrc(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(src))})
-		iface := goObject.(interface {
+	subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(src))
-			Event(*GstBaseSrc, *gst.Event) bool
+
-		})
+	iface := subclass.(interface {
-		ok = iface.Event(ToGstBaseSrc(gObject), gst.ToGstEvent(unsafe.Pointer(event)))
+		Event(*GstBaseSrc, *gst.Event) bool
 	})
+	ok = iface.Event(goBaseSrc, gst.ToGstEvent(unsafe.Pointer(event)))
+
 	return gboolean(ok)
 }
 
@@ -218,12 +251,14 @@ func goGstBaseSrcEvent(src *C.GstBaseSrc, event *C.GstEvent) C.gboolean {
 func goGstBaseSrcCreate(src *C.GstBaseSrc, offset C.guint64, size C.guint, buf **C.GstBuffer) C.GstFlowReturn {
 	var ret gst.FlowReturn
 	var gobuf *gst.Buffer
-	glib.WithPointerTransferOriginal(unsafe.Pointer(src), func(gObject *glib.Object, goObject glib.GoObjectSubclass) {
+	goBaseSrc := ToGstBaseSrc(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(src))})
-		iface := goObject.(interface {
+	subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(src))
-			Create(*GstBaseSrc, uint64, uint) (gst.FlowReturn, *gst.Buffer)
+
-		})
+	iface := subclass.(interface {
-		ret, gobuf = iface.Create(ToGstBaseSrc(gObject), uint64(offset), uint(size))
+		Create(*GstBaseSrc, uint64, uint) (gst.FlowReturn, *gst.Buffer)
 	})
+	ret, gobuf = iface.Create(goBaseSrc, uint64(offset), uint(size))
+
 	if ret == gst.FlowOK {
 		C.memcpy(unsafe.Pointer(*buf), unsafe.Pointer(gobuf.Instance()), C.sizeof_GstBuffer)
 	}
@@ -234,12 +269,14 @@ func goGstBaseSrcCreate(src *C.GstBaseSrc, offset C.guint64, size C.guint, buf *
 func goGstBaseSrcAlloc(src *C.GstBaseSrc, offset C.guint64, size C.guint, buf **C.GstBuffer) C.GstFlowReturn {
 	var ret gst.FlowReturn
 	var gobuf *gst.Buffer
-	glib.WithPointerTransferOriginal(unsafe.Pointer(src), func(gObject *glib.Object, goObject glib.GoObjectSubclass) {
+	goBaseSrc := ToGstBaseSrc(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(src))})
-		iface := goObject.(interface {
+	subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(src))
-			Alloc(*GstBaseSrc, uint64, uint) (gst.FlowReturn, *gst.Buffer)
+
-		})
+	iface := subclass.(interface {
-		ret, gobuf = iface.Alloc(ToGstBaseSrc(gObject), uint64(offset), uint(size))
+		Alloc(*GstBaseSrc, uint64, uint) (gst.FlowReturn, *gst.Buffer)
 	})
+	ret, gobuf = iface.Alloc(goBaseSrc, uint64(offset), uint(size))
+
 	if ret == gst.FlowOK {
 		C.memcpy(unsafe.Pointer(*buf), unsafe.Pointer(gobuf.Instance()), C.sizeof_GstBuffer)
 	}
@@ -249,11 +286,13 @@ 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 {
 	var ret gst.FlowReturn
-	glib.WithPointerTransferOriginal(unsafe.Pointer(src), func(gObject *glib.Object, goObject glib.GoObjectSubclass) {
+	goBaseSrc := ToGstBaseSrc(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(src))})
-		iface := goObject.(interface {
+	subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(src))
-			Fill(*GstBaseSrc, uint64, uint, *gst.Buffer) gst.FlowReturn
+
-		})
+	iface := subclass.(interface {
-		ret = iface.Fill(ToGstBaseSrc(gObject), uint64(offset), uint(size), gst.ToGstBuffer(unsafe.Pointer(buf)))
+		Fill(*GstBaseSrc, uint64, uint, *gst.Buffer) gst.FlowReturn
 	})
+	ret = iface.Fill(goBaseSrc, uint64(offset), uint(size), gst.ToGstBuffer(unsafe.Pointer(buf)))
+
 	return C.GstFlowReturn(ret)
 }

gst/base/gst_base_transform.go

@@ -18,6 +18,22 @@ setGstBaseTransformTransformIPOnPassthrough (GstBaseTransform * obj, gboolean en
 	GstBaseTransformClass * klass = toGstBaseTransformClass(g_type_class_peek_parent(this_class));
 	klass->transform_ip_on_passthrough = enabled;
 }
+
+gboolean
+gstBaseTransformParentSrcEvent (GstBaseTransform * obj, GstEvent * event)
+{
+	GObjectClass * this_class = G_OBJECT_GET_CLASS(G_OBJECT(obj));
+	GstBaseTransformClass * parent = toGstBaseTransformClass(g_type_class_peek_parent(this_class));
+	return parent->src_event(obj, event);
+}
+
+gboolean
+gstBaseTransformParentSinkEvent (GstBaseTransform * obj, GstEvent * event)
+{
+	GObjectClass * this_class = G_OBJECT_GET_CLASS(G_OBJECT(obj));
+	GstBaseTransformClass * parent = toGstBaseTransformClass(g_type_class_peek_parent(this_class));
+	return parent->sink_event(obj, event);
+}
 */
 import "C"
 
@@ -196,3 +212,93 @@ func (g *GstBaseTransform) UpdateSrcCaps(caps *gst.Caps) {
 		(*C.GstCaps)(unsafe.Pointer(caps.Instance())),
 	)
 }
+
+func (g *GstBaseTransform) ParentAcceptCaps(direction gst.PadDirection, caps *gst.Caps) bool {
+	panic("not implemented")
+}
+
+func (g *GstBaseTransform) ParentBeforeTransform(buffer *gst.Buffer) {
+	panic("not implemented")
+}
+
+func (g *GstBaseTransform) ParentCopyMetadata(input, output *gst.Buffer) bool {
+	panic("not implemented")
+}
+
+func (g *GstBaseTransform) ParentDecideAllocation(query *gst.Query) bool {
+	panic("not implemented")
+}
+
+func (g *GstBaseTransform) ParentFilterMeta(query *gst.Query, api glib.Type, params *gst.Structure) bool {
+	panic("not implemented")
+}
+
+func (g *GstBaseTransform) ParentFixateCaps(directon gst.PadDirection, caps *gst.Caps, othercaps *gst.Caps) *gst.Caps {
+	panic("not implemented")
+}
+
+func (g *GstBaseTransform) ParentGenerateOutput(gst.FlowReturn, *gst.Buffer) {
+	panic("not implemented")
+}
+
+func (g *GstBaseTransform) ParentGetUnitSize(caps *gst.Caps) (ok bool, size int64) {
+	panic("not implemented")
+}
+
+func (g *GstBaseTransform) ParentPrepareOutputBuffer(input *gst.Buffer) (gst.FlowReturn, *gst.Buffer) {
+	panic("not implemented")
+}
+
+func (g *GstBaseTransform) ParentProposeAllocation(decideQuery, query *gst.Query) bool {
+	panic("not implemented")
+}
+
+func (g *GstBaseTransform) ParentQuery(direction gst.PadDirection, query *gst.Query) bool {
+	panic("not implemented")
+}
+
+func (g *GstBaseTransform) ParentSetCaps(incaps, outcaps *gst.Caps) bool {
+	panic("not implemented")
+}
+
+// ParentSrcEvent chains the event up to the parent class
+func (g *GstBaseTransform) ParentSrcEvent(event *gst.Event) bool {
+	return gobool(C.gstBaseTransformParentSrcEvent(g.Instance(), (*C.GstEvent)(unsafe.Pointer(event.Instance()))))
+}
+
+// ParentSinkEvent chains the event up to the parent class
+func (g *GstBaseTransform) ParentSinkEvent(event *gst.Event) bool {
+	return gobool(C.gstBaseTransformParentSinkEvent(g.Instance(), (*C.GstEvent)(unsafe.Pointer(event.Instance()))))
+}
+
+func (g *GstBaseTransform) ParentStart(bool) {
+	panic("not implemented")
+}
+
+func (g *GstBaseTransform) ParentStop(bool) {
+	panic("not implemented")
+}
+
+func (g *GstBaseTransform) ParentSubmitInputBuffer(isDiscont bool, input *gst.Buffer) gst.FlowReturn {
+	panic("not implemented")
+}
+
+func (g *GstBaseTransform) ParentTransform(inbuf, outbuf *gst.Buffer) gst.FlowReturn {
+	panic("not implemented")
+}
+
+func (g *GstBaseTransform) ParentTransformCaps(direction gst.PadDirection, caps, filter *gst.Caps) *gst.Caps {
+	panic("not implemented")
+}
+
+func (g *GstBaseTransform) ParentTransformIP(buf *gst.Buffer) gst.FlowReturn {
+	panic("not implemented")
+}
+
+func (g *GstBaseTransform) ParentTransformMeta(outbuf *gst.Buffer, meta *gst.Meta, inbuf *gst.Buffer) bool {
+	panic("not implemented")
+}
+
+func (g *GstBaseTransform) ParentTransformSize(direction gst.PadDirection, caps *gst.Caps, size int64, othercaps *gst.Caps) (ok bool, othersize int64) {
+	panic("not implemented")
+}

gst/base/gst_base_transform_exports.go

@@ -15,70 +15,80 @@ import (
 //export goGstBaseTransformAcceptCaps
 func goGstBaseTransformAcceptCaps(self *C.GstBaseTransform, direction C.GstPadDirection, caps *C.GstCaps) C.gboolean {
 	var ret bool
-	glib.WithPointerTransferOriginal(unsafe.Pointer(self), func(gObject *glib.Object, goObject glib.GoObjectSubclass) {
+	goBaseT := ToGstBaseTransform(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(self))})
-		iface := goObject.(interface {
+	subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(self))
-			AcceptCaps(*GstBaseTransform, gst.PadDirection, *gst.Caps) bool
+
-		})
+	iface := subclass.(interface {
-		ret = iface.AcceptCaps(ToGstBaseTransform(self), gst.PadDirection(direction), gst.ToGstCaps(unsafe.Pointer(caps)))
+		AcceptCaps(*GstBaseTransform, gst.PadDirection, *gst.Caps) bool
 	})
+	ret = iface.AcceptCaps(goBaseT, gst.PadDirection(direction), gst.ToGstCaps(unsafe.Pointer(caps)))
+
 	return gboolean(ret)
 }
 
 //export goGstBaseTransformBeforeTransform
 func goGstBaseTransformBeforeTransform(self *C.GstBaseTransform, buffer *C.GstBuffer) {
-	glib.WithPointerTransferOriginal(unsafe.Pointer(self), func(gObject *glib.Object, goObject glib.GoObjectSubclass) {
+	goBaseT := ToGstBaseTransform(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(self))})
-		iface := goObject.(interface {
+	subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(self))
-			BeforeTransform(*GstBaseTransform, *gst.Buffer)
+
-		})
+	iface := subclass.(interface {
-		iface.BeforeTransform(ToGstBaseTransform(self), gst.ToGstBuffer(unsafe.Pointer(buffer)))
+		BeforeTransform(*GstBaseTransform, *gst.Buffer)
 	})
+	iface.BeforeTransform(goBaseT, gst.ToGstBuffer(unsafe.Pointer(buffer)))
 }
 
 //export goGstBaseTransformCopyMetadata
 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) {
+	goBaseT := ToGstBaseTransform(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(self))})
-		iface := goObject.(interface {
+	subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(self))
-			CopyMetadata(self *GstBaseTransform, input, output *gst.Buffer) bool
+
-		})
+	iface := subclass.(interface {
-		ret = iface.CopyMetadata(ToGstBaseTransform(self), gst.ToGstBuffer(unsafe.Pointer(input)), gst.ToGstBuffer(unsafe.Pointer(output)))
+		CopyMetadata(self *GstBaseTransform, input, output *gst.Buffer) bool
 	})
+	ret = iface.CopyMetadata(goBaseT, gst.ToGstBuffer(unsafe.Pointer(input)), gst.ToGstBuffer(unsafe.Pointer(output)))
 	return gboolean(ret)
 }
 
 //export goGstBaseTransformDecideAllocation
 func goGstBaseTransformDecideAllocation(self *C.GstBaseTransform, query *C.GstQuery) C.gboolean {
 	var ret bool
-	glib.WithPointerTransferOriginal(unsafe.Pointer(self), func(gObject *glib.Object, goObject glib.GoObjectSubclass) {
+	goBaseT := ToGstBaseTransform(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(self))})
-		iface := goObject.(interface {
+	subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(self))
-			DecideAllocation(self *GstBaseTransform, query *gst.Query) bool
+
-		})
+	iface := subclass.(interface {
-		ret = iface.DecideAllocation(ToGstBaseTransform(self), gst.ToGstQuery(unsafe.Pointer(query)))
+		DecideAllocation(self *GstBaseTransform, query *gst.Query) bool
 	})
+	ret = iface.DecideAllocation(goBaseT, gst.ToGstQuery(unsafe.Pointer(query)))
+
 	return gboolean(ret)
 }
 
 //export goGstBaseTransformFilterMeta
 func goGstBaseTransformFilterMeta(self *C.GstBaseTransform, query *C.GstQuery, api C.GType, params *C.GstStructure) C.gboolean {
 	var ret bool
-	glib.WithPointerTransferOriginal(unsafe.Pointer(self), func(gObject *glib.Object, goObject glib.GoObjectSubclass) {
+	goBaseT := ToGstBaseTransform(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(self))})
-		iface := goObject.(interface {
+	subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(self))
-			FilterMeta(self *GstBaseTransform, query *gst.Query, api glib.Type, params *gst.Structure) bool
+
-		})
+	iface := subclass.(interface {
-		ret = iface.FilterMeta(ToGstBaseTransform(self), gst.ToGstQuery(unsafe.Pointer(query)), glib.Type(api), gst.FromGstStructureUnsafe(unsafe.Pointer(params)))
+		FilterMeta(self *GstBaseTransform, query *gst.Query, api glib.Type, params *gst.Structure) bool
 	})
+	ret = iface.FilterMeta(goBaseT, gst.ToGstQuery(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 {
 	var ret *gst.Caps
-	glib.WithPointerTransferOriginal(unsafe.Pointer(self), func(gObject *glib.Object, goObject glib.GoObjectSubclass) {
+	goBaseT := ToGstBaseTransform(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(self))})
-		iface := goObject.(interface {
+	subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(self))
-			FixateCaps(self *GstBaseTransform, directon gst.PadDirection, caps *gst.Caps, othercaps *gst.Caps) *gst.Caps
+
-		})
+	iface := subclass.(interface {
-		ret = iface.FixateCaps(ToGstBaseTransform(self), gst.PadDirection(direction), gst.ToGstCaps(unsafe.Pointer(caps)), gst.ToGstCaps(unsafe.Pointer(othercaps)))
+		FixateCaps(self *GstBaseTransform, directon gst.PadDirection, caps *gst.Caps, othercaps *gst.Caps) *gst.Caps
 	})
+	ret = iface.FixateCaps(goBaseT, gst.PadDirection(direction), gst.ToGstCaps(unsafe.Pointer(caps)), gst.ToGstCaps(unsafe.Pointer(othercaps)))
+
 	if ret == nil {
 		return nil
 	}
@@ -89,12 +99,14 @@ func goGstBaseTransformFixateCaps(self *C.GstBaseTransform, direction C.GstPadDi
 func goGstBaseTransformGenerateOutput(self *C.GstBaseTransform, buf **C.GstBuffer) C.GstFlowReturn {
 	var ret gst.FlowReturn
 	var out *gst.Buffer
-	glib.WithPointerTransferOriginal(unsafe.Pointer(self), func(gObject *glib.Object, goObject glib.GoObjectSubclass) {
+	goBaseT := ToGstBaseTransform(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(self))})
-		iface := goObject.(interface {
+	subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(self))
-			GenerateOutput(self *GstBaseTransform) (gst.FlowReturn, *gst.Buffer)
+
-		})
+	iface := subclass.(interface {
-		ret, out = iface.GenerateOutput(ToGstBaseTransform(self))
+		GenerateOutput(self *GstBaseTransform) (gst.FlowReturn, *gst.Buffer)
 	})
+	ret, out = iface.GenerateOutput(goBaseT)
+
 	if out != nil {
 		C.memcpy(unsafe.Pointer(*buf), unsafe.Pointer(out.Instance()), C.sizeof_GstBuffer)
 	}
@@ -105,12 +117,14 @@ func goGstBaseTransformGenerateOutput(self *C.GstBaseTransform, buf **C.GstBuffe
 func goGstBaseTransformGetUnitSize(self *C.GstBaseTransform, caps *C.GstCaps, size *C.gsize) C.gboolean {
 	var ret bool
 	var out int64
-	glib.WithPointerTransferOriginal(unsafe.Pointer(self), func(gObject *glib.Object, goObject glib.GoObjectSubclass) {
+	goBaseT := ToGstBaseTransform(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(self))})
-		iface := goObject.(interface {
+	subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(self))
-			GetUnitSize(self *GstBaseTransform, caps *gst.Caps) (ok bool, size int64)
+
-		})
+	iface := subclass.(interface {
-		ret, out = iface.GetUnitSize(ToGstBaseTransform(self), gst.ToGstCaps(unsafe.Pointer(caps)))
+		GetUnitSize(self *GstBaseTransform, caps *gst.Caps) (ok bool, size int64)
 	})
+	ret, out = iface.GetUnitSize(goBaseT, gst.ToGstCaps(unsafe.Pointer(caps)))
+
 	if ret {
 		*size = C.gsize(out)
 	}
@@ -121,12 +135,14 @@ func goGstBaseTransformGetUnitSize(self *C.GstBaseTransform, caps *C.GstCaps, si
 func goGstBaseTransformPrepareOutputBuffer(self *C.GstBaseTransform, input *C.GstBuffer, outbuf **C.GstBuffer) C.GstFlowReturn {
 	var ret gst.FlowReturn
 	var out *gst.Buffer
-	glib.WithPointerTransferOriginal(unsafe.Pointer(self), func(gObject *glib.Object, goObject glib.GoObjectSubclass) {
+	goBaseT := ToGstBaseTransform(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(self))})
-		iface := goObject.(interface {
+	subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(self))
-			PrepareOutputBuffer(self *GstBaseTransform, input *gst.Buffer) (gst.FlowReturn, *gst.Buffer)
+
-		})
+	iface := subclass.(interface {
-		ret, out = iface.PrepareOutputBuffer(ToGstBaseTransform(self), gst.ToGstBuffer(unsafe.Pointer(input)))
+		PrepareOutputBuffer(self *GstBaseTransform, input *gst.Buffer) (gst.FlowReturn, *gst.Buffer)
 	})
+	ret, out = iface.PrepareOutputBuffer(goBaseT, gst.ToGstBuffer(unsafe.Pointer(input)))
+
 	if out != nil {
 		C.memcpy(unsafe.Pointer(*outbuf), unsafe.Pointer(out.Instance()), C.sizeof_GstBuffer)
 	}
@@ -136,120 +152,143 @@ func goGstBaseTransformPrepareOutputBuffer(self *C.GstBaseTransform, input *C.Gs
 //export goGstBaseTransformProposeAllocation
 func goGstBaseTransformProposeAllocation(self *C.GstBaseTransform, decide, query *C.GstQuery) C.gboolean {
 	var ret bool
-	glib.WithPointerTransferOriginal(unsafe.Pointer(self), func(gObject *glib.Object, goObject glib.GoObjectSubclass) {
+	goBaseT := ToGstBaseTransform(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(self))})
-		iface := goObject.(interface {
+	subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(self))
-			ProposeAllocation(self *GstBaseTransform, decideQuery, query *gst.Query) bool
+
-		})
+	iface := subclass.(interface {
-		ret = iface.ProposeAllocation(ToGstBaseTransform(self), gst.ToGstQuery(unsafe.Pointer(decide)), gst.ToGstQuery(unsafe.Pointer(query)))
+		ProposeAllocation(self *GstBaseTransform, decideQuery, query *gst.Query) bool
 	})
+	ret = iface.ProposeAllocation(goBaseT, gst.ToGstQuery(unsafe.Pointer(decide)), gst.ToGstQuery(unsafe.Pointer(query)))
+
 	return gboolean(ret)
 }
 
 //export goGstBaseTransformQuery
 func goGstBaseTransformQuery(self *C.GstBaseTransform, direction C.GstPadDirection, query *C.GstQuery) C.gboolean {
 	var ret bool
-	glib.WithPointerTransferOriginal(unsafe.Pointer(self), func(gObject *glib.Object, goObject glib.GoObjectSubclass) {
+	goBaseT := ToGstBaseTransform(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(self))})
-		iface := goObject.(interface {
+	subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(self))
-			Query(self *GstBaseTransform, direction gst.PadDirection, query *gst.Query) bool
+
-		})
+	iface := subclass.(interface {
-		ret = iface.Query(ToGstBaseTransform(self), gst.PadDirection(direction), gst.ToGstQuery(unsafe.Pointer(query)))
+		Query(self *GstBaseTransform, direction gst.PadDirection, query *gst.Query) bool
 	})
+	ret = iface.Query(goBaseT, gst.PadDirection(direction), gst.ToGstQuery(unsafe.Pointer(query)))
+
 	return gboolean(ret)
 }
 
 //export goGstBaseTransformSetCaps
 func goGstBaseTransformSetCaps(self *C.GstBaseTransform, incaps, outcaps *C.GstCaps) C.gboolean {
 	var ret bool
-	glib.WithPointerTransferOriginal(unsafe.Pointer(self), func(gObject *glib.Object, goObject glib.GoObjectSubclass) {
+	goBaseT := ToGstBaseTransform(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(self))})
-		iface := goObject.(interface {
+	subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(self))
-			SetCaps(self *GstBaseTransform, incaps, outcaps *gst.Caps) bool
+
-		})
+	iface := subclass.(interface {
-		ret = iface.SetCaps(ToGstBaseTransform(self), gst.ToGstCaps(unsafe.Pointer(incaps)), gst.ToGstCaps(unsafe.Pointer(outcaps)))
+		SetCaps(self *GstBaseTransform, incaps, outcaps *gst.Caps) bool
 	})
+	ret = iface.SetCaps(goBaseT, gst.ToGstCaps(unsafe.Pointer(incaps)), gst.ToGstCaps(unsafe.Pointer(outcaps)))
+
 	return gboolean(ret)
 }
 
 //export goGstBaseTransformSinkEvent
 func goGstBaseTransformSinkEvent(self *C.GstBaseTransform, event *C.GstEvent) C.gboolean {
 	var ret bool
-	glib.WithPointerTransferOriginal(unsafe.Pointer(self), func(gObject *glib.Object, goObject glib.GoObjectSubclass) {
+
-		iface := goObject.(interface {
+	goBaseT := ToGstBaseTransform(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(self))})
-			SinkEvent(self *GstBaseTransform, event *gst.Event) bool
+	subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(self))
-		})
+
-		ret = iface.SinkEvent(ToGstBaseTransform(self), gst.ToGstEvent(unsafe.Pointer(event)))
+	iface := subclass.(interface {
+		SinkEvent(self *GstBaseTransform, event *gst.Event) bool
 	})
+
+	ret = iface.SinkEvent(goBaseT, gst.ToGstEvent(unsafe.Pointer(event)))
+
 	return gboolean(ret)
 }
 
 //export goGstBaseTransformSrcEvent
 func goGstBaseTransformSrcEvent(self *C.GstBaseTransform, event *C.GstEvent) C.gboolean {
 	var ret bool
-	glib.WithPointerTransferOriginal(unsafe.Pointer(self), func(gObject *glib.Object, goObject glib.GoObjectSubclass) {
+
-		iface := goObject.(interface {
+	goBaseT := ToGstBaseTransform(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(self))})
-			SrcEvent(self *GstBaseTransform, event *gst.Event) bool
+	subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(self))
-		})
+
-		ret = iface.SrcEvent(ToGstBaseTransform(self), gst.ToGstEvent(unsafe.Pointer(event)))
+	iface := subclass.(interface {
+		SrcEvent(self *GstBaseTransform, event *gst.Event) bool
 	})
+	ret = iface.SrcEvent(goBaseT, gst.ToGstEvent(unsafe.Pointer(event)))
+
 	return gboolean(ret)
 }
 
 //export goGstBaseTransformStart
 func goGstBaseTransformStart(self *C.GstBaseTransform) C.gboolean {
 	var ret bool
-	glib.WithPointerTransferOriginal(unsafe.Pointer(self), func(gObject *glib.Object, goObject glib.GoObjectSubclass) {
+	goBaseT := ToGstBaseTransform(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(self))})
-		iface := goObject.(interface {
+	subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(self))
-			Start(self *GstBaseTransform) bool
+
-		})
+	iface := subclass.(interface {
-		ret = iface.Start(ToGstBaseTransform(self))
+		Start(self *GstBaseTransform) bool
 	})
+	ret = iface.Start(goBaseT)
+
 	return gboolean(ret)
 }
 
 //export goGstBaseTransformStop
 func goGstBaseTransformStop(self *C.GstBaseTransform) C.gboolean {
 	var ret bool
-	glib.WithPointerTransferOriginal(unsafe.Pointer(self), func(gObject *glib.Object, goObject glib.GoObjectSubclass) {
+	goBaseT := ToGstBaseTransform(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(self))})
-		iface := goObject.(interface {
+	subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(self))
-			Stop(self *GstBaseTransform) bool
+
-		})
+	iface := subclass.(interface {
-		ret = iface.Stop(ToGstBaseTransform(self))
+		Stop(self *GstBaseTransform) bool
 	})
+	ret = iface.Stop(goBaseT)
+
 	return gboolean(ret)
 }
 
 //export goGstBaseTransformSubmitInputBuffer
 func goGstBaseTransformSubmitInputBuffer(self *C.GstBaseTransform, isDiscont C.gboolean, input *C.GstBuffer) C.GstFlowReturn {
 	var ret gst.FlowReturn
-	glib.WithPointerTransferOriginal(unsafe.Pointer(self), func(gObject *glib.Object, goObject glib.GoObjectSubclass) {
+	goBaseT := ToGstBaseTransform(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(self))})
-		iface := goObject.(interface {
+	subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(self))
-			SubmitInputBuffer(self *GstBaseTransform, isDiscont bool, input *gst.Buffer) gst.FlowReturn
+
-		})
+	iface := subclass.(interface {
-		ret = iface.SubmitInputBuffer(ToGstBaseTransform(self), gobool(isDiscont), gst.ToGstBuffer(unsafe.Pointer(input)))
+		SubmitInputBuffer(self *GstBaseTransform, isDiscont bool, input *gst.Buffer) gst.FlowReturn
 	})
+	ret = iface.SubmitInputBuffer(goBaseT, gobool(isDiscont), gst.ToGstBuffer(unsafe.Pointer(input)))
+
 	return C.GstFlowReturn(ret)
 }
 
 //export goGstBaseTransformTransform
 func goGstBaseTransformTransform(self *C.GstBaseTransform, inbuf, outbuf *C.GstBuffer) C.GstFlowReturn {
 	var ret gst.FlowReturn
-	glib.WithPointerTransferOriginal(unsafe.Pointer(self), func(gObject *glib.Object, goObject glib.GoObjectSubclass) {
+	goBaseT := ToGstBaseTransform(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(self))})
-		iface := goObject.(interface {
+	subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(self))
-			Transform(self *GstBaseTransform, inbuf, outbuf *gst.Buffer) gst.FlowReturn
+
-		})
+	iface := subclass.(interface {
-		ret = iface.Transform(ToGstBaseTransform(self), gst.ToGstBuffer(unsafe.Pointer(inbuf)), gst.ToGstBuffer(unsafe.Pointer(outbuf)))
+		Transform(self *GstBaseTransform, inbuf, outbuf *gst.Buffer) gst.FlowReturn
 	})
+	ret = iface.Transform(goBaseT, gst.ToGstBuffer(unsafe.Pointer(inbuf)), gst.ToGstBuffer(unsafe.Pointer(outbuf)))
+
 	return C.GstFlowReturn(ret)
 }
 
 //export goGstBaseTransformTransformCaps
 func goGstBaseTransformTransformCaps(self *C.GstBaseTransform, direction C.GstPadDirection, caps, filter *C.GstCaps) *C.GstCaps {
 	var ret *gst.Caps
-	glib.WithPointerTransferOriginal(unsafe.Pointer(self), func(gObject *glib.Object, goObject glib.GoObjectSubclass) {
+	goBaseT := ToGstBaseTransform(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(self))})
-		iface := goObject.(interface {
+	subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(self))
-			TransformCaps(self *GstBaseTransform, direction gst.PadDirection, caps, filter *gst.Caps) *gst.Caps
+
-		})
+	iface := subclass.(interface {
-		ret = iface.TransformCaps(ToGstBaseTransform(self), gst.PadDirection(direction), gst.ToGstCaps(unsafe.Pointer(caps)), gst.ToGstCaps(unsafe.Pointer(filter)))
+		TransformCaps(self *GstBaseTransform, direction gst.PadDirection, caps, filter *gst.Caps) *gst.Caps
 	})
+	ret = iface.TransformCaps(goBaseT, gst.PadDirection(direction), gst.ToGstCaps(unsafe.Pointer(caps)), gst.ToGstCaps(unsafe.Pointer(filter)))
+
 	if ret == nil {
 		return nil
 	}
@@ -259,24 +298,28 @@ func goGstBaseTransformTransformCaps(self *C.GstBaseTransform, direction C.GstPa
 //export goGstBaseTransformTransformIP
 func goGstBaseTransformTransformIP(self *C.GstBaseTransform, buf *C.GstBuffer) C.GstFlowReturn {
 	var ret gst.FlowReturn
-	glib.WithPointerTransferOriginal(unsafe.Pointer(self), func(gObject *glib.Object, goObject glib.GoObjectSubclass) {
+	goBaseT := ToGstBaseTransform(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(self))})
-		iface := goObject.(interface {
+	subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(self))
-			TransformIP(self *GstBaseTransform, buf *gst.Buffer) gst.FlowReturn
+
-		})
+	iface := subclass.(interface {
-		ret = iface.TransformIP(ToGstBaseTransform(self), gst.ToGstBuffer(unsafe.Pointer(buf)))
+		TransformIP(self *GstBaseTransform, buf *gst.Buffer) gst.FlowReturn
 	})
+	ret = iface.TransformIP(goBaseT, gst.ToGstBuffer(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 {
 	var ret bool
-	glib.WithPointerTransferOriginal(unsafe.Pointer(self), func(gObject *glib.Object, goObject glib.GoObjectSubclass) {
+	goBaseT := ToGstBaseTransform(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(self))})
-		iface := goObject.(interface {
+	subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(self))
-			TransformMeta(self *GstBaseTransform, outbuf *gst.Buffer, meta *gst.Meta, inbuf *gst.Buffer) bool
+
-		})
+	iface := subclass.(interface {
-		ret = iface.TransformMeta(ToGstBaseTransform(self), gst.ToGstBuffer(unsafe.Pointer(outbuf)), gst.FromGstMetaUnsafe(unsafe.Pointer(meta)), gst.ToGstBuffer(unsafe.Pointer(inbuf)))
+		TransformMeta(self *GstBaseTransform, outbuf *gst.Buffer, meta *gst.Meta, inbuf *gst.Buffer) bool
 	})
+	ret = iface.TransformMeta(goBaseT, gst.ToGstBuffer(unsafe.Pointer(outbuf)), gst.FromGstMetaUnsafe(unsafe.Pointer(meta)), gst.ToGstBuffer(unsafe.Pointer(inbuf)))
+
 	return gboolean(ret)
 }
 
@@ -284,12 +327,14 @@ func goGstBaseTransformTransformMeta(self *C.GstBaseTransform, outbuf *C.GstBuff
 func goGstBaseTransformTransformSize(self *C.GstBaseTransform, direction C.GstPadDirection, caps *C.GstCaps, size C.gsize, othercaps *C.GstCaps, outsize *C.gsize) C.gboolean {
 	var ret bool
 	var othersize int64
-	glib.WithPointerTransferOriginal(unsafe.Pointer(self), func(gObject *glib.Object, goObject glib.GoObjectSubclass) {
+	goBaseT := ToGstBaseTransform(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(self))})
-		iface := goObject.(interface {
+	subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(self))
-			TransformSize(self *GstBaseTransform, direction gst.PadDirection, caps *gst.Caps, size int64, othercaps *gst.Caps) (ok bool, othersize int64)
+
-		})
+	iface := subclass.(interface {
-		ret, othersize = iface.TransformSize(ToGstBaseTransform(self), gst.PadDirection(direction), gst.ToGstCaps(unsafe.Pointer(caps)), int64(size), gst.ToGstCaps(unsafe.Pointer(othercaps)))
+		TransformSize(self *GstBaseTransform, direction gst.PadDirection, caps *gst.Caps, size int64, othercaps *gst.Caps) (ok bool, othersize int64)
 	})
+	ret, othersize = iface.TransformSize(goBaseT, gst.PadDirection(direction), gst.ToGstCaps(unsafe.Pointer(caps)), int64(size), gst.ToGstCaps(unsafe.Pointer(othercaps)))
+
 	if ret {
 		*outsize = C.gsize(othersize)
 	}

gst/base/gst_push_src_exports.go

@@ -16,12 +16,14 @@ import (
 func goGstPushSrcAlloc(src *C.GstPushSrc, buf **C.GstBuffer) C.GstFlowReturn {
 	var ret gst.FlowReturn
 	var outbuf *gst.Buffer
-	glib.WithPointerTransferOriginal(unsafe.Pointer(src), func(gObject *glib.Object, goObject glib.GoObjectSubclass) {
+	goPushSrc := ToGstPushSrc(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(src))})
-		iface := goObject.(interface {
+	subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(src))
-			Alloc(*GstPushSrc) (gst.FlowReturn, *gst.Buffer)
+
-		})
+	iface := subclass.(interface {
-		ret, outbuf = iface.Alloc(ToGstPushSrc(gObject))
+		Alloc(*GstPushSrc) (gst.FlowReturn, *gst.Buffer)
 	})
+	ret, outbuf = iface.Alloc(goPushSrc)
+
 	if outbuf != nil {
 		C.memcpy(unsafe.Pointer(*buf), unsafe.Pointer(outbuf.Instance()), C.sizeof_GstBuffer)
 	}
@@ -32,12 +34,14 @@ func goGstPushSrcAlloc(src *C.GstPushSrc, buf **C.GstBuffer) C.GstFlowReturn {
 func goGstPushSrcCreate(src *C.GstPushSrc, buf **C.GstBuffer) C.GstFlowReturn {
 	var ret gst.FlowReturn
 	var outbuf *gst.Buffer
-	glib.WithPointerTransferOriginal(unsafe.Pointer(src), func(gObject *glib.Object, goObject glib.GoObjectSubclass) {
+	goPushSrc := ToGstPushSrc(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(src))})
-		iface := goObject.(interface {
+	subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(src))
-			Create(*GstPushSrc) (gst.FlowReturn, *gst.Buffer)
+
-		})
+	iface := subclass.(interface {
-		ret, outbuf = iface.Create(ToGstPushSrc(gObject))
+		Create(*GstPushSrc) (gst.FlowReturn, *gst.Buffer)
 	})
+	ret, outbuf = iface.Create(goPushSrc)
+
 	if outbuf != nil {
 		C.memcpy(unsafe.Pointer(*buf), unsafe.Pointer(outbuf.Instance()), C.sizeof_GstBuffer)
 	}
@@ -47,11 +51,13 @@ func goGstPushSrcCreate(src *C.GstPushSrc, buf **C.GstBuffer) C.GstFlowReturn {
 //export goGstPushSrcFill
 func goGstPushSrcFill(src *C.GstPushSrc, buf *C.GstBuffer) C.GstFlowReturn {
 	var ret gst.FlowReturn
-	glib.WithPointerTransferOriginal(unsafe.Pointer(src), func(gObject *glib.Object, goObject glib.GoObjectSubclass) {
+	goPushSrc := ToGstPushSrc(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(src))})
-		iface := goObject.(interface {
+	subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(src))
-			Fill(*GstPushSrc, *gst.Buffer) gst.FlowReturn
+
-		})
+	iface := subclass.(interface {
-		ret = iface.Fill(ToGstPushSrc(gObject), gst.ToGstBuffer(unsafe.Pointer(buf)))
+		Fill(*GstPushSrc, *gst.Buffer) gst.FlowReturn
 	})
+	ret = iface.Fill(goPushSrc, gst.ToGstBuffer(unsafe.Pointer(buf)))
+
 	return C.GstFlowReturn(ret)
 }

gst/gst_uri_handler_exports.go

@@ -33,9 +33,9 @@ func goURIHdlrGetProtocols(gtype C.GType) **C.gchar {
 //export goURIHdlrGetURI
 func goURIHdlrGetURI(hdlr *C.GstURIHandler) *C.gchar {
 	var uri string
-	glib.WithPointerTransferOriginal(unsafe.Pointer(hdlr), func(gobj *glib.Object, obj glib.GoObjectSubclass) {
+	subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(hdlr))
-		uri = obj.(URIHandler).GetURI()
+	uri = subclass.(URIHandler).GetURI()
-	})
+
 	if uri == "" {
 		return nil
 	}
@@ -46,9 +46,10 @@ func goURIHdlrGetURI(hdlr *C.GstURIHandler) *C.gchar {
 func goURIHdlrSetURI(hdlr *C.GstURIHandler, uri *C.gchar, gerr **C.GError) C.gboolean {
 	var ok bool
 	var err error
-	glib.WithPointerTransferOriginal(unsafe.Pointer(hdlr), func(gobj *glib.Object, obj glib.GoObjectSubclass) {
+	subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(hdlr))
-		ok, err = obj.(URIHandler).SetURI(C.GoString(uri))
+
-	})
+	ok, err = subclass.(URIHandler).SetURI(C.GoString(uri))
+
 	if err != nil {
 		errMsg := C.CString(err.Error())
 		defer C.free(unsafe.Pointer(errMsg))