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