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