mirror of
https://github.com/go-gst/go-gst.git
synced 2025-10-08 01:11:28 +08:00
1530 lines
60 KiB
Go
1530 lines
60 KiB
Go
// Code generated by girgen. DO NOT EDIT.
|
|
|
|
package gstcontroller
|
|
|
|
import (
|
|
"fmt"
|
|
"runtime"
|
|
"unsafe"
|
|
|
|
"github.com/diamondburned/gotk4/pkg/glib/v2"
|
|
"github.com/diamondburned/gotk4/pkg/gobject/v2"
|
|
"github.com/go-gst/go-gst/pkg/gst"
|
|
)
|
|
|
|
// #cgo pkg-config: gstreamer-controller-1.0
|
|
// #cgo CFLAGS: -Wno-deprecated-declarations
|
|
// #include <gst/controller/controller.h>
|
|
import "C"
|
|
|
|
// GType values.
|
|
var (
|
|
TypeInterpolationMode = gobject.Type(C.gst_interpolation_mode_get_type())
|
|
TypeLFOWaveform = gobject.Type(C.gst_lfo_waveform_get_type())
|
|
TypeARGBControlBinding = gobject.Type(C.gst_argb_control_binding_get_type())
|
|
TypeDirectControlBinding = gobject.Type(C.gst_direct_control_binding_get_type())
|
|
TypeLFOControlSource = gobject.Type(C.gst_lfo_control_source_get_type())
|
|
TypeProxyControlBinding = gobject.Type(C.gst_proxy_control_binding_get_type())
|
|
TypeTimedValueControlSource = gobject.Type(C.gst_timed_value_control_source_get_type())
|
|
TypeTriggerControlSource = gobject.Type(C.gst_trigger_control_source_get_type())
|
|
TypeInterpolationControlSource = gobject.Type(C.gst_interpolation_control_source_get_type())
|
|
TypeControlPoint = gobject.Type(C.gst_control_point_get_type())
|
|
)
|
|
|
|
func init() {
|
|
gobject.RegisterGValueMarshalers([]gobject.TypeMarshaler{
|
|
gobject.TypeMarshaler{T: TypeInterpolationMode, F: marshalInterpolationMode},
|
|
gobject.TypeMarshaler{T: TypeLFOWaveform, F: marshalLFOWaveform},
|
|
gobject.TypeMarshaler{T: TypeARGBControlBinding, F: marshalARGBControlBindingInstance},
|
|
gobject.TypeMarshaler{T: TypeDirectControlBinding, F: marshalDirectControlBindingInstance},
|
|
gobject.TypeMarshaler{T: TypeLFOControlSource, F: marshalLFOControlSourceInstance},
|
|
gobject.TypeMarshaler{T: TypeProxyControlBinding, F: marshalProxyControlBindingInstance},
|
|
gobject.TypeMarshaler{T: TypeTimedValueControlSource, F: marshalTimedValueControlSourceInstance},
|
|
gobject.TypeMarshaler{T: TypeTriggerControlSource, F: marshalTriggerControlSourceInstance},
|
|
gobject.TypeMarshaler{T: TypeInterpolationControlSource, F: marshalInterpolationControlSourceInstance},
|
|
gobject.TypeMarshaler{T: TypeControlPoint, F: marshalControlPoint},
|
|
})
|
|
}
|
|
|
|
// InterpolationMode wraps GstInterpolationMode
|
|
//
|
|
// The various interpolation modes available.
|
|
type InterpolationMode C.int
|
|
|
|
const (
|
|
// InterpolationModeNone wraps GST_INTERPOLATION_MODE_NONE
|
|
//
|
|
// steps-like interpolation, default
|
|
InterpolationModeNone InterpolationMode = 0
|
|
// InterpolationModeLinear wraps GST_INTERPOLATION_MODE_LINEAR
|
|
//
|
|
// linear interpolation
|
|
InterpolationModeLinear InterpolationMode = 1
|
|
// InterpolationModeCubic wraps GST_INTERPOLATION_MODE_CUBIC
|
|
//
|
|
// cubic interpolation (natural), may overshoot
|
|
// the min or max values set by the control point, but is more 'curvy'
|
|
InterpolationModeCubic InterpolationMode = 2
|
|
// InterpolationModeCubicMonotonic wraps GST_INTERPOLATION_MODE_CUBIC_MONOTONIC
|
|
//
|
|
// monotonic cubic interpolation, will not
|
|
// produce any values outside of the min-max range set by the control points
|
|
// (Since: 1.8)
|
|
InterpolationModeCubicMonotonic InterpolationMode = 3
|
|
)
|
|
|
|
func marshalInterpolationMode(p unsafe.Pointer) (any, error) {
|
|
return InterpolationMode(gobject.ValueFromNative(p).Enum()), nil
|
|
}
|
|
|
|
var _ gobject.GoValueInitializer = InterpolationMode(0)
|
|
|
|
func (e InterpolationMode) InitGoValue(v *gobject.Value) {
|
|
v.Init(TypeInterpolationMode)
|
|
v.SetEnum(int(e))
|
|
}
|
|
|
|
func (e InterpolationMode) String() string {
|
|
switch e {
|
|
case InterpolationModeNone: return "InterpolationModeNone"
|
|
case InterpolationModeLinear: return "InterpolationModeLinear"
|
|
case InterpolationModeCubic: return "InterpolationModeCubic"
|
|
case InterpolationModeCubicMonotonic: return "InterpolationModeCubicMonotonic"
|
|
default: return fmt.Sprintf("InterpolationMode(%d)", e)
|
|
}
|
|
}
|
|
|
|
// LFOWaveform wraps GstLFOWaveform
|
|
//
|
|
// The various waveform modes available.
|
|
type LFOWaveform C.int
|
|
|
|
const (
|
|
// LfoWaveformSine wraps GST_LFO_WAVEFORM_SINE
|
|
//
|
|
// sine waveform
|
|
LfoWaveformSine LFOWaveform = 0
|
|
// LfoWaveformSquare wraps GST_LFO_WAVEFORM_SQUARE
|
|
//
|
|
// square waveform
|
|
LfoWaveformSquare LFOWaveform = 1
|
|
// LfoWaveformSaw wraps GST_LFO_WAVEFORM_SAW
|
|
//
|
|
// saw waveform
|
|
LfoWaveformSaw LFOWaveform = 2
|
|
// LfoWaveformReverseSaw wraps GST_LFO_WAVEFORM_REVERSE_SAW
|
|
//
|
|
// reverse saw waveform
|
|
LfoWaveformReverseSaw LFOWaveform = 3
|
|
// LfoWaveformTriangle wraps GST_LFO_WAVEFORM_TRIANGLE
|
|
//
|
|
// triangle waveform
|
|
LfoWaveformTriangle LFOWaveform = 4
|
|
)
|
|
|
|
func marshalLFOWaveform(p unsafe.Pointer) (any, error) {
|
|
return LFOWaveform(gobject.ValueFromNative(p).Enum()), nil
|
|
}
|
|
|
|
var _ gobject.GoValueInitializer = LFOWaveform(0)
|
|
|
|
func (e LFOWaveform) InitGoValue(v *gobject.Value) {
|
|
v.Init(TypeLFOWaveform)
|
|
v.SetEnum(int(e))
|
|
}
|
|
|
|
func (e LFOWaveform) String() string {
|
|
switch e {
|
|
case LfoWaveformReverseSaw: return "LfoWaveformReverseSaw"
|
|
case LfoWaveformTriangle: return "LfoWaveformTriangle"
|
|
case LfoWaveformSine: return "LfoWaveformSine"
|
|
case LfoWaveformSquare: return "LfoWaveformSquare"
|
|
case LfoWaveformSaw: return "LfoWaveformSaw"
|
|
default: return fmt.Sprintf("LFOWaveform(%d)", e)
|
|
}
|
|
}
|
|
|
|
// TimedValueControlInvalidateCache wraps gst_timed_value_control_invalidate_cache
|
|
//
|
|
// The function takes the following parameters:
|
|
//
|
|
// - self TimedValueControlSource: the #GstTimedValueControlSource
|
|
//
|
|
// Reset the controlled value cache.
|
|
func TimedValueControlInvalidateCache(self TimedValueControlSource) {
|
|
var carg1 *C.GstTimedValueControlSource // in, none, converted
|
|
|
|
carg1 = (*C.GstTimedValueControlSource)(UnsafeTimedValueControlSourceToGlibNone(self))
|
|
|
|
C.gst_timed_value_control_invalidate_cache(carg1)
|
|
runtime.KeepAlive(self)
|
|
}
|
|
|
|
// ARGBControlBindingInstance is the instance type used by all types extending GstARGBControlBinding. It is used internally by the bindings. Users should use the interface [ARGBControlBinding] instead.
|
|
type ARGBControlBindingInstance struct {
|
|
_ [0]func() // equal guard
|
|
gst.ControlBindingInstance
|
|
}
|
|
|
|
var _ ARGBControlBinding = (*ARGBControlBindingInstance)(nil)
|
|
|
|
// ARGBControlBinding wraps GstARGBControlBinding
|
|
//
|
|
// A value mapping object that attaches multiple control sources to a guint
|
|
// gobject properties representing a color. A control value of 0.0 will turn the
|
|
// color component off and a value of 1.0 will be the color level.
|
|
type ARGBControlBinding interface {
|
|
gst.ControlBinding
|
|
upcastToGstARGBControlBinding() *ARGBControlBindingInstance
|
|
}
|
|
|
|
func unsafeWrapARGBControlBinding(base *gobject.ObjectInstance) *ARGBControlBindingInstance {
|
|
return &ARGBControlBindingInstance{
|
|
ControlBindingInstance: gst.ControlBindingInstance{
|
|
ObjectInstance: gst.ObjectInstance{
|
|
InitiallyUnownedInstance: gobject.InitiallyUnownedInstance{
|
|
ObjectInstance: *base,
|
|
},
|
|
},
|
|
},
|
|
}
|
|
}
|
|
|
|
func marshalARGBControlBindingInstance(p unsafe.Pointer) (any, error) {
|
|
return unsafeWrapARGBControlBinding(gobject.ValueFromNative(p).Object()), nil
|
|
}
|
|
|
|
// UnsafeARGBControlBindingFromGlibNone is used to convert raw GstARGBControlBinding pointers to go while taking a reference and attaching a finalizer. This is used by the bindings internally.
|
|
func UnsafeARGBControlBindingFromGlibNone(c unsafe.Pointer) ARGBControlBinding {
|
|
return gobject.UnsafeObjectFromGlibNone(c).(ARGBControlBinding)
|
|
}
|
|
|
|
// UnsafeARGBControlBindingFromGlibFull is used to convert raw GstARGBControlBinding pointers to go while attaching a finalizer. This is used by the bindings internally.
|
|
func UnsafeARGBControlBindingFromGlibFull(c unsafe.Pointer) ARGBControlBinding {
|
|
return gobject.UnsafeObjectFromGlibFull(c).(ARGBControlBinding)
|
|
}
|
|
|
|
func (a *ARGBControlBindingInstance) upcastToGstARGBControlBinding() *ARGBControlBindingInstance {
|
|
return a
|
|
}
|
|
|
|
// UnsafeARGBControlBindingToGlibNone is used to convert the instance to it's C value GstARGBControlBinding. This is used by the bindings internally.
|
|
func UnsafeARGBControlBindingToGlibNone(c ARGBControlBinding) unsafe.Pointer {
|
|
return gobject.UnsafeObjectToGlibNone(c)
|
|
}
|
|
|
|
// UnsafeARGBControlBindingToGlibFull is used to convert the instance to it's C value GstARGBControlBinding, while removeing the finalizer. This is used by the bindings internally.
|
|
func UnsafeARGBControlBindingToGlibFull(c ARGBControlBinding) unsafe.Pointer {
|
|
return gobject.UnsafeObjectToGlibFull(c)
|
|
}
|
|
|
|
// NewARGBControlBinding wraps gst_argb_control_binding_new
|
|
//
|
|
// The function takes the following parameters:
|
|
//
|
|
// - object gst.Object: the object of the property
|
|
// - propertyName string: the property-name to attach the control source
|
|
// - csA gst.ControlSource: the control source for the alpha channel
|
|
// - csR gst.ControlSource: the control source for the red channel
|
|
// - csG gst.ControlSource: the control source for the green channel
|
|
// - csB gst.ControlSource: the control source for the blue channel
|
|
//
|
|
// The function returns the following values:
|
|
//
|
|
// - goret gst.ControlBinding
|
|
//
|
|
// Create a new control-binding that attaches the given #GstControlSource to the
|
|
// #GObject property.
|
|
func NewARGBControlBinding(object gst.Object, propertyName string, csA gst.ControlSource, csR gst.ControlSource, csG gst.ControlSource, csB gst.ControlSource) gst.ControlBinding {
|
|
var carg1 *C.GstObject // in, none, converted
|
|
var carg2 *C.gchar // in, none, string, casted *C.gchar
|
|
var carg3 *C.GstControlSource // in, none, converted
|
|
var carg4 *C.GstControlSource // in, none, converted
|
|
var carg5 *C.GstControlSource // in, none, converted
|
|
var carg6 *C.GstControlSource // in, none, converted
|
|
var cret *C.GstControlBinding // return, none, converted
|
|
|
|
carg1 = (*C.GstObject)(gst.UnsafeObjectToGlibNone(object))
|
|
carg2 = (*C.gchar)(unsafe.Pointer(C.CString(propertyName)))
|
|
defer C.free(unsafe.Pointer(carg2))
|
|
carg3 = (*C.GstControlSource)(gst.UnsafeControlSourceToGlibNone(csA))
|
|
carg4 = (*C.GstControlSource)(gst.UnsafeControlSourceToGlibNone(csR))
|
|
carg5 = (*C.GstControlSource)(gst.UnsafeControlSourceToGlibNone(csG))
|
|
carg6 = (*C.GstControlSource)(gst.UnsafeControlSourceToGlibNone(csB))
|
|
|
|
cret = C.gst_argb_control_binding_new(carg1, carg2, carg3, carg4, carg5, carg6)
|
|
runtime.KeepAlive(object)
|
|
runtime.KeepAlive(propertyName)
|
|
runtime.KeepAlive(csA)
|
|
runtime.KeepAlive(csR)
|
|
runtime.KeepAlive(csG)
|
|
runtime.KeepAlive(csB)
|
|
|
|
var goret gst.ControlBinding
|
|
|
|
goret = gst.UnsafeControlBindingFromGlibNone(unsafe.Pointer(cret))
|
|
|
|
return goret
|
|
}
|
|
|
|
// DirectControlBindingInstance is the instance type used by all types extending GstDirectControlBinding. It is used internally by the bindings. Users should use the interface [DirectControlBinding] instead.
|
|
type DirectControlBindingInstance struct {
|
|
_ [0]func() // equal guard
|
|
gst.ControlBindingInstance
|
|
}
|
|
|
|
var _ DirectControlBinding = (*DirectControlBindingInstance)(nil)
|
|
|
|
// DirectControlBinding wraps GstDirectControlBinding
|
|
//
|
|
// A value mapping object that attaches control sources to gobject properties. It
|
|
// will map the control values directly to the target property range. If a
|
|
// non-absolute direct control binding is used, the value range [0.0 ... 1.0]
|
|
// is mapped to full target property range, and all values outside the range
|
|
// will be clipped. An absolute control binding will not do any value
|
|
// transformations.
|
|
type DirectControlBinding interface {
|
|
gst.ControlBinding
|
|
upcastToGstDirectControlBinding() *DirectControlBindingInstance
|
|
}
|
|
|
|
func unsafeWrapDirectControlBinding(base *gobject.ObjectInstance) *DirectControlBindingInstance {
|
|
return &DirectControlBindingInstance{
|
|
ControlBindingInstance: gst.ControlBindingInstance{
|
|
ObjectInstance: gst.ObjectInstance{
|
|
InitiallyUnownedInstance: gobject.InitiallyUnownedInstance{
|
|
ObjectInstance: *base,
|
|
},
|
|
},
|
|
},
|
|
}
|
|
}
|
|
|
|
func marshalDirectControlBindingInstance(p unsafe.Pointer) (any, error) {
|
|
return unsafeWrapDirectControlBinding(gobject.ValueFromNative(p).Object()), nil
|
|
}
|
|
|
|
// UnsafeDirectControlBindingFromGlibNone is used to convert raw GstDirectControlBinding pointers to go while taking a reference and attaching a finalizer. This is used by the bindings internally.
|
|
func UnsafeDirectControlBindingFromGlibNone(c unsafe.Pointer) DirectControlBinding {
|
|
return gobject.UnsafeObjectFromGlibNone(c).(DirectControlBinding)
|
|
}
|
|
|
|
// UnsafeDirectControlBindingFromGlibFull is used to convert raw GstDirectControlBinding pointers to go while attaching a finalizer. This is used by the bindings internally.
|
|
func UnsafeDirectControlBindingFromGlibFull(c unsafe.Pointer) DirectControlBinding {
|
|
return gobject.UnsafeObjectFromGlibFull(c).(DirectControlBinding)
|
|
}
|
|
|
|
func (d *DirectControlBindingInstance) upcastToGstDirectControlBinding() *DirectControlBindingInstance {
|
|
return d
|
|
}
|
|
|
|
// UnsafeDirectControlBindingToGlibNone is used to convert the instance to it's C value GstDirectControlBinding. This is used by the bindings internally.
|
|
func UnsafeDirectControlBindingToGlibNone(c DirectControlBinding) unsafe.Pointer {
|
|
return gobject.UnsafeObjectToGlibNone(c)
|
|
}
|
|
|
|
// UnsafeDirectControlBindingToGlibFull is used to convert the instance to it's C value GstDirectControlBinding, while removeing the finalizer. This is used by the bindings internally.
|
|
func UnsafeDirectControlBindingToGlibFull(c DirectControlBinding) unsafe.Pointer {
|
|
return gobject.UnsafeObjectToGlibFull(c)
|
|
}
|
|
|
|
// NewDirectControlBinding wraps gst_direct_control_binding_new
|
|
//
|
|
// The function takes the following parameters:
|
|
//
|
|
// - object gst.Object: the object of the property
|
|
// - propertyName string: the property-name to attach the control source
|
|
// - cs gst.ControlSource: the control source
|
|
//
|
|
// The function returns the following values:
|
|
//
|
|
// - goret gst.ControlBinding
|
|
//
|
|
// Create a new control-binding that attaches the #GstControlSource to the
|
|
// #GObject property. It will map the control source range [0.0 ... 1.0] to
|
|
// the full target property range, and clip all values outside this range.
|
|
func NewDirectControlBinding(object gst.Object, propertyName string, cs gst.ControlSource) gst.ControlBinding {
|
|
var carg1 *C.GstObject // in, none, converted
|
|
var carg2 *C.gchar // in, none, string, casted *C.gchar
|
|
var carg3 *C.GstControlSource // in, none, converted
|
|
var cret *C.GstControlBinding // return, none, converted
|
|
|
|
carg1 = (*C.GstObject)(gst.UnsafeObjectToGlibNone(object))
|
|
carg2 = (*C.gchar)(unsafe.Pointer(C.CString(propertyName)))
|
|
defer C.free(unsafe.Pointer(carg2))
|
|
carg3 = (*C.GstControlSource)(gst.UnsafeControlSourceToGlibNone(cs))
|
|
|
|
cret = C.gst_direct_control_binding_new(carg1, carg2, carg3)
|
|
runtime.KeepAlive(object)
|
|
runtime.KeepAlive(propertyName)
|
|
runtime.KeepAlive(cs)
|
|
|
|
var goret gst.ControlBinding
|
|
|
|
goret = gst.UnsafeControlBindingFromGlibNone(unsafe.Pointer(cret))
|
|
|
|
return goret
|
|
}
|
|
|
|
// NewDirectControlBindingAbsolute wraps gst_direct_control_binding_new_absolute
|
|
//
|
|
// The function takes the following parameters:
|
|
//
|
|
// - object gst.Object: the object of the property
|
|
// - propertyName string: the property-name to attach the control source
|
|
// - cs gst.ControlSource: the control source
|
|
//
|
|
// The function returns the following values:
|
|
//
|
|
// - goret gst.ControlBinding
|
|
//
|
|
// Create a new control-binding that attaches the #GstControlSource to the
|
|
// #GObject property. It will directly map the control source values to the
|
|
// target property range without any transformations.
|
|
func NewDirectControlBindingAbsolute(object gst.Object, propertyName string, cs gst.ControlSource) gst.ControlBinding {
|
|
var carg1 *C.GstObject // in, none, converted
|
|
var carg2 *C.gchar // in, none, string, casted *C.gchar
|
|
var carg3 *C.GstControlSource // in, none, converted
|
|
var cret *C.GstControlBinding // return, none, converted
|
|
|
|
carg1 = (*C.GstObject)(gst.UnsafeObjectToGlibNone(object))
|
|
carg2 = (*C.gchar)(unsafe.Pointer(C.CString(propertyName)))
|
|
defer C.free(unsafe.Pointer(carg2))
|
|
carg3 = (*C.GstControlSource)(gst.UnsafeControlSourceToGlibNone(cs))
|
|
|
|
cret = C.gst_direct_control_binding_new_absolute(carg1, carg2, carg3)
|
|
runtime.KeepAlive(object)
|
|
runtime.KeepAlive(propertyName)
|
|
runtime.KeepAlive(cs)
|
|
|
|
var goret gst.ControlBinding
|
|
|
|
goret = gst.UnsafeControlBindingFromGlibNone(unsafe.Pointer(cret))
|
|
|
|
return goret
|
|
}
|
|
|
|
// LFOControlSourceInstance is the instance type used by all types extending GstLFOControlSource. It is used internally by the bindings. Users should use the interface [LFOControlSource] instead.
|
|
type LFOControlSourceInstance struct {
|
|
_ [0]func() // equal guard
|
|
gst.ControlSourceInstance
|
|
}
|
|
|
|
var _ LFOControlSource = (*LFOControlSourceInstance)(nil)
|
|
|
|
// LFOControlSource wraps GstLFOControlSource
|
|
//
|
|
// #GstLFOControlSource is a #GstControlSource, that provides several periodic
|
|
// waveforms as control values.
|
|
//
|
|
// To use #GstLFOControlSource get a new instance by calling
|
|
// gst_lfo_control_source_new(), bind it to a #GParamSpec and set the relevant
|
|
// properties.
|
|
//
|
|
// All functions are MT-safe.
|
|
type LFOControlSource interface {
|
|
gst.ControlSource
|
|
upcastToGstLFOControlSource() *LFOControlSourceInstance
|
|
}
|
|
|
|
func unsafeWrapLFOControlSource(base *gobject.ObjectInstance) *LFOControlSourceInstance {
|
|
return &LFOControlSourceInstance{
|
|
ControlSourceInstance: gst.ControlSourceInstance{
|
|
ObjectInstance: gst.ObjectInstance{
|
|
InitiallyUnownedInstance: gobject.InitiallyUnownedInstance{
|
|
ObjectInstance: *base,
|
|
},
|
|
},
|
|
},
|
|
}
|
|
}
|
|
|
|
func marshalLFOControlSourceInstance(p unsafe.Pointer) (any, error) {
|
|
return unsafeWrapLFOControlSource(gobject.ValueFromNative(p).Object()), nil
|
|
}
|
|
|
|
// UnsafeLFOControlSourceFromGlibNone is used to convert raw GstLFOControlSource pointers to go while taking a reference and attaching a finalizer. This is used by the bindings internally.
|
|
func UnsafeLFOControlSourceFromGlibNone(c unsafe.Pointer) LFOControlSource {
|
|
return gobject.UnsafeObjectFromGlibNone(c).(LFOControlSource)
|
|
}
|
|
|
|
// UnsafeLFOControlSourceFromGlibFull is used to convert raw GstLFOControlSource pointers to go while attaching a finalizer. This is used by the bindings internally.
|
|
func UnsafeLFOControlSourceFromGlibFull(c unsafe.Pointer) LFOControlSource {
|
|
return gobject.UnsafeObjectFromGlibFull(c).(LFOControlSource)
|
|
}
|
|
|
|
func (l *LFOControlSourceInstance) upcastToGstLFOControlSource() *LFOControlSourceInstance {
|
|
return l
|
|
}
|
|
|
|
// UnsafeLFOControlSourceToGlibNone is used to convert the instance to it's C value GstLFOControlSource. This is used by the bindings internally.
|
|
func UnsafeLFOControlSourceToGlibNone(c LFOControlSource) unsafe.Pointer {
|
|
return gobject.UnsafeObjectToGlibNone(c)
|
|
}
|
|
|
|
// UnsafeLFOControlSourceToGlibFull is used to convert the instance to it's C value GstLFOControlSource, while removeing the finalizer. This is used by the bindings internally.
|
|
func UnsafeLFOControlSourceToGlibFull(c LFOControlSource) unsafe.Pointer {
|
|
return gobject.UnsafeObjectToGlibFull(c)
|
|
}
|
|
|
|
// NewLFOControlSource wraps gst_lfo_control_source_new
|
|
// The function returns the following values:
|
|
//
|
|
// - goret gst.ControlSource
|
|
//
|
|
// This returns a new, unbound #GstLFOControlSource.
|
|
func NewLFOControlSource() gst.ControlSource {
|
|
var cret *C.GstControlSource // return, full, converted
|
|
|
|
cret = C.gst_lfo_control_source_new()
|
|
|
|
var goret gst.ControlSource
|
|
|
|
goret = gst.UnsafeControlSourceFromGlibFull(unsafe.Pointer(cret))
|
|
|
|
return goret
|
|
}
|
|
|
|
// ProxyControlBindingInstance is the instance type used by all types extending GstProxyControlBinding. It is used internally by the bindings. Users should use the interface [ProxyControlBinding] instead.
|
|
type ProxyControlBindingInstance struct {
|
|
_ [0]func() // equal guard
|
|
gst.ControlBindingInstance
|
|
}
|
|
|
|
var _ ProxyControlBinding = (*ProxyControlBindingInstance)(nil)
|
|
|
|
// ProxyControlBinding wraps GstProxyControlBinding
|
|
//
|
|
// A #GstControlBinding that forwards requests to another #GstControlBinding
|
|
type ProxyControlBinding interface {
|
|
gst.ControlBinding
|
|
upcastToGstProxyControlBinding() *ProxyControlBindingInstance
|
|
}
|
|
|
|
func unsafeWrapProxyControlBinding(base *gobject.ObjectInstance) *ProxyControlBindingInstance {
|
|
return &ProxyControlBindingInstance{
|
|
ControlBindingInstance: gst.ControlBindingInstance{
|
|
ObjectInstance: gst.ObjectInstance{
|
|
InitiallyUnownedInstance: gobject.InitiallyUnownedInstance{
|
|
ObjectInstance: *base,
|
|
},
|
|
},
|
|
},
|
|
}
|
|
}
|
|
|
|
func marshalProxyControlBindingInstance(p unsafe.Pointer) (any, error) {
|
|
return unsafeWrapProxyControlBinding(gobject.ValueFromNative(p).Object()), nil
|
|
}
|
|
|
|
// UnsafeProxyControlBindingFromGlibNone is used to convert raw GstProxyControlBinding pointers to go while taking a reference and attaching a finalizer. This is used by the bindings internally.
|
|
func UnsafeProxyControlBindingFromGlibNone(c unsafe.Pointer) ProxyControlBinding {
|
|
return gobject.UnsafeObjectFromGlibNone(c).(ProxyControlBinding)
|
|
}
|
|
|
|
// UnsafeProxyControlBindingFromGlibFull is used to convert raw GstProxyControlBinding pointers to go while attaching a finalizer. This is used by the bindings internally.
|
|
func UnsafeProxyControlBindingFromGlibFull(c unsafe.Pointer) ProxyControlBinding {
|
|
return gobject.UnsafeObjectFromGlibFull(c).(ProxyControlBinding)
|
|
}
|
|
|
|
func (p *ProxyControlBindingInstance) upcastToGstProxyControlBinding() *ProxyControlBindingInstance {
|
|
return p
|
|
}
|
|
|
|
// UnsafeProxyControlBindingToGlibNone is used to convert the instance to it's C value GstProxyControlBinding. This is used by the bindings internally.
|
|
func UnsafeProxyControlBindingToGlibNone(c ProxyControlBinding) unsafe.Pointer {
|
|
return gobject.UnsafeObjectToGlibNone(c)
|
|
}
|
|
|
|
// UnsafeProxyControlBindingToGlibFull is used to convert the instance to it's C value GstProxyControlBinding, while removeing the finalizer. This is used by the bindings internally.
|
|
func UnsafeProxyControlBindingToGlibFull(c ProxyControlBinding) unsafe.Pointer {
|
|
return gobject.UnsafeObjectToGlibFull(c)
|
|
}
|
|
|
|
// NewProxyControlBinding wraps gst_proxy_control_binding_new
|
|
//
|
|
// The function takes the following parameters:
|
|
//
|
|
// - object gst.Object: a #GstObject
|
|
// - propertyName string: the property name in @object to control
|
|
// - refObject gst.Object: a #GstObject to forward all
|
|
// #GstControlBinding requests to
|
|
// - refPropertyName string: the property_name in @ref_object to control
|
|
//
|
|
// The function returns the following values:
|
|
//
|
|
// - goret gst.ControlBinding
|
|
//
|
|
// #GstProxyControlBinding forwards all access to data or `sync_values()`
|
|
// requests from @property_name on @object to the control binding at
|
|
// @ref_property_name on @ref_object.
|
|
func NewProxyControlBinding(object gst.Object, propertyName string, refObject gst.Object, refPropertyName string) gst.ControlBinding {
|
|
var carg1 *C.GstObject // in, none, converted
|
|
var carg2 *C.gchar // in, none, string, casted *C.gchar
|
|
var carg3 *C.GstObject // in, none, converted
|
|
var carg4 *C.gchar // in, none, string, casted *C.gchar
|
|
var cret *C.GstControlBinding // return, none, converted
|
|
|
|
carg1 = (*C.GstObject)(gst.UnsafeObjectToGlibNone(object))
|
|
carg2 = (*C.gchar)(unsafe.Pointer(C.CString(propertyName)))
|
|
defer C.free(unsafe.Pointer(carg2))
|
|
carg3 = (*C.GstObject)(gst.UnsafeObjectToGlibNone(refObject))
|
|
carg4 = (*C.gchar)(unsafe.Pointer(C.CString(refPropertyName)))
|
|
defer C.free(unsafe.Pointer(carg4))
|
|
|
|
cret = C.gst_proxy_control_binding_new(carg1, carg2, carg3, carg4)
|
|
runtime.KeepAlive(object)
|
|
runtime.KeepAlive(propertyName)
|
|
runtime.KeepAlive(refObject)
|
|
runtime.KeepAlive(refPropertyName)
|
|
|
|
var goret gst.ControlBinding
|
|
|
|
goret = gst.UnsafeControlBindingFromGlibNone(unsafe.Pointer(cret))
|
|
|
|
return goret
|
|
}
|
|
|
|
// TimedValueControlSourceInstance is the instance type used by all types extending GstTimedValueControlSource. It is used internally by the bindings. Users should use the interface [TimedValueControlSource] instead.
|
|
type TimedValueControlSourceInstance struct {
|
|
_ [0]func() // equal guard
|
|
gst.ControlSourceInstance
|
|
}
|
|
|
|
var _ TimedValueControlSource = (*TimedValueControlSourceInstance)(nil)
|
|
|
|
// TimedValueControlSource wraps GstTimedValueControlSource
|
|
//
|
|
// Base class for #GstControlSource that use time-stamped values.
|
|
//
|
|
// When overriding bind, chain up first to give this bind implementation a
|
|
// chance to setup things.
|
|
//
|
|
// All functions are MT-safe.
|
|
type TimedValueControlSource interface {
|
|
gst.ControlSource
|
|
upcastToGstTimedValueControlSource() *TimedValueControlSourceInstance
|
|
|
|
// FindControlPointIter wraps gst_timed_value_control_source_find_control_point_iter
|
|
//
|
|
// The function takes the following parameters:
|
|
//
|
|
// - timestamp gst.ClockTime: the search key
|
|
//
|
|
// The function returns the following values:
|
|
//
|
|
// - goret *glib.SequenceIter
|
|
//
|
|
// Find last value before given timestamp in control point list.
|
|
// If all values in the control point list come after the given
|
|
// timestamp or no values exist, %NULL is returned.
|
|
//
|
|
// For use in control source implementations.
|
|
FindControlPointIter(gst.ClockTime) *glib.SequenceIter
|
|
// GetCount wraps gst_timed_value_control_source_get_count
|
|
// The function returns the following values:
|
|
//
|
|
// - goret int
|
|
//
|
|
// Get the number of control points that are set.
|
|
GetCount() int
|
|
// Set wraps gst_timed_value_control_source_set
|
|
//
|
|
// The function takes the following parameters:
|
|
//
|
|
// - timestamp gst.ClockTime: the time the control-change is scheduled for
|
|
// - value float64: the control-value
|
|
//
|
|
// The function returns the following values:
|
|
//
|
|
// - goret bool
|
|
//
|
|
// Set the value of given controller-handled property at a certain time.
|
|
Set(gst.ClockTime, float64) bool
|
|
// Unset wraps gst_timed_value_control_source_unset
|
|
//
|
|
// The function takes the following parameters:
|
|
//
|
|
// - timestamp gst.ClockTime: the time the control-change should be removed from
|
|
//
|
|
// The function returns the following values:
|
|
//
|
|
// - goret bool
|
|
//
|
|
// Used to remove the value of given controller-handled property at a certain
|
|
// time.
|
|
Unset(gst.ClockTime) bool
|
|
// UnsetAll wraps gst_timed_value_control_source_unset_all
|
|
//
|
|
// Used to remove all time-stamped values of given controller-handled property
|
|
UnsetAll()
|
|
}
|
|
|
|
func unsafeWrapTimedValueControlSource(base *gobject.ObjectInstance) *TimedValueControlSourceInstance {
|
|
return &TimedValueControlSourceInstance{
|
|
ControlSourceInstance: gst.ControlSourceInstance{
|
|
ObjectInstance: gst.ObjectInstance{
|
|
InitiallyUnownedInstance: gobject.InitiallyUnownedInstance{
|
|
ObjectInstance: *base,
|
|
},
|
|
},
|
|
},
|
|
}
|
|
}
|
|
|
|
func marshalTimedValueControlSourceInstance(p unsafe.Pointer) (any, error) {
|
|
return unsafeWrapTimedValueControlSource(gobject.ValueFromNative(p).Object()), nil
|
|
}
|
|
|
|
// UnsafeTimedValueControlSourceFromGlibNone is used to convert raw GstTimedValueControlSource pointers to go while taking a reference and attaching a finalizer. This is used by the bindings internally.
|
|
func UnsafeTimedValueControlSourceFromGlibNone(c unsafe.Pointer) TimedValueControlSource {
|
|
return gobject.UnsafeObjectFromGlibNone(c).(TimedValueControlSource)
|
|
}
|
|
|
|
// UnsafeTimedValueControlSourceFromGlibFull is used to convert raw GstTimedValueControlSource pointers to go while attaching a finalizer. This is used by the bindings internally.
|
|
func UnsafeTimedValueControlSourceFromGlibFull(c unsafe.Pointer) TimedValueControlSource {
|
|
return gobject.UnsafeObjectFromGlibFull(c).(TimedValueControlSource)
|
|
}
|
|
|
|
func (t *TimedValueControlSourceInstance) upcastToGstTimedValueControlSource() *TimedValueControlSourceInstance {
|
|
return t
|
|
}
|
|
|
|
// UnsafeTimedValueControlSourceToGlibNone is used to convert the instance to it's C value GstTimedValueControlSource. This is used by the bindings internally.
|
|
func UnsafeTimedValueControlSourceToGlibNone(c TimedValueControlSource) unsafe.Pointer {
|
|
return gobject.UnsafeObjectToGlibNone(c)
|
|
}
|
|
|
|
// UnsafeTimedValueControlSourceToGlibFull is used to convert the instance to it's C value GstTimedValueControlSource, while removeing the finalizer. This is used by the bindings internally.
|
|
func UnsafeTimedValueControlSourceToGlibFull(c TimedValueControlSource) unsafe.Pointer {
|
|
return gobject.UnsafeObjectToGlibFull(c)
|
|
}
|
|
|
|
// FindControlPointIter wraps gst_timed_value_control_source_find_control_point_iter
|
|
//
|
|
// The function takes the following parameters:
|
|
//
|
|
// - timestamp gst.ClockTime: the search key
|
|
//
|
|
// The function returns the following values:
|
|
//
|
|
// - goret *glib.SequenceIter
|
|
//
|
|
// Find last value before given timestamp in control point list.
|
|
// If all values in the control point list come after the given
|
|
// timestamp or no values exist, %NULL is returned.
|
|
//
|
|
// For use in control source implementations.
|
|
func (self *TimedValueControlSourceInstance) FindControlPointIter(timestamp gst.ClockTime) *glib.SequenceIter {
|
|
var carg0 *C.GstTimedValueControlSource // in, none, converted
|
|
var carg1 C.GstClockTime // in, none, casted, alias
|
|
var cret *C.GSequenceIter // return, none, converted
|
|
|
|
carg0 = (*C.GstTimedValueControlSource)(UnsafeTimedValueControlSourceToGlibNone(self))
|
|
carg1 = C.GstClockTime(timestamp)
|
|
|
|
cret = C.gst_timed_value_control_source_find_control_point_iter(carg0, carg1)
|
|
runtime.KeepAlive(self)
|
|
runtime.KeepAlive(timestamp)
|
|
|
|
var goret *glib.SequenceIter
|
|
|
|
goret = glib.UnsafeSequenceIterFromGlibNone(unsafe.Pointer(cret))
|
|
|
|
return goret
|
|
}
|
|
|
|
// GetCount wraps gst_timed_value_control_source_get_count
|
|
// The function returns the following values:
|
|
//
|
|
// - goret int
|
|
//
|
|
// Get the number of control points that are set.
|
|
func (self *TimedValueControlSourceInstance) GetCount() int {
|
|
var carg0 *C.GstTimedValueControlSource // in, none, converted
|
|
var cret C.gint // return, none, casted
|
|
|
|
carg0 = (*C.GstTimedValueControlSource)(UnsafeTimedValueControlSourceToGlibNone(self))
|
|
|
|
cret = C.gst_timed_value_control_source_get_count(carg0)
|
|
runtime.KeepAlive(self)
|
|
|
|
var goret int
|
|
|
|
goret = int(cret)
|
|
|
|
return goret
|
|
}
|
|
|
|
// Set wraps gst_timed_value_control_source_set
|
|
//
|
|
// The function takes the following parameters:
|
|
//
|
|
// - timestamp gst.ClockTime: the time the control-change is scheduled for
|
|
// - value float64: the control-value
|
|
//
|
|
// The function returns the following values:
|
|
//
|
|
// - goret bool
|
|
//
|
|
// Set the value of given controller-handled property at a certain time.
|
|
func (self *TimedValueControlSourceInstance) Set(timestamp gst.ClockTime, value float64) bool {
|
|
var carg0 *C.GstTimedValueControlSource // in, none, converted
|
|
var carg1 C.GstClockTime // in, none, casted, alias
|
|
var carg2 C.gdouble // in, none, casted
|
|
var cret C.gboolean // return
|
|
|
|
carg0 = (*C.GstTimedValueControlSource)(UnsafeTimedValueControlSourceToGlibNone(self))
|
|
carg1 = C.GstClockTime(timestamp)
|
|
carg2 = C.gdouble(value)
|
|
|
|
cret = C.gst_timed_value_control_source_set(carg0, carg1, carg2)
|
|
runtime.KeepAlive(self)
|
|
runtime.KeepAlive(timestamp)
|
|
runtime.KeepAlive(value)
|
|
|
|
var goret bool
|
|
|
|
if cret != 0 {
|
|
goret = true
|
|
}
|
|
|
|
return goret
|
|
}
|
|
|
|
// Unset wraps gst_timed_value_control_source_unset
|
|
//
|
|
// The function takes the following parameters:
|
|
//
|
|
// - timestamp gst.ClockTime: the time the control-change should be removed from
|
|
//
|
|
// The function returns the following values:
|
|
//
|
|
// - goret bool
|
|
//
|
|
// Used to remove the value of given controller-handled property at a certain
|
|
// time.
|
|
func (self *TimedValueControlSourceInstance) Unset(timestamp gst.ClockTime) bool {
|
|
var carg0 *C.GstTimedValueControlSource // in, none, converted
|
|
var carg1 C.GstClockTime // in, none, casted, alias
|
|
var cret C.gboolean // return
|
|
|
|
carg0 = (*C.GstTimedValueControlSource)(UnsafeTimedValueControlSourceToGlibNone(self))
|
|
carg1 = C.GstClockTime(timestamp)
|
|
|
|
cret = C.gst_timed_value_control_source_unset(carg0, carg1)
|
|
runtime.KeepAlive(self)
|
|
runtime.KeepAlive(timestamp)
|
|
|
|
var goret bool
|
|
|
|
if cret != 0 {
|
|
goret = true
|
|
}
|
|
|
|
return goret
|
|
}
|
|
|
|
// UnsetAll wraps gst_timed_value_control_source_unset_all
|
|
//
|
|
// Used to remove all time-stamped values of given controller-handled property
|
|
func (self *TimedValueControlSourceInstance) UnsetAll() {
|
|
var carg0 *C.GstTimedValueControlSource // in, none, converted
|
|
|
|
carg0 = (*C.GstTimedValueControlSource)(UnsafeTimedValueControlSourceToGlibNone(self))
|
|
|
|
C.gst_timed_value_control_source_unset_all(carg0)
|
|
runtime.KeepAlive(self)
|
|
}
|
|
|
|
// TriggerControlSourceInstance is the instance type used by all types extending GstTriggerControlSource. It is used internally by the bindings. Users should use the interface [TriggerControlSource] instead.
|
|
type TriggerControlSourceInstance struct {
|
|
_ [0]func() // equal guard
|
|
TimedValueControlSourceInstance
|
|
}
|
|
|
|
var _ TriggerControlSource = (*TriggerControlSourceInstance)(nil)
|
|
|
|
// TriggerControlSource wraps GstTriggerControlSource
|
|
//
|
|
// #GstTriggerControlSource is a #GstControlSource, that returns values from user-given
|
|
// control points. It allows for a tolerance on the time-stamps.
|
|
//
|
|
// To use #GstTriggerControlSource get a new instance by calling
|
|
// gst_trigger_control_source_new(), bind it to a #GParamSpec and set some
|
|
// control points by calling gst_timed_value_control_source_set().
|
|
//
|
|
// All functions are MT-safe.
|
|
type TriggerControlSource interface {
|
|
TimedValueControlSource
|
|
upcastToGstTriggerControlSource() *TriggerControlSourceInstance
|
|
}
|
|
|
|
func unsafeWrapTriggerControlSource(base *gobject.ObjectInstance) *TriggerControlSourceInstance {
|
|
return &TriggerControlSourceInstance{
|
|
TimedValueControlSourceInstance: TimedValueControlSourceInstance{
|
|
ControlSourceInstance: gst.ControlSourceInstance{
|
|
ObjectInstance: gst.ObjectInstance{
|
|
InitiallyUnownedInstance: gobject.InitiallyUnownedInstance{
|
|
ObjectInstance: *base,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
}
|
|
}
|
|
|
|
func marshalTriggerControlSourceInstance(p unsafe.Pointer) (any, error) {
|
|
return unsafeWrapTriggerControlSource(gobject.ValueFromNative(p).Object()), nil
|
|
}
|
|
|
|
// UnsafeTriggerControlSourceFromGlibNone is used to convert raw GstTriggerControlSource pointers to go while taking a reference and attaching a finalizer. This is used by the bindings internally.
|
|
func UnsafeTriggerControlSourceFromGlibNone(c unsafe.Pointer) TriggerControlSource {
|
|
return gobject.UnsafeObjectFromGlibNone(c).(TriggerControlSource)
|
|
}
|
|
|
|
// UnsafeTriggerControlSourceFromGlibFull is used to convert raw GstTriggerControlSource pointers to go while attaching a finalizer. This is used by the bindings internally.
|
|
func UnsafeTriggerControlSourceFromGlibFull(c unsafe.Pointer) TriggerControlSource {
|
|
return gobject.UnsafeObjectFromGlibFull(c).(TriggerControlSource)
|
|
}
|
|
|
|
func (t *TriggerControlSourceInstance) upcastToGstTriggerControlSource() *TriggerControlSourceInstance {
|
|
return t
|
|
}
|
|
|
|
// UnsafeTriggerControlSourceToGlibNone is used to convert the instance to it's C value GstTriggerControlSource. This is used by the bindings internally.
|
|
func UnsafeTriggerControlSourceToGlibNone(c TriggerControlSource) unsafe.Pointer {
|
|
return gobject.UnsafeObjectToGlibNone(c)
|
|
}
|
|
|
|
// UnsafeTriggerControlSourceToGlibFull is used to convert the instance to it's C value GstTriggerControlSource, while removeing the finalizer. This is used by the bindings internally.
|
|
func UnsafeTriggerControlSourceToGlibFull(c TriggerControlSource) unsafe.Pointer {
|
|
return gobject.UnsafeObjectToGlibFull(c)
|
|
}
|
|
|
|
// NewTriggerControlSource wraps gst_trigger_control_source_new
|
|
// The function returns the following values:
|
|
//
|
|
// - goret gst.ControlSource
|
|
//
|
|
// This returns a new, unbound #GstTriggerControlSource.
|
|
func NewTriggerControlSource() gst.ControlSource {
|
|
var cret *C.GstControlSource // return, full, converted
|
|
|
|
cret = C.gst_trigger_control_source_new()
|
|
|
|
var goret gst.ControlSource
|
|
|
|
goret = gst.UnsafeControlSourceFromGlibFull(unsafe.Pointer(cret))
|
|
|
|
return goret
|
|
}
|
|
|
|
// InterpolationControlSourceInstance is the instance type used by all types extending GstInterpolationControlSource. It is used internally by the bindings. Users should use the interface [InterpolationControlSource] instead.
|
|
type InterpolationControlSourceInstance struct {
|
|
_ [0]func() // equal guard
|
|
TimedValueControlSourceInstance
|
|
}
|
|
|
|
var _ InterpolationControlSource = (*InterpolationControlSourceInstance)(nil)
|
|
|
|
// InterpolationControlSource wraps GstInterpolationControlSource
|
|
//
|
|
// #GstInterpolationControlSource is a #GstControlSource, that interpolates values between user-given
|
|
// control points. It supports several interpolation modes and property types.
|
|
//
|
|
// To use #GstInterpolationControlSource get a new instance by calling
|
|
// gst_interpolation_control_source_new(), bind it to a #GParamSpec and set some
|
|
// control points by calling gst_timed_value_control_source_set().
|
|
//
|
|
// All functions are MT-safe.
|
|
type InterpolationControlSource interface {
|
|
TimedValueControlSource
|
|
upcastToGstInterpolationControlSource() *InterpolationControlSourceInstance
|
|
}
|
|
|
|
func unsafeWrapInterpolationControlSource(base *gobject.ObjectInstance) *InterpolationControlSourceInstance {
|
|
return &InterpolationControlSourceInstance{
|
|
TimedValueControlSourceInstance: TimedValueControlSourceInstance{
|
|
ControlSourceInstance: gst.ControlSourceInstance{
|
|
ObjectInstance: gst.ObjectInstance{
|
|
InitiallyUnownedInstance: gobject.InitiallyUnownedInstance{
|
|
ObjectInstance: *base,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
}
|
|
}
|
|
|
|
func marshalInterpolationControlSourceInstance(p unsafe.Pointer) (any, error) {
|
|
return unsafeWrapInterpolationControlSource(gobject.ValueFromNative(p).Object()), nil
|
|
}
|
|
|
|
// UnsafeInterpolationControlSourceFromGlibNone is used to convert raw GstInterpolationControlSource pointers to go while taking a reference and attaching a finalizer. This is used by the bindings internally.
|
|
func UnsafeInterpolationControlSourceFromGlibNone(c unsafe.Pointer) InterpolationControlSource {
|
|
return gobject.UnsafeObjectFromGlibNone(c).(InterpolationControlSource)
|
|
}
|
|
|
|
// UnsafeInterpolationControlSourceFromGlibFull is used to convert raw GstInterpolationControlSource pointers to go while attaching a finalizer. This is used by the bindings internally.
|
|
func UnsafeInterpolationControlSourceFromGlibFull(c unsafe.Pointer) InterpolationControlSource {
|
|
return gobject.UnsafeObjectFromGlibFull(c).(InterpolationControlSource)
|
|
}
|
|
|
|
func (i *InterpolationControlSourceInstance) upcastToGstInterpolationControlSource() *InterpolationControlSourceInstance {
|
|
return i
|
|
}
|
|
|
|
// UnsafeInterpolationControlSourceToGlibNone is used to convert the instance to it's C value GstInterpolationControlSource. This is used by the bindings internally.
|
|
func UnsafeInterpolationControlSourceToGlibNone(c InterpolationControlSource) unsafe.Pointer {
|
|
return gobject.UnsafeObjectToGlibNone(c)
|
|
}
|
|
|
|
// UnsafeInterpolationControlSourceToGlibFull is used to convert the instance to it's C value GstInterpolationControlSource, while removeing the finalizer. This is used by the bindings internally.
|
|
func UnsafeInterpolationControlSourceToGlibFull(c InterpolationControlSource) unsafe.Pointer {
|
|
return gobject.UnsafeObjectToGlibFull(c)
|
|
}
|
|
|
|
// NewInterpolationControlSource wraps gst_interpolation_control_source_new
|
|
// The function returns the following values:
|
|
//
|
|
// - goret gst.ControlSource
|
|
//
|
|
// This returns a new, unbound #GstInterpolationControlSource.
|
|
func NewInterpolationControlSource() gst.ControlSource {
|
|
var cret *C.GstControlSource // return, full, converted
|
|
|
|
cret = C.gst_interpolation_control_source_new()
|
|
|
|
var goret gst.ControlSource
|
|
|
|
goret = gst.UnsafeControlSourceFromGlibFull(unsafe.Pointer(cret))
|
|
|
|
return goret
|
|
}
|
|
|
|
// ARGBControlBindingClass wraps GstARGBControlBindingClass
|
|
//
|
|
// The class structure of #GstARGBControlBinding.
|
|
type ARGBControlBindingClass struct {
|
|
*argbControlBindingClass
|
|
}
|
|
|
|
// argbControlBindingClass is the struct that's finalized
|
|
type argbControlBindingClass struct {
|
|
native *C.GstARGBControlBindingClass
|
|
}
|
|
|
|
// UnsafeARGBControlBindingClassFromGlibBorrow is used to convert raw C.GstARGBControlBindingClass pointers to go. This is used by the bindings internally.
|
|
func UnsafeARGBControlBindingClassFromGlibBorrow(p unsafe.Pointer) *ARGBControlBindingClass {
|
|
return &ARGBControlBindingClass{&argbControlBindingClass{(*C.GstARGBControlBindingClass)(p)}}
|
|
}
|
|
|
|
// UnsafeARGBControlBindingClassFromGlibNone is used to convert raw C.GstARGBControlBindingClass pointers to go while taking a reference. This is used by the bindings internally.
|
|
func UnsafeARGBControlBindingClassFromGlibNone(p unsafe.Pointer) *ARGBControlBindingClass {
|
|
// FIXME: this has no ref function, what should we do here?
|
|
wrapped := UnsafeARGBControlBindingClassFromGlibBorrow(p)
|
|
runtime.SetFinalizer(
|
|
wrapped.argbControlBindingClass,
|
|
func (intern *argbControlBindingClass) {
|
|
C.free(unsafe.Pointer(intern.native))
|
|
},
|
|
)
|
|
return wrapped
|
|
}
|
|
|
|
// UnsafeARGBControlBindingClassFromGlibFull is used to convert raw C.GstARGBControlBindingClass pointers to go while taking a reference. This is used by the bindings internally.
|
|
func UnsafeARGBControlBindingClassFromGlibFull(p unsafe.Pointer) *ARGBControlBindingClass {
|
|
wrapped := UnsafeARGBControlBindingClassFromGlibBorrow(p)
|
|
runtime.SetFinalizer(
|
|
wrapped.argbControlBindingClass,
|
|
func (intern *argbControlBindingClass) {
|
|
C.free(unsafe.Pointer(intern.native))
|
|
},
|
|
)
|
|
return wrapped
|
|
}
|
|
|
|
// UnsafeARGBControlBindingClassFree unrefs/frees the underlying resource. This is used by the bindings internally.
|
|
//
|
|
// After this is called, no other method on [ARGBControlBindingClass] is expected to work anymore.
|
|
func UnsafeARGBControlBindingClassFree(a *ARGBControlBindingClass) {
|
|
C.free(unsafe.Pointer(a.native))
|
|
}
|
|
|
|
// UnsafeARGBControlBindingClassToGlibNone returns the underlying C pointer. This is used by the bindings internally.
|
|
func UnsafeARGBControlBindingClassToGlibNone(a *ARGBControlBindingClass) unsafe.Pointer {
|
|
return unsafe.Pointer(a.native)
|
|
}
|
|
|
|
// UnsafeARGBControlBindingClassToGlibFull returns the underlying C pointer and gives up ownership.
|
|
// This is used by the bindings internally.
|
|
func UnsafeARGBControlBindingClassToGlibFull(a *ARGBControlBindingClass) unsafe.Pointer {
|
|
runtime.SetFinalizer(a.argbControlBindingClass, nil)
|
|
_p := unsafe.Pointer(a.native)
|
|
a.native = nil // ARGBControlBindingClass is invalid from here on
|
|
return _p
|
|
}
|
|
// ControlPoint wraps GstControlPoint
|
|
//
|
|
// An internal structure for value+time and various temporary
|
|
// values used for interpolation. This "inherits" from
|
|
// GstTimedValue.
|
|
type ControlPoint struct {
|
|
*controlPoint
|
|
}
|
|
|
|
// controlPoint is the struct that's finalized
|
|
type controlPoint struct {
|
|
native *C.GstControlPoint
|
|
}
|
|
|
|
var _ gobject.GoValueInitializer = (*ControlPoint)(nil)
|
|
|
|
func marshalControlPoint(p unsafe.Pointer) (interface{}, error) {
|
|
b := gobject.ValueFromNative(p).Boxed()
|
|
return UnsafeControlPointFromGlibBorrow(b), nil
|
|
}
|
|
|
|
func (r *ControlPoint) InitGoValue(v *gobject.Value) {
|
|
v.Init(TypeControlPoint)
|
|
v.SetBoxed(unsafe.Pointer(r.native))
|
|
}
|
|
|
|
// UnsafeControlPointFromGlibBorrow is used to convert raw C.GstControlPoint pointers to go. This is used by the bindings internally.
|
|
func UnsafeControlPointFromGlibBorrow(p unsafe.Pointer) *ControlPoint {
|
|
return &ControlPoint{&controlPoint{(*C.GstControlPoint)(p)}}
|
|
}
|
|
|
|
// UnsafeControlPointFromGlibNone is used to convert raw C.GstControlPoint pointers to go while taking a reference. This is used by the bindings internally.
|
|
func UnsafeControlPointFromGlibNone(p unsafe.Pointer) *ControlPoint {
|
|
// FIXME: this has no ref function, what should we do here?
|
|
wrapped := UnsafeControlPointFromGlibBorrow(p)
|
|
runtime.SetFinalizer(
|
|
wrapped.controlPoint,
|
|
func (intern *controlPoint) {
|
|
C.gst_control_point_free(intern.native)
|
|
},
|
|
)
|
|
return wrapped
|
|
}
|
|
|
|
// UnsafeControlPointFromGlibFull is used to convert raw C.GstControlPoint pointers to go while taking a reference. This is used by the bindings internally.
|
|
func UnsafeControlPointFromGlibFull(p unsafe.Pointer) *ControlPoint {
|
|
wrapped := UnsafeControlPointFromGlibBorrow(p)
|
|
runtime.SetFinalizer(
|
|
wrapped.controlPoint,
|
|
func (intern *controlPoint) {
|
|
C.gst_control_point_free(intern.native)
|
|
},
|
|
)
|
|
return wrapped
|
|
}
|
|
|
|
// UnsafeControlPointFree unrefs/frees the underlying resource. This is used by the bindings internally.
|
|
//
|
|
// After this is called, no other method on [ControlPoint] is expected to work anymore.
|
|
func UnsafeControlPointFree(c *ControlPoint) {
|
|
C.gst_control_point_free(c.native)
|
|
}
|
|
|
|
// UnsafeControlPointToGlibNone returns the underlying C pointer. This is used by the bindings internally.
|
|
func UnsafeControlPointToGlibNone(c *ControlPoint) unsafe.Pointer {
|
|
return unsafe.Pointer(c.native)
|
|
}
|
|
|
|
// UnsafeControlPointToGlibFull returns the underlying C pointer and gives up ownership.
|
|
// This is used by the bindings internally.
|
|
func UnsafeControlPointToGlibFull(c *ControlPoint) unsafe.Pointer {
|
|
runtime.SetFinalizer(c.controlPoint, nil)
|
|
_p := unsafe.Pointer(c.native)
|
|
c.native = nil // ControlPoint is invalid from here on
|
|
return _p
|
|
}
|
|
// Copy wraps gst_control_point_copy
|
|
// The function returns the following values:
|
|
//
|
|
// - goret *ControlPoint
|
|
//
|
|
// Copies a #GstControlPoint
|
|
func (cp *ControlPoint) Copy() *ControlPoint {
|
|
var carg0 *C.GstControlPoint // in, none, converted
|
|
var cret *C.GstControlPoint // return, full, converted
|
|
|
|
carg0 = (*C.GstControlPoint)(UnsafeControlPointToGlibNone(cp))
|
|
|
|
cret = C.gst_control_point_copy(carg0)
|
|
runtime.KeepAlive(cp)
|
|
|
|
var goret *ControlPoint
|
|
|
|
goret = UnsafeControlPointFromGlibFull(unsafe.Pointer(cret))
|
|
|
|
return goret
|
|
}
|
|
|
|
// DirectControlBindingClass wraps GstDirectControlBindingClass
|
|
//
|
|
// The class structure of #GstDirectControlBinding.
|
|
type DirectControlBindingClass struct {
|
|
*directControlBindingClass
|
|
}
|
|
|
|
// directControlBindingClass is the struct that's finalized
|
|
type directControlBindingClass struct {
|
|
native *C.GstDirectControlBindingClass
|
|
}
|
|
|
|
// UnsafeDirectControlBindingClassFromGlibBorrow is used to convert raw C.GstDirectControlBindingClass pointers to go. This is used by the bindings internally.
|
|
func UnsafeDirectControlBindingClassFromGlibBorrow(p unsafe.Pointer) *DirectControlBindingClass {
|
|
return &DirectControlBindingClass{&directControlBindingClass{(*C.GstDirectControlBindingClass)(p)}}
|
|
}
|
|
|
|
// UnsafeDirectControlBindingClassFromGlibNone is used to convert raw C.GstDirectControlBindingClass pointers to go while taking a reference. This is used by the bindings internally.
|
|
func UnsafeDirectControlBindingClassFromGlibNone(p unsafe.Pointer) *DirectControlBindingClass {
|
|
// FIXME: this has no ref function, what should we do here?
|
|
wrapped := UnsafeDirectControlBindingClassFromGlibBorrow(p)
|
|
runtime.SetFinalizer(
|
|
wrapped.directControlBindingClass,
|
|
func (intern *directControlBindingClass) {
|
|
C.free(unsafe.Pointer(intern.native))
|
|
},
|
|
)
|
|
return wrapped
|
|
}
|
|
|
|
// UnsafeDirectControlBindingClassFromGlibFull is used to convert raw C.GstDirectControlBindingClass pointers to go while taking a reference. This is used by the bindings internally.
|
|
func UnsafeDirectControlBindingClassFromGlibFull(p unsafe.Pointer) *DirectControlBindingClass {
|
|
wrapped := UnsafeDirectControlBindingClassFromGlibBorrow(p)
|
|
runtime.SetFinalizer(
|
|
wrapped.directControlBindingClass,
|
|
func (intern *directControlBindingClass) {
|
|
C.free(unsafe.Pointer(intern.native))
|
|
},
|
|
)
|
|
return wrapped
|
|
}
|
|
|
|
// UnsafeDirectControlBindingClassFree unrefs/frees the underlying resource. This is used by the bindings internally.
|
|
//
|
|
// After this is called, no other method on [DirectControlBindingClass] is expected to work anymore.
|
|
func UnsafeDirectControlBindingClassFree(d *DirectControlBindingClass) {
|
|
C.free(unsafe.Pointer(d.native))
|
|
}
|
|
|
|
// UnsafeDirectControlBindingClassToGlibNone returns the underlying C pointer. This is used by the bindings internally.
|
|
func UnsafeDirectControlBindingClassToGlibNone(d *DirectControlBindingClass) unsafe.Pointer {
|
|
return unsafe.Pointer(d.native)
|
|
}
|
|
|
|
// UnsafeDirectControlBindingClassToGlibFull returns the underlying C pointer and gives up ownership.
|
|
// This is used by the bindings internally.
|
|
func UnsafeDirectControlBindingClassToGlibFull(d *DirectControlBindingClass) unsafe.Pointer {
|
|
runtime.SetFinalizer(d.directControlBindingClass, nil)
|
|
_p := unsafe.Pointer(d.native)
|
|
d.native = nil // DirectControlBindingClass is invalid from here on
|
|
return _p
|
|
}
|
|
// InterpolationControlSourceClass wraps GstInterpolationControlSourceClass
|
|
type InterpolationControlSourceClass struct {
|
|
*interpolationControlSourceClass
|
|
}
|
|
|
|
// interpolationControlSourceClass is the struct that's finalized
|
|
type interpolationControlSourceClass struct {
|
|
native *C.GstInterpolationControlSourceClass
|
|
}
|
|
|
|
// UnsafeInterpolationControlSourceClassFromGlibBorrow is used to convert raw C.GstInterpolationControlSourceClass pointers to go. This is used by the bindings internally.
|
|
func UnsafeInterpolationControlSourceClassFromGlibBorrow(p unsafe.Pointer) *InterpolationControlSourceClass {
|
|
return &InterpolationControlSourceClass{&interpolationControlSourceClass{(*C.GstInterpolationControlSourceClass)(p)}}
|
|
}
|
|
|
|
// UnsafeInterpolationControlSourceClassFromGlibNone is used to convert raw C.GstInterpolationControlSourceClass pointers to go while taking a reference. This is used by the bindings internally.
|
|
func UnsafeInterpolationControlSourceClassFromGlibNone(p unsafe.Pointer) *InterpolationControlSourceClass {
|
|
// FIXME: this has no ref function, what should we do here?
|
|
wrapped := UnsafeInterpolationControlSourceClassFromGlibBorrow(p)
|
|
runtime.SetFinalizer(
|
|
wrapped.interpolationControlSourceClass,
|
|
func (intern *interpolationControlSourceClass) {
|
|
C.free(unsafe.Pointer(intern.native))
|
|
},
|
|
)
|
|
return wrapped
|
|
}
|
|
|
|
// UnsafeInterpolationControlSourceClassFromGlibFull is used to convert raw C.GstInterpolationControlSourceClass pointers to go while taking a reference. This is used by the bindings internally.
|
|
func UnsafeInterpolationControlSourceClassFromGlibFull(p unsafe.Pointer) *InterpolationControlSourceClass {
|
|
wrapped := UnsafeInterpolationControlSourceClassFromGlibBorrow(p)
|
|
runtime.SetFinalizer(
|
|
wrapped.interpolationControlSourceClass,
|
|
func (intern *interpolationControlSourceClass) {
|
|
C.free(unsafe.Pointer(intern.native))
|
|
},
|
|
)
|
|
return wrapped
|
|
}
|
|
|
|
// UnsafeInterpolationControlSourceClassFree unrefs/frees the underlying resource. This is used by the bindings internally.
|
|
//
|
|
// After this is called, no other method on [InterpolationControlSourceClass] is expected to work anymore.
|
|
func UnsafeInterpolationControlSourceClassFree(i *InterpolationControlSourceClass) {
|
|
C.free(unsafe.Pointer(i.native))
|
|
}
|
|
|
|
// UnsafeInterpolationControlSourceClassToGlibNone returns the underlying C pointer. This is used by the bindings internally.
|
|
func UnsafeInterpolationControlSourceClassToGlibNone(i *InterpolationControlSourceClass) unsafe.Pointer {
|
|
return unsafe.Pointer(i.native)
|
|
}
|
|
|
|
// UnsafeInterpolationControlSourceClassToGlibFull returns the underlying C pointer and gives up ownership.
|
|
// This is used by the bindings internally.
|
|
func UnsafeInterpolationControlSourceClassToGlibFull(i *InterpolationControlSourceClass) unsafe.Pointer {
|
|
runtime.SetFinalizer(i.interpolationControlSourceClass, nil)
|
|
_p := unsafe.Pointer(i.native)
|
|
i.native = nil // InterpolationControlSourceClass is invalid from here on
|
|
return _p
|
|
}
|
|
// LFOControlSourceClass wraps GstLFOControlSourceClass
|
|
type LFOControlSourceClass struct {
|
|
*lfoControlSourceClass
|
|
}
|
|
|
|
// lfoControlSourceClass is the struct that's finalized
|
|
type lfoControlSourceClass struct {
|
|
native *C.GstLFOControlSourceClass
|
|
}
|
|
|
|
// UnsafeLFOControlSourceClassFromGlibBorrow is used to convert raw C.GstLFOControlSourceClass pointers to go. This is used by the bindings internally.
|
|
func UnsafeLFOControlSourceClassFromGlibBorrow(p unsafe.Pointer) *LFOControlSourceClass {
|
|
return &LFOControlSourceClass{&lfoControlSourceClass{(*C.GstLFOControlSourceClass)(p)}}
|
|
}
|
|
|
|
// UnsafeLFOControlSourceClassFromGlibNone is used to convert raw C.GstLFOControlSourceClass pointers to go while taking a reference. This is used by the bindings internally.
|
|
func UnsafeLFOControlSourceClassFromGlibNone(p unsafe.Pointer) *LFOControlSourceClass {
|
|
// FIXME: this has no ref function, what should we do here?
|
|
wrapped := UnsafeLFOControlSourceClassFromGlibBorrow(p)
|
|
runtime.SetFinalizer(
|
|
wrapped.lfoControlSourceClass,
|
|
func (intern *lfoControlSourceClass) {
|
|
C.free(unsafe.Pointer(intern.native))
|
|
},
|
|
)
|
|
return wrapped
|
|
}
|
|
|
|
// UnsafeLFOControlSourceClassFromGlibFull is used to convert raw C.GstLFOControlSourceClass pointers to go while taking a reference. This is used by the bindings internally.
|
|
func UnsafeLFOControlSourceClassFromGlibFull(p unsafe.Pointer) *LFOControlSourceClass {
|
|
wrapped := UnsafeLFOControlSourceClassFromGlibBorrow(p)
|
|
runtime.SetFinalizer(
|
|
wrapped.lfoControlSourceClass,
|
|
func (intern *lfoControlSourceClass) {
|
|
C.free(unsafe.Pointer(intern.native))
|
|
},
|
|
)
|
|
return wrapped
|
|
}
|
|
|
|
// UnsafeLFOControlSourceClassFree unrefs/frees the underlying resource. This is used by the bindings internally.
|
|
//
|
|
// After this is called, no other method on [LFOControlSourceClass] is expected to work anymore.
|
|
func UnsafeLFOControlSourceClassFree(l *LFOControlSourceClass) {
|
|
C.free(unsafe.Pointer(l.native))
|
|
}
|
|
|
|
// UnsafeLFOControlSourceClassToGlibNone returns the underlying C pointer. This is used by the bindings internally.
|
|
func UnsafeLFOControlSourceClassToGlibNone(l *LFOControlSourceClass) unsafe.Pointer {
|
|
return unsafe.Pointer(l.native)
|
|
}
|
|
|
|
// UnsafeLFOControlSourceClassToGlibFull returns the underlying C pointer and gives up ownership.
|
|
// This is used by the bindings internally.
|
|
func UnsafeLFOControlSourceClassToGlibFull(l *LFOControlSourceClass) unsafe.Pointer {
|
|
runtime.SetFinalizer(l.lfoControlSourceClass, nil)
|
|
_p := unsafe.Pointer(l.native)
|
|
l.native = nil // LFOControlSourceClass is invalid from here on
|
|
return _p
|
|
}
|
|
// ProxyControlBindingClass wraps GstProxyControlBindingClass
|
|
//
|
|
// Opaque #GstProxyControlBindingClass struct
|
|
type ProxyControlBindingClass struct {
|
|
*proxyControlBindingClass
|
|
}
|
|
|
|
// proxyControlBindingClass is the struct that's finalized
|
|
type proxyControlBindingClass struct {
|
|
native *C.GstProxyControlBindingClass
|
|
}
|
|
|
|
// UnsafeProxyControlBindingClassFromGlibBorrow is used to convert raw C.GstProxyControlBindingClass pointers to go. This is used by the bindings internally.
|
|
func UnsafeProxyControlBindingClassFromGlibBorrow(p unsafe.Pointer) *ProxyControlBindingClass {
|
|
return &ProxyControlBindingClass{&proxyControlBindingClass{(*C.GstProxyControlBindingClass)(p)}}
|
|
}
|
|
|
|
// UnsafeProxyControlBindingClassFromGlibNone is used to convert raw C.GstProxyControlBindingClass pointers to go while taking a reference. This is used by the bindings internally.
|
|
func UnsafeProxyControlBindingClassFromGlibNone(p unsafe.Pointer) *ProxyControlBindingClass {
|
|
// FIXME: this has no ref function, what should we do here?
|
|
wrapped := UnsafeProxyControlBindingClassFromGlibBorrow(p)
|
|
runtime.SetFinalizer(
|
|
wrapped.proxyControlBindingClass,
|
|
func (intern *proxyControlBindingClass) {
|
|
C.free(unsafe.Pointer(intern.native))
|
|
},
|
|
)
|
|
return wrapped
|
|
}
|
|
|
|
// UnsafeProxyControlBindingClassFromGlibFull is used to convert raw C.GstProxyControlBindingClass pointers to go while taking a reference. This is used by the bindings internally.
|
|
func UnsafeProxyControlBindingClassFromGlibFull(p unsafe.Pointer) *ProxyControlBindingClass {
|
|
wrapped := UnsafeProxyControlBindingClassFromGlibBorrow(p)
|
|
runtime.SetFinalizer(
|
|
wrapped.proxyControlBindingClass,
|
|
func (intern *proxyControlBindingClass) {
|
|
C.free(unsafe.Pointer(intern.native))
|
|
},
|
|
)
|
|
return wrapped
|
|
}
|
|
|
|
// UnsafeProxyControlBindingClassFree unrefs/frees the underlying resource. This is used by the bindings internally.
|
|
//
|
|
// After this is called, no other method on [ProxyControlBindingClass] is expected to work anymore.
|
|
func UnsafeProxyControlBindingClassFree(p *ProxyControlBindingClass) {
|
|
C.free(unsafe.Pointer(p.native))
|
|
}
|
|
|
|
// UnsafeProxyControlBindingClassToGlibNone returns the underlying C pointer. This is used by the bindings internally.
|
|
func UnsafeProxyControlBindingClassToGlibNone(p *ProxyControlBindingClass) unsafe.Pointer {
|
|
return unsafe.Pointer(p.native)
|
|
}
|
|
|
|
// UnsafeProxyControlBindingClassToGlibFull returns the underlying C pointer and gives up ownership.
|
|
// This is used by the bindings internally.
|
|
func UnsafeProxyControlBindingClassToGlibFull(p *ProxyControlBindingClass) unsafe.Pointer {
|
|
runtime.SetFinalizer(p.proxyControlBindingClass, nil)
|
|
_p := unsafe.Pointer(p.native)
|
|
p.native = nil // ProxyControlBindingClass is invalid from here on
|
|
return _p
|
|
}
|
|
// TimedValueControlSourceClass wraps GstTimedValueControlSourceClass
|
|
type TimedValueControlSourceClass struct {
|
|
*timedValueControlSourceClass
|
|
}
|
|
|
|
// timedValueControlSourceClass is the struct that's finalized
|
|
type timedValueControlSourceClass struct {
|
|
native *C.GstTimedValueControlSourceClass
|
|
}
|
|
|
|
// UnsafeTimedValueControlSourceClassFromGlibBorrow is used to convert raw C.GstTimedValueControlSourceClass pointers to go. This is used by the bindings internally.
|
|
func UnsafeTimedValueControlSourceClassFromGlibBorrow(p unsafe.Pointer) *TimedValueControlSourceClass {
|
|
return &TimedValueControlSourceClass{&timedValueControlSourceClass{(*C.GstTimedValueControlSourceClass)(p)}}
|
|
}
|
|
|
|
// UnsafeTimedValueControlSourceClassFromGlibNone is used to convert raw C.GstTimedValueControlSourceClass pointers to go while taking a reference. This is used by the bindings internally.
|
|
func UnsafeTimedValueControlSourceClassFromGlibNone(p unsafe.Pointer) *TimedValueControlSourceClass {
|
|
// FIXME: this has no ref function, what should we do here?
|
|
wrapped := UnsafeTimedValueControlSourceClassFromGlibBorrow(p)
|
|
runtime.SetFinalizer(
|
|
wrapped.timedValueControlSourceClass,
|
|
func (intern *timedValueControlSourceClass) {
|
|
C.free(unsafe.Pointer(intern.native))
|
|
},
|
|
)
|
|
return wrapped
|
|
}
|
|
|
|
// UnsafeTimedValueControlSourceClassFromGlibFull is used to convert raw C.GstTimedValueControlSourceClass pointers to go while taking a reference. This is used by the bindings internally.
|
|
func UnsafeTimedValueControlSourceClassFromGlibFull(p unsafe.Pointer) *TimedValueControlSourceClass {
|
|
wrapped := UnsafeTimedValueControlSourceClassFromGlibBorrow(p)
|
|
runtime.SetFinalizer(
|
|
wrapped.timedValueControlSourceClass,
|
|
func (intern *timedValueControlSourceClass) {
|
|
C.free(unsafe.Pointer(intern.native))
|
|
},
|
|
)
|
|
return wrapped
|
|
}
|
|
|
|
// UnsafeTimedValueControlSourceClassFree unrefs/frees the underlying resource. This is used by the bindings internally.
|
|
//
|
|
// After this is called, no other method on [TimedValueControlSourceClass] is expected to work anymore.
|
|
func UnsafeTimedValueControlSourceClassFree(t *TimedValueControlSourceClass) {
|
|
C.free(unsafe.Pointer(t.native))
|
|
}
|
|
|
|
// UnsafeTimedValueControlSourceClassToGlibNone returns the underlying C pointer. This is used by the bindings internally.
|
|
func UnsafeTimedValueControlSourceClassToGlibNone(t *TimedValueControlSourceClass) unsafe.Pointer {
|
|
return unsafe.Pointer(t.native)
|
|
}
|
|
|
|
// UnsafeTimedValueControlSourceClassToGlibFull returns the underlying C pointer and gives up ownership.
|
|
// This is used by the bindings internally.
|
|
func UnsafeTimedValueControlSourceClassToGlibFull(t *TimedValueControlSourceClass) unsafe.Pointer {
|
|
runtime.SetFinalizer(t.timedValueControlSourceClass, nil)
|
|
_p := unsafe.Pointer(t.native)
|
|
t.native = nil // TimedValueControlSourceClass is invalid from here on
|
|
return _p
|
|
}
|
|
// TriggerControlSourceClass wraps GstTriggerControlSourceClass
|
|
type TriggerControlSourceClass struct {
|
|
*triggerControlSourceClass
|
|
}
|
|
|
|
// triggerControlSourceClass is the struct that's finalized
|
|
type triggerControlSourceClass struct {
|
|
native *C.GstTriggerControlSourceClass
|
|
}
|
|
|
|
// UnsafeTriggerControlSourceClassFromGlibBorrow is used to convert raw C.GstTriggerControlSourceClass pointers to go. This is used by the bindings internally.
|
|
func UnsafeTriggerControlSourceClassFromGlibBorrow(p unsafe.Pointer) *TriggerControlSourceClass {
|
|
return &TriggerControlSourceClass{&triggerControlSourceClass{(*C.GstTriggerControlSourceClass)(p)}}
|
|
}
|
|
|
|
// UnsafeTriggerControlSourceClassFromGlibNone is used to convert raw C.GstTriggerControlSourceClass pointers to go while taking a reference. This is used by the bindings internally.
|
|
func UnsafeTriggerControlSourceClassFromGlibNone(p unsafe.Pointer) *TriggerControlSourceClass {
|
|
// FIXME: this has no ref function, what should we do here?
|
|
wrapped := UnsafeTriggerControlSourceClassFromGlibBorrow(p)
|
|
runtime.SetFinalizer(
|
|
wrapped.triggerControlSourceClass,
|
|
func (intern *triggerControlSourceClass) {
|
|
C.free(unsafe.Pointer(intern.native))
|
|
},
|
|
)
|
|
return wrapped
|
|
}
|
|
|
|
// UnsafeTriggerControlSourceClassFromGlibFull is used to convert raw C.GstTriggerControlSourceClass pointers to go while taking a reference. This is used by the bindings internally.
|
|
func UnsafeTriggerControlSourceClassFromGlibFull(p unsafe.Pointer) *TriggerControlSourceClass {
|
|
wrapped := UnsafeTriggerControlSourceClassFromGlibBorrow(p)
|
|
runtime.SetFinalizer(
|
|
wrapped.triggerControlSourceClass,
|
|
func (intern *triggerControlSourceClass) {
|
|
C.free(unsafe.Pointer(intern.native))
|
|
},
|
|
)
|
|
return wrapped
|
|
}
|
|
|
|
// UnsafeTriggerControlSourceClassFree unrefs/frees the underlying resource. This is used by the bindings internally.
|
|
//
|
|
// After this is called, no other method on [TriggerControlSourceClass] is expected to work anymore.
|
|
func UnsafeTriggerControlSourceClassFree(t *TriggerControlSourceClass) {
|
|
C.free(unsafe.Pointer(t.native))
|
|
}
|
|
|
|
// UnsafeTriggerControlSourceClassToGlibNone returns the underlying C pointer. This is used by the bindings internally.
|
|
func UnsafeTriggerControlSourceClassToGlibNone(t *TriggerControlSourceClass) unsafe.Pointer {
|
|
return unsafe.Pointer(t.native)
|
|
}
|
|
|
|
// UnsafeTriggerControlSourceClassToGlibFull returns the underlying C pointer and gives up ownership.
|
|
// This is used by the bindings internally.
|
|
func UnsafeTriggerControlSourceClassToGlibFull(t *TriggerControlSourceClass) unsafe.Pointer {
|
|
runtime.SetFinalizer(t.triggerControlSourceClass, nil)
|
|
_p := unsafe.Pointer(t.native)
|
|
t.native = nil // TriggerControlSourceClass is invalid from here on
|
|
return _p
|
|
}
|