gstreamer_audio_sys/
lib.rs

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

gstreamer_audio_sys/
lib.rs
