Skip to main content

gstreamer_audio_sys/
lib.rs

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