1#![allow(unused_unsafe)]
2use std::ffi::{c_void, CStr, CString, IntoStringError, NulError};
3use std::fmt::{Display, Formatter};
4use std::mem::size_of;
5use std::os::raw::c_char;
6use std::ptr::{null, null_mut};
7use std::slice;
8pub mod errors;
9pub mod ffi;
10#[cfg(feature = "flags")]
11mod flags;
12#[cfg(feature = "flags")]
13pub use flags::*;
14#[derive(Debug)]
15pub enum Error {
16 Fmod {
17 function: String,
18 code: i32,
19 message: String,
20 },
21 EnumBindgen {
22 enumeration: String,
23 value: String,
24 },
25 String(IntoStringError),
26 StringNul(NulError),
27 NotDspFft,
28}
29impl Display for Error {
30 fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
31 match self {
32 Error::Fmod {
33 function,
34 code,
35 message,
36 } => {
37 write!(f, "{}: {} ({})", function, message, code)
38 }
39 Error::EnumBindgen { enumeration, value } => {
40 write!(
41 f,
42 "FMOD returns unexpected value {} for {} enum",
43 value, enumeration
44 )
45 }
46 Error::String(_) => {
47 write!(f, "invalid UTF-8 when converting C string")
48 }
49 Error::StringNul(_) => {
50 write!(
51 f,
52 "nul byte was found in the middle, C strings can't contain it"
53 )
54 }
55 Error::NotDspFft => {
56 write!(f, "trying get FFT from DSP which not FFT")
57 }
58 }
59 }
60}
61impl std::error::Error for Error {}
62impl From<NulError> for Error {
63 fn from(error: NulError) -> Self {
64 Error::StringNul(error)
65 }
66}
67macro_rules! err_fmod {
68 ($ function : expr , $ code : expr) => {
69 Error::Fmod {
70 function: $function.to_string(),
71 code: $code,
72 message: errors::map_fmod_error($code).to_string(),
73 }
74 };
75}
76macro_rules! move_string_to_c {
77 ($ value : expr) => {
78 CString::new($value)
79 .unwrap_or(CString::from(c"err!"))
80 .into_raw()
81 };
82}
83macro_rules! err_enum {
84 ($ enumeration : expr , $ value : expr) => {
85 Error::EnumBindgen {
86 enumeration: $enumeration.to_string(),
87 value: $value.to_string(),
88 }
89 };
90}
91macro_rules! to_string {
92 ($ ptr : expr) => {
93 if $ptr.is_null() {
94 Ok(String::new())
95 } else {
96 CString::from(CStr::from_ptr($ptr))
97 .into_string()
98 .map_err(Error::String)
99 }
100 };
101}
102macro_rules! string_buffer {
103 ($ len : expr) => {
104 if $len == 0 {
105 std::ptr::null_mut()
106 } else {
107 Box::into_raw(vec![0; $len as usize].into_boxed_slice()) as *mut _
108 }
109 };
110}
111macro_rules! ptr_opt {
112 ($ ptr : expr , $ value : expr) => {
113 if $ptr.is_null() {
114 None
115 } else {
116 Some($value)
117 }
118 };
119}
120macro_rules! opt_ptr {
121 ($ opt : expr , $ map : expr) => {
122 $opt.map($map).unwrap_or(null_mut())
123 };
124}
125macro_rules! to_vec {
126 ($ ptr : expr , $ length : expr , $ closure : expr) => {
127 if $length == 0 {
128 Ok(vec![])
129 } else {
130 slice::from_raw_parts($ptr, $length as usize)
131 .to_vec()
132 .into_iter()
133 .map($closure)
134 .collect::<Result<Vec<_>, Error>>()
135 }
136 };
137 ($ ptr : expr , $ length : expr) => {
138 if $length == 0 {
139 vec![]
140 } else {
141 slice::from_raw_parts($ptr, $length as usize).to_vec()
142 }
143 };
144}
145macro_rules! to_bool {
146 ($ value : expr) => {
147 match $value {
148 1 => true,
149 _ => false,
150 }
151 };
152}
153macro_rules! from_bool {
154 ($ value : expr) => {
155 match $value {
156 true => 1,
157 _ => 0,
158 }
159 };
160}
161pub fn attr3d_array8(
162 values: Vec<Attributes3d>,
163) -> [Attributes3d; ffi::FMOD_MAX_LISTENERS as usize] {
164 values.try_into().expect("slice with incorrect length")
165}
166pub fn vec_as_mut_ptr<T, O, F>(values: Vec<T>, map: F) -> *mut O
167where
168 F: FnMut(T) -> O,
169{
170 let mut values = values.into_iter().map(map).collect::<Vec<O>>();
171 Box::into_raw(values.into_boxed_slice()) as *mut _
172}
173const fn from_ref<T: ?Sized>(value: &T) -> *const T {
174 value
175}
176#[derive(Debug, Clone, Copy, PartialEq)]
177pub enum LoadingState {
178 Unloading,
179 Unloaded,
180 Loading,
181 Loaded,
182 Error,
183}
184impl From<LoadingState> for ffi::FMOD_STUDIO_LOADING_STATE {
185 fn from(value: LoadingState) -> ffi::FMOD_STUDIO_LOADING_STATE {
186 match value {
187 LoadingState::Unloading => ffi::FMOD_STUDIO_LOADING_STATE_UNLOADING,
188 LoadingState::Unloaded => ffi::FMOD_STUDIO_LOADING_STATE_UNLOADED,
189 LoadingState::Loading => ffi::FMOD_STUDIO_LOADING_STATE_LOADING,
190 LoadingState::Loaded => ffi::FMOD_STUDIO_LOADING_STATE_LOADED,
191 LoadingState::Error => ffi::FMOD_STUDIO_LOADING_STATE_ERROR,
192 }
193 }
194}
195impl LoadingState {
196 pub fn from(value: ffi::FMOD_STUDIO_LOADING_STATE) -> Result<LoadingState, Error> {
197 match value {
198 ffi::FMOD_STUDIO_LOADING_STATE_UNLOADING => Ok(LoadingState::Unloading),
199 ffi::FMOD_STUDIO_LOADING_STATE_UNLOADED => Ok(LoadingState::Unloaded),
200 ffi::FMOD_STUDIO_LOADING_STATE_LOADING => Ok(LoadingState::Loading),
201 ffi::FMOD_STUDIO_LOADING_STATE_LOADED => Ok(LoadingState::Loaded),
202 ffi::FMOD_STUDIO_LOADING_STATE_ERROR => Ok(LoadingState::Error),
203 _ => Err(err_enum!("FMOD_STUDIO_LOADING_STATE", value)),
204 }
205 }
206}
207#[derive(Debug, Clone, Copy, PartialEq)]
208pub enum LoadMemoryMode {
209 Memory,
210 MemoryPoint,
211}
212impl From<LoadMemoryMode> for ffi::FMOD_STUDIO_LOAD_MEMORY_MODE {
213 fn from(value: LoadMemoryMode) -> ffi::FMOD_STUDIO_LOAD_MEMORY_MODE {
214 match value {
215 LoadMemoryMode::Memory => ffi::FMOD_STUDIO_LOAD_MEMORY,
216 LoadMemoryMode::MemoryPoint => ffi::FMOD_STUDIO_LOAD_MEMORY_POINT,
217 }
218 }
219}
220impl LoadMemoryMode {
221 pub fn from(value: ffi::FMOD_STUDIO_LOAD_MEMORY_MODE) -> Result<LoadMemoryMode, Error> {
222 match value {
223 ffi::FMOD_STUDIO_LOAD_MEMORY => Ok(LoadMemoryMode::Memory),
224 ffi::FMOD_STUDIO_LOAD_MEMORY_POINT => Ok(LoadMemoryMode::MemoryPoint),
225 _ => Err(err_enum!("FMOD_STUDIO_LOAD_MEMORY_MODE", value)),
226 }
227 }
228}
229#[derive(Debug, Clone, Copy, PartialEq)]
230pub enum ParameterType {
231 GameControlled,
232 AutomaticDistance,
233 AutomaticEventConeAngle,
234 AutomaticEventOrientation,
235 AutomaticDirection,
236 AutomaticElevation,
237 AutomaticListenerOrientation,
238 AutomaticSpeed,
239 AutomaticSpeedAbsolute,
240 AutomaticDistanceNormalized,
241 Max,
242}
243impl From<ParameterType> for ffi::FMOD_STUDIO_PARAMETER_TYPE {
244 fn from(value: ParameterType) -> ffi::FMOD_STUDIO_PARAMETER_TYPE {
245 match value {
246 ParameterType::GameControlled => ffi::FMOD_STUDIO_PARAMETER_GAME_CONTROLLED,
247 ParameterType::AutomaticDistance => ffi::FMOD_STUDIO_PARAMETER_AUTOMATIC_DISTANCE,
248 ParameterType::AutomaticEventConeAngle => {
249 ffi::FMOD_STUDIO_PARAMETER_AUTOMATIC_EVENT_CONE_ANGLE
250 }
251 ParameterType::AutomaticEventOrientation => {
252 ffi::FMOD_STUDIO_PARAMETER_AUTOMATIC_EVENT_ORIENTATION
253 }
254 ParameterType::AutomaticDirection => ffi::FMOD_STUDIO_PARAMETER_AUTOMATIC_DIRECTION,
255 ParameterType::AutomaticElevation => ffi::FMOD_STUDIO_PARAMETER_AUTOMATIC_ELEVATION,
256 ParameterType::AutomaticListenerOrientation => {
257 ffi::FMOD_STUDIO_PARAMETER_AUTOMATIC_LISTENER_ORIENTATION
258 }
259 ParameterType::AutomaticSpeed => ffi::FMOD_STUDIO_PARAMETER_AUTOMATIC_SPEED,
260 ParameterType::AutomaticSpeedAbsolute => {
261 ffi::FMOD_STUDIO_PARAMETER_AUTOMATIC_SPEED_ABSOLUTE
262 }
263 ParameterType::AutomaticDistanceNormalized => {
264 ffi::FMOD_STUDIO_PARAMETER_AUTOMATIC_DISTANCE_NORMALIZED
265 }
266 ParameterType::Max => ffi::FMOD_STUDIO_PARAMETER_MAX,
267 }
268 }
269}
270impl ParameterType {
271 pub fn from(value: ffi::FMOD_STUDIO_PARAMETER_TYPE) -> Result<ParameterType, Error> {
272 match value {
273 ffi::FMOD_STUDIO_PARAMETER_GAME_CONTROLLED => Ok(ParameterType::GameControlled),
274 ffi::FMOD_STUDIO_PARAMETER_AUTOMATIC_DISTANCE => Ok(ParameterType::AutomaticDistance),
275 ffi::FMOD_STUDIO_PARAMETER_AUTOMATIC_EVENT_CONE_ANGLE => {
276 Ok(ParameterType::AutomaticEventConeAngle)
277 }
278 ffi::FMOD_STUDIO_PARAMETER_AUTOMATIC_EVENT_ORIENTATION => {
279 Ok(ParameterType::AutomaticEventOrientation)
280 }
281 ffi::FMOD_STUDIO_PARAMETER_AUTOMATIC_DIRECTION => Ok(ParameterType::AutomaticDirection),
282 ffi::FMOD_STUDIO_PARAMETER_AUTOMATIC_ELEVATION => Ok(ParameterType::AutomaticElevation),
283 ffi::FMOD_STUDIO_PARAMETER_AUTOMATIC_LISTENER_ORIENTATION => {
284 Ok(ParameterType::AutomaticListenerOrientation)
285 }
286 ffi::FMOD_STUDIO_PARAMETER_AUTOMATIC_SPEED => Ok(ParameterType::AutomaticSpeed),
287 ffi::FMOD_STUDIO_PARAMETER_AUTOMATIC_SPEED_ABSOLUTE => {
288 Ok(ParameterType::AutomaticSpeedAbsolute)
289 }
290 ffi::FMOD_STUDIO_PARAMETER_AUTOMATIC_DISTANCE_NORMALIZED => {
291 Ok(ParameterType::AutomaticDistanceNormalized)
292 }
293 ffi::FMOD_STUDIO_PARAMETER_MAX => Ok(ParameterType::Max),
294 _ => Err(err_enum!("FMOD_STUDIO_PARAMETER_TYPE", value)),
295 }
296 }
297}
298#[derive(Debug, Clone, Copy, PartialEq)]
299pub enum UserPropertyType {
300 Integer,
301 Boolean,
302 Float,
303 String,
304}
305impl From<UserPropertyType> for ffi::FMOD_STUDIO_USER_PROPERTY_TYPE {
306 fn from(value: UserPropertyType) -> ffi::FMOD_STUDIO_USER_PROPERTY_TYPE {
307 match value {
308 UserPropertyType::Integer => ffi::FMOD_STUDIO_USER_PROPERTY_TYPE_INTEGER,
309 UserPropertyType::Boolean => ffi::FMOD_STUDIO_USER_PROPERTY_TYPE_BOOLEAN,
310 UserPropertyType::Float => ffi::FMOD_STUDIO_USER_PROPERTY_TYPE_FLOAT,
311 UserPropertyType::String => ffi::FMOD_STUDIO_USER_PROPERTY_TYPE_STRING,
312 }
313 }
314}
315impl UserPropertyType {
316 pub fn from(value: ffi::FMOD_STUDIO_USER_PROPERTY_TYPE) -> Result<UserPropertyType, Error> {
317 match value {
318 ffi::FMOD_STUDIO_USER_PROPERTY_TYPE_INTEGER => Ok(UserPropertyType::Integer),
319 ffi::FMOD_STUDIO_USER_PROPERTY_TYPE_BOOLEAN => Ok(UserPropertyType::Boolean),
320 ffi::FMOD_STUDIO_USER_PROPERTY_TYPE_FLOAT => Ok(UserPropertyType::Float),
321 ffi::FMOD_STUDIO_USER_PROPERTY_TYPE_STRING => Ok(UserPropertyType::String),
322 _ => Err(err_enum!("FMOD_STUDIO_USER_PROPERTY_TYPE", value)),
323 }
324 }
325}
326#[derive(Debug, Clone, Copy, PartialEq)]
327pub enum EventProperty {
328 ChannelPriority,
329 ScheduleDelay,
330 ScheduleLookahead,
331 MinimumDistance,
332 MaximumDistance,
333 Cooldown,
334 Max,
335}
336impl From<EventProperty> for ffi::FMOD_STUDIO_EVENT_PROPERTY {
337 fn from(value: EventProperty) -> ffi::FMOD_STUDIO_EVENT_PROPERTY {
338 match value {
339 EventProperty::ChannelPriority => ffi::FMOD_STUDIO_EVENT_PROPERTY_CHANNELPRIORITY,
340 EventProperty::ScheduleDelay => ffi::FMOD_STUDIO_EVENT_PROPERTY_SCHEDULE_DELAY,
341 EventProperty::ScheduleLookahead => ffi::FMOD_STUDIO_EVENT_PROPERTY_SCHEDULE_LOOKAHEAD,
342 EventProperty::MinimumDistance => ffi::FMOD_STUDIO_EVENT_PROPERTY_MINIMUM_DISTANCE,
343 EventProperty::MaximumDistance => ffi::FMOD_STUDIO_EVENT_PROPERTY_MAXIMUM_DISTANCE,
344 EventProperty::Cooldown => ffi::FMOD_STUDIO_EVENT_PROPERTY_COOLDOWN,
345 EventProperty::Max => ffi::FMOD_STUDIO_EVENT_PROPERTY_MAX,
346 }
347 }
348}
349impl EventProperty {
350 pub fn from(value: ffi::FMOD_STUDIO_EVENT_PROPERTY) -> Result<EventProperty, Error> {
351 match value {
352 ffi::FMOD_STUDIO_EVENT_PROPERTY_CHANNELPRIORITY => Ok(EventProperty::ChannelPriority),
353 ffi::FMOD_STUDIO_EVENT_PROPERTY_SCHEDULE_DELAY => Ok(EventProperty::ScheduleDelay),
354 ffi::FMOD_STUDIO_EVENT_PROPERTY_SCHEDULE_LOOKAHEAD => {
355 Ok(EventProperty::ScheduleLookahead)
356 }
357 ffi::FMOD_STUDIO_EVENT_PROPERTY_MINIMUM_DISTANCE => Ok(EventProperty::MinimumDistance),
358 ffi::FMOD_STUDIO_EVENT_PROPERTY_MAXIMUM_DISTANCE => Ok(EventProperty::MaximumDistance),
359 ffi::FMOD_STUDIO_EVENT_PROPERTY_COOLDOWN => Ok(EventProperty::Cooldown),
360 ffi::FMOD_STUDIO_EVENT_PROPERTY_MAX => Ok(EventProperty::Max),
361 _ => Err(err_enum!("FMOD_STUDIO_EVENT_PROPERTY", value)),
362 }
363 }
364}
365#[derive(Debug, Clone, Copy, PartialEq)]
366pub enum PlaybackState {
367 Playing,
368 Sustaining,
369 Stopped,
370 Starting,
371 Stopping,
372}
373impl From<PlaybackState> for ffi::FMOD_STUDIO_PLAYBACK_STATE {
374 fn from(value: PlaybackState) -> ffi::FMOD_STUDIO_PLAYBACK_STATE {
375 match value {
376 PlaybackState::Playing => ffi::FMOD_STUDIO_PLAYBACK_PLAYING,
377 PlaybackState::Sustaining => ffi::FMOD_STUDIO_PLAYBACK_SUSTAINING,
378 PlaybackState::Stopped => ffi::FMOD_STUDIO_PLAYBACK_STOPPED,
379 PlaybackState::Starting => ffi::FMOD_STUDIO_PLAYBACK_STARTING,
380 PlaybackState::Stopping => ffi::FMOD_STUDIO_PLAYBACK_STOPPING,
381 }
382 }
383}
384impl PlaybackState {
385 pub fn from(value: ffi::FMOD_STUDIO_PLAYBACK_STATE) -> Result<PlaybackState, Error> {
386 match value {
387 ffi::FMOD_STUDIO_PLAYBACK_PLAYING => Ok(PlaybackState::Playing),
388 ffi::FMOD_STUDIO_PLAYBACK_SUSTAINING => Ok(PlaybackState::Sustaining),
389 ffi::FMOD_STUDIO_PLAYBACK_STOPPED => Ok(PlaybackState::Stopped),
390 ffi::FMOD_STUDIO_PLAYBACK_STARTING => Ok(PlaybackState::Starting),
391 ffi::FMOD_STUDIO_PLAYBACK_STOPPING => Ok(PlaybackState::Stopping),
392 _ => Err(err_enum!("FMOD_STUDIO_PLAYBACK_STATE", value)),
393 }
394 }
395}
396#[derive(Debug, Clone, Copy, PartialEq)]
397pub enum StopMode {
398 AllowFadeout,
399 Immediate,
400}
401impl From<StopMode> for ffi::FMOD_STUDIO_STOP_MODE {
402 fn from(value: StopMode) -> ffi::FMOD_STUDIO_STOP_MODE {
403 match value {
404 StopMode::AllowFadeout => ffi::FMOD_STUDIO_STOP_ALLOWFADEOUT,
405 StopMode::Immediate => ffi::FMOD_STUDIO_STOP_IMMEDIATE,
406 }
407 }
408}
409impl StopMode {
410 pub fn from(value: ffi::FMOD_STUDIO_STOP_MODE) -> Result<StopMode, Error> {
411 match value {
412 ffi::FMOD_STUDIO_STOP_ALLOWFADEOUT => Ok(StopMode::AllowFadeout),
413 ffi::FMOD_STUDIO_STOP_IMMEDIATE => Ok(StopMode::Immediate),
414 _ => Err(err_enum!("FMOD_STUDIO_STOP_MODE", value)),
415 }
416 }
417}
418#[derive(Debug, Clone, Copy, PartialEq)]
419pub enum InstanceType {
420 None,
421 System,
422 EventDescription,
423 EventInstance,
424 ParameterInstance,
425 Bus,
426 Vca,
427 Bank,
428 CommandReplay,
429}
430impl From<InstanceType> for ffi::FMOD_STUDIO_INSTANCETYPE {
431 fn from(value: InstanceType) -> ffi::FMOD_STUDIO_INSTANCETYPE {
432 match value {
433 InstanceType::None => ffi::FMOD_STUDIO_INSTANCETYPE_NONE,
434 InstanceType::System => ffi::FMOD_STUDIO_INSTANCETYPE_SYSTEM,
435 InstanceType::EventDescription => ffi::FMOD_STUDIO_INSTANCETYPE_EVENTDESCRIPTION,
436 InstanceType::EventInstance => ffi::FMOD_STUDIO_INSTANCETYPE_EVENTINSTANCE,
437 InstanceType::ParameterInstance => ffi::FMOD_STUDIO_INSTANCETYPE_PARAMETERINSTANCE,
438 InstanceType::Bus => ffi::FMOD_STUDIO_INSTANCETYPE_BUS,
439 InstanceType::Vca => ffi::FMOD_STUDIO_INSTANCETYPE_VCA,
440 InstanceType::Bank => ffi::FMOD_STUDIO_INSTANCETYPE_BANK,
441 InstanceType::CommandReplay => ffi::FMOD_STUDIO_INSTANCETYPE_COMMANDREPLAY,
442 }
443 }
444}
445impl InstanceType {
446 pub fn from(value: ffi::FMOD_STUDIO_INSTANCETYPE) -> Result<InstanceType, Error> {
447 match value {
448 ffi::FMOD_STUDIO_INSTANCETYPE_NONE => Ok(InstanceType::None),
449 ffi::FMOD_STUDIO_INSTANCETYPE_SYSTEM => Ok(InstanceType::System),
450 ffi::FMOD_STUDIO_INSTANCETYPE_EVENTDESCRIPTION => Ok(InstanceType::EventDescription),
451 ffi::FMOD_STUDIO_INSTANCETYPE_EVENTINSTANCE => Ok(InstanceType::EventInstance),
452 ffi::FMOD_STUDIO_INSTANCETYPE_PARAMETERINSTANCE => Ok(InstanceType::ParameterInstance),
453 ffi::FMOD_STUDIO_INSTANCETYPE_BUS => Ok(InstanceType::Bus),
454 ffi::FMOD_STUDIO_INSTANCETYPE_VCA => Ok(InstanceType::Vca),
455 ffi::FMOD_STUDIO_INSTANCETYPE_BANK => Ok(InstanceType::Bank),
456 ffi::FMOD_STUDIO_INSTANCETYPE_COMMANDREPLAY => Ok(InstanceType::CommandReplay),
457 _ => Err(err_enum!("FMOD_STUDIO_INSTANCETYPE", value)),
458 }
459 }
460}
461#[derive(Debug, Clone, Copy, PartialEq)]
462pub enum ThreadType {
463 Mixer,
464 Feeder,
465 Stream,
466 File,
467 Nonblocking,
468 Record,
469 Geometry,
470 Profiler,
471 StudioUpdate,
472 StudioLoadBank,
473 StudioLoadSample,
474 Convolution1,
475 Convolution2,
476 Max,
477}
478impl From<ThreadType> for ffi::FMOD_THREAD_TYPE {
479 fn from(value: ThreadType) -> ffi::FMOD_THREAD_TYPE {
480 match value {
481 ThreadType::Mixer => ffi::FMOD_THREAD_TYPE_MIXER,
482 ThreadType::Feeder => ffi::FMOD_THREAD_TYPE_FEEDER,
483 ThreadType::Stream => ffi::FMOD_THREAD_TYPE_STREAM,
484 ThreadType::File => ffi::FMOD_THREAD_TYPE_FILE,
485 ThreadType::Nonblocking => ffi::FMOD_THREAD_TYPE_NONBLOCKING,
486 ThreadType::Record => ffi::FMOD_THREAD_TYPE_RECORD,
487 ThreadType::Geometry => ffi::FMOD_THREAD_TYPE_GEOMETRY,
488 ThreadType::Profiler => ffi::FMOD_THREAD_TYPE_PROFILER,
489 ThreadType::StudioUpdate => ffi::FMOD_THREAD_TYPE_STUDIO_UPDATE,
490 ThreadType::StudioLoadBank => ffi::FMOD_THREAD_TYPE_STUDIO_LOAD_BANK,
491 ThreadType::StudioLoadSample => ffi::FMOD_THREAD_TYPE_STUDIO_LOAD_SAMPLE,
492 ThreadType::Convolution1 => ffi::FMOD_THREAD_TYPE_CONVOLUTION1,
493 ThreadType::Convolution2 => ffi::FMOD_THREAD_TYPE_CONVOLUTION2,
494 ThreadType::Max => ffi::FMOD_THREAD_TYPE_MAX,
495 }
496 }
497}
498impl ThreadType {
499 pub fn from(value: ffi::FMOD_THREAD_TYPE) -> Result<ThreadType, Error> {
500 match value {
501 ffi::FMOD_THREAD_TYPE_MIXER => Ok(ThreadType::Mixer),
502 ffi::FMOD_THREAD_TYPE_FEEDER => Ok(ThreadType::Feeder),
503 ffi::FMOD_THREAD_TYPE_STREAM => Ok(ThreadType::Stream),
504 ffi::FMOD_THREAD_TYPE_FILE => Ok(ThreadType::File),
505 ffi::FMOD_THREAD_TYPE_NONBLOCKING => Ok(ThreadType::Nonblocking),
506 ffi::FMOD_THREAD_TYPE_RECORD => Ok(ThreadType::Record),
507 ffi::FMOD_THREAD_TYPE_GEOMETRY => Ok(ThreadType::Geometry),
508 ffi::FMOD_THREAD_TYPE_PROFILER => Ok(ThreadType::Profiler),
509 ffi::FMOD_THREAD_TYPE_STUDIO_UPDATE => Ok(ThreadType::StudioUpdate),
510 ffi::FMOD_THREAD_TYPE_STUDIO_LOAD_BANK => Ok(ThreadType::StudioLoadBank),
511 ffi::FMOD_THREAD_TYPE_STUDIO_LOAD_SAMPLE => Ok(ThreadType::StudioLoadSample),
512 ffi::FMOD_THREAD_TYPE_CONVOLUTION1 => Ok(ThreadType::Convolution1),
513 ffi::FMOD_THREAD_TYPE_CONVOLUTION2 => Ok(ThreadType::Convolution2),
514 ffi::FMOD_THREAD_TYPE_MAX => Ok(ThreadType::Max),
515 _ => Err(err_enum!("FMOD_THREAD_TYPE", value)),
516 }
517 }
518}
519#[derive(Debug, Clone, Copy, PartialEq)]
520pub enum FmodResult {
521 Ok,
522 ErrBadcommand,
523 ErrChannelAlloc,
524 ErrChannelStolen,
525 ErrDma,
526 ErrDspConnection,
527 ErrDspDontprocess,
528 ErrDspFormat,
529 ErrDspInuse,
530 ErrDspNotfound,
531 ErrDspReserved,
532 ErrDspSilence,
533 ErrDspType,
534 ErrFileBad,
535 ErrFileCouldnotseek,
536 ErrFileDiskejected,
537 ErrFileEof,
538 ErrFileEndofdata,
539 ErrFileNotfound,
540 ErrFormat,
541 ErrHeaderMismatch,
542 ErrHttp,
543 ErrHttpAccess,
544 ErrHttpProxyAuth,
545 ErrHttpServerError,
546 ErrHttpTimeout,
547 ErrInitialization,
548 ErrInitialized,
549 ErrInternal,
550 ErrInvalidFloat,
551 ErrInvalidHandle,
552 ErrInvalidParam,
553 ErrInvalidPosition,
554 ErrInvalidSpeaker,
555 ErrInvalidSyncpoint,
556 ErrInvalidThread,
557 ErrInvalidVector,
558 ErrMaxaudible,
559 ErrMemory,
560 ErrMemoryCantpoint,
561 ErrNeeds3D,
562 ErrNeedshardware,
563 ErrNetConnect,
564 ErrNetSocketError,
565 ErrNetUrl,
566 ErrNetWouldBlock,
567 ErrNotready,
568 ErrOutputAllocated,
569 ErrOutputCreatebuffer,
570 ErrOutputDrivercall,
571 ErrOutputFormat,
572 ErrOutputInit,
573 ErrOutputNodrivers,
574 ErrPlugin,
575 ErrPluginMissing,
576 ErrPluginResource,
577 ErrPluginVersion,
578 ErrRecord,
579 ErrReverbChannelgroup,
580 ErrReverbInstance,
581 ErrSubsounds,
582 ErrSubsoundAllocated,
583 ErrSubsoundCantmove,
584 ErrTagnotfound,
585 ErrToomanychannels,
586 ErrTruncated,
587 ErrUnimplemented,
588 ErrUninitialized,
589 ErrUnsupported,
590 ErrVersion,
591 ErrEventAlreadyLoaded,
592 ErrEventLiveupdateBusy,
593 ErrEventLiveupdateMismatch,
594 ErrEventLiveupdateTimeout,
595 ErrEventNotfound,
596 ErrStudioUninitialized,
597 ErrStudioNotLoaded,
598 ErrInvalidString,
599 ErrAlreadyLocked,
600 ErrNotLocked,
601 ErrRecordDisconnected,
602 ErrToomanysamples,
603}
604impl From<FmodResult> for ffi::FMOD_RESULT {
605 fn from(value: FmodResult) -> ffi::FMOD_RESULT {
606 match value {
607 FmodResult::Ok => ffi::FMOD_OK,
608 FmodResult::ErrBadcommand => ffi::FMOD_ERR_BADCOMMAND,
609 FmodResult::ErrChannelAlloc => ffi::FMOD_ERR_CHANNEL_ALLOC,
610 FmodResult::ErrChannelStolen => ffi::FMOD_ERR_CHANNEL_STOLEN,
611 FmodResult::ErrDma => ffi::FMOD_ERR_DMA,
612 FmodResult::ErrDspConnection => ffi::FMOD_ERR_DSP_CONNECTION,
613 FmodResult::ErrDspDontprocess => ffi::FMOD_ERR_DSP_DONTPROCESS,
614 FmodResult::ErrDspFormat => ffi::FMOD_ERR_DSP_FORMAT,
615 FmodResult::ErrDspInuse => ffi::FMOD_ERR_DSP_INUSE,
616 FmodResult::ErrDspNotfound => ffi::FMOD_ERR_DSP_NOTFOUND,
617 FmodResult::ErrDspReserved => ffi::FMOD_ERR_DSP_RESERVED,
618 FmodResult::ErrDspSilence => ffi::FMOD_ERR_DSP_SILENCE,
619 FmodResult::ErrDspType => ffi::FMOD_ERR_DSP_TYPE,
620 FmodResult::ErrFileBad => ffi::FMOD_ERR_FILE_BAD,
621 FmodResult::ErrFileCouldnotseek => ffi::FMOD_ERR_FILE_COULDNOTSEEK,
622 FmodResult::ErrFileDiskejected => ffi::FMOD_ERR_FILE_DISKEJECTED,
623 FmodResult::ErrFileEof => ffi::FMOD_ERR_FILE_EOF,
624 FmodResult::ErrFileEndofdata => ffi::FMOD_ERR_FILE_ENDOFDATA,
625 FmodResult::ErrFileNotfound => ffi::FMOD_ERR_FILE_NOTFOUND,
626 FmodResult::ErrFormat => ffi::FMOD_ERR_FORMAT,
627 FmodResult::ErrHeaderMismatch => ffi::FMOD_ERR_HEADER_MISMATCH,
628 FmodResult::ErrHttp => ffi::FMOD_ERR_HTTP,
629 FmodResult::ErrHttpAccess => ffi::FMOD_ERR_HTTP_ACCESS,
630 FmodResult::ErrHttpProxyAuth => ffi::FMOD_ERR_HTTP_PROXY_AUTH,
631 FmodResult::ErrHttpServerError => ffi::FMOD_ERR_HTTP_SERVER_ERROR,
632 FmodResult::ErrHttpTimeout => ffi::FMOD_ERR_HTTP_TIMEOUT,
633 FmodResult::ErrInitialization => ffi::FMOD_ERR_INITIALIZATION,
634 FmodResult::ErrInitialized => ffi::FMOD_ERR_INITIALIZED,
635 FmodResult::ErrInternal => ffi::FMOD_ERR_INTERNAL,
636 FmodResult::ErrInvalidFloat => ffi::FMOD_ERR_INVALID_FLOAT,
637 FmodResult::ErrInvalidHandle => ffi::FMOD_ERR_INVALID_HANDLE,
638 FmodResult::ErrInvalidParam => ffi::FMOD_ERR_INVALID_PARAM,
639 FmodResult::ErrInvalidPosition => ffi::FMOD_ERR_INVALID_POSITION,
640 FmodResult::ErrInvalidSpeaker => ffi::FMOD_ERR_INVALID_SPEAKER,
641 FmodResult::ErrInvalidSyncpoint => ffi::FMOD_ERR_INVALID_SYNCPOINT,
642 FmodResult::ErrInvalidThread => ffi::FMOD_ERR_INVALID_THREAD,
643 FmodResult::ErrInvalidVector => ffi::FMOD_ERR_INVALID_VECTOR,
644 FmodResult::ErrMaxaudible => ffi::FMOD_ERR_MAXAUDIBLE,
645 FmodResult::ErrMemory => ffi::FMOD_ERR_MEMORY,
646 FmodResult::ErrMemoryCantpoint => ffi::FMOD_ERR_MEMORY_CANTPOINT,
647 FmodResult::ErrNeeds3D => ffi::FMOD_ERR_NEEDS3D,
648 FmodResult::ErrNeedshardware => ffi::FMOD_ERR_NEEDSHARDWARE,
649 FmodResult::ErrNetConnect => ffi::FMOD_ERR_NET_CONNECT,
650 FmodResult::ErrNetSocketError => ffi::FMOD_ERR_NET_SOCKET_ERROR,
651 FmodResult::ErrNetUrl => ffi::FMOD_ERR_NET_URL,
652 FmodResult::ErrNetWouldBlock => ffi::FMOD_ERR_NET_WOULD_BLOCK,
653 FmodResult::ErrNotready => ffi::FMOD_ERR_NOTREADY,
654 FmodResult::ErrOutputAllocated => ffi::FMOD_ERR_OUTPUT_ALLOCATED,
655 FmodResult::ErrOutputCreatebuffer => ffi::FMOD_ERR_OUTPUT_CREATEBUFFER,
656 FmodResult::ErrOutputDrivercall => ffi::FMOD_ERR_OUTPUT_DRIVERCALL,
657 FmodResult::ErrOutputFormat => ffi::FMOD_ERR_OUTPUT_FORMAT,
658 FmodResult::ErrOutputInit => ffi::FMOD_ERR_OUTPUT_INIT,
659 FmodResult::ErrOutputNodrivers => ffi::FMOD_ERR_OUTPUT_NODRIVERS,
660 FmodResult::ErrPlugin => ffi::FMOD_ERR_PLUGIN,
661 FmodResult::ErrPluginMissing => ffi::FMOD_ERR_PLUGIN_MISSING,
662 FmodResult::ErrPluginResource => ffi::FMOD_ERR_PLUGIN_RESOURCE,
663 FmodResult::ErrPluginVersion => ffi::FMOD_ERR_PLUGIN_VERSION,
664 FmodResult::ErrRecord => ffi::FMOD_ERR_RECORD,
665 FmodResult::ErrReverbChannelgroup => ffi::FMOD_ERR_REVERB_CHANNELGROUP,
666 FmodResult::ErrReverbInstance => ffi::FMOD_ERR_REVERB_INSTANCE,
667 FmodResult::ErrSubsounds => ffi::FMOD_ERR_SUBSOUNDS,
668 FmodResult::ErrSubsoundAllocated => ffi::FMOD_ERR_SUBSOUND_ALLOCATED,
669 FmodResult::ErrSubsoundCantmove => ffi::FMOD_ERR_SUBSOUND_CANTMOVE,
670 FmodResult::ErrTagnotfound => ffi::FMOD_ERR_TAGNOTFOUND,
671 FmodResult::ErrToomanychannels => ffi::FMOD_ERR_TOOMANYCHANNELS,
672 FmodResult::ErrTruncated => ffi::FMOD_ERR_TRUNCATED,
673 FmodResult::ErrUnimplemented => ffi::FMOD_ERR_UNIMPLEMENTED,
674 FmodResult::ErrUninitialized => ffi::FMOD_ERR_UNINITIALIZED,
675 FmodResult::ErrUnsupported => ffi::FMOD_ERR_UNSUPPORTED,
676 FmodResult::ErrVersion => ffi::FMOD_ERR_VERSION,
677 FmodResult::ErrEventAlreadyLoaded => ffi::FMOD_ERR_EVENT_ALREADY_LOADED,
678 FmodResult::ErrEventLiveupdateBusy => ffi::FMOD_ERR_EVENT_LIVEUPDATE_BUSY,
679 FmodResult::ErrEventLiveupdateMismatch => ffi::FMOD_ERR_EVENT_LIVEUPDATE_MISMATCH,
680 FmodResult::ErrEventLiveupdateTimeout => ffi::FMOD_ERR_EVENT_LIVEUPDATE_TIMEOUT,
681 FmodResult::ErrEventNotfound => ffi::FMOD_ERR_EVENT_NOTFOUND,
682 FmodResult::ErrStudioUninitialized => ffi::FMOD_ERR_STUDIO_UNINITIALIZED,
683 FmodResult::ErrStudioNotLoaded => ffi::FMOD_ERR_STUDIO_NOT_LOADED,
684 FmodResult::ErrInvalidString => ffi::FMOD_ERR_INVALID_STRING,
685 FmodResult::ErrAlreadyLocked => ffi::FMOD_ERR_ALREADY_LOCKED,
686 FmodResult::ErrNotLocked => ffi::FMOD_ERR_NOT_LOCKED,
687 FmodResult::ErrRecordDisconnected => ffi::FMOD_ERR_RECORD_DISCONNECTED,
688 FmodResult::ErrToomanysamples => ffi::FMOD_ERR_TOOMANYSAMPLES,
689 }
690 }
691}
692impl FmodResult {
693 pub fn from(value: ffi::FMOD_RESULT) -> Result<FmodResult, Error> {
694 match value {
695 ffi::FMOD_OK => Ok(FmodResult::Ok),
696 ffi::FMOD_ERR_BADCOMMAND => Ok(FmodResult::ErrBadcommand),
697 ffi::FMOD_ERR_CHANNEL_ALLOC => Ok(FmodResult::ErrChannelAlloc),
698 ffi::FMOD_ERR_CHANNEL_STOLEN => Ok(FmodResult::ErrChannelStolen),
699 ffi::FMOD_ERR_DMA => Ok(FmodResult::ErrDma),
700 ffi::FMOD_ERR_DSP_CONNECTION => Ok(FmodResult::ErrDspConnection),
701 ffi::FMOD_ERR_DSP_DONTPROCESS => Ok(FmodResult::ErrDspDontprocess),
702 ffi::FMOD_ERR_DSP_FORMAT => Ok(FmodResult::ErrDspFormat),
703 ffi::FMOD_ERR_DSP_INUSE => Ok(FmodResult::ErrDspInuse),
704 ffi::FMOD_ERR_DSP_NOTFOUND => Ok(FmodResult::ErrDspNotfound),
705 ffi::FMOD_ERR_DSP_RESERVED => Ok(FmodResult::ErrDspReserved),
706 ffi::FMOD_ERR_DSP_SILENCE => Ok(FmodResult::ErrDspSilence),
707 ffi::FMOD_ERR_DSP_TYPE => Ok(FmodResult::ErrDspType),
708 ffi::FMOD_ERR_FILE_BAD => Ok(FmodResult::ErrFileBad),
709 ffi::FMOD_ERR_FILE_COULDNOTSEEK => Ok(FmodResult::ErrFileCouldnotseek),
710 ffi::FMOD_ERR_FILE_DISKEJECTED => Ok(FmodResult::ErrFileDiskejected),
711 ffi::FMOD_ERR_FILE_EOF => Ok(FmodResult::ErrFileEof),
712 ffi::FMOD_ERR_FILE_ENDOFDATA => Ok(FmodResult::ErrFileEndofdata),
713 ffi::FMOD_ERR_FILE_NOTFOUND => Ok(FmodResult::ErrFileNotfound),
714 ffi::FMOD_ERR_FORMAT => Ok(FmodResult::ErrFormat),
715 ffi::FMOD_ERR_HEADER_MISMATCH => Ok(FmodResult::ErrHeaderMismatch),
716 ffi::FMOD_ERR_HTTP => Ok(FmodResult::ErrHttp),
717 ffi::FMOD_ERR_HTTP_ACCESS => Ok(FmodResult::ErrHttpAccess),
718 ffi::FMOD_ERR_HTTP_PROXY_AUTH => Ok(FmodResult::ErrHttpProxyAuth),
719 ffi::FMOD_ERR_HTTP_SERVER_ERROR => Ok(FmodResult::ErrHttpServerError),
720 ffi::FMOD_ERR_HTTP_TIMEOUT => Ok(FmodResult::ErrHttpTimeout),
721 ffi::FMOD_ERR_INITIALIZATION => Ok(FmodResult::ErrInitialization),
722 ffi::FMOD_ERR_INITIALIZED => Ok(FmodResult::ErrInitialized),
723 ffi::FMOD_ERR_INTERNAL => Ok(FmodResult::ErrInternal),
724 ffi::FMOD_ERR_INVALID_FLOAT => Ok(FmodResult::ErrInvalidFloat),
725 ffi::FMOD_ERR_INVALID_HANDLE => Ok(FmodResult::ErrInvalidHandle),
726 ffi::FMOD_ERR_INVALID_PARAM => Ok(FmodResult::ErrInvalidParam),
727 ffi::FMOD_ERR_INVALID_POSITION => Ok(FmodResult::ErrInvalidPosition),
728 ffi::FMOD_ERR_INVALID_SPEAKER => Ok(FmodResult::ErrInvalidSpeaker),
729 ffi::FMOD_ERR_INVALID_SYNCPOINT => Ok(FmodResult::ErrInvalidSyncpoint),
730 ffi::FMOD_ERR_INVALID_THREAD => Ok(FmodResult::ErrInvalidThread),
731 ffi::FMOD_ERR_INVALID_VECTOR => Ok(FmodResult::ErrInvalidVector),
732 ffi::FMOD_ERR_MAXAUDIBLE => Ok(FmodResult::ErrMaxaudible),
733 ffi::FMOD_ERR_MEMORY => Ok(FmodResult::ErrMemory),
734 ffi::FMOD_ERR_MEMORY_CANTPOINT => Ok(FmodResult::ErrMemoryCantpoint),
735 ffi::FMOD_ERR_NEEDS3D => Ok(FmodResult::ErrNeeds3D),
736 ffi::FMOD_ERR_NEEDSHARDWARE => Ok(FmodResult::ErrNeedshardware),
737 ffi::FMOD_ERR_NET_CONNECT => Ok(FmodResult::ErrNetConnect),
738 ffi::FMOD_ERR_NET_SOCKET_ERROR => Ok(FmodResult::ErrNetSocketError),
739 ffi::FMOD_ERR_NET_URL => Ok(FmodResult::ErrNetUrl),
740 ffi::FMOD_ERR_NET_WOULD_BLOCK => Ok(FmodResult::ErrNetWouldBlock),
741 ffi::FMOD_ERR_NOTREADY => Ok(FmodResult::ErrNotready),
742 ffi::FMOD_ERR_OUTPUT_ALLOCATED => Ok(FmodResult::ErrOutputAllocated),
743 ffi::FMOD_ERR_OUTPUT_CREATEBUFFER => Ok(FmodResult::ErrOutputCreatebuffer),
744 ffi::FMOD_ERR_OUTPUT_DRIVERCALL => Ok(FmodResult::ErrOutputDrivercall),
745 ffi::FMOD_ERR_OUTPUT_FORMAT => Ok(FmodResult::ErrOutputFormat),
746 ffi::FMOD_ERR_OUTPUT_INIT => Ok(FmodResult::ErrOutputInit),
747 ffi::FMOD_ERR_OUTPUT_NODRIVERS => Ok(FmodResult::ErrOutputNodrivers),
748 ffi::FMOD_ERR_PLUGIN => Ok(FmodResult::ErrPlugin),
749 ffi::FMOD_ERR_PLUGIN_MISSING => Ok(FmodResult::ErrPluginMissing),
750 ffi::FMOD_ERR_PLUGIN_RESOURCE => Ok(FmodResult::ErrPluginResource),
751 ffi::FMOD_ERR_PLUGIN_VERSION => Ok(FmodResult::ErrPluginVersion),
752 ffi::FMOD_ERR_RECORD => Ok(FmodResult::ErrRecord),
753 ffi::FMOD_ERR_REVERB_CHANNELGROUP => Ok(FmodResult::ErrReverbChannelgroup),
754 ffi::FMOD_ERR_REVERB_INSTANCE => Ok(FmodResult::ErrReverbInstance),
755 ffi::FMOD_ERR_SUBSOUNDS => Ok(FmodResult::ErrSubsounds),
756 ffi::FMOD_ERR_SUBSOUND_ALLOCATED => Ok(FmodResult::ErrSubsoundAllocated),
757 ffi::FMOD_ERR_SUBSOUND_CANTMOVE => Ok(FmodResult::ErrSubsoundCantmove),
758 ffi::FMOD_ERR_TAGNOTFOUND => Ok(FmodResult::ErrTagnotfound),
759 ffi::FMOD_ERR_TOOMANYCHANNELS => Ok(FmodResult::ErrToomanychannels),
760 ffi::FMOD_ERR_TRUNCATED => Ok(FmodResult::ErrTruncated),
761 ffi::FMOD_ERR_UNIMPLEMENTED => Ok(FmodResult::ErrUnimplemented),
762 ffi::FMOD_ERR_UNINITIALIZED => Ok(FmodResult::ErrUninitialized),
763 ffi::FMOD_ERR_UNSUPPORTED => Ok(FmodResult::ErrUnsupported),
764 ffi::FMOD_ERR_VERSION => Ok(FmodResult::ErrVersion),
765 ffi::FMOD_ERR_EVENT_ALREADY_LOADED => Ok(FmodResult::ErrEventAlreadyLoaded),
766 ffi::FMOD_ERR_EVENT_LIVEUPDATE_BUSY => Ok(FmodResult::ErrEventLiveupdateBusy),
767 ffi::FMOD_ERR_EVENT_LIVEUPDATE_MISMATCH => Ok(FmodResult::ErrEventLiveupdateMismatch),
768 ffi::FMOD_ERR_EVENT_LIVEUPDATE_TIMEOUT => Ok(FmodResult::ErrEventLiveupdateTimeout),
769 ffi::FMOD_ERR_EVENT_NOTFOUND => Ok(FmodResult::ErrEventNotfound),
770 ffi::FMOD_ERR_STUDIO_UNINITIALIZED => Ok(FmodResult::ErrStudioUninitialized),
771 ffi::FMOD_ERR_STUDIO_NOT_LOADED => Ok(FmodResult::ErrStudioNotLoaded),
772 ffi::FMOD_ERR_INVALID_STRING => Ok(FmodResult::ErrInvalidString),
773 ffi::FMOD_ERR_ALREADY_LOCKED => Ok(FmodResult::ErrAlreadyLocked),
774 ffi::FMOD_ERR_NOT_LOCKED => Ok(FmodResult::ErrNotLocked),
775 ffi::FMOD_ERR_RECORD_DISCONNECTED => Ok(FmodResult::ErrRecordDisconnected),
776 ffi::FMOD_ERR_TOOMANYSAMPLES => Ok(FmodResult::ErrToomanysamples),
777 _ => Err(err_enum!("FMOD_RESULT", value)),
778 }
779 }
780}
781#[derive(Debug, Clone, Copy, PartialEq)]
782pub enum ChannelControlType {
783 Channel,
784 ChannelGroup,
785 Max,
786}
787impl From<ChannelControlType> for ffi::FMOD_CHANNELCONTROL_TYPE {
788 fn from(value: ChannelControlType) -> ffi::FMOD_CHANNELCONTROL_TYPE {
789 match value {
790 ChannelControlType::Channel => ffi::FMOD_CHANNELCONTROL_CHANNEL,
791 ChannelControlType::ChannelGroup => ffi::FMOD_CHANNELCONTROL_CHANNELGROUP,
792 ChannelControlType::Max => ffi::FMOD_CHANNELCONTROL_MAX,
793 }
794 }
795}
796impl ChannelControlType {
797 pub fn from(value: ffi::FMOD_CHANNELCONTROL_TYPE) -> Result<ChannelControlType, Error> {
798 match value {
799 ffi::FMOD_CHANNELCONTROL_CHANNEL => Ok(ChannelControlType::Channel),
800 ffi::FMOD_CHANNELCONTROL_CHANNELGROUP => Ok(ChannelControlType::ChannelGroup),
801 ffi::FMOD_CHANNELCONTROL_MAX => Ok(ChannelControlType::Max),
802 _ => Err(err_enum!("FMOD_CHANNELCONTROL_TYPE", value)),
803 }
804 }
805}
806#[derive(Debug, Clone, Copy, PartialEq)]
807pub enum OutputType {
808 Autodetect,
809 Unknown,
810 NoSound,
811 WavWriter,
812 NoSoundNrt,
813 WavWriterNrt,
814 Wasapi,
815 Asio,
816 PulseAudio,
817 Alsa,
818 CoreAudio,
819 AudioTrack,
820 OpenSL,
821 AudioOut,
822 Audio3D,
823 WebAudio,
824 NnAudio,
825 Winsonic,
826 AAudio,
827 AudioWorklet,
828 Phase,
829 Ohaudio,
830 Max,
831}
832impl From<OutputType> for ffi::FMOD_OUTPUTTYPE {
833 fn from(value: OutputType) -> ffi::FMOD_OUTPUTTYPE {
834 match value {
835 OutputType::Autodetect => ffi::FMOD_OUTPUTTYPE_AUTODETECT,
836 OutputType::Unknown => ffi::FMOD_OUTPUTTYPE_UNKNOWN,
837 OutputType::NoSound => ffi::FMOD_OUTPUTTYPE_NOSOUND,
838 OutputType::WavWriter => ffi::FMOD_OUTPUTTYPE_WAVWRITER,
839 OutputType::NoSoundNrt => ffi::FMOD_OUTPUTTYPE_NOSOUND_NRT,
840 OutputType::WavWriterNrt => ffi::FMOD_OUTPUTTYPE_WAVWRITER_NRT,
841 OutputType::Wasapi => ffi::FMOD_OUTPUTTYPE_WASAPI,
842 OutputType::Asio => ffi::FMOD_OUTPUTTYPE_ASIO,
843 OutputType::PulseAudio => ffi::FMOD_OUTPUTTYPE_PULSEAUDIO,
844 OutputType::Alsa => ffi::FMOD_OUTPUTTYPE_ALSA,
845 OutputType::CoreAudio => ffi::FMOD_OUTPUTTYPE_COREAUDIO,
846 OutputType::AudioTrack => ffi::FMOD_OUTPUTTYPE_AUDIOTRACK,
847 OutputType::OpenSL => ffi::FMOD_OUTPUTTYPE_OPENSL,
848 OutputType::AudioOut => ffi::FMOD_OUTPUTTYPE_AUDIOOUT,
849 OutputType::Audio3D => ffi::FMOD_OUTPUTTYPE_AUDIO3D,
850 OutputType::WebAudio => ffi::FMOD_OUTPUTTYPE_WEBAUDIO,
851 OutputType::NnAudio => ffi::FMOD_OUTPUTTYPE_NNAUDIO,
852 OutputType::Winsonic => ffi::FMOD_OUTPUTTYPE_WINSONIC,
853 OutputType::AAudio => ffi::FMOD_OUTPUTTYPE_AAUDIO,
854 OutputType::AudioWorklet => ffi::FMOD_OUTPUTTYPE_AUDIOWORKLET,
855 OutputType::Phase => ffi::FMOD_OUTPUTTYPE_PHASE,
856 OutputType::Ohaudio => ffi::FMOD_OUTPUTTYPE_OHAUDIO,
857 OutputType::Max => ffi::FMOD_OUTPUTTYPE_MAX,
858 }
859 }
860}
861impl OutputType {
862 pub fn from(value: ffi::FMOD_OUTPUTTYPE) -> Result<OutputType, Error> {
863 match value {
864 ffi::FMOD_OUTPUTTYPE_AUTODETECT => Ok(OutputType::Autodetect),
865 ffi::FMOD_OUTPUTTYPE_UNKNOWN => Ok(OutputType::Unknown),
866 ffi::FMOD_OUTPUTTYPE_NOSOUND => Ok(OutputType::NoSound),
867 ffi::FMOD_OUTPUTTYPE_WAVWRITER => Ok(OutputType::WavWriter),
868 ffi::FMOD_OUTPUTTYPE_NOSOUND_NRT => Ok(OutputType::NoSoundNrt),
869 ffi::FMOD_OUTPUTTYPE_WAVWRITER_NRT => Ok(OutputType::WavWriterNrt),
870 ffi::FMOD_OUTPUTTYPE_WASAPI => Ok(OutputType::Wasapi),
871 ffi::FMOD_OUTPUTTYPE_ASIO => Ok(OutputType::Asio),
872 ffi::FMOD_OUTPUTTYPE_PULSEAUDIO => Ok(OutputType::PulseAudio),
873 ffi::FMOD_OUTPUTTYPE_ALSA => Ok(OutputType::Alsa),
874 ffi::FMOD_OUTPUTTYPE_COREAUDIO => Ok(OutputType::CoreAudio),
875 ffi::FMOD_OUTPUTTYPE_AUDIOTRACK => Ok(OutputType::AudioTrack),
876 ffi::FMOD_OUTPUTTYPE_OPENSL => Ok(OutputType::OpenSL),
877 ffi::FMOD_OUTPUTTYPE_AUDIOOUT => Ok(OutputType::AudioOut),
878 ffi::FMOD_OUTPUTTYPE_AUDIO3D => Ok(OutputType::Audio3D),
879 ffi::FMOD_OUTPUTTYPE_WEBAUDIO => Ok(OutputType::WebAudio),
880 ffi::FMOD_OUTPUTTYPE_NNAUDIO => Ok(OutputType::NnAudio),
881 ffi::FMOD_OUTPUTTYPE_WINSONIC => Ok(OutputType::Winsonic),
882 ffi::FMOD_OUTPUTTYPE_AAUDIO => Ok(OutputType::AAudio),
883 ffi::FMOD_OUTPUTTYPE_AUDIOWORKLET => Ok(OutputType::AudioWorklet),
884 ffi::FMOD_OUTPUTTYPE_PHASE => Ok(OutputType::Phase),
885 ffi::FMOD_OUTPUTTYPE_OHAUDIO => Ok(OutputType::Ohaudio),
886 ffi::FMOD_OUTPUTTYPE_MAX => Ok(OutputType::Max),
887 _ => Err(err_enum!("FMOD_OUTPUTTYPE", value)),
888 }
889 }
890}
891#[derive(Debug, Clone, Copy, PartialEq)]
892pub enum DebugMode {
893 Tty,
894 File,
895 Callback,
896}
897impl From<DebugMode> for ffi::FMOD_DEBUG_MODE {
898 fn from(value: DebugMode) -> ffi::FMOD_DEBUG_MODE {
899 match value {
900 DebugMode::Tty => ffi::FMOD_DEBUG_MODE_TTY,
901 DebugMode::File => ffi::FMOD_DEBUG_MODE_FILE,
902 DebugMode::Callback => ffi::FMOD_DEBUG_MODE_CALLBACK,
903 }
904 }
905}
906impl DebugMode {
907 pub fn from(value: ffi::FMOD_DEBUG_MODE) -> Result<DebugMode, Error> {
908 match value {
909 ffi::FMOD_DEBUG_MODE_TTY => Ok(DebugMode::Tty),
910 ffi::FMOD_DEBUG_MODE_FILE => Ok(DebugMode::File),
911 ffi::FMOD_DEBUG_MODE_CALLBACK => Ok(DebugMode::Callback),
912 _ => Err(err_enum!("FMOD_DEBUG_MODE", value)),
913 }
914 }
915}
916#[derive(Debug, Clone, Copy, PartialEq)]
917pub enum SpeakerMode {
918 Default,
919 Raw,
920 Mono,
921 Stereo,
922 Quad,
923 Surround,
924 Mode5Point1,
925 Mode7Point1,
926 Mode7Point1Point4,
927 Max,
928}
929impl From<SpeakerMode> for ffi::FMOD_SPEAKERMODE {
930 fn from(value: SpeakerMode) -> ffi::FMOD_SPEAKERMODE {
931 match value {
932 SpeakerMode::Default => ffi::FMOD_SPEAKERMODE_DEFAULT,
933 SpeakerMode::Raw => ffi::FMOD_SPEAKERMODE_RAW,
934 SpeakerMode::Mono => ffi::FMOD_SPEAKERMODE_MONO,
935 SpeakerMode::Stereo => ffi::FMOD_SPEAKERMODE_STEREO,
936 SpeakerMode::Quad => ffi::FMOD_SPEAKERMODE_QUAD,
937 SpeakerMode::Surround => ffi::FMOD_SPEAKERMODE_SURROUND,
938 SpeakerMode::Mode5Point1 => ffi::FMOD_SPEAKERMODE_5POINT1,
939 SpeakerMode::Mode7Point1 => ffi::FMOD_SPEAKERMODE_7POINT1,
940 SpeakerMode::Mode7Point1Point4 => ffi::FMOD_SPEAKERMODE_7POINT1POINT4,
941 SpeakerMode::Max => ffi::FMOD_SPEAKERMODE_MAX,
942 }
943 }
944}
945impl SpeakerMode {
946 pub fn from(value: ffi::FMOD_SPEAKERMODE) -> Result<SpeakerMode, Error> {
947 match value {
948 ffi::FMOD_SPEAKERMODE_DEFAULT => Ok(SpeakerMode::Default),
949 ffi::FMOD_SPEAKERMODE_RAW => Ok(SpeakerMode::Raw),
950 ffi::FMOD_SPEAKERMODE_MONO => Ok(SpeakerMode::Mono),
951 ffi::FMOD_SPEAKERMODE_STEREO => Ok(SpeakerMode::Stereo),
952 ffi::FMOD_SPEAKERMODE_QUAD => Ok(SpeakerMode::Quad),
953 ffi::FMOD_SPEAKERMODE_SURROUND => Ok(SpeakerMode::Surround),
954 ffi::FMOD_SPEAKERMODE_5POINT1 => Ok(SpeakerMode::Mode5Point1),
955 ffi::FMOD_SPEAKERMODE_7POINT1 => Ok(SpeakerMode::Mode7Point1),
956 ffi::FMOD_SPEAKERMODE_7POINT1POINT4 => Ok(SpeakerMode::Mode7Point1Point4),
957 ffi::FMOD_SPEAKERMODE_MAX => Ok(SpeakerMode::Max),
958 _ => Err(err_enum!("FMOD_SPEAKERMODE", value)),
959 }
960 }
961}
962#[derive(Debug, Clone, Copy, PartialEq)]
963pub enum Speaker {
964 None,
965 FrontLeft,
966 FrontRight,
967 FrontCenter,
968 LowFrequency,
969 SurroundLeft,
970 SurroundRight,
971 BackLeft,
972 BackRight,
973 TopFrontLeft,
974 TopFrontRight,
975 TopBackLeft,
976 TopBackRight,
977 Max,
978}
979impl From<Speaker> for ffi::FMOD_SPEAKER {
980 fn from(value: Speaker) -> ffi::FMOD_SPEAKER {
981 match value {
982 Speaker::None => ffi::FMOD_SPEAKER_NONE,
983 Speaker::FrontLeft => ffi::FMOD_SPEAKER_FRONT_LEFT,
984 Speaker::FrontRight => ffi::FMOD_SPEAKER_FRONT_RIGHT,
985 Speaker::FrontCenter => ffi::FMOD_SPEAKER_FRONT_CENTER,
986 Speaker::LowFrequency => ffi::FMOD_SPEAKER_LOW_FREQUENCY,
987 Speaker::SurroundLeft => ffi::FMOD_SPEAKER_SURROUND_LEFT,
988 Speaker::SurroundRight => ffi::FMOD_SPEAKER_SURROUND_RIGHT,
989 Speaker::BackLeft => ffi::FMOD_SPEAKER_BACK_LEFT,
990 Speaker::BackRight => ffi::FMOD_SPEAKER_BACK_RIGHT,
991 Speaker::TopFrontLeft => ffi::FMOD_SPEAKER_TOP_FRONT_LEFT,
992 Speaker::TopFrontRight => ffi::FMOD_SPEAKER_TOP_FRONT_RIGHT,
993 Speaker::TopBackLeft => ffi::FMOD_SPEAKER_TOP_BACK_LEFT,
994 Speaker::TopBackRight => ffi::FMOD_SPEAKER_TOP_BACK_RIGHT,
995 Speaker::Max => ffi::FMOD_SPEAKER_MAX,
996 }
997 }
998}
999impl Speaker {
1000 pub fn from(value: ffi::FMOD_SPEAKER) -> Result<Speaker, Error> {
1001 match value {
1002 ffi::FMOD_SPEAKER_NONE => Ok(Speaker::None),
1003 ffi::FMOD_SPEAKER_FRONT_LEFT => Ok(Speaker::FrontLeft),
1004 ffi::FMOD_SPEAKER_FRONT_RIGHT => Ok(Speaker::FrontRight),
1005 ffi::FMOD_SPEAKER_FRONT_CENTER => Ok(Speaker::FrontCenter),
1006 ffi::FMOD_SPEAKER_LOW_FREQUENCY => Ok(Speaker::LowFrequency),
1007 ffi::FMOD_SPEAKER_SURROUND_LEFT => Ok(Speaker::SurroundLeft),
1008 ffi::FMOD_SPEAKER_SURROUND_RIGHT => Ok(Speaker::SurroundRight),
1009 ffi::FMOD_SPEAKER_BACK_LEFT => Ok(Speaker::BackLeft),
1010 ffi::FMOD_SPEAKER_BACK_RIGHT => Ok(Speaker::BackRight),
1011 ffi::FMOD_SPEAKER_TOP_FRONT_LEFT => Ok(Speaker::TopFrontLeft),
1012 ffi::FMOD_SPEAKER_TOP_FRONT_RIGHT => Ok(Speaker::TopFrontRight),
1013 ffi::FMOD_SPEAKER_TOP_BACK_LEFT => Ok(Speaker::TopBackLeft),
1014 ffi::FMOD_SPEAKER_TOP_BACK_RIGHT => Ok(Speaker::TopBackRight),
1015 ffi::FMOD_SPEAKER_MAX => Ok(Speaker::Max),
1016 _ => Err(err_enum!("FMOD_SPEAKER", value)),
1017 }
1018 }
1019}
1020#[derive(Debug, Clone, Copy, PartialEq)]
1021pub enum ChannelOrder {
1022 Default,
1023 WaveFormat,
1024 ProTools,
1025 AllMono,
1026 AllStereo,
1027 Alsa,
1028 Max,
1029}
1030impl From<ChannelOrder> for ffi::FMOD_CHANNELORDER {
1031 fn from(value: ChannelOrder) -> ffi::FMOD_CHANNELORDER {
1032 match value {
1033 ChannelOrder::Default => ffi::FMOD_CHANNELORDER_DEFAULT,
1034 ChannelOrder::WaveFormat => ffi::FMOD_CHANNELORDER_WAVEFORMAT,
1035 ChannelOrder::ProTools => ffi::FMOD_CHANNELORDER_PROTOOLS,
1036 ChannelOrder::AllMono => ffi::FMOD_CHANNELORDER_ALLMONO,
1037 ChannelOrder::AllStereo => ffi::FMOD_CHANNELORDER_ALLSTEREO,
1038 ChannelOrder::Alsa => ffi::FMOD_CHANNELORDER_ALSA,
1039 ChannelOrder::Max => ffi::FMOD_CHANNELORDER_MAX,
1040 }
1041 }
1042}
1043impl ChannelOrder {
1044 pub fn from(value: ffi::FMOD_CHANNELORDER) -> Result<ChannelOrder, Error> {
1045 match value {
1046 ffi::FMOD_CHANNELORDER_DEFAULT => Ok(ChannelOrder::Default),
1047 ffi::FMOD_CHANNELORDER_WAVEFORMAT => Ok(ChannelOrder::WaveFormat),
1048 ffi::FMOD_CHANNELORDER_PROTOOLS => Ok(ChannelOrder::ProTools),
1049 ffi::FMOD_CHANNELORDER_ALLMONO => Ok(ChannelOrder::AllMono),
1050 ffi::FMOD_CHANNELORDER_ALLSTEREO => Ok(ChannelOrder::AllStereo),
1051 ffi::FMOD_CHANNELORDER_ALSA => Ok(ChannelOrder::Alsa),
1052 ffi::FMOD_CHANNELORDER_MAX => Ok(ChannelOrder::Max),
1053 _ => Err(err_enum!("FMOD_CHANNELORDER", value)),
1054 }
1055 }
1056}
1057#[derive(Debug, Clone, Copy, PartialEq)]
1058pub enum PluginType {
1059 Output,
1060 Codec,
1061 Dsp,
1062 Max,
1063}
1064impl From<PluginType> for ffi::FMOD_PLUGINTYPE {
1065 fn from(value: PluginType) -> ffi::FMOD_PLUGINTYPE {
1066 match value {
1067 PluginType::Output => ffi::FMOD_PLUGINTYPE_OUTPUT,
1068 PluginType::Codec => ffi::FMOD_PLUGINTYPE_CODEC,
1069 PluginType::Dsp => ffi::FMOD_PLUGINTYPE_DSP,
1070 PluginType::Max => ffi::FMOD_PLUGINTYPE_MAX,
1071 }
1072 }
1073}
1074impl PluginType {
1075 pub fn from(value: ffi::FMOD_PLUGINTYPE) -> Result<PluginType, Error> {
1076 match value {
1077 ffi::FMOD_PLUGINTYPE_OUTPUT => Ok(PluginType::Output),
1078 ffi::FMOD_PLUGINTYPE_CODEC => Ok(PluginType::Codec),
1079 ffi::FMOD_PLUGINTYPE_DSP => Ok(PluginType::Dsp),
1080 ffi::FMOD_PLUGINTYPE_MAX => Ok(PluginType::Max),
1081 _ => Err(err_enum!("FMOD_PLUGINTYPE", value)),
1082 }
1083 }
1084}
1085#[derive(Debug, Clone, Copy, PartialEq)]
1086pub enum SoundType {
1087 Unknown,
1088 Aiff,
1089 Asf,
1090 Dls,
1091 Flac,
1092 Fsb,
1093 It,
1094 Midi,
1095 Mod,
1096 Mpeg,
1097 OggVorbis,
1098 Playlist,
1099 Raw,
1100 S3M,
1101 User,
1102 Wav,
1103 Xm,
1104 Xma,
1105 AudioQueue,
1106 At9,
1107 Vorbis,
1108 MediaFoundation,
1109 Mediacodec,
1110 Fadpcm,
1111 Opus,
1112 Max,
1113}
1114impl From<SoundType> for ffi::FMOD_SOUND_TYPE {
1115 fn from(value: SoundType) -> ffi::FMOD_SOUND_TYPE {
1116 match value {
1117 SoundType::Unknown => ffi::FMOD_SOUND_TYPE_UNKNOWN,
1118 SoundType::Aiff => ffi::FMOD_SOUND_TYPE_AIFF,
1119 SoundType::Asf => ffi::FMOD_SOUND_TYPE_ASF,
1120 SoundType::Dls => ffi::FMOD_SOUND_TYPE_DLS,
1121 SoundType::Flac => ffi::FMOD_SOUND_TYPE_FLAC,
1122 SoundType::Fsb => ffi::FMOD_SOUND_TYPE_FSB,
1123 SoundType::It => ffi::FMOD_SOUND_TYPE_IT,
1124 SoundType::Midi => ffi::FMOD_SOUND_TYPE_MIDI,
1125 SoundType::Mod => ffi::FMOD_SOUND_TYPE_MOD,
1126 SoundType::Mpeg => ffi::FMOD_SOUND_TYPE_MPEG,
1127 SoundType::OggVorbis => ffi::FMOD_SOUND_TYPE_OGGVORBIS,
1128 SoundType::Playlist => ffi::FMOD_SOUND_TYPE_PLAYLIST,
1129 SoundType::Raw => ffi::FMOD_SOUND_TYPE_RAW,
1130 SoundType::S3M => ffi::FMOD_SOUND_TYPE_S3M,
1131 SoundType::User => ffi::FMOD_SOUND_TYPE_USER,
1132 SoundType::Wav => ffi::FMOD_SOUND_TYPE_WAV,
1133 SoundType::Xm => ffi::FMOD_SOUND_TYPE_XM,
1134 SoundType::Xma => ffi::FMOD_SOUND_TYPE_XMA,
1135 SoundType::AudioQueue => ffi::FMOD_SOUND_TYPE_AUDIOQUEUE,
1136 SoundType::At9 => ffi::FMOD_SOUND_TYPE_AT9,
1137 SoundType::Vorbis => ffi::FMOD_SOUND_TYPE_VORBIS,
1138 SoundType::MediaFoundation => ffi::FMOD_SOUND_TYPE_MEDIA_FOUNDATION,
1139 SoundType::Mediacodec => ffi::FMOD_SOUND_TYPE_MEDIACODEC,
1140 SoundType::Fadpcm => ffi::FMOD_SOUND_TYPE_FADPCM,
1141 SoundType::Opus => ffi::FMOD_SOUND_TYPE_OPUS,
1142 SoundType::Max => ffi::FMOD_SOUND_TYPE_MAX,
1143 }
1144 }
1145}
1146impl SoundType {
1147 pub fn from(value: ffi::FMOD_SOUND_TYPE) -> Result<SoundType, Error> {
1148 match value {
1149 ffi::FMOD_SOUND_TYPE_UNKNOWN => Ok(SoundType::Unknown),
1150 ffi::FMOD_SOUND_TYPE_AIFF => Ok(SoundType::Aiff),
1151 ffi::FMOD_SOUND_TYPE_ASF => Ok(SoundType::Asf),
1152 ffi::FMOD_SOUND_TYPE_DLS => Ok(SoundType::Dls),
1153 ffi::FMOD_SOUND_TYPE_FLAC => Ok(SoundType::Flac),
1154 ffi::FMOD_SOUND_TYPE_FSB => Ok(SoundType::Fsb),
1155 ffi::FMOD_SOUND_TYPE_IT => Ok(SoundType::It),
1156 ffi::FMOD_SOUND_TYPE_MIDI => Ok(SoundType::Midi),
1157 ffi::FMOD_SOUND_TYPE_MOD => Ok(SoundType::Mod),
1158 ffi::FMOD_SOUND_TYPE_MPEG => Ok(SoundType::Mpeg),
1159 ffi::FMOD_SOUND_TYPE_OGGVORBIS => Ok(SoundType::OggVorbis),
1160 ffi::FMOD_SOUND_TYPE_PLAYLIST => Ok(SoundType::Playlist),
1161 ffi::FMOD_SOUND_TYPE_RAW => Ok(SoundType::Raw),
1162 ffi::FMOD_SOUND_TYPE_S3M => Ok(SoundType::S3M),
1163 ffi::FMOD_SOUND_TYPE_USER => Ok(SoundType::User),
1164 ffi::FMOD_SOUND_TYPE_WAV => Ok(SoundType::Wav),
1165 ffi::FMOD_SOUND_TYPE_XM => Ok(SoundType::Xm),
1166 ffi::FMOD_SOUND_TYPE_XMA => Ok(SoundType::Xma),
1167 ffi::FMOD_SOUND_TYPE_AUDIOQUEUE => Ok(SoundType::AudioQueue),
1168 ffi::FMOD_SOUND_TYPE_AT9 => Ok(SoundType::At9),
1169 ffi::FMOD_SOUND_TYPE_VORBIS => Ok(SoundType::Vorbis),
1170 ffi::FMOD_SOUND_TYPE_MEDIA_FOUNDATION => Ok(SoundType::MediaFoundation),
1171 ffi::FMOD_SOUND_TYPE_MEDIACODEC => Ok(SoundType::Mediacodec),
1172 ffi::FMOD_SOUND_TYPE_FADPCM => Ok(SoundType::Fadpcm),
1173 ffi::FMOD_SOUND_TYPE_OPUS => Ok(SoundType::Opus),
1174 ffi::FMOD_SOUND_TYPE_MAX => Ok(SoundType::Max),
1175 _ => Err(err_enum!("FMOD_SOUND_TYPE", value)),
1176 }
1177 }
1178}
1179#[derive(Debug, Clone, Copy, PartialEq)]
1180pub enum SoundFormat {
1181 None,
1182 Pcm8,
1183 Pcm16,
1184 Pcm24,
1185 Pcm32,
1186 PcmFloat,
1187 Bitstream,
1188 Max,
1189}
1190impl From<SoundFormat> for ffi::FMOD_SOUND_FORMAT {
1191 fn from(value: SoundFormat) -> ffi::FMOD_SOUND_FORMAT {
1192 match value {
1193 SoundFormat::None => ffi::FMOD_SOUND_FORMAT_NONE,
1194 SoundFormat::Pcm8 => ffi::FMOD_SOUND_FORMAT_PCM8,
1195 SoundFormat::Pcm16 => ffi::FMOD_SOUND_FORMAT_PCM16,
1196 SoundFormat::Pcm24 => ffi::FMOD_SOUND_FORMAT_PCM24,
1197 SoundFormat::Pcm32 => ffi::FMOD_SOUND_FORMAT_PCM32,
1198 SoundFormat::PcmFloat => ffi::FMOD_SOUND_FORMAT_PCMFLOAT,
1199 SoundFormat::Bitstream => ffi::FMOD_SOUND_FORMAT_BITSTREAM,
1200 SoundFormat::Max => ffi::FMOD_SOUND_FORMAT_MAX,
1201 }
1202 }
1203}
1204impl SoundFormat {
1205 pub fn from(value: ffi::FMOD_SOUND_FORMAT) -> Result<SoundFormat, Error> {
1206 match value {
1207 ffi::FMOD_SOUND_FORMAT_NONE => Ok(SoundFormat::None),
1208 ffi::FMOD_SOUND_FORMAT_PCM8 => Ok(SoundFormat::Pcm8),
1209 ffi::FMOD_SOUND_FORMAT_PCM16 => Ok(SoundFormat::Pcm16),
1210 ffi::FMOD_SOUND_FORMAT_PCM24 => Ok(SoundFormat::Pcm24),
1211 ffi::FMOD_SOUND_FORMAT_PCM32 => Ok(SoundFormat::Pcm32),
1212 ffi::FMOD_SOUND_FORMAT_PCMFLOAT => Ok(SoundFormat::PcmFloat),
1213 ffi::FMOD_SOUND_FORMAT_BITSTREAM => Ok(SoundFormat::Bitstream),
1214 ffi::FMOD_SOUND_FORMAT_MAX => Ok(SoundFormat::Max),
1215 _ => Err(err_enum!("FMOD_SOUND_FORMAT", value)),
1216 }
1217 }
1218}
1219#[derive(Debug, Clone, Copy, PartialEq)]
1220pub enum OpenState {
1221 Ready,
1222 Loading,
1223 Error,
1224 Connecting,
1225 Buffering,
1226 Seeking,
1227 Playing,
1228 SetPosition,
1229 Max,
1230}
1231impl From<OpenState> for ffi::FMOD_OPENSTATE {
1232 fn from(value: OpenState) -> ffi::FMOD_OPENSTATE {
1233 match value {
1234 OpenState::Ready => ffi::FMOD_OPENSTATE_READY,
1235 OpenState::Loading => ffi::FMOD_OPENSTATE_LOADING,
1236 OpenState::Error => ffi::FMOD_OPENSTATE_ERROR,
1237 OpenState::Connecting => ffi::FMOD_OPENSTATE_CONNECTING,
1238 OpenState::Buffering => ffi::FMOD_OPENSTATE_BUFFERING,
1239 OpenState::Seeking => ffi::FMOD_OPENSTATE_SEEKING,
1240 OpenState::Playing => ffi::FMOD_OPENSTATE_PLAYING,
1241 OpenState::SetPosition => ffi::FMOD_OPENSTATE_SETPOSITION,
1242 OpenState::Max => ffi::FMOD_OPENSTATE_MAX,
1243 }
1244 }
1245}
1246impl OpenState {
1247 pub fn from(value: ffi::FMOD_OPENSTATE) -> Result<OpenState, Error> {
1248 match value {
1249 ffi::FMOD_OPENSTATE_READY => Ok(OpenState::Ready),
1250 ffi::FMOD_OPENSTATE_LOADING => Ok(OpenState::Loading),
1251 ffi::FMOD_OPENSTATE_ERROR => Ok(OpenState::Error),
1252 ffi::FMOD_OPENSTATE_CONNECTING => Ok(OpenState::Connecting),
1253 ffi::FMOD_OPENSTATE_BUFFERING => Ok(OpenState::Buffering),
1254 ffi::FMOD_OPENSTATE_SEEKING => Ok(OpenState::Seeking),
1255 ffi::FMOD_OPENSTATE_PLAYING => Ok(OpenState::Playing),
1256 ffi::FMOD_OPENSTATE_SETPOSITION => Ok(OpenState::SetPosition),
1257 ffi::FMOD_OPENSTATE_MAX => Ok(OpenState::Max),
1258 _ => Err(err_enum!("FMOD_OPENSTATE", value)),
1259 }
1260 }
1261}
1262#[derive(Debug, Clone, Copy, PartialEq)]
1263pub enum SoundGroupBehavior {
1264 Fail,
1265 Mute,
1266 StealLowest,
1267 Max,
1268}
1269impl From<SoundGroupBehavior> for ffi::FMOD_SOUNDGROUP_BEHAVIOR {
1270 fn from(value: SoundGroupBehavior) -> ffi::FMOD_SOUNDGROUP_BEHAVIOR {
1271 match value {
1272 SoundGroupBehavior::Fail => ffi::FMOD_SOUNDGROUP_BEHAVIOR_FAIL,
1273 SoundGroupBehavior::Mute => ffi::FMOD_SOUNDGROUP_BEHAVIOR_MUTE,
1274 SoundGroupBehavior::StealLowest => ffi::FMOD_SOUNDGROUP_BEHAVIOR_STEALLOWEST,
1275 SoundGroupBehavior::Max => ffi::FMOD_SOUNDGROUP_BEHAVIOR_MAX,
1276 }
1277 }
1278}
1279impl SoundGroupBehavior {
1280 pub fn from(value: ffi::FMOD_SOUNDGROUP_BEHAVIOR) -> Result<SoundGroupBehavior, Error> {
1281 match value {
1282 ffi::FMOD_SOUNDGROUP_BEHAVIOR_FAIL => Ok(SoundGroupBehavior::Fail),
1283 ffi::FMOD_SOUNDGROUP_BEHAVIOR_MUTE => Ok(SoundGroupBehavior::Mute),
1284 ffi::FMOD_SOUNDGROUP_BEHAVIOR_STEALLOWEST => Ok(SoundGroupBehavior::StealLowest),
1285 ffi::FMOD_SOUNDGROUP_BEHAVIOR_MAX => Ok(SoundGroupBehavior::Max),
1286 _ => Err(err_enum!("FMOD_SOUNDGROUP_BEHAVIOR", value)),
1287 }
1288 }
1289}
1290#[derive(Debug, Clone, Copy, PartialEq)]
1291pub enum ChannelControlCallbackType {
1292 End,
1293 VirtualVoice,
1294 SyncPoint,
1295 Occlusion,
1296 Max,
1297}
1298impl From<ChannelControlCallbackType> for ffi::FMOD_CHANNELCONTROL_CALLBACK_TYPE {
1299 fn from(value: ChannelControlCallbackType) -> ffi::FMOD_CHANNELCONTROL_CALLBACK_TYPE {
1300 match value {
1301 ChannelControlCallbackType::End => ffi::FMOD_CHANNELCONTROL_CALLBACK_END,
1302 ChannelControlCallbackType::VirtualVoice => {
1303 ffi::FMOD_CHANNELCONTROL_CALLBACK_VIRTUALVOICE
1304 }
1305 ChannelControlCallbackType::SyncPoint => ffi::FMOD_CHANNELCONTROL_CALLBACK_SYNCPOINT,
1306 ChannelControlCallbackType::Occlusion => ffi::FMOD_CHANNELCONTROL_CALLBACK_OCCLUSION,
1307 ChannelControlCallbackType::Max => ffi::FMOD_CHANNELCONTROL_CALLBACK_MAX,
1308 }
1309 }
1310}
1311impl ChannelControlCallbackType {
1312 pub fn from(
1313 value: ffi::FMOD_CHANNELCONTROL_CALLBACK_TYPE,
1314 ) -> Result<ChannelControlCallbackType, Error> {
1315 match value {
1316 ffi::FMOD_CHANNELCONTROL_CALLBACK_END => Ok(ChannelControlCallbackType::End),
1317 ffi::FMOD_CHANNELCONTROL_CALLBACK_VIRTUALVOICE => {
1318 Ok(ChannelControlCallbackType::VirtualVoice)
1319 }
1320 ffi::FMOD_CHANNELCONTROL_CALLBACK_SYNCPOINT => {
1321 Ok(ChannelControlCallbackType::SyncPoint)
1322 }
1323 ffi::FMOD_CHANNELCONTROL_CALLBACK_OCCLUSION => {
1324 Ok(ChannelControlCallbackType::Occlusion)
1325 }
1326 ffi::FMOD_CHANNELCONTROL_CALLBACK_MAX => Ok(ChannelControlCallbackType::Max),
1327 _ => Err(err_enum!("FMOD_CHANNELCONTROL_CALLBACK_TYPE", value)),
1328 }
1329 }
1330}
1331#[derive(Debug, Clone, Copy, PartialEq)]
1332pub enum ChannelControlDspIndex {
1333 Head,
1334 Fader,
1335 Tail,
1336}
1337impl From<ChannelControlDspIndex> for ffi::FMOD_CHANNELCONTROL_DSP_INDEX {
1338 fn from(value: ChannelControlDspIndex) -> ffi::FMOD_CHANNELCONTROL_DSP_INDEX {
1339 match value {
1340 ChannelControlDspIndex::Head => ffi::FMOD_CHANNELCONTROL_DSP_HEAD,
1341 ChannelControlDspIndex::Fader => ffi::FMOD_CHANNELCONTROL_DSP_FADER,
1342 ChannelControlDspIndex::Tail => ffi::FMOD_CHANNELCONTROL_DSP_TAIL,
1343 }
1344 }
1345}
1346impl ChannelControlDspIndex {
1347 pub fn from(
1348 value: ffi::FMOD_CHANNELCONTROL_DSP_INDEX,
1349 ) -> Result<ChannelControlDspIndex, Error> {
1350 match value {
1351 ffi::FMOD_CHANNELCONTROL_DSP_HEAD => Ok(ChannelControlDspIndex::Head),
1352 ffi::FMOD_CHANNELCONTROL_DSP_FADER => Ok(ChannelControlDspIndex::Fader),
1353 ffi::FMOD_CHANNELCONTROL_DSP_TAIL => Ok(ChannelControlDspIndex::Tail),
1354 _ => Err(err_enum!("FMOD_CHANNELCONTROL_DSP_INDEX", value)),
1355 }
1356 }
1357}
1358#[derive(Debug, Clone, Copy, PartialEq)]
1359pub enum ErrorCallbackInstancetype {
1360 None,
1361 System,
1362 Channel,
1363 ChannelGroup,
1364 ChannelControl,
1365 Sound,
1366 SoundGroup,
1367 Dsp,
1368 DspConnection,
1369 Geometry,
1370 Reverb3d,
1371 Studio,
1372 EventDescription,
1373 EventInstance,
1374 ParameterInstance,
1375 Bus,
1376 Vca,
1377 Bank,
1378 CommandReplay,
1379}
1380impl From<ErrorCallbackInstancetype> for ffi::FMOD_ERRORCALLBACK_INSTANCETYPE {
1381 fn from(value: ErrorCallbackInstancetype) -> ffi::FMOD_ERRORCALLBACK_INSTANCETYPE {
1382 match value {
1383 ErrorCallbackInstancetype::None => ffi::FMOD_ERRORCALLBACK_INSTANCETYPE_NONE,
1384 ErrorCallbackInstancetype::System => ffi::FMOD_ERRORCALLBACK_INSTANCETYPE_SYSTEM,
1385 ErrorCallbackInstancetype::Channel => ffi::FMOD_ERRORCALLBACK_INSTANCETYPE_CHANNEL,
1386 ErrorCallbackInstancetype::ChannelGroup => {
1387 ffi::FMOD_ERRORCALLBACK_INSTANCETYPE_CHANNELGROUP
1388 }
1389 ErrorCallbackInstancetype::ChannelControl => {
1390 ffi::FMOD_ERRORCALLBACK_INSTANCETYPE_CHANNELCONTROL
1391 }
1392 ErrorCallbackInstancetype::Sound => ffi::FMOD_ERRORCALLBACK_INSTANCETYPE_SOUND,
1393 ErrorCallbackInstancetype::SoundGroup => {
1394 ffi::FMOD_ERRORCALLBACK_INSTANCETYPE_SOUNDGROUP
1395 }
1396 ErrorCallbackInstancetype::Dsp => ffi::FMOD_ERRORCALLBACK_INSTANCETYPE_DSP,
1397 ErrorCallbackInstancetype::DspConnection => {
1398 ffi::FMOD_ERRORCALLBACK_INSTANCETYPE_DSPCONNECTION
1399 }
1400 ErrorCallbackInstancetype::Geometry => ffi::FMOD_ERRORCALLBACK_INSTANCETYPE_GEOMETRY,
1401 ErrorCallbackInstancetype::Reverb3d => ffi::FMOD_ERRORCALLBACK_INSTANCETYPE_REVERB3D,
1402 ErrorCallbackInstancetype::Studio => ffi::FMOD_ERRORCALLBACK_INSTANCETYPE_STUDIO_SYSTEM,
1403 ErrorCallbackInstancetype::EventDescription => {
1404 ffi::FMOD_ERRORCALLBACK_INSTANCETYPE_STUDIO_EVENTDESCRIPTION
1405 }
1406 ErrorCallbackInstancetype::EventInstance => {
1407 ffi::FMOD_ERRORCALLBACK_INSTANCETYPE_STUDIO_EVENTINSTANCE
1408 }
1409 ErrorCallbackInstancetype::ParameterInstance => {
1410 ffi::FMOD_ERRORCALLBACK_INSTANCETYPE_STUDIO_PARAMETERINSTANCE
1411 }
1412 ErrorCallbackInstancetype::Bus => ffi::FMOD_ERRORCALLBACK_INSTANCETYPE_STUDIO_BUS,
1413 ErrorCallbackInstancetype::Vca => ffi::FMOD_ERRORCALLBACK_INSTANCETYPE_STUDIO_VCA,
1414 ErrorCallbackInstancetype::Bank => ffi::FMOD_ERRORCALLBACK_INSTANCETYPE_STUDIO_BANK,
1415 ErrorCallbackInstancetype::CommandReplay => {
1416 ffi::FMOD_ERRORCALLBACK_INSTANCETYPE_STUDIO_COMMANDREPLAY
1417 }
1418 }
1419 }
1420}
1421impl ErrorCallbackInstancetype {
1422 pub fn from(
1423 value: ffi::FMOD_ERRORCALLBACK_INSTANCETYPE,
1424 ) -> Result<ErrorCallbackInstancetype, Error> {
1425 match value {
1426 ffi::FMOD_ERRORCALLBACK_INSTANCETYPE_NONE => Ok(ErrorCallbackInstancetype::None),
1427 ffi::FMOD_ERRORCALLBACK_INSTANCETYPE_SYSTEM => Ok(ErrorCallbackInstancetype::System),
1428 ffi::FMOD_ERRORCALLBACK_INSTANCETYPE_CHANNEL => Ok(ErrorCallbackInstancetype::Channel),
1429 ffi::FMOD_ERRORCALLBACK_INSTANCETYPE_CHANNELGROUP => {
1430 Ok(ErrorCallbackInstancetype::ChannelGroup)
1431 }
1432 ffi::FMOD_ERRORCALLBACK_INSTANCETYPE_CHANNELCONTROL => {
1433 Ok(ErrorCallbackInstancetype::ChannelControl)
1434 }
1435 ffi::FMOD_ERRORCALLBACK_INSTANCETYPE_SOUND => Ok(ErrorCallbackInstancetype::Sound),
1436 ffi::FMOD_ERRORCALLBACK_INSTANCETYPE_SOUNDGROUP => {
1437 Ok(ErrorCallbackInstancetype::SoundGroup)
1438 }
1439 ffi::FMOD_ERRORCALLBACK_INSTANCETYPE_DSP => Ok(ErrorCallbackInstancetype::Dsp),
1440 ffi::FMOD_ERRORCALLBACK_INSTANCETYPE_DSPCONNECTION => {
1441 Ok(ErrorCallbackInstancetype::DspConnection)
1442 }
1443 ffi::FMOD_ERRORCALLBACK_INSTANCETYPE_GEOMETRY => {
1444 Ok(ErrorCallbackInstancetype::Geometry)
1445 }
1446 ffi::FMOD_ERRORCALLBACK_INSTANCETYPE_REVERB3D => {
1447 Ok(ErrorCallbackInstancetype::Reverb3d)
1448 }
1449 ffi::FMOD_ERRORCALLBACK_INSTANCETYPE_STUDIO_SYSTEM => {
1450 Ok(ErrorCallbackInstancetype::Studio)
1451 }
1452 ffi::FMOD_ERRORCALLBACK_INSTANCETYPE_STUDIO_EVENTDESCRIPTION => {
1453 Ok(ErrorCallbackInstancetype::EventDescription)
1454 }
1455 ffi::FMOD_ERRORCALLBACK_INSTANCETYPE_STUDIO_EVENTINSTANCE => {
1456 Ok(ErrorCallbackInstancetype::EventInstance)
1457 }
1458 ffi::FMOD_ERRORCALLBACK_INSTANCETYPE_STUDIO_PARAMETERINSTANCE => {
1459 Ok(ErrorCallbackInstancetype::ParameterInstance)
1460 }
1461 ffi::FMOD_ERRORCALLBACK_INSTANCETYPE_STUDIO_BUS => Ok(ErrorCallbackInstancetype::Bus),
1462 ffi::FMOD_ERRORCALLBACK_INSTANCETYPE_STUDIO_VCA => Ok(ErrorCallbackInstancetype::Vca),
1463 ffi::FMOD_ERRORCALLBACK_INSTANCETYPE_STUDIO_BANK => Ok(ErrorCallbackInstancetype::Bank),
1464 ffi::FMOD_ERRORCALLBACK_INSTANCETYPE_STUDIO_COMMANDREPLAY => {
1465 Ok(ErrorCallbackInstancetype::CommandReplay)
1466 }
1467 _ => Err(err_enum!("FMOD_ERRORCALLBACK_INSTANCETYPE", value)),
1468 }
1469 }
1470}
1471#[derive(Debug, Clone, Copy, PartialEq)]
1472pub enum DspResampler {
1473 Default,
1474 NoInterp,
1475 Linear,
1476 Cubic,
1477 Spline,
1478 Max,
1479}
1480impl From<DspResampler> for ffi::FMOD_DSP_RESAMPLER {
1481 fn from(value: DspResampler) -> ffi::FMOD_DSP_RESAMPLER {
1482 match value {
1483 DspResampler::Default => ffi::FMOD_DSP_RESAMPLER_DEFAULT,
1484 DspResampler::NoInterp => ffi::FMOD_DSP_RESAMPLER_NOINTERP,
1485 DspResampler::Linear => ffi::FMOD_DSP_RESAMPLER_LINEAR,
1486 DspResampler::Cubic => ffi::FMOD_DSP_RESAMPLER_CUBIC,
1487 DspResampler::Spline => ffi::FMOD_DSP_RESAMPLER_SPLINE,
1488 DspResampler::Max => ffi::FMOD_DSP_RESAMPLER_MAX,
1489 }
1490 }
1491}
1492impl DspResampler {
1493 pub fn from(value: ffi::FMOD_DSP_RESAMPLER) -> Result<DspResampler, Error> {
1494 match value {
1495 ffi::FMOD_DSP_RESAMPLER_DEFAULT => Ok(DspResampler::Default),
1496 ffi::FMOD_DSP_RESAMPLER_NOINTERP => Ok(DspResampler::NoInterp),
1497 ffi::FMOD_DSP_RESAMPLER_LINEAR => Ok(DspResampler::Linear),
1498 ffi::FMOD_DSP_RESAMPLER_CUBIC => Ok(DspResampler::Cubic),
1499 ffi::FMOD_DSP_RESAMPLER_SPLINE => Ok(DspResampler::Spline),
1500 ffi::FMOD_DSP_RESAMPLER_MAX => Ok(DspResampler::Max),
1501 _ => Err(err_enum!("FMOD_DSP_RESAMPLER", value)),
1502 }
1503 }
1504}
1505#[derive(Debug, Clone, Copy, PartialEq)]
1506pub enum DspCallbackType {
1507 Dataparameterrelease,
1508 Max,
1509}
1510impl From<DspCallbackType> for ffi::FMOD_DSP_CALLBACK_TYPE {
1511 fn from(value: DspCallbackType) -> ffi::FMOD_DSP_CALLBACK_TYPE {
1512 match value {
1513 DspCallbackType::Dataparameterrelease => ffi::FMOD_DSP_CALLBACK_DATAPARAMETERRELEASE,
1514 DspCallbackType::Max => ffi::FMOD_DSP_CALLBACK_MAX,
1515 }
1516 }
1517}
1518impl DspCallbackType {
1519 pub fn from(value: ffi::FMOD_DSP_CALLBACK_TYPE) -> Result<DspCallbackType, Error> {
1520 match value {
1521 ffi::FMOD_DSP_CALLBACK_DATAPARAMETERRELEASE => {
1522 Ok(DspCallbackType::Dataparameterrelease)
1523 }
1524 ffi::FMOD_DSP_CALLBACK_MAX => Ok(DspCallbackType::Max),
1525 _ => Err(err_enum!("FMOD_DSP_CALLBACK_TYPE", value)),
1526 }
1527 }
1528}
1529#[derive(Debug, Clone, Copy, PartialEq)]
1530pub enum DspConnectionType {
1531 Standard,
1532 Sidechain,
1533 Send,
1534 SendSidechain,
1535 Max,
1536}
1537impl From<DspConnectionType> for ffi::FMOD_DSPCONNECTION_TYPE {
1538 fn from(value: DspConnectionType) -> ffi::FMOD_DSPCONNECTION_TYPE {
1539 match value {
1540 DspConnectionType::Standard => ffi::FMOD_DSPCONNECTION_TYPE_STANDARD,
1541 DspConnectionType::Sidechain => ffi::FMOD_DSPCONNECTION_TYPE_SIDECHAIN,
1542 DspConnectionType::Send => ffi::FMOD_DSPCONNECTION_TYPE_SEND,
1543 DspConnectionType::SendSidechain => ffi::FMOD_DSPCONNECTION_TYPE_SEND_SIDECHAIN,
1544 DspConnectionType::Max => ffi::FMOD_DSPCONNECTION_TYPE_MAX,
1545 }
1546 }
1547}
1548impl DspConnectionType {
1549 pub fn from(value: ffi::FMOD_DSPCONNECTION_TYPE) -> Result<DspConnectionType, Error> {
1550 match value {
1551 ffi::FMOD_DSPCONNECTION_TYPE_STANDARD => Ok(DspConnectionType::Standard),
1552 ffi::FMOD_DSPCONNECTION_TYPE_SIDECHAIN => Ok(DspConnectionType::Sidechain),
1553 ffi::FMOD_DSPCONNECTION_TYPE_SEND => Ok(DspConnectionType::Send),
1554 ffi::FMOD_DSPCONNECTION_TYPE_SEND_SIDECHAIN => Ok(DspConnectionType::SendSidechain),
1555 ffi::FMOD_DSPCONNECTION_TYPE_MAX => Ok(DspConnectionType::Max),
1556 _ => Err(err_enum!("FMOD_DSPCONNECTION_TYPE", value)),
1557 }
1558 }
1559}
1560#[derive(Debug, Clone, Copy, PartialEq)]
1561pub enum TagType {
1562 Unknown,
1563 Id3V1,
1564 Id3V2,
1565 VorbisComment,
1566 Shoutcast,
1567 Icecast,
1568 Asf,
1569 Midi,
1570 Playlist,
1571 Fmod,
1572 User,
1573 Max,
1574}
1575impl From<TagType> for ffi::FMOD_TAGTYPE {
1576 fn from(value: TagType) -> ffi::FMOD_TAGTYPE {
1577 match value {
1578 TagType::Unknown => ffi::FMOD_TAGTYPE_UNKNOWN,
1579 TagType::Id3V1 => ffi::FMOD_TAGTYPE_ID3V1,
1580 TagType::Id3V2 => ffi::FMOD_TAGTYPE_ID3V2,
1581 TagType::VorbisComment => ffi::FMOD_TAGTYPE_VORBISCOMMENT,
1582 TagType::Shoutcast => ffi::FMOD_TAGTYPE_SHOUTCAST,
1583 TagType::Icecast => ffi::FMOD_TAGTYPE_ICECAST,
1584 TagType::Asf => ffi::FMOD_TAGTYPE_ASF,
1585 TagType::Midi => ffi::FMOD_TAGTYPE_MIDI,
1586 TagType::Playlist => ffi::FMOD_TAGTYPE_PLAYLIST,
1587 TagType::Fmod => ffi::FMOD_TAGTYPE_FMOD,
1588 TagType::User => ffi::FMOD_TAGTYPE_USER,
1589 TagType::Max => ffi::FMOD_TAGTYPE_MAX,
1590 }
1591 }
1592}
1593impl TagType {
1594 pub fn from(value: ffi::FMOD_TAGTYPE) -> Result<TagType, Error> {
1595 match value {
1596 ffi::FMOD_TAGTYPE_UNKNOWN => Ok(TagType::Unknown),
1597 ffi::FMOD_TAGTYPE_ID3V1 => Ok(TagType::Id3V1),
1598 ffi::FMOD_TAGTYPE_ID3V2 => Ok(TagType::Id3V2),
1599 ffi::FMOD_TAGTYPE_VORBISCOMMENT => Ok(TagType::VorbisComment),
1600 ffi::FMOD_TAGTYPE_SHOUTCAST => Ok(TagType::Shoutcast),
1601 ffi::FMOD_TAGTYPE_ICECAST => Ok(TagType::Icecast),
1602 ffi::FMOD_TAGTYPE_ASF => Ok(TagType::Asf),
1603 ffi::FMOD_TAGTYPE_MIDI => Ok(TagType::Midi),
1604 ffi::FMOD_TAGTYPE_PLAYLIST => Ok(TagType::Playlist),
1605 ffi::FMOD_TAGTYPE_FMOD => Ok(TagType::Fmod),
1606 ffi::FMOD_TAGTYPE_USER => Ok(TagType::User),
1607 ffi::FMOD_TAGTYPE_MAX => Ok(TagType::Max),
1608 _ => Err(err_enum!("FMOD_TAGTYPE", value)),
1609 }
1610 }
1611}
1612#[derive(Debug, Clone, Copy, PartialEq)]
1613pub enum TagDataType {
1614 Binary,
1615 Int,
1616 Float,
1617 String,
1618 StringUtf16,
1619 StringUtf16Be,
1620 StringUtf8,
1621 Max,
1622}
1623impl From<TagDataType> for ffi::FMOD_TAGDATATYPE {
1624 fn from(value: TagDataType) -> ffi::FMOD_TAGDATATYPE {
1625 match value {
1626 TagDataType::Binary => ffi::FMOD_TAGDATATYPE_BINARY,
1627 TagDataType::Int => ffi::FMOD_TAGDATATYPE_INT,
1628 TagDataType::Float => ffi::FMOD_TAGDATATYPE_FLOAT,
1629 TagDataType::String => ffi::FMOD_TAGDATATYPE_STRING,
1630 TagDataType::StringUtf16 => ffi::FMOD_TAGDATATYPE_STRING_UTF16,
1631 TagDataType::StringUtf16Be => ffi::FMOD_TAGDATATYPE_STRING_UTF16BE,
1632 TagDataType::StringUtf8 => ffi::FMOD_TAGDATATYPE_STRING_UTF8,
1633 TagDataType::Max => ffi::FMOD_TAGDATATYPE_MAX,
1634 }
1635 }
1636}
1637impl TagDataType {
1638 pub fn from(value: ffi::FMOD_TAGDATATYPE) -> Result<TagDataType, Error> {
1639 match value {
1640 ffi::FMOD_TAGDATATYPE_BINARY => Ok(TagDataType::Binary),
1641 ffi::FMOD_TAGDATATYPE_INT => Ok(TagDataType::Int),
1642 ffi::FMOD_TAGDATATYPE_FLOAT => Ok(TagDataType::Float),
1643 ffi::FMOD_TAGDATATYPE_STRING => Ok(TagDataType::String),
1644 ffi::FMOD_TAGDATATYPE_STRING_UTF16 => Ok(TagDataType::StringUtf16),
1645 ffi::FMOD_TAGDATATYPE_STRING_UTF16BE => Ok(TagDataType::StringUtf16Be),
1646 ffi::FMOD_TAGDATATYPE_STRING_UTF8 => Ok(TagDataType::StringUtf8),
1647 ffi::FMOD_TAGDATATYPE_MAX => Ok(TagDataType::Max),
1648 _ => Err(err_enum!("FMOD_TAGDATATYPE", value)),
1649 }
1650 }
1651}
1652#[derive(Debug, Clone, Copy, PartialEq)]
1653pub enum PortType {
1654 Music,
1655 CopyrightMusic,
1656 Voice,
1657 Controller,
1658 Personal,
1659 Vibration,
1660 Aux,
1661 Max,
1662}
1663impl From<PortType> for ffi::FMOD_PORT_TYPE {
1664 fn from(value: PortType) -> ffi::FMOD_PORT_TYPE {
1665 match value {
1666 PortType::Music => ffi::FMOD_PORT_TYPE_MUSIC,
1667 PortType::CopyrightMusic => ffi::FMOD_PORT_TYPE_COPYRIGHT_MUSIC,
1668 PortType::Voice => ffi::FMOD_PORT_TYPE_VOICE,
1669 PortType::Controller => ffi::FMOD_PORT_TYPE_CONTROLLER,
1670 PortType::Personal => ffi::FMOD_PORT_TYPE_PERSONAL,
1671 PortType::Vibration => ffi::FMOD_PORT_TYPE_VIBRATION,
1672 PortType::Aux => ffi::FMOD_PORT_TYPE_AUX,
1673 PortType::Max => ffi::FMOD_PORT_TYPE_MAX,
1674 }
1675 }
1676}
1677impl PortType {
1678 pub fn from(value: ffi::FMOD_PORT_TYPE) -> Result<PortType, Error> {
1679 match value {
1680 ffi::FMOD_PORT_TYPE_MUSIC => Ok(PortType::Music),
1681 ffi::FMOD_PORT_TYPE_COPYRIGHT_MUSIC => Ok(PortType::CopyrightMusic),
1682 ffi::FMOD_PORT_TYPE_VOICE => Ok(PortType::Voice),
1683 ffi::FMOD_PORT_TYPE_CONTROLLER => Ok(PortType::Controller),
1684 ffi::FMOD_PORT_TYPE_PERSONAL => Ok(PortType::Personal),
1685 ffi::FMOD_PORT_TYPE_VIBRATION => Ok(PortType::Vibration),
1686 ffi::FMOD_PORT_TYPE_AUX => Ok(PortType::Aux),
1687 ffi::FMOD_PORT_TYPE_MAX => Ok(PortType::Max),
1688 _ => Err(err_enum!("FMOD_PORT_TYPE", value)),
1689 }
1690 }
1691}
1692#[derive(Debug, Clone, Copy, PartialEq)]
1693pub enum DspProcessOperation {
1694 Perform,
1695 Query,
1696}
1697impl From<DspProcessOperation> for ffi::FMOD_DSP_PROCESS_OPERATION {
1698 fn from(value: DspProcessOperation) -> ffi::FMOD_DSP_PROCESS_OPERATION {
1699 match value {
1700 DspProcessOperation::Perform => ffi::FMOD_DSP_PROCESS_PERFORM,
1701 DspProcessOperation::Query => ffi::FMOD_DSP_PROCESS_QUERY,
1702 }
1703 }
1704}
1705impl DspProcessOperation {
1706 pub fn from(value: ffi::FMOD_DSP_PROCESS_OPERATION) -> Result<DspProcessOperation, Error> {
1707 match value {
1708 ffi::FMOD_DSP_PROCESS_PERFORM => Ok(DspProcessOperation::Perform),
1709 ffi::FMOD_DSP_PROCESS_QUERY => Ok(DspProcessOperation::Query),
1710 _ => Err(err_enum!("FMOD_DSP_PROCESS_OPERATION", value)),
1711 }
1712 }
1713}
1714#[derive(Debug, Clone, Copy, PartialEq)]
1715pub enum DspPanSurroundFlags {
1716 Default,
1717 RotationNotBiased,
1718}
1719impl From<DspPanSurroundFlags> for ffi::FMOD_DSP_PAN_SURROUND_FLAGS {
1720 fn from(value: DspPanSurroundFlags) -> ffi::FMOD_DSP_PAN_SURROUND_FLAGS {
1721 match value {
1722 DspPanSurroundFlags::Default => ffi::FMOD_DSP_PAN_SURROUND_DEFAULT,
1723 DspPanSurroundFlags::RotationNotBiased => {
1724 ffi::FMOD_DSP_PAN_SURROUND_ROTATION_NOT_BIASED
1725 }
1726 }
1727 }
1728}
1729impl DspPanSurroundFlags {
1730 pub fn from(value: ffi::FMOD_DSP_PAN_SURROUND_FLAGS) -> Result<DspPanSurroundFlags, Error> {
1731 match value {
1732 ffi::FMOD_DSP_PAN_SURROUND_DEFAULT => Ok(DspPanSurroundFlags::Default),
1733 ffi::FMOD_DSP_PAN_SURROUND_ROTATION_NOT_BIASED => {
1734 Ok(DspPanSurroundFlags::RotationNotBiased)
1735 }
1736 _ => Err(err_enum!("FMOD_DSP_PAN_SURROUND_FLAGS", value)),
1737 }
1738 }
1739}
1740#[derive(Debug, Clone, Copy, PartialEq)]
1741pub enum DspParameterType {
1742 Float,
1743 Int,
1744 Bool,
1745 Data,
1746 Max,
1747}
1748impl From<DspParameterType> for ffi::FMOD_DSP_PARAMETER_TYPE {
1749 fn from(value: DspParameterType) -> ffi::FMOD_DSP_PARAMETER_TYPE {
1750 match value {
1751 DspParameterType::Float => ffi::FMOD_DSP_PARAMETER_TYPE_FLOAT,
1752 DspParameterType::Int => ffi::FMOD_DSP_PARAMETER_TYPE_INT,
1753 DspParameterType::Bool => ffi::FMOD_DSP_PARAMETER_TYPE_BOOL,
1754 DspParameterType::Data => ffi::FMOD_DSP_PARAMETER_TYPE_DATA,
1755 DspParameterType::Max => ffi::FMOD_DSP_PARAMETER_TYPE_MAX,
1756 }
1757 }
1758}
1759impl DspParameterType {
1760 pub fn from(value: ffi::FMOD_DSP_PARAMETER_TYPE) -> Result<DspParameterType, Error> {
1761 match value {
1762 ffi::FMOD_DSP_PARAMETER_TYPE_FLOAT => Ok(DspParameterType::Float),
1763 ffi::FMOD_DSP_PARAMETER_TYPE_INT => Ok(DspParameterType::Int),
1764 ffi::FMOD_DSP_PARAMETER_TYPE_BOOL => Ok(DspParameterType::Bool),
1765 ffi::FMOD_DSP_PARAMETER_TYPE_DATA => Ok(DspParameterType::Data),
1766 ffi::FMOD_DSP_PARAMETER_TYPE_MAX => Ok(DspParameterType::Max),
1767 _ => Err(err_enum!("FMOD_DSP_PARAMETER_TYPE", value)),
1768 }
1769 }
1770}
1771#[derive(Debug, Clone, Copy, PartialEq)]
1772pub enum DspParameterFloatMappingType {
1773 Linear,
1774 Auto,
1775 PiecewiseLinear,
1776}
1777impl From<DspParameterFloatMappingType> for ffi::FMOD_DSP_PARAMETER_FLOAT_MAPPING_TYPE {
1778 fn from(value: DspParameterFloatMappingType) -> ffi::FMOD_DSP_PARAMETER_FLOAT_MAPPING_TYPE {
1779 match value {
1780 DspParameterFloatMappingType::Linear => {
1781 ffi::FMOD_DSP_PARAMETER_FLOAT_MAPPING_TYPE_LINEAR
1782 }
1783 DspParameterFloatMappingType::Auto => ffi::FMOD_DSP_PARAMETER_FLOAT_MAPPING_TYPE_AUTO,
1784 DspParameterFloatMappingType::PiecewiseLinear => {
1785 ffi::FMOD_DSP_PARAMETER_FLOAT_MAPPING_TYPE_PIECEWISE_LINEAR
1786 }
1787 }
1788 }
1789}
1790impl DspParameterFloatMappingType {
1791 pub fn from(
1792 value: ffi::FMOD_DSP_PARAMETER_FLOAT_MAPPING_TYPE,
1793 ) -> Result<DspParameterFloatMappingType, Error> {
1794 match value {
1795 ffi::FMOD_DSP_PARAMETER_FLOAT_MAPPING_TYPE_LINEAR => {
1796 Ok(DspParameterFloatMappingType::Linear)
1797 }
1798 ffi::FMOD_DSP_PARAMETER_FLOAT_MAPPING_TYPE_AUTO => {
1799 Ok(DspParameterFloatMappingType::Auto)
1800 }
1801 ffi::FMOD_DSP_PARAMETER_FLOAT_MAPPING_TYPE_PIECEWISE_LINEAR => {
1802 Ok(DspParameterFloatMappingType::PiecewiseLinear)
1803 }
1804 _ => Err(err_enum!("FMOD_DSP_PARAMETER_FLOAT_MAPPING_TYPE", value)),
1805 }
1806 }
1807}
1808#[derive(Debug, Clone, Copy, PartialEq)]
1809pub enum DspParameterDataType {
1810 User,
1811 OverallGain,
1812 Attributes3D,
1813 Sidechain,
1814 Fft,
1815 AttributesMulti3D,
1816 AttenuationRange,
1817}
1818impl From<DspParameterDataType> for ffi::FMOD_DSP_PARAMETER_DATA_TYPE {
1819 fn from(value: DspParameterDataType) -> ffi::FMOD_DSP_PARAMETER_DATA_TYPE {
1820 match value {
1821 DspParameterDataType::User => ffi::FMOD_DSP_PARAMETER_DATA_TYPE_USER,
1822 DspParameterDataType::OverallGain => ffi::FMOD_DSP_PARAMETER_DATA_TYPE_OVERALLGAIN,
1823 DspParameterDataType::Attributes3D => ffi::FMOD_DSP_PARAMETER_DATA_TYPE_3DATTRIBUTES,
1824 DspParameterDataType::Sidechain => ffi::FMOD_DSP_PARAMETER_DATA_TYPE_SIDECHAIN,
1825 DspParameterDataType::Fft => ffi::FMOD_DSP_PARAMETER_DATA_TYPE_FFT,
1826 DspParameterDataType::AttributesMulti3D => {
1827 ffi::FMOD_DSP_PARAMETER_DATA_TYPE_3DATTRIBUTES_MULTI
1828 }
1829 DspParameterDataType::AttenuationRange => {
1830 ffi::FMOD_DSP_PARAMETER_DATA_TYPE_ATTENUATION_RANGE
1831 }
1832 }
1833 }
1834}
1835impl DspParameterDataType {
1836 pub fn from(value: ffi::FMOD_DSP_PARAMETER_DATA_TYPE) -> Result<DspParameterDataType, Error> {
1837 match value {
1838 ffi::FMOD_DSP_PARAMETER_DATA_TYPE_USER => Ok(DspParameterDataType::User),
1839 ffi::FMOD_DSP_PARAMETER_DATA_TYPE_OVERALLGAIN => Ok(DspParameterDataType::OverallGain),
1840 ffi::FMOD_DSP_PARAMETER_DATA_TYPE_3DATTRIBUTES => {
1841 Ok(DspParameterDataType::Attributes3D)
1842 }
1843 ffi::FMOD_DSP_PARAMETER_DATA_TYPE_SIDECHAIN => Ok(DspParameterDataType::Sidechain),
1844 ffi::FMOD_DSP_PARAMETER_DATA_TYPE_FFT => Ok(DspParameterDataType::Fft),
1845 ffi::FMOD_DSP_PARAMETER_DATA_TYPE_3DATTRIBUTES_MULTI => {
1846 Ok(DspParameterDataType::AttributesMulti3D)
1847 }
1848 ffi::FMOD_DSP_PARAMETER_DATA_TYPE_ATTENUATION_RANGE => {
1849 Ok(DspParameterDataType::AttenuationRange)
1850 }
1851 _ => Err(err_enum!("FMOD_DSP_PARAMETER_DATA_TYPE", value)),
1852 }
1853 }
1854}
1855#[derive(Debug, Clone, Copy, PartialEq)]
1856pub enum DspType {
1857 Unknown,
1858 Mixer,
1859 Oscillator,
1860 Lowpass,
1861 Itlowpass,
1862 Highpass,
1863 Echo,
1864 Fader,
1865 Flange,
1866 Distortion,
1867 Normalize,
1868 Limiter,
1869 Parameq,
1870 Pitchshift,
1871 Chorus,
1872 Vstplugin,
1873 Winampplugin,
1874 Itecho,
1875 Compressor,
1876 Sfxreverb,
1877 LowpassSimple,
1878 Delay,
1879 Tremolo,
1880 Ladspaplugin,
1881 Send,
1882 Return,
1883 HighpassSimple,
1884 Pan,
1885 ThreeEq,
1886 Fft,
1887 LoudnessMeter,
1888 Envelopefollower,
1889 Convolutionreverb,
1890 Channelmix,
1891 Transceiver,
1892 Objectpan,
1893 MultibandEq,
1894 Max,
1895}
1896impl From<DspType> for ffi::FMOD_DSP_TYPE {
1897 fn from(value: DspType) -> ffi::FMOD_DSP_TYPE {
1898 match value {
1899 DspType::Unknown => ffi::FMOD_DSP_TYPE_UNKNOWN,
1900 DspType::Mixer => ffi::FMOD_DSP_TYPE_MIXER,
1901 DspType::Oscillator => ffi::FMOD_DSP_TYPE_OSCILLATOR,
1902 DspType::Lowpass => ffi::FMOD_DSP_TYPE_LOWPASS,
1903 DspType::Itlowpass => ffi::FMOD_DSP_TYPE_ITLOWPASS,
1904 DspType::Highpass => ffi::FMOD_DSP_TYPE_HIGHPASS,
1905 DspType::Echo => ffi::FMOD_DSP_TYPE_ECHO,
1906 DspType::Fader => ffi::FMOD_DSP_TYPE_FADER,
1907 DspType::Flange => ffi::FMOD_DSP_TYPE_FLANGE,
1908 DspType::Distortion => ffi::FMOD_DSP_TYPE_DISTORTION,
1909 DspType::Normalize => ffi::FMOD_DSP_TYPE_NORMALIZE,
1910 DspType::Limiter => ffi::FMOD_DSP_TYPE_LIMITER,
1911 DspType::Parameq => ffi::FMOD_DSP_TYPE_PARAMEQ,
1912 DspType::Pitchshift => ffi::FMOD_DSP_TYPE_PITCHSHIFT,
1913 DspType::Chorus => ffi::FMOD_DSP_TYPE_CHORUS,
1914 DspType::Vstplugin => ffi::FMOD_DSP_TYPE_VSTPLUGIN,
1915 DspType::Winampplugin => ffi::FMOD_DSP_TYPE_WINAMPPLUGIN,
1916 DspType::Itecho => ffi::FMOD_DSP_TYPE_ITECHO,
1917 DspType::Compressor => ffi::FMOD_DSP_TYPE_COMPRESSOR,
1918 DspType::Sfxreverb => ffi::FMOD_DSP_TYPE_SFXREVERB,
1919 DspType::LowpassSimple => ffi::FMOD_DSP_TYPE_LOWPASS_SIMPLE,
1920 DspType::Delay => ffi::FMOD_DSP_TYPE_DELAY,
1921 DspType::Tremolo => ffi::FMOD_DSP_TYPE_TREMOLO,
1922 DspType::Ladspaplugin => ffi::FMOD_DSP_TYPE_LADSPAPLUGIN,
1923 DspType::Send => ffi::FMOD_DSP_TYPE_SEND,
1924 DspType::Return => ffi::FMOD_DSP_TYPE_RETURN,
1925 DspType::HighpassSimple => ffi::FMOD_DSP_TYPE_HIGHPASS_SIMPLE,
1926 DspType::Pan => ffi::FMOD_DSP_TYPE_PAN,
1927 DspType::ThreeEq => ffi::FMOD_DSP_TYPE_THREE_EQ,
1928 DspType::Fft => ffi::FMOD_DSP_TYPE_FFT,
1929 DspType::LoudnessMeter => ffi::FMOD_DSP_TYPE_LOUDNESS_METER,
1930 DspType::Envelopefollower => ffi::FMOD_DSP_TYPE_ENVELOPEFOLLOWER,
1931 DspType::Convolutionreverb => ffi::FMOD_DSP_TYPE_CONVOLUTIONREVERB,
1932 DspType::Channelmix => ffi::FMOD_DSP_TYPE_CHANNELMIX,
1933 DspType::Transceiver => ffi::FMOD_DSP_TYPE_TRANSCEIVER,
1934 DspType::Objectpan => ffi::FMOD_DSP_TYPE_OBJECTPAN,
1935 DspType::MultibandEq => ffi::FMOD_DSP_TYPE_MULTIBAND_EQ,
1936 DspType::Max => ffi::FMOD_DSP_TYPE_MAX,
1937 }
1938 }
1939}
1940impl DspType {
1941 pub fn from(value: ffi::FMOD_DSP_TYPE) -> Result<DspType, Error> {
1942 match value {
1943 ffi::FMOD_DSP_TYPE_UNKNOWN => Ok(DspType::Unknown),
1944 ffi::FMOD_DSP_TYPE_MIXER => Ok(DspType::Mixer),
1945 ffi::FMOD_DSP_TYPE_OSCILLATOR => Ok(DspType::Oscillator),
1946 ffi::FMOD_DSP_TYPE_LOWPASS => Ok(DspType::Lowpass),
1947 ffi::FMOD_DSP_TYPE_ITLOWPASS => Ok(DspType::Itlowpass),
1948 ffi::FMOD_DSP_TYPE_HIGHPASS => Ok(DspType::Highpass),
1949 ffi::FMOD_DSP_TYPE_ECHO => Ok(DspType::Echo),
1950 ffi::FMOD_DSP_TYPE_FADER => Ok(DspType::Fader),
1951 ffi::FMOD_DSP_TYPE_FLANGE => Ok(DspType::Flange),
1952 ffi::FMOD_DSP_TYPE_DISTORTION => Ok(DspType::Distortion),
1953 ffi::FMOD_DSP_TYPE_NORMALIZE => Ok(DspType::Normalize),
1954 ffi::FMOD_DSP_TYPE_LIMITER => Ok(DspType::Limiter),
1955 ffi::FMOD_DSP_TYPE_PARAMEQ => Ok(DspType::Parameq),
1956 ffi::FMOD_DSP_TYPE_PITCHSHIFT => Ok(DspType::Pitchshift),
1957 ffi::FMOD_DSP_TYPE_CHORUS => Ok(DspType::Chorus),
1958 ffi::FMOD_DSP_TYPE_VSTPLUGIN => Ok(DspType::Vstplugin),
1959 ffi::FMOD_DSP_TYPE_WINAMPPLUGIN => Ok(DspType::Winampplugin),
1960 ffi::FMOD_DSP_TYPE_ITECHO => Ok(DspType::Itecho),
1961 ffi::FMOD_DSP_TYPE_COMPRESSOR => Ok(DspType::Compressor),
1962 ffi::FMOD_DSP_TYPE_SFXREVERB => Ok(DspType::Sfxreverb),
1963 ffi::FMOD_DSP_TYPE_LOWPASS_SIMPLE => Ok(DspType::LowpassSimple),
1964 ffi::FMOD_DSP_TYPE_DELAY => Ok(DspType::Delay),
1965 ffi::FMOD_DSP_TYPE_TREMOLO => Ok(DspType::Tremolo),
1966 ffi::FMOD_DSP_TYPE_LADSPAPLUGIN => Ok(DspType::Ladspaplugin),
1967 ffi::FMOD_DSP_TYPE_SEND => Ok(DspType::Send),
1968 ffi::FMOD_DSP_TYPE_RETURN => Ok(DspType::Return),
1969 ffi::FMOD_DSP_TYPE_HIGHPASS_SIMPLE => Ok(DspType::HighpassSimple),
1970 ffi::FMOD_DSP_TYPE_PAN => Ok(DspType::Pan),
1971 ffi::FMOD_DSP_TYPE_THREE_EQ => Ok(DspType::ThreeEq),
1972 ffi::FMOD_DSP_TYPE_FFT => Ok(DspType::Fft),
1973 ffi::FMOD_DSP_TYPE_LOUDNESS_METER => Ok(DspType::LoudnessMeter),
1974 ffi::FMOD_DSP_TYPE_ENVELOPEFOLLOWER => Ok(DspType::Envelopefollower),
1975 ffi::FMOD_DSP_TYPE_CONVOLUTIONREVERB => Ok(DspType::Convolutionreverb),
1976 ffi::FMOD_DSP_TYPE_CHANNELMIX => Ok(DspType::Channelmix),
1977 ffi::FMOD_DSP_TYPE_TRANSCEIVER => Ok(DspType::Transceiver),
1978 ffi::FMOD_DSP_TYPE_OBJECTPAN => Ok(DspType::Objectpan),
1979 ffi::FMOD_DSP_TYPE_MULTIBAND_EQ => Ok(DspType::MultibandEq),
1980 ffi::FMOD_DSP_TYPE_MAX => Ok(DspType::Max),
1981 _ => Err(err_enum!("FMOD_DSP_TYPE", value)),
1982 }
1983 }
1984}
1985#[derive(Debug, Clone, Copy, PartialEq)]
1986pub enum DspOscillator {
1987 Type,
1988 Rate,
1989}
1990impl From<DspOscillator> for ffi::FMOD_DSP_OSCILLATOR {
1991 fn from(value: DspOscillator) -> ffi::FMOD_DSP_OSCILLATOR {
1992 match value {
1993 DspOscillator::Type => ffi::FMOD_DSP_OSCILLATOR_TYPE,
1994 DspOscillator::Rate => ffi::FMOD_DSP_OSCILLATOR_RATE,
1995 }
1996 }
1997}
1998impl DspOscillator {
1999 pub fn from(value: ffi::FMOD_DSP_OSCILLATOR) -> Result<DspOscillator, Error> {
2000 match value {
2001 ffi::FMOD_DSP_OSCILLATOR_TYPE => Ok(DspOscillator::Type),
2002 ffi::FMOD_DSP_OSCILLATOR_RATE => Ok(DspOscillator::Rate),
2003 _ => Err(err_enum!("FMOD_DSP_OSCILLATOR", value)),
2004 }
2005 }
2006}
2007#[derive(Debug, Clone, Copy, PartialEq)]
2008pub enum DspLowPass {
2009 Cutoff,
2010 Resonance,
2011}
2012impl From<DspLowPass> for ffi::FMOD_DSP_LOWPASS {
2013 fn from(value: DspLowPass) -> ffi::FMOD_DSP_LOWPASS {
2014 match value {
2015 DspLowPass::Cutoff => ffi::FMOD_DSP_LOWPASS_CUTOFF,
2016 DspLowPass::Resonance => ffi::FMOD_DSP_LOWPASS_RESONANCE,
2017 }
2018 }
2019}
2020impl DspLowPass {
2021 pub fn from(value: ffi::FMOD_DSP_LOWPASS) -> Result<DspLowPass, Error> {
2022 match value {
2023 ffi::FMOD_DSP_LOWPASS_CUTOFF => Ok(DspLowPass::Cutoff),
2024 ffi::FMOD_DSP_LOWPASS_RESONANCE => Ok(DspLowPass::Resonance),
2025 _ => Err(err_enum!("FMOD_DSP_LOWPASS", value)),
2026 }
2027 }
2028}
2029#[derive(Debug, Clone, Copy, PartialEq)]
2030pub enum DspItLowPass {
2031 Cutoff,
2032 Resonance,
2033}
2034impl From<DspItLowPass> for ffi::FMOD_DSP_ITLOWPASS {
2035 fn from(value: DspItLowPass) -> ffi::FMOD_DSP_ITLOWPASS {
2036 match value {
2037 DspItLowPass::Cutoff => ffi::FMOD_DSP_ITLOWPASS_CUTOFF,
2038 DspItLowPass::Resonance => ffi::FMOD_DSP_ITLOWPASS_RESONANCE,
2039 }
2040 }
2041}
2042impl DspItLowPass {
2043 pub fn from(value: ffi::FMOD_DSP_ITLOWPASS) -> Result<DspItLowPass, Error> {
2044 match value {
2045 ffi::FMOD_DSP_ITLOWPASS_CUTOFF => Ok(DspItLowPass::Cutoff),
2046 ffi::FMOD_DSP_ITLOWPASS_RESONANCE => Ok(DspItLowPass::Resonance),
2047 _ => Err(err_enum!("FMOD_DSP_ITLOWPASS", value)),
2048 }
2049 }
2050}
2051#[derive(Debug, Clone, Copy, PartialEq)]
2052pub enum DspHighPass {
2053 Cutoff,
2054 Resonance,
2055}
2056impl From<DspHighPass> for ffi::FMOD_DSP_HIGHPASS {
2057 fn from(value: DspHighPass) -> ffi::FMOD_DSP_HIGHPASS {
2058 match value {
2059 DspHighPass::Cutoff => ffi::FMOD_DSP_HIGHPASS_CUTOFF,
2060 DspHighPass::Resonance => ffi::FMOD_DSP_HIGHPASS_RESONANCE,
2061 }
2062 }
2063}
2064impl DspHighPass {
2065 pub fn from(value: ffi::FMOD_DSP_HIGHPASS) -> Result<DspHighPass, Error> {
2066 match value {
2067 ffi::FMOD_DSP_HIGHPASS_CUTOFF => Ok(DspHighPass::Cutoff),
2068 ffi::FMOD_DSP_HIGHPASS_RESONANCE => Ok(DspHighPass::Resonance),
2069 _ => Err(err_enum!("FMOD_DSP_HIGHPASS", value)),
2070 }
2071 }
2072}
2073#[derive(Debug, Clone, Copy, PartialEq)]
2074pub enum DspEcho {
2075 Delay,
2076 Feedback,
2077 DryLevel,
2078 WetLevel,
2079}
2080impl From<DspEcho> for ffi::FMOD_DSP_ECHO {
2081 fn from(value: DspEcho) -> ffi::FMOD_DSP_ECHO {
2082 match value {
2083 DspEcho::Delay => ffi::FMOD_DSP_ECHO_DELAY,
2084 DspEcho::Feedback => ffi::FMOD_DSP_ECHO_FEEDBACK,
2085 DspEcho::DryLevel => ffi::FMOD_DSP_ECHO_DRYLEVEL,
2086 DspEcho::WetLevel => ffi::FMOD_DSP_ECHO_WETLEVEL,
2087 }
2088 }
2089}
2090impl DspEcho {
2091 pub fn from(value: ffi::FMOD_DSP_ECHO) -> Result<DspEcho, Error> {
2092 match value {
2093 ffi::FMOD_DSP_ECHO_DELAY => Ok(DspEcho::Delay),
2094 ffi::FMOD_DSP_ECHO_FEEDBACK => Ok(DspEcho::Feedback),
2095 ffi::FMOD_DSP_ECHO_DRYLEVEL => Ok(DspEcho::DryLevel),
2096 ffi::FMOD_DSP_ECHO_WETLEVEL => Ok(DspEcho::WetLevel),
2097 _ => Err(err_enum!("FMOD_DSP_ECHO", value)),
2098 }
2099 }
2100}
2101#[derive(Debug, Clone, Copy, PartialEq)]
2102pub enum DspFader {
2103 Gain,
2104 OverallGain,
2105}
2106impl From<DspFader> for ffi::FMOD_DSP_FADER {
2107 fn from(value: DspFader) -> ffi::FMOD_DSP_FADER {
2108 match value {
2109 DspFader::Gain => ffi::FMOD_DSP_FADER_GAIN,
2110 DspFader::OverallGain => ffi::FMOD_DSP_FADER_OVERALL_GAIN,
2111 }
2112 }
2113}
2114impl DspFader {
2115 pub fn from(value: ffi::FMOD_DSP_FADER) -> Result<DspFader, Error> {
2116 match value {
2117 ffi::FMOD_DSP_FADER_GAIN => Ok(DspFader::Gain),
2118 ffi::FMOD_DSP_FADER_OVERALL_GAIN => Ok(DspFader::OverallGain),
2119 _ => Err(err_enum!("FMOD_DSP_FADER", value)),
2120 }
2121 }
2122}
2123#[derive(Debug, Clone, Copy, PartialEq)]
2124pub enum DspFlange {
2125 Mix,
2126 Depth,
2127 Rate,
2128}
2129impl From<DspFlange> for ffi::FMOD_DSP_FLANGE {
2130 fn from(value: DspFlange) -> ffi::FMOD_DSP_FLANGE {
2131 match value {
2132 DspFlange::Mix => ffi::FMOD_DSP_FLANGE_MIX,
2133 DspFlange::Depth => ffi::FMOD_DSP_FLANGE_DEPTH,
2134 DspFlange::Rate => ffi::FMOD_DSP_FLANGE_RATE,
2135 }
2136 }
2137}
2138impl DspFlange {
2139 pub fn from(value: ffi::FMOD_DSP_FLANGE) -> Result<DspFlange, Error> {
2140 match value {
2141 ffi::FMOD_DSP_FLANGE_MIX => Ok(DspFlange::Mix),
2142 ffi::FMOD_DSP_FLANGE_DEPTH => Ok(DspFlange::Depth),
2143 ffi::FMOD_DSP_FLANGE_RATE => Ok(DspFlange::Rate),
2144 _ => Err(err_enum!("FMOD_DSP_FLANGE", value)),
2145 }
2146 }
2147}
2148#[derive(Debug, Clone, Copy, PartialEq)]
2149pub enum DspDistortion {
2150 Level,
2151}
2152impl From<DspDistortion> for ffi::FMOD_DSP_DISTORTION {
2153 fn from(value: DspDistortion) -> ffi::FMOD_DSP_DISTORTION {
2154 match value {
2155 DspDistortion::Level => ffi::FMOD_DSP_DISTORTION_LEVEL,
2156 }
2157 }
2158}
2159impl DspDistortion {
2160 pub fn from(value: ffi::FMOD_DSP_DISTORTION) -> Result<DspDistortion, Error> {
2161 match value {
2162 ffi::FMOD_DSP_DISTORTION_LEVEL => Ok(DspDistortion::Level),
2163 _ => Err(err_enum!("FMOD_DSP_DISTORTION", value)),
2164 }
2165 }
2166}
2167#[derive(Debug, Clone, Copy, PartialEq)]
2168pub enum DspNormalize {
2169 FadeTime,
2170 Threshold,
2171 MaxAmp,
2172}
2173impl From<DspNormalize> for ffi::FMOD_DSP_NORMALIZE {
2174 fn from(value: DspNormalize) -> ffi::FMOD_DSP_NORMALIZE {
2175 match value {
2176 DspNormalize::FadeTime => ffi::FMOD_DSP_NORMALIZE_FADETIME,
2177 DspNormalize::Threshold => ffi::FMOD_DSP_NORMALIZE_THRESHOLD,
2178 DspNormalize::MaxAmp => ffi::FMOD_DSP_NORMALIZE_MAXAMP,
2179 }
2180 }
2181}
2182impl DspNormalize {
2183 pub fn from(value: ffi::FMOD_DSP_NORMALIZE) -> Result<DspNormalize, Error> {
2184 match value {
2185 ffi::FMOD_DSP_NORMALIZE_FADETIME => Ok(DspNormalize::FadeTime),
2186 ffi::FMOD_DSP_NORMALIZE_THRESHOLD => Ok(DspNormalize::Threshold),
2187 ffi::FMOD_DSP_NORMALIZE_MAXAMP => Ok(DspNormalize::MaxAmp),
2188 _ => Err(err_enum!("FMOD_DSP_NORMALIZE", value)),
2189 }
2190 }
2191}
2192#[derive(Debug, Clone, Copy, PartialEq)]
2193pub enum DspLimiter {
2194 ReleaseTime,
2195 Ceiling,
2196 MaximizerGain,
2197 Mode,
2198}
2199impl From<DspLimiter> for ffi::FMOD_DSP_LIMITER {
2200 fn from(value: DspLimiter) -> ffi::FMOD_DSP_LIMITER {
2201 match value {
2202 DspLimiter::ReleaseTime => ffi::FMOD_DSP_LIMITER_RELEASETIME,
2203 DspLimiter::Ceiling => ffi::FMOD_DSP_LIMITER_CEILING,
2204 DspLimiter::MaximizerGain => ffi::FMOD_DSP_LIMITER_MAXIMIZERGAIN,
2205 DspLimiter::Mode => ffi::FMOD_DSP_LIMITER_MODE,
2206 }
2207 }
2208}
2209impl DspLimiter {
2210 pub fn from(value: ffi::FMOD_DSP_LIMITER) -> Result<DspLimiter, Error> {
2211 match value {
2212 ffi::FMOD_DSP_LIMITER_RELEASETIME => Ok(DspLimiter::ReleaseTime),
2213 ffi::FMOD_DSP_LIMITER_CEILING => Ok(DspLimiter::Ceiling),
2214 ffi::FMOD_DSP_LIMITER_MAXIMIZERGAIN => Ok(DspLimiter::MaximizerGain),
2215 ffi::FMOD_DSP_LIMITER_MODE => Ok(DspLimiter::Mode),
2216 _ => Err(err_enum!("FMOD_DSP_LIMITER", value)),
2217 }
2218 }
2219}
2220#[derive(Debug, Clone, Copy, PartialEq)]
2221pub enum DspParameq {
2222 Center,
2223 Bandwidth,
2224 Gain,
2225}
2226impl From<DspParameq> for ffi::FMOD_DSP_PARAMEQ {
2227 fn from(value: DspParameq) -> ffi::FMOD_DSP_PARAMEQ {
2228 match value {
2229 DspParameq::Center => ffi::FMOD_DSP_PARAMEQ_CENTER,
2230 DspParameq::Bandwidth => ffi::FMOD_DSP_PARAMEQ_BANDWIDTH,
2231 DspParameq::Gain => ffi::FMOD_DSP_PARAMEQ_GAIN,
2232 }
2233 }
2234}
2235impl DspParameq {
2236 pub fn from(value: ffi::FMOD_DSP_PARAMEQ) -> Result<DspParameq, Error> {
2237 match value {
2238 ffi::FMOD_DSP_PARAMEQ_CENTER => Ok(DspParameq::Center),
2239 ffi::FMOD_DSP_PARAMEQ_BANDWIDTH => Ok(DspParameq::Bandwidth),
2240 ffi::FMOD_DSP_PARAMEQ_GAIN => Ok(DspParameq::Gain),
2241 _ => Err(err_enum!("FMOD_DSP_PARAMEQ", value)),
2242 }
2243 }
2244}
2245#[derive(Debug, Clone, Copy, PartialEq)]
2246pub enum DspMultibandEq {
2247 AFilter,
2248 AFrequency,
2249 AQ,
2250 AGain,
2251 BFilter,
2252 BFrequency,
2253 BQ,
2254 BGain,
2255 CFilter,
2256 CFrequency,
2257 CQ,
2258 CGain,
2259 DFilter,
2260 DFrequency,
2261 DQ,
2262 DGain,
2263 EFilter,
2264 EFrequency,
2265 EQ,
2266 EGain,
2267}
2268impl From<DspMultibandEq> for ffi::FMOD_DSP_MULTIBAND_EQ {
2269 fn from(value: DspMultibandEq) -> ffi::FMOD_DSP_MULTIBAND_EQ {
2270 match value {
2271 DspMultibandEq::AFilter => ffi::FMOD_DSP_MULTIBAND_EQ_A_FILTER,
2272 DspMultibandEq::AFrequency => ffi::FMOD_DSP_MULTIBAND_EQ_A_FREQUENCY,
2273 DspMultibandEq::AQ => ffi::FMOD_DSP_MULTIBAND_EQ_A_Q,
2274 DspMultibandEq::AGain => ffi::FMOD_DSP_MULTIBAND_EQ_A_GAIN,
2275 DspMultibandEq::BFilter => ffi::FMOD_DSP_MULTIBAND_EQ_B_FILTER,
2276 DspMultibandEq::BFrequency => ffi::FMOD_DSP_MULTIBAND_EQ_B_FREQUENCY,
2277 DspMultibandEq::BQ => ffi::FMOD_DSP_MULTIBAND_EQ_B_Q,
2278 DspMultibandEq::BGain => ffi::FMOD_DSP_MULTIBAND_EQ_B_GAIN,
2279 DspMultibandEq::CFilter => ffi::FMOD_DSP_MULTIBAND_EQ_C_FILTER,
2280 DspMultibandEq::CFrequency => ffi::FMOD_DSP_MULTIBAND_EQ_C_FREQUENCY,
2281 DspMultibandEq::CQ => ffi::FMOD_DSP_MULTIBAND_EQ_C_Q,
2282 DspMultibandEq::CGain => ffi::FMOD_DSP_MULTIBAND_EQ_C_GAIN,
2283 DspMultibandEq::DFilter => ffi::FMOD_DSP_MULTIBAND_EQ_D_FILTER,
2284 DspMultibandEq::DFrequency => ffi::FMOD_DSP_MULTIBAND_EQ_D_FREQUENCY,
2285 DspMultibandEq::DQ => ffi::FMOD_DSP_MULTIBAND_EQ_D_Q,
2286 DspMultibandEq::DGain => ffi::FMOD_DSP_MULTIBAND_EQ_D_GAIN,
2287 DspMultibandEq::EFilter => ffi::FMOD_DSP_MULTIBAND_EQ_E_FILTER,
2288 DspMultibandEq::EFrequency => ffi::FMOD_DSP_MULTIBAND_EQ_E_FREQUENCY,
2289 DspMultibandEq::EQ => ffi::FMOD_DSP_MULTIBAND_EQ_E_Q,
2290 DspMultibandEq::EGain => ffi::FMOD_DSP_MULTIBAND_EQ_E_GAIN,
2291 }
2292 }
2293}
2294impl DspMultibandEq {
2295 pub fn from(value: ffi::FMOD_DSP_MULTIBAND_EQ) -> Result<DspMultibandEq, Error> {
2296 match value {
2297 ffi::FMOD_DSP_MULTIBAND_EQ_A_FILTER => Ok(DspMultibandEq::AFilter),
2298 ffi::FMOD_DSP_MULTIBAND_EQ_A_FREQUENCY => Ok(DspMultibandEq::AFrequency),
2299 ffi::FMOD_DSP_MULTIBAND_EQ_A_Q => Ok(DspMultibandEq::AQ),
2300 ffi::FMOD_DSP_MULTIBAND_EQ_A_GAIN => Ok(DspMultibandEq::AGain),
2301 ffi::FMOD_DSP_MULTIBAND_EQ_B_FILTER => Ok(DspMultibandEq::BFilter),
2302 ffi::FMOD_DSP_MULTIBAND_EQ_B_FREQUENCY => Ok(DspMultibandEq::BFrequency),
2303 ffi::FMOD_DSP_MULTIBAND_EQ_B_Q => Ok(DspMultibandEq::BQ),
2304 ffi::FMOD_DSP_MULTIBAND_EQ_B_GAIN => Ok(DspMultibandEq::BGain),
2305 ffi::FMOD_DSP_MULTIBAND_EQ_C_FILTER => Ok(DspMultibandEq::CFilter),
2306 ffi::FMOD_DSP_MULTIBAND_EQ_C_FREQUENCY => Ok(DspMultibandEq::CFrequency),
2307 ffi::FMOD_DSP_MULTIBAND_EQ_C_Q => Ok(DspMultibandEq::CQ),
2308 ffi::FMOD_DSP_MULTIBAND_EQ_C_GAIN => Ok(DspMultibandEq::CGain),
2309 ffi::FMOD_DSP_MULTIBAND_EQ_D_FILTER => Ok(DspMultibandEq::DFilter),
2310 ffi::FMOD_DSP_MULTIBAND_EQ_D_FREQUENCY => Ok(DspMultibandEq::DFrequency),
2311 ffi::FMOD_DSP_MULTIBAND_EQ_D_Q => Ok(DspMultibandEq::DQ),
2312 ffi::FMOD_DSP_MULTIBAND_EQ_D_GAIN => Ok(DspMultibandEq::DGain),
2313 ffi::FMOD_DSP_MULTIBAND_EQ_E_FILTER => Ok(DspMultibandEq::EFilter),
2314 ffi::FMOD_DSP_MULTIBAND_EQ_E_FREQUENCY => Ok(DspMultibandEq::EFrequency),
2315 ffi::FMOD_DSP_MULTIBAND_EQ_E_Q => Ok(DspMultibandEq::EQ),
2316 ffi::FMOD_DSP_MULTIBAND_EQ_E_GAIN => Ok(DspMultibandEq::EGain),
2317 _ => Err(err_enum!("FMOD_DSP_MULTIBAND_EQ", value)),
2318 }
2319 }
2320}
2321#[derive(Debug, Clone, Copy, PartialEq)]
2322pub enum DspMultibandEqFilterType {
2323 Disabled,
2324 Lowpass12Db,
2325 Lowpass24Db,
2326 Lowpass48Db,
2327 Highpass12Db,
2328 Highpass24Db,
2329 Highpass48Db,
2330 LowShelf,
2331 HighShelf,
2332 Peaking,
2333 Bandpass,
2334 Notch,
2335 AllPass,
2336}
2337impl From<DspMultibandEqFilterType> for ffi::FMOD_DSP_MULTIBAND_EQ_FILTER_TYPE {
2338 fn from(value: DspMultibandEqFilterType) -> ffi::FMOD_DSP_MULTIBAND_EQ_FILTER_TYPE {
2339 match value {
2340 DspMultibandEqFilterType::Disabled => ffi::FMOD_DSP_MULTIBAND_EQ_FILTER_DISABLED,
2341 DspMultibandEqFilterType::Lowpass12Db => ffi::FMOD_DSP_MULTIBAND_EQ_FILTER_LOWPASS_12DB,
2342 DspMultibandEqFilterType::Lowpass24Db => ffi::FMOD_DSP_MULTIBAND_EQ_FILTER_LOWPASS_24DB,
2343 DspMultibandEqFilterType::Lowpass48Db => ffi::FMOD_DSP_MULTIBAND_EQ_FILTER_LOWPASS_48DB,
2344 DspMultibandEqFilterType::Highpass12Db => {
2345 ffi::FMOD_DSP_MULTIBAND_EQ_FILTER_HIGHPASS_12DB
2346 }
2347 DspMultibandEqFilterType::Highpass24Db => {
2348 ffi::FMOD_DSP_MULTIBAND_EQ_FILTER_HIGHPASS_24DB
2349 }
2350 DspMultibandEqFilterType::Highpass48Db => {
2351 ffi::FMOD_DSP_MULTIBAND_EQ_FILTER_HIGHPASS_48DB
2352 }
2353 DspMultibandEqFilterType::LowShelf => ffi::FMOD_DSP_MULTIBAND_EQ_FILTER_LOWSHELF,
2354 DspMultibandEqFilterType::HighShelf => ffi::FMOD_DSP_MULTIBAND_EQ_FILTER_HIGHSHELF,
2355 DspMultibandEqFilterType::Peaking => ffi::FMOD_DSP_MULTIBAND_EQ_FILTER_PEAKING,
2356 DspMultibandEqFilterType::Bandpass => ffi::FMOD_DSP_MULTIBAND_EQ_FILTER_BANDPASS,
2357 DspMultibandEqFilterType::Notch => ffi::FMOD_DSP_MULTIBAND_EQ_FILTER_NOTCH,
2358 DspMultibandEqFilterType::AllPass => ffi::FMOD_DSP_MULTIBAND_EQ_FILTER_ALLPASS,
2359 }
2360 }
2361}
2362impl DspMultibandEqFilterType {
2363 pub fn from(
2364 value: ffi::FMOD_DSP_MULTIBAND_EQ_FILTER_TYPE,
2365 ) -> Result<DspMultibandEqFilterType, Error> {
2366 match value {
2367 ffi::FMOD_DSP_MULTIBAND_EQ_FILTER_DISABLED => Ok(DspMultibandEqFilterType::Disabled),
2368 ffi::FMOD_DSP_MULTIBAND_EQ_FILTER_LOWPASS_12DB => {
2369 Ok(DspMultibandEqFilterType::Lowpass12Db)
2370 }
2371 ffi::FMOD_DSP_MULTIBAND_EQ_FILTER_LOWPASS_24DB => {
2372 Ok(DspMultibandEqFilterType::Lowpass24Db)
2373 }
2374 ffi::FMOD_DSP_MULTIBAND_EQ_FILTER_LOWPASS_48DB => {
2375 Ok(DspMultibandEqFilterType::Lowpass48Db)
2376 }
2377 ffi::FMOD_DSP_MULTIBAND_EQ_FILTER_HIGHPASS_12DB => {
2378 Ok(DspMultibandEqFilterType::Highpass12Db)
2379 }
2380 ffi::FMOD_DSP_MULTIBAND_EQ_FILTER_HIGHPASS_24DB => {
2381 Ok(DspMultibandEqFilterType::Highpass24Db)
2382 }
2383 ffi::FMOD_DSP_MULTIBAND_EQ_FILTER_HIGHPASS_48DB => {
2384 Ok(DspMultibandEqFilterType::Highpass48Db)
2385 }
2386 ffi::FMOD_DSP_MULTIBAND_EQ_FILTER_LOWSHELF => Ok(DspMultibandEqFilterType::LowShelf),
2387 ffi::FMOD_DSP_MULTIBAND_EQ_FILTER_HIGHSHELF => Ok(DspMultibandEqFilterType::HighShelf),
2388 ffi::FMOD_DSP_MULTIBAND_EQ_FILTER_PEAKING => Ok(DspMultibandEqFilterType::Peaking),
2389 ffi::FMOD_DSP_MULTIBAND_EQ_FILTER_BANDPASS => Ok(DspMultibandEqFilterType::Bandpass),
2390 ffi::FMOD_DSP_MULTIBAND_EQ_FILTER_NOTCH => Ok(DspMultibandEqFilterType::Notch),
2391 ffi::FMOD_DSP_MULTIBAND_EQ_FILTER_ALLPASS => Ok(DspMultibandEqFilterType::AllPass),
2392 _ => Err(err_enum!("FMOD_DSP_MULTIBAND_EQ_FILTER_TYPE", value)),
2393 }
2394 }
2395}
2396#[derive(Debug, Clone, Copy, PartialEq)]
2397pub enum DspPitchShift {
2398 Pitch,
2399 FftSize,
2400 Overlap,
2401 MaxChannels,
2402}
2403impl From<DspPitchShift> for ffi::FMOD_DSP_PITCHSHIFT {
2404 fn from(value: DspPitchShift) -> ffi::FMOD_DSP_PITCHSHIFT {
2405 match value {
2406 DspPitchShift::Pitch => ffi::FMOD_DSP_PITCHSHIFT_PITCH,
2407 DspPitchShift::FftSize => ffi::FMOD_DSP_PITCHSHIFT_FFTSIZE,
2408 DspPitchShift::Overlap => ffi::FMOD_DSP_PITCHSHIFT_OVERLAP,
2409 DspPitchShift::MaxChannels => ffi::FMOD_DSP_PITCHSHIFT_MAXCHANNELS,
2410 }
2411 }
2412}
2413impl DspPitchShift {
2414 pub fn from(value: ffi::FMOD_DSP_PITCHSHIFT) -> Result<DspPitchShift, Error> {
2415 match value {
2416 ffi::FMOD_DSP_PITCHSHIFT_PITCH => Ok(DspPitchShift::Pitch),
2417 ffi::FMOD_DSP_PITCHSHIFT_FFTSIZE => Ok(DspPitchShift::FftSize),
2418 ffi::FMOD_DSP_PITCHSHIFT_OVERLAP => Ok(DspPitchShift::Overlap),
2419 ffi::FMOD_DSP_PITCHSHIFT_MAXCHANNELS => Ok(DspPitchShift::MaxChannels),
2420 _ => Err(err_enum!("FMOD_DSP_PITCHSHIFT", value)),
2421 }
2422 }
2423}
2424#[derive(Debug, Clone, Copy, PartialEq)]
2425pub enum DspChorus {
2426 Mix,
2427 Rate,
2428 Depth,
2429}
2430impl From<DspChorus> for ffi::FMOD_DSP_CHORUS {
2431 fn from(value: DspChorus) -> ffi::FMOD_DSP_CHORUS {
2432 match value {
2433 DspChorus::Mix => ffi::FMOD_DSP_CHORUS_MIX,
2434 DspChorus::Rate => ffi::FMOD_DSP_CHORUS_RATE,
2435 DspChorus::Depth => ffi::FMOD_DSP_CHORUS_DEPTH,
2436 }
2437 }
2438}
2439impl DspChorus {
2440 pub fn from(value: ffi::FMOD_DSP_CHORUS) -> Result<DspChorus, Error> {
2441 match value {
2442 ffi::FMOD_DSP_CHORUS_MIX => Ok(DspChorus::Mix),
2443 ffi::FMOD_DSP_CHORUS_RATE => Ok(DspChorus::Rate),
2444 ffi::FMOD_DSP_CHORUS_DEPTH => Ok(DspChorus::Depth),
2445 _ => Err(err_enum!("FMOD_DSP_CHORUS", value)),
2446 }
2447 }
2448}
2449#[derive(Debug, Clone, Copy, PartialEq)]
2450pub enum DspItEcho {
2451 WetDryMix,
2452 Feedback,
2453 LeftDelay,
2454 RightDelay,
2455 PanDelay,
2456}
2457impl From<DspItEcho> for ffi::FMOD_DSP_ITECHO {
2458 fn from(value: DspItEcho) -> ffi::FMOD_DSP_ITECHO {
2459 match value {
2460 DspItEcho::WetDryMix => ffi::FMOD_DSP_ITECHO_WETDRYMIX,
2461 DspItEcho::Feedback => ffi::FMOD_DSP_ITECHO_FEEDBACK,
2462 DspItEcho::LeftDelay => ffi::FMOD_DSP_ITECHO_LEFTDELAY,
2463 DspItEcho::RightDelay => ffi::FMOD_DSP_ITECHO_RIGHTDELAY,
2464 DspItEcho::PanDelay => ffi::FMOD_DSP_ITECHO_PANDELAY,
2465 }
2466 }
2467}
2468impl DspItEcho {
2469 pub fn from(value: ffi::FMOD_DSP_ITECHO) -> Result<DspItEcho, Error> {
2470 match value {
2471 ffi::FMOD_DSP_ITECHO_WETDRYMIX => Ok(DspItEcho::WetDryMix),
2472 ffi::FMOD_DSP_ITECHO_FEEDBACK => Ok(DspItEcho::Feedback),
2473 ffi::FMOD_DSP_ITECHO_LEFTDELAY => Ok(DspItEcho::LeftDelay),
2474 ffi::FMOD_DSP_ITECHO_RIGHTDELAY => Ok(DspItEcho::RightDelay),
2475 ffi::FMOD_DSP_ITECHO_PANDELAY => Ok(DspItEcho::PanDelay),
2476 _ => Err(err_enum!("FMOD_DSP_ITECHO", value)),
2477 }
2478 }
2479}
2480#[derive(Debug, Clone, Copy, PartialEq)]
2481pub enum DspCompressor {
2482 Threshold,
2483 Ratio,
2484 Attack,
2485 Release,
2486 GainMakeup,
2487 UseSidechain,
2488 Linked,
2489}
2490impl From<DspCompressor> for ffi::FMOD_DSP_COMPRESSOR {
2491 fn from(value: DspCompressor) -> ffi::FMOD_DSP_COMPRESSOR {
2492 match value {
2493 DspCompressor::Threshold => ffi::FMOD_DSP_COMPRESSOR_THRESHOLD,
2494 DspCompressor::Ratio => ffi::FMOD_DSP_COMPRESSOR_RATIO,
2495 DspCompressor::Attack => ffi::FMOD_DSP_COMPRESSOR_ATTACK,
2496 DspCompressor::Release => ffi::FMOD_DSP_COMPRESSOR_RELEASE,
2497 DspCompressor::GainMakeup => ffi::FMOD_DSP_COMPRESSOR_GAINMAKEUP,
2498 DspCompressor::UseSidechain => ffi::FMOD_DSP_COMPRESSOR_USESIDECHAIN,
2499 DspCompressor::Linked => ffi::FMOD_DSP_COMPRESSOR_LINKED,
2500 }
2501 }
2502}
2503impl DspCompressor {
2504 pub fn from(value: ffi::FMOD_DSP_COMPRESSOR) -> Result<DspCompressor, Error> {
2505 match value {
2506 ffi::FMOD_DSP_COMPRESSOR_THRESHOLD => Ok(DspCompressor::Threshold),
2507 ffi::FMOD_DSP_COMPRESSOR_RATIO => Ok(DspCompressor::Ratio),
2508 ffi::FMOD_DSP_COMPRESSOR_ATTACK => Ok(DspCompressor::Attack),
2509 ffi::FMOD_DSP_COMPRESSOR_RELEASE => Ok(DspCompressor::Release),
2510 ffi::FMOD_DSP_COMPRESSOR_GAINMAKEUP => Ok(DspCompressor::GainMakeup),
2511 ffi::FMOD_DSP_COMPRESSOR_USESIDECHAIN => Ok(DspCompressor::UseSidechain),
2512 ffi::FMOD_DSP_COMPRESSOR_LINKED => Ok(DspCompressor::Linked),
2513 _ => Err(err_enum!("FMOD_DSP_COMPRESSOR", value)),
2514 }
2515 }
2516}
2517#[derive(Debug, Clone, Copy, PartialEq)]
2518pub enum DspSfxReverb {
2519 DecayTime,
2520 EarlyDelay,
2521 LateDelay,
2522 HfReference,
2523 HfDecayRatio,
2524 Diffusion,
2525 Density,
2526 LowShelfFrequency,
2527 LowShelfGain,
2528 HighCut,
2529 EarlyLateMix,
2530 WetLevel,
2531 DryLevel,
2532}
2533impl From<DspSfxReverb> for ffi::FMOD_DSP_SFXREVERB {
2534 fn from(value: DspSfxReverb) -> ffi::FMOD_DSP_SFXREVERB {
2535 match value {
2536 DspSfxReverb::DecayTime => ffi::FMOD_DSP_SFXREVERB_DECAYTIME,
2537 DspSfxReverb::EarlyDelay => ffi::FMOD_DSP_SFXREVERB_EARLYDELAY,
2538 DspSfxReverb::LateDelay => ffi::FMOD_DSP_SFXREVERB_LATEDELAY,
2539 DspSfxReverb::HfReference => ffi::FMOD_DSP_SFXREVERB_HFREFERENCE,
2540 DspSfxReverb::HfDecayRatio => ffi::FMOD_DSP_SFXREVERB_HFDECAYRATIO,
2541 DspSfxReverb::Diffusion => ffi::FMOD_DSP_SFXREVERB_DIFFUSION,
2542 DspSfxReverb::Density => ffi::FMOD_DSP_SFXREVERB_DENSITY,
2543 DspSfxReverb::LowShelfFrequency => ffi::FMOD_DSP_SFXREVERB_LOWSHELFFREQUENCY,
2544 DspSfxReverb::LowShelfGain => ffi::FMOD_DSP_SFXREVERB_LOWSHELFGAIN,
2545 DspSfxReverb::HighCut => ffi::FMOD_DSP_SFXREVERB_HIGHCUT,
2546 DspSfxReverb::EarlyLateMix => ffi::FMOD_DSP_SFXREVERB_EARLYLATEMIX,
2547 DspSfxReverb::WetLevel => ffi::FMOD_DSP_SFXREVERB_WETLEVEL,
2548 DspSfxReverb::DryLevel => ffi::FMOD_DSP_SFXREVERB_DRYLEVEL,
2549 }
2550 }
2551}
2552impl DspSfxReverb {
2553 pub fn from(value: ffi::FMOD_DSP_SFXREVERB) -> Result<DspSfxReverb, Error> {
2554 match value {
2555 ffi::FMOD_DSP_SFXREVERB_DECAYTIME => Ok(DspSfxReverb::DecayTime),
2556 ffi::FMOD_DSP_SFXREVERB_EARLYDELAY => Ok(DspSfxReverb::EarlyDelay),
2557 ffi::FMOD_DSP_SFXREVERB_LATEDELAY => Ok(DspSfxReverb::LateDelay),
2558 ffi::FMOD_DSP_SFXREVERB_HFREFERENCE => Ok(DspSfxReverb::HfReference),
2559 ffi::FMOD_DSP_SFXREVERB_HFDECAYRATIO => Ok(DspSfxReverb::HfDecayRatio),
2560 ffi::FMOD_DSP_SFXREVERB_DIFFUSION => Ok(DspSfxReverb::Diffusion),
2561 ffi::FMOD_DSP_SFXREVERB_DENSITY => Ok(DspSfxReverb::Density),
2562 ffi::FMOD_DSP_SFXREVERB_LOWSHELFFREQUENCY => Ok(DspSfxReverb::LowShelfFrequency),
2563 ffi::FMOD_DSP_SFXREVERB_LOWSHELFGAIN => Ok(DspSfxReverb::LowShelfGain),
2564 ffi::FMOD_DSP_SFXREVERB_HIGHCUT => Ok(DspSfxReverb::HighCut),
2565 ffi::FMOD_DSP_SFXREVERB_EARLYLATEMIX => Ok(DspSfxReverb::EarlyLateMix),
2566 ffi::FMOD_DSP_SFXREVERB_WETLEVEL => Ok(DspSfxReverb::WetLevel),
2567 ffi::FMOD_DSP_SFXREVERB_DRYLEVEL => Ok(DspSfxReverb::DryLevel),
2568 _ => Err(err_enum!("FMOD_DSP_SFXREVERB", value)),
2569 }
2570 }
2571}
2572#[derive(Debug, Clone, Copy, PartialEq)]
2573pub enum DspLowPassSimple {
2574 Cutoff,
2575}
2576impl From<DspLowPassSimple> for ffi::FMOD_DSP_LOWPASS_SIMPLE {
2577 fn from(value: DspLowPassSimple) -> ffi::FMOD_DSP_LOWPASS_SIMPLE {
2578 match value {
2579 DspLowPassSimple::Cutoff => ffi::FMOD_DSP_LOWPASS_SIMPLE_CUTOFF,
2580 }
2581 }
2582}
2583impl DspLowPassSimple {
2584 pub fn from(value: ffi::FMOD_DSP_LOWPASS_SIMPLE) -> Result<DspLowPassSimple, Error> {
2585 match value {
2586 ffi::FMOD_DSP_LOWPASS_SIMPLE_CUTOFF => Ok(DspLowPassSimple::Cutoff),
2587 _ => Err(err_enum!("FMOD_DSP_LOWPASS_SIMPLE", value)),
2588 }
2589 }
2590}
2591#[derive(Debug, Clone, Copy, PartialEq)]
2592pub enum DspDelay {
2593 Ch0,
2594 Ch1,
2595 Ch2,
2596 Ch3,
2597 Ch4,
2598 Ch5,
2599 Ch6,
2600 Ch7,
2601 Ch8,
2602 Ch9,
2603 Ch10,
2604 Ch11,
2605 Ch12,
2606 Ch13,
2607 Ch14,
2608 Ch15,
2609 MaxDelay,
2610}
2611impl From<DspDelay> for ffi::FMOD_DSP_DELAY {
2612 fn from(value: DspDelay) -> ffi::FMOD_DSP_DELAY {
2613 match value {
2614 DspDelay::Ch0 => ffi::FMOD_DSP_DELAY_CH0,
2615 DspDelay::Ch1 => ffi::FMOD_DSP_DELAY_CH1,
2616 DspDelay::Ch2 => ffi::FMOD_DSP_DELAY_CH2,
2617 DspDelay::Ch3 => ffi::FMOD_DSP_DELAY_CH3,
2618 DspDelay::Ch4 => ffi::FMOD_DSP_DELAY_CH4,
2619 DspDelay::Ch5 => ffi::FMOD_DSP_DELAY_CH5,
2620 DspDelay::Ch6 => ffi::FMOD_DSP_DELAY_CH6,
2621 DspDelay::Ch7 => ffi::FMOD_DSP_DELAY_CH7,
2622 DspDelay::Ch8 => ffi::FMOD_DSP_DELAY_CH8,
2623 DspDelay::Ch9 => ffi::FMOD_DSP_DELAY_CH9,
2624 DspDelay::Ch10 => ffi::FMOD_DSP_DELAY_CH10,
2625 DspDelay::Ch11 => ffi::FMOD_DSP_DELAY_CH11,
2626 DspDelay::Ch12 => ffi::FMOD_DSP_DELAY_CH12,
2627 DspDelay::Ch13 => ffi::FMOD_DSP_DELAY_CH13,
2628 DspDelay::Ch14 => ffi::FMOD_DSP_DELAY_CH14,
2629 DspDelay::Ch15 => ffi::FMOD_DSP_DELAY_CH15,
2630 DspDelay::MaxDelay => ffi::FMOD_DSP_DELAY_MAXDELAY,
2631 }
2632 }
2633}
2634impl DspDelay {
2635 pub fn from(value: ffi::FMOD_DSP_DELAY) -> Result<DspDelay, Error> {
2636 match value {
2637 ffi::FMOD_DSP_DELAY_CH0 => Ok(DspDelay::Ch0),
2638 ffi::FMOD_DSP_DELAY_CH1 => Ok(DspDelay::Ch1),
2639 ffi::FMOD_DSP_DELAY_CH2 => Ok(DspDelay::Ch2),
2640 ffi::FMOD_DSP_DELAY_CH3 => Ok(DspDelay::Ch3),
2641 ffi::FMOD_DSP_DELAY_CH4 => Ok(DspDelay::Ch4),
2642 ffi::FMOD_DSP_DELAY_CH5 => Ok(DspDelay::Ch5),
2643 ffi::FMOD_DSP_DELAY_CH6 => Ok(DspDelay::Ch6),
2644 ffi::FMOD_DSP_DELAY_CH7 => Ok(DspDelay::Ch7),
2645 ffi::FMOD_DSP_DELAY_CH8 => Ok(DspDelay::Ch8),
2646 ffi::FMOD_DSP_DELAY_CH9 => Ok(DspDelay::Ch9),
2647 ffi::FMOD_DSP_DELAY_CH10 => Ok(DspDelay::Ch10),
2648 ffi::FMOD_DSP_DELAY_CH11 => Ok(DspDelay::Ch11),
2649 ffi::FMOD_DSP_DELAY_CH12 => Ok(DspDelay::Ch12),
2650 ffi::FMOD_DSP_DELAY_CH13 => Ok(DspDelay::Ch13),
2651 ffi::FMOD_DSP_DELAY_CH14 => Ok(DspDelay::Ch14),
2652 ffi::FMOD_DSP_DELAY_CH15 => Ok(DspDelay::Ch15),
2653 ffi::FMOD_DSP_DELAY_MAXDELAY => Ok(DspDelay::MaxDelay),
2654 _ => Err(err_enum!("FMOD_DSP_DELAY", value)),
2655 }
2656 }
2657}
2658#[derive(Debug, Clone, Copy, PartialEq)]
2659pub enum DspTremolo {
2660 Frequency,
2661 Depth,
2662 Shape,
2663 Skew,
2664 Duty,
2665 Square,
2666 Phase,
2667 Spread,
2668}
2669impl From<DspTremolo> for ffi::FMOD_DSP_TREMOLO {
2670 fn from(value: DspTremolo) -> ffi::FMOD_DSP_TREMOLO {
2671 match value {
2672 DspTremolo::Frequency => ffi::FMOD_DSP_TREMOLO_FREQUENCY,
2673 DspTremolo::Depth => ffi::FMOD_DSP_TREMOLO_DEPTH,
2674 DspTremolo::Shape => ffi::FMOD_DSP_TREMOLO_SHAPE,
2675 DspTremolo::Skew => ffi::FMOD_DSP_TREMOLO_SKEW,
2676 DspTremolo::Duty => ffi::FMOD_DSP_TREMOLO_DUTY,
2677 DspTremolo::Square => ffi::FMOD_DSP_TREMOLO_SQUARE,
2678 DspTremolo::Phase => ffi::FMOD_DSP_TREMOLO_PHASE,
2679 DspTremolo::Spread => ffi::FMOD_DSP_TREMOLO_SPREAD,
2680 }
2681 }
2682}
2683impl DspTremolo {
2684 pub fn from(value: ffi::FMOD_DSP_TREMOLO) -> Result<DspTremolo, Error> {
2685 match value {
2686 ffi::FMOD_DSP_TREMOLO_FREQUENCY => Ok(DspTremolo::Frequency),
2687 ffi::FMOD_DSP_TREMOLO_DEPTH => Ok(DspTremolo::Depth),
2688 ffi::FMOD_DSP_TREMOLO_SHAPE => Ok(DspTremolo::Shape),
2689 ffi::FMOD_DSP_TREMOLO_SKEW => Ok(DspTremolo::Skew),
2690 ffi::FMOD_DSP_TREMOLO_DUTY => Ok(DspTremolo::Duty),
2691 ffi::FMOD_DSP_TREMOLO_SQUARE => Ok(DspTremolo::Square),
2692 ffi::FMOD_DSP_TREMOLO_PHASE => Ok(DspTremolo::Phase),
2693 ffi::FMOD_DSP_TREMOLO_SPREAD => Ok(DspTremolo::Spread),
2694 _ => Err(err_enum!("FMOD_DSP_TREMOLO", value)),
2695 }
2696 }
2697}
2698#[derive(Debug, Clone, Copy, PartialEq)]
2699pub enum DspSend {
2700 ReturnId,
2701 Level,
2702}
2703impl From<DspSend> for ffi::FMOD_DSP_SEND {
2704 fn from(value: DspSend) -> ffi::FMOD_DSP_SEND {
2705 match value {
2706 DspSend::ReturnId => ffi::FMOD_DSP_SEND_RETURNID,
2707 DspSend::Level => ffi::FMOD_DSP_SEND_LEVEL,
2708 }
2709 }
2710}
2711impl DspSend {
2712 pub fn from(value: ffi::FMOD_DSP_SEND) -> Result<DspSend, Error> {
2713 match value {
2714 ffi::FMOD_DSP_SEND_RETURNID => Ok(DspSend::ReturnId),
2715 ffi::FMOD_DSP_SEND_LEVEL => Ok(DspSend::Level),
2716 _ => Err(err_enum!("FMOD_DSP_SEND", value)),
2717 }
2718 }
2719}
2720#[derive(Debug, Clone, Copy, PartialEq)]
2721pub enum DspReturn {
2722 Id,
2723 InputSpeakerMode,
2724}
2725impl From<DspReturn> for ffi::FMOD_DSP_RETURN {
2726 fn from(value: DspReturn) -> ffi::FMOD_DSP_RETURN {
2727 match value {
2728 DspReturn::Id => ffi::FMOD_DSP_RETURN_ID,
2729 DspReturn::InputSpeakerMode => ffi::FMOD_DSP_RETURN_INPUT_SPEAKER_MODE,
2730 }
2731 }
2732}
2733impl DspReturn {
2734 pub fn from(value: ffi::FMOD_DSP_RETURN) -> Result<DspReturn, Error> {
2735 match value {
2736 ffi::FMOD_DSP_RETURN_ID => Ok(DspReturn::Id),
2737 ffi::FMOD_DSP_RETURN_INPUT_SPEAKER_MODE => Ok(DspReturn::InputSpeakerMode),
2738 _ => Err(err_enum!("FMOD_DSP_RETURN", value)),
2739 }
2740 }
2741}
2742#[derive(Debug, Clone, Copy, PartialEq)]
2743pub enum DspHighpassSimple {
2744 Cutoff,
2745}
2746impl From<DspHighpassSimple> for ffi::FMOD_DSP_HIGHPASS_SIMPLE {
2747 fn from(value: DspHighpassSimple) -> ffi::FMOD_DSP_HIGHPASS_SIMPLE {
2748 match value {
2749 DspHighpassSimple::Cutoff => ffi::FMOD_DSP_HIGHPASS_SIMPLE_CUTOFF,
2750 }
2751 }
2752}
2753impl DspHighpassSimple {
2754 pub fn from(value: ffi::FMOD_DSP_HIGHPASS_SIMPLE) -> Result<DspHighpassSimple, Error> {
2755 match value {
2756 ffi::FMOD_DSP_HIGHPASS_SIMPLE_CUTOFF => Ok(DspHighpassSimple::Cutoff),
2757 _ => Err(err_enum!("FMOD_DSP_HIGHPASS_SIMPLE", value)),
2758 }
2759 }
2760}
2761#[derive(Debug, Clone, Copy, PartialEq)]
2762pub enum DspPan2DStereoModeType {
2763 Distributed,
2764 Discrete,
2765}
2766impl From<DspPan2DStereoModeType> for ffi::FMOD_DSP_PAN_2D_STEREO_MODE_TYPE {
2767 fn from(value: DspPan2DStereoModeType) -> ffi::FMOD_DSP_PAN_2D_STEREO_MODE_TYPE {
2768 match value {
2769 DspPan2DStereoModeType::Distributed => ffi::FMOD_DSP_PAN_2D_STEREO_MODE_DISTRIBUTED,
2770 DspPan2DStereoModeType::Discrete => ffi::FMOD_DSP_PAN_2D_STEREO_MODE_DISCRETE,
2771 }
2772 }
2773}
2774impl DspPan2DStereoModeType {
2775 pub fn from(
2776 value: ffi::FMOD_DSP_PAN_2D_STEREO_MODE_TYPE,
2777 ) -> Result<DspPan2DStereoModeType, Error> {
2778 match value {
2779 ffi::FMOD_DSP_PAN_2D_STEREO_MODE_DISTRIBUTED => Ok(DspPan2DStereoModeType::Distributed),
2780 ffi::FMOD_DSP_PAN_2D_STEREO_MODE_DISCRETE => Ok(DspPan2DStereoModeType::Discrete),
2781 _ => Err(err_enum!("FMOD_DSP_PAN_2D_STEREO_MODE_TYPE", value)),
2782 }
2783 }
2784}
2785#[derive(Debug, Clone, Copy, PartialEq)]
2786pub enum DspPanModeType {
2787 Mono,
2788 Stereo,
2789 Surround,
2790}
2791impl From<DspPanModeType> for ffi::FMOD_DSP_PAN_MODE_TYPE {
2792 fn from(value: DspPanModeType) -> ffi::FMOD_DSP_PAN_MODE_TYPE {
2793 match value {
2794 DspPanModeType::Mono => ffi::FMOD_DSP_PAN_MODE_MONO,
2795 DspPanModeType::Stereo => ffi::FMOD_DSP_PAN_MODE_STEREO,
2796 DspPanModeType::Surround => ffi::FMOD_DSP_PAN_MODE_SURROUND,
2797 }
2798 }
2799}
2800impl DspPanModeType {
2801 pub fn from(value: ffi::FMOD_DSP_PAN_MODE_TYPE) -> Result<DspPanModeType, Error> {
2802 match value {
2803 ffi::FMOD_DSP_PAN_MODE_MONO => Ok(DspPanModeType::Mono),
2804 ffi::FMOD_DSP_PAN_MODE_STEREO => Ok(DspPanModeType::Stereo),
2805 ffi::FMOD_DSP_PAN_MODE_SURROUND => Ok(DspPanModeType::Surround),
2806 _ => Err(err_enum!("FMOD_DSP_PAN_MODE_TYPE", value)),
2807 }
2808 }
2809}
2810#[derive(Debug, Clone, Copy, PartialEq)]
2811pub enum DspPan3DRolloffType {
2812 LinearSquared,
2813 Linear,
2814 Inverse,
2815 InverseTapered,
2816 Custom,
2817}
2818impl From<DspPan3DRolloffType> for ffi::FMOD_DSP_PAN_3D_ROLLOFF_TYPE {
2819 fn from(value: DspPan3DRolloffType) -> ffi::FMOD_DSP_PAN_3D_ROLLOFF_TYPE {
2820 match value {
2821 DspPan3DRolloffType::LinearSquared => ffi::FMOD_DSP_PAN_3D_ROLLOFF_LINEARSQUARED,
2822 DspPan3DRolloffType::Linear => ffi::FMOD_DSP_PAN_3D_ROLLOFF_LINEAR,
2823 DspPan3DRolloffType::Inverse => ffi::FMOD_DSP_PAN_3D_ROLLOFF_INVERSE,
2824 DspPan3DRolloffType::InverseTapered => ffi::FMOD_DSP_PAN_3D_ROLLOFF_INVERSETAPERED,
2825 DspPan3DRolloffType::Custom => ffi::FMOD_DSP_PAN_3D_ROLLOFF_CUSTOM,
2826 }
2827 }
2828}
2829impl DspPan3DRolloffType {
2830 pub fn from(value: ffi::FMOD_DSP_PAN_3D_ROLLOFF_TYPE) -> Result<DspPan3DRolloffType, Error> {
2831 match value {
2832 ffi::FMOD_DSP_PAN_3D_ROLLOFF_LINEARSQUARED => Ok(DspPan3DRolloffType::LinearSquared),
2833 ffi::FMOD_DSP_PAN_3D_ROLLOFF_LINEAR => Ok(DspPan3DRolloffType::Linear),
2834 ffi::FMOD_DSP_PAN_3D_ROLLOFF_INVERSE => Ok(DspPan3DRolloffType::Inverse),
2835 ffi::FMOD_DSP_PAN_3D_ROLLOFF_INVERSETAPERED => Ok(DspPan3DRolloffType::InverseTapered),
2836 ffi::FMOD_DSP_PAN_3D_ROLLOFF_CUSTOM => Ok(DspPan3DRolloffType::Custom),
2837 _ => Err(err_enum!("FMOD_DSP_PAN_3D_ROLLOFF_TYPE", value)),
2838 }
2839 }
2840}
2841#[derive(Debug, Clone, Copy, PartialEq)]
2842pub enum DspPan3DExtentModeType {
2843 Auto,
2844 User,
2845 Off,
2846}
2847impl From<DspPan3DExtentModeType> for ffi::FMOD_DSP_PAN_3D_EXTENT_MODE_TYPE {
2848 fn from(value: DspPan3DExtentModeType) -> ffi::FMOD_DSP_PAN_3D_EXTENT_MODE_TYPE {
2849 match value {
2850 DspPan3DExtentModeType::Auto => ffi::FMOD_DSP_PAN_3D_EXTENT_MODE_AUTO,
2851 DspPan3DExtentModeType::User => ffi::FMOD_DSP_PAN_3D_EXTENT_MODE_USER,
2852 DspPan3DExtentModeType::Off => ffi::FMOD_DSP_PAN_3D_EXTENT_MODE_OFF,
2853 }
2854 }
2855}
2856impl DspPan3DExtentModeType {
2857 pub fn from(
2858 value: ffi::FMOD_DSP_PAN_3D_EXTENT_MODE_TYPE,
2859 ) -> Result<DspPan3DExtentModeType, Error> {
2860 match value {
2861 ffi::FMOD_DSP_PAN_3D_EXTENT_MODE_AUTO => Ok(DspPan3DExtentModeType::Auto),
2862 ffi::FMOD_DSP_PAN_3D_EXTENT_MODE_USER => Ok(DspPan3DExtentModeType::User),
2863 ffi::FMOD_DSP_PAN_3D_EXTENT_MODE_OFF => Ok(DspPan3DExtentModeType::Off),
2864 _ => Err(err_enum!("FMOD_DSP_PAN_3D_EXTENT_MODE_TYPE", value)),
2865 }
2866 }
2867}
2868#[derive(Debug, Clone, Copy, PartialEq)]
2869pub enum DspPan {
2870 Mode,
2871 StereoPosition2D,
2872 Direction2D,
2873 Extent2D,
2874 Rotation2D,
2875 LfeLevel2D,
2876 StereoMode2D,
2877 StereoSeparation2D,
2878 StereoAxis2D,
2879 EnabledSpeakers,
2880 Position3D,
2881 Rolloff3D,
2882 MinDistance3D,
2883 MaxDistance3D,
2884 ExtentMode3D,
2885 SoundSize3D,
2886 MinExtent3D,
2887 PanBlend3D,
2888 LfeUpmixEnabled,
2889 OverallGain,
2890 SurroundSpeakerMode,
2891 HeightBlend2D,
2892 AttenuationRange,
2893 OverrideRange,
2894}
2895impl From<DspPan> for ffi::FMOD_DSP_PAN {
2896 fn from(value: DspPan) -> ffi::FMOD_DSP_PAN {
2897 match value {
2898 DspPan::Mode => ffi::FMOD_DSP_PAN_MODE,
2899 DspPan::StereoPosition2D => ffi::FMOD_DSP_PAN_2D_STEREO_POSITION,
2900 DspPan::Direction2D => ffi::FMOD_DSP_PAN_2D_DIRECTION,
2901 DspPan::Extent2D => ffi::FMOD_DSP_PAN_2D_EXTENT,
2902 DspPan::Rotation2D => ffi::FMOD_DSP_PAN_2D_ROTATION,
2903 DspPan::LfeLevel2D => ffi::FMOD_DSP_PAN_2D_LFE_LEVEL,
2904 DspPan::StereoMode2D => ffi::FMOD_DSP_PAN_2D_STEREO_MODE,
2905 DspPan::StereoSeparation2D => ffi::FMOD_DSP_PAN_2D_STEREO_SEPARATION,
2906 DspPan::StereoAxis2D => ffi::FMOD_DSP_PAN_2D_STEREO_AXIS,
2907 DspPan::EnabledSpeakers => ffi::FMOD_DSP_PAN_ENABLED_SPEAKERS,
2908 DspPan::Position3D => ffi::FMOD_DSP_PAN_3D_POSITION,
2909 DspPan::Rolloff3D => ffi::FMOD_DSP_PAN_3D_ROLLOFF,
2910 DspPan::MinDistance3D => ffi::FMOD_DSP_PAN_3D_MIN_DISTANCE,
2911 DspPan::MaxDistance3D => ffi::FMOD_DSP_PAN_3D_MAX_DISTANCE,
2912 DspPan::ExtentMode3D => ffi::FMOD_DSP_PAN_3D_EXTENT_MODE,
2913 DspPan::SoundSize3D => ffi::FMOD_DSP_PAN_3D_SOUND_SIZE,
2914 DspPan::MinExtent3D => ffi::FMOD_DSP_PAN_3D_MIN_EXTENT,
2915 DspPan::PanBlend3D => ffi::FMOD_DSP_PAN_3D_PAN_BLEND,
2916 DspPan::LfeUpmixEnabled => ffi::FMOD_DSP_PAN_LFE_UPMIX_ENABLED,
2917 DspPan::OverallGain => ffi::FMOD_DSP_PAN_OVERALL_GAIN,
2918 DspPan::SurroundSpeakerMode => ffi::FMOD_DSP_PAN_SURROUND_SPEAKER_MODE,
2919 DspPan::HeightBlend2D => ffi::FMOD_DSP_PAN_2D_HEIGHT_BLEND,
2920 DspPan::AttenuationRange => ffi::FMOD_DSP_PAN_ATTENUATION_RANGE,
2921 DspPan::OverrideRange => ffi::FMOD_DSP_PAN_OVERRIDE_RANGE,
2922 }
2923 }
2924}
2925impl DspPan {
2926 pub fn from(value: ffi::FMOD_DSP_PAN) -> Result<DspPan, Error> {
2927 match value {
2928 ffi::FMOD_DSP_PAN_MODE => Ok(DspPan::Mode),
2929 ffi::FMOD_DSP_PAN_2D_STEREO_POSITION => Ok(DspPan::StereoPosition2D),
2930 ffi::FMOD_DSP_PAN_2D_DIRECTION => Ok(DspPan::Direction2D),
2931 ffi::FMOD_DSP_PAN_2D_EXTENT => Ok(DspPan::Extent2D),
2932 ffi::FMOD_DSP_PAN_2D_ROTATION => Ok(DspPan::Rotation2D),
2933 ffi::FMOD_DSP_PAN_2D_LFE_LEVEL => Ok(DspPan::LfeLevel2D),
2934 ffi::FMOD_DSP_PAN_2D_STEREO_MODE => Ok(DspPan::StereoMode2D),
2935 ffi::FMOD_DSP_PAN_2D_STEREO_SEPARATION => Ok(DspPan::StereoSeparation2D),
2936 ffi::FMOD_DSP_PAN_2D_STEREO_AXIS => Ok(DspPan::StereoAxis2D),
2937 ffi::FMOD_DSP_PAN_ENABLED_SPEAKERS => Ok(DspPan::EnabledSpeakers),
2938 ffi::FMOD_DSP_PAN_3D_POSITION => Ok(DspPan::Position3D),
2939 ffi::FMOD_DSP_PAN_3D_ROLLOFF => Ok(DspPan::Rolloff3D),
2940 ffi::FMOD_DSP_PAN_3D_MIN_DISTANCE => Ok(DspPan::MinDistance3D),
2941 ffi::FMOD_DSP_PAN_3D_MAX_DISTANCE => Ok(DspPan::MaxDistance3D),
2942 ffi::FMOD_DSP_PAN_3D_EXTENT_MODE => Ok(DspPan::ExtentMode3D),
2943 ffi::FMOD_DSP_PAN_3D_SOUND_SIZE => Ok(DspPan::SoundSize3D),
2944 ffi::FMOD_DSP_PAN_3D_MIN_EXTENT => Ok(DspPan::MinExtent3D),
2945 ffi::FMOD_DSP_PAN_3D_PAN_BLEND => Ok(DspPan::PanBlend3D),
2946 ffi::FMOD_DSP_PAN_LFE_UPMIX_ENABLED => Ok(DspPan::LfeUpmixEnabled),
2947 ffi::FMOD_DSP_PAN_OVERALL_GAIN => Ok(DspPan::OverallGain),
2948 ffi::FMOD_DSP_PAN_SURROUND_SPEAKER_MODE => Ok(DspPan::SurroundSpeakerMode),
2949 ffi::FMOD_DSP_PAN_2D_HEIGHT_BLEND => Ok(DspPan::HeightBlend2D),
2950 ffi::FMOD_DSP_PAN_ATTENUATION_RANGE => Ok(DspPan::AttenuationRange),
2951 ffi::FMOD_DSP_PAN_OVERRIDE_RANGE => Ok(DspPan::OverrideRange),
2952 _ => Err(err_enum!("FMOD_DSP_PAN", value)),
2953 }
2954 }
2955}
2956#[derive(Debug, Clone, Copy, PartialEq)]
2957pub enum DspThreeEqCrossoverSlopeType {
2958 Slope12Db,
2959 Slope24Db,
2960 Slope48Db,
2961}
2962impl From<DspThreeEqCrossoverSlopeType> for ffi::FMOD_DSP_THREE_EQ_CROSSOVERSLOPE_TYPE {
2963 fn from(value: DspThreeEqCrossoverSlopeType) -> ffi::FMOD_DSP_THREE_EQ_CROSSOVERSLOPE_TYPE {
2964 match value {
2965 DspThreeEqCrossoverSlopeType::Slope12Db => ffi::FMOD_DSP_THREE_EQ_CROSSOVERSLOPE_12DB,
2966 DspThreeEqCrossoverSlopeType::Slope24Db => ffi::FMOD_DSP_THREE_EQ_CROSSOVERSLOPE_24DB,
2967 DspThreeEqCrossoverSlopeType::Slope48Db => ffi::FMOD_DSP_THREE_EQ_CROSSOVERSLOPE_48DB,
2968 }
2969 }
2970}
2971impl DspThreeEqCrossoverSlopeType {
2972 pub fn from(
2973 value: ffi::FMOD_DSP_THREE_EQ_CROSSOVERSLOPE_TYPE,
2974 ) -> Result<DspThreeEqCrossoverSlopeType, Error> {
2975 match value {
2976 ffi::FMOD_DSP_THREE_EQ_CROSSOVERSLOPE_12DB => {
2977 Ok(DspThreeEqCrossoverSlopeType::Slope12Db)
2978 }
2979 ffi::FMOD_DSP_THREE_EQ_CROSSOVERSLOPE_24DB => {
2980 Ok(DspThreeEqCrossoverSlopeType::Slope24Db)
2981 }
2982 ffi::FMOD_DSP_THREE_EQ_CROSSOVERSLOPE_48DB => {
2983 Ok(DspThreeEqCrossoverSlopeType::Slope48Db)
2984 }
2985 _ => Err(err_enum!("FMOD_DSP_THREE_EQ_CROSSOVERSLOPE_TYPE", value)),
2986 }
2987 }
2988}
2989#[derive(Debug, Clone, Copy, PartialEq)]
2990pub enum DspThreeEq {
2991 LowGain,
2992 MidGain,
2993 HighGain,
2994 LowCrossover,
2995 HightCorssover,
2996 CrossoverSlope,
2997}
2998impl From<DspThreeEq> for ffi::FMOD_DSP_THREE_EQ {
2999 fn from(value: DspThreeEq) -> ffi::FMOD_DSP_THREE_EQ {
3000 match value {
3001 DspThreeEq::LowGain => ffi::FMOD_DSP_THREE_EQ_LOWGAIN,
3002 DspThreeEq::MidGain => ffi::FMOD_DSP_THREE_EQ_MIDGAIN,
3003 DspThreeEq::HighGain => ffi::FMOD_DSP_THREE_EQ_HIGHGAIN,
3004 DspThreeEq::LowCrossover => ffi::FMOD_DSP_THREE_EQ_LOWCROSSOVER,
3005 DspThreeEq::HightCorssover => ffi::FMOD_DSP_THREE_EQ_HIGHCROSSOVER,
3006 DspThreeEq::CrossoverSlope => ffi::FMOD_DSP_THREE_EQ_CROSSOVERSLOPE,
3007 }
3008 }
3009}
3010impl DspThreeEq {
3011 pub fn from(value: ffi::FMOD_DSP_THREE_EQ) -> Result<DspThreeEq, Error> {
3012 match value {
3013 ffi::FMOD_DSP_THREE_EQ_LOWGAIN => Ok(DspThreeEq::LowGain),
3014 ffi::FMOD_DSP_THREE_EQ_MIDGAIN => Ok(DspThreeEq::MidGain),
3015 ffi::FMOD_DSP_THREE_EQ_HIGHGAIN => Ok(DspThreeEq::HighGain),
3016 ffi::FMOD_DSP_THREE_EQ_LOWCROSSOVER => Ok(DspThreeEq::LowCrossover),
3017 ffi::FMOD_DSP_THREE_EQ_HIGHCROSSOVER => Ok(DspThreeEq::HightCorssover),
3018 ffi::FMOD_DSP_THREE_EQ_CROSSOVERSLOPE => Ok(DspThreeEq::CrossoverSlope),
3019 _ => Err(err_enum!("FMOD_DSP_THREE_EQ", value)),
3020 }
3021 }
3022}
3023#[derive(Debug, Clone, Copy, PartialEq)]
3024pub enum DspFftWindow {
3025 Rect,
3026 Triangle,
3027 Hamming,
3028 Hanning,
3029 BlackMan,
3030 BlackManHarris,
3031}
3032impl From<DspFftWindow> for ffi::FMOD_DSP_FFT_WINDOW {
3033 fn from(value: DspFftWindow) -> ffi::FMOD_DSP_FFT_WINDOW {
3034 match value {
3035 DspFftWindow::Rect => ffi::FMOD_DSP_FFT_WINDOW_RECT,
3036 DspFftWindow::Triangle => ffi::FMOD_DSP_FFT_WINDOW_TRIANGLE,
3037 DspFftWindow::Hamming => ffi::FMOD_DSP_FFT_WINDOW_HAMMING,
3038 DspFftWindow::Hanning => ffi::FMOD_DSP_FFT_WINDOW_HANNING,
3039 DspFftWindow::BlackMan => ffi::FMOD_DSP_FFT_WINDOW_BLACKMAN,
3040 DspFftWindow::BlackManHarris => ffi::FMOD_DSP_FFT_WINDOW_BLACKMANHARRIS,
3041 }
3042 }
3043}
3044impl DspFftWindow {
3045 pub fn from(value: ffi::FMOD_DSP_FFT_WINDOW) -> Result<DspFftWindow, Error> {
3046 match value {
3047 ffi::FMOD_DSP_FFT_WINDOW_RECT => Ok(DspFftWindow::Rect),
3048 ffi::FMOD_DSP_FFT_WINDOW_TRIANGLE => Ok(DspFftWindow::Triangle),
3049 ffi::FMOD_DSP_FFT_WINDOW_HAMMING => Ok(DspFftWindow::Hamming),
3050 ffi::FMOD_DSP_FFT_WINDOW_HANNING => Ok(DspFftWindow::Hanning),
3051 ffi::FMOD_DSP_FFT_WINDOW_BLACKMAN => Ok(DspFftWindow::BlackMan),
3052 ffi::FMOD_DSP_FFT_WINDOW_BLACKMANHARRIS => Ok(DspFftWindow::BlackManHarris),
3053 _ => Err(err_enum!("FMOD_DSP_FFT_WINDOW", value)),
3054 }
3055 }
3056}
3057#[derive(Debug, Clone, Copy, PartialEq)]
3058pub enum DspFft {
3059 WindowSize,
3060 WindowType,
3061 SpectrumData,
3062 DominantFreq,
3063}
3064impl From<DspFft> for ffi::FMOD_DSP_FFT {
3065 fn from(value: DspFft) -> ffi::FMOD_DSP_FFT {
3066 match value {
3067 DspFft::WindowSize => ffi::FMOD_DSP_FFT_WINDOWSIZE,
3068 DspFft::WindowType => ffi::FMOD_DSP_FFT_WINDOWTYPE,
3069 DspFft::SpectrumData => ffi::FMOD_DSP_FFT_SPECTRUMDATA,
3070 DspFft::DominantFreq => ffi::FMOD_DSP_FFT_DOMINANT_FREQ,
3071 }
3072 }
3073}
3074impl DspFft {
3075 pub fn from(value: ffi::FMOD_DSP_FFT) -> Result<DspFft, Error> {
3076 match value {
3077 ffi::FMOD_DSP_FFT_WINDOWSIZE => Ok(DspFft::WindowSize),
3078 ffi::FMOD_DSP_FFT_WINDOWTYPE => Ok(DspFft::WindowType),
3079 ffi::FMOD_DSP_FFT_SPECTRUMDATA => Ok(DspFft::SpectrumData),
3080 ffi::FMOD_DSP_FFT_DOMINANT_FREQ => Ok(DspFft::DominantFreq),
3081 _ => Err(err_enum!("FMOD_DSP_FFT", value)),
3082 }
3083 }
3084}
3085#[derive(Debug, Clone, Copy, PartialEq)]
3086pub enum DspLoudnessMeter {
3087 State,
3088 Weighting,
3089 Info,
3090}
3091impl From<DspLoudnessMeter> for ffi::FMOD_DSP_LOUDNESS_METER {
3092 fn from(value: DspLoudnessMeter) -> ffi::FMOD_DSP_LOUDNESS_METER {
3093 match value {
3094 DspLoudnessMeter::State => ffi::FMOD_DSP_LOUDNESS_METER_STATE,
3095 DspLoudnessMeter::Weighting => ffi::FMOD_DSP_LOUDNESS_METER_WEIGHTING,
3096 DspLoudnessMeter::Info => ffi::FMOD_DSP_LOUDNESS_METER_INFO,
3097 }
3098 }
3099}
3100impl DspLoudnessMeter {
3101 pub fn from(value: ffi::FMOD_DSP_LOUDNESS_METER) -> Result<DspLoudnessMeter, Error> {
3102 match value {
3103 ffi::FMOD_DSP_LOUDNESS_METER_STATE => Ok(DspLoudnessMeter::State),
3104 ffi::FMOD_DSP_LOUDNESS_METER_WEIGHTING => Ok(DspLoudnessMeter::Weighting),
3105 ffi::FMOD_DSP_LOUDNESS_METER_INFO => Ok(DspLoudnessMeter::Info),
3106 _ => Err(err_enum!("FMOD_DSP_LOUDNESS_METER", value)),
3107 }
3108 }
3109}
3110#[derive(Debug, Clone, Copy, PartialEq)]
3111pub enum DspLoudnessMeterStateType {
3112 ResetIntegrated,
3113 ResetMaxpeak,
3114 ResetAll,
3115 Paused,
3116 Analyzing,
3117}
3118impl From<DspLoudnessMeterStateType> for ffi::FMOD_DSP_LOUDNESS_METER_STATE_TYPE {
3119 fn from(value: DspLoudnessMeterStateType) -> ffi::FMOD_DSP_LOUDNESS_METER_STATE_TYPE {
3120 match value {
3121 DspLoudnessMeterStateType::ResetIntegrated => {
3122 ffi::FMOD_DSP_LOUDNESS_METER_STATE_RESET_INTEGRATED
3123 }
3124 DspLoudnessMeterStateType::ResetMaxpeak => {
3125 ffi::FMOD_DSP_LOUDNESS_METER_STATE_RESET_MAXPEAK
3126 }
3127 DspLoudnessMeterStateType::ResetAll => ffi::FMOD_DSP_LOUDNESS_METER_STATE_RESET_ALL,
3128 DspLoudnessMeterStateType::Paused => ffi::FMOD_DSP_LOUDNESS_METER_STATE_PAUSED,
3129 DspLoudnessMeterStateType::Analyzing => ffi::FMOD_DSP_LOUDNESS_METER_STATE_ANALYZING,
3130 }
3131 }
3132}
3133impl DspLoudnessMeterStateType {
3134 pub fn from(
3135 value: ffi::FMOD_DSP_LOUDNESS_METER_STATE_TYPE,
3136 ) -> Result<DspLoudnessMeterStateType, Error> {
3137 match value {
3138 ffi::FMOD_DSP_LOUDNESS_METER_STATE_RESET_INTEGRATED => {
3139 Ok(DspLoudnessMeterStateType::ResetIntegrated)
3140 }
3141 ffi::FMOD_DSP_LOUDNESS_METER_STATE_RESET_MAXPEAK => {
3142 Ok(DspLoudnessMeterStateType::ResetMaxpeak)
3143 }
3144 ffi::FMOD_DSP_LOUDNESS_METER_STATE_RESET_ALL => Ok(DspLoudnessMeterStateType::ResetAll),
3145 ffi::FMOD_DSP_LOUDNESS_METER_STATE_PAUSED => Ok(DspLoudnessMeterStateType::Paused),
3146 ffi::FMOD_DSP_LOUDNESS_METER_STATE_ANALYZING => {
3147 Ok(DspLoudnessMeterStateType::Analyzing)
3148 }
3149 _ => Err(err_enum!("FMOD_DSP_LOUDNESS_METER_STATE_TYPE", value)),
3150 }
3151 }
3152}
3153#[derive(Debug, Clone, Copy, PartialEq)]
3154pub enum DspEnvelopeFollower {
3155 Attack,
3156 Release,
3157 Envelope,
3158 UseSidechain,
3159}
3160impl From<DspEnvelopeFollower> for ffi::FMOD_DSP_ENVELOPEFOLLOWER {
3161 fn from(value: DspEnvelopeFollower) -> ffi::FMOD_DSP_ENVELOPEFOLLOWER {
3162 match value {
3163 DspEnvelopeFollower::Attack => ffi::FMOD_DSP_ENVELOPEFOLLOWER_ATTACK,
3164 DspEnvelopeFollower::Release => ffi::FMOD_DSP_ENVELOPEFOLLOWER_RELEASE,
3165 DspEnvelopeFollower::Envelope => ffi::FMOD_DSP_ENVELOPEFOLLOWER_ENVELOPE,
3166 DspEnvelopeFollower::UseSidechain => ffi::FMOD_DSP_ENVELOPEFOLLOWER_USESIDECHAIN,
3167 }
3168 }
3169}
3170impl DspEnvelopeFollower {
3171 pub fn from(value: ffi::FMOD_DSP_ENVELOPEFOLLOWER) -> Result<DspEnvelopeFollower, Error> {
3172 match value {
3173 ffi::FMOD_DSP_ENVELOPEFOLLOWER_ATTACK => Ok(DspEnvelopeFollower::Attack),
3174 ffi::FMOD_DSP_ENVELOPEFOLLOWER_RELEASE => Ok(DspEnvelopeFollower::Release),
3175 ffi::FMOD_DSP_ENVELOPEFOLLOWER_ENVELOPE => Ok(DspEnvelopeFollower::Envelope),
3176 ffi::FMOD_DSP_ENVELOPEFOLLOWER_USESIDECHAIN => Ok(DspEnvelopeFollower::UseSidechain),
3177 _ => Err(err_enum!("FMOD_DSP_ENVELOPEFOLLOWER", value)),
3178 }
3179 }
3180}
3181#[derive(Debug, Clone, Copy, PartialEq)]
3182pub enum DspConvolutionReverb {
3183 ParamIr,
3184 ParamWet,
3185 ParamDry,
3186 ParamLinked,
3187}
3188impl From<DspConvolutionReverb> for ffi::FMOD_DSP_CONVOLUTION_REVERB {
3189 fn from(value: DspConvolutionReverb) -> ffi::FMOD_DSP_CONVOLUTION_REVERB {
3190 match value {
3191 DspConvolutionReverb::ParamIr => ffi::FMOD_DSP_CONVOLUTION_REVERB_PARAM_IR,
3192 DspConvolutionReverb::ParamWet => ffi::FMOD_DSP_CONVOLUTION_REVERB_PARAM_WET,
3193 DspConvolutionReverb::ParamDry => ffi::FMOD_DSP_CONVOLUTION_REVERB_PARAM_DRY,
3194 DspConvolutionReverb::ParamLinked => ffi::FMOD_DSP_CONVOLUTION_REVERB_PARAM_LINKED,
3195 }
3196 }
3197}
3198impl DspConvolutionReverb {
3199 pub fn from(value: ffi::FMOD_DSP_CONVOLUTION_REVERB) -> Result<DspConvolutionReverb, Error> {
3200 match value {
3201 ffi::FMOD_DSP_CONVOLUTION_REVERB_PARAM_IR => Ok(DspConvolutionReverb::ParamIr),
3202 ffi::FMOD_DSP_CONVOLUTION_REVERB_PARAM_WET => Ok(DspConvolutionReverb::ParamWet),
3203 ffi::FMOD_DSP_CONVOLUTION_REVERB_PARAM_DRY => Ok(DspConvolutionReverb::ParamDry),
3204 ffi::FMOD_DSP_CONVOLUTION_REVERB_PARAM_LINKED => Ok(DspConvolutionReverb::ParamLinked),
3205 _ => Err(err_enum!("FMOD_DSP_CONVOLUTION_REVERB", value)),
3206 }
3207 }
3208}
3209#[derive(Debug, Clone, Copy, PartialEq)]
3210pub enum DspChannelMixOutput {
3211 Default,
3212 AllMono,
3213 AllStereo,
3214 AllQuad,
3215 All5Point1,
3216 All7Point1,
3217 AllLfe,
3218 All7Point1Point4,
3219}
3220impl From<DspChannelMixOutput> for ffi::FMOD_DSP_CHANNELMIX_OUTPUT {
3221 fn from(value: DspChannelMixOutput) -> ffi::FMOD_DSP_CHANNELMIX_OUTPUT {
3222 match value {
3223 DspChannelMixOutput::Default => ffi::FMOD_DSP_CHANNELMIX_OUTPUT_DEFAULT,
3224 DspChannelMixOutput::AllMono => ffi::FMOD_DSP_CHANNELMIX_OUTPUT_ALLMONO,
3225 DspChannelMixOutput::AllStereo => ffi::FMOD_DSP_CHANNELMIX_OUTPUT_ALLSTEREO,
3226 DspChannelMixOutput::AllQuad => ffi::FMOD_DSP_CHANNELMIX_OUTPUT_ALLQUAD,
3227 DspChannelMixOutput::All5Point1 => ffi::FMOD_DSP_CHANNELMIX_OUTPUT_ALL5POINT1,
3228 DspChannelMixOutput::All7Point1 => ffi::FMOD_DSP_CHANNELMIX_OUTPUT_ALL7POINT1,
3229 DspChannelMixOutput::AllLfe => ffi::FMOD_DSP_CHANNELMIX_OUTPUT_ALLLFE,
3230 DspChannelMixOutput::All7Point1Point4 => {
3231 ffi::FMOD_DSP_CHANNELMIX_OUTPUT_ALL7POINT1POINT4
3232 }
3233 }
3234 }
3235}
3236impl DspChannelMixOutput {
3237 pub fn from(value: ffi::FMOD_DSP_CHANNELMIX_OUTPUT) -> Result<DspChannelMixOutput, Error> {
3238 match value {
3239 ffi::FMOD_DSP_CHANNELMIX_OUTPUT_DEFAULT => Ok(DspChannelMixOutput::Default),
3240 ffi::FMOD_DSP_CHANNELMIX_OUTPUT_ALLMONO => Ok(DspChannelMixOutput::AllMono),
3241 ffi::FMOD_DSP_CHANNELMIX_OUTPUT_ALLSTEREO => Ok(DspChannelMixOutput::AllStereo),
3242 ffi::FMOD_DSP_CHANNELMIX_OUTPUT_ALLQUAD => Ok(DspChannelMixOutput::AllQuad),
3243 ffi::FMOD_DSP_CHANNELMIX_OUTPUT_ALL5POINT1 => Ok(DspChannelMixOutput::All5Point1),
3244 ffi::FMOD_DSP_CHANNELMIX_OUTPUT_ALL7POINT1 => Ok(DspChannelMixOutput::All7Point1),
3245 ffi::FMOD_DSP_CHANNELMIX_OUTPUT_ALLLFE => Ok(DspChannelMixOutput::AllLfe),
3246 ffi::FMOD_DSP_CHANNELMIX_OUTPUT_ALL7POINT1POINT4 => {
3247 Ok(DspChannelMixOutput::All7Point1Point4)
3248 }
3249 _ => Err(err_enum!("FMOD_DSP_CHANNELMIX_OUTPUT", value)),
3250 }
3251 }
3252}
3253#[derive(Debug, Clone, Copy, PartialEq)]
3254pub enum DspChannelMix {
3255 OutputGrouping,
3256 GainCh0,
3257 GainCh1,
3258 GainCh2,
3259 GainCh3,
3260 GainCh4,
3261 GainCh5,
3262 GainCh6,
3263 GainCh7,
3264 GainCh8,
3265 GainCh9,
3266 GainCh10,
3267 GainCh11,
3268 GainCh12,
3269 GainCh13,
3270 GainCh14,
3271 GainCh15,
3272 GainCh16,
3273 GainCh17,
3274 GainCh18,
3275 GainCh19,
3276 GainCh20,
3277 GainCh21,
3278 GainCh22,
3279 GainCh23,
3280 GainCh24,
3281 GainCh25,
3282 GainCh26,
3283 GainCh27,
3284 GainCh28,
3285 GainCh29,
3286 GainCh30,
3287 GainCh31,
3288 OutputCh0,
3289 OutputCh1,
3290 OutputCh2,
3291 OutputCh3,
3292 OutputCh4,
3293 OutputCh5,
3294 OutputCh6,
3295 OutputCh7,
3296 OutputCh8,
3297 OutputCh9,
3298 OutputCh10,
3299 OutputCh11,
3300 OutputCh12,
3301 OutputCh13,
3302 OutputCh14,
3303 OutputCh15,
3304 OutputCh16,
3305 OutputCh17,
3306 OutputCh18,
3307 OutputCh19,
3308 OutputCh20,
3309 OutputCh21,
3310 OutputCh22,
3311 OutputCh23,
3312 OutputCh24,
3313 OutputCh25,
3314 OutputCh26,
3315 OutputCh27,
3316 OutputCh28,
3317 OutputCh29,
3318 OutputCh30,
3319 OutputCh31,
3320}
3321impl From<DspChannelMix> for ffi::FMOD_DSP_CHANNELMIX {
3322 fn from(value: DspChannelMix) -> ffi::FMOD_DSP_CHANNELMIX {
3323 match value {
3324 DspChannelMix::OutputGrouping => ffi::FMOD_DSP_CHANNELMIX_OUTPUTGROUPING,
3325 DspChannelMix::GainCh0 => ffi::FMOD_DSP_CHANNELMIX_GAIN_CH0,
3326 DspChannelMix::GainCh1 => ffi::FMOD_DSP_CHANNELMIX_GAIN_CH1,
3327 DspChannelMix::GainCh2 => ffi::FMOD_DSP_CHANNELMIX_GAIN_CH2,
3328 DspChannelMix::GainCh3 => ffi::FMOD_DSP_CHANNELMIX_GAIN_CH3,
3329 DspChannelMix::GainCh4 => ffi::FMOD_DSP_CHANNELMIX_GAIN_CH4,
3330 DspChannelMix::GainCh5 => ffi::FMOD_DSP_CHANNELMIX_GAIN_CH5,
3331 DspChannelMix::GainCh6 => ffi::FMOD_DSP_CHANNELMIX_GAIN_CH6,
3332 DspChannelMix::GainCh7 => ffi::FMOD_DSP_CHANNELMIX_GAIN_CH7,
3333 DspChannelMix::GainCh8 => ffi::FMOD_DSP_CHANNELMIX_GAIN_CH8,
3334 DspChannelMix::GainCh9 => ffi::FMOD_DSP_CHANNELMIX_GAIN_CH9,
3335 DspChannelMix::GainCh10 => ffi::FMOD_DSP_CHANNELMIX_GAIN_CH10,
3336 DspChannelMix::GainCh11 => ffi::FMOD_DSP_CHANNELMIX_GAIN_CH11,
3337 DspChannelMix::GainCh12 => ffi::FMOD_DSP_CHANNELMIX_GAIN_CH12,
3338 DspChannelMix::GainCh13 => ffi::FMOD_DSP_CHANNELMIX_GAIN_CH13,
3339 DspChannelMix::GainCh14 => ffi::FMOD_DSP_CHANNELMIX_GAIN_CH14,
3340 DspChannelMix::GainCh15 => ffi::FMOD_DSP_CHANNELMIX_GAIN_CH15,
3341 DspChannelMix::GainCh16 => ffi::FMOD_DSP_CHANNELMIX_GAIN_CH16,
3342 DspChannelMix::GainCh17 => ffi::FMOD_DSP_CHANNELMIX_GAIN_CH17,
3343 DspChannelMix::GainCh18 => ffi::FMOD_DSP_CHANNELMIX_GAIN_CH18,
3344 DspChannelMix::GainCh19 => ffi::FMOD_DSP_CHANNELMIX_GAIN_CH19,
3345 DspChannelMix::GainCh20 => ffi::FMOD_DSP_CHANNELMIX_GAIN_CH20,
3346 DspChannelMix::GainCh21 => ffi::FMOD_DSP_CHANNELMIX_GAIN_CH21,
3347 DspChannelMix::GainCh22 => ffi::FMOD_DSP_CHANNELMIX_GAIN_CH22,
3348 DspChannelMix::GainCh23 => ffi::FMOD_DSP_CHANNELMIX_GAIN_CH23,
3349 DspChannelMix::GainCh24 => ffi::FMOD_DSP_CHANNELMIX_GAIN_CH24,
3350 DspChannelMix::GainCh25 => ffi::FMOD_DSP_CHANNELMIX_GAIN_CH25,
3351 DspChannelMix::GainCh26 => ffi::FMOD_DSP_CHANNELMIX_GAIN_CH26,
3352 DspChannelMix::GainCh27 => ffi::FMOD_DSP_CHANNELMIX_GAIN_CH27,
3353 DspChannelMix::GainCh28 => ffi::FMOD_DSP_CHANNELMIX_GAIN_CH28,
3354 DspChannelMix::GainCh29 => ffi::FMOD_DSP_CHANNELMIX_GAIN_CH29,
3355 DspChannelMix::GainCh30 => ffi::FMOD_DSP_CHANNELMIX_GAIN_CH30,
3356 DspChannelMix::GainCh31 => ffi::FMOD_DSP_CHANNELMIX_GAIN_CH31,
3357 DspChannelMix::OutputCh0 => ffi::FMOD_DSP_CHANNELMIX_OUTPUT_CH0,
3358 DspChannelMix::OutputCh1 => ffi::FMOD_DSP_CHANNELMIX_OUTPUT_CH1,
3359 DspChannelMix::OutputCh2 => ffi::FMOD_DSP_CHANNELMIX_OUTPUT_CH2,
3360 DspChannelMix::OutputCh3 => ffi::FMOD_DSP_CHANNELMIX_OUTPUT_CH3,
3361 DspChannelMix::OutputCh4 => ffi::FMOD_DSP_CHANNELMIX_OUTPUT_CH4,
3362 DspChannelMix::OutputCh5 => ffi::FMOD_DSP_CHANNELMIX_OUTPUT_CH5,
3363 DspChannelMix::OutputCh6 => ffi::FMOD_DSP_CHANNELMIX_OUTPUT_CH6,
3364 DspChannelMix::OutputCh7 => ffi::FMOD_DSP_CHANNELMIX_OUTPUT_CH7,
3365 DspChannelMix::OutputCh8 => ffi::FMOD_DSP_CHANNELMIX_OUTPUT_CH8,
3366 DspChannelMix::OutputCh9 => ffi::FMOD_DSP_CHANNELMIX_OUTPUT_CH9,
3367 DspChannelMix::OutputCh10 => ffi::FMOD_DSP_CHANNELMIX_OUTPUT_CH10,
3368 DspChannelMix::OutputCh11 => ffi::FMOD_DSP_CHANNELMIX_OUTPUT_CH11,
3369 DspChannelMix::OutputCh12 => ffi::FMOD_DSP_CHANNELMIX_OUTPUT_CH12,
3370 DspChannelMix::OutputCh13 => ffi::FMOD_DSP_CHANNELMIX_OUTPUT_CH13,
3371 DspChannelMix::OutputCh14 => ffi::FMOD_DSP_CHANNELMIX_OUTPUT_CH14,
3372 DspChannelMix::OutputCh15 => ffi::FMOD_DSP_CHANNELMIX_OUTPUT_CH15,
3373 DspChannelMix::OutputCh16 => ffi::FMOD_DSP_CHANNELMIX_OUTPUT_CH16,
3374 DspChannelMix::OutputCh17 => ffi::FMOD_DSP_CHANNELMIX_OUTPUT_CH17,
3375 DspChannelMix::OutputCh18 => ffi::FMOD_DSP_CHANNELMIX_OUTPUT_CH18,
3376 DspChannelMix::OutputCh19 => ffi::FMOD_DSP_CHANNELMIX_OUTPUT_CH19,
3377 DspChannelMix::OutputCh20 => ffi::FMOD_DSP_CHANNELMIX_OUTPUT_CH20,
3378 DspChannelMix::OutputCh21 => ffi::FMOD_DSP_CHANNELMIX_OUTPUT_CH21,
3379 DspChannelMix::OutputCh22 => ffi::FMOD_DSP_CHANNELMIX_OUTPUT_CH22,
3380 DspChannelMix::OutputCh23 => ffi::FMOD_DSP_CHANNELMIX_OUTPUT_CH23,
3381 DspChannelMix::OutputCh24 => ffi::FMOD_DSP_CHANNELMIX_OUTPUT_CH24,
3382 DspChannelMix::OutputCh25 => ffi::FMOD_DSP_CHANNELMIX_OUTPUT_CH25,
3383 DspChannelMix::OutputCh26 => ffi::FMOD_DSP_CHANNELMIX_OUTPUT_CH26,
3384 DspChannelMix::OutputCh27 => ffi::FMOD_DSP_CHANNELMIX_OUTPUT_CH27,
3385 DspChannelMix::OutputCh28 => ffi::FMOD_DSP_CHANNELMIX_OUTPUT_CH28,
3386 DspChannelMix::OutputCh29 => ffi::FMOD_DSP_CHANNELMIX_OUTPUT_CH29,
3387 DspChannelMix::OutputCh30 => ffi::FMOD_DSP_CHANNELMIX_OUTPUT_CH30,
3388 DspChannelMix::OutputCh31 => ffi::FMOD_DSP_CHANNELMIX_OUTPUT_CH31,
3389 }
3390 }
3391}
3392impl DspChannelMix {
3393 pub fn from(value: ffi::FMOD_DSP_CHANNELMIX) -> Result<DspChannelMix, Error> {
3394 match value {
3395 ffi::FMOD_DSP_CHANNELMIX_OUTPUTGROUPING => Ok(DspChannelMix::OutputGrouping),
3396 ffi::FMOD_DSP_CHANNELMIX_GAIN_CH0 => Ok(DspChannelMix::GainCh0),
3397 ffi::FMOD_DSP_CHANNELMIX_GAIN_CH1 => Ok(DspChannelMix::GainCh1),
3398 ffi::FMOD_DSP_CHANNELMIX_GAIN_CH2 => Ok(DspChannelMix::GainCh2),
3399 ffi::FMOD_DSP_CHANNELMIX_GAIN_CH3 => Ok(DspChannelMix::GainCh3),
3400 ffi::FMOD_DSP_CHANNELMIX_GAIN_CH4 => Ok(DspChannelMix::GainCh4),
3401 ffi::FMOD_DSP_CHANNELMIX_GAIN_CH5 => Ok(DspChannelMix::GainCh5),
3402 ffi::FMOD_DSP_CHANNELMIX_GAIN_CH6 => Ok(DspChannelMix::GainCh6),
3403 ffi::FMOD_DSP_CHANNELMIX_GAIN_CH7 => Ok(DspChannelMix::GainCh7),
3404 ffi::FMOD_DSP_CHANNELMIX_GAIN_CH8 => Ok(DspChannelMix::GainCh8),
3405 ffi::FMOD_DSP_CHANNELMIX_GAIN_CH9 => Ok(DspChannelMix::GainCh9),
3406 ffi::FMOD_DSP_CHANNELMIX_GAIN_CH10 => Ok(DspChannelMix::GainCh10),
3407 ffi::FMOD_DSP_CHANNELMIX_GAIN_CH11 => Ok(DspChannelMix::GainCh11),
3408 ffi::FMOD_DSP_CHANNELMIX_GAIN_CH12 => Ok(DspChannelMix::GainCh12),
3409 ffi::FMOD_DSP_CHANNELMIX_GAIN_CH13 => Ok(DspChannelMix::GainCh13),
3410 ffi::FMOD_DSP_CHANNELMIX_GAIN_CH14 => Ok(DspChannelMix::GainCh14),
3411 ffi::FMOD_DSP_CHANNELMIX_GAIN_CH15 => Ok(DspChannelMix::GainCh15),
3412 ffi::FMOD_DSP_CHANNELMIX_GAIN_CH16 => Ok(DspChannelMix::GainCh16),
3413 ffi::FMOD_DSP_CHANNELMIX_GAIN_CH17 => Ok(DspChannelMix::GainCh17),
3414 ffi::FMOD_DSP_CHANNELMIX_GAIN_CH18 => Ok(DspChannelMix::GainCh18),
3415 ffi::FMOD_DSP_CHANNELMIX_GAIN_CH19 => Ok(DspChannelMix::GainCh19),
3416 ffi::FMOD_DSP_CHANNELMIX_GAIN_CH20 => Ok(DspChannelMix::GainCh20),
3417 ffi::FMOD_DSP_CHANNELMIX_GAIN_CH21 => Ok(DspChannelMix::GainCh21),
3418 ffi::FMOD_DSP_CHANNELMIX_GAIN_CH22 => Ok(DspChannelMix::GainCh22),
3419 ffi::FMOD_DSP_CHANNELMIX_GAIN_CH23 => Ok(DspChannelMix::GainCh23),
3420 ffi::FMOD_DSP_CHANNELMIX_GAIN_CH24 => Ok(DspChannelMix::GainCh24),
3421 ffi::FMOD_DSP_CHANNELMIX_GAIN_CH25 => Ok(DspChannelMix::GainCh25),
3422 ffi::FMOD_DSP_CHANNELMIX_GAIN_CH26 => Ok(DspChannelMix::GainCh26),
3423 ffi::FMOD_DSP_CHANNELMIX_GAIN_CH27 => Ok(DspChannelMix::GainCh27),
3424 ffi::FMOD_DSP_CHANNELMIX_GAIN_CH28 => Ok(DspChannelMix::GainCh28),
3425 ffi::FMOD_DSP_CHANNELMIX_GAIN_CH29 => Ok(DspChannelMix::GainCh29),
3426 ffi::FMOD_DSP_CHANNELMIX_GAIN_CH30 => Ok(DspChannelMix::GainCh30),
3427 ffi::FMOD_DSP_CHANNELMIX_GAIN_CH31 => Ok(DspChannelMix::GainCh31),
3428 ffi::FMOD_DSP_CHANNELMIX_OUTPUT_CH0 => Ok(DspChannelMix::OutputCh0),
3429 ffi::FMOD_DSP_CHANNELMIX_OUTPUT_CH1 => Ok(DspChannelMix::OutputCh1),
3430 ffi::FMOD_DSP_CHANNELMIX_OUTPUT_CH2 => Ok(DspChannelMix::OutputCh2),
3431 ffi::FMOD_DSP_CHANNELMIX_OUTPUT_CH3 => Ok(DspChannelMix::OutputCh3),
3432 ffi::FMOD_DSP_CHANNELMIX_OUTPUT_CH4 => Ok(DspChannelMix::OutputCh4),
3433 ffi::FMOD_DSP_CHANNELMIX_OUTPUT_CH5 => Ok(DspChannelMix::OutputCh5),
3434 ffi::FMOD_DSP_CHANNELMIX_OUTPUT_CH6 => Ok(DspChannelMix::OutputCh6),
3435 ffi::FMOD_DSP_CHANNELMIX_OUTPUT_CH7 => Ok(DspChannelMix::OutputCh7),
3436 ffi::FMOD_DSP_CHANNELMIX_OUTPUT_CH8 => Ok(DspChannelMix::OutputCh8),
3437 ffi::FMOD_DSP_CHANNELMIX_OUTPUT_CH9 => Ok(DspChannelMix::OutputCh9),
3438 ffi::FMOD_DSP_CHANNELMIX_OUTPUT_CH10 => Ok(DspChannelMix::OutputCh10),
3439 ffi::FMOD_DSP_CHANNELMIX_OUTPUT_CH11 => Ok(DspChannelMix::OutputCh11),
3440 ffi::FMOD_DSP_CHANNELMIX_OUTPUT_CH12 => Ok(DspChannelMix::OutputCh12),
3441 ffi::FMOD_DSP_CHANNELMIX_OUTPUT_CH13 => Ok(DspChannelMix::OutputCh13),
3442 ffi::FMOD_DSP_CHANNELMIX_OUTPUT_CH14 => Ok(DspChannelMix::OutputCh14),
3443 ffi::FMOD_DSP_CHANNELMIX_OUTPUT_CH15 => Ok(DspChannelMix::OutputCh15),
3444 ffi::FMOD_DSP_CHANNELMIX_OUTPUT_CH16 => Ok(DspChannelMix::OutputCh16),
3445 ffi::FMOD_DSP_CHANNELMIX_OUTPUT_CH17 => Ok(DspChannelMix::OutputCh17),
3446 ffi::FMOD_DSP_CHANNELMIX_OUTPUT_CH18 => Ok(DspChannelMix::OutputCh18),
3447 ffi::FMOD_DSP_CHANNELMIX_OUTPUT_CH19 => Ok(DspChannelMix::OutputCh19),
3448 ffi::FMOD_DSP_CHANNELMIX_OUTPUT_CH20 => Ok(DspChannelMix::OutputCh20),
3449 ffi::FMOD_DSP_CHANNELMIX_OUTPUT_CH21 => Ok(DspChannelMix::OutputCh21),
3450 ffi::FMOD_DSP_CHANNELMIX_OUTPUT_CH22 => Ok(DspChannelMix::OutputCh22),
3451 ffi::FMOD_DSP_CHANNELMIX_OUTPUT_CH23 => Ok(DspChannelMix::OutputCh23),
3452 ffi::FMOD_DSP_CHANNELMIX_OUTPUT_CH24 => Ok(DspChannelMix::OutputCh24),
3453 ffi::FMOD_DSP_CHANNELMIX_OUTPUT_CH25 => Ok(DspChannelMix::OutputCh25),
3454 ffi::FMOD_DSP_CHANNELMIX_OUTPUT_CH26 => Ok(DspChannelMix::OutputCh26),
3455 ffi::FMOD_DSP_CHANNELMIX_OUTPUT_CH27 => Ok(DspChannelMix::OutputCh27),
3456 ffi::FMOD_DSP_CHANNELMIX_OUTPUT_CH28 => Ok(DspChannelMix::OutputCh28),
3457 ffi::FMOD_DSP_CHANNELMIX_OUTPUT_CH29 => Ok(DspChannelMix::OutputCh29),
3458 ffi::FMOD_DSP_CHANNELMIX_OUTPUT_CH30 => Ok(DspChannelMix::OutputCh30),
3459 ffi::FMOD_DSP_CHANNELMIX_OUTPUT_CH31 => Ok(DspChannelMix::OutputCh31),
3460 _ => Err(err_enum!("FMOD_DSP_CHANNELMIX", value)),
3461 }
3462 }
3463}
3464#[derive(Debug, Clone, Copy, PartialEq)]
3465pub enum DspTransceiverSpeakerMode {
3466 Auto,
3467 Mono,
3468 Stereo,
3469 Surround,
3470}
3471impl From<DspTransceiverSpeakerMode> for ffi::FMOD_DSP_TRANSCEIVER_SPEAKERMODE {
3472 fn from(value: DspTransceiverSpeakerMode) -> ffi::FMOD_DSP_TRANSCEIVER_SPEAKERMODE {
3473 match value {
3474 DspTransceiverSpeakerMode::Auto => ffi::FMOD_DSP_TRANSCEIVER_SPEAKERMODE_AUTO,
3475 DspTransceiverSpeakerMode::Mono => ffi::FMOD_DSP_TRANSCEIVER_SPEAKERMODE_MONO,
3476 DspTransceiverSpeakerMode::Stereo => ffi::FMOD_DSP_TRANSCEIVER_SPEAKERMODE_STEREO,
3477 DspTransceiverSpeakerMode::Surround => ffi::FMOD_DSP_TRANSCEIVER_SPEAKERMODE_SURROUND,
3478 }
3479 }
3480}
3481impl DspTransceiverSpeakerMode {
3482 pub fn from(
3483 value: ffi::FMOD_DSP_TRANSCEIVER_SPEAKERMODE,
3484 ) -> Result<DspTransceiverSpeakerMode, Error> {
3485 match value {
3486 ffi::FMOD_DSP_TRANSCEIVER_SPEAKERMODE_AUTO => Ok(DspTransceiverSpeakerMode::Auto),
3487 ffi::FMOD_DSP_TRANSCEIVER_SPEAKERMODE_MONO => Ok(DspTransceiverSpeakerMode::Mono),
3488 ffi::FMOD_DSP_TRANSCEIVER_SPEAKERMODE_STEREO => Ok(DspTransceiverSpeakerMode::Stereo),
3489 ffi::FMOD_DSP_TRANSCEIVER_SPEAKERMODE_SURROUND => {
3490 Ok(DspTransceiverSpeakerMode::Surround)
3491 }
3492 _ => Err(err_enum!("FMOD_DSP_TRANSCEIVER_SPEAKERMODE", value)),
3493 }
3494 }
3495}
3496#[derive(Debug, Clone, Copy, PartialEq)]
3497pub enum DspTransceiver {
3498 Transmit,
3499 Gain,
3500 Channel,
3501 TransmitSpeakerMode,
3502}
3503impl From<DspTransceiver> for ffi::FMOD_DSP_TRANSCEIVER {
3504 fn from(value: DspTransceiver) -> ffi::FMOD_DSP_TRANSCEIVER {
3505 match value {
3506 DspTransceiver::Transmit => ffi::FMOD_DSP_TRANSCEIVER_TRANSMIT,
3507 DspTransceiver::Gain => ffi::FMOD_DSP_TRANSCEIVER_GAIN,
3508 DspTransceiver::Channel => ffi::FMOD_DSP_TRANSCEIVER_CHANNEL,
3509 DspTransceiver::TransmitSpeakerMode => ffi::FMOD_DSP_TRANSCEIVER_TRANSMITSPEAKERMODE,
3510 }
3511 }
3512}
3513impl DspTransceiver {
3514 pub fn from(value: ffi::FMOD_DSP_TRANSCEIVER) -> Result<DspTransceiver, Error> {
3515 match value {
3516 ffi::FMOD_DSP_TRANSCEIVER_TRANSMIT => Ok(DspTransceiver::Transmit),
3517 ffi::FMOD_DSP_TRANSCEIVER_GAIN => Ok(DspTransceiver::Gain),
3518 ffi::FMOD_DSP_TRANSCEIVER_CHANNEL => Ok(DspTransceiver::Channel),
3519 ffi::FMOD_DSP_TRANSCEIVER_TRANSMITSPEAKERMODE => {
3520 Ok(DspTransceiver::TransmitSpeakerMode)
3521 }
3522 _ => Err(err_enum!("FMOD_DSP_TRANSCEIVER", value)),
3523 }
3524 }
3525}
3526#[derive(Debug, Clone, Copy, PartialEq)]
3527pub enum DspObjectPan {
3528 Position3D,
3529 Rolloff3D,
3530 MinDistance3D,
3531 MaxDistance3D,
3532 ExtentMode3D,
3533 SoundSize3D,
3534 MinExtent3D,
3535 OverallGain,
3536 OutputGain,
3537 AttenuationRange,
3538 OverrideRange,
3539}
3540impl From<DspObjectPan> for ffi::FMOD_DSP_OBJECTPAN {
3541 fn from(value: DspObjectPan) -> ffi::FMOD_DSP_OBJECTPAN {
3542 match value {
3543 DspObjectPan::Position3D => ffi::FMOD_DSP_OBJECTPAN_3D_POSITION,
3544 DspObjectPan::Rolloff3D => ffi::FMOD_DSP_OBJECTPAN_3D_ROLLOFF,
3545 DspObjectPan::MinDistance3D => ffi::FMOD_DSP_OBJECTPAN_3D_MIN_DISTANCE,
3546 DspObjectPan::MaxDistance3D => ffi::FMOD_DSP_OBJECTPAN_3D_MAX_DISTANCE,
3547 DspObjectPan::ExtentMode3D => ffi::FMOD_DSP_OBJECTPAN_3D_EXTENT_MODE,
3548 DspObjectPan::SoundSize3D => ffi::FMOD_DSP_OBJECTPAN_3D_SOUND_SIZE,
3549 DspObjectPan::MinExtent3D => ffi::FMOD_DSP_OBJECTPAN_3D_MIN_EXTENT,
3550 DspObjectPan::OverallGain => ffi::FMOD_DSP_OBJECTPAN_OVERALL_GAIN,
3551 DspObjectPan::OutputGain => ffi::FMOD_DSP_OBJECTPAN_OUTPUTGAIN,
3552 DspObjectPan::AttenuationRange => ffi::FMOD_DSP_OBJECTPAN_ATTENUATION_RANGE,
3553 DspObjectPan::OverrideRange => ffi::FMOD_DSP_OBJECTPAN_OVERRIDE_RANGE,
3554 }
3555 }
3556}
3557impl DspObjectPan {
3558 pub fn from(value: ffi::FMOD_DSP_OBJECTPAN) -> Result<DspObjectPan, Error> {
3559 match value {
3560 ffi::FMOD_DSP_OBJECTPAN_3D_POSITION => Ok(DspObjectPan::Position3D),
3561 ffi::FMOD_DSP_OBJECTPAN_3D_ROLLOFF => Ok(DspObjectPan::Rolloff3D),
3562 ffi::FMOD_DSP_OBJECTPAN_3D_MIN_DISTANCE => Ok(DspObjectPan::MinDistance3D),
3563 ffi::FMOD_DSP_OBJECTPAN_3D_MAX_DISTANCE => Ok(DspObjectPan::MaxDistance3D),
3564 ffi::FMOD_DSP_OBJECTPAN_3D_EXTENT_MODE => Ok(DspObjectPan::ExtentMode3D),
3565 ffi::FMOD_DSP_OBJECTPAN_3D_SOUND_SIZE => Ok(DspObjectPan::SoundSize3D),
3566 ffi::FMOD_DSP_OBJECTPAN_3D_MIN_EXTENT => Ok(DspObjectPan::MinExtent3D),
3567 ffi::FMOD_DSP_OBJECTPAN_OVERALL_GAIN => Ok(DspObjectPan::OverallGain),
3568 ffi::FMOD_DSP_OBJECTPAN_OUTPUTGAIN => Ok(DspObjectPan::OutputGain),
3569 ffi::FMOD_DSP_OBJECTPAN_ATTENUATION_RANGE => Ok(DspObjectPan::AttenuationRange),
3570 ffi::FMOD_DSP_OBJECTPAN_OVERRIDE_RANGE => Ok(DspObjectPan::OverrideRange),
3571 _ => Err(err_enum!("FMOD_DSP_OBJECTPAN", value)),
3572 }
3573 }
3574}
3575#[derive(Debug, Clone)]
3576pub struct BankInfo {
3577 pub size: i32,
3578 pub userdata: *mut c_void,
3579 pub userdatalength: i32,
3580 pub opencallback: ffi::FMOD_FILE_OPEN_CALLBACK,
3581 pub closecallback: ffi::FMOD_FILE_CLOSE_CALLBACK,
3582 pub readcallback: ffi::FMOD_FILE_READ_CALLBACK,
3583 pub seekcallback: ffi::FMOD_FILE_SEEK_CALLBACK,
3584}
3585impl TryFrom<ffi::FMOD_STUDIO_BANK_INFO> for BankInfo {
3586 type Error = Error;
3587 fn try_from(value: ffi::FMOD_STUDIO_BANK_INFO) -> Result<Self, Self::Error> {
3588 unsafe {
3589 Ok(BankInfo {
3590 size: value.size,
3591 userdata: value.userdata,
3592 userdatalength: value.userdatalength,
3593 opencallback: value.opencallback,
3594 closecallback: value.closecallback,
3595 readcallback: value.readcallback,
3596 seekcallback: value.seekcallback,
3597 })
3598 }
3599 }
3600}
3601impl Into<ffi::FMOD_STUDIO_BANK_INFO> for BankInfo {
3602 fn into(self) -> ffi::FMOD_STUDIO_BANK_INFO {
3603 ffi::FMOD_STUDIO_BANK_INFO {
3604 size: self.size,
3605 userdata: self.userdata,
3606 userdatalength: self.userdatalength,
3607 opencallback: self.opencallback,
3608 closecallback: self.closecallback,
3609 readcallback: self.readcallback,
3610 seekcallback: self.seekcallback,
3611 }
3612 }
3613}
3614#[derive(Debug, Clone)]
3615pub struct ParameterId {
3616 pub data_1: u32,
3617 pub data_2: u32,
3618}
3619impl TryFrom<ffi::FMOD_STUDIO_PARAMETER_ID> for ParameterId {
3620 type Error = Error;
3621 fn try_from(value: ffi::FMOD_STUDIO_PARAMETER_ID) -> Result<Self, Self::Error> {
3622 unsafe {
3623 Ok(ParameterId {
3624 data_1: value.data1,
3625 data_2: value.data2,
3626 })
3627 }
3628 }
3629}
3630impl Into<ffi::FMOD_STUDIO_PARAMETER_ID> for ParameterId {
3631 fn into(self) -> ffi::FMOD_STUDIO_PARAMETER_ID {
3632 ffi::FMOD_STUDIO_PARAMETER_ID {
3633 data1: self.data_1,
3634 data2: self.data_2,
3635 }
3636 }
3637}
3638#[derive(Debug, Clone)]
3639pub struct ParameterDescription {
3640 pub name: String,
3641 pub id: ParameterId,
3642 pub minimum: f32,
3643 pub maximum: f32,
3644 pub defaultvalue: f32,
3645 pub type_: ParameterType,
3646 pub flags: ffi::FMOD_STUDIO_PARAMETER_FLAGS,
3647 pub guid: Guid,
3648}
3649impl TryFrom<ffi::FMOD_STUDIO_PARAMETER_DESCRIPTION> for ParameterDescription {
3650 type Error = Error;
3651 fn try_from(value: ffi::FMOD_STUDIO_PARAMETER_DESCRIPTION) -> Result<Self, Self::Error> {
3652 unsafe {
3653 Ok(ParameterDescription {
3654 name: to_string!(value.name)?,
3655 id: ParameterId::try_from(value.id)?,
3656 minimum: value.minimum,
3657 maximum: value.maximum,
3658 defaultvalue: value.defaultvalue,
3659 type_: ParameterType::from(value.type_)?,
3660 flags: value.flags,
3661 guid: Guid::try_from(value.guid)?,
3662 })
3663 }
3664 }
3665}
3666impl Into<ffi::FMOD_STUDIO_PARAMETER_DESCRIPTION> for ParameterDescription {
3667 fn into(self) -> ffi::FMOD_STUDIO_PARAMETER_DESCRIPTION {
3668 ffi::FMOD_STUDIO_PARAMETER_DESCRIPTION {
3669 name: move_string_to_c!(self.name),
3670 id: self.id.into(),
3671 minimum: self.minimum,
3672 maximum: self.maximum,
3673 defaultvalue: self.defaultvalue,
3674 type_: self.type_.into(),
3675 flags: self.flags,
3676 guid: self.guid.into(),
3677 }
3678 }
3679}
3680#[derive(Clone)]
3681pub struct UserProperty {
3682 pub name: String,
3683 pub type_: UserPropertyType,
3684 pub union: ffi::FMOD_STUDIO_USER_PROPERTY_UNION,
3685}
3686impl TryFrom<ffi::FMOD_STUDIO_USER_PROPERTY> for UserProperty {
3687 type Error = Error;
3688 fn try_from(value: ffi::FMOD_STUDIO_USER_PROPERTY) -> Result<Self, Self::Error> {
3689 unsafe {
3690 Ok(UserProperty {
3691 name: to_string!(value.name)?,
3692 type_: UserPropertyType::from(value.type_)?,
3693 union: value.union,
3694 })
3695 }
3696 }
3697}
3698impl Into<ffi::FMOD_STUDIO_USER_PROPERTY> for UserProperty {
3699 fn into(self) -> ffi::FMOD_STUDIO_USER_PROPERTY {
3700 ffi::FMOD_STUDIO_USER_PROPERTY {
3701 name: move_string_to_c!(self.name),
3702 type_: self.type_.into(),
3703 union: self.union,
3704 }
3705 }
3706}
3707#[derive(Debug, Clone)]
3708pub struct ProgrammerSoundProperties {
3709 pub name: String,
3710 pub sound: Sound,
3711 pub subsound_index: i32,
3712}
3713impl TryFrom<ffi::FMOD_STUDIO_PROGRAMMER_SOUND_PROPERTIES> for ProgrammerSoundProperties {
3714 type Error = Error;
3715 fn try_from(value: ffi::FMOD_STUDIO_PROGRAMMER_SOUND_PROPERTIES) -> Result<Self, Self::Error> {
3716 unsafe {
3717 Ok(ProgrammerSoundProperties {
3718 name: to_string!(value.name)?,
3719 sound: Sound::from(value.sound),
3720 subsound_index: value.subsoundIndex,
3721 })
3722 }
3723 }
3724}
3725impl Into<ffi::FMOD_STUDIO_PROGRAMMER_SOUND_PROPERTIES> for ProgrammerSoundProperties {
3726 fn into(self) -> ffi::FMOD_STUDIO_PROGRAMMER_SOUND_PROPERTIES {
3727 ffi::FMOD_STUDIO_PROGRAMMER_SOUND_PROPERTIES {
3728 name: move_string_to_c!(self.name),
3729 sound: self.sound.as_mut_ptr(),
3730 subsoundIndex: self.subsound_index,
3731 }
3732 }
3733}
3734#[derive(Debug, Clone)]
3735pub struct PluginInstanceProperties {
3736 pub name: String,
3737 pub dsp: Dsp,
3738}
3739impl TryFrom<ffi::FMOD_STUDIO_PLUGIN_INSTANCE_PROPERTIES> for PluginInstanceProperties {
3740 type Error = Error;
3741 fn try_from(value: ffi::FMOD_STUDIO_PLUGIN_INSTANCE_PROPERTIES) -> Result<Self, Self::Error> {
3742 unsafe {
3743 Ok(PluginInstanceProperties {
3744 name: to_string!(value.name)?,
3745 dsp: Dsp::from(value.dsp),
3746 })
3747 }
3748 }
3749}
3750impl Into<ffi::FMOD_STUDIO_PLUGIN_INSTANCE_PROPERTIES> for PluginInstanceProperties {
3751 fn into(self) -> ffi::FMOD_STUDIO_PLUGIN_INSTANCE_PROPERTIES {
3752 ffi::FMOD_STUDIO_PLUGIN_INSTANCE_PROPERTIES {
3753 name: move_string_to_c!(self.name),
3754 dsp: self.dsp.as_mut_ptr(),
3755 }
3756 }
3757}
3758#[derive(Debug, Clone)]
3759pub struct TimelineMarkerProperties {
3760 pub name: String,
3761 pub position: i32,
3762}
3763impl TryFrom<ffi::FMOD_STUDIO_TIMELINE_MARKER_PROPERTIES> for TimelineMarkerProperties {
3764 type Error = Error;
3765 fn try_from(value: ffi::FMOD_STUDIO_TIMELINE_MARKER_PROPERTIES) -> Result<Self, Self::Error> {
3766 unsafe {
3767 Ok(TimelineMarkerProperties {
3768 name: to_string!(value.name)?,
3769 position: value.position,
3770 })
3771 }
3772 }
3773}
3774impl Into<ffi::FMOD_STUDIO_TIMELINE_MARKER_PROPERTIES> for TimelineMarkerProperties {
3775 fn into(self) -> ffi::FMOD_STUDIO_TIMELINE_MARKER_PROPERTIES {
3776 ffi::FMOD_STUDIO_TIMELINE_MARKER_PROPERTIES {
3777 name: move_string_to_c!(self.name),
3778 position: self.position,
3779 }
3780 }
3781}
3782#[derive(Debug, Clone)]
3783pub struct TimelineBeatProperties {
3784 pub bar: i32,
3785 pub beat: i32,
3786 pub position: i32,
3787 pub tempo: f32,
3788 pub timesignatureupper: i32,
3789 pub timesignaturelower: i32,
3790}
3791impl TryFrom<ffi::FMOD_STUDIO_TIMELINE_BEAT_PROPERTIES> for TimelineBeatProperties {
3792 type Error = Error;
3793 fn try_from(value: ffi::FMOD_STUDIO_TIMELINE_BEAT_PROPERTIES) -> Result<Self, Self::Error> {
3794 unsafe {
3795 Ok(TimelineBeatProperties {
3796 bar: value.bar,
3797 beat: value.beat,
3798 position: value.position,
3799 tempo: value.tempo,
3800 timesignatureupper: value.timesignatureupper,
3801 timesignaturelower: value.timesignaturelower,
3802 })
3803 }
3804 }
3805}
3806impl Into<ffi::FMOD_STUDIO_TIMELINE_BEAT_PROPERTIES> for TimelineBeatProperties {
3807 fn into(self) -> ffi::FMOD_STUDIO_TIMELINE_BEAT_PROPERTIES {
3808 ffi::FMOD_STUDIO_TIMELINE_BEAT_PROPERTIES {
3809 bar: self.bar,
3810 beat: self.beat,
3811 position: self.position,
3812 tempo: self.tempo,
3813 timesignatureupper: self.timesignatureupper,
3814 timesignaturelower: self.timesignaturelower,
3815 }
3816 }
3817}
3818#[derive(Debug, Clone)]
3819pub struct TimelineNestedBeatProperties {
3820 pub eventid: Guid,
3821 pub properties: TimelineBeatProperties,
3822}
3823impl TryFrom<ffi::FMOD_STUDIO_TIMELINE_NESTED_BEAT_PROPERTIES> for TimelineNestedBeatProperties {
3824 type Error = Error;
3825 fn try_from(
3826 value: ffi::FMOD_STUDIO_TIMELINE_NESTED_BEAT_PROPERTIES,
3827 ) -> Result<Self, Self::Error> {
3828 unsafe {
3829 Ok(TimelineNestedBeatProperties {
3830 eventid: Guid::try_from(value.eventid)?,
3831 properties: TimelineBeatProperties::try_from(value.properties)?,
3832 })
3833 }
3834 }
3835}
3836impl Into<ffi::FMOD_STUDIO_TIMELINE_NESTED_BEAT_PROPERTIES> for TimelineNestedBeatProperties {
3837 fn into(self) -> ffi::FMOD_STUDIO_TIMELINE_NESTED_BEAT_PROPERTIES {
3838 ffi::FMOD_STUDIO_TIMELINE_NESTED_BEAT_PROPERTIES {
3839 eventid: self.eventid.into(),
3840 properties: self.properties.into(),
3841 }
3842 }
3843}
3844#[derive(Debug, Clone)]
3845pub struct StudioAdvancedSettings {
3846 pub commandqueuesize: u32,
3847 pub handleinitialsize: u32,
3848 pub studioupdateperiod: i32,
3849 pub idlesampledatapoolsize: i32,
3850 pub streamingscheduledelay: u32,
3851 pub encryptionkey: String,
3852}
3853impl TryFrom<ffi::FMOD_STUDIO_ADVANCEDSETTINGS> for StudioAdvancedSettings {
3854 type Error = Error;
3855 fn try_from(value: ffi::FMOD_STUDIO_ADVANCEDSETTINGS) -> Result<Self, Self::Error> {
3856 unsafe {
3857 Ok(StudioAdvancedSettings {
3858 commandqueuesize: value.commandqueuesize,
3859 handleinitialsize: value.handleinitialsize,
3860 studioupdateperiod: value.studioupdateperiod,
3861 idlesampledatapoolsize: value.idlesampledatapoolsize,
3862 streamingscheduledelay: value.streamingscheduledelay,
3863 encryptionkey: to_string!(value.encryptionkey)?,
3864 })
3865 }
3866 }
3867}
3868impl Into<ffi::FMOD_STUDIO_ADVANCEDSETTINGS> for StudioAdvancedSettings {
3869 fn into(self) -> ffi::FMOD_STUDIO_ADVANCEDSETTINGS {
3870 ffi::FMOD_STUDIO_ADVANCEDSETTINGS {
3871 cbsize: size_of::<ffi::FMOD_STUDIO_ADVANCEDSETTINGS>() as i32,
3872 commandqueuesize: self.commandqueuesize,
3873 handleinitialsize: self.handleinitialsize,
3874 studioupdateperiod: self.studioupdateperiod,
3875 idlesampledatapoolsize: self.idlesampledatapoolsize,
3876 streamingscheduledelay: self.streamingscheduledelay,
3877 encryptionkey: move_string_to_c!(self.encryptionkey),
3878 }
3879 }
3880}
3881#[derive(Debug, Clone)]
3882pub struct StudioCpuUsage {
3883 pub update: f32,
3884}
3885impl TryFrom<ffi::FMOD_STUDIO_CPU_USAGE> for StudioCpuUsage {
3886 type Error = Error;
3887 fn try_from(value: ffi::FMOD_STUDIO_CPU_USAGE) -> Result<Self, Self::Error> {
3888 unsafe {
3889 Ok(StudioCpuUsage {
3890 update: value.update,
3891 })
3892 }
3893 }
3894}
3895impl Into<ffi::FMOD_STUDIO_CPU_USAGE> for StudioCpuUsage {
3896 fn into(self) -> ffi::FMOD_STUDIO_CPU_USAGE {
3897 ffi::FMOD_STUDIO_CPU_USAGE {
3898 update: self.update,
3899 }
3900 }
3901}
3902#[derive(Debug, Clone)]
3903pub struct BufferInfo {
3904 pub currentusage: i32,
3905 pub peakusage: i32,
3906 pub capacity: i32,
3907 pub stallcount: i32,
3908 pub stalltime: f32,
3909}
3910impl TryFrom<ffi::FMOD_STUDIO_BUFFER_INFO> for BufferInfo {
3911 type Error = Error;
3912 fn try_from(value: ffi::FMOD_STUDIO_BUFFER_INFO) -> Result<Self, Self::Error> {
3913 unsafe {
3914 Ok(BufferInfo {
3915 currentusage: value.currentusage,
3916 peakusage: value.peakusage,
3917 capacity: value.capacity,
3918 stallcount: value.stallcount,
3919 stalltime: value.stalltime,
3920 })
3921 }
3922 }
3923}
3924impl Into<ffi::FMOD_STUDIO_BUFFER_INFO> for BufferInfo {
3925 fn into(self) -> ffi::FMOD_STUDIO_BUFFER_INFO {
3926 ffi::FMOD_STUDIO_BUFFER_INFO {
3927 currentusage: self.currentusage,
3928 peakusage: self.peakusage,
3929 capacity: self.capacity,
3930 stallcount: self.stallcount,
3931 stalltime: self.stalltime,
3932 }
3933 }
3934}
3935#[derive(Debug, Clone)]
3936pub struct BufferUsage {
3937 pub studiocommandqueue: BufferInfo,
3938 pub studiohandle: BufferInfo,
3939}
3940impl TryFrom<ffi::FMOD_STUDIO_BUFFER_USAGE> for BufferUsage {
3941 type Error = Error;
3942 fn try_from(value: ffi::FMOD_STUDIO_BUFFER_USAGE) -> Result<Self, Self::Error> {
3943 unsafe {
3944 Ok(BufferUsage {
3945 studiocommandqueue: BufferInfo::try_from(value.studiocommandqueue)?,
3946 studiohandle: BufferInfo::try_from(value.studiohandle)?,
3947 })
3948 }
3949 }
3950}
3951impl Into<ffi::FMOD_STUDIO_BUFFER_USAGE> for BufferUsage {
3952 fn into(self) -> ffi::FMOD_STUDIO_BUFFER_USAGE {
3953 ffi::FMOD_STUDIO_BUFFER_USAGE {
3954 studiocommandqueue: self.studiocommandqueue.into(),
3955 studiohandle: self.studiohandle.into(),
3956 }
3957 }
3958}
3959#[derive(Debug, Clone)]
3960pub struct SoundInfo {
3961 pub name_or_data: String,
3962 pub mode: ffi::FMOD_MODE,
3963 pub exinfo: CreateSoundexInfo,
3964 pub subsoundindex: i32,
3965}
3966impl TryFrom<ffi::FMOD_STUDIO_SOUND_INFO> for SoundInfo {
3967 type Error = Error;
3968 fn try_from(value: ffi::FMOD_STUDIO_SOUND_INFO) -> Result<Self, Self::Error> {
3969 unsafe {
3970 Ok(SoundInfo {
3971 name_or_data: to_string!(value.name_or_data)?,
3972 mode: value.mode,
3973 exinfo: CreateSoundexInfo::try_from(value.exinfo)?,
3974 subsoundindex: value.subsoundindex,
3975 })
3976 }
3977 }
3978}
3979impl Into<ffi::FMOD_STUDIO_SOUND_INFO> for SoundInfo {
3980 fn into(self) -> ffi::FMOD_STUDIO_SOUND_INFO {
3981 ffi::FMOD_STUDIO_SOUND_INFO {
3982 name_or_data: move_string_to_c!(self.name_or_data),
3983 mode: self.mode,
3984 exinfo: self.exinfo.into(),
3985 subsoundindex: self.subsoundindex,
3986 }
3987 }
3988}
3989#[derive(Debug, Clone)]
3990pub struct CommandInfo {
3991 pub commandname: String,
3992 pub parentcommandindex: i32,
3993 pub framenumber: i32,
3994 pub frametime: f32,
3995 pub instancetype: InstanceType,
3996 pub outputtype: InstanceType,
3997 pub instancehandle: u32,
3998 pub outputhandle: u32,
3999}
4000impl TryFrom<ffi::FMOD_STUDIO_COMMAND_INFO> for CommandInfo {
4001 type Error = Error;
4002 fn try_from(value: ffi::FMOD_STUDIO_COMMAND_INFO) -> Result<Self, Self::Error> {
4003 unsafe {
4004 Ok(CommandInfo {
4005 commandname: to_string!(value.commandname)?,
4006 parentcommandindex: value.parentcommandindex,
4007 framenumber: value.framenumber,
4008 frametime: value.frametime,
4009 instancetype: InstanceType::from(value.instancetype)?,
4010 outputtype: InstanceType::from(value.outputtype)?,
4011 instancehandle: value.instancehandle,
4012 outputhandle: value.outputhandle,
4013 })
4014 }
4015 }
4016}
4017impl Into<ffi::FMOD_STUDIO_COMMAND_INFO> for CommandInfo {
4018 fn into(self) -> ffi::FMOD_STUDIO_COMMAND_INFO {
4019 ffi::FMOD_STUDIO_COMMAND_INFO {
4020 commandname: move_string_to_c!(self.commandname),
4021 parentcommandindex: self.parentcommandindex,
4022 framenumber: self.framenumber,
4023 frametime: self.frametime,
4024 instancetype: self.instancetype.into(),
4025 outputtype: self.outputtype.into(),
4026 instancehandle: self.instancehandle,
4027 outputhandle: self.outputhandle,
4028 }
4029 }
4030}
4031#[derive(Debug, Clone)]
4032pub struct MemoryUsage {
4033 pub exclusive: i32,
4034 pub inclusive: i32,
4035 pub sampledata: i32,
4036}
4037impl TryFrom<ffi::FMOD_STUDIO_MEMORY_USAGE> for MemoryUsage {
4038 type Error = Error;
4039 fn try_from(value: ffi::FMOD_STUDIO_MEMORY_USAGE) -> Result<Self, Self::Error> {
4040 unsafe {
4041 Ok(MemoryUsage {
4042 exclusive: value.exclusive,
4043 inclusive: value.inclusive,
4044 sampledata: value.sampledata,
4045 })
4046 }
4047 }
4048}
4049impl Into<ffi::FMOD_STUDIO_MEMORY_USAGE> for MemoryUsage {
4050 fn into(self) -> ffi::FMOD_STUDIO_MEMORY_USAGE {
4051 ffi::FMOD_STUDIO_MEMORY_USAGE {
4052 exclusive: self.exclusive,
4053 inclusive: self.inclusive,
4054 sampledata: self.sampledata,
4055 }
4056 }
4057}
4058#[derive(Debug, Clone)]
4059pub struct AsyncReadInfo {
4060 pub handle: *mut c_void,
4061 pub offset: u32,
4062 pub sizebytes: u32,
4063 pub priority: i32,
4064 pub userdata: *mut c_void,
4065 pub buffer: *mut c_void,
4066 pub bytesread: u32,
4067 pub done: ffi::FMOD_FILE_ASYNCDONE_FUNC,
4068}
4069impl TryFrom<ffi::FMOD_ASYNCREADINFO> for AsyncReadInfo {
4070 type Error = Error;
4071 fn try_from(value: ffi::FMOD_ASYNCREADINFO) -> Result<Self, Self::Error> {
4072 unsafe {
4073 Ok(AsyncReadInfo {
4074 handle: value.handle,
4075 offset: value.offset,
4076 sizebytes: value.sizebytes,
4077 priority: value.priority,
4078 userdata: value.userdata,
4079 buffer: value.buffer,
4080 bytesread: value.bytesread,
4081 done: value.done,
4082 })
4083 }
4084 }
4085}
4086impl Into<ffi::FMOD_ASYNCREADINFO> for AsyncReadInfo {
4087 fn into(self) -> ffi::FMOD_ASYNCREADINFO {
4088 ffi::FMOD_ASYNCREADINFO {
4089 handle: self.handle,
4090 offset: self.offset,
4091 sizebytes: self.sizebytes,
4092 priority: self.priority,
4093 userdata: self.userdata,
4094 buffer: self.buffer,
4095 bytesread: self.bytesread,
4096 done: self.done,
4097 }
4098 }
4099}
4100#[derive(Debug, Clone, Copy, PartialEq)]
4101pub struct Vector {
4102 pub x: f32,
4103 pub y: f32,
4104 pub z: f32,
4105}
4106impl TryFrom<ffi::FMOD_VECTOR> for Vector {
4107 type Error = Error;
4108 fn try_from(value: ffi::FMOD_VECTOR) -> Result<Self, Self::Error> {
4109 unsafe {
4110 Ok(Vector {
4111 x: value.x,
4112 y: value.y,
4113 z: value.z,
4114 })
4115 }
4116 }
4117}
4118impl Vector {
4119 pub const fn new(x: f32, y: f32, z: f32) -> Self {
4120 Vector { x, y, z }
4121 }
4122}
4123impl From<[f32; 3]> for Vector {
4124 fn from(value: [f32; 3]) -> Vector {
4125 Vector {
4126 x: value[0],
4127 y: value[1],
4128 z: value[2],
4129 }
4130 }
4131}
4132impl From<Vector> for [f32; 3] {
4133 fn from(value: Vector) -> [f32; 3] {
4134 [value.x, value.y, value.z]
4135 }
4136}
4137impl From<(f32, f32, f32)> for Vector {
4138 fn from(value: (f32, f32, f32)) -> Vector {
4139 Vector {
4140 x: value.0,
4141 y: value.1,
4142 z: value.2,
4143 }
4144 }
4145}
4146impl From<Vector> for (f32, f32, f32) {
4147 fn from(value: Vector) -> (f32, f32, f32) {
4148 (value.x, value.y, value.z)
4149 }
4150}
4151impl Into<ffi::FMOD_VECTOR> for Vector {
4152 fn into(self) -> ffi::FMOD_VECTOR {
4153 ffi::FMOD_VECTOR {
4154 x: self.x,
4155 y: self.y,
4156 z: self.z,
4157 }
4158 }
4159}
4160#[derive(Debug, Clone)]
4161pub struct Attributes3d {
4162 pub position: Vector,
4163 pub velocity: Vector,
4164 pub forward: Vector,
4165 pub up: Vector,
4166}
4167impl TryFrom<ffi::FMOD_3D_ATTRIBUTES> for Attributes3d {
4168 type Error = Error;
4169 fn try_from(value: ffi::FMOD_3D_ATTRIBUTES) -> Result<Self, Self::Error> {
4170 unsafe {
4171 Ok(Attributes3d {
4172 position: Vector::try_from(value.position)?,
4173 velocity: Vector::try_from(value.velocity)?,
4174 forward: Vector::try_from(value.forward)?,
4175 up: Vector::try_from(value.up)?,
4176 })
4177 }
4178 }
4179}
4180impl Into<ffi::FMOD_3D_ATTRIBUTES> for Attributes3d {
4181 fn into(self) -> ffi::FMOD_3D_ATTRIBUTES {
4182 ffi::FMOD_3D_ATTRIBUTES {
4183 position: self.position.into(),
4184 velocity: self.velocity.into(),
4185 forward: self.forward.into(),
4186 up: self.up.into(),
4187 }
4188 }
4189}
4190#[derive(Debug, Clone)]
4191pub struct Guid {
4192 pub data_1: u32,
4193 pub data_2: u16,
4194 pub data_3: u16,
4195 pub data_4: [u8; 8 as usize],
4196}
4197impl TryFrom<ffi::FMOD_GUID> for Guid {
4198 type Error = Error;
4199 fn try_from(value: ffi::FMOD_GUID) -> Result<Self, Self::Error> {
4200 unsafe {
4201 Ok(Guid {
4202 data_1: value.Data1,
4203 data_2: value.Data2,
4204 data_3: value.Data3,
4205 data_4: value.Data4,
4206 })
4207 }
4208 }
4209}
4210impl Guid {
4211 pub fn from_ptr(value: *mut ffi::FMOD_GUID) -> Self {
4212 let value = unsafe { *value };
4213 Self {
4214 data_1: value.Data1,
4215 data_2: value.Data2,
4216 data_3: value.Data3,
4217 data_4: value.Data4,
4218 }
4219 }
4220}
4221impl Into<ffi::FMOD_GUID> for Guid {
4222 fn into(self) -> ffi::FMOD_GUID {
4223 ffi::FMOD_GUID {
4224 Data1: self.data_1,
4225 Data2: self.data_2,
4226 Data3: self.data_3,
4227 Data4: self.data_4,
4228 }
4229 }
4230}
4231#[derive(Debug, Clone)]
4232pub struct PluginList {
4233 pub type_: PluginType,
4234 pub description: *mut c_void,
4235}
4236impl TryFrom<ffi::FMOD_PLUGINLIST> for PluginList {
4237 type Error = Error;
4238 fn try_from(value: ffi::FMOD_PLUGINLIST) -> Result<Self, Self::Error> {
4239 unsafe {
4240 Ok(PluginList {
4241 type_: PluginType::from(value.type_)?,
4242 description: value.description,
4243 })
4244 }
4245 }
4246}
4247impl Into<ffi::FMOD_PLUGINLIST> for PluginList {
4248 fn into(self) -> ffi::FMOD_PLUGINLIST {
4249 ffi::FMOD_PLUGINLIST {
4250 type_: self.type_.into(),
4251 description: self.description,
4252 }
4253 }
4254}
4255#[derive(Debug, Clone)]
4256pub struct AdvancedSettings {
4257 pub max_mpeg_codecs: i32,
4258 pub max_adpcm_codecs: i32,
4259 pub max_xma_codecs: i32,
4260 pub max_vorbis_codecs: i32,
4261 pub max_at_9_codecs: i32,
4262 pub max_fadpcm_codecs: i32,
4263 pub max_pcm_codecs: i32,
4264 pub asio_num_channels: i32,
4265 pub asio_channel_list: Vec<String>,
4266 pub asio_speaker_list: Vec<Speaker>,
4267 pub vol_0_virtualvol: f32,
4268 pub default_decode_buffer_size: u32,
4269 pub profile_port: u16,
4270 pub geometry_max_fade_time: u32,
4271 pub distance_filter_center_freq: f32,
4272 pub reverb_3_d_instance: i32,
4273 pub dsp_buffer_pool_size: i32,
4274 pub resampler_method: DspResampler,
4275 pub random_seed: u32,
4276 pub max_convolution_threads: i32,
4277 pub max_opus_codecs: i32,
4278 pub max_spatial_objects: i32,
4279}
4280impl TryFrom<ffi::FMOD_ADVANCEDSETTINGS> for AdvancedSettings {
4281 type Error = Error;
4282 fn try_from(value: ffi::FMOD_ADVANCEDSETTINGS) -> Result<Self, Self::Error> {
4283 unsafe {
4284 Ok(AdvancedSettings {
4285 max_mpeg_codecs: value.maxMPEGCodecs,
4286 max_adpcm_codecs: value.maxADPCMCodecs,
4287 max_xma_codecs: value.maxXMACodecs,
4288 max_vorbis_codecs: value.maxVorbisCodecs,
4289 max_at_9_codecs: value.maxAT9Codecs,
4290 max_fadpcm_codecs: value.maxFADPCMCodecs,
4291 max_pcm_codecs: value.maxPCMCodecs,
4292 asio_num_channels: value.ASIONumChannels,
4293 asio_channel_list: to_vec!(
4294 value.ASIOChannelList,
4295 value.ASIONumChannels,
4296 |ptr| to_string!(ptr)
4297 )?,
4298 asio_speaker_list: to_vec!(
4299 value.ASIOSpeakerList,
4300 value.ASIONumChannels,
4301 Speaker::from
4302 )?,
4303 vol_0_virtualvol: value.vol0virtualvol,
4304 default_decode_buffer_size: value.defaultDecodeBufferSize,
4305 profile_port: value.profilePort,
4306 geometry_max_fade_time: value.geometryMaxFadeTime,
4307 distance_filter_center_freq: value.distanceFilterCenterFreq,
4308 reverb_3_d_instance: value.reverb3Dinstance,
4309 dsp_buffer_pool_size: value.DSPBufferPoolSize,
4310 resampler_method: DspResampler::from(value.resamplerMethod)?,
4311 random_seed: value.randomSeed,
4312 max_convolution_threads: value.maxConvolutionThreads,
4313 max_opus_codecs: value.maxOpusCodecs,
4314 max_spatial_objects: value.maxSpatialObjects,
4315 })
4316 }
4317 }
4318}
4319impl Into<ffi::FMOD_ADVANCEDSETTINGS> for AdvancedSettings {
4320 fn into(self) -> ffi::FMOD_ADVANCEDSETTINGS {
4321 ffi::FMOD_ADVANCEDSETTINGS {
4322 cbSize: size_of::<ffi::FMOD_ADVANCEDSETTINGS>() as i32,
4323 maxMPEGCodecs: self.max_mpeg_codecs,
4324 maxADPCMCodecs: self.max_adpcm_codecs,
4325 maxXMACodecs: self.max_xma_codecs,
4326 maxVorbisCodecs: self.max_vorbis_codecs,
4327 maxAT9Codecs: self.max_at_9_codecs,
4328 maxFADPCMCodecs: self.max_fadpcm_codecs,
4329 maxPCMCodecs: self.max_pcm_codecs,
4330 ASIONumChannels: self.asio_num_channels,
4331 ASIOChannelList: self
4332 .asio_channel_list
4333 .into_iter()
4334 .map(|val| val.as_ptr())
4335 .collect::<Vec<_>>()
4336 .as_mut_ptr()
4337 .cast(),
4338 ASIOSpeakerList: self
4339 .asio_speaker_list
4340 .into_iter()
4341 .map(|val| val.into())
4342 .collect::<Vec<_>>()
4343 .as_mut_ptr(),
4344 vol0virtualvol: self.vol_0_virtualvol,
4345 defaultDecodeBufferSize: self.default_decode_buffer_size,
4346 profilePort: self.profile_port,
4347 geometryMaxFadeTime: self.geometry_max_fade_time,
4348 distanceFilterCenterFreq: self.distance_filter_center_freq,
4349 reverb3Dinstance: self.reverb_3_d_instance,
4350 DSPBufferPoolSize: self.dsp_buffer_pool_size,
4351 resamplerMethod: self.resampler_method.into(),
4352 randomSeed: self.random_seed,
4353 maxConvolutionThreads: self.max_convolution_threads,
4354 maxOpusCodecs: self.max_opus_codecs,
4355 maxSpatialObjects: self.max_spatial_objects,
4356 }
4357 }
4358}
4359#[derive(Debug, Clone)]
4360pub struct Tag {
4361 pub type_: TagType,
4362 pub datatype: TagDataType,
4363 pub name: String,
4364 pub data: *mut c_void,
4365 pub datalen: u32,
4366 pub updated: ffi::FMOD_BOOL,
4367}
4368impl TryFrom<ffi::FMOD_TAG> for Tag {
4369 type Error = Error;
4370 fn try_from(value: ffi::FMOD_TAG) -> Result<Self, Self::Error> {
4371 unsafe {
4372 Ok(Tag {
4373 type_: TagType::from(value.type_)?,
4374 datatype: TagDataType::from(value.datatype)?,
4375 name: to_string!(value.name)?,
4376 data: value.data,
4377 datalen: value.datalen,
4378 updated: value.updated,
4379 })
4380 }
4381 }
4382}
4383impl Into<ffi::FMOD_TAG> for Tag {
4384 fn into(self) -> ffi::FMOD_TAG {
4385 ffi::FMOD_TAG {
4386 type_: self.type_.into(),
4387 datatype: self.datatype.into(),
4388 name: move_string_to_c!(self.name) as *mut _,
4389 data: self.data,
4390 datalen: self.datalen,
4391 updated: self.updated,
4392 }
4393 }
4394}
4395#[derive(Debug, Clone)]
4396pub struct CreateSoundexInfo {
4397 pub length: u32,
4398 pub fileoffset: u32,
4399 pub numchannels: i32,
4400 pub defaultfrequency: i32,
4401 pub format: SoundFormat,
4402 pub decodebuffersize: u32,
4403 pub initialsubsound: i32,
4404 pub numsubsounds: i32,
4405 pub inclusionlist: Option<Vec<i32>>,
4406 pub pcmreadcallback: ffi::FMOD_SOUND_PCMREAD_CALLBACK,
4407 pub pcmsetposcallback: ffi::FMOD_SOUND_PCMSETPOS_CALLBACK,
4408 pub nonblockcallback: ffi::FMOD_SOUND_NONBLOCK_CALLBACK,
4409 pub dlsname: Option<String>,
4410 pub encryptionkey: Option<String>,
4411 pub maxpolyphony: i32,
4412 pub userdata: *mut c_void,
4413 pub suggestedsoundtype: SoundType,
4414 pub fileuseropen: ffi::FMOD_FILE_OPEN_CALLBACK,
4415 pub fileuserclose: ffi::FMOD_FILE_CLOSE_CALLBACK,
4416 pub fileuserread: ffi::FMOD_FILE_READ_CALLBACK,
4417 pub fileuserseek: ffi::FMOD_FILE_SEEK_CALLBACK,
4418 pub fileuserasyncread: ffi::FMOD_FILE_ASYNCREAD_CALLBACK,
4419 pub fileuserasynccancel: ffi::FMOD_FILE_ASYNCCANCEL_CALLBACK,
4420 pub fileuserdata: *mut c_void,
4421 pub filebuffersize: i32,
4422 pub channelorder: ChannelOrder,
4423 pub initialsoundgroup: Option<SoundGroup>,
4424 pub initialseekposition: u32,
4425 pub initialseekpostype: ffi::FMOD_TIMEUNIT,
4426 pub ignoresetfilesystem: i32,
4427 pub audioqueuepolicy: u32,
4428 pub minmidigranularity: u32,
4429 pub nonblockthreadid: i32,
4430 pub fsbguid: Option<Guid>,
4431}
4432impl TryFrom<ffi::FMOD_CREATESOUNDEXINFO> for CreateSoundexInfo {
4433 type Error = Error;
4434 fn try_from(value: ffi::FMOD_CREATESOUNDEXINFO) -> Result<Self, Self::Error> {
4435 unsafe {
4436 Ok(CreateSoundexInfo {
4437 length: value.length,
4438 fileoffset: value.fileoffset,
4439 numchannels: value.numchannels,
4440 defaultfrequency: value.defaultfrequency,
4441 format: SoundFormat::from(value.format)?,
4442 decodebuffersize: value.decodebuffersize,
4443 initialsubsound: value.initialsubsound,
4444 numsubsounds: value.numsubsounds,
4445 inclusionlist: ptr_opt!(
4446 value.inclusionlist,
4447 to_vec!(value.inclusionlist, value.inclusionlistnum)
4448 ),
4449 pcmreadcallback: value.pcmreadcallback,
4450 pcmsetposcallback: value.pcmsetposcallback,
4451 nonblockcallback: value.nonblockcallback,
4452 dlsname: ptr_opt!(value.dlsname, to_string!(value.dlsname)?),
4453 encryptionkey: ptr_opt!(value.encryptionkey, to_string!(value.encryptionkey)?),
4454 maxpolyphony: value.maxpolyphony,
4455 userdata: value.userdata,
4456 suggestedsoundtype: SoundType::from(value.suggestedsoundtype)?,
4457 fileuseropen: value.fileuseropen,
4458 fileuserclose: value.fileuserclose,
4459 fileuserread: value.fileuserread,
4460 fileuserseek: value.fileuserseek,
4461 fileuserasyncread: value.fileuserasyncread,
4462 fileuserasynccancel: value.fileuserasynccancel,
4463 fileuserdata: value.fileuserdata,
4464 filebuffersize: value.filebuffersize,
4465 channelorder: ChannelOrder::from(value.channelorder)?,
4466 initialsoundgroup: ptr_opt!(
4467 value.initialsoundgroup,
4468 SoundGroup::from(value.initialsoundgroup)
4469 ),
4470 initialseekposition: value.initialseekposition,
4471 initialseekpostype: value.initialseekpostype,
4472 ignoresetfilesystem: value.ignoresetfilesystem,
4473 audioqueuepolicy: value.audioqueuepolicy,
4474 minmidigranularity: value.minmidigranularity,
4475 nonblockthreadid: value.nonblockthreadid,
4476 fsbguid: ptr_opt!(value.fsbguid, Guid::from_ptr(value.fsbguid)),
4477 })
4478 }
4479 }
4480}
4481impl Default for CreateSoundexInfo {
4482 fn default() -> Self {
4483 Self::try_from(ffi::FMOD_CREATESOUNDEXINFO::default()).unwrap()
4484 }
4485}
4486impl Into<ffi::FMOD_CREATESOUNDEXINFO> for CreateSoundexInfo {
4487 fn into(self) -> ffi::FMOD_CREATESOUNDEXINFO {
4488 ffi::FMOD_CREATESOUNDEXINFO {
4489 cbsize: size_of::<ffi::FMOD_CREATESOUNDEXINFO>() as i32,
4490 length: self.length,
4491 fileoffset: self.fileoffset,
4492 numchannels: self.numchannels,
4493 defaultfrequency: self.defaultfrequency,
4494 format: self.format.into(),
4495 decodebuffersize: self.decodebuffersize,
4496 initialsubsound: self.initialsubsound,
4497 numsubsounds: self.numsubsounds,
4498 inclusionlist: opt_ptr!(self.inclusionlist.clone(), |v| v.as_slice().as_ptr()
4499 as *mut _),
4500 inclusionlistnum: self.inclusionlist.map(|v| v.len()).unwrap_or(0) as _,
4501 pcmreadcallback: self.pcmreadcallback,
4502 pcmsetposcallback: self.pcmsetposcallback,
4503 nonblockcallback: self.nonblockcallback,
4504 dlsname: opt_ptr!(self.dlsname.map(|v| CString::new(v).unwrap()), |v| v
4505 .as_ptr()),
4506 encryptionkey: opt_ptr!(self.encryptionkey.map(|v| CString::new(v).unwrap()), |v| v
4507 .as_ptr()),
4508 maxpolyphony: self.maxpolyphony,
4509 userdata: self.userdata,
4510 suggestedsoundtype: self.suggestedsoundtype.into(),
4511 fileuseropen: self.fileuseropen,
4512 fileuserclose: self.fileuserclose,
4513 fileuserread: self.fileuserread,
4514 fileuserseek: self.fileuserseek,
4515 fileuserasyncread: self.fileuserasyncread,
4516 fileuserasynccancel: self.fileuserasynccancel,
4517 fileuserdata: self.fileuserdata,
4518 filebuffersize: self.filebuffersize,
4519 channelorder: self.channelorder.into(),
4520 initialsoundgroup: opt_ptr!(self.initialsoundgroup, |v| v.as_mut_ptr()),
4521 initialseekposition: self.initialseekposition,
4522 initialseekpostype: self.initialseekpostype,
4523 ignoresetfilesystem: self.ignoresetfilesystem,
4524 audioqueuepolicy: self.audioqueuepolicy,
4525 minmidigranularity: self.minmidigranularity,
4526 nonblockthreadid: self.nonblockthreadid,
4527 fsbguid: opt_ptr!(self.fsbguid, |v| &mut v.into() as *mut _),
4528 }
4529 }
4530}
4531#[derive(Debug, Clone)]
4532pub struct ReverbProperties {
4533 pub decay_time: f32,
4534 pub early_delay: f32,
4535 pub late_delay: f32,
4536 pub hf_reference: f32,
4537 pub hf_decay_ratio: f32,
4538 pub diffusion: f32,
4539 pub density: f32,
4540 pub low_shelf_frequency: f32,
4541 pub low_shelf_gain: f32,
4542 pub high_cut: f32,
4543 pub early_late_mix: f32,
4544 pub wet_level: f32,
4545}
4546impl ReverbProperties {
4547 #[inline]
4548 pub fn off() -> Self {
4549 Self::try_from(ffi::FMOD_PRESET_OFF).unwrap()
4550 }
4551 #[inline]
4552 pub fn generic() -> Self {
4553 Self::try_from(ffi::FMOD_PRESET_GENERIC).unwrap()
4554 }
4555 #[inline]
4556 pub fn paddedcell() -> Self {
4557 Self::try_from(ffi::FMOD_PRESET_PADDEDCELL).unwrap()
4558 }
4559 #[inline]
4560 pub fn room() -> Self {
4561 Self::try_from(ffi::FMOD_PRESET_ROOM).unwrap()
4562 }
4563 #[inline]
4564 pub fn bathroom() -> Self {
4565 Self::try_from(ffi::FMOD_PRESET_BATHROOM).unwrap()
4566 }
4567 #[inline]
4568 pub fn livingroom() -> Self {
4569 Self::try_from(ffi::FMOD_PRESET_LIVINGROOM).unwrap()
4570 }
4571 #[inline]
4572 pub fn stoneroom() -> Self {
4573 Self::try_from(ffi::FMOD_PRESET_STONEROOM).unwrap()
4574 }
4575 #[inline]
4576 pub fn auditorium() -> Self {
4577 Self::try_from(ffi::FMOD_PRESET_AUDITORIUM).unwrap()
4578 }
4579 #[inline]
4580 pub fn concerthall() -> Self {
4581 Self::try_from(ffi::FMOD_PRESET_CONCERTHALL).unwrap()
4582 }
4583 #[inline]
4584 pub fn cave() -> Self {
4585 Self::try_from(ffi::FMOD_PRESET_CAVE).unwrap()
4586 }
4587 #[inline]
4588 pub fn arena() -> Self {
4589 Self::try_from(ffi::FMOD_PRESET_ARENA).unwrap()
4590 }
4591 #[inline]
4592 pub fn hangar() -> Self {
4593 Self::try_from(ffi::FMOD_PRESET_HANGAR).unwrap()
4594 }
4595 #[inline]
4596 pub fn carpettedhallway() -> Self {
4597 Self::try_from(ffi::FMOD_PRESET_CARPETTEDHALLWAY).unwrap()
4598 }
4599 #[inline]
4600 pub fn hallway() -> Self {
4601 Self::try_from(ffi::FMOD_PRESET_HALLWAY).unwrap()
4602 }
4603 #[inline]
4604 pub fn stonecorridor() -> Self {
4605 Self::try_from(ffi::FMOD_PRESET_STONECORRIDOR).unwrap()
4606 }
4607 #[inline]
4608 pub fn alley() -> Self {
4609 Self::try_from(ffi::FMOD_PRESET_ALLEY).unwrap()
4610 }
4611 #[inline]
4612 pub fn forest() -> Self {
4613 Self::try_from(ffi::FMOD_PRESET_FOREST).unwrap()
4614 }
4615 #[inline]
4616 pub fn city() -> Self {
4617 Self::try_from(ffi::FMOD_PRESET_CITY).unwrap()
4618 }
4619 #[inline]
4620 pub fn mountains() -> Self {
4621 Self::try_from(ffi::FMOD_PRESET_MOUNTAINS).unwrap()
4622 }
4623 #[inline]
4624 pub fn quarry() -> Self {
4625 Self::try_from(ffi::FMOD_PRESET_QUARRY).unwrap()
4626 }
4627 #[inline]
4628 pub fn plain() -> Self {
4629 Self::try_from(ffi::FMOD_PRESET_PLAIN).unwrap()
4630 }
4631 #[inline]
4632 pub fn parkinglot() -> Self {
4633 Self::try_from(ffi::FMOD_PRESET_PARKINGLOT).unwrap()
4634 }
4635 #[inline]
4636 pub fn sewerpipe() -> Self {
4637 Self::try_from(ffi::FMOD_PRESET_SEWERPIPE).unwrap()
4638 }
4639 #[inline]
4640 pub fn underwater() -> Self {
4641 Self::try_from(ffi::FMOD_PRESET_UNDERWATER).unwrap()
4642 }
4643}
4644impl TryFrom<ffi::FMOD_REVERB_PROPERTIES> for ReverbProperties {
4645 type Error = Error;
4646 fn try_from(value: ffi::FMOD_REVERB_PROPERTIES) -> Result<Self, Self::Error> {
4647 unsafe {
4648 Ok(ReverbProperties {
4649 decay_time: value.DecayTime,
4650 early_delay: value.EarlyDelay,
4651 late_delay: value.LateDelay,
4652 hf_reference: value.HFReference,
4653 hf_decay_ratio: value.HFDecayRatio,
4654 diffusion: value.Diffusion,
4655 density: value.Density,
4656 low_shelf_frequency: value.LowShelfFrequency,
4657 low_shelf_gain: value.LowShelfGain,
4658 high_cut: value.HighCut,
4659 early_late_mix: value.EarlyLateMix,
4660 wet_level: value.WetLevel,
4661 })
4662 }
4663 }
4664}
4665impl Into<ffi::FMOD_REVERB_PROPERTIES> for ReverbProperties {
4666 fn into(self) -> ffi::FMOD_REVERB_PROPERTIES {
4667 ffi::FMOD_REVERB_PROPERTIES {
4668 DecayTime: self.decay_time,
4669 EarlyDelay: self.early_delay,
4670 LateDelay: self.late_delay,
4671 HFReference: self.hf_reference,
4672 HFDecayRatio: self.hf_decay_ratio,
4673 Diffusion: self.diffusion,
4674 Density: self.density,
4675 LowShelfFrequency: self.low_shelf_frequency,
4676 LowShelfGain: self.low_shelf_gain,
4677 HighCut: self.high_cut,
4678 EarlyLateMix: self.early_late_mix,
4679 WetLevel: self.wet_level,
4680 }
4681 }
4682}
4683#[derive(Debug, Clone)]
4684pub struct ErrorCallbackInfo {
4685 pub result: FmodResult,
4686 pub instancetype: ErrorCallbackInstancetype,
4687 pub instance: *mut c_void,
4688 pub functionname: String,
4689 pub functionparams: String,
4690}
4691impl TryFrom<ffi::FMOD_ERRORCALLBACK_INFO> for ErrorCallbackInfo {
4692 type Error = Error;
4693 fn try_from(value: ffi::FMOD_ERRORCALLBACK_INFO) -> Result<Self, Self::Error> {
4694 unsafe {
4695 Ok(ErrorCallbackInfo {
4696 result: FmodResult::from(value.result)?,
4697 instancetype: ErrorCallbackInstancetype::from(value.instancetype)?,
4698 instance: value.instance,
4699 functionname: to_string!(value.functionname)?,
4700 functionparams: to_string!(value.functionparams)?,
4701 })
4702 }
4703 }
4704}
4705impl Into<ffi::FMOD_ERRORCALLBACK_INFO> for ErrorCallbackInfo {
4706 fn into(self) -> ffi::FMOD_ERRORCALLBACK_INFO {
4707 ffi::FMOD_ERRORCALLBACK_INFO {
4708 result: self.result.into(),
4709 instancetype: self.instancetype.into(),
4710 instance: self.instance,
4711 functionname: move_string_to_c!(self.functionname),
4712 functionparams: move_string_to_c!(self.functionparams),
4713 }
4714 }
4715}
4716#[derive(Debug, Clone)]
4717pub struct CpuUsage {
4718 pub dsp: f32,
4719 pub stream: f32,
4720 pub geometry: f32,
4721 pub update: f32,
4722 pub convolution_1: f32,
4723 pub convolution_2: f32,
4724}
4725impl TryFrom<ffi::FMOD_CPU_USAGE> for CpuUsage {
4726 type Error = Error;
4727 fn try_from(value: ffi::FMOD_CPU_USAGE) -> Result<Self, Self::Error> {
4728 unsafe {
4729 Ok(CpuUsage {
4730 dsp: value.dsp,
4731 stream: value.stream,
4732 geometry: value.geometry,
4733 update: value.update,
4734 convolution_1: value.convolution1,
4735 convolution_2: value.convolution2,
4736 })
4737 }
4738 }
4739}
4740impl Into<ffi::FMOD_CPU_USAGE> for CpuUsage {
4741 fn into(self) -> ffi::FMOD_CPU_USAGE {
4742 ffi::FMOD_CPU_USAGE {
4743 dsp: self.dsp,
4744 stream: self.stream,
4745 geometry: self.geometry,
4746 update: self.update,
4747 convolution1: self.convolution_1,
4748 convolution2: self.convolution_2,
4749 }
4750 }
4751}
4752#[derive(Debug, Clone)]
4753pub struct DspDataParameterInfo {
4754 pub data: *mut c_void,
4755 pub length: u32,
4756 pub index: i32,
4757}
4758impl TryFrom<ffi::FMOD_DSP_DATA_PARAMETER_INFO> for DspDataParameterInfo {
4759 type Error = Error;
4760 fn try_from(value: ffi::FMOD_DSP_DATA_PARAMETER_INFO) -> Result<Self, Self::Error> {
4761 unsafe {
4762 Ok(DspDataParameterInfo {
4763 data: value.data,
4764 length: value.length,
4765 index: value.index,
4766 })
4767 }
4768 }
4769}
4770impl Into<ffi::FMOD_DSP_DATA_PARAMETER_INFO> for DspDataParameterInfo {
4771 fn into(self) -> ffi::FMOD_DSP_DATA_PARAMETER_INFO {
4772 ffi::FMOD_DSP_DATA_PARAMETER_INFO {
4773 data: self.data,
4774 length: self.length,
4775 index: self.index,
4776 }
4777 }
4778}
4779#[derive(Debug, Clone)]
4780pub struct CodecDescription {
4781 pub apiversion: u32,
4782 pub name: String,
4783 pub version: u32,
4784 pub defaultasstream: i32,
4785 pub timeunits: ffi::FMOD_TIMEUNIT,
4786 pub open: ffi::FMOD_CODEC_OPEN_CALLBACK,
4787 pub close: ffi::FMOD_CODEC_CLOSE_CALLBACK,
4788 pub read: ffi::FMOD_CODEC_READ_CALLBACK,
4789 pub getlength: ffi::FMOD_CODEC_GETLENGTH_CALLBACK,
4790 pub setposition: ffi::FMOD_CODEC_SETPOSITION_CALLBACK,
4791 pub getposition: ffi::FMOD_CODEC_GETPOSITION_CALLBACK,
4792 pub soundcreate: ffi::FMOD_CODEC_SOUNDCREATE_CALLBACK,
4793 pub getwaveformat: ffi::FMOD_CODEC_GETWAVEFORMAT_CALLBACK,
4794}
4795impl TryFrom<ffi::FMOD_CODEC_DESCRIPTION> for CodecDescription {
4796 type Error = Error;
4797 fn try_from(value: ffi::FMOD_CODEC_DESCRIPTION) -> Result<Self, Self::Error> {
4798 unsafe {
4799 Ok(CodecDescription {
4800 apiversion: value.apiversion,
4801 name: to_string!(value.name)?,
4802 version: value.version,
4803 defaultasstream: value.defaultasstream,
4804 timeunits: value.timeunits,
4805 open: value.open,
4806 close: value.close,
4807 read: value.read,
4808 getlength: value.getlength,
4809 setposition: value.setposition,
4810 getposition: value.getposition,
4811 soundcreate: value.soundcreate,
4812 getwaveformat: value.getwaveformat,
4813 })
4814 }
4815 }
4816}
4817impl Into<ffi::FMOD_CODEC_DESCRIPTION> for CodecDescription {
4818 fn into(self) -> ffi::FMOD_CODEC_DESCRIPTION {
4819 ffi::FMOD_CODEC_DESCRIPTION {
4820 apiversion: self.apiversion,
4821 name: move_string_to_c!(self.name),
4822 version: self.version,
4823 defaultasstream: self.defaultasstream,
4824 timeunits: self.timeunits,
4825 open: self.open,
4826 close: self.close,
4827 read: self.read,
4828 getlength: self.getlength,
4829 setposition: self.setposition,
4830 getposition: self.getposition,
4831 soundcreate: self.soundcreate,
4832 getwaveformat: self.getwaveformat,
4833 }
4834 }
4835}
4836#[derive(Debug, Clone)]
4837pub struct CodecWaveformat {
4838 pub name: String,
4839 pub format: SoundFormat,
4840 pub channels: i32,
4841 pub frequency: i32,
4842 pub lengthbytes: u32,
4843 pub lengthpcm: u32,
4844 pub pcmblocksize: u32,
4845 pub loopstart: i32,
4846 pub loopend: i32,
4847 pub mode: ffi::FMOD_MODE,
4848 pub channelmask: ffi::FMOD_CHANNELMASK,
4849 pub channelorder: ChannelOrder,
4850 pub peakvolume: f32,
4851}
4852impl TryFrom<ffi::FMOD_CODEC_WAVEFORMAT> for CodecWaveformat {
4853 type Error = Error;
4854 fn try_from(value: ffi::FMOD_CODEC_WAVEFORMAT) -> Result<Self, Self::Error> {
4855 unsafe {
4856 Ok(CodecWaveformat {
4857 name: to_string!(value.name)?,
4858 format: SoundFormat::from(value.format)?,
4859 channels: value.channels,
4860 frequency: value.frequency,
4861 lengthbytes: value.lengthbytes,
4862 lengthpcm: value.lengthpcm,
4863 pcmblocksize: value.pcmblocksize,
4864 loopstart: value.loopstart,
4865 loopend: value.loopend,
4866 mode: value.mode,
4867 channelmask: value.channelmask,
4868 channelorder: ChannelOrder::from(value.channelorder)?,
4869 peakvolume: value.peakvolume,
4870 })
4871 }
4872 }
4873}
4874impl Into<ffi::FMOD_CODEC_WAVEFORMAT> for CodecWaveformat {
4875 fn into(self) -> ffi::FMOD_CODEC_WAVEFORMAT {
4876 ffi::FMOD_CODEC_WAVEFORMAT {
4877 name: move_string_to_c!(self.name),
4878 format: self.format.into(),
4879 channels: self.channels,
4880 frequency: self.frequency,
4881 lengthbytes: self.lengthbytes,
4882 lengthpcm: self.lengthpcm,
4883 pcmblocksize: self.pcmblocksize,
4884 loopstart: self.loopstart,
4885 loopend: self.loopend,
4886 mode: self.mode,
4887 channelmask: self.channelmask,
4888 channelorder: self.channelorder.into(),
4889 peakvolume: self.peakvolume,
4890 }
4891 }
4892}
4893#[derive(Debug, Clone)]
4894pub struct CodecStateFunctions {
4895 pub metadata: ffi::FMOD_CODEC_METADATA_FUNC,
4896 pub alloc: ffi::FMOD_CODEC_ALLOC_FUNC,
4897 pub free: ffi::FMOD_CODEC_FREE_FUNC,
4898 pub log: ffi::FMOD_CODEC_LOG_FUNC,
4899 pub read: ffi::FMOD_CODEC_FILE_READ_FUNC,
4900 pub seek: ffi::FMOD_CODEC_FILE_SEEK_FUNC,
4901 pub tell: ffi::FMOD_CODEC_FILE_TELL_FUNC,
4902 pub size: ffi::FMOD_CODEC_FILE_SIZE_FUNC,
4903}
4904impl TryFrom<ffi::FMOD_CODEC_STATE_FUNCTIONS> for CodecStateFunctions {
4905 type Error = Error;
4906 fn try_from(value: ffi::FMOD_CODEC_STATE_FUNCTIONS) -> Result<Self, Self::Error> {
4907 unsafe {
4908 Ok(CodecStateFunctions {
4909 metadata: value.metadata,
4910 alloc: value.alloc,
4911 free: value.free,
4912 log: value.log,
4913 read: value.read,
4914 seek: value.seek,
4915 tell: value.tell,
4916 size: value.size,
4917 })
4918 }
4919 }
4920}
4921impl Into<ffi::FMOD_CODEC_STATE_FUNCTIONS> for CodecStateFunctions {
4922 fn into(self) -> ffi::FMOD_CODEC_STATE_FUNCTIONS {
4923 ffi::FMOD_CODEC_STATE_FUNCTIONS {
4924 metadata: self.metadata,
4925 alloc: self.alloc,
4926 free: self.free,
4927 log: self.log,
4928 read: self.read,
4929 seek: self.seek,
4930 tell: self.tell,
4931 size: self.size,
4932 }
4933 }
4934}
4935#[derive(Debug, Clone)]
4936pub struct CodecState {
4937 pub plugindata: *mut c_void,
4938 pub waveformat: CodecWaveformat,
4939 pub functions: CodecStateFunctions,
4940 pub numsubsounds: i32,
4941}
4942impl TryFrom<ffi::FMOD_CODEC_STATE> for CodecState {
4943 type Error = Error;
4944 fn try_from(value: ffi::FMOD_CODEC_STATE) -> Result<Self, Self::Error> {
4945 unsafe {
4946 Ok(CodecState {
4947 plugindata: value.plugindata,
4948 waveformat: CodecWaveformat::try_from(*value.waveformat)?,
4949 functions: CodecStateFunctions::try_from(*value.functions)?,
4950 numsubsounds: value.numsubsounds,
4951 })
4952 }
4953 }
4954}
4955impl Into<ffi::FMOD_CODEC_STATE> for CodecState {
4956 fn into(self) -> ffi::FMOD_CODEC_STATE {
4957 ffi::FMOD_CODEC_STATE {
4958 plugindata: self.plugindata,
4959 waveformat: &mut self.waveformat.into(),
4960 functions: &mut self.functions.into(),
4961 numsubsounds: self.numsubsounds,
4962 }
4963 }
4964}
4965#[derive(Debug, Clone)]
4966pub struct OutputDescription {
4967 pub apiversion: u32,
4968 pub name: String,
4969 pub version: u32,
4970 pub method: ffi::FMOD_OUTPUT_METHOD,
4971 pub getnumdrivers: ffi::FMOD_OUTPUT_GETNUMDRIVERS_CALLBACK,
4972 pub getdriverinfo: ffi::FMOD_OUTPUT_GETDRIVERINFO_CALLBACK,
4973 pub init: ffi::FMOD_OUTPUT_INIT_CALLBACK,
4974 pub start: ffi::FMOD_OUTPUT_START_CALLBACK,
4975 pub stop: ffi::FMOD_OUTPUT_STOP_CALLBACK,
4976 pub close: ffi::FMOD_OUTPUT_CLOSE_CALLBACK,
4977 pub update: ffi::FMOD_OUTPUT_UPDATE_CALLBACK,
4978 pub gethandle: ffi::FMOD_OUTPUT_GETHANDLE_CALLBACK,
4979 pub mixer: ffi::FMOD_OUTPUT_MIXER_CALLBACK,
4980 pub object_3_dgetinfo: ffi::FMOD_OUTPUT_OBJECT3DGETINFO_CALLBACK,
4981 pub object_3_dalloc: ffi::FMOD_OUTPUT_OBJECT3DALLOC_CALLBACK,
4982 pub object_3_dfree: ffi::FMOD_OUTPUT_OBJECT3DFREE_CALLBACK,
4983 pub object_3_dupdate: ffi::FMOD_OUTPUT_OBJECT3DUPDATE_CALLBACK,
4984 pub openport: ffi::FMOD_OUTPUT_OPENPORT_CALLBACK,
4985 pub closeport: ffi::FMOD_OUTPUT_CLOSEPORT_CALLBACK,
4986 pub devicelistchanged: ffi::FMOD_OUTPUT_DEVICELISTCHANGED_CALLBACK,
4987}
4988impl TryFrom<ffi::FMOD_OUTPUT_DESCRIPTION> for OutputDescription {
4989 type Error = Error;
4990 fn try_from(value: ffi::FMOD_OUTPUT_DESCRIPTION) -> Result<Self, Self::Error> {
4991 unsafe {
4992 Ok(OutputDescription {
4993 apiversion: value.apiversion,
4994 name: to_string!(value.name)?,
4995 version: value.version,
4996 method: value.method,
4997 getnumdrivers: value.getnumdrivers,
4998 getdriverinfo: value.getdriverinfo,
4999 init: value.init,
5000 start: value.start,
5001 stop: value.stop,
5002 close: value.close,
5003 update: value.update,
5004 gethandle: value.gethandle,
5005 mixer: value.mixer,
5006 object_3_dgetinfo: value.object3dgetinfo,
5007 object_3_dalloc: value.object3dalloc,
5008 object_3_dfree: value.object3dfree,
5009 object_3_dupdate: value.object3dupdate,
5010 openport: value.openport,
5011 closeport: value.closeport,
5012 devicelistchanged: value.devicelistchanged,
5013 })
5014 }
5015 }
5016}
5017impl Into<ffi::FMOD_OUTPUT_DESCRIPTION> for OutputDescription {
5018 fn into(self) -> ffi::FMOD_OUTPUT_DESCRIPTION {
5019 ffi::FMOD_OUTPUT_DESCRIPTION {
5020 apiversion: self.apiversion,
5021 name: move_string_to_c!(self.name),
5022 version: self.version,
5023 method: self.method,
5024 getnumdrivers: self.getnumdrivers,
5025 getdriverinfo: self.getdriverinfo,
5026 init: self.init,
5027 start: self.start,
5028 stop: self.stop,
5029 close: self.close,
5030 update: self.update,
5031 gethandle: self.gethandle,
5032 mixer: self.mixer,
5033 object3dgetinfo: self.object_3_dgetinfo,
5034 object3dalloc: self.object_3_dalloc,
5035 object3dfree: self.object_3_dfree,
5036 object3dupdate: self.object_3_dupdate,
5037 openport: self.openport,
5038 closeport: self.closeport,
5039 devicelistchanged: self.devicelistchanged,
5040 }
5041 }
5042}
5043#[derive(Debug, Clone)]
5044pub struct OutputState {
5045 pub plugindata: *mut c_void,
5046 pub readfrommixer: ffi::FMOD_OUTPUT_READFROMMIXER_FUNC,
5047 pub alloc: ffi::FMOD_OUTPUT_ALLOC_FUNC,
5048 pub free: ffi::FMOD_OUTPUT_FREE_FUNC,
5049 pub log: ffi::FMOD_OUTPUT_LOG_FUNC,
5050 pub copyport: ffi::FMOD_OUTPUT_COPYPORT_FUNC,
5051 pub requestreset: ffi::FMOD_OUTPUT_REQUESTRESET_FUNC,
5052}
5053impl TryFrom<ffi::FMOD_OUTPUT_STATE> for OutputState {
5054 type Error = Error;
5055 fn try_from(value: ffi::FMOD_OUTPUT_STATE) -> Result<Self, Self::Error> {
5056 unsafe {
5057 Ok(OutputState {
5058 plugindata: value.plugindata,
5059 readfrommixer: value.readfrommixer,
5060 alloc: value.alloc,
5061 free: value.free,
5062 log: value.log,
5063 copyport: value.copyport,
5064 requestreset: value.requestreset,
5065 })
5066 }
5067 }
5068}
5069impl Into<ffi::FMOD_OUTPUT_STATE> for OutputState {
5070 fn into(self) -> ffi::FMOD_OUTPUT_STATE {
5071 ffi::FMOD_OUTPUT_STATE {
5072 plugindata: self.plugindata,
5073 readfrommixer: self.readfrommixer,
5074 alloc: self.alloc,
5075 free: self.free,
5076 log: self.log,
5077 copyport: self.copyport,
5078 requestreset: self.requestreset,
5079 }
5080 }
5081}
5082#[derive(Debug, Clone)]
5083pub struct OutputObject3Dinfo {
5084 pub buffer: Vec<f32>,
5085 pub bufferlength: u32,
5086 pub position: Vector,
5087 pub gain: f32,
5088 pub spread: f32,
5089 pub priority: f32,
5090}
5091impl TryFrom<ffi::FMOD_OUTPUT_OBJECT3DINFO> for OutputObject3Dinfo {
5092 type Error = Error;
5093 fn try_from(value: ffi::FMOD_OUTPUT_OBJECT3DINFO) -> Result<Self, Self::Error> {
5094 unsafe {
5095 Ok(OutputObject3Dinfo {
5096 buffer: to_vec!(value.buffer, value.bufferlength),
5097 bufferlength: value.bufferlength,
5098 position: Vector::try_from(value.position)?,
5099 gain: value.gain,
5100 spread: value.spread,
5101 priority: value.priority,
5102 })
5103 }
5104 }
5105}
5106impl Into<ffi::FMOD_OUTPUT_OBJECT3DINFO> for OutputObject3Dinfo {
5107 fn into(self) -> ffi::FMOD_OUTPUT_OBJECT3DINFO {
5108 ffi::FMOD_OUTPUT_OBJECT3DINFO {
5109 buffer: self.buffer.as_ptr() as *mut _,
5110 bufferlength: self.bufferlength,
5111 position: self.position.into(),
5112 gain: self.gain,
5113 spread: self.spread,
5114 priority: self.priority,
5115 }
5116 }
5117}
5118#[derive(Debug, Clone)]
5119pub struct DspBufferArray {
5120 pub numbuffers: i32,
5121 pub buffernumchannels: Vec<i32>,
5122 pub bufferchannelmask: Vec<ffi::FMOD_CHANNELMASK>,
5123 pub buffers: Vec<f32>,
5124 pub speakermode: SpeakerMode,
5125}
5126impl TryFrom<ffi::FMOD_DSP_BUFFER_ARRAY> for DspBufferArray {
5127 type Error = Error;
5128 fn try_from(value: ffi::FMOD_DSP_BUFFER_ARRAY) -> Result<Self, Self::Error> {
5129 unsafe {
5130 Ok(DspBufferArray {
5131 numbuffers: value.numbuffers,
5132 buffernumchannels: to_vec!(value.buffernumchannels, value.numbuffers),
5133 bufferchannelmask: to_vec!(value.bufferchannelmask, value.numbuffers),
5134 buffers: to_vec!(value.buffers, value.numbuffers, |ptr| Ok(*ptr))?,
5135 speakermode: SpeakerMode::from(value.speakermode)?,
5136 })
5137 }
5138 }
5139}
5140impl Into<ffi::FMOD_DSP_BUFFER_ARRAY> for DspBufferArray {
5141 fn into(self) -> ffi::FMOD_DSP_BUFFER_ARRAY {
5142 ffi::FMOD_DSP_BUFFER_ARRAY {
5143 numbuffers: self.numbuffers,
5144 buffernumchannels: self.buffernumchannels.as_ptr() as *mut _,
5145 bufferchannelmask: self.bufferchannelmask.as_ptr() as *mut _,
5146 buffers: self.buffers.as_ptr() as *mut _,
5147 speakermode: self.speakermode.into(),
5148 }
5149 }
5150}
5151#[derive(Debug, Clone)]
5152pub struct Complex {
5153 pub real: f32,
5154 pub imag: f32,
5155}
5156impl TryFrom<ffi::FMOD_COMPLEX> for Complex {
5157 type Error = Error;
5158 fn try_from(value: ffi::FMOD_COMPLEX) -> Result<Self, Self::Error> {
5159 unsafe {
5160 Ok(Complex {
5161 real: value.real,
5162 imag: value.imag,
5163 })
5164 }
5165 }
5166}
5167impl Into<ffi::FMOD_COMPLEX> for Complex {
5168 fn into(self) -> ffi::FMOD_COMPLEX {
5169 ffi::FMOD_COMPLEX {
5170 real: self.real,
5171 imag: self.imag,
5172 }
5173 }
5174}
5175#[derive(Debug, Clone)]
5176pub struct DspParameterFloatMappingPiecewiseLinear {
5177 pub numpoints: i32,
5178 pub pointparamvalues: Vec<f32>,
5179 pub pointpositions: Vec<f32>,
5180}
5181impl TryFrom<ffi::FMOD_DSP_PARAMETER_FLOAT_MAPPING_PIECEWISE_LINEAR>
5182 for DspParameterFloatMappingPiecewiseLinear
5183{
5184 type Error = Error;
5185 fn try_from(
5186 value: ffi::FMOD_DSP_PARAMETER_FLOAT_MAPPING_PIECEWISE_LINEAR,
5187 ) -> Result<Self, Self::Error> {
5188 unsafe {
5189 Ok(DspParameterFloatMappingPiecewiseLinear {
5190 numpoints: value.numpoints,
5191 pointparamvalues: to_vec!(value.pointparamvalues, value.numpoints),
5192 pointpositions: to_vec!(value.pointpositions, value.numpoints),
5193 })
5194 }
5195 }
5196}
5197impl Into<ffi::FMOD_DSP_PARAMETER_FLOAT_MAPPING_PIECEWISE_LINEAR>
5198 for DspParameterFloatMappingPiecewiseLinear
5199{
5200 fn into(self) -> ffi::FMOD_DSP_PARAMETER_FLOAT_MAPPING_PIECEWISE_LINEAR {
5201 ffi::FMOD_DSP_PARAMETER_FLOAT_MAPPING_PIECEWISE_LINEAR {
5202 numpoints: self.numpoints,
5203 pointparamvalues: self.pointparamvalues.as_ptr() as *mut _,
5204 pointpositions: self.pointpositions.as_ptr() as *mut _,
5205 }
5206 }
5207}
5208#[derive(Debug, Clone)]
5209pub struct DspParameterFloatMapping {
5210 pub type_: DspParameterFloatMappingType,
5211 pub piecewiselinearmapping: DspParameterFloatMappingPiecewiseLinear,
5212}
5213impl TryFrom<ffi::FMOD_DSP_PARAMETER_FLOAT_MAPPING> for DspParameterFloatMapping {
5214 type Error = Error;
5215 fn try_from(value: ffi::FMOD_DSP_PARAMETER_FLOAT_MAPPING) -> Result<Self, Self::Error> {
5216 unsafe {
5217 Ok(DspParameterFloatMapping {
5218 type_: DspParameterFloatMappingType::from(value.type_)?,
5219 piecewiselinearmapping: DspParameterFloatMappingPiecewiseLinear::try_from(
5220 value.piecewiselinearmapping,
5221 )?,
5222 })
5223 }
5224 }
5225}
5226impl Into<ffi::FMOD_DSP_PARAMETER_FLOAT_MAPPING> for DspParameterFloatMapping {
5227 fn into(self) -> ffi::FMOD_DSP_PARAMETER_FLOAT_MAPPING {
5228 ffi::FMOD_DSP_PARAMETER_FLOAT_MAPPING {
5229 type_: self.type_.into(),
5230 piecewiselinearmapping: self.piecewiselinearmapping.into(),
5231 }
5232 }
5233}
5234#[derive(Debug, Clone)]
5235pub struct DspParameterDescFloat {
5236 pub min: f32,
5237 pub max: f32,
5238 pub defaultval: f32,
5239 pub mapping: DspParameterFloatMapping,
5240}
5241impl TryFrom<ffi::FMOD_DSP_PARAMETER_DESC_FLOAT> for DspParameterDescFloat {
5242 type Error = Error;
5243 fn try_from(value: ffi::FMOD_DSP_PARAMETER_DESC_FLOAT) -> Result<Self, Self::Error> {
5244 unsafe {
5245 Ok(DspParameterDescFloat {
5246 min: value.min,
5247 max: value.max,
5248 defaultval: value.defaultval,
5249 mapping: DspParameterFloatMapping::try_from(value.mapping)?,
5250 })
5251 }
5252 }
5253}
5254impl Into<ffi::FMOD_DSP_PARAMETER_DESC_FLOAT> for DspParameterDescFloat {
5255 fn into(self) -> ffi::FMOD_DSP_PARAMETER_DESC_FLOAT {
5256 ffi::FMOD_DSP_PARAMETER_DESC_FLOAT {
5257 min: self.min,
5258 max: self.max,
5259 defaultval: self.defaultval,
5260 mapping: self.mapping.into(),
5261 }
5262 }
5263}
5264#[derive(Debug, Clone)]
5265pub struct DspParameterDescInt {
5266 pub min: i32,
5267 pub max: i32,
5268 pub defaultval: i32,
5269 pub goestoinf: ffi::FMOD_BOOL,
5270 pub valuenames: Vec<String>,
5271}
5272impl TryFrom<ffi::FMOD_DSP_PARAMETER_DESC_INT> for DspParameterDescInt {
5273 type Error = Error;
5274 fn try_from(value: ffi::FMOD_DSP_PARAMETER_DESC_INT) -> Result<Self, Self::Error> {
5275 unsafe {
5276 Ok(DspParameterDescInt {
5277 min: value.min,
5278 max: value.max,
5279 defaultval: value.defaultval,
5280 goestoinf: value.goestoinf,
5281 valuenames: vec![],
5282 })
5283 }
5284 }
5285}
5286impl Into<ffi::FMOD_DSP_PARAMETER_DESC_INT> for DspParameterDescInt {
5287 fn into(self) -> ffi::FMOD_DSP_PARAMETER_DESC_INT {
5288 ffi::FMOD_DSP_PARAMETER_DESC_INT {
5289 min: self.min,
5290 max: self.max,
5291 defaultval: self.defaultval,
5292 goestoinf: self.goestoinf,
5293 valuenames: self.valuenames.as_ptr() as *mut _,
5294 }
5295 }
5296}
5297#[derive(Debug, Clone)]
5298pub struct DspParameterDescBool {
5299 pub defaultval: ffi::FMOD_BOOL,
5300 pub valuenames: Vec<String>,
5301}
5302impl TryFrom<ffi::FMOD_DSP_PARAMETER_DESC_BOOL> for DspParameterDescBool {
5303 type Error = Error;
5304 fn try_from(value: ffi::FMOD_DSP_PARAMETER_DESC_BOOL) -> Result<Self, Self::Error> {
5305 unsafe {
5306 Ok(DspParameterDescBool {
5307 defaultval: value.defaultval,
5308 valuenames: vec![],
5309 })
5310 }
5311 }
5312}
5313impl Into<ffi::FMOD_DSP_PARAMETER_DESC_BOOL> for DspParameterDescBool {
5314 fn into(self) -> ffi::FMOD_DSP_PARAMETER_DESC_BOOL {
5315 ffi::FMOD_DSP_PARAMETER_DESC_BOOL {
5316 defaultval: self.defaultval,
5317 valuenames: self.valuenames.as_ptr() as *mut _,
5318 }
5319 }
5320}
5321#[derive(Debug, Clone)]
5322pub struct DspParameterDescData {
5323 pub datatype: i32,
5324}
5325impl TryFrom<ffi::FMOD_DSP_PARAMETER_DESC_DATA> for DspParameterDescData {
5326 type Error = Error;
5327 fn try_from(value: ffi::FMOD_DSP_PARAMETER_DESC_DATA) -> Result<Self, Self::Error> {
5328 unsafe {
5329 Ok(DspParameterDescData {
5330 datatype: value.datatype,
5331 })
5332 }
5333 }
5334}
5335impl Into<ffi::FMOD_DSP_PARAMETER_DESC_DATA> for DspParameterDescData {
5336 fn into(self) -> ffi::FMOD_DSP_PARAMETER_DESC_DATA {
5337 ffi::FMOD_DSP_PARAMETER_DESC_DATA {
5338 datatype: self.datatype,
5339 }
5340 }
5341}
5342#[derive(Clone)]
5343pub struct DspParameterDesc {
5344 pub type_: DspParameterType,
5345 pub name: [c_char; 16 as usize],
5346 pub label: [c_char; 16 as usize],
5347 pub description: String,
5348 pub union: ffi::FMOD_DSP_PARAMETER_DESC_UNION,
5349}
5350impl TryFrom<ffi::FMOD_DSP_PARAMETER_DESC> for DspParameterDesc {
5351 type Error = Error;
5352 fn try_from(value: ffi::FMOD_DSP_PARAMETER_DESC) -> Result<Self, Self::Error> {
5353 unsafe {
5354 Ok(DspParameterDesc {
5355 type_: DspParameterType::from(value.type_)?,
5356 name: value.name,
5357 label: value.label,
5358 description: to_string!(value.description)?,
5359 union: value.union,
5360 })
5361 }
5362 }
5363}
5364impl Into<ffi::FMOD_DSP_PARAMETER_DESC> for DspParameterDesc {
5365 fn into(self) -> ffi::FMOD_DSP_PARAMETER_DESC {
5366 ffi::FMOD_DSP_PARAMETER_DESC {
5367 type_: self.type_.into(),
5368 name: self.name,
5369 label: self.label,
5370 description: move_string_to_c!(self.description),
5371 union: self.union,
5372 }
5373 }
5374}
5375#[derive(Debug, Clone)]
5376pub struct DspParameterOverallgain {
5377 pub linear_gain: f32,
5378 pub linear_gain_additive: f32,
5379}
5380impl TryFrom<ffi::FMOD_DSP_PARAMETER_OVERALLGAIN> for DspParameterOverallgain {
5381 type Error = Error;
5382 fn try_from(value: ffi::FMOD_DSP_PARAMETER_OVERALLGAIN) -> Result<Self, Self::Error> {
5383 unsafe {
5384 Ok(DspParameterOverallgain {
5385 linear_gain: value.linear_gain,
5386 linear_gain_additive: value.linear_gain_additive,
5387 })
5388 }
5389 }
5390}
5391impl Into<ffi::FMOD_DSP_PARAMETER_OVERALLGAIN> for DspParameterOverallgain {
5392 fn into(self) -> ffi::FMOD_DSP_PARAMETER_OVERALLGAIN {
5393 ffi::FMOD_DSP_PARAMETER_OVERALLGAIN {
5394 linear_gain: self.linear_gain,
5395 linear_gain_additive: self.linear_gain_additive,
5396 }
5397 }
5398}
5399#[derive(Debug, Clone)]
5400pub struct DspParameterAttributes3d {
5401 pub relative: Attributes3d,
5402 pub absolute: Attributes3d,
5403}
5404impl TryFrom<ffi::FMOD_DSP_PARAMETER_3DATTRIBUTES> for DspParameterAttributes3d {
5405 type Error = Error;
5406 fn try_from(value: ffi::FMOD_DSP_PARAMETER_3DATTRIBUTES) -> Result<Self, Self::Error> {
5407 unsafe {
5408 Ok(DspParameterAttributes3d {
5409 relative: Attributes3d::try_from(value.relative)?,
5410 absolute: Attributes3d::try_from(value.absolute)?,
5411 })
5412 }
5413 }
5414}
5415impl Into<ffi::FMOD_DSP_PARAMETER_3DATTRIBUTES> for DspParameterAttributes3d {
5416 fn into(self) -> ffi::FMOD_DSP_PARAMETER_3DATTRIBUTES {
5417 ffi::FMOD_DSP_PARAMETER_3DATTRIBUTES {
5418 relative: self.relative.into(),
5419 absolute: self.absolute.into(),
5420 }
5421 }
5422}
5423#[derive(Debug, Clone)]
5424pub struct DspParameterAttributes3dMulti {
5425 pub numlisteners: i32,
5426 pub relative: [Attributes3d; ffi::FMOD_MAX_LISTENERS as usize],
5427 pub weight: [f32; ffi::FMOD_MAX_LISTENERS as usize],
5428 pub absolute: Attributes3d,
5429}
5430impl TryFrom<ffi::FMOD_DSP_PARAMETER_3DATTRIBUTES_MULTI> for DspParameterAttributes3dMulti {
5431 type Error = Error;
5432 fn try_from(value: ffi::FMOD_DSP_PARAMETER_3DATTRIBUTES_MULTI) -> Result<Self, Self::Error> {
5433 unsafe {
5434 Ok(DspParameterAttributes3dMulti {
5435 numlisteners: value.numlisteners,
5436 relative: attr3d_array8(
5437 value
5438 .relative
5439 .map(Attributes3d::try_from)
5440 .into_iter()
5441 .collect::<Result<Vec<Attributes3d>, Error>>()?,
5442 ),
5443 weight: value.weight,
5444 absolute: Attributes3d::try_from(value.absolute)?,
5445 })
5446 }
5447 }
5448}
5449impl Into<ffi::FMOD_DSP_PARAMETER_3DATTRIBUTES_MULTI> for DspParameterAttributes3dMulti {
5450 fn into(self) -> ffi::FMOD_DSP_PARAMETER_3DATTRIBUTES_MULTI {
5451 ffi::FMOD_DSP_PARAMETER_3DATTRIBUTES_MULTI {
5452 numlisteners: self.numlisteners,
5453 relative: self.relative.map(Attributes3d::into),
5454 weight: self.weight,
5455 absolute: self.absolute.into(),
5456 }
5457 }
5458}
5459#[derive(Debug, Clone)]
5460pub struct DspParameterAttenuationRange {
5461 pub min: f32,
5462 pub max: f32,
5463}
5464impl TryFrom<ffi::FMOD_DSP_PARAMETER_ATTENUATION_RANGE> for DspParameterAttenuationRange {
5465 type Error = Error;
5466 fn try_from(value: ffi::FMOD_DSP_PARAMETER_ATTENUATION_RANGE) -> Result<Self, Self::Error> {
5467 unsafe {
5468 Ok(DspParameterAttenuationRange {
5469 min: value.min,
5470 max: value.max,
5471 })
5472 }
5473 }
5474}
5475impl Into<ffi::FMOD_DSP_PARAMETER_ATTENUATION_RANGE> for DspParameterAttenuationRange {
5476 fn into(self) -> ffi::FMOD_DSP_PARAMETER_ATTENUATION_RANGE {
5477 ffi::FMOD_DSP_PARAMETER_ATTENUATION_RANGE {
5478 min: self.min,
5479 max: self.max,
5480 }
5481 }
5482}
5483#[derive(Debug, Clone)]
5484pub struct DspParameterSidechain {
5485 pub sidechainenable: ffi::FMOD_BOOL,
5486}
5487impl TryFrom<ffi::FMOD_DSP_PARAMETER_SIDECHAIN> for DspParameterSidechain {
5488 type Error = Error;
5489 fn try_from(value: ffi::FMOD_DSP_PARAMETER_SIDECHAIN) -> Result<Self, Self::Error> {
5490 unsafe {
5491 Ok(DspParameterSidechain {
5492 sidechainenable: value.sidechainenable,
5493 })
5494 }
5495 }
5496}
5497impl Into<ffi::FMOD_DSP_PARAMETER_SIDECHAIN> for DspParameterSidechain {
5498 fn into(self) -> ffi::FMOD_DSP_PARAMETER_SIDECHAIN {
5499 ffi::FMOD_DSP_PARAMETER_SIDECHAIN {
5500 sidechainenable: self.sidechainenable,
5501 }
5502 }
5503}
5504#[derive(Debug, Clone)]
5505pub struct DspParameterFft {
5506 pub length: i32,
5507 pub spectrum: Vec<Vec<f32>>,
5508}
5509impl TryFrom<ffi::FMOD_DSP_PARAMETER_FFT> for DspParameterFft {
5510 type Error = Error;
5511 fn try_from(value: ffi::FMOD_DSP_PARAMETER_FFT) -> Result<Self, Self::Error> {
5512 unsafe {
5513 Ok(DspParameterFft {
5514 length: value.length,
5515 spectrum: to_vec!(value.spectrum.as_ptr(), value.numchannels, |ptr| Ok(
5516 to_vec!(ptr, value.length)
5517 ))?,
5518 })
5519 }
5520 }
5521}
5522impl TryFrom<Dsp> for DspParameterFft {
5523 type Error = Error;
5524 fn try_from(dsp: Dsp) -> Result<Self, Self::Error> {
5525 match dsp.get_type() {
5526 Ok(DspType::Fft) => {
5527 let (ptr, _, _) = dsp.get_parameter_data(ffi::FMOD_DSP_FFT_SPECTRUMDATA, 0)?;
5528 let fft = unsafe { *(ptr as *const ffi::FMOD_DSP_PARAMETER_FFT) };
5529 DspParameterFft::try_from(fft)
5530 }
5531 _ => Err(Error::NotDspFft),
5532 }
5533 }
5534}
5535impl Into<ffi::FMOD_DSP_PARAMETER_FFT> for DspParameterFft {
5536 fn into(self) -> ffi::FMOD_DSP_PARAMETER_FFT {
5537 ffi::FMOD_DSP_PARAMETER_FFT {
5538 length: self.length,
5539 numchannels: self.spectrum.len() as i32,
5540 spectrum: [null_mut(); 32],
5541 }
5542 }
5543}
5544#[derive(Clone)]
5545pub struct DspDescription {
5546 pub pluginsdkversion: u32,
5547 pub name: [c_char; 32 as usize],
5548 pub version: u32,
5549 pub numinputbuffers: i32,
5550 pub numoutputbuffers: i32,
5551 pub create: ffi::FMOD_DSP_CREATE_CALLBACK,
5552 pub release: ffi::FMOD_DSP_RELEASE_CALLBACK,
5553 pub reset: ffi::FMOD_DSP_RESET_CALLBACK,
5554 pub read: ffi::FMOD_DSP_READ_CALLBACK,
5555 pub process: ffi::FMOD_DSP_PROCESS_CALLBACK,
5556 pub setposition: ffi::FMOD_DSP_SETPOSITION_CALLBACK,
5557 pub paramdesc: Vec<DspParameterDesc>,
5558 pub setparameterfloat: ffi::FMOD_DSP_SETPARAM_FLOAT_CALLBACK,
5559 pub setparameterint: ffi::FMOD_DSP_SETPARAM_INT_CALLBACK,
5560 pub setparameterbool: ffi::FMOD_DSP_SETPARAM_BOOL_CALLBACK,
5561 pub setparameterdata: ffi::FMOD_DSP_SETPARAM_DATA_CALLBACK,
5562 pub getparameterfloat: ffi::FMOD_DSP_GETPARAM_FLOAT_CALLBACK,
5563 pub getparameterint: ffi::FMOD_DSP_GETPARAM_INT_CALLBACK,
5564 pub getparameterbool: ffi::FMOD_DSP_GETPARAM_BOOL_CALLBACK,
5565 pub getparameterdata: ffi::FMOD_DSP_GETPARAM_DATA_CALLBACK,
5566 pub shouldiprocess: ffi::FMOD_DSP_SHOULDIPROCESS_CALLBACK,
5567 pub userdata: *mut c_void,
5568 pub sys_register: ffi::FMOD_DSP_SYSTEM_REGISTER_CALLBACK,
5569 pub sys_deregister: ffi::FMOD_DSP_SYSTEM_DEREGISTER_CALLBACK,
5570 pub sys_mix: ffi::FMOD_DSP_SYSTEM_MIX_CALLBACK,
5571}
5572impl TryFrom<ffi::FMOD_DSP_DESCRIPTION> for DspDescription {
5573 type Error = Error;
5574 fn try_from(value: ffi::FMOD_DSP_DESCRIPTION) -> Result<Self, Self::Error> {
5575 unsafe {
5576 Ok(DspDescription {
5577 pluginsdkversion: value.pluginsdkversion,
5578 name: value.name,
5579 version: value.version,
5580 numinputbuffers: value.numinputbuffers,
5581 numoutputbuffers: value.numoutputbuffers,
5582 create: value.create,
5583 release: value.release,
5584 reset: value.reset,
5585 read: value.read,
5586 process: value.process,
5587 setposition: value.setposition,
5588 paramdesc: to_vec!(
5589 *value.paramdesc,
5590 value.numparameters,
5591 DspParameterDesc::try_from
5592 )?,
5593 setparameterfloat: value.setparameterfloat,
5594 setparameterint: value.setparameterint,
5595 setparameterbool: value.setparameterbool,
5596 setparameterdata: value.setparameterdata,
5597 getparameterfloat: value.getparameterfloat,
5598 getparameterint: value.getparameterint,
5599 getparameterbool: value.getparameterbool,
5600 getparameterdata: value.getparameterdata,
5601 shouldiprocess: value.shouldiprocess,
5602 userdata: value.userdata,
5603 sys_register: value.sys_register,
5604 sys_deregister: value.sys_deregister,
5605 sys_mix: value.sys_mix,
5606 })
5607 }
5608 }
5609}
5610impl Into<ffi::FMOD_DSP_DESCRIPTION> for DspDescription {
5611 fn into(self) -> ffi::FMOD_DSP_DESCRIPTION {
5612 ffi::FMOD_DSP_DESCRIPTION {
5613 pluginsdkversion: self.pluginsdkversion,
5614 name: self.name,
5615 version: self.version,
5616 numinputbuffers: self.numinputbuffers,
5617 numoutputbuffers: self.numoutputbuffers,
5618 create: self.create,
5619 release: self.release,
5620 reset: self.reset,
5621 read: self.read,
5622 process: self.process,
5623 setposition: self.setposition,
5624 numparameters: self.paramdesc.len() as i32,
5625 paramdesc: vec_as_mut_ptr(self.paramdesc, |param| {
5626 Box::into_raw(Box::new(param.into()))
5627 }),
5628 setparameterfloat: self.setparameterfloat,
5629 setparameterint: self.setparameterint,
5630 setparameterbool: self.setparameterbool,
5631 setparameterdata: self.setparameterdata,
5632 getparameterfloat: self.getparameterfloat,
5633 getparameterint: self.getparameterint,
5634 getparameterbool: self.getparameterbool,
5635 getparameterdata: self.getparameterdata,
5636 shouldiprocess: self.shouldiprocess,
5637 userdata: self.userdata,
5638 sys_register: self.sys_register,
5639 sys_deregister: self.sys_deregister,
5640 sys_mix: self.sys_mix,
5641 }
5642 }
5643}
5644#[derive(Debug, Clone)]
5645pub struct DspStateDftFunctions {
5646 pub fftreal: ffi::FMOD_DSP_DFT_FFTREAL_FUNC,
5647 pub inversefftreal: ffi::FMOD_DSP_DFT_IFFTREAL_FUNC,
5648}
5649impl TryFrom<ffi::FMOD_DSP_STATE_DFT_FUNCTIONS> for DspStateDftFunctions {
5650 type Error = Error;
5651 fn try_from(value: ffi::FMOD_DSP_STATE_DFT_FUNCTIONS) -> Result<Self, Self::Error> {
5652 unsafe {
5653 Ok(DspStateDftFunctions {
5654 fftreal: value.fftreal,
5655 inversefftreal: value.inversefftreal,
5656 })
5657 }
5658 }
5659}
5660impl Into<ffi::FMOD_DSP_STATE_DFT_FUNCTIONS> for DspStateDftFunctions {
5661 fn into(self) -> ffi::FMOD_DSP_STATE_DFT_FUNCTIONS {
5662 ffi::FMOD_DSP_STATE_DFT_FUNCTIONS {
5663 fftreal: self.fftreal,
5664 inversefftreal: self.inversefftreal,
5665 }
5666 }
5667}
5668#[derive(Debug, Clone)]
5669pub struct DspStatePanFunctions {
5670 pub summonomatrix: ffi::FMOD_DSP_PAN_SUMMONOMATRIX_FUNC,
5671 pub sumstereomatrix: ffi::FMOD_DSP_PAN_SUMSTEREOMATRIX_FUNC,
5672 pub sumsurroundmatrix: ffi::FMOD_DSP_PAN_SUMSURROUNDMATRIX_FUNC,
5673 pub summonotosurroundmatrix: ffi::FMOD_DSP_PAN_SUMMONOTOSURROUNDMATRIX_FUNC,
5674 pub sumstereotosurroundmatrix: ffi::FMOD_DSP_PAN_SUMSTEREOTOSURROUNDMATRIX_FUNC,
5675 pub getrolloffgain: ffi::FMOD_DSP_PAN_GETROLLOFFGAIN_FUNC,
5676}
5677impl TryFrom<ffi::FMOD_DSP_STATE_PAN_FUNCTIONS> for DspStatePanFunctions {
5678 type Error = Error;
5679 fn try_from(value: ffi::FMOD_DSP_STATE_PAN_FUNCTIONS) -> Result<Self, Self::Error> {
5680 unsafe {
5681 Ok(DspStatePanFunctions {
5682 summonomatrix: value.summonomatrix,
5683 sumstereomatrix: value.sumstereomatrix,
5684 sumsurroundmatrix: value.sumsurroundmatrix,
5685 summonotosurroundmatrix: value.summonotosurroundmatrix,
5686 sumstereotosurroundmatrix: value.sumstereotosurroundmatrix,
5687 getrolloffgain: value.getrolloffgain,
5688 })
5689 }
5690 }
5691}
5692impl Into<ffi::FMOD_DSP_STATE_PAN_FUNCTIONS> for DspStatePanFunctions {
5693 fn into(self) -> ffi::FMOD_DSP_STATE_PAN_FUNCTIONS {
5694 ffi::FMOD_DSP_STATE_PAN_FUNCTIONS {
5695 summonomatrix: self.summonomatrix,
5696 sumstereomatrix: self.sumstereomatrix,
5697 sumsurroundmatrix: self.sumsurroundmatrix,
5698 summonotosurroundmatrix: self.summonotosurroundmatrix,
5699 sumstereotosurroundmatrix: self.sumstereotosurroundmatrix,
5700 getrolloffgain: self.getrolloffgain,
5701 }
5702 }
5703}
5704#[derive(Debug, Clone)]
5705pub struct DspStateFunctions {
5706 pub alloc: ffi::FMOD_DSP_ALLOC_FUNC,
5707 pub realloc: ffi::FMOD_DSP_REALLOC_FUNC,
5708 pub free: ffi::FMOD_DSP_FREE_FUNC,
5709 pub getsamplerate: ffi::FMOD_DSP_GETSAMPLERATE_FUNC,
5710 pub getblocksize: ffi::FMOD_DSP_GETBLOCKSIZE_FUNC,
5711 pub dft: DspStateDftFunctions,
5712 pub pan: DspStatePanFunctions,
5713 pub getspeakermode: ffi::FMOD_DSP_GETSPEAKERMODE_FUNC,
5714 pub getclock: ffi::FMOD_DSP_GETCLOCK_FUNC,
5715 pub getlistenerattributes: ffi::FMOD_DSP_GETLISTENERATTRIBUTES_FUNC,
5716 pub log: ffi::FMOD_DSP_LOG_FUNC,
5717 pub getuserdata: ffi::FMOD_DSP_GETUSERDATA_FUNC,
5718}
5719impl TryFrom<ffi::FMOD_DSP_STATE_FUNCTIONS> for DspStateFunctions {
5720 type Error = Error;
5721 fn try_from(value: ffi::FMOD_DSP_STATE_FUNCTIONS) -> Result<Self, Self::Error> {
5722 unsafe {
5723 Ok(DspStateFunctions {
5724 alloc: value.alloc,
5725 realloc: value.realloc,
5726 free: value.free,
5727 getsamplerate: value.getsamplerate,
5728 getblocksize: value.getblocksize,
5729 dft: DspStateDftFunctions::try_from(*value.dft)?,
5730 pan: DspStatePanFunctions::try_from(*value.pan)?,
5731 getspeakermode: value.getspeakermode,
5732 getclock: value.getclock,
5733 getlistenerattributes: value.getlistenerattributes,
5734 log: value.log,
5735 getuserdata: value.getuserdata,
5736 })
5737 }
5738 }
5739}
5740impl Into<ffi::FMOD_DSP_STATE_FUNCTIONS> for DspStateFunctions {
5741 fn into(self) -> ffi::FMOD_DSP_STATE_FUNCTIONS {
5742 ffi::FMOD_DSP_STATE_FUNCTIONS {
5743 alloc: self.alloc,
5744 realloc: self.realloc,
5745 free: self.free,
5746 getsamplerate: self.getsamplerate,
5747 getblocksize: self.getblocksize,
5748 dft: &mut self.dft.into(),
5749 pan: &mut self.pan.into(),
5750 getspeakermode: self.getspeakermode,
5751 getclock: self.getclock,
5752 getlistenerattributes: self.getlistenerattributes,
5753 log: self.log,
5754 getuserdata: self.getuserdata,
5755 }
5756 }
5757}
5758#[derive(Debug, Clone)]
5759pub struct DspState {
5760 pub instance: *mut c_void,
5761 pub plugindata: *mut c_void,
5762 pub channelmask: ffi::FMOD_CHANNELMASK,
5763 pub source_speakermode: SpeakerMode,
5764 pub sidechaindata: Vec<f32>,
5765 pub sidechainchannels: i32,
5766 pub functions: DspStateFunctions,
5767 pub systemobject: i32,
5768}
5769impl TryFrom<ffi::FMOD_DSP_STATE> for DspState {
5770 type Error = Error;
5771 fn try_from(value: ffi::FMOD_DSP_STATE) -> Result<Self, Self::Error> {
5772 unsafe {
5773 Ok(DspState {
5774 instance: value.instance,
5775 plugindata: value.plugindata,
5776 channelmask: value.channelmask,
5777 source_speakermode: SpeakerMode::from(value.source_speakermode)?,
5778 sidechaindata: to_vec!(value.sidechaindata, value.sidechainchannels),
5779 sidechainchannels: value.sidechainchannels,
5780 functions: DspStateFunctions::try_from(*value.functions)?,
5781 systemobject: value.systemobject,
5782 })
5783 }
5784 }
5785}
5786impl Into<ffi::FMOD_DSP_STATE> for DspState {
5787 fn into(self) -> ffi::FMOD_DSP_STATE {
5788 ffi::FMOD_DSP_STATE {
5789 instance: self.instance,
5790 plugindata: self.plugindata,
5791 channelmask: self.channelmask,
5792 source_speakermode: self.source_speakermode.into(),
5793 sidechaindata: self.sidechaindata.as_ptr() as *mut _,
5794 sidechainchannels: self.sidechainchannels,
5795 functions: &mut self.functions.into(),
5796 systemobject: self.systemobject,
5797 }
5798 }
5799}
5800#[derive(Debug, Clone)]
5801pub struct DspMeteringInfo {
5802 pub numsamples: i32,
5803 pub peaklevel: [f32; 32 as usize],
5804 pub rmslevel: [f32; 32 as usize],
5805 pub numchannels: i16,
5806}
5807impl TryFrom<ffi::FMOD_DSP_METERING_INFO> for DspMeteringInfo {
5808 type Error = Error;
5809 fn try_from(value: ffi::FMOD_DSP_METERING_INFO) -> Result<Self, Self::Error> {
5810 unsafe {
5811 Ok(DspMeteringInfo {
5812 numsamples: value.numsamples,
5813 peaklevel: value.peaklevel,
5814 rmslevel: value.rmslevel,
5815 numchannels: value.numchannels,
5816 })
5817 }
5818 }
5819}
5820impl Into<ffi::FMOD_DSP_METERING_INFO> for DspMeteringInfo {
5821 fn into(self) -> ffi::FMOD_DSP_METERING_INFO {
5822 ffi::FMOD_DSP_METERING_INFO {
5823 numsamples: self.numsamples,
5824 peaklevel: self.peaklevel,
5825 rmslevel: self.rmslevel,
5826 numchannels: self.numchannels,
5827 }
5828 }
5829}
5830#[derive(Debug, Clone)]
5831pub struct DspLoudnessMeterInfoType {
5832 pub momentaryloudness: f32,
5833 pub shorttermloudness: f32,
5834 pub integratedloudness: f32,
5835 pub loudness_10_thpercentile: f32,
5836 pub loudness_95_thpercentile: f32,
5837 pub loudnesshistogram: [f32; ffi::FMOD_DSP_LOUDNESS_METER_HISTOGRAM_SAMPLES as usize],
5838 pub maxtruepeak: f32,
5839 pub maxmomentaryloudness: f32,
5840}
5841impl TryFrom<ffi::FMOD_DSP_LOUDNESS_METER_INFO_TYPE> for DspLoudnessMeterInfoType {
5842 type Error = Error;
5843 fn try_from(value: ffi::FMOD_DSP_LOUDNESS_METER_INFO_TYPE) -> Result<Self, Self::Error> {
5844 unsafe {
5845 Ok(DspLoudnessMeterInfoType {
5846 momentaryloudness: value.momentaryloudness,
5847 shorttermloudness: value.shorttermloudness,
5848 integratedloudness: value.integratedloudness,
5849 loudness_10_thpercentile: value.loudness10thpercentile,
5850 loudness_95_thpercentile: value.loudness95thpercentile,
5851 loudnesshistogram: value.loudnesshistogram,
5852 maxtruepeak: value.maxtruepeak,
5853 maxmomentaryloudness: value.maxmomentaryloudness,
5854 })
5855 }
5856 }
5857}
5858impl Into<ffi::FMOD_DSP_LOUDNESS_METER_INFO_TYPE> for DspLoudnessMeterInfoType {
5859 fn into(self) -> ffi::FMOD_DSP_LOUDNESS_METER_INFO_TYPE {
5860 ffi::FMOD_DSP_LOUDNESS_METER_INFO_TYPE {
5861 momentaryloudness: self.momentaryloudness,
5862 shorttermloudness: self.shorttermloudness,
5863 integratedloudness: self.integratedloudness,
5864 loudness10thpercentile: self.loudness_10_thpercentile,
5865 loudness95thpercentile: self.loudness_95_thpercentile,
5866 loudnesshistogram: self.loudnesshistogram,
5867 maxtruepeak: self.maxtruepeak,
5868 maxmomentaryloudness: self.maxmomentaryloudness,
5869 }
5870 }
5871}
5872#[derive(Debug, Clone)]
5873pub struct DspLoudnessMeterWeightingType {
5874 pub channelweight: [f32; 32 as usize],
5875}
5876impl TryFrom<ffi::FMOD_DSP_LOUDNESS_METER_WEIGHTING_TYPE> for DspLoudnessMeterWeightingType {
5877 type Error = Error;
5878 fn try_from(value: ffi::FMOD_DSP_LOUDNESS_METER_WEIGHTING_TYPE) -> Result<Self, Self::Error> {
5879 unsafe {
5880 Ok(DspLoudnessMeterWeightingType {
5881 channelweight: value.channelweight,
5882 })
5883 }
5884 }
5885}
5886impl Into<ffi::FMOD_DSP_LOUDNESS_METER_WEIGHTING_TYPE> for DspLoudnessMeterWeightingType {
5887 fn into(self) -> ffi::FMOD_DSP_LOUDNESS_METER_WEIGHTING_TYPE {
5888 ffi::FMOD_DSP_LOUDNESS_METER_WEIGHTING_TYPE {
5889 channelweight: self.channelweight,
5890 }
5891 }
5892}
5893#[derive(Debug, Clone, Copy)]
5894pub struct Channel {
5895 pointer: *mut ffi::FMOD_CHANNEL,
5896}
5897unsafe impl Send for Channel {}
5898unsafe impl Sync for Channel {}
5899impl Channel {
5900 #[inline]
5901 pub fn from(pointer: *mut ffi::FMOD_CHANNEL) -> Self {
5902 Self { pointer }
5903 }
5904 #[inline]
5905 pub fn as_mut_ptr(&self) -> *mut ffi::FMOD_CHANNEL {
5906 self.pointer
5907 }
5908 pub fn get_system_object(&self) -> Result<System, Error> {
5909 unsafe {
5910 let mut system = null_mut();
5911 match ffi::FMOD_Channel_GetSystemObject(self.pointer, &mut system) {
5912 ffi::FMOD_OK => Ok(System::from(system)),
5913 error => Err(err_fmod!("FMOD_Channel_GetSystemObject", error)),
5914 }
5915 }
5916 }
5917 pub fn stop(&self) -> Result<(), Error> {
5918 unsafe {
5919 match ffi::FMOD_Channel_Stop(self.pointer) {
5920 ffi::FMOD_OK => Ok(()),
5921 error => Err(err_fmod!("FMOD_Channel_Stop", error)),
5922 }
5923 }
5924 }
5925 pub fn set_paused(&self, paused: bool) -> Result<(), Error> {
5926 unsafe {
5927 match ffi::FMOD_Channel_SetPaused(self.pointer, from_bool!(paused)) {
5928 ffi::FMOD_OK => Ok(()),
5929 error => Err(err_fmod!("FMOD_Channel_SetPaused", error)),
5930 }
5931 }
5932 }
5933 pub fn get_paused(&self) -> Result<bool, Error> {
5934 unsafe {
5935 let mut paused = ffi::FMOD_BOOL::default();
5936 match ffi::FMOD_Channel_GetPaused(self.pointer, &mut paused) {
5937 ffi::FMOD_OK => Ok(to_bool!(paused)),
5938 error => Err(err_fmod!("FMOD_Channel_GetPaused", error)),
5939 }
5940 }
5941 }
5942 pub fn set_volume(&self, volume: f32) -> Result<(), Error> {
5943 unsafe {
5944 match ffi::FMOD_Channel_SetVolume(self.pointer, volume) {
5945 ffi::FMOD_OK => Ok(()),
5946 error => Err(err_fmod!("FMOD_Channel_SetVolume", error)),
5947 }
5948 }
5949 }
5950 pub fn get_volume(&self) -> Result<f32, Error> {
5951 unsafe {
5952 let mut volume = f32::default();
5953 match ffi::FMOD_Channel_GetVolume(self.pointer, &mut volume) {
5954 ffi::FMOD_OK => Ok(volume),
5955 error => Err(err_fmod!("FMOD_Channel_GetVolume", error)),
5956 }
5957 }
5958 }
5959 pub fn set_volume_ramp(&self, ramp: bool) -> Result<(), Error> {
5960 unsafe {
5961 match ffi::FMOD_Channel_SetVolumeRamp(self.pointer, from_bool!(ramp)) {
5962 ffi::FMOD_OK => Ok(()),
5963 error => Err(err_fmod!("FMOD_Channel_SetVolumeRamp", error)),
5964 }
5965 }
5966 }
5967 pub fn get_volume_ramp(&self) -> Result<bool, Error> {
5968 unsafe {
5969 let mut ramp = ffi::FMOD_BOOL::default();
5970 match ffi::FMOD_Channel_GetVolumeRamp(self.pointer, &mut ramp) {
5971 ffi::FMOD_OK => Ok(to_bool!(ramp)),
5972 error => Err(err_fmod!("FMOD_Channel_GetVolumeRamp", error)),
5973 }
5974 }
5975 }
5976 pub fn get_audibility(&self) -> Result<f32, Error> {
5977 unsafe {
5978 let mut audibility = f32::default();
5979 match ffi::FMOD_Channel_GetAudibility(self.pointer, &mut audibility) {
5980 ffi::FMOD_OK => Ok(audibility),
5981 error => Err(err_fmod!("FMOD_Channel_GetAudibility", error)),
5982 }
5983 }
5984 }
5985 pub fn set_pitch(&self, pitch: f32) -> Result<(), Error> {
5986 unsafe {
5987 match ffi::FMOD_Channel_SetPitch(self.pointer, pitch) {
5988 ffi::FMOD_OK => Ok(()),
5989 error => Err(err_fmod!("FMOD_Channel_SetPitch", error)),
5990 }
5991 }
5992 }
5993 pub fn get_pitch(&self) -> Result<f32, Error> {
5994 unsafe {
5995 let mut pitch = f32::default();
5996 match ffi::FMOD_Channel_GetPitch(self.pointer, &mut pitch) {
5997 ffi::FMOD_OK => Ok(pitch),
5998 error => Err(err_fmod!("FMOD_Channel_GetPitch", error)),
5999 }
6000 }
6001 }
6002 pub fn set_mute(&self, mute: bool) -> Result<(), Error> {
6003 unsafe {
6004 match ffi::FMOD_Channel_SetMute(self.pointer, from_bool!(mute)) {
6005 ffi::FMOD_OK => Ok(()),
6006 error => Err(err_fmod!("FMOD_Channel_SetMute", error)),
6007 }
6008 }
6009 }
6010 pub fn get_mute(&self) -> Result<bool, Error> {
6011 unsafe {
6012 let mut mute = ffi::FMOD_BOOL::default();
6013 match ffi::FMOD_Channel_GetMute(self.pointer, &mut mute) {
6014 ffi::FMOD_OK => Ok(to_bool!(mute)),
6015 error => Err(err_fmod!("FMOD_Channel_GetMute", error)),
6016 }
6017 }
6018 }
6019 pub fn set_reverb_properties(&self, instance: i32, wet: f32) -> Result<(), Error> {
6020 unsafe {
6021 match ffi::FMOD_Channel_SetReverbProperties(self.pointer, instance, wet) {
6022 ffi::FMOD_OK => Ok(()),
6023 error => Err(err_fmod!("FMOD_Channel_SetReverbProperties", error)),
6024 }
6025 }
6026 }
6027 pub fn get_reverb_properties(&self, instance: i32) -> Result<f32, Error> {
6028 unsafe {
6029 let mut wet = f32::default();
6030 match ffi::FMOD_Channel_GetReverbProperties(self.pointer, instance, &mut wet) {
6031 ffi::FMOD_OK => Ok(wet),
6032 error => Err(err_fmod!("FMOD_Channel_GetReverbProperties", error)),
6033 }
6034 }
6035 }
6036 pub fn set_low_pass_gain(&self, gain: f32) -> Result<(), Error> {
6037 unsafe {
6038 match ffi::FMOD_Channel_SetLowPassGain(self.pointer, gain) {
6039 ffi::FMOD_OK => Ok(()),
6040 error => Err(err_fmod!("FMOD_Channel_SetLowPassGain", error)),
6041 }
6042 }
6043 }
6044 pub fn get_low_pass_gain(&self) -> Result<f32, Error> {
6045 unsafe {
6046 let mut gain = f32::default();
6047 match ffi::FMOD_Channel_GetLowPassGain(self.pointer, &mut gain) {
6048 ffi::FMOD_OK => Ok(gain),
6049 error => Err(err_fmod!("FMOD_Channel_GetLowPassGain", error)),
6050 }
6051 }
6052 }
6053 pub fn set_mode(&self, mode: impl Into<ffi::FMOD_MODE>) -> Result<(), Error> {
6054 unsafe {
6055 match ffi::FMOD_Channel_SetMode(self.pointer, mode.into()) {
6056 ffi::FMOD_OK => Ok(()),
6057 error => Err(err_fmod!("FMOD_Channel_SetMode", error)),
6058 }
6059 }
6060 }
6061 pub fn get_mode(&self) -> Result<ffi::FMOD_MODE, Error> {
6062 unsafe {
6063 let mut mode = ffi::FMOD_MODE::default();
6064 match ffi::FMOD_Channel_GetMode(self.pointer, &mut mode) {
6065 ffi::FMOD_OK => Ok(mode),
6066 error => Err(err_fmod!("FMOD_Channel_GetMode", error)),
6067 }
6068 }
6069 }
6070 pub fn set_callback(&self, callback: ffi::FMOD_CHANNELCONTROL_CALLBACK) -> Result<(), Error> {
6071 unsafe {
6072 match ffi::FMOD_Channel_SetCallback(self.pointer, callback) {
6073 ffi::FMOD_OK => Ok(()),
6074 error => Err(err_fmod!("FMOD_Channel_SetCallback", error)),
6075 }
6076 }
6077 }
6078 pub fn is_playing(&self) -> Result<bool, Error> {
6079 unsafe {
6080 let mut isplaying = ffi::FMOD_BOOL::default();
6081 match ffi::FMOD_Channel_IsPlaying(self.pointer, &mut isplaying) {
6082 ffi::FMOD_OK => Ok(to_bool!(isplaying)),
6083 error => Err(err_fmod!("FMOD_Channel_IsPlaying", error)),
6084 }
6085 }
6086 }
6087 pub fn set_pan(&self, pan: f32) -> Result<(), Error> {
6088 unsafe {
6089 match ffi::FMOD_Channel_SetPan(self.pointer, pan) {
6090 ffi::FMOD_OK => Ok(()),
6091 error => Err(err_fmod!("FMOD_Channel_SetPan", error)),
6092 }
6093 }
6094 }
6095 pub fn set_mix_levels_output(
6096 &self,
6097 frontleft: f32,
6098 frontright: f32,
6099 center: f32,
6100 lfe: f32,
6101 surroundleft: f32,
6102 surroundright: f32,
6103 backleft: f32,
6104 backright: f32,
6105 ) -> Result<(), Error> {
6106 unsafe {
6107 match ffi::FMOD_Channel_SetMixLevelsOutput(
6108 self.pointer,
6109 frontleft,
6110 frontright,
6111 center,
6112 lfe,
6113 surroundleft,
6114 surroundright,
6115 backleft,
6116 backright,
6117 ) {
6118 ffi::FMOD_OK => Ok(()),
6119 error => Err(err_fmod!("FMOD_Channel_SetMixLevelsOutput", error)),
6120 }
6121 }
6122 }
6123 pub fn set_mix_levels_input(&self, levels: *mut f32, numlevels: i32) -> Result<(), Error> {
6124 unsafe {
6125 match ffi::FMOD_Channel_SetMixLevelsInput(self.pointer, levels, numlevels) {
6126 ffi::FMOD_OK => Ok(()),
6127 error => Err(err_fmod!("FMOD_Channel_SetMixLevelsInput", error)),
6128 }
6129 }
6130 }
6131 pub fn set_mix_matrix(
6132 &self,
6133 matrix: Option<*mut f32>,
6134 outchannels: i32,
6135 inchannels: i32,
6136 inchannel_hop: Option<i32>,
6137 ) -> Result<(), Error> {
6138 unsafe {
6139 match ffi::FMOD_Channel_SetMixMatrix(
6140 self.pointer,
6141 matrix.unwrap_or(null_mut()),
6142 outchannels,
6143 inchannels,
6144 inchannel_hop.unwrap_or(0),
6145 ) {
6146 ffi::FMOD_OK => Ok(()),
6147 error => Err(err_fmod!("FMOD_Channel_SetMixMatrix", error)),
6148 }
6149 }
6150 }
6151 pub fn get_mix_matrix(&self, inchannel_hop: i32) -> Result<(f32, i32, i32), Error> {
6152 unsafe {
6153 let mut matrix = f32::default();
6154 let mut outchannels = i32::default();
6155 let mut inchannels = i32::default();
6156 match ffi::FMOD_Channel_GetMixMatrix(
6157 self.pointer,
6158 &mut matrix,
6159 &mut outchannels,
6160 &mut inchannels,
6161 inchannel_hop,
6162 ) {
6163 ffi::FMOD_OK => Ok((matrix, outchannels, inchannels)),
6164 error => Err(err_fmod!("FMOD_Channel_GetMixMatrix", error)),
6165 }
6166 }
6167 }
6168 pub fn get_dsp_clock(&self) -> Result<(u64, u64), Error> {
6169 unsafe {
6170 let mut dspclock = u64::default();
6171 let mut parentclock = u64::default();
6172 match ffi::FMOD_Channel_GetDSPClock(self.pointer, &mut dspclock, &mut parentclock) {
6173 ffi::FMOD_OK => Ok((dspclock, parentclock)),
6174 error => Err(err_fmod!("FMOD_Channel_GetDSPClock", error)),
6175 }
6176 }
6177 }
6178 pub fn set_delay(
6179 &self,
6180 dspclock_start: Option<u64>,
6181 dspclock_end: Option<u64>,
6182 stopchannels: bool,
6183 ) -> Result<(), Error> {
6184 unsafe {
6185 match ffi::FMOD_Channel_SetDelay(
6186 self.pointer,
6187 dspclock_start.unwrap_or(0),
6188 dspclock_end.unwrap_or(0),
6189 from_bool!(stopchannels),
6190 ) {
6191 ffi::FMOD_OK => Ok(()),
6192 error => Err(err_fmod!("FMOD_Channel_SetDelay", error)),
6193 }
6194 }
6195 }
6196 pub fn get_delay(&self) -> Result<(u64, u64, bool), Error> {
6197 unsafe {
6198 let mut dspclock_start = u64::default();
6199 let mut dspclock_end = u64::default();
6200 let mut stopchannels = ffi::FMOD_BOOL::default();
6201 match ffi::FMOD_Channel_GetDelay(
6202 self.pointer,
6203 &mut dspclock_start,
6204 &mut dspclock_end,
6205 &mut stopchannels,
6206 ) {
6207 ffi::FMOD_OK => Ok((dspclock_start, dspclock_end, to_bool!(stopchannels))),
6208 error => Err(err_fmod!("FMOD_Channel_GetDelay", error)),
6209 }
6210 }
6211 }
6212 pub fn add_fade_point(&self, dspclock: u64, volume: f32) -> Result<(), Error> {
6213 unsafe {
6214 match ffi::FMOD_Channel_AddFadePoint(self.pointer, dspclock, volume) {
6215 ffi::FMOD_OK => Ok(()),
6216 error => Err(err_fmod!("FMOD_Channel_AddFadePoint", error)),
6217 }
6218 }
6219 }
6220 pub fn set_fade_point_ramp(&self, dspclock: u64, volume: f32) -> Result<(), Error> {
6221 unsafe {
6222 match ffi::FMOD_Channel_SetFadePointRamp(self.pointer, dspclock, volume) {
6223 ffi::FMOD_OK => Ok(()),
6224 error => Err(err_fmod!("FMOD_Channel_SetFadePointRamp", error)),
6225 }
6226 }
6227 }
6228 pub fn remove_fade_points(&self, dspclock_start: u64, dspclock_end: u64) -> Result<(), Error> {
6229 unsafe {
6230 match ffi::FMOD_Channel_RemoveFadePoints(self.pointer, dspclock_start, dspclock_end) {
6231 ffi::FMOD_OK => Ok(()),
6232 error => Err(err_fmod!("FMOD_Channel_RemoveFadePoints", error)),
6233 }
6234 }
6235 }
6236 pub fn get_fade_points(&self) -> Result<(u32, u64, f32), Error> {
6237 unsafe {
6238 let mut numpoints = u32::default();
6239 let mut point_dspclock = u64::default();
6240 let mut point_volume = f32::default();
6241 match ffi::FMOD_Channel_GetFadePoints(
6242 self.pointer,
6243 &mut numpoints,
6244 &mut point_dspclock,
6245 &mut point_volume,
6246 ) {
6247 ffi::FMOD_OK => Ok((numpoints, point_dspclock, point_volume)),
6248 error => Err(err_fmod!("FMOD_Channel_GetFadePoints", error)),
6249 }
6250 }
6251 }
6252 pub fn get_dsp(&self, index: i32) -> Result<Dsp, Error> {
6253 unsafe {
6254 let mut dsp = null_mut();
6255 match ffi::FMOD_Channel_GetDSP(self.pointer, index, &mut dsp) {
6256 ffi::FMOD_OK => Ok(Dsp::from(dsp)),
6257 error => Err(err_fmod!("FMOD_Channel_GetDSP", error)),
6258 }
6259 }
6260 }
6261 pub fn add_dsp(&self, index: i32, dsp: Dsp) -> Result<(), Error> {
6262 unsafe {
6263 match ffi::FMOD_Channel_AddDSP(self.pointer, index, dsp.as_mut_ptr()) {
6264 ffi::FMOD_OK => Ok(()),
6265 error => Err(err_fmod!("FMOD_Channel_AddDSP", error)),
6266 }
6267 }
6268 }
6269 pub fn remove_dsp(&self, dsp: Dsp) -> Result<(), Error> {
6270 unsafe {
6271 match ffi::FMOD_Channel_RemoveDSP(self.pointer, dsp.as_mut_ptr()) {
6272 ffi::FMOD_OK => Ok(()),
6273 error => Err(err_fmod!("FMOD_Channel_RemoveDSP", error)),
6274 }
6275 }
6276 }
6277 pub fn get_num_ds_ps(&self) -> Result<i32, Error> {
6278 unsafe {
6279 let mut numdsps = i32::default();
6280 match ffi::FMOD_Channel_GetNumDSPs(self.pointer, &mut numdsps) {
6281 ffi::FMOD_OK => Ok(numdsps),
6282 error => Err(err_fmod!("FMOD_Channel_GetNumDSPs", error)),
6283 }
6284 }
6285 }
6286 pub fn set_dsp_index(&self, dsp: Dsp, index: i32) -> Result<(), Error> {
6287 unsafe {
6288 match ffi::FMOD_Channel_SetDSPIndex(self.pointer, dsp.as_mut_ptr(), index) {
6289 ffi::FMOD_OK => Ok(()),
6290 error => Err(err_fmod!("FMOD_Channel_SetDSPIndex", error)),
6291 }
6292 }
6293 }
6294 pub fn get_dsp_index(&self, dsp: Dsp) -> Result<i32, Error> {
6295 unsafe {
6296 let mut index = i32::default();
6297 match ffi::FMOD_Channel_GetDSPIndex(self.pointer, dsp.as_mut_ptr(), &mut index) {
6298 ffi::FMOD_OK => Ok(index),
6299 error => Err(err_fmod!("FMOD_Channel_GetDSPIndex", error)),
6300 }
6301 }
6302 }
6303 pub fn set_3d_attributes(&self, pos: Option<Vector>, vel: Option<Vector>) -> Result<(), Error> {
6304 unsafe {
6305 match ffi::FMOD_Channel_Set3DAttributes(
6306 self.pointer,
6307 pos.map(Vector::into)
6308 .as_ref()
6309 .map(from_ref)
6310 .unwrap_or_else(null),
6311 vel.map(Vector::into)
6312 .as_ref()
6313 .map(from_ref)
6314 .unwrap_or_else(null),
6315 ) {
6316 ffi::FMOD_OK => Ok(()),
6317 error => Err(err_fmod!("FMOD_Channel_Set3DAttributes", error)),
6318 }
6319 }
6320 }
6321 pub fn get_3d_attributes(&self) -> Result<(Vector, Vector), Error> {
6322 unsafe {
6323 let mut pos = ffi::FMOD_VECTOR::default();
6324 let mut vel = ffi::FMOD_VECTOR::default();
6325 match ffi::FMOD_Channel_Get3DAttributes(self.pointer, &mut pos, &mut vel) {
6326 ffi::FMOD_OK => Ok((Vector::try_from(pos)?, Vector::try_from(vel)?)),
6327 error => Err(err_fmod!("FMOD_Channel_Get3DAttributes", error)),
6328 }
6329 }
6330 }
6331 pub fn set_3d_min_max_distance(&self, mindistance: f32, maxdistance: f32) -> Result<(), Error> {
6332 unsafe {
6333 match ffi::FMOD_Channel_Set3DMinMaxDistance(self.pointer, mindistance, maxdistance) {
6334 ffi::FMOD_OK => Ok(()),
6335 error => Err(err_fmod!("FMOD_Channel_Set3DMinMaxDistance", error)),
6336 }
6337 }
6338 }
6339 pub fn get_3d_min_max_distance(&self) -> Result<(f32, f32), Error> {
6340 unsafe {
6341 let mut mindistance = f32::default();
6342 let mut maxdistance = f32::default();
6343 match ffi::FMOD_Channel_Get3DMinMaxDistance(
6344 self.pointer,
6345 &mut mindistance,
6346 &mut maxdistance,
6347 ) {
6348 ffi::FMOD_OK => Ok((mindistance, maxdistance)),
6349 error => Err(err_fmod!("FMOD_Channel_Get3DMinMaxDistance", error)),
6350 }
6351 }
6352 }
6353 pub fn set_3d_cone_settings(
6354 &self,
6355 insideconeangle: f32,
6356 outsideconeangle: f32,
6357 outsidevolume: f32,
6358 ) -> Result<(), Error> {
6359 unsafe {
6360 match ffi::FMOD_Channel_Set3DConeSettings(
6361 self.pointer,
6362 insideconeangle,
6363 outsideconeangle,
6364 outsidevolume,
6365 ) {
6366 ffi::FMOD_OK => Ok(()),
6367 error => Err(err_fmod!("FMOD_Channel_Set3DConeSettings", error)),
6368 }
6369 }
6370 }
6371 pub fn get_3d_cone_settings(&self) -> Result<(f32, f32, f32), Error> {
6372 unsafe {
6373 let mut insideconeangle = f32::default();
6374 let mut outsideconeangle = f32::default();
6375 let mut outsidevolume = f32::default();
6376 match ffi::FMOD_Channel_Get3DConeSettings(
6377 self.pointer,
6378 &mut insideconeangle,
6379 &mut outsideconeangle,
6380 &mut outsidevolume,
6381 ) {
6382 ffi::FMOD_OK => Ok((insideconeangle, outsideconeangle, outsidevolume)),
6383 error => Err(err_fmod!("FMOD_Channel_Get3DConeSettings", error)),
6384 }
6385 }
6386 }
6387 pub fn set_3d_cone_orientation(&self, orientation: Vector) -> Result<(), Error> {
6388 unsafe {
6389 match ffi::FMOD_Channel_Set3DConeOrientation(self.pointer, &mut orientation.into()) {
6390 ffi::FMOD_OK => Ok(()),
6391 error => Err(err_fmod!("FMOD_Channel_Set3DConeOrientation", error)),
6392 }
6393 }
6394 }
6395 pub fn get_3d_cone_orientation(&self) -> Result<Vector, Error> {
6396 unsafe {
6397 let mut orientation = ffi::FMOD_VECTOR::default();
6398 match ffi::FMOD_Channel_Get3DConeOrientation(self.pointer, &mut orientation) {
6399 ffi::FMOD_OK => Ok(Vector::try_from(orientation)?),
6400 error => Err(err_fmod!("FMOD_Channel_Get3DConeOrientation", error)),
6401 }
6402 }
6403 }
6404 pub fn set_3d_custom_rolloff(&self, points: Vec<Vector>) -> Result<(), Error> {
6405 unsafe {
6406 let numpoints = points.len() as i32;
6407 match ffi::FMOD_Channel_Set3DCustomRolloff(
6408 self.pointer,
6409 vec_as_mut_ptr(points, |point| point.into()),
6410 numpoints,
6411 ) {
6412 ffi::FMOD_OK => Ok(()),
6413 error => Err(err_fmod!("FMOD_Channel_Set3DCustomRolloff", error)),
6414 }
6415 }
6416 }
6417 pub fn get_3d_custom_rolloff(&self) -> Result<Vec<Vector>, Error> {
6418 unsafe {
6419 let mut points = null_mut();
6420 let mut numpoints = i32::default();
6421 match ffi::FMOD_Channel_Get3DCustomRolloff(self.pointer, &mut points, &mut numpoints) {
6422 ffi::FMOD_OK => Ok(to_vec!(points, numpoints, Vector::try_from)?),
6423 error => Err(err_fmod!("FMOD_Channel_Get3DCustomRolloff", error)),
6424 }
6425 }
6426 }
6427 pub fn set_3d_occlusion(
6428 &self,
6429 directocclusion: f32,
6430 reverbocclusion: f32,
6431 ) -> Result<(), Error> {
6432 unsafe {
6433 match ffi::FMOD_Channel_Set3DOcclusion(self.pointer, directocclusion, reverbocclusion) {
6434 ffi::FMOD_OK => Ok(()),
6435 error => Err(err_fmod!("FMOD_Channel_Set3DOcclusion", error)),
6436 }
6437 }
6438 }
6439 pub fn get_3d_occlusion(&self) -> Result<(f32, f32), Error> {
6440 unsafe {
6441 let mut directocclusion = f32::default();
6442 let mut reverbocclusion = f32::default();
6443 match ffi::FMOD_Channel_Get3DOcclusion(
6444 self.pointer,
6445 &mut directocclusion,
6446 &mut reverbocclusion,
6447 ) {
6448 ffi::FMOD_OK => Ok((directocclusion, reverbocclusion)),
6449 error => Err(err_fmod!("FMOD_Channel_Get3DOcclusion", error)),
6450 }
6451 }
6452 }
6453 pub fn set_3d_spread(&self, angle: f32) -> Result<(), Error> {
6454 unsafe {
6455 match ffi::FMOD_Channel_Set3DSpread(self.pointer, angle) {
6456 ffi::FMOD_OK => Ok(()),
6457 error => Err(err_fmod!("FMOD_Channel_Set3DSpread", error)),
6458 }
6459 }
6460 }
6461 pub fn get_3d_spread(&self) -> Result<f32, Error> {
6462 unsafe {
6463 let mut angle = f32::default();
6464 match ffi::FMOD_Channel_Get3DSpread(self.pointer, &mut angle) {
6465 ffi::FMOD_OK => Ok(angle),
6466 error => Err(err_fmod!("FMOD_Channel_Get3DSpread", error)),
6467 }
6468 }
6469 }
6470 pub fn set_3d_level(&self, level: f32) -> Result<(), Error> {
6471 unsafe {
6472 match ffi::FMOD_Channel_Set3DLevel(self.pointer, level) {
6473 ffi::FMOD_OK => Ok(()),
6474 error => Err(err_fmod!("FMOD_Channel_Set3DLevel", error)),
6475 }
6476 }
6477 }
6478 pub fn get_3d_level(&self) -> Result<f32, Error> {
6479 unsafe {
6480 let mut level = f32::default();
6481 match ffi::FMOD_Channel_Get3DLevel(self.pointer, &mut level) {
6482 ffi::FMOD_OK => Ok(level),
6483 error => Err(err_fmod!("FMOD_Channel_Get3DLevel", error)),
6484 }
6485 }
6486 }
6487 pub fn set_3d_doppler_level(&self, level: f32) -> Result<(), Error> {
6488 unsafe {
6489 match ffi::FMOD_Channel_Set3DDopplerLevel(self.pointer, level) {
6490 ffi::FMOD_OK => Ok(()),
6491 error => Err(err_fmod!("FMOD_Channel_Set3DDopplerLevel", error)),
6492 }
6493 }
6494 }
6495 pub fn get_3d_doppler_level(&self) -> Result<f32, Error> {
6496 unsafe {
6497 let mut level = f32::default();
6498 match ffi::FMOD_Channel_Get3DDopplerLevel(self.pointer, &mut level) {
6499 ffi::FMOD_OK => Ok(level),
6500 error => Err(err_fmod!("FMOD_Channel_Get3DDopplerLevel", error)),
6501 }
6502 }
6503 }
6504 pub fn set_3d_distance_filter(
6505 &self,
6506 custom: bool,
6507 custom_level: f32,
6508 center_freq: Option<f32>,
6509 ) -> Result<(), Error> {
6510 unsafe {
6511 match ffi::FMOD_Channel_Set3DDistanceFilter(
6512 self.pointer,
6513 from_bool!(custom),
6514 custom_level,
6515 center_freq.unwrap_or(0.0),
6516 ) {
6517 ffi::FMOD_OK => Ok(()),
6518 error => Err(err_fmod!("FMOD_Channel_Set3DDistanceFilter", error)),
6519 }
6520 }
6521 }
6522 pub fn get_3d_distance_filter(&self) -> Result<(bool, f32, f32), Error> {
6523 unsafe {
6524 let mut custom = ffi::FMOD_BOOL::default();
6525 let mut custom_level = f32::default();
6526 let mut center_freq = f32::default();
6527 match ffi::FMOD_Channel_Get3DDistanceFilter(
6528 self.pointer,
6529 &mut custom,
6530 &mut custom_level,
6531 &mut center_freq,
6532 ) {
6533 ffi::FMOD_OK => Ok((to_bool!(custom), custom_level, center_freq)),
6534 error => Err(err_fmod!("FMOD_Channel_Get3DDistanceFilter", error)),
6535 }
6536 }
6537 }
6538 pub fn set_user_data(&self, userdata: *mut c_void) -> Result<(), Error> {
6539 unsafe {
6540 match ffi::FMOD_Channel_SetUserData(self.pointer, userdata) {
6541 ffi::FMOD_OK => Ok(()),
6542 error => Err(err_fmod!("FMOD_Channel_SetUserData", error)),
6543 }
6544 }
6545 }
6546 pub fn get_user_data(&self) -> Result<*mut c_void, Error> {
6547 unsafe {
6548 let mut userdata = null_mut();
6549 match ffi::FMOD_Channel_GetUserData(self.pointer, &mut userdata) {
6550 ffi::FMOD_OK => Ok(userdata),
6551 error => Err(err_fmod!("FMOD_Channel_GetUserData", error)),
6552 }
6553 }
6554 }
6555 pub fn set_frequency(&self, frequency: f32) -> Result<(), Error> {
6556 unsafe {
6557 match ffi::FMOD_Channel_SetFrequency(self.pointer, frequency) {
6558 ffi::FMOD_OK => Ok(()),
6559 error => Err(err_fmod!("FMOD_Channel_SetFrequency", error)),
6560 }
6561 }
6562 }
6563 pub fn get_frequency(&self) -> Result<f32, Error> {
6564 unsafe {
6565 let mut frequency = f32::default();
6566 match ffi::FMOD_Channel_GetFrequency(self.pointer, &mut frequency) {
6567 ffi::FMOD_OK => Ok(frequency),
6568 error => Err(err_fmod!("FMOD_Channel_GetFrequency", error)),
6569 }
6570 }
6571 }
6572 pub fn set_priority(&self, priority: i32) -> Result<(), Error> {
6573 unsafe {
6574 match ffi::FMOD_Channel_SetPriority(self.pointer, priority) {
6575 ffi::FMOD_OK => Ok(()),
6576 error => Err(err_fmod!("FMOD_Channel_SetPriority", error)),
6577 }
6578 }
6579 }
6580 pub fn get_priority(&self) -> Result<i32, Error> {
6581 unsafe {
6582 let mut priority = i32::default();
6583 match ffi::FMOD_Channel_GetPriority(self.pointer, &mut priority) {
6584 ffi::FMOD_OK => Ok(priority),
6585 error => Err(err_fmod!("FMOD_Channel_GetPriority", error)),
6586 }
6587 }
6588 }
6589 pub fn set_position(
6590 &self,
6591 position: u32,
6592 postype: impl Into<ffi::FMOD_TIMEUNIT>,
6593 ) -> Result<(), Error> {
6594 unsafe {
6595 match ffi::FMOD_Channel_SetPosition(self.pointer, position, postype.into()) {
6596 ffi::FMOD_OK => Ok(()),
6597 error => Err(err_fmod!("FMOD_Channel_SetPosition", error)),
6598 }
6599 }
6600 }
6601 pub fn get_position(&self, postype: impl Into<ffi::FMOD_TIMEUNIT>) -> Result<u32, Error> {
6602 unsafe {
6603 let mut position = u32::default();
6604 match ffi::FMOD_Channel_GetPosition(self.pointer, &mut position, postype.into()) {
6605 ffi::FMOD_OK => Ok(position),
6606 error => Err(err_fmod!("FMOD_Channel_GetPosition", error)),
6607 }
6608 }
6609 }
6610 pub fn set_channel_group(&self, channelgroup: ChannelGroup) -> Result<(), Error> {
6611 unsafe {
6612 match ffi::FMOD_Channel_SetChannelGroup(self.pointer, channelgroup.as_mut_ptr()) {
6613 ffi::FMOD_OK => Ok(()),
6614 error => Err(err_fmod!("FMOD_Channel_SetChannelGroup", error)),
6615 }
6616 }
6617 }
6618 pub fn get_channel_group(&self) -> Result<ChannelGroup, Error> {
6619 unsafe {
6620 let mut channelgroup = null_mut();
6621 match ffi::FMOD_Channel_GetChannelGroup(self.pointer, &mut channelgroup) {
6622 ffi::FMOD_OK => Ok(ChannelGroup::from(channelgroup)),
6623 error => Err(err_fmod!("FMOD_Channel_GetChannelGroup", error)),
6624 }
6625 }
6626 }
6627 pub fn set_loop_count(&self, loopcount: i32) -> Result<(), Error> {
6628 unsafe {
6629 match ffi::FMOD_Channel_SetLoopCount(self.pointer, loopcount) {
6630 ffi::FMOD_OK => Ok(()),
6631 error => Err(err_fmod!("FMOD_Channel_SetLoopCount", error)),
6632 }
6633 }
6634 }
6635 pub fn get_loop_count(&self) -> Result<i32, Error> {
6636 unsafe {
6637 let mut loopcount = i32::default();
6638 match ffi::FMOD_Channel_GetLoopCount(self.pointer, &mut loopcount) {
6639 ffi::FMOD_OK => Ok(loopcount),
6640 error => Err(err_fmod!("FMOD_Channel_GetLoopCount", error)),
6641 }
6642 }
6643 }
6644 pub fn set_loop_points(
6645 &self,
6646 loopstart: u32,
6647 loopstarttype: impl Into<ffi::FMOD_TIMEUNIT>,
6648 loopend: u32,
6649 loopendtype: impl Into<ffi::FMOD_TIMEUNIT>,
6650 ) -> Result<(), Error> {
6651 unsafe {
6652 match ffi::FMOD_Channel_SetLoopPoints(
6653 self.pointer,
6654 loopstart,
6655 loopstarttype.into(),
6656 loopend,
6657 loopendtype.into(),
6658 ) {
6659 ffi::FMOD_OK => Ok(()),
6660 error => Err(err_fmod!("FMOD_Channel_SetLoopPoints", error)),
6661 }
6662 }
6663 }
6664 pub fn get_loop_points(
6665 &self,
6666 loopstarttype: impl Into<ffi::FMOD_TIMEUNIT>,
6667 loopendtype: impl Into<ffi::FMOD_TIMEUNIT>,
6668 ) -> Result<(u32, u32), Error> {
6669 unsafe {
6670 let mut loopstart = u32::default();
6671 let mut loopend = u32::default();
6672 match ffi::FMOD_Channel_GetLoopPoints(
6673 self.pointer,
6674 &mut loopstart,
6675 loopstarttype.into(),
6676 &mut loopend,
6677 loopendtype.into(),
6678 ) {
6679 ffi::FMOD_OK => Ok((loopstart, loopend)),
6680 error => Err(err_fmod!("FMOD_Channel_GetLoopPoints", error)),
6681 }
6682 }
6683 }
6684 pub fn is_virtual(&self) -> Result<bool, Error> {
6685 unsafe {
6686 let mut isvirtual = ffi::FMOD_BOOL::default();
6687 match ffi::FMOD_Channel_IsVirtual(self.pointer, &mut isvirtual) {
6688 ffi::FMOD_OK => Ok(to_bool!(isvirtual)),
6689 error => Err(err_fmod!("FMOD_Channel_IsVirtual", error)),
6690 }
6691 }
6692 }
6693 pub fn get_current_sound(&self) -> Result<Sound, Error> {
6694 unsafe {
6695 let mut sound = null_mut();
6696 match ffi::FMOD_Channel_GetCurrentSound(self.pointer, &mut sound) {
6697 ffi::FMOD_OK => Ok(Sound::from(sound)),
6698 error => Err(err_fmod!("FMOD_Channel_GetCurrentSound", error)),
6699 }
6700 }
6701 }
6702 pub fn get_index(&self) -> Result<i32, Error> {
6703 unsafe {
6704 let mut index = i32::default();
6705 match ffi::FMOD_Channel_GetIndex(self.pointer, &mut index) {
6706 ffi::FMOD_OK => Ok(index),
6707 error => Err(err_fmod!("FMOD_Channel_GetIndex", error)),
6708 }
6709 }
6710 }
6711}
6712#[derive(Debug, Clone, Copy)]
6713pub struct ChannelControl {
6714 pointer: *mut ffi::FMOD_CHANNELCONTROL,
6715}
6716unsafe impl Send for ChannelControl {}
6717unsafe impl Sync for ChannelControl {}
6718impl ChannelControl {
6719 #[inline]
6720 pub fn from(pointer: *mut ffi::FMOD_CHANNELCONTROL) -> Self {
6721 Self { pointer }
6722 }
6723 #[inline]
6724 pub fn as_mut_ptr(&self) -> *mut ffi::FMOD_CHANNELCONTROL {
6725 self.pointer
6726 }
6727}
6728#[derive(Debug, Clone, Copy)]
6729pub struct ChannelGroup {
6730 pointer: *mut ffi::FMOD_CHANNELGROUP,
6731}
6732unsafe impl Send for ChannelGroup {}
6733unsafe impl Sync for ChannelGroup {}
6734impl ChannelGroup {
6735 #[inline]
6736 pub fn from(pointer: *mut ffi::FMOD_CHANNELGROUP) -> Self {
6737 Self { pointer }
6738 }
6739 #[inline]
6740 pub fn as_mut_ptr(&self) -> *mut ffi::FMOD_CHANNELGROUP {
6741 self.pointer
6742 }
6743 pub fn get_system_object(&self) -> Result<System, Error> {
6744 unsafe {
6745 let mut system = null_mut();
6746 match ffi::FMOD_ChannelGroup_GetSystemObject(self.pointer, &mut system) {
6747 ffi::FMOD_OK => Ok(System::from(system)),
6748 error => Err(err_fmod!("FMOD_ChannelGroup_GetSystemObject", error)),
6749 }
6750 }
6751 }
6752 pub fn stop(&self) -> Result<(), Error> {
6753 unsafe {
6754 match ffi::FMOD_ChannelGroup_Stop(self.pointer) {
6755 ffi::FMOD_OK => Ok(()),
6756 error => Err(err_fmod!("FMOD_ChannelGroup_Stop", error)),
6757 }
6758 }
6759 }
6760 pub fn set_paused(&self, paused: bool) -> Result<(), Error> {
6761 unsafe {
6762 match ffi::FMOD_ChannelGroup_SetPaused(self.pointer, from_bool!(paused)) {
6763 ffi::FMOD_OK => Ok(()),
6764 error => Err(err_fmod!("FMOD_ChannelGroup_SetPaused", error)),
6765 }
6766 }
6767 }
6768 pub fn get_paused(&self) -> Result<bool, Error> {
6769 unsafe {
6770 let mut paused = ffi::FMOD_BOOL::default();
6771 match ffi::FMOD_ChannelGroup_GetPaused(self.pointer, &mut paused) {
6772 ffi::FMOD_OK => Ok(to_bool!(paused)),
6773 error => Err(err_fmod!("FMOD_ChannelGroup_GetPaused", error)),
6774 }
6775 }
6776 }
6777 pub fn set_volume(&self, volume: f32) -> Result<(), Error> {
6778 unsafe {
6779 match ffi::FMOD_ChannelGroup_SetVolume(self.pointer, volume) {
6780 ffi::FMOD_OK => Ok(()),
6781 error => Err(err_fmod!("FMOD_ChannelGroup_SetVolume", error)),
6782 }
6783 }
6784 }
6785 pub fn get_volume(&self) -> Result<f32, Error> {
6786 unsafe {
6787 let mut volume = f32::default();
6788 match ffi::FMOD_ChannelGroup_GetVolume(self.pointer, &mut volume) {
6789 ffi::FMOD_OK => Ok(volume),
6790 error => Err(err_fmod!("FMOD_ChannelGroup_GetVolume", error)),
6791 }
6792 }
6793 }
6794 pub fn set_volume_ramp(&self, ramp: bool) -> Result<(), Error> {
6795 unsafe {
6796 match ffi::FMOD_ChannelGroup_SetVolumeRamp(self.pointer, from_bool!(ramp)) {
6797 ffi::FMOD_OK => Ok(()),
6798 error => Err(err_fmod!("FMOD_ChannelGroup_SetVolumeRamp", error)),
6799 }
6800 }
6801 }
6802 pub fn get_volume_ramp(&self) -> Result<bool, Error> {
6803 unsafe {
6804 let mut ramp = ffi::FMOD_BOOL::default();
6805 match ffi::FMOD_ChannelGroup_GetVolumeRamp(self.pointer, &mut ramp) {
6806 ffi::FMOD_OK => Ok(to_bool!(ramp)),
6807 error => Err(err_fmod!("FMOD_ChannelGroup_GetVolumeRamp", error)),
6808 }
6809 }
6810 }
6811 pub fn get_audibility(&self) -> Result<f32, Error> {
6812 unsafe {
6813 let mut audibility = f32::default();
6814 match ffi::FMOD_ChannelGroup_GetAudibility(self.pointer, &mut audibility) {
6815 ffi::FMOD_OK => Ok(audibility),
6816 error => Err(err_fmod!("FMOD_ChannelGroup_GetAudibility", error)),
6817 }
6818 }
6819 }
6820 pub fn set_pitch(&self, pitch: f32) -> Result<(), Error> {
6821 unsafe {
6822 match ffi::FMOD_ChannelGroup_SetPitch(self.pointer, pitch) {
6823 ffi::FMOD_OK => Ok(()),
6824 error => Err(err_fmod!("FMOD_ChannelGroup_SetPitch", error)),
6825 }
6826 }
6827 }
6828 pub fn get_pitch(&self) -> Result<f32, Error> {
6829 unsafe {
6830 let mut pitch = f32::default();
6831 match ffi::FMOD_ChannelGroup_GetPitch(self.pointer, &mut pitch) {
6832 ffi::FMOD_OK => Ok(pitch),
6833 error => Err(err_fmod!("FMOD_ChannelGroup_GetPitch", error)),
6834 }
6835 }
6836 }
6837 pub fn set_mute(&self, mute: bool) -> Result<(), Error> {
6838 unsafe {
6839 match ffi::FMOD_ChannelGroup_SetMute(self.pointer, from_bool!(mute)) {
6840 ffi::FMOD_OK => Ok(()),
6841 error => Err(err_fmod!("FMOD_ChannelGroup_SetMute", error)),
6842 }
6843 }
6844 }
6845 pub fn get_mute(&self) -> Result<bool, Error> {
6846 unsafe {
6847 let mut mute = ffi::FMOD_BOOL::default();
6848 match ffi::FMOD_ChannelGroup_GetMute(self.pointer, &mut mute) {
6849 ffi::FMOD_OK => Ok(to_bool!(mute)),
6850 error => Err(err_fmod!("FMOD_ChannelGroup_GetMute", error)),
6851 }
6852 }
6853 }
6854 pub fn set_reverb_properties(&self, instance: i32, wet: f32) -> Result<(), Error> {
6855 unsafe {
6856 match ffi::FMOD_ChannelGroup_SetReverbProperties(self.pointer, instance, wet) {
6857 ffi::FMOD_OK => Ok(()),
6858 error => Err(err_fmod!("FMOD_ChannelGroup_SetReverbProperties", error)),
6859 }
6860 }
6861 }
6862 pub fn get_reverb_properties(&self, instance: i32) -> Result<f32, Error> {
6863 unsafe {
6864 let mut wet = f32::default();
6865 match ffi::FMOD_ChannelGroup_GetReverbProperties(self.pointer, instance, &mut wet) {
6866 ffi::FMOD_OK => Ok(wet),
6867 error => Err(err_fmod!("FMOD_ChannelGroup_GetReverbProperties", error)),
6868 }
6869 }
6870 }
6871 pub fn set_low_pass_gain(&self, gain: f32) -> Result<(), Error> {
6872 unsafe {
6873 match ffi::FMOD_ChannelGroup_SetLowPassGain(self.pointer, gain) {
6874 ffi::FMOD_OK => Ok(()),
6875 error => Err(err_fmod!("FMOD_ChannelGroup_SetLowPassGain", error)),
6876 }
6877 }
6878 }
6879 pub fn get_low_pass_gain(&self) -> Result<f32, Error> {
6880 unsafe {
6881 let mut gain = f32::default();
6882 match ffi::FMOD_ChannelGroup_GetLowPassGain(self.pointer, &mut gain) {
6883 ffi::FMOD_OK => Ok(gain),
6884 error => Err(err_fmod!("FMOD_ChannelGroup_GetLowPassGain", error)),
6885 }
6886 }
6887 }
6888 pub fn set_mode(&self, mode: impl Into<ffi::FMOD_MODE>) -> Result<(), Error> {
6889 unsafe {
6890 match ffi::FMOD_ChannelGroup_SetMode(self.pointer, mode.into()) {
6891 ffi::FMOD_OK => Ok(()),
6892 error => Err(err_fmod!("FMOD_ChannelGroup_SetMode", error)),
6893 }
6894 }
6895 }
6896 pub fn get_mode(&self) -> Result<ffi::FMOD_MODE, Error> {
6897 unsafe {
6898 let mut mode = ffi::FMOD_MODE::default();
6899 match ffi::FMOD_ChannelGroup_GetMode(self.pointer, &mut mode) {
6900 ffi::FMOD_OK => Ok(mode),
6901 error => Err(err_fmod!("FMOD_ChannelGroup_GetMode", error)),
6902 }
6903 }
6904 }
6905 pub fn set_callback(&self, callback: ffi::FMOD_CHANNELCONTROL_CALLBACK) -> Result<(), Error> {
6906 unsafe {
6907 match ffi::FMOD_ChannelGroup_SetCallback(self.pointer, callback) {
6908 ffi::FMOD_OK => Ok(()),
6909 error => Err(err_fmod!("FMOD_ChannelGroup_SetCallback", error)),
6910 }
6911 }
6912 }
6913 pub fn is_playing(&self) -> Result<bool, Error> {
6914 unsafe {
6915 let mut isplaying = ffi::FMOD_BOOL::default();
6916 match ffi::FMOD_ChannelGroup_IsPlaying(self.pointer, &mut isplaying) {
6917 ffi::FMOD_OK => Ok(to_bool!(isplaying)),
6918 error => Err(err_fmod!("FMOD_ChannelGroup_IsPlaying", error)),
6919 }
6920 }
6921 }
6922 pub fn set_pan(&self, pan: f32) -> Result<(), Error> {
6923 unsafe {
6924 match ffi::FMOD_ChannelGroup_SetPan(self.pointer, pan) {
6925 ffi::FMOD_OK => Ok(()),
6926 error => Err(err_fmod!("FMOD_ChannelGroup_SetPan", error)),
6927 }
6928 }
6929 }
6930 pub fn set_mix_levels_output(
6931 &self,
6932 frontleft: f32,
6933 frontright: f32,
6934 center: f32,
6935 lfe: f32,
6936 surroundleft: f32,
6937 surroundright: f32,
6938 backleft: f32,
6939 backright: f32,
6940 ) -> Result<(), Error> {
6941 unsafe {
6942 match ffi::FMOD_ChannelGroup_SetMixLevelsOutput(
6943 self.pointer,
6944 frontleft,
6945 frontright,
6946 center,
6947 lfe,
6948 surroundleft,
6949 surroundright,
6950 backleft,
6951 backright,
6952 ) {
6953 ffi::FMOD_OK => Ok(()),
6954 error => Err(err_fmod!("FMOD_ChannelGroup_SetMixLevelsOutput", error)),
6955 }
6956 }
6957 }
6958 pub fn set_mix_levels_input(&self, levels: *mut f32, numlevels: i32) -> Result<(), Error> {
6959 unsafe {
6960 match ffi::FMOD_ChannelGroup_SetMixLevelsInput(self.pointer, levels, numlevels) {
6961 ffi::FMOD_OK => Ok(()),
6962 error => Err(err_fmod!("FMOD_ChannelGroup_SetMixLevelsInput", error)),
6963 }
6964 }
6965 }
6966 pub fn set_mix_matrix(
6967 &self,
6968 matrix: Option<*mut f32>,
6969 outchannels: i32,
6970 inchannels: i32,
6971 inchannel_hop: Option<i32>,
6972 ) -> Result<(), Error> {
6973 unsafe {
6974 match ffi::FMOD_ChannelGroup_SetMixMatrix(
6975 self.pointer,
6976 matrix.unwrap_or(null_mut()),
6977 outchannels,
6978 inchannels,
6979 inchannel_hop.unwrap_or(0),
6980 ) {
6981 ffi::FMOD_OK => Ok(()),
6982 error => Err(err_fmod!("FMOD_ChannelGroup_SetMixMatrix", error)),
6983 }
6984 }
6985 }
6986 pub fn get_mix_matrix(&self, inchannel_hop: i32) -> Result<(f32, i32, i32), Error> {
6987 unsafe {
6988 let mut matrix = f32::default();
6989 let mut outchannels = i32::default();
6990 let mut inchannels = i32::default();
6991 match ffi::FMOD_ChannelGroup_GetMixMatrix(
6992 self.pointer,
6993 &mut matrix,
6994 &mut outchannels,
6995 &mut inchannels,
6996 inchannel_hop,
6997 ) {
6998 ffi::FMOD_OK => Ok((matrix, outchannels, inchannels)),
6999 error => Err(err_fmod!("FMOD_ChannelGroup_GetMixMatrix", error)),
7000 }
7001 }
7002 }
7003 pub fn get_dsp_clock(&self) -> Result<(u64, u64), Error> {
7004 unsafe {
7005 let mut dspclock = u64::default();
7006 let mut parentclock = u64::default();
7007 match ffi::FMOD_ChannelGroup_GetDSPClock(self.pointer, &mut dspclock, &mut parentclock)
7008 {
7009 ffi::FMOD_OK => Ok((dspclock, parentclock)),
7010 error => Err(err_fmod!("FMOD_ChannelGroup_GetDSPClock", error)),
7011 }
7012 }
7013 }
7014 pub fn set_delay(
7015 &self,
7016 dspclock_start: Option<u64>,
7017 dspclock_end: Option<u64>,
7018 stopchannels: bool,
7019 ) -> Result<(), Error> {
7020 unsafe {
7021 match ffi::FMOD_ChannelGroup_SetDelay(
7022 self.pointer,
7023 dspclock_start.unwrap_or(0),
7024 dspclock_end.unwrap_or(0),
7025 from_bool!(stopchannels),
7026 ) {
7027 ffi::FMOD_OK => Ok(()),
7028 error => Err(err_fmod!("FMOD_ChannelGroup_SetDelay", error)),
7029 }
7030 }
7031 }
7032 pub fn get_delay(&self) -> Result<(u64, u64, bool), Error> {
7033 unsafe {
7034 let mut dspclock_start = u64::default();
7035 let mut dspclock_end = u64::default();
7036 let mut stopchannels = ffi::FMOD_BOOL::default();
7037 match ffi::FMOD_ChannelGroup_GetDelay(
7038 self.pointer,
7039 &mut dspclock_start,
7040 &mut dspclock_end,
7041 &mut stopchannels,
7042 ) {
7043 ffi::FMOD_OK => Ok((dspclock_start, dspclock_end, to_bool!(stopchannels))),
7044 error => Err(err_fmod!("FMOD_ChannelGroup_GetDelay", error)),
7045 }
7046 }
7047 }
7048 pub fn add_fade_point(&self, dspclock: u64, volume: f32) -> Result<(), Error> {
7049 unsafe {
7050 match ffi::FMOD_ChannelGroup_AddFadePoint(self.pointer, dspclock, volume) {
7051 ffi::FMOD_OK => Ok(()),
7052 error => Err(err_fmod!("FMOD_ChannelGroup_AddFadePoint", error)),
7053 }
7054 }
7055 }
7056 pub fn set_fade_point_ramp(&self, dspclock: u64, volume: f32) -> Result<(), Error> {
7057 unsafe {
7058 match ffi::FMOD_ChannelGroup_SetFadePointRamp(self.pointer, dspclock, volume) {
7059 ffi::FMOD_OK => Ok(()),
7060 error => Err(err_fmod!("FMOD_ChannelGroup_SetFadePointRamp", error)),
7061 }
7062 }
7063 }
7064 pub fn remove_fade_points(&self, dspclock_start: u64, dspclock_end: u64) -> Result<(), Error> {
7065 unsafe {
7066 match ffi::FMOD_ChannelGroup_RemoveFadePoints(
7067 self.pointer,
7068 dspclock_start,
7069 dspclock_end,
7070 ) {
7071 ffi::FMOD_OK => Ok(()),
7072 error => Err(err_fmod!("FMOD_ChannelGroup_RemoveFadePoints", error)),
7073 }
7074 }
7075 }
7076 pub fn get_fade_points(&self) -> Result<(u32, u64, f32), Error> {
7077 unsafe {
7078 let mut numpoints = u32::default();
7079 let mut point_dspclock = u64::default();
7080 let mut point_volume = f32::default();
7081 match ffi::FMOD_ChannelGroup_GetFadePoints(
7082 self.pointer,
7083 &mut numpoints,
7084 &mut point_dspclock,
7085 &mut point_volume,
7086 ) {
7087 ffi::FMOD_OK => Ok((numpoints, point_dspclock, point_volume)),
7088 error => Err(err_fmod!("FMOD_ChannelGroup_GetFadePoints", error)),
7089 }
7090 }
7091 }
7092 pub fn get_dsp(&self, index: i32) -> Result<Dsp, Error> {
7093 unsafe {
7094 let mut dsp = null_mut();
7095 match ffi::FMOD_ChannelGroup_GetDSP(self.pointer, index, &mut dsp) {
7096 ffi::FMOD_OK => Ok(Dsp::from(dsp)),
7097 error => Err(err_fmod!("FMOD_ChannelGroup_GetDSP", error)),
7098 }
7099 }
7100 }
7101 pub fn add_dsp(&self, index: i32, dsp: Dsp) -> Result<(), Error> {
7102 unsafe {
7103 match ffi::FMOD_ChannelGroup_AddDSP(self.pointer, index, dsp.as_mut_ptr()) {
7104 ffi::FMOD_OK => Ok(()),
7105 error => Err(err_fmod!("FMOD_ChannelGroup_AddDSP", error)),
7106 }
7107 }
7108 }
7109 pub fn remove_dsp(&self, dsp: Dsp) -> Result<(), Error> {
7110 unsafe {
7111 match ffi::FMOD_ChannelGroup_RemoveDSP(self.pointer, dsp.as_mut_ptr()) {
7112 ffi::FMOD_OK => Ok(()),
7113 error => Err(err_fmod!("FMOD_ChannelGroup_RemoveDSP", error)),
7114 }
7115 }
7116 }
7117 pub fn get_num_ds_ps(&self) -> Result<i32, Error> {
7118 unsafe {
7119 let mut numdsps = i32::default();
7120 match ffi::FMOD_ChannelGroup_GetNumDSPs(self.pointer, &mut numdsps) {
7121 ffi::FMOD_OK => Ok(numdsps),
7122 error => Err(err_fmod!("FMOD_ChannelGroup_GetNumDSPs", error)),
7123 }
7124 }
7125 }
7126 pub fn set_dsp_index(&self, dsp: Dsp, index: i32) -> Result<(), Error> {
7127 unsafe {
7128 match ffi::FMOD_ChannelGroup_SetDSPIndex(self.pointer, dsp.as_mut_ptr(), index) {
7129 ffi::FMOD_OK => Ok(()),
7130 error => Err(err_fmod!("FMOD_ChannelGroup_SetDSPIndex", error)),
7131 }
7132 }
7133 }
7134 pub fn get_dsp_index(&self, dsp: Dsp) -> Result<i32, Error> {
7135 unsafe {
7136 let mut index = i32::default();
7137 match ffi::FMOD_ChannelGroup_GetDSPIndex(self.pointer, dsp.as_mut_ptr(), &mut index) {
7138 ffi::FMOD_OK => Ok(index),
7139 error => Err(err_fmod!("FMOD_ChannelGroup_GetDSPIndex", error)),
7140 }
7141 }
7142 }
7143 pub fn set_3d_attributes(&self, pos: Option<Vector>, vel: Option<Vector>) -> Result<(), Error> {
7144 unsafe {
7145 match ffi::FMOD_ChannelGroup_Set3DAttributes(
7146 self.pointer,
7147 pos.map(Vector::into)
7148 .as_ref()
7149 .map(from_ref)
7150 .unwrap_or_else(null),
7151 vel.map(Vector::into)
7152 .as_ref()
7153 .map(from_ref)
7154 .unwrap_or_else(null),
7155 ) {
7156 ffi::FMOD_OK => Ok(()),
7157 error => Err(err_fmod!("FMOD_ChannelGroup_Set3DAttributes", error)),
7158 }
7159 }
7160 }
7161 pub fn get_3d_attributes(&self) -> Result<(Vector, Vector), Error> {
7162 unsafe {
7163 let mut pos = ffi::FMOD_VECTOR::default();
7164 let mut vel = ffi::FMOD_VECTOR::default();
7165 match ffi::FMOD_ChannelGroup_Get3DAttributes(self.pointer, &mut pos, &mut vel) {
7166 ffi::FMOD_OK => Ok((Vector::try_from(pos)?, Vector::try_from(vel)?)),
7167 error => Err(err_fmod!("FMOD_ChannelGroup_Get3DAttributes", error)),
7168 }
7169 }
7170 }
7171 pub fn set_3d_min_max_distance(&self, mindistance: f32, maxdistance: f32) -> Result<(), Error> {
7172 unsafe {
7173 match ffi::FMOD_ChannelGroup_Set3DMinMaxDistance(self.pointer, mindistance, maxdistance)
7174 {
7175 ffi::FMOD_OK => Ok(()),
7176 error => Err(err_fmod!("FMOD_ChannelGroup_Set3DMinMaxDistance", error)),
7177 }
7178 }
7179 }
7180 pub fn get_3d_min_max_distance(&self) -> Result<(f32, f32), Error> {
7181 unsafe {
7182 let mut mindistance = f32::default();
7183 let mut maxdistance = f32::default();
7184 match ffi::FMOD_ChannelGroup_Get3DMinMaxDistance(
7185 self.pointer,
7186 &mut mindistance,
7187 &mut maxdistance,
7188 ) {
7189 ffi::FMOD_OK => Ok((mindistance, maxdistance)),
7190 error => Err(err_fmod!("FMOD_ChannelGroup_Get3DMinMaxDistance", error)),
7191 }
7192 }
7193 }
7194 pub fn set_3d_cone_settings(
7195 &self,
7196 insideconeangle: f32,
7197 outsideconeangle: f32,
7198 outsidevolume: f32,
7199 ) -> Result<(), Error> {
7200 unsafe {
7201 match ffi::FMOD_ChannelGroup_Set3DConeSettings(
7202 self.pointer,
7203 insideconeangle,
7204 outsideconeangle,
7205 outsidevolume,
7206 ) {
7207 ffi::FMOD_OK => Ok(()),
7208 error => Err(err_fmod!("FMOD_ChannelGroup_Set3DConeSettings", error)),
7209 }
7210 }
7211 }
7212 pub fn get_3d_cone_settings(&self) -> Result<(f32, f32, f32), Error> {
7213 unsafe {
7214 let mut insideconeangle = f32::default();
7215 let mut outsideconeangle = f32::default();
7216 let mut outsidevolume = f32::default();
7217 match ffi::FMOD_ChannelGroup_Get3DConeSettings(
7218 self.pointer,
7219 &mut insideconeangle,
7220 &mut outsideconeangle,
7221 &mut outsidevolume,
7222 ) {
7223 ffi::FMOD_OK => Ok((insideconeangle, outsideconeangle, outsidevolume)),
7224 error => Err(err_fmod!("FMOD_ChannelGroup_Get3DConeSettings", error)),
7225 }
7226 }
7227 }
7228 pub fn set_3d_cone_orientation(&self, orientation: Vector) -> Result<(), Error> {
7229 unsafe {
7230 match ffi::FMOD_ChannelGroup_Set3DConeOrientation(self.pointer, &mut orientation.into())
7231 {
7232 ffi::FMOD_OK => Ok(()),
7233 error => Err(err_fmod!("FMOD_ChannelGroup_Set3DConeOrientation", error)),
7234 }
7235 }
7236 }
7237 pub fn get_3d_cone_orientation(&self) -> Result<Vector, Error> {
7238 unsafe {
7239 let mut orientation = ffi::FMOD_VECTOR::default();
7240 match ffi::FMOD_ChannelGroup_Get3DConeOrientation(self.pointer, &mut orientation) {
7241 ffi::FMOD_OK => Ok(Vector::try_from(orientation)?),
7242 error => Err(err_fmod!("FMOD_ChannelGroup_Get3DConeOrientation", error)),
7243 }
7244 }
7245 }
7246 pub fn set_3d_custom_rolloff(&self, points: Vec<Vector>) -> Result<(), Error> {
7247 unsafe {
7248 let numpoints = points.len() as i32;
7249 match ffi::FMOD_ChannelGroup_Set3DCustomRolloff(
7250 self.pointer,
7251 vec_as_mut_ptr(points, |point| point.into()),
7252 numpoints,
7253 ) {
7254 ffi::FMOD_OK => Ok(()),
7255 error => Err(err_fmod!("FMOD_ChannelGroup_Set3DCustomRolloff", error)),
7256 }
7257 }
7258 }
7259 pub fn get_3d_custom_rolloff(&self) -> Result<Vec<Vector>, Error> {
7260 unsafe {
7261 let mut points = null_mut();
7262 let mut numpoints = i32::default();
7263 match ffi::FMOD_ChannelGroup_Get3DCustomRolloff(
7264 self.pointer,
7265 &mut points,
7266 &mut numpoints,
7267 ) {
7268 ffi::FMOD_OK => Ok(to_vec!(points, numpoints, Vector::try_from)?),
7269 error => Err(err_fmod!("FMOD_ChannelGroup_Get3DCustomRolloff", error)),
7270 }
7271 }
7272 }
7273 pub fn set_3d_occlusion(
7274 &self,
7275 directocclusion: f32,
7276 reverbocclusion: f32,
7277 ) -> Result<(), Error> {
7278 unsafe {
7279 match ffi::FMOD_ChannelGroup_Set3DOcclusion(
7280 self.pointer,
7281 directocclusion,
7282 reverbocclusion,
7283 ) {
7284 ffi::FMOD_OK => Ok(()),
7285 error => Err(err_fmod!("FMOD_ChannelGroup_Set3DOcclusion", error)),
7286 }
7287 }
7288 }
7289 pub fn get_3d_occlusion(&self) -> Result<(f32, f32), Error> {
7290 unsafe {
7291 let mut directocclusion = f32::default();
7292 let mut reverbocclusion = f32::default();
7293 match ffi::FMOD_ChannelGroup_Get3DOcclusion(
7294 self.pointer,
7295 &mut directocclusion,
7296 &mut reverbocclusion,
7297 ) {
7298 ffi::FMOD_OK => Ok((directocclusion, reverbocclusion)),
7299 error => Err(err_fmod!("FMOD_ChannelGroup_Get3DOcclusion", error)),
7300 }
7301 }
7302 }
7303 pub fn set_3d_spread(&self, angle: f32) -> Result<(), Error> {
7304 unsafe {
7305 match ffi::FMOD_ChannelGroup_Set3DSpread(self.pointer, angle) {
7306 ffi::FMOD_OK => Ok(()),
7307 error => Err(err_fmod!("FMOD_ChannelGroup_Set3DSpread", error)),
7308 }
7309 }
7310 }
7311 pub fn get_3d_spread(&self) -> Result<f32, Error> {
7312 unsafe {
7313 let mut angle = f32::default();
7314 match ffi::FMOD_ChannelGroup_Get3DSpread(self.pointer, &mut angle) {
7315 ffi::FMOD_OK => Ok(angle),
7316 error => Err(err_fmod!("FMOD_ChannelGroup_Get3DSpread", error)),
7317 }
7318 }
7319 }
7320 pub fn set_3d_level(&self, level: f32) -> Result<(), Error> {
7321 unsafe {
7322 match ffi::FMOD_ChannelGroup_Set3DLevel(self.pointer, level) {
7323 ffi::FMOD_OK => Ok(()),
7324 error => Err(err_fmod!("FMOD_ChannelGroup_Set3DLevel", error)),
7325 }
7326 }
7327 }
7328 pub fn get_3d_level(&self) -> Result<f32, Error> {
7329 unsafe {
7330 let mut level = f32::default();
7331 match ffi::FMOD_ChannelGroup_Get3DLevel(self.pointer, &mut level) {
7332 ffi::FMOD_OK => Ok(level),
7333 error => Err(err_fmod!("FMOD_ChannelGroup_Get3DLevel", error)),
7334 }
7335 }
7336 }
7337 pub fn set_3d_doppler_level(&self, level: f32) -> Result<(), Error> {
7338 unsafe {
7339 match ffi::FMOD_ChannelGroup_Set3DDopplerLevel(self.pointer, level) {
7340 ffi::FMOD_OK => Ok(()),
7341 error => Err(err_fmod!("FMOD_ChannelGroup_Set3DDopplerLevel", error)),
7342 }
7343 }
7344 }
7345 pub fn get_3d_doppler_level(&self) -> Result<f32, Error> {
7346 unsafe {
7347 let mut level = f32::default();
7348 match ffi::FMOD_ChannelGroup_Get3DDopplerLevel(self.pointer, &mut level) {
7349 ffi::FMOD_OK => Ok(level),
7350 error => Err(err_fmod!("FMOD_ChannelGroup_Get3DDopplerLevel", error)),
7351 }
7352 }
7353 }
7354 pub fn set_3d_distance_filter(
7355 &self,
7356 custom: bool,
7357 custom_level: f32,
7358 center_freq: Option<f32>,
7359 ) -> Result<(), Error> {
7360 unsafe {
7361 match ffi::FMOD_ChannelGroup_Set3DDistanceFilter(
7362 self.pointer,
7363 from_bool!(custom),
7364 custom_level,
7365 center_freq.unwrap_or(0.0),
7366 ) {
7367 ffi::FMOD_OK => Ok(()),
7368 error => Err(err_fmod!("FMOD_ChannelGroup_Set3DDistanceFilter", error)),
7369 }
7370 }
7371 }
7372 pub fn get_3d_distance_filter(&self) -> Result<(bool, f32, f32), Error> {
7373 unsafe {
7374 let mut custom = ffi::FMOD_BOOL::default();
7375 let mut custom_level = f32::default();
7376 let mut center_freq = f32::default();
7377 match ffi::FMOD_ChannelGroup_Get3DDistanceFilter(
7378 self.pointer,
7379 &mut custom,
7380 &mut custom_level,
7381 &mut center_freq,
7382 ) {
7383 ffi::FMOD_OK => Ok((to_bool!(custom), custom_level, center_freq)),
7384 error => Err(err_fmod!("FMOD_ChannelGroup_Get3DDistanceFilter", error)),
7385 }
7386 }
7387 }
7388 pub fn set_user_data(&self, userdata: *mut c_void) -> Result<(), Error> {
7389 unsafe {
7390 match ffi::FMOD_ChannelGroup_SetUserData(self.pointer, userdata) {
7391 ffi::FMOD_OK => Ok(()),
7392 error => Err(err_fmod!("FMOD_ChannelGroup_SetUserData", error)),
7393 }
7394 }
7395 }
7396 pub fn get_user_data(&self) -> Result<*mut c_void, Error> {
7397 unsafe {
7398 let mut userdata = null_mut();
7399 match ffi::FMOD_ChannelGroup_GetUserData(self.pointer, &mut userdata) {
7400 ffi::FMOD_OK => Ok(userdata),
7401 error => Err(err_fmod!("FMOD_ChannelGroup_GetUserData", error)),
7402 }
7403 }
7404 }
7405 pub fn release(&self) -> Result<(), Error> {
7406 unsafe {
7407 match ffi::FMOD_ChannelGroup_Release(self.pointer) {
7408 ffi::FMOD_OK => Ok(()),
7409 error => Err(err_fmod!("FMOD_ChannelGroup_Release", error)),
7410 }
7411 }
7412 }
7413 pub fn add_group(
7414 &self,
7415 group: ChannelGroup,
7416 propagatedspclock: bool,
7417 ) -> Result<DspConnection, Error> {
7418 unsafe {
7419 let mut connection = null_mut();
7420 match ffi::FMOD_ChannelGroup_AddGroup(
7421 self.pointer,
7422 group.as_mut_ptr(),
7423 from_bool!(propagatedspclock),
7424 &mut connection,
7425 ) {
7426 ffi::FMOD_OK => Ok(DspConnection::from(connection)),
7427 error => Err(err_fmod!("FMOD_ChannelGroup_AddGroup", error)),
7428 }
7429 }
7430 }
7431 pub fn get_num_groups(&self) -> Result<i32, Error> {
7432 unsafe {
7433 let mut numgroups = i32::default();
7434 match ffi::FMOD_ChannelGroup_GetNumGroups(self.pointer, &mut numgroups) {
7435 ffi::FMOD_OK => Ok(numgroups),
7436 error => Err(err_fmod!("FMOD_ChannelGroup_GetNumGroups", error)),
7437 }
7438 }
7439 }
7440 pub fn get_group(&self, index: i32) -> Result<ChannelGroup, Error> {
7441 unsafe {
7442 let mut group = null_mut();
7443 match ffi::FMOD_ChannelGroup_GetGroup(self.pointer, index, &mut group) {
7444 ffi::FMOD_OK => Ok(ChannelGroup::from(group)),
7445 error => Err(err_fmod!("FMOD_ChannelGroup_GetGroup", error)),
7446 }
7447 }
7448 }
7449 pub fn get_parent_group(&self) -> Result<ChannelGroup, Error> {
7450 unsafe {
7451 let mut group = null_mut();
7452 match ffi::FMOD_ChannelGroup_GetParentGroup(self.pointer, &mut group) {
7453 ffi::FMOD_OK => Ok(ChannelGroup::from(group)),
7454 error => Err(err_fmod!("FMOD_ChannelGroup_GetParentGroup", error)),
7455 }
7456 }
7457 }
7458 pub fn get_name(&self, namelen: i32) -> Result<String, Error> {
7459 unsafe {
7460 let name = string_buffer!(namelen);
7461 match ffi::FMOD_ChannelGroup_GetName(self.pointer, name, namelen) {
7462 ffi::FMOD_OK => Ok(to_string!(name)?),
7463 error => Err(err_fmod!("FMOD_ChannelGroup_GetName", error)),
7464 }
7465 }
7466 }
7467 pub fn get_num_channels(&self) -> Result<i32, Error> {
7468 unsafe {
7469 let mut numchannels = i32::default();
7470 match ffi::FMOD_ChannelGroup_GetNumChannels(self.pointer, &mut numchannels) {
7471 ffi::FMOD_OK => Ok(numchannels),
7472 error => Err(err_fmod!("FMOD_ChannelGroup_GetNumChannels", error)),
7473 }
7474 }
7475 }
7476 pub fn get_channel(&self, index: i32) -> Result<Channel, Error> {
7477 unsafe {
7478 let mut channel = null_mut();
7479 match ffi::FMOD_ChannelGroup_GetChannel(self.pointer, index, &mut channel) {
7480 ffi::FMOD_OK => Ok(Channel::from(channel)),
7481 error => Err(err_fmod!("FMOD_ChannelGroup_GetChannel", error)),
7482 }
7483 }
7484 }
7485}
7486#[derive(Debug, Clone, Copy)]
7487pub struct Dsp {
7488 pointer: *mut ffi::FMOD_DSP,
7489}
7490unsafe impl Send for Dsp {}
7491unsafe impl Sync for Dsp {}
7492impl Dsp {
7493 #[inline]
7494 pub fn from(pointer: *mut ffi::FMOD_DSP) -> Self {
7495 Self { pointer }
7496 }
7497 #[inline]
7498 pub fn as_mut_ptr(&self) -> *mut ffi::FMOD_DSP {
7499 self.pointer
7500 }
7501 pub fn release(&self) -> Result<(), Error> {
7502 unsafe {
7503 match ffi::FMOD_DSP_Release(self.pointer) {
7504 ffi::FMOD_OK => Ok(()),
7505 error => Err(err_fmod!("FMOD_DSP_Release", error)),
7506 }
7507 }
7508 }
7509 pub fn get_system_object(&self) -> Result<System, Error> {
7510 unsafe {
7511 let mut system = null_mut();
7512 match ffi::FMOD_DSP_GetSystemObject(self.pointer, &mut system) {
7513 ffi::FMOD_OK => Ok(System::from(system)),
7514 error => Err(err_fmod!("FMOD_DSP_GetSystemObject", error)),
7515 }
7516 }
7517 }
7518 pub fn add_input(&self, input: Dsp, type_: DspConnectionType) -> Result<DspConnection, Error> {
7519 unsafe {
7520 let mut connection = null_mut();
7521 match ffi::FMOD_DSP_AddInput(
7522 self.pointer,
7523 input.as_mut_ptr(),
7524 &mut connection,
7525 type_.into(),
7526 ) {
7527 ffi::FMOD_OK => Ok(DspConnection::from(connection)),
7528 error => Err(err_fmod!("FMOD_DSP_AddInput", error)),
7529 }
7530 }
7531 }
7532 pub fn disconnect_from(
7533 &self,
7534 target: Option<Dsp>,
7535 connection: Option<DspConnection>,
7536 ) -> Result<(), Error> {
7537 unsafe {
7538 match ffi::FMOD_DSP_DisconnectFrom(
7539 self.pointer,
7540 target.map(|value| value.as_mut_ptr()).unwrap_or(null_mut()),
7541 connection
7542 .map(|value| value.as_mut_ptr())
7543 .unwrap_or(null_mut()),
7544 ) {
7545 ffi::FMOD_OK => Ok(()),
7546 error => Err(err_fmod!("FMOD_DSP_DisconnectFrom", error)),
7547 }
7548 }
7549 }
7550 pub fn disconnect_all(&self, inputs: bool, outputs: bool) -> Result<(), Error> {
7551 unsafe {
7552 match ffi::FMOD_DSP_DisconnectAll(self.pointer, from_bool!(inputs), from_bool!(outputs))
7553 {
7554 ffi::FMOD_OK => Ok(()),
7555 error => Err(err_fmod!("FMOD_DSP_DisconnectAll", error)),
7556 }
7557 }
7558 }
7559 pub fn get_num_inputs(&self) -> Result<i32, Error> {
7560 unsafe {
7561 let mut numinputs = i32::default();
7562 match ffi::FMOD_DSP_GetNumInputs(self.pointer, &mut numinputs) {
7563 ffi::FMOD_OK => Ok(numinputs),
7564 error => Err(err_fmod!("FMOD_DSP_GetNumInputs", error)),
7565 }
7566 }
7567 }
7568 pub fn get_num_outputs(&self) -> Result<i32, Error> {
7569 unsafe {
7570 let mut numoutputs = i32::default();
7571 match ffi::FMOD_DSP_GetNumOutputs(self.pointer, &mut numoutputs) {
7572 ffi::FMOD_OK => Ok(numoutputs),
7573 error => Err(err_fmod!("FMOD_DSP_GetNumOutputs", error)),
7574 }
7575 }
7576 }
7577 pub fn get_input(&self, index: i32) -> Result<(Dsp, DspConnection), Error> {
7578 unsafe {
7579 let mut input = null_mut();
7580 let mut inputconnection = null_mut();
7581 match ffi::FMOD_DSP_GetInput(self.pointer, index, &mut input, &mut inputconnection) {
7582 ffi::FMOD_OK => Ok((Dsp::from(input), DspConnection::from(inputconnection))),
7583 error => Err(err_fmod!("FMOD_DSP_GetInput", error)),
7584 }
7585 }
7586 }
7587 pub fn get_output(&self, index: i32) -> Result<(Dsp, DspConnection), Error> {
7588 unsafe {
7589 let mut output = null_mut();
7590 let mut outputconnection = null_mut();
7591 match ffi::FMOD_DSP_GetOutput(self.pointer, index, &mut output, &mut outputconnection) {
7592 ffi::FMOD_OK => Ok((Dsp::from(output), DspConnection::from(outputconnection))),
7593 error => Err(err_fmod!("FMOD_DSP_GetOutput", error)),
7594 }
7595 }
7596 }
7597 pub fn set_active(&self, active: bool) -> Result<(), Error> {
7598 unsafe {
7599 match ffi::FMOD_DSP_SetActive(self.pointer, from_bool!(active)) {
7600 ffi::FMOD_OK => Ok(()),
7601 error => Err(err_fmod!("FMOD_DSP_SetActive", error)),
7602 }
7603 }
7604 }
7605 pub fn get_active(&self) -> Result<bool, Error> {
7606 unsafe {
7607 let mut active = ffi::FMOD_BOOL::default();
7608 match ffi::FMOD_DSP_GetActive(self.pointer, &mut active) {
7609 ffi::FMOD_OK => Ok(to_bool!(active)),
7610 error => Err(err_fmod!("FMOD_DSP_GetActive", error)),
7611 }
7612 }
7613 }
7614 pub fn set_bypass(&self, bypass: bool) -> Result<(), Error> {
7615 unsafe {
7616 match ffi::FMOD_DSP_SetBypass(self.pointer, from_bool!(bypass)) {
7617 ffi::FMOD_OK => Ok(()),
7618 error => Err(err_fmod!("FMOD_DSP_SetBypass", error)),
7619 }
7620 }
7621 }
7622 pub fn get_bypass(&self) -> Result<bool, Error> {
7623 unsafe {
7624 let mut bypass = ffi::FMOD_BOOL::default();
7625 match ffi::FMOD_DSP_GetBypass(self.pointer, &mut bypass) {
7626 ffi::FMOD_OK => Ok(to_bool!(bypass)),
7627 error => Err(err_fmod!("FMOD_DSP_GetBypass", error)),
7628 }
7629 }
7630 }
7631 pub fn set_wet_dry_mix(&self, prewet: f32, postwet: f32, dry: f32) -> Result<(), Error> {
7632 unsafe {
7633 match ffi::FMOD_DSP_SetWetDryMix(self.pointer, prewet, postwet, dry) {
7634 ffi::FMOD_OK => Ok(()),
7635 error => Err(err_fmod!("FMOD_DSP_SetWetDryMix", error)),
7636 }
7637 }
7638 }
7639 pub fn get_wet_dry_mix(&self) -> Result<(f32, f32, f32), Error> {
7640 unsafe {
7641 let mut prewet = f32::default();
7642 let mut postwet = f32::default();
7643 let mut dry = f32::default();
7644 match ffi::FMOD_DSP_GetWetDryMix(self.pointer, &mut prewet, &mut postwet, &mut dry) {
7645 ffi::FMOD_OK => Ok((prewet, postwet, dry)),
7646 error => Err(err_fmod!("FMOD_DSP_GetWetDryMix", error)),
7647 }
7648 }
7649 }
7650 pub fn set_channel_format(
7651 &self,
7652 channelmask: impl Into<ffi::FMOD_CHANNELMASK>,
7653 numchannels: i32,
7654 source_speakermode: SpeakerMode,
7655 ) -> Result<(), Error> {
7656 unsafe {
7657 match ffi::FMOD_DSP_SetChannelFormat(
7658 self.pointer,
7659 channelmask.into(),
7660 numchannels,
7661 source_speakermode.into(),
7662 ) {
7663 ffi::FMOD_OK => Ok(()),
7664 error => Err(err_fmod!("FMOD_DSP_SetChannelFormat", error)),
7665 }
7666 }
7667 }
7668 pub fn get_channel_format(&self) -> Result<(ffi::FMOD_CHANNELMASK, i32, SpeakerMode), Error> {
7669 unsafe {
7670 let mut channelmask = ffi::FMOD_CHANNELMASK::default();
7671 let mut numchannels = i32::default();
7672 let mut source_speakermode = ffi::FMOD_SPEAKERMODE::default();
7673 match ffi::FMOD_DSP_GetChannelFormat(
7674 self.pointer,
7675 &mut channelmask,
7676 &mut numchannels,
7677 &mut source_speakermode,
7678 ) {
7679 ffi::FMOD_OK => Ok((
7680 channelmask,
7681 numchannels,
7682 SpeakerMode::from(source_speakermode)?,
7683 )),
7684 error => Err(err_fmod!("FMOD_DSP_GetChannelFormat", error)),
7685 }
7686 }
7687 }
7688 pub fn get_output_channel_format(
7689 &self,
7690 inmask: impl Into<ffi::FMOD_CHANNELMASK>,
7691 inchannels: i32,
7692 inspeakermode: SpeakerMode,
7693 ) -> Result<(ffi::FMOD_CHANNELMASK, i32, SpeakerMode), Error> {
7694 unsafe {
7695 let mut outmask = ffi::FMOD_CHANNELMASK::default();
7696 let mut outchannels = i32::default();
7697 let mut outspeakermode = ffi::FMOD_SPEAKERMODE::default();
7698 match ffi::FMOD_DSP_GetOutputChannelFormat(
7699 self.pointer,
7700 inmask.into(),
7701 inchannels,
7702 inspeakermode.into(),
7703 &mut outmask,
7704 &mut outchannels,
7705 &mut outspeakermode,
7706 ) {
7707 ffi::FMOD_OK => Ok((outmask, outchannels, SpeakerMode::from(outspeakermode)?)),
7708 error => Err(err_fmod!("FMOD_DSP_GetOutputChannelFormat", error)),
7709 }
7710 }
7711 }
7712 pub fn reset(&self) -> Result<(), Error> {
7713 unsafe {
7714 match ffi::FMOD_DSP_Reset(self.pointer) {
7715 ffi::FMOD_OK => Ok(()),
7716 error => Err(err_fmod!("FMOD_DSP_Reset", error)),
7717 }
7718 }
7719 }
7720 pub fn set_callback(&self, callback: ffi::FMOD_DSP_CALLBACK) -> Result<(), Error> {
7721 unsafe {
7722 match ffi::FMOD_DSP_SetCallback(self.pointer, callback) {
7723 ffi::FMOD_OK => Ok(()),
7724 error => Err(err_fmod!("FMOD_DSP_SetCallback", error)),
7725 }
7726 }
7727 }
7728 pub fn set_parameter_float(&self, index: i32, value: f32) -> Result<(), Error> {
7729 unsafe {
7730 match ffi::FMOD_DSP_SetParameterFloat(self.pointer, index, value) {
7731 ffi::FMOD_OK => Ok(()),
7732 error => Err(err_fmod!("FMOD_DSP_SetParameterFloat", error)),
7733 }
7734 }
7735 }
7736 pub fn set_parameter_int(&self, index: i32, value: i32) -> Result<(), Error> {
7737 unsafe {
7738 match ffi::FMOD_DSP_SetParameterInt(self.pointer, index, value) {
7739 ffi::FMOD_OK => Ok(()),
7740 error => Err(err_fmod!("FMOD_DSP_SetParameterInt", error)),
7741 }
7742 }
7743 }
7744 pub fn set_parameter_bool(&self, index: i32, value: bool) -> Result<(), Error> {
7745 unsafe {
7746 match ffi::FMOD_DSP_SetParameterBool(self.pointer, index, from_bool!(value)) {
7747 ffi::FMOD_OK => Ok(()),
7748 error => Err(err_fmod!("FMOD_DSP_SetParameterBool", error)),
7749 }
7750 }
7751 }
7752 pub fn set_parameter_data(
7753 &self,
7754 index: i32,
7755 data: *mut c_void,
7756 length: u32,
7757 ) -> Result<(), Error> {
7758 unsafe {
7759 match ffi::FMOD_DSP_SetParameterData(self.pointer, index, data, length) {
7760 ffi::FMOD_OK => Ok(()),
7761 error => Err(err_fmod!("FMOD_DSP_SetParameterData", error)),
7762 }
7763 }
7764 }
7765 pub fn get_parameter_float(
7766 &self,
7767 index: i32,
7768 valuestrlen: i32,
7769 ) -> Result<(f32, String), Error> {
7770 unsafe {
7771 let mut value = f32::default();
7772 let valuestr = string_buffer!(valuestrlen);
7773 match ffi::FMOD_DSP_GetParameterFloat(
7774 self.pointer,
7775 index,
7776 &mut value,
7777 valuestr,
7778 valuestrlen,
7779 ) {
7780 ffi::FMOD_OK => Ok((value, to_string!(valuestr)?)),
7781 error => Err(err_fmod!("FMOD_DSP_GetParameterFloat", error)),
7782 }
7783 }
7784 }
7785 pub fn get_parameter_int(&self, index: i32, valuestrlen: i32) -> Result<(i32, String), Error> {
7786 unsafe {
7787 let mut value = i32::default();
7788 let valuestr = string_buffer!(valuestrlen);
7789 match ffi::FMOD_DSP_GetParameterInt(
7790 self.pointer,
7791 index,
7792 &mut value,
7793 valuestr,
7794 valuestrlen,
7795 ) {
7796 ffi::FMOD_OK => Ok((value, to_string!(valuestr)?)),
7797 error => Err(err_fmod!("FMOD_DSP_GetParameterInt", error)),
7798 }
7799 }
7800 }
7801 pub fn get_parameter_bool(
7802 &self,
7803 index: i32,
7804 valuestrlen: i32,
7805 ) -> Result<(bool, String), Error> {
7806 unsafe {
7807 let mut value = ffi::FMOD_BOOL::default();
7808 let valuestr = string_buffer!(valuestrlen);
7809 match ffi::FMOD_DSP_GetParameterBool(
7810 self.pointer,
7811 index,
7812 &mut value,
7813 valuestr,
7814 valuestrlen,
7815 ) {
7816 ffi::FMOD_OK => Ok((to_bool!(value), to_string!(valuestr)?)),
7817 error => Err(err_fmod!("FMOD_DSP_GetParameterBool", error)),
7818 }
7819 }
7820 }
7821 pub fn get_parameter_data(
7822 &self,
7823 index: i32,
7824 valuestrlen: i32,
7825 ) -> Result<(*mut c_void, u32, String), Error> {
7826 unsafe {
7827 let mut data = null_mut();
7828 let mut length = u32::default();
7829 let valuestr = string_buffer!(valuestrlen);
7830 match ffi::FMOD_DSP_GetParameterData(
7831 self.pointer,
7832 index,
7833 &mut data,
7834 &mut length,
7835 valuestr,
7836 valuestrlen,
7837 ) {
7838 ffi::FMOD_OK => Ok((data, length, to_string!(valuestr)?)),
7839 error => Err(err_fmod!("FMOD_DSP_GetParameterData", error)),
7840 }
7841 }
7842 }
7843 pub fn get_num_parameters(&self) -> Result<i32, Error> {
7844 unsafe {
7845 let mut numparams = i32::default();
7846 match ffi::FMOD_DSP_GetNumParameters(self.pointer, &mut numparams) {
7847 ffi::FMOD_OK => Ok(numparams),
7848 error => Err(err_fmod!("FMOD_DSP_GetNumParameters", error)),
7849 }
7850 }
7851 }
7852 pub fn get_parameter_info(&self, index: i32) -> Result<DspParameterDesc, Error> {
7853 unsafe {
7854 let mut desc = null_mut();
7855 match ffi::FMOD_DSP_GetParameterInfo(self.pointer, index, &mut desc) {
7856 ffi::FMOD_OK => Ok(DspParameterDesc::try_from(*desc)?),
7857 error => Err(err_fmod!("FMOD_DSP_GetParameterInfo", error)),
7858 }
7859 }
7860 }
7861 pub fn get_data_parameter_index(&self, datatype: i32) -> Result<i32, Error> {
7862 unsafe {
7863 let mut index = i32::default();
7864 match ffi::FMOD_DSP_GetDataParameterIndex(self.pointer, datatype, &mut index) {
7865 ffi::FMOD_OK => Ok(index),
7866 error => Err(err_fmod!("FMOD_DSP_GetDataParameterIndex", error)),
7867 }
7868 }
7869 }
7870 pub fn show_config_dialog(&self, hwnd: *mut c_void, show: bool) -> Result<(), Error> {
7871 unsafe {
7872 match ffi::FMOD_DSP_ShowConfigDialog(self.pointer, hwnd, from_bool!(show)) {
7873 ffi::FMOD_OK => Ok(()),
7874 error => Err(err_fmod!("FMOD_DSP_ShowConfigDialog", error)),
7875 }
7876 }
7877 }
7878 pub fn get_info(&self) -> Result<(String, u32, i32, i32, i32), Error> {
7879 unsafe {
7880 let name = string_buffer!(32);
7881 let mut version = u32::default();
7882 let mut channels = i32::default();
7883 let mut configwidth = i32::default();
7884 let mut configheight = i32::default();
7885 match ffi::FMOD_DSP_GetInfo(
7886 self.pointer,
7887 name,
7888 &mut version,
7889 &mut channels,
7890 &mut configwidth,
7891 &mut configheight,
7892 ) {
7893 ffi::FMOD_OK => Ok((
7894 to_string!(name)?,
7895 version,
7896 channels,
7897 configwidth,
7898 configheight,
7899 )),
7900 error => Err(err_fmod!("FMOD_DSP_GetInfo", error)),
7901 }
7902 }
7903 }
7904 pub fn get_type(&self) -> Result<DspType, Error> {
7905 unsafe {
7906 let mut type_ = ffi::FMOD_DSP_TYPE::default();
7907 match ffi::FMOD_DSP_GetType(self.pointer, &mut type_) {
7908 ffi::FMOD_OK => Ok(DspType::from(type_)?),
7909 error => Err(err_fmod!("FMOD_DSP_GetType", error)),
7910 }
7911 }
7912 }
7913 pub fn get_idle(&self) -> Result<bool, Error> {
7914 unsafe {
7915 let mut idle = ffi::FMOD_BOOL::default();
7916 match ffi::FMOD_DSP_GetIdle(self.pointer, &mut idle) {
7917 ffi::FMOD_OK => Ok(to_bool!(idle)),
7918 error => Err(err_fmod!("FMOD_DSP_GetIdle", error)),
7919 }
7920 }
7921 }
7922 pub fn set_user_data(&self, userdata: *mut c_void) -> Result<(), Error> {
7923 unsafe {
7924 match ffi::FMOD_DSP_SetUserData(self.pointer, userdata) {
7925 ffi::FMOD_OK => Ok(()),
7926 error => Err(err_fmod!("FMOD_DSP_SetUserData", error)),
7927 }
7928 }
7929 }
7930 pub fn get_user_data(&self) -> Result<*mut c_void, Error> {
7931 unsafe {
7932 let mut userdata = null_mut();
7933 match ffi::FMOD_DSP_GetUserData(self.pointer, &mut userdata) {
7934 ffi::FMOD_OK => Ok(userdata),
7935 error => Err(err_fmod!("FMOD_DSP_GetUserData", error)),
7936 }
7937 }
7938 }
7939 pub fn set_metering_enabled(
7940 &self,
7941 input_enabled: bool,
7942 output_enabled: bool,
7943 ) -> Result<(), Error> {
7944 unsafe {
7945 match ffi::FMOD_DSP_SetMeteringEnabled(
7946 self.pointer,
7947 from_bool!(input_enabled),
7948 from_bool!(output_enabled),
7949 ) {
7950 ffi::FMOD_OK => Ok(()),
7951 error => Err(err_fmod!("FMOD_DSP_SetMeteringEnabled", error)),
7952 }
7953 }
7954 }
7955 pub fn get_metering_enabled(&self) -> Result<(bool, bool), Error> {
7956 unsafe {
7957 let mut input_enabled = ffi::FMOD_BOOL::default();
7958 let mut output_enabled = ffi::FMOD_BOOL::default();
7959 match ffi::FMOD_DSP_GetMeteringEnabled(
7960 self.pointer,
7961 &mut input_enabled,
7962 &mut output_enabled,
7963 ) {
7964 ffi::FMOD_OK => Ok((to_bool!(input_enabled), to_bool!(output_enabled))),
7965 error => Err(err_fmod!("FMOD_DSP_GetMeteringEnabled", error)),
7966 }
7967 }
7968 }
7969 pub fn get_metering_info(&self) -> Result<(DspMeteringInfo, DspMeteringInfo), Error> {
7970 unsafe {
7971 let mut input_info = ffi::FMOD_DSP_METERING_INFO::default();
7972 let mut output_info = ffi::FMOD_DSP_METERING_INFO::default();
7973 match ffi::FMOD_DSP_GetMeteringInfo(self.pointer, &mut input_info, &mut output_info) {
7974 ffi::FMOD_OK => Ok((
7975 DspMeteringInfo::try_from(input_info)?,
7976 DspMeteringInfo::try_from(output_info)?,
7977 )),
7978 error => Err(err_fmod!("FMOD_DSP_GetMeteringInfo", error)),
7979 }
7980 }
7981 }
7982 pub fn get_cpu_usage(&self) -> Result<(u32, u32), Error> {
7983 unsafe {
7984 let mut exclusive = u32::default();
7985 let mut inclusive = u32::default();
7986 match ffi::FMOD_DSP_GetCPUUsage(self.pointer, &mut exclusive, &mut inclusive) {
7987 ffi::FMOD_OK => Ok((exclusive, inclusive)),
7988 error => Err(err_fmod!("FMOD_DSP_GetCPUUsage", error)),
7989 }
7990 }
7991 }
7992}
7993#[derive(Debug, Clone, Copy)]
7994pub struct DspConnection {
7995 pointer: *mut ffi::FMOD_DSPCONNECTION,
7996}
7997unsafe impl Send for DspConnection {}
7998unsafe impl Sync for DspConnection {}
7999impl DspConnection {
8000 #[inline]
8001 pub fn from(pointer: *mut ffi::FMOD_DSPCONNECTION) -> Self {
8002 Self { pointer }
8003 }
8004 #[inline]
8005 pub fn as_mut_ptr(&self) -> *mut ffi::FMOD_DSPCONNECTION {
8006 self.pointer
8007 }
8008 pub fn get_input(&self) -> Result<Dsp, Error> {
8009 unsafe {
8010 let mut input = null_mut();
8011 match ffi::FMOD_DSPConnection_GetInput(self.pointer, &mut input) {
8012 ffi::FMOD_OK => Ok(Dsp::from(input)),
8013 error => Err(err_fmod!("FMOD_DSPConnection_GetInput", error)),
8014 }
8015 }
8016 }
8017 pub fn get_output(&self) -> Result<Dsp, Error> {
8018 unsafe {
8019 let mut output = null_mut();
8020 match ffi::FMOD_DSPConnection_GetOutput(self.pointer, &mut output) {
8021 ffi::FMOD_OK => Ok(Dsp::from(output)),
8022 error => Err(err_fmod!("FMOD_DSPConnection_GetOutput", error)),
8023 }
8024 }
8025 }
8026 pub fn set_mix(&self, volume: f32) -> Result<(), Error> {
8027 unsafe {
8028 match ffi::FMOD_DSPConnection_SetMix(self.pointer, volume) {
8029 ffi::FMOD_OK => Ok(()),
8030 error => Err(err_fmod!("FMOD_DSPConnection_SetMix", error)),
8031 }
8032 }
8033 }
8034 pub fn get_mix(&self) -> Result<f32, Error> {
8035 unsafe {
8036 let mut volume = f32::default();
8037 match ffi::FMOD_DSPConnection_GetMix(self.pointer, &mut volume) {
8038 ffi::FMOD_OK => Ok(volume),
8039 error => Err(err_fmod!("FMOD_DSPConnection_GetMix", error)),
8040 }
8041 }
8042 }
8043 pub fn set_mix_matrix(
8044 &self,
8045 matrix: Option<*mut f32>,
8046 outchannels: i32,
8047 inchannels: i32,
8048 inchannel_hop: Option<i32>,
8049 ) -> Result<(), Error> {
8050 unsafe {
8051 match ffi::FMOD_DSPConnection_SetMixMatrix(
8052 self.pointer,
8053 matrix.unwrap_or(null_mut()),
8054 outchannels,
8055 inchannels,
8056 inchannel_hop.unwrap_or(0),
8057 ) {
8058 ffi::FMOD_OK => Ok(()),
8059 error => Err(err_fmod!("FMOD_DSPConnection_SetMixMatrix", error)),
8060 }
8061 }
8062 }
8063 pub fn get_mix_matrix(&self, inchannel_hop: Option<i32>) -> Result<(f32, i32, i32), Error> {
8064 unsafe {
8065 let mut matrix = f32::default();
8066 let mut outchannels = i32::default();
8067 let mut inchannels = i32::default();
8068 match ffi::FMOD_DSPConnection_GetMixMatrix(
8069 self.pointer,
8070 &mut matrix,
8071 &mut outchannels,
8072 &mut inchannels,
8073 inchannel_hop.unwrap_or(0),
8074 ) {
8075 ffi::FMOD_OK => Ok((matrix, outchannels, inchannels)),
8076 error => Err(err_fmod!("FMOD_DSPConnection_GetMixMatrix", error)),
8077 }
8078 }
8079 }
8080 pub fn get_type(&self) -> Result<DspConnectionType, Error> {
8081 unsafe {
8082 let mut type_ = ffi::FMOD_DSPCONNECTION_TYPE::default();
8083 match ffi::FMOD_DSPConnection_GetType(self.pointer, &mut type_) {
8084 ffi::FMOD_OK => Ok(DspConnectionType::from(type_)?),
8085 error => Err(err_fmod!("FMOD_DSPConnection_GetType", error)),
8086 }
8087 }
8088 }
8089 pub fn set_user_data(&self, userdata: *mut c_void) -> Result<(), Error> {
8090 unsafe {
8091 match ffi::FMOD_DSPConnection_SetUserData(self.pointer, userdata) {
8092 ffi::FMOD_OK => Ok(()),
8093 error => Err(err_fmod!("FMOD_DSPConnection_SetUserData", error)),
8094 }
8095 }
8096 }
8097 pub fn get_user_data(&self) -> Result<*mut c_void, Error> {
8098 unsafe {
8099 let mut userdata = null_mut();
8100 match ffi::FMOD_DSPConnection_GetUserData(self.pointer, &mut userdata) {
8101 ffi::FMOD_OK => Ok(userdata),
8102 error => Err(err_fmod!("FMOD_DSPConnection_GetUserData", error)),
8103 }
8104 }
8105 }
8106}
8107#[derive(Debug, Clone, Copy)]
8108pub struct Geometry {
8109 pointer: *mut ffi::FMOD_GEOMETRY,
8110}
8111unsafe impl Send for Geometry {}
8112unsafe impl Sync for Geometry {}
8113impl Geometry {
8114 #[inline]
8115 pub fn from(pointer: *mut ffi::FMOD_GEOMETRY) -> Self {
8116 Self { pointer }
8117 }
8118 #[inline]
8119 pub fn as_mut_ptr(&self) -> *mut ffi::FMOD_GEOMETRY {
8120 self.pointer
8121 }
8122 pub fn release(&self) -> Result<(), Error> {
8123 unsafe {
8124 match ffi::FMOD_Geometry_Release(self.pointer) {
8125 ffi::FMOD_OK => Ok(()),
8126 error => Err(err_fmod!("FMOD_Geometry_Release", error)),
8127 }
8128 }
8129 }
8130 pub fn add_polygon(
8131 &self,
8132 directocclusion: f32,
8133 reverbocclusion: f32,
8134 doublesided: bool,
8135 numvertices: i32,
8136 vertices: Vector,
8137 ) -> Result<i32, Error> {
8138 unsafe {
8139 let mut polygonindex = i32::default();
8140 match ffi::FMOD_Geometry_AddPolygon(
8141 self.pointer,
8142 directocclusion,
8143 reverbocclusion,
8144 from_bool!(doublesided),
8145 numvertices,
8146 &vertices.into(),
8147 &mut polygonindex,
8148 ) {
8149 ffi::FMOD_OK => Ok(polygonindex),
8150 error => Err(err_fmod!("FMOD_Geometry_AddPolygon", error)),
8151 }
8152 }
8153 }
8154 pub fn get_num_polygons(&self) -> Result<i32, Error> {
8155 unsafe {
8156 let mut numpolygons = i32::default();
8157 match ffi::FMOD_Geometry_GetNumPolygons(self.pointer, &mut numpolygons) {
8158 ffi::FMOD_OK => Ok(numpolygons),
8159 error => Err(err_fmod!("FMOD_Geometry_GetNumPolygons", error)),
8160 }
8161 }
8162 }
8163 pub fn get_max_polygons(&self) -> Result<(i32, i32), Error> {
8164 unsafe {
8165 let mut maxpolygons = i32::default();
8166 let mut maxvertices = i32::default();
8167 match ffi::FMOD_Geometry_GetMaxPolygons(
8168 self.pointer,
8169 &mut maxpolygons,
8170 &mut maxvertices,
8171 ) {
8172 ffi::FMOD_OK => Ok((maxpolygons, maxvertices)),
8173 error => Err(err_fmod!("FMOD_Geometry_GetMaxPolygons", error)),
8174 }
8175 }
8176 }
8177 pub fn get_polygon_num_vertices(&self, index: i32) -> Result<i32, Error> {
8178 unsafe {
8179 let mut numvertices = i32::default();
8180 match ffi::FMOD_Geometry_GetPolygonNumVertices(self.pointer, index, &mut numvertices) {
8181 ffi::FMOD_OK => Ok(numvertices),
8182 error => Err(err_fmod!("FMOD_Geometry_GetPolygonNumVertices", error)),
8183 }
8184 }
8185 }
8186 pub fn set_polygon_vertex(
8187 &self,
8188 index: i32,
8189 vertexindex: i32,
8190 vertex: Vector,
8191 ) -> Result<(), Error> {
8192 unsafe {
8193 match ffi::FMOD_Geometry_SetPolygonVertex(
8194 self.pointer,
8195 index,
8196 vertexindex,
8197 &vertex.into(),
8198 ) {
8199 ffi::FMOD_OK => Ok(()),
8200 error => Err(err_fmod!("FMOD_Geometry_SetPolygonVertex", error)),
8201 }
8202 }
8203 }
8204 pub fn get_polygon_vertex(&self, index: i32, vertexindex: i32) -> Result<Vector, Error> {
8205 unsafe {
8206 let mut vertex = ffi::FMOD_VECTOR::default();
8207 match ffi::FMOD_Geometry_GetPolygonVertex(self.pointer, index, vertexindex, &mut vertex)
8208 {
8209 ffi::FMOD_OK => Ok(Vector::try_from(vertex)?),
8210 error => Err(err_fmod!("FMOD_Geometry_GetPolygonVertex", error)),
8211 }
8212 }
8213 }
8214 pub fn set_polygon_attributes(
8215 &self,
8216 index: i32,
8217 directocclusion: f32,
8218 reverbocclusion: f32,
8219 doublesided: bool,
8220 ) -> Result<(), Error> {
8221 unsafe {
8222 match ffi::FMOD_Geometry_SetPolygonAttributes(
8223 self.pointer,
8224 index,
8225 directocclusion,
8226 reverbocclusion,
8227 from_bool!(doublesided),
8228 ) {
8229 ffi::FMOD_OK => Ok(()),
8230 error => Err(err_fmod!("FMOD_Geometry_SetPolygonAttributes", error)),
8231 }
8232 }
8233 }
8234 pub fn get_polygon_attributes(&self, index: i32) -> Result<(f32, f32, bool), Error> {
8235 unsafe {
8236 let mut directocclusion = f32::default();
8237 let mut reverbocclusion = f32::default();
8238 let mut doublesided = ffi::FMOD_BOOL::default();
8239 match ffi::FMOD_Geometry_GetPolygonAttributes(
8240 self.pointer,
8241 index,
8242 &mut directocclusion,
8243 &mut reverbocclusion,
8244 &mut doublesided,
8245 ) {
8246 ffi::FMOD_OK => Ok((directocclusion, reverbocclusion, to_bool!(doublesided))),
8247 error => Err(err_fmod!("FMOD_Geometry_GetPolygonAttributes", error)),
8248 }
8249 }
8250 }
8251 pub fn set_active(&self, active: bool) -> Result<(), Error> {
8252 unsafe {
8253 match ffi::FMOD_Geometry_SetActive(self.pointer, from_bool!(active)) {
8254 ffi::FMOD_OK => Ok(()),
8255 error => Err(err_fmod!("FMOD_Geometry_SetActive", error)),
8256 }
8257 }
8258 }
8259 pub fn get_active(&self) -> Result<bool, Error> {
8260 unsafe {
8261 let mut active = ffi::FMOD_BOOL::default();
8262 match ffi::FMOD_Geometry_GetActive(self.pointer, &mut active) {
8263 ffi::FMOD_OK => Ok(to_bool!(active)),
8264 error => Err(err_fmod!("FMOD_Geometry_GetActive", error)),
8265 }
8266 }
8267 }
8268 pub fn set_rotation(&self, forward: Option<Vector>, up: Option<Vector>) -> Result<(), Error> {
8269 unsafe {
8270 match ffi::FMOD_Geometry_SetRotation(
8271 self.pointer,
8272 forward
8273 .map(Vector::into)
8274 .as_ref()
8275 .map(from_ref)
8276 .unwrap_or_else(null),
8277 up.map(Vector::into)
8278 .as_ref()
8279 .map(from_ref)
8280 .unwrap_or_else(null),
8281 ) {
8282 ffi::FMOD_OK => Ok(()),
8283 error => Err(err_fmod!("FMOD_Geometry_SetRotation", error)),
8284 }
8285 }
8286 }
8287 pub fn get_rotation(&self) -> Result<(Vector, Vector), Error> {
8288 unsafe {
8289 let mut forward = ffi::FMOD_VECTOR::default();
8290 let mut up = ffi::FMOD_VECTOR::default();
8291 match ffi::FMOD_Geometry_GetRotation(self.pointer, &mut forward, &mut up) {
8292 ffi::FMOD_OK => Ok((Vector::try_from(forward)?, Vector::try_from(up)?)),
8293 error => Err(err_fmod!("FMOD_Geometry_GetRotation", error)),
8294 }
8295 }
8296 }
8297 pub fn set_position(&self, position: Vector) -> Result<(), Error> {
8298 unsafe {
8299 match ffi::FMOD_Geometry_SetPosition(self.pointer, &position.into()) {
8300 ffi::FMOD_OK => Ok(()),
8301 error => Err(err_fmod!("FMOD_Geometry_SetPosition", error)),
8302 }
8303 }
8304 }
8305 pub fn get_position(&self) -> Result<Vector, Error> {
8306 unsafe {
8307 let mut position = ffi::FMOD_VECTOR::default();
8308 match ffi::FMOD_Geometry_GetPosition(self.pointer, &mut position) {
8309 ffi::FMOD_OK => Ok(Vector::try_from(position)?),
8310 error => Err(err_fmod!("FMOD_Geometry_GetPosition", error)),
8311 }
8312 }
8313 }
8314 pub fn set_scale(&self, scale: Vector) -> Result<(), Error> {
8315 unsafe {
8316 match ffi::FMOD_Geometry_SetScale(self.pointer, &scale.into()) {
8317 ffi::FMOD_OK => Ok(()),
8318 error => Err(err_fmod!("FMOD_Geometry_SetScale", error)),
8319 }
8320 }
8321 }
8322 pub fn get_scale(&self) -> Result<Vector, Error> {
8323 unsafe {
8324 let mut scale = ffi::FMOD_VECTOR::default();
8325 match ffi::FMOD_Geometry_GetScale(self.pointer, &mut scale) {
8326 ffi::FMOD_OK => Ok(Vector::try_from(scale)?),
8327 error => Err(err_fmod!("FMOD_Geometry_GetScale", error)),
8328 }
8329 }
8330 }
8331 pub fn save(&self) -> Result<(*mut c_void, i32), Error> {
8332 unsafe {
8333 let data = null_mut();
8334 let mut datasize = i32::default();
8335 match ffi::FMOD_Geometry_Save(self.pointer, data, &mut datasize) {
8336 ffi::FMOD_OK => Ok((data, datasize)),
8337 error => Err(err_fmod!("FMOD_Geometry_Save", error)),
8338 }
8339 }
8340 }
8341 pub fn set_user_data(&self, userdata: *mut c_void) -> Result<(), Error> {
8342 unsafe {
8343 match ffi::FMOD_Geometry_SetUserData(self.pointer, userdata) {
8344 ffi::FMOD_OK => Ok(()),
8345 error => Err(err_fmod!("FMOD_Geometry_SetUserData", error)),
8346 }
8347 }
8348 }
8349 pub fn get_user_data(&self) -> Result<*mut c_void, Error> {
8350 unsafe {
8351 let mut userdata = null_mut();
8352 match ffi::FMOD_Geometry_GetUserData(self.pointer, &mut userdata) {
8353 ffi::FMOD_OK => Ok(userdata),
8354 error => Err(err_fmod!("FMOD_Geometry_GetUserData", error)),
8355 }
8356 }
8357 }
8358}
8359#[derive(Debug, Clone, Copy)]
8360pub struct Polygon {
8361 pointer: *mut ffi::FMOD_POLYGON,
8362}
8363unsafe impl Send for Polygon {}
8364unsafe impl Sync for Polygon {}
8365impl Polygon {
8366 #[inline]
8367 pub fn from(pointer: *mut ffi::FMOD_POLYGON) -> Self {
8368 Self { pointer }
8369 }
8370 #[inline]
8371 pub fn as_mut_ptr(&self) -> *mut ffi::FMOD_POLYGON {
8372 self.pointer
8373 }
8374}
8375#[derive(Debug, Clone, Copy)]
8376pub struct Reverb3d {
8377 pointer: *mut ffi::FMOD_REVERB3D,
8378}
8379unsafe impl Send for Reverb3d {}
8380unsafe impl Sync for Reverb3d {}
8381impl Reverb3d {
8382 #[inline]
8383 pub fn from(pointer: *mut ffi::FMOD_REVERB3D) -> Self {
8384 Self { pointer }
8385 }
8386 #[inline]
8387 pub fn as_mut_ptr(&self) -> *mut ffi::FMOD_REVERB3D {
8388 self.pointer
8389 }
8390 pub fn release(&self) -> Result<(), Error> {
8391 unsafe {
8392 match ffi::FMOD_Reverb3D_Release(self.pointer) {
8393 ffi::FMOD_OK => Ok(()),
8394 error => Err(err_fmod!("FMOD_Reverb3D_Release", error)),
8395 }
8396 }
8397 }
8398 pub fn set_3d_attributes(
8399 &self,
8400 position: Option<Vector>,
8401 mindistance: f32,
8402 maxdistance: f32,
8403 ) -> Result<(), Error> {
8404 unsafe {
8405 match ffi::FMOD_Reverb3D_Set3DAttributes(
8406 self.pointer,
8407 position
8408 .map(Vector::into)
8409 .as_ref()
8410 .map(from_ref)
8411 .unwrap_or_else(null),
8412 mindistance,
8413 maxdistance,
8414 ) {
8415 ffi::FMOD_OK => Ok(()),
8416 error => Err(err_fmod!("FMOD_Reverb3D_Set3DAttributes", error)),
8417 }
8418 }
8419 }
8420 pub fn get_3d_attributes(&self) -> Result<(Vector, f32, f32), Error> {
8421 unsafe {
8422 let mut position = ffi::FMOD_VECTOR::default();
8423 let mut mindistance = f32::default();
8424 let mut maxdistance = f32::default();
8425 match ffi::FMOD_Reverb3D_Get3DAttributes(
8426 self.pointer,
8427 &mut position,
8428 &mut mindistance,
8429 &mut maxdistance,
8430 ) {
8431 ffi::FMOD_OK => Ok((Vector::try_from(position)?, mindistance, maxdistance)),
8432 error => Err(err_fmod!("FMOD_Reverb3D_Get3DAttributes", error)),
8433 }
8434 }
8435 }
8436 pub fn set_properties(&self, properties: ReverbProperties) -> Result<(), Error> {
8437 unsafe {
8438 match ffi::FMOD_Reverb3D_SetProperties(self.pointer, &properties.into()) {
8439 ffi::FMOD_OK => Ok(()),
8440 error => Err(err_fmod!("FMOD_Reverb3D_SetProperties", error)),
8441 }
8442 }
8443 }
8444 pub fn get_properties(&self) -> Result<ReverbProperties, Error> {
8445 unsafe {
8446 let mut properties = ffi::FMOD_REVERB_PROPERTIES::default();
8447 match ffi::FMOD_Reverb3D_GetProperties(self.pointer, &mut properties) {
8448 ffi::FMOD_OK => Ok(ReverbProperties::try_from(properties)?),
8449 error => Err(err_fmod!("FMOD_Reverb3D_GetProperties", error)),
8450 }
8451 }
8452 }
8453 pub fn set_active(&self, active: bool) -> Result<(), Error> {
8454 unsafe {
8455 match ffi::FMOD_Reverb3D_SetActive(self.pointer, from_bool!(active)) {
8456 ffi::FMOD_OK => Ok(()),
8457 error => Err(err_fmod!("FMOD_Reverb3D_SetActive", error)),
8458 }
8459 }
8460 }
8461 pub fn get_active(&self) -> Result<bool, Error> {
8462 unsafe {
8463 let mut active = ffi::FMOD_BOOL::default();
8464 match ffi::FMOD_Reverb3D_GetActive(self.pointer, &mut active) {
8465 ffi::FMOD_OK => Ok(to_bool!(active)),
8466 error => Err(err_fmod!("FMOD_Reverb3D_GetActive", error)),
8467 }
8468 }
8469 }
8470 pub fn set_user_data(&self, userdata: *mut c_void) -> Result<(), Error> {
8471 unsafe {
8472 match ffi::FMOD_Reverb3D_SetUserData(self.pointer, userdata) {
8473 ffi::FMOD_OK => Ok(()),
8474 error => Err(err_fmod!("FMOD_Reverb3D_SetUserData", error)),
8475 }
8476 }
8477 }
8478 pub fn get_user_data(&self) -> Result<*mut c_void, Error> {
8479 unsafe {
8480 let mut userdata = null_mut();
8481 match ffi::FMOD_Reverb3D_GetUserData(self.pointer, &mut userdata) {
8482 ffi::FMOD_OK => Ok(userdata),
8483 error => Err(err_fmod!("FMOD_Reverb3D_GetUserData", error)),
8484 }
8485 }
8486 }
8487}
8488#[derive(Debug, Clone, Copy)]
8489pub struct Sound {
8490 pointer: *mut ffi::FMOD_SOUND,
8491}
8492unsafe impl Send for Sound {}
8493unsafe impl Sync for Sound {}
8494impl Sound {
8495 #[inline]
8496 pub fn from(pointer: *mut ffi::FMOD_SOUND) -> Self {
8497 Self { pointer }
8498 }
8499 #[inline]
8500 pub fn as_mut_ptr(&self) -> *mut ffi::FMOD_SOUND {
8501 self.pointer
8502 }
8503 pub fn release(&self) -> Result<(), Error> {
8504 unsafe {
8505 match ffi::FMOD_Sound_Release(self.pointer) {
8506 ffi::FMOD_OK => Ok(()),
8507 error => Err(err_fmod!("FMOD_Sound_Release", error)),
8508 }
8509 }
8510 }
8511 pub fn get_system_object(&self) -> Result<System, Error> {
8512 unsafe {
8513 let mut system = null_mut();
8514 match ffi::FMOD_Sound_GetSystemObject(self.pointer, &mut system) {
8515 ffi::FMOD_OK => Ok(System::from(system)),
8516 error => Err(err_fmod!("FMOD_Sound_GetSystemObject", error)),
8517 }
8518 }
8519 }
8520 pub fn lock(
8521 &self,
8522 offset: u32,
8523 length: u32,
8524 ) -> Result<(*mut c_void, *mut c_void, u32, u32), Error> {
8525 unsafe {
8526 let mut ptr_1 = null_mut();
8527 let mut ptr_2 = null_mut();
8528 let mut len_1 = u32::default();
8529 let mut len_2 = u32::default();
8530 match ffi::FMOD_Sound_Lock(
8531 self.pointer,
8532 offset,
8533 length,
8534 &mut ptr_1,
8535 &mut ptr_2,
8536 &mut len_1,
8537 &mut len_2,
8538 ) {
8539 ffi::FMOD_OK => Ok((ptr_1, ptr_2, len_1, len_2)),
8540 error => Err(err_fmod!("FMOD_Sound_Lock", error)),
8541 }
8542 }
8543 }
8544 pub fn unlock(
8545 &self,
8546 ptr_1: *mut c_void,
8547 ptr_2: *mut c_void,
8548 len_1: u32,
8549 len_2: u32,
8550 ) -> Result<(), Error> {
8551 unsafe {
8552 match ffi::FMOD_Sound_Unlock(self.pointer, ptr_1, ptr_2, len_1, len_2) {
8553 ffi::FMOD_OK => Ok(()),
8554 error => Err(err_fmod!("FMOD_Sound_Unlock", error)),
8555 }
8556 }
8557 }
8558 pub fn set_defaults(&self, frequency: f32, priority: i32) -> Result<(), Error> {
8559 unsafe {
8560 match ffi::FMOD_Sound_SetDefaults(self.pointer, frequency, priority) {
8561 ffi::FMOD_OK => Ok(()),
8562 error => Err(err_fmod!("FMOD_Sound_SetDefaults", error)),
8563 }
8564 }
8565 }
8566 pub fn get_defaults(&self) -> Result<(f32, i32), Error> {
8567 unsafe {
8568 let mut frequency = f32::default();
8569 let mut priority = i32::default();
8570 match ffi::FMOD_Sound_GetDefaults(self.pointer, &mut frequency, &mut priority) {
8571 ffi::FMOD_OK => Ok((frequency, priority)),
8572 error => Err(err_fmod!("FMOD_Sound_GetDefaults", error)),
8573 }
8574 }
8575 }
8576 pub fn set_3d_min_max_distance(&self, min: f32, max: f32) -> Result<(), Error> {
8577 unsafe {
8578 match ffi::FMOD_Sound_Set3DMinMaxDistance(self.pointer, min, max) {
8579 ffi::FMOD_OK => Ok(()),
8580 error => Err(err_fmod!("FMOD_Sound_Set3DMinMaxDistance", error)),
8581 }
8582 }
8583 }
8584 pub fn get_3d_min_max_distance(&self) -> Result<(f32, f32), Error> {
8585 unsafe {
8586 let mut min = f32::default();
8587 let mut max = f32::default();
8588 match ffi::FMOD_Sound_Get3DMinMaxDistance(self.pointer, &mut min, &mut max) {
8589 ffi::FMOD_OK => Ok((min, max)),
8590 error => Err(err_fmod!("FMOD_Sound_Get3DMinMaxDistance", error)),
8591 }
8592 }
8593 }
8594 pub fn set_3d_cone_settings(
8595 &self,
8596 insideconeangle: f32,
8597 outsideconeangle: f32,
8598 outsidevolume: f32,
8599 ) -> Result<(), Error> {
8600 unsafe {
8601 match ffi::FMOD_Sound_Set3DConeSettings(
8602 self.pointer,
8603 insideconeangle,
8604 outsideconeangle,
8605 outsidevolume,
8606 ) {
8607 ffi::FMOD_OK => Ok(()),
8608 error => Err(err_fmod!("FMOD_Sound_Set3DConeSettings", error)),
8609 }
8610 }
8611 }
8612 pub fn get_3d_cone_settings(&self) -> Result<(f32, f32, f32), Error> {
8613 unsafe {
8614 let mut insideconeangle = f32::default();
8615 let mut outsideconeangle = f32::default();
8616 let mut outsidevolume = f32::default();
8617 match ffi::FMOD_Sound_Get3DConeSettings(
8618 self.pointer,
8619 &mut insideconeangle,
8620 &mut outsideconeangle,
8621 &mut outsidevolume,
8622 ) {
8623 ffi::FMOD_OK => Ok((insideconeangle, outsideconeangle, outsidevolume)),
8624 error => Err(err_fmod!("FMOD_Sound_Get3DConeSettings", error)),
8625 }
8626 }
8627 }
8628 pub fn set_3d_custom_rolloff(&self, points: Vec<Vector>) -> Result<(), Error> {
8629 unsafe {
8630 let numpoints = points.len() as i32;
8631 match ffi::FMOD_Sound_Set3DCustomRolloff(
8632 self.pointer,
8633 vec_as_mut_ptr(points, |point| point.into()),
8634 numpoints,
8635 ) {
8636 ffi::FMOD_OK => Ok(()),
8637 error => Err(err_fmod!("FMOD_Sound_Set3DCustomRolloff", error)),
8638 }
8639 }
8640 }
8641 pub fn get_3d_custom_rolloff(&self) -> Result<Vec<Vector>, Error> {
8642 unsafe {
8643 let mut points = null_mut();
8644 let mut numpoints = i32::default();
8645 match ffi::FMOD_Sound_Get3DCustomRolloff(self.pointer, &mut points, &mut numpoints) {
8646 ffi::FMOD_OK => Ok(to_vec!(points, numpoints, Vector::try_from)?),
8647 error => Err(err_fmod!("FMOD_Sound_Get3DCustomRolloff", error)),
8648 }
8649 }
8650 }
8651 pub fn get_sub_sound(&self, index: i32) -> Result<Sound, Error> {
8652 unsafe {
8653 let mut subsound = null_mut();
8654 match ffi::FMOD_Sound_GetSubSound(self.pointer, index, &mut subsound) {
8655 ffi::FMOD_OK => Ok(Sound::from(subsound)),
8656 error => Err(err_fmod!("FMOD_Sound_GetSubSound", error)),
8657 }
8658 }
8659 }
8660 pub fn get_sub_sound_parent(&self) -> Result<Sound, Error> {
8661 unsafe {
8662 let mut parentsound = null_mut();
8663 match ffi::FMOD_Sound_GetSubSoundParent(self.pointer, &mut parentsound) {
8664 ffi::FMOD_OK => Ok(Sound::from(parentsound)),
8665 error => Err(err_fmod!("FMOD_Sound_GetSubSoundParent", error)),
8666 }
8667 }
8668 }
8669 pub fn get_name(&self, namelen: i32) -> Result<String, Error> {
8670 unsafe {
8671 let name = string_buffer!(namelen);
8672 match ffi::FMOD_Sound_GetName(self.pointer, name, namelen) {
8673 ffi::FMOD_OK => Ok(to_string!(name)?),
8674 error => Err(err_fmod!("FMOD_Sound_GetName", error)),
8675 }
8676 }
8677 }
8678 pub fn get_length(&self, lengthtype: impl Into<ffi::FMOD_TIMEUNIT>) -> Result<u32, Error> {
8679 unsafe {
8680 let mut length = u32::default();
8681 match ffi::FMOD_Sound_GetLength(self.pointer, &mut length, lengthtype.into()) {
8682 ffi::FMOD_OK => Ok(length),
8683 error => Err(err_fmod!("FMOD_Sound_GetLength", error)),
8684 }
8685 }
8686 }
8687 pub fn get_format(&self) -> Result<(SoundType, SoundFormat, i32, i32), Error> {
8688 unsafe {
8689 let mut type_ = ffi::FMOD_SOUND_TYPE::default();
8690 let mut format = ffi::FMOD_SOUND_FORMAT::default();
8691 let mut channels = i32::default();
8692 let mut bits = i32::default();
8693 match ffi::FMOD_Sound_GetFormat(
8694 self.pointer,
8695 &mut type_,
8696 &mut format,
8697 &mut channels,
8698 &mut bits,
8699 ) {
8700 ffi::FMOD_OK => Ok((
8701 SoundType::from(type_)?,
8702 SoundFormat::from(format)?,
8703 channels,
8704 bits,
8705 )),
8706 error => Err(err_fmod!("FMOD_Sound_GetFormat", error)),
8707 }
8708 }
8709 }
8710 pub fn get_num_sub_sounds(&self) -> Result<i32, Error> {
8711 unsafe {
8712 let mut numsubsounds = i32::default();
8713 match ffi::FMOD_Sound_GetNumSubSounds(self.pointer, &mut numsubsounds) {
8714 ffi::FMOD_OK => Ok(numsubsounds),
8715 error => Err(err_fmod!("FMOD_Sound_GetNumSubSounds", error)),
8716 }
8717 }
8718 }
8719 pub fn get_num_tags(&self) -> Result<(i32, i32), Error> {
8720 unsafe {
8721 let mut numtags = i32::default();
8722 let mut numtagsupdated = i32::default();
8723 match ffi::FMOD_Sound_GetNumTags(self.pointer, &mut numtags, &mut numtagsupdated) {
8724 ffi::FMOD_OK => Ok((numtags, numtagsupdated)),
8725 error => Err(err_fmod!("FMOD_Sound_GetNumTags", error)),
8726 }
8727 }
8728 }
8729 pub fn get_tag(&self, name: &str, index: Option<i32>) -> Result<Tag, Error> {
8730 unsafe {
8731 let mut tag = ffi::FMOD_TAG::default();
8732 match ffi::FMOD_Sound_GetTag(
8733 self.pointer,
8734 CString::new(name)?.as_ptr(),
8735 index.unwrap_or(0),
8736 &mut tag,
8737 ) {
8738 ffi::FMOD_OK => Ok(Tag::try_from(tag)?),
8739 error => Err(err_fmod!("FMOD_Sound_GetTag", error)),
8740 }
8741 }
8742 }
8743 pub fn get_open_state(&self) -> Result<(OpenState, u32, bool, bool), Error> {
8744 unsafe {
8745 let mut openstate = ffi::FMOD_OPENSTATE::default();
8746 let mut percentbuffered = u32::default();
8747 let mut starving = ffi::FMOD_BOOL::default();
8748 let mut diskbusy = ffi::FMOD_BOOL::default();
8749 match ffi::FMOD_Sound_GetOpenState(
8750 self.pointer,
8751 &mut openstate,
8752 &mut percentbuffered,
8753 &mut starving,
8754 &mut diskbusy,
8755 ) {
8756 ffi::FMOD_OK => Ok((
8757 OpenState::from(openstate)?,
8758 percentbuffered,
8759 to_bool!(starving),
8760 to_bool!(diskbusy),
8761 )),
8762 error => Err(err_fmod!("FMOD_Sound_GetOpenState", error)),
8763 }
8764 }
8765 }
8766 pub fn read_data(&self, buffer: *mut c_void, length: u32) -> Result<u32, Error> {
8767 unsafe {
8768 let mut read = u32::default();
8769 match ffi::FMOD_Sound_ReadData(self.pointer, buffer, length, &mut read) {
8770 ffi::FMOD_OK => Ok(read),
8771 error => Err(err_fmod!("FMOD_Sound_ReadData", error)),
8772 }
8773 }
8774 }
8775 pub fn seek_data(&self, pcm: u32) -> Result<(), Error> {
8776 unsafe {
8777 match ffi::FMOD_Sound_SeekData(self.pointer, pcm) {
8778 ffi::FMOD_OK => Ok(()),
8779 error => Err(err_fmod!("FMOD_Sound_SeekData", error)),
8780 }
8781 }
8782 }
8783 pub fn set_sound_group(&self, soundgroup: SoundGroup) -> Result<(), Error> {
8784 unsafe {
8785 match ffi::FMOD_Sound_SetSoundGroup(self.pointer, soundgroup.as_mut_ptr()) {
8786 ffi::FMOD_OK => Ok(()),
8787 error => Err(err_fmod!("FMOD_Sound_SetSoundGroup", error)),
8788 }
8789 }
8790 }
8791 pub fn get_sound_group(&self) -> Result<SoundGroup, Error> {
8792 unsafe {
8793 let mut soundgroup = null_mut();
8794 match ffi::FMOD_Sound_GetSoundGroup(self.pointer, &mut soundgroup) {
8795 ffi::FMOD_OK => Ok(SoundGroup::from(soundgroup)),
8796 error => Err(err_fmod!("FMOD_Sound_GetSoundGroup", error)),
8797 }
8798 }
8799 }
8800 pub fn get_num_sync_points(&self) -> Result<i32, Error> {
8801 unsafe {
8802 let mut numsyncpoints = i32::default();
8803 match ffi::FMOD_Sound_GetNumSyncPoints(self.pointer, &mut numsyncpoints) {
8804 ffi::FMOD_OK => Ok(numsyncpoints),
8805 error => Err(err_fmod!("FMOD_Sound_GetNumSyncPoints", error)),
8806 }
8807 }
8808 }
8809 pub fn get_sync_point(&self, index: i32) -> Result<SyncPoint, Error> {
8810 unsafe {
8811 let mut point = null_mut();
8812 match ffi::FMOD_Sound_GetSyncPoint(self.pointer, index, &mut point) {
8813 ffi::FMOD_OK => Ok(SyncPoint::from(point)),
8814 error => Err(err_fmod!("FMOD_Sound_GetSyncPoint", error)),
8815 }
8816 }
8817 }
8818 pub fn get_sync_point_info(
8819 &self,
8820 point: SyncPoint,
8821 namelen: i32,
8822 offsettype: impl Into<ffi::FMOD_TIMEUNIT>,
8823 ) -> Result<(String, u32), Error> {
8824 unsafe {
8825 let name = string_buffer!(namelen);
8826 let mut offset = u32::default();
8827 match ffi::FMOD_Sound_GetSyncPointInfo(
8828 self.pointer,
8829 point.as_mut_ptr(),
8830 name,
8831 namelen,
8832 &mut offset,
8833 offsettype.into(),
8834 ) {
8835 ffi::FMOD_OK => Ok((to_string!(name)?, offset)),
8836 error => Err(err_fmod!("FMOD_Sound_GetSyncPointInfo", error)),
8837 }
8838 }
8839 }
8840 pub fn add_sync_point(
8841 &self,
8842 offset: u32,
8843 offsettype: impl Into<ffi::FMOD_TIMEUNIT>,
8844 name: Option<String>,
8845 ) -> Result<SyncPoint, Error> {
8846 unsafe {
8847 let mut point = null_mut();
8848 match ffi::FMOD_Sound_AddSyncPoint(
8849 self.pointer,
8850 offset,
8851 offsettype.into(),
8852 name.map(|value| CString::new(value).map(|value| value.as_ptr()))
8853 .unwrap_or(Ok(null_mut()))?,
8854 &mut point,
8855 ) {
8856 ffi::FMOD_OK => Ok(SyncPoint::from(point)),
8857 error => Err(err_fmod!("FMOD_Sound_AddSyncPoint", error)),
8858 }
8859 }
8860 }
8861 pub fn delete_sync_point(&self, point: SyncPoint) -> Result<(), Error> {
8862 unsafe {
8863 match ffi::FMOD_Sound_DeleteSyncPoint(self.pointer, point.as_mut_ptr()) {
8864 ffi::FMOD_OK => Ok(()),
8865 error => Err(err_fmod!("FMOD_Sound_DeleteSyncPoint", error)),
8866 }
8867 }
8868 }
8869 pub fn set_mode(&self, mode: impl Into<ffi::FMOD_MODE>) -> Result<(), Error> {
8870 unsafe {
8871 match ffi::FMOD_Sound_SetMode(self.pointer, mode.into()) {
8872 ffi::FMOD_OK => Ok(()),
8873 error => Err(err_fmod!("FMOD_Sound_SetMode", error)),
8874 }
8875 }
8876 }
8877 pub fn get_mode(&self) -> Result<ffi::FMOD_MODE, Error> {
8878 unsafe {
8879 let mut mode = ffi::FMOD_MODE::default();
8880 match ffi::FMOD_Sound_GetMode(self.pointer, &mut mode) {
8881 ffi::FMOD_OK => Ok(mode),
8882 error => Err(err_fmod!("FMOD_Sound_GetMode", error)),
8883 }
8884 }
8885 }
8886 pub fn set_loop_count(&self, loopcount: i32) -> Result<(), Error> {
8887 unsafe {
8888 match ffi::FMOD_Sound_SetLoopCount(self.pointer, loopcount) {
8889 ffi::FMOD_OK => Ok(()),
8890 error => Err(err_fmod!("FMOD_Sound_SetLoopCount", error)),
8891 }
8892 }
8893 }
8894 pub fn get_loop_count(&self) -> Result<i32, Error> {
8895 unsafe {
8896 let mut loopcount = i32::default();
8897 match ffi::FMOD_Sound_GetLoopCount(self.pointer, &mut loopcount) {
8898 ffi::FMOD_OK => Ok(loopcount),
8899 error => Err(err_fmod!("FMOD_Sound_GetLoopCount", error)),
8900 }
8901 }
8902 }
8903 pub fn set_loop_points(
8904 &self,
8905 loopstart: u32,
8906 loopstarttype: impl Into<ffi::FMOD_TIMEUNIT>,
8907 loopend: u32,
8908 loopendtype: impl Into<ffi::FMOD_TIMEUNIT>,
8909 ) -> Result<(), Error> {
8910 unsafe {
8911 match ffi::FMOD_Sound_SetLoopPoints(
8912 self.pointer,
8913 loopstart,
8914 loopstarttype.into(),
8915 loopend,
8916 loopendtype.into(),
8917 ) {
8918 ffi::FMOD_OK => Ok(()),
8919 error => Err(err_fmod!("FMOD_Sound_SetLoopPoints", error)),
8920 }
8921 }
8922 }
8923 pub fn get_loop_points(
8924 &self,
8925 loopstarttype: impl Into<ffi::FMOD_TIMEUNIT>,
8926 loopendtype: impl Into<ffi::FMOD_TIMEUNIT>,
8927 ) -> Result<(u32, u32), Error> {
8928 unsafe {
8929 let mut loopstart = u32::default();
8930 let mut loopend = u32::default();
8931 match ffi::FMOD_Sound_GetLoopPoints(
8932 self.pointer,
8933 &mut loopstart,
8934 loopstarttype.into(),
8935 &mut loopend,
8936 loopendtype.into(),
8937 ) {
8938 ffi::FMOD_OK => Ok((loopstart, loopend)),
8939 error => Err(err_fmod!("FMOD_Sound_GetLoopPoints", error)),
8940 }
8941 }
8942 }
8943 pub fn get_music_num_channels(&self) -> Result<i32, Error> {
8944 unsafe {
8945 let mut numchannels = i32::default();
8946 match ffi::FMOD_Sound_GetMusicNumChannels(self.pointer, &mut numchannels) {
8947 ffi::FMOD_OK => Ok(numchannels),
8948 error => Err(err_fmod!("FMOD_Sound_GetMusicNumChannels", error)),
8949 }
8950 }
8951 }
8952 pub fn set_music_channel_volume(&self, channel: i32, volume: f32) -> Result<(), Error> {
8953 unsafe {
8954 match ffi::FMOD_Sound_SetMusicChannelVolume(self.pointer, channel, volume) {
8955 ffi::FMOD_OK => Ok(()),
8956 error => Err(err_fmod!("FMOD_Sound_SetMusicChannelVolume", error)),
8957 }
8958 }
8959 }
8960 pub fn get_music_channel_volume(&self, channel: i32) -> Result<f32, Error> {
8961 unsafe {
8962 let mut volume = f32::default();
8963 match ffi::FMOD_Sound_GetMusicChannelVolume(self.pointer, channel, &mut volume) {
8964 ffi::FMOD_OK => Ok(volume),
8965 error => Err(err_fmod!("FMOD_Sound_GetMusicChannelVolume", error)),
8966 }
8967 }
8968 }
8969 pub fn set_music_speed(&self, speed: f32) -> Result<(), Error> {
8970 unsafe {
8971 match ffi::FMOD_Sound_SetMusicSpeed(self.pointer, speed) {
8972 ffi::FMOD_OK => Ok(()),
8973 error => Err(err_fmod!("FMOD_Sound_SetMusicSpeed", error)),
8974 }
8975 }
8976 }
8977 pub fn get_music_speed(&self) -> Result<f32, Error> {
8978 unsafe {
8979 let mut speed = f32::default();
8980 match ffi::FMOD_Sound_GetMusicSpeed(self.pointer, &mut speed) {
8981 ffi::FMOD_OK => Ok(speed),
8982 error => Err(err_fmod!("FMOD_Sound_GetMusicSpeed", error)),
8983 }
8984 }
8985 }
8986 pub fn set_user_data(&self, userdata: *mut c_void) -> Result<(), Error> {
8987 unsafe {
8988 match ffi::FMOD_Sound_SetUserData(self.pointer, userdata) {
8989 ffi::FMOD_OK => Ok(()),
8990 error => Err(err_fmod!("FMOD_Sound_SetUserData", error)),
8991 }
8992 }
8993 }
8994 pub fn get_user_data(&self) -> Result<*mut c_void, Error> {
8995 unsafe {
8996 let mut userdata = null_mut();
8997 match ffi::FMOD_Sound_GetUserData(self.pointer, &mut userdata) {
8998 ffi::FMOD_OK => Ok(userdata),
8999 error => Err(err_fmod!("FMOD_Sound_GetUserData", error)),
9000 }
9001 }
9002 }
9003}
9004#[derive(Debug, Clone, Copy)]
9005pub struct SoundGroup {
9006 pointer: *mut ffi::FMOD_SOUNDGROUP,
9007}
9008unsafe impl Send for SoundGroup {}
9009unsafe impl Sync for SoundGroup {}
9010impl SoundGroup {
9011 #[inline]
9012 pub fn from(pointer: *mut ffi::FMOD_SOUNDGROUP) -> Self {
9013 Self { pointer }
9014 }
9015 #[inline]
9016 pub fn as_mut_ptr(&self) -> *mut ffi::FMOD_SOUNDGROUP {
9017 self.pointer
9018 }
9019 pub fn release(&self) -> Result<(), Error> {
9020 unsafe {
9021 match ffi::FMOD_SoundGroup_Release(self.pointer) {
9022 ffi::FMOD_OK => Ok(()),
9023 error => Err(err_fmod!("FMOD_SoundGroup_Release", error)),
9024 }
9025 }
9026 }
9027 pub fn get_system_object(&self) -> Result<System, Error> {
9028 unsafe {
9029 let mut system = null_mut();
9030 match ffi::FMOD_SoundGroup_GetSystemObject(self.pointer, &mut system) {
9031 ffi::FMOD_OK => Ok(System::from(system)),
9032 error => Err(err_fmod!("FMOD_SoundGroup_GetSystemObject", error)),
9033 }
9034 }
9035 }
9036 pub fn set_max_audible(&self, maxaudible: i32) -> Result<(), Error> {
9037 unsafe {
9038 match ffi::FMOD_SoundGroup_SetMaxAudible(self.pointer, maxaudible) {
9039 ffi::FMOD_OK => Ok(()),
9040 error => Err(err_fmod!("FMOD_SoundGroup_SetMaxAudible", error)),
9041 }
9042 }
9043 }
9044 pub fn get_max_audible(&self) -> Result<i32, Error> {
9045 unsafe {
9046 let mut maxaudible = i32::default();
9047 match ffi::FMOD_SoundGroup_GetMaxAudible(self.pointer, &mut maxaudible) {
9048 ffi::FMOD_OK => Ok(maxaudible),
9049 error => Err(err_fmod!("FMOD_SoundGroup_GetMaxAudible", error)),
9050 }
9051 }
9052 }
9053 pub fn set_max_audible_behavior(&self, behavior: SoundGroupBehavior) -> Result<(), Error> {
9054 unsafe {
9055 match ffi::FMOD_SoundGroup_SetMaxAudibleBehavior(self.pointer, behavior.into()) {
9056 ffi::FMOD_OK => Ok(()),
9057 error => Err(err_fmod!("FMOD_SoundGroup_SetMaxAudibleBehavior", error)),
9058 }
9059 }
9060 }
9061 pub fn get_max_audible_behavior(&self) -> Result<SoundGroupBehavior, Error> {
9062 unsafe {
9063 let mut behavior = ffi::FMOD_SOUNDGROUP_BEHAVIOR::default();
9064 match ffi::FMOD_SoundGroup_GetMaxAudibleBehavior(self.pointer, &mut behavior) {
9065 ffi::FMOD_OK => Ok(SoundGroupBehavior::from(behavior)?),
9066 error => Err(err_fmod!("FMOD_SoundGroup_GetMaxAudibleBehavior", error)),
9067 }
9068 }
9069 }
9070 pub fn set_mute_fade_speed(&self, speed: f32) -> Result<(), Error> {
9071 unsafe {
9072 match ffi::FMOD_SoundGroup_SetMuteFadeSpeed(self.pointer, speed) {
9073 ffi::FMOD_OK => Ok(()),
9074 error => Err(err_fmod!("FMOD_SoundGroup_SetMuteFadeSpeed", error)),
9075 }
9076 }
9077 }
9078 pub fn get_mute_fade_speed(&self) -> Result<f32, Error> {
9079 unsafe {
9080 let mut speed = f32::default();
9081 match ffi::FMOD_SoundGroup_GetMuteFadeSpeed(self.pointer, &mut speed) {
9082 ffi::FMOD_OK => Ok(speed),
9083 error => Err(err_fmod!("FMOD_SoundGroup_GetMuteFadeSpeed", error)),
9084 }
9085 }
9086 }
9087 pub fn set_volume(&self, volume: f32) -> Result<(), Error> {
9088 unsafe {
9089 match ffi::FMOD_SoundGroup_SetVolume(self.pointer, volume) {
9090 ffi::FMOD_OK => Ok(()),
9091 error => Err(err_fmod!("FMOD_SoundGroup_SetVolume", error)),
9092 }
9093 }
9094 }
9095 pub fn get_volume(&self) -> Result<f32, Error> {
9096 unsafe {
9097 let mut volume = f32::default();
9098 match ffi::FMOD_SoundGroup_GetVolume(self.pointer, &mut volume) {
9099 ffi::FMOD_OK => Ok(volume),
9100 error => Err(err_fmod!("FMOD_SoundGroup_GetVolume", error)),
9101 }
9102 }
9103 }
9104 pub fn stop(&self) -> Result<(), Error> {
9105 unsafe {
9106 match ffi::FMOD_SoundGroup_Stop(self.pointer) {
9107 ffi::FMOD_OK => Ok(()),
9108 error => Err(err_fmod!("FMOD_SoundGroup_Stop", error)),
9109 }
9110 }
9111 }
9112 pub fn get_name(&self, namelen: i32) -> Result<String, Error> {
9113 unsafe {
9114 let name = string_buffer!(namelen);
9115 match ffi::FMOD_SoundGroup_GetName(self.pointer, name, namelen) {
9116 ffi::FMOD_OK => Ok(to_string!(name)?),
9117 error => Err(err_fmod!("FMOD_SoundGroup_GetName", error)),
9118 }
9119 }
9120 }
9121 pub fn get_num_sounds(&self) -> Result<i32, Error> {
9122 unsafe {
9123 let mut numsounds = i32::default();
9124 match ffi::FMOD_SoundGroup_GetNumSounds(self.pointer, &mut numsounds) {
9125 ffi::FMOD_OK => Ok(numsounds),
9126 error => Err(err_fmod!("FMOD_SoundGroup_GetNumSounds", error)),
9127 }
9128 }
9129 }
9130 pub fn get_sound(&self, index: i32) -> Result<Sound, Error> {
9131 unsafe {
9132 let mut sound = null_mut();
9133 match ffi::FMOD_SoundGroup_GetSound(self.pointer, index, &mut sound) {
9134 ffi::FMOD_OK => Ok(Sound::from(sound)),
9135 error => Err(err_fmod!("FMOD_SoundGroup_GetSound", error)),
9136 }
9137 }
9138 }
9139 pub fn get_num_playing(&self) -> Result<i32, Error> {
9140 unsafe {
9141 let mut numplaying = i32::default();
9142 match ffi::FMOD_SoundGroup_GetNumPlaying(self.pointer, &mut numplaying) {
9143 ffi::FMOD_OK => Ok(numplaying),
9144 error => Err(err_fmod!("FMOD_SoundGroup_GetNumPlaying", error)),
9145 }
9146 }
9147 }
9148 pub fn set_user_data(&self, userdata: *mut c_void) -> Result<(), Error> {
9149 unsafe {
9150 match ffi::FMOD_SoundGroup_SetUserData(self.pointer, userdata) {
9151 ffi::FMOD_OK => Ok(()),
9152 error => Err(err_fmod!("FMOD_SoundGroup_SetUserData", error)),
9153 }
9154 }
9155 }
9156 pub fn get_user_data(&self) -> Result<*mut c_void, Error> {
9157 unsafe {
9158 let mut userdata = null_mut();
9159 match ffi::FMOD_SoundGroup_GetUserData(self.pointer, &mut userdata) {
9160 ffi::FMOD_OK => Ok(userdata),
9161 error => Err(err_fmod!("FMOD_SoundGroup_GetUserData", error)),
9162 }
9163 }
9164 }
9165}
9166#[derive(Debug, Clone, Copy)]
9167pub struct Bank {
9168 pointer: *mut ffi::FMOD_STUDIO_BANK,
9169}
9170unsafe impl Send for Bank {}
9171unsafe impl Sync for Bank {}
9172impl Bank {
9173 #[inline]
9174 pub fn from(pointer: *mut ffi::FMOD_STUDIO_BANK) -> Self {
9175 Self { pointer }
9176 }
9177 #[inline]
9178 pub fn as_mut_ptr(&self) -> *mut ffi::FMOD_STUDIO_BANK {
9179 self.pointer
9180 }
9181 pub fn is_valid(&self) -> bool {
9182 unsafe { to_bool!(ffi::FMOD_Studio_Bank_IsValid(self.pointer)) }
9183 }
9184 pub fn get_id(&self) -> Result<Guid, Error> {
9185 unsafe {
9186 let mut id = ffi::FMOD_GUID::default();
9187 match ffi::FMOD_Studio_Bank_GetID(self.pointer, &mut id) {
9188 ffi::FMOD_OK => Ok(Guid::try_from(id)?),
9189 error => Err(err_fmod!("FMOD_Studio_Bank_GetID", error)),
9190 }
9191 }
9192 }
9193 pub fn get_path(&self) -> Result<String, Error> {
9194 unsafe {
9195 let mut retrieved = i32::default();
9196 match ffi::FMOD_Studio_Bank_GetPath(self.pointer, null_mut(), 0, &mut retrieved) {
9197 ffi::FMOD_OK => {
9198 let mut buf = vec![0u8; retrieved as usize];
9199 match ffi::FMOD_Studio_Bank_GetPath(
9200 self.pointer,
9201 buf.as_mut_ptr() as *mut _,
9202 retrieved,
9203 &mut retrieved,
9204 ) {
9205 ffi::FMOD_OK => Ok(CString::from_vec_with_nul_unchecked(buf)
9206 .into_string()
9207 .map_err(Error::String)?),
9208 error => Err(err_fmod!("FMOD_Studio_Bank_GetPath", error)),
9209 }
9210 }
9211 error => Err(err_fmod!("FMOD_Studio_Bank_GetPath", error)),
9212 }
9213 }
9214 }
9215 pub fn unload(&self) -> Result<(), Error> {
9216 unsafe {
9217 match ffi::FMOD_Studio_Bank_Unload(self.pointer) {
9218 ffi::FMOD_OK => Ok(()),
9219 error => Err(err_fmod!("FMOD_Studio_Bank_Unload", error)),
9220 }
9221 }
9222 }
9223 pub fn load_sample_data(&self) -> Result<(), Error> {
9224 unsafe {
9225 match ffi::FMOD_Studio_Bank_LoadSampleData(self.pointer) {
9226 ffi::FMOD_OK => Ok(()),
9227 error => Err(err_fmod!("FMOD_Studio_Bank_LoadSampleData", error)),
9228 }
9229 }
9230 }
9231 pub fn unload_sample_data(&self) -> Result<(), Error> {
9232 unsafe {
9233 match ffi::FMOD_Studio_Bank_UnloadSampleData(self.pointer) {
9234 ffi::FMOD_OK => Ok(()),
9235 error => Err(err_fmod!("FMOD_Studio_Bank_UnloadSampleData", error)),
9236 }
9237 }
9238 }
9239 pub fn get_loading_state(&self) -> Result<LoadingState, Error> {
9240 unsafe {
9241 let mut state = ffi::FMOD_STUDIO_LOADING_STATE::default();
9242 match ffi::FMOD_Studio_Bank_GetLoadingState(self.pointer, &mut state) {
9243 ffi::FMOD_OK => Ok(LoadingState::from(state)?),
9244 error => Err(err_fmod!("FMOD_Studio_Bank_GetLoadingState", error)),
9245 }
9246 }
9247 }
9248 pub fn get_sample_loading_state(&self) -> Result<LoadingState, Error> {
9249 unsafe {
9250 let mut state = ffi::FMOD_STUDIO_LOADING_STATE::default();
9251 match ffi::FMOD_Studio_Bank_GetSampleLoadingState(self.pointer, &mut state) {
9252 ffi::FMOD_OK => Ok(LoadingState::from(state)?),
9253 error => Err(err_fmod!("FMOD_Studio_Bank_GetSampleLoadingState", error)),
9254 }
9255 }
9256 }
9257 pub fn get_string_count(&self) -> Result<i32, Error> {
9258 unsafe {
9259 let mut count = i32::default();
9260 match ffi::FMOD_Studio_Bank_GetStringCount(self.pointer, &mut count) {
9261 ffi::FMOD_OK => Ok(count),
9262 error => Err(err_fmod!("FMOD_Studio_Bank_GetStringCount", error)),
9263 }
9264 }
9265 }
9266 pub fn get_string_info(&self, index: i32, size: i32) -> Result<(Guid, String, i32), Error> {
9267 unsafe {
9268 let mut id = ffi::FMOD_GUID::default();
9269 let path = string_buffer!(size);
9270 let mut retrieved = i32::default();
9271 match ffi::FMOD_Studio_Bank_GetStringInfo(
9272 self.pointer,
9273 index,
9274 &mut id,
9275 path,
9276 size,
9277 &mut retrieved,
9278 ) {
9279 ffi::FMOD_OK => Ok((Guid::try_from(id)?, to_string!(path)?, retrieved)),
9280 error => Err(err_fmod!("FMOD_Studio_Bank_GetStringInfo", error)),
9281 }
9282 }
9283 }
9284 pub fn get_event_count(&self) -> Result<i32, Error> {
9285 unsafe {
9286 let mut count = i32::default();
9287 match ffi::FMOD_Studio_Bank_GetEventCount(self.pointer, &mut count) {
9288 ffi::FMOD_OK => Ok(count),
9289 error => Err(err_fmod!("FMOD_Studio_Bank_GetEventCount", error)),
9290 }
9291 }
9292 }
9293 pub fn get_event_list(&self, capacity: i32) -> Result<Vec<EventDescription>, Error> {
9294 unsafe {
9295 let mut array = vec![null_mut(); capacity as usize];
9296 let mut count = i32::default();
9297 match ffi::FMOD_Studio_Bank_GetEventList(
9298 self.pointer,
9299 array.as_mut_ptr(),
9300 capacity,
9301 &mut count,
9302 ) {
9303 ffi::FMOD_OK => Ok(array
9304 .into_iter()
9305 .take(count as usize)
9306 .map(EventDescription::from)
9307 .collect()),
9308 error => Err(err_fmod!("FMOD_Studio_Bank_GetEventList", error)),
9309 }
9310 }
9311 }
9312 pub fn get_bus_count(&self) -> Result<i32, Error> {
9313 unsafe {
9314 let mut count = i32::default();
9315 match ffi::FMOD_Studio_Bank_GetBusCount(self.pointer, &mut count) {
9316 ffi::FMOD_OK => Ok(count),
9317 error => Err(err_fmod!("FMOD_Studio_Bank_GetBusCount", error)),
9318 }
9319 }
9320 }
9321 pub fn get_bus_list(&self, capacity: i32) -> Result<Vec<Bus>, Error> {
9322 unsafe {
9323 let mut array = vec![null_mut(); capacity as usize];
9324 let mut count = i32::default();
9325 match ffi::FMOD_Studio_Bank_GetBusList(
9326 self.pointer,
9327 array.as_mut_ptr(),
9328 capacity,
9329 &mut count,
9330 ) {
9331 ffi::FMOD_OK => Ok(array
9332 .into_iter()
9333 .take(count as usize)
9334 .map(Bus::from)
9335 .collect()),
9336 error => Err(err_fmod!("FMOD_Studio_Bank_GetBusList", error)),
9337 }
9338 }
9339 }
9340 pub fn get_vca_count(&self) -> Result<i32, Error> {
9341 unsafe {
9342 let mut count = i32::default();
9343 match ffi::FMOD_Studio_Bank_GetVCACount(self.pointer, &mut count) {
9344 ffi::FMOD_OK => Ok(count),
9345 error => Err(err_fmod!("FMOD_Studio_Bank_GetVCACount", error)),
9346 }
9347 }
9348 }
9349 pub fn get_vca_list(&self, capacity: i32) -> Result<Vec<Vca>, Error> {
9350 unsafe {
9351 let mut array = vec![null_mut(); capacity as usize];
9352 let mut count = i32::default();
9353 match ffi::FMOD_Studio_Bank_GetVCAList(
9354 self.pointer,
9355 array.as_mut_ptr(),
9356 capacity,
9357 &mut count,
9358 ) {
9359 ffi::FMOD_OK => Ok(array
9360 .into_iter()
9361 .take(count as usize)
9362 .map(Vca::from)
9363 .collect()),
9364 error => Err(err_fmod!("FMOD_Studio_Bank_GetVCAList", error)),
9365 }
9366 }
9367 }
9368 pub fn get_user_data(&self) -> Result<*mut c_void, Error> {
9369 unsafe {
9370 let mut userdata = null_mut();
9371 match ffi::FMOD_Studio_Bank_GetUserData(self.pointer, &mut userdata) {
9372 ffi::FMOD_OK => Ok(userdata),
9373 error => Err(err_fmod!("FMOD_Studio_Bank_GetUserData", error)),
9374 }
9375 }
9376 }
9377 pub fn set_user_data(&self, userdata: *mut c_void) -> Result<(), Error> {
9378 unsafe {
9379 match ffi::FMOD_Studio_Bank_SetUserData(self.pointer, userdata) {
9380 ffi::FMOD_OK => Ok(()),
9381 error => Err(err_fmod!("FMOD_Studio_Bank_SetUserData", error)),
9382 }
9383 }
9384 }
9385}
9386#[derive(Debug, Clone, Copy)]
9387pub struct Bus {
9388 pointer: *mut ffi::FMOD_STUDIO_BUS,
9389}
9390unsafe impl Send for Bus {}
9391unsafe impl Sync for Bus {}
9392impl Bus {
9393 #[inline]
9394 pub fn from(pointer: *mut ffi::FMOD_STUDIO_BUS) -> Self {
9395 Self { pointer }
9396 }
9397 #[inline]
9398 pub fn as_mut_ptr(&self) -> *mut ffi::FMOD_STUDIO_BUS {
9399 self.pointer
9400 }
9401 pub fn is_valid(&self) -> bool {
9402 unsafe { to_bool!(ffi::FMOD_Studio_Bus_IsValid(self.pointer)) }
9403 }
9404 pub fn get_id(&self) -> Result<Guid, Error> {
9405 unsafe {
9406 let mut id = ffi::FMOD_GUID::default();
9407 match ffi::FMOD_Studio_Bus_GetID(self.pointer, &mut id) {
9408 ffi::FMOD_OK => Ok(Guid::try_from(id)?),
9409 error => Err(err_fmod!("FMOD_Studio_Bus_GetID", error)),
9410 }
9411 }
9412 }
9413 pub fn get_path(&self) -> Result<String, Error> {
9414 unsafe {
9415 let mut retrieved = i32::default();
9416 match ffi::FMOD_Studio_Bus_GetPath(self.pointer, null_mut(), 0, &mut retrieved) {
9417 ffi::FMOD_OK => {
9418 let mut buf = vec![0u8; retrieved as usize];
9419 match ffi::FMOD_Studio_Bus_GetPath(
9420 self.pointer,
9421 buf.as_mut_ptr() as *mut _,
9422 retrieved,
9423 &mut retrieved,
9424 ) {
9425 ffi::FMOD_OK => Ok(CString::from_vec_with_nul_unchecked(buf)
9426 .into_string()
9427 .map_err(Error::String)?),
9428 error => Err(err_fmod!("FMOD_Studio_Bus_GetPath", error)),
9429 }
9430 }
9431 error => Err(err_fmod!("FMOD_Studio_Bus_GetPath", error)),
9432 }
9433 }
9434 }
9435 pub fn get_volume(&self) -> Result<(f32, f32), Error> {
9436 unsafe {
9437 let mut volume = f32::default();
9438 let mut finalvolume = f32::default();
9439 match ffi::FMOD_Studio_Bus_GetVolume(self.pointer, &mut volume, &mut finalvolume) {
9440 ffi::FMOD_OK => Ok((volume, finalvolume)),
9441 error => Err(err_fmod!("FMOD_Studio_Bus_GetVolume", error)),
9442 }
9443 }
9444 }
9445 pub fn set_volume(&self, volume: f32) -> Result<(), Error> {
9446 unsafe {
9447 match ffi::FMOD_Studio_Bus_SetVolume(self.pointer, volume) {
9448 ffi::FMOD_OK => Ok(()),
9449 error => Err(err_fmod!("FMOD_Studio_Bus_SetVolume", error)),
9450 }
9451 }
9452 }
9453 pub fn get_paused(&self) -> Result<bool, Error> {
9454 unsafe {
9455 let mut paused = ffi::FMOD_BOOL::default();
9456 match ffi::FMOD_Studio_Bus_GetPaused(self.pointer, &mut paused) {
9457 ffi::FMOD_OK => Ok(to_bool!(paused)),
9458 error => Err(err_fmod!("FMOD_Studio_Bus_GetPaused", error)),
9459 }
9460 }
9461 }
9462 pub fn set_paused(&self, paused: bool) -> Result<(), Error> {
9463 unsafe {
9464 match ffi::FMOD_Studio_Bus_SetPaused(self.pointer, from_bool!(paused)) {
9465 ffi::FMOD_OK => Ok(()),
9466 error => Err(err_fmod!("FMOD_Studio_Bus_SetPaused", error)),
9467 }
9468 }
9469 }
9470 pub fn get_mute(&self) -> Result<bool, Error> {
9471 unsafe {
9472 let mut mute = ffi::FMOD_BOOL::default();
9473 match ffi::FMOD_Studio_Bus_GetMute(self.pointer, &mut mute) {
9474 ffi::FMOD_OK => Ok(to_bool!(mute)),
9475 error => Err(err_fmod!("FMOD_Studio_Bus_GetMute", error)),
9476 }
9477 }
9478 }
9479 pub fn set_mute(&self, mute: bool) -> Result<(), Error> {
9480 unsafe {
9481 match ffi::FMOD_Studio_Bus_SetMute(self.pointer, from_bool!(mute)) {
9482 ffi::FMOD_OK => Ok(()),
9483 error => Err(err_fmod!("FMOD_Studio_Bus_SetMute", error)),
9484 }
9485 }
9486 }
9487 pub fn stop_all_events(&self, mode: StopMode) -> Result<(), Error> {
9488 unsafe {
9489 match ffi::FMOD_Studio_Bus_StopAllEvents(self.pointer, mode.into()) {
9490 ffi::FMOD_OK => Ok(()),
9491 error => Err(err_fmod!("FMOD_Studio_Bus_StopAllEvents", error)),
9492 }
9493 }
9494 }
9495 pub fn get_port_index(&self) -> Result<ffi::FMOD_PORT_INDEX, Error> {
9496 unsafe {
9497 let mut index = ffi::FMOD_PORT_INDEX::default();
9498 match ffi::FMOD_Studio_Bus_GetPortIndex(self.pointer, &mut index) {
9499 ffi::FMOD_OK => Ok(index),
9500 error => Err(err_fmod!("FMOD_Studio_Bus_GetPortIndex", error)),
9501 }
9502 }
9503 }
9504 pub fn set_port_index(&self, index: impl Into<ffi::FMOD_PORT_INDEX>) -> Result<(), Error> {
9505 unsafe {
9506 match ffi::FMOD_Studio_Bus_SetPortIndex(self.pointer, index.into()) {
9507 ffi::FMOD_OK => Ok(()),
9508 error => Err(err_fmod!("FMOD_Studio_Bus_SetPortIndex", error)),
9509 }
9510 }
9511 }
9512 pub fn lock_channel_group(&self) -> Result<(), Error> {
9513 unsafe {
9514 match ffi::FMOD_Studio_Bus_LockChannelGroup(self.pointer) {
9515 ffi::FMOD_OK => Ok(()),
9516 error => Err(err_fmod!("FMOD_Studio_Bus_LockChannelGroup", error)),
9517 }
9518 }
9519 }
9520 pub fn unlock_channel_group(&self) -> Result<(), Error> {
9521 unsafe {
9522 match ffi::FMOD_Studio_Bus_UnlockChannelGroup(self.pointer) {
9523 ffi::FMOD_OK => Ok(()),
9524 error => Err(err_fmod!("FMOD_Studio_Bus_UnlockChannelGroup", error)),
9525 }
9526 }
9527 }
9528 pub fn get_channel_group(&self) -> Result<ChannelGroup, Error> {
9529 unsafe {
9530 let mut group = null_mut();
9531 match ffi::FMOD_Studio_Bus_GetChannelGroup(self.pointer, &mut group) {
9532 ffi::FMOD_OK => Ok(ChannelGroup::from(group)),
9533 error => Err(err_fmod!("FMOD_Studio_Bus_GetChannelGroup", error)),
9534 }
9535 }
9536 }
9537 pub fn get_cpu_usage(&self) -> Result<(u32, u32), Error> {
9538 unsafe {
9539 let mut exclusive = u32::default();
9540 let mut inclusive = u32::default();
9541 match ffi::FMOD_Studio_Bus_GetCPUUsage(self.pointer, &mut exclusive, &mut inclusive) {
9542 ffi::FMOD_OK => Ok((exclusive, inclusive)),
9543 error => Err(err_fmod!("FMOD_Studio_Bus_GetCPUUsage", error)),
9544 }
9545 }
9546 }
9547 pub fn get_memory_usage(&self) -> Result<MemoryUsage, Error> {
9548 unsafe {
9549 let mut memoryusage = ffi::FMOD_STUDIO_MEMORY_USAGE::default();
9550 match ffi::FMOD_Studio_Bus_GetMemoryUsage(self.pointer, &mut memoryusage) {
9551 ffi::FMOD_OK => Ok(MemoryUsage::try_from(memoryusage)?),
9552 error => Err(err_fmod!("FMOD_Studio_Bus_GetMemoryUsage", error)),
9553 }
9554 }
9555 }
9556}
9557#[derive(Debug, Clone, Copy)]
9558pub struct CommandReplay {
9559 pointer: *mut ffi::FMOD_STUDIO_COMMANDREPLAY,
9560}
9561unsafe impl Send for CommandReplay {}
9562unsafe impl Sync for CommandReplay {}
9563impl CommandReplay {
9564 #[inline]
9565 pub fn from(pointer: *mut ffi::FMOD_STUDIO_COMMANDREPLAY) -> Self {
9566 Self { pointer }
9567 }
9568 #[inline]
9569 pub fn as_mut_ptr(&self) -> *mut ffi::FMOD_STUDIO_COMMANDREPLAY {
9570 self.pointer
9571 }
9572 pub fn is_valid(&self) -> bool {
9573 unsafe { to_bool!(ffi::FMOD_Studio_CommandReplay_IsValid(self.pointer)) }
9574 }
9575 pub fn get_system(&self) -> Result<Studio, Error> {
9576 unsafe {
9577 let mut system = null_mut();
9578 match ffi::FMOD_Studio_CommandReplay_GetSystem(self.pointer, &mut system) {
9579 ffi::FMOD_OK => Ok(Studio::from(system)),
9580 error => Err(err_fmod!("FMOD_Studio_CommandReplay_GetSystem", error)),
9581 }
9582 }
9583 }
9584 pub fn get_length(&self) -> Result<f32, Error> {
9585 unsafe {
9586 let mut length = f32::default();
9587 match ffi::FMOD_Studio_CommandReplay_GetLength(self.pointer, &mut length) {
9588 ffi::FMOD_OK => Ok(length),
9589 error => Err(err_fmod!("FMOD_Studio_CommandReplay_GetLength", error)),
9590 }
9591 }
9592 }
9593 pub fn get_command_count(&self) -> Result<i32, Error> {
9594 unsafe {
9595 let mut count = i32::default();
9596 match ffi::FMOD_Studio_CommandReplay_GetCommandCount(self.pointer, &mut count) {
9597 ffi::FMOD_OK => Ok(count),
9598 error => Err(err_fmod!(
9599 "FMOD_Studio_CommandReplay_GetCommandCount",
9600 error
9601 )),
9602 }
9603 }
9604 }
9605 pub fn get_command_info(&self, commandindex: i32) -> Result<CommandInfo, Error> {
9606 unsafe {
9607 let mut info = ffi::FMOD_STUDIO_COMMAND_INFO::default();
9608 match ffi::FMOD_Studio_CommandReplay_GetCommandInfo(
9609 self.pointer,
9610 commandindex,
9611 &mut info,
9612 ) {
9613 ffi::FMOD_OK => Ok(CommandInfo::try_from(info)?),
9614 error => Err(err_fmod!("FMOD_Studio_CommandReplay_GetCommandInfo", error)),
9615 }
9616 }
9617 }
9618 pub fn get_command_string(&self, commandindex: i32, length: i32) -> Result<String, Error> {
9619 unsafe {
9620 let buffer = string_buffer!(length);
9621 match ffi::FMOD_Studio_CommandReplay_GetCommandString(
9622 self.pointer,
9623 commandindex,
9624 buffer,
9625 length,
9626 ) {
9627 ffi::FMOD_OK => Ok(to_string!(buffer)?),
9628 error => Err(err_fmod!(
9629 "FMOD_Studio_CommandReplay_GetCommandString",
9630 error
9631 )),
9632 }
9633 }
9634 }
9635 pub fn get_command_at_time(&self, time: f32) -> Result<i32, Error> {
9636 unsafe {
9637 let mut commandindex = i32::default();
9638 match ffi::FMOD_Studio_CommandReplay_GetCommandAtTime(
9639 self.pointer,
9640 time,
9641 &mut commandindex,
9642 ) {
9643 ffi::FMOD_OK => Ok(commandindex),
9644 error => Err(err_fmod!(
9645 "FMOD_Studio_CommandReplay_GetCommandAtTime",
9646 error
9647 )),
9648 }
9649 }
9650 }
9651 pub fn set_bank_path(&self, bank_path: &str) -> Result<(), Error> {
9652 unsafe {
9653 match ffi::FMOD_Studio_CommandReplay_SetBankPath(
9654 self.pointer,
9655 CString::new(bank_path)?.as_ptr(),
9656 ) {
9657 ffi::FMOD_OK => Ok(()),
9658 error => Err(err_fmod!("FMOD_Studio_CommandReplay_SetBankPath", error)),
9659 }
9660 }
9661 }
9662 pub fn start(&self) -> Result<(), Error> {
9663 unsafe {
9664 match ffi::FMOD_Studio_CommandReplay_Start(self.pointer) {
9665 ffi::FMOD_OK => Ok(()),
9666 error => Err(err_fmod!("FMOD_Studio_CommandReplay_Start", error)),
9667 }
9668 }
9669 }
9670 pub fn stop(&self) -> Result<(), Error> {
9671 unsafe {
9672 match ffi::FMOD_Studio_CommandReplay_Stop(self.pointer) {
9673 ffi::FMOD_OK => Ok(()),
9674 error => Err(err_fmod!("FMOD_Studio_CommandReplay_Stop", error)),
9675 }
9676 }
9677 }
9678 pub fn seek_to_time(&self, time: f32) -> Result<(), Error> {
9679 unsafe {
9680 match ffi::FMOD_Studio_CommandReplay_SeekToTime(self.pointer, time) {
9681 ffi::FMOD_OK => Ok(()),
9682 error => Err(err_fmod!("FMOD_Studio_CommandReplay_SeekToTime", error)),
9683 }
9684 }
9685 }
9686 pub fn seek_to_command(&self, commandindex: i32) -> Result<(), Error> {
9687 unsafe {
9688 match ffi::FMOD_Studio_CommandReplay_SeekToCommand(self.pointer, commandindex) {
9689 ffi::FMOD_OK => Ok(()),
9690 error => Err(err_fmod!("FMOD_Studio_CommandReplay_SeekToCommand", error)),
9691 }
9692 }
9693 }
9694 pub fn get_paused(&self) -> Result<bool, Error> {
9695 unsafe {
9696 let mut paused = ffi::FMOD_BOOL::default();
9697 match ffi::FMOD_Studio_CommandReplay_GetPaused(self.pointer, &mut paused) {
9698 ffi::FMOD_OK => Ok(to_bool!(paused)),
9699 error => Err(err_fmod!("FMOD_Studio_CommandReplay_GetPaused", error)),
9700 }
9701 }
9702 }
9703 pub fn set_paused(&self, paused: bool) -> Result<(), Error> {
9704 unsafe {
9705 match ffi::FMOD_Studio_CommandReplay_SetPaused(self.pointer, from_bool!(paused)) {
9706 ffi::FMOD_OK => Ok(()),
9707 error => Err(err_fmod!("FMOD_Studio_CommandReplay_SetPaused", error)),
9708 }
9709 }
9710 }
9711 pub fn get_playback_state(&self) -> Result<PlaybackState, Error> {
9712 unsafe {
9713 let mut state = ffi::FMOD_STUDIO_PLAYBACK_STATE::default();
9714 match ffi::FMOD_Studio_CommandReplay_GetPlaybackState(self.pointer, &mut state) {
9715 ffi::FMOD_OK => Ok(PlaybackState::from(state)?),
9716 error => Err(err_fmod!(
9717 "FMOD_Studio_CommandReplay_GetPlaybackState",
9718 error
9719 )),
9720 }
9721 }
9722 }
9723 pub fn get_current_command(&self) -> Result<(i32, f32), Error> {
9724 unsafe {
9725 let mut commandindex = i32::default();
9726 let mut currenttime = f32::default();
9727 match ffi::FMOD_Studio_CommandReplay_GetCurrentCommand(
9728 self.pointer,
9729 &mut commandindex,
9730 &mut currenttime,
9731 ) {
9732 ffi::FMOD_OK => Ok((commandindex, currenttime)),
9733 error => Err(err_fmod!(
9734 "FMOD_Studio_CommandReplay_GetCurrentCommand",
9735 error
9736 )),
9737 }
9738 }
9739 }
9740 pub fn release(&self) -> Result<(), Error> {
9741 unsafe {
9742 match ffi::FMOD_Studio_CommandReplay_Release(self.pointer) {
9743 ffi::FMOD_OK => Ok(()),
9744 error => Err(err_fmod!("FMOD_Studio_CommandReplay_Release", error)),
9745 }
9746 }
9747 }
9748 pub fn set_frame_callback(
9749 &self,
9750 callback: ffi::FMOD_STUDIO_COMMANDREPLAY_FRAME_CALLBACK,
9751 ) -> Result<(), Error> {
9752 unsafe {
9753 match ffi::FMOD_Studio_CommandReplay_SetFrameCallback(self.pointer, callback) {
9754 ffi::FMOD_OK => Ok(()),
9755 error => Err(err_fmod!(
9756 "FMOD_Studio_CommandReplay_SetFrameCallback",
9757 error
9758 )),
9759 }
9760 }
9761 }
9762 pub fn set_load_bank_callback(
9763 &self,
9764 callback: ffi::FMOD_STUDIO_COMMANDREPLAY_LOAD_BANK_CALLBACK,
9765 ) -> Result<(), Error> {
9766 unsafe {
9767 match ffi::FMOD_Studio_CommandReplay_SetLoadBankCallback(self.pointer, callback) {
9768 ffi::FMOD_OK => Ok(()),
9769 error => Err(err_fmod!(
9770 "FMOD_Studio_CommandReplay_SetLoadBankCallback",
9771 error
9772 )),
9773 }
9774 }
9775 }
9776 pub fn set_create_instance_callback(
9777 &self,
9778 callback: ffi::FMOD_STUDIO_COMMANDREPLAY_CREATE_INSTANCE_CALLBACK,
9779 ) -> Result<(), Error> {
9780 unsafe {
9781 match ffi::FMOD_Studio_CommandReplay_SetCreateInstanceCallback(self.pointer, callback) {
9782 ffi::FMOD_OK => Ok(()),
9783 error => Err(err_fmod!(
9784 "FMOD_Studio_CommandReplay_SetCreateInstanceCallback",
9785 error
9786 )),
9787 }
9788 }
9789 }
9790 pub fn get_user_data(&self) -> Result<*mut c_void, Error> {
9791 unsafe {
9792 let mut userdata = null_mut();
9793 match ffi::FMOD_Studio_CommandReplay_GetUserData(self.pointer, &mut userdata) {
9794 ffi::FMOD_OK => Ok(userdata),
9795 error => Err(err_fmod!("FMOD_Studio_CommandReplay_GetUserData", error)),
9796 }
9797 }
9798 }
9799 pub fn set_user_data(&self, userdata: *mut c_void) -> Result<(), Error> {
9800 unsafe {
9801 match ffi::FMOD_Studio_CommandReplay_SetUserData(self.pointer, userdata) {
9802 ffi::FMOD_OK => Ok(()),
9803 error => Err(err_fmod!("FMOD_Studio_CommandReplay_SetUserData", error)),
9804 }
9805 }
9806 }
9807}
9808#[derive(Debug, Clone, Copy)]
9809pub struct EventDescription {
9810 pointer: *mut ffi::FMOD_STUDIO_EVENTDESCRIPTION,
9811}
9812unsafe impl Send for EventDescription {}
9813unsafe impl Sync for EventDescription {}
9814impl EventDescription {
9815 #[inline]
9816 pub fn from(pointer: *mut ffi::FMOD_STUDIO_EVENTDESCRIPTION) -> Self {
9817 Self { pointer }
9818 }
9819 #[inline]
9820 pub fn as_mut_ptr(&self) -> *mut ffi::FMOD_STUDIO_EVENTDESCRIPTION {
9821 self.pointer
9822 }
9823 pub fn is_valid(&self) -> bool {
9824 unsafe { to_bool!(ffi::FMOD_Studio_EventDescription_IsValid(self.pointer)) }
9825 }
9826 pub fn get_id(&self) -> Result<Guid, Error> {
9827 unsafe {
9828 let mut id = ffi::FMOD_GUID::default();
9829 match ffi::FMOD_Studio_EventDescription_GetID(self.pointer, &mut id) {
9830 ffi::FMOD_OK => Ok(Guid::try_from(id)?),
9831 error => Err(err_fmod!("FMOD_Studio_EventDescription_GetID", error)),
9832 }
9833 }
9834 }
9835 pub fn get_path(&self) -> Result<String, Error> {
9836 unsafe {
9837 let mut retrieved = i32::default();
9838 match ffi::FMOD_Studio_EventDescription_GetPath(
9839 self.pointer,
9840 null_mut(),
9841 0,
9842 &mut retrieved,
9843 ) {
9844 ffi::FMOD_OK => {
9845 let mut buf = vec![0u8; retrieved as usize];
9846 match ffi::FMOD_Studio_EventDescription_GetPath(
9847 self.pointer,
9848 buf.as_mut_ptr() as *mut _,
9849 retrieved,
9850 &mut retrieved,
9851 ) {
9852 ffi::FMOD_OK => Ok(CString::from_vec_with_nul_unchecked(buf)
9853 .into_string()
9854 .map_err(Error::String)?),
9855 error => Err(err_fmod!("FMOD_Studio_EventDescription_GetPath", error)),
9856 }
9857 }
9858 error => Err(err_fmod!("FMOD_Studio_EventDescription_GetPath", error)),
9859 }
9860 }
9861 }
9862 pub fn get_parameter_description_count(&self) -> Result<i32, Error> {
9863 unsafe {
9864 let mut count = i32::default();
9865 match ffi::FMOD_Studio_EventDescription_GetParameterDescriptionCount(
9866 self.pointer,
9867 &mut count,
9868 ) {
9869 ffi::FMOD_OK => Ok(count),
9870 error => Err(err_fmod!(
9871 "FMOD_Studio_EventDescription_GetParameterDescriptionCount",
9872 error
9873 )),
9874 }
9875 }
9876 }
9877 pub fn get_parameter_description_by_index(
9878 &self,
9879 index: i32,
9880 ) -> Result<ParameterDescription, Error> {
9881 unsafe {
9882 let mut parameter = ffi::FMOD_STUDIO_PARAMETER_DESCRIPTION::default();
9883 match ffi::FMOD_Studio_EventDescription_GetParameterDescriptionByIndex(
9884 self.pointer,
9885 index,
9886 &mut parameter,
9887 ) {
9888 ffi::FMOD_OK => Ok(ParameterDescription::try_from(parameter)?),
9889 error => Err(err_fmod!(
9890 "FMOD_Studio_EventDescription_GetParameterDescriptionByIndex",
9891 error
9892 )),
9893 }
9894 }
9895 }
9896 pub fn get_parameter_description_by_name(
9897 &self,
9898 name: &str,
9899 ) -> Result<ParameterDescription, Error> {
9900 unsafe {
9901 let mut parameter = ffi::FMOD_STUDIO_PARAMETER_DESCRIPTION::default();
9902 match ffi::FMOD_Studio_EventDescription_GetParameterDescriptionByName(
9903 self.pointer,
9904 CString::new(name)?.as_ptr(),
9905 &mut parameter,
9906 ) {
9907 ffi::FMOD_OK => Ok(ParameterDescription::try_from(parameter)?),
9908 error => Err(err_fmod!(
9909 "FMOD_Studio_EventDescription_GetParameterDescriptionByName",
9910 error
9911 )),
9912 }
9913 }
9914 }
9915 pub fn get_parameter_description_by_id(
9916 &self,
9917 id: ParameterId,
9918 ) -> Result<ParameterDescription, Error> {
9919 unsafe {
9920 let mut parameter = ffi::FMOD_STUDIO_PARAMETER_DESCRIPTION::default();
9921 match ffi::FMOD_Studio_EventDescription_GetParameterDescriptionByID(
9922 self.pointer,
9923 id.into(),
9924 &mut parameter,
9925 ) {
9926 ffi::FMOD_OK => Ok(ParameterDescription::try_from(parameter)?),
9927 error => Err(err_fmod!(
9928 "FMOD_Studio_EventDescription_GetParameterDescriptionByID",
9929 error
9930 )),
9931 }
9932 }
9933 }
9934 pub fn get_parameter_label_by_index(
9935 &self,
9936 index: i32,
9937 labelindex: i32,
9938 size: i32,
9939 ) -> Result<(String, i32), Error> {
9940 unsafe {
9941 let label = string_buffer!(size);
9942 let mut retrieved = i32::default();
9943 match ffi::FMOD_Studio_EventDescription_GetParameterLabelByIndex(
9944 self.pointer,
9945 index,
9946 labelindex,
9947 label,
9948 size,
9949 &mut retrieved,
9950 ) {
9951 ffi::FMOD_OK => Ok((to_string!(label)?, retrieved)),
9952 error => Err(err_fmod!(
9953 "FMOD_Studio_EventDescription_GetParameterLabelByIndex",
9954 error
9955 )),
9956 }
9957 }
9958 }
9959 pub fn get_parameter_label_by_name(
9960 &self,
9961 name: &str,
9962 labelindex: i32,
9963 size: i32,
9964 ) -> Result<(String, i32), Error> {
9965 unsafe {
9966 let label = string_buffer!(size);
9967 let mut retrieved = i32::default();
9968 match ffi::FMOD_Studio_EventDescription_GetParameterLabelByName(
9969 self.pointer,
9970 CString::new(name)?.as_ptr(),
9971 labelindex,
9972 label,
9973 size,
9974 &mut retrieved,
9975 ) {
9976 ffi::FMOD_OK => Ok((to_string!(label)?, retrieved)),
9977 error => Err(err_fmod!(
9978 "FMOD_Studio_EventDescription_GetParameterLabelByName",
9979 error
9980 )),
9981 }
9982 }
9983 }
9984 pub fn get_parameter_label_by_id(
9985 &self,
9986 id: ParameterId,
9987 labelindex: i32,
9988 size: i32,
9989 ) -> Result<(String, i32), Error> {
9990 unsafe {
9991 let label = string_buffer!(size);
9992 let mut retrieved = i32::default();
9993 match ffi::FMOD_Studio_EventDescription_GetParameterLabelByID(
9994 self.pointer,
9995 id.into(),
9996 labelindex,
9997 label,
9998 size,
9999 &mut retrieved,
10000 ) {
10001 ffi::FMOD_OK => Ok((to_string!(label)?, retrieved)),
10002 error => Err(err_fmod!(
10003 "FMOD_Studio_EventDescription_GetParameterLabelByID",
10004 error
10005 )),
10006 }
10007 }
10008 }
10009 pub fn get_user_property_count(&self) -> Result<i32, Error> {
10010 unsafe {
10011 let mut count = i32::default();
10012 match ffi::FMOD_Studio_EventDescription_GetUserPropertyCount(self.pointer, &mut count) {
10013 ffi::FMOD_OK => Ok(count),
10014 error => Err(err_fmod!(
10015 "FMOD_Studio_EventDescription_GetUserPropertyCount",
10016 error
10017 )),
10018 }
10019 }
10020 }
10021 pub fn get_user_property_by_index(&self, index: i32) -> Result<UserProperty, Error> {
10022 unsafe {
10023 let mut property = ffi::FMOD_STUDIO_USER_PROPERTY::default();
10024 match ffi::FMOD_Studio_EventDescription_GetUserPropertyByIndex(
10025 self.pointer,
10026 index,
10027 &mut property,
10028 ) {
10029 ffi::FMOD_OK => Ok(UserProperty::try_from(property)?),
10030 error => Err(err_fmod!(
10031 "FMOD_Studio_EventDescription_GetUserPropertyByIndex",
10032 error
10033 )),
10034 }
10035 }
10036 }
10037 pub fn get_user_property(&self, name: &str) -> Result<UserProperty, Error> {
10038 unsafe {
10039 let mut property = ffi::FMOD_STUDIO_USER_PROPERTY::default();
10040 match ffi::FMOD_Studio_EventDescription_GetUserProperty(
10041 self.pointer,
10042 CString::new(name)?.as_ptr(),
10043 &mut property,
10044 ) {
10045 ffi::FMOD_OK => Ok(UserProperty::try_from(property)?),
10046 error => Err(err_fmod!(
10047 "FMOD_Studio_EventDescription_GetUserProperty",
10048 error
10049 )),
10050 }
10051 }
10052 }
10053 pub fn get_length(&self) -> Result<i32, Error> {
10054 unsafe {
10055 let mut length = i32::default();
10056 match ffi::FMOD_Studio_EventDescription_GetLength(self.pointer, &mut length) {
10057 ffi::FMOD_OK => Ok(length),
10058 error => Err(err_fmod!("FMOD_Studio_EventDescription_GetLength", error)),
10059 }
10060 }
10061 }
10062 pub fn get_min_max_distance(&self) -> Result<(f32, f32), Error> {
10063 unsafe {
10064 let mut min = f32::default();
10065 let mut max = f32::default();
10066 match ffi::FMOD_Studio_EventDescription_GetMinMaxDistance(
10067 self.pointer,
10068 &mut min,
10069 &mut max,
10070 ) {
10071 ffi::FMOD_OK => Ok((min, max)),
10072 error => Err(err_fmod!(
10073 "FMOD_Studio_EventDescription_GetMinMaxDistance",
10074 error
10075 )),
10076 }
10077 }
10078 }
10079 pub fn get_sound_size(&self) -> Result<f32, Error> {
10080 unsafe {
10081 let mut size = f32::default();
10082 match ffi::FMOD_Studio_EventDescription_GetSoundSize(self.pointer, &mut size) {
10083 ffi::FMOD_OK => Ok(size),
10084 error => Err(err_fmod!(
10085 "FMOD_Studio_EventDescription_GetSoundSize",
10086 error
10087 )),
10088 }
10089 }
10090 }
10091 pub fn is_snapshot(&self) -> Result<bool, Error> {
10092 unsafe {
10093 let mut snapshot = ffi::FMOD_BOOL::default();
10094 match ffi::FMOD_Studio_EventDescription_IsSnapshot(self.pointer, &mut snapshot) {
10095 ffi::FMOD_OK => Ok(to_bool!(snapshot)),
10096 error => Err(err_fmod!("FMOD_Studio_EventDescription_IsSnapshot", error)),
10097 }
10098 }
10099 }
10100 pub fn is_oneshot(&self) -> Result<bool, Error> {
10101 unsafe {
10102 let mut oneshot = ffi::FMOD_BOOL::default();
10103 match ffi::FMOD_Studio_EventDescription_IsOneshot(self.pointer, &mut oneshot) {
10104 ffi::FMOD_OK => Ok(to_bool!(oneshot)),
10105 error => Err(err_fmod!("FMOD_Studio_EventDescription_IsOneshot", error)),
10106 }
10107 }
10108 }
10109 pub fn is_stream(&self) -> Result<bool, Error> {
10110 unsafe {
10111 let mut is_stream = ffi::FMOD_BOOL::default();
10112 match ffi::FMOD_Studio_EventDescription_IsStream(self.pointer, &mut is_stream) {
10113 ffi::FMOD_OK => Ok(to_bool!(is_stream)),
10114 error => Err(err_fmod!("FMOD_Studio_EventDescription_IsStream", error)),
10115 }
10116 }
10117 }
10118 pub fn is_3d(&self) -> Result<bool, Error> {
10119 unsafe {
10120 let mut is_3_d = ffi::FMOD_BOOL::default();
10121 match ffi::FMOD_Studio_EventDescription_Is3D(self.pointer, &mut is_3_d) {
10122 ffi::FMOD_OK => Ok(to_bool!(is_3_d)),
10123 error => Err(err_fmod!("FMOD_Studio_EventDescription_Is3D", error)),
10124 }
10125 }
10126 }
10127 pub fn is_doppler_enabled(&self) -> Result<bool, Error> {
10128 unsafe {
10129 let mut doppler = ffi::FMOD_BOOL::default();
10130 match ffi::FMOD_Studio_EventDescription_IsDopplerEnabled(self.pointer, &mut doppler) {
10131 ffi::FMOD_OK => Ok(to_bool!(doppler)),
10132 error => Err(err_fmod!(
10133 "FMOD_Studio_EventDescription_IsDopplerEnabled",
10134 error
10135 )),
10136 }
10137 }
10138 }
10139 pub fn has_sustain_point(&self) -> Result<bool, Error> {
10140 unsafe {
10141 let mut sustain_point = ffi::FMOD_BOOL::default();
10142 match ffi::FMOD_Studio_EventDescription_HasSustainPoint(
10143 self.pointer,
10144 &mut sustain_point,
10145 ) {
10146 ffi::FMOD_OK => Ok(to_bool!(sustain_point)),
10147 error => Err(err_fmod!(
10148 "FMOD_Studio_EventDescription_HasSustainPoint",
10149 error
10150 )),
10151 }
10152 }
10153 }
10154 pub fn create_instance(&self) -> Result<EventInstance, Error> {
10155 unsafe {
10156 let mut instance = null_mut();
10157 match ffi::FMOD_Studio_EventDescription_CreateInstance(self.pointer, &mut instance) {
10158 ffi::FMOD_OK => Ok(EventInstance::from(instance)),
10159 error => Err(err_fmod!(
10160 "FMOD_Studio_EventDescription_CreateInstance",
10161 error
10162 )),
10163 }
10164 }
10165 }
10166 pub fn get_instance_count(&self) -> Result<i32, Error> {
10167 unsafe {
10168 let mut count = i32::default();
10169 match ffi::FMOD_Studio_EventDescription_GetInstanceCount(self.pointer, &mut count) {
10170 ffi::FMOD_OK => Ok(count),
10171 error => Err(err_fmod!(
10172 "FMOD_Studio_EventDescription_GetInstanceCount",
10173 error
10174 )),
10175 }
10176 }
10177 }
10178 pub fn get_instance_list(&self, capacity: i32) -> Result<Vec<EventInstance>, Error> {
10179 unsafe {
10180 let mut array = vec![null_mut(); capacity as usize];
10181 let mut count = i32::default();
10182 match ffi::FMOD_Studio_EventDescription_GetInstanceList(
10183 self.pointer,
10184 array.as_mut_ptr(),
10185 capacity,
10186 &mut count,
10187 ) {
10188 ffi::FMOD_OK => Ok(array
10189 .into_iter()
10190 .take(count as usize)
10191 .map(EventInstance::from)
10192 .collect()),
10193 error => Err(err_fmod!(
10194 "FMOD_Studio_EventDescription_GetInstanceList",
10195 error
10196 )),
10197 }
10198 }
10199 }
10200 pub fn load_sample_data(&self) -> Result<(), Error> {
10201 unsafe {
10202 match ffi::FMOD_Studio_EventDescription_LoadSampleData(self.pointer) {
10203 ffi::FMOD_OK => Ok(()),
10204 error => Err(err_fmod!(
10205 "FMOD_Studio_EventDescription_LoadSampleData",
10206 error
10207 )),
10208 }
10209 }
10210 }
10211 pub fn unload_sample_data(&self) -> Result<(), Error> {
10212 unsafe {
10213 match ffi::FMOD_Studio_EventDescription_UnloadSampleData(self.pointer) {
10214 ffi::FMOD_OK => Ok(()),
10215 error => Err(err_fmod!(
10216 "FMOD_Studio_EventDescription_UnloadSampleData",
10217 error
10218 )),
10219 }
10220 }
10221 }
10222 pub fn get_sample_loading_state(&self) -> Result<LoadingState, Error> {
10223 unsafe {
10224 let mut state = ffi::FMOD_STUDIO_LOADING_STATE::default();
10225 match ffi::FMOD_Studio_EventDescription_GetSampleLoadingState(self.pointer, &mut state)
10226 {
10227 ffi::FMOD_OK => Ok(LoadingState::from(state)?),
10228 error => Err(err_fmod!(
10229 "FMOD_Studio_EventDescription_GetSampleLoadingState",
10230 error
10231 )),
10232 }
10233 }
10234 }
10235 pub fn release_all_instances(&self) -> Result<(), Error> {
10236 unsafe {
10237 match ffi::FMOD_Studio_EventDescription_ReleaseAllInstances(self.pointer) {
10238 ffi::FMOD_OK => Ok(()),
10239 error => Err(err_fmod!(
10240 "FMOD_Studio_EventDescription_ReleaseAllInstances",
10241 error
10242 )),
10243 }
10244 }
10245 }
10246 pub fn set_callback(
10247 &self,
10248 callback: ffi::FMOD_STUDIO_EVENT_CALLBACK,
10249 callbackmask: impl Into<ffi::FMOD_STUDIO_EVENT_CALLBACK_TYPE>,
10250 ) -> Result<(), Error> {
10251 unsafe {
10252 match ffi::FMOD_Studio_EventDescription_SetCallback(
10253 self.pointer,
10254 callback,
10255 callbackmask.into(),
10256 ) {
10257 ffi::FMOD_OK => Ok(()),
10258 error => Err(err_fmod!("FMOD_Studio_EventDescription_SetCallback", error)),
10259 }
10260 }
10261 }
10262 pub fn get_user_data(&self) -> Result<*mut c_void, Error> {
10263 unsafe {
10264 let mut userdata = null_mut();
10265 match ffi::FMOD_Studio_EventDescription_GetUserData(self.pointer, &mut userdata) {
10266 ffi::FMOD_OK => Ok(userdata),
10267 error => Err(err_fmod!("FMOD_Studio_EventDescription_GetUserData", error)),
10268 }
10269 }
10270 }
10271 pub fn set_user_data(&self, userdata: *mut c_void) -> Result<(), Error> {
10272 unsafe {
10273 match ffi::FMOD_Studio_EventDescription_SetUserData(self.pointer, userdata) {
10274 ffi::FMOD_OK => Ok(()),
10275 error => Err(err_fmod!("FMOD_Studio_EventDescription_SetUserData", error)),
10276 }
10277 }
10278 }
10279}
10280#[derive(Debug, Clone, Copy)]
10281pub struct EventInstance {
10282 pointer: *mut ffi::FMOD_STUDIO_EVENTINSTANCE,
10283}
10284unsafe impl Send for EventInstance {}
10285unsafe impl Sync for EventInstance {}
10286impl EventInstance {
10287 #[inline]
10288 pub fn from(pointer: *mut ffi::FMOD_STUDIO_EVENTINSTANCE) -> Self {
10289 Self { pointer }
10290 }
10291 #[inline]
10292 pub fn as_mut_ptr(&self) -> *mut ffi::FMOD_STUDIO_EVENTINSTANCE {
10293 self.pointer
10294 }
10295 pub fn is_valid(&self) -> bool {
10296 unsafe { to_bool!(ffi::FMOD_Studio_EventInstance_IsValid(self.pointer)) }
10297 }
10298 pub fn get_description(&self) -> Result<EventDescription, Error> {
10299 unsafe {
10300 let mut description = null_mut();
10301 match ffi::FMOD_Studio_EventInstance_GetDescription(self.pointer, &mut description) {
10302 ffi::FMOD_OK => Ok(EventDescription::from(description)),
10303 error => Err(err_fmod!("FMOD_Studio_EventInstance_GetDescription", error)),
10304 }
10305 }
10306 }
10307 pub fn get_volume(&self) -> Result<(f32, f32), Error> {
10308 unsafe {
10309 let mut volume = f32::default();
10310 let mut finalvolume = f32::default();
10311 match ffi::FMOD_Studio_EventInstance_GetVolume(
10312 self.pointer,
10313 &mut volume,
10314 &mut finalvolume,
10315 ) {
10316 ffi::FMOD_OK => Ok((volume, finalvolume)),
10317 error => Err(err_fmod!("FMOD_Studio_EventInstance_GetVolume", error)),
10318 }
10319 }
10320 }
10321 pub fn set_volume(&self, volume: f32) -> Result<(), Error> {
10322 unsafe {
10323 match ffi::FMOD_Studio_EventInstance_SetVolume(self.pointer, volume) {
10324 ffi::FMOD_OK => Ok(()),
10325 error => Err(err_fmod!("FMOD_Studio_EventInstance_SetVolume", error)),
10326 }
10327 }
10328 }
10329 pub fn get_pitch(&self) -> Result<(f32, f32), Error> {
10330 unsafe {
10331 let mut pitch = f32::default();
10332 let mut finalpitch = f32::default();
10333 match ffi::FMOD_Studio_EventInstance_GetPitch(self.pointer, &mut pitch, &mut finalpitch)
10334 {
10335 ffi::FMOD_OK => Ok((pitch, finalpitch)),
10336 error => Err(err_fmod!("FMOD_Studio_EventInstance_GetPitch", error)),
10337 }
10338 }
10339 }
10340 pub fn set_pitch(&self, pitch: f32) -> Result<(), Error> {
10341 unsafe {
10342 match ffi::FMOD_Studio_EventInstance_SetPitch(self.pointer, pitch) {
10343 ffi::FMOD_OK => Ok(()),
10344 error => Err(err_fmod!("FMOD_Studio_EventInstance_SetPitch", error)),
10345 }
10346 }
10347 }
10348 pub fn get_3d_attributes(&self) -> Result<Attributes3d, Error> {
10349 unsafe {
10350 let mut attributes = ffi::FMOD_3D_ATTRIBUTES::default();
10351 match ffi::FMOD_Studio_EventInstance_Get3DAttributes(self.pointer, &mut attributes) {
10352 ffi::FMOD_OK => Ok(Attributes3d::try_from(attributes)?),
10353 error => Err(err_fmod!(
10354 "FMOD_Studio_EventInstance_Get3DAttributes",
10355 error
10356 )),
10357 }
10358 }
10359 }
10360 pub fn set_3d_attributes(&self, attributes: Attributes3d) -> Result<(), Error> {
10361 unsafe {
10362 match ffi::FMOD_Studio_EventInstance_Set3DAttributes(
10363 self.pointer,
10364 &mut attributes.into(),
10365 ) {
10366 ffi::FMOD_OK => Ok(()),
10367 error => Err(err_fmod!(
10368 "FMOD_Studio_EventInstance_Set3DAttributes",
10369 error
10370 )),
10371 }
10372 }
10373 }
10374 pub fn get_listener_mask(&self) -> Result<u32, Error> {
10375 unsafe {
10376 let mut mask = u32::default();
10377 match ffi::FMOD_Studio_EventInstance_GetListenerMask(self.pointer, &mut mask) {
10378 ffi::FMOD_OK => Ok(mask),
10379 error => Err(err_fmod!(
10380 "FMOD_Studio_EventInstance_GetListenerMask",
10381 error
10382 )),
10383 }
10384 }
10385 }
10386 pub fn set_listener_mask(&self, mask: u32) -> Result<(), Error> {
10387 unsafe {
10388 match ffi::FMOD_Studio_EventInstance_SetListenerMask(self.pointer, mask) {
10389 ffi::FMOD_OK => Ok(()),
10390 error => Err(err_fmod!(
10391 "FMOD_Studio_EventInstance_SetListenerMask",
10392 error
10393 )),
10394 }
10395 }
10396 }
10397 pub fn get_property(&self, index: EventProperty) -> Result<f32, Error> {
10398 unsafe {
10399 let mut value = f32::default();
10400 match ffi::FMOD_Studio_EventInstance_GetProperty(self.pointer, index.into(), &mut value)
10401 {
10402 ffi::FMOD_OK => Ok(value),
10403 error => Err(err_fmod!("FMOD_Studio_EventInstance_GetProperty", error)),
10404 }
10405 }
10406 }
10407 pub fn set_property(&self, index: EventProperty, value: f32) -> Result<(), Error> {
10408 unsafe {
10409 match ffi::FMOD_Studio_EventInstance_SetProperty(self.pointer, index.into(), value) {
10410 ffi::FMOD_OK => Ok(()),
10411 error => Err(err_fmod!("FMOD_Studio_EventInstance_SetProperty", error)),
10412 }
10413 }
10414 }
10415 pub fn get_reverb_level(&self, index: i32) -> Result<f32, Error> {
10416 unsafe {
10417 let mut level = f32::default();
10418 match ffi::FMOD_Studio_EventInstance_GetReverbLevel(self.pointer, index, &mut level) {
10419 ffi::FMOD_OK => Ok(level),
10420 error => Err(err_fmod!("FMOD_Studio_EventInstance_GetReverbLevel", error)),
10421 }
10422 }
10423 }
10424 pub fn set_reverb_level(&self, index: i32, level: f32) -> Result<(), Error> {
10425 unsafe {
10426 match ffi::FMOD_Studio_EventInstance_SetReverbLevel(self.pointer, index, level) {
10427 ffi::FMOD_OK => Ok(()),
10428 error => Err(err_fmod!("FMOD_Studio_EventInstance_SetReverbLevel", error)),
10429 }
10430 }
10431 }
10432 pub fn get_paused(&self) -> Result<bool, Error> {
10433 unsafe {
10434 let mut paused = ffi::FMOD_BOOL::default();
10435 match ffi::FMOD_Studio_EventInstance_GetPaused(self.pointer, &mut paused) {
10436 ffi::FMOD_OK => Ok(to_bool!(paused)),
10437 error => Err(err_fmod!("FMOD_Studio_EventInstance_GetPaused", error)),
10438 }
10439 }
10440 }
10441 pub fn set_paused(&self, paused: bool) -> Result<(), Error> {
10442 unsafe {
10443 match ffi::FMOD_Studio_EventInstance_SetPaused(self.pointer, from_bool!(paused)) {
10444 ffi::FMOD_OK => Ok(()),
10445 error => Err(err_fmod!("FMOD_Studio_EventInstance_SetPaused", error)),
10446 }
10447 }
10448 }
10449 pub fn start(&self) -> Result<(), Error> {
10450 unsafe {
10451 match ffi::FMOD_Studio_EventInstance_Start(self.pointer) {
10452 ffi::FMOD_OK => Ok(()),
10453 error => Err(err_fmod!("FMOD_Studio_EventInstance_Start", error)),
10454 }
10455 }
10456 }
10457 pub fn stop(&self, mode: StopMode) -> Result<(), Error> {
10458 unsafe {
10459 match ffi::FMOD_Studio_EventInstance_Stop(self.pointer, mode.into()) {
10460 ffi::FMOD_OK => Ok(()),
10461 error => Err(err_fmod!("FMOD_Studio_EventInstance_Stop", error)),
10462 }
10463 }
10464 }
10465 pub fn get_timeline_position(&self) -> Result<i32, Error> {
10466 unsafe {
10467 let mut position = i32::default();
10468 match ffi::FMOD_Studio_EventInstance_GetTimelinePosition(self.pointer, &mut position) {
10469 ffi::FMOD_OK => Ok(position),
10470 error => Err(err_fmod!(
10471 "FMOD_Studio_EventInstance_GetTimelinePosition",
10472 error
10473 )),
10474 }
10475 }
10476 }
10477 pub fn set_timeline_position(&self, position: i32) -> Result<(), Error> {
10478 unsafe {
10479 match ffi::FMOD_Studio_EventInstance_SetTimelinePosition(self.pointer, position) {
10480 ffi::FMOD_OK => Ok(()),
10481 error => Err(err_fmod!(
10482 "FMOD_Studio_EventInstance_SetTimelinePosition",
10483 error
10484 )),
10485 }
10486 }
10487 }
10488 pub fn get_playback_state(&self) -> Result<PlaybackState, Error> {
10489 unsafe {
10490 let mut state = ffi::FMOD_STUDIO_PLAYBACK_STATE::default();
10491 match ffi::FMOD_Studio_EventInstance_GetPlaybackState(self.pointer, &mut state) {
10492 ffi::FMOD_OK => Ok(PlaybackState::from(state)?),
10493 error => Err(err_fmod!(
10494 "FMOD_Studio_EventInstance_GetPlaybackState",
10495 error
10496 )),
10497 }
10498 }
10499 }
10500 pub fn get_channel_group(&self) -> Result<ChannelGroup, Error> {
10501 unsafe {
10502 let mut group = null_mut();
10503 match ffi::FMOD_Studio_EventInstance_GetChannelGroup(self.pointer, &mut group) {
10504 ffi::FMOD_OK => Ok(ChannelGroup::from(group)),
10505 error => Err(err_fmod!(
10506 "FMOD_Studio_EventInstance_GetChannelGroup",
10507 error
10508 )),
10509 }
10510 }
10511 }
10512 pub fn get_min_max_distance(&self) -> Result<(f32, f32), Error> {
10513 unsafe {
10514 let mut min = f32::default();
10515 let mut max = f32::default();
10516 match ffi::FMOD_Studio_EventInstance_GetMinMaxDistance(self.pointer, &mut min, &mut max)
10517 {
10518 ffi::FMOD_OK => Ok((min, max)),
10519 error => Err(err_fmod!(
10520 "FMOD_Studio_EventInstance_GetMinMaxDistance",
10521 error
10522 )),
10523 }
10524 }
10525 }
10526 pub fn release(&self) -> Result<(), Error> {
10527 unsafe {
10528 match ffi::FMOD_Studio_EventInstance_Release(self.pointer) {
10529 ffi::FMOD_OK => Ok(()),
10530 error => Err(err_fmod!("FMOD_Studio_EventInstance_Release", error)),
10531 }
10532 }
10533 }
10534 pub fn is_virtual(&self) -> Result<bool, Error> {
10535 unsafe {
10536 let mut virtualstate = ffi::FMOD_BOOL::default();
10537 match ffi::FMOD_Studio_EventInstance_IsVirtual(self.pointer, &mut virtualstate) {
10538 ffi::FMOD_OK => Ok(to_bool!(virtualstate)),
10539 error => Err(err_fmod!("FMOD_Studio_EventInstance_IsVirtual", error)),
10540 }
10541 }
10542 }
10543 pub fn get_parameter_by_name(&self, name: &str) -> Result<(f32, f32), Error> {
10544 unsafe {
10545 let mut value = f32::default();
10546 let mut finalvalue = f32::default();
10547 match ffi::FMOD_Studio_EventInstance_GetParameterByName(
10548 self.pointer,
10549 CString::new(name)?.as_ptr(),
10550 &mut value,
10551 &mut finalvalue,
10552 ) {
10553 ffi::FMOD_OK => Ok((value, finalvalue)),
10554 error => Err(err_fmod!(
10555 "FMOD_Studio_EventInstance_GetParameterByName",
10556 error
10557 )),
10558 }
10559 }
10560 }
10561 pub fn set_parameter_by_name(
10562 &self,
10563 name: &str,
10564 value: f32,
10565 ignoreseekspeed: bool,
10566 ) -> Result<(), Error> {
10567 unsafe {
10568 match ffi::FMOD_Studio_EventInstance_SetParameterByName(
10569 self.pointer,
10570 CString::new(name)?.as_ptr(),
10571 value,
10572 from_bool!(ignoreseekspeed),
10573 ) {
10574 ffi::FMOD_OK => Ok(()),
10575 error => Err(err_fmod!(
10576 "FMOD_Studio_EventInstance_SetParameterByName",
10577 error
10578 )),
10579 }
10580 }
10581 }
10582 pub fn set_parameter_by_name_with_label(
10583 &self,
10584 name: &str,
10585 label: &str,
10586 ignoreseekspeed: bool,
10587 ) -> Result<(), Error> {
10588 unsafe {
10589 match ffi::FMOD_Studio_EventInstance_SetParameterByNameWithLabel(
10590 self.pointer,
10591 CString::new(name)?.as_ptr(),
10592 CString::new(label)?.as_ptr(),
10593 from_bool!(ignoreseekspeed),
10594 ) {
10595 ffi::FMOD_OK => Ok(()),
10596 error => Err(err_fmod!(
10597 "FMOD_Studio_EventInstance_SetParameterByNameWithLabel",
10598 error
10599 )),
10600 }
10601 }
10602 }
10603 pub fn get_parameter_by_id(&self, id: ParameterId) -> Result<(f32, f32), Error> {
10604 unsafe {
10605 let mut value = f32::default();
10606 let mut finalvalue = f32::default();
10607 match ffi::FMOD_Studio_EventInstance_GetParameterByID(
10608 self.pointer,
10609 id.into(),
10610 &mut value,
10611 &mut finalvalue,
10612 ) {
10613 ffi::FMOD_OK => Ok((value, finalvalue)),
10614 error => Err(err_fmod!(
10615 "FMOD_Studio_EventInstance_GetParameterByID",
10616 error
10617 )),
10618 }
10619 }
10620 }
10621 pub fn set_parameter_by_id(
10622 &self,
10623 id: ParameterId,
10624 value: f32,
10625 ignoreseekspeed: bool,
10626 ) -> Result<(), Error> {
10627 unsafe {
10628 match ffi::FMOD_Studio_EventInstance_SetParameterByID(
10629 self.pointer,
10630 id.into(),
10631 value,
10632 from_bool!(ignoreseekspeed),
10633 ) {
10634 ffi::FMOD_OK => Ok(()),
10635 error => Err(err_fmod!(
10636 "FMOD_Studio_EventInstance_SetParameterByID",
10637 error
10638 )),
10639 }
10640 }
10641 }
10642 pub fn set_parameter_by_id_with_label(
10643 &self,
10644 id: ParameterId,
10645 label: &str,
10646 ignoreseekspeed: bool,
10647 ) -> Result<(), Error> {
10648 unsafe {
10649 match ffi::FMOD_Studio_EventInstance_SetParameterByIDWithLabel(
10650 self.pointer,
10651 id.into(),
10652 CString::new(label)?.as_ptr(),
10653 from_bool!(ignoreseekspeed),
10654 ) {
10655 ffi::FMOD_OK => Ok(()),
10656 error => Err(err_fmod!(
10657 "FMOD_Studio_EventInstance_SetParameterByIDWithLabel",
10658 error
10659 )),
10660 }
10661 }
10662 }
10663 pub fn set_parameters_by_i_ds(
10664 &self,
10665 ids: ParameterId,
10666 values: *mut f32,
10667 count: i32,
10668 ignoreseekspeed: bool,
10669 ) -> Result<(), Error> {
10670 unsafe {
10671 match ffi::FMOD_Studio_EventInstance_SetParametersByIDs(
10672 self.pointer,
10673 &ids.into(),
10674 values,
10675 count,
10676 from_bool!(ignoreseekspeed),
10677 ) {
10678 ffi::FMOD_OK => Ok(()),
10679 error => Err(err_fmod!(
10680 "FMOD_Studio_EventInstance_SetParametersByIDs",
10681 error
10682 )),
10683 }
10684 }
10685 }
10686 pub fn key_off(&self) -> Result<(), Error> {
10687 unsafe {
10688 match ffi::FMOD_Studio_EventInstance_KeyOff(self.pointer) {
10689 ffi::FMOD_OK => Ok(()),
10690 error => Err(err_fmod!("FMOD_Studio_EventInstance_KeyOff", error)),
10691 }
10692 }
10693 }
10694 pub fn set_callback(
10695 &self,
10696 callback: ffi::FMOD_STUDIO_EVENT_CALLBACK,
10697 callbackmask: impl Into<ffi::FMOD_STUDIO_EVENT_CALLBACK_TYPE>,
10698 ) -> Result<(), Error> {
10699 unsafe {
10700 match ffi::FMOD_Studio_EventInstance_SetCallback(
10701 self.pointer,
10702 callback,
10703 callbackmask.into(),
10704 ) {
10705 ffi::FMOD_OK => Ok(()),
10706 error => Err(err_fmod!("FMOD_Studio_EventInstance_SetCallback", error)),
10707 }
10708 }
10709 }
10710 pub fn get_user_data(&self) -> Result<*mut c_void, Error> {
10711 unsafe {
10712 let mut userdata = null_mut();
10713 match ffi::FMOD_Studio_EventInstance_GetUserData(self.pointer, &mut userdata) {
10714 ffi::FMOD_OK => Ok(userdata),
10715 error => Err(err_fmod!("FMOD_Studio_EventInstance_GetUserData", error)),
10716 }
10717 }
10718 }
10719 pub fn set_user_data(&self, userdata: *mut c_void) -> Result<(), Error> {
10720 unsafe {
10721 match ffi::FMOD_Studio_EventInstance_SetUserData(self.pointer, userdata) {
10722 ffi::FMOD_OK => Ok(()),
10723 error => Err(err_fmod!("FMOD_Studio_EventInstance_SetUserData", error)),
10724 }
10725 }
10726 }
10727 pub fn get_cpu_usage(&self) -> Result<(u32, u32), Error> {
10728 unsafe {
10729 let mut exclusive = u32::default();
10730 let mut inclusive = u32::default();
10731 match ffi::FMOD_Studio_EventInstance_GetCPUUsage(
10732 self.pointer,
10733 &mut exclusive,
10734 &mut inclusive,
10735 ) {
10736 ffi::FMOD_OK => Ok((exclusive, inclusive)),
10737 error => Err(err_fmod!("FMOD_Studio_EventInstance_GetCPUUsage", error)),
10738 }
10739 }
10740 }
10741 pub fn get_memory_usage(&self) -> Result<MemoryUsage, Error> {
10742 unsafe {
10743 let mut memoryusage = ffi::FMOD_STUDIO_MEMORY_USAGE::default();
10744 match ffi::FMOD_Studio_EventInstance_GetMemoryUsage(self.pointer, &mut memoryusage) {
10745 ffi::FMOD_OK => Ok(MemoryUsage::try_from(memoryusage)?),
10746 error => Err(err_fmod!("FMOD_Studio_EventInstance_GetMemoryUsage", error)),
10747 }
10748 }
10749 }
10750}
10751#[derive(Debug, Clone, Copy)]
10752pub struct Studio {
10753 pointer: *mut ffi::FMOD_STUDIO_SYSTEM,
10754}
10755unsafe impl Send for Studio {}
10756unsafe impl Sync for Studio {}
10757impl Studio {
10758 #[inline]
10759 pub fn from(pointer: *mut ffi::FMOD_STUDIO_SYSTEM) -> Self {
10760 Self { pointer }
10761 }
10762 #[inline]
10763 pub fn as_mut_ptr(&self) -> *mut ffi::FMOD_STUDIO_SYSTEM {
10764 self.pointer
10765 }
10766 pub fn create() -> Result<Studio, Error> {
10767 unsafe {
10768 let mut system = null_mut();
10769 match ffi::FMOD_Studio_System_Create(&mut system, ffi::FMOD_VERSION) {
10770 ffi::FMOD_OK => Ok(Studio::from(system)),
10771 error => Err(err_fmod!("FMOD_Studio_System_Create", error)),
10772 }
10773 }
10774 }
10775 pub fn is_valid(&self) -> bool {
10776 unsafe { to_bool!(ffi::FMOD_Studio_System_IsValid(self.pointer)) }
10777 }
10778 pub fn set_advanced_settings(&self, settings: StudioAdvancedSettings) -> Result<(), Error> {
10779 unsafe {
10780 match ffi::FMOD_Studio_System_SetAdvancedSettings(self.pointer, &mut settings.into()) {
10781 ffi::FMOD_OK => Ok(()),
10782 error => Err(err_fmod!("FMOD_Studio_System_SetAdvancedSettings", error)),
10783 }
10784 }
10785 }
10786 pub fn get_advanced_settings(&self) -> Result<StudioAdvancedSettings, Error> {
10787 unsafe {
10788 let mut settings = ffi::FMOD_STUDIO_ADVANCEDSETTINGS::default();
10789 match ffi::FMOD_Studio_System_GetAdvancedSettings(self.pointer, &mut settings) {
10790 ffi::FMOD_OK => Ok(StudioAdvancedSettings::try_from(settings)?),
10791 error => Err(err_fmod!("FMOD_Studio_System_GetAdvancedSettings", error)),
10792 }
10793 }
10794 }
10795 pub fn initialize(
10796 &self,
10797 maxchannels: i32,
10798 studioflags: impl Into<ffi::FMOD_STUDIO_INITFLAGS>,
10799 flags: impl Into<ffi::FMOD_INITFLAGS>,
10800 extradriverdata: Option<*mut c_void>,
10801 ) -> Result<(), Error> {
10802 unsafe {
10803 match ffi::FMOD_Studio_System_Initialize(
10804 self.pointer,
10805 maxchannels,
10806 studioflags.into(),
10807 flags.into(),
10808 extradriverdata.unwrap_or(null_mut()),
10809 ) {
10810 ffi::FMOD_OK => Ok(()),
10811 error => Err(err_fmod!("FMOD_Studio_System_Initialize", error)),
10812 }
10813 }
10814 }
10815 pub fn release(&self) -> Result<(), Error> {
10816 unsafe {
10817 match ffi::FMOD_Studio_System_Release(self.pointer) {
10818 ffi::FMOD_OK => Ok(()),
10819 error => Err(err_fmod!("FMOD_Studio_System_Release", error)),
10820 }
10821 }
10822 }
10823 pub fn update(&self) -> Result<(), Error> {
10824 unsafe {
10825 match ffi::FMOD_Studio_System_Update(self.pointer) {
10826 ffi::FMOD_OK => Ok(()),
10827 error => Err(err_fmod!("FMOD_Studio_System_Update", error)),
10828 }
10829 }
10830 }
10831 pub fn get_core_system(&self) -> Result<System, Error> {
10832 unsafe {
10833 let mut coresystem = null_mut();
10834 match ffi::FMOD_Studio_System_GetCoreSystem(self.pointer, &mut coresystem) {
10835 ffi::FMOD_OK => Ok(System::from(coresystem)),
10836 error => Err(err_fmod!("FMOD_Studio_System_GetCoreSystem", error)),
10837 }
10838 }
10839 }
10840 pub fn get_event(&self, path_or_id: &str) -> Result<EventDescription, Error> {
10841 unsafe {
10842 let mut event = null_mut();
10843 match ffi::FMOD_Studio_System_GetEvent(
10844 self.pointer,
10845 CString::new(path_or_id)?.as_ptr(),
10846 &mut event,
10847 ) {
10848 ffi::FMOD_OK => Ok(EventDescription::from(event)),
10849 error => Err(err_fmod!("FMOD_Studio_System_GetEvent", error)),
10850 }
10851 }
10852 }
10853 pub fn get_bus(&self, path_or_id: &str) -> Result<Bus, Error> {
10854 unsafe {
10855 let mut bus = null_mut();
10856 match ffi::FMOD_Studio_System_GetBus(
10857 self.pointer,
10858 CString::new(path_or_id)?.as_ptr(),
10859 &mut bus,
10860 ) {
10861 ffi::FMOD_OK => Ok(Bus::from(bus)),
10862 error => Err(err_fmod!("FMOD_Studio_System_GetBus", error)),
10863 }
10864 }
10865 }
10866 pub fn get_vca(&self, path_or_id: &str) -> Result<Vca, Error> {
10867 unsafe {
10868 let mut vca = null_mut();
10869 match ffi::FMOD_Studio_System_GetVCA(
10870 self.pointer,
10871 CString::new(path_or_id)?.as_ptr(),
10872 &mut vca,
10873 ) {
10874 ffi::FMOD_OK => Ok(Vca::from(vca)),
10875 error => Err(err_fmod!("FMOD_Studio_System_GetVCA", error)),
10876 }
10877 }
10878 }
10879 pub fn get_bank(&self, path_or_id: &str) -> Result<Bank, Error> {
10880 unsafe {
10881 let mut bank = null_mut();
10882 match ffi::FMOD_Studio_System_GetBank(
10883 self.pointer,
10884 CString::new(path_or_id)?.as_ptr(),
10885 &mut bank,
10886 ) {
10887 ffi::FMOD_OK => Ok(Bank::from(bank)),
10888 error => Err(err_fmod!("FMOD_Studio_System_GetBank", error)),
10889 }
10890 }
10891 }
10892 pub fn get_event_by_id(&self, id: Guid) -> Result<EventDescription, Error> {
10893 unsafe {
10894 let mut event = null_mut();
10895 match ffi::FMOD_Studio_System_GetEventByID(self.pointer, &id.into(), &mut event) {
10896 ffi::FMOD_OK => Ok(EventDescription::from(event)),
10897 error => Err(err_fmod!("FMOD_Studio_System_GetEventByID", error)),
10898 }
10899 }
10900 }
10901 pub fn get_bus_by_id(&self, id: Guid) -> Result<Bus, Error> {
10902 unsafe {
10903 let mut bus = null_mut();
10904 match ffi::FMOD_Studio_System_GetBusByID(self.pointer, &id.into(), &mut bus) {
10905 ffi::FMOD_OK => Ok(Bus::from(bus)),
10906 error => Err(err_fmod!("FMOD_Studio_System_GetBusByID", error)),
10907 }
10908 }
10909 }
10910 pub fn get_vca_by_id(&self, id: Guid) -> Result<Vca, Error> {
10911 unsafe {
10912 let mut vca = null_mut();
10913 match ffi::FMOD_Studio_System_GetVCAByID(self.pointer, &id.into(), &mut vca) {
10914 ffi::FMOD_OK => Ok(Vca::from(vca)),
10915 error => Err(err_fmod!("FMOD_Studio_System_GetVCAByID", error)),
10916 }
10917 }
10918 }
10919 pub fn get_bank_by_id(&self, id: Guid) -> Result<Bank, Error> {
10920 unsafe {
10921 let mut bank = null_mut();
10922 match ffi::FMOD_Studio_System_GetBankByID(self.pointer, &id.into(), &mut bank) {
10923 ffi::FMOD_OK => Ok(Bank::from(bank)),
10924 error => Err(err_fmod!("FMOD_Studio_System_GetBankByID", error)),
10925 }
10926 }
10927 }
10928 pub fn get_sound_info(&self, key: &str) -> Result<SoundInfo, Error> {
10929 unsafe {
10930 let mut info = ffi::FMOD_STUDIO_SOUND_INFO::default();
10931 match ffi::FMOD_Studio_System_GetSoundInfo(
10932 self.pointer,
10933 CString::new(key)?.as_ptr(),
10934 &mut info,
10935 ) {
10936 ffi::FMOD_OK => Ok(SoundInfo::try_from(info)?),
10937 error => Err(err_fmod!("FMOD_Studio_System_GetSoundInfo", error)),
10938 }
10939 }
10940 }
10941 pub fn get_parameter_description_by_name(
10942 &self,
10943 name: &str,
10944 ) -> Result<ParameterDescription, Error> {
10945 unsafe {
10946 let mut parameter = ffi::FMOD_STUDIO_PARAMETER_DESCRIPTION::default();
10947 match ffi::FMOD_Studio_System_GetParameterDescriptionByName(
10948 self.pointer,
10949 CString::new(name)?.as_ptr(),
10950 &mut parameter,
10951 ) {
10952 ffi::FMOD_OK => Ok(ParameterDescription::try_from(parameter)?),
10953 error => Err(err_fmod!(
10954 "FMOD_Studio_System_GetParameterDescriptionByName",
10955 error
10956 )),
10957 }
10958 }
10959 }
10960 pub fn get_parameter_description_by_id(
10961 &self,
10962 id: ParameterId,
10963 ) -> Result<ParameterDescription, Error> {
10964 unsafe {
10965 let mut parameter = ffi::FMOD_STUDIO_PARAMETER_DESCRIPTION::default();
10966 match ffi::FMOD_Studio_System_GetParameterDescriptionByID(
10967 self.pointer,
10968 id.into(),
10969 &mut parameter,
10970 ) {
10971 ffi::FMOD_OK => Ok(ParameterDescription::try_from(parameter)?),
10972 error => Err(err_fmod!(
10973 "FMOD_Studio_System_GetParameterDescriptionByID",
10974 error
10975 )),
10976 }
10977 }
10978 }
10979 pub fn get_parameter_label_by_name(
10980 &self,
10981 name: &str,
10982 labelindex: i32,
10983 size: i32,
10984 ) -> Result<(String, i32), Error> {
10985 unsafe {
10986 let label = string_buffer!(size);
10987 let mut retrieved = i32::default();
10988 match ffi::FMOD_Studio_System_GetParameterLabelByName(
10989 self.pointer,
10990 CString::new(name)?.as_ptr(),
10991 labelindex,
10992 label,
10993 size,
10994 &mut retrieved,
10995 ) {
10996 ffi::FMOD_OK => Ok((to_string!(label)?, retrieved)),
10997 error => Err(err_fmod!(
10998 "FMOD_Studio_System_GetParameterLabelByName",
10999 error
11000 )),
11001 }
11002 }
11003 }
11004 pub fn get_parameter_label_by_id(
11005 &self,
11006 id: ParameterId,
11007 labelindex: i32,
11008 size: i32,
11009 ) -> Result<(String, i32), Error> {
11010 unsafe {
11011 let label = string_buffer!(size);
11012 let mut retrieved = i32::default();
11013 match ffi::FMOD_Studio_System_GetParameterLabelByID(
11014 self.pointer,
11015 id.into(),
11016 labelindex,
11017 label,
11018 size,
11019 &mut retrieved,
11020 ) {
11021 ffi::FMOD_OK => Ok((to_string!(label)?, retrieved)),
11022 error => Err(err_fmod!("FMOD_Studio_System_GetParameterLabelByID", error)),
11023 }
11024 }
11025 }
11026 pub fn get_parameter_by_id(&self, id: ParameterId) -> Result<(f32, f32), Error> {
11027 unsafe {
11028 let mut value = f32::default();
11029 let mut finalvalue = f32::default();
11030 match ffi::FMOD_Studio_System_GetParameterByID(
11031 self.pointer,
11032 id.into(),
11033 &mut value,
11034 &mut finalvalue,
11035 ) {
11036 ffi::FMOD_OK => Ok((value, finalvalue)),
11037 error => Err(err_fmod!("FMOD_Studio_System_GetParameterByID", error)),
11038 }
11039 }
11040 }
11041 pub fn set_parameter_by_id(
11042 &self,
11043 id: ParameterId,
11044 value: f32,
11045 ignoreseekspeed: bool,
11046 ) -> Result<(), Error> {
11047 unsafe {
11048 match ffi::FMOD_Studio_System_SetParameterByID(
11049 self.pointer,
11050 id.into(),
11051 value,
11052 from_bool!(ignoreseekspeed),
11053 ) {
11054 ffi::FMOD_OK => Ok(()),
11055 error => Err(err_fmod!("FMOD_Studio_System_SetParameterByID", error)),
11056 }
11057 }
11058 }
11059 pub fn set_parameter_by_id_with_label(
11060 &self,
11061 id: ParameterId,
11062 label: &str,
11063 ignoreseekspeed: bool,
11064 ) -> Result<(), Error> {
11065 unsafe {
11066 match ffi::FMOD_Studio_System_SetParameterByIDWithLabel(
11067 self.pointer,
11068 id.into(),
11069 CString::new(label)?.as_ptr(),
11070 from_bool!(ignoreseekspeed),
11071 ) {
11072 ffi::FMOD_OK => Ok(()),
11073 error => Err(err_fmod!(
11074 "FMOD_Studio_System_SetParameterByIDWithLabel",
11075 error
11076 )),
11077 }
11078 }
11079 }
11080 pub fn set_parameters_by_i_ds(
11081 &self,
11082 ids: ParameterId,
11083 values: *mut f32,
11084 count: i32,
11085 ignoreseekspeed: bool,
11086 ) -> Result<(), Error> {
11087 unsafe {
11088 match ffi::FMOD_Studio_System_SetParametersByIDs(
11089 self.pointer,
11090 &ids.into(),
11091 values,
11092 count,
11093 from_bool!(ignoreseekspeed),
11094 ) {
11095 ffi::FMOD_OK => Ok(()),
11096 error => Err(err_fmod!("FMOD_Studio_System_SetParametersByIDs", error)),
11097 }
11098 }
11099 }
11100 pub fn get_parameter_by_name(&self, name: &str) -> Result<(f32, f32), Error> {
11101 unsafe {
11102 let mut value = f32::default();
11103 let mut finalvalue = f32::default();
11104 match ffi::FMOD_Studio_System_GetParameterByName(
11105 self.pointer,
11106 CString::new(name)?.as_ptr(),
11107 &mut value,
11108 &mut finalvalue,
11109 ) {
11110 ffi::FMOD_OK => Ok((value, finalvalue)),
11111 error => Err(err_fmod!("FMOD_Studio_System_GetParameterByName", error)),
11112 }
11113 }
11114 }
11115 pub fn set_parameter_by_name(
11116 &self,
11117 name: &str,
11118 value: f32,
11119 ignoreseekspeed: bool,
11120 ) -> Result<(), Error> {
11121 unsafe {
11122 match ffi::FMOD_Studio_System_SetParameterByName(
11123 self.pointer,
11124 CString::new(name)?.as_ptr(),
11125 value,
11126 from_bool!(ignoreseekspeed),
11127 ) {
11128 ffi::FMOD_OK => Ok(()),
11129 error => Err(err_fmod!("FMOD_Studio_System_SetParameterByName", error)),
11130 }
11131 }
11132 }
11133 pub fn set_parameter_by_name_with_label(
11134 &self,
11135 name: &str,
11136 label: &str,
11137 ignoreseekspeed: bool,
11138 ) -> Result<(), Error> {
11139 unsafe {
11140 match ffi::FMOD_Studio_System_SetParameterByNameWithLabel(
11141 self.pointer,
11142 CString::new(name)?.as_ptr(),
11143 CString::new(label)?.as_ptr(),
11144 from_bool!(ignoreseekspeed),
11145 ) {
11146 ffi::FMOD_OK => Ok(()),
11147 error => Err(err_fmod!(
11148 "FMOD_Studio_System_SetParameterByNameWithLabel",
11149 error
11150 )),
11151 }
11152 }
11153 }
11154 pub fn lookup_id(&self, path: &str) -> Result<Guid, Error> {
11155 unsafe {
11156 let mut id = ffi::FMOD_GUID::default();
11157 match ffi::FMOD_Studio_System_LookupID(
11158 self.pointer,
11159 CString::new(path)?.as_ptr(),
11160 &mut id,
11161 ) {
11162 ffi::FMOD_OK => Ok(Guid::try_from(id)?),
11163 error => Err(err_fmod!("FMOD_Studio_System_LookupID", error)),
11164 }
11165 }
11166 }
11167 pub fn lookup_path(&self, id: Guid) -> Result<String, Error> {
11168 unsafe {
11169 let mut retrieved = i32::default();
11170 let id = id.into();
11171 match ffi::FMOD_Studio_System_LookupPath(
11172 self.pointer,
11173 &id,
11174 null_mut(),
11175 0,
11176 &mut retrieved,
11177 ) {
11178 ffi::FMOD_OK => {
11179 let mut buf = vec![0u8; retrieved as usize];
11180 match ffi::FMOD_Studio_System_LookupPath(
11181 self.pointer,
11182 &id,
11183 buf.as_mut_ptr() as *mut _,
11184 retrieved,
11185 &mut retrieved,
11186 ) {
11187 ffi::FMOD_OK => Ok(CString::from_vec_with_nul_unchecked(buf)
11188 .into_string()
11189 .map_err(Error::String)?),
11190 error => Err(err_fmod!("FMOD_Studio_System_LookupPath", error)),
11191 }
11192 }
11193 error => Err(err_fmod!("FMOD_Studio_System_LookupPath", error)),
11194 }
11195 }
11196 }
11197 pub fn get_num_listeners(&self) -> Result<i32, Error> {
11198 unsafe {
11199 let mut numlisteners = i32::default();
11200 match ffi::FMOD_Studio_System_GetNumListeners(self.pointer, &mut numlisteners) {
11201 ffi::FMOD_OK => Ok(numlisteners),
11202 error => Err(err_fmod!("FMOD_Studio_System_GetNumListeners", error)),
11203 }
11204 }
11205 }
11206 pub fn set_num_listeners(&self, numlisteners: i32) -> Result<(), Error> {
11207 unsafe {
11208 match ffi::FMOD_Studio_System_SetNumListeners(self.pointer, numlisteners) {
11209 ffi::FMOD_OK => Ok(()),
11210 error => Err(err_fmod!("FMOD_Studio_System_SetNumListeners", error)),
11211 }
11212 }
11213 }
11214 pub fn get_listener_attributes(&self, index: i32) -> Result<(Attributes3d, Vector), Error> {
11215 unsafe {
11216 let mut attributes = ffi::FMOD_3D_ATTRIBUTES::default();
11217 let mut attenuationposition = ffi::FMOD_VECTOR::default();
11218 match ffi::FMOD_Studio_System_GetListenerAttributes(
11219 self.pointer,
11220 index,
11221 &mut attributes,
11222 &mut attenuationposition,
11223 ) {
11224 ffi::FMOD_OK => Ok((
11225 Attributes3d::try_from(attributes)?,
11226 Vector::try_from(attenuationposition)?,
11227 )),
11228 error => Err(err_fmod!("FMOD_Studio_System_GetListenerAttributes", error)),
11229 }
11230 }
11231 }
11232 pub fn set_listener_attributes(
11233 &self,
11234 index: i32,
11235 attributes: Attributes3d,
11236 attenuationposition: Option<Vector>,
11237 ) -> Result<(), Error> {
11238 unsafe {
11239 match ffi::FMOD_Studio_System_SetListenerAttributes(
11240 self.pointer,
11241 index,
11242 &attributes.into(),
11243 attenuationposition
11244 .map(Vector::into)
11245 .as_ref()
11246 .map(from_ref)
11247 .unwrap_or_else(null),
11248 ) {
11249 ffi::FMOD_OK => Ok(()),
11250 error => Err(err_fmod!("FMOD_Studio_System_SetListenerAttributes", error)),
11251 }
11252 }
11253 }
11254 pub fn get_listener_weight(&self, index: i32) -> Result<f32, Error> {
11255 unsafe {
11256 let mut weight = f32::default();
11257 match ffi::FMOD_Studio_System_GetListenerWeight(self.pointer, index, &mut weight) {
11258 ffi::FMOD_OK => Ok(weight),
11259 error => Err(err_fmod!("FMOD_Studio_System_GetListenerWeight", error)),
11260 }
11261 }
11262 }
11263 pub fn set_listener_weight(&self, index: i32, weight: f32) -> Result<(), Error> {
11264 unsafe {
11265 match ffi::FMOD_Studio_System_SetListenerWeight(self.pointer, index, weight) {
11266 ffi::FMOD_OK => Ok(()),
11267 error => Err(err_fmod!("FMOD_Studio_System_SetListenerWeight", error)),
11268 }
11269 }
11270 }
11271 pub fn load_bank_file(
11272 &self,
11273 filename: &str,
11274 flags: impl Into<ffi::FMOD_STUDIO_LOAD_BANK_FLAGS>,
11275 ) -> Result<Bank, Error> {
11276 unsafe {
11277 let mut bank = null_mut();
11278 match ffi::FMOD_Studio_System_LoadBankFile(
11279 self.pointer,
11280 CString::new(filename)?.as_ptr(),
11281 flags.into(),
11282 &mut bank,
11283 ) {
11284 ffi::FMOD_OK => Ok(Bank::from(bank)),
11285 error => Err(err_fmod!("FMOD_Studio_System_LoadBankFile", error)),
11286 }
11287 }
11288 }
11289 pub fn load_bank_memory(
11290 &self,
11291 buffer: &[u8],
11292 flags: impl Into<ffi::FMOD_STUDIO_LOAD_BANK_FLAGS>,
11293 ) -> Result<Bank, Error> {
11294 unsafe {
11295 let mut bank = null_mut();
11296 match ffi::FMOD_Studio_System_LoadBankMemory(
11297 self.pointer,
11298 buffer.as_ptr() as *const std::os::raw::c_char,
11299 buffer.len() as std::os::raw::c_int,
11300 LoadMemoryMode::Memory.into(),
11301 flags.into(),
11302 &mut bank,
11303 ) {
11304 ffi::FMOD_OK => Ok(Bank::from(bank)),
11305 error => Err(err_fmod!("FMOD_Studio_System_LoadBankMemory", error)),
11306 }
11307 }
11308 }
11309 pub fn load_bank_custom(
11310 &self,
11311 info: BankInfo,
11312 flags: impl Into<ffi::FMOD_STUDIO_LOAD_BANK_FLAGS>,
11313 ) -> Result<Bank, Error> {
11314 unsafe {
11315 let mut bank = null_mut();
11316 match ffi::FMOD_Studio_System_LoadBankCustom(
11317 self.pointer,
11318 &info.into(),
11319 flags.into(),
11320 &mut bank,
11321 ) {
11322 ffi::FMOD_OK => Ok(Bank::from(bank)),
11323 error => Err(err_fmod!("FMOD_Studio_System_LoadBankCustom", error)),
11324 }
11325 }
11326 }
11327 pub fn register_plugin(&self, description: DspDescription) -> Result<(), Error> {
11328 unsafe {
11329 match ffi::FMOD_Studio_System_RegisterPlugin(self.pointer, &description.into()) {
11330 ffi::FMOD_OK => Ok(()),
11331 error => Err(err_fmod!("FMOD_Studio_System_RegisterPlugin", error)),
11332 }
11333 }
11334 }
11335 pub fn unregister_plugin(&self, name: &str) -> Result<(), Error> {
11336 unsafe {
11337 match ffi::FMOD_Studio_System_UnregisterPlugin(
11338 self.pointer,
11339 CString::new(name)?.as_ptr(),
11340 ) {
11341 ffi::FMOD_OK => Ok(()),
11342 error => Err(err_fmod!("FMOD_Studio_System_UnregisterPlugin", error)),
11343 }
11344 }
11345 }
11346 pub fn unload_all(&self) -> Result<(), Error> {
11347 unsafe {
11348 match ffi::FMOD_Studio_System_UnloadAll(self.pointer) {
11349 ffi::FMOD_OK => Ok(()),
11350 error => Err(err_fmod!("FMOD_Studio_System_UnloadAll", error)),
11351 }
11352 }
11353 }
11354 pub fn flush_commands(&self) -> Result<(), Error> {
11355 unsafe {
11356 match ffi::FMOD_Studio_System_FlushCommands(self.pointer) {
11357 ffi::FMOD_OK => Ok(()),
11358 error => Err(err_fmod!("FMOD_Studio_System_FlushCommands", error)),
11359 }
11360 }
11361 }
11362 pub fn flush_sample_loading(&self) -> Result<(), Error> {
11363 unsafe {
11364 match ffi::FMOD_Studio_System_FlushSampleLoading(self.pointer) {
11365 ffi::FMOD_OK => Ok(()),
11366 error => Err(err_fmod!("FMOD_Studio_System_FlushSampleLoading", error)),
11367 }
11368 }
11369 }
11370 pub fn start_command_capture(
11371 &self,
11372 filename: &str,
11373 flags: impl Into<ffi::FMOD_STUDIO_COMMANDCAPTURE_FLAGS>,
11374 ) -> Result<(), Error> {
11375 unsafe {
11376 match ffi::FMOD_Studio_System_StartCommandCapture(
11377 self.pointer,
11378 CString::new(filename)?.as_ptr(),
11379 flags.into(),
11380 ) {
11381 ffi::FMOD_OK => Ok(()),
11382 error => Err(err_fmod!("FMOD_Studio_System_StartCommandCapture", error)),
11383 }
11384 }
11385 }
11386 pub fn stop_command_capture(&self) -> Result<(), Error> {
11387 unsafe {
11388 match ffi::FMOD_Studio_System_StopCommandCapture(self.pointer) {
11389 ffi::FMOD_OK => Ok(()),
11390 error => Err(err_fmod!("FMOD_Studio_System_StopCommandCapture", error)),
11391 }
11392 }
11393 }
11394 pub fn load_command_replay(
11395 &self,
11396 filename: &str,
11397 flags: impl Into<ffi::FMOD_STUDIO_COMMANDREPLAY_FLAGS>,
11398 ) -> Result<CommandReplay, Error> {
11399 unsafe {
11400 let mut replay = null_mut();
11401 match ffi::FMOD_Studio_System_LoadCommandReplay(
11402 self.pointer,
11403 CString::new(filename)?.as_ptr(),
11404 flags.into(),
11405 &mut replay,
11406 ) {
11407 ffi::FMOD_OK => Ok(CommandReplay::from(replay)),
11408 error => Err(err_fmod!("FMOD_Studio_System_LoadCommandReplay", error)),
11409 }
11410 }
11411 }
11412 pub fn get_bank_count(&self) -> Result<i32, Error> {
11413 unsafe {
11414 let mut count = i32::default();
11415 match ffi::FMOD_Studio_System_GetBankCount(self.pointer, &mut count) {
11416 ffi::FMOD_OK => Ok(count),
11417 error => Err(err_fmod!("FMOD_Studio_System_GetBankCount", error)),
11418 }
11419 }
11420 }
11421 pub fn get_bank_list(&self, capacity: i32) -> Result<Vec<Bank>, Error> {
11422 unsafe {
11423 let mut array = vec![null_mut(); capacity as usize];
11424 let mut count = i32::default();
11425 match ffi::FMOD_Studio_System_GetBankList(
11426 self.pointer,
11427 array.as_mut_ptr(),
11428 capacity,
11429 &mut count,
11430 ) {
11431 ffi::FMOD_OK => Ok(array
11432 .into_iter()
11433 .take(count as usize)
11434 .map(Bank::from)
11435 .collect()),
11436 error => Err(err_fmod!("FMOD_Studio_System_GetBankList", error)),
11437 }
11438 }
11439 }
11440 pub fn get_parameter_description_count(&self) -> Result<i32, Error> {
11441 unsafe {
11442 let mut count = i32::default();
11443 match ffi::FMOD_Studio_System_GetParameterDescriptionCount(self.pointer, &mut count) {
11444 ffi::FMOD_OK => Ok(count),
11445 error => Err(err_fmod!(
11446 "FMOD_Studio_System_GetParameterDescriptionCount",
11447 error
11448 )),
11449 }
11450 }
11451 }
11452 pub fn get_parameter_description_list(
11453 &self,
11454 capacity: i32,
11455 ) -> Result<Vec<ParameterDescription>, Error> {
11456 unsafe {
11457 let mut array =
11458 vec![ffi::FMOD_STUDIO_PARAMETER_DESCRIPTION::default(); capacity as usize];
11459 let mut count = i32::default();
11460 match ffi::FMOD_Studio_System_GetParameterDescriptionList(
11461 self.pointer,
11462 array.as_mut_ptr(),
11463 capacity,
11464 &mut count,
11465 ) {
11466 ffi::FMOD_OK => Ok(array
11467 .into_iter()
11468 .take(count as usize)
11469 .map(ParameterDescription::try_from)
11470 .collect::<Result<_, Error>>()?),
11471 error => Err(err_fmod!(
11472 "FMOD_Studio_System_GetParameterDescriptionList",
11473 error
11474 )),
11475 }
11476 }
11477 }
11478 pub fn get_cpu_usage(&self) -> Result<(StudioCpuUsage, CpuUsage), Error> {
11479 unsafe {
11480 let mut usage = ffi::FMOD_STUDIO_CPU_USAGE::default();
11481 let mut usage_core = ffi::FMOD_CPU_USAGE::default();
11482 match ffi::FMOD_Studio_System_GetCPUUsage(self.pointer, &mut usage, &mut usage_core) {
11483 ffi::FMOD_OK => Ok((
11484 StudioCpuUsage::try_from(usage)?,
11485 CpuUsage::try_from(usage_core)?,
11486 )),
11487 error => Err(err_fmod!("FMOD_Studio_System_GetCPUUsage", error)),
11488 }
11489 }
11490 }
11491 pub fn get_buffer_usage(&self) -> Result<BufferUsage, Error> {
11492 unsafe {
11493 let mut usage = ffi::FMOD_STUDIO_BUFFER_USAGE::default();
11494 match ffi::FMOD_Studio_System_GetBufferUsage(self.pointer, &mut usage) {
11495 ffi::FMOD_OK => Ok(BufferUsage::try_from(usage)?),
11496 error => Err(err_fmod!("FMOD_Studio_System_GetBufferUsage", error)),
11497 }
11498 }
11499 }
11500 pub fn reset_buffer_usage(&self) -> Result<(), Error> {
11501 unsafe {
11502 match ffi::FMOD_Studio_System_ResetBufferUsage(self.pointer) {
11503 ffi::FMOD_OK => Ok(()),
11504 error => Err(err_fmod!("FMOD_Studio_System_ResetBufferUsage", error)),
11505 }
11506 }
11507 }
11508 pub fn set_callback(
11509 &self,
11510 callback: ffi::FMOD_STUDIO_SYSTEM_CALLBACK,
11511 callbackmask: impl Into<ffi::FMOD_STUDIO_SYSTEM_CALLBACK_TYPE>,
11512 ) -> Result<(), Error> {
11513 unsafe {
11514 match ffi::FMOD_Studio_System_SetCallback(self.pointer, callback, callbackmask.into()) {
11515 ffi::FMOD_OK => Ok(()),
11516 error => Err(err_fmod!("FMOD_Studio_System_SetCallback", error)),
11517 }
11518 }
11519 }
11520 pub fn set_user_data(&self, userdata: *mut c_void) -> Result<(), Error> {
11521 unsafe {
11522 match ffi::FMOD_Studio_System_SetUserData(self.pointer, userdata) {
11523 ffi::FMOD_OK => Ok(()),
11524 error => Err(err_fmod!("FMOD_Studio_System_SetUserData", error)),
11525 }
11526 }
11527 }
11528 pub fn get_user_data(&self) -> Result<*mut c_void, Error> {
11529 unsafe {
11530 let mut userdata = null_mut();
11531 match ffi::FMOD_Studio_System_GetUserData(self.pointer, &mut userdata) {
11532 ffi::FMOD_OK => Ok(userdata),
11533 error => Err(err_fmod!("FMOD_Studio_System_GetUserData", error)),
11534 }
11535 }
11536 }
11537 pub fn get_memory_usage(&self) -> Result<MemoryUsage, Error> {
11538 unsafe {
11539 let mut memoryusage = ffi::FMOD_STUDIO_MEMORY_USAGE::default();
11540 match ffi::FMOD_Studio_System_GetMemoryUsage(self.pointer, &mut memoryusage) {
11541 ffi::FMOD_OK => Ok(MemoryUsage::try_from(memoryusage)?),
11542 error => Err(err_fmod!("FMOD_Studio_System_GetMemoryUsage", error)),
11543 }
11544 }
11545 }
11546}
11547#[derive(Debug, Clone, Copy)]
11548pub struct Vca {
11549 pointer: *mut ffi::FMOD_STUDIO_VCA,
11550}
11551unsafe impl Send for Vca {}
11552unsafe impl Sync for Vca {}
11553impl Vca {
11554 #[inline]
11555 pub fn from(pointer: *mut ffi::FMOD_STUDIO_VCA) -> Self {
11556 Self { pointer }
11557 }
11558 #[inline]
11559 pub fn as_mut_ptr(&self) -> *mut ffi::FMOD_STUDIO_VCA {
11560 self.pointer
11561 }
11562 pub fn is_valid(&self) -> bool {
11563 unsafe { to_bool!(ffi::FMOD_Studio_VCA_IsValid(self.pointer)) }
11564 }
11565 pub fn get_id(&self) -> Result<Guid, Error> {
11566 unsafe {
11567 let mut id = ffi::FMOD_GUID::default();
11568 match ffi::FMOD_Studio_VCA_GetID(self.pointer, &mut id) {
11569 ffi::FMOD_OK => Ok(Guid::try_from(id)?),
11570 error => Err(err_fmod!("FMOD_Studio_VCA_GetID", error)),
11571 }
11572 }
11573 }
11574 pub fn get_path(&self) -> Result<String, Error> {
11575 unsafe {
11576 let mut retrieved = i32::default();
11577 match ffi::FMOD_Studio_VCA_GetPath(self.pointer, null_mut(), 0, &mut retrieved) {
11578 ffi::FMOD_OK => {
11579 let mut buf = vec![0u8; retrieved as usize];
11580 match ffi::FMOD_Studio_VCA_GetPath(
11581 self.pointer,
11582 buf.as_mut_ptr() as *mut _,
11583 retrieved,
11584 &mut retrieved,
11585 ) {
11586 ffi::FMOD_OK => Ok(CString::from_vec_with_nul_unchecked(buf)
11587 .into_string()
11588 .map_err(Error::String)?),
11589 error => Err(err_fmod!("FMOD_Studio_VCA_GetPath", error)),
11590 }
11591 }
11592 error => Err(err_fmod!("FMOD_Studio_VCA_GetPath", error)),
11593 }
11594 }
11595 }
11596 pub fn get_volume(&self) -> Result<(f32, f32), Error> {
11597 unsafe {
11598 let mut volume = f32::default();
11599 let mut finalvolume = f32::default();
11600 match ffi::FMOD_Studio_VCA_GetVolume(self.pointer, &mut volume, &mut finalvolume) {
11601 ffi::FMOD_OK => Ok((volume, finalvolume)),
11602 error => Err(err_fmod!("FMOD_Studio_VCA_GetVolume", error)),
11603 }
11604 }
11605 }
11606 pub fn set_volume(&self, volume: f32) -> Result<(), Error> {
11607 unsafe {
11608 match ffi::FMOD_Studio_VCA_SetVolume(self.pointer, volume) {
11609 ffi::FMOD_OK => Ok(()),
11610 error => Err(err_fmod!("FMOD_Studio_VCA_SetVolume", error)),
11611 }
11612 }
11613 }
11614}
11615#[derive(Debug, Clone, Copy)]
11616pub struct SyncPoint {
11617 pointer: *mut ffi::FMOD_SYNCPOINT,
11618}
11619unsafe impl Send for SyncPoint {}
11620unsafe impl Sync for SyncPoint {}
11621impl SyncPoint {
11622 #[inline]
11623 pub fn from(pointer: *mut ffi::FMOD_SYNCPOINT) -> Self {
11624 Self { pointer }
11625 }
11626 #[inline]
11627 pub fn as_mut_ptr(&self) -> *mut ffi::FMOD_SYNCPOINT {
11628 self.pointer
11629 }
11630}
11631#[derive(Debug, Clone, Copy)]
11632pub struct System {
11633 pointer: *mut ffi::FMOD_SYSTEM,
11634}
11635unsafe impl Send for System {}
11636unsafe impl Sync for System {}
11637impl System {
11638 #[inline]
11639 pub fn from(pointer: *mut ffi::FMOD_SYSTEM) -> Self {
11640 Self { pointer }
11641 }
11642 #[inline]
11643 pub fn as_mut_ptr(&self) -> *mut ffi::FMOD_SYSTEM {
11644 self.pointer
11645 }
11646 pub fn create() -> Result<System, Error> {
11647 unsafe {
11648 let mut system = null_mut();
11649 match ffi::FMOD_System_Create(&mut system, ffi::FMOD_VERSION) {
11650 ffi::FMOD_OK => Ok(System::from(system)),
11651 error => Err(err_fmod!("FMOD_System_Create", error)),
11652 }
11653 }
11654 }
11655 pub fn release(&self) -> Result<(), Error> {
11656 unsafe {
11657 match ffi::FMOD_System_Release(self.pointer) {
11658 ffi::FMOD_OK => Ok(()),
11659 error => Err(err_fmod!("FMOD_System_Release", error)),
11660 }
11661 }
11662 }
11663 pub fn set_output(&self, output: OutputType) -> Result<(), Error> {
11664 unsafe {
11665 match ffi::FMOD_System_SetOutput(self.pointer, output.into()) {
11666 ffi::FMOD_OK => Ok(()),
11667 error => Err(err_fmod!("FMOD_System_SetOutput", error)),
11668 }
11669 }
11670 }
11671 pub fn get_output(&self) -> Result<OutputType, Error> {
11672 unsafe {
11673 let mut output = ffi::FMOD_OUTPUTTYPE::default();
11674 match ffi::FMOD_System_GetOutput(self.pointer, &mut output) {
11675 ffi::FMOD_OK => Ok(OutputType::from(output)?),
11676 error => Err(err_fmod!("FMOD_System_GetOutput", error)),
11677 }
11678 }
11679 }
11680 pub fn get_num_drivers(&self) -> Result<i32, Error> {
11681 unsafe {
11682 let mut numdrivers = i32::default();
11683 match ffi::FMOD_System_GetNumDrivers(self.pointer, &mut numdrivers) {
11684 ffi::FMOD_OK => Ok(numdrivers),
11685 error => Err(err_fmod!("FMOD_System_GetNumDrivers", error)),
11686 }
11687 }
11688 }
11689 pub fn get_driver_info(
11690 &self,
11691 id: i32,
11692 namelen: i32,
11693 ) -> Result<(String, Guid, i32, SpeakerMode, i32), Error> {
11694 unsafe {
11695 let name = string_buffer!(namelen);
11696 let mut guid = ffi::FMOD_GUID::default();
11697 let mut systemrate = i32::default();
11698 let mut speakermode = ffi::FMOD_SPEAKERMODE::default();
11699 let mut speakermodechannels = i32::default();
11700 match ffi::FMOD_System_GetDriverInfo(
11701 self.pointer,
11702 id,
11703 name,
11704 namelen,
11705 &mut guid,
11706 &mut systemrate,
11707 &mut speakermode,
11708 &mut speakermodechannels,
11709 ) {
11710 ffi::FMOD_OK => Ok((
11711 to_string!(name)?,
11712 Guid::try_from(guid)?,
11713 systemrate,
11714 SpeakerMode::from(speakermode)?,
11715 speakermodechannels,
11716 )),
11717 error => Err(err_fmod!("FMOD_System_GetDriverInfo", error)),
11718 }
11719 }
11720 }
11721 pub fn set_driver(&self, driver: i32) -> Result<(), Error> {
11722 unsafe {
11723 match ffi::FMOD_System_SetDriver(self.pointer, driver) {
11724 ffi::FMOD_OK => Ok(()),
11725 error => Err(err_fmod!("FMOD_System_SetDriver", error)),
11726 }
11727 }
11728 }
11729 pub fn get_driver(&self) -> Result<i32, Error> {
11730 unsafe {
11731 let mut driver = i32::default();
11732 match ffi::FMOD_System_GetDriver(self.pointer, &mut driver) {
11733 ffi::FMOD_OK => Ok(driver),
11734 error => Err(err_fmod!("FMOD_System_GetDriver", error)),
11735 }
11736 }
11737 }
11738 pub fn set_software_channels(&self, numsoftwarechannels: i32) -> Result<(), Error> {
11739 unsafe {
11740 match ffi::FMOD_System_SetSoftwareChannels(self.pointer, numsoftwarechannels) {
11741 ffi::FMOD_OK => Ok(()),
11742 error => Err(err_fmod!("FMOD_System_SetSoftwareChannels", error)),
11743 }
11744 }
11745 }
11746 pub fn get_software_channels(&self) -> Result<i32, Error> {
11747 unsafe {
11748 let mut numsoftwarechannels = i32::default();
11749 match ffi::FMOD_System_GetSoftwareChannels(self.pointer, &mut numsoftwarechannels) {
11750 ffi::FMOD_OK => Ok(numsoftwarechannels),
11751 error => Err(err_fmod!("FMOD_System_GetSoftwareChannels", error)),
11752 }
11753 }
11754 }
11755 pub fn set_software_format(
11756 &self,
11757 samplerate: Option<i32>,
11758 speakermode: Option<SpeakerMode>,
11759 numrawspeakers: Option<i32>,
11760 ) -> Result<(), Error> {
11761 unsafe {
11762 match ffi::FMOD_System_SetSoftwareFormat(
11763 self.pointer,
11764 samplerate.unwrap_or(0),
11765 speakermode.map(|value| value.into()).unwrap_or(0),
11766 numrawspeakers.unwrap_or(0),
11767 ) {
11768 ffi::FMOD_OK => Ok(()),
11769 error => Err(err_fmod!("FMOD_System_SetSoftwareFormat", error)),
11770 }
11771 }
11772 }
11773 pub fn get_software_format(&self) -> Result<(i32, SpeakerMode, i32), Error> {
11774 unsafe {
11775 let mut samplerate = i32::default();
11776 let mut speakermode = ffi::FMOD_SPEAKERMODE::default();
11777 let mut numrawspeakers = i32::default();
11778 match ffi::FMOD_System_GetSoftwareFormat(
11779 self.pointer,
11780 &mut samplerate,
11781 &mut speakermode,
11782 &mut numrawspeakers,
11783 ) {
11784 ffi::FMOD_OK => Ok((samplerate, SpeakerMode::from(speakermode)?, numrawspeakers)),
11785 error => Err(err_fmod!("FMOD_System_GetSoftwareFormat", error)),
11786 }
11787 }
11788 }
11789 pub fn set_dsp_buffer_size(&self, bufferlength: u32, numbuffers: i32) -> Result<(), Error> {
11790 unsafe {
11791 match ffi::FMOD_System_SetDSPBufferSize(self.pointer, bufferlength, numbuffers) {
11792 ffi::FMOD_OK => Ok(()),
11793 error => Err(err_fmod!("FMOD_System_SetDSPBufferSize", error)),
11794 }
11795 }
11796 }
11797 pub fn get_dsp_buffer_size(&self) -> Result<(u32, i32), Error> {
11798 unsafe {
11799 let mut bufferlength = u32::default();
11800 let mut numbuffers = i32::default();
11801 match ffi::FMOD_System_GetDSPBufferSize(
11802 self.pointer,
11803 &mut bufferlength,
11804 &mut numbuffers,
11805 ) {
11806 ffi::FMOD_OK => Ok((bufferlength, numbuffers)),
11807 error => Err(err_fmod!("FMOD_System_GetDSPBufferSize", error)),
11808 }
11809 }
11810 }
11811 pub fn set_file_system(
11812 &self,
11813 useropen: ffi::FMOD_FILE_OPEN_CALLBACK,
11814 userclose: ffi::FMOD_FILE_CLOSE_CALLBACK,
11815 userread: ffi::FMOD_FILE_READ_CALLBACK,
11816 userseek: ffi::FMOD_FILE_SEEK_CALLBACK,
11817 userasyncread: ffi::FMOD_FILE_ASYNCREAD_CALLBACK,
11818 userasynccancel: ffi::FMOD_FILE_ASYNCCANCEL_CALLBACK,
11819 blockalign: Option<i32>,
11820 ) -> Result<(), Error> {
11821 unsafe {
11822 match ffi::FMOD_System_SetFileSystem(
11823 self.pointer,
11824 useropen,
11825 userclose,
11826 userread,
11827 userseek,
11828 userasyncread,
11829 userasynccancel,
11830 blockalign.unwrap_or(0),
11831 ) {
11832 ffi::FMOD_OK => Ok(()),
11833 error => Err(err_fmod!("FMOD_System_SetFileSystem", error)),
11834 }
11835 }
11836 }
11837 pub fn attach_file_system(
11838 &self,
11839 useropen: ffi::FMOD_FILE_OPEN_CALLBACK,
11840 userclose: ffi::FMOD_FILE_CLOSE_CALLBACK,
11841 userread: ffi::FMOD_FILE_READ_CALLBACK,
11842 userseek: ffi::FMOD_FILE_SEEK_CALLBACK,
11843 ) -> Result<(), Error> {
11844 unsafe {
11845 match ffi::FMOD_System_AttachFileSystem(
11846 self.pointer,
11847 useropen,
11848 userclose,
11849 userread,
11850 userseek,
11851 ) {
11852 ffi::FMOD_OK => Ok(()),
11853 error => Err(err_fmod!("FMOD_System_AttachFileSystem", error)),
11854 }
11855 }
11856 }
11857 pub fn set_advanced_settings(&self, settings: AdvancedSettings) -> Result<(), Error> {
11858 unsafe {
11859 match ffi::FMOD_System_SetAdvancedSettings(self.pointer, &mut settings.into()) {
11860 ffi::FMOD_OK => Ok(()),
11861 error => Err(err_fmod!("FMOD_System_SetAdvancedSettings", error)),
11862 }
11863 }
11864 }
11865 pub fn get_advanced_settings(&self) -> Result<AdvancedSettings, Error> {
11866 unsafe {
11867 let mut settings = ffi::FMOD_ADVANCEDSETTINGS::default();
11868 match ffi::FMOD_System_GetAdvancedSettings(self.pointer, &mut settings) {
11869 ffi::FMOD_OK => Ok(AdvancedSettings::try_from(settings)?),
11870 error => Err(err_fmod!("FMOD_System_GetAdvancedSettings", error)),
11871 }
11872 }
11873 }
11874 pub fn set_callback(
11875 &self,
11876 callback: ffi::FMOD_SYSTEM_CALLBACK,
11877 callbackmask: impl Into<ffi::FMOD_SYSTEM_CALLBACK_TYPE>,
11878 ) -> Result<(), Error> {
11879 unsafe {
11880 match ffi::FMOD_System_SetCallback(self.pointer, callback, callbackmask.into()) {
11881 ffi::FMOD_OK => Ok(()),
11882 error => Err(err_fmod!("FMOD_System_SetCallback", error)),
11883 }
11884 }
11885 }
11886 pub fn set_plugin_path(&self, path: &str) -> Result<(), Error> {
11887 unsafe {
11888 match ffi::FMOD_System_SetPluginPath(self.pointer, CString::new(path)?.as_ptr()) {
11889 ffi::FMOD_OK => Ok(()),
11890 error => Err(err_fmod!("FMOD_System_SetPluginPath", error)),
11891 }
11892 }
11893 }
11894 pub fn load_plugin(&self, filename: &str, priority: Option<u32>) -> Result<u32, Error> {
11895 unsafe {
11896 let mut handle = u32::default();
11897 match ffi::FMOD_System_LoadPlugin(
11898 self.pointer,
11899 CString::new(filename)?.as_ptr(),
11900 &mut handle,
11901 priority.unwrap_or(0),
11902 ) {
11903 ffi::FMOD_OK => Ok(handle),
11904 error => Err(err_fmod!("FMOD_System_LoadPlugin", error)),
11905 }
11906 }
11907 }
11908 pub fn unload_plugin(&self, handle: u32) -> Result<(), Error> {
11909 unsafe {
11910 match ffi::FMOD_System_UnloadPlugin(self.pointer, handle) {
11911 ffi::FMOD_OK => Ok(()),
11912 error => Err(err_fmod!("FMOD_System_UnloadPlugin", error)),
11913 }
11914 }
11915 }
11916 pub fn get_num_nested_plugins(&self, handle: u32) -> Result<i32, Error> {
11917 unsafe {
11918 let mut count = i32::default();
11919 match ffi::FMOD_System_GetNumNestedPlugins(self.pointer, handle, &mut count) {
11920 ffi::FMOD_OK => Ok(count),
11921 error => Err(err_fmod!("FMOD_System_GetNumNestedPlugins", error)),
11922 }
11923 }
11924 }
11925 pub fn get_nested_plugin(&self, handle: u32, index: i32) -> Result<u32, Error> {
11926 unsafe {
11927 let mut nestedhandle = u32::default();
11928 match ffi::FMOD_System_GetNestedPlugin(self.pointer, handle, index, &mut nestedhandle) {
11929 ffi::FMOD_OK => Ok(nestedhandle),
11930 error => Err(err_fmod!("FMOD_System_GetNestedPlugin", error)),
11931 }
11932 }
11933 }
11934 pub fn get_num_plugins(&self, plugintype: PluginType) -> Result<i32, Error> {
11935 unsafe {
11936 let mut numplugins = i32::default();
11937 match ffi::FMOD_System_GetNumPlugins(self.pointer, plugintype.into(), &mut numplugins) {
11938 ffi::FMOD_OK => Ok(numplugins),
11939 error => Err(err_fmod!("FMOD_System_GetNumPlugins", error)),
11940 }
11941 }
11942 }
11943 pub fn get_plugin_handle(&self, plugintype: PluginType, index: i32) -> Result<u32, Error> {
11944 unsafe {
11945 let mut handle = u32::default();
11946 match ffi::FMOD_System_GetPluginHandle(
11947 self.pointer,
11948 plugintype.into(),
11949 index,
11950 &mut handle,
11951 ) {
11952 ffi::FMOD_OK => Ok(handle),
11953 error => Err(err_fmod!("FMOD_System_GetPluginHandle", error)),
11954 }
11955 }
11956 }
11957 pub fn get_plugin_info(
11958 &self,
11959 handle: u32,
11960 namelen: i32,
11961 ) -> Result<(PluginType, String, u32), Error> {
11962 unsafe {
11963 let mut plugintype = ffi::FMOD_PLUGINTYPE::default();
11964 let name = string_buffer!(namelen);
11965 let mut version = u32::default();
11966 match ffi::FMOD_System_GetPluginInfo(
11967 self.pointer,
11968 handle,
11969 &mut plugintype,
11970 name,
11971 namelen,
11972 &mut version,
11973 ) {
11974 ffi::FMOD_OK => Ok((PluginType::from(plugintype)?, to_string!(name)?, version)),
11975 error => Err(err_fmod!("FMOD_System_GetPluginInfo", error)),
11976 }
11977 }
11978 }
11979 pub fn set_output_by_plugin(&self, handle: u32) -> Result<(), Error> {
11980 unsafe {
11981 match ffi::FMOD_System_SetOutputByPlugin(self.pointer, handle) {
11982 ffi::FMOD_OK => Ok(()),
11983 error => Err(err_fmod!("FMOD_System_SetOutputByPlugin", error)),
11984 }
11985 }
11986 }
11987 pub fn get_output_by_plugin(&self) -> Result<u32, Error> {
11988 unsafe {
11989 let mut handle = u32::default();
11990 match ffi::FMOD_System_GetOutputByPlugin(self.pointer, &mut handle) {
11991 ffi::FMOD_OK => Ok(handle),
11992 error => Err(err_fmod!("FMOD_System_GetOutputByPlugin", error)),
11993 }
11994 }
11995 }
11996 pub fn create_dsp_by_plugin(&self, handle: u32) -> Result<Dsp, Error> {
11997 unsafe {
11998 let mut dsp = null_mut();
11999 match ffi::FMOD_System_CreateDSPByPlugin(self.pointer, handle, &mut dsp) {
12000 ffi::FMOD_OK => Ok(Dsp::from(dsp)),
12001 error => Err(err_fmod!("FMOD_System_CreateDSPByPlugin", error)),
12002 }
12003 }
12004 }
12005 pub fn get_dsp_info_by_plugin(&self, handle: u32) -> Result<DspDescription, Error> {
12006 unsafe {
12007 let mut description = null();
12008 match ffi::FMOD_System_GetDSPInfoByPlugin(self.pointer, handle, &mut description) {
12009 ffi::FMOD_OK => Ok(DspDescription::try_from(*description)?),
12010 error => Err(err_fmod!("FMOD_System_GetDSPInfoByPlugin", error)),
12011 }
12012 }
12013 }
12014 pub fn register_codec(
12015 &self,
12016 description: CodecDescription,
12017 priority: Option<u32>,
12018 ) -> Result<u32, Error> {
12019 unsafe {
12020 let mut handle = u32::default();
12021 match ffi::FMOD_System_RegisterCodec(
12022 self.pointer,
12023 &mut description.into(),
12024 &mut handle,
12025 priority.unwrap_or(0),
12026 ) {
12027 ffi::FMOD_OK => Ok(handle),
12028 error => Err(err_fmod!("FMOD_System_RegisterCodec", error)),
12029 }
12030 }
12031 }
12032 pub fn register_dsp(&self, description: DspDescription) -> Result<u32, Error> {
12033 unsafe {
12034 let mut handle = u32::default();
12035 match ffi::FMOD_System_RegisterDSP(self.pointer, &description.into(), &mut handle) {
12036 ffi::FMOD_OK => Ok(handle),
12037 error => Err(err_fmod!("FMOD_System_RegisterDSP", error)),
12038 }
12039 }
12040 }
12041 pub fn register_output(&self, description: OutputDescription) -> Result<u32, Error> {
12042 unsafe {
12043 let mut handle = u32::default();
12044 match ffi::FMOD_System_RegisterOutput(self.pointer, &description.into(), &mut handle) {
12045 ffi::FMOD_OK => Ok(handle),
12046 error => Err(err_fmod!("FMOD_System_RegisterOutput", error)),
12047 }
12048 }
12049 }
12050 pub fn init(
12051 &self,
12052 maxchannels: i32,
12053 flags: impl Into<ffi::FMOD_INITFLAGS>,
12054 extradriverdata: Option<*mut c_void>,
12055 ) -> Result<(), Error> {
12056 unsafe {
12057 match ffi::FMOD_System_Init(
12058 self.pointer,
12059 maxchannels,
12060 flags.into(),
12061 extradriverdata.unwrap_or(null_mut()),
12062 ) {
12063 ffi::FMOD_OK => Ok(()),
12064 error => Err(err_fmod!("FMOD_System_Init", error)),
12065 }
12066 }
12067 }
12068 pub fn close(&self) -> Result<(), Error> {
12069 unsafe {
12070 match ffi::FMOD_System_Close(self.pointer) {
12071 ffi::FMOD_OK => Ok(()),
12072 error => Err(err_fmod!("FMOD_System_Close", error)),
12073 }
12074 }
12075 }
12076 pub fn update(&self) -> Result<(), Error> {
12077 unsafe {
12078 match ffi::FMOD_System_Update(self.pointer) {
12079 ffi::FMOD_OK => Ok(()),
12080 error => Err(err_fmod!("FMOD_System_Update", error)),
12081 }
12082 }
12083 }
12084 pub fn set_speaker_position(
12085 &self,
12086 speaker: Speaker,
12087 x: f32,
12088 y: f32,
12089 active: bool,
12090 ) -> Result<(), Error> {
12091 unsafe {
12092 match ffi::FMOD_System_SetSpeakerPosition(
12093 self.pointer,
12094 speaker.into(),
12095 x,
12096 y,
12097 from_bool!(active),
12098 ) {
12099 ffi::FMOD_OK => Ok(()),
12100 error => Err(err_fmod!("FMOD_System_SetSpeakerPosition", error)),
12101 }
12102 }
12103 }
12104 pub fn get_speaker_position(&self, speaker: Speaker) -> Result<(f32, f32, bool), Error> {
12105 unsafe {
12106 let mut x = f32::default();
12107 let mut y = f32::default();
12108 let mut active = ffi::FMOD_BOOL::default();
12109 match ffi::FMOD_System_GetSpeakerPosition(
12110 self.pointer,
12111 speaker.into(),
12112 &mut x,
12113 &mut y,
12114 &mut active,
12115 ) {
12116 ffi::FMOD_OK => Ok((x, y, to_bool!(active))),
12117 error => Err(err_fmod!("FMOD_System_GetSpeakerPosition", error)),
12118 }
12119 }
12120 }
12121 pub fn set_stream_buffer_size(
12122 &self,
12123 filebuffersize: u32,
12124 filebuffersizetype: impl Into<ffi::FMOD_TIMEUNIT>,
12125 ) -> Result<(), Error> {
12126 unsafe {
12127 match ffi::FMOD_System_SetStreamBufferSize(
12128 self.pointer,
12129 filebuffersize,
12130 filebuffersizetype.into(),
12131 ) {
12132 ffi::FMOD_OK => Ok(()),
12133 error => Err(err_fmod!("FMOD_System_SetStreamBufferSize", error)),
12134 }
12135 }
12136 }
12137 pub fn get_stream_buffer_size(&self) -> Result<(u32, ffi::FMOD_TIMEUNIT), Error> {
12138 unsafe {
12139 let mut filebuffersize = u32::default();
12140 let mut filebuffersizetype = ffi::FMOD_TIMEUNIT::default();
12141 match ffi::FMOD_System_GetStreamBufferSize(
12142 self.pointer,
12143 &mut filebuffersize,
12144 &mut filebuffersizetype,
12145 ) {
12146 ffi::FMOD_OK => Ok((filebuffersize, filebuffersizetype)),
12147 error => Err(err_fmod!("FMOD_System_GetStreamBufferSize", error)),
12148 }
12149 }
12150 }
12151 pub fn set_3d_settings(
12152 &self,
12153 dopplerscale: f32,
12154 distancefactor: f32,
12155 rolloffscale: f32,
12156 ) -> Result<(), Error> {
12157 unsafe {
12158 match ffi::FMOD_System_Set3DSettings(
12159 self.pointer,
12160 dopplerscale,
12161 distancefactor,
12162 rolloffscale,
12163 ) {
12164 ffi::FMOD_OK => Ok(()),
12165 error => Err(err_fmod!("FMOD_System_Set3DSettings", error)),
12166 }
12167 }
12168 }
12169 pub fn get_3d_settings(&self) -> Result<(f32, f32, f32), Error> {
12170 unsafe {
12171 let mut dopplerscale = f32::default();
12172 let mut distancefactor = f32::default();
12173 let mut rolloffscale = f32::default();
12174 match ffi::FMOD_System_Get3DSettings(
12175 self.pointer,
12176 &mut dopplerscale,
12177 &mut distancefactor,
12178 &mut rolloffscale,
12179 ) {
12180 ffi::FMOD_OK => Ok((dopplerscale, distancefactor, rolloffscale)),
12181 error => Err(err_fmod!("FMOD_System_Get3DSettings", error)),
12182 }
12183 }
12184 }
12185 pub fn set_3d_num_listeners(&self, numlisteners: i32) -> Result<(), Error> {
12186 unsafe {
12187 match ffi::FMOD_System_Set3DNumListeners(self.pointer, numlisteners) {
12188 ffi::FMOD_OK => Ok(()),
12189 error => Err(err_fmod!("FMOD_System_Set3DNumListeners", error)),
12190 }
12191 }
12192 }
12193 pub fn get_3d_num_listeners(&self) -> Result<i32, Error> {
12194 unsafe {
12195 let mut numlisteners = i32::default();
12196 match ffi::FMOD_System_Get3DNumListeners(self.pointer, &mut numlisteners) {
12197 ffi::FMOD_OK => Ok(numlisteners),
12198 error => Err(err_fmod!("FMOD_System_Get3DNumListeners", error)),
12199 }
12200 }
12201 }
12202 pub fn set_3d_listener_attributes(
12203 &self,
12204 listener: i32,
12205 pos: Option<Vector>,
12206 vel: Option<Vector>,
12207 forward: Option<Vector>,
12208 up: Option<Vector>,
12209 ) -> Result<(), Error> {
12210 unsafe {
12211 match ffi::FMOD_System_Set3DListenerAttributes(
12212 self.pointer,
12213 listener,
12214 pos.map(Vector::into)
12215 .as_ref()
12216 .map(from_ref)
12217 .unwrap_or_else(null),
12218 vel.map(Vector::into)
12219 .as_ref()
12220 .map(from_ref)
12221 .unwrap_or_else(null),
12222 forward
12223 .map(Vector::into)
12224 .as_ref()
12225 .map(from_ref)
12226 .unwrap_or_else(null),
12227 up.map(Vector::into)
12228 .as_ref()
12229 .map(from_ref)
12230 .unwrap_or_else(null),
12231 ) {
12232 ffi::FMOD_OK => Ok(()),
12233 error => Err(err_fmod!("FMOD_System_Set3DListenerAttributes", error)),
12234 }
12235 }
12236 }
12237 pub fn get_3d_listener_attributes(
12238 &self,
12239 listener: i32,
12240 ) -> Result<(Vector, Vector, Vector, Vector), Error> {
12241 unsafe {
12242 let mut pos = ffi::FMOD_VECTOR::default();
12243 let mut vel = ffi::FMOD_VECTOR::default();
12244 let mut forward = ffi::FMOD_VECTOR::default();
12245 let mut up = ffi::FMOD_VECTOR::default();
12246 match ffi::FMOD_System_Get3DListenerAttributes(
12247 self.pointer,
12248 listener,
12249 &mut pos,
12250 &mut vel,
12251 &mut forward,
12252 &mut up,
12253 ) {
12254 ffi::FMOD_OK => Ok((
12255 Vector::try_from(pos)?,
12256 Vector::try_from(vel)?,
12257 Vector::try_from(forward)?,
12258 Vector::try_from(up)?,
12259 )),
12260 error => Err(err_fmod!("FMOD_System_Get3DListenerAttributes", error)),
12261 }
12262 }
12263 }
12264 pub fn set_3d_rolloff_callback(
12265 &self,
12266 callback: ffi::FMOD_3D_ROLLOFF_CALLBACK,
12267 ) -> Result<(), Error> {
12268 unsafe {
12269 match ffi::FMOD_System_Set3DRolloffCallback(self.pointer, callback) {
12270 ffi::FMOD_OK => Ok(()),
12271 error => Err(err_fmod!("FMOD_System_Set3DRolloffCallback", error)),
12272 }
12273 }
12274 }
12275 pub fn mixer_suspend(&self) -> Result<(), Error> {
12276 unsafe {
12277 match ffi::FMOD_System_MixerSuspend(self.pointer) {
12278 ffi::FMOD_OK => Ok(()),
12279 error => Err(err_fmod!("FMOD_System_MixerSuspend", error)),
12280 }
12281 }
12282 }
12283 pub fn mixer_resume(&self) -> Result<(), Error> {
12284 unsafe {
12285 match ffi::FMOD_System_MixerResume(self.pointer) {
12286 ffi::FMOD_OK => Ok(()),
12287 error => Err(err_fmod!("FMOD_System_MixerResume", error)),
12288 }
12289 }
12290 }
12291 pub fn get_default_mix_matrix(
12292 &self,
12293 sourcespeakermode: SpeakerMode,
12294 targetspeakermode: SpeakerMode,
12295 matrixhop: Option<i32>,
12296 ) -> Result<f32, Error> {
12297 unsafe {
12298 let mut matrix = f32::default();
12299 match ffi::FMOD_System_GetDefaultMixMatrix(
12300 self.pointer,
12301 sourcespeakermode.into(),
12302 targetspeakermode.into(),
12303 &mut matrix,
12304 matrixhop.unwrap_or(0),
12305 ) {
12306 ffi::FMOD_OK => Ok(matrix),
12307 error => Err(err_fmod!("FMOD_System_GetDefaultMixMatrix", error)),
12308 }
12309 }
12310 }
12311 pub fn get_speaker_mode_channels(&self, mode: SpeakerMode) -> Result<i32, Error> {
12312 unsafe {
12313 let mut channels = i32::default();
12314 match ffi::FMOD_System_GetSpeakerModeChannels(self.pointer, mode.into(), &mut channels)
12315 {
12316 ffi::FMOD_OK => Ok(channels),
12317 error => Err(err_fmod!("FMOD_System_GetSpeakerModeChannels", error)),
12318 }
12319 }
12320 }
12321 pub fn get_version(&self) -> Result<u32, Error> {
12322 unsafe {
12323 let mut version = u32::default();
12324 match ffi::FMOD_System_GetVersion(self.pointer, &mut version) {
12325 ffi::FMOD_OK => Ok(version),
12326 error => Err(err_fmod!("FMOD_System_GetVersion", error)),
12327 }
12328 }
12329 }
12330 pub fn get_output_handle(&self) -> Result<*mut c_void, Error> {
12331 unsafe {
12332 let mut handle = null_mut();
12333 match ffi::FMOD_System_GetOutputHandle(self.pointer, &mut handle) {
12334 ffi::FMOD_OK => Ok(handle),
12335 error => Err(err_fmod!("FMOD_System_GetOutputHandle", error)),
12336 }
12337 }
12338 }
12339 pub fn get_channels_playing(&self) -> Result<(i32, i32), Error> {
12340 unsafe {
12341 let mut channels = i32::default();
12342 let mut realchannels = i32::default();
12343 match ffi::FMOD_System_GetChannelsPlaying(
12344 self.pointer,
12345 &mut channels,
12346 &mut realchannels,
12347 ) {
12348 ffi::FMOD_OK => Ok((channels, realchannels)),
12349 error => Err(err_fmod!("FMOD_System_GetChannelsPlaying", error)),
12350 }
12351 }
12352 }
12353 pub fn get_cpu_usage(&self) -> Result<CpuUsage, Error> {
12354 unsafe {
12355 let mut usage = ffi::FMOD_CPU_USAGE::default();
12356 match ffi::FMOD_System_GetCPUUsage(self.pointer, &mut usage) {
12357 ffi::FMOD_OK => Ok(CpuUsage::try_from(usage)?),
12358 error => Err(err_fmod!("FMOD_System_GetCPUUsage", error)),
12359 }
12360 }
12361 }
12362 pub fn get_file_usage(&self) -> Result<(i64, i64, i64), Error> {
12363 unsafe {
12364 let mut sample_bytes_read = i64::default();
12365 let mut stream_bytes_read = i64::default();
12366 let mut other_bytes_read = i64::default();
12367 match ffi::FMOD_System_GetFileUsage(
12368 self.pointer,
12369 &mut sample_bytes_read,
12370 &mut stream_bytes_read,
12371 &mut other_bytes_read,
12372 ) {
12373 ffi::FMOD_OK => Ok((sample_bytes_read, stream_bytes_read, other_bytes_read)),
12374 error => Err(err_fmod!("FMOD_System_GetFileUsage", error)),
12375 }
12376 }
12377 }
12378 pub fn create_sound(
12379 &self,
12380 name_or_data: &str,
12381 mode: impl Into<ffi::FMOD_MODE>,
12382 exinfo: Option<CreateSoundexInfo>,
12383 ) -> Result<Sound, Error> {
12384 unsafe {
12385 let mut sound = null_mut();
12386 match ffi::FMOD_System_CreateSound(
12387 self.pointer,
12388 CString::new(name_or_data)?.as_ptr(),
12389 mode.into(),
12390 exinfo
12391 .map(|value| &mut value.into() as *mut _)
12392 .unwrap_or(null_mut()),
12393 &mut sound,
12394 ) {
12395 ffi::FMOD_OK => Ok(Sound::from(sound)),
12396 error => Err(err_fmod!("FMOD_System_CreateSound", error)),
12397 }
12398 }
12399 }
12400 pub fn create_sound_from(
12401 &self,
12402 data: &[u8],
12403 mode: impl Into<ffi::FMOD_MODE>,
12404 exinfo: CreateSoundexInfo,
12405 ) -> Result<Sound, Error> {
12406 unsafe {
12407 let mut sound = null_mut();
12408 match ffi::FMOD_System_CreateSound(
12409 self.pointer,
12410 data.as_ptr() as *const _,
12411 mode.into(),
12412 &mut exinfo.into() as *mut _,
12413 &mut sound,
12414 ) {
12415 ffi::FMOD_OK => Ok(Sound::from(sound)),
12416 error => Err(err_fmod!("FMOD_System_CreateSound", error)),
12417 }
12418 }
12419 }
12420 pub fn create_stream(
12421 &self,
12422 name_or_data: &str,
12423 mode: impl Into<ffi::FMOD_MODE>,
12424 exinfo: Option<CreateSoundexInfo>,
12425 ) -> Result<Sound, Error> {
12426 unsafe {
12427 let mut sound = null_mut();
12428 match ffi::FMOD_System_CreateStream(
12429 self.pointer,
12430 CString::new(name_or_data)?.as_ptr(),
12431 mode.into(),
12432 exinfo
12433 .map(|value| &mut value.into() as *mut _)
12434 .unwrap_or(null_mut()),
12435 &mut sound,
12436 ) {
12437 ffi::FMOD_OK => Ok(Sound::from(sound)),
12438 error => Err(err_fmod!("FMOD_System_CreateStream", error)),
12439 }
12440 }
12441 }
12442 pub fn create_stream_from(
12443 &self,
12444 data: &[u8],
12445 mode: impl Into<ffi::FMOD_MODE>,
12446 exinfo: CreateSoundexInfo,
12447 ) -> Result<Sound, Error> {
12448 unsafe {
12449 let mut sound = null_mut();
12450 match ffi::FMOD_System_CreateStream(
12451 self.pointer,
12452 data.as_ptr() as *const _,
12453 mode.into(),
12454 &mut exinfo.into() as *mut _,
12455 &mut sound,
12456 ) {
12457 ffi::FMOD_OK => Ok(Sound::from(sound)),
12458 error => Err(err_fmod!("FMOD_System_CreateStream", error)),
12459 }
12460 }
12461 }
12462 pub fn create_dsp(&self, description: DspDescription) -> Result<Dsp, Error> {
12463 unsafe {
12464 let mut dsp = null_mut();
12465 match ffi::FMOD_System_CreateDSP(self.pointer, &description.into(), &mut dsp) {
12466 ffi::FMOD_OK => Ok(Dsp::from(dsp)),
12467 error => Err(err_fmod!("FMOD_System_CreateDSP", error)),
12468 }
12469 }
12470 }
12471 pub fn create_dsp_by_type(&self, type_: DspType) -> Result<Dsp, Error> {
12472 unsafe {
12473 let mut dsp = null_mut();
12474 match ffi::FMOD_System_CreateDSPByType(self.pointer, type_.into(), &mut dsp) {
12475 ffi::FMOD_OK => Ok(Dsp::from(dsp)),
12476 error => Err(err_fmod!("FMOD_System_CreateDSPByType", error)),
12477 }
12478 }
12479 }
12480 pub fn create_channel_group(&self, name: Option<String>) -> Result<ChannelGroup, Error> {
12481 unsafe {
12482 let mut channelgroup = null_mut();
12483 match ffi::FMOD_System_CreateChannelGroup(
12484 self.pointer,
12485 name.map(|value| CString::new(value).map(|value| value.as_ptr()))
12486 .unwrap_or(Ok(null_mut()))?,
12487 &mut channelgroup,
12488 ) {
12489 ffi::FMOD_OK => Ok(ChannelGroup::from(channelgroup)),
12490 error => Err(err_fmod!("FMOD_System_CreateChannelGroup", error)),
12491 }
12492 }
12493 }
12494 pub fn create_sound_group(&self, name: &str) -> Result<SoundGroup, Error> {
12495 unsafe {
12496 let mut soundgroup = null_mut();
12497 match ffi::FMOD_System_CreateSoundGroup(
12498 self.pointer,
12499 CString::new(name)?.as_ptr(),
12500 &mut soundgroup,
12501 ) {
12502 ffi::FMOD_OK => Ok(SoundGroup::from(soundgroup)),
12503 error => Err(err_fmod!("FMOD_System_CreateSoundGroup", error)),
12504 }
12505 }
12506 }
12507 pub fn create_reverb_3d(&self) -> Result<Reverb3d, Error> {
12508 unsafe {
12509 let mut reverb = null_mut();
12510 match ffi::FMOD_System_CreateReverb3D(self.pointer, &mut reverb) {
12511 ffi::FMOD_OK => Ok(Reverb3d::from(reverb)),
12512 error => Err(err_fmod!("FMOD_System_CreateReverb3D", error)),
12513 }
12514 }
12515 }
12516 pub fn play_sound(
12517 &self,
12518 sound: Sound,
12519 channelgroup: Option<ChannelGroup>,
12520 paused: bool,
12521 ) -> Result<Channel, Error> {
12522 unsafe {
12523 let mut channel = null_mut();
12524 match ffi::FMOD_System_PlaySound(
12525 self.pointer,
12526 sound.as_mut_ptr(),
12527 channelgroup
12528 .map(|value| value.as_mut_ptr())
12529 .unwrap_or(null_mut()),
12530 from_bool!(paused),
12531 &mut channel,
12532 ) {
12533 ffi::FMOD_OK => Ok(Channel::from(channel)),
12534 error => Err(err_fmod!("FMOD_System_PlaySound", error)),
12535 }
12536 }
12537 }
12538 pub fn play_dsp(
12539 &self,
12540 dsp: Dsp,
12541 channelgroup: Option<ChannelGroup>,
12542 paused: bool,
12543 ) -> Result<Channel, Error> {
12544 unsafe {
12545 let mut channel = null_mut();
12546 match ffi::FMOD_System_PlayDSP(
12547 self.pointer,
12548 dsp.as_mut_ptr(),
12549 channelgroup
12550 .map(|value| value.as_mut_ptr())
12551 .unwrap_or(null_mut()),
12552 from_bool!(paused),
12553 &mut channel,
12554 ) {
12555 ffi::FMOD_OK => Ok(Channel::from(channel)),
12556 error => Err(err_fmod!("FMOD_System_PlayDSP", error)),
12557 }
12558 }
12559 }
12560 pub fn get_channel(&self, channelid: i32) -> Result<Channel, Error> {
12561 unsafe {
12562 let mut channel = null_mut();
12563 match ffi::FMOD_System_GetChannel(self.pointer, channelid, &mut channel) {
12564 ffi::FMOD_OK => Ok(Channel::from(channel)),
12565 error => Err(err_fmod!("FMOD_System_GetChannel", error)),
12566 }
12567 }
12568 }
12569 pub fn get_dsp_info_by_type(&self, type_: DspType) -> Result<DspDescription, Error> {
12570 unsafe {
12571 let mut description = null();
12572 match ffi::FMOD_System_GetDSPInfoByType(self.pointer, type_.into(), &mut description) {
12573 ffi::FMOD_OK => Ok(DspDescription::try_from(*description)?),
12574 error => Err(err_fmod!("FMOD_System_GetDSPInfoByType", error)),
12575 }
12576 }
12577 }
12578 pub fn get_master_channel_group(&self) -> Result<ChannelGroup, Error> {
12579 unsafe {
12580 let mut channelgroup = null_mut();
12581 match ffi::FMOD_System_GetMasterChannelGroup(self.pointer, &mut channelgroup) {
12582 ffi::FMOD_OK => Ok(ChannelGroup::from(channelgroup)),
12583 error => Err(err_fmod!("FMOD_System_GetMasterChannelGroup", error)),
12584 }
12585 }
12586 }
12587 pub fn get_master_sound_group(&self) -> Result<SoundGroup, Error> {
12588 unsafe {
12589 let mut soundgroup = null_mut();
12590 match ffi::FMOD_System_GetMasterSoundGroup(self.pointer, &mut soundgroup) {
12591 ffi::FMOD_OK => Ok(SoundGroup::from(soundgroup)),
12592 error => Err(err_fmod!("FMOD_System_GetMasterSoundGroup", error)),
12593 }
12594 }
12595 }
12596 pub fn attach_channel_group_to_port(
12597 &self,
12598 port_type: PortType,
12599 port_index: impl Into<ffi::FMOD_PORT_INDEX>,
12600 channelgroup: ChannelGroup,
12601 pass_thru: bool,
12602 ) -> Result<(), Error> {
12603 unsafe {
12604 match ffi::FMOD_System_AttachChannelGroupToPort(
12605 self.pointer,
12606 port_type.into(),
12607 port_index.into(),
12608 channelgroup.as_mut_ptr(),
12609 from_bool!(pass_thru),
12610 ) {
12611 ffi::FMOD_OK => Ok(()),
12612 error => Err(err_fmod!("FMOD_System_AttachChannelGroupToPort", error)),
12613 }
12614 }
12615 }
12616 pub fn detach_channel_group_from_port(&self, channelgroup: ChannelGroup) -> Result<(), Error> {
12617 unsafe {
12618 match ffi::FMOD_System_DetachChannelGroupFromPort(
12619 self.pointer,
12620 channelgroup.as_mut_ptr(),
12621 ) {
12622 ffi::FMOD_OK => Ok(()),
12623 error => Err(err_fmod!("FMOD_System_DetachChannelGroupFromPort", error)),
12624 }
12625 }
12626 }
12627 pub fn set_reverb_properties(
12628 &self,
12629 instance: i32,
12630 prop: ReverbProperties,
12631 ) -> Result<(), Error> {
12632 unsafe {
12633 match ffi::FMOD_System_SetReverbProperties(self.pointer, instance, &prop.into()) {
12634 ffi::FMOD_OK => Ok(()),
12635 error => Err(err_fmod!("FMOD_System_SetReverbProperties", error)),
12636 }
12637 }
12638 }
12639 pub fn get_reverb_properties(&self, instance: i32) -> Result<ReverbProperties, Error> {
12640 unsafe {
12641 let mut prop = ffi::FMOD_REVERB_PROPERTIES::default();
12642 match ffi::FMOD_System_GetReverbProperties(self.pointer, instance, &mut prop) {
12643 ffi::FMOD_OK => Ok(ReverbProperties::try_from(prop)?),
12644 error => Err(err_fmod!("FMOD_System_GetReverbProperties", error)),
12645 }
12646 }
12647 }
12648 pub fn lock_dsp(&self) -> Result<(), Error> {
12649 unsafe {
12650 match ffi::FMOD_System_LockDSP(self.pointer) {
12651 ffi::FMOD_OK => Ok(()),
12652 error => Err(err_fmod!("FMOD_System_LockDSP", error)),
12653 }
12654 }
12655 }
12656 pub fn unlock_dsp(&self) -> Result<(), Error> {
12657 unsafe {
12658 match ffi::FMOD_System_UnlockDSP(self.pointer) {
12659 ffi::FMOD_OK => Ok(()),
12660 error => Err(err_fmod!("FMOD_System_UnlockDSP", error)),
12661 }
12662 }
12663 }
12664 pub fn get_record_num_drivers(&self) -> Result<(i32, i32), Error> {
12665 unsafe {
12666 let mut numdrivers = i32::default();
12667 let mut numconnected = i32::default();
12668 match ffi::FMOD_System_GetRecordNumDrivers(
12669 self.pointer,
12670 &mut numdrivers,
12671 &mut numconnected,
12672 ) {
12673 ffi::FMOD_OK => Ok((numdrivers, numconnected)),
12674 error => Err(err_fmod!("FMOD_System_GetRecordNumDrivers", error)),
12675 }
12676 }
12677 }
12678 pub fn get_record_driver_info(
12679 &self,
12680 id: i32,
12681 namelen: i32,
12682 ) -> Result<(String, Guid, i32, SpeakerMode, i32, ffi::FMOD_DRIVER_STATE), Error> {
12683 unsafe {
12684 let name = string_buffer!(namelen);
12685 let mut guid = ffi::FMOD_GUID::default();
12686 let mut systemrate = i32::default();
12687 let mut speakermode = ffi::FMOD_SPEAKERMODE::default();
12688 let mut speakermodechannels = i32::default();
12689 let mut state = ffi::FMOD_DRIVER_STATE::default();
12690 match ffi::FMOD_System_GetRecordDriverInfo(
12691 self.pointer,
12692 id,
12693 name,
12694 namelen,
12695 &mut guid,
12696 &mut systemrate,
12697 &mut speakermode,
12698 &mut speakermodechannels,
12699 &mut state,
12700 ) {
12701 ffi::FMOD_OK => Ok((
12702 to_string!(name)?,
12703 Guid::try_from(guid)?,
12704 systemrate,
12705 SpeakerMode::from(speakermode)?,
12706 speakermodechannels,
12707 state,
12708 )),
12709 error => Err(err_fmod!("FMOD_System_GetRecordDriverInfo", error)),
12710 }
12711 }
12712 }
12713 pub fn get_record_position(&self, id: i32) -> Result<u32, Error> {
12714 unsafe {
12715 let mut position = u32::default();
12716 match ffi::FMOD_System_GetRecordPosition(self.pointer, id, &mut position) {
12717 ffi::FMOD_OK => Ok(position),
12718 error => Err(err_fmod!("FMOD_System_GetRecordPosition", error)),
12719 }
12720 }
12721 }
12722 pub fn record_start(&self, id: i32, sound: Sound, loop_: bool) -> Result<(), Error> {
12723 unsafe {
12724 match ffi::FMOD_System_RecordStart(
12725 self.pointer,
12726 id,
12727 sound.as_mut_ptr(),
12728 from_bool!(loop_),
12729 ) {
12730 ffi::FMOD_OK => Ok(()),
12731 error => Err(err_fmod!("FMOD_System_RecordStart", error)),
12732 }
12733 }
12734 }
12735 pub fn record_stop(&self, id: i32) -> Result<(), Error> {
12736 unsafe {
12737 match ffi::FMOD_System_RecordStop(self.pointer, id) {
12738 ffi::FMOD_OK => Ok(()),
12739 error => Err(err_fmod!("FMOD_System_RecordStop", error)),
12740 }
12741 }
12742 }
12743 pub fn is_recording(&self, id: i32) -> Result<bool, Error> {
12744 unsafe {
12745 let mut recording = ffi::FMOD_BOOL::default();
12746 match ffi::FMOD_System_IsRecording(self.pointer, id, &mut recording) {
12747 ffi::FMOD_OK => Ok(to_bool!(recording)),
12748 error => Err(err_fmod!("FMOD_System_IsRecording", error)),
12749 }
12750 }
12751 }
12752 pub fn create_geometry(&self, maxpolygons: i32, maxvertices: i32) -> Result<Geometry, Error> {
12753 unsafe {
12754 let mut geometry = null_mut();
12755 match ffi::FMOD_System_CreateGeometry(
12756 self.pointer,
12757 maxpolygons,
12758 maxvertices,
12759 &mut geometry,
12760 ) {
12761 ffi::FMOD_OK => Ok(Geometry::from(geometry)),
12762 error => Err(err_fmod!("FMOD_System_CreateGeometry", error)),
12763 }
12764 }
12765 }
12766 pub fn set_geometry_settings(&self, maxworldsize: f32) -> Result<(), Error> {
12767 unsafe {
12768 match ffi::FMOD_System_SetGeometrySettings(self.pointer, maxworldsize) {
12769 ffi::FMOD_OK => Ok(()),
12770 error => Err(err_fmod!("FMOD_System_SetGeometrySettings", error)),
12771 }
12772 }
12773 }
12774 pub fn get_geometry_settings(&self) -> Result<f32, Error> {
12775 unsafe {
12776 let mut maxworldsize = f32::default();
12777 match ffi::FMOD_System_GetGeometrySettings(self.pointer, &mut maxworldsize) {
12778 ffi::FMOD_OK => Ok(maxworldsize),
12779 error => Err(err_fmod!("FMOD_System_GetGeometrySettings", error)),
12780 }
12781 }
12782 }
12783 pub fn load_geometry(&self, data: *const c_void, datasize: i32) -> Result<Geometry, Error> {
12784 unsafe {
12785 let mut geometry = null_mut();
12786 match ffi::FMOD_System_LoadGeometry(self.pointer, data, datasize, &mut geometry) {
12787 ffi::FMOD_OK => Ok(Geometry::from(geometry)),
12788 error => Err(err_fmod!("FMOD_System_LoadGeometry", error)),
12789 }
12790 }
12791 }
12792 pub fn get_geometry_occlusion(
12793 &self,
12794 listener: Vector,
12795 source: Vector,
12796 ) -> Result<(f32, f32), Error> {
12797 unsafe {
12798 let mut direct = f32::default();
12799 let mut reverb = f32::default();
12800 match ffi::FMOD_System_GetGeometryOcclusion(
12801 self.pointer,
12802 &listener.into(),
12803 &source.into(),
12804 &mut direct,
12805 &mut reverb,
12806 ) {
12807 ffi::FMOD_OK => Ok((direct, reverb)),
12808 error => Err(err_fmod!("FMOD_System_GetGeometryOcclusion", error)),
12809 }
12810 }
12811 }
12812 pub fn set_network_proxy(&self, proxy: &str) -> Result<(), Error> {
12813 unsafe {
12814 match ffi::FMOD_System_SetNetworkProxy(self.pointer, CString::new(proxy)?.as_ptr()) {
12815 ffi::FMOD_OK => Ok(()),
12816 error => Err(err_fmod!("FMOD_System_SetNetworkProxy", error)),
12817 }
12818 }
12819 }
12820 pub fn get_network_proxy(&self, proxylen: i32) -> Result<String, Error> {
12821 unsafe {
12822 let proxy = string_buffer!(proxylen);
12823 match ffi::FMOD_System_GetNetworkProxy(self.pointer, proxy, proxylen) {
12824 ffi::FMOD_OK => Ok(to_string!(proxy)?),
12825 error => Err(err_fmod!("FMOD_System_GetNetworkProxy", error)),
12826 }
12827 }
12828 }
12829 pub fn set_network_timeout(&self, timeout: i32) -> Result<(), Error> {
12830 unsafe {
12831 match ffi::FMOD_System_SetNetworkTimeout(self.pointer, timeout) {
12832 ffi::FMOD_OK => Ok(()),
12833 error => Err(err_fmod!("FMOD_System_SetNetworkTimeout", error)),
12834 }
12835 }
12836 }
12837 pub fn get_network_timeout(&self) -> Result<i32, Error> {
12838 unsafe {
12839 let mut timeout = i32::default();
12840 match ffi::FMOD_System_GetNetworkTimeout(self.pointer, &mut timeout) {
12841 ffi::FMOD_OK => Ok(timeout),
12842 error => Err(err_fmod!("FMOD_System_GetNetworkTimeout", error)),
12843 }
12844 }
12845 }
12846 pub fn set_user_data(&self, userdata: *mut c_void) -> Result<(), Error> {
12847 unsafe {
12848 match ffi::FMOD_System_SetUserData(self.pointer, userdata) {
12849 ffi::FMOD_OK => Ok(()),
12850 error => Err(err_fmod!("FMOD_System_SetUserData", error)),
12851 }
12852 }
12853 }
12854 pub fn get_user_data(&self) -> Result<*mut c_void, Error> {
12855 unsafe {
12856 let mut userdata = null_mut();
12857 match ffi::FMOD_System_GetUserData(self.pointer, &mut userdata) {
12858 ffi::FMOD_OK => Ok(userdata),
12859 error => Err(err_fmod!("FMOD_System_GetUserData", error)),
12860 }
12861 }
12862 }
12863}