1#![allow(non_camel_case_types, non_upper_case_globals, non_snake_case)]
7#![allow(
8 clippy::approx_constant,
9 clippy::type_complexity,
10 clippy::unreadable_literal,
11 clippy::upper_case_acronyms
12)]
13#![cfg_attr(docsrs, feature(doc_cfg))]
14
15use glib_sys as glib;
16use gobject_sys as gobject;
17use gstreamer_base_sys as gst_base;
18use gstreamer_sys as gst;
19
20#[cfg(unix)]
21#[allow(unused_imports)]
22use libc::{dev_t, gid_t, pid_t, socklen_t, uid_t};
23#[allow(unused_imports)]
24use libc::{intptr_t, off_t, size_t, ssize_t, time_t, uintptr_t, FILE};
25#[allow(unused_imports)]
26use std::ffi::{
27 c_char, c_double, c_float, c_int, c_long, c_short, c_uchar, c_uint, c_ulong, c_ushort, c_void,
28};
29
30#[allow(unused_imports)]
31use glib::{gboolean, gconstpointer, gpointer, GType};
32
33pub type GstAudioBaseSinkDiscontReason = c_int;
35pub const GST_AUDIO_BASE_SINK_DISCONT_REASON_NO_DISCONT: GstAudioBaseSinkDiscontReason = 0;
36pub const GST_AUDIO_BASE_SINK_DISCONT_REASON_NEW_CAPS: GstAudioBaseSinkDiscontReason = 1;
37pub const GST_AUDIO_BASE_SINK_DISCONT_REASON_FLUSH: GstAudioBaseSinkDiscontReason = 2;
38pub const GST_AUDIO_BASE_SINK_DISCONT_REASON_SYNC_LATENCY: GstAudioBaseSinkDiscontReason = 3;
39pub const GST_AUDIO_BASE_SINK_DISCONT_REASON_ALIGNMENT: GstAudioBaseSinkDiscontReason = 4;
40pub const GST_AUDIO_BASE_SINK_DISCONT_REASON_DEVICE_FAILURE: GstAudioBaseSinkDiscontReason = 5;
41
42pub type GstAudioBaseSinkSlaveMethod = c_int;
43pub const GST_AUDIO_BASE_SINK_SLAVE_RESAMPLE: GstAudioBaseSinkSlaveMethod = 0;
44pub const GST_AUDIO_BASE_SINK_SLAVE_SKEW: GstAudioBaseSinkSlaveMethod = 1;
45pub const GST_AUDIO_BASE_SINK_SLAVE_NONE: GstAudioBaseSinkSlaveMethod = 2;
46pub const GST_AUDIO_BASE_SINK_SLAVE_CUSTOM: GstAudioBaseSinkSlaveMethod = 3;
47
48pub type GstAudioBaseSrcSlaveMethod = c_int;
49pub const GST_AUDIO_BASE_SRC_SLAVE_RESAMPLE: GstAudioBaseSrcSlaveMethod = 0;
50pub const GST_AUDIO_BASE_SRC_SLAVE_RE_TIMESTAMP: GstAudioBaseSrcSlaveMethod = 1;
51pub const GST_AUDIO_BASE_SRC_SLAVE_SKEW: GstAudioBaseSrcSlaveMethod = 2;
52pub const GST_AUDIO_BASE_SRC_SLAVE_NONE: GstAudioBaseSrcSlaveMethod = 3;
53
54pub type GstAudioCdSrcMode = c_int;
55pub const GST_AUDIO_CD_SRC_MODE_NORMAL: GstAudioCdSrcMode = 0;
56pub const GST_AUDIO_CD_SRC_MODE_CONTINUOUS: GstAudioCdSrcMode = 1;
57
58pub type GstAudioChannelPosition = c_int;
59pub const GST_AUDIO_CHANNEL_POSITION_NONE: GstAudioChannelPosition = -3;
60pub const GST_AUDIO_CHANNEL_POSITION_MONO: GstAudioChannelPosition = -2;
61pub const GST_AUDIO_CHANNEL_POSITION_INVALID: GstAudioChannelPosition = -1;
62pub const GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT: GstAudioChannelPosition = 0;
63pub const GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT: GstAudioChannelPosition = 1;
64pub const GST_AUDIO_CHANNEL_POSITION_FRONT_CENTER: GstAudioChannelPosition = 2;
65pub const GST_AUDIO_CHANNEL_POSITION_LFE1: GstAudioChannelPosition = 3;
66pub const GST_AUDIO_CHANNEL_POSITION_REAR_LEFT: GstAudioChannelPosition = 4;
67pub const GST_AUDIO_CHANNEL_POSITION_REAR_RIGHT: GstAudioChannelPosition = 5;
68pub const GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT_OF_CENTER: GstAudioChannelPosition = 6;
69pub const GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT_OF_CENTER: GstAudioChannelPosition = 7;
70pub const GST_AUDIO_CHANNEL_POSITION_REAR_CENTER: GstAudioChannelPosition = 8;
71pub const GST_AUDIO_CHANNEL_POSITION_LFE2: GstAudioChannelPosition = 9;
72pub const GST_AUDIO_CHANNEL_POSITION_SIDE_LEFT: GstAudioChannelPosition = 10;
73pub const GST_AUDIO_CHANNEL_POSITION_SIDE_RIGHT: GstAudioChannelPosition = 11;
74pub const GST_AUDIO_CHANNEL_POSITION_TOP_FRONT_LEFT: GstAudioChannelPosition = 12;
75pub const GST_AUDIO_CHANNEL_POSITION_TOP_FRONT_RIGHT: GstAudioChannelPosition = 13;
76pub const GST_AUDIO_CHANNEL_POSITION_TOP_FRONT_CENTER: GstAudioChannelPosition = 14;
77pub const GST_AUDIO_CHANNEL_POSITION_TOP_CENTER: GstAudioChannelPosition = 15;
78pub const GST_AUDIO_CHANNEL_POSITION_TOP_REAR_LEFT: GstAudioChannelPosition = 16;
79pub const GST_AUDIO_CHANNEL_POSITION_TOP_REAR_RIGHT: GstAudioChannelPosition = 17;
80pub const GST_AUDIO_CHANNEL_POSITION_TOP_SIDE_LEFT: GstAudioChannelPosition = 18;
81pub const GST_AUDIO_CHANNEL_POSITION_TOP_SIDE_RIGHT: GstAudioChannelPosition = 19;
82pub const GST_AUDIO_CHANNEL_POSITION_TOP_REAR_CENTER: GstAudioChannelPosition = 20;
83pub const GST_AUDIO_CHANNEL_POSITION_BOTTOM_FRONT_CENTER: GstAudioChannelPosition = 21;
84pub const GST_AUDIO_CHANNEL_POSITION_BOTTOM_FRONT_LEFT: GstAudioChannelPosition = 22;
85pub const GST_AUDIO_CHANNEL_POSITION_BOTTOM_FRONT_RIGHT: GstAudioChannelPosition = 23;
86pub const GST_AUDIO_CHANNEL_POSITION_WIDE_LEFT: GstAudioChannelPosition = 24;
87pub const GST_AUDIO_CHANNEL_POSITION_WIDE_RIGHT: GstAudioChannelPosition = 25;
88pub const GST_AUDIO_CHANNEL_POSITION_SURROUND_LEFT: GstAudioChannelPosition = 26;
89pub const GST_AUDIO_CHANNEL_POSITION_SURROUND_RIGHT: GstAudioChannelPosition = 27;
90#[cfg(feature = "v1_26")]
91#[cfg_attr(docsrs, doc(cfg(feature = "v1_26")))]
92pub const GST_AUDIO_CHANNEL_POSITION_TOP_SURROUND_LEFT: GstAudioChannelPosition = 28;
93#[cfg(feature = "v1_26")]
94#[cfg_attr(docsrs, doc(cfg(feature = "v1_26")))]
95pub const GST_AUDIO_CHANNEL_POSITION_TOP_SURROUND_RIGHT: GstAudioChannelPosition = 29;
96
97pub type GstAudioDitherMethod = c_int;
98pub const GST_AUDIO_DITHER_NONE: GstAudioDitherMethod = 0;
99pub const GST_AUDIO_DITHER_RPDF: GstAudioDitherMethod = 1;
100pub const GST_AUDIO_DITHER_TPDF: GstAudioDitherMethod = 2;
101pub const GST_AUDIO_DITHER_TPDF_HF: GstAudioDitherMethod = 3;
102
103pub type GstAudioFormat = c_int;
104pub const GST_AUDIO_FORMAT_UNKNOWN: GstAudioFormat = 0;
105pub const GST_AUDIO_FORMAT_ENCODED: GstAudioFormat = 1;
106pub const GST_AUDIO_FORMAT_S8: GstAudioFormat = 2;
107pub const GST_AUDIO_FORMAT_U8: GstAudioFormat = 3;
108pub const GST_AUDIO_FORMAT_S16LE: GstAudioFormat = 4;
109pub const GST_AUDIO_FORMAT_S16BE: GstAudioFormat = 5;
110pub const GST_AUDIO_FORMAT_U16LE: GstAudioFormat = 6;
111pub const GST_AUDIO_FORMAT_U16BE: GstAudioFormat = 7;
112pub const GST_AUDIO_FORMAT_S24_32LE: GstAudioFormat = 8;
113pub const GST_AUDIO_FORMAT_S24_32BE: GstAudioFormat = 9;
114pub const GST_AUDIO_FORMAT_U24_32LE: GstAudioFormat = 10;
115pub const GST_AUDIO_FORMAT_U24_32BE: GstAudioFormat = 11;
116pub const GST_AUDIO_FORMAT_S32LE: GstAudioFormat = 12;
117pub const GST_AUDIO_FORMAT_S32BE: GstAudioFormat = 13;
118pub const GST_AUDIO_FORMAT_U32LE: GstAudioFormat = 14;
119pub const GST_AUDIO_FORMAT_U32BE: GstAudioFormat = 15;
120pub const GST_AUDIO_FORMAT_S24LE: GstAudioFormat = 16;
121pub const GST_AUDIO_FORMAT_S24BE: GstAudioFormat = 17;
122pub const GST_AUDIO_FORMAT_U24LE: GstAudioFormat = 18;
123pub const GST_AUDIO_FORMAT_U24BE: GstAudioFormat = 19;
124pub const GST_AUDIO_FORMAT_S20LE: GstAudioFormat = 20;
125pub const GST_AUDIO_FORMAT_S20BE: GstAudioFormat = 21;
126pub const GST_AUDIO_FORMAT_U20LE: GstAudioFormat = 22;
127pub const GST_AUDIO_FORMAT_U20BE: GstAudioFormat = 23;
128pub const GST_AUDIO_FORMAT_S18LE: GstAudioFormat = 24;
129pub const GST_AUDIO_FORMAT_S18BE: GstAudioFormat = 25;
130pub const GST_AUDIO_FORMAT_U18LE: GstAudioFormat = 26;
131pub const GST_AUDIO_FORMAT_U18BE: GstAudioFormat = 27;
132pub const GST_AUDIO_FORMAT_F32LE: GstAudioFormat = 28;
133pub const GST_AUDIO_FORMAT_F32BE: GstAudioFormat = 29;
134pub const GST_AUDIO_FORMAT_F64LE: GstAudioFormat = 30;
135pub const GST_AUDIO_FORMAT_F64BE: GstAudioFormat = 31;
136#[cfg(feature = "v1_28")]
137#[cfg_attr(docsrs, doc(cfg(feature = "v1_28")))]
138pub const GST_AUDIO_FORMAT_S20_32LE: GstAudioFormat = 32;
139#[cfg(feature = "v1_28")]
140#[cfg_attr(docsrs, doc(cfg(feature = "v1_28")))]
141pub const GST_AUDIO_FORMAT_S20_32BE: GstAudioFormat = 33;
142#[cfg(feature = "v1_28")]
143#[cfg_attr(docsrs, doc(cfg(feature = "v1_28")))]
144pub const GST_AUDIO_FORMAT_U20_32LE: GstAudioFormat = 34;
145#[cfg(feature = "v1_28")]
146#[cfg_attr(docsrs, doc(cfg(feature = "v1_28")))]
147pub const GST_AUDIO_FORMAT_U20_32BE: GstAudioFormat = 35;
148
149pub type GstAudioLayout = c_int;
150pub const GST_AUDIO_LAYOUT_INTERLEAVED: GstAudioLayout = 0;
151pub const GST_AUDIO_LAYOUT_NON_INTERLEAVED: GstAudioLayout = 1;
152
153pub type GstAudioNoiseShapingMethod = c_int;
154pub const GST_AUDIO_NOISE_SHAPING_NONE: GstAudioNoiseShapingMethod = 0;
155pub const GST_AUDIO_NOISE_SHAPING_ERROR_FEEDBACK: GstAudioNoiseShapingMethod = 1;
156pub const GST_AUDIO_NOISE_SHAPING_SIMPLE: GstAudioNoiseShapingMethod = 2;
157pub const GST_AUDIO_NOISE_SHAPING_MEDIUM: GstAudioNoiseShapingMethod = 3;
158pub const GST_AUDIO_NOISE_SHAPING_HIGH: GstAudioNoiseShapingMethod = 4;
159
160pub type GstAudioResamplerFilterInterpolation = c_int;
161pub const GST_AUDIO_RESAMPLER_FILTER_INTERPOLATION_NONE: GstAudioResamplerFilterInterpolation = 0;
162pub const GST_AUDIO_RESAMPLER_FILTER_INTERPOLATION_LINEAR: GstAudioResamplerFilterInterpolation = 1;
163pub const GST_AUDIO_RESAMPLER_FILTER_INTERPOLATION_CUBIC: GstAudioResamplerFilterInterpolation = 2;
164
165pub type GstAudioResamplerFilterMode = c_int;
166pub const GST_AUDIO_RESAMPLER_FILTER_MODE_INTERPOLATED: GstAudioResamplerFilterMode = 0;
167pub const GST_AUDIO_RESAMPLER_FILTER_MODE_FULL: GstAudioResamplerFilterMode = 1;
168pub const GST_AUDIO_RESAMPLER_FILTER_MODE_AUTO: GstAudioResamplerFilterMode = 2;
169
170pub type GstAudioResamplerMethod = c_int;
171pub const GST_AUDIO_RESAMPLER_METHOD_NEAREST: GstAudioResamplerMethod = 0;
172pub const GST_AUDIO_RESAMPLER_METHOD_LINEAR: GstAudioResamplerMethod = 1;
173pub const GST_AUDIO_RESAMPLER_METHOD_CUBIC: GstAudioResamplerMethod = 2;
174pub const GST_AUDIO_RESAMPLER_METHOD_BLACKMAN_NUTTALL: GstAudioResamplerMethod = 3;
175pub const GST_AUDIO_RESAMPLER_METHOD_KAISER: GstAudioResamplerMethod = 4;
176
177pub type GstAudioRingBufferFormatType = c_int;
178pub const GST_AUDIO_RING_BUFFER_FORMAT_TYPE_RAW: GstAudioRingBufferFormatType = 0;
179pub const GST_AUDIO_RING_BUFFER_FORMAT_TYPE_MU_LAW: GstAudioRingBufferFormatType = 1;
180pub const GST_AUDIO_RING_BUFFER_FORMAT_TYPE_A_LAW: GstAudioRingBufferFormatType = 2;
181pub const GST_AUDIO_RING_BUFFER_FORMAT_TYPE_IMA_ADPCM: GstAudioRingBufferFormatType = 3;
182pub const GST_AUDIO_RING_BUFFER_FORMAT_TYPE_MPEG: GstAudioRingBufferFormatType = 4;
183pub const GST_AUDIO_RING_BUFFER_FORMAT_TYPE_GSM: GstAudioRingBufferFormatType = 5;
184pub const GST_AUDIO_RING_BUFFER_FORMAT_TYPE_IEC958: GstAudioRingBufferFormatType = 6;
185pub const GST_AUDIO_RING_BUFFER_FORMAT_TYPE_AC3: GstAudioRingBufferFormatType = 7;
186pub const GST_AUDIO_RING_BUFFER_FORMAT_TYPE_EAC3: GstAudioRingBufferFormatType = 8;
187pub const GST_AUDIO_RING_BUFFER_FORMAT_TYPE_DTS: GstAudioRingBufferFormatType = 9;
188pub const GST_AUDIO_RING_BUFFER_FORMAT_TYPE_MPEG2_AAC: GstAudioRingBufferFormatType = 10;
189pub const GST_AUDIO_RING_BUFFER_FORMAT_TYPE_MPEG4_AAC: GstAudioRingBufferFormatType = 11;
190pub const GST_AUDIO_RING_BUFFER_FORMAT_TYPE_MPEG2_AAC_RAW: GstAudioRingBufferFormatType = 12;
191pub const GST_AUDIO_RING_BUFFER_FORMAT_TYPE_MPEG4_AAC_RAW: GstAudioRingBufferFormatType = 13;
192pub const GST_AUDIO_RING_BUFFER_FORMAT_TYPE_FLAC: GstAudioRingBufferFormatType = 14;
193pub const GST_AUDIO_RING_BUFFER_FORMAT_TYPE_DSD: GstAudioRingBufferFormatType = 15;
194
195pub type GstAudioRingBufferState = c_int;
196pub const GST_AUDIO_RING_BUFFER_STATE_STOPPED: GstAudioRingBufferState = 0;
197pub const GST_AUDIO_RING_BUFFER_STATE_PAUSED: GstAudioRingBufferState = 1;
198pub const GST_AUDIO_RING_BUFFER_STATE_STARTED: GstAudioRingBufferState = 2;
199pub const GST_AUDIO_RING_BUFFER_STATE_ERROR: GstAudioRingBufferState = 3;
200
201pub type GstDsdFormat = c_int;
202pub const GST_DSD_FORMAT_UNKNOWN: GstDsdFormat = 0;
203pub const GST_DSD_FORMAT_U8: GstDsdFormat = 1;
204pub const GST_DSD_FORMAT_U16LE: GstDsdFormat = 2;
205pub const GST_DSD_FORMAT_U16BE: GstDsdFormat = 3;
206pub const GST_DSD_FORMAT_U32LE: GstDsdFormat = 4;
207pub const GST_DSD_FORMAT_U32BE: GstDsdFormat = 5;
208pub const GST_NUM_DSD_FORMATS: GstDsdFormat = 6;
209pub const GST_DSD_FORMAT_U16: GstDsdFormat = 2;
210pub const GST_DSD_FORMAT_U32: GstDsdFormat = 4;
211
212pub type GstStreamVolumeFormat = c_int;
213pub const GST_STREAM_VOLUME_FORMAT_LINEAR: GstStreamVolumeFormat = 0;
214pub const GST_STREAM_VOLUME_FORMAT_CUBIC: GstStreamVolumeFormat = 1;
215pub const GST_STREAM_VOLUME_FORMAT_DB: GstStreamVolumeFormat = 2;
216
217pub const GST_AUDIO_CHANNELS_RANGE: &[u8] = b"(int) [ 1, max ]\0";
219pub const GST_AUDIO_CONVERTER_OPT_DITHER_METHOD: &[u8] = b"GstAudioConverter.dither-method\0";
220pub const GST_AUDIO_CONVERTER_OPT_DITHER_THRESHOLD: &[u8] = b"GstAudioConverter.dither-threshold\0";
221pub const GST_AUDIO_CONVERTER_OPT_MIX_MATRIX: &[u8] = b"GstAudioConverter.mix-matrix\0";
222pub const GST_AUDIO_CONVERTER_OPT_NOISE_SHAPING_METHOD: &[u8] =
223 b"GstAudioConverter.noise-shaping-method\0";
224pub const GST_AUDIO_CONVERTER_OPT_QUANTIZATION: &[u8] = b"GstAudioConverter.quantization\0";
225pub const GST_AUDIO_CONVERTER_OPT_RESAMPLER_METHOD: &[u8] = b"GstAudioConverter.resampler-method\0";
226pub const GST_AUDIO_DECODER_MAX_ERRORS: c_int = -1;
227pub const GST_AUDIO_DECODER_SINK_NAME: &[u8] = b"sink\0";
228pub const GST_AUDIO_DECODER_SRC_NAME: &[u8] = b"src\0";
229pub const GST_AUDIO_DEF_CHANNELS: c_int = 2;
230pub const GST_AUDIO_DEF_FORMAT: &[u8] = b"S16LE\0";
231pub const GST_AUDIO_DEF_RATE: c_int = 44100;
232pub const GST_AUDIO_ENCODER_SINK_NAME: &[u8] = b"sink\0";
233pub const GST_AUDIO_ENCODER_SRC_NAME: &[u8] = b"src\0";
234pub const GST_AUDIO_FORMAT_LAST: c_int = 36;
235pub const GST_AUDIO_RATE_RANGE: &[u8] = b"(int) [ 1, max ]\0";
236pub const GST_AUDIO_RESAMPLER_OPT_CUBIC_B: &[u8] = b"GstAudioResampler.cubic-b\0";
237pub const GST_AUDIO_RESAMPLER_OPT_CUBIC_C: &[u8] = b"GstAudioResampler.cubic-c\0";
238pub const GST_AUDIO_RESAMPLER_OPT_CUTOFF: &[u8] = b"GstAudioResampler.cutoff\0";
239pub const GST_AUDIO_RESAMPLER_OPT_FILTER_INTERPOLATION: &[u8] =
240 b"GstAudioResampler.filter-interpolation\0";
241pub const GST_AUDIO_RESAMPLER_OPT_FILTER_MODE: &[u8] = b"GstAudioResampler.filter-mode\0";
242pub const GST_AUDIO_RESAMPLER_OPT_FILTER_MODE_THRESHOLD: &[u8] =
243 b"GstAudioResampler.filter-mode-threshold\0";
244pub const GST_AUDIO_RESAMPLER_OPT_FILTER_OVERSAMPLE: &[u8] =
245 b"GstAudioResampler.filter-oversample\0";
246pub const GST_AUDIO_RESAMPLER_OPT_MAX_PHASE_ERROR: &[u8] = b"GstAudioResampler.max-phase-error\0";
247pub const GST_AUDIO_RESAMPLER_OPT_N_TAPS: &[u8] = b"GstAudioResampler.n-taps\0";
248pub const GST_AUDIO_RESAMPLER_OPT_STOP_ATTENUATION: &[u8] =
249 b"GstAudioResampler.stop-attenutation\0";
250pub const GST_AUDIO_RESAMPLER_OPT_TRANSITION_BANDWIDTH: &[u8] =
251 b"GstAudioResampler.transition-bandwidth\0";
252pub const GST_AUDIO_RESAMPLER_QUALITY_DEFAULT: c_int = 4;
253pub const GST_AUDIO_RESAMPLER_QUALITY_MAX: c_int = 10;
254pub const GST_AUDIO_RESAMPLER_QUALITY_MIN: c_int = 0;
255pub const GST_DSD_FORMATS_ALL: &[u8] = b"{ DSDU32BE, DSDU16BE, DSDU8, DSDU32LE, DSDU16LE }\0";
256pub const GST_DSD_MEDIA_TYPE: &[u8] = b"audio/x-dsd\0";
257pub const GST_DSD_SILENCE_PATTERN_BYTE: c_int = 105;
258pub const GST_META_TAG_AUDIO_CHANNELS_STR: &[u8] = b"channels\0";
259pub const GST_META_TAG_AUDIO_RATE_STR: &[u8] = b"rate\0";
260pub const GST_META_TAG_AUDIO_STR: &[u8] = b"audio\0";
261pub const GST_META_TAG_DSD_PLANE_OFFSETS_STR: &[u8] = b"dsdplaneoffsets\0";
262
263pub type GstAudioChannelMixerFlags = c_uint;
265pub const GST_AUDIO_CHANNEL_MIXER_FLAGS_NONE: GstAudioChannelMixerFlags = 0;
266pub const GST_AUDIO_CHANNEL_MIXER_FLAGS_NON_INTERLEAVED_IN: GstAudioChannelMixerFlags = 1;
267pub const GST_AUDIO_CHANNEL_MIXER_FLAGS_NON_INTERLEAVED_OUT: GstAudioChannelMixerFlags = 2;
268pub const GST_AUDIO_CHANNEL_MIXER_FLAGS_UNPOSITIONED_IN: GstAudioChannelMixerFlags = 4;
269pub const GST_AUDIO_CHANNEL_MIXER_FLAGS_UNPOSITIONED_OUT: GstAudioChannelMixerFlags = 8;
270
271pub type GstAudioConverterFlags = c_uint;
272pub const GST_AUDIO_CONVERTER_FLAG_NONE: GstAudioConverterFlags = 0;
273pub const GST_AUDIO_CONVERTER_FLAG_IN_WRITABLE: GstAudioConverterFlags = 1;
274pub const GST_AUDIO_CONVERTER_FLAG_VARIABLE_RATE: GstAudioConverterFlags = 2;
275
276pub type GstAudioFlags = c_uint;
277pub const GST_AUDIO_FLAG_NONE: GstAudioFlags = 0;
278pub const GST_AUDIO_FLAG_UNPOSITIONED: GstAudioFlags = 1;
279
280pub type GstAudioFormatFlags = c_uint;
281pub const GST_AUDIO_FORMAT_FLAG_INTEGER: GstAudioFormatFlags = 1;
282pub const GST_AUDIO_FORMAT_FLAG_FLOAT: GstAudioFormatFlags = 2;
283pub const GST_AUDIO_FORMAT_FLAG_SIGNED: GstAudioFormatFlags = 4;
284pub const GST_AUDIO_FORMAT_FLAG_COMPLEX: GstAudioFormatFlags = 16;
285pub const GST_AUDIO_FORMAT_FLAG_UNPACK: GstAudioFormatFlags = 32;
286
287pub type GstAudioPackFlags = c_uint;
288pub const GST_AUDIO_PACK_FLAG_NONE: GstAudioPackFlags = 0;
289pub const GST_AUDIO_PACK_FLAG_TRUNCATE_RANGE: GstAudioPackFlags = 1;
290
291pub type GstAudioQuantizeFlags = c_uint;
292pub const GST_AUDIO_QUANTIZE_FLAG_NONE: GstAudioQuantizeFlags = 0;
293pub const GST_AUDIO_QUANTIZE_FLAG_NON_INTERLEAVED: GstAudioQuantizeFlags = 1;
294
295pub type GstAudioResamplerFlags = c_uint;
296pub const GST_AUDIO_RESAMPLER_FLAG_NONE: GstAudioResamplerFlags = 0;
297pub const GST_AUDIO_RESAMPLER_FLAG_NON_INTERLEAVED_IN: GstAudioResamplerFlags = 1;
298pub const GST_AUDIO_RESAMPLER_FLAG_NON_INTERLEAVED_OUT: GstAudioResamplerFlags = 2;
299pub const GST_AUDIO_RESAMPLER_FLAG_VARIABLE_RATE: GstAudioResamplerFlags = 4;
300
301#[derive(Copy, Clone)]
303#[repr(C)]
304pub union GstAudioRingBufferSpec_ABI {
305 pub abi: GstAudioRingBufferSpec_ABI_abi,
306 pub _gst_reserved: [gpointer; 4],
307}
308
309impl ::std::fmt::Debug for GstAudioRingBufferSpec_ABI {
310 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
311 f.debug_struct(&format!("GstAudioRingBufferSpec_ABI @ {self:p}"))
312 .field("abi", unsafe { &self.abi })
313 .finish()
314 }
315}
316
317pub type GstAudioBaseSinkCustomSlavingCallback = Option<
319 unsafe extern "C" fn(
320 *mut GstAudioBaseSink,
321 gst::GstClockTime,
322 gst::GstClockTime,
323 *mut gst::GstClockTimeDiff,
324 GstAudioBaseSinkDiscontReason,
325 gpointer,
326 ),
327>;
328pub type GstAudioClockGetTimeFunc =
329 Option<unsafe extern "C" fn(*mut gst::GstClock, gpointer) -> gst::GstClockTime>;
330pub type GstAudioFormatPack = Option<
331 unsafe extern "C" fn(
332 *const GstAudioFormatInfo,
333 GstAudioPackFlags,
334 gconstpointer,
335 gpointer,
336 c_int,
337 ),
338>;
339pub type GstAudioFormatUnpack = Option<
340 unsafe extern "C" fn(
341 *const GstAudioFormatInfo,
342 GstAudioPackFlags,
343 gpointer,
344 gconstpointer,
345 c_int,
346 ),
347>;
348pub type GstAudioRingBufferCallback =
349 Option<unsafe extern "C" fn(*mut GstAudioRingBuffer, *mut u8, c_uint, gpointer)>;
350
351#[derive(Copy, Clone)]
353#[repr(C)]
354pub struct GstAudioAggregatorClass {
355 pub parent_class: gst_base::GstAggregatorClass,
356 pub create_output_buffer:
357 Option<unsafe extern "C" fn(*mut GstAudioAggregator, c_uint) -> *mut gst::GstBuffer>,
358 pub aggregate_one_buffer: Option<
359 unsafe extern "C" fn(
360 *mut GstAudioAggregator,
361 *mut GstAudioAggregatorPad,
362 *mut gst::GstBuffer,
363 c_uint,
364 *mut gst::GstBuffer,
365 c_uint,
366 c_uint,
367 ) -> gboolean,
368 >,
369 pub _gst_reserved: [gpointer; 20],
370}
371
372impl ::std::fmt::Debug for GstAudioAggregatorClass {
373 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
374 f.debug_struct(&format!("GstAudioAggregatorClass @ {self:p}"))
375 .field("parent_class", &self.parent_class)
376 .field("create_output_buffer", &self.create_output_buffer)
377 .field("aggregate_one_buffer", &self.aggregate_one_buffer)
378 .finish()
379 }
380}
381
382#[derive(Copy, Clone)]
383#[repr(C)]
384pub struct GstAudioAggregatorConvertPadClass {
385 pub parent_class: GstAudioAggregatorPadClass,
386 pub _gst_reserved: [gpointer; 4],
387}
388
389impl ::std::fmt::Debug for GstAudioAggregatorConvertPadClass {
390 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
391 f.debug_struct(&format!("GstAudioAggregatorConvertPadClass @ {self:p}"))
392 .field("parent_class", &self.parent_class)
393 .finish()
394 }
395}
396
397#[repr(C)]
398#[allow(dead_code)]
399pub struct _GstAudioAggregatorConvertPadPrivate {
400 _data: [u8; 0],
401 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
402}
403
404pub type GstAudioAggregatorConvertPadPrivate = _GstAudioAggregatorConvertPadPrivate;
405
406#[derive(Copy, Clone)]
407#[repr(C)]
408pub struct GstAudioAggregatorPadClass {
409 pub parent_class: gst_base::GstAggregatorPadClass,
410 pub convert_buffer: Option<
411 unsafe extern "C" fn(
412 *mut GstAudioAggregatorPad,
413 *mut GstAudioInfo,
414 *mut GstAudioInfo,
415 *mut gst::GstBuffer,
416 ) -> *mut gst::GstBuffer,
417 >,
418 pub update_conversion_info: Option<unsafe extern "C" fn(*mut GstAudioAggregatorPad)>,
419 pub _gst_reserved: [gpointer; 20],
420}
421
422impl ::std::fmt::Debug for GstAudioAggregatorPadClass {
423 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
424 f.debug_struct(&format!("GstAudioAggregatorPadClass @ {self:p}"))
425 .field("parent_class", &self.parent_class)
426 .field("convert_buffer", &self.convert_buffer)
427 .field("update_conversion_info", &self.update_conversion_info)
428 .finish()
429 }
430}
431
432#[repr(C)]
433#[allow(dead_code)]
434pub struct _GstAudioAggregatorPadPrivate {
435 _data: [u8; 0],
436 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
437}
438
439pub type GstAudioAggregatorPadPrivate = _GstAudioAggregatorPadPrivate;
440
441#[repr(C)]
442#[allow(dead_code)]
443pub struct _GstAudioAggregatorPrivate {
444 _data: [u8; 0],
445 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
446}
447
448pub type GstAudioAggregatorPrivate = _GstAudioAggregatorPrivate;
449
450#[derive(Copy, Clone)]
451#[repr(C)]
452pub struct GstAudioBaseSinkClass {
453 pub parent_class: gst_base::GstBaseSinkClass,
454 pub create_ringbuffer:
455 Option<unsafe extern "C" fn(*mut GstAudioBaseSink) -> *mut GstAudioRingBuffer>,
456 pub payload: Option<
457 unsafe extern "C" fn(*mut GstAudioBaseSink, *mut gst::GstBuffer) -> *mut gst::GstBuffer,
458 >,
459 pub _gst_reserved: [gpointer; 4],
460}
461
462impl ::std::fmt::Debug for GstAudioBaseSinkClass {
463 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
464 f.debug_struct(&format!("GstAudioBaseSinkClass @ {self:p}"))
465 .field("parent_class", &self.parent_class)
466 .field("create_ringbuffer", &self.create_ringbuffer)
467 .field("payload", &self.payload)
468 .finish()
469 }
470}
471
472#[repr(C)]
473#[allow(dead_code)]
474pub struct _GstAudioBaseSinkPrivate {
475 _data: [u8; 0],
476 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
477}
478
479pub type GstAudioBaseSinkPrivate = _GstAudioBaseSinkPrivate;
480
481#[derive(Copy, Clone)]
482#[repr(C)]
483pub struct GstAudioBaseSrcClass {
484 pub parent_class: gst_base::GstPushSrcClass,
485 pub create_ringbuffer:
486 Option<unsafe extern "C" fn(*mut GstAudioBaseSrc) -> *mut GstAudioRingBuffer>,
487 pub _gst_reserved: [gpointer; 4],
488}
489
490impl ::std::fmt::Debug for GstAudioBaseSrcClass {
491 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
492 f.debug_struct(&format!("GstAudioBaseSrcClass @ {self:p}"))
493 .field("parent_class", &self.parent_class)
494 .field("create_ringbuffer", &self.create_ringbuffer)
495 .finish()
496 }
497}
498
499#[repr(C)]
500#[allow(dead_code)]
501pub struct _GstAudioBaseSrcPrivate {
502 _data: [u8; 0],
503 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
504}
505
506pub type GstAudioBaseSrcPrivate = _GstAudioBaseSrcPrivate;
507
508#[derive(Copy, Clone)]
509#[repr(C)]
510pub struct GstAudioBuffer {
511 pub info: GstAudioInfo,
512 pub n_samples: size_t,
513 pub n_planes: c_int,
514 pub planes: *mut gpointer,
515 pub buffer: *mut gst::GstBuffer,
516 pub map_infos: *mut gst::GstMapInfo,
517 pub priv_planes_arr: [gpointer; 8],
518 pub priv_map_infos_arr: [gst::GstMapInfo; 8],
519 pub _gst_reserved: [gpointer; 4],
520}
521
522impl ::std::fmt::Debug for GstAudioBuffer {
523 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
524 f.debug_struct(&format!("GstAudioBuffer @ {self:p}"))
525 .field("info", &self.info)
526 .field("n_samples", &self.n_samples)
527 .field("n_planes", &self.n_planes)
528 .field("planes", &self.planes)
529 .field("buffer", &self.buffer)
530 .finish()
531 }
532}
533
534#[derive(Copy, Clone)]
535#[repr(C)]
536pub struct GstAudioCdSrcClass {
537 pub pushsrc_class: gst_base::GstPushSrcClass,
538 pub open: Option<unsafe extern "C" fn(*mut GstAudioCdSrc, *const c_char) -> gboolean>,
539 pub close: Option<unsafe extern "C" fn(*mut GstAudioCdSrc)>,
540 pub read_sector: Option<unsafe extern "C" fn(*mut GstAudioCdSrc, c_int) -> *mut gst::GstBuffer>,
541 pub _gst_reserved: [gpointer; 20],
542}
543
544impl ::std::fmt::Debug for GstAudioCdSrcClass {
545 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
546 f.debug_struct(&format!("GstAudioCdSrcClass @ {self:p}"))
547 .field("pushsrc_class", &self.pushsrc_class)
548 .field("open", &self.open)
549 .field("close", &self.close)
550 .field("read_sector", &self.read_sector)
551 .finish()
552 }
553}
554
555#[repr(C)]
556#[allow(dead_code)]
557pub struct _GstAudioCdSrcPrivate {
558 _data: [u8; 0],
559 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
560}
561
562pub type GstAudioCdSrcPrivate = _GstAudioCdSrcPrivate;
563
564#[derive(Copy, Clone)]
565#[repr(C)]
566pub struct GstAudioCdSrcTrack {
567 pub is_audio: gboolean,
568 pub num: c_uint,
569 pub start: c_uint,
570 pub end: c_uint,
571 pub tags: *mut gst::GstTagList,
572 pub _gst_reserved1: [c_uint; 2],
573 pub _gst_reserved2: [gpointer; 2],
574}
575
576impl ::std::fmt::Debug for GstAudioCdSrcTrack {
577 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
578 f.debug_struct(&format!("GstAudioCdSrcTrack @ {self:p}"))
579 .field("is_audio", &self.is_audio)
580 .field("num", &self.num)
581 .field("start", &self.start)
582 .field("end", &self.end)
583 .field("tags", &self.tags)
584 .finish()
585 }
586}
587
588#[repr(C)]
589#[allow(dead_code)]
590pub struct _GstAudioChannelMixer {
591 _data: [u8; 0],
592 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
593}
594
595pub type GstAudioChannelMixer = _GstAudioChannelMixer;
596
597#[derive(Copy, Clone)]
598#[repr(C)]
599pub struct GstAudioClippingMeta {
600 pub meta: gst::GstMeta,
601 pub format: gst::GstFormat,
602 pub start: u64,
603 pub end: u64,
604}
605
606impl ::std::fmt::Debug for GstAudioClippingMeta {
607 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
608 f.debug_struct(&format!("GstAudioClippingMeta @ {self:p}"))
609 .field("meta", &self.meta)
610 .field("format", &self.format)
611 .field("start", &self.start)
612 .field("end", &self.end)
613 .finish()
614 }
615}
616
617#[derive(Copy, Clone)]
618#[repr(C)]
619pub struct GstAudioClockClass {
620 pub parent_class: gst::GstSystemClockClass,
621 pub _gst_reserved: [gpointer; 4],
622}
623
624impl ::std::fmt::Debug for GstAudioClockClass {
625 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
626 f.debug_struct(&format!("GstAudioClockClass @ {self:p}"))
627 .field("parent_class", &self.parent_class)
628 .finish()
629 }
630}
631
632#[repr(C)]
633#[allow(dead_code)]
634pub struct GstAudioConverter {
635 _data: [u8; 0],
636 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
637}
638
639impl ::std::fmt::Debug for GstAudioConverter {
640 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
641 f.debug_struct(&format!("GstAudioConverter @ {self:p}"))
642 .finish()
643 }
644}
645
646#[derive(Copy, Clone)]
647#[repr(C)]
648pub struct GstAudioDecoderClass {
649 pub element_class: gst::GstElementClass,
650 pub start: Option<unsafe extern "C" fn(*mut GstAudioDecoder) -> gboolean>,
651 pub stop: Option<unsafe extern "C" fn(*mut GstAudioDecoder) -> gboolean>,
652 pub set_format:
653 Option<unsafe extern "C" fn(*mut GstAudioDecoder, *mut gst::GstCaps) -> gboolean>,
654 pub parse: Option<
655 unsafe extern "C" fn(
656 *mut GstAudioDecoder,
657 *mut gst_base::GstAdapter,
658 *mut c_int,
659 *mut c_int,
660 ) -> gst::GstFlowReturn,
661 >,
662 pub handle_frame: Option<
663 unsafe extern "C" fn(*mut GstAudioDecoder, *mut *mut gst::GstBuffer) -> gst::GstFlowReturn,
664 >,
665 pub flush: Option<unsafe extern "C" fn(*mut GstAudioDecoder, gboolean)>,
666 pub pre_push: Option<
667 unsafe extern "C" fn(*mut GstAudioDecoder, *mut *mut gst::GstBuffer) -> gst::GstFlowReturn,
668 >,
669 pub sink_event:
670 Option<unsafe extern "C" fn(*mut GstAudioDecoder, *mut gst::GstEvent) -> gboolean>,
671 pub src_event:
672 Option<unsafe extern "C" fn(*mut GstAudioDecoder, *mut gst::GstEvent) -> gboolean>,
673 pub open: Option<unsafe extern "C" fn(*mut GstAudioDecoder) -> gboolean>,
674 pub close: Option<unsafe extern "C" fn(*mut GstAudioDecoder) -> gboolean>,
675 pub negotiate: Option<unsafe extern "C" fn(*mut GstAudioDecoder) -> gboolean>,
676 pub decide_allocation:
677 Option<unsafe extern "C" fn(*mut GstAudioDecoder, *mut gst::GstQuery) -> gboolean>,
678 pub propose_allocation:
679 Option<unsafe extern "C" fn(*mut GstAudioDecoder, *mut gst::GstQuery) -> gboolean>,
680 pub sink_query:
681 Option<unsafe extern "C" fn(*mut GstAudioDecoder, *mut gst::GstQuery) -> gboolean>,
682 pub src_query:
683 Option<unsafe extern "C" fn(*mut GstAudioDecoder, *mut gst::GstQuery) -> gboolean>,
684 pub getcaps:
685 Option<unsafe extern "C" fn(*mut GstAudioDecoder, *mut gst::GstCaps) -> *mut gst::GstCaps>,
686 pub transform_meta: Option<
687 unsafe extern "C" fn(
688 *mut GstAudioDecoder,
689 *mut gst::GstBuffer,
690 *mut gst::GstMeta,
691 *mut gst::GstBuffer,
692 ) -> gboolean,
693 >,
694 pub _gst_reserved: [gpointer; 16],
695}
696
697impl ::std::fmt::Debug for GstAudioDecoderClass {
698 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
699 f.debug_struct(&format!("GstAudioDecoderClass @ {self:p}"))
700 .field("element_class", &self.element_class)
701 .field("start", &self.start)
702 .field("stop", &self.stop)
703 .field("set_format", &self.set_format)
704 .field("parse", &self.parse)
705 .field("handle_frame", &self.handle_frame)
706 .field("flush", &self.flush)
707 .field("pre_push", &self.pre_push)
708 .field("sink_event", &self.sink_event)
709 .field("src_event", &self.src_event)
710 .field("open", &self.open)
711 .field("close", &self.close)
712 .field("negotiate", &self.negotiate)
713 .field("decide_allocation", &self.decide_allocation)
714 .field("propose_allocation", &self.propose_allocation)
715 .field("sink_query", &self.sink_query)
716 .field("src_query", &self.src_query)
717 .field("getcaps", &self.getcaps)
718 .field("transform_meta", &self.transform_meta)
719 .finish()
720 }
721}
722
723#[repr(C)]
724#[allow(dead_code)]
725pub struct _GstAudioDecoderPrivate {
726 _data: [u8; 0],
727 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
728}
729
730pub type GstAudioDecoderPrivate = _GstAudioDecoderPrivate;
731
732#[derive(Copy, Clone)]
733#[repr(C)]
734pub struct GstAudioDownmixMeta {
735 pub meta: gst::GstMeta,
736 pub from_position: *mut GstAudioChannelPosition,
737 pub to_position: *mut GstAudioChannelPosition,
738 pub from_channels: c_int,
739 pub to_channels: c_int,
740 pub matrix: *mut *mut c_float,
741}
742
743impl ::std::fmt::Debug for GstAudioDownmixMeta {
744 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
745 f.debug_struct(&format!("GstAudioDownmixMeta @ {self:p}"))
746 .field("meta", &self.meta)
747 .field("from_position", &self.from_position)
748 .field("to_position", &self.to_position)
749 .field("from_channels", &self.from_channels)
750 .field("to_channels", &self.to_channels)
751 .field("matrix", &self.matrix)
752 .finish()
753 }
754}
755
756#[derive(Copy, Clone)]
757#[repr(C)]
758pub struct GstAudioEncoderClass {
759 pub element_class: gst::GstElementClass,
760 pub start: Option<unsafe extern "C" fn(*mut GstAudioEncoder) -> gboolean>,
761 pub stop: Option<unsafe extern "C" fn(*mut GstAudioEncoder) -> gboolean>,
762 pub set_format:
763 Option<unsafe extern "C" fn(*mut GstAudioEncoder, *mut GstAudioInfo) -> gboolean>,
764 pub handle_frame: Option<
765 unsafe extern "C" fn(*mut GstAudioEncoder, *mut *mut gst::GstBuffer) -> gst::GstFlowReturn,
766 >,
767 pub flush: Option<unsafe extern "C" fn(*mut GstAudioEncoder)>,
768 pub pre_push: Option<
769 unsafe extern "C" fn(*mut GstAudioEncoder, *mut *mut gst::GstBuffer) -> gst::GstFlowReturn,
770 >,
771 pub sink_event:
772 Option<unsafe extern "C" fn(*mut GstAudioEncoder, *mut gst::GstEvent) -> gboolean>,
773 pub src_event:
774 Option<unsafe extern "C" fn(*mut GstAudioEncoder, *mut gst::GstEvent) -> gboolean>,
775 pub getcaps:
776 Option<unsafe extern "C" fn(*mut GstAudioEncoder, *mut gst::GstCaps) -> *mut gst::GstCaps>,
777 pub open: Option<unsafe extern "C" fn(*mut GstAudioEncoder) -> gboolean>,
778 pub close: Option<unsafe extern "C" fn(*mut GstAudioEncoder) -> gboolean>,
779 pub negotiate: Option<unsafe extern "C" fn(*mut GstAudioEncoder) -> gboolean>,
780 pub decide_allocation:
781 Option<unsafe extern "C" fn(*mut GstAudioEncoder, *mut gst::GstQuery) -> gboolean>,
782 pub propose_allocation:
783 Option<unsafe extern "C" fn(*mut GstAudioEncoder, *mut gst::GstQuery) -> gboolean>,
784 pub transform_meta: Option<
785 unsafe extern "C" fn(
786 *mut GstAudioEncoder,
787 *mut gst::GstBuffer,
788 *mut gst::GstMeta,
789 *mut gst::GstBuffer,
790 ) -> gboolean,
791 >,
792 pub sink_query:
793 Option<unsafe extern "C" fn(*mut GstAudioEncoder, *mut gst::GstQuery) -> gboolean>,
794 pub src_query:
795 Option<unsafe extern "C" fn(*mut GstAudioEncoder, *mut gst::GstQuery) -> gboolean>,
796 pub _gst_reserved: [gpointer; 17],
797}
798
799impl ::std::fmt::Debug for GstAudioEncoderClass {
800 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
801 f.debug_struct(&format!("GstAudioEncoderClass @ {self:p}"))
802 .field("element_class", &self.element_class)
803 .field("start", &self.start)
804 .field("stop", &self.stop)
805 .field("set_format", &self.set_format)
806 .field("handle_frame", &self.handle_frame)
807 .field("flush", &self.flush)
808 .field("pre_push", &self.pre_push)
809 .field("sink_event", &self.sink_event)
810 .field("src_event", &self.src_event)
811 .field("getcaps", &self.getcaps)
812 .field("open", &self.open)
813 .field("close", &self.close)
814 .field("negotiate", &self.negotiate)
815 .field("decide_allocation", &self.decide_allocation)
816 .field("propose_allocation", &self.propose_allocation)
817 .field("transform_meta", &self.transform_meta)
818 .field("sink_query", &self.sink_query)
819 .field("src_query", &self.src_query)
820 .finish()
821 }
822}
823
824#[repr(C)]
825#[allow(dead_code)]
826pub struct _GstAudioEncoderPrivate {
827 _data: [u8; 0],
828 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
829}
830
831pub type GstAudioEncoderPrivate = _GstAudioEncoderPrivate;
832
833#[derive(Copy, Clone)]
834#[repr(C)]
835pub struct GstAudioFilterClass {
836 pub basetransformclass: gst_base::GstBaseTransformClass,
837 pub setup: Option<unsafe extern "C" fn(*mut GstAudioFilter, *const GstAudioInfo) -> gboolean>,
838 pub _gst_reserved: [gpointer; 4],
839}
840
841impl ::std::fmt::Debug for GstAudioFilterClass {
842 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
843 f.debug_struct(&format!("GstAudioFilterClass @ {self:p}"))
844 .field("basetransformclass", &self.basetransformclass)
845 .field("setup", &self.setup)
846 .finish()
847 }
848}
849
850#[derive(Copy, Clone)]
851#[repr(C)]
852pub struct GstAudioFormatInfo {
853 pub format: GstAudioFormat,
854 pub name: *const c_char,
855 pub description: *const c_char,
856 pub flags: GstAudioFormatFlags,
857 pub endianness: c_int,
858 pub width: c_int,
859 pub depth: c_int,
860 pub silence: [u8; 8],
861 pub unpack_format: GstAudioFormat,
862 pub unpack_func: GstAudioFormatUnpack,
863 pub pack_func: GstAudioFormatPack,
864 pub _gst_reserved: [gpointer; 4],
865}
866
867impl ::std::fmt::Debug for GstAudioFormatInfo {
868 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
869 f.debug_struct(&format!("GstAudioFormatInfo @ {self:p}"))
870 .field("format", &self.format)
871 .field("name", &self.name)
872 .field("description", &self.description)
873 .field("flags", &self.flags)
874 .field("endianness", &self.endianness)
875 .field("width", &self.width)
876 .field("depth", &self.depth)
877 .field("silence", &self.silence)
878 .field("unpack_format", &self.unpack_format)
879 .field("unpack_func", &self.unpack_func)
880 .field("pack_func", &self.pack_func)
881 .finish()
882 }
883}
884
885#[derive(Copy, Clone)]
886#[repr(C)]
887pub struct GstAudioInfo {
888 pub finfo: *const GstAudioFormatInfo,
889 pub flags: GstAudioFlags,
890 pub layout: GstAudioLayout,
891 pub rate: c_int,
892 pub channels: c_int,
893 pub bpf: c_int,
894 pub position: [GstAudioChannelPosition; 64],
895 pub _gst_reserved: [gpointer; 4],
896}
897
898impl ::std::fmt::Debug for GstAudioInfo {
899 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
900 f.debug_struct(&format!("GstAudioInfo @ {self:p}"))
901 .field("finfo", &self.finfo)
902 .field("flags", &self.flags)
903 .field("layout", &self.layout)
904 .field("rate", &self.rate)
905 .field("channels", &self.channels)
906 .field("bpf", &self.bpf)
907 .finish()
908 }
909}
910
911#[derive(Copy, Clone)]
912#[repr(C)]
913pub struct GstAudioLevelMeta {
914 pub meta: gst::GstMeta,
915 pub level: u8,
916 pub voice_activity: gboolean,
917}
918
919impl ::std::fmt::Debug for GstAudioLevelMeta {
920 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
921 f.debug_struct(&format!("GstAudioLevelMeta @ {self:p}"))
922 .field("meta", &self.meta)
923 .field("level", &self.level)
924 .field("voice_activity", &self.voice_activity)
925 .finish()
926 }
927}
928
929#[derive(Copy, Clone)]
930#[repr(C)]
931pub struct GstAudioMeta {
932 pub meta: gst::GstMeta,
933 pub info: GstAudioInfo,
934 pub samples: size_t,
935 pub offsets: *mut size_t,
936 pub priv_offsets_arr: [size_t; 8],
937 pub _gst_reserved: [gpointer; 4],
938}
939
940impl ::std::fmt::Debug for GstAudioMeta {
941 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
942 f.debug_struct(&format!("GstAudioMeta @ {self:p}"))
943 .field("meta", &self.meta)
944 .field("info", &self.info)
945 .field("samples", &self.samples)
946 .field("offsets", &self.offsets)
947 .finish()
948 }
949}
950
951#[repr(C)]
952#[allow(dead_code)]
953pub struct _GstAudioQuantize {
954 _data: [u8; 0],
955 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
956}
957
958pub type GstAudioQuantize = _GstAudioQuantize;
959
960#[repr(C)]
961#[allow(dead_code)]
962pub struct _GstAudioResampler {
963 _data: [u8; 0],
964 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
965}
966
967pub type GstAudioResampler = _GstAudioResampler;
968
969#[derive(Copy, Clone)]
970#[repr(C)]
971pub struct GstAudioRingBufferClass {
972 pub parent_class: gst::GstObjectClass,
973 pub open_device: Option<unsafe extern "C" fn(*mut GstAudioRingBuffer) -> gboolean>,
974 pub acquire: Option<
975 unsafe extern "C" fn(*mut GstAudioRingBuffer, *mut GstAudioRingBufferSpec) -> gboolean,
976 >,
977 pub release: Option<unsafe extern "C" fn(*mut GstAudioRingBuffer) -> gboolean>,
978 pub close_device: Option<unsafe extern "C" fn(*mut GstAudioRingBuffer) -> gboolean>,
979 pub start: Option<unsafe extern "C" fn(*mut GstAudioRingBuffer) -> gboolean>,
980 pub pause: Option<unsafe extern "C" fn(*mut GstAudioRingBuffer) -> gboolean>,
981 pub resume: Option<unsafe extern "C" fn(*mut GstAudioRingBuffer) -> gboolean>,
982 pub stop: Option<unsafe extern "C" fn(*mut GstAudioRingBuffer) -> gboolean>,
983 pub delay: Option<unsafe extern "C" fn(*mut GstAudioRingBuffer) -> c_uint>,
984 pub activate: Option<unsafe extern "C" fn(*mut GstAudioRingBuffer, gboolean) -> gboolean>,
985 pub commit: Option<
986 unsafe extern "C" fn(
987 *mut GstAudioRingBuffer,
988 *mut u64,
989 *mut u8,
990 c_int,
991 c_int,
992 *mut c_int,
993 ) -> c_uint,
994 >,
995 pub clear_all: Option<unsafe extern "C" fn(*mut GstAudioRingBuffer)>,
996 pub _gst_reserved: [gpointer; 4],
997}
998
999impl ::std::fmt::Debug for GstAudioRingBufferClass {
1000 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1001 f.debug_struct(&format!("GstAudioRingBufferClass @ {self:p}"))
1002 .field("parent_class", &self.parent_class)
1003 .field("open_device", &self.open_device)
1004 .field("acquire", &self.acquire)
1005 .field("release", &self.release)
1006 .field("close_device", &self.close_device)
1007 .field("start", &self.start)
1008 .field("pause", &self.pause)
1009 .field("resume", &self.resume)
1010 .field("stop", &self.stop)
1011 .field("delay", &self.delay)
1012 .field("activate", &self.activate)
1013 .field("commit", &self.commit)
1014 .field("clear_all", &self.clear_all)
1015 .finish()
1016 }
1017}
1018
1019#[repr(C)]
1020#[allow(dead_code)]
1021pub struct _GstAudioRingBufferPrivate {
1022 _data: [u8; 0],
1023 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1024}
1025
1026pub type GstAudioRingBufferPrivate = _GstAudioRingBufferPrivate;
1027
1028#[derive(Copy, Clone)]
1029#[repr(C)]
1030pub struct GstAudioRingBufferSpec {
1031 pub caps: *mut gst::GstCaps,
1032 pub type_: GstAudioRingBufferFormatType,
1033 pub info: GstAudioInfo,
1034 pub latency_time: u64,
1035 pub buffer_time: u64,
1036 pub segsize: c_int,
1037 pub segtotal: c_int,
1038 pub seglatency: c_int,
1039 pub ABI: GstAudioRingBufferSpec_ABI,
1040}
1041
1042impl ::std::fmt::Debug for GstAudioRingBufferSpec {
1043 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1044 f.debug_struct(&format!("GstAudioRingBufferSpec @ {self:p}"))
1045 .field("caps", &self.caps)
1046 .field("type_", &self.type_)
1047 .field("info", &self.info)
1048 .field("latency_time", &self.latency_time)
1049 .field("buffer_time", &self.buffer_time)
1050 .field("segsize", &self.segsize)
1051 .field("segtotal", &self.segtotal)
1052 .field("seglatency", &self.seglatency)
1053 .field("ABI", &self.ABI)
1054 .finish()
1055 }
1056}
1057
1058#[derive(Copy, Clone)]
1059#[repr(C)]
1060pub struct GstAudioRingBufferSpec_ABI_abi {
1061 pub dsd_format: GstDsdFormat,
1062}
1063
1064impl ::std::fmt::Debug for GstAudioRingBufferSpec_ABI_abi {
1065 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1066 f.debug_struct(&format!("GstAudioRingBufferSpec_ABI_abi @ {self:p}"))
1067 .field("dsd_format", &self.dsd_format)
1068 .finish()
1069 }
1070}
1071
1072#[derive(Copy, Clone)]
1073#[repr(C)]
1074pub struct GstAudioSinkClass {
1075 pub parent_class: GstAudioBaseSinkClass,
1076 pub open: Option<unsafe extern "C" fn(*mut GstAudioSink) -> gboolean>,
1077 pub prepare:
1078 Option<unsafe extern "C" fn(*mut GstAudioSink, *mut GstAudioRingBufferSpec) -> gboolean>,
1079 pub unprepare: Option<unsafe extern "C" fn(*mut GstAudioSink) -> gboolean>,
1080 pub close: Option<unsafe extern "C" fn(*mut GstAudioSink) -> gboolean>,
1081 pub write: Option<unsafe extern "C" fn(*mut GstAudioSink, gpointer, c_uint) -> c_int>,
1082 pub delay: Option<unsafe extern "C" fn(*mut GstAudioSink) -> c_uint>,
1083 pub reset: Option<unsafe extern "C" fn(*mut GstAudioSink)>,
1084 pub pause: Option<unsafe extern "C" fn(*mut GstAudioSink)>,
1085 pub resume: Option<unsafe extern "C" fn(*mut GstAudioSink)>,
1086 pub stop: Option<unsafe extern "C" fn(*mut GstAudioSink)>,
1087 pub extension: *mut GstAudioSinkClassExtension,
1088}
1089
1090impl ::std::fmt::Debug for GstAudioSinkClass {
1091 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1092 f.debug_struct(&format!("GstAudioSinkClass @ {self:p}"))
1093 .field("parent_class", &self.parent_class)
1094 .field("open", &self.open)
1095 .field("prepare", &self.prepare)
1096 .field("unprepare", &self.unprepare)
1097 .field("close", &self.close)
1098 .field("write", &self.write)
1099 .field("delay", &self.delay)
1100 .field("reset", &self.reset)
1101 .field("pause", &self.pause)
1102 .field("resume", &self.resume)
1103 .field("stop", &self.stop)
1104 .field("extension", &self.extension)
1105 .finish()
1106 }
1107}
1108
1109#[derive(Copy, Clone)]
1110#[repr(C)]
1111pub struct GstAudioSinkClassExtension {
1112 pub clear_all: Option<unsafe extern "C" fn(*mut GstAudioSink)>,
1113}
1114
1115impl ::std::fmt::Debug for GstAudioSinkClassExtension {
1116 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1117 f.debug_struct(&format!("GstAudioSinkClassExtension @ {self:p}"))
1118 .field("clear_all", &self.clear_all)
1119 .finish()
1120 }
1121}
1122
1123#[derive(Copy, Clone)]
1124#[repr(C)]
1125pub struct GstAudioSrcClass {
1126 pub parent_class: GstAudioBaseSrcClass,
1127 pub open: Option<unsafe extern "C" fn(*mut GstAudioSrc) -> gboolean>,
1128 pub prepare:
1129 Option<unsafe extern "C" fn(*mut GstAudioSrc, *mut GstAudioRingBufferSpec) -> gboolean>,
1130 pub unprepare: Option<unsafe extern "C" fn(*mut GstAudioSrc) -> gboolean>,
1131 pub close: Option<unsafe extern "C" fn(*mut GstAudioSrc) -> gboolean>,
1132 pub read: Option<
1133 unsafe extern "C" fn(*mut GstAudioSrc, gpointer, c_uint, *mut gst::GstClockTime) -> c_uint,
1134 >,
1135 pub delay: Option<unsafe extern "C" fn(*mut GstAudioSrc) -> c_uint>,
1136 pub reset: Option<unsafe extern "C" fn(*mut GstAudioSrc)>,
1137 pub _gst_reserved: [gpointer; 4],
1138}
1139
1140impl ::std::fmt::Debug for GstAudioSrcClass {
1141 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1142 f.debug_struct(&format!("GstAudioSrcClass @ {self:p}"))
1143 .field("parent_class", &self.parent_class)
1144 .field("open", &self.open)
1145 .field("prepare", &self.prepare)
1146 .field("unprepare", &self.unprepare)
1147 .field("close", &self.close)
1148 .field("read", &self.read)
1149 .field("delay", &self.delay)
1150 .field("reset", &self.reset)
1151 .finish()
1152 }
1153}
1154
1155#[repr(C)]
1156#[allow(dead_code)]
1157pub struct GstAudioStreamAlign {
1158 _data: [u8; 0],
1159 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1160}
1161
1162impl ::std::fmt::Debug for GstAudioStreamAlign {
1163 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1164 f.debug_struct(&format!("GstAudioStreamAlign @ {self:p}"))
1165 .finish()
1166 }
1167}
1168
1169#[derive(Copy, Clone)]
1170#[repr(C)]
1171pub struct GstDsdInfo {
1172 pub format: GstDsdFormat,
1173 pub rate: c_int,
1174 pub channels: c_int,
1175 pub layout: GstAudioLayout,
1176 pub reversed_bytes: gboolean,
1177 pub positions: [GstAudioChannelPosition; 64],
1178 pub flags: GstAudioFlags,
1179 pub _gst_reserved: [gpointer; 4],
1180}
1181
1182impl ::std::fmt::Debug for GstDsdInfo {
1183 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1184 f.debug_struct(&format!("GstDsdInfo @ {self:p}"))
1185 .field("format", &self.format)
1186 .field("rate", &self.rate)
1187 .field("channels", &self.channels)
1188 .field("layout", &self.layout)
1189 .field("reversed_bytes", &self.reversed_bytes)
1190 .field("flags", &self.flags)
1191 .finish()
1192 }
1193}
1194
1195#[derive(Copy, Clone)]
1196#[repr(C)]
1197pub struct GstDsdPlaneOffsetMeta {
1198 pub meta: gst::GstMeta,
1199 pub num_channels: c_int,
1200 pub num_bytes_per_channel: size_t,
1201 pub offsets: *mut size_t,
1202 pub priv_offsets_arr: [size_t; 8],
1203 pub _gst_reserved: [gpointer; 4],
1204}
1205
1206impl ::std::fmt::Debug for GstDsdPlaneOffsetMeta {
1207 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1208 f.debug_struct(&format!("GstDsdPlaneOffsetMeta @ {self:p}"))
1209 .field("meta", &self.meta)
1210 .field("num_channels", &self.num_channels)
1211 .field("num_bytes_per_channel", &self.num_bytes_per_channel)
1212 .field("offsets", &self.offsets)
1213 .finish()
1214 }
1215}
1216
1217#[derive(Copy, Clone)]
1218#[repr(C)]
1219pub struct GstStreamVolumeInterface {
1220 pub iface: gobject::GTypeInterface,
1221}
1222
1223impl ::std::fmt::Debug for GstStreamVolumeInterface {
1224 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1225 f.debug_struct(&format!("GstStreamVolumeInterface @ {self:p}"))
1226 .field("iface", &self.iface)
1227 .finish()
1228 }
1229}
1230
1231#[derive(Copy, Clone)]
1233#[repr(C)]
1234pub struct GstAudioAggregator {
1235 pub parent: gst_base::GstAggregator,
1236 pub current_caps: *mut gst::GstCaps,
1237 pub priv_: *mut GstAudioAggregatorPrivate,
1238 pub _gst_reserved: [gpointer; 4],
1239}
1240
1241impl ::std::fmt::Debug for GstAudioAggregator {
1242 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1243 f.debug_struct(&format!("GstAudioAggregator @ {self:p}"))
1244 .field("parent", &self.parent)
1245 .field("current_caps", &self.current_caps)
1246 .finish()
1247 }
1248}
1249
1250#[derive(Copy, Clone)]
1251#[repr(C)]
1252pub struct GstAudioAggregatorConvertPad {
1253 pub parent: GstAudioAggregatorPad,
1254 pub priv_: *mut GstAudioAggregatorConvertPadPrivate,
1255 pub _gst_reserved: [gpointer; 4],
1256}
1257
1258impl ::std::fmt::Debug for GstAudioAggregatorConvertPad {
1259 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1260 f.debug_struct(&format!("GstAudioAggregatorConvertPad @ {self:p}"))
1261 .finish()
1262 }
1263}
1264
1265#[derive(Copy, Clone)]
1266#[repr(C)]
1267pub struct GstAudioAggregatorPad {
1268 pub parent: gst_base::GstAggregatorPad,
1269 pub info: GstAudioInfo,
1270 pub priv_: *mut GstAudioAggregatorPadPrivate,
1271 pub _gst_reserved: [gpointer; 4],
1272}
1273
1274impl ::std::fmt::Debug for GstAudioAggregatorPad {
1275 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1276 f.debug_struct(&format!("GstAudioAggregatorPad @ {self:p}"))
1277 .field("parent", &self.parent)
1278 .field("info", &self.info)
1279 .finish()
1280 }
1281}
1282
1283#[derive(Copy, Clone)]
1284#[repr(C)]
1285pub struct GstAudioBaseSink {
1286 pub element: gst_base::GstBaseSink,
1287 pub ringbuffer: *mut GstAudioRingBuffer,
1288 pub buffer_time: u64,
1289 pub latency_time: u64,
1290 pub next_sample: u64,
1291 pub provided_clock: *mut gst::GstClock,
1292 pub eos_rendering: gboolean,
1293 pub priv_: *mut GstAudioBaseSinkPrivate,
1294 pub _gst_reserved: [gpointer; 4],
1295}
1296
1297impl ::std::fmt::Debug for GstAudioBaseSink {
1298 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1299 f.debug_struct(&format!("GstAudioBaseSink @ {self:p}"))
1300 .field("element", &self.element)
1301 .field("ringbuffer", &self.ringbuffer)
1302 .field("buffer_time", &self.buffer_time)
1303 .field("latency_time", &self.latency_time)
1304 .field("next_sample", &self.next_sample)
1305 .field("provided_clock", &self.provided_clock)
1306 .field("eos_rendering", &self.eos_rendering)
1307 .finish()
1308 }
1309}
1310
1311#[derive(Copy, Clone)]
1312#[repr(C)]
1313pub struct GstAudioBaseSrc {
1314 pub element: gst_base::GstPushSrc,
1315 pub ringbuffer: *mut GstAudioRingBuffer,
1316 pub buffer_time: gst::GstClockTime,
1317 pub latency_time: gst::GstClockTime,
1318 pub next_sample: u64,
1319 pub clock: *mut gst::GstClock,
1320 pub priv_: *mut GstAudioBaseSrcPrivate,
1321 pub _gst_reserved: [gpointer; 4],
1322}
1323
1324impl ::std::fmt::Debug for GstAudioBaseSrc {
1325 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1326 f.debug_struct(&format!("GstAudioBaseSrc @ {self:p}"))
1327 .field("element", &self.element)
1328 .field("ringbuffer", &self.ringbuffer)
1329 .field("buffer_time", &self.buffer_time)
1330 .field("latency_time", &self.latency_time)
1331 .field("next_sample", &self.next_sample)
1332 .field("clock", &self.clock)
1333 .finish()
1334 }
1335}
1336
1337#[derive(Copy, Clone)]
1338#[repr(C)]
1339pub struct GstAudioCdSrc {
1340 pub pushsrc: gst_base::GstPushSrc,
1341 pub tags: *mut gst::GstTagList,
1342 pub priv_: *mut GstAudioCdSrcPrivate,
1343 pub _gst_reserved1: [c_uint; 2],
1344 pub _gst_reserved2: [gpointer; 2],
1345}
1346
1347impl ::std::fmt::Debug for GstAudioCdSrc {
1348 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1349 f.debug_struct(&format!("GstAudioCdSrc @ {self:p}"))
1350 .field("pushsrc", &self.pushsrc)
1351 .field("tags", &self.tags)
1352 .finish()
1353 }
1354}
1355
1356#[derive(Copy, Clone)]
1357#[repr(C)]
1358pub struct GstAudioClock {
1359 pub clock: gst::GstSystemClock,
1360 pub func: GstAudioClockGetTimeFunc,
1361 pub user_data: gpointer,
1362 pub destroy_notify: glib::GDestroyNotify,
1363 pub last_time: gst::GstClockTime,
1364 pub time_offset: gst::GstClockTimeDiff,
1365 pub _gst_reserved: [gpointer; 4],
1366}
1367
1368impl ::std::fmt::Debug for GstAudioClock {
1369 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1370 f.debug_struct(&format!("GstAudioClock @ {self:p}"))
1371 .field("clock", &self.clock)
1372 .field("func", &self.func)
1373 .field("user_data", &self.user_data)
1374 .field("destroy_notify", &self.destroy_notify)
1375 .finish()
1376 }
1377}
1378
1379#[derive(Copy, Clone)]
1380#[repr(C)]
1381pub struct GstAudioDecoder {
1382 pub element: gst::GstElement,
1383 pub sinkpad: *mut gst::GstPad,
1384 pub srcpad: *mut gst::GstPad,
1385 pub stream_lock: glib::GRecMutex,
1386 pub input_segment: gst::GstSegment,
1387 pub output_segment: gst::GstSegment,
1388 pub priv_: *mut GstAudioDecoderPrivate,
1389 pub _gst_reserved: [gpointer; 20],
1390}
1391
1392impl ::std::fmt::Debug for GstAudioDecoder {
1393 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1394 f.debug_struct(&format!("GstAudioDecoder @ {self:p}"))
1395 .field("element", &self.element)
1396 .field("sinkpad", &self.sinkpad)
1397 .field("srcpad", &self.srcpad)
1398 .field("stream_lock", &self.stream_lock)
1399 .field("input_segment", &self.input_segment)
1400 .field("output_segment", &self.output_segment)
1401 .finish()
1402 }
1403}
1404
1405#[derive(Copy, Clone)]
1406#[repr(C)]
1407pub struct GstAudioEncoder {
1408 pub element: gst::GstElement,
1409 pub sinkpad: *mut gst::GstPad,
1410 pub srcpad: *mut gst::GstPad,
1411 pub stream_lock: glib::GRecMutex,
1412 pub input_segment: gst::GstSegment,
1413 pub output_segment: gst::GstSegment,
1414 pub priv_: *mut GstAudioEncoderPrivate,
1415 pub _gst_reserved: [gpointer; 20],
1416}
1417
1418impl ::std::fmt::Debug for GstAudioEncoder {
1419 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1420 f.debug_struct(&format!("GstAudioEncoder @ {self:p}"))
1421 .field("element", &self.element)
1422 .field("sinkpad", &self.sinkpad)
1423 .field("srcpad", &self.srcpad)
1424 .field("stream_lock", &self.stream_lock)
1425 .field("input_segment", &self.input_segment)
1426 .field("output_segment", &self.output_segment)
1427 .finish()
1428 }
1429}
1430
1431#[derive(Copy, Clone)]
1432#[repr(C)]
1433pub struct GstAudioFilter {
1434 pub basetransform: gst_base::GstBaseTransform,
1435 pub info: GstAudioInfo,
1436 pub _gst_reserved: [gpointer; 4],
1437}
1438
1439impl ::std::fmt::Debug for GstAudioFilter {
1440 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1441 f.debug_struct(&format!("GstAudioFilter @ {self:p}"))
1442 .field("basetransform", &self.basetransform)
1443 .field("info", &self.info)
1444 .finish()
1445 }
1446}
1447
1448#[derive(Copy, Clone)]
1449#[repr(C)]
1450pub struct GstAudioRingBuffer {
1451 pub object: gst::GstObject,
1452 pub cond: glib::GCond,
1453 pub open: gboolean,
1454 pub acquired: gboolean,
1455 pub memory: *mut u8,
1456 pub size: size_t,
1457 pub timestamps: *mut gst::GstClockTime,
1458 pub spec: GstAudioRingBufferSpec,
1459 pub samples_per_seg: c_int,
1460 pub empty_seg: *mut u8,
1461 pub state: c_int,
1462 pub segdone: c_int,
1463 pub segbase: c_int,
1464 pub waiting: c_int,
1465 pub callback: GstAudioRingBufferCallback,
1466 pub cb_data: gpointer,
1467 pub need_reorder: gboolean,
1468 pub channel_reorder_map: [c_int; 64],
1469 pub flushing: gboolean,
1470 pub may_start: c_int,
1471 pub active: gboolean,
1472 pub cb_data_notify: glib::GDestroyNotify,
1473 pub priv_: *mut GstAudioRingBufferPrivate,
1474 pub _gst_reserved: [gpointer; 2],
1475}
1476
1477impl ::std::fmt::Debug for GstAudioRingBuffer {
1478 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1479 f.debug_struct(&format!("GstAudioRingBuffer @ {self:p}"))
1480 .field("object", &self.object)
1481 .field("cond", &self.cond)
1482 .field("open", &self.open)
1483 .field("acquired", &self.acquired)
1484 .field("memory", &self.memory)
1485 .field("size", &self.size)
1486 .field("spec", &self.spec)
1487 .field("samples_per_seg", &self.samples_per_seg)
1488 .field("empty_seg", &self.empty_seg)
1489 .field("state", &self.state)
1490 .field("segdone", &self.segdone)
1491 .field("segbase", &self.segbase)
1492 .field("waiting", &self.waiting)
1493 .finish()
1494 }
1495}
1496
1497#[derive(Copy, Clone)]
1498#[repr(C)]
1499pub struct GstAudioSink {
1500 pub element: GstAudioBaseSink,
1501 pub thread: *mut glib::GThread,
1502 pub _gst_reserved: [gpointer; 4],
1503}
1504
1505impl ::std::fmt::Debug for GstAudioSink {
1506 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1507 f.debug_struct(&format!("GstAudioSink @ {self:p}"))
1508 .field("element", &self.element)
1509 .finish()
1510 }
1511}
1512
1513#[derive(Copy, Clone)]
1514#[repr(C)]
1515pub struct GstAudioSrc {
1516 pub element: GstAudioBaseSrc,
1517 pub thread: *mut glib::GThread,
1518 pub _gst_reserved: [gpointer; 4],
1519}
1520
1521impl ::std::fmt::Debug for GstAudioSrc {
1522 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1523 f.debug_struct(&format!("GstAudioSrc @ {self:p}"))
1524 .field("element", &self.element)
1525 .finish()
1526 }
1527}
1528
1529#[repr(C)]
1531#[allow(dead_code)]
1532pub struct GstStreamVolume {
1533 _data: [u8; 0],
1534 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1535}
1536
1537impl ::std::fmt::Debug for GstStreamVolume {
1538 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1539 write!(f, "GstStreamVolume @ {self:p}")
1540 }
1541}
1542
1543extern "C" {
1544
1545 pub fn gst_audio_base_sink_discont_reason_get_type() -> GType;
1549
1550 pub fn gst_audio_base_sink_slave_method_get_type() -> GType;
1554
1555 pub fn gst_audio_base_src_slave_method_get_type() -> GType;
1559
1560 pub fn gst_audio_cd_src_mode_get_type() -> GType;
1564
1565 pub fn gst_audio_channel_position_get_type() -> GType;
1569
1570 pub fn gst_audio_dither_method_get_type() -> GType;
1574
1575 pub fn gst_audio_format_get_type() -> GType;
1579 pub fn gst_audio_format_build_integer(
1580 sign: gboolean,
1581 endianness: c_int,
1582 width: c_int,
1583 depth: c_int,
1584 ) -> GstAudioFormat;
1585 pub fn gst_audio_format_fill_silence(
1586 info: *const GstAudioFormatInfo,
1587 dest: gpointer,
1588 length: size_t,
1589 );
1590 pub fn gst_audio_format_from_string(format: *const c_char) -> GstAudioFormat;
1591 pub fn gst_audio_format_get_info(format: GstAudioFormat) -> *const GstAudioFormatInfo;
1592 pub fn gst_audio_format_to_string(format: GstAudioFormat) -> *const c_char;
1593
1594 pub fn gst_audio_layout_get_type() -> GType;
1598
1599 pub fn gst_audio_noise_shaping_method_get_type() -> GType;
1603
1604 pub fn gst_audio_resampler_filter_interpolation_get_type() -> GType;
1608
1609 pub fn gst_audio_resampler_filter_mode_get_type() -> GType;
1613
1614 pub fn gst_audio_resampler_method_get_type() -> GType;
1618
1619 pub fn gst_audio_ring_buffer_format_type_get_type() -> GType;
1623
1624 pub fn gst_audio_ring_buffer_state_get_type() -> GType;
1628
1629 #[cfg(feature = "v1_24")]
1633 #[cfg_attr(docsrs, doc(cfg(feature = "v1_24")))]
1634 pub fn gst_dsd_format_get_type() -> GType;
1635 #[cfg(feature = "v1_24")]
1636 #[cfg_attr(docsrs, doc(cfg(feature = "v1_24")))]
1637 pub fn gst_dsd_format_from_string(str: *const c_char) -> GstDsdFormat;
1638 #[cfg(feature = "v1_24")]
1639 #[cfg_attr(docsrs, doc(cfg(feature = "v1_24")))]
1640 pub fn gst_dsd_format_get_width(format: GstDsdFormat) -> c_uint;
1641 #[cfg(feature = "v1_24")]
1642 #[cfg_attr(docsrs, doc(cfg(feature = "v1_24")))]
1643 pub fn gst_dsd_format_to_string(format: GstDsdFormat) -> *const c_char;
1644
1645 pub fn gst_audio_channel_mixer_flags_get_type() -> GType;
1649
1650 pub fn gst_audio_converter_flags_get_type() -> GType;
1654
1655 pub fn gst_audio_flags_get_type() -> GType;
1659
1660 pub fn gst_audio_format_flags_get_type() -> GType;
1664
1665 pub fn gst_audio_pack_flags_get_type() -> GType;
1669
1670 pub fn gst_audio_quantize_flags_get_type() -> GType;
1674
1675 pub fn gst_audio_resampler_flags_get_type() -> GType;
1679
1680 #[cfg(feature = "v1_16")]
1684 #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
1685 pub fn gst_audio_buffer_unmap(buffer: *mut GstAudioBuffer);
1686 pub fn gst_audio_buffer_clip(
1687 buffer: *mut gst::GstBuffer,
1688 segment: *const gst::GstSegment,
1689 rate: c_int,
1690 bpf: c_int,
1691 ) -> *mut gst::GstBuffer;
1692 #[cfg(feature = "v1_16")]
1693 #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
1694 pub fn gst_audio_buffer_map(
1695 buffer: *mut GstAudioBuffer,
1696 info: *const GstAudioInfo,
1697 gstbuffer: *mut gst::GstBuffer,
1698 flags: gst::GstMapFlags,
1699 ) -> gboolean;
1700 pub fn gst_audio_buffer_reorder_channels(
1701 buffer: *mut gst::GstBuffer,
1702 format: GstAudioFormat,
1703 channels: c_int,
1704 from: *const GstAudioChannelPosition,
1705 to: *const GstAudioChannelPosition,
1706 ) -> gboolean;
1707 #[cfg(feature = "v1_16")]
1708 #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
1709 pub fn gst_audio_buffer_truncate(
1710 buffer: *mut gst::GstBuffer,
1711 bpf: c_int,
1712 trim: size_t,
1713 samples: size_t,
1714 ) -> *mut gst::GstBuffer;
1715
1716 pub fn gst_audio_channel_mixer_free(mix: *mut GstAudioChannelMixer);
1720 pub fn gst_audio_channel_mixer_is_passthrough(mix: *mut GstAudioChannelMixer) -> gboolean;
1721 pub fn gst_audio_channel_mixer_samples(
1722 mix: *mut GstAudioChannelMixer,
1723 in_: *const gpointer,
1724 out: *mut gpointer,
1725 samples: c_int,
1726 );
1727 pub fn gst_audio_channel_mixer_new(
1728 flags: GstAudioChannelMixerFlags,
1729 format: GstAudioFormat,
1730 in_channels: c_int,
1731 in_position: *mut GstAudioChannelPosition,
1732 out_channels: c_int,
1733 out_position: *mut GstAudioChannelPosition,
1734 ) -> *mut GstAudioChannelMixer;
1735 pub fn gst_audio_channel_mixer_new_with_matrix(
1736 flags: GstAudioChannelMixerFlags,
1737 format: GstAudioFormat,
1738 in_channels: c_int,
1739 out_channels: c_int,
1740 matrix: *mut *mut c_float,
1741 ) -> *mut GstAudioChannelMixer;
1742
1743 pub fn gst_audio_clipping_meta_get_info() -> *const gst::GstMetaInfo;
1747
1748 pub fn gst_audio_converter_get_type() -> GType;
1752 pub fn gst_audio_converter_new(
1753 flags: GstAudioConverterFlags,
1754 in_info: *mut GstAudioInfo,
1755 out_info: *mut GstAudioInfo,
1756 config: *mut gst::GstStructure,
1757 ) -> *mut GstAudioConverter;
1758 pub fn gst_audio_converter_convert(
1759 convert: *mut GstAudioConverter,
1760 flags: GstAudioConverterFlags,
1761 in_: gpointer,
1762 in_size: size_t,
1763 out: *mut u8,
1764 out_size: *mut size_t,
1765 ) -> gboolean;
1766 pub fn gst_audio_converter_free(convert: *mut GstAudioConverter);
1767 pub fn gst_audio_converter_get_config(
1768 convert: *mut GstAudioConverter,
1769 in_rate: *mut c_int,
1770 out_rate: *mut c_int,
1771 ) -> *const gst::GstStructure;
1772 pub fn gst_audio_converter_get_in_frames(
1773 convert: *mut GstAudioConverter,
1774 out_frames: size_t,
1775 ) -> size_t;
1776 pub fn gst_audio_converter_get_max_latency(convert: *mut GstAudioConverter) -> size_t;
1777 pub fn gst_audio_converter_get_out_frames(
1778 convert: *mut GstAudioConverter,
1779 in_frames: size_t,
1780 ) -> size_t;
1781 #[cfg(feature = "v1_16")]
1782 #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
1783 pub fn gst_audio_converter_is_passthrough(convert: *mut GstAudioConverter) -> gboolean;
1784 pub fn gst_audio_converter_reset(convert: *mut GstAudioConverter);
1785 pub fn gst_audio_converter_samples(
1786 convert: *mut GstAudioConverter,
1787 flags: GstAudioConverterFlags,
1788 in_: *mut gpointer,
1789 in_frames: size_t,
1790 out: *mut gpointer,
1791 out_frames: size_t,
1792 ) -> gboolean;
1793 pub fn gst_audio_converter_supports_inplace(convert: *mut GstAudioConverter) -> gboolean;
1794 pub fn gst_audio_converter_update_config(
1795 convert: *mut GstAudioConverter,
1796 in_rate: c_int,
1797 out_rate: c_int,
1798 config: *mut gst::GstStructure,
1799 ) -> gboolean;
1800
1801 pub fn gst_audio_downmix_meta_get_info() -> *const gst::GstMetaInfo;
1805
1806 pub fn gst_audio_filter_class_add_pad_templates(
1810 klass: *mut GstAudioFilterClass,
1811 allowed_caps: *mut gst::GstCaps,
1812 );
1813
1814 #[cfg(feature = "v1_20")]
1818 #[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
1819 pub fn gst_audio_format_info_fill_silence(
1820 info: *const GstAudioFormatInfo,
1821 dest: gpointer,
1822 length: size_t,
1823 );
1824
1825 pub fn gst_audio_info_get_type() -> GType;
1829 pub fn gst_audio_info_new() -> *mut GstAudioInfo;
1830 #[cfg(feature = "v1_20")]
1831 #[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
1832 pub fn gst_audio_info_new_from_caps(caps: *const gst::GstCaps) -> *mut GstAudioInfo;
1833 pub fn gst_audio_info_convert(
1834 info: *const GstAudioInfo,
1835 src_fmt: gst::GstFormat,
1836 src_val: i64,
1837 dest_fmt: gst::GstFormat,
1838 dest_val: *mut i64,
1839 ) -> gboolean;
1840 pub fn gst_audio_info_copy(info: *const GstAudioInfo) -> *mut GstAudioInfo;
1841 pub fn gst_audio_info_free(info: *mut GstAudioInfo);
1842 pub fn gst_audio_info_is_equal(
1843 info: *const GstAudioInfo,
1844 other: *const GstAudioInfo,
1845 ) -> gboolean;
1846 pub fn gst_audio_info_set_format(
1847 info: *mut GstAudioInfo,
1848 format: GstAudioFormat,
1849 rate: c_int,
1850 channels: c_int,
1851 position: *const [GstAudioChannelPosition; 64],
1852 );
1853 pub fn gst_audio_info_to_caps(info: *const GstAudioInfo) -> *mut gst::GstCaps;
1854 pub fn gst_audio_info_from_caps(info: *mut GstAudioInfo, caps: *const gst::GstCaps)
1855 -> gboolean;
1856 pub fn gst_audio_info_init(info: *mut GstAudioInfo);
1857
1858 #[cfg(feature = "v1_20")]
1862 #[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
1863 pub fn gst_audio_level_meta_get_info() -> *const gst::GstMetaInfo;
1864
1865 #[cfg(feature = "v1_16")]
1869 #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
1870 pub fn gst_audio_meta_get_info() -> *const gst::GstMetaInfo;
1871
1872 pub fn gst_audio_quantize_free(quant: *mut GstAudioQuantize);
1876 pub fn gst_audio_quantize_reset(quant: *mut GstAudioQuantize);
1877 pub fn gst_audio_quantize_samples(
1878 quant: *mut GstAudioQuantize,
1879 in_: *const gpointer,
1880 out: *mut gpointer,
1881 samples: c_uint,
1882 );
1883 pub fn gst_audio_quantize_new(
1884 dither: GstAudioDitherMethod,
1885 ns: GstAudioNoiseShapingMethod,
1886 flags: GstAudioQuantizeFlags,
1887 format: GstAudioFormat,
1888 channels: c_uint,
1889 quantizer: c_uint,
1890 ) -> *mut GstAudioQuantize;
1891
1892 pub fn gst_audio_resampler_free(resampler: *mut GstAudioResampler);
1896 pub fn gst_audio_resampler_get_in_frames(
1897 resampler: *mut GstAudioResampler,
1898 out_frames: size_t,
1899 ) -> size_t;
1900 pub fn gst_audio_resampler_get_max_latency(resampler: *mut GstAudioResampler) -> size_t;
1901 pub fn gst_audio_resampler_get_out_frames(
1902 resampler: *mut GstAudioResampler,
1903 in_frames: size_t,
1904 ) -> size_t;
1905 pub fn gst_audio_resampler_resample(
1906 resampler: *mut GstAudioResampler,
1907 in_: *mut gpointer,
1908 in_frames: size_t,
1909 out: *mut gpointer,
1910 out_frames: size_t,
1911 );
1912 pub fn gst_audio_resampler_reset(resampler: *mut GstAudioResampler);
1913 pub fn gst_audio_resampler_update(
1914 resampler: *mut GstAudioResampler,
1915 in_rate: c_int,
1916 out_rate: c_int,
1917 options: *mut gst::GstStructure,
1918 ) -> gboolean;
1919 pub fn gst_audio_resampler_new(
1920 method: GstAudioResamplerMethod,
1921 flags: GstAudioResamplerFlags,
1922 format: GstAudioFormat,
1923 channels: c_int,
1924 in_rate: c_int,
1925 out_rate: c_int,
1926 options: *mut gst::GstStructure,
1927 ) -> *mut GstAudioResampler;
1928 pub fn gst_audio_resampler_options_set_quality(
1929 method: GstAudioResamplerMethod,
1930 quality: c_uint,
1931 in_rate: c_int,
1932 out_rate: c_int,
1933 options: *mut gst::GstStructure,
1934 );
1935
1936 pub fn gst_audio_stream_align_get_type() -> GType;
1940 pub fn gst_audio_stream_align_new(
1941 rate: c_int,
1942 alignment_threshold: gst::GstClockTime,
1943 discont_wait: gst::GstClockTime,
1944 ) -> *mut GstAudioStreamAlign;
1945 pub fn gst_audio_stream_align_copy(
1946 align: *const GstAudioStreamAlign,
1947 ) -> *mut GstAudioStreamAlign;
1948 pub fn gst_audio_stream_align_free(align: *mut GstAudioStreamAlign);
1949 pub fn gst_audio_stream_align_get_alignment_threshold(
1950 align: *const GstAudioStreamAlign,
1951 ) -> gst::GstClockTime;
1952 pub fn gst_audio_stream_align_get_discont_wait(
1953 align: *const GstAudioStreamAlign,
1954 ) -> gst::GstClockTime;
1955 pub fn gst_audio_stream_align_get_rate(align: *const GstAudioStreamAlign) -> c_int;
1956 pub fn gst_audio_stream_align_get_samples_since_discont(
1957 align: *const GstAudioStreamAlign,
1958 ) -> u64;
1959 pub fn gst_audio_stream_align_get_timestamp_at_discont(
1960 align: *const GstAudioStreamAlign,
1961 ) -> gst::GstClockTime;
1962 pub fn gst_audio_stream_align_mark_discont(align: *mut GstAudioStreamAlign);
1963 pub fn gst_audio_stream_align_process(
1964 align: *mut GstAudioStreamAlign,
1965 discont: gboolean,
1966 timestamp: gst::GstClockTime,
1967 n_samples: c_uint,
1968 out_timestamp: *mut gst::GstClockTime,
1969 out_duration: *mut gst::GstClockTime,
1970 out_sample_position: *mut u64,
1971 ) -> gboolean;
1972 pub fn gst_audio_stream_align_set_alignment_threshold(
1973 align: *mut GstAudioStreamAlign,
1974 alignment_threshold: gst::GstClockTime,
1975 );
1976 pub fn gst_audio_stream_align_set_discont_wait(
1977 align: *mut GstAudioStreamAlign,
1978 discont_wait: gst::GstClockTime,
1979 );
1980 pub fn gst_audio_stream_align_set_rate(align: *mut GstAudioStreamAlign, rate: c_int);
1981
1982 #[cfg(feature = "v1_24")]
1986 #[cfg_attr(docsrs, doc(cfg(feature = "v1_24")))]
1987 pub fn gst_dsd_info_get_type() -> GType;
1988 #[cfg(feature = "v1_24")]
1989 #[cfg_attr(docsrs, doc(cfg(feature = "v1_24")))]
1990 pub fn gst_dsd_info_new() -> *mut GstDsdInfo;
1991 #[cfg(feature = "v1_24")]
1992 #[cfg_attr(docsrs, doc(cfg(feature = "v1_24")))]
1993 pub fn gst_dsd_info_new_from_caps(caps: *const gst::GstCaps) -> *mut GstDsdInfo;
1994 #[cfg(feature = "v1_24")]
1995 #[cfg_attr(docsrs, doc(cfg(feature = "v1_24")))]
1996 pub fn gst_dsd_info_copy(info: *const GstDsdInfo) -> *mut GstDsdInfo;
1997 #[cfg(feature = "v1_24")]
1998 #[cfg_attr(docsrs, doc(cfg(feature = "v1_24")))]
1999 pub fn gst_dsd_info_free(info: *mut GstDsdInfo);
2000 #[cfg(feature = "v1_24")]
2001 #[cfg_attr(docsrs, doc(cfg(feature = "v1_24")))]
2002 pub fn gst_dsd_info_is_equal(info: *const GstDsdInfo, other: *const GstDsdInfo) -> gboolean;
2003 #[cfg(feature = "v1_24")]
2004 #[cfg_attr(docsrs, doc(cfg(feature = "v1_24")))]
2005 pub fn gst_dsd_info_set_format(
2006 info: *mut GstDsdInfo,
2007 format: GstDsdFormat,
2008 rate: c_int,
2009 channels: c_int,
2010 positions: *const [GstAudioChannelPosition; 64],
2011 );
2012 #[cfg(feature = "v1_24")]
2013 #[cfg_attr(docsrs, doc(cfg(feature = "v1_24")))]
2014 pub fn gst_dsd_info_to_caps(info: *const GstDsdInfo) -> *mut gst::GstCaps;
2015 #[cfg(feature = "v1_24")]
2016 #[cfg_attr(docsrs, doc(cfg(feature = "v1_24")))]
2017 pub fn gst_dsd_info_from_caps(info: *mut GstDsdInfo, caps: *const gst::GstCaps) -> gboolean;
2018 #[cfg(feature = "v1_24")]
2019 #[cfg_attr(docsrs, doc(cfg(feature = "v1_24")))]
2020 pub fn gst_dsd_info_init(info: *mut GstDsdInfo);
2021
2022 #[cfg(feature = "v1_24")]
2026 #[cfg_attr(docsrs, doc(cfg(feature = "v1_24")))]
2027 pub fn gst_dsd_plane_offset_meta_get_info() -> *const gst::GstMetaInfo;
2028
2029 pub fn gst_audio_aggregator_get_type() -> GType;
2033 pub fn gst_audio_aggregator_set_sink_caps(
2034 aagg: *mut GstAudioAggregator,
2035 pad: *mut GstAudioAggregatorPad,
2036 caps: *mut gst::GstCaps,
2037 );
2038
2039 pub fn gst_audio_aggregator_convert_pad_get_type() -> GType;
2043
2044 pub fn gst_audio_aggregator_pad_get_type() -> GType;
2048
2049 pub fn gst_audio_base_sink_get_type() -> GType;
2053 pub fn gst_audio_base_sink_create_ringbuffer(
2054 sink: *mut GstAudioBaseSink,
2055 ) -> *mut GstAudioRingBuffer;
2056 pub fn gst_audio_base_sink_get_alignment_threshold(
2057 sink: *mut GstAudioBaseSink,
2058 ) -> gst::GstClockTime;
2059 pub fn gst_audio_base_sink_get_discont_wait(sink: *mut GstAudioBaseSink) -> gst::GstClockTime;
2060 pub fn gst_audio_base_sink_get_drift_tolerance(sink: *mut GstAudioBaseSink) -> i64;
2061 pub fn gst_audio_base_sink_get_provide_clock(sink: *mut GstAudioBaseSink) -> gboolean;
2062 pub fn gst_audio_base_sink_get_slave_method(
2063 sink: *mut GstAudioBaseSink,
2064 ) -> GstAudioBaseSinkSlaveMethod;
2065 pub fn gst_audio_base_sink_report_device_failure(sink: *mut GstAudioBaseSink);
2066 pub fn gst_audio_base_sink_set_alignment_threshold(
2067 sink: *mut GstAudioBaseSink,
2068 alignment_threshold: gst::GstClockTime,
2069 );
2070 pub fn gst_audio_base_sink_set_custom_slaving_callback(
2071 sink: *mut GstAudioBaseSink,
2072 callback: GstAudioBaseSinkCustomSlavingCallback,
2073 user_data: gpointer,
2074 notify: glib::GDestroyNotify,
2075 );
2076 pub fn gst_audio_base_sink_set_discont_wait(
2077 sink: *mut GstAudioBaseSink,
2078 discont_wait: gst::GstClockTime,
2079 );
2080 pub fn gst_audio_base_sink_set_drift_tolerance(
2081 sink: *mut GstAudioBaseSink,
2082 drift_tolerance: i64,
2083 );
2084 pub fn gst_audio_base_sink_set_provide_clock(sink: *mut GstAudioBaseSink, provide: gboolean);
2085 pub fn gst_audio_base_sink_set_slave_method(
2086 sink: *mut GstAudioBaseSink,
2087 method: GstAudioBaseSinkSlaveMethod,
2088 );
2089
2090 pub fn gst_audio_base_src_get_type() -> GType;
2094 pub fn gst_audio_base_src_create_ringbuffer(
2095 src: *mut GstAudioBaseSrc,
2096 ) -> *mut GstAudioRingBuffer;
2097 pub fn gst_audio_base_src_get_provide_clock(src: *mut GstAudioBaseSrc) -> gboolean;
2098 pub fn gst_audio_base_src_get_slave_method(
2099 src: *mut GstAudioBaseSrc,
2100 ) -> GstAudioBaseSrcSlaveMethod;
2101 pub fn gst_audio_base_src_set_provide_clock(src: *mut GstAudioBaseSrc, provide: gboolean);
2102 pub fn gst_audio_base_src_set_slave_method(
2103 src: *mut GstAudioBaseSrc,
2104 method: GstAudioBaseSrcSlaveMethod,
2105 );
2106
2107 pub fn gst_audio_cd_src_get_type() -> GType;
2111 pub fn gst_audio_cd_src_add_track(
2112 src: *mut GstAudioCdSrc,
2113 track: *mut GstAudioCdSrcTrack,
2114 ) -> gboolean;
2115
2116 pub fn gst_audio_clock_get_type() -> GType;
2120 pub fn gst_audio_clock_new(
2121 name: *const c_char,
2122 func: GstAudioClockGetTimeFunc,
2123 user_data: gpointer,
2124 destroy_notify: glib::GDestroyNotify,
2125 ) -> *mut gst::GstClock;
2126 pub fn gst_audio_clock_adjust(
2127 clock: *mut GstAudioClock,
2128 time: gst::GstClockTime,
2129 ) -> gst::GstClockTime;
2130 pub fn gst_audio_clock_get_time(clock: *mut GstAudioClock) -> gst::GstClockTime;
2131 pub fn gst_audio_clock_invalidate(clock: *mut GstAudioClock);
2132 pub fn gst_audio_clock_reset(clock: *mut GstAudioClock, time: gst::GstClockTime);
2133
2134 pub fn gst_audio_decoder_get_type() -> GType;
2138 pub fn gst_audio_decoder_allocate_output_buffer(
2139 dec: *mut GstAudioDecoder,
2140 size: size_t,
2141 ) -> *mut gst::GstBuffer;
2142 pub fn gst_audio_decoder_finish_frame(
2143 dec: *mut GstAudioDecoder,
2144 buf: *mut gst::GstBuffer,
2145 frames: c_int,
2146 ) -> gst::GstFlowReturn;
2147 #[cfg(feature = "v1_16")]
2148 #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
2149 pub fn gst_audio_decoder_finish_subframe(
2150 dec: *mut GstAudioDecoder,
2151 buf: *mut gst::GstBuffer,
2152 ) -> gst::GstFlowReturn;
2153 pub fn gst_audio_decoder_get_allocator(
2154 dec: *mut GstAudioDecoder,
2155 allocator: *mut *mut gst::GstAllocator,
2156 params: *mut gst::GstAllocationParams,
2157 );
2158 pub fn gst_audio_decoder_get_audio_info(dec: *mut GstAudioDecoder) -> *mut GstAudioInfo;
2159 pub fn gst_audio_decoder_get_delay(dec: *mut GstAudioDecoder) -> c_int;
2160 pub fn gst_audio_decoder_get_drainable(dec: *mut GstAudioDecoder) -> gboolean;
2161 pub fn gst_audio_decoder_get_estimate_rate(dec: *mut GstAudioDecoder) -> c_int;
2162 pub fn gst_audio_decoder_get_latency(
2163 dec: *mut GstAudioDecoder,
2164 min: *mut gst::GstClockTime,
2165 max: *mut gst::GstClockTime,
2166 );
2167 pub fn gst_audio_decoder_get_max_errors(dec: *mut GstAudioDecoder) -> c_int;
2168 pub fn gst_audio_decoder_get_min_latency(dec: *mut GstAudioDecoder) -> gst::GstClockTime;
2169 pub fn gst_audio_decoder_get_needs_format(dec: *mut GstAudioDecoder) -> gboolean;
2170 pub fn gst_audio_decoder_get_parse_state(
2171 dec: *mut GstAudioDecoder,
2172 sync: *mut gboolean,
2173 eos: *mut gboolean,
2174 );
2175 pub fn gst_audio_decoder_get_plc(dec: *mut GstAudioDecoder) -> gboolean;
2176 pub fn gst_audio_decoder_get_plc_aware(dec: *mut GstAudioDecoder) -> c_int;
2177 pub fn gst_audio_decoder_get_tolerance(dec: *mut GstAudioDecoder) -> gst::GstClockTime;
2178 pub fn gst_audio_decoder_merge_tags(
2179 dec: *mut GstAudioDecoder,
2180 tags: *const gst::GstTagList,
2181 mode: gst::GstTagMergeMode,
2182 );
2183 pub fn gst_audio_decoder_negotiate(dec: *mut GstAudioDecoder) -> gboolean;
2184 pub fn gst_audio_decoder_proxy_getcaps(
2185 decoder: *mut GstAudioDecoder,
2186 caps: *mut gst::GstCaps,
2187 filter: *mut gst::GstCaps,
2188 ) -> *mut gst::GstCaps;
2189 pub fn gst_audio_decoder_set_allocation_caps(
2190 dec: *mut GstAudioDecoder,
2191 allocation_caps: *mut gst::GstCaps,
2192 );
2193 pub fn gst_audio_decoder_set_drainable(dec: *mut GstAudioDecoder, enabled: gboolean);
2194 pub fn gst_audio_decoder_set_estimate_rate(dec: *mut GstAudioDecoder, enabled: gboolean);
2195 pub fn gst_audio_decoder_set_latency(
2196 dec: *mut GstAudioDecoder,
2197 min: gst::GstClockTime,
2198 max: gst::GstClockTime,
2199 );
2200 pub fn gst_audio_decoder_set_max_errors(dec: *mut GstAudioDecoder, num: c_int);
2201 pub fn gst_audio_decoder_set_min_latency(dec: *mut GstAudioDecoder, num: gst::GstClockTime);
2202 pub fn gst_audio_decoder_set_needs_format(dec: *mut GstAudioDecoder, enabled: gboolean);
2203 #[cfg(feature = "v1_16")]
2204 #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
2205 pub fn gst_audio_decoder_set_output_caps(
2206 dec: *mut GstAudioDecoder,
2207 caps: *mut gst::GstCaps,
2208 ) -> gboolean;
2209 pub fn gst_audio_decoder_set_output_format(
2210 dec: *mut GstAudioDecoder,
2211 info: *const GstAudioInfo,
2212 ) -> gboolean;
2213 pub fn gst_audio_decoder_set_plc(dec: *mut GstAudioDecoder, enabled: gboolean);
2214 pub fn gst_audio_decoder_set_plc_aware(dec: *mut GstAudioDecoder, plc: gboolean);
2215 pub fn gst_audio_decoder_set_tolerance(dec: *mut GstAudioDecoder, tolerance: gst::GstClockTime);
2216 pub fn gst_audio_decoder_set_use_default_pad_acceptcaps(
2217 decoder: *mut GstAudioDecoder,
2218 use_: gboolean,
2219 );
2220
2221 pub fn gst_audio_encoder_get_type() -> GType;
2225 pub fn gst_audio_encoder_allocate_output_buffer(
2226 enc: *mut GstAudioEncoder,
2227 size: size_t,
2228 ) -> *mut gst::GstBuffer;
2229 pub fn gst_audio_encoder_finish_frame(
2230 enc: *mut GstAudioEncoder,
2231 buffer: *mut gst::GstBuffer,
2232 samples: c_int,
2233 ) -> gst::GstFlowReturn;
2234 pub fn gst_audio_encoder_get_allocator(
2235 enc: *mut GstAudioEncoder,
2236 allocator: *mut *mut gst::GstAllocator,
2237 params: *mut gst::GstAllocationParams,
2238 );
2239 pub fn gst_audio_encoder_get_audio_info(enc: *mut GstAudioEncoder) -> *mut GstAudioInfo;
2240 pub fn gst_audio_encoder_get_drainable(enc: *mut GstAudioEncoder) -> gboolean;
2241 pub fn gst_audio_encoder_get_frame_max(enc: *mut GstAudioEncoder) -> c_int;
2242 pub fn gst_audio_encoder_get_frame_samples_max(enc: *mut GstAudioEncoder) -> c_int;
2243 pub fn gst_audio_encoder_get_frame_samples_min(enc: *mut GstAudioEncoder) -> c_int;
2244 pub fn gst_audio_encoder_get_hard_min(enc: *mut GstAudioEncoder) -> gboolean;
2245 pub fn gst_audio_encoder_get_hard_resync(enc: *mut GstAudioEncoder) -> gboolean;
2246 pub fn gst_audio_encoder_get_latency(
2247 enc: *mut GstAudioEncoder,
2248 min: *mut gst::GstClockTime,
2249 max: *mut gst::GstClockTime,
2250 );
2251 pub fn gst_audio_encoder_get_lookahead(enc: *mut GstAudioEncoder) -> c_int;
2252 pub fn gst_audio_encoder_get_mark_granule(enc: *mut GstAudioEncoder) -> gboolean;
2253 pub fn gst_audio_encoder_get_perfect_timestamp(enc: *mut GstAudioEncoder) -> gboolean;
2254 pub fn gst_audio_encoder_get_tolerance(enc: *mut GstAudioEncoder) -> gst::GstClockTime;
2255 pub fn gst_audio_encoder_merge_tags(
2256 enc: *mut GstAudioEncoder,
2257 tags: *const gst::GstTagList,
2258 mode: gst::GstTagMergeMode,
2259 );
2260 pub fn gst_audio_encoder_negotiate(enc: *mut GstAudioEncoder) -> gboolean;
2261 pub fn gst_audio_encoder_proxy_getcaps(
2262 enc: *mut GstAudioEncoder,
2263 caps: *mut gst::GstCaps,
2264 filter: *mut gst::GstCaps,
2265 ) -> *mut gst::GstCaps;
2266 pub fn gst_audio_encoder_set_allocation_caps(
2267 enc: *mut GstAudioEncoder,
2268 allocation_caps: *mut gst::GstCaps,
2269 );
2270 pub fn gst_audio_encoder_set_drainable(enc: *mut GstAudioEncoder, enabled: gboolean);
2271 pub fn gst_audio_encoder_set_frame_max(enc: *mut GstAudioEncoder, num: c_int);
2272 pub fn gst_audio_encoder_set_frame_samples_max(enc: *mut GstAudioEncoder, num: c_int);
2273 pub fn gst_audio_encoder_set_frame_samples_min(enc: *mut GstAudioEncoder, num: c_int);
2274 pub fn gst_audio_encoder_set_hard_min(enc: *mut GstAudioEncoder, enabled: gboolean);
2275 pub fn gst_audio_encoder_set_hard_resync(enc: *mut GstAudioEncoder, enabled: gboolean);
2276 pub fn gst_audio_encoder_set_headers(enc: *mut GstAudioEncoder, headers: *mut glib::GList);
2277 pub fn gst_audio_encoder_set_latency(
2278 enc: *mut GstAudioEncoder,
2279 min: gst::GstClockTime,
2280 max: gst::GstClockTime,
2281 );
2282 pub fn gst_audio_encoder_set_lookahead(enc: *mut GstAudioEncoder, num: c_int);
2283 pub fn gst_audio_encoder_set_mark_granule(enc: *mut GstAudioEncoder, enabled: gboolean);
2284 pub fn gst_audio_encoder_set_output_format(
2285 enc: *mut GstAudioEncoder,
2286 caps: *mut gst::GstCaps,
2287 ) -> gboolean;
2288 pub fn gst_audio_encoder_set_perfect_timestamp(enc: *mut GstAudioEncoder, enabled: gboolean);
2289 pub fn gst_audio_encoder_set_tolerance(enc: *mut GstAudioEncoder, tolerance: gst::GstClockTime);
2290
2291 pub fn gst_audio_filter_get_type() -> GType;
2295
2296 pub fn gst_audio_ring_buffer_get_type() -> GType;
2300 pub fn gst_audio_ring_buffer_debug_spec_buff(spec: *mut GstAudioRingBufferSpec);
2301 pub fn gst_audio_ring_buffer_debug_spec_caps(spec: *mut GstAudioRingBufferSpec);
2302 pub fn gst_audio_ring_buffer_parse_caps(
2303 spec: *mut GstAudioRingBufferSpec,
2304 caps: *mut gst::GstCaps,
2305 ) -> gboolean;
2306 pub fn gst_audio_ring_buffer_acquire(
2307 buf: *mut GstAudioRingBuffer,
2308 spec: *mut GstAudioRingBufferSpec,
2309 ) -> gboolean;
2310 pub fn gst_audio_ring_buffer_activate(
2311 buf: *mut GstAudioRingBuffer,
2312 active: gboolean,
2313 ) -> gboolean;
2314 pub fn gst_audio_ring_buffer_advance(buf: *mut GstAudioRingBuffer, advance: c_uint);
2315 pub fn gst_audio_ring_buffer_clear(buf: *mut GstAudioRingBuffer, segment: c_int);
2316 pub fn gst_audio_ring_buffer_clear_all(buf: *mut GstAudioRingBuffer);
2317 pub fn gst_audio_ring_buffer_close_device(buf: *mut GstAudioRingBuffer) -> gboolean;
2318 pub fn gst_audio_ring_buffer_commit(
2319 buf: *mut GstAudioRingBuffer,
2320 sample: *mut u64,
2321 data: *mut u8,
2322 in_samples: c_int,
2323 out_samples: c_int,
2324 accum: *mut c_int,
2325 ) -> c_uint;
2326 pub fn gst_audio_ring_buffer_convert(
2327 buf: *mut GstAudioRingBuffer,
2328 src_fmt: gst::GstFormat,
2329 src_val: i64,
2330 dest_fmt: gst::GstFormat,
2331 dest_val: *mut i64,
2332 ) -> gboolean;
2333 pub fn gst_audio_ring_buffer_delay(buf: *mut GstAudioRingBuffer) -> c_uint;
2334 pub fn gst_audio_ring_buffer_device_is_open(buf: *mut GstAudioRingBuffer) -> gboolean;
2335 #[cfg(feature = "v1_26")]
2336 #[cfg_attr(docsrs, doc(cfg(feature = "v1_26")))]
2337 pub fn gst_audio_ring_buffer_get_segbase(buf: *mut GstAudioRingBuffer) -> u64;
2338 #[cfg(feature = "v1_26")]
2339 #[cfg_attr(docsrs, doc(cfg(feature = "v1_26")))]
2340 pub fn gst_audio_ring_buffer_get_segdone(buf: *mut GstAudioRingBuffer) -> u64;
2341 pub fn gst_audio_ring_buffer_is_acquired(buf: *mut GstAudioRingBuffer) -> gboolean;
2342 pub fn gst_audio_ring_buffer_is_active(buf: *mut GstAudioRingBuffer) -> gboolean;
2343 pub fn gst_audio_ring_buffer_is_flushing(buf: *mut GstAudioRingBuffer) -> gboolean;
2344 pub fn gst_audio_ring_buffer_may_start(buf: *mut GstAudioRingBuffer, allowed: gboolean);
2345 pub fn gst_audio_ring_buffer_open_device(buf: *mut GstAudioRingBuffer) -> gboolean;
2346 pub fn gst_audio_ring_buffer_pause(buf: *mut GstAudioRingBuffer) -> gboolean;
2347 pub fn gst_audio_ring_buffer_prepare_read(
2348 buf: *mut GstAudioRingBuffer,
2349 segment: *mut c_int,
2350 readptr: *mut *mut u8,
2351 len: *mut c_int,
2352 ) -> gboolean;
2353 pub fn gst_audio_ring_buffer_read(
2354 buf: *mut GstAudioRingBuffer,
2355 sample: u64,
2356 data: *mut u8,
2357 len: c_uint,
2358 timestamp: *mut gst::GstClockTime,
2359 ) -> c_uint;
2360 pub fn gst_audio_ring_buffer_release(buf: *mut GstAudioRingBuffer) -> gboolean;
2361 pub fn gst_audio_ring_buffer_samples_done(buf: *mut GstAudioRingBuffer) -> u64;
2362 pub fn gst_audio_ring_buffer_set_callback(
2363 buf: *mut GstAudioRingBuffer,
2364 cb: GstAudioRingBufferCallback,
2365 user_data: gpointer,
2366 );
2367 pub fn gst_audio_ring_buffer_set_callback_full(
2368 buf: *mut GstAudioRingBuffer,
2369 cb: GstAudioRingBufferCallback,
2370 user_data: gpointer,
2371 notify: glib::GDestroyNotify,
2372 );
2373 pub fn gst_audio_ring_buffer_set_channel_positions(
2374 buf: *mut GstAudioRingBuffer,
2375 position: *const GstAudioChannelPosition,
2376 );
2377 #[cfg(feature = "v1_24")]
2378 #[cfg_attr(docsrs, doc(cfg(feature = "v1_24")))]
2379 pub fn gst_audio_ring_buffer_set_errored(buf: *mut GstAudioRingBuffer);
2380 pub fn gst_audio_ring_buffer_set_flushing(buf: *mut GstAudioRingBuffer, flushing: gboolean);
2381 pub fn gst_audio_ring_buffer_set_sample(buf: *mut GstAudioRingBuffer, sample: u64);
2382 #[cfg(feature = "v1_26")]
2383 #[cfg_attr(docsrs, doc(cfg(feature = "v1_26")))]
2384 pub fn gst_audio_ring_buffer_set_segdone(buf: *mut GstAudioRingBuffer, segdone: u64);
2385 pub fn gst_audio_ring_buffer_set_timestamp(
2386 buf: *mut GstAudioRingBuffer,
2387 readseg: c_int,
2388 timestamp: gst::GstClockTime,
2389 );
2390 pub fn gst_audio_ring_buffer_start(buf: *mut GstAudioRingBuffer) -> gboolean;
2391 pub fn gst_audio_ring_buffer_stop(buf: *mut GstAudioRingBuffer) -> gboolean;
2392
2393 pub fn gst_audio_sink_get_type() -> GType;
2397
2398 pub fn gst_audio_src_get_type() -> GType;
2402
2403 pub fn gst_stream_volume_get_type() -> GType;
2407 pub fn gst_stream_volume_convert_volume(
2408 from: GstStreamVolumeFormat,
2409 to: GstStreamVolumeFormat,
2410 val: c_double,
2411 ) -> c_double;
2412 pub fn gst_stream_volume_get_mute(volume: *mut GstStreamVolume) -> gboolean;
2413 pub fn gst_stream_volume_get_volume(
2414 volume: *mut GstStreamVolume,
2415 format: GstStreamVolumeFormat,
2416 ) -> c_double;
2417 pub fn gst_stream_volume_set_mute(volume: *mut GstStreamVolume, mute: gboolean);
2418 pub fn gst_stream_volume_set_volume(
2419 volume: *mut GstStreamVolume,
2420 format: GstStreamVolumeFormat,
2421 val: c_double,
2422 );
2423
2424 pub fn gst_audio_channel_get_fallback_mask(channels: c_int) -> u64;
2428 pub fn gst_audio_channel_positions_from_mask(
2429 channels: c_int,
2430 channel_mask: u64,
2431 position: *mut GstAudioChannelPosition,
2432 ) -> gboolean;
2433 pub fn gst_audio_channel_positions_to_mask(
2434 position: *const GstAudioChannelPosition,
2435 channels: c_int,
2436 force_order: gboolean,
2437 channel_mask: *mut u64,
2438 ) -> gboolean;
2439 pub fn gst_audio_channel_positions_to_string(
2440 position: *const GstAudioChannelPosition,
2441 channels: c_int,
2442 ) -> *mut c_char;
2443 pub fn gst_audio_channel_positions_to_valid_order(
2444 position: *mut GstAudioChannelPosition,
2445 channels: c_int,
2446 ) -> gboolean;
2447 pub fn gst_audio_check_valid_channel_positions(
2448 position: *const GstAudioChannelPosition,
2449 channels: c_int,
2450 force_order: gboolean,
2451 ) -> gboolean;
2452 pub fn gst_audio_clipping_meta_api_get_type() -> GType;
2453 pub fn gst_audio_downmix_meta_api_get_type() -> GType;
2454 pub fn gst_audio_format_info_get_type() -> GType;
2455 #[cfg(feature = "v1_18")]
2456 #[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
2457 pub fn gst_audio_formats_raw(len: *mut c_uint) -> *const GstAudioFormat;
2458 pub fn gst_audio_get_channel_reorder_map(
2459 channels: c_int,
2460 from: *const GstAudioChannelPosition,
2461 to: *const GstAudioChannelPosition,
2462 reorder_map: *mut c_int,
2463 ) -> gboolean;
2464 pub fn gst_audio_iec61937_frame_size(spec: *const GstAudioRingBufferSpec) -> c_uint;
2465 pub fn gst_audio_iec61937_payload(
2466 src: *const u8,
2467 src_n: c_uint,
2468 dst: *mut u8,
2469 dst_n: c_uint,
2470 spec: *const GstAudioRingBufferSpec,
2471 endianness: c_int,
2472 ) -> gboolean;
2473 #[cfg(feature = "v1_20")]
2474 #[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
2475 pub fn gst_audio_level_meta_api_get_type() -> GType;
2476 #[cfg(feature = "v1_18")]
2477 #[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
2478 pub fn gst_audio_make_raw_caps(
2479 formats: *const GstAudioFormat,
2480 len: c_uint,
2481 layout: GstAudioLayout,
2482 ) -> *mut gst::GstCaps;
2483 #[cfg(feature = "v1_16")]
2484 #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
2485 pub fn gst_audio_meta_api_get_type() -> GType;
2486 pub fn gst_audio_reorder_channels(
2487 data: gpointer,
2488 size: size_t,
2489 format: GstAudioFormat,
2490 channels: c_int,
2491 from: *const GstAudioChannelPosition,
2492 to: *const GstAudioChannelPosition,
2493 ) -> gboolean;
2494 #[cfg(feature = "v1_26")]
2495 #[cfg_attr(docsrs, doc(cfg(feature = "v1_26")))]
2496 pub fn gst_audio_reorder_channels_with_reorder_map(
2497 data: gpointer,
2498 size: size_t,
2499 bps: c_int,
2500 channels: c_int,
2501 reorder_map: *const c_int,
2502 );
2503 pub fn gst_buffer_add_audio_clipping_meta(
2504 buffer: *mut gst::GstBuffer,
2505 format: gst::GstFormat,
2506 start: u64,
2507 end: u64,
2508 ) -> *mut GstAudioClippingMeta;
2509 pub fn gst_buffer_add_audio_downmix_meta(
2510 buffer: *mut gst::GstBuffer,
2511 from_position: *const GstAudioChannelPosition,
2512 from_channels: c_int,
2513 to_position: *const GstAudioChannelPosition,
2514 to_channels: c_int,
2515 matrix: *mut *const c_float,
2516 ) -> *mut GstAudioDownmixMeta;
2517 #[cfg(feature = "v1_20")]
2518 #[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
2519 pub fn gst_buffer_add_audio_level_meta(
2520 buffer: *mut gst::GstBuffer,
2521 level: u8,
2522 voice_activity: gboolean,
2523 ) -> *mut GstAudioLevelMeta;
2524 #[cfg(feature = "v1_16")]
2525 #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
2526 pub fn gst_buffer_add_audio_meta(
2527 buffer: *mut gst::GstBuffer,
2528 info: *const GstAudioInfo,
2529 samples: size_t,
2530 offsets: *mut size_t,
2531 ) -> *mut GstAudioMeta;
2532 #[cfg(feature = "v1_24")]
2533 #[cfg_attr(docsrs, doc(cfg(feature = "v1_24")))]
2534 pub fn gst_buffer_add_dsd_plane_offset_meta(
2535 buffer: *mut gst::GstBuffer,
2536 num_channels: c_int,
2537 num_bytes_per_channel: size_t,
2538 offsets: *mut size_t,
2539 ) -> *mut GstDsdPlaneOffsetMeta;
2540 pub fn gst_buffer_get_audio_downmix_meta_for_channels(
2541 buffer: *mut gst::GstBuffer,
2542 to_position: *const GstAudioChannelPosition,
2543 to_channels: c_int,
2544 ) -> *mut GstAudioDownmixMeta;
2545 #[cfg(feature = "v1_20")]
2546 #[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
2547 pub fn gst_buffer_get_audio_level_meta(buffer: *mut gst::GstBuffer) -> *mut GstAudioLevelMeta;
2548 #[cfg(feature = "v1_24")]
2549 #[cfg_attr(docsrs, doc(cfg(feature = "v1_24")))]
2550 pub fn gst_dsd_convert(
2551 input_data: *const u8,
2552 output_data: *mut u8,
2553 input_format: GstDsdFormat,
2554 output_format: GstDsdFormat,
2555 input_layout: GstAudioLayout,
2556 output_layout: GstAudioLayout,
2557 input_plane_offsets: *const size_t,
2558 output_plane_offsets: *const size_t,
2559 num_dsd_bytes: size_t,
2560 num_channels: c_int,
2561 reverse_byte_bits: gboolean,
2562 );
2563 pub fn gst_dsd_plane_offset_meta_api_get_type() -> GType;
2564
2565}