mirrors/gstreamer-rs
mirrors/gstreamer-rs
1
1
Fork 1
mirror of https://gitlab.freedesktop.org/gstreamer/gstreamer-rs.git synced 2024-06-11 02:39:24 +00:00
Code Issues Projects Releases Wiki Activity
gstreamer-rs/gstreamer-editing-services/sys/src/lib.rs
Marijn Suijten d50d7b4a95 Update gir and regenerate 
This version adds a `--strip-docs` flag to `generator.py`, used in
conjunction with `--strip-docs --embed-docs` to clean documentation
first before re-embedding it (otherwise the same text would show up
multiple times).  It is also used in the CI to check that no
documentation disappears on stripping, ie. all documentation is properly
annotated with `// rustdoc-stripper-ignore-next`.
2021-05-05 12:23:40 +02:00

4206 lines
155 KiB
Rust
Raw Blame History

// Generated by gir (https://github.com/gtk-rs/gir @ 612ed89)
// from gir-files (https://github.com/gtk-rs/gir-files @ 6088bb6)
// from gst-gir-files (https://gitlab.freedesktop.org/gstreamer/gir-files-rs.git @ 208138a)
// DO NOT EDIT
#![allow(non_camel_case_types, non_upper_case_globals, non_snake_case)]
#![allow(
clippy::approx_constant,
clippy::type_complexity,
clippy::unreadable_literal,
clippy::upper_case_acronyms
)]
#![cfg_attr(feature = "dox", feature(doc_cfg))]
use gio_sys as gio;
use glib_sys as glib;
use gobject_sys as gobject;
use gstreamer_pbutils_sys as gst_pbutils;
use gstreamer_sys as gst;
#[allow(unused_imports)]
use libc::{
c_char, c_double, c_float, c_int, c_long, c_short, c_uchar, c_uint, c_ulong, c_ushort, c_void,
intptr_t, size_t, ssize_t, time_t, uintptr_t, FILE,
};
#[allow(unused_imports)]
use glib::{gboolean, gconstpointer, gpointer, GType};
// Aliases
pub type GESFrameNumber = i64;
// Enums
pub type GESAssetLoadingReturn = c_int;
pub const GES_ASSET_LOADING_ERROR: GESAssetLoadingReturn = 0;
pub const GES_ASSET_LOADING_ASYNC: GESAssetLoadingReturn = 1;
pub const GES_ASSET_LOADING_OK: GESAssetLoadingReturn = 2;
pub type GESChildrenControlMode = c_int;
pub const GES_CHILDREN_UPDATE: GESChildrenControlMode = 0;
pub const GES_CHILDREN_IGNORE_NOTIFIES: GESChildrenControlMode = 1;
pub const GES_CHILDREN_UPDATE_OFFSETS: GESChildrenControlMode = 2;
pub const GES_CHILDREN_UPDATE_ALL_VALUES: GESChildrenControlMode = 3;
pub const GES_CHILDREN_LAST: GESChildrenControlMode = 4;
pub type GESEdge = c_int;
pub const GES_EDGE_START: GESEdge = 0;
pub const GES_EDGE_END: GESEdge = 1;
pub const GES_EDGE_NONE: GESEdge = 2;
pub type GESEditMode = c_int;
pub const GES_EDIT_MODE_NORMAL: GESEditMode = 0;
pub const GES_EDIT_MODE_RIPPLE: GESEditMode = 1;
pub const GES_EDIT_MODE_ROLL: GESEditMode = 2;
pub const GES_EDIT_MODE_TRIM: GESEditMode = 3;
pub const GES_EDIT_MODE_SLIDE: GESEditMode = 4;
pub type GESError = c_int;
pub const GES_ERROR_ASSET_WRONG_ID: GESError = 0;
pub const GES_ERROR_ASSET_LOADING: GESError = 1;
pub const GES_ERROR_FORMATTER_MALFORMED_INPUT_FILE: GESError = 2;
pub const GES_ERROR_INVALID_FRAME_NUMBER: GESError = 3;
pub const GES_ERROR_NEGATIVE_LAYER: GESError = 4;
pub const GES_ERROR_NEGATIVE_TIME: GESError = 5;
pub const GES_ERROR_NOT_ENOUGH_INTERNAL_CONTENT: GESError = 6;
pub const GES_ERROR_INVALID_OVERLAP_IN_TRACK: GESError = 7;
pub const GES_ERROR_INVALID_EFFECT_BIN_DESCRIPTION: GESError = 8;
pub type GESTextHAlign = c_int;
pub const GES_TEXT_HALIGN_LEFT: GESTextHAlign = 0;
pub const GES_TEXT_HALIGN_CENTER: GESTextHAlign = 1;
pub const GES_TEXT_HALIGN_RIGHT: GESTextHAlign = 2;
pub const GES_TEXT_HALIGN_POSITION: GESTextHAlign = 4;
pub const GES_TEXT_HALIGN_ABSOLUTE: GESTextHAlign = 5;
pub type GESTextVAlign = c_int;
pub const GES_TEXT_VALIGN_BASELINE: GESTextVAlign = 0;
pub const GES_TEXT_VALIGN_BOTTOM: GESTextVAlign = 1;
pub const GES_TEXT_VALIGN_TOP: GESTextVAlign = 2;
pub const GES_TEXT_VALIGN_POSITION: GESTextVAlign = 3;
pub const GES_TEXT_VALIGN_CENTER: GESTextVAlign = 4;
pub const GES_TEXT_VALIGN_ABSOLUTE: GESTextVAlign = 5;
pub type GESVideoStandardTransitionType = c_int;
pub const GES_VIDEO_STANDARD_TRANSITION_TYPE_NONE: GESVideoStandardTransitionType = 0;
pub const GES_VIDEO_STANDARD_TRANSITION_TYPE_BAR_WIPE_LR: GESVideoStandardTransitionType = 1;
pub const GES_VIDEO_STANDARD_TRANSITION_TYPE_BAR_WIPE_TB: GESVideoStandardTransitionType = 2;
pub const GES_VIDEO_STANDARD_TRANSITION_TYPE_BOX_WIPE_TL: GESVideoStandardTransitionType = 3;
pub const GES_VIDEO_STANDARD_TRANSITION_TYPE_BOX_WIPE_TR: GESVideoStandardTransitionType = 4;
pub const GES_VIDEO_STANDARD_TRANSITION_TYPE_BOX_WIPE_BR: GESVideoStandardTransitionType = 5;
pub const GES_VIDEO_STANDARD_TRANSITION_TYPE_BOX_WIPE_BL: GESVideoStandardTransitionType = 6;
pub const GES_VIDEO_STANDARD_TRANSITION_TYPE_FOUR_BOX_WIPE_CI: GESVideoStandardTransitionType = 7;
pub const GES_VIDEO_STANDARD_TRANSITION_TYPE_FOUR_BOX_WIPE_CO: GESVideoStandardTransitionType = 8;
pub const GES_VIDEO_STANDARD_TRANSITION_TYPE_BARNDOOR_V: GESVideoStandardTransitionType = 21;
pub const GES_VIDEO_STANDARD_TRANSITION_TYPE_BARNDOOR_H: GESVideoStandardTransitionType = 22;
pub const GES_VIDEO_STANDARD_TRANSITION_TYPE_BOX_WIPE_TC: GESVideoStandardTransitionType = 23;
pub const GES_VIDEO_STANDARD_TRANSITION_TYPE_BOX_WIPE_RC: GESVideoStandardTransitionType = 24;
pub const GES_VIDEO_STANDARD_TRANSITION_TYPE_BOX_WIPE_BC: GESVideoStandardTransitionType = 25;
pub const GES_VIDEO_STANDARD_TRANSITION_TYPE_BOX_WIPE_LC: GESVideoStandardTransitionType = 26;
pub const GES_VIDEO_STANDARD_TRANSITION_TYPE_DIAGONAL_TL: GESVideoStandardTransitionType = 41;
pub const GES_VIDEO_STANDARD_TRANSITION_TYPE_DIAGONAL_TR: GESVideoStandardTransitionType = 42;
pub const GES_VIDEO_STANDARD_TRANSITION_TYPE_BOWTIE_V: GESVideoStandardTransitionType = 43;
pub const GES_VIDEO_STANDARD_TRANSITION_TYPE_BOWTIE_H: GESVideoStandardTransitionType = 44;
pub const GES_VIDEO_STANDARD_TRANSITION_TYPE_BARNDOOR_DBL: GESVideoStandardTransitionType = 45;
pub const GES_VIDEO_STANDARD_TRANSITION_TYPE_BARNDOOR_DTL: GESVideoStandardTransitionType = 46;
pub const GES_VIDEO_STANDARD_TRANSITION_TYPE_MISC_DIAGONAL_DBD: GESVideoStandardTransitionType = 47;
pub const GES_VIDEO_STANDARD_TRANSITION_TYPE_MISC_DIAGONAL_DD: GESVideoStandardTransitionType = 48;
pub const GES_VIDEO_STANDARD_TRANSITION_TYPE_VEE_D: GESVideoStandardTransitionType = 61;
pub const GES_VIDEO_STANDARD_TRANSITION_TYPE_VEE_L: GESVideoStandardTransitionType = 62;
pub const GES_VIDEO_STANDARD_TRANSITION_TYPE_VEE_U: GESVideoStandardTransitionType = 63;
pub const GES_VIDEO_STANDARD_TRANSITION_TYPE_VEE_R: GESVideoStandardTransitionType = 64;
pub const GES_VIDEO_STANDARD_TRANSITION_TYPE_BARNVEE_D: GESVideoStandardTransitionType = 65;
pub const GES_VIDEO_STANDARD_TRANSITION_TYPE_BARNVEE_L: GESVideoStandardTransitionType = 66;
pub const GES_VIDEO_STANDARD_TRANSITION_TYPE_BARNVEE_U: GESVideoStandardTransitionType = 67;
pub const GES_VIDEO_STANDARD_TRANSITION_TYPE_BARNVEE_R: GESVideoStandardTransitionType = 68;
pub const GES_VIDEO_STANDARD_TRANSITION_TYPE_IRIS_RECT: GESVideoStandardTransitionType = 101;
pub const GES_VIDEO_STANDARD_TRANSITION_TYPE_CLOCK_CW12: GESVideoStandardTransitionType = 201;
pub const GES_VIDEO_STANDARD_TRANSITION_TYPE_CLOCK_CW3: GESVideoStandardTransitionType = 202;
pub const GES_VIDEO_STANDARD_TRANSITION_TYPE_CLOCK_CW6: GESVideoStandardTransitionType = 203;
pub const GES_VIDEO_STANDARD_TRANSITION_TYPE_CLOCK_CW9: GESVideoStandardTransitionType = 204;
pub const GES_VIDEO_STANDARD_TRANSITION_TYPE_PINWHEEL_TBV: GESVideoStandardTransitionType = 205;
pub const GES_VIDEO_STANDARD_TRANSITION_TYPE_PINWHEEL_TBH: GESVideoStandardTransitionType = 206;
pub const GES_VIDEO_STANDARD_TRANSITION_TYPE_PINWHEEL_FB: GESVideoStandardTransitionType = 207;
pub const GES_VIDEO_STANDARD_TRANSITION_TYPE_FAN_CT: GESVideoStandardTransitionType = 211;
pub const GES_VIDEO_STANDARD_TRANSITION_TYPE_FAN_CR: GESVideoStandardTransitionType = 212;
pub const GES_VIDEO_STANDARD_TRANSITION_TYPE_DOUBLEFAN_FOV: GESVideoStandardTransitionType = 213;
pub const GES_VIDEO_STANDARD_TRANSITION_TYPE_DOUBLEFAN_FOH: GESVideoStandardTransitionType = 214;
pub const GES_VIDEO_STANDARD_TRANSITION_TYPE_SINGLESWEEP_CWT: GESVideoStandardTransitionType = 221;
pub const GES_VIDEO_STANDARD_TRANSITION_TYPE_SINGLESWEEP_CWR: GESVideoStandardTransitionType = 222;
pub const GES_VIDEO_STANDARD_TRANSITION_TYPE_SINGLESWEEP_CWB: GESVideoStandardTransitionType = 223;
pub const GES_VIDEO_STANDARD_TRANSITION_TYPE_SINGLESWEEP_CWL: GESVideoStandardTransitionType = 224;
pub const GES_VIDEO_STANDARD_TRANSITION_TYPE_DOUBLESWEEP_PV: GESVideoStandardTransitionType = 225;
pub const GES_VIDEO_STANDARD_TRANSITION_TYPE_DOUBLESWEEP_PD: GESVideoStandardTransitionType = 226;
pub const GES_VIDEO_STANDARD_TRANSITION_TYPE_DOUBLESWEEP_OV: GESVideoStandardTransitionType = 227;
pub const GES_VIDEO_STANDARD_TRANSITION_TYPE_DOUBLESWEEP_OH: GESVideoStandardTransitionType = 228;
pub const GES_VIDEO_STANDARD_TRANSITION_TYPE_FAN_T: GESVideoStandardTransitionType = 231;
pub const GES_VIDEO_STANDARD_TRANSITION_TYPE_FAN_R: GESVideoStandardTransitionType = 232;
pub const GES_VIDEO_STANDARD_TRANSITION_TYPE_FAN_B: GESVideoStandardTransitionType = 233;
pub const GES_VIDEO_STANDARD_TRANSITION_TYPE_FAN_L: GESVideoStandardTransitionType = 234;
pub const GES_VIDEO_STANDARD_TRANSITION_TYPE_DOUBLEFAN_FIV: GESVideoStandardTransitionType = 235;
pub const GES_VIDEO_STANDARD_TRANSITION_TYPE_DOUBLEFAN_FIH: GESVideoStandardTransitionType = 236;
pub const GES_VIDEO_STANDARD_TRANSITION_TYPE_SINGLESWEEP_CWTL: GESVideoStandardTransitionType = 241;
pub const GES_VIDEO_STANDARD_TRANSITION_TYPE_SINGLESWEEP_CWBL: GESVideoStandardTransitionType = 242;
pub const GES_VIDEO_STANDARD_TRANSITION_TYPE_SINGLESWEEP_CWBR: GESVideoStandardTransitionType = 243;
pub const GES_VIDEO_STANDARD_TRANSITION_TYPE_SINGLESWEEP_CWTR: GESVideoStandardTransitionType = 244;
pub const GES_VIDEO_STANDARD_TRANSITION_TYPE_DOUBLESWEEP_PDTL: GESVideoStandardTransitionType = 245;
pub const GES_VIDEO_STANDARD_TRANSITION_TYPE_DOUBLESWEEP_PDBL: GESVideoStandardTransitionType = 246;
pub const GES_VIDEO_STANDARD_TRANSITION_TYPE_SALOONDOOR_T: GESVideoStandardTransitionType = 251;
pub const GES_VIDEO_STANDARD_TRANSITION_TYPE_SALOONDOOR_L: GESVideoStandardTransitionType = 252;
pub const GES_VIDEO_STANDARD_TRANSITION_TYPE_SALOONDOOR_B: GESVideoStandardTransitionType = 253;
pub const GES_VIDEO_STANDARD_TRANSITION_TYPE_SALOONDOOR_R: GESVideoStandardTransitionType = 254;
pub const GES_VIDEO_STANDARD_TRANSITION_TYPE_WINDSHIELD_R: GESVideoStandardTransitionType = 261;
pub const GES_VIDEO_STANDARD_TRANSITION_TYPE_WINDSHIELD_U: GESVideoStandardTransitionType = 262;
pub const GES_VIDEO_STANDARD_TRANSITION_TYPE_WINDSHIELD_V: GESVideoStandardTransitionType = 263;
pub const GES_VIDEO_STANDARD_TRANSITION_TYPE_WINDSHIELD_H: GESVideoStandardTransitionType = 264;
pub const GES_VIDEO_STANDARD_TRANSITION_TYPE_CROSSFADE: GESVideoStandardTransitionType = 512;
pub type GESVideoTestPattern = c_int;
pub const GES_VIDEO_TEST_PATTERN_SMPTE: GESVideoTestPattern = 0;
pub const GES_VIDEO_TEST_PATTERN_SNOW: GESVideoTestPattern = 1;
pub const GES_VIDEO_TEST_PATTERN_BLACK: GESVideoTestPattern = 2;
pub const GES_VIDEO_TEST_PATTERN_WHITE: GESVideoTestPattern = 3;
pub const GES_VIDEO_TEST_PATTERN_RED: GESVideoTestPattern = 4;
pub const GES_VIDEO_TEST_PATTERN_GREEN: GESVideoTestPattern = 5;
pub const GES_VIDEO_TEST_PATTERN_BLUE: GESVideoTestPattern = 6;
pub const GES_VIDEO_TEST_PATTERN_CHECKERS1: GESVideoTestPattern = 7;
pub const GES_VIDEO_TEST_PATTERN_CHECKERS2: GESVideoTestPattern = 8;
pub const GES_VIDEO_TEST_PATTERN_CHECKERS4: GESVideoTestPattern = 9;
pub const GES_VIDEO_TEST_PATTERN_CHECKERS8: GESVideoTestPattern = 10;
pub const GES_VIDEO_TEST_PATTERN_CIRCULAR: GESVideoTestPattern = 11;
pub const GES_VIDEO_TEST_PATTERN_BLINK: GESVideoTestPattern = 12;
pub const GES_VIDEO_TEST_PATTERN_SMPTE75: GESVideoTestPattern = 13;
pub const GES_VIDEO_TEST_ZONE_PLATE: GESVideoTestPattern = 14;
pub const GES_VIDEO_TEST_GAMUT: GESVideoTestPattern = 15;
pub const GES_VIDEO_TEST_CHROMA_ZONE_PLATE: GESVideoTestPattern = 16;
pub const GES_VIDEO_TEST_PATTERN_SOLID: GESVideoTestPattern = 17;
// Constants
pub const GES_FRAME_NUMBER_NONE: i64 = 9223372036854775807;
pub const GES_META_DESCRIPTION: *const c_char = b"description\0" as *const u8 as *const c_char;
pub const GES_META_FORMATTER_EXTENSION: *const c_char =
b"extension\0" as *const u8 as *const c_char;
pub const GES_META_FORMATTER_MIMETYPE: *const c_char = b"mimetype\0" as *const u8 as *const c_char;
pub const GES_META_FORMATTER_NAME: *const c_char = b"name\0" as *const u8 as *const c_char;
pub const GES_META_FORMATTER_RANK: *const c_char = b"rank\0" as *const u8 as *const c_char;
pub const GES_META_FORMATTER_VERSION: *const c_char = b"version\0" as *const u8 as *const c_char;
pub const GES_META_FORMAT_VERSION: *const c_char =
b"format-version\0" as *const u8 as *const c_char;
pub const GES_META_MARKER_COLOR: *const c_char = b"marker-color\0" as *const u8 as *const c_char;
pub const GES_META_VOLUME: *const c_char = b"volume\0" as *const u8 as *const c_char;
pub const GES_META_VOLUME_DEFAULT: c_double = 1.000000;
pub const GES_MULTI_FILE_URI_PREFIX: *const c_char =
b"multifile://\0" as *const u8 as *const c_char;
pub const GES_PADDING: c_int = 4;
pub const GES_PADDING_LARGE: c_int = 20;
pub const GES_TIMELINE_ELEMENT_NO_LAYER_PRIORITY: u32 = 4294967295;
pub const GES_VERSION_MAJOR: c_int = 1;
pub const GES_VERSION_MICRO: c_int = 2;
pub const GES_VERSION_MINOR: c_int = 18;
pub const GES_VERSION_NANO: c_int = 0;
// Flags
pub type GESMetaFlag = c_uint;
pub const GES_META_READABLE: GESMetaFlag = 1;
pub const GES_META_WRITABLE: GESMetaFlag = 2;
pub const GES_META_READ_WRITE: GESMetaFlag = 3;
pub type GESPipelineFlags = c_uint;
pub const GES_PIPELINE_MODE_PREVIEW_AUDIO: GESPipelineFlags = 1;
pub const GES_PIPELINE_MODE_PREVIEW_VIDEO: GESPipelineFlags = 2;
pub const GES_PIPELINE_MODE_PREVIEW: GESPipelineFlags = 3;
pub const GES_PIPELINE_MODE_RENDER: GESPipelineFlags = 4;
pub const GES_PIPELINE_MODE_SMART_RENDER: GESPipelineFlags = 8;
pub type GESTrackType = c_uint;
pub const GES_TRACK_TYPE_UNKNOWN: GESTrackType = 1;
pub const GES_TRACK_TYPE_AUDIO: GESTrackType = 2;
pub const GES_TRACK_TYPE_VIDEO: GESTrackType = 4;
pub const GES_TRACK_TYPE_TEXT: GESTrackType = 8;
pub const GES_TRACK_TYPE_CUSTOM: GESTrackType = 16;
// Unions
#[repr(C)]
#[derive(Copy, Clone)]
pub union GESClipClass_ABI {
pub _ges_reserved: [gpointer; 20],
pub abi: GESClipClass_ABI_abi,
}
impl ::std::fmt::Debug for GESClipClass_ABI {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GESClipClass_ABI @ {:?}", self as *const _))
.field("_ges_reserved", unsafe { &self._ges_reserved })
.field("abi", unsafe { &self.abi })
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union GESTrackElementClass_ABI {
pub _ges_reserved: [gpointer; 20],
pub abi: GESTrackElementClass_ABI_abi,
}
impl ::std::fmt::Debug for GESTrackElementClass_ABI {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"GESTrackElementClass_ABI @ {:?}",
self as *const _
))
.field("_ges_reserved", unsafe { &self._ges_reserved })
.field("abi", unsafe { &self.abi })
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union GESVideoSourceClass_ABI {
pub _ges_reserved: [gpointer; 4],
pub abi: GESVideoSourceClass_ABI_abi,
}
impl ::std::fmt::Debug for GESVideoSourceClass_ABI {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GESVideoSourceClass_ABI @ {:?}", self as *const _))
.field("_ges_reserved", unsafe { &self._ges_reserved })
.field("abi", unsafe { &self.abi })
.finish()
}
}
// Callbacks
pub type GESBaseEffectTimeTranslationFunc = Option<
unsafe extern "C" fn(
*mut GESBaseEffect,
gst::GstClockTime,
*mut glib::GHashTable,
gpointer,
) -> gst::GstClockTime,
>;
pub type GESCreateElementForGapFunc =
Option<unsafe extern "C" fn(*mut GESTrack) -> *mut gst::GstElement>;
pub type GESCreateTrackElementFunc =
Option<unsafe extern "C" fn(*mut GESClip, GESTrackType) -> *mut GESTrackElement>;
pub type GESCreateTrackElementsFunc =
Option<unsafe extern "C" fn(*mut GESClip, GESTrackType) -> *mut glib::GList>;
pub type GESExtractableCheckId =
Option<unsafe extern "C" fn(GType, *const c_char, *mut *mut glib::GError) -> *mut c_char>;
pub type GESFillTrackElementFunc = Option<
unsafe extern "C" fn(*mut GESClip, *mut GESTrackElement, *mut gst::GstElement) -> gboolean,
>;
pub type GESFormatterCanLoadURIMethod = Option<
unsafe extern "C" fn(*mut GESFormatter, *const c_char, *mut *mut glib::GError) -> gboolean,
>;
pub type GESFormatterLoadFromURIMethod = Option<
unsafe extern "C" fn(
*mut GESFormatter,
*mut GESTimeline,
*const c_char,
*mut *mut glib::GError,
) -> gboolean,
>;
pub type GESFormatterSaveToURIMethod = Option<
unsafe extern "C" fn(
*mut GESFormatter,
*mut GESTimeline,
*const c_char,
gboolean,
*mut *mut glib::GError,
) -> gboolean,
>;
pub type GESMetaForeachFunc = Option<
unsafe extern "C" fn(*const GESMetaContainer, *const c_char, *const gobject::GValue, gpointer),
>;
// Records
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GESAssetClass {
pub parent: gobject::GObjectClass,
pub start_loading: Option<
unsafe extern "C" fn(*mut GESAsset, *mut *mut glib::GError) -> GESAssetLoadingReturn,
>,
pub extract:
Option<unsafe extern "C" fn(*mut GESAsset, *mut *mut glib::GError) -> *mut GESExtractable>,
pub inform_proxy: Option<unsafe extern "C" fn(*mut GESAsset, *const c_char)>,
pub proxied: Option<unsafe extern "C" fn(*mut GESAsset, *mut GESAsset)>,
pub request_id_update: Option<
unsafe extern "C" fn(*mut GESAsset, *mut *mut c_char, *mut glib::GError) -> gboolean,
>,
pub _ges_reserved: [gpointer; 4],
}
impl ::std::fmt::Debug for GESAssetClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GESAssetClass @ {:?}", self as *const _))
.field("parent", &self.parent)
.field("start_loading", &self.start_loading)
.field("extract", &self.extract)
.field("inform_proxy", &self.inform_proxy)
.field("proxied", &self.proxied)
.field("request_id_update", &self.request_id_update)
.field("_ges_reserved", &self._ges_reserved)
.finish()
}
}
#[repr(C)]
pub struct _GESAssetPrivate(c_void);
pub type GESAssetPrivate = *mut _GESAssetPrivate;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GESAudioSourceClass {
pub parent_class: GESSourceClass,
pub create_source: Option<unsafe extern "C" fn(*mut GESTrackElement) -> *mut gst::GstElement>,
pub _ges_reserved: [gpointer; 4],
}
impl ::std::fmt::Debug for GESAudioSourceClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GESAudioSourceClass @ {:?}", self as *const _))
.field("create_source", &self.create_source)
.finish()
}
}
#[repr(C)]
pub struct _GESAudioSourcePrivate(c_void);
pub type GESAudioSourcePrivate = *mut _GESAudioSourcePrivate;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GESAudioTestSourceClass {
pub parent_class: GESAudioSourceClass,
pub _ges_reserved: [gpointer; 4],
}
impl ::std::fmt::Debug for GESAudioTestSourceClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GESAudioTestSourceClass @ {:?}", self as *const _))
.finish()
}
}
#[repr(C)]
pub struct _GESAudioTestSourcePrivate(c_void);
pub type GESAudioTestSourcePrivate = *mut _GESAudioTestSourcePrivate;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GESAudioTrackClass {
pub parent_class: GESTrackClass,
pub _ges_reserved: [gpointer; 4],
}
impl ::std::fmt::Debug for GESAudioTrackClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GESAudioTrackClass @ {:?}", self as *const _))
.field("parent_class", &self.parent_class)
.field("_ges_reserved", &self._ges_reserved)
.finish()
}
}
#[repr(C)]
pub struct _GESAudioTrackPrivate(c_void);
pub type GESAudioTrackPrivate = *mut _GESAudioTrackPrivate;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GESAudioTransitionClass {
pub parent_class: GESTransitionClass,
pub _ges_reserved: [gpointer; 4],
}
impl ::std::fmt::Debug for GESAudioTransitionClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GESAudioTransitionClass @ {:?}", self as *const _))
.field("parent_class", &self.parent_class)
.field("_ges_reserved", &self._ges_reserved)
.finish()
}
}
#[repr(C)]
pub struct _GESAudioTransitionPrivate(c_void);
pub type GESAudioTransitionPrivate = *mut _GESAudioTransitionPrivate;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GESAudioUriSourceClass {
pub parent_class: GESAudioSourceClass,
pub _ges_reserved: [gpointer; 4],
}
impl ::std::fmt::Debug for GESAudioUriSourceClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GESAudioUriSourceClass @ {:?}", self as *const _))
.finish()
}
}
#[repr(C)]
pub struct _GESAudioUriSourcePrivate(c_void);
pub type GESAudioUriSourcePrivate = *mut _GESAudioUriSourcePrivate;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GESBaseEffectClass {
pub parent_class: GESOperationClass,
pub _ges_reserved: [gpointer; 4],
}
impl ::std::fmt::Debug for GESBaseEffectClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GESBaseEffectClass @ {:?}", self as *const _))
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GESBaseEffectClipClass {
pub parent_class: GESOperationClipClass,
pub _ges_reserved: [gpointer; 4],
}
impl ::std::fmt::Debug for GESBaseEffectClipClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GESBaseEffectClipClass @ {:?}", self as *const _))
.finish()
}
}
#[repr(C)]
pub struct _GESBaseEffectClipPrivate(c_void);
pub type GESBaseEffectClipPrivate = *mut _GESBaseEffectClipPrivate;
#[repr(C)]
pub struct _GESBaseEffectPrivate(c_void);
pub type GESBaseEffectPrivate = *mut _GESBaseEffectPrivate;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GESBaseTransitionClipClass {
pub parent_class: GESOperationClipClass,
pub _ges_reserved: [gpointer; 4],
}
impl ::std::fmt::Debug for GESBaseTransitionClipClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"GESBaseTransitionClipClass @ {:?}",
self as *const _
))
.finish()
}
}
#[repr(C)]
pub struct _GESBaseTransitionClipPrivate(c_void);
pub type GESBaseTransitionClipPrivate = *mut _GESBaseTransitionClipPrivate;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GESBaseXmlFormatterClass {
pub parent: GESFormatterClass,
pub content_parser: glib::GMarkupParser,
pub save: Option<
unsafe extern "C" fn(
*mut GESFormatter,
*mut GESTimeline,
*mut *mut glib::GError,
) -> *mut glib::GString,
>,
pub _ges_reserved: [gpointer; 4],
}
impl ::std::fmt::Debug for GESBaseXmlFormatterClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"GESBaseXmlFormatterClass @ {:?}",
self as *const _
))
.field("parent", &self.parent)
.field("content_parser", &self.content_parser)
.field("save", &self.save)
.field("_ges_reserved", &self._ges_reserved)
.finish()
}
}
#[repr(C)]
pub struct _GESBaseXmlFormatterPrivate(c_void);
pub type GESBaseXmlFormatterPrivate = *mut _GESBaseXmlFormatterPrivate;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GESClipAssetClass {
pub parent: GESAssetClass,
pub get_natural_framerate:
Option<unsafe extern "C" fn(*mut GESClipAsset, *mut c_int, *mut c_int) -> gboolean>,
pub _ges_reserved: [gpointer; 3],
}
impl ::std::fmt::Debug for GESClipAssetClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GESClipAssetClass @ {:?}", self as *const _))
.field("parent", &self.parent)
.field("get_natural_framerate", &self.get_natural_framerate)
.field("_ges_reserved", &self._ges_reserved)
.finish()
}
}
#[repr(C)]
pub struct _GESClipAssetPrivate(c_void);
pub type GESClipAssetPrivate = *mut _GESClipAssetPrivate;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GESClipClass {
pub parent_class: GESContainerClass,
pub create_track_element: GESCreateTrackElementFunc,
pub create_track_elements: GESCreateTrackElementsFunc,
pub ABI: GESClipClass_ABI,
}
impl ::std::fmt::Debug for GESClipClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GESClipClass @ {:?}", self as *const _))
.field("create_track_element", &self.create_track_element)
.field("create_track_elements", &self.create_track_elements)
.field("ABI", &self.ABI)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GESClipClass_ABI_abi {
pub can_add_effects: gboolean,
}
impl ::std::fmt::Debug for GESClipClass_ABI_abi {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GESClipClass_ABI_abi @ {:?}", self as *const _))
.field("can_add_effects", &self.can_add_effects)
.finish()
}
}
#[repr(C)]
pub struct _GESClipPrivate(c_void);
pub type GESClipPrivate = *mut _GESClipPrivate;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GESCommandLineFormatterClass {
pub parent_class: GESFormatterClass,
}
impl ::std::fmt::Debug for GESCommandLineFormatterClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"GESCommandLineFormatterClass @ {:?}",
self as *const _
))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
pub struct _GESCommandLineFormatterPrivate(c_void);
pub type GESCommandLineFormatterPrivate = *mut _GESCommandLineFormatterPrivate;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GESContainerClass {
pub parent_class: GESTimelineElementClass,
pub child_added: Option<unsafe extern "C" fn(*mut GESContainer, *mut GESTimelineElement)>,
pub child_removed: Option<unsafe extern "C" fn(*mut GESContainer, *mut GESTimelineElement)>,
pub add_child:
Option<unsafe extern "C" fn(*mut GESContainer, *mut GESTimelineElement) -> gboolean>,
pub remove_child:
Option<unsafe extern "C" fn(*mut GESContainer, *mut GESTimelineElement) -> gboolean>,
pub ungroup: Option<unsafe extern "C" fn(*mut GESContainer, gboolean) -> *mut glib::GList>,
pub group: Option<unsafe extern "C" fn(*mut glib::GList) -> *mut GESContainer>,
pub edit: Option<
unsafe extern "C" fn(
*mut GESContainer,
*mut glib::GList,
c_int,
GESEditMode,
GESEdge,
u64,
) -> gboolean,
>,
pub grouping_priority: c_uint,
pub _ges_reserved: [gpointer; 20],
}
impl ::std::fmt::Debug for GESContainerClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GESContainerClass @ {:?}", self as *const _))
.field("child_added", &self.child_added)
.field("child_removed", &self.child_removed)
.field("add_child", &self.add_child)
.field("remove_child", &self.remove_child)
.field("ungroup", &self.ungroup)
.field("group", &self.group)
.field("edit", &self.edit)
.finish()
}
}
#[repr(C)]
pub struct _GESContainerPrivate(c_void);
pub type GESContainerPrivate = *mut _GESContainerPrivate;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GESEffectAssetClass {
pub parent_class: GESTrackElementAssetClass,
pub _ges_reserved: [gpointer; 4],
}
impl ::std::fmt::Debug for GESEffectAssetClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GESEffectAssetClass @ {:?}", self as *const _))
.field("parent_class", &self.parent_class)
.field("_ges_reserved", &self._ges_reserved)
.finish()
}
}
#[repr(C)]
pub struct _GESEffectAssetPrivate(c_void);
pub type GESEffectAssetPrivate = *mut _GESEffectAssetPrivate;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GESEffectClass {
pub parent_class: GESBaseEffectClass,
pub rate_properties: *mut glib::GList,
pub _ges_reserved: [gpointer; 4],
}
impl ::std::fmt::Debug for GESEffectClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GESEffectClass @ {:?}", self as *const _))
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GESEffectClipClass {
pub parent_class: GESBaseEffectClipClass,
pub _ges_reserved: [gpointer; 4],
}
impl ::std::fmt::Debug for GESEffectClipClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GESEffectClipClass @ {:?}", self as *const _))
.finish()
}
}
#[repr(C)]
pub struct _GESEffectClipPrivate(c_void);
pub type GESEffectClipPrivate = *mut _GESEffectClipPrivate;
#[repr(C)]
pub struct _GESEffectPrivate(c_void);
pub type GESEffectPrivate = *mut _GESEffectPrivate;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GESExtractableInterface {
pub parent: gobject::GTypeInterface,
pub asset_type: GType,
pub check_id: GESExtractableCheckId,
pub can_update_asset: gboolean,
pub set_asset: Option<unsafe extern "C" fn(*mut GESExtractable, *mut GESAsset)>,
pub set_asset_full:
Option<unsafe extern "C" fn(*mut GESExtractable, *mut GESAsset) -> gboolean>,
pub get_parameters_from_id:
Option<unsafe extern "C" fn(*const c_char, *mut c_uint) -> *mut gobject::GParameter>,
pub get_id: Option<unsafe extern "C" fn(*mut GESExtractable) -> *mut c_char>,
pub get_real_extractable_type: Option<unsafe extern "C" fn(GType, *const c_char) -> GType>,
pub register_metas: Option<
unsafe extern "C" fn(
*mut GESExtractableInterface,
*mut gobject::GObjectClass,
*mut GESAsset,
) -> gboolean,
>,
pub _ges_reserved: [gpointer; 4],
}
impl ::std::fmt::Debug for GESExtractableInterface {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GESExtractableInterface @ {:?}", self as *const _))
.field("parent", &self.parent)
.field("asset_type", &self.asset_type)
.field("check_id", &self.check_id)
.field("can_update_asset", &self.can_update_asset)
.field("set_asset", &self.set_asset)
.field("set_asset_full", &self.set_asset_full)
.field("get_parameters_from_id", &self.get_parameters_from_id)
.field("get_id", &self.get_id)
.field("get_real_extractable_type", &self.get_real_extractable_type)
.field("register_metas", &self.register_metas)
.field("_ges_reserved", &self._ges_reserved)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GESFormatterClass {
pub parent_class: gobject::GInitiallyUnownedClass,
pub can_load_uri: GESFormatterCanLoadURIMethod,
pub load_from_uri: GESFormatterLoadFromURIMethod,
pub save_to_uri: GESFormatterSaveToURIMethod,
pub name: *mut c_char,
pub description: *mut c_char,
pub extension: *mut c_char,
pub mimetype: *mut c_char,
pub version: c_double,
pub rank: gst::GstRank,
pub _ges_reserved: [gpointer; 4],
}
impl ::std::fmt::Debug for GESFormatterClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GESFormatterClass @ {:?}", self as *const _))
.field("parent_class", &self.parent_class)
.field("can_load_uri", &self.can_load_uri)
.field("load_from_uri", &self.load_from_uri)
.field("save_to_uri", &self.save_to_uri)
.finish()
}
}
#[repr(C)]
pub struct _GESFormatterPrivate(c_void);
pub type GESFormatterPrivate = *mut _GESFormatterPrivate;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GESGroupClass {
pub parent_class: GESContainerClass,
pub _ges_reserved: [gpointer; 4],
}
impl ::std::fmt::Debug for GESGroupClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GESGroupClass @ {:?}", self as *const _))
.field("parent_class", &self.parent_class)
.field("_ges_reserved", &self._ges_reserved)
.finish()
}
}
#[repr(C)]
pub struct _GESGroupPrivate(c_void);
pub type GESGroupPrivate = *mut _GESGroupPrivate;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GESImageSourceClass {
pub parent_class: GESVideoSourceClass,
pub _ges_reserved: [gpointer; 4],
}
impl ::std::fmt::Debug for GESImageSourceClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GESImageSourceClass @ {:?}", self as *const _))
.field("parent_class", &self.parent_class)
.field("_ges_reserved", &self._ges_reserved)
.finish()
}
}
#[repr(C)]
pub struct _GESImageSourcePrivate(c_void);
pub type GESImageSourcePrivate = *mut _GESImageSourcePrivate;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GESLayerClass {
pub parent_class: gobject::GInitiallyUnownedClass,
pub get_objects: Option<unsafe extern "C" fn(*mut GESLayer) -> *mut glib::GList>,
pub object_added: Option<unsafe extern "C" fn(*mut GESLayer, *mut GESClip)>,
pub object_removed: Option<unsafe extern "C" fn(*mut GESLayer, *mut GESClip)>,
pub _ges_reserved: [gpointer; 4],
}
impl ::std::fmt::Debug for GESLayerClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GESLayerClass @ {:?}", self as *const _))
.field("get_objects", &self.get_objects)
.field("object_added", &self.object_added)
.field("object_removed", &self.object_removed)
.finish()
}
}
#[repr(C)]
pub struct _GESLayerPrivate(c_void);
pub type GESLayerPrivate = *mut _GESLayerPrivate;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GESMarkerClass {
pub parent_class: gobject::GObjectClass,
}
impl ::std::fmt::Debug for GESMarkerClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GESMarkerClass @ {:?}", self as *const _))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GESMarkerListClass {
pub parent_class: gobject::GObjectClass,
}
impl ::std::fmt::Debug for GESMarkerListClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GESMarkerListClass @ {:?}", self as *const _))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GESMetaContainerInterface {
pub parent_iface: gobject::GTypeInterface,
pub _ges_reserved: [gpointer; 4],
}
impl ::std::fmt::Debug for GESMetaContainerInterface {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"GESMetaContainerInterface @ {:?}",
self as *const _
))
.field("parent_iface", &self.parent_iface)
.field("_ges_reserved", &self._ges_reserved)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GESMultiFileSourceClass {
pub parent_class: GESVideoSourceClass,
pub _ges_reserved: [gpointer; 4],
}
impl ::std::fmt::Debug for GESMultiFileSourceClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GESMultiFileSourceClass @ {:?}", self as *const _))
.field("parent_class", &self.parent_class)
.field("_ges_reserved", &self._ges_reserved)
.finish()
}
}
#[repr(C)]
pub struct _GESMultiFileSourcePrivate(c_void);
pub type GESMultiFileSourcePrivate = *mut _GESMultiFileSourcePrivate;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GESOperationClass {
pub parent_class: GESTrackElementClass,
pub _ges_reserved: [gpointer; 4],
}
impl ::std::fmt::Debug for GESOperationClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GESOperationClass @ {:?}", self as *const _))
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GESOperationClipClass {
pub parent_class: GESClipClass,
pub _ges_reserved: [gpointer; 4],
}
impl ::std::fmt::Debug for GESOperationClipClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GESOperationClipClass @ {:?}", self as *const _))
.finish()
}
}
#[repr(C)]
pub struct _GESOperationClipPrivate(c_void);
pub type GESOperationClipPrivate = *mut _GESOperationClipPrivate;
#[repr(C)]
pub struct _GESOperationPrivate(c_void);
pub type GESOperationPrivate = *mut _GESOperationPrivate;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GESOverlayClipClass {
pub parent_class: GESOperationClipClass,
pub _ges_reserved: [gpointer; 4],
}
impl ::std::fmt::Debug for GESOverlayClipClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GESOverlayClipClass @ {:?}", self as *const _))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
pub struct _GESOverlayClipPrivate(c_void);
pub type GESOverlayClipPrivate = *mut _GESOverlayClipPrivate;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GESPipelineClass {
pub parent_class: gst::GstPipelineClass,
pub _ges_reserved: [gpointer; 4],
}
impl ::std::fmt::Debug for GESPipelineClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GESPipelineClass @ {:?}", self as *const _))
.finish()
}
}
#[repr(C)]
pub struct _GESPipelinePrivate(c_void);
pub type GESPipelinePrivate = *mut _GESPipelinePrivate;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GESPitiviFormatterClass {
pub parent_class: GESFormatterClass,
pub _ges_reserved: [gpointer; 4],
}
impl ::std::fmt::Debug for GESPitiviFormatterClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GESPitiviFormatterClass @ {:?}", self as *const _))
.finish()
}
}
#[repr(C)]
pub struct _GESPitiviFormatterPrivate(c_void);
pub type GESPitiviFormatterPrivate = *mut _GESPitiviFormatterPrivate;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GESProjectClass {
pub parent_class: GESAssetClass,
pub asset_added: Option<unsafe extern "C" fn(*mut GESProject, *mut GESAsset)>,
pub asset_loading: Option<unsafe extern "C" fn(*mut GESProject, *mut GESAsset)>,
pub asset_removed: Option<unsafe extern "C" fn(*mut GESProject, *mut GESAsset)>,
pub missing_uri: Option<
unsafe extern "C" fn(*mut GESProject, *mut glib::GError, *mut GESAsset) -> *mut c_char,
>,
pub loading_error: Option<
unsafe extern "C" fn(*mut GESProject, *mut glib::GError, *mut c_char, GType) -> gboolean,
>,
pub loaded: Option<unsafe extern "C" fn(*mut GESProject, *mut GESTimeline) -> gboolean>,
pub loading: Option<unsafe extern "C" fn(*mut GESProject, *mut GESTimeline)>,
pub _ges_reserved: [gpointer; 3],
}
impl ::std::fmt::Debug for GESProjectClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GESProjectClass @ {:?}", self as *const _))
.field("parent_class", &self.parent_class)
.field("asset_added", &self.asset_added)
.field("asset_loading", &self.asset_loading)
.field("asset_removed", &self.asset_removed)
.field("missing_uri", &self.missing_uri)
.field("loading_error", &self.loading_error)
.field("loaded", &self.loaded)
.field("loading", &self.loading)
.field("_ges_reserved", &self._ges_reserved)
.finish()
}
}
#[repr(C)]
pub struct _GESProjectPrivate(c_void);
pub type GESProjectPrivate = *mut _GESProjectPrivate;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GESSourceClass {
pub parent_class: GESTrackElementClass,
pub _ges_reserved: [gpointer; 4],
}
impl ::std::fmt::Debug for GESSourceClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GESSourceClass @ {:?}", self as *const _))
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GESSourceClipAssetClass {
pub parent_class: GESClipAssetClass,
}
impl ::std::fmt::Debug for GESSourceClipAssetClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GESSourceClipAssetClass @ {:?}", self as *const _))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GESSourceClipClass {
pub parent_class: GESClipClass,
pub _ges_reserved: [gpointer; 4],
}
impl ::std::fmt::Debug for GESSourceClipClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GESSourceClipClass @ {:?}", self as *const _))
.finish()
}
}
#[repr(C)]
pub struct _GESSourceClipPrivate(c_void);
pub type GESSourceClipPrivate = *mut _GESSourceClipPrivate;
#[repr(C)]
pub struct _GESSourcePrivate(c_void);
pub type GESSourcePrivate = *mut _GESSourcePrivate;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GESTestClipClass {
pub parent_class: GESSourceClipClass,
pub _ges_reserved: [gpointer; 4],
}
impl ::std::fmt::Debug for GESTestClipClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GESTestClipClass @ {:?}", self as *const _))
.finish()
}
}
#[repr(C)]
pub struct _GESTestClipPrivate(c_void);
pub type GESTestClipPrivate = *mut _GESTestClipPrivate;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GESTextOverlayClass {
pub parent_class: GESOperationClass,
pub _ges_reserved: [gpointer; 4],
}
impl ::std::fmt::Debug for GESTextOverlayClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GESTextOverlayClass @ {:?}", self as *const _))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GESTextOverlayClipClass {
pub parent_class: GESOverlayClipClass,
pub _ges_reserved: [gpointer; 4],
}
impl ::std::fmt::Debug for GESTextOverlayClipClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GESTextOverlayClipClass @ {:?}", self as *const _))
.finish()
}
}
#[repr(C)]
pub struct _GESTextOverlayClipPrivate(c_void);
pub type GESTextOverlayClipPrivate = *mut _GESTextOverlayClipPrivate;
#[repr(C)]
pub struct _GESTextOverlayPrivate(c_void);
pub type GESTextOverlayPrivate = *mut _GESTextOverlayPrivate;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GESTimelineClass {
pub parent_class: gst::GstBinClass,
pub track_added: Option<unsafe extern "C" fn(*mut GESTimeline, *mut GESTrack)>,
pub track_removed: Option<unsafe extern "C" fn(*mut GESTimeline, *mut GESTrack)>,
pub layer_added: Option<unsafe extern "C" fn(*mut GESTimeline, *mut GESLayer)>,
pub layer_removed: Option<unsafe extern "C" fn(*mut GESTimeline, *mut GESLayer)>,
pub group_added: Option<unsafe extern "C" fn(*mut GESTimeline, *mut GESGroup)>,
pub group_removed:
Option<unsafe extern "C" fn(*mut GESTimeline, *mut GESGroup, *mut glib::GPtrArray)>,
pub _ges_reserved: [gpointer; 4],
}
impl ::std::fmt::Debug for GESTimelineClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GESTimelineClass @ {:?}", self as *const _))
.field("parent_class", &self.parent_class)
.field("track_added", &self.track_added)
.field("track_removed", &self.track_removed)
.field("layer_added", &self.layer_added)
.field("layer_removed", &self.layer_removed)
.field("group_added", &self.group_added)
.field("group_removed", &self.group_removed)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GESTimelineElementClass {
pub parent_class: gobject::GInitiallyUnownedClass,
pub set_parent:
Option<unsafe extern "C" fn(*mut GESTimelineElement, *mut GESTimelineElement) -> gboolean>,
pub set_start:
Option<unsafe extern "C" fn(*mut GESTimelineElement, gst::GstClockTime) -> gboolean>,
pub set_inpoint:
Option<unsafe extern "C" fn(*mut GESTimelineElement, gst::GstClockTime) -> gboolean>,
pub set_duration:
Option<unsafe extern "C" fn(*mut GESTimelineElement, gst::GstClockTime) -> gboolean>,
pub set_max_duration:
Option<unsafe extern "C" fn(*mut GESTimelineElement, gst::GstClockTime) -> gboolean>,
pub set_priority: Option<unsafe extern "C" fn(*mut GESTimelineElement, u32) -> gboolean>,
pub ripple: Option<unsafe extern "C" fn(*mut GESTimelineElement, u64) -> gboolean>,
pub ripple_end: Option<unsafe extern "C" fn(*mut GESTimelineElement, u64) -> gboolean>,
pub roll_start: Option<unsafe extern "C" fn(*mut GESTimelineElement, u64) -> gboolean>,
pub roll_end: Option<unsafe extern "C" fn(*mut GESTimelineElement, u64) -> gboolean>,
pub trim: Option<unsafe extern "C" fn(*mut GESTimelineElement, u64) -> gboolean>,
pub deep_copy: Option<unsafe extern "C" fn(*mut GESTimelineElement, *mut GESTimelineElement)>,
pub paste: Option<
unsafe extern "C" fn(
*mut GESTimelineElement,
*mut GESTimelineElement,
gst::GstClockTime,
) -> *mut GESTimelineElement,
>,
pub list_children_properties: Option<
unsafe extern "C" fn(*mut GESTimelineElement, *mut c_uint) -> *mut *mut gobject::GParamSpec,
>,
pub lookup_child: Option<
unsafe extern "C" fn(
*mut GESTimelineElement,
*const c_char,
*mut *mut gobject::GObject,
*mut *mut gobject::GParamSpec,
) -> gboolean,
>,
pub get_track_types: Option<unsafe extern "C" fn(*mut GESTimelineElement) -> GESTrackType>,
pub set_child_property: Option<
unsafe extern "C" fn(
*mut GESTimelineElement,
*mut gobject::GObject,
*mut gobject::GParamSpec,
*mut gobject::GValue,
),
>,
pub get_layer_priority: Option<unsafe extern "C" fn(*mut GESTimelineElement) -> u32>,
pub get_natural_framerate:
Option<unsafe extern "C" fn(*mut GESTimelineElement, *mut c_int, *mut c_int) -> gboolean>,
pub set_child_property_full: Option<
unsafe extern "C" fn(
*mut GESTimelineElement,
*mut gobject::GObject,
*mut gobject::GParamSpec,
*const gobject::GValue,
*mut *mut glib::GError,
) -> gboolean,
>,
pub _ges_reserved: [gpointer; 14],
}
impl ::std::fmt::Debug for GESTimelineElementClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GESTimelineElementClass @ {:?}", self as *const _))
.field("parent_class", &self.parent_class)
.field("set_parent", &self.set_parent)
.field("set_start", &self.set_start)
.field("set_inpoint", &self.set_inpoint)
.field("set_duration", &self.set_duration)
.field("set_max_duration", &self.set_max_duration)
.field("set_priority", &self.set_priority)
.field("ripple", &self.ripple)
.field("ripple_end", &self.ripple_end)
.field("roll_start", &self.roll_start)
.field("roll_end", &self.roll_end)
.field("trim", &self.trim)
.field("deep_copy", &self.deep_copy)
.field("paste", &self.paste)
.field("list_children_properties", &self.list_children_properties)
.field("lookup_child", &self.lookup_child)
.field("get_track_types", &self.get_track_types)
.field("set_child_property", &self.set_child_property)
.field("get_layer_priority", &self.get_layer_priority)
.field("get_natural_framerate", &self.get_natural_framerate)
.field("set_child_property_full", &self.set_child_property_full)
.field("_ges_reserved", &self._ges_reserved)
.finish()
}
}
#[repr(C)]
pub struct _GESTimelineElementPrivate(c_void);
pub type GESTimelineElementPrivate = *mut _GESTimelineElementPrivate;
#[repr(C)]
pub struct _GESTimelinePrivate(c_void);
pub type GESTimelinePrivate = *mut _GESTimelinePrivate;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GESTitleClipClass {
pub parent_class: GESSourceClipClass,
pub _ges_reserved: [gpointer; 4],
}
impl ::std::fmt::Debug for GESTitleClipClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GESTitleClipClass @ {:?}", self as *const _))
.finish()
}
}
#[repr(C)]
pub struct _GESTitleClipPrivate(c_void);
pub type GESTitleClipPrivate = *mut _GESTitleClipPrivate;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GESTitleSourceClass {
pub parent_class: GESVideoSourceClass,
pub _ges_reserved: [gpointer; 3],
}
impl ::std::fmt::Debug for GESTitleSourceClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GESTitleSourceClass @ {:?}", self as *const _))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
pub struct _GESTitleSourcePrivate(c_void);
pub type GESTitleSourcePrivate = *mut _GESTitleSourcePrivate;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GESTrackClass {
pub parent_class: gst::GstBinClass,
pub get_mixing_element: Option<unsafe extern "C" fn(*mut GESTrack) -> *mut gst::GstElement>,
pub _ges_reserved: [gpointer; 4],
}
impl ::std::fmt::Debug for GESTrackClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GESTrackClass @ {:?}", self as *const _))
.field("get_mixing_element", &self.get_mixing_element)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GESTrackElementAssetClass {
pub parent_class: GESAssetClass,
pub get_natural_framerate:
Option<unsafe extern "C" fn(*mut GESTrackElementAsset, *mut c_int, *mut c_int) -> gboolean>,
pub _ges_reserved: [gpointer; 3],
}
impl ::std::fmt::Debug for GESTrackElementAssetClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"GESTrackElementAssetClass @ {:?}",
self as *const _
))
.field("parent_class", &self.parent_class)
.field("get_natural_framerate", &self.get_natural_framerate)
.field("_ges_reserved", &self._ges_reserved)
.finish()
}
}
#[repr(C)]
pub struct _GESTrackElementAssetPrivate(c_void);
pub type GESTrackElementAssetPrivate = *mut _GESTrackElementAssetPrivate;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GESTrackElementClass {
pub parent_class: GESTimelineElementClass,
pub nleobject_factorytype: *const c_char,
pub create_gnl_object:
Option<unsafe extern "C" fn(*mut GESTrackElement) -> *mut gst::GstElement>,
pub create_element: Option<unsafe extern "C" fn(*mut GESTrackElement) -> *mut gst::GstElement>,
pub active_changed: Option<unsafe extern "C" fn(*mut GESTrackElement, gboolean)>,
pub changed: Option<unsafe extern "C" fn(*mut GESTrackElement)>,
pub list_children_properties: Option<
unsafe extern "C" fn(*mut GESTrackElement, *mut c_uint) -> *mut *mut gobject::GParamSpec,
>,
pub lookup_child: Option<
unsafe extern "C" fn(
*mut GESTrackElement,
*const c_char,
*mut *mut gst::GstElement,
*mut *mut gobject::GParamSpec,
) -> gboolean,
>,
pub ABI: GESTrackElementClass_ABI,
}
impl ::std::fmt::Debug for GESTrackElementClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GESTrackElementClass @ {:?}", self as *const _))
.field("nleobject_factorytype", &self.nleobject_factorytype)
.field("create_gnl_object", &self.create_gnl_object)
.field("create_element", &self.create_element)
.field("active_changed", &self.active_changed)
.field("changed", &self.changed)
.field("list_children_properties", &self.list_children_properties)
.field("lookup_child", &self.lookup_child)
.field("ABI", &self.ABI)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GESTrackElementClass_ABI_abi {
pub default_has_internal_source: gboolean,
pub default_track_type: GESTrackType,
}
impl ::std::fmt::Debug for GESTrackElementClass_ABI_abi {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"GESTrackElementClass_ABI_abi @ {:?}",
self as *const _
))
.field(
"default_has_internal_source",
&self.default_has_internal_source,
)
.field("default_track_type", &self.default_track_type)
.finish()
}
}
#[repr(C)]
pub struct _GESTrackElementPrivate(c_void);
pub type GESTrackElementPrivate = *mut _GESTrackElementPrivate;
#[repr(C)]
pub struct _GESTrackPrivate(c_void);
pub type GESTrackPrivate = *mut _GESTrackPrivate;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GESTransitionClass {
pub parent_class: GESOperationClass,
pub _ges_reserved: [gpointer; 4],
}
impl ::std::fmt::Debug for GESTransitionClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GESTransitionClass @ {:?}", self as *const _))
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GESTransitionClipClass {
pub parent_class: GESBaseTransitionClipClass,
pub _ges_reserved: [gpointer; 4],
}
impl ::std::fmt::Debug for GESTransitionClipClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GESTransitionClipClass @ {:?}", self as *const _))
.finish()
}
}
#[repr(C)]
pub struct _GESTransitionClipPrivate(c_void);
pub type GESTransitionClipPrivate = *mut _GESTransitionClipPrivate;
#[repr(C)]
pub struct _GESTransitionPrivate(c_void);
pub type GESTransitionPrivate = *mut _GESTransitionPrivate;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GESUriClipAssetClass {
pub parent_class: GESSourceClipAssetClass,
pub discoverer: *mut gst_pbutils::GstDiscoverer,
pub sync_discoverer: *mut gst_pbutils::GstDiscoverer,
pub discovered: Option<
unsafe extern "C" fn(
*mut gst_pbutils::GstDiscoverer,
*mut gst_pbutils::GstDiscovererInfo,
*mut glib::GError,
gpointer,
),
>,
pub _ges_reserved: [gpointer; 3],
}
impl ::std::fmt::Debug for GESUriClipAssetClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GESUriClipAssetClass @ {:?}", self as *const _))
.field("parent_class", &self.parent_class)
.field("discovered", &self.discovered)
.finish()
}
}
#[repr(C)]
pub struct _GESUriClipAssetPrivate(c_void);
pub type GESUriClipAssetPrivate = *mut _GESUriClipAssetPrivate;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GESUriClipClass {
pub parent_class: GESSourceClipClass,
pub _ges_reserved: [gpointer; 4],
}
impl ::std::fmt::Debug for GESUriClipClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GESUriClipClass @ {:?}", self as *const _))
.finish()
}
}
#[repr(C)]
pub struct _GESUriClipPrivate(c_void);
pub type GESUriClipPrivate = *mut _GESUriClipPrivate;
#[repr(C)]
pub struct _GESUriSource(c_void);
pub type GESUriSource = *mut _GESUriSource;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GESUriSourceAssetClass {
pub parent_class: GESTrackElementAssetClass,
pub _ges_reserved: [gpointer; 4],
}
impl ::std::fmt::Debug for GESUriSourceAssetClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GESUriSourceAssetClass @ {:?}", self as *const _))
.field("parent_class", &self.parent_class)
.field("_ges_reserved", &self._ges_reserved)
.finish()
}
}
#[repr(C)]
pub struct _GESUriSourceAssetPrivate(c_void);
pub type GESUriSourceAssetPrivate = *mut _GESUriSourceAssetPrivate;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GESVideoSourceClass {
pub parent_class: GESSourceClass,
pub create_source: Option<unsafe extern "C" fn(*mut GESTrackElement) -> *mut gst::GstElement>,
pub ABI: GESVideoSourceClass_ABI,
}
impl ::std::fmt::Debug for GESVideoSourceClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GESVideoSourceClass @ {:?}", self as *const _))
.field("create_source", &self.create_source)
.field("ABI", &self.ABI)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GESVideoSourceClass_ABI_abi {
pub disable_scale_in_compositor: gboolean,
pub needs_converters: Option<unsafe extern "C" fn(*mut GESVideoSource) -> gboolean>,
pub get_natural_size:
Option<unsafe extern "C" fn(*mut GESVideoSource, *mut c_int, *mut c_int) -> gboolean>,
pub create_filters: Option<
unsafe extern "C" fn(*mut GESVideoSource, *mut glib::GPtrArray, gboolean) -> gboolean,
>,
}
impl ::std::fmt::Debug for GESVideoSourceClass_ABI_abi {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!(
"GESVideoSourceClass_ABI_abi @ {:?}",
self as *const _
))
.field(
"disable_scale_in_compositor",
&self.disable_scale_in_compositor,
)
.field("needs_converters", &self.needs_converters)
.field("get_natural_size", &self.get_natural_size)
.field("create_filters", &self.create_filters)
.finish()
}
}
#[repr(C)]
pub struct _GESVideoSourcePrivate(c_void);
pub type GESVideoSourcePrivate = *mut _GESVideoSourcePrivate;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GESVideoTestSourceClass {
pub parent_class: GESVideoSourceClass,
pub _ges_reserved: [gpointer; 4],
}
impl ::std::fmt::Debug for GESVideoTestSourceClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GESVideoTestSourceClass @ {:?}", self as *const _))
.field("parent_class", &self.parent_class)
.field("_ges_reserved", &self._ges_reserved)
.finish()
}
}
#[repr(C)]
pub struct _GESVideoTestSourcePrivate(c_void);
pub type GESVideoTestSourcePrivate = *mut _GESVideoTestSourcePrivate;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GESVideoTrackClass {
pub parent_class: GESTrackClass,
pub _ges_reserved: [gpointer; 4],
}
impl ::std::fmt::Debug for GESVideoTrackClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GESVideoTrackClass @ {:?}", self as *const _))
.field("parent_class", &self.parent_class)
.field("_ges_reserved", &self._ges_reserved)
.finish()
}
}
#[repr(C)]
pub struct _GESVideoTrackPrivate(c_void);
pub type GESVideoTrackPrivate = *mut _GESVideoTrackPrivate;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GESVideoTransitionClass {
pub parent_class: GESTransitionClass,
pub _ges_reserved: [gpointer; 4],
}
impl ::std::fmt::Debug for GESVideoTransitionClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GESVideoTransitionClass @ {:?}", self as *const _))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
pub struct _GESVideoTransitionPrivate(c_void);
pub type GESVideoTransitionPrivate = *mut _GESVideoTransitionPrivate;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GESVideoUriSourceClass {
pub parent_class: GESVideoSourceClass,
pub _ges_reserved: [gpointer; 4],
}
impl ::std::fmt::Debug for GESVideoUriSourceClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GESVideoUriSourceClass @ {:?}", self as *const _))
.finish()
}
}
#[repr(C)]
pub struct _GESVideoUriSourcePrivate(c_void);
pub type GESVideoUriSourcePrivate = *mut _GESVideoUriSourcePrivate;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GESXmlFormatterClass {
pub parent: GESBaseXmlFormatterClass,
pub _ges_reserved: [gpointer; 4],
}
impl ::std::fmt::Debug for GESXmlFormatterClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GESXmlFormatterClass @ {:?}", self as *const _))
.field("parent", &self.parent)
.field("_ges_reserved", &self._ges_reserved)
.finish()
}
}
#[repr(C)]
pub struct _GESXmlFormatterPrivate(c_void);
pub type GESXmlFormatterPrivate = *mut _GESXmlFormatterPrivate;
// Classes
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GESAsset {
pub parent: gobject::GObject,
pub priv_: *mut GESAssetPrivate,
pub _ges_reserved: [gpointer; 4],
}
impl ::std::fmt::Debug for GESAsset {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GESAsset @ {:?}", self as *const _))
.field("parent", &self.parent)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GESAudioSource {
pub parent: GESSource,
pub priv_: *mut GESAudioSourcePrivate,
pub _ges_reserved: [gpointer; 4],
}
impl ::std::fmt::Debug for GESAudioSource {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GESAudioSource @ {:?}", self as *const _))
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GESAudioTestSource {
pub parent: GESAudioSource,
pub priv_: *mut GESAudioTestSourcePrivate,
pub _ges_reserved: [gpointer; 4],
}
impl ::std::fmt::Debug for GESAudioTestSource {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GESAudioTestSource @ {:?}", self as *const _))
.field("parent", &self.parent)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GESAudioTrack {
pub parent_instance: GESTrack,
pub priv_: *mut GESAudioTrackPrivate,
pub _ges_reserved: [gpointer; 4],
}
impl ::std::fmt::Debug for GESAudioTrack {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GESAudioTrack @ {:?}", self as *const _))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GESAudioTransition {
pub parent: GESTransition,
pub priv_: *mut GESAudioTransitionPrivate,
pub _ges_reserved: [gpointer; 4],
}
impl ::std::fmt::Debug for GESAudioTransition {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GESAudioTransition @ {:?}", self as *const _))
.field("parent", &self.parent)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GESAudioUriSource {
pub parent: GESAudioSource,
pub uri: *mut c_char,
pub priv_: *mut GESUriSource,
pub _ges_reserved: [gpointer; 4],
}
impl ::std::fmt::Debug for GESAudioUriSource {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GESAudioUriSource @ {:?}", self as *const _))
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GESBaseEffect {
pub parent: GESOperation,
pub priv_: *mut GESBaseEffectPrivate,
pub _ges_reserved: [gpointer; 4],
}
impl ::std::fmt::Debug for GESBaseEffect {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GESBaseEffect @ {:?}", self as *const _))
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GESBaseEffectClip {
pub parent: GESOperationClip,
pub priv_: *mut GESBaseEffectClipPrivate,
pub _ges_reserved: [gpointer; 4],
}
impl ::std::fmt::Debug for GESBaseEffectClip {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GESBaseEffectClip @ {:?}", self as *const _))
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GESBaseTransitionClip {
pub parent: GESOperationClip,
pub priv_: *mut GESBaseTransitionClipPrivate,
pub _ges_reserved: [gpointer; 4],
}
impl ::std::fmt::Debug for GESBaseTransitionClip {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GESBaseTransitionClip @ {:?}", self as *const _))
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GESBaseXmlFormatter {
pub parent: GESFormatter,
pub priv_: *mut GESBaseXmlFormatterPrivate,
pub xmlcontent: *mut c_char,
pub _ges_reserved: [gpointer; 3],
}
impl ::std::fmt::Debug for GESBaseXmlFormatter {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GESBaseXmlFormatter @ {:?}", self as *const _))
.field("parent", &self.parent)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GESClip {
pub parent: GESContainer,
pub priv_: *mut GESClipPrivate,
pub _ges_reserved: [gpointer; 20],
}
impl ::std::fmt::Debug for GESClip {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GESClip @ {:?}", self as *const _))
.field("parent", &self.parent)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GESClipAsset {
pub parent: GESAsset,
pub priv_: *mut GESClipAssetPrivate,
pub _ges_reserved: [gpointer; 4],
}
impl ::std::fmt::Debug for GESClipAsset {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GESClipAsset @ {:?}", self as *const _))
.field("parent", &self.parent)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GESCommandLineFormatter {
pub parent_instance: GESFormatter,
pub priv_: *mut GESCommandLineFormatterPrivate,
}
impl ::std::fmt::Debug for GESCommandLineFormatter {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GESCommandLineFormatter @ {:?}", self as *const _))
.field("parent_instance", &self.parent_instance)
.field("priv_", &self.priv_)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GESContainer {
pub parent: GESTimelineElement,
pub children: *mut glib::GList,
pub height: u32,
pub children_control_mode: GESChildrenControlMode,
pub initiated_move: *mut GESTimelineElement,
pub priv_: *mut GESContainerPrivate,
pub _ges_reserved: [gpointer; 20],
}
impl ::std::fmt::Debug for GESContainer {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GESContainer @ {:?}", self as *const _))
.field("parent", &self.parent)
.field("children", &self.children)
.field("height", &self.height)
.field("children_control_mode", &self.children_control_mode)
.field("initiated_move", &self.initiated_move)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GESEffect {
pub parent: GESBaseEffect,
pub priv_: *mut GESEffectPrivate,
pub _ges_reserved: [gpointer; 4],
}
impl ::std::fmt::Debug for GESEffect {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GESEffect @ {:?}", self as *const _))
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GESEffectAsset {
pub parent_instance: GESTrackElementAsset,
pub priv_: *mut GESEffectAssetPrivate,
pub _ges_reserved: [gpointer; 4],
}
impl ::std::fmt::Debug for GESEffectAsset {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GESEffectAsset @ {:?}", self as *const _))
.field("parent_instance", &self.parent_instance)
.field("priv_", &self.priv_)
.field("_ges_reserved", &self._ges_reserved)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GESEffectClip {
pub parent: GESBaseEffectClip,
pub priv_: *mut GESEffectClipPrivate,
pub _ges_reserved: [gpointer; 4],
}
impl ::std::fmt::Debug for GESEffectClip {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GESEffectClip @ {:?}", self as *const _))
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GESFormatter {
pub parent: gobject::GInitiallyUnowned,
pub priv_: *mut GESFormatterPrivate,
pub project: *mut GESProject,
pub timeline: *mut GESTimeline,
pub _ges_reserved: [gpointer; 4],
}
impl ::std::fmt::Debug for GESFormatter {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GESFormatter @ {:?}", self as *const _))
.field("parent", &self.parent)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GESGroup {
pub parent: GESContainer,
pub priv_: *mut GESGroupPrivate,
pub _ges_reserved: [gpointer; 4],
}
impl ::std::fmt::Debug for GESGroup {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GESGroup @ {:?}", self as *const _))
.field("parent", &self.parent)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GESImageSource {
pub parent: GESVideoSource,
pub uri: *mut c_char,
pub priv_: *mut GESImageSourcePrivate,
pub _ges_reserved: [gpointer; 4],
}
impl ::std::fmt::Debug for GESImageSource {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GESImageSource @ {:?}", self as *const _))
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GESLayer {
pub parent: gobject::GInitiallyUnowned,
pub timeline: *mut GESTimeline,
pub min_nle_priority: u32,
pub max_nle_priority: u32,
pub priv_: *mut GESLayerPrivate,
pub _ges_reserved: [gpointer; 4],
}
impl ::std::fmt::Debug for GESLayer {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GESLayer @ {:?}", self as *const _))
.field("parent", &self.parent)
.field("timeline", &self.timeline)
.field("min_nle_priority", &self.min_nle_priority)
.field("max_nle_priority", &self.max_nle_priority)
.field("priv_", &self.priv_)
.field("_ges_reserved", &self._ges_reserved)
.finish()
}
}
#[repr(C)]
pub struct GESMarker(c_void);
impl ::std::fmt::Debug for GESMarker {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GESMarker @ {:?}", self as *const _))
.finish()
}
}
#[repr(C)]
pub struct GESMarkerList(c_void);
impl ::std::fmt::Debug for GESMarkerList {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GESMarkerList @ {:?}", self as *const _))
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GESMultiFileSource {
pub parent: GESVideoSource,
pub uri: *mut c_char,
pub priv_: *mut GESMultiFileSourcePrivate,
pub _ges_reserved: [gpointer; 4],
}
impl ::std::fmt::Debug for GESMultiFileSource {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GESMultiFileSource @ {:?}", self as *const _))
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GESOperation {
pub parent: GESTrackElement,
pub priv_: *mut GESOperationPrivate,
pub _ges_reserved: [gpointer; 4],
}
impl ::std::fmt::Debug for GESOperation {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GESOperation @ {:?}", self as *const _))
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GESOperationClip {
pub parent: GESClip,
pub priv_: *mut GESOperationClipPrivate,
pub _ges_reserved: [gpointer; 4],
}
impl ::std::fmt::Debug for GESOperationClip {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GESOperationClip @ {:?}", self as *const _))
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GESOverlayClip {
pub parent: GESOperationClip,
pub priv_: *mut GESOverlayClipPrivate,
pub _ges_reserved: [gpointer; 4],
}
impl ::std::fmt::Debug for GESOverlayClip {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GESOverlayClip @ {:?}", self as *const _))
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GESPipeline {
pub parent: gst::GstPipeline,
pub priv_: *mut GESPipelinePrivate,
pub _ges_reserved: [gpointer; 4],
}
impl ::std::fmt::Debug for GESPipeline {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GESPipeline @ {:?}", self as *const _))
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GESPitiviFormatter {
pub parent: GESFormatter,
pub priv_: *mut GESPitiviFormatterPrivate,
pub _ges_reserved: [gpointer; 4],
}
impl ::std::fmt::Debug for GESPitiviFormatter {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GESPitiviFormatter @ {:?}", self as *const _))
.field("parent", &self.parent)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GESProject {
pub parent: GESAsset,
pub priv_: *mut GESProjectPrivate,
pub __ges_reserved: [gpointer; 20],
}
impl ::std::fmt::Debug for GESProject {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GESProject @ {:?}", self as *const _))
.field("parent", &self.parent)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GESSource {
pub parent: GESTrackElement,
pub priv_: *mut GESSourcePrivate,
pub _ges_reserved: [gpointer; 4],
}
impl ::std::fmt::Debug for GESSource {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GESSource @ {:?}", self as *const _))
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GESSourceClip {
pub parent: GESClip,
pub priv_: *mut GESSourceClipPrivate,
pub _ges_reserved: [gpointer; 4],
}
impl ::std::fmt::Debug for GESSourceClip {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GESSourceClip @ {:?}", self as *const _))
.field("parent", &self.parent)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GESSourceClipAsset {
pub parent_instance: GESClipAsset,
}
impl ::std::fmt::Debug for GESSourceClipAsset {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GESSourceClipAsset @ {:?}", self as *const _))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GESTestClip {
pub parent: GESSourceClip,
pub priv_: *mut GESTestClipPrivate,
pub _ges_reserved: [gpointer; 4],
}
impl ::std::fmt::Debug for GESTestClip {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GESTestClip @ {:?}", self as *const _))
.field("parent", &self.parent)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GESTextOverlay {
pub parent: GESOperation,
pub priv_: *mut GESTextOverlayPrivate,
pub _ges_reserved: [gpointer; 4],
}
impl ::std::fmt::Debug for GESTextOverlay {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GESTextOverlay @ {:?}", self as *const _))
.field("parent", &self.parent)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GESTextOverlayClip {
pub parent: GESOverlayClip,
pub priv_: *mut GESTextOverlayClipPrivate,
pub _ges_reserved: [gpointer; 4],
}
impl ::std::fmt::Debug for GESTextOverlayClip {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GESTextOverlayClip @ {:?}", self as *const _))
.field("parent", &self.parent)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GESTimeline {
pub parent: gst::GstBin,
pub layers: *mut glib::GList,
pub tracks: *mut glib::GList,
pub priv_: *mut GESTimelinePrivate,
pub _ges_reserved: [gpointer; 4],
}
impl ::std::fmt::Debug for GESTimeline {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GESTimeline @ {:?}", self as *const _))
.field("parent", &self.parent)
.field("layers", &self.layers)
.field("tracks", &self.tracks)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GESTimelineElement {
pub parent_instance: gobject::GInitiallyUnowned,
pub parent: *mut GESTimelineElement,
pub asset: *mut GESAsset,
pub start: gst::GstClockTime,
pub inpoint: gst::GstClockTime,
pub duration: gst::GstClockTime,
pub maxduration: gst::GstClockTime,
pub priority: u32,
pub timeline: *mut GESTimeline,
pub name: *mut c_char,
pub priv_: *mut GESTimelineElementPrivate,
pub _ges_reserved: [gpointer; 20],
}
impl ::std::fmt::Debug for GESTimelineElement {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GESTimelineElement @ {:?}", self as *const _))
.field("parent_instance", &self.parent_instance)
.field("parent", &self.parent)
.field("asset", &self.asset)
.field("start", &self.start)
.field("inpoint", &self.inpoint)
.field("duration", &self.duration)
.field("maxduration", &self.maxduration)
.field("priority", &self.priority)
.field("timeline", &self.timeline)
.field("name", &self.name)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GESTitleClip {
pub parent: GESSourceClip,
pub priv_: *mut GESTitleClipPrivate,
pub _ges_reserved: [gpointer; 4],
}
impl ::std::fmt::Debug for GESTitleClip {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GESTitleClip @ {:?}", self as *const _))
.field("parent", &self.parent)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GESTitleSource {
pub parent: GESVideoSource,
pub priv_: *mut GESTitleSourcePrivate,
pub _ges_reserved: [gpointer; 4],
}
impl ::std::fmt::Debug for GESTitleSource {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GESTitleSource @ {:?}", self as *const _))
.field("parent", &self.parent)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GESTrack {
pub parent: gst::GstBin,
pub type_: GESTrackType,
pub priv_: *mut GESTrackPrivate,
pub _ges_reserved: [gpointer; 4],
}
impl ::std::fmt::Debug for GESTrack {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GESTrack @ {:?}", self as *const _))
.field("parent", &self.parent)
.field("type_", &self.type_)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GESTrackElement {
pub parent: GESTimelineElement,
pub active: gboolean,
pub priv_: *mut GESTrackElementPrivate,
pub asset: *mut GESAsset,
pub _ges_reserved: [gpointer; 20],
}
impl ::std::fmt::Debug for GESTrackElement {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GESTrackElement @ {:?}", self as *const _))
.field("parent", &self.parent)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GESTrackElementAsset {
pub parent: GESAsset,
pub priv_: *mut GESTrackElementAssetPrivate,
pub __ges_reserved: [gpointer; 4],
}
impl ::std::fmt::Debug for GESTrackElementAsset {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GESTrackElementAsset @ {:?}", self as *const _))
.field("parent", &self.parent)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GESTransition {
pub parent: GESOperation,
pub priv_: *mut GESTransitionPrivate,
pub _ges_reserved: [gpointer; 4],
}
impl ::std::fmt::Debug for GESTransition {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GESTransition @ {:?}", self as *const _))
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GESTransitionClip {
pub parent: GESBaseTransitionClip,
pub vtype: GESVideoStandardTransitionType,
pub priv_: *mut GESTransitionClipPrivate,
pub _ges_reserved: [gpointer; 4],
}
impl ::std::fmt::Debug for GESTransitionClip {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GESTransitionClip @ {:?}", self as *const _))
.field("vtype", &self.vtype)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GESUriClip {
pub parent: GESSourceClip,
pub priv_: *mut GESUriClipPrivate,
pub _ges_reserved: [gpointer; 4],
}
impl ::std::fmt::Debug for GESUriClip {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GESUriClip @ {:?}", self as *const _))
.field("parent", &self.parent)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GESUriClipAsset {
pub parent: GESSourceClipAsset,
pub priv_: *mut GESUriClipAssetPrivate,
pub __ges_reserved: [gpointer; 4],
}
impl ::std::fmt::Debug for GESUriClipAsset {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GESUriClipAsset @ {:?}", self as *const _))
.field("parent", &self.parent)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GESUriSourceAsset {
pub parent: GESTrackElementAsset,
pub priv_: *mut GESUriSourceAssetPrivate,
pub __ges_reserved: [gpointer; 4],
}
impl ::std::fmt::Debug for GESUriSourceAsset {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GESUriSourceAsset @ {:?}", self as *const _))
.field("parent", &self.parent)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GESVideoSource {
pub parent: GESSource,
pub priv_: *mut GESVideoSourcePrivate,
pub _ges_reserved: [gpointer; 4],
}
impl ::std::fmt::Debug for GESVideoSource {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GESVideoSource @ {:?}", self as *const _))
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GESVideoTestSource {
pub parent: GESVideoSource,
pub priv_: *mut GESVideoTestSourcePrivate,
pub _ges_reserved: [gpointer; 4],
}
impl ::std::fmt::Debug for GESVideoTestSource {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GESVideoTestSource @ {:?}", self as *const _))
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GESVideoTrack {
pub parent_instance: GESTrack,
pub priv_: *mut GESVideoTrackPrivate,
pub _ges_reserved: [gpointer; 4],
}
impl ::std::fmt::Debug for GESVideoTrack {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GESVideoTrack @ {:?}", self as *const _))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GESVideoTransition {
pub parent: GESTransition,
pub priv_: *mut GESVideoTransitionPrivate,
pub _ges_reserved: [gpointer; 4],
}
impl ::std::fmt::Debug for GESVideoTransition {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GESVideoTransition @ {:?}", self as *const _))
.field("parent", &self.parent)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GESVideoUriSource {
pub parent: GESVideoSource,
pub uri: *mut c_char,
pub priv_: *mut GESUriSource,
pub _ges_reserved: [gpointer; 4],
}
impl ::std::fmt::Debug for GESVideoUriSource {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GESVideoUriSource @ {:?}", self as *const _))
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GESXmlFormatter {
pub parent: GESBaseXmlFormatter,
pub priv_: *mut GESXmlFormatterPrivate,
pub _ges_reserved: [gpointer; 4],
}
impl ::std::fmt::Debug for GESXmlFormatter {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GESXmlFormatter @ {:?}", self as *const _))
.field("parent", &self.parent)
.field("priv_", &self.priv_)
.field("_ges_reserved", &self._ges_reserved)
.finish()
}
}
// Interfaces
#[repr(C)]
pub struct GESExtractable(c_void);
impl ::std::fmt::Debug for GESExtractable {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GESExtractable @ {:?}", self as *const _)
}
}
#[repr(C)]
pub struct GESMetaContainer(c_void);
impl ::std::fmt::Debug for GESMetaContainer {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GESMetaContainer @ {:?}", self as *const _)
}
}
#[link(name = "ges-1.0")]
extern "C" {
//=========================================================================
// GESEdge
//=========================================================================
pub fn ges_edge_get_type() -> GType;
#[cfg(any(feature = "v1_16", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_16")))]
pub fn ges_edge_name(edge: GESEdge) -> *const c_char;
//=========================================================================
// GESEditMode
//=========================================================================
pub fn ges_edit_mode_get_type() -> GType;
#[cfg(any(feature = "v1_18", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
pub fn ges_edit_mode_name(mode: GESEditMode) -> *const c_char;
//=========================================================================
// GESTextHAlign
//=========================================================================
pub fn ges_text_halign_get_type() -> GType;
//=========================================================================
// GESTextVAlign
//=========================================================================
pub fn ges_text_valign_get_type() -> GType;
//=========================================================================
// GESVideoStandardTransitionType
//=========================================================================
pub fn ges_video_standard_transition_type_get_type() -> GType;
//=========================================================================
// GESVideoTestPattern
//=========================================================================
pub fn ges_video_test_pattern_get_type() -> GType;
//=========================================================================
// GESMetaFlag
//=========================================================================
pub fn ges_meta_flag_get_type() -> GType;
//=========================================================================
// GESPipelineFlags
//=========================================================================
pub fn ges_pipeline_flags_get_type() -> GType;
//=========================================================================
// GESTrackType
//=========================================================================
pub fn ges_track_type_get_type() -> GType;
pub fn ges_track_type_name(type_: GESTrackType) -> *const c_char;
//=========================================================================
// GESEffectClass
//=========================================================================
pub fn ges_effect_class_register_rate_property(
klass: *mut GESEffectClass,
element_name: *const c_char,
property_name: *const c_char,
) -> gboolean;
//=========================================================================
// GESFormatterClass
//=========================================================================
pub fn ges_formatter_class_register_metas(
klass: *mut GESFormatterClass,
name: *const c_char,
description: *const c_char,
extensions: *const c_char,
caps: *const c_char,
version: c_double,
rank: gst::GstRank,
);
//=========================================================================
// GESUriClipAssetClass
//=========================================================================
pub fn ges_uri_clip_asset_class_set_timeout(
klass: *mut GESUriClipAssetClass,
timeout: gst::GstClockTime,
);
//=========================================================================
// GESAsset
//=========================================================================
pub fn ges_asset_get_type() -> GType;
pub fn ges_asset_needs_reload(extractable_type: GType, id: *const c_char) -> gboolean;
pub fn ges_asset_request(
extractable_type: GType,
id: *const c_char,
error: *mut *mut glib::GError,
) -> *mut GESAsset;
pub fn ges_asset_request_async(
extractable_type: GType,
id: *const c_char,
cancellable: *mut gio::GCancellable,
callback: gio::GAsyncReadyCallback,
user_data: gpointer,
);
pub fn ges_asset_request_finish(
res: *mut gio::GAsyncResult,
error: *mut *mut glib::GError,
) -> *mut GESAsset;
pub fn ges_asset_extract(
self_: *mut GESAsset,
error: *mut *mut glib::GError,
) -> *mut GESExtractable;
pub fn ges_asset_get_error(self_: *mut GESAsset) -> *mut glib::GError;
pub fn ges_asset_get_extractable_type(self_: *mut GESAsset) -> GType;
pub fn ges_asset_get_id(self_: *mut GESAsset) -> *const c_char;
pub fn ges_asset_get_proxy(asset: *mut GESAsset) -> *mut GESAsset;
pub fn ges_asset_get_proxy_target(proxy: *mut GESAsset) -> *mut GESAsset;
pub fn ges_asset_list_proxies(asset: *mut GESAsset) -> *mut glib::GList;
pub fn ges_asset_set_proxy(asset: *mut GESAsset, proxy: *mut GESAsset) -> gboolean;
pub fn ges_asset_unproxy(asset: *mut GESAsset, proxy: *mut GESAsset) -> gboolean;
//=========================================================================
// GESAudioSource
//=========================================================================
pub fn ges_audio_source_get_type() -> GType;
//=========================================================================
// GESAudioTestSource
//=========================================================================
pub fn ges_audio_test_source_get_type() -> GType;
pub fn ges_audio_test_source_get_freq(self_: *mut GESAudioTestSource) -> c_double;
pub fn ges_audio_test_source_get_volume(self_: *mut GESAudioTestSource) -> c_double;
pub fn ges_audio_test_source_set_freq(self_: *mut GESAudioTestSource, freq: c_double);
pub fn ges_audio_test_source_set_volume(self_: *mut GESAudioTestSource, volume: c_double);
//=========================================================================
// GESAudioTrack
//=========================================================================
pub fn ges_audio_track_get_type() -> GType;
pub fn ges_audio_track_new() -> *mut GESAudioTrack;
//=========================================================================
// GESAudioTransition
//=========================================================================
pub fn ges_audio_transition_get_type() -> GType;
pub fn ges_audio_transition_new() -> *mut GESAudioTransition;
//=========================================================================
// GESAudioUriSource
//=========================================================================
pub fn ges_audio_uri_source_get_type() -> GType;
//=========================================================================
// GESBaseEffect
//=========================================================================
pub fn ges_base_effect_get_type() -> GType;
#[cfg(any(feature = "v1_18", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
pub fn ges_base_effect_is_time_effect(effect: *mut GESBaseEffect) -> gboolean;
#[cfg(any(feature = "v1_18", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
pub fn ges_base_effect_register_time_property(
effect: *mut GESBaseEffect,
child_property_name: *const c_char,
) -> gboolean;
#[cfg(any(feature = "v1_18", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
pub fn ges_base_effect_set_time_translation_funcs(
effect: *mut GESBaseEffect,
source_to_sink_func: GESBaseEffectTimeTranslationFunc,
sink_to_source_func: GESBaseEffectTimeTranslationFunc,
user_data: gpointer,
destroy: glib::GDestroyNotify,
) -> gboolean;
//=========================================================================
// GESBaseEffectClip
//=========================================================================
pub fn ges_base_effect_clip_get_type() -> GType;
//=========================================================================
// GESBaseTransitionClip
//=========================================================================
pub fn ges_base_transition_clip_get_type() -> GType;
//=========================================================================
// GESBaseXmlFormatter
//=========================================================================
pub fn ges_base_xml_formatter_get_type() -> GType;
//=========================================================================
// GESClip
//=========================================================================
pub fn ges_clip_get_type() -> GType;
pub fn ges_clip_add_asset(clip: *mut GESClip, asset: *mut GESAsset) -> *mut GESTrackElement;
#[cfg(any(feature = "v1_18", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
pub fn ges_clip_add_child_to_track(
clip: *mut GESClip,
child: *mut GESTrackElement,
track: *mut GESTrack,
error: *mut *mut glib::GError,
) -> *mut GESTrackElement;
#[cfg(any(feature = "v1_18", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
pub fn ges_clip_add_top_effect(
clip: *mut GESClip,
effect: *mut GESBaseEffect,
index: c_int,
error: *mut *mut glib::GError,
) -> gboolean;
pub fn ges_clip_find_track_element(
clip: *mut GESClip,
track: *mut GESTrack,
type_: GType,
) -> *mut GESTrackElement;
pub fn ges_clip_find_track_elements(
clip: *mut GESClip,
track: *mut GESTrack,
track_type: GESTrackType,
type_: GType,
) -> *mut glib::GList;
#[cfg(any(feature = "v1_18", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
pub fn ges_clip_get_duration_limit(clip: *mut GESClip) -> gst::GstClockTime;
#[cfg(any(feature = "v1_18", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
pub fn ges_clip_get_internal_time_from_timeline_time(
clip: *mut GESClip,
child: *mut GESTrackElement,
timeline_time: gst::GstClockTime,
error: *mut *mut glib::GError,
) -> gst::GstClockTime;
pub fn ges_clip_get_layer(clip: *mut GESClip) -> *mut GESLayer;
pub fn ges_clip_get_supported_formats(clip: *mut GESClip) -> GESTrackType;
#[cfg(any(feature = "v1_18", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
pub fn ges_clip_get_timeline_time_from_internal_time(
clip: *mut GESClip,
child: *mut GESTrackElement,
internal_time: gst::GstClockTime,
error: *mut *mut glib::GError,
) -> gst::GstClockTime;
#[cfg(any(feature = "v1_18", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
pub fn ges_clip_get_timeline_time_from_source_frame(
clip: *mut GESClip,
frame_number: GESFrameNumber,
error: *mut *mut glib::GError,
) -> gst::GstClockTime;
pub fn ges_clip_get_top_effect_index(clip: *mut GESClip, effect: *mut GESBaseEffect) -> c_int;
pub fn ges_clip_get_top_effect_position(
clip: *mut GESClip,
effect: *mut GESBaseEffect,
) -> c_int;
pub fn ges_clip_get_top_effects(clip: *mut GESClip) -> *mut glib::GList;
pub fn ges_clip_move_to_layer(clip: *mut GESClip, layer: *mut GESLayer) -> gboolean;
#[cfg(any(feature = "v1_18", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
pub fn ges_clip_move_to_layer_full(
clip: *mut GESClip,
layer: *mut GESLayer,
error: *mut *mut glib::GError,
) -> gboolean;
#[cfg(any(feature = "v1_18", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
pub fn ges_clip_remove_top_effect(
clip: *mut GESClip,
effect: *mut GESBaseEffect,
error: *mut *mut glib::GError,
) -> gboolean;
pub fn ges_clip_set_supported_formats(clip: *mut GESClip, supportedformats: GESTrackType);
pub fn ges_clip_set_top_effect_index(
clip: *mut GESClip,
effect: *mut GESBaseEffect,
newindex: c_uint,
) -> gboolean;
#[cfg(any(feature = "v1_18", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
pub fn ges_clip_set_top_effect_index_full(
clip: *mut GESClip,
effect: *mut GESBaseEffect,
newindex: c_uint,
error: *mut *mut glib::GError,
) -> gboolean;
pub fn ges_clip_set_top_effect_priority(
clip: *mut GESClip,
effect: *mut GESBaseEffect,
newpriority: c_uint,
) -> gboolean;
pub fn ges_clip_split(clip: *mut GESClip, position: u64) -> *mut GESClip;
#[cfg(any(feature = "v1_18", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
pub fn ges_clip_split_full(
clip: *mut GESClip,
position: u64,
error: *mut *mut glib::GError,
) -> *mut GESClip;
//=========================================================================
// GESClipAsset
//=========================================================================
pub fn ges_clip_asset_get_type() -> GType;
#[cfg(any(feature = "v1_18", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
pub fn ges_clip_asset_get_frame_time(
self_: *mut GESClipAsset,
frame_number: GESFrameNumber,
) -> gst::GstClockTime;
#[cfg(any(feature = "v1_18", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
pub fn ges_clip_asset_get_natural_framerate(
self_: *mut GESClipAsset,
framerate_n: *mut c_int,
framerate_d: *mut c_int,
) -> gboolean;
pub fn ges_clip_asset_get_supported_formats(self_: *mut GESClipAsset) -> GESTrackType;
pub fn ges_clip_asset_set_supported_formats(
self_: *mut GESClipAsset,
supportedformats: GESTrackType,
);
//=========================================================================
// GESCommandLineFormatter
//=========================================================================
pub fn ges_command_line_formatter_get_type() -> GType;
pub fn ges_command_line_formatter_get_help(
nargs: c_int,
commands: *mut *mut c_char,
) -> *mut c_char;
//=========================================================================
// GESContainer
//=========================================================================
pub fn ges_container_get_type() -> GType;
pub fn ges_container_group(containers: *mut glib::GList) -> *mut GESContainer;
pub fn ges_container_add(
container: *mut GESContainer,
child: *mut GESTimelineElement,
) -> gboolean;
pub fn ges_container_edit(
container: *mut GESContainer,
layers: *mut glib::GList,
new_layer_priority: c_int,
mode: GESEditMode,
edge: GESEdge,
position: u64,
) -> gboolean;
pub fn ges_container_get_children(
container: *mut GESContainer,
recursive: gboolean,
) -> *mut glib::GList;
pub fn ges_container_remove(
container: *mut GESContainer,
child: *mut GESTimelineElement,
) -> gboolean;
pub fn ges_container_ungroup(
container: *mut GESContainer,
recursive: gboolean,
) -> *mut glib::GList;
//=========================================================================
// GESEffect
//=========================================================================
pub fn ges_effect_get_type() -> GType;
pub fn ges_effect_new(bin_description: *const c_char) -> *mut GESEffect;
//=========================================================================
// GESEffectAsset
//=========================================================================
pub fn ges_effect_asset_get_type() -> GType;
//=========================================================================
// GESEffectClip
//=========================================================================
pub fn ges_effect_clip_get_type() -> GType;
pub fn ges_effect_clip_new(
video_bin_description: *const c_char,
audio_bin_description: *const c_char,
) -> *mut GESEffectClip;
//=========================================================================
// GESFormatter
//=========================================================================
pub fn ges_formatter_get_type() -> GType;
pub fn ges_formatter_can_load_uri(
uri: *const c_char,
error: *mut *mut glib::GError,
) -> gboolean;
pub fn ges_formatter_can_save_uri(
uri: *const c_char,
error: *mut *mut glib::GError,
) -> gboolean;
pub fn ges_formatter_get_default() -> *mut GESAsset;
pub fn ges_formatter_load_from_uri(
formatter: *mut GESFormatter,
timeline: *mut GESTimeline,
uri: *const c_char,
error: *mut *mut glib::GError,
) -> gboolean;
pub fn ges_formatter_save_to_uri(
formatter: *mut GESFormatter,
timeline: *mut GESTimeline,
uri: *const c_char,
overwrite: gboolean,
error: *mut *mut glib::GError,
) -> gboolean;
//=========================================================================
// GESGroup
//=========================================================================
pub fn ges_group_get_type() -> GType;
pub fn ges_group_new() -> *mut GESGroup;
//=========================================================================
// GESImageSource
//=========================================================================
pub fn ges_image_source_get_type() -> GType;
//=========================================================================
// GESLayer
//=========================================================================
pub fn ges_layer_get_type() -> GType;
pub fn ges_layer_new() -> *mut GESLayer;
pub fn ges_layer_add_asset(
layer: *mut GESLayer,
asset: *mut GESAsset,
start: gst::GstClockTime,
inpoint: gst::GstClockTime,
duration: gst::GstClockTime,
track_types: GESTrackType,
) -> *mut GESClip;
#[cfg(any(feature = "v1_18", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
pub fn ges_layer_add_asset_full(
layer: *mut GESLayer,
asset: *mut GESAsset,
start: gst::GstClockTime,
inpoint: gst::GstClockTime,
duration: gst::GstClockTime,
track_types: GESTrackType,
error: *mut *mut glib::GError,
) -> *mut GESClip;
pub fn ges_layer_add_clip(layer: *mut GESLayer, clip: *mut GESClip) -> gboolean;
#[cfg(any(feature = "v1_18", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
pub fn ges_layer_add_clip_full(
layer: *mut GESLayer,
clip: *mut GESClip,
error: *mut *mut glib::GError,
) -> gboolean;
#[cfg(any(feature = "v1_18", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
pub fn ges_layer_get_active_for_track(layer: *mut GESLayer, track: *mut GESTrack) -> gboolean;
pub fn ges_layer_get_auto_transition(layer: *mut GESLayer) -> gboolean;
pub fn ges_layer_get_clips(layer: *mut GESLayer) -> *mut glib::GList;
pub fn ges_layer_get_clips_in_interval(
layer: *mut GESLayer,
start: gst::GstClockTime,
end: gst::GstClockTime,
) -> *mut glib::GList;
pub fn ges_layer_get_duration(layer: *mut GESLayer) -> gst::GstClockTime;
pub fn ges_layer_get_priority(layer: *mut GESLayer) -> c_uint;
pub fn ges_layer_get_timeline(layer: *mut GESLayer) -> *mut GESTimeline;
pub fn ges_layer_is_empty(layer: *mut GESLayer) -> gboolean;
pub fn ges_layer_remove_clip(layer: *mut GESLayer, clip: *mut GESClip) -> gboolean;
#[cfg(any(feature = "v1_18", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
pub fn ges_layer_set_active_for_tracks(
layer: *mut GESLayer,
active: gboolean,
tracks: *mut glib::GList,
) -> gboolean;
pub fn ges_layer_set_auto_transition(layer: *mut GESLayer, auto_transition: gboolean);
pub fn ges_layer_set_priority(layer: *mut GESLayer, priority: c_uint);
pub fn ges_layer_set_timeline(layer: *mut GESLayer, timeline: *mut GESTimeline);
//=========================================================================
// GESMarker
//=========================================================================
#[cfg(any(feature = "v1_18", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
pub fn ges_marker_get_type() -> GType;
//=========================================================================
// GESMarkerList
//=========================================================================
#[cfg(any(feature = "v1_18", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
pub fn ges_marker_list_get_type() -> GType;
#[cfg(any(feature = "v1_18", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
pub fn ges_marker_list_new() -> *mut GESMarkerList;
#[cfg(any(feature = "v1_18", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
pub fn ges_marker_list_add(
list: *mut GESMarkerList,
position: gst::GstClockTime,
) -> *mut GESMarker;
#[cfg(any(feature = "v1_18", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
pub fn ges_marker_list_get_markers(list: *mut GESMarkerList) -> *mut glib::GList;
#[cfg(any(feature = "v1_18", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
pub fn ges_marker_list_move(
list: *mut GESMarkerList,
marker: *mut GESMarker,
position: gst::GstClockTime,
) -> gboolean;
#[cfg(any(feature = "v1_18", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
pub fn ges_marker_list_remove(list: *mut GESMarkerList, marker: *mut GESMarker) -> gboolean;
#[cfg(any(feature = "v1_18", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
pub fn ges_marker_list_size(list: *mut GESMarkerList) -> c_uint;
//=========================================================================
// GESMultiFileSource
//=========================================================================
pub fn ges_multi_file_source_get_type() -> GType;
pub fn ges_multi_file_source_new(uri: *mut c_char) -> *mut GESMultiFileSource;
//=========================================================================
// GESOperation
//=========================================================================
pub fn ges_operation_get_type() -> GType;
//=========================================================================
// GESOperationClip
//=========================================================================
pub fn ges_operation_clip_get_type() -> GType;
//=========================================================================
// GESOverlayClip
//=========================================================================
pub fn ges_overlay_clip_get_type() -> GType;
//=========================================================================
// GESPipeline
//=========================================================================
pub fn ges_pipeline_get_type() -> GType;
pub fn ges_pipeline_new() -> *mut GESPipeline;
pub fn ges_pipeline_get_mode(pipeline: *mut GESPipeline) -> GESPipelineFlags;
pub fn ges_pipeline_get_thumbnail(
self_: *mut GESPipeline,
caps: *mut gst::GstCaps,
) -> *mut gst::GstSample;
pub fn ges_pipeline_get_thumbnail_rgb24(
self_: *mut GESPipeline,
width: c_int,
height: c_int,
) -> *mut gst::GstSample;
pub fn ges_pipeline_preview_get_audio_sink(self_: *mut GESPipeline) -> *mut gst::GstElement;
pub fn ges_pipeline_preview_get_video_sink(self_: *mut GESPipeline) -> *mut gst::GstElement;
pub fn ges_pipeline_preview_set_audio_sink(self_: *mut GESPipeline, sink: *mut gst::GstElement);
pub fn ges_pipeline_preview_set_video_sink(self_: *mut GESPipeline, sink: *mut gst::GstElement);
pub fn ges_pipeline_save_thumbnail(
self_: *mut GESPipeline,
width: c_int,
height: c_int,
format: *const c_char,
location: *const c_char,
error: *mut *mut glib::GError,
) -> gboolean;
pub fn ges_pipeline_set_mode(pipeline: *mut GESPipeline, mode: GESPipelineFlags) -> gboolean;
pub fn ges_pipeline_set_render_settings(
pipeline: *mut GESPipeline,
output_uri: *const c_char,
profile: *mut gst_pbutils::GstEncodingProfile,
) -> gboolean;
pub fn ges_pipeline_set_timeline(
pipeline: *mut GESPipeline,
timeline: *mut GESTimeline,
) -> gboolean;
//=========================================================================
// GESPitiviFormatter
//=========================================================================
pub fn ges_pitivi_formatter_get_type() -> GType;
pub fn ges_pitivi_formatter_new() -> *mut GESPitiviFormatter;
//=========================================================================
// GESProject
//=========================================================================
pub fn ges_project_get_type() -> GType;
pub fn ges_project_new(uri: *const c_char) -> *mut GESProject;
pub fn ges_project_add_asset(project: *mut GESProject, asset: *mut GESAsset) -> gboolean;
pub fn ges_project_add_encoding_profile(
project: *mut GESProject,
profile: *mut gst_pbutils::GstEncodingProfile,
) -> gboolean;
#[cfg(any(feature = "v1_18", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
pub fn ges_project_add_formatter(project: *mut GESProject, formatter: *mut GESFormatter);
pub fn ges_project_create_asset(
project: *mut GESProject,
id: *const c_char,
extractable_type: GType,
) -> gboolean;
pub fn ges_project_create_asset_sync(
project: *mut GESProject,
id: *const c_char,
extractable_type: GType,
error: *mut *mut glib::GError,
) -> *mut GESAsset;
pub fn ges_project_get_asset(
project: *mut GESProject,
id: *const c_char,
extractable_type: GType,
) -> *mut GESAsset;
pub fn ges_project_get_loading_assets(project: *mut GESProject) -> *mut glib::GList;
pub fn ges_project_get_uri(project: *mut GESProject) -> *mut c_char;
pub fn ges_project_list_assets(project: *mut GESProject, filter: GType) -> *mut glib::GList;
pub fn ges_project_list_encoding_profiles(project: *mut GESProject) -> *const glib::GList;
pub fn ges_project_load(
project: *mut GESProject,
timeline: *mut GESTimeline,
error: *mut *mut glib::GError,
) -> gboolean;
pub fn ges_project_remove_asset(project: *mut GESProject, asset: *mut GESAsset) -> gboolean;
pub fn ges_project_save(
project: *mut GESProject,
timeline: *mut GESTimeline,
uri: *const c_char,
formatter_asset: *mut GESAsset,
overwrite: gboolean,
error: *mut *mut glib::GError,
) -> gboolean;
//=========================================================================
// GESSource
//=========================================================================
pub fn ges_source_get_type() -> GType;
//=========================================================================
// GESSourceClip
//=========================================================================
pub fn ges_source_clip_get_type() -> GType;
#[cfg(any(feature = "v1_18", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
pub fn ges_source_clip_new_time_overlay() -> *mut GESSourceClip;
//=========================================================================
// GESSourceClipAsset
//=========================================================================
#[cfg(any(feature = "v1_18", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
pub fn ges_source_clip_asset_get_type() -> GType;
//=========================================================================
// GESTestClip
//=========================================================================
pub fn ges_test_clip_get_type() -> GType;
pub fn ges_test_clip_new() -> *mut GESTestClip;
pub fn ges_test_clip_new_for_nick(nick: *mut c_char) -> *mut GESTestClip;
pub fn ges_test_clip_get_frequency(self_: *mut GESTestClip) -> c_double;
pub fn ges_test_clip_get_volume(self_: *mut GESTestClip) -> c_double;
pub fn ges_test_clip_get_vpattern(self_: *mut GESTestClip) -> GESVideoTestPattern;
pub fn ges_test_clip_is_muted(self_: *mut GESTestClip) -> gboolean;
pub fn ges_test_clip_set_frequency(self_: *mut GESTestClip, freq: c_double);
pub fn ges_test_clip_set_mute(self_: *mut GESTestClip, mute: gboolean);
pub fn ges_test_clip_set_volume(self_: *mut GESTestClip, volume: c_double);
pub fn ges_test_clip_set_vpattern(self_: *mut GESTestClip, vpattern: GESVideoTestPattern);
//=========================================================================
// GESTextOverlay
//=========================================================================
pub fn ges_text_overlay_get_type() -> GType;
pub fn ges_text_overlay_new() -> *mut GESTextOverlay;
pub fn ges_text_overlay_get_color(self_: *mut GESTextOverlay) -> u32;
pub fn ges_text_overlay_get_font_desc(self_: *mut GESTextOverlay) -> *const c_char;
pub fn ges_text_overlay_get_halignment(self_: *mut GESTextOverlay) -> GESTextHAlign;
pub fn ges_text_overlay_get_text(self_: *mut GESTextOverlay) -> *const c_char;
pub fn ges_text_overlay_get_valignment(self_: *mut GESTextOverlay) -> GESTextVAlign;
pub fn ges_text_overlay_get_xpos(self_: *mut GESTextOverlay) -> c_double;
pub fn ges_text_overlay_get_ypos(self_: *mut GESTextOverlay) -> c_double;
pub fn ges_text_overlay_set_color(self_: *mut GESTextOverlay, color: u32);
pub fn ges_text_overlay_set_font_desc(self_: *mut GESTextOverlay, font_desc: *const c_char);
pub fn ges_text_overlay_set_halignment(self_: *mut GESTextOverlay, halign: GESTextHAlign);
pub fn ges_text_overlay_set_text(self_: *mut GESTextOverlay, text: *const c_char);
pub fn ges_text_overlay_set_valignment(self_: *mut GESTextOverlay, valign: GESTextVAlign);
pub fn ges_text_overlay_set_xpos(self_: *mut GESTextOverlay, position: c_double);
pub fn ges_text_overlay_set_ypos(self_: *mut GESTextOverlay, position: c_double);
//=========================================================================
// GESTextOverlayClip
//=========================================================================
pub fn ges_text_overlay_clip_get_type() -> GType;
pub fn ges_text_overlay_clip_new() -> *mut GESTextOverlayClip;
pub fn ges_text_overlay_clip_get_color(self_: *mut GESTextOverlayClip) -> u32;
pub fn ges_text_overlay_clip_get_font_desc(self_: *mut GESTextOverlayClip) -> *const c_char;
pub fn ges_text_overlay_clip_get_halignment(self_: *mut GESTextOverlayClip) -> GESTextHAlign;
pub fn ges_text_overlay_clip_get_text(self_: *mut GESTextOverlayClip) -> *const c_char;
pub fn ges_text_overlay_clip_get_valignment(self_: *mut GESTextOverlayClip) -> GESTextVAlign;
pub fn ges_text_overlay_clip_get_xpos(self_: *mut GESTextOverlayClip) -> c_double;
pub fn ges_text_overlay_clip_get_ypos(self_: *mut GESTextOverlayClip) -> c_double;
pub fn ges_text_overlay_clip_set_color(self_: *mut GESTextOverlayClip, color: u32);
pub fn ges_text_overlay_clip_set_font_desc(
self_: *mut GESTextOverlayClip,
font_desc: *const c_char,
);
pub fn ges_text_overlay_clip_set_halign(self_: *mut GESTextOverlayClip, halign: GESTextHAlign);
pub fn ges_text_overlay_clip_set_text(self_: *mut GESTextOverlayClip, text: *const c_char);
pub fn ges_text_overlay_clip_set_valign(self_: *mut GESTextOverlayClip, valign: GESTextVAlign);
pub fn ges_text_overlay_clip_set_xpos(self_: *mut GESTextOverlayClip, position: c_double);
pub fn ges_text_overlay_clip_set_ypos(self_: *mut GESTextOverlayClip, position: c_double);
//=========================================================================
// GESTimeline
//=========================================================================
pub fn ges_timeline_get_type() -> GType;
pub fn ges_timeline_new() -> *mut GESTimeline;
pub fn ges_timeline_new_audio_video() -> *mut GESTimeline;
pub fn ges_timeline_new_from_uri(
uri: *const c_char,
error: *mut *mut glib::GError,
) -> *mut GESTimeline;
pub fn ges_timeline_add_layer(timeline: *mut GESTimeline, layer: *mut GESLayer) -> gboolean;
pub fn ges_timeline_add_track(timeline: *mut GESTimeline, track: *mut GESTrack) -> gboolean;
pub fn ges_timeline_append_layer(timeline: *mut GESTimeline) -> *mut GESLayer;
pub fn ges_timeline_commit(timeline: *mut GESTimeline) -> gboolean;
pub fn ges_timeline_commit_sync(timeline: *mut GESTimeline) -> gboolean;
pub fn ges_timeline_get_auto_transition(timeline: *mut GESTimeline) -> gboolean;
pub fn ges_timeline_get_duration(timeline: *mut GESTimeline) -> gst::GstClockTime;
pub fn ges_timeline_get_element(
timeline: *mut GESTimeline,
name: *const c_char,
) -> *mut GESTimelineElement;
#[cfg(any(feature = "v1_18", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
pub fn ges_timeline_get_frame_at(
self_: *mut GESTimeline,
timestamp: gst::GstClockTime,
) -> GESFrameNumber;
#[cfg(any(feature = "v1_18", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
pub fn ges_timeline_get_frame_time(
self_: *mut GESTimeline,
frame_number: GESFrameNumber,
) -> gst::GstClockTime;
pub fn ges_timeline_get_groups(timeline: *mut GESTimeline) -> *mut glib::GList;
pub fn ges_timeline_get_layer(timeline: *mut GESTimeline, priority: c_uint) -> *mut GESLayer;
pub fn ges_timeline_get_layers(timeline: *mut GESTimeline) -> *mut glib::GList;
pub fn ges_timeline_get_pad_for_track(
timeline: *mut GESTimeline,
track: *mut GESTrack,
) -> *mut gst::GstPad;
pub fn ges_timeline_get_snapping_distance(timeline: *mut GESTimeline) -> gst::GstClockTime;
pub fn ges_timeline_get_track_for_pad(
timeline: *mut GESTimeline,
pad: *mut gst::GstPad,
) -> *mut GESTrack;
pub fn ges_timeline_get_tracks(timeline: *mut GESTimeline) -> *mut glib::GList;
pub fn ges_timeline_is_empty(timeline: *mut GESTimeline) -> gboolean;
pub fn ges_timeline_load_from_uri(
timeline: *mut GESTimeline,
uri: *const c_char,
error: *mut *mut glib::GError,
) -> gboolean;
#[cfg(any(feature = "v1_16", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_16")))]
pub fn ges_timeline_move_layer(
timeline: *mut GESTimeline,
layer: *mut GESLayer,
new_layer_priority: c_uint,
) -> gboolean;
pub fn ges_timeline_paste_element(
timeline: *mut GESTimeline,
element: *mut GESTimelineElement,
position: gst::GstClockTime,
layer_priority: c_int,
) -> *mut GESTimelineElement;
pub fn ges_timeline_remove_layer(timeline: *mut GESTimeline, layer: *mut GESLayer) -> gboolean;
pub fn ges_timeline_remove_track(timeline: *mut GESTimeline, track: *mut GESTrack) -> gboolean;
pub fn ges_timeline_save_to_uri(
timeline: *mut GESTimeline,
uri: *const c_char,
formatter_asset: *mut GESAsset,
overwrite: gboolean,
error: *mut *mut glib::GError,
) -> gboolean;
pub fn ges_timeline_set_auto_transition(timeline: *mut GESTimeline, auto_transition: gboolean);
pub fn ges_timeline_set_snapping_distance(
timeline: *mut GESTimeline,
snapping_distance: gst::GstClockTime,
);
//=========================================================================
// GESTimelineElement
//=========================================================================
pub fn ges_timeline_element_get_type() -> GType;
pub fn ges_timeline_element_add_child_property(
self_: *mut GESTimelineElement,
pspec: *mut gobject::GParamSpec,
child: *mut gobject::GObject,
) -> gboolean;
pub fn ges_timeline_element_copy(
self_: *mut GESTimelineElement,
deep: gboolean,
) -> *mut GESTimelineElement;
#[cfg(any(feature = "v1_18", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
pub fn ges_timeline_element_edit(
self_: *mut GESTimelineElement,
layers: *mut glib::GList,
new_layer_priority: i64,
mode: GESEditMode,
edge: GESEdge,
position: u64,
) -> gboolean;
#[cfg(any(feature = "v1_18", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
pub fn ges_timeline_element_edit_full(
self_: *mut GESTimelineElement,
new_layer_priority: i64,
mode: GESEditMode,
edge: GESEdge,
position: u64,
error: *mut *mut glib::GError,
) -> gboolean;
pub fn ges_timeline_element_get_child_properties(
self_: *mut GESTimelineElement,
first_property_name: *const c_char,
...
);
pub fn ges_timeline_element_get_child_property(
self_: *mut GESTimelineElement,
property_name: *const c_char,
value: *mut gobject::GValue,
) -> gboolean;
pub fn ges_timeline_element_get_child_property_by_pspec(
self_: *mut GESTimelineElement,
pspec: *mut gobject::GParamSpec,
value: *mut gobject::GValue,
);
//pub fn ges_timeline_element_get_child_property_valist(self_: *mut GESTimelineElement, first_property_name: *const c_char, var_args: /*Unimplemented*/va_list);
pub fn ges_timeline_element_get_duration(self_: *mut GESTimelineElement) -> gst::GstClockTime;
pub fn ges_timeline_element_get_inpoint(self_: *mut GESTimelineElement) -> gst::GstClockTime;
#[cfg(any(feature = "v1_16", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_16")))]
pub fn ges_timeline_element_get_layer_priority(self_: *mut GESTimelineElement) -> u32;
pub fn ges_timeline_element_get_max_duration(
self_: *mut GESTimelineElement,
) -> gst::GstClockTime;
pub fn ges_timeline_element_get_name(self_: *mut GESTimelineElement) -> *mut c_char;
#[cfg(any(feature = "v1_18", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
pub fn ges_timeline_element_get_natural_framerate(
self_: *mut GESTimelineElement,
framerate_n: *mut c_int,
framerate_d: *mut c_int,
) -> gboolean;
pub fn ges_timeline_element_get_parent(
self_: *mut GESTimelineElement,
) -> *mut GESTimelineElement;
pub fn ges_timeline_element_get_priority(self_: *mut GESTimelineElement) -> u32;
pub fn ges_timeline_element_get_start(self_: *mut GESTimelineElement) -> gst::GstClockTime;
pub fn ges_timeline_element_get_timeline(self_: *mut GESTimelineElement) -> *mut GESTimeline;
pub fn ges_timeline_element_get_toplevel_parent(
self_: *mut GESTimelineElement,
) -> *mut GESTimelineElement;
pub fn ges_timeline_element_get_track_types(self_: *mut GESTimelineElement) -> GESTrackType;
pub fn ges_timeline_element_list_children_properties(
self_: *mut GESTimelineElement,
n_properties: *mut c_uint,
) -> *mut *mut gobject::GParamSpec;
pub fn ges_timeline_element_lookup_child(
self_: *mut GESTimelineElement,
prop_name: *const c_char,
child: *mut *mut gobject::GObject,
pspec: *mut *mut gobject::GParamSpec,
) -> gboolean;
pub fn ges_timeline_element_paste(
self_: *mut GESTimelineElement,
paste_position: gst::GstClockTime,
) -> *mut GESTimelineElement;
pub fn ges_timeline_element_remove_child_property(
self_: *mut GESTimelineElement,
pspec: *mut gobject::GParamSpec,
) -> gboolean;
pub fn ges_timeline_element_ripple(
self_: *mut GESTimelineElement,
start: gst::GstClockTime,
) -> gboolean;
pub fn ges_timeline_element_ripple_end(
self_: *mut GESTimelineElement,
end: gst::GstClockTime,
) -> gboolean;
pub fn ges_timeline_element_roll_end(
self_: *mut GESTimelineElement,
end: gst::GstClockTime,
) -> gboolean;
pub fn ges_timeline_element_roll_start(
self_: *mut GESTimelineElement,
start: gst::GstClockTime,
) -> gboolean;
pub fn ges_timeline_element_set_child_properties(
self_: *mut GESTimelineElement,
first_property_name: *const c_char,
...
);
pub fn ges_timeline_element_set_child_property(
self_: *mut GESTimelineElement,
property_name: *const c_char,
value: *const gobject::GValue,
) -> gboolean;
pub fn ges_timeline_element_set_child_property_by_pspec(
self_: *mut GESTimelineElement,
pspec: *mut gobject::GParamSpec,
value: *const gobject::GValue,
);
#[cfg(any(feature = "v1_18", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
pub fn ges_timeline_element_set_child_property_full(
self_: *mut GESTimelineElement,
property_name: *const c_char,
value: *const gobject::GValue,
error: *mut *mut glib::GError,
) -> gboolean;
//pub fn ges_timeline_element_set_child_property_valist(self_: *mut GESTimelineElement, first_property_name: *const c_char, var_args: /*Unimplemented*/va_list);
pub fn ges_timeline_element_set_duration(
self_: *mut GESTimelineElement,
duration: gst::GstClockTime,
) -> gboolean;
pub fn ges_timeline_element_set_inpoint(
self_: *mut GESTimelineElement,
inpoint: gst::GstClockTime,
) -> gboolean;
pub fn ges_timeline_element_set_max_duration(
self_: *mut GESTimelineElement,
maxduration: gst::GstClockTime,
) -> gboolean;
pub fn ges_timeline_element_set_name(
self_: *mut GESTimelineElement,
name: *const c_char,
) -> gboolean;
pub fn ges_timeline_element_set_parent(
self_: *mut GESTimelineElement,
parent: *mut GESTimelineElement,
) -> gboolean;
pub fn ges_timeline_element_set_priority(
self_: *mut GESTimelineElement,
priority: u32,
) -> gboolean;
pub fn ges_timeline_element_set_start(
self_: *mut GESTimelineElement,
start: gst::GstClockTime,
) -> gboolean;
pub fn ges_timeline_element_set_timeline(
self_: *mut GESTimelineElement,
timeline: *mut GESTimeline,
) -> gboolean;
pub fn ges_timeline_element_trim(
self_: *mut GESTimelineElement,
start: gst::GstClockTime,
) -> gboolean;
//=========================================================================
// GESTitleClip
//=========================================================================
pub fn ges_title_clip_get_type() -> GType;
pub fn ges_title_clip_new() -> *mut GESTitleClip;
pub fn ges_title_clip_get_background_color(self_: *mut GESTitleClip) -> u32;
pub fn ges_title_clip_get_font_desc(self_: *mut GESTitleClip) -> *const c_char;
pub fn ges_title_clip_get_halignment(self_: *mut GESTitleClip) -> GESTextHAlign;
pub fn ges_title_clip_get_text(self_: *mut GESTitleClip) -> *const c_char;
pub fn ges_title_clip_get_text_color(self_: *mut GESTitleClip) -> u32;
pub fn ges_title_clip_get_valignment(self_: *mut GESTitleClip) -> GESTextVAlign;
pub fn ges_title_clip_get_xpos(self_: *mut GESTitleClip) -> c_double;
pub fn ges_title_clip_get_ypos(self_: *mut GESTitleClip) -> c_double;
pub fn ges_title_clip_set_background(self_: *mut GESTitleClip, background: u32);
pub fn ges_title_clip_set_color(self_: *mut GESTitleClip, color: u32);
pub fn ges_title_clip_set_font_desc(self_: *mut GESTitleClip, font_desc: *const c_char);
pub fn ges_title_clip_set_halignment(self_: *mut GESTitleClip, halign: GESTextHAlign);
pub fn ges_title_clip_set_text(self_: *mut GESTitleClip, text: *const c_char);
pub fn ges_title_clip_set_valignment(self_: *mut GESTitleClip, valign: GESTextVAlign);
pub fn ges_title_clip_set_xpos(self_: *mut GESTitleClip, position: c_double);
pub fn ges_title_clip_set_ypos(self_: *mut GESTitleClip, position: c_double);
//=========================================================================
// GESTitleSource
//=========================================================================
pub fn ges_title_source_get_type() -> GType;
pub fn ges_title_source_get_background_color(source: *mut GESTitleSource) -> u32;
pub fn ges_title_source_get_font_desc(source: *mut GESTitleSource) -> *const c_char;
pub fn ges_title_source_get_halignment(source: *mut GESTitleSource) -> GESTextHAlign;
pub fn ges_title_source_get_text(source: *mut GESTitleSource) -> *const c_char;
pub fn ges_title_source_get_text_color(source: *mut GESTitleSource) -> u32;
pub fn ges_title_source_get_valignment(source: *mut GESTitleSource) -> GESTextVAlign;
pub fn ges_title_source_get_xpos(source: *mut GESTitleSource) -> c_double;
pub fn ges_title_source_get_ypos(source: *mut GESTitleSource) -> c_double;
pub fn ges_title_source_set_background_color(self_: *mut GESTitleSource, color: u32);
pub fn ges_title_source_set_font_desc(self_: *mut GESTitleSource, font_desc: *const c_char);
pub fn ges_title_source_set_halignment(self_: *mut GESTitleSource, halign: GESTextHAlign);
pub fn ges_title_source_set_text(self_: *mut GESTitleSource, text: *const c_char);
pub fn ges_title_source_set_text_color(self_: *mut GESTitleSource, color: u32);
pub fn ges_title_source_set_valignment(self_: *mut GESTitleSource, valign: GESTextVAlign);
pub fn ges_title_source_set_xpos(self_: *mut GESTitleSource, position: c_double);
pub fn ges_title_source_set_ypos(self_: *mut GESTitleSource, position: c_double);
//=========================================================================
// GESTrack
//=========================================================================
pub fn ges_track_get_type() -> GType;
pub fn ges_track_new(type_: GESTrackType, caps: *mut gst::GstCaps) -> *mut GESTrack;
pub fn ges_track_add_element(track: *mut GESTrack, object: *mut GESTrackElement) -> gboolean;
#[cfg(any(feature = "v1_18", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
pub fn ges_track_add_element_full(
track: *mut GESTrack,
object: *mut GESTrackElement,
error: *mut *mut glib::GError,
) -> gboolean;
pub fn ges_track_commit(track: *mut GESTrack) -> gboolean;
pub fn ges_track_get_caps(track: *mut GESTrack) -> *const gst::GstCaps;
pub fn ges_track_get_elements(track: *mut GESTrack) -> *mut glib::GList;
pub fn ges_track_get_mixing(track: *mut GESTrack) -> gboolean;
#[cfg(any(feature = "v1_18", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
pub fn ges_track_get_restriction_caps(track: *mut GESTrack) -> *mut gst::GstCaps;
pub fn ges_track_get_timeline(track: *mut GESTrack) -> *const GESTimeline;
pub fn ges_track_remove_element(track: *mut GESTrack, object: *mut GESTrackElement)
-> gboolean;
#[cfg(any(feature = "v1_18", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
pub fn ges_track_remove_element_full(
track: *mut GESTrack,
object: *mut GESTrackElement,
error: *mut *mut glib::GError,
) -> gboolean;
pub fn ges_track_set_create_element_for_gap_func(
track: *mut GESTrack,
func: GESCreateElementForGapFunc,
);
pub fn ges_track_set_mixing(track: *mut GESTrack, mixing: gboolean);
pub fn ges_track_set_restriction_caps(track: *mut GESTrack, caps: *const gst::GstCaps);
pub fn ges_track_set_timeline(track: *mut GESTrack, timeline: *mut GESTimeline);
pub fn ges_track_update_restriction_caps(track: *mut GESTrack, caps: *const gst::GstCaps);
//=========================================================================
// GESTrackElement
//=========================================================================
pub fn ges_track_element_get_type() -> GType;
pub fn ges_track_element_add_children_props(
self_: *mut GESTrackElement,
element: *mut gst::GstElement,
wanted_categories: *mut *const c_char,
blacklist: *mut *const c_char,
whitelist: *mut *const c_char,
);
#[cfg(any(feature = "v1_18", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
pub fn ges_track_element_clamp_control_source(
object: *mut GESTrackElement,
property_name: *const c_char,
);
pub fn ges_track_element_edit(
object: *mut GESTrackElement,
layers: *mut glib::GList,
mode: GESEditMode,
edge: GESEdge,
position: u64,
) -> gboolean;
pub fn ges_track_element_get_all_control_bindings(
trackelement: *mut GESTrackElement,
) -> *mut glib::GHashTable;
#[cfg(any(feature = "v1_18", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
pub fn ges_track_element_get_auto_clamp_control_sources(
object: *mut GESTrackElement,
) -> gboolean;
pub fn ges_track_element_get_child_properties(
object: *mut GESTrackElement,
first_property_name: *const c_char,
...
);
pub fn ges_track_element_get_child_property(
object: *mut GESTrackElement,
property_name: *const c_char,
value: *mut gobject::GValue,
) -> gboolean;
pub fn ges_track_element_get_child_property_by_pspec(
object: *mut GESTrackElement,
pspec: *mut gobject::GParamSpec,
value: *mut gobject::GValue,
);
//pub fn ges_track_element_get_child_property_valist(object: *mut GESTrackElement, first_property_name: *const c_char, var_args: /*Unimplemented*/va_list);
pub fn ges_track_element_get_control_binding(
object: *mut GESTrackElement,
property_name: *const c_char,
) -> *mut gst::GstControlBinding;
pub fn ges_track_element_get_element(object: *mut GESTrackElement) -> *mut gst::GstElement;
pub fn ges_track_element_get_gnlobject(object: *mut GESTrackElement) -> *mut gst::GstElement;
pub fn ges_track_element_get_nleobject(object: *mut GESTrackElement) -> *mut gst::GstElement;
pub fn ges_track_element_get_track(object: *mut GESTrackElement) -> *mut GESTrack;
pub fn ges_track_element_get_track_type(object: *mut GESTrackElement) -> GESTrackType;
#[cfg(any(feature = "v1_18", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
pub fn ges_track_element_has_internal_source(object: *mut GESTrackElement) -> gboolean;
pub fn ges_track_element_is_active(object: *mut GESTrackElement) -> gboolean;
#[cfg(any(feature = "v1_18", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
pub fn ges_track_element_is_core(object: *mut GESTrackElement) -> gboolean;
pub fn ges_track_element_list_children_properties(
object: *mut GESTrackElement,
n_properties: *mut c_uint,
) -> *mut *mut gobject::GParamSpec;
pub fn ges_track_element_lookup_child(
object: *mut GESTrackElement,
prop_name: *const c_char,
element: *mut *mut gst::GstElement,
pspec: *mut *mut gobject::GParamSpec,
) -> gboolean;
pub fn ges_track_element_remove_control_binding(
object: *mut GESTrackElement,
property_name: *const c_char,
) -> gboolean;
pub fn ges_track_element_set_active(object: *mut GESTrackElement, active: gboolean)
-> gboolean;
#[cfg(any(feature = "v1_18", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
pub fn ges_track_element_set_auto_clamp_control_sources(
object: *mut GESTrackElement,
auto_clamp: gboolean,
);
pub fn ges_track_element_set_child_properties(
object: *mut GESTrackElement,
first_property_name: *const c_char,
...
);
pub fn ges_track_element_set_child_property(
object: *mut GESTrackElement,
property_name: *const c_char,
value: *mut gobject::GValue,
) -> gboolean;
pub fn ges_track_element_set_child_property_by_pspec(
object: *mut GESTrackElement,
pspec: *mut gobject::GParamSpec,
value: *mut gobject::GValue,
);
//pub fn ges_track_element_set_child_property_valist(object: *mut GESTrackElement, first_property_name: *const c_char, var_args: /*Unimplemented*/va_list);
pub fn ges_track_element_set_control_source(
object: *mut GESTrackElement,
source: *mut gst::GstControlSource,
property_name: *const c_char,
binding_type: *const c_char,
) -> gboolean;
#[cfg(any(feature = "v1_18", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
pub fn ges_track_element_set_has_internal_source(
object: *mut GESTrackElement,
has_internal_source: gboolean,
) -> gboolean;
pub fn ges_track_element_set_track_type(object: *mut GESTrackElement, type_: GESTrackType);
//=========================================================================
// GESTrackElementAsset
//=========================================================================
pub fn ges_track_element_asset_get_type() -> GType;
#[cfg(any(feature = "v1_18", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
pub fn ges_track_element_asset_get_natural_framerate(
self_: *mut GESTrackElementAsset,
framerate_n: *mut c_int,
framerate_d: *mut c_int,
) -> gboolean;
pub fn ges_track_element_asset_get_track_type(asset: *mut GESTrackElementAsset)
-> GESTrackType;
pub fn ges_track_element_asset_set_track_type(
asset: *mut GESTrackElementAsset,
type_: GESTrackType,
);
//=========================================================================
// GESTransition
//=========================================================================
pub fn ges_transition_get_type() -> GType;
//=========================================================================
// GESTransitionClip
//=========================================================================
pub fn ges_transition_clip_get_type() -> GType;
pub fn ges_transition_clip_new(vtype: GESVideoStandardTransitionType)
-> *mut GESTransitionClip;
pub fn ges_transition_clip_new_for_nick(nick: *mut c_char) -> *mut GESTransitionClip;
//=========================================================================
// GESUriClip
//=========================================================================
pub fn ges_uri_clip_get_type() -> GType;
pub fn ges_uri_clip_new(uri: *const c_char) -> *mut GESUriClip;
pub fn ges_uri_clip_get_uri(self_: *mut GESUriClip) -> *const c_char;
pub fn ges_uri_clip_is_image(self_: *mut GESUriClip) -> gboolean;
pub fn ges_uri_clip_is_muted(self_: *mut GESUriClip) -> gboolean;
pub fn ges_uri_clip_set_is_image(self_: *mut GESUriClip, is_image: gboolean);
pub fn ges_uri_clip_set_mute(self_: *mut GESUriClip, mute: gboolean);
//=========================================================================
// GESUriClipAsset
//=========================================================================
pub fn ges_uri_clip_asset_get_type() -> GType;
#[cfg(any(feature = "v1_16", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_16")))]
pub fn ges_uri_clip_asset_finish(
res: *mut gio::GAsyncResult,
error: *mut *mut glib::GError,
) -> *mut GESUriClipAsset;
pub fn ges_uri_clip_asset_new(
uri: *const c_char,
cancellable: *mut gio::GCancellable,
callback: gio::GAsyncReadyCallback,
user_data: gpointer,
);
pub fn ges_uri_clip_asset_request_sync(
uri: *const c_char,
error: *mut *mut glib::GError,
) -> *mut GESUriClipAsset;
pub fn ges_uri_clip_asset_get_duration(self_: *mut GESUriClipAsset) -> gst::GstClockTime;
pub fn ges_uri_clip_asset_get_info(
self_: *const GESUriClipAsset,
) -> *mut gst_pbutils::GstDiscovererInfo;
#[cfg(any(feature = "v1_18", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
pub fn ges_uri_clip_asset_get_max_duration(self_: *mut GESUriClipAsset) -> gst::GstClockTime;
pub fn ges_uri_clip_asset_get_stream_assets(self_: *mut GESUriClipAsset) -> *const glib::GList;
#[cfg(any(feature = "v1_18", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
pub fn ges_uri_clip_asset_is_image(self_: *mut GESUriClipAsset) -> gboolean;
//=========================================================================
// GESUriSourceAsset
//=========================================================================
pub fn ges_uri_source_asset_get_type() -> GType;
pub fn ges_uri_source_asset_get_filesource_asset(
asset: *mut GESUriSourceAsset,
) -> *const GESUriClipAsset;
pub fn ges_uri_source_asset_get_stream_info(
asset: *mut GESUriSourceAsset,
) -> *mut gst_pbutils::GstDiscovererStreamInfo;
pub fn ges_uri_source_asset_get_stream_uri(asset: *mut GESUriSourceAsset) -> *const c_char;
#[cfg(any(feature = "v1_18", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
pub fn ges_uri_source_asset_is_image(asset: *mut GESUriSourceAsset) -> gboolean;
//=========================================================================
// GESVideoSource
//=========================================================================
pub fn ges_video_source_get_type() -> GType;
#[cfg(any(feature = "v1_18", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
pub fn ges_video_source_get_natural_size(
self_: *mut GESVideoSource,
width: *mut c_int,
height: *mut c_int,
) -> gboolean;
//=========================================================================
// GESVideoTestSource
//=========================================================================
pub fn ges_video_test_source_get_type() -> GType;
pub fn ges_video_test_source_get_pattern(
source: *mut GESVideoTestSource,
) -> GESVideoTestPattern;
pub fn ges_video_test_source_set_pattern(
self_: *mut GESVideoTestSource,
pattern: GESVideoTestPattern,
);
//=========================================================================
// GESVideoTrack
//=========================================================================
pub fn ges_video_track_get_type() -> GType;
pub fn ges_video_track_new() -> *mut GESVideoTrack;
//=========================================================================
// GESVideoTransition
//=========================================================================
pub fn ges_video_transition_get_type() -> GType;
pub fn ges_video_transition_new() -> *mut GESVideoTransition;
pub fn ges_video_transition_get_border(self_: *mut GESVideoTransition) -> c_int;
pub fn ges_video_transition_get_transition_type(
trans: *mut GESVideoTransition,
) -> GESVideoStandardTransitionType;
pub fn ges_video_transition_is_inverted(self_: *mut GESVideoTransition) -> gboolean;
pub fn ges_video_transition_set_border(self_: *mut GESVideoTransition, value: c_uint);
pub fn ges_video_transition_set_inverted(self_: *mut GESVideoTransition, inverted: gboolean);
pub fn ges_video_transition_set_transition_type(
self_: *mut GESVideoTransition,
type_: GESVideoStandardTransitionType,
) -> gboolean;
//=========================================================================
// GESVideoUriSource
//=========================================================================
pub fn ges_video_uri_source_get_type() -> GType;
//=========================================================================
// GESXmlFormatter
//=========================================================================
pub fn ges_xml_formatter_get_type() -> GType;
//=========================================================================
// GESExtractable
//=========================================================================
pub fn ges_extractable_get_type() -> GType;
pub fn ges_extractable_get_asset(self_: *mut GESExtractable) -> *mut GESAsset;
pub fn ges_extractable_get_id(self_: *mut GESExtractable) -> *mut c_char;
pub fn ges_extractable_set_asset(self_: *mut GESExtractable, asset: *mut GESAsset) -> gboolean;
//=========================================================================
// GESMetaContainer
//=========================================================================
pub fn ges_meta_container_get_type() -> GType;
pub fn ges_meta_container_add_metas_from_string(
container: *mut GESMetaContainer,
str: *const c_char,
) -> gboolean;
pub fn ges_meta_container_check_meta_registered(
container: *mut GESMetaContainer,
meta_item: *const c_char,
flags: *mut GESMetaFlag,
type_: *mut GType,
) -> gboolean;
pub fn ges_meta_container_foreach(
container: *mut GESMetaContainer,
func: GESMetaForeachFunc,
user_data: gpointer,
);
pub fn ges_meta_container_get_boolean(
container: *mut GESMetaContainer,
meta_item: *const c_char,
dest: *mut gboolean,
) -> gboolean;
pub fn ges_meta_container_get_date(
container: *mut GESMetaContainer,
meta_item: *const c_char,
dest: *mut *mut glib::GDate,
) -> gboolean;
pub fn ges_meta_container_get_date_time(
container: *mut GESMetaContainer,
meta_item: *const c_char,
dest: *mut *mut gst::GstDateTime,
) -> gboolean;
pub fn ges_meta_container_get_double(
container: *mut GESMetaContainer,
meta_item: *const c_char,
dest: *mut c_double,
) -> gboolean;
pub fn ges_meta_container_get_float(
container: *mut GESMetaContainer,
meta_item: *const c_char,
dest: *mut c_float,
) -> gboolean;
pub fn ges_meta_container_get_int(
container: *mut GESMetaContainer,
meta_item: *const c_char,
dest: *mut c_int,
) -> gboolean;
pub fn ges_meta_container_get_int64(
container: *mut GESMetaContainer,
meta_item: *const c_char,
dest: *mut i64,
) -> gboolean;
#[cfg(any(feature = "v1_18", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
pub fn ges_meta_container_get_marker_list(
container: *mut GESMetaContainer,
key: *const c_char,
) -> *mut GESMarkerList;
pub fn ges_meta_container_get_meta(
container: *mut GESMetaContainer,
key: *const c_char,
) -> *const gobject::GValue;
pub fn ges_meta_container_get_string(
container: *mut GESMetaContainer,
meta_item: *const c_char,
) -> *const c_char;
pub fn ges_meta_container_get_uint(
container: *mut GESMetaContainer,
meta_item: *const c_char,
dest: *mut c_uint,
) -> gboolean;
pub fn ges_meta_container_get_uint64(
container: *mut GESMetaContainer,
meta_item: *const c_char,
dest: *mut u64,
) -> gboolean;
pub fn ges_meta_container_metas_to_string(container: *mut GESMetaContainer) -> *mut c_char;
pub fn ges_meta_container_register_meta(
container: *mut GESMetaContainer,
flags: GESMetaFlag,
meta_item: *const c_char,
value: *const gobject::GValue,
) -> gboolean;
pub fn ges_meta_container_register_meta_boolean(
container: *mut GESMetaContainer,
flags: GESMetaFlag,
meta_item: *const c_char,
value: gboolean,
) -> gboolean;
pub fn ges_meta_container_register_meta_date(
container: *mut GESMetaContainer,
flags: GESMetaFlag,
meta_item: *const c_char,
value: *const glib::GDate,
) -> gboolean;
pub fn ges_meta_container_register_meta_date_time(
container: *mut GESMetaContainer,
flags: GESMetaFlag,
meta_item: *const c_char,
value: *const gst::GstDateTime,
) -> gboolean;
pub fn ges_meta_container_register_meta_double(
container: *mut GESMetaContainer,
flags: GESMetaFlag,
meta_item: *const c_char,
value: c_double,
) -> gboolean;
pub fn ges_meta_container_register_meta_float(
container: *mut GESMetaContainer,
flags: GESMetaFlag,
meta_item: *const c_char,
value: c_float,
) -> gboolean;
pub fn ges_meta_container_register_meta_int(
container: *mut GESMetaContainer,
flags: GESMetaFlag,
meta_item: *const c_char,
value: c_int,
) -> gboolean;
pub fn ges_meta_container_register_meta_int64(
container: *mut GESMetaContainer,
flags: GESMetaFlag,
meta_item: *const c_char,
value: i64,
) -> gboolean;
pub fn ges_meta_container_register_meta_string(
container: *mut GESMetaContainer,
flags: GESMetaFlag,
meta_item: *const c_char,
value: *const c_char,
) -> gboolean;
pub fn ges_meta_container_register_meta_uint(
container: *mut GESMetaContainer,
flags: GESMetaFlag,
meta_item: *const c_char,
value: c_uint,
) -> gboolean;
pub fn ges_meta_container_register_meta_uint64(
container: *mut GESMetaContainer,
flags: GESMetaFlag,
meta_item: *const c_char,
value: u64,
) -> gboolean;
#[cfg(any(feature = "v1_18", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
pub fn ges_meta_container_register_static_meta(
container: *mut GESMetaContainer,
flags: GESMetaFlag,
meta_item: *const c_char,
type_: GType,
) -> gboolean;
pub fn ges_meta_container_set_boolean(
container: *mut GESMetaContainer,
meta_item: *const c_char,
value: gboolean,
) -> gboolean;
pub fn ges_meta_container_set_date(
container: *mut GESMetaContainer,
meta_item: *const c_char,
value: *const glib::GDate,
) -> gboolean;
pub fn ges_meta_container_set_date_time(
container: *mut GESMetaContainer,
meta_item: *const c_char,
value: *const gst::GstDateTime,
) -> gboolean;
pub fn ges_meta_container_set_double(
container: *mut GESMetaContainer,
meta_item: *const c_char,
value: c_double,
) -> gboolean;
pub fn ges_meta_container_set_float(
container: *mut GESMetaContainer,
meta_item: *const c_char,
value: c_float,
) -> gboolean;
pub fn ges_meta_container_set_int(
container: *mut GESMetaContainer,
meta_item: *const c_char,
value: c_int,
) -> gboolean;
pub fn ges_meta_container_set_int64(
container: *mut GESMetaContainer,
meta_item: *const c_char,
value: i64,
) -> gboolean;
#[cfg(any(feature = "v1_18", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
pub fn ges_meta_container_set_marker_list(
container: *mut GESMetaContainer,
meta_item: *const c_char,
list: *const GESMarkerList,
) -> gboolean;
pub fn ges_meta_container_set_meta(
container: *mut GESMetaContainer,
meta_item: *const c_char,
value: *const gobject::GValue,
) -> gboolean;
pub fn ges_meta_container_set_string(
container: *mut GESMetaContainer,
meta_item: *const c_char,
value: *const c_char,
) -> gboolean;
pub fn ges_meta_container_set_uint(
container: *mut GESMetaContainer,
meta_item: *const c_char,
value: c_uint,
) -> gboolean;
pub fn ges_meta_container_set_uint64(
container: *mut GESMetaContainer,
meta_item: *const c_char,
value: u64,
) -> gboolean;
//=========================================================================
// Other functions
//=========================================================================
pub fn ges_add_missing_uri_relocation_uri(uri: *const c_char, recurse: gboolean) -> gboolean;
pub fn ges_deinit();
#[cfg(any(feature = "v1_18", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
pub fn ges_find_formatter_for_uri(uri: *const c_char) -> *mut GESAsset;
pub fn ges_init() -> gboolean;
pub fn ges_init_check(
argc: *mut c_int,
argv: *mut *mut *mut c_char,
error: *mut *mut glib::GError,
) -> gboolean;
pub fn ges_init_get_option_group() -> *mut glib::GOptionGroup;
#[cfg(any(feature = "v1_16", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_16")))]
pub fn ges_is_initialized() -> gboolean;
pub fn ges_list_assets(filter: GType) -> *mut glib::GList;
pub fn ges_play_sink_convert_frame(
playsink: *mut gst::GstElement,
caps: *mut gst::GstCaps,
) -> *mut gst::GstSample;
pub fn ges_pspec_equal(key_spec_1: gconstpointer, key_spec_2: gconstpointer) -> gboolean;
pub fn ges_pspec_hash(key_spec: gconstpointer) -> c_uint;
pub fn ges_validate_register_action_types() -> gboolean;
pub fn ges_version(
major: *mut c_uint,
minor: *mut c_uint,
micro: *mut c_uint,
nano: *mut c_uint,
);
}
Reference in a new issue View git blame Copy permalink