From 96b7315e7af44db5e385b0181bc358ea078bacf9 Mon Sep 17 00:00:00 2001 From: RSWilli Date: Mon, 9 Dec 2024 10:53:09 +0100 Subject: [PATCH] add custom transform example and remove calls to deprecated methods --- .../internal/customtransform/element.go | 68 +++++ .../internal/customtransform/register.go | 23 ++ examples/plugins/basetransform/main.go | 46 +++ gst/app/cgo_exports.go | 7 +- gst/base/gst_base_sink_exports.go | 216 ++++++++------ gst/base/gst_base_src_exports.go | 229 ++++++++------- gst/base/gst_base_transform.go | 106 +++++++ gst/base/gst_base_transform_exports.go | 265 ++++++++++-------- gst/base/gst_push_src_exports.go | 36 ++- gst/gst_uri_handler_exports.go | 13 +- 10 files changed, 690 insertions(+), 319 deletions(-) create mode 100644 examples/plugins/basetransform/internal/customtransform/element.go create mode 100644 examples/plugins/basetransform/internal/customtransform/register.go create mode 100644 examples/plugins/basetransform/main.go diff --git a/examples/plugins/basetransform/internal/customtransform/element.go b/examples/plugins/basetransform/internal/customtransform/element.go new file mode 100644 index 0000000..8821ac6 --- /dev/null +++ b/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 ", + ) + 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) +} diff --git a/examples/plugins/basetransform/internal/customtransform/register.go b/examples/plugins/basetransform/internal/customtransform/register.go new file mode 100644 index 0000000..980b198 --- /dev/null +++ b/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, + ) +} diff --git a/examples/plugins/basetransform/main.go b/examples/plugins/basetransform/main.go new file mode 100644 index 0000000..892dec3 --- /dev/null +++ b/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) + } +} diff --git a/gst/app/cgo_exports.go b/gst/app/cgo_exports.go index 8373084..06e8eca 100644 --- a/gst/app/cgo_exports.go +++ b/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 } diff --git a/gst/base/gst_base_sink_exports.go b/gst/base/gst_base_sink_exports.go index 92c5d6b..dd24ba7 100644 --- a/gst/base/gst_base_sink_exports.go +++ b/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) { - iface := goObject.(interface { - ActivatePull(self *GstBaseSink, active bool) bool - }) - ret = gboolean(iface.ActivatePull(ToGstBaseSink(gObject), gobool(active))) + goBaseSink := ToGstBaseSink(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(sink))}) + subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(sink)) + + iface := subclass.(interface { + 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) { - iface := goObject.(interface { - Event(self *GstBaseSink, event *gst.Event) bool - }) - ret = gboolean(iface.Event(ToGstBaseSink(gObject), gst.ToGstEvent(unsafe.Pointer(event)))) + goBaseSink := ToGstBaseSink(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(sink))}) + subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(sink)) + + iface := subclass.(interface { + 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) { - iface := goObject.(interface { - Fixate(self *GstBaseSink, caps *gst.Caps) *gst.Caps - }) - fixated = iface.Fixate(ToGstBaseSink(gObject), gst.ToGstCaps(unsafe.Pointer(caps))) + goBaseSink := ToGstBaseSink(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(sink))}) + subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(sink)) + + iface := subclass.(interface { + 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) { - iface := goObject.(interface { - GetCaps(self *GstBaseSink, filter *gst.Caps) *gst.Caps - }) - filtered = iface.GetCaps(ToGstBaseSink(gObject), gst.ToGstCaps(unsafe.Pointer(filter))) + goBaseSink := ToGstBaseSink(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(sink))}) + subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(sink)) + + iface := subclass.(interface { + 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) { - iface := goObject.(interface { - GetTimes(self *GstBaseSink, buffer *gst.Buffer) (start, end time.Duration) // should this be a ClockTime? - }) - retStart, retEnd = iface.GetTimes(ToGstBaseSink(gObject), gst.ToGstBuffer(unsafe.Pointer(buf))) + goBaseSink := ToGstBaseSink(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(sink))}) + subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(sink)) + + iface := subclass.(interface { + 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) { - iface := goObject.(interface { - Prepare(self *GstBaseSink, buffer *gst.Buffer) gst.FlowReturn - }) - ret = iface.Prepare(ToGstBaseSink(gObject), gst.ToGstBuffer(unsafe.Pointer(buf))) + goBaseSink := ToGstBaseSink(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(sink))}) + subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(sink)) + + iface := subclass.(interface { + 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) { - iface := goObject.(interface { - PrepareList(self *GstBaseSink, bufferList *gst.BufferList) gst.FlowReturn - }) - ret = iface.PrepareList(ToGstBaseSink(gObject), gst.ToGstBufferList(unsafe.Pointer(list))) + goBaseSink := ToGstBaseSink(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(sink))}) + subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(sink)) + + iface := subclass.(interface { + 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) { - iface := goObject.(interface { - Preroll(self *GstBaseSink, buffer *gst.Buffer) gst.FlowReturn - }) - ret = iface.Preroll(ToGstBaseSink(gObject), gst.ToGstBuffer(unsafe.Pointer(buf))) + goBaseSink := ToGstBaseSink(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(sink))}) + subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(sink)) + + iface := subclass.(interface { + 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) { - iface := goObject.(interface { - ProposeAllocation(self *GstBaseSink, query *gst.Query) bool - }) - ret = iface.ProposeAllocation(ToGstBaseSink(gObject), gst.ToGstQuery(unsafe.Pointer(query))) + goBaseSink := ToGstBaseSink(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(sink))}) + subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(sink)) + + iface := subclass.(interface { + 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) { - iface := goObject.(interface { - Query(self *GstBaseSink, query *gst.Query) bool - }) - ret = iface.Query(ToGstBaseSink(gObject), gst.ToGstQuery(unsafe.Pointer(query))) + goBaseSink := ToGstBaseSink(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(sink))}) + subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(sink)) + + iface := subclass.(interface { + 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) { - iface := goObject.(interface { - Render(self *GstBaseSink, buffer *gst.Buffer) gst.FlowReturn - }) - ret = iface.Render(ToGstBaseSink(gObject), gst.ToGstBuffer(unsafe.Pointer(buf))) + goBaseSink := ToGstBaseSink(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(sink))}) + subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(sink)) + + iface := subclass.(interface { + 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) { - iface := goObject.(interface { - RenderList(self *GstBaseSink, bufferList *gst.BufferList) gst.FlowReturn - }) - ret = iface.RenderList(ToGstBaseSink(gObject), gst.ToGstBufferList(unsafe.Pointer(buf))) + goBaseSink := ToGstBaseSink(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(sink))}) + subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(sink)) + + iface := subclass.(interface { + 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) { - iface := goObject.(interface { - SetCaps(self *GstBaseSink, caps *gst.Caps) bool - }) - ret = iface.SetCaps(ToGstBaseSink(gObject), gst.ToGstCaps(unsafe.Pointer(caps))) + goBaseSink := ToGstBaseSink(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(sink))}) + subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(sink)) + + iface := subclass.(interface { + 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) { - iface := goObject.(interface { - Start(self *GstBaseSink) bool - }) - ret = iface.Start(ToGstBaseSink(gObject)) + goBaseSink := ToGstBaseSink(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(sink))}) + subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(sink)) + + iface := subclass.(interface { + 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) { - iface := goObject.(interface { - Stop(self *GstBaseSink) bool - }) - ret = iface.Stop(ToGstBaseSink(gObject)) + goBaseSink := ToGstBaseSink(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(sink))}) + subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(sink)) + + iface := subclass.(interface { + 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) { - iface := goObject.(interface { - Unlock(self *GstBaseSink) bool - }) - ret = iface.Unlock(ToGstBaseSink(gObject)) + goBaseSink := ToGstBaseSink(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(sink))}) + subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(sink)) + + iface := subclass.(interface { + 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) { - iface := goObject.(interface { - UnlockStop(self *GstBaseSink) bool - }) - ret = iface.UnlockStop(ToGstBaseSink(gObject)) + goBaseSink := ToGstBaseSink(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(sink))}) + subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(sink)) + + iface := subclass.(interface { + 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) { - iface := goObject.(interface { - WaitEvent(self *GstBaseSink, event *gst.Event) gst.FlowReturn - }) - ret = iface.WaitEvent(ToGstBaseSink(gObject), gst.ToGstEvent(unsafe.Pointer(event))) + goBaseSink := ToGstBaseSink(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(sink))}) + subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(sink)) + + iface := subclass.(interface { + WaitEvent(self *GstBaseSink, event *gst.Event) gst.FlowReturn }) + ret = iface.WaitEvent(goBaseSink, gst.ToGstEvent(unsafe.Pointer(event))) + return C.GstFlowReturn(ret) } diff --git a/gst/base/gst_base_src_exports.go b/gst/base/gst_base_src_exports.go index 1455917..bb655f6 100644 --- a/gst/base/gst_base_src_exports.go +++ b/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 { - GetCaps(*GstBaseSrc, *gst.Caps) *gst.Caps - }) - caps = iface.GetCaps(ToGstBaseSrc(gObject), gst.ToGstCaps(unsafe.Pointer(filter))) + + goBaseSrc := ToGstBaseSrc(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(src))}) + subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(src)) + + 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) { - iface := goObject.(interface { - Negotiate(*GstBaseSrc) bool - }) - ret = iface.Negotiate(ToGstBaseSrc(gObject)) + goBaseSrc := ToGstBaseSrc(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(src))}) + subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(src)) + + iface := subclass.(interface { + 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) { - iface := goObject.(interface { - Fixate(*GstBaseSrc, *gst.Caps) *gst.Caps - }) - caps = iface.Fixate(ToGstBaseSrc(gObject), gst.ToGstCaps(unsafe.Pointer(filter))) + goBaseSrc := ToGstBaseSrc(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(src))}) + subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(src)) + + iface := subclass.(interface { + 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) { - iface := goObject.(interface { - SetCaps(*GstBaseSrc, *gst.Caps) bool - }) - ret = iface.SetCaps(ToGstBaseSrc(gObject), gst.ToGstCaps(unsafe.Pointer(caps))) + goBaseSrc := ToGstBaseSrc(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(src))}) + subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(src)) + + iface := subclass.(interface { + 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) { - iface := goObject.(interface { - DecideAllocation(*GstBaseSrc, *gst.Query) bool - }) - ret = iface.DecideAllocation(ToGstBaseSrc(gObject), gst.ToGstQuery(unsafe.Pointer(query))) + goBaseSrc := ToGstBaseSrc(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(src))}) + subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(src)) + + iface := subclass.(interface { + 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) { - iface := goObject.(interface { - Start(*GstBaseSrc) bool - }) - ret = iface.Start(ToGstBaseSrc(gObject)) + goBaseSrc := ToGstBaseSrc(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(src))}) + subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(src)) + + iface := subclass.(interface { + 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) { - iface := goObject.(interface { - Stop(*GstBaseSrc) bool - }) - ret = iface.Stop(ToGstBaseSrc(gObject)) + goBaseSrc := ToGstBaseSrc(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(src))}) + subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(src)) + + iface := subclass.(interface { + 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) { - iface := goObject.(interface { - GetTimes(*GstBaseSrc, *gst.Buffer) (start, end time.Duration) // should this be a ClockTime? - }) - gostart, goend = iface.GetTimes(ToGstBaseSrc(gObject), gst.ToGstBuffer(unsafe.Pointer(buf))) + goBaseSrc := ToGstBaseSrc(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(src))}) + subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(src)) + + iface := subclass.(interface { + 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) { - iface := goObject.(interface { - GetSize(*GstBaseSrc) (bool, int64) - }) - ok, gosize = iface.GetSize(ToGstBaseSrc(gObject)) + goBaseSrc := ToGstBaseSrc(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(src))}) + subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(src)) + + iface := subclass.(interface { + 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) { - iface := goObject.(interface { - IsSeekable(*GstBaseSrc) bool - }) - ok = iface.IsSeekable(ToGstBaseSrc(gObject)) + goBaseSrc := ToGstBaseSrc(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(src))}) + subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(src)) + + iface := subclass.(interface { + 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) { - 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))) + goBaseSrc := ToGstBaseSrc(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(src))}) + subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(src)) + + iface := subclass.(interface { + 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) { - iface := goObject.(interface { - DoSeek(*GstBaseSrc, *gst.Segment) bool - }) - ok = iface.DoSeek(ToGstBaseSrc(gObject), gst.ToGstSegment(unsafe.Pointer(segment))) + goBaseSrc := ToGstBaseSrc(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(src))}) + subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(src)) + + iface := subclass.(interface { + 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) { - iface := goObject.(interface { - Unlock(*GstBaseSrc) bool - }) - ok = iface.Unlock(ToGstBaseSrc(gObject)) + goBaseSrc := ToGstBaseSrc(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(src))}) + subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(src)) + + iface := subclass.(interface { + 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) { - iface := goObject.(interface { - UnlockStop(*GstBaseSrc) bool - }) - ok = iface.UnlockStop(ToGstBaseSrc(gObject)) + goBaseSrc := ToGstBaseSrc(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(src))}) + subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(src)) + + iface := subclass.(interface { + 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) { - iface := goObject.(interface { - Query(*GstBaseSrc, *gst.Query) bool - }) - ok = iface.Query(ToGstBaseSrc(gObject), gst.ToGstQuery(unsafe.Pointer(query))) + goBaseSrc := ToGstBaseSrc(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(src))}) + subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(src)) + + iface := subclass.(interface { + 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) { - iface := goObject.(interface { - Event(*GstBaseSrc, *gst.Event) bool - }) - ok = iface.Event(ToGstBaseSrc(gObject), gst.ToGstEvent(unsafe.Pointer(event))) + goBaseSrc := ToGstBaseSrc(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(src))}) + subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(src)) + + iface := subclass.(interface { + 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) { - iface := goObject.(interface { - Create(*GstBaseSrc, uint64, uint) (gst.FlowReturn, *gst.Buffer) - }) - ret, gobuf = iface.Create(ToGstBaseSrc(gObject), uint64(offset), uint(size)) + goBaseSrc := ToGstBaseSrc(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(src))}) + subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(src)) + + iface := subclass.(interface { + 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) { - iface := goObject.(interface { - Alloc(*GstBaseSrc, uint64, uint) (gst.FlowReturn, *gst.Buffer) - }) - ret, gobuf = iface.Alloc(ToGstBaseSrc(gObject), uint64(offset), uint(size)) + goBaseSrc := ToGstBaseSrc(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(src))}) + subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(src)) + + iface := subclass.(interface { + 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) { - 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))) + goBaseSrc := ToGstBaseSrc(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(src))}) + subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(src)) + + iface := subclass.(interface { + 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) } diff --git a/gst/base/gst_base_transform.go b/gst/base/gst_base_transform.go index 54c9c98..9eeca63 100644 --- a/gst/base/gst_base_transform.go +++ b/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") +} diff --git a/gst/base/gst_base_transform_exports.go b/gst/base/gst_base_transform_exports.go index b657285..602492a 100644 --- a/gst/base/gst_base_transform_exports.go +++ b/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) { - iface := goObject.(interface { - AcceptCaps(*GstBaseTransform, gst.PadDirection, *gst.Caps) bool - }) - ret = iface.AcceptCaps(ToGstBaseTransform(self), gst.PadDirection(direction), gst.ToGstCaps(unsafe.Pointer(caps))) + goBaseT := ToGstBaseTransform(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(self))}) + subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(self)) + + iface := subclass.(interface { + 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) { - iface := goObject.(interface { - BeforeTransform(*GstBaseTransform, *gst.Buffer) - }) - iface.BeforeTransform(ToGstBaseTransform(self), gst.ToGstBuffer(unsafe.Pointer(buffer))) + goBaseT := ToGstBaseTransform(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(self))}) + subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(self)) + + iface := subclass.(interface { + 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) { - 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))) + goBaseT := ToGstBaseTransform(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(self))}) + subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(self)) + + iface := subclass.(interface { + 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) { - iface := goObject.(interface { - DecideAllocation(self *GstBaseTransform, query *gst.Query) bool - }) - ret = iface.DecideAllocation(ToGstBaseTransform(self), gst.ToGstQuery(unsafe.Pointer(query))) + goBaseT := ToGstBaseTransform(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(self))}) + subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(self)) + + iface := subclass.(interface { + 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) { - 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))) + goBaseT := ToGstBaseTransform(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(self))}) + subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(self)) + + iface := subclass.(interface { + 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) { - 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))) + goBaseT := ToGstBaseTransform(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(self))}) + subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(self)) + + iface := subclass.(interface { + 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) { - iface := goObject.(interface { - GenerateOutput(self *GstBaseTransform) (gst.FlowReturn, *gst.Buffer) - }) - ret, out = iface.GenerateOutput(ToGstBaseTransform(self)) + goBaseT := ToGstBaseTransform(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(self))}) + subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(self)) + + iface := subclass.(interface { + 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) { - iface := goObject.(interface { - GetUnitSize(self *GstBaseTransform, caps *gst.Caps) (ok bool, size int64) - }) - ret, out = iface.GetUnitSize(ToGstBaseTransform(self), gst.ToGstCaps(unsafe.Pointer(caps))) + goBaseT := ToGstBaseTransform(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(self))}) + subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(self)) + + iface := subclass.(interface { + 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) { - iface := goObject.(interface { - PrepareOutputBuffer(self *GstBaseTransform, input *gst.Buffer) (gst.FlowReturn, *gst.Buffer) - }) - ret, out = iface.PrepareOutputBuffer(ToGstBaseTransform(self), gst.ToGstBuffer(unsafe.Pointer(input))) + goBaseT := ToGstBaseTransform(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(self))}) + subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(self)) + + iface := subclass.(interface { + 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) { - 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))) + goBaseT := ToGstBaseTransform(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(self))}) + subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(self)) + + iface := subclass.(interface { + 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) { - 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))) + goBaseT := ToGstBaseTransform(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(self))}) + subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(self)) + + iface := subclass.(interface { + 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) { - 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))) + goBaseT := ToGstBaseTransform(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(self))}) + subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(self)) + + iface := subclass.(interface { + 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 { - SinkEvent(self *GstBaseTransform, event *gst.Event) bool - }) - ret = iface.SinkEvent(ToGstBaseTransform(self), gst.ToGstEvent(unsafe.Pointer(event))) + + goBaseT := ToGstBaseTransform(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(self))}) + subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(self)) + + 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 { - SrcEvent(self *GstBaseTransform, event *gst.Event) bool - }) - ret = iface.SrcEvent(ToGstBaseTransform(self), gst.ToGstEvent(unsafe.Pointer(event))) + + goBaseT := ToGstBaseTransform(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(self))}) + subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(self)) + + 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) { - iface := goObject.(interface { - Start(self *GstBaseTransform) bool - }) - ret = iface.Start(ToGstBaseTransform(self)) + goBaseT := ToGstBaseTransform(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(self))}) + subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(self)) + + iface := subclass.(interface { + 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) { - iface := goObject.(interface { - Stop(self *GstBaseTransform) bool - }) - ret = iface.Stop(ToGstBaseTransform(self)) + goBaseT := ToGstBaseTransform(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(self))}) + subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(self)) + + iface := subclass.(interface { + 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) { - 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))) + goBaseT := ToGstBaseTransform(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(self))}) + subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(self)) + + iface := subclass.(interface { + 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) { - 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))) + goBaseT := ToGstBaseTransform(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(self))}) + subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(self)) + + iface := subclass.(interface { + 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) { - 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))) + goBaseT := ToGstBaseTransform(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(self))}) + subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(self)) + + iface := subclass.(interface { + 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) { - iface := goObject.(interface { - TransformIP(self *GstBaseTransform, buf *gst.Buffer) gst.FlowReturn - }) - ret = iface.TransformIP(ToGstBaseTransform(self), gst.ToGstBuffer(unsafe.Pointer(buf))) + goBaseT := ToGstBaseTransform(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(self))}) + subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(self)) + + iface := subclass.(interface { + 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) { - 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))) + goBaseT := ToGstBaseTransform(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(self))}) + subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(self)) + + iface := subclass.(interface { + 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) { - 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))) + goBaseT := ToGstBaseTransform(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(self))}) + subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(self)) + + iface := subclass.(interface { + 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) } diff --git a/gst/base/gst_push_src_exports.go b/gst/base/gst_push_src_exports.go index dd19312..c3797bb 100644 --- a/gst/base/gst_push_src_exports.go +++ b/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) { - iface := goObject.(interface { - Alloc(*GstPushSrc) (gst.FlowReturn, *gst.Buffer) - }) - ret, outbuf = iface.Alloc(ToGstPushSrc(gObject)) + goPushSrc := ToGstPushSrc(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(src))}) + subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(src)) + + iface := subclass.(interface { + 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) { - iface := goObject.(interface { - Create(*GstPushSrc) (gst.FlowReturn, *gst.Buffer) - }) - ret, outbuf = iface.Create(ToGstPushSrc(gObject)) + goPushSrc := ToGstPushSrc(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(src))}) + subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(src)) + + iface := subclass.(interface { + 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) { - iface := goObject.(interface { - Fill(*GstPushSrc, *gst.Buffer) gst.FlowReturn - }) - ret = iface.Fill(ToGstPushSrc(gObject), gst.ToGstBuffer(unsafe.Pointer(buf))) + goPushSrc := ToGstPushSrc(&glib.Object{GObject: glib.ToGObject(unsafe.Pointer(src))}) + subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(src)) + + iface := subclass.(interface { + Fill(*GstPushSrc, *gst.Buffer) gst.FlowReturn }) + ret = iface.Fill(goPushSrc, gst.ToGstBuffer(unsafe.Pointer(buf))) + return C.GstFlowReturn(ret) } diff --git a/gst/gst_uri_handler_exports.go b/gst/gst_uri_handler_exports.go index bf0e775..7826540 100644 --- a/gst/gst_uri_handler_exports.go +++ b/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) { - uri = obj.(URIHandler).GetURI() - }) + subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(hdlr)) + 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) { - ok, err = obj.(URIHandler).SetURI(C.GoString(uri)) - }) + subclass := glib.FromObjectUnsafePrivate(unsafe.Pointer(hdlr)) + + ok, err = subclass.(URIHandler).SetURI(C.GoString(uri)) + if err != nil { errMsg := C.CString(err.Error()) defer C.free(unsafe.Pointer(errMsg))