gstreamer_audio_sys/
lib.rs

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

gstreamer_audio_sys/
lib.rs
