1use crate::ffi;
7use glib::{prelude::*, translate::*};
8
9#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
10#[non_exhaustive]
11#[doc(alias = "GstAudioDitherMethod")]
12pub enum AudioDitherMethod {
13 #[doc(alias = "GST_AUDIO_DITHER_NONE")]
14 None,
15 #[doc(alias = "GST_AUDIO_DITHER_RPDF")]
16 Rpdf,
17 #[doc(alias = "GST_AUDIO_DITHER_TPDF")]
18 Tpdf,
19 #[doc(alias = "GST_AUDIO_DITHER_TPDF_HF")]
20 TpdfHf,
21 #[doc(hidden)]
22 __Unknown(i32),
23}
24
25#[doc(hidden)]
26impl IntoGlib for AudioDitherMethod {
27 type GlibType = ffi::GstAudioDitherMethod;
28
29 #[inline]
30 fn into_glib(self) -> ffi::GstAudioDitherMethod {
31 match self {
32 Self::None => ffi::GST_AUDIO_DITHER_NONE,
33 Self::Rpdf => ffi::GST_AUDIO_DITHER_RPDF,
34 Self::Tpdf => ffi::GST_AUDIO_DITHER_TPDF,
35 Self::TpdfHf => ffi::GST_AUDIO_DITHER_TPDF_HF,
36 Self::__Unknown(value) => value,
37 }
38 }
39}
40
41#[doc(hidden)]
42impl FromGlib<ffi::GstAudioDitherMethod> for AudioDitherMethod {
43 #[inline]
44 unsafe fn from_glib(value: ffi::GstAudioDitherMethod) -> Self {
45 skip_assert_initialized!();
46
47 match value {
48 ffi::GST_AUDIO_DITHER_NONE => Self::None,
49 ffi::GST_AUDIO_DITHER_RPDF => Self::Rpdf,
50 ffi::GST_AUDIO_DITHER_TPDF => Self::Tpdf,
51 ffi::GST_AUDIO_DITHER_TPDF_HF => Self::TpdfHf,
52 value => Self::__Unknown(value),
53 }
54 }
55}
56
57impl StaticType for AudioDitherMethod {
58 #[inline]
59 #[doc(alias = "gst_audio_dither_method_get_type")]
60 fn static_type() -> glib::Type {
61 unsafe { from_glib(ffi::gst_audio_dither_method_get_type()) }
62 }
63}
64
65impl glib::HasParamSpec for AudioDitherMethod {
66 type ParamSpec = glib::ParamSpecEnum;
67 type SetValue = Self;
68 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
69
70 fn param_spec_builder() -> Self::BuilderFn {
71 Self::ParamSpec::builder_with_default
72 }
73}
74
75impl glib::value::ValueType for AudioDitherMethod {
76 type Type = Self;
77}
78
79unsafe impl<'a> glib::value::FromValue<'a> for AudioDitherMethod {
80 type Checker = glib::value::GenericValueTypeChecker<Self>;
81
82 #[inline]
83 unsafe fn from_value(value: &'a glib::Value) -> Self {
84 skip_assert_initialized!();
85 unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
86 }
87}
88
89impl ToValue for AudioDitherMethod {
90 #[inline]
91 fn to_value(&self) -> glib::Value {
92 let mut value = glib::Value::for_value_type::<Self>();
93 unsafe {
94 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
95 }
96 value
97 }
98
99 #[inline]
100 fn value_type(&self) -> glib::Type {
101 Self::static_type()
102 }
103}
104
105impl From<AudioDitherMethod> for glib::Value {
106 #[inline]
107 fn from(v: AudioDitherMethod) -> Self {
108 skip_assert_initialized!();
109 ToValue::to_value(&v)
110 }
111}
112
113#[derive(Debug, Eq, PartialEq, Hash, Clone, Copy)]
114#[non_exhaustive]
115#[doc(alias = "GstAudioFormat")]
116pub enum AudioFormat {
117 #[doc(alias = "GST_AUDIO_FORMAT_UNKNOWN")]
118 Unknown,
119 #[doc(alias = "GST_AUDIO_FORMAT_ENCODED")]
120 Encoded,
121 #[doc(alias = "GST_AUDIO_FORMAT_S8")]
122 S8,
123 #[doc(alias = "GST_AUDIO_FORMAT_U8")]
124 U8,
125 #[doc(alias = "GST_AUDIO_FORMAT_S16LE")]
126 S16le,
127 #[doc(alias = "GST_AUDIO_FORMAT_S16BE")]
128 S16be,
129 #[doc(alias = "GST_AUDIO_FORMAT_U16LE")]
130 U16le,
131 #[doc(alias = "GST_AUDIO_FORMAT_U16BE")]
132 U16be,
133 #[doc(alias = "GST_AUDIO_FORMAT_S24_32LE")]
134 S2432le,
135 #[doc(alias = "GST_AUDIO_FORMAT_S24_32BE")]
136 S2432be,
137 #[doc(alias = "GST_AUDIO_FORMAT_U24_32LE")]
138 U2432le,
139 #[doc(alias = "GST_AUDIO_FORMAT_U24_32BE")]
140 U2432be,
141 #[doc(alias = "GST_AUDIO_FORMAT_S32LE")]
142 S32le,
143 #[doc(alias = "GST_AUDIO_FORMAT_S32BE")]
144 S32be,
145 #[doc(alias = "GST_AUDIO_FORMAT_U32LE")]
146 U32le,
147 #[doc(alias = "GST_AUDIO_FORMAT_U32BE")]
148 U32be,
149 #[doc(alias = "GST_AUDIO_FORMAT_S24LE")]
150 S24le,
151 #[doc(alias = "GST_AUDIO_FORMAT_S24BE")]
152 S24be,
153 #[doc(alias = "GST_AUDIO_FORMAT_U24LE")]
154 U24le,
155 #[doc(alias = "GST_AUDIO_FORMAT_U24BE")]
156 U24be,
157 #[doc(alias = "GST_AUDIO_FORMAT_S20LE")]
158 S20le,
159 #[doc(alias = "GST_AUDIO_FORMAT_S20BE")]
160 S20be,
161 #[doc(alias = "GST_AUDIO_FORMAT_U20LE")]
162 U20le,
163 #[doc(alias = "GST_AUDIO_FORMAT_U20BE")]
164 U20be,
165 #[doc(alias = "GST_AUDIO_FORMAT_S18LE")]
166 S18le,
167 #[doc(alias = "GST_AUDIO_FORMAT_S18BE")]
168 S18be,
169 #[doc(alias = "GST_AUDIO_FORMAT_U18LE")]
170 U18le,
171 #[doc(alias = "GST_AUDIO_FORMAT_U18BE")]
172 U18be,
173 #[doc(alias = "GST_AUDIO_FORMAT_F32LE")]
174 F32le,
175 #[doc(alias = "GST_AUDIO_FORMAT_F32BE")]
176 F32be,
177 #[doc(alias = "GST_AUDIO_FORMAT_F64LE")]
178 F64le,
179 #[doc(alias = "GST_AUDIO_FORMAT_F64BE")]
180 F64be,
181 #[cfg(feature = "v1_28")]
182 #[cfg_attr(docsrs, doc(cfg(feature = "v1_28")))]
183 #[doc(alias = "GST_AUDIO_FORMAT_S20_32LE")]
184 S2032le,
185 #[cfg(feature = "v1_28")]
186 #[cfg_attr(docsrs, doc(cfg(feature = "v1_28")))]
187 #[doc(alias = "GST_AUDIO_FORMAT_S20_32BE")]
188 S2032be,
189 #[cfg(feature = "v1_28")]
190 #[cfg_attr(docsrs, doc(cfg(feature = "v1_28")))]
191 #[doc(alias = "GST_AUDIO_FORMAT_U20_32LE")]
192 U2032le,
193 #[cfg(feature = "v1_28")]
194 #[cfg_attr(docsrs, doc(cfg(feature = "v1_28")))]
195 #[doc(alias = "GST_AUDIO_FORMAT_U20_32BE")]
196 U2032be,
197 #[doc(hidden)]
198 __Unknown(i32),
199}
200
201impl AudioFormat {
202 #[doc(alias = "gst_audio_format_from_string")]
203 pub fn from_string(format: &str) -> AudioFormat {
204 assert_initialized_main_thread!();
205 unsafe { from_glib(ffi::gst_audio_format_from_string(format.to_glib_none().0)) }
206 }
207}
208
209impl std::fmt::Display for AudioFormat {
210 #[inline]
211 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
212 f.write_str(&self.to_str())
213 }
214}
215
216#[doc(hidden)]
217impl IntoGlib for AudioFormat {
218 type GlibType = ffi::GstAudioFormat;
219
220 fn into_glib(self) -> ffi::GstAudioFormat {
221 match self {
222 Self::Unknown => ffi::GST_AUDIO_FORMAT_UNKNOWN,
223 Self::Encoded => ffi::GST_AUDIO_FORMAT_ENCODED,
224 Self::S8 => ffi::GST_AUDIO_FORMAT_S8,
225 Self::U8 => ffi::GST_AUDIO_FORMAT_U8,
226 Self::S16le => ffi::GST_AUDIO_FORMAT_S16LE,
227 Self::S16be => ffi::GST_AUDIO_FORMAT_S16BE,
228 Self::U16le => ffi::GST_AUDIO_FORMAT_U16LE,
229 Self::U16be => ffi::GST_AUDIO_FORMAT_U16BE,
230 Self::S2432le => ffi::GST_AUDIO_FORMAT_S24_32LE,
231 Self::S2432be => ffi::GST_AUDIO_FORMAT_S24_32BE,
232 Self::U2432le => ffi::GST_AUDIO_FORMAT_U24_32LE,
233 Self::U2432be => ffi::GST_AUDIO_FORMAT_U24_32BE,
234 Self::S32le => ffi::GST_AUDIO_FORMAT_S32LE,
235 Self::S32be => ffi::GST_AUDIO_FORMAT_S32BE,
236 Self::U32le => ffi::GST_AUDIO_FORMAT_U32LE,
237 Self::U32be => ffi::GST_AUDIO_FORMAT_U32BE,
238 Self::S24le => ffi::GST_AUDIO_FORMAT_S24LE,
239 Self::S24be => ffi::GST_AUDIO_FORMAT_S24BE,
240 Self::U24le => ffi::GST_AUDIO_FORMAT_U24LE,
241 Self::U24be => ffi::GST_AUDIO_FORMAT_U24BE,
242 Self::S20le => ffi::GST_AUDIO_FORMAT_S20LE,
243 Self::S20be => ffi::GST_AUDIO_FORMAT_S20BE,
244 Self::U20le => ffi::GST_AUDIO_FORMAT_U20LE,
245 Self::U20be => ffi::GST_AUDIO_FORMAT_U20BE,
246 Self::S18le => ffi::GST_AUDIO_FORMAT_S18LE,
247 Self::S18be => ffi::GST_AUDIO_FORMAT_S18BE,
248 Self::U18le => ffi::GST_AUDIO_FORMAT_U18LE,
249 Self::U18be => ffi::GST_AUDIO_FORMAT_U18BE,
250 Self::F32le => ffi::GST_AUDIO_FORMAT_F32LE,
251 Self::F32be => ffi::GST_AUDIO_FORMAT_F32BE,
252 Self::F64le => ffi::GST_AUDIO_FORMAT_F64LE,
253 Self::F64be => ffi::GST_AUDIO_FORMAT_F64BE,
254 #[cfg(feature = "v1_28")]
255 Self::S2032le => ffi::GST_AUDIO_FORMAT_S20_32LE,
256 #[cfg(feature = "v1_28")]
257 Self::S2032be => ffi::GST_AUDIO_FORMAT_S20_32BE,
258 #[cfg(feature = "v1_28")]
259 Self::U2032le => ffi::GST_AUDIO_FORMAT_U20_32LE,
260 #[cfg(feature = "v1_28")]
261 Self::U2032be => ffi::GST_AUDIO_FORMAT_U20_32BE,
262 Self::__Unknown(value) => value,
263 }
264 }
265}
266
267#[doc(hidden)]
268impl FromGlib<ffi::GstAudioFormat> for AudioFormat {
269 unsafe fn from_glib(value: ffi::GstAudioFormat) -> Self {
270 skip_assert_initialized!();
271
272 match value {
273 ffi::GST_AUDIO_FORMAT_UNKNOWN => Self::Unknown,
274 ffi::GST_AUDIO_FORMAT_ENCODED => Self::Encoded,
275 ffi::GST_AUDIO_FORMAT_S8 => Self::S8,
276 ffi::GST_AUDIO_FORMAT_U8 => Self::U8,
277 ffi::GST_AUDIO_FORMAT_S16LE => Self::S16le,
278 ffi::GST_AUDIO_FORMAT_S16BE => Self::S16be,
279 ffi::GST_AUDIO_FORMAT_U16LE => Self::U16le,
280 ffi::GST_AUDIO_FORMAT_U16BE => Self::U16be,
281 ffi::GST_AUDIO_FORMAT_S24_32LE => Self::S2432le,
282 ffi::GST_AUDIO_FORMAT_S24_32BE => Self::S2432be,
283 ffi::GST_AUDIO_FORMAT_U24_32LE => Self::U2432le,
284 ffi::GST_AUDIO_FORMAT_U24_32BE => Self::U2432be,
285 ffi::GST_AUDIO_FORMAT_S32LE => Self::S32le,
286 ffi::GST_AUDIO_FORMAT_S32BE => Self::S32be,
287 ffi::GST_AUDIO_FORMAT_U32LE => Self::U32le,
288 ffi::GST_AUDIO_FORMAT_U32BE => Self::U32be,
289 ffi::GST_AUDIO_FORMAT_S24LE => Self::S24le,
290 ffi::GST_AUDIO_FORMAT_S24BE => Self::S24be,
291 ffi::GST_AUDIO_FORMAT_U24LE => Self::U24le,
292 ffi::GST_AUDIO_FORMAT_U24BE => Self::U24be,
293 ffi::GST_AUDIO_FORMAT_S20LE => Self::S20le,
294 ffi::GST_AUDIO_FORMAT_S20BE => Self::S20be,
295 ffi::GST_AUDIO_FORMAT_U20LE => Self::U20le,
296 ffi::GST_AUDIO_FORMAT_U20BE => Self::U20be,
297 ffi::GST_AUDIO_FORMAT_S18LE => Self::S18le,
298 ffi::GST_AUDIO_FORMAT_S18BE => Self::S18be,
299 ffi::GST_AUDIO_FORMAT_U18LE => Self::U18le,
300 ffi::GST_AUDIO_FORMAT_U18BE => Self::U18be,
301 ffi::GST_AUDIO_FORMAT_F32LE => Self::F32le,
302 ffi::GST_AUDIO_FORMAT_F32BE => Self::F32be,
303 ffi::GST_AUDIO_FORMAT_F64LE => Self::F64le,
304 ffi::GST_AUDIO_FORMAT_F64BE => Self::F64be,
305 #[cfg(feature = "v1_28")]
306 ffi::GST_AUDIO_FORMAT_S20_32LE => Self::S2032le,
307 #[cfg(feature = "v1_28")]
308 ffi::GST_AUDIO_FORMAT_S20_32BE => Self::S2032be,
309 #[cfg(feature = "v1_28")]
310 ffi::GST_AUDIO_FORMAT_U20_32LE => Self::U2032le,
311 #[cfg(feature = "v1_28")]
312 ffi::GST_AUDIO_FORMAT_U20_32BE => Self::U2032be,
313 value => Self::__Unknown(value),
314 }
315 }
316}
317
318impl StaticType for AudioFormat {
319 #[inline]
320 #[doc(alias = "gst_audio_format_get_type")]
321 fn static_type() -> glib::Type {
322 unsafe { from_glib(ffi::gst_audio_format_get_type()) }
323 }
324}
325
326impl glib::HasParamSpec for AudioFormat {
327 type ParamSpec = glib::ParamSpecEnum;
328 type SetValue = Self;
329 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
330
331 fn param_spec_builder() -> Self::BuilderFn {
332 Self::ParamSpec::builder_with_default
333 }
334}
335
336impl glib::value::ValueType for AudioFormat {
337 type Type = Self;
338}
339
340unsafe impl<'a> glib::value::FromValue<'a> for AudioFormat {
341 type Checker = glib::value::GenericValueTypeChecker<Self>;
342
343 #[inline]
344 unsafe fn from_value(value: &'a glib::Value) -> Self {
345 skip_assert_initialized!();
346 unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
347 }
348}
349
350impl ToValue for AudioFormat {
351 #[inline]
352 fn to_value(&self) -> glib::Value {
353 let mut value = glib::Value::for_value_type::<Self>();
354 unsafe {
355 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
356 }
357 value
358 }
359
360 #[inline]
361 fn value_type(&self) -> glib::Type {
362 Self::static_type()
363 }
364}
365
366impl From<AudioFormat> for glib::Value {
367 #[inline]
368 fn from(v: AudioFormat) -> Self {
369 skip_assert_initialized!();
370 ToValue::to_value(&v)
371 }
372}
373
374#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
375#[non_exhaustive]
376#[doc(alias = "GstAudioLayout")]
377pub enum AudioLayout {
378 #[doc(alias = "GST_AUDIO_LAYOUT_INTERLEAVED")]
379 Interleaved,
380 #[doc(alias = "GST_AUDIO_LAYOUT_NON_INTERLEAVED")]
381 NonInterleaved,
382 #[doc(hidden)]
383 __Unknown(i32),
384}
385
386#[doc(hidden)]
387impl IntoGlib for AudioLayout {
388 type GlibType = ffi::GstAudioLayout;
389
390 #[inline]
391 fn into_glib(self) -> ffi::GstAudioLayout {
392 match self {
393 Self::Interleaved => ffi::GST_AUDIO_LAYOUT_INTERLEAVED,
394 Self::NonInterleaved => ffi::GST_AUDIO_LAYOUT_NON_INTERLEAVED,
395 Self::__Unknown(value) => value,
396 }
397 }
398}
399
400#[doc(hidden)]
401impl FromGlib<ffi::GstAudioLayout> for AudioLayout {
402 #[inline]
403 unsafe fn from_glib(value: ffi::GstAudioLayout) -> Self {
404 skip_assert_initialized!();
405
406 match value {
407 ffi::GST_AUDIO_LAYOUT_INTERLEAVED => Self::Interleaved,
408 ffi::GST_AUDIO_LAYOUT_NON_INTERLEAVED => Self::NonInterleaved,
409 value => Self::__Unknown(value),
410 }
411 }
412}
413
414impl StaticType for AudioLayout {
415 #[inline]
416 #[doc(alias = "gst_audio_layout_get_type")]
417 fn static_type() -> glib::Type {
418 unsafe { from_glib(ffi::gst_audio_layout_get_type()) }
419 }
420}
421
422impl glib::HasParamSpec for AudioLayout {
423 type ParamSpec = glib::ParamSpecEnum;
424 type SetValue = Self;
425 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
426
427 fn param_spec_builder() -> Self::BuilderFn {
428 Self::ParamSpec::builder_with_default
429 }
430}
431
432impl glib::value::ValueType for AudioLayout {
433 type Type = Self;
434}
435
436unsafe impl<'a> glib::value::FromValue<'a> for AudioLayout {
437 type Checker = glib::value::GenericValueTypeChecker<Self>;
438
439 #[inline]
440 unsafe fn from_value(value: &'a glib::Value) -> Self {
441 skip_assert_initialized!();
442 unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
443 }
444}
445
446impl ToValue for AudioLayout {
447 #[inline]
448 fn to_value(&self) -> glib::Value {
449 let mut value = glib::Value::for_value_type::<Self>();
450 unsafe {
451 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
452 }
453 value
454 }
455
456 #[inline]
457 fn value_type(&self) -> glib::Type {
458 Self::static_type()
459 }
460}
461
462impl From<AudioLayout> for glib::Value {
463 #[inline]
464 fn from(v: AudioLayout) -> Self {
465 skip_assert_initialized!();
466 ToValue::to_value(&v)
467 }
468}
469
470#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
471#[non_exhaustive]
472#[doc(alias = "GstAudioNoiseShapingMethod")]
473pub enum AudioNoiseShapingMethod {
474 #[doc(alias = "GST_AUDIO_NOISE_SHAPING_NONE")]
475 None,
476 #[doc(alias = "GST_AUDIO_NOISE_SHAPING_ERROR_FEEDBACK")]
477 ErrorFeedback,
478 #[doc(alias = "GST_AUDIO_NOISE_SHAPING_SIMPLE")]
479 Simple,
480 #[doc(alias = "GST_AUDIO_NOISE_SHAPING_MEDIUM")]
481 Medium,
482 #[doc(alias = "GST_AUDIO_NOISE_SHAPING_HIGH")]
483 High,
484 #[doc(hidden)]
485 __Unknown(i32),
486}
487
488#[doc(hidden)]
489impl IntoGlib for AudioNoiseShapingMethod {
490 type GlibType = ffi::GstAudioNoiseShapingMethod;
491
492 #[inline]
493 fn into_glib(self) -> ffi::GstAudioNoiseShapingMethod {
494 match self {
495 Self::None => ffi::GST_AUDIO_NOISE_SHAPING_NONE,
496 Self::ErrorFeedback => ffi::GST_AUDIO_NOISE_SHAPING_ERROR_FEEDBACK,
497 Self::Simple => ffi::GST_AUDIO_NOISE_SHAPING_SIMPLE,
498 Self::Medium => ffi::GST_AUDIO_NOISE_SHAPING_MEDIUM,
499 Self::High => ffi::GST_AUDIO_NOISE_SHAPING_HIGH,
500 Self::__Unknown(value) => value,
501 }
502 }
503}
504
505#[doc(hidden)]
506impl FromGlib<ffi::GstAudioNoiseShapingMethod> for AudioNoiseShapingMethod {
507 #[inline]
508 unsafe fn from_glib(value: ffi::GstAudioNoiseShapingMethod) -> Self {
509 skip_assert_initialized!();
510
511 match value {
512 ffi::GST_AUDIO_NOISE_SHAPING_NONE => Self::None,
513 ffi::GST_AUDIO_NOISE_SHAPING_ERROR_FEEDBACK => Self::ErrorFeedback,
514 ffi::GST_AUDIO_NOISE_SHAPING_SIMPLE => Self::Simple,
515 ffi::GST_AUDIO_NOISE_SHAPING_MEDIUM => Self::Medium,
516 ffi::GST_AUDIO_NOISE_SHAPING_HIGH => Self::High,
517 value => Self::__Unknown(value),
518 }
519 }
520}
521
522impl StaticType for AudioNoiseShapingMethod {
523 #[inline]
524 #[doc(alias = "gst_audio_noise_shaping_method_get_type")]
525 fn static_type() -> glib::Type {
526 unsafe { from_glib(ffi::gst_audio_noise_shaping_method_get_type()) }
527 }
528}
529
530impl glib::HasParamSpec for AudioNoiseShapingMethod {
531 type ParamSpec = glib::ParamSpecEnum;
532 type SetValue = Self;
533 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
534
535 fn param_spec_builder() -> Self::BuilderFn {
536 Self::ParamSpec::builder_with_default
537 }
538}
539
540impl glib::value::ValueType for AudioNoiseShapingMethod {
541 type Type = Self;
542}
543
544unsafe impl<'a> glib::value::FromValue<'a> for AudioNoiseShapingMethod {
545 type Checker = glib::value::GenericValueTypeChecker<Self>;
546
547 #[inline]
548 unsafe fn from_value(value: &'a glib::Value) -> Self {
549 skip_assert_initialized!();
550 unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
551 }
552}
553
554impl ToValue for AudioNoiseShapingMethod {
555 #[inline]
556 fn to_value(&self) -> glib::Value {
557 let mut value = glib::Value::for_value_type::<Self>();
558 unsafe {
559 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
560 }
561 value
562 }
563
564 #[inline]
565 fn value_type(&self) -> glib::Type {
566 Self::static_type()
567 }
568}
569
570impl From<AudioNoiseShapingMethod> for glib::Value {
571 #[inline]
572 fn from(v: AudioNoiseShapingMethod) -> Self {
573 skip_assert_initialized!();
574 ToValue::to_value(&v)
575 }
576}
577
578#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
579#[non_exhaustive]
580#[doc(alias = "GstAudioResamplerMethod")]
581pub enum AudioResamplerMethod {
582 #[doc(alias = "GST_AUDIO_RESAMPLER_METHOD_NEAREST")]
583 Nearest,
584 #[doc(alias = "GST_AUDIO_RESAMPLER_METHOD_LINEAR")]
585 Linear,
586 #[doc(alias = "GST_AUDIO_RESAMPLER_METHOD_CUBIC")]
587 Cubic,
588 #[doc(alias = "GST_AUDIO_RESAMPLER_METHOD_BLACKMAN_NUTTALL")]
589 BlackmanNuttall,
590 #[doc(alias = "GST_AUDIO_RESAMPLER_METHOD_KAISER")]
591 Kaiser,
592 #[doc(hidden)]
593 __Unknown(i32),
594}
595
596#[doc(hidden)]
597impl IntoGlib for AudioResamplerMethod {
598 type GlibType = ffi::GstAudioResamplerMethod;
599
600 #[inline]
601 fn into_glib(self) -> ffi::GstAudioResamplerMethod {
602 match self {
603 Self::Nearest => ffi::GST_AUDIO_RESAMPLER_METHOD_NEAREST,
604 Self::Linear => ffi::GST_AUDIO_RESAMPLER_METHOD_LINEAR,
605 Self::Cubic => ffi::GST_AUDIO_RESAMPLER_METHOD_CUBIC,
606 Self::BlackmanNuttall => ffi::GST_AUDIO_RESAMPLER_METHOD_BLACKMAN_NUTTALL,
607 Self::Kaiser => ffi::GST_AUDIO_RESAMPLER_METHOD_KAISER,
608 Self::__Unknown(value) => value,
609 }
610 }
611}
612
613#[doc(hidden)]
614impl FromGlib<ffi::GstAudioResamplerMethod> for AudioResamplerMethod {
615 #[inline]
616 unsafe fn from_glib(value: ffi::GstAudioResamplerMethod) -> Self {
617 skip_assert_initialized!();
618
619 match value {
620 ffi::GST_AUDIO_RESAMPLER_METHOD_NEAREST => Self::Nearest,
621 ffi::GST_AUDIO_RESAMPLER_METHOD_LINEAR => Self::Linear,
622 ffi::GST_AUDIO_RESAMPLER_METHOD_CUBIC => Self::Cubic,
623 ffi::GST_AUDIO_RESAMPLER_METHOD_BLACKMAN_NUTTALL => Self::BlackmanNuttall,
624 ffi::GST_AUDIO_RESAMPLER_METHOD_KAISER => Self::Kaiser,
625 value => Self::__Unknown(value),
626 }
627 }
628}
629
630impl StaticType for AudioResamplerMethod {
631 #[inline]
632 #[doc(alias = "gst_audio_resampler_method_get_type")]
633 fn static_type() -> glib::Type {
634 unsafe { from_glib(ffi::gst_audio_resampler_method_get_type()) }
635 }
636}
637
638impl glib::HasParamSpec for AudioResamplerMethod {
639 type ParamSpec = glib::ParamSpecEnum;
640 type SetValue = Self;
641 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
642
643 fn param_spec_builder() -> Self::BuilderFn {
644 Self::ParamSpec::builder_with_default
645 }
646}
647
648impl glib::value::ValueType for AudioResamplerMethod {
649 type Type = Self;
650}
651
652unsafe impl<'a> glib::value::FromValue<'a> for AudioResamplerMethod {
653 type Checker = glib::value::GenericValueTypeChecker<Self>;
654
655 #[inline]
656 unsafe fn from_value(value: &'a glib::Value) -> Self {
657 skip_assert_initialized!();
658 unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
659 }
660}
661
662impl ToValue for AudioResamplerMethod {
663 #[inline]
664 fn to_value(&self) -> glib::Value {
665 let mut value = glib::Value::for_value_type::<Self>();
666 unsafe {
667 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
668 }
669 value
670 }
671
672 #[inline]
673 fn value_type(&self) -> glib::Type {
674 Self::static_type()
675 }
676}
677
678impl From<AudioResamplerMethod> for glib::Value {
679 #[inline]
680 fn from(v: AudioResamplerMethod) -> Self {
681 skip_assert_initialized!();
682 ToValue::to_value(&v)
683 }
684}
685
686#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
687#[non_exhaustive]
688#[doc(alias = "GstAudioRingBufferFormatType")]
689pub enum AudioRingBufferFormatType {
690 #[doc(alias = "GST_AUDIO_RING_BUFFER_FORMAT_TYPE_RAW")]
691 Raw,
692 #[doc(alias = "GST_AUDIO_RING_BUFFER_FORMAT_TYPE_MU_LAW")]
693 MuLaw,
694 #[doc(alias = "GST_AUDIO_RING_BUFFER_FORMAT_TYPE_A_LAW")]
695 ALaw,
696 #[doc(alias = "GST_AUDIO_RING_BUFFER_FORMAT_TYPE_IMA_ADPCM")]
697 ImaAdpcm,
698 #[doc(alias = "GST_AUDIO_RING_BUFFER_FORMAT_TYPE_MPEG")]
699 Mpeg,
700 #[doc(alias = "GST_AUDIO_RING_BUFFER_FORMAT_TYPE_GSM")]
701 Gsm,
702 #[doc(alias = "GST_AUDIO_RING_BUFFER_FORMAT_TYPE_IEC958")]
703 Iec958,
704 #[doc(alias = "GST_AUDIO_RING_BUFFER_FORMAT_TYPE_AC3")]
705 Ac3,
706 #[doc(alias = "GST_AUDIO_RING_BUFFER_FORMAT_TYPE_EAC3")]
707 Eac3,
708 #[doc(alias = "GST_AUDIO_RING_BUFFER_FORMAT_TYPE_DTS")]
709 Dts,
710 #[doc(alias = "GST_AUDIO_RING_BUFFER_FORMAT_TYPE_MPEG2_AAC")]
711 Mpeg2Aac,
712 #[doc(alias = "GST_AUDIO_RING_BUFFER_FORMAT_TYPE_MPEG4_AAC")]
713 Mpeg4Aac,
714 #[doc(alias = "GST_AUDIO_RING_BUFFER_FORMAT_TYPE_MPEG2_AAC_RAW")]
715 Mpeg2AacRaw,
716 #[doc(alias = "GST_AUDIO_RING_BUFFER_FORMAT_TYPE_MPEG4_AAC_RAW")]
717 Mpeg4AacRaw,
718 #[doc(alias = "GST_AUDIO_RING_BUFFER_FORMAT_TYPE_FLAC")]
719 Flac,
720 #[cfg(feature = "v1_24")]
721 #[cfg_attr(docsrs, doc(cfg(feature = "v1_24")))]
722 #[doc(alias = "GST_AUDIO_RING_BUFFER_FORMAT_TYPE_DSD")]
723 Dsd,
724 #[doc(hidden)]
725 __Unknown(i32),
726}
727
728#[doc(hidden)]
729impl IntoGlib for AudioRingBufferFormatType {
730 type GlibType = ffi::GstAudioRingBufferFormatType;
731
732 fn into_glib(self) -> ffi::GstAudioRingBufferFormatType {
733 match self {
734 Self::Raw => ffi::GST_AUDIO_RING_BUFFER_FORMAT_TYPE_RAW,
735 Self::MuLaw => ffi::GST_AUDIO_RING_BUFFER_FORMAT_TYPE_MU_LAW,
736 Self::ALaw => ffi::GST_AUDIO_RING_BUFFER_FORMAT_TYPE_A_LAW,
737 Self::ImaAdpcm => ffi::GST_AUDIO_RING_BUFFER_FORMAT_TYPE_IMA_ADPCM,
738 Self::Mpeg => ffi::GST_AUDIO_RING_BUFFER_FORMAT_TYPE_MPEG,
739 Self::Gsm => ffi::GST_AUDIO_RING_BUFFER_FORMAT_TYPE_GSM,
740 Self::Iec958 => ffi::GST_AUDIO_RING_BUFFER_FORMAT_TYPE_IEC958,
741 Self::Ac3 => ffi::GST_AUDIO_RING_BUFFER_FORMAT_TYPE_AC3,
742 Self::Eac3 => ffi::GST_AUDIO_RING_BUFFER_FORMAT_TYPE_EAC3,
743 Self::Dts => ffi::GST_AUDIO_RING_BUFFER_FORMAT_TYPE_DTS,
744 Self::Mpeg2Aac => ffi::GST_AUDIO_RING_BUFFER_FORMAT_TYPE_MPEG2_AAC,
745 Self::Mpeg4Aac => ffi::GST_AUDIO_RING_BUFFER_FORMAT_TYPE_MPEG4_AAC,
746 Self::Mpeg2AacRaw => ffi::GST_AUDIO_RING_BUFFER_FORMAT_TYPE_MPEG2_AAC_RAW,
747 Self::Mpeg4AacRaw => ffi::GST_AUDIO_RING_BUFFER_FORMAT_TYPE_MPEG4_AAC_RAW,
748 Self::Flac => ffi::GST_AUDIO_RING_BUFFER_FORMAT_TYPE_FLAC,
749 #[cfg(feature = "v1_24")]
750 Self::Dsd => ffi::GST_AUDIO_RING_BUFFER_FORMAT_TYPE_DSD,
751 Self::__Unknown(value) => value,
752 }
753 }
754}
755
756#[doc(hidden)]
757impl FromGlib<ffi::GstAudioRingBufferFormatType> for AudioRingBufferFormatType {
758 unsafe fn from_glib(value: ffi::GstAudioRingBufferFormatType) -> Self {
759 skip_assert_initialized!();
760
761 match value {
762 ffi::GST_AUDIO_RING_BUFFER_FORMAT_TYPE_RAW => Self::Raw,
763 ffi::GST_AUDIO_RING_BUFFER_FORMAT_TYPE_MU_LAW => Self::MuLaw,
764 ffi::GST_AUDIO_RING_BUFFER_FORMAT_TYPE_A_LAW => Self::ALaw,
765 ffi::GST_AUDIO_RING_BUFFER_FORMAT_TYPE_IMA_ADPCM => Self::ImaAdpcm,
766 ffi::GST_AUDIO_RING_BUFFER_FORMAT_TYPE_MPEG => Self::Mpeg,
767 ffi::GST_AUDIO_RING_BUFFER_FORMAT_TYPE_GSM => Self::Gsm,
768 ffi::GST_AUDIO_RING_BUFFER_FORMAT_TYPE_IEC958 => Self::Iec958,
769 ffi::GST_AUDIO_RING_BUFFER_FORMAT_TYPE_AC3 => Self::Ac3,
770 ffi::GST_AUDIO_RING_BUFFER_FORMAT_TYPE_EAC3 => Self::Eac3,
771 ffi::GST_AUDIO_RING_BUFFER_FORMAT_TYPE_DTS => Self::Dts,
772 ffi::GST_AUDIO_RING_BUFFER_FORMAT_TYPE_MPEG2_AAC => Self::Mpeg2Aac,
773 ffi::GST_AUDIO_RING_BUFFER_FORMAT_TYPE_MPEG4_AAC => Self::Mpeg4Aac,
774 ffi::GST_AUDIO_RING_BUFFER_FORMAT_TYPE_MPEG2_AAC_RAW => Self::Mpeg2AacRaw,
775 ffi::GST_AUDIO_RING_BUFFER_FORMAT_TYPE_MPEG4_AAC_RAW => Self::Mpeg4AacRaw,
776 ffi::GST_AUDIO_RING_BUFFER_FORMAT_TYPE_FLAC => Self::Flac,
777 #[cfg(feature = "v1_24")]
778 ffi::GST_AUDIO_RING_BUFFER_FORMAT_TYPE_DSD => Self::Dsd,
779 value => Self::__Unknown(value),
780 }
781 }
782}
783
784impl StaticType for AudioRingBufferFormatType {
785 #[inline]
786 #[doc(alias = "gst_audio_ring_buffer_format_type_get_type")]
787 fn static_type() -> glib::Type {
788 unsafe { from_glib(ffi::gst_audio_ring_buffer_format_type_get_type()) }
789 }
790}
791
792impl glib::HasParamSpec for AudioRingBufferFormatType {
793 type ParamSpec = glib::ParamSpecEnum;
794 type SetValue = Self;
795 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
796
797 fn param_spec_builder() -> Self::BuilderFn {
798 Self::ParamSpec::builder_with_default
799 }
800}
801
802impl glib::value::ValueType for AudioRingBufferFormatType {
803 type Type = Self;
804}
805
806unsafe impl<'a> glib::value::FromValue<'a> for AudioRingBufferFormatType {
807 type Checker = glib::value::GenericValueTypeChecker<Self>;
808
809 #[inline]
810 unsafe fn from_value(value: &'a glib::Value) -> Self {
811 skip_assert_initialized!();
812 unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
813 }
814}
815
816impl ToValue for AudioRingBufferFormatType {
817 #[inline]
818 fn to_value(&self) -> glib::Value {
819 let mut value = glib::Value::for_value_type::<Self>();
820 unsafe {
821 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
822 }
823 value
824 }
825
826 #[inline]
827 fn value_type(&self) -> glib::Type {
828 Self::static_type()
829 }
830}
831
832impl From<AudioRingBufferFormatType> for glib::Value {
833 #[inline]
834 fn from(v: AudioRingBufferFormatType) -> Self {
835 skip_assert_initialized!();
836 ToValue::to_value(&v)
837 }
838}
839
840#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
841#[non_exhaustive]
842#[doc(alias = "GstStreamVolumeFormat")]
843pub enum StreamVolumeFormat {
844 #[doc(alias = "GST_STREAM_VOLUME_FORMAT_LINEAR")]
845 Linear,
846 #[doc(alias = "GST_STREAM_VOLUME_FORMAT_CUBIC")]
847 Cubic,
848 #[doc(alias = "GST_STREAM_VOLUME_FORMAT_DB")]
849 Db,
850 #[doc(hidden)]
851 __Unknown(i32),
852}
853
854#[doc(hidden)]
855impl IntoGlib for StreamVolumeFormat {
856 type GlibType = ffi::GstStreamVolumeFormat;
857
858 #[inline]
859 fn into_glib(self) -> ffi::GstStreamVolumeFormat {
860 match self {
861 Self::Linear => ffi::GST_STREAM_VOLUME_FORMAT_LINEAR,
862 Self::Cubic => ffi::GST_STREAM_VOLUME_FORMAT_CUBIC,
863 Self::Db => ffi::GST_STREAM_VOLUME_FORMAT_DB,
864 Self::__Unknown(value) => value,
865 }
866 }
867}
868
869#[doc(hidden)]
870impl FromGlib<ffi::GstStreamVolumeFormat> for StreamVolumeFormat {
871 #[inline]
872 unsafe fn from_glib(value: ffi::GstStreamVolumeFormat) -> Self {
873 skip_assert_initialized!();
874
875 match value {
876 ffi::GST_STREAM_VOLUME_FORMAT_LINEAR => Self::Linear,
877 ffi::GST_STREAM_VOLUME_FORMAT_CUBIC => Self::Cubic,
878 ffi::GST_STREAM_VOLUME_FORMAT_DB => Self::Db,
879 value => Self::__Unknown(value),
880 }
881 }
882}