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

add custom transform example and remove calls to deprecated methods

Browse Source
This commit is contained in:
RSWilli
2024-12-09 10:53:09 +01:00
parent b9dce0b926
commit 96b7315e7a
10 changed files with 690 additions and 319 deletions
Download Patch File Download Diff File Expand all files Collapse all files

68
examples/plugins/basetransform/internal/customtransform/element.go Normal file
View File

@@ -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)
}

23
examples/plugins/basetransform/internal/customtransform/register.go Normal file
View File

@@ -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,
)
}

46
examples/plugins/basetransform/main.go Normal file
View File

@@ -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)
}
}

7
gst/app/cgo_exports.go
View File

@@ -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
}

216
gst/base/gst_base_sink_exports.go
View File

@@ -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)
}

229
gst/base/gst_base_src_exports.go
View File

@@ -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)
}

106
gst/base/gst_base_transform.go
View File

@@ -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")
}

265
gst/base/gst_base_transform_exports.go
View File

@@ -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)
}

36
gst/base/gst_push_src_exports.go
View File

@@ -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)
}

13
gst/gst_uri_handler_exports.go
View File

@@ -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))