mt-lang 0.2.0 → 0.2.2
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- checksums.yaml +4 -4
- data/README.md +12 -0
- data/Rakefile +1 -1
- data/docs/index.html +13 -3
- data/lib/milk_tea/base.rb +7 -2
- data/std/asset_pack.mt +267 -0
- data/std/async/libuv_runtime.mt +539 -0
- data/std/async/mailbox.mt +191 -0
- data/std/async/runtime.mt +87 -0
- data/std/async.mt +87 -0
- data/std/base64.mt +185 -0
- data/std/behavior_tree.mt +396 -0
- data/std/binary.mt +314 -0
- data/std/binary_heap.mt +157 -0
- data/std/bitset.mt +239 -0
- data/std/box2d.mt +535 -0
- data/std/bytes.mt +46 -0
- data/std/c/box2d.mt +1254 -0
- data/std/c/cgltf.mt +647 -0
- data/std/c/cjson.mt +106 -0
- data/std/c/crypto.mt +11 -0
- data/std/c/crypto_support.h +51 -0
- data/std/c/ctype.mt +19 -0
- data/std/c/ctype_bindgen.h +29 -0
- data/std/c/curl.mt +1223 -0
- data/std/c/enet.mt +473 -0
- data/std/c/errno.mt +41 -0
- data/std/c/errno_bindgen.h +53 -0
- data/std/c/flecs.mt +2945 -0
- data/std/c/fs.linux.mt +43 -0
- data/std/c/fs.windows.mt +43 -0
- data/std/c/fs_support.h +954 -0
- data/std/c/gl.mt +2065 -0
- data/std/c/gl_registry_helpers.h +10748 -0
- data/std/c/glfw.mt +499 -0
- data/std/c/libc.mt +167 -0
- data/std/c/libuv.mt +1491 -0
- data/std/c/math.mt +22 -0
- data/std/c/math_bindgen.h +31 -0
- data/std/c/miniaudio.mt +3420 -0
- data/std/c/pcre2.mt +735 -0
- data/std/c/process.mt +58 -0
- data/std/c/process_support.h +1147 -0
- data/std/c/raygui.mt +1602 -0
- data/std/c/raylib.mt +1245 -0
- data/std/c/raymath.mt +163 -0
- data/std/c/rlgl.mt +434 -0
- data/std/c/rpng.mt +60 -0
- data/std/c/rres.mt +187 -0
- data/std/c/sdl3.mt +4132 -0
- data/std/c/sqlite3.mt +951 -0
- data/std/c/stb_image.mt +52 -0
- data/std/c/stb_image_resize2.mt +128 -0
- data/std/c/stb_image_write.mt +19 -0
- data/std/c/stb_rect_pack.mt +38 -0
- data/std/c/stb_truetype.mt +175 -0
- data/std/c/stb_vorbis.mt +31 -0
- data/std/c/stdio.mt +90 -0
- data/std/c/steamworks.h +5769 -0
- data/std/c/steamworks.mt +4771 -0
- data/std/c/string.mt +16 -0
- data/std/c/string_bindgen.h +36 -0
- data/std/c/sync.mt +33 -0
- data/std/c/sync_support.h +219 -0
- data/std/c/terminal.mt +24 -0
- data/std/c/terminal_support.h +408 -0
- data/std/c/time.mt +26 -0
- data/std/c/tls.mt +24 -0
- data/std/c/tls_support.h +626 -0
- data/std/c/tracy.mt +53 -0
- data/std/c/zlib.mt +20 -0
- data/std/c/zlib_support.h +239 -0
- data/std/c/zstd.mt +231 -0
- data/std/cell.mt +60 -0
- data/std/cgltf.mt +115 -0
- data/std/cjson.mt +90 -0
- data/std/cli.mt +768 -0
- data/std/cookie.mt +198 -0
- data/std/counter.mt +160 -0
- data/std/crypto.mt +74 -0
- data/std/cstring.mt +13 -0
- data/std/ctype.mt +52 -0
- data/std/curl/runtime.mt +261 -0
- data/std/curl.mt +38 -0
- data/std/deque.mt +348 -0
- data/std/encoding.mt +93 -0
- data/std/enet.mt +133 -0
- data/std/env.mt +41 -0
- data/std/errno.mt +47 -0
- data/std/flecs.mt +978 -0
- data/std/fmt.mt +271 -0
- data/std/fs.linux.mt +696 -0
- data/std/fs.windows.mt +711 -0
- data/std/fsm.mt +267 -0
- data/std/gl.mt +2062 -0
- data/std/glfw.mt +471 -0
- data/std/goap.mt +342 -0
- data/std/graph.mt +521 -0
- data/std/gzip.mt +77 -0
- data/std/hash.mt +429 -0
- data/std/http/server.mt +810 -0
- data/std/http.mt +1227 -0
- data/std/intern.mt +53 -0
- data/std/jobs.mt +288 -0
- data/std/json.mt +627 -0
- data/std/libc.mt +34 -0
- data/std/libuv.mt +554 -0
- data/std/linear_algebra.mt +243 -0
- data/std/linked_map.mt +372 -0
- data/std/linked_map_view.mt +49 -0
- data/std/linked_set.mt +117 -0
- data/std/log.mt +69 -0
- data/std/map.mt +418 -0
- data/std/math.mt +24 -0
- data/std/mem/arena.mt +137 -0
- data/std/mem/endian.mt +51 -0
- data/std/mem/heap.mt +298 -0
- data/std/mem/pool.mt +164 -0
- data/std/mem/stack.mt +47 -0
- data/std/mem/tracking.mt +119 -0
- data/std/miniaudio.mt +1299 -0
- data/std/multiset.mt +191 -0
- data/std/net/channel.mt +727 -0
- data/std/net/clock.mt +237 -0
- data/std/net/discovery.mt +277 -0
- data/std/net/lobby.mt +813 -0
- data/std/net/manager.mt +539 -0
- data/std/net/mux.mt +839 -0
- data/std/net/nat.mt +122 -0
- data/std/net/packet.mt +219 -0
- data/std/net/punch.mt +162 -0
- data/std/net/rpc.mt +119 -0
- data/std/net/session.mt +1157 -0
- data/std/net/stun.mt +252 -0
- data/std/net/sync.mt +183 -0
- data/std/net/turn.mt +459 -0
- data/std/net.mt +2944 -0
- data/std/oauth2.mt +408 -0
- data/std/option.mt +51 -0
- data/std/ordered_map.mt +497 -0
- data/std/ordered_set.mt +348 -0
- data/std/path.mt +368 -0
- data/std/pcre2/runtime.mt +35 -0
- data/std/pcre2.mt +78 -0
- data/std/priority_queue.mt +55 -0
- data/std/process.mt +837 -0
- data/std/queue.mt +55 -0
- data/std/random.mt +146 -0
- data/std/raygui.mt +99 -0
- data/std/raylib/debug_console.mt +71 -0
- data/std/raylib/easing.mt +388 -0
- data/std/raylib/packed_assets.mt +255 -0
- data/std/raylib/runtime.mt +30 -0
- data/std/raylib/tracy_gpu.mt +37 -0
- data/std/raylib.mt +1510 -0
- data/std/raymath.mt +153 -0
- data/std/result.mt +89 -0
- data/std/rlgl.mt +268 -0
- data/std/rpng.mt +46 -0
- data/std/rres.mt +36 -0
- data/std/sdl3/runtime.mt +54 -0
- data/std/sdl3.mt +1731 -0
- data/std/serialize.mt +68 -0
- data/std/set.mt +124 -0
- data/std/spatial.mt +176 -0
- data/std/sqlite3.mt +151 -0
- data/std/stack.mt +55 -0
- data/std/stb_image.mt +47 -0
- data/std/stb_image_resize2.mt +41 -0
- data/std/stb_image_write.mt +17 -0
- data/std/stb_rect_pack.mt +15 -0
- data/std/stb_truetype.mt +77 -0
- data/std/stb_vorbis.mt +16 -0
- data/std/stdio.mt +88 -0
- data/std/steamworks.mt +1542 -0
- data/std/str.mt +293 -0
- data/std/string.mt +234 -0
- data/std/sync.mt +194 -0
- data/std/tar.mt +704 -0
- data/std/terminal.mt +1002 -0
- data/std/testing.mt +266 -0
- data/std/thread.mt +120 -0
- data/std/time.mt +105 -0
- data/std/tls.mt +616 -0
- data/std/toml.mt +1310 -0
- data/std/tracy.mt +42 -0
- data/std/uri.mt +118 -0
- data/std/url.mt +372 -0
- data/std/vec.mt +433 -0
- data/std/zstd.mt +94 -0
- metadata +187 -2
data/std/miniaudio.mt
ADDED
|
@@ -0,0 +1,1299 @@
|
|
|
1
|
+
# generated by mtc imported-bindings from std.c.miniaudio using bindings/imported/miniaudio.binding.json
|
|
2
|
+
|
|
3
|
+
import std.c.miniaudio as c
|
|
4
|
+
|
|
5
|
+
public type context_anonymous_union_14 = c.ma_context_anonymous_union_14
|
|
6
|
+
public type context_anonymous_union_15 = c.ma_context_anonymous_union_15
|
|
7
|
+
public type device_resampling = c.ma_device_resampling
|
|
8
|
+
public type device_playback = c.ma_device_playback
|
|
9
|
+
public type device_capture = c.ma_device_capture
|
|
10
|
+
public type device_anonymous_union_24 = c.ma_device_anonymous_union_24
|
|
11
|
+
public type linear_resampler_x0 = c.ma_linear_resampler_x0
|
|
12
|
+
public type linear_resampler_x1 = c.ma_linear_resampler_x1
|
|
13
|
+
public type resampler_config_linear = c.ma_resampler_config_linear
|
|
14
|
+
public type resampler_state = c.ma_resampler_state
|
|
15
|
+
public type channel_converter_weights = c.ma_channel_converter_weights
|
|
16
|
+
public type job_toc = c.ma_job_toc
|
|
17
|
+
public type job_data = c.ma_job_data
|
|
18
|
+
public type device_notification_data = c.ma_device_notification_data
|
|
19
|
+
public type device_id_custom = c.ma_device_id_custom
|
|
20
|
+
public type context_config_dsound = c.ma_context_config_dsound
|
|
21
|
+
public type context_config_alsa = c.ma_context_config_alsa
|
|
22
|
+
public type context_config_pulse = c.ma_context_config_pulse
|
|
23
|
+
public type context_config_coreaudio = c.ma_context_config_coreaudio
|
|
24
|
+
public type context_config_jack = c.ma_context_config_jack
|
|
25
|
+
public type device_config_playback = c.ma_device_config_playback
|
|
26
|
+
public type device_config_capture = c.ma_device_config_capture
|
|
27
|
+
public type device_config_wasapi = c.ma_device_config_wasapi
|
|
28
|
+
public type device_config_alsa = c.ma_device_config_alsa
|
|
29
|
+
public type device_config_pulse = c.ma_device_config_pulse
|
|
30
|
+
public type device_config_coreaudio = c.ma_device_config_coreaudio
|
|
31
|
+
public type device_config_opensl = c.ma_device_config_opensl
|
|
32
|
+
public type device_config_aaudio = c.ma_device_config_aaudio
|
|
33
|
+
public type device_info_nativeDataFormats = c.ma_device_info_nativeDataFormats
|
|
34
|
+
public type context_command__wasapi_data = c.ma_context_command__wasapi_data
|
|
35
|
+
public type decoder_data = c.ma_decoder_data
|
|
36
|
+
public type encoder_data = c.ma_encoder_data
|
|
37
|
+
public type noise_state = c.ma_noise_state
|
|
38
|
+
public type resource_manager_data_buffer_connector = c.ma_resource_manager_data_buffer_connector
|
|
39
|
+
public type resource_manager_data_source_backend = c.ma_resource_manager_data_source_backend
|
|
40
|
+
public type resource_manager_data_supply_backend = c.ma_resource_manager_data_supply_backend
|
|
41
|
+
public type engine_node_fadeSettings = c.ma_engine_node_fadeSettings
|
|
42
|
+
public type context_anonymous_union_14_alsa = c.ma_context_anonymous_union_14_alsa
|
|
43
|
+
public type context_anonymous_union_14_pulse = c.ma_context_anonymous_union_14_pulse
|
|
44
|
+
public type context_anonymous_union_14_jack = c.ma_context_anonymous_union_14_jack
|
|
45
|
+
public type context_anonymous_union_14_null_backend = c.ma_context_anonymous_union_14_null_backend
|
|
46
|
+
public type context_anonymous_union_15_posix = c.ma_context_anonymous_union_15_posix
|
|
47
|
+
public type device_resampling_linear = c.ma_device_resampling_linear
|
|
48
|
+
public type device_anonymous_union_24_alsa = c.ma_device_anonymous_union_24_alsa
|
|
49
|
+
public type device_anonymous_union_24_pulse = c.ma_device_anonymous_union_24_pulse
|
|
50
|
+
public type device_anonymous_union_24_jack = c.ma_device_anonymous_union_24_jack
|
|
51
|
+
public type device_anonymous_union_24_null_device = c.ma_device_anonymous_union_24_null_device
|
|
52
|
+
public type job_toc_breakup = c.ma_job_toc_breakup
|
|
53
|
+
public type job_data_custom = c.ma_job_data_custom
|
|
54
|
+
public type job_data_resourceManager = c.ma_job_data_resourceManager
|
|
55
|
+
public type job_data_device = c.ma_job_data_device
|
|
56
|
+
public type device_notification_data_started = c.ma_device_notification_data_started
|
|
57
|
+
public type device_notification_data_stopped = c.ma_device_notification_data_stopped
|
|
58
|
+
public type device_notification_data_rerouted = c.ma_device_notification_data_rerouted
|
|
59
|
+
public type device_notification_data_interruption = c.ma_device_notification_data_interruption
|
|
60
|
+
public type context_command__wasapi_data_quit = c.ma_context_command__wasapi_data_quit
|
|
61
|
+
public type context_command__wasapi_data_createAudioClient = c.ma_context_command__wasapi_data_createAudioClient
|
|
62
|
+
public type context_command__wasapi_data_releaseAudioClient = c.ma_context_command__wasapi_data_releaseAudioClient
|
|
63
|
+
public type decoder_data_vfs = c.ma_decoder_data_vfs
|
|
64
|
+
public type decoder_data_memory = c.ma_decoder_data_memory
|
|
65
|
+
public type encoder_data_vfs = c.ma_encoder_data_vfs
|
|
66
|
+
public type noise_state_pink = c.ma_noise_state_pink
|
|
67
|
+
public type noise_state_brownian = c.ma_noise_state_brownian
|
|
68
|
+
public type resource_manager_data_supply_backend_encoded = c.ma_resource_manager_data_supply_backend_encoded
|
|
69
|
+
public type resource_manager_data_supply_backend_decoded = c.ma_resource_manager_data_supply_backend_decoded
|
|
70
|
+
public type resource_manager_data_supply_backend_decodedPaged = c.ma_resource_manager_data_supply_backend_decodedPaged
|
|
71
|
+
public type job_data_resourceManager_loadDataBufferNode = c.ma_job_data_resourceManager_loadDataBufferNode
|
|
72
|
+
public type job_data_resourceManager_freeDataBufferNode = c.ma_job_data_resourceManager_freeDataBufferNode
|
|
73
|
+
public type job_data_resourceManager_pageDataBufferNode = c.ma_job_data_resourceManager_pageDataBufferNode
|
|
74
|
+
public type job_data_resourceManager_loadDataBuffer = c.ma_job_data_resourceManager_loadDataBuffer
|
|
75
|
+
public type job_data_resourceManager_freeDataBuffer = c.ma_job_data_resourceManager_freeDataBuffer
|
|
76
|
+
public type job_data_resourceManager_loadDataStream = c.ma_job_data_resourceManager_loadDataStream
|
|
77
|
+
public type job_data_resourceManager_freeDataStream = c.ma_job_data_resourceManager_freeDataStream
|
|
78
|
+
public type job_data_resourceManager_pageDataStream = c.ma_job_data_resourceManager_pageDataStream
|
|
79
|
+
public type job_data_resourceManager_seekDataStream = c.ma_job_data_resourceManager_seekDataStream
|
|
80
|
+
public type job_data_device_aaudio = c.ma_job_data_device_aaudio
|
|
81
|
+
public type job_data_device_aaudio_reroute = c.ma_job_data_device_aaudio_reroute
|
|
82
|
+
public type va_list = c.va_list
|
|
83
|
+
public type int8 = c.ma_int8
|
|
84
|
+
public type uint8 = c.ma_uint8
|
|
85
|
+
public type int16 = c.ma_int16
|
|
86
|
+
public type uint16 = c.ma_uint16
|
|
87
|
+
public type int32 = c.ma_int32
|
|
88
|
+
public type uint32 = c.ma_uint32
|
|
89
|
+
public type int64 = c.ma_int64
|
|
90
|
+
public type uint64 = c.ma_uint64
|
|
91
|
+
public type uintptr = c.ma_uintptr
|
|
92
|
+
public type bool8 = c.ma_bool8
|
|
93
|
+
public type bool32 = c.ma_bool32
|
|
94
|
+
public type float_ = c.ma_float
|
|
95
|
+
public type double_ = c.ma_double
|
|
96
|
+
public type handle = c.ma_handle
|
|
97
|
+
public type ptr_ = c.ma_ptr
|
|
98
|
+
public type proc_ = c.ma_proc
|
|
99
|
+
public type pthread_t = c.ma_pthread_t
|
|
100
|
+
public type pthread_mutex_t = c.ma_pthread_mutex_t
|
|
101
|
+
public type pthread_cond_t = c.ma_pthread_cond_t
|
|
102
|
+
public type wchar_win32 = c.ma_wchar_win32
|
|
103
|
+
public type log_level = c.ma_log_level
|
|
104
|
+
public type channel = c.ma_channel
|
|
105
|
+
public type result = c.ma_result
|
|
106
|
+
public type stream_format = c.ma_stream_format
|
|
107
|
+
public type stream_layout = c.ma_stream_layout
|
|
108
|
+
public type dither_mode = c.ma_dither_mode
|
|
109
|
+
public type format = c.ma_format
|
|
110
|
+
public type standard_sample_rate = c.ma_standard_sample_rate
|
|
111
|
+
public type channel_mix_mode = c.ma_channel_mix_mode
|
|
112
|
+
public type standard_channel_map = c.ma_standard_channel_map
|
|
113
|
+
public type performance_profile = c.ma_performance_profile
|
|
114
|
+
public type allocation_callbacks = c.ma_allocation_callbacks
|
|
115
|
+
public type lcg = c.ma_lcg
|
|
116
|
+
public type atomic_uint32 = c.ma_atomic_uint32
|
|
117
|
+
public type atomic_int32 = c.ma_atomic_int32
|
|
118
|
+
public type atomic_uint64 = c.ma_atomic_uint64
|
|
119
|
+
public type atomic_float = c.ma_atomic_float
|
|
120
|
+
public type atomic_bool32 = c.ma_atomic_bool32
|
|
121
|
+
public type spinlock = c.ma_spinlock
|
|
122
|
+
public type thread_priority = c.ma_thread_priority
|
|
123
|
+
public type thread = c.ma_thread
|
|
124
|
+
public type mutex = c.ma_mutex
|
|
125
|
+
public type event_ = c.ma_event
|
|
126
|
+
public type semaphore = c.ma_semaphore
|
|
127
|
+
public type log_callback_proc = c.ma_log_callback_proc
|
|
128
|
+
public type log_callback = c.ma_log_callback
|
|
129
|
+
public type log = c.ma_log
|
|
130
|
+
public type biquad_coefficient = c.ma_biquad_coefficient
|
|
131
|
+
public type biquad_config = c.ma_biquad_config
|
|
132
|
+
public type biquad = c.ma_biquad
|
|
133
|
+
public type lpf2_config = c.ma_lpf2_config
|
|
134
|
+
public type lpf1_config = c.ma_lpf1_config
|
|
135
|
+
public type lpf1 = c.ma_lpf1
|
|
136
|
+
public type lpf2 = c.ma_lpf2
|
|
137
|
+
public type lpf_config = c.ma_lpf_config
|
|
138
|
+
public type lpf = c.ma_lpf
|
|
139
|
+
public type hpf2_config = c.ma_hpf2_config
|
|
140
|
+
public type hpf1_config = c.ma_hpf1_config
|
|
141
|
+
public type hpf1 = c.ma_hpf1
|
|
142
|
+
public type hpf2 = c.ma_hpf2
|
|
143
|
+
public type hpf_config = c.ma_hpf_config
|
|
144
|
+
public type hpf = c.ma_hpf
|
|
145
|
+
public type bpf2_config = c.ma_bpf2_config
|
|
146
|
+
public type bpf2 = c.ma_bpf2
|
|
147
|
+
public type bpf_config = c.ma_bpf_config
|
|
148
|
+
public type bpf = c.ma_bpf
|
|
149
|
+
public type notch_config = c.ma_notch_config
|
|
150
|
+
public type notch2_config = c.ma_notch2_config
|
|
151
|
+
public type notch2 = c.ma_notch2
|
|
152
|
+
public type peak_config = c.ma_peak_config
|
|
153
|
+
public type peak2_config = c.ma_peak2_config
|
|
154
|
+
public type peak2 = c.ma_peak2
|
|
155
|
+
public type loshelf_config = c.ma_loshelf_config
|
|
156
|
+
public type loshelf2_config = c.ma_loshelf2_config
|
|
157
|
+
public type loshelf2 = c.ma_loshelf2
|
|
158
|
+
public type hishelf_config = c.ma_hishelf_config
|
|
159
|
+
public type hishelf2_config = c.ma_hishelf2_config
|
|
160
|
+
public type hishelf2 = c.ma_hishelf2
|
|
161
|
+
public type delay_config = c.ma_delay_config
|
|
162
|
+
public type delay = c.ma_delay
|
|
163
|
+
public type gainer_config = c.ma_gainer_config
|
|
164
|
+
public type gainer = c.ma_gainer
|
|
165
|
+
public type pan_mode = c.ma_pan_mode
|
|
166
|
+
public type panner_config = c.ma_panner_config
|
|
167
|
+
public type panner = c.ma_panner
|
|
168
|
+
public type fader_config = c.ma_fader_config
|
|
169
|
+
public type fader = c.ma_fader
|
|
170
|
+
public type vec3f = c.ma_vec3f
|
|
171
|
+
public type atomic_vec3f = c.ma_atomic_vec3f
|
|
172
|
+
public type attenuation_model = c.ma_attenuation_model
|
|
173
|
+
public type positioning = c.ma_positioning
|
|
174
|
+
public type handedness = c.ma_handedness
|
|
175
|
+
public type spatializer_listener_config = c.ma_spatializer_listener_config
|
|
176
|
+
public type spatializer_listener = c.ma_spatializer_listener
|
|
177
|
+
public type spatializer_config = c.ma_spatializer_config
|
|
178
|
+
public type spatializer = c.ma_spatializer
|
|
179
|
+
public type linear_resampler_config = c.ma_linear_resampler_config
|
|
180
|
+
public type linear_resampler = c.ma_linear_resampler
|
|
181
|
+
public type resampling_backend = c.ma_resampling_backend
|
|
182
|
+
public type resampling_backend_vtable = c.ma_resampling_backend_vtable
|
|
183
|
+
public type resample_algorithm = c.ma_resample_algorithm
|
|
184
|
+
public type resampler_config = c.ma_resampler_config
|
|
185
|
+
public type resampler = c.ma_resampler
|
|
186
|
+
public type channel_conversion_path = c.ma_channel_conversion_path
|
|
187
|
+
public type mono_expansion_mode = c.ma_mono_expansion_mode
|
|
188
|
+
public type channel_converter_config = c.ma_channel_converter_config
|
|
189
|
+
public type channel_converter = c.ma_channel_converter
|
|
190
|
+
public type data_converter_config = c.ma_data_converter_config
|
|
191
|
+
public type data_converter_execution_path = c.ma_data_converter_execution_path
|
|
192
|
+
public type data_converter = c.ma_data_converter
|
|
193
|
+
public type data_source = c.ma_data_source
|
|
194
|
+
public type data_source_vtable = c.ma_data_source_vtable
|
|
195
|
+
public type data_source_get_next_proc = c.ma_data_source_get_next_proc
|
|
196
|
+
public type data_source_config = c.ma_data_source_config
|
|
197
|
+
public type data_source_base = c.ma_data_source_base
|
|
198
|
+
public type audio_buffer_ref = c.ma_audio_buffer_ref
|
|
199
|
+
public type audio_buffer_config = c.ma_audio_buffer_config
|
|
200
|
+
public type audio_buffer = c.ma_audio_buffer
|
|
201
|
+
public type paged_audio_buffer_page = c.ma_paged_audio_buffer_page
|
|
202
|
+
public type paged_audio_buffer_data = c.ma_paged_audio_buffer_data
|
|
203
|
+
public type paged_audio_buffer_config = c.ma_paged_audio_buffer_config
|
|
204
|
+
public type paged_audio_buffer = c.ma_paged_audio_buffer
|
|
205
|
+
public type rb = c.ma_rb
|
|
206
|
+
public type pcm_rb = c.ma_pcm_rb
|
|
207
|
+
public type duplex_rb = c.ma_duplex_rb
|
|
208
|
+
public type fence = c.ma_fence
|
|
209
|
+
public type async_notification = c.ma_async_notification
|
|
210
|
+
public type async_notification_callbacks = c.ma_async_notification_callbacks
|
|
211
|
+
public type async_notification_poll = c.ma_async_notification_poll
|
|
212
|
+
public type async_notification_event = c.ma_async_notification_event
|
|
213
|
+
public type slot_allocator_config = c.ma_slot_allocator_config
|
|
214
|
+
public type slot_allocator_group = c.ma_slot_allocator_group
|
|
215
|
+
public type slot_allocator = c.ma_slot_allocator
|
|
216
|
+
public type job_proc = c.ma_job_proc
|
|
217
|
+
public type job_type = c.ma_job_type
|
|
218
|
+
public type job = c.ma_job
|
|
219
|
+
public type job_queue_flags = c.ma_job_queue_flags
|
|
220
|
+
public type job_queue_config = c.ma_job_queue_config
|
|
221
|
+
public type job_queue = c.ma_job_queue
|
|
222
|
+
public type device_state = c.ma_device_state
|
|
223
|
+
public type atomic_device_state = c.ma_atomic_device_state
|
|
224
|
+
public type backend = c.ma_backend
|
|
225
|
+
public type device_job_thread_config = c.ma_device_job_thread_config
|
|
226
|
+
public type device_job_thread = c.ma_device_job_thread
|
|
227
|
+
public type device_notification_type = c.ma_device_notification_type
|
|
228
|
+
public type device_notification = c.ma_device_notification
|
|
229
|
+
public type device_notification_proc = c.ma_device_notification_proc
|
|
230
|
+
public type device_data_proc = c.ma_device_data_proc
|
|
231
|
+
public type stop_proc = c.ma_stop_proc
|
|
232
|
+
public type device_type = c.ma_device_type
|
|
233
|
+
public type share_mode = c.ma_share_mode
|
|
234
|
+
public type ios_session_category = c.ma_ios_session_category
|
|
235
|
+
public type ios_session_category_option = c.ma_ios_session_category_option
|
|
236
|
+
public type opensl_stream_type = c.ma_opensl_stream_type
|
|
237
|
+
public type opensl_recording_preset = c.ma_opensl_recording_preset
|
|
238
|
+
public type wasapi_usage = c.ma_wasapi_usage
|
|
239
|
+
public type aaudio_usage = c.ma_aaudio_usage
|
|
240
|
+
public type aaudio_content_type = c.ma_aaudio_content_type
|
|
241
|
+
public type aaudio_input_preset = c.ma_aaudio_input_preset
|
|
242
|
+
public type aaudio_allowed_capture_policy = c.ma_aaudio_allowed_capture_policy
|
|
243
|
+
public type timer = c.ma_timer
|
|
244
|
+
public type device_id = c.ma_device_id
|
|
245
|
+
public type device_info = c.ma_device_info
|
|
246
|
+
public type device_config = c.ma_device_config
|
|
247
|
+
public type enum_devices_callback_proc = c.ma_enum_devices_callback_proc
|
|
248
|
+
public type device_descriptor = c.ma_device_descriptor
|
|
249
|
+
public type backend_callbacks = c.ma_backend_callbacks
|
|
250
|
+
public type context_config = c.ma_context_config
|
|
251
|
+
public type context_command__wasapi = c.ma_context_command__wasapi
|
|
252
|
+
public type context = c.ma_context
|
|
253
|
+
public type device = c.ma_device
|
|
254
|
+
public type vfs = c.ma_vfs
|
|
255
|
+
public type vfs_file = c.ma_vfs_file
|
|
256
|
+
public type open_mode_flags = c.ma_open_mode_flags
|
|
257
|
+
public type seek_origin = c.ma_seek_origin
|
|
258
|
+
public type file_info = c.ma_file_info
|
|
259
|
+
public type vfs_callbacks = c.ma_vfs_callbacks
|
|
260
|
+
public type default_vfs = c.ma_default_vfs
|
|
261
|
+
public type read_proc = c.ma_read_proc
|
|
262
|
+
public type seek_proc = c.ma_seek_proc
|
|
263
|
+
public type tell_proc = c.ma_tell_proc
|
|
264
|
+
public type encoding_format = c.ma_encoding_format
|
|
265
|
+
public type decoding_backend_config = c.ma_decoding_backend_config
|
|
266
|
+
public type decoding_backend_vtable = c.ma_decoding_backend_vtable
|
|
267
|
+
public type decoder_read_proc = c.ma_decoder_read_proc
|
|
268
|
+
public type decoder_seek_proc = c.ma_decoder_seek_proc
|
|
269
|
+
public type decoder_tell_proc = c.ma_decoder_tell_proc
|
|
270
|
+
public type decoder_config = c.ma_decoder_config
|
|
271
|
+
public type decoder = c.ma_decoder
|
|
272
|
+
public type encoder_write_proc = c.ma_encoder_write_proc
|
|
273
|
+
public type encoder_seek_proc = c.ma_encoder_seek_proc
|
|
274
|
+
public type encoder_init_proc = c.ma_encoder_init_proc
|
|
275
|
+
public type encoder_uninit_proc = c.ma_encoder_uninit_proc
|
|
276
|
+
public type encoder_write_pcm_frames_proc = c.ma_encoder_write_pcm_frames_proc
|
|
277
|
+
public type encoder_config = c.ma_encoder_config
|
|
278
|
+
public type encoder = c.ma_encoder
|
|
279
|
+
public type waveform_type = c.ma_waveform_type
|
|
280
|
+
public type waveform_config = c.ma_waveform_config
|
|
281
|
+
public type waveform = c.ma_waveform
|
|
282
|
+
public type pulsewave_config = c.ma_pulsewave_config
|
|
283
|
+
public type pulsewave = c.ma_pulsewave
|
|
284
|
+
public type noise_type = c.ma_noise_type
|
|
285
|
+
public type noise_config = c.ma_noise_config
|
|
286
|
+
public type noise = c.ma_noise
|
|
287
|
+
public type resource_manager_data_source_flags = c.ma_resource_manager_data_source_flags
|
|
288
|
+
public type resource_manager_pipeline_stage_notification = c.ma_resource_manager_pipeline_stage_notification
|
|
289
|
+
public type resource_manager_pipeline_notifications = c.ma_resource_manager_pipeline_notifications
|
|
290
|
+
public type resource_manager_flags = c.ma_resource_manager_flags
|
|
291
|
+
public type resource_manager_data_source_config = c.ma_resource_manager_data_source_config
|
|
292
|
+
public type resource_manager_data_supply_type = c.ma_resource_manager_data_supply_type
|
|
293
|
+
public type resource_manager_data_supply = c.ma_resource_manager_data_supply
|
|
294
|
+
public type resource_manager_data_buffer_node = c.ma_resource_manager_data_buffer_node
|
|
295
|
+
public type resource_manager_data_buffer = c.ma_resource_manager_data_buffer
|
|
296
|
+
public type resource_manager_data_stream = c.ma_resource_manager_data_stream
|
|
297
|
+
public type resource_manager_data_source = c.ma_resource_manager_data_source
|
|
298
|
+
public type resource_manager_config = c.ma_resource_manager_config
|
|
299
|
+
public type resource_manager = c.ma_resource_manager
|
|
300
|
+
public type stack = c.ma_stack
|
|
301
|
+
public type node = c.ma_node
|
|
302
|
+
public type node_flags = c.ma_node_flags
|
|
303
|
+
public type node_state = c.ma_node_state
|
|
304
|
+
public type node_vtable = c.ma_node_vtable
|
|
305
|
+
public type node_config = c.ma_node_config
|
|
306
|
+
public type node_output_bus = c.ma_node_output_bus
|
|
307
|
+
public type node_input_bus = c.ma_node_input_bus
|
|
308
|
+
public type node_base = c.ma_node_base
|
|
309
|
+
public type node_graph_config = c.ma_node_graph_config
|
|
310
|
+
public type node_graph = c.ma_node_graph
|
|
311
|
+
public type data_source_node_config = c.ma_data_source_node_config
|
|
312
|
+
public type data_source_node = c.ma_data_source_node
|
|
313
|
+
public type splitter_node_config = c.ma_splitter_node_config
|
|
314
|
+
public type splitter_node = c.ma_splitter_node
|
|
315
|
+
public type biquad_node_config = c.ma_biquad_node_config
|
|
316
|
+
public type biquad_node = c.ma_biquad_node
|
|
317
|
+
public type lpf_node_config = c.ma_lpf_node_config
|
|
318
|
+
public type lpf_node = c.ma_lpf_node
|
|
319
|
+
public type hpf_node_config = c.ma_hpf_node_config
|
|
320
|
+
public type hpf_node = c.ma_hpf_node
|
|
321
|
+
public type bpf_node_config = c.ma_bpf_node_config
|
|
322
|
+
public type bpf_node = c.ma_bpf_node
|
|
323
|
+
public type notch_node_config = c.ma_notch_node_config
|
|
324
|
+
public type notch_node = c.ma_notch_node
|
|
325
|
+
public type peak_node_config = c.ma_peak_node_config
|
|
326
|
+
public type peak_node = c.ma_peak_node
|
|
327
|
+
public type loshelf_node_config = c.ma_loshelf_node_config
|
|
328
|
+
public type loshelf_node = c.ma_loshelf_node
|
|
329
|
+
public type hishelf_node_config = c.ma_hishelf_node_config
|
|
330
|
+
public type hishelf_node = c.ma_hishelf_node
|
|
331
|
+
public type delay_node_config = c.ma_delay_node_config
|
|
332
|
+
public type delay_node = c.ma_delay_node
|
|
333
|
+
public type sound_flags = c.ma_sound_flags
|
|
334
|
+
public type engine_node_type = c.ma_engine_node_type
|
|
335
|
+
public type engine_node_config = c.ma_engine_node_config
|
|
336
|
+
public type engine_node = c.ma_engine_node
|
|
337
|
+
public type sound_end_proc = c.ma_sound_end_proc
|
|
338
|
+
public type sound_config = c.ma_sound_config
|
|
339
|
+
public type sound = c.ma_sound
|
|
340
|
+
public type sound_inlined = c.ma_sound_inlined
|
|
341
|
+
public type sound_group_config = c.ma_sound_group_config
|
|
342
|
+
public type sound_group = c.ma_sound_group
|
|
343
|
+
public type engine_process_proc = c.ma_engine_process_proc
|
|
344
|
+
public type engine_config = c.ma_engine_config
|
|
345
|
+
public type engine = c.ma_engine
|
|
346
|
+
|
|
347
|
+
public const VERSION_MAJOR: int = c.MA_VERSION_MAJOR
|
|
348
|
+
public const VERSION_MINOR: int = c.MA_VERSION_MINOR
|
|
349
|
+
public const VERSION_REVISION: int = c.MA_VERSION_REVISION
|
|
350
|
+
public const SIZEOF_PTR: int = c.MA_SIZEOF_PTR
|
|
351
|
+
public const TRUE: int = c.MA_TRUE
|
|
352
|
+
public const FALSE: int = c.MA_FALSE
|
|
353
|
+
public const SIZE_MAX: uint = c.MA_SIZE_MAX
|
|
354
|
+
public const SIMD_ALIGNMENT: int = c.MA_SIMD_ALIGNMENT
|
|
355
|
+
public const MIN_CHANNELS: int = c.MA_MIN_CHANNELS
|
|
356
|
+
public const MAX_CHANNELS: int = c.MA_MAX_CHANNELS
|
|
357
|
+
public const MAX_FILTER_ORDER: int = c.MA_MAX_FILTER_ORDER
|
|
358
|
+
public const MAX_LOG_CALLBACKS: int = c.MA_MAX_LOG_CALLBACKS
|
|
359
|
+
public const CHANNEL_INDEX_NULL: int = c.MA_CHANNEL_INDEX_NULL
|
|
360
|
+
public const DATA_SOURCE_SELF_MANAGED_RANGE_AND_LOOP_POINT: int = c.MA_DATA_SOURCE_SELF_MANAGED_RANGE_AND_LOOP_POINT
|
|
361
|
+
public const MAX_DEVICE_NAME_LENGTH: int = c.MA_MAX_DEVICE_NAME_LENGTH
|
|
362
|
+
public const RESOURCE_MANAGER_MAX_JOB_THREAD_COUNT: int = c.MA_RESOURCE_MANAGER_MAX_JOB_THREAD_COUNT
|
|
363
|
+
public const MAX_NODE_BUS_COUNT: int = c.MA_MAX_NODE_BUS_COUNT
|
|
364
|
+
public const MAX_NODE_LOCAL_BUS_COUNT: int = c.MA_MAX_NODE_LOCAL_BUS_COUNT
|
|
365
|
+
public const NODE_BUS_COUNT_UNKNOWN: int = c.MA_NODE_BUS_COUNT_UNKNOWN
|
|
366
|
+
public const ENGINE_MAX_LISTENERS: int = c.MA_ENGINE_MAX_LISTENERS
|
|
367
|
+
public const SOUND_SOURCE_CHANNEL_COUNT: uint = c.MA_SOUND_SOURCE_CHANNEL_COUNT
|
|
368
|
+
|
|
369
|
+
public foreign function version(p_major: ptr[uint32], p_minor: ptr[uint32], p_revision: ptr[uint32]) -> void = c.ma_version
|
|
370
|
+
public foreign function version_string() -> cstr = c.ma_version_string
|
|
371
|
+
public foreign function log_callback_init(on_log: fn(arg0: ptr[void], arg1: uint32, arg2: cstr) -> void, p_user_data: ptr[void]) -> log_callback = c.ma_log_callback_init
|
|
372
|
+
public foreign function log_init(p_allocation_callbacks: const_ptr[allocation_callbacks], p_log: ptr[log]) -> result = c.ma_log_init
|
|
373
|
+
public foreign function log_uninit(p_log: ptr[log]) -> void = c.ma_log_uninit
|
|
374
|
+
public foreign function log_register_callback(p_log: ptr[log], callback: log_callback) -> result = c.ma_log_register_callback
|
|
375
|
+
public foreign function log_unregister_callback(p_log: ptr[log], callback: log_callback) -> result = c.ma_log_unregister_callback
|
|
376
|
+
public foreign function log_post(p_log: ptr[log], level: uint, p_message: str as cstr) -> result = c.ma_log_post
|
|
377
|
+
public foreign function log_postv(p_log: ptr[log], level: uint, p_format: str as cstr, args: va_list) -> result = c.ma_log_postv
|
|
378
|
+
public foreign function log_postf(p_log: ptr[log], level: uint, p_format: str as cstr, ...) -> result = c.ma_log_postf
|
|
379
|
+
public foreign function biquad_config_init(format: format, channels: uint, b0: double, b1: double, b2: double, a0: double, a1: double, a2: double) -> biquad_config = c.ma_biquad_config_init
|
|
380
|
+
public foreign function biquad_get_heap_size(p_config: const_ptr[biquad_config], p_heap_size_in_bytes: ptr[ptr_uint]) -> result = c.ma_biquad_get_heap_size
|
|
381
|
+
public foreign function biquad_init_preallocated(p_config: const_ptr[biquad_config], p_heap: ptr[void], p_bq: ptr[biquad]) -> result = c.ma_biquad_init_preallocated
|
|
382
|
+
public foreign function biquad_init(p_config: const_ptr[biquad_config], p_allocation_callbacks: const_ptr[allocation_callbacks], p_bq: ptr[biquad]) -> result = c.ma_biquad_init
|
|
383
|
+
public foreign function biquad_uninit(p_bq: ptr[biquad], p_allocation_callbacks: const_ptr[allocation_callbacks]) -> void = c.ma_biquad_uninit
|
|
384
|
+
public foreign function biquad_reinit(p_config: const_ptr[biquad_config], p_bq: ptr[biquad]) -> result = c.ma_biquad_reinit
|
|
385
|
+
public foreign function biquad_clear_cache(p_bq: ptr[biquad]) -> result = c.ma_biquad_clear_cache
|
|
386
|
+
public foreign function biquad_process_pcm_frames(p_bq: ptr[biquad], p_frames_out: ptr[void], p_frames_in: const_ptr[void], frame_count: ulong) -> result = c.ma_biquad_process_pcm_frames
|
|
387
|
+
public foreign function biquad_get_latency(p_bq: const_ptr[biquad]) -> uint32 = c.ma_biquad_get_latency
|
|
388
|
+
public foreign function lpf1_config_init(format: format, channels: uint, sample_rate: uint, cutoff_frequency: double) -> lpf1_config = c.ma_lpf1_config_init
|
|
389
|
+
public foreign function lpf2_config_init(format: format, channels: uint, sample_rate: uint, cutoff_frequency: double, q: double) -> lpf2_config = c.ma_lpf2_config_init
|
|
390
|
+
public foreign function lpf1_get_heap_size(p_config: const_ptr[lpf1_config], p_heap_size_in_bytes: ptr[ptr_uint]) -> result = c.ma_lpf1_get_heap_size
|
|
391
|
+
public foreign function lpf1_init_preallocated(p_config: const_ptr[lpf1_config], p_heap: ptr[void], p_lpf: ptr[lpf1]) -> result = c.ma_lpf1_init_preallocated
|
|
392
|
+
public foreign function lpf1_init(p_config: const_ptr[lpf1_config], p_allocation_callbacks: const_ptr[allocation_callbacks], p_lpf: ptr[lpf1]) -> result = c.ma_lpf1_init
|
|
393
|
+
public foreign function lpf1_uninit(p_lpf: ptr[lpf1], p_allocation_callbacks: const_ptr[allocation_callbacks]) -> void = c.ma_lpf1_uninit
|
|
394
|
+
public foreign function lpf1_reinit(p_config: const_ptr[lpf1_config], p_lpf: ptr[lpf1]) -> result = c.ma_lpf1_reinit
|
|
395
|
+
public foreign function lpf1_clear_cache(p_lpf: ptr[lpf1]) -> result = c.ma_lpf1_clear_cache
|
|
396
|
+
public foreign function lpf1_process_pcm_frames(p_lpf: ptr[lpf1], p_frames_out: ptr[void], p_frames_in: const_ptr[void], frame_count: ulong) -> result = c.ma_lpf1_process_pcm_frames
|
|
397
|
+
public foreign function lpf1_get_latency(p_lpf: const_ptr[lpf1]) -> uint32 = c.ma_lpf1_get_latency
|
|
398
|
+
public foreign function lpf2_get_heap_size(p_config: const_ptr[lpf2_config], p_heap_size_in_bytes: ptr[ptr_uint]) -> result = c.ma_lpf2_get_heap_size
|
|
399
|
+
public foreign function lpf2_init_preallocated(p_config: const_ptr[lpf2_config], p_heap: ptr[void], p_hpf: ptr[lpf2]) -> result = c.ma_lpf2_init_preallocated
|
|
400
|
+
public foreign function lpf2_init(p_config: const_ptr[lpf2_config], p_allocation_callbacks: const_ptr[allocation_callbacks], p_lpf: ptr[lpf2]) -> result = c.ma_lpf2_init
|
|
401
|
+
public foreign function lpf2_uninit(p_lpf: ptr[lpf2], p_allocation_callbacks: const_ptr[allocation_callbacks]) -> void = c.ma_lpf2_uninit
|
|
402
|
+
public foreign function lpf2_reinit(p_config: const_ptr[lpf2_config], p_lpf: ptr[lpf2]) -> result = c.ma_lpf2_reinit
|
|
403
|
+
public foreign function lpf2_clear_cache(p_lpf: ptr[lpf2]) -> result = c.ma_lpf2_clear_cache
|
|
404
|
+
public foreign function lpf2_process_pcm_frames(p_lpf: ptr[lpf2], p_frames_out: ptr[void], p_frames_in: const_ptr[void], frame_count: ulong) -> result = c.ma_lpf2_process_pcm_frames
|
|
405
|
+
public foreign function lpf2_get_latency(p_lpf: const_ptr[lpf2]) -> uint32 = c.ma_lpf2_get_latency
|
|
406
|
+
public foreign function lpf_config_init(format: format, channels: uint, sample_rate: uint, cutoff_frequency: double, order: uint) -> lpf_config = c.ma_lpf_config_init
|
|
407
|
+
public foreign function lpf_get_heap_size(p_config: const_ptr[lpf_config], p_heap_size_in_bytes: ptr[ptr_uint]) -> result = c.ma_lpf_get_heap_size
|
|
408
|
+
public foreign function lpf_init_preallocated(p_config: const_ptr[lpf_config], p_heap: ptr[void], p_lpf: ptr[lpf]) -> result = c.ma_lpf_init_preallocated
|
|
409
|
+
public foreign function lpf_init(p_config: const_ptr[lpf_config], p_allocation_callbacks: const_ptr[allocation_callbacks], p_lpf: ptr[lpf]) -> result = c.ma_lpf_init
|
|
410
|
+
public foreign function lpf_uninit(p_lpf: ptr[lpf], p_allocation_callbacks: const_ptr[allocation_callbacks]) -> void = c.ma_lpf_uninit
|
|
411
|
+
public foreign function lpf_reinit(p_config: const_ptr[lpf_config], p_lpf: ptr[lpf]) -> result = c.ma_lpf_reinit
|
|
412
|
+
public foreign function lpf_clear_cache(p_lpf: ptr[lpf]) -> result = c.ma_lpf_clear_cache
|
|
413
|
+
public foreign function lpf_process_pcm_frames(p_lpf: ptr[lpf], p_frames_out: ptr[void], p_frames_in: const_ptr[void], frame_count: ulong) -> result = c.ma_lpf_process_pcm_frames
|
|
414
|
+
public foreign function lpf_get_latency(p_lpf: const_ptr[lpf]) -> uint32 = c.ma_lpf_get_latency
|
|
415
|
+
public foreign function hpf1_config_init(format: format, channels: uint, sample_rate: uint, cutoff_frequency: double) -> hpf1_config = c.ma_hpf1_config_init
|
|
416
|
+
public foreign function hpf2_config_init(format: format, channels: uint, sample_rate: uint, cutoff_frequency: double, q: double) -> hpf2_config = c.ma_hpf2_config_init
|
|
417
|
+
public foreign function hpf1_get_heap_size(p_config: const_ptr[hpf1_config], p_heap_size_in_bytes: ptr[ptr_uint]) -> result = c.ma_hpf1_get_heap_size
|
|
418
|
+
public foreign function hpf1_init_preallocated(p_config: const_ptr[hpf1_config], p_heap: ptr[void], p_lpf: ptr[hpf1]) -> result = c.ma_hpf1_init_preallocated
|
|
419
|
+
public foreign function hpf1_init(p_config: const_ptr[hpf1_config], p_allocation_callbacks: const_ptr[allocation_callbacks], p_hpf: ptr[hpf1]) -> result = c.ma_hpf1_init
|
|
420
|
+
public foreign function hpf1_uninit(p_hpf: ptr[hpf1], p_allocation_callbacks: const_ptr[allocation_callbacks]) -> void = c.ma_hpf1_uninit
|
|
421
|
+
public foreign function hpf1_reinit(p_config: const_ptr[hpf1_config], p_hpf: ptr[hpf1]) -> result = c.ma_hpf1_reinit
|
|
422
|
+
public foreign function hpf1_process_pcm_frames(p_hpf: ptr[hpf1], p_frames_out: ptr[void], p_frames_in: const_ptr[void], frame_count: ulong) -> result = c.ma_hpf1_process_pcm_frames
|
|
423
|
+
public foreign function hpf1_get_latency(p_hpf: const_ptr[hpf1]) -> uint32 = c.ma_hpf1_get_latency
|
|
424
|
+
public foreign function hpf2_get_heap_size(p_config: const_ptr[hpf2_config], p_heap_size_in_bytes: ptr[ptr_uint]) -> result = c.ma_hpf2_get_heap_size
|
|
425
|
+
public foreign function hpf2_init_preallocated(p_config: const_ptr[hpf2_config], p_heap: ptr[void], p_hpf: ptr[hpf2]) -> result = c.ma_hpf2_init_preallocated
|
|
426
|
+
public foreign function hpf2_init(p_config: const_ptr[hpf2_config], p_allocation_callbacks: const_ptr[allocation_callbacks], p_hpf: ptr[hpf2]) -> result = c.ma_hpf2_init
|
|
427
|
+
public foreign function hpf2_uninit(p_hpf: ptr[hpf2], p_allocation_callbacks: const_ptr[allocation_callbacks]) -> void = c.ma_hpf2_uninit
|
|
428
|
+
public foreign function hpf2_reinit(p_config: const_ptr[hpf2_config], p_hpf: ptr[hpf2]) -> result = c.ma_hpf2_reinit
|
|
429
|
+
public foreign function hpf2_process_pcm_frames(p_hpf: ptr[hpf2], p_frames_out: ptr[void], p_frames_in: const_ptr[void], frame_count: ulong) -> result = c.ma_hpf2_process_pcm_frames
|
|
430
|
+
public foreign function hpf2_get_latency(p_hpf: const_ptr[hpf2]) -> uint32 = c.ma_hpf2_get_latency
|
|
431
|
+
public foreign function hpf_config_init(format: format, channels: uint, sample_rate: uint, cutoff_frequency: double, order: uint) -> hpf_config = c.ma_hpf_config_init
|
|
432
|
+
public foreign function hpf_get_heap_size(p_config: const_ptr[hpf_config], p_heap_size_in_bytes: ptr[ptr_uint]) -> result = c.ma_hpf_get_heap_size
|
|
433
|
+
public foreign function hpf_init_preallocated(p_config: const_ptr[hpf_config], p_heap: ptr[void], p_lpf: ptr[hpf]) -> result = c.ma_hpf_init_preallocated
|
|
434
|
+
public foreign function hpf_init(p_config: const_ptr[hpf_config], p_allocation_callbacks: const_ptr[allocation_callbacks], p_hpf: ptr[hpf]) -> result = c.ma_hpf_init
|
|
435
|
+
public foreign function hpf_uninit(p_hpf: ptr[hpf], p_allocation_callbacks: const_ptr[allocation_callbacks]) -> void = c.ma_hpf_uninit
|
|
436
|
+
public foreign function hpf_reinit(p_config: const_ptr[hpf_config], p_hpf: ptr[hpf]) -> result = c.ma_hpf_reinit
|
|
437
|
+
public foreign function hpf_process_pcm_frames(p_hpf: ptr[hpf], p_frames_out: ptr[void], p_frames_in: const_ptr[void], frame_count: ulong) -> result = c.ma_hpf_process_pcm_frames
|
|
438
|
+
public foreign function hpf_get_latency(p_hpf: const_ptr[hpf]) -> uint32 = c.ma_hpf_get_latency
|
|
439
|
+
public foreign function bpf2_config_init(format: format, channels: uint, sample_rate: uint, cutoff_frequency: double, q: double) -> bpf2_config = c.ma_bpf2_config_init
|
|
440
|
+
public foreign function bpf2_get_heap_size(p_config: const_ptr[bpf2_config], p_heap_size_in_bytes: ptr[ptr_uint]) -> result = c.ma_bpf2_get_heap_size
|
|
441
|
+
public foreign function bpf2_init_preallocated(p_config: const_ptr[bpf2_config], p_heap: ptr[void], p_bpf: ptr[bpf2]) -> result = c.ma_bpf2_init_preallocated
|
|
442
|
+
public foreign function bpf2_init(p_config: const_ptr[bpf2_config], p_allocation_callbacks: const_ptr[allocation_callbacks], p_bpf: ptr[bpf2]) -> result = c.ma_bpf2_init
|
|
443
|
+
public foreign function bpf2_uninit(p_bpf: ptr[bpf2], p_allocation_callbacks: const_ptr[allocation_callbacks]) -> void = c.ma_bpf2_uninit
|
|
444
|
+
public foreign function bpf2_reinit(p_config: const_ptr[bpf2_config], p_bpf: ptr[bpf2]) -> result = c.ma_bpf2_reinit
|
|
445
|
+
public foreign function bpf2_process_pcm_frames(p_bpf: ptr[bpf2], p_frames_out: ptr[void], p_frames_in: const_ptr[void], frame_count: ulong) -> result = c.ma_bpf2_process_pcm_frames
|
|
446
|
+
public foreign function bpf2_get_latency(p_bpf: const_ptr[bpf2]) -> uint32 = c.ma_bpf2_get_latency
|
|
447
|
+
public foreign function bpf_config_init(format: format, channels: uint, sample_rate: uint, cutoff_frequency: double, order: uint) -> bpf_config = c.ma_bpf_config_init
|
|
448
|
+
public foreign function bpf_get_heap_size(p_config: const_ptr[bpf_config], p_heap_size_in_bytes: ptr[ptr_uint]) -> result = c.ma_bpf_get_heap_size
|
|
449
|
+
public foreign function bpf_init_preallocated(p_config: const_ptr[bpf_config], p_heap: ptr[void], p_bpf: ptr[bpf]) -> result = c.ma_bpf_init_preallocated
|
|
450
|
+
public foreign function bpf_init(p_config: const_ptr[bpf_config], p_allocation_callbacks: const_ptr[allocation_callbacks], p_bpf: ptr[bpf]) -> result = c.ma_bpf_init
|
|
451
|
+
public foreign function bpf_uninit(p_bpf: ptr[bpf], p_allocation_callbacks: const_ptr[allocation_callbacks]) -> void = c.ma_bpf_uninit
|
|
452
|
+
public foreign function bpf_reinit(p_config: const_ptr[bpf_config], p_bpf: ptr[bpf]) -> result = c.ma_bpf_reinit
|
|
453
|
+
public foreign function bpf_process_pcm_frames(p_bpf: ptr[bpf], p_frames_out: ptr[void], p_frames_in: const_ptr[void], frame_count: ulong) -> result = c.ma_bpf_process_pcm_frames
|
|
454
|
+
public foreign function bpf_get_latency(p_bpf: const_ptr[bpf]) -> uint32 = c.ma_bpf_get_latency
|
|
455
|
+
public foreign function notch2_config_init(format: format, channels: uint, sample_rate: uint, q: double, frequency: double) -> notch2_config = c.ma_notch2_config_init
|
|
456
|
+
public foreign function notch2_get_heap_size(p_config: const_ptr[notch2_config], p_heap_size_in_bytes: ptr[ptr_uint]) -> result = c.ma_notch2_get_heap_size
|
|
457
|
+
public foreign function notch2_init_preallocated(p_config: const_ptr[notch2_config], p_heap: ptr[void], p_filter: ptr[notch2]) -> result = c.ma_notch2_init_preallocated
|
|
458
|
+
public foreign function notch2_init(p_config: const_ptr[notch2_config], p_allocation_callbacks: const_ptr[allocation_callbacks], p_filter: ptr[notch2]) -> result = c.ma_notch2_init
|
|
459
|
+
public foreign function notch2_uninit(p_filter: ptr[notch2], p_allocation_callbacks: const_ptr[allocation_callbacks]) -> void = c.ma_notch2_uninit
|
|
460
|
+
public foreign function notch2_reinit(p_config: const_ptr[notch2_config], p_filter: ptr[notch2]) -> result = c.ma_notch2_reinit
|
|
461
|
+
public foreign function notch2_process_pcm_frames(p_filter: ptr[notch2], p_frames_out: ptr[void], p_frames_in: const_ptr[void], frame_count: ulong) -> result = c.ma_notch2_process_pcm_frames
|
|
462
|
+
public foreign function notch2_get_latency(p_filter: const_ptr[notch2]) -> uint32 = c.ma_notch2_get_latency
|
|
463
|
+
public foreign function peak2_config_init(format: format, channels: uint, sample_rate: uint, gain_db: double, q: double, frequency: double) -> peak2_config = c.ma_peak2_config_init
|
|
464
|
+
public foreign function peak2_get_heap_size(p_config: const_ptr[peak2_config], p_heap_size_in_bytes: ptr[ptr_uint]) -> result = c.ma_peak2_get_heap_size
|
|
465
|
+
public foreign function peak2_init_preallocated(p_config: const_ptr[peak2_config], p_heap: ptr[void], p_filter: ptr[peak2]) -> result = c.ma_peak2_init_preallocated
|
|
466
|
+
public foreign function peak2_init(p_config: const_ptr[peak2_config], p_allocation_callbacks: const_ptr[allocation_callbacks], p_filter: ptr[peak2]) -> result = c.ma_peak2_init
|
|
467
|
+
public foreign function peak2_uninit(p_filter: ptr[peak2], p_allocation_callbacks: const_ptr[allocation_callbacks]) -> void = c.ma_peak2_uninit
|
|
468
|
+
public foreign function peak2_reinit(p_config: const_ptr[peak2_config], p_filter: ptr[peak2]) -> result = c.ma_peak2_reinit
|
|
469
|
+
public foreign function peak2_process_pcm_frames(p_filter: ptr[peak2], p_frames_out: ptr[void], p_frames_in: const_ptr[void], frame_count: ulong) -> result = c.ma_peak2_process_pcm_frames
|
|
470
|
+
public foreign function peak2_get_latency(p_filter: const_ptr[peak2]) -> uint32 = c.ma_peak2_get_latency
|
|
471
|
+
public foreign function loshelf2_config_init(format: format, channels: uint, sample_rate: uint, gain_db: double, shelf_slope: double, frequency: double) -> loshelf2_config = c.ma_loshelf2_config_init
|
|
472
|
+
public foreign function loshelf2_get_heap_size(p_config: const_ptr[loshelf2_config], p_heap_size_in_bytes: ptr[ptr_uint]) -> result = c.ma_loshelf2_get_heap_size
|
|
473
|
+
public foreign function loshelf2_init_preallocated(p_config: const_ptr[loshelf2_config], p_heap: ptr[void], p_filter: ptr[loshelf2]) -> result = c.ma_loshelf2_init_preallocated
|
|
474
|
+
public foreign function loshelf2_init(p_config: const_ptr[loshelf2_config], p_allocation_callbacks: const_ptr[allocation_callbacks], p_filter: ptr[loshelf2]) -> result = c.ma_loshelf2_init
|
|
475
|
+
public foreign function loshelf2_uninit(p_filter: ptr[loshelf2], p_allocation_callbacks: const_ptr[allocation_callbacks]) -> void = c.ma_loshelf2_uninit
|
|
476
|
+
public foreign function loshelf2_reinit(p_config: const_ptr[loshelf2_config], p_filter: ptr[loshelf2]) -> result = c.ma_loshelf2_reinit
|
|
477
|
+
public foreign function loshelf2_process_pcm_frames(p_filter: ptr[loshelf2], p_frames_out: ptr[void], p_frames_in: const_ptr[void], frame_count: ulong) -> result = c.ma_loshelf2_process_pcm_frames
|
|
478
|
+
public foreign function loshelf2_get_latency(p_filter: const_ptr[loshelf2]) -> uint32 = c.ma_loshelf2_get_latency
|
|
479
|
+
public foreign function hishelf2_config_init(format: format, channels: uint, sample_rate: uint, gain_db: double, shelf_slope: double, frequency: double) -> hishelf2_config = c.ma_hishelf2_config_init
|
|
480
|
+
public foreign function hishelf2_get_heap_size(p_config: const_ptr[hishelf2_config], p_heap_size_in_bytes: ptr[ptr_uint]) -> result = c.ma_hishelf2_get_heap_size
|
|
481
|
+
public foreign function hishelf2_init_preallocated(p_config: const_ptr[hishelf2_config], p_heap: ptr[void], p_filter: ptr[hishelf2]) -> result = c.ma_hishelf2_init_preallocated
|
|
482
|
+
public foreign function hishelf2_init(p_config: const_ptr[hishelf2_config], p_allocation_callbacks: const_ptr[allocation_callbacks], p_filter: ptr[hishelf2]) -> result = c.ma_hishelf2_init
|
|
483
|
+
public foreign function hishelf2_uninit(p_filter: ptr[hishelf2], p_allocation_callbacks: const_ptr[allocation_callbacks]) -> void = c.ma_hishelf2_uninit
|
|
484
|
+
public foreign function hishelf2_reinit(p_config: const_ptr[hishelf2_config], p_filter: ptr[hishelf2]) -> result = c.ma_hishelf2_reinit
|
|
485
|
+
public foreign function hishelf2_process_pcm_frames(p_filter: ptr[hishelf2], p_frames_out: ptr[void], p_frames_in: const_ptr[void], frame_count: ulong) -> result = c.ma_hishelf2_process_pcm_frames
|
|
486
|
+
public foreign function hishelf2_get_latency(p_filter: const_ptr[hishelf2]) -> uint32 = c.ma_hishelf2_get_latency
|
|
487
|
+
public foreign function delay_config_init(channels: uint, sample_rate: uint, delay_in_frames: uint, decay: float) -> delay_config = c.ma_delay_config_init
|
|
488
|
+
public foreign function delay_init(p_config: const_ptr[delay_config], p_allocation_callbacks: const_ptr[allocation_callbacks], p_delay: ptr[delay]) -> result = c.ma_delay_init
|
|
489
|
+
public foreign function delay_uninit(p_delay: ptr[delay], p_allocation_callbacks: const_ptr[allocation_callbacks]) -> void = c.ma_delay_uninit
|
|
490
|
+
public foreign function delay_process_pcm_frames(p_delay: ptr[delay], p_frames_out: ptr[void], p_frames_in: const_ptr[void], frame_count: uint) -> result = c.ma_delay_process_pcm_frames
|
|
491
|
+
public foreign function delay_set_wet(p_delay: ptr[delay], value: float) -> void = c.ma_delay_set_wet
|
|
492
|
+
public foreign function delay_get_wet(p_delay: const_ptr[delay]) -> float = c.ma_delay_get_wet
|
|
493
|
+
public foreign function delay_set_dry(p_delay: ptr[delay], value: float) -> void = c.ma_delay_set_dry
|
|
494
|
+
public foreign function delay_get_dry(p_delay: const_ptr[delay]) -> float = c.ma_delay_get_dry
|
|
495
|
+
public foreign function delay_set_decay(p_delay: ptr[delay], value: float) -> void = c.ma_delay_set_decay
|
|
496
|
+
public foreign function delay_get_decay(p_delay: const_ptr[delay]) -> float = c.ma_delay_get_decay
|
|
497
|
+
public foreign function gainer_config_init(channels: uint, smooth_time_in_frames: uint) -> gainer_config = c.ma_gainer_config_init
|
|
498
|
+
public foreign function gainer_get_heap_size(p_config: const_ptr[gainer_config], p_heap_size_in_bytes: ptr[ptr_uint]) -> result = c.ma_gainer_get_heap_size
|
|
499
|
+
public foreign function gainer_init_preallocated(p_config: const_ptr[gainer_config], p_heap: ptr[void], p_gainer: ptr[gainer]) -> result = c.ma_gainer_init_preallocated
|
|
500
|
+
public foreign function gainer_init(p_config: const_ptr[gainer_config], p_allocation_callbacks: const_ptr[allocation_callbacks], p_gainer: ptr[gainer]) -> result = c.ma_gainer_init
|
|
501
|
+
public foreign function gainer_uninit(p_gainer: ptr[gainer], p_allocation_callbacks: const_ptr[allocation_callbacks]) -> void = c.ma_gainer_uninit
|
|
502
|
+
public foreign function gainer_process_pcm_frames(p_gainer: ptr[gainer], p_frames_out: ptr[void], p_frames_in: const_ptr[void], frame_count: ulong) -> result = c.ma_gainer_process_pcm_frames
|
|
503
|
+
public foreign function gainer_set_gain(p_gainer: ptr[gainer], new_gain: float) -> result = c.ma_gainer_set_gain
|
|
504
|
+
public foreign function gainer_set_gains(p_gainer: ptr[gainer], p_new_gains: ptr[float]) -> result = c.ma_gainer_set_gains
|
|
505
|
+
public foreign function gainer_set_master_volume(p_gainer: ptr[gainer], volume: float) -> result = c.ma_gainer_set_master_volume
|
|
506
|
+
public foreign function gainer_get_master_volume(p_gainer: const_ptr[gainer], p_volume: ptr[float]) -> result = c.ma_gainer_get_master_volume
|
|
507
|
+
public foreign function panner_config_init(format: format, channels: uint) -> panner_config = c.ma_panner_config_init
|
|
508
|
+
public foreign function panner_init(p_config: const_ptr[panner_config], p_panner: ptr[panner]) -> result = c.ma_panner_init
|
|
509
|
+
public foreign function panner_process_pcm_frames(p_panner: ptr[panner], p_frames_out: ptr[void], p_frames_in: const_ptr[void], frame_count: ulong) -> result = c.ma_panner_process_pcm_frames
|
|
510
|
+
public foreign function panner_set_mode(p_panner: ptr[panner], mode: pan_mode) -> void = c.ma_panner_set_mode
|
|
511
|
+
public foreign function panner_get_mode(p_panner: const_ptr[panner]) -> pan_mode = c.ma_panner_get_mode
|
|
512
|
+
public foreign function panner_set_pan(p_panner: ptr[panner], pan: float) -> void = c.ma_panner_set_pan
|
|
513
|
+
public foreign function panner_get_pan(p_panner: const_ptr[panner]) -> float = c.ma_panner_get_pan
|
|
514
|
+
public foreign function fader_config_init(format: format, channels: uint, sample_rate: uint) -> fader_config = c.ma_fader_config_init
|
|
515
|
+
public foreign function fader_init(p_config: const_ptr[fader_config], p_fader: ptr[fader]) -> result = c.ma_fader_init
|
|
516
|
+
public foreign function fader_process_pcm_frames(p_fader: ptr[fader], p_frames_out: ptr[void], p_frames_in: const_ptr[void], frame_count: ulong) -> result = c.ma_fader_process_pcm_frames
|
|
517
|
+
public foreign function fader_get_data_format(p_fader: const_ptr[fader], p_format: ptr[format], p_channels: ptr[uint32], p_sample_rate: ptr[uint32]) -> void = c.ma_fader_get_data_format
|
|
518
|
+
public foreign function fader_set_fade(p_fader: ptr[fader], volume_beg: float, volume_end: float, length_in_frames: ulong) -> void = c.ma_fader_set_fade
|
|
519
|
+
public foreign function fader_set_fade_ex(p_fader: ptr[fader], volume_beg: float, volume_end: float, length_in_frames: ulong, start_offset_in_frames: long) -> void = c.ma_fader_set_fade_ex
|
|
520
|
+
public foreign function fader_get_current_volume(p_fader: const_ptr[fader]) -> float = c.ma_fader_get_current_volume
|
|
521
|
+
public foreign function spatializer_listener_config_init(channels_out: uint) -> spatializer_listener_config = c.ma_spatializer_listener_config_init
|
|
522
|
+
public foreign function spatializer_listener_get_heap_size(p_config: const_ptr[spatializer_listener_config], p_heap_size_in_bytes: ptr[ptr_uint]) -> result = c.ma_spatializer_listener_get_heap_size
|
|
523
|
+
public foreign function spatializer_listener_init_preallocated(p_config: const_ptr[spatializer_listener_config], p_heap: ptr[void], p_listener: ptr[spatializer_listener]) -> result = c.ma_spatializer_listener_init_preallocated
|
|
524
|
+
public foreign function spatializer_listener_init(p_config: const_ptr[spatializer_listener_config], p_allocation_callbacks: const_ptr[allocation_callbacks], p_listener: ptr[spatializer_listener]) -> result = c.ma_spatializer_listener_init
|
|
525
|
+
public foreign function spatializer_listener_uninit(p_listener: ptr[spatializer_listener], p_allocation_callbacks: const_ptr[allocation_callbacks]) -> void = c.ma_spatializer_listener_uninit
|
|
526
|
+
public foreign function spatializer_listener_get_channel_map(p_listener: ptr[spatializer_listener]) -> ptr[channel] = c.ma_spatializer_listener_get_channel_map
|
|
527
|
+
public foreign function spatializer_listener_set_cone(p_listener: ptr[spatializer_listener], inner_angle_in_radians: float, outer_angle_in_radians: float, outer_gain: float) -> void = c.ma_spatializer_listener_set_cone
|
|
528
|
+
public foreign function spatializer_listener_get_cone(p_listener: const_ptr[spatializer_listener], p_inner_angle_in_radians: ptr[float], p_outer_angle_in_radians: ptr[float], p_outer_gain: ptr[float]) -> void = c.ma_spatializer_listener_get_cone
|
|
529
|
+
public foreign function spatializer_listener_set_position(p_listener: ptr[spatializer_listener], x: float, y: float, z: float) -> void = c.ma_spatializer_listener_set_position
|
|
530
|
+
public foreign function spatializer_listener_get_position(p_listener: const_ptr[spatializer_listener]) -> vec3f = c.ma_spatializer_listener_get_position
|
|
531
|
+
public foreign function spatializer_listener_set_direction(p_listener: ptr[spatializer_listener], x: float, y: float, z: float) -> void = c.ma_spatializer_listener_set_direction
|
|
532
|
+
public foreign function spatializer_listener_get_direction(p_listener: const_ptr[spatializer_listener]) -> vec3f = c.ma_spatializer_listener_get_direction
|
|
533
|
+
public foreign function spatializer_listener_set_velocity(p_listener: ptr[spatializer_listener], x: float, y: float, z: float) -> void = c.ma_spatializer_listener_set_velocity
|
|
534
|
+
public foreign function spatializer_listener_get_velocity(p_listener: const_ptr[spatializer_listener]) -> vec3f = c.ma_spatializer_listener_get_velocity
|
|
535
|
+
public foreign function spatializer_listener_set_speed_of_sound(p_listener: ptr[spatializer_listener], speed_of_sound: float) -> void = c.ma_spatializer_listener_set_speed_of_sound
|
|
536
|
+
public foreign function spatializer_listener_get_speed_of_sound(p_listener: const_ptr[spatializer_listener]) -> float = c.ma_spatializer_listener_get_speed_of_sound
|
|
537
|
+
public foreign function spatializer_listener_set_world_up(p_listener: ptr[spatializer_listener], x: float, y: float, z: float) -> void = c.ma_spatializer_listener_set_world_up
|
|
538
|
+
public foreign function spatializer_listener_get_world_up(p_listener: const_ptr[spatializer_listener]) -> vec3f = c.ma_spatializer_listener_get_world_up
|
|
539
|
+
public foreign function spatializer_listener_set_enabled(p_listener: ptr[spatializer_listener], is_enabled: uint) -> void = c.ma_spatializer_listener_set_enabled
|
|
540
|
+
public foreign function spatializer_listener_is_enabled(p_listener: const_ptr[spatializer_listener]) -> bool32 = c.ma_spatializer_listener_is_enabled
|
|
541
|
+
public foreign function spatializer_config_init(channels_in: uint, channels_out: uint) -> spatializer_config = c.ma_spatializer_config_init
|
|
542
|
+
public foreign function spatializer_get_heap_size(p_config: const_ptr[spatializer_config], p_heap_size_in_bytes: ptr[ptr_uint]) -> result = c.ma_spatializer_get_heap_size
|
|
543
|
+
public foreign function spatializer_init_preallocated(p_config: const_ptr[spatializer_config], p_heap: ptr[void], p_spatializer: ptr[spatializer]) -> result = c.ma_spatializer_init_preallocated
|
|
544
|
+
public foreign function spatializer_init(p_config: const_ptr[spatializer_config], p_allocation_callbacks: const_ptr[allocation_callbacks], p_spatializer: ptr[spatializer]) -> result = c.ma_spatializer_init
|
|
545
|
+
public foreign function spatializer_uninit(p_spatializer: ptr[spatializer], p_allocation_callbacks: const_ptr[allocation_callbacks]) -> void = c.ma_spatializer_uninit
|
|
546
|
+
public foreign function spatializer_process_pcm_frames(p_spatializer: ptr[spatializer], p_listener: ptr[spatializer_listener], p_frames_out: ptr[void], p_frames_in: const_ptr[void], frame_count: ulong) -> result = c.ma_spatializer_process_pcm_frames
|
|
547
|
+
public foreign function spatializer_set_master_volume(p_spatializer: ptr[spatializer], volume: float) -> result = c.ma_spatializer_set_master_volume
|
|
548
|
+
public foreign function spatializer_get_master_volume(p_spatializer: const_ptr[spatializer], p_volume: ptr[float]) -> result = c.ma_spatializer_get_master_volume
|
|
549
|
+
public foreign function spatializer_get_input_channels(p_spatializer: const_ptr[spatializer]) -> uint32 = c.ma_spatializer_get_input_channels
|
|
550
|
+
public foreign function spatializer_get_output_channels(p_spatializer: const_ptr[spatializer]) -> uint32 = c.ma_spatializer_get_output_channels
|
|
551
|
+
public foreign function spatializer_set_attenuation_model(p_spatializer: ptr[spatializer], attenuation_model: attenuation_model) -> void = c.ma_spatializer_set_attenuation_model
|
|
552
|
+
public foreign function spatializer_get_attenuation_model(p_spatializer: const_ptr[spatializer]) -> attenuation_model = c.ma_spatializer_get_attenuation_model
|
|
553
|
+
public foreign function spatializer_set_positioning(p_spatializer: ptr[spatializer], positioning: positioning) -> void = c.ma_spatializer_set_positioning
|
|
554
|
+
public foreign function spatializer_get_positioning(p_spatializer: const_ptr[spatializer]) -> positioning = c.ma_spatializer_get_positioning
|
|
555
|
+
public foreign function spatializer_set_rolloff(p_spatializer: ptr[spatializer], rolloff: float) -> void = c.ma_spatializer_set_rolloff
|
|
556
|
+
public foreign function spatializer_get_rolloff(p_spatializer: const_ptr[spatializer]) -> float = c.ma_spatializer_get_rolloff
|
|
557
|
+
public foreign function spatializer_set_min_gain(p_spatializer: ptr[spatializer], min_gain: float) -> void = c.ma_spatializer_set_min_gain
|
|
558
|
+
public foreign function spatializer_get_min_gain(p_spatializer: const_ptr[spatializer]) -> float = c.ma_spatializer_get_min_gain
|
|
559
|
+
public foreign function spatializer_set_max_gain(p_spatializer: ptr[spatializer], max_gain: float) -> void = c.ma_spatializer_set_max_gain
|
|
560
|
+
public foreign function spatializer_get_max_gain(p_spatializer: const_ptr[spatializer]) -> float = c.ma_spatializer_get_max_gain
|
|
561
|
+
public foreign function spatializer_set_min_distance(p_spatializer: ptr[spatializer], min_distance: float) -> void = c.ma_spatializer_set_min_distance
|
|
562
|
+
public foreign function spatializer_get_min_distance(p_spatializer: const_ptr[spatializer]) -> float = c.ma_spatializer_get_min_distance
|
|
563
|
+
public foreign function spatializer_set_max_distance(p_spatializer: ptr[spatializer], max_distance: float) -> void = c.ma_spatializer_set_max_distance
|
|
564
|
+
public foreign function spatializer_get_max_distance(p_spatializer: const_ptr[spatializer]) -> float = c.ma_spatializer_get_max_distance
|
|
565
|
+
public foreign function spatializer_set_cone(p_spatializer: ptr[spatializer], inner_angle_in_radians: float, outer_angle_in_radians: float, outer_gain: float) -> void = c.ma_spatializer_set_cone
|
|
566
|
+
public foreign function spatializer_get_cone(p_spatializer: const_ptr[spatializer], p_inner_angle_in_radians: ptr[float], p_outer_angle_in_radians: ptr[float], p_outer_gain: ptr[float]) -> void = c.ma_spatializer_get_cone
|
|
567
|
+
public foreign function spatializer_set_doppler_factor(p_spatializer: ptr[spatializer], doppler_factor: float) -> void = c.ma_spatializer_set_doppler_factor
|
|
568
|
+
public foreign function spatializer_get_doppler_factor(p_spatializer: const_ptr[spatializer]) -> float = c.ma_spatializer_get_doppler_factor
|
|
569
|
+
public foreign function spatializer_set_directional_attenuation_factor(p_spatializer: ptr[spatializer], directional_attenuation_factor: float) -> void = c.ma_spatializer_set_directional_attenuation_factor
|
|
570
|
+
public foreign function spatializer_get_directional_attenuation_factor(p_spatializer: const_ptr[spatializer]) -> float = c.ma_spatializer_get_directional_attenuation_factor
|
|
571
|
+
public foreign function spatializer_set_position(p_spatializer: ptr[spatializer], x: float, y: float, z: float) -> void = c.ma_spatializer_set_position
|
|
572
|
+
public foreign function spatializer_get_position(p_spatializer: const_ptr[spatializer]) -> vec3f = c.ma_spatializer_get_position
|
|
573
|
+
public foreign function spatializer_set_direction(p_spatializer: ptr[spatializer], x: float, y: float, z: float) -> void = c.ma_spatializer_set_direction
|
|
574
|
+
public foreign function spatializer_get_direction(p_spatializer: const_ptr[spatializer]) -> vec3f = c.ma_spatializer_get_direction
|
|
575
|
+
public foreign function spatializer_set_velocity(p_spatializer: ptr[spatializer], x: float, y: float, z: float) -> void = c.ma_spatializer_set_velocity
|
|
576
|
+
public foreign function spatializer_get_velocity(p_spatializer: const_ptr[spatializer]) -> vec3f = c.ma_spatializer_get_velocity
|
|
577
|
+
public foreign function spatializer_get_relative_position_and_direction(p_spatializer: const_ptr[spatializer], p_listener: const_ptr[spatializer_listener], p_relative_pos: ptr[vec3f], p_relative_dir: ptr[vec3f]) -> void = c.ma_spatializer_get_relative_position_and_direction
|
|
578
|
+
public foreign function linear_resampler_config_init(format: format, channels: uint, sample_rate_in: uint, sample_rate_out: uint) -> linear_resampler_config = c.ma_linear_resampler_config_init
|
|
579
|
+
public foreign function linear_resampler_get_heap_size(p_config: const_ptr[linear_resampler_config], p_heap_size_in_bytes: ptr[ptr_uint]) -> result = c.ma_linear_resampler_get_heap_size
|
|
580
|
+
public foreign function linear_resampler_init_preallocated(p_config: const_ptr[linear_resampler_config], p_heap: ptr[void], p_resampler: ptr[linear_resampler]) -> result = c.ma_linear_resampler_init_preallocated
|
|
581
|
+
public foreign function linear_resampler_init(p_config: const_ptr[linear_resampler_config], p_allocation_callbacks: const_ptr[allocation_callbacks], p_resampler: ptr[linear_resampler]) -> result = c.ma_linear_resampler_init
|
|
582
|
+
public foreign function linear_resampler_uninit(p_resampler: ptr[linear_resampler], p_allocation_callbacks: const_ptr[allocation_callbacks]) -> void = c.ma_linear_resampler_uninit
|
|
583
|
+
public foreign function linear_resampler_process_pcm_frames(p_resampler: ptr[linear_resampler], p_frames_in: const_ptr[void], p_frame_count_in: ptr[uint64], p_frames_out: ptr[void], p_frame_count_out: ptr[uint64]) -> result = c.ma_linear_resampler_process_pcm_frames
|
|
584
|
+
public foreign function linear_resampler_set_rate(p_resampler: ptr[linear_resampler], sample_rate_in: uint, sample_rate_out: uint) -> result = c.ma_linear_resampler_set_rate
|
|
585
|
+
public foreign function linear_resampler_set_rate_ratio(p_resampler: ptr[linear_resampler], ratio_in_out: float) -> result = c.ma_linear_resampler_set_rate_ratio
|
|
586
|
+
public foreign function linear_resampler_get_input_latency(p_resampler: const_ptr[linear_resampler]) -> uint64 = c.ma_linear_resampler_get_input_latency
|
|
587
|
+
public foreign function linear_resampler_get_output_latency(p_resampler: const_ptr[linear_resampler]) -> uint64 = c.ma_linear_resampler_get_output_latency
|
|
588
|
+
public foreign function linear_resampler_get_required_input_frame_count(p_resampler: const_ptr[linear_resampler], output_frame_count: ulong, p_input_frame_count: ptr[uint64]) -> result = c.ma_linear_resampler_get_required_input_frame_count
|
|
589
|
+
public foreign function linear_resampler_get_expected_output_frame_count(p_resampler: const_ptr[linear_resampler], input_frame_count: ulong, p_output_frame_count: ptr[uint64]) -> result = c.ma_linear_resampler_get_expected_output_frame_count
|
|
590
|
+
public foreign function linear_resampler_reset(p_resampler: ptr[linear_resampler]) -> result = c.ma_linear_resampler_reset
|
|
591
|
+
public foreign function resampler_config_init(format: format, channels: uint, sample_rate_in: uint, sample_rate_out: uint, algorithm: resample_algorithm) -> resampler_config = c.ma_resampler_config_init
|
|
592
|
+
public foreign function resampler_get_heap_size(p_config: const_ptr[resampler_config], p_heap_size_in_bytes: ptr[ptr_uint]) -> result = c.ma_resampler_get_heap_size
|
|
593
|
+
public foreign function resampler_init_preallocated(p_config: const_ptr[resampler_config], p_heap: ptr[void], p_resampler: ptr[resampler]) -> result = c.ma_resampler_init_preallocated
|
|
594
|
+
public foreign function resampler_init(p_config: const_ptr[resampler_config], p_allocation_callbacks: const_ptr[allocation_callbacks], p_resampler: ptr[resampler]) -> result = c.ma_resampler_init
|
|
595
|
+
public foreign function resampler_uninit(p_resampler: ptr[resampler], p_allocation_callbacks: const_ptr[allocation_callbacks]) -> void = c.ma_resampler_uninit
|
|
596
|
+
public foreign function resampler_process_pcm_frames(p_resampler: ptr[resampler], p_frames_in: const_ptr[void], p_frame_count_in: ptr[uint64], p_frames_out: ptr[void], p_frame_count_out: ptr[uint64]) -> result = c.ma_resampler_process_pcm_frames
|
|
597
|
+
public foreign function resampler_set_rate(p_resampler: ptr[resampler], sample_rate_in: uint, sample_rate_out: uint) -> result = c.ma_resampler_set_rate
|
|
598
|
+
public foreign function resampler_set_rate_ratio(p_resampler: ptr[resampler], ratio: float) -> result = c.ma_resampler_set_rate_ratio
|
|
599
|
+
public foreign function resampler_get_input_latency(p_resampler: const_ptr[resampler]) -> uint64 = c.ma_resampler_get_input_latency
|
|
600
|
+
public foreign function resampler_get_output_latency(p_resampler: const_ptr[resampler]) -> uint64 = c.ma_resampler_get_output_latency
|
|
601
|
+
public foreign function resampler_get_required_input_frame_count(p_resampler: const_ptr[resampler], output_frame_count: ulong, p_input_frame_count: ptr[uint64]) -> result = c.ma_resampler_get_required_input_frame_count
|
|
602
|
+
public foreign function resampler_get_expected_output_frame_count(p_resampler: const_ptr[resampler], input_frame_count: ulong, p_output_frame_count: ptr[uint64]) -> result = c.ma_resampler_get_expected_output_frame_count
|
|
603
|
+
public foreign function resampler_reset(p_resampler: ptr[resampler]) -> result = c.ma_resampler_reset
|
|
604
|
+
public foreign function channel_converter_config_init(format: format, channels_in: uint, p_channel_map_in: const_ptr[channel], channels_out: uint, p_channel_map_out: const_ptr[channel], mixing_mode: channel_mix_mode) -> channel_converter_config = c.ma_channel_converter_config_init
|
|
605
|
+
public foreign function channel_converter_get_heap_size(p_config: const_ptr[channel_converter_config], p_heap_size_in_bytes: ptr[ptr_uint]) -> result = c.ma_channel_converter_get_heap_size
|
|
606
|
+
public foreign function channel_converter_init_preallocated(p_config: const_ptr[channel_converter_config], p_heap: ptr[void], p_converter: ptr[channel_converter]) -> result = c.ma_channel_converter_init_preallocated
|
|
607
|
+
public foreign function channel_converter_init(p_config: const_ptr[channel_converter_config], p_allocation_callbacks: const_ptr[allocation_callbacks], p_converter: ptr[channel_converter]) -> result = c.ma_channel_converter_init
|
|
608
|
+
public foreign function channel_converter_uninit(p_converter: ptr[channel_converter], p_allocation_callbacks: const_ptr[allocation_callbacks]) -> void = c.ma_channel_converter_uninit
|
|
609
|
+
public foreign function channel_converter_process_pcm_frames(p_converter: ptr[channel_converter], p_frames_out: ptr[void], p_frames_in: const_ptr[void], frame_count: ulong) -> result = c.ma_channel_converter_process_pcm_frames
|
|
610
|
+
public foreign function channel_converter_get_input_channel_map(p_converter: const_ptr[channel_converter], p_channel_map: ptr[channel], channel_map_cap: ptr_uint) -> result = c.ma_channel_converter_get_input_channel_map
|
|
611
|
+
public foreign function channel_converter_get_output_channel_map(p_converter: const_ptr[channel_converter], p_channel_map: ptr[channel], channel_map_cap: ptr_uint) -> result = c.ma_channel_converter_get_output_channel_map
|
|
612
|
+
public foreign function data_converter_config_init_default() -> data_converter_config = c.ma_data_converter_config_init_default
|
|
613
|
+
public foreign function data_converter_config_init(format_in: format, format_out: format, channels_in: uint, channels_out: uint, sample_rate_in: uint, sample_rate_out: uint) -> data_converter_config = c.ma_data_converter_config_init
|
|
614
|
+
public foreign function data_converter_get_heap_size(p_config: const_ptr[data_converter_config], p_heap_size_in_bytes: ptr[ptr_uint]) -> result = c.ma_data_converter_get_heap_size
|
|
615
|
+
public foreign function data_converter_init_preallocated(p_config: const_ptr[data_converter_config], p_heap: ptr[void], p_converter: ptr[data_converter]) -> result = c.ma_data_converter_init_preallocated
|
|
616
|
+
public foreign function data_converter_init(p_config: const_ptr[data_converter_config], p_allocation_callbacks: const_ptr[allocation_callbacks], p_converter: ptr[data_converter]) -> result = c.ma_data_converter_init
|
|
617
|
+
public foreign function data_converter_uninit(p_converter: ptr[data_converter], p_allocation_callbacks: const_ptr[allocation_callbacks]) -> void = c.ma_data_converter_uninit
|
|
618
|
+
public foreign function data_converter_process_pcm_frames(p_converter: ptr[data_converter], p_frames_in: const_ptr[void], p_frame_count_in: ptr[uint64], p_frames_out: ptr[void], p_frame_count_out: ptr[uint64]) -> result = c.ma_data_converter_process_pcm_frames
|
|
619
|
+
public foreign function data_converter_set_rate(p_converter: ptr[data_converter], sample_rate_in: uint, sample_rate_out: uint) -> result = c.ma_data_converter_set_rate
|
|
620
|
+
public foreign function data_converter_set_rate_ratio(p_converter: ptr[data_converter], ratio_in_out: float) -> result = c.ma_data_converter_set_rate_ratio
|
|
621
|
+
public foreign function data_converter_get_input_latency(p_converter: const_ptr[data_converter]) -> uint64 = c.ma_data_converter_get_input_latency
|
|
622
|
+
public foreign function data_converter_get_output_latency(p_converter: const_ptr[data_converter]) -> uint64 = c.ma_data_converter_get_output_latency
|
|
623
|
+
public foreign function data_converter_get_required_input_frame_count(p_converter: const_ptr[data_converter], output_frame_count: ulong, p_input_frame_count: ptr[uint64]) -> result = c.ma_data_converter_get_required_input_frame_count
|
|
624
|
+
public foreign function data_converter_get_expected_output_frame_count(p_converter: const_ptr[data_converter], input_frame_count: ulong, p_output_frame_count: ptr[uint64]) -> result = c.ma_data_converter_get_expected_output_frame_count
|
|
625
|
+
public foreign function data_converter_get_input_channel_map(p_converter: const_ptr[data_converter], p_channel_map: ptr[channel], channel_map_cap: ptr_uint) -> result = c.ma_data_converter_get_input_channel_map
|
|
626
|
+
public foreign function data_converter_get_output_channel_map(p_converter: const_ptr[data_converter], p_channel_map: ptr[channel], channel_map_cap: ptr_uint) -> result = c.ma_data_converter_get_output_channel_map
|
|
627
|
+
public foreign function data_converter_reset(p_converter: ptr[data_converter]) -> result = c.ma_data_converter_reset
|
|
628
|
+
public foreign function pcm_u8_to_s16(p_out: ptr[void], p_in: const_ptr[void], count: ulong, dither_mode: dither_mode) -> void = c.ma_pcm_u8_to_s16
|
|
629
|
+
public foreign function pcm_u8_to_s24(p_out: ptr[void], p_in: const_ptr[void], count: ulong, dither_mode: dither_mode) -> void = c.ma_pcm_u8_to_s24
|
|
630
|
+
public foreign function pcm_u8_to_s32(p_out: ptr[void], p_in: const_ptr[void], count: ulong, dither_mode: dither_mode) -> void = c.ma_pcm_u8_to_s32
|
|
631
|
+
public foreign function pcm_u8_to_f32(p_out: ptr[void], p_in: const_ptr[void], count: ulong, dither_mode: dither_mode) -> void = c.ma_pcm_u8_to_f32
|
|
632
|
+
public foreign function pcm_s16_to_u8(p_out: ptr[void], p_in: const_ptr[void], count: ulong, dither_mode: dither_mode) -> void = c.ma_pcm_s16_to_u8
|
|
633
|
+
public foreign function pcm_s16_to_s24(p_out: ptr[void], p_in: const_ptr[void], count: ulong, dither_mode: dither_mode) -> void = c.ma_pcm_s16_to_s24
|
|
634
|
+
public foreign function pcm_s16_to_s32(p_out: ptr[void], p_in: const_ptr[void], count: ulong, dither_mode: dither_mode) -> void = c.ma_pcm_s16_to_s32
|
|
635
|
+
public foreign function pcm_s16_to_f32(p_out: ptr[void], p_in: const_ptr[void], count: ulong, dither_mode: dither_mode) -> void = c.ma_pcm_s16_to_f32
|
|
636
|
+
public foreign function pcm_s24_to_u8(p_out: ptr[void], p_in: const_ptr[void], count: ulong, dither_mode: dither_mode) -> void = c.ma_pcm_s24_to_u8
|
|
637
|
+
public foreign function pcm_s24_to_s16(p_out: ptr[void], p_in: const_ptr[void], count: ulong, dither_mode: dither_mode) -> void = c.ma_pcm_s24_to_s16
|
|
638
|
+
public foreign function pcm_s24_to_s32(p_out: ptr[void], p_in: const_ptr[void], count: ulong, dither_mode: dither_mode) -> void = c.ma_pcm_s24_to_s32
|
|
639
|
+
public foreign function pcm_s24_to_f32(p_out: ptr[void], p_in: const_ptr[void], count: ulong, dither_mode: dither_mode) -> void = c.ma_pcm_s24_to_f32
|
|
640
|
+
public foreign function pcm_s32_to_u8(p_out: ptr[void], p_in: const_ptr[void], count: ulong, dither_mode: dither_mode) -> void = c.ma_pcm_s32_to_u8
|
|
641
|
+
public foreign function pcm_s32_to_s16(p_out: ptr[void], p_in: const_ptr[void], count: ulong, dither_mode: dither_mode) -> void = c.ma_pcm_s32_to_s16
|
|
642
|
+
public foreign function pcm_s32_to_s24(p_out: ptr[void], p_in: const_ptr[void], count: ulong, dither_mode: dither_mode) -> void = c.ma_pcm_s32_to_s24
|
|
643
|
+
public foreign function pcm_s32_to_f32(p_out: ptr[void], p_in: const_ptr[void], count: ulong, dither_mode: dither_mode) -> void = c.ma_pcm_s32_to_f32
|
|
644
|
+
public foreign function pcm_f32_to_u8(p_out: ptr[void], p_in: const_ptr[void], count: ulong, dither_mode: dither_mode) -> void = c.ma_pcm_f32_to_u8
|
|
645
|
+
public foreign function pcm_f32_to_s16(p_out: ptr[void], p_in: const_ptr[void], count: ulong, dither_mode: dither_mode) -> void = c.ma_pcm_f32_to_s16
|
|
646
|
+
public foreign function pcm_f32_to_s24(p_out: ptr[void], p_in: const_ptr[void], count: ulong, dither_mode: dither_mode) -> void = c.ma_pcm_f32_to_s24
|
|
647
|
+
public foreign function pcm_f32_to_s32(p_out: ptr[void], p_in: const_ptr[void], count: ulong, dither_mode: dither_mode) -> void = c.ma_pcm_f32_to_s32
|
|
648
|
+
public foreign function pcm_convert(p_out: ptr[void], format_out: format, p_in: const_ptr[void], format_in: format, sample_count: ulong, dither_mode: dither_mode) -> void = c.ma_pcm_convert
|
|
649
|
+
public foreign function convert_pcm_frames_format(p_out: ptr[void], format_out: format, p_in: const_ptr[void], format_in: format, frame_count: ulong, channels: uint, dither_mode: dither_mode) -> void = c.ma_convert_pcm_frames_format
|
|
650
|
+
public foreign function deinterleave_pcm_frames(format: format, channels: uint, frame_count: ulong, p_interleaved_pcm_frames: const_ptr[void], pp_deinterleaved_pcm_frames: ptr[ptr[void]]) -> void = c.ma_deinterleave_pcm_frames
|
|
651
|
+
public foreign function interleave_pcm_frames(format: format, channels: uint, frame_count: ulong, pp_deinterleaved_pcm_frames: ptr[const_ptr[void]], p_interleaved_pcm_frames: ptr[void]) -> void = c.ma_interleave_pcm_frames
|
|
652
|
+
public foreign function channel_map_get_channel(p_channel_map: const_ptr[channel], channel_count: uint, channel_index: uint) -> channel = c.ma_channel_map_get_channel
|
|
653
|
+
public foreign function channel_map_init_blank(p_channel_map: ptr[channel], channels: uint) -> void = c.ma_channel_map_init_blank
|
|
654
|
+
public foreign function channel_map_init_standard(standard_channel_map: standard_channel_map, p_channel_map: ptr[channel], channel_map_cap: ptr_uint, channels: uint) -> void = c.ma_channel_map_init_standard
|
|
655
|
+
public foreign function channel_map_copy(p_out: ptr[channel], p_in: const_ptr[channel], channels: uint) -> void = c.ma_channel_map_copy
|
|
656
|
+
public foreign function channel_map_copy_or_default(p_out: ptr[channel], channel_map_cap_out: ptr_uint, p_in: const_ptr[channel], channels: uint) -> void = c.ma_channel_map_copy_or_default
|
|
657
|
+
public foreign function channel_map_is_valid(p_channel_map: const_ptr[channel], channels: uint) -> bool32 = c.ma_channel_map_is_valid
|
|
658
|
+
public foreign function channel_map_is_equal(p_channel_map_a: const_ptr[channel], p_channel_map_b: const_ptr[channel], channels: uint) -> bool32 = c.ma_channel_map_is_equal
|
|
659
|
+
public foreign function channel_map_is_blank(p_channel_map: const_ptr[channel], channels: uint) -> bool32 = c.ma_channel_map_is_blank
|
|
660
|
+
public foreign function channel_map_contains_channel_position(channels: uint, p_channel_map: const_ptr[channel], channel_position: ubyte) -> bool32 = c.ma_channel_map_contains_channel_position
|
|
661
|
+
public foreign function channel_map_find_channel_position(channels: uint, p_channel_map: const_ptr[channel], channel_position: ubyte, p_channel_index: ptr[uint32]) -> bool32 = c.ma_channel_map_find_channel_position
|
|
662
|
+
public foreign function channel_map_to_string(p_channel_map: const_ptr[channel], channels: uint, p_buffer_out: ptr[char], buffer_cap: ptr_uint) -> ptr_uint = c.ma_channel_map_to_string
|
|
663
|
+
public foreign function channel_position_to_string(channel: ubyte) -> cstr = c.ma_channel_position_to_string
|
|
664
|
+
public foreign function convert_frames(p_out: ptr[void], frame_count_out: ulong, format_out: format, channels_out: uint, sample_rate_out: uint, p_in: const_ptr[void], frame_count_in: ulong, format_in: format, channels_in: uint, sample_rate_in: uint) -> uint64 = c.ma_convert_frames
|
|
665
|
+
public foreign function convert_frames_ex(p_out: ptr[void], frame_count_out: ulong, p_in: const_ptr[void], frame_count_in: ulong, p_config: const_ptr[data_converter_config]) -> uint64 = c.ma_convert_frames_ex
|
|
666
|
+
public foreign function data_source_config_init() -> data_source_config = c.ma_data_source_config_init
|
|
667
|
+
public foreign function data_source_init(p_config: const_ptr[data_source_config], p_data_source: ptr[data_source]) -> result = c.ma_data_source_init
|
|
668
|
+
public foreign function data_source_uninit(p_data_source: ptr[data_source]) -> void = c.ma_data_source_uninit
|
|
669
|
+
public foreign function data_source_read_pcm_frames(p_data_source: ptr[data_source], p_frames_out: ptr[void], frame_count: ulong, p_frames_read: ptr[uint64]) -> result = c.ma_data_source_read_pcm_frames
|
|
670
|
+
public foreign function data_source_seek_pcm_frames(p_data_source: ptr[data_source], frame_count: ulong, p_frames_seeked: ptr[uint64]) -> result = c.ma_data_source_seek_pcm_frames
|
|
671
|
+
public foreign function data_source_seek_to_pcm_frame(p_data_source: ptr[data_source], frame_index: ulong) -> result = c.ma_data_source_seek_to_pcm_frame
|
|
672
|
+
public foreign function data_source_seek_seconds(p_data_source: ptr[data_source], second_count: float, p_seconds_seeked: ptr[float]) -> result = c.ma_data_source_seek_seconds
|
|
673
|
+
public foreign function data_source_seek_to_second(p_data_source: ptr[data_source], seek_point_in_seconds: float) -> result = c.ma_data_source_seek_to_second
|
|
674
|
+
public foreign function data_source_get_data_format(p_data_source: ptr[data_source], p_format: ptr[format], p_channels: ptr[uint32], p_sample_rate: ptr[uint32], p_channel_map: ptr[channel], channel_map_cap: ptr_uint) -> result = c.ma_data_source_get_data_format
|
|
675
|
+
public foreign function data_source_get_cursor_in_pcm_frames(p_data_source: ptr[data_source], p_cursor: ptr[uint64]) -> result = c.ma_data_source_get_cursor_in_pcm_frames
|
|
676
|
+
public foreign function data_source_get_length_in_pcm_frames(p_data_source: ptr[data_source], p_length: ptr[uint64]) -> result = c.ma_data_source_get_length_in_pcm_frames
|
|
677
|
+
public foreign function data_source_get_cursor_in_seconds(p_data_source: ptr[data_source], p_cursor: ptr[float]) -> result = c.ma_data_source_get_cursor_in_seconds
|
|
678
|
+
public foreign function data_source_get_length_in_seconds(p_data_source: ptr[data_source], p_length: ptr[float]) -> result = c.ma_data_source_get_length_in_seconds
|
|
679
|
+
public foreign function data_source_set_looping(p_data_source: ptr[data_source], is_looping: uint) -> result = c.ma_data_source_set_looping
|
|
680
|
+
public foreign function data_source_is_looping(p_data_source: const_ptr[data_source]) -> bool32 = c.ma_data_source_is_looping
|
|
681
|
+
public foreign function data_source_set_range_in_pcm_frames(p_data_source: ptr[data_source], range_beg_in_frames: ulong, range_end_in_frames: ulong) -> result = c.ma_data_source_set_range_in_pcm_frames
|
|
682
|
+
public foreign function data_source_get_range_in_pcm_frames(p_data_source: const_ptr[data_source], p_range_beg_in_frames: ptr[uint64], p_range_end_in_frames: ptr[uint64]) -> void = c.ma_data_source_get_range_in_pcm_frames
|
|
683
|
+
public foreign function data_source_set_loop_point_in_pcm_frames(p_data_source: ptr[data_source], loop_beg_in_frames: ulong, loop_end_in_frames: ulong) -> result = c.ma_data_source_set_loop_point_in_pcm_frames
|
|
684
|
+
public foreign function data_source_get_loop_point_in_pcm_frames(p_data_source: const_ptr[data_source], p_loop_beg_in_frames: ptr[uint64], p_loop_end_in_frames: ptr[uint64]) -> void = c.ma_data_source_get_loop_point_in_pcm_frames
|
|
685
|
+
public foreign function data_source_set_current(p_data_source: ptr[data_source], p_current_data_source: ptr[data_source]) -> result = c.ma_data_source_set_current
|
|
686
|
+
public foreign function data_source_get_current(p_data_source: const_ptr[data_source]) -> ptr[data_source] = c.ma_data_source_get_current
|
|
687
|
+
public foreign function data_source_set_next(p_data_source: ptr[data_source], p_next_data_source: ptr[data_source]) -> result = c.ma_data_source_set_next
|
|
688
|
+
public foreign function data_source_get_next(p_data_source: const_ptr[data_source]) -> ptr[data_source] = c.ma_data_source_get_next
|
|
689
|
+
public foreign function data_source_set_next_callback(p_data_source: ptr[data_source], on_get_next: fn(arg0: ptr[data_source]) -> ptr[data_source]) -> result = c.ma_data_source_set_next_callback
|
|
690
|
+
public foreign function data_source_get_next_callback(p_data_source: const_ptr[data_source]) -> data_source_get_next_proc = c.ma_data_source_get_next_callback
|
|
691
|
+
public foreign function audio_buffer_ref_init(format: format, channels: uint, p_data: const_ptr[void], size_in_frames: ulong, p_audio_buffer_ref: ptr[audio_buffer_ref]) -> result = c.ma_audio_buffer_ref_init
|
|
692
|
+
public foreign function audio_buffer_ref_uninit(p_audio_buffer_ref: ptr[audio_buffer_ref]) -> void = c.ma_audio_buffer_ref_uninit
|
|
693
|
+
public foreign function audio_buffer_ref_set_data(p_audio_buffer_ref: ptr[audio_buffer_ref], p_data: const_ptr[void], size_in_frames: ulong) -> result = c.ma_audio_buffer_ref_set_data
|
|
694
|
+
public foreign function audio_buffer_ref_read_pcm_frames(p_audio_buffer_ref: ptr[audio_buffer_ref], p_frames_out: ptr[void], frame_count: ulong, loop: uint) -> uint64 = c.ma_audio_buffer_ref_read_pcm_frames
|
|
695
|
+
public foreign function audio_buffer_ref_seek_to_pcm_frame(p_audio_buffer_ref: ptr[audio_buffer_ref], frame_index: ulong) -> result = c.ma_audio_buffer_ref_seek_to_pcm_frame
|
|
696
|
+
public foreign function audio_buffer_ref_map(p_audio_buffer_ref: ptr[audio_buffer_ref], pp_frames_out: ptr[ptr[void]], p_frame_count: ptr[uint64]) -> result = c.ma_audio_buffer_ref_map
|
|
697
|
+
public foreign function audio_buffer_ref_unmap(p_audio_buffer_ref: ptr[audio_buffer_ref], frame_count: ulong) -> result = c.ma_audio_buffer_ref_unmap
|
|
698
|
+
public foreign function audio_buffer_ref_at_end(p_audio_buffer_ref: const_ptr[audio_buffer_ref]) -> bool32 = c.ma_audio_buffer_ref_at_end
|
|
699
|
+
public foreign function audio_buffer_ref_get_cursor_in_pcm_frames(p_audio_buffer_ref: const_ptr[audio_buffer_ref], p_cursor: ptr[uint64]) -> result = c.ma_audio_buffer_ref_get_cursor_in_pcm_frames
|
|
700
|
+
public foreign function audio_buffer_ref_get_length_in_pcm_frames(p_audio_buffer_ref: const_ptr[audio_buffer_ref], p_length: ptr[uint64]) -> result = c.ma_audio_buffer_ref_get_length_in_pcm_frames
|
|
701
|
+
public foreign function audio_buffer_ref_get_available_frames(p_audio_buffer_ref: const_ptr[audio_buffer_ref], p_available_frames: ptr[uint64]) -> result = c.ma_audio_buffer_ref_get_available_frames
|
|
702
|
+
public foreign function audio_buffer_config_init(format: format, channels: uint, size_in_frames: ulong, p_data: const_ptr[void], p_allocation_callbacks: const_ptr[allocation_callbacks]) -> audio_buffer_config = c.ma_audio_buffer_config_init
|
|
703
|
+
public foreign function audio_buffer_init(p_config: const_ptr[audio_buffer_config], p_audio_buffer: ptr[audio_buffer]) -> result = c.ma_audio_buffer_init
|
|
704
|
+
public foreign function audio_buffer_init_copy(p_config: const_ptr[audio_buffer_config], p_audio_buffer: ptr[audio_buffer]) -> result = c.ma_audio_buffer_init_copy
|
|
705
|
+
public foreign function audio_buffer_alloc_and_init(p_config: const_ptr[audio_buffer_config], pp_audio_buffer: ptr[ptr[audio_buffer]]) -> result = c.ma_audio_buffer_alloc_and_init
|
|
706
|
+
public foreign function audio_buffer_uninit(p_audio_buffer: ptr[audio_buffer]) -> void = c.ma_audio_buffer_uninit
|
|
707
|
+
public foreign function audio_buffer_uninit_and_free(p_audio_buffer: ptr[audio_buffer]) -> void = c.ma_audio_buffer_uninit_and_free
|
|
708
|
+
public foreign function audio_buffer_read_pcm_frames(p_audio_buffer: ptr[audio_buffer], p_frames_out: ptr[void], frame_count: ulong, loop: uint) -> uint64 = c.ma_audio_buffer_read_pcm_frames
|
|
709
|
+
public foreign function audio_buffer_seek_to_pcm_frame(p_audio_buffer: ptr[audio_buffer], frame_index: ulong) -> result = c.ma_audio_buffer_seek_to_pcm_frame
|
|
710
|
+
public foreign function audio_buffer_map(p_audio_buffer: ptr[audio_buffer], pp_frames_out: ptr[ptr[void]], p_frame_count: ptr[uint64]) -> result = c.ma_audio_buffer_map
|
|
711
|
+
public foreign function audio_buffer_unmap(p_audio_buffer: ptr[audio_buffer], frame_count: ulong) -> result = c.ma_audio_buffer_unmap
|
|
712
|
+
public foreign function audio_buffer_at_end(p_audio_buffer: const_ptr[audio_buffer]) -> bool32 = c.ma_audio_buffer_at_end
|
|
713
|
+
public foreign function audio_buffer_get_cursor_in_pcm_frames(p_audio_buffer: const_ptr[audio_buffer], p_cursor: ptr[uint64]) -> result = c.ma_audio_buffer_get_cursor_in_pcm_frames
|
|
714
|
+
public foreign function audio_buffer_get_length_in_pcm_frames(p_audio_buffer: const_ptr[audio_buffer], p_length: ptr[uint64]) -> result = c.ma_audio_buffer_get_length_in_pcm_frames
|
|
715
|
+
public foreign function audio_buffer_get_available_frames(p_audio_buffer: const_ptr[audio_buffer], p_available_frames: ptr[uint64]) -> result = c.ma_audio_buffer_get_available_frames
|
|
716
|
+
public foreign function paged_audio_buffer_data_init(format: format, channels: uint, p_data: ptr[paged_audio_buffer_data]) -> result = c.ma_paged_audio_buffer_data_init
|
|
717
|
+
public foreign function paged_audio_buffer_data_uninit(p_data: ptr[paged_audio_buffer_data], p_allocation_callbacks: const_ptr[allocation_callbacks]) -> void = c.ma_paged_audio_buffer_data_uninit
|
|
718
|
+
public foreign function paged_audio_buffer_data_get_head(p_data: ptr[paged_audio_buffer_data]) -> ptr[paged_audio_buffer_page] = c.ma_paged_audio_buffer_data_get_head
|
|
719
|
+
public foreign function paged_audio_buffer_data_get_tail(p_data: ptr[paged_audio_buffer_data]) -> ptr[paged_audio_buffer_page] = c.ma_paged_audio_buffer_data_get_tail
|
|
720
|
+
public foreign function paged_audio_buffer_data_get_length_in_pcm_frames(p_data: ptr[paged_audio_buffer_data], p_length: ptr[uint64]) -> result = c.ma_paged_audio_buffer_data_get_length_in_pcm_frames
|
|
721
|
+
public foreign function paged_audio_buffer_data_allocate_page(p_data: ptr[paged_audio_buffer_data], page_size_in_frames: ulong, p_initial_data: const_ptr[void], p_allocation_callbacks: const_ptr[allocation_callbacks], pp_page: ptr[ptr[paged_audio_buffer_page]]) -> result = c.ma_paged_audio_buffer_data_allocate_page
|
|
722
|
+
public foreign function paged_audio_buffer_data_free_page(p_data: ptr[paged_audio_buffer_data], p_page: ptr[paged_audio_buffer_page], p_allocation_callbacks: const_ptr[allocation_callbacks]) -> result = c.ma_paged_audio_buffer_data_free_page
|
|
723
|
+
public foreign function paged_audio_buffer_data_append_page(p_data: ptr[paged_audio_buffer_data], p_page: ptr[paged_audio_buffer_page]) -> result = c.ma_paged_audio_buffer_data_append_page
|
|
724
|
+
public foreign function paged_audio_buffer_data_allocate_and_append_page(p_data: ptr[paged_audio_buffer_data], page_size_in_frames: uint, p_initial_data: const_ptr[void], p_allocation_callbacks: const_ptr[allocation_callbacks]) -> result = c.ma_paged_audio_buffer_data_allocate_and_append_page
|
|
725
|
+
public foreign function paged_audio_buffer_config_init(p_data: ptr[paged_audio_buffer_data]) -> paged_audio_buffer_config = c.ma_paged_audio_buffer_config_init
|
|
726
|
+
public foreign function paged_audio_buffer_init(p_config: const_ptr[paged_audio_buffer_config], p_paged_audio_buffer: ptr[paged_audio_buffer]) -> result = c.ma_paged_audio_buffer_init
|
|
727
|
+
public foreign function paged_audio_buffer_uninit(p_paged_audio_buffer: ptr[paged_audio_buffer]) -> void = c.ma_paged_audio_buffer_uninit
|
|
728
|
+
public foreign function paged_audio_buffer_read_pcm_frames(p_paged_audio_buffer: ptr[paged_audio_buffer], p_frames_out: ptr[void], frame_count: ulong, p_frames_read: ptr[uint64]) -> result = c.ma_paged_audio_buffer_read_pcm_frames
|
|
729
|
+
public foreign function paged_audio_buffer_seek_to_pcm_frame(p_paged_audio_buffer: ptr[paged_audio_buffer], frame_index: ulong) -> result = c.ma_paged_audio_buffer_seek_to_pcm_frame
|
|
730
|
+
public foreign function paged_audio_buffer_get_cursor_in_pcm_frames(p_paged_audio_buffer: ptr[paged_audio_buffer], p_cursor: ptr[uint64]) -> result = c.ma_paged_audio_buffer_get_cursor_in_pcm_frames
|
|
731
|
+
public foreign function paged_audio_buffer_get_length_in_pcm_frames(p_paged_audio_buffer: ptr[paged_audio_buffer], p_length: ptr[uint64]) -> result = c.ma_paged_audio_buffer_get_length_in_pcm_frames
|
|
732
|
+
public foreign function rb_init_ex(subbuffer_size_in_bytes: ptr_uint, subbuffer_count: ptr_uint, subbuffer_stride_in_bytes: ptr_uint, p_optional_preallocated_buffer: ptr[void], p_allocation_callbacks: const_ptr[allocation_callbacks], p_rb: ptr[rb]) -> result = c.ma_rb_init_ex
|
|
733
|
+
public foreign function rb_init(buffer_size_in_bytes: ptr_uint, p_optional_preallocated_buffer: ptr[void], p_allocation_callbacks: const_ptr[allocation_callbacks], p_rb: ptr[rb]) -> result = c.ma_rb_init
|
|
734
|
+
public foreign function rb_uninit(p_rb: ptr[rb]) -> void = c.ma_rb_uninit
|
|
735
|
+
public foreign function rb_reset(p_rb: ptr[rb]) -> void = c.ma_rb_reset
|
|
736
|
+
public foreign function rb_acquire_read(p_rb: ptr[rb], p_size_in_bytes: ptr[ptr_uint], pp_buffer_out: ptr[ptr[void]]) -> result = c.ma_rb_acquire_read
|
|
737
|
+
public foreign function rb_commit_read(p_rb: ptr[rb], size_in_bytes: ptr_uint) -> result = c.ma_rb_commit_read
|
|
738
|
+
public foreign function rb_acquire_write(p_rb: ptr[rb], p_size_in_bytes: ptr[ptr_uint], pp_buffer_out: ptr[ptr[void]]) -> result = c.ma_rb_acquire_write
|
|
739
|
+
public foreign function rb_commit_write(p_rb: ptr[rb], size_in_bytes: ptr_uint) -> result = c.ma_rb_commit_write
|
|
740
|
+
public foreign function rb_seek_read(p_rb: ptr[rb], offset_in_bytes: ptr_uint) -> result = c.ma_rb_seek_read
|
|
741
|
+
public foreign function rb_seek_write(p_rb: ptr[rb], offset_in_bytes: ptr_uint) -> result = c.ma_rb_seek_write
|
|
742
|
+
public foreign function rb_pointer_distance(p_rb: ptr[rb]) -> int32 = c.ma_rb_pointer_distance
|
|
743
|
+
public foreign function rb_available_read(p_rb: ptr[rb]) -> uint32 = c.ma_rb_available_read
|
|
744
|
+
public foreign function rb_available_write(p_rb: ptr[rb]) -> uint32 = c.ma_rb_available_write
|
|
745
|
+
public foreign function rb_get_subbuffer_size(p_rb: ptr[rb]) -> ptr_uint = c.ma_rb_get_subbuffer_size
|
|
746
|
+
public foreign function rb_get_subbuffer_stride(p_rb: ptr[rb]) -> ptr_uint = c.ma_rb_get_subbuffer_stride
|
|
747
|
+
public foreign function rb_get_subbuffer_offset(p_rb: ptr[rb], subbuffer_index: ptr_uint) -> ptr_uint = c.ma_rb_get_subbuffer_offset
|
|
748
|
+
public foreign function rb_get_subbuffer_ptr(p_rb: ptr[rb], subbuffer_index: ptr_uint, p_buffer: ptr[void]) -> ptr[void] = c.ma_rb_get_subbuffer_ptr
|
|
749
|
+
public foreign function pcm_rb_init_ex(format: format, channels: uint, subbuffer_size_in_frames: uint, subbuffer_count: uint, subbuffer_stride_in_frames: uint, p_optional_preallocated_buffer: ptr[void], p_allocation_callbacks: const_ptr[allocation_callbacks], p_rb: ptr[pcm_rb]) -> result = c.ma_pcm_rb_init_ex
|
|
750
|
+
public foreign function pcm_rb_init(format: format, channels: uint, buffer_size_in_frames: uint, p_optional_preallocated_buffer: ptr[void], p_allocation_callbacks: const_ptr[allocation_callbacks], p_rb: ptr[pcm_rb]) -> result = c.ma_pcm_rb_init
|
|
751
|
+
public foreign function pcm_rb_uninit(p_rb: ptr[pcm_rb]) -> void = c.ma_pcm_rb_uninit
|
|
752
|
+
public foreign function pcm_rb_reset(p_rb: ptr[pcm_rb]) -> void = c.ma_pcm_rb_reset
|
|
753
|
+
public foreign function pcm_rb_acquire_read(p_rb: ptr[pcm_rb], p_size_in_frames: ptr[uint32], pp_buffer_out: ptr[ptr[void]]) -> result = c.ma_pcm_rb_acquire_read
|
|
754
|
+
public foreign function pcm_rb_commit_read(p_rb: ptr[pcm_rb], size_in_frames: uint) -> result = c.ma_pcm_rb_commit_read
|
|
755
|
+
public foreign function pcm_rb_acquire_write(p_rb: ptr[pcm_rb], p_size_in_frames: ptr[uint32], pp_buffer_out: ptr[ptr[void]]) -> result = c.ma_pcm_rb_acquire_write
|
|
756
|
+
public foreign function pcm_rb_commit_write(p_rb: ptr[pcm_rb], size_in_frames: uint) -> result = c.ma_pcm_rb_commit_write
|
|
757
|
+
public foreign function pcm_rb_seek_read(p_rb: ptr[pcm_rb], offset_in_frames: uint) -> result = c.ma_pcm_rb_seek_read
|
|
758
|
+
public foreign function pcm_rb_seek_write(p_rb: ptr[pcm_rb], offset_in_frames: uint) -> result = c.ma_pcm_rb_seek_write
|
|
759
|
+
public foreign function pcm_rb_pointer_distance(p_rb: ptr[pcm_rb]) -> int32 = c.ma_pcm_rb_pointer_distance
|
|
760
|
+
public foreign function pcm_rb_available_read(p_rb: ptr[pcm_rb]) -> uint32 = c.ma_pcm_rb_available_read
|
|
761
|
+
public foreign function pcm_rb_available_write(p_rb: ptr[pcm_rb]) -> uint32 = c.ma_pcm_rb_available_write
|
|
762
|
+
public foreign function pcm_rb_get_subbuffer_size(p_rb: ptr[pcm_rb]) -> uint32 = c.ma_pcm_rb_get_subbuffer_size
|
|
763
|
+
public foreign function pcm_rb_get_subbuffer_stride(p_rb: ptr[pcm_rb]) -> uint32 = c.ma_pcm_rb_get_subbuffer_stride
|
|
764
|
+
public foreign function pcm_rb_get_subbuffer_offset(p_rb: ptr[pcm_rb], subbuffer_index: uint) -> uint32 = c.ma_pcm_rb_get_subbuffer_offset
|
|
765
|
+
public foreign function pcm_rb_get_subbuffer_ptr(p_rb: ptr[pcm_rb], subbuffer_index: uint, p_buffer: ptr[void]) -> ptr[void] = c.ma_pcm_rb_get_subbuffer_ptr
|
|
766
|
+
public foreign function pcm_rb_get_format(p_rb: const_ptr[pcm_rb]) -> format = c.ma_pcm_rb_get_format
|
|
767
|
+
public foreign function pcm_rb_get_channels(p_rb: const_ptr[pcm_rb]) -> uint32 = c.ma_pcm_rb_get_channels
|
|
768
|
+
public foreign function pcm_rb_get_sample_rate(p_rb: const_ptr[pcm_rb]) -> uint32 = c.ma_pcm_rb_get_sample_rate
|
|
769
|
+
public foreign function pcm_rb_set_sample_rate(p_rb: ptr[pcm_rb], sample_rate: uint) -> void = c.ma_pcm_rb_set_sample_rate
|
|
770
|
+
public foreign function duplex_rb_init(capture_format: format, capture_channels: uint, sample_rate: uint, capture_internal_sample_rate: uint, capture_internal_period_size_in_frames: uint, p_allocation_callbacks: const_ptr[allocation_callbacks], p_rb: ptr[duplex_rb]) -> result = c.ma_duplex_rb_init
|
|
771
|
+
public foreign function duplex_rb_uninit(p_rb: ptr[duplex_rb]) -> result = c.ma_duplex_rb_uninit
|
|
772
|
+
public foreign function result_description(result: result) -> cstr = c.ma_result_description
|
|
773
|
+
public foreign function malloc(sz: ptr_uint, p_allocation_callbacks: const_ptr[allocation_callbacks]) -> ptr[void] = c.ma_malloc
|
|
774
|
+
public foreign function calloc(sz: ptr_uint, p_allocation_callbacks: const_ptr[allocation_callbacks]) -> ptr[void] = c.ma_calloc
|
|
775
|
+
public foreign function realloc(p: ptr[void], sz: ptr_uint, p_allocation_callbacks: const_ptr[allocation_callbacks]) -> ptr[void] = c.ma_realloc
|
|
776
|
+
public foreign function free(p: ptr[void], p_allocation_callbacks: const_ptr[allocation_callbacks]) -> void = c.ma_free
|
|
777
|
+
public foreign function aligned_malloc(sz: ptr_uint, alignment: ptr_uint, p_allocation_callbacks: const_ptr[allocation_callbacks]) -> ptr[void] = c.ma_aligned_malloc
|
|
778
|
+
public foreign function aligned_free(p: ptr[void], p_allocation_callbacks: const_ptr[allocation_callbacks]) -> void = c.ma_aligned_free
|
|
779
|
+
public foreign function get_format_name(format: format) -> cstr = c.ma_get_format_name
|
|
780
|
+
public foreign function blend_f32(p_out: ptr[float], p_in_a: ptr[float], p_in_b: ptr[float], factor: float, channels: uint) -> void = c.ma_blend_f32
|
|
781
|
+
public foreign function get_bytes_per_sample(format: format) -> uint32 = c.ma_get_bytes_per_sample
|
|
782
|
+
public foreign function log_level_to_string(log_level: uint) -> cstr = c.ma_log_level_to_string
|
|
783
|
+
public foreign function spinlock_lock(p_spinlock: ptr[spinlock]) -> result = c.ma_spinlock_lock
|
|
784
|
+
public foreign function spinlock_lock_noyield(p_spinlock: ptr[spinlock]) -> result = c.ma_spinlock_lock_noyield
|
|
785
|
+
public foreign function spinlock_unlock(p_spinlock: ptr[spinlock]) -> result = c.ma_spinlock_unlock
|
|
786
|
+
public foreign function mutex_init(p_mutex: ptr[mutex]) -> result = c.ma_mutex_init
|
|
787
|
+
public foreign function mutex_uninit(p_mutex: ptr[mutex]) -> void = c.ma_mutex_uninit
|
|
788
|
+
public foreign function mutex_lock(p_mutex: ptr[mutex]) -> void = c.ma_mutex_lock
|
|
789
|
+
public foreign function mutex_unlock(p_mutex: ptr[mutex]) -> void = c.ma_mutex_unlock
|
|
790
|
+
public foreign function event_init(p_event: ptr[event_]) -> result = c.ma_event_init
|
|
791
|
+
public foreign function event_uninit(p_event: ptr[event_]) -> void = c.ma_event_uninit
|
|
792
|
+
public foreign function event_wait(p_event: ptr[event_]) -> result = c.ma_event_wait
|
|
793
|
+
public foreign function event_signal(p_event: ptr[event_]) -> result = c.ma_event_signal
|
|
794
|
+
public foreign function semaphore_init(initial_value: int, p_semaphore: ptr[semaphore]) -> result = c.ma_semaphore_init
|
|
795
|
+
public foreign function semaphore_uninit(p_semaphore: ptr[semaphore]) -> void = c.ma_semaphore_uninit
|
|
796
|
+
public foreign function semaphore_wait(p_semaphore: ptr[semaphore]) -> result = c.ma_semaphore_wait
|
|
797
|
+
public foreign function semaphore_release(p_semaphore: ptr[semaphore]) -> result = c.ma_semaphore_release
|
|
798
|
+
public foreign function fence_init(p_fence: ptr[fence]) -> result = c.ma_fence_init
|
|
799
|
+
public foreign function fence_uninit(p_fence: ptr[fence]) -> void = c.ma_fence_uninit
|
|
800
|
+
public foreign function fence_acquire(p_fence: ptr[fence]) -> result = c.ma_fence_acquire
|
|
801
|
+
public foreign function fence_release(p_fence: ptr[fence]) -> result = c.ma_fence_release
|
|
802
|
+
public foreign function fence_wait(p_fence: ptr[fence]) -> result = c.ma_fence_wait
|
|
803
|
+
public foreign function async_notification_signal(p_notification: ptr[async_notification]) -> result = c.ma_async_notification_signal
|
|
804
|
+
public foreign function async_notification_poll_init(p_notification_poll: ptr[async_notification_poll]) -> result = c.ma_async_notification_poll_init
|
|
805
|
+
public foreign function async_notification_poll_is_signalled(p_notification_poll: const_ptr[async_notification_poll]) -> bool32 = c.ma_async_notification_poll_is_signalled
|
|
806
|
+
public foreign function async_notification_event_init(p_notification_event: ptr[async_notification_event]) -> result = c.ma_async_notification_event_init
|
|
807
|
+
public foreign function async_notification_event_uninit(p_notification_event: ptr[async_notification_event]) -> result = c.ma_async_notification_event_uninit
|
|
808
|
+
public foreign function async_notification_event_wait(p_notification_event: ptr[async_notification_event]) -> result = c.ma_async_notification_event_wait
|
|
809
|
+
public foreign function async_notification_event_signal(p_notification_event: ptr[async_notification_event]) -> result = c.ma_async_notification_event_signal
|
|
810
|
+
public foreign function slot_allocator_config_init(capacity: uint) -> slot_allocator_config = c.ma_slot_allocator_config_init
|
|
811
|
+
public foreign function slot_allocator_get_heap_size(p_config: const_ptr[slot_allocator_config], p_heap_size_in_bytes: ptr[ptr_uint]) -> result = c.ma_slot_allocator_get_heap_size
|
|
812
|
+
public foreign function slot_allocator_init_preallocated(p_config: const_ptr[slot_allocator_config], p_heap: ptr[void], p_allocator: ptr[slot_allocator]) -> result = c.ma_slot_allocator_init_preallocated
|
|
813
|
+
public foreign function slot_allocator_init(p_config: const_ptr[slot_allocator_config], p_allocation_callbacks: const_ptr[allocation_callbacks], p_allocator: ptr[slot_allocator]) -> result = c.ma_slot_allocator_init
|
|
814
|
+
public foreign function slot_allocator_uninit(p_allocator: ptr[slot_allocator], p_allocation_callbacks: const_ptr[allocation_callbacks]) -> void = c.ma_slot_allocator_uninit
|
|
815
|
+
public foreign function slot_allocator_alloc(p_allocator: ptr[slot_allocator], p_slot: ptr[uint64]) -> result = c.ma_slot_allocator_alloc
|
|
816
|
+
public foreign function slot_allocator_free(p_allocator: ptr[slot_allocator], slot: ulong) -> result = c.ma_slot_allocator_free
|
|
817
|
+
public foreign function job_init(code: ushort) -> job = c.ma_job_init
|
|
818
|
+
public foreign function job_process(p_job: ptr[job]) -> result = c.ma_job_process
|
|
819
|
+
public foreign function job_queue_config_init(flags_: uint, capacity: uint) -> job_queue_config = c.ma_job_queue_config_init
|
|
820
|
+
public foreign function job_queue_get_heap_size(p_config: const_ptr[job_queue_config], p_heap_size_in_bytes: ptr[ptr_uint]) -> result = c.ma_job_queue_get_heap_size
|
|
821
|
+
public foreign function job_queue_init_preallocated(p_config: const_ptr[job_queue_config], p_heap: ptr[void], p_queue: ptr[job_queue]) -> result = c.ma_job_queue_init_preallocated
|
|
822
|
+
public foreign function job_queue_init(p_config: const_ptr[job_queue_config], p_allocation_callbacks: const_ptr[allocation_callbacks], p_queue: ptr[job_queue]) -> result = c.ma_job_queue_init
|
|
823
|
+
public foreign function job_queue_uninit(p_queue: ptr[job_queue], p_allocation_callbacks: const_ptr[allocation_callbacks]) -> void = c.ma_job_queue_uninit
|
|
824
|
+
public foreign function job_queue_post(p_queue: ptr[job_queue], p_job: const_ptr[job]) -> result = c.ma_job_queue_post
|
|
825
|
+
public foreign function job_queue_next(p_queue: ptr[job_queue], p_job: ptr[job]) -> result = c.ma_job_queue_next
|
|
826
|
+
public foreign function device_job_thread_config_init() -> device_job_thread_config = c.ma_device_job_thread_config_init
|
|
827
|
+
public foreign function device_job_thread_init(p_config: const_ptr[device_job_thread_config], p_allocation_callbacks: const_ptr[allocation_callbacks], p_job_thread: ptr[device_job_thread]) -> result = c.ma_device_job_thread_init
|
|
828
|
+
public foreign function device_job_thread_uninit(p_job_thread: ptr[device_job_thread], p_allocation_callbacks: const_ptr[allocation_callbacks]) -> void = c.ma_device_job_thread_uninit
|
|
829
|
+
public foreign function device_job_thread_post(p_job_thread: ptr[device_job_thread], p_job: const_ptr[job]) -> result = c.ma_device_job_thread_post
|
|
830
|
+
public foreign function device_job_thread_next(p_job_thread: ptr[device_job_thread], p_job: ptr[job]) -> result = c.ma_device_job_thread_next
|
|
831
|
+
public foreign function device_id_equal(p_a: const_ptr[device_id], p_b: const_ptr[device_id]) -> bool32 = c.ma_device_id_equal
|
|
832
|
+
public foreign function context_config_init() -> context_config = c.ma_context_config_init
|
|
833
|
+
public foreign function context_init(backends: const_ptr[backend], backend_count: uint, p_config: const_ptr[context_config], p_context: ptr[context]) -> result = c.ma_context_init
|
|
834
|
+
public foreign function context_uninit(p_context: ptr[context]) -> result = c.ma_context_uninit
|
|
835
|
+
public foreign function context_sizeof() -> ptr_uint = c.ma_context_sizeof
|
|
836
|
+
public foreign function context_get_log(p_context: ptr[context]) -> ptr[log] = c.ma_context_get_log
|
|
837
|
+
public foreign function context_enumerate_devices(p_context: ptr[context], callback: fn(arg0: ptr[context], arg1: device_type, arg2: const_ptr[device_info], arg3: ptr[void]) -> bool32, p_user_data: ptr[void]) -> result = c.ma_context_enumerate_devices
|
|
838
|
+
public foreign function context_get_devices(p_context: ptr[context], pp_playback_device_infos: ptr[ptr[device_info]], p_playback_device_count: ptr[uint32], pp_capture_device_infos: ptr[ptr[device_info]], p_capture_device_count: ptr[uint32]) -> result = c.ma_context_get_devices
|
|
839
|
+
public foreign function context_get_device_info(p_context: ptr[context], device_type: device_type, p_device_id: const_ptr[device_id], p_device_info: ptr[device_info]) -> result = c.ma_context_get_device_info
|
|
840
|
+
public foreign function context_is_loopback_supported(p_context: ptr[context]) -> bool32 = c.ma_context_is_loopback_supported
|
|
841
|
+
public foreign function device_config_init(device_type: device_type) -> device_config = c.ma_device_config_init
|
|
842
|
+
public foreign function device_init(p_context: ptr[context], p_config: const_ptr[device_config], p_device: ptr[device]) -> result = c.ma_device_init
|
|
843
|
+
public foreign function device_init_ex(backends: const_ptr[backend], backend_count: uint, p_context_config: const_ptr[context_config], p_config: const_ptr[device_config], p_device: ptr[device]) -> result = c.ma_device_init_ex
|
|
844
|
+
public foreign function device_uninit(p_device: ptr[device]) -> void = c.ma_device_uninit
|
|
845
|
+
public foreign function device_get_context(p_device: ptr[device]) -> ptr[context] = c.ma_device_get_context
|
|
846
|
+
public foreign function device_get_log(p_device: ptr[device]) -> ptr[log] = c.ma_device_get_log
|
|
847
|
+
public foreign function device_get_info(p_device: ptr[device], type_: device_type, p_device_info: ptr[device_info]) -> result = c.ma_device_get_info
|
|
848
|
+
public foreign function device_get_name(p_device: ptr[device], type_: device_type, p_name: ptr[char], name_cap: ptr_uint, p_length_not_including_null_terminator: ptr[ptr_uint]) -> result = c.ma_device_get_name
|
|
849
|
+
public foreign function device_start(p_device: ptr[device]) -> result = c.ma_device_start
|
|
850
|
+
public foreign function device_stop(p_device: ptr[device]) -> result = c.ma_device_stop
|
|
851
|
+
public foreign function device_is_started(p_device: const_ptr[device]) -> bool32 = c.ma_device_is_started
|
|
852
|
+
public foreign function device_get_state(p_device: const_ptr[device]) -> device_state = c.ma_device_get_state
|
|
853
|
+
public foreign function device_post_init(p_device: ptr[device], device_type: device_type, p_playback_descriptor: const_ptr[device_descriptor], p_capture_descriptor: const_ptr[device_descriptor]) -> result = c.ma_device_post_init
|
|
854
|
+
public foreign function device_set_master_volume(p_device: ptr[device], volume: float) -> result = c.ma_device_set_master_volume
|
|
855
|
+
public foreign function device_get_master_volume(p_device: ptr[device], p_volume: ptr[float]) -> result = c.ma_device_get_master_volume
|
|
856
|
+
public foreign function device_set_master_volume_db(p_device: ptr[device], gain_db: float) -> result = c.ma_device_set_master_volume_db
|
|
857
|
+
public foreign function device_get_master_volume_db(p_device: ptr[device], p_gain_db: ptr[float]) -> result = c.ma_device_get_master_volume_db
|
|
858
|
+
public foreign function device_handle_backend_data_callback(p_device: ptr[device], p_output: ptr[void], p_input: const_ptr[void], frame_count: uint) -> result = c.ma_device_handle_backend_data_callback
|
|
859
|
+
public foreign function calculate_buffer_size_in_frames_from_descriptor(p_descriptor: const_ptr[device_descriptor], native_sample_rate: uint, performance_profile: performance_profile) -> uint32 = c.ma_calculate_buffer_size_in_frames_from_descriptor
|
|
860
|
+
public foreign function get_backend_name(backend: backend) -> cstr = c.ma_get_backend_name
|
|
861
|
+
public foreign function get_backend_from_name(p_backend_name: str as cstr, p_backend: ptr[backend]) -> result = c.ma_get_backend_from_name
|
|
862
|
+
public foreign function is_backend_enabled(backend: backend) -> bool32 = c.ma_is_backend_enabled
|
|
863
|
+
public foreign function get_enabled_backends(p_backends: ptr[backend], backend_cap: ptr_uint, p_backend_count: ptr[ptr_uint]) -> result = c.ma_get_enabled_backends
|
|
864
|
+
public foreign function is_loopback_supported(backend: backend) -> bool32 = c.ma_is_loopback_supported
|
|
865
|
+
public foreign function calculate_buffer_size_in_milliseconds_from_frames(buffer_size_in_frames: uint, sample_rate: uint) -> uint32 = c.ma_calculate_buffer_size_in_milliseconds_from_frames
|
|
866
|
+
public foreign function calculate_buffer_size_in_frames_from_milliseconds(buffer_size_in_milliseconds: uint, sample_rate: uint) -> uint32 = c.ma_calculate_buffer_size_in_frames_from_milliseconds
|
|
867
|
+
public foreign function copy_pcm_frames(dst: ptr[void], src: const_ptr[void], frame_count: ulong, format: format, channels: uint) -> void = c.ma_copy_pcm_frames
|
|
868
|
+
public foreign function silence_pcm_frames(p: ptr[void], frame_count: ulong, format: format, channels: uint) -> void = c.ma_silence_pcm_frames
|
|
869
|
+
public foreign function offset_pcm_frames_ptr(p: ptr[void], offset_in_frames: ulong, format: format, channels: uint) -> ptr[void] = c.ma_offset_pcm_frames_ptr
|
|
870
|
+
public foreign function offset_pcm_frames_const_ptr(p: const_ptr[void], offset_in_frames: ulong, format: format, channels: uint) -> const_ptr[void] = c.ma_offset_pcm_frames_const_ptr
|
|
871
|
+
public foreign function clip_samples_u8(p_dst: ptr[uint8], p_src: const_ptr[int16], count: ulong) -> void = c.ma_clip_samples_u8
|
|
872
|
+
public foreign function clip_samples_s16(p_dst: ptr[int16], p_src: const_ptr[int32], count: ulong) -> void = c.ma_clip_samples_s16
|
|
873
|
+
public foreign function clip_samples_s24(p_dst: ptr[uint8], p_src: const_ptr[int64], count: ulong) -> void = c.ma_clip_samples_s24
|
|
874
|
+
public foreign function clip_samples_s32(p_dst: ptr[int32], p_src: const_ptr[int64], count: ulong) -> void = c.ma_clip_samples_s32
|
|
875
|
+
public foreign function clip_samples_f32(p_dst: ptr[float], p_src: const_ptr[float], count: ulong) -> void = c.ma_clip_samples_f32
|
|
876
|
+
public foreign function clip_pcm_frames(p_dst: ptr[void], p_src: const_ptr[void], frame_count: ulong, format: format, channels: uint) -> void = c.ma_clip_pcm_frames
|
|
877
|
+
public foreign function copy_and_apply_volume_factor_u8(p_samples_out: ptr[uint8], p_samples_in: const_ptr[uint8], sample_count: ulong, factor: float) -> void = c.ma_copy_and_apply_volume_factor_u8
|
|
878
|
+
public foreign function copy_and_apply_volume_factor_s16(p_samples_out: ptr[int16], p_samples_in: const_ptr[int16], sample_count: ulong, factor: float) -> void = c.ma_copy_and_apply_volume_factor_s16
|
|
879
|
+
public foreign function copy_and_apply_volume_factor_s24(p_samples_out: ptr[void], p_samples_in: const_ptr[void], sample_count: ulong, factor: float) -> void = c.ma_copy_and_apply_volume_factor_s24
|
|
880
|
+
public foreign function copy_and_apply_volume_factor_s32(p_samples_out: ptr[int32], p_samples_in: const_ptr[int32], sample_count: ulong, factor: float) -> void = c.ma_copy_and_apply_volume_factor_s32
|
|
881
|
+
public foreign function copy_and_apply_volume_factor_f32(p_samples_out: ptr[float], p_samples_in: const_ptr[float], sample_count: ulong, factor: float) -> void = c.ma_copy_and_apply_volume_factor_f32
|
|
882
|
+
public foreign function apply_volume_factor_u8(p_samples: ptr[uint8], sample_count: ulong, factor: float) -> void = c.ma_apply_volume_factor_u8
|
|
883
|
+
public foreign function apply_volume_factor_s16(p_samples: ptr[int16], sample_count: ulong, factor: float) -> void = c.ma_apply_volume_factor_s16
|
|
884
|
+
public foreign function apply_volume_factor_s24(p_samples: ptr[void], sample_count: ulong, factor: float) -> void = c.ma_apply_volume_factor_s24
|
|
885
|
+
public foreign function apply_volume_factor_s32(p_samples: ptr[int32], sample_count: ulong, factor: float) -> void = c.ma_apply_volume_factor_s32
|
|
886
|
+
public foreign function apply_volume_factor_f32(p_samples: ptr[float], sample_count: ulong, factor: float) -> void = c.ma_apply_volume_factor_f32
|
|
887
|
+
public foreign function copy_and_apply_volume_factor_pcm_frames_u8(p_frames_out: ptr[uint8], p_frames_in: const_ptr[uint8], frame_count: ulong, channels: uint, factor: float) -> void = c.ma_copy_and_apply_volume_factor_pcm_frames_u8
|
|
888
|
+
public foreign function copy_and_apply_volume_factor_pcm_frames_s16(p_frames_out: ptr[int16], p_frames_in: const_ptr[int16], frame_count: ulong, channels: uint, factor: float) -> void = c.ma_copy_and_apply_volume_factor_pcm_frames_s16
|
|
889
|
+
public foreign function copy_and_apply_volume_factor_pcm_frames_s24(p_frames_out: ptr[void], p_frames_in: const_ptr[void], frame_count: ulong, channels: uint, factor: float) -> void = c.ma_copy_and_apply_volume_factor_pcm_frames_s24
|
|
890
|
+
public foreign function copy_and_apply_volume_factor_pcm_frames_s32(p_frames_out: ptr[int32], p_frames_in: const_ptr[int32], frame_count: ulong, channels: uint, factor: float) -> void = c.ma_copy_and_apply_volume_factor_pcm_frames_s32
|
|
891
|
+
public foreign function copy_and_apply_volume_factor_pcm_frames_f32(p_frames_out: ptr[float], p_frames_in: const_ptr[float], frame_count: ulong, channels: uint, factor: float) -> void = c.ma_copy_and_apply_volume_factor_pcm_frames_f32
|
|
892
|
+
public foreign function copy_and_apply_volume_factor_pcm_frames(p_frames_out: ptr[void], p_frames_in: const_ptr[void], frame_count: ulong, format: format, channels: uint, factor: float) -> void = c.ma_copy_and_apply_volume_factor_pcm_frames
|
|
893
|
+
public foreign function apply_volume_factor_pcm_frames_u8(p_frames: ptr[uint8], frame_count: ulong, channels: uint, factor: float) -> void = c.ma_apply_volume_factor_pcm_frames_u8
|
|
894
|
+
public foreign function apply_volume_factor_pcm_frames_s16(p_frames: ptr[int16], frame_count: ulong, channels: uint, factor: float) -> void = c.ma_apply_volume_factor_pcm_frames_s16
|
|
895
|
+
public foreign function apply_volume_factor_pcm_frames_s24(p_frames: ptr[void], frame_count: ulong, channels: uint, factor: float) -> void = c.ma_apply_volume_factor_pcm_frames_s24
|
|
896
|
+
public foreign function apply_volume_factor_pcm_frames_s32(p_frames: ptr[int32], frame_count: ulong, channels: uint, factor: float) -> void = c.ma_apply_volume_factor_pcm_frames_s32
|
|
897
|
+
public foreign function apply_volume_factor_pcm_frames_f32(p_frames: ptr[float], frame_count: ulong, channels: uint, factor: float) -> void = c.ma_apply_volume_factor_pcm_frames_f32
|
|
898
|
+
public foreign function apply_volume_factor_pcm_frames(p_frames: ptr[void], frame_count: ulong, format: format, channels: uint, factor: float) -> void = c.ma_apply_volume_factor_pcm_frames
|
|
899
|
+
public foreign function copy_and_apply_volume_factor_per_channel_f32(p_frames_out: ptr[float], p_frames_in: const_ptr[float], frame_count: ulong, channels: uint, p_channel_gains: ptr[float]) -> void = c.ma_copy_and_apply_volume_factor_per_channel_f32
|
|
900
|
+
public foreign function copy_and_apply_volume_and_clip_samples_u8(p_dst: ptr[uint8], p_src: const_ptr[int16], count: ulong, volume: float) -> void = c.ma_copy_and_apply_volume_and_clip_samples_u8
|
|
901
|
+
public foreign function copy_and_apply_volume_and_clip_samples_s16(p_dst: ptr[int16], p_src: const_ptr[int32], count: ulong, volume: float) -> void = c.ma_copy_and_apply_volume_and_clip_samples_s16
|
|
902
|
+
public foreign function copy_and_apply_volume_and_clip_samples_s24(p_dst: ptr[uint8], p_src: const_ptr[int64], count: ulong, volume: float) -> void = c.ma_copy_and_apply_volume_and_clip_samples_s24
|
|
903
|
+
public foreign function copy_and_apply_volume_and_clip_samples_s32(p_dst: ptr[int32], p_src: const_ptr[int64], count: ulong, volume: float) -> void = c.ma_copy_and_apply_volume_and_clip_samples_s32
|
|
904
|
+
public foreign function copy_and_apply_volume_and_clip_samples_f32(p_dst: ptr[float], p_src: const_ptr[float], count: ulong, volume: float) -> void = c.ma_copy_and_apply_volume_and_clip_samples_f32
|
|
905
|
+
public foreign function copy_and_apply_volume_and_clip_pcm_frames(p_dst: ptr[void], p_src: const_ptr[void], frame_count: ulong, format: format, channels: uint, volume: float) -> void = c.ma_copy_and_apply_volume_and_clip_pcm_frames
|
|
906
|
+
public foreign function volume_linear_to_db(factor: float) -> float = c.ma_volume_linear_to_db
|
|
907
|
+
public foreign function volume_db_to_linear(gain: float) -> float = c.ma_volume_db_to_linear
|
|
908
|
+
public foreign function mix_pcm_frames_f32(p_dst: ptr[float], p_src: const_ptr[float], frame_count: ulong, channels: uint, volume: float) -> result = c.ma_mix_pcm_frames_f32
|
|
909
|
+
public foreign function vfs_open(p_vfs: ptr[vfs], p_file_path: str as cstr, open_mode: uint, p_file: ptr[vfs_file]) -> result = c.ma_vfs_open
|
|
910
|
+
public foreign function vfs_open_w(p_vfs: ptr[vfs], p_file_path: const_ptr[int], open_mode: uint, p_file: ptr[vfs_file]) -> result = c.ma_vfs_open_w
|
|
911
|
+
public foreign function vfs_close(p_vfs: ptr[vfs], file: ptr[void]) -> result = c.ma_vfs_close
|
|
912
|
+
public foreign function vfs_read(p_vfs: ptr[vfs], file: ptr[void], p_dst: ptr[void], size_in_bytes: ptr_uint, p_bytes_read: ptr[ptr_uint]) -> result = c.ma_vfs_read
|
|
913
|
+
public foreign function vfs_write(p_vfs: ptr[vfs], file: ptr[void], p_src: const_ptr[void], size_in_bytes: ptr_uint, p_bytes_written: ptr[ptr_uint]) -> result = c.ma_vfs_write
|
|
914
|
+
public foreign function vfs_seek(p_vfs: ptr[vfs], file: ptr[void], offset: long, origin: seek_origin) -> result = c.ma_vfs_seek
|
|
915
|
+
public foreign function vfs_tell(p_vfs: ptr[vfs], file: ptr[void], p_cursor: ptr[int64]) -> result = c.ma_vfs_tell
|
|
916
|
+
public foreign function vfs_info(p_vfs: ptr[vfs], file: ptr[void], p_info: ptr[file_info]) -> result = c.ma_vfs_info
|
|
917
|
+
public foreign function vfs_open_and_read_file(p_vfs: ptr[vfs], p_file_path: str as cstr, pp_data: ptr[ptr[void]], p_size: ptr[ptr_uint], p_allocation_callbacks: const_ptr[allocation_callbacks]) -> result = c.ma_vfs_open_and_read_file
|
|
918
|
+
public foreign function default_vfs_init(p_vfs: ptr[default_vfs], p_allocation_callbacks: const_ptr[allocation_callbacks]) -> result = c.ma_default_vfs_init
|
|
919
|
+
public foreign function decoding_backend_config_init(preferred_format: format, seek_point_count: uint) -> decoding_backend_config = c.ma_decoding_backend_config_init
|
|
920
|
+
public foreign function decoder_config_init(output_format: format, output_channels: uint, output_sample_rate: uint) -> decoder_config = c.ma_decoder_config_init
|
|
921
|
+
public foreign function decoder_config_init_default() -> decoder_config = c.ma_decoder_config_init_default
|
|
922
|
+
public foreign function decoder_init(on_read: fn(arg0: ptr[decoder], arg1: ptr[void], arg2: ptr_uint, arg3: ptr[ptr_uint]) -> result, on_seek: fn(arg0: ptr[decoder], arg1: int64, arg2: seek_origin) -> result, p_user_data: ptr[void], p_config: const_ptr[decoder_config], p_decoder: ptr[decoder]) -> result = c.ma_decoder_init
|
|
923
|
+
public foreign function decoder_init_memory(p_data: const_ptr[void], data_size: ptr_uint, p_config: const_ptr[decoder_config], p_decoder: ptr[decoder]) -> result = c.ma_decoder_init_memory
|
|
924
|
+
public foreign function decoder_init_vfs(p_vfs: ptr[vfs], p_file_path: str as cstr, p_config: const_ptr[decoder_config], p_decoder: ptr[decoder]) -> result = c.ma_decoder_init_vfs
|
|
925
|
+
public foreign function decoder_init_vfs_w(p_vfs: ptr[vfs], p_file_path: const_ptr[int], p_config: const_ptr[decoder_config], p_decoder: ptr[decoder]) -> result = c.ma_decoder_init_vfs_w
|
|
926
|
+
public foreign function decoder_init_file(p_file_path: str as cstr, p_config: const_ptr[decoder_config], p_decoder: ptr[decoder]) -> result = c.ma_decoder_init_file
|
|
927
|
+
public foreign function decoder_init_file_w(p_file_path: const_ptr[int], p_config: const_ptr[decoder_config], p_decoder: ptr[decoder]) -> result = c.ma_decoder_init_file_w
|
|
928
|
+
public foreign function decoder_uninit(p_decoder: ptr[decoder]) -> result = c.ma_decoder_uninit
|
|
929
|
+
public foreign function decoder_read_pcm_frames(p_decoder: ptr[decoder], p_frames_out: ptr[void], frame_count: ulong, p_frames_read: ptr[uint64]) -> result = c.ma_decoder_read_pcm_frames
|
|
930
|
+
public foreign function decoder_seek_to_pcm_frame(p_decoder: ptr[decoder], frame_index: ulong) -> result = c.ma_decoder_seek_to_pcm_frame
|
|
931
|
+
public foreign function decoder_get_data_format(p_decoder: ptr[decoder], p_format: ptr[format], p_channels: ptr[uint32], p_sample_rate: ptr[uint32], p_channel_map: ptr[channel], channel_map_cap: ptr_uint) -> result = c.ma_decoder_get_data_format
|
|
932
|
+
public foreign function decoder_get_cursor_in_pcm_frames(p_decoder: ptr[decoder], p_cursor: ptr[uint64]) -> result = c.ma_decoder_get_cursor_in_pcm_frames
|
|
933
|
+
public foreign function decoder_get_length_in_pcm_frames(p_decoder: ptr[decoder], p_length: ptr[uint64]) -> result = c.ma_decoder_get_length_in_pcm_frames
|
|
934
|
+
public foreign function decoder_get_available_frames(p_decoder: ptr[decoder], p_available_frames: ptr[uint64]) -> result = c.ma_decoder_get_available_frames
|
|
935
|
+
public foreign function decode_from_vfs(p_vfs: ptr[vfs], p_file_path: str as cstr, p_config: ptr[decoder_config], p_frame_count_out: ptr[uint64], pp_pcm_frames_out: ptr[ptr[void]]) -> result = c.ma_decode_from_vfs
|
|
936
|
+
public foreign function decode_file(p_file_path: str as cstr, p_config: ptr[decoder_config], p_frame_count_out: ptr[uint64], pp_pcm_frames_out: ptr[ptr[void]]) -> result = c.ma_decode_file
|
|
937
|
+
public foreign function decode_memory(p_data: const_ptr[void], data_size: ptr_uint, p_config: ptr[decoder_config], p_frame_count_out: ptr[uint64], pp_pcm_frames_out: ptr[ptr[void]]) -> result = c.ma_decode_memory
|
|
938
|
+
public foreign function encoder_config_init(encoding_format: encoding_format, format: format, channels: uint, sample_rate: uint) -> encoder_config = c.ma_encoder_config_init
|
|
939
|
+
public foreign function encoder_init(on_write: fn(arg0: ptr[encoder], arg1: const_ptr[void], arg2: ptr_uint, arg3: ptr[ptr_uint]) -> result, on_seek: fn(arg0: ptr[encoder], arg1: int64, arg2: seek_origin) -> result, p_user_data: ptr[void], p_config: const_ptr[encoder_config], p_encoder: ptr[encoder]) -> result = c.ma_encoder_init
|
|
940
|
+
public foreign function encoder_init_vfs(p_vfs: ptr[vfs], p_file_path: str as cstr, p_config: const_ptr[encoder_config], p_encoder: ptr[encoder]) -> result = c.ma_encoder_init_vfs
|
|
941
|
+
public foreign function encoder_init_vfs_w(p_vfs: ptr[vfs], p_file_path: const_ptr[int], p_config: const_ptr[encoder_config], p_encoder: ptr[encoder]) -> result = c.ma_encoder_init_vfs_w
|
|
942
|
+
public foreign function encoder_init_file(p_file_path: str as cstr, p_config: const_ptr[encoder_config], p_encoder: ptr[encoder]) -> result = c.ma_encoder_init_file
|
|
943
|
+
public foreign function encoder_init_file_w(p_file_path: const_ptr[int], p_config: const_ptr[encoder_config], p_encoder: ptr[encoder]) -> result = c.ma_encoder_init_file_w
|
|
944
|
+
public foreign function encoder_uninit(p_encoder: ptr[encoder]) -> void = c.ma_encoder_uninit
|
|
945
|
+
public foreign function encoder_write_pcm_frames(p_encoder: ptr[encoder], p_frames_in: const_ptr[void], frame_count: ulong, p_frames_written: ptr[uint64]) -> result = c.ma_encoder_write_pcm_frames
|
|
946
|
+
public foreign function waveform_config_init(format: format, channels: uint, sample_rate: uint, type_: waveform_type, amplitude: double, frequency: double) -> waveform_config = c.ma_waveform_config_init
|
|
947
|
+
public foreign function waveform_init(p_config: const_ptr[waveform_config], p_waveform: ptr[waveform]) -> result = c.ma_waveform_init
|
|
948
|
+
public foreign function waveform_uninit(p_waveform: ptr[waveform]) -> void = c.ma_waveform_uninit
|
|
949
|
+
public foreign function waveform_read_pcm_frames(p_waveform: ptr[waveform], p_frames_out: ptr[void], frame_count: ulong, p_frames_read: ptr[uint64]) -> result = c.ma_waveform_read_pcm_frames
|
|
950
|
+
public foreign function waveform_seek_to_pcm_frame(p_waveform: ptr[waveform], frame_index: ulong) -> result = c.ma_waveform_seek_to_pcm_frame
|
|
951
|
+
public foreign function waveform_set_amplitude(p_waveform: ptr[waveform], amplitude: double) -> result = c.ma_waveform_set_amplitude
|
|
952
|
+
public foreign function waveform_set_frequency(p_waveform: ptr[waveform], frequency: double) -> result = c.ma_waveform_set_frequency
|
|
953
|
+
public foreign function waveform_set_type(p_waveform: ptr[waveform], type_: waveform_type) -> result = c.ma_waveform_set_type
|
|
954
|
+
public foreign function waveform_set_sample_rate(p_waveform: ptr[waveform], sample_rate: uint) -> result = c.ma_waveform_set_sample_rate
|
|
955
|
+
public foreign function pulsewave_config_init(format: format, channels: uint, sample_rate: uint, duty_cycle: double, amplitude: double, frequency: double) -> pulsewave_config = c.ma_pulsewave_config_init
|
|
956
|
+
public foreign function pulsewave_init(p_config: const_ptr[pulsewave_config], p_waveform: ptr[pulsewave]) -> result = c.ma_pulsewave_init
|
|
957
|
+
public foreign function pulsewave_uninit(p_waveform: ptr[pulsewave]) -> void = c.ma_pulsewave_uninit
|
|
958
|
+
public foreign function pulsewave_read_pcm_frames(p_waveform: ptr[pulsewave], p_frames_out: ptr[void], frame_count: ulong, p_frames_read: ptr[uint64]) -> result = c.ma_pulsewave_read_pcm_frames
|
|
959
|
+
public foreign function pulsewave_seek_to_pcm_frame(p_waveform: ptr[pulsewave], frame_index: ulong) -> result = c.ma_pulsewave_seek_to_pcm_frame
|
|
960
|
+
public foreign function pulsewave_set_amplitude(p_waveform: ptr[pulsewave], amplitude: double) -> result = c.ma_pulsewave_set_amplitude
|
|
961
|
+
public foreign function pulsewave_set_frequency(p_waveform: ptr[pulsewave], frequency: double) -> result = c.ma_pulsewave_set_frequency
|
|
962
|
+
public foreign function pulsewave_set_sample_rate(p_waveform: ptr[pulsewave], sample_rate: uint) -> result = c.ma_pulsewave_set_sample_rate
|
|
963
|
+
public foreign function pulsewave_set_duty_cycle(p_waveform: ptr[pulsewave], duty_cycle: double) -> result = c.ma_pulsewave_set_duty_cycle
|
|
964
|
+
public foreign function noise_config_init(format: format, channels: uint, type_: noise_type, seed: int, amplitude: double) -> noise_config = c.ma_noise_config_init
|
|
965
|
+
public foreign function noise_get_heap_size(p_config: const_ptr[noise_config], p_heap_size_in_bytes: ptr[ptr_uint]) -> result = c.ma_noise_get_heap_size
|
|
966
|
+
public foreign function noise_init_preallocated(p_config: const_ptr[noise_config], p_heap: ptr[void], p_noise: ptr[noise]) -> result = c.ma_noise_init_preallocated
|
|
967
|
+
public foreign function noise_init(p_config: const_ptr[noise_config], p_allocation_callbacks: const_ptr[allocation_callbacks], p_noise: ptr[noise]) -> result = c.ma_noise_init
|
|
968
|
+
public foreign function noise_uninit(p_noise: ptr[noise], p_allocation_callbacks: const_ptr[allocation_callbacks]) -> void = c.ma_noise_uninit
|
|
969
|
+
public foreign function noise_read_pcm_frames(p_noise: ptr[noise], p_frames_out: ptr[void], frame_count: ulong, p_frames_read: ptr[uint64]) -> result = c.ma_noise_read_pcm_frames
|
|
970
|
+
public foreign function noise_set_amplitude(p_noise: ptr[noise], amplitude: double) -> result = c.ma_noise_set_amplitude
|
|
971
|
+
public foreign function noise_set_seed(p_noise: ptr[noise], seed: int) -> result = c.ma_noise_set_seed
|
|
972
|
+
public foreign function noise_set_type(p_noise: ptr[noise], type_: noise_type) -> result = c.ma_noise_set_type
|
|
973
|
+
public foreign function resource_manager_pipeline_notifications_init() -> resource_manager_pipeline_notifications = c.ma_resource_manager_pipeline_notifications_init
|
|
974
|
+
public foreign function resource_manager_data_source_config_init() -> resource_manager_data_source_config = c.ma_resource_manager_data_source_config_init
|
|
975
|
+
public foreign function resource_manager_config_init() -> resource_manager_config = c.ma_resource_manager_config_init
|
|
976
|
+
public foreign function resource_manager_init(p_config: const_ptr[resource_manager_config], p_resource_manager: ptr[resource_manager]) -> result = c.ma_resource_manager_init
|
|
977
|
+
public foreign function resource_manager_uninit(p_resource_manager: ptr[resource_manager]) -> void = c.ma_resource_manager_uninit
|
|
978
|
+
public foreign function resource_manager_get_log(p_resource_manager: ptr[resource_manager]) -> ptr[log] = c.ma_resource_manager_get_log
|
|
979
|
+
public foreign function resource_manager_register_file(p_resource_manager: ptr[resource_manager], p_file_path: str as cstr, flags_: uint) -> result = c.ma_resource_manager_register_file
|
|
980
|
+
public foreign function resource_manager_register_file_w(p_resource_manager: ptr[resource_manager], p_file_path: const_ptr[int], flags_: uint) -> result = c.ma_resource_manager_register_file_w
|
|
981
|
+
public foreign function resource_manager_register_decoded_data(p_resource_manager: ptr[resource_manager], p_name: str as cstr, p_data: const_ptr[void], frame_count: ulong, format: format, channels: uint, sample_rate: uint) -> result = c.ma_resource_manager_register_decoded_data
|
|
982
|
+
public foreign function resource_manager_register_decoded_data_w(p_resource_manager: ptr[resource_manager], p_name: const_ptr[int], p_data: const_ptr[void], frame_count: ulong, format: format, channels: uint, sample_rate: uint) -> result = c.ma_resource_manager_register_decoded_data_w
|
|
983
|
+
public foreign function resource_manager_register_encoded_data(p_resource_manager: ptr[resource_manager], p_name: str as cstr, p_data: const_ptr[void], size_in_bytes: ptr_uint) -> result = c.ma_resource_manager_register_encoded_data
|
|
984
|
+
public foreign function resource_manager_register_encoded_data_w(p_resource_manager: ptr[resource_manager], p_name: const_ptr[int], p_data: const_ptr[void], size_in_bytes: ptr_uint) -> result = c.ma_resource_manager_register_encoded_data_w
|
|
985
|
+
public foreign function resource_manager_unregister_file(p_resource_manager: ptr[resource_manager], p_file_path: str as cstr) -> result = c.ma_resource_manager_unregister_file
|
|
986
|
+
public foreign function resource_manager_unregister_file_w(p_resource_manager: ptr[resource_manager], p_file_path: const_ptr[int]) -> result = c.ma_resource_manager_unregister_file_w
|
|
987
|
+
public foreign function resource_manager_unregister_data(p_resource_manager: ptr[resource_manager], p_name: str as cstr) -> result = c.ma_resource_manager_unregister_data
|
|
988
|
+
public foreign function resource_manager_unregister_data_w(p_resource_manager: ptr[resource_manager], p_name: const_ptr[int]) -> result = c.ma_resource_manager_unregister_data_w
|
|
989
|
+
public foreign function resource_manager_data_buffer_init_ex(p_resource_manager: ptr[resource_manager], p_config: const_ptr[resource_manager_data_source_config], p_data_buffer: ptr[resource_manager_data_buffer]) -> result = c.ma_resource_manager_data_buffer_init_ex
|
|
990
|
+
public foreign function resource_manager_data_buffer_init(p_resource_manager: ptr[resource_manager], p_file_path: str as cstr, flags_: uint, p_notifications: const_ptr[resource_manager_pipeline_notifications], p_data_buffer: ptr[resource_manager_data_buffer]) -> result = c.ma_resource_manager_data_buffer_init
|
|
991
|
+
public foreign function resource_manager_data_buffer_init_w(p_resource_manager: ptr[resource_manager], p_file_path: const_ptr[int], flags_: uint, p_notifications: const_ptr[resource_manager_pipeline_notifications], p_data_buffer: ptr[resource_manager_data_buffer]) -> result = c.ma_resource_manager_data_buffer_init_w
|
|
992
|
+
public foreign function resource_manager_data_buffer_init_copy(p_resource_manager: ptr[resource_manager], p_existing_data_buffer: const_ptr[resource_manager_data_buffer], p_data_buffer: ptr[resource_manager_data_buffer]) -> result = c.ma_resource_manager_data_buffer_init_copy
|
|
993
|
+
public foreign function resource_manager_data_buffer_uninit(p_data_buffer: ptr[resource_manager_data_buffer]) -> result = c.ma_resource_manager_data_buffer_uninit
|
|
994
|
+
public foreign function resource_manager_data_buffer_read_pcm_frames(p_data_buffer: ptr[resource_manager_data_buffer], p_frames_out: ptr[void], frame_count: ulong, p_frames_read: ptr[uint64]) -> result = c.ma_resource_manager_data_buffer_read_pcm_frames
|
|
995
|
+
public foreign function resource_manager_data_buffer_seek_to_pcm_frame(p_data_buffer: ptr[resource_manager_data_buffer], frame_index: ulong) -> result = c.ma_resource_manager_data_buffer_seek_to_pcm_frame
|
|
996
|
+
public foreign function resource_manager_data_buffer_get_data_format(p_data_buffer: ptr[resource_manager_data_buffer], p_format: ptr[format], p_channels: ptr[uint32], p_sample_rate: ptr[uint32], p_channel_map: ptr[channel], channel_map_cap: ptr_uint) -> result = c.ma_resource_manager_data_buffer_get_data_format
|
|
997
|
+
public foreign function resource_manager_data_buffer_get_cursor_in_pcm_frames(p_data_buffer: ptr[resource_manager_data_buffer], p_cursor: ptr[uint64]) -> result = c.ma_resource_manager_data_buffer_get_cursor_in_pcm_frames
|
|
998
|
+
public foreign function resource_manager_data_buffer_get_length_in_pcm_frames(p_data_buffer: ptr[resource_manager_data_buffer], p_length: ptr[uint64]) -> result = c.ma_resource_manager_data_buffer_get_length_in_pcm_frames
|
|
999
|
+
public foreign function resource_manager_data_buffer_result(p_data_buffer: const_ptr[resource_manager_data_buffer]) -> result = c.ma_resource_manager_data_buffer_result
|
|
1000
|
+
public foreign function resource_manager_data_buffer_set_looping(p_data_buffer: ptr[resource_manager_data_buffer], is_looping: uint) -> result = c.ma_resource_manager_data_buffer_set_looping
|
|
1001
|
+
public foreign function resource_manager_data_buffer_is_looping(p_data_buffer: const_ptr[resource_manager_data_buffer]) -> bool32 = c.ma_resource_manager_data_buffer_is_looping
|
|
1002
|
+
public foreign function resource_manager_data_buffer_get_available_frames(p_data_buffer: ptr[resource_manager_data_buffer], p_available_frames: ptr[uint64]) -> result = c.ma_resource_manager_data_buffer_get_available_frames
|
|
1003
|
+
public foreign function resource_manager_data_stream_init_ex(p_resource_manager: ptr[resource_manager], p_config: const_ptr[resource_manager_data_source_config], p_data_stream: ptr[resource_manager_data_stream]) -> result = c.ma_resource_manager_data_stream_init_ex
|
|
1004
|
+
public foreign function resource_manager_data_stream_init(p_resource_manager: ptr[resource_manager], p_file_path: str as cstr, flags_: uint, p_notifications: const_ptr[resource_manager_pipeline_notifications], p_data_stream: ptr[resource_manager_data_stream]) -> result = c.ma_resource_manager_data_stream_init
|
|
1005
|
+
public foreign function resource_manager_data_stream_init_w(p_resource_manager: ptr[resource_manager], p_file_path: const_ptr[int], flags_: uint, p_notifications: const_ptr[resource_manager_pipeline_notifications], p_data_stream: ptr[resource_manager_data_stream]) -> result = c.ma_resource_manager_data_stream_init_w
|
|
1006
|
+
public foreign function resource_manager_data_stream_uninit(p_data_stream: ptr[resource_manager_data_stream]) -> result = c.ma_resource_manager_data_stream_uninit
|
|
1007
|
+
public foreign function resource_manager_data_stream_read_pcm_frames(p_data_stream: ptr[resource_manager_data_stream], p_frames_out: ptr[void], frame_count: ulong, p_frames_read: ptr[uint64]) -> result = c.ma_resource_manager_data_stream_read_pcm_frames
|
|
1008
|
+
public foreign function resource_manager_data_stream_seek_to_pcm_frame(p_data_stream: ptr[resource_manager_data_stream], frame_index: ulong) -> result = c.ma_resource_manager_data_stream_seek_to_pcm_frame
|
|
1009
|
+
public foreign function resource_manager_data_stream_get_data_format(p_data_stream: ptr[resource_manager_data_stream], p_format: ptr[format], p_channels: ptr[uint32], p_sample_rate: ptr[uint32], p_channel_map: ptr[channel], channel_map_cap: ptr_uint) -> result = c.ma_resource_manager_data_stream_get_data_format
|
|
1010
|
+
public foreign function resource_manager_data_stream_get_cursor_in_pcm_frames(p_data_stream: ptr[resource_manager_data_stream], p_cursor: ptr[uint64]) -> result = c.ma_resource_manager_data_stream_get_cursor_in_pcm_frames
|
|
1011
|
+
public foreign function resource_manager_data_stream_get_length_in_pcm_frames(p_data_stream: ptr[resource_manager_data_stream], p_length: ptr[uint64]) -> result = c.ma_resource_manager_data_stream_get_length_in_pcm_frames
|
|
1012
|
+
public foreign function resource_manager_data_stream_result(p_data_stream: const_ptr[resource_manager_data_stream]) -> result = c.ma_resource_manager_data_stream_result
|
|
1013
|
+
public foreign function resource_manager_data_stream_set_looping(p_data_stream: ptr[resource_manager_data_stream], is_looping: uint) -> result = c.ma_resource_manager_data_stream_set_looping
|
|
1014
|
+
public foreign function resource_manager_data_stream_is_looping(p_data_stream: const_ptr[resource_manager_data_stream]) -> bool32 = c.ma_resource_manager_data_stream_is_looping
|
|
1015
|
+
public foreign function resource_manager_data_stream_get_available_frames(p_data_stream: ptr[resource_manager_data_stream], p_available_frames: ptr[uint64]) -> result = c.ma_resource_manager_data_stream_get_available_frames
|
|
1016
|
+
public foreign function resource_manager_data_source_init_ex(p_resource_manager: ptr[resource_manager], p_config: const_ptr[resource_manager_data_source_config], p_data_source: ptr[resource_manager_data_source]) -> result = c.ma_resource_manager_data_source_init_ex
|
|
1017
|
+
public foreign function resource_manager_data_source_init(p_resource_manager: ptr[resource_manager], p_name: str as cstr, flags_: uint, p_notifications: const_ptr[resource_manager_pipeline_notifications], p_data_source: ptr[resource_manager_data_source]) -> result = c.ma_resource_manager_data_source_init
|
|
1018
|
+
public foreign function resource_manager_data_source_init_w(p_resource_manager: ptr[resource_manager], p_name: const_ptr[int], flags_: uint, p_notifications: const_ptr[resource_manager_pipeline_notifications], p_data_source: ptr[resource_manager_data_source]) -> result = c.ma_resource_manager_data_source_init_w
|
|
1019
|
+
public foreign function resource_manager_data_source_init_copy(p_resource_manager: ptr[resource_manager], p_existing_data_source: const_ptr[resource_manager_data_source], p_data_source: ptr[resource_manager_data_source]) -> result = c.ma_resource_manager_data_source_init_copy
|
|
1020
|
+
public foreign function resource_manager_data_source_uninit(p_data_source: ptr[resource_manager_data_source]) -> result = c.ma_resource_manager_data_source_uninit
|
|
1021
|
+
public foreign function resource_manager_data_source_read_pcm_frames(p_data_source: ptr[resource_manager_data_source], p_frames_out: ptr[void], frame_count: ulong, p_frames_read: ptr[uint64]) -> result = c.ma_resource_manager_data_source_read_pcm_frames
|
|
1022
|
+
public foreign function resource_manager_data_source_seek_to_pcm_frame(p_data_source: ptr[resource_manager_data_source], frame_index: ulong) -> result = c.ma_resource_manager_data_source_seek_to_pcm_frame
|
|
1023
|
+
public foreign function resource_manager_data_source_get_data_format(p_data_source: ptr[resource_manager_data_source], p_format: ptr[format], p_channels: ptr[uint32], p_sample_rate: ptr[uint32], p_channel_map: ptr[channel], channel_map_cap: ptr_uint) -> result = c.ma_resource_manager_data_source_get_data_format
|
|
1024
|
+
public foreign function resource_manager_data_source_get_cursor_in_pcm_frames(p_data_source: ptr[resource_manager_data_source], p_cursor: ptr[uint64]) -> result = c.ma_resource_manager_data_source_get_cursor_in_pcm_frames
|
|
1025
|
+
public foreign function resource_manager_data_source_get_length_in_pcm_frames(p_data_source: ptr[resource_manager_data_source], p_length: ptr[uint64]) -> result = c.ma_resource_manager_data_source_get_length_in_pcm_frames
|
|
1026
|
+
public foreign function resource_manager_data_source_result(p_data_source: const_ptr[resource_manager_data_source]) -> result = c.ma_resource_manager_data_source_result
|
|
1027
|
+
public foreign function resource_manager_data_source_set_looping(p_data_source: ptr[resource_manager_data_source], is_looping: uint) -> result = c.ma_resource_manager_data_source_set_looping
|
|
1028
|
+
public foreign function resource_manager_data_source_is_looping(p_data_source: const_ptr[resource_manager_data_source]) -> bool32 = c.ma_resource_manager_data_source_is_looping
|
|
1029
|
+
public foreign function resource_manager_data_source_get_available_frames(p_data_source: ptr[resource_manager_data_source], p_available_frames: ptr[uint64]) -> result = c.ma_resource_manager_data_source_get_available_frames
|
|
1030
|
+
public foreign function resource_manager_post_job(p_resource_manager: ptr[resource_manager], p_job: const_ptr[job]) -> result = c.ma_resource_manager_post_job
|
|
1031
|
+
public foreign function resource_manager_post_job_quit(p_resource_manager: ptr[resource_manager]) -> result = c.ma_resource_manager_post_job_quit
|
|
1032
|
+
public foreign function resource_manager_next_job(p_resource_manager: ptr[resource_manager], p_job: ptr[job]) -> result = c.ma_resource_manager_next_job
|
|
1033
|
+
public foreign function resource_manager_process_job(p_resource_manager: ptr[resource_manager], p_job: ptr[job]) -> result = c.ma_resource_manager_process_job
|
|
1034
|
+
public foreign function resource_manager_process_next_job(p_resource_manager: ptr[resource_manager]) -> result = c.ma_resource_manager_process_next_job
|
|
1035
|
+
public foreign function node_config_init() -> node_config = c.ma_node_config_init
|
|
1036
|
+
public foreign function node_get_heap_size(p_node_graph: ptr[node_graph], p_config: const_ptr[node_config], p_heap_size_in_bytes: ptr[ptr_uint]) -> result = c.ma_node_get_heap_size
|
|
1037
|
+
public foreign function node_init_preallocated(p_node_graph: ptr[node_graph], p_config: const_ptr[node_config], p_heap: ptr[void], p_node: ptr[node]) -> result = c.ma_node_init_preallocated
|
|
1038
|
+
public foreign function node_init(p_node_graph: ptr[node_graph], p_config: const_ptr[node_config], p_allocation_callbacks: const_ptr[allocation_callbacks], p_node: ptr[node]) -> result = c.ma_node_init
|
|
1039
|
+
public foreign function node_uninit(p_node: ptr[node], p_allocation_callbacks: const_ptr[allocation_callbacks]) -> void = c.ma_node_uninit
|
|
1040
|
+
public foreign function node_get_node_graph(p_node: const_ptr[node]) -> ptr[node_graph] = c.ma_node_get_node_graph
|
|
1041
|
+
public foreign function node_get_input_bus_count(p_node: const_ptr[node]) -> uint32 = c.ma_node_get_input_bus_count
|
|
1042
|
+
public foreign function node_get_output_bus_count(p_node: const_ptr[node]) -> uint32 = c.ma_node_get_output_bus_count
|
|
1043
|
+
public foreign function node_get_input_channels(p_node: const_ptr[node], input_bus_index: uint) -> uint32 = c.ma_node_get_input_channels
|
|
1044
|
+
public foreign function node_get_output_channels(p_node: const_ptr[node], output_bus_index: uint) -> uint32 = c.ma_node_get_output_channels
|
|
1045
|
+
public foreign function node_attach_output_bus(p_node: ptr[node], output_bus_index: uint, p_other_node: ptr[node], other_node_input_bus_index: uint) -> result = c.ma_node_attach_output_bus
|
|
1046
|
+
public foreign function node_detach_output_bus(p_node: ptr[node], output_bus_index: uint) -> result = c.ma_node_detach_output_bus
|
|
1047
|
+
public foreign function node_detach_all_output_buses(p_node: ptr[node]) -> result = c.ma_node_detach_all_output_buses
|
|
1048
|
+
public foreign function node_set_output_bus_volume(p_node: ptr[node], output_bus_index: uint, volume: float) -> result = c.ma_node_set_output_bus_volume
|
|
1049
|
+
public foreign function node_get_output_bus_volume(p_node: const_ptr[node], output_bus_index: uint) -> float = c.ma_node_get_output_bus_volume
|
|
1050
|
+
public foreign function node_set_state(p_node: ptr[node], state: node_state) -> result = c.ma_node_set_state
|
|
1051
|
+
public foreign function node_get_state(p_node: const_ptr[node]) -> node_state = c.ma_node_get_state
|
|
1052
|
+
public foreign function node_set_state_time(p_node: ptr[node], state: node_state, global_time: ulong) -> result = c.ma_node_set_state_time
|
|
1053
|
+
public foreign function node_get_state_time(p_node: const_ptr[node], state: node_state) -> uint64 = c.ma_node_get_state_time
|
|
1054
|
+
public foreign function node_get_state_by_time(p_node: const_ptr[node], global_time: ulong) -> node_state = c.ma_node_get_state_by_time
|
|
1055
|
+
public foreign function node_get_state_by_time_range(p_node: const_ptr[node], global_time_beg: ulong, global_time_end: ulong) -> node_state = c.ma_node_get_state_by_time_range
|
|
1056
|
+
public foreign function node_get_time(p_node: const_ptr[node]) -> uint64 = c.ma_node_get_time
|
|
1057
|
+
public foreign function node_set_time(p_node: ptr[node], local_time: ulong) -> result = c.ma_node_set_time
|
|
1058
|
+
public foreign function node_graph_config_init(channels: uint) -> node_graph_config = c.ma_node_graph_config_init
|
|
1059
|
+
public foreign function node_graph_init(p_config: const_ptr[node_graph_config], p_allocation_callbacks: const_ptr[allocation_callbacks], p_node_graph: ptr[node_graph]) -> result = c.ma_node_graph_init
|
|
1060
|
+
public foreign function node_graph_uninit(p_node_graph: ptr[node_graph], p_allocation_callbacks: const_ptr[allocation_callbacks]) -> void = c.ma_node_graph_uninit
|
|
1061
|
+
public foreign function node_graph_get_endpoint(p_node_graph: ptr[node_graph]) -> ptr[node] = c.ma_node_graph_get_endpoint
|
|
1062
|
+
public foreign function node_graph_read_pcm_frames(p_node_graph: ptr[node_graph], p_frames_out: ptr[void], frame_count: ulong, p_frames_read: ptr[uint64]) -> result = c.ma_node_graph_read_pcm_frames
|
|
1063
|
+
public foreign function node_graph_get_channels(p_node_graph: const_ptr[node_graph]) -> uint32 = c.ma_node_graph_get_channels
|
|
1064
|
+
public foreign function node_graph_get_time(p_node_graph: const_ptr[node_graph]) -> uint64 = c.ma_node_graph_get_time
|
|
1065
|
+
public foreign function node_graph_set_time(p_node_graph: ptr[node_graph], global_time: ulong) -> result = c.ma_node_graph_set_time
|
|
1066
|
+
public foreign function node_graph_get_processing_size_in_frames(p_node_graph: const_ptr[node_graph]) -> uint32 = c.ma_node_graph_get_processing_size_in_frames
|
|
1067
|
+
public foreign function data_source_node_config_init(p_data_source: ptr[data_source]) -> data_source_node_config = c.ma_data_source_node_config_init
|
|
1068
|
+
public foreign function data_source_node_init(p_node_graph: ptr[node_graph], p_config: const_ptr[data_source_node_config], p_allocation_callbacks: const_ptr[allocation_callbacks], p_data_source_node: ptr[data_source_node]) -> result = c.ma_data_source_node_init
|
|
1069
|
+
public foreign function data_source_node_uninit(p_data_source_node: ptr[data_source_node], p_allocation_callbacks: const_ptr[allocation_callbacks]) -> void = c.ma_data_source_node_uninit
|
|
1070
|
+
public foreign function data_source_node_set_looping(p_data_source_node: ptr[data_source_node], is_looping: uint) -> result = c.ma_data_source_node_set_looping
|
|
1071
|
+
public foreign function data_source_node_is_looping(p_data_source_node: ptr[data_source_node]) -> bool32 = c.ma_data_source_node_is_looping
|
|
1072
|
+
public foreign function splitter_node_config_init(channels: uint) -> splitter_node_config = c.ma_splitter_node_config_init
|
|
1073
|
+
public foreign function splitter_node_init(p_node_graph: ptr[node_graph], p_config: const_ptr[splitter_node_config], p_allocation_callbacks: const_ptr[allocation_callbacks], p_splitter_node: ptr[splitter_node]) -> result = c.ma_splitter_node_init
|
|
1074
|
+
public foreign function splitter_node_uninit(p_splitter_node: ptr[splitter_node], p_allocation_callbacks: const_ptr[allocation_callbacks]) -> void = c.ma_splitter_node_uninit
|
|
1075
|
+
public foreign function biquad_node_config_init(channels: uint, b0: float, b1: float, b2: float, a0: float, a1: float, a2: float) -> biquad_node_config = c.ma_biquad_node_config_init
|
|
1076
|
+
public foreign function biquad_node_init(p_node_graph: ptr[node_graph], p_config: const_ptr[biquad_node_config], p_allocation_callbacks: const_ptr[allocation_callbacks], p_node: ptr[biquad_node]) -> result = c.ma_biquad_node_init
|
|
1077
|
+
public foreign function biquad_node_reinit(p_config: const_ptr[biquad_config], p_node: ptr[biquad_node]) -> result = c.ma_biquad_node_reinit
|
|
1078
|
+
public foreign function biquad_node_uninit(p_node: ptr[biquad_node], p_allocation_callbacks: const_ptr[allocation_callbacks]) -> void = c.ma_biquad_node_uninit
|
|
1079
|
+
public foreign function lpf_node_config_init(channels: uint, sample_rate: uint, cutoff_frequency: double, order: uint) -> lpf_node_config = c.ma_lpf_node_config_init
|
|
1080
|
+
public foreign function lpf_node_init(p_node_graph: ptr[node_graph], p_config: const_ptr[lpf_node_config], p_allocation_callbacks: const_ptr[allocation_callbacks], p_node: ptr[lpf_node]) -> result = c.ma_lpf_node_init
|
|
1081
|
+
public foreign function lpf_node_reinit(p_config: const_ptr[lpf_config], p_node: ptr[lpf_node]) -> result = c.ma_lpf_node_reinit
|
|
1082
|
+
public foreign function lpf_node_uninit(p_node: ptr[lpf_node], p_allocation_callbacks: const_ptr[allocation_callbacks]) -> void = c.ma_lpf_node_uninit
|
|
1083
|
+
public foreign function hpf_node_config_init(channels: uint, sample_rate: uint, cutoff_frequency: double, order: uint) -> hpf_node_config = c.ma_hpf_node_config_init
|
|
1084
|
+
public foreign function hpf_node_init(p_node_graph: ptr[node_graph], p_config: const_ptr[hpf_node_config], p_allocation_callbacks: const_ptr[allocation_callbacks], p_node: ptr[hpf_node]) -> result = c.ma_hpf_node_init
|
|
1085
|
+
public foreign function hpf_node_reinit(p_config: const_ptr[hpf_config], p_node: ptr[hpf_node]) -> result = c.ma_hpf_node_reinit
|
|
1086
|
+
public foreign function hpf_node_uninit(p_node: ptr[hpf_node], p_allocation_callbacks: const_ptr[allocation_callbacks]) -> void = c.ma_hpf_node_uninit
|
|
1087
|
+
public foreign function bpf_node_config_init(channels: uint, sample_rate: uint, cutoff_frequency: double, order: uint) -> bpf_node_config = c.ma_bpf_node_config_init
|
|
1088
|
+
public foreign function bpf_node_init(p_node_graph: ptr[node_graph], p_config: const_ptr[bpf_node_config], p_allocation_callbacks: const_ptr[allocation_callbacks], p_node: ptr[bpf_node]) -> result = c.ma_bpf_node_init
|
|
1089
|
+
public foreign function bpf_node_reinit(p_config: const_ptr[bpf_config], p_node: ptr[bpf_node]) -> result = c.ma_bpf_node_reinit
|
|
1090
|
+
public foreign function bpf_node_uninit(p_node: ptr[bpf_node], p_allocation_callbacks: const_ptr[allocation_callbacks]) -> void = c.ma_bpf_node_uninit
|
|
1091
|
+
public foreign function notch_node_config_init(channels: uint, sample_rate: uint, q: double, frequency: double) -> notch_node_config = c.ma_notch_node_config_init
|
|
1092
|
+
public foreign function notch_node_init(p_node_graph: ptr[node_graph], p_config: const_ptr[notch_node_config], p_allocation_callbacks: const_ptr[allocation_callbacks], p_node: ptr[notch_node]) -> result = c.ma_notch_node_init
|
|
1093
|
+
public foreign function notch_node_reinit(p_config: const_ptr[notch_config], p_node: ptr[notch_node]) -> result = c.ma_notch_node_reinit
|
|
1094
|
+
public foreign function notch_node_uninit(p_node: ptr[notch_node], p_allocation_callbacks: const_ptr[allocation_callbacks]) -> void = c.ma_notch_node_uninit
|
|
1095
|
+
public foreign function peak_node_config_init(channels: uint, sample_rate: uint, gain_db: double, q: double, frequency: double) -> peak_node_config = c.ma_peak_node_config_init
|
|
1096
|
+
public foreign function peak_node_init(p_node_graph: ptr[node_graph], p_config: const_ptr[peak_node_config], p_allocation_callbacks: const_ptr[allocation_callbacks], p_node: ptr[peak_node]) -> result = c.ma_peak_node_init
|
|
1097
|
+
public foreign function peak_node_reinit(p_config: const_ptr[peak_config], p_node: ptr[peak_node]) -> result = c.ma_peak_node_reinit
|
|
1098
|
+
public foreign function peak_node_uninit(p_node: ptr[peak_node], p_allocation_callbacks: const_ptr[allocation_callbacks]) -> void = c.ma_peak_node_uninit
|
|
1099
|
+
public foreign function loshelf_node_config_init(channels: uint, sample_rate: uint, gain_db: double, q: double, frequency: double) -> loshelf_node_config = c.ma_loshelf_node_config_init
|
|
1100
|
+
public foreign function loshelf_node_init(p_node_graph: ptr[node_graph], p_config: const_ptr[loshelf_node_config], p_allocation_callbacks: const_ptr[allocation_callbacks], p_node: ptr[loshelf_node]) -> result = c.ma_loshelf_node_init
|
|
1101
|
+
public foreign function loshelf_node_reinit(p_config: const_ptr[loshelf_config], p_node: ptr[loshelf_node]) -> result = c.ma_loshelf_node_reinit
|
|
1102
|
+
public foreign function loshelf_node_uninit(p_node: ptr[loshelf_node], p_allocation_callbacks: const_ptr[allocation_callbacks]) -> void = c.ma_loshelf_node_uninit
|
|
1103
|
+
public foreign function hishelf_node_config_init(channels: uint, sample_rate: uint, gain_db: double, q: double, frequency: double) -> hishelf_node_config = c.ma_hishelf_node_config_init
|
|
1104
|
+
public foreign function hishelf_node_init(p_node_graph: ptr[node_graph], p_config: const_ptr[hishelf_node_config], p_allocation_callbacks: const_ptr[allocation_callbacks], p_node: ptr[hishelf_node]) -> result = c.ma_hishelf_node_init
|
|
1105
|
+
public foreign function hishelf_node_reinit(p_config: const_ptr[hishelf_config], p_node: ptr[hishelf_node]) -> result = c.ma_hishelf_node_reinit
|
|
1106
|
+
public foreign function hishelf_node_uninit(p_node: ptr[hishelf_node], p_allocation_callbacks: const_ptr[allocation_callbacks]) -> void = c.ma_hishelf_node_uninit
|
|
1107
|
+
public foreign function delay_node_config_init(channels: uint, sample_rate: uint, delay_in_frames: uint, decay: float) -> delay_node_config = c.ma_delay_node_config_init
|
|
1108
|
+
public foreign function delay_node_init(p_node_graph: ptr[node_graph], p_config: const_ptr[delay_node_config], p_allocation_callbacks: const_ptr[allocation_callbacks], p_delay_node: ptr[delay_node]) -> result = c.ma_delay_node_init
|
|
1109
|
+
public foreign function delay_node_uninit(p_delay_node: ptr[delay_node], p_allocation_callbacks: const_ptr[allocation_callbacks]) -> void = c.ma_delay_node_uninit
|
|
1110
|
+
public foreign function delay_node_set_wet(p_delay_node: ptr[delay_node], value: float) -> void = c.ma_delay_node_set_wet
|
|
1111
|
+
public foreign function delay_node_get_wet(p_delay_node: const_ptr[delay_node]) -> float = c.ma_delay_node_get_wet
|
|
1112
|
+
public foreign function delay_node_set_dry(p_delay_node: ptr[delay_node], value: float) -> void = c.ma_delay_node_set_dry
|
|
1113
|
+
public foreign function delay_node_get_dry(p_delay_node: const_ptr[delay_node]) -> float = c.ma_delay_node_get_dry
|
|
1114
|
+
public foreign function delay_node_set_decay(p_delay_node: ptr[delay_node], value: float) -> void = c.ma_delay_node_set_decay
|
|
1115
|
+
public foreign function delay_node_get_decay(p_delay_node: const_ptr[delay_node]) -> float = c.ma_delay_node_get_decay
|
|
1116
|
+
public foreign function engine_node_config_init(p_engine: ptr[engine], type_: engine_node_type, flags_: uint) -> engine_node_config = c.ma_engine_node_config_init
|
|
1117
|
+
public foreign function engine_node_get_heap_size(p_config: const_ptr[engine_node_config], p_heap_size_in_bytes: ptr[ptr_uint]) -> result = c.ma_engine_node_get_heap_size
|
|
1118
|
+
public foreign function engine_node_init_preallocated(p_config: const_ptr[engine_node_config], p_heap: ptr[void], p_engine_node: ptr[engine_node]) -> result = c.ma_engine_node_init_preallocated
|
|
1119
|
+
public foreign function engine_node_init(p_config: const_ptr[engine_node_config], p_allocation_callbacks: const_ptr[allocation_callbacks], p_engine_node: ptr[engine_node]) -> result = c.ma_engine_node_init
|
|
1120
|
+
public foreign function engine_node_uninit(p_engine_node: ptr[engine_node], p_allocation_callbacks: const_ptr[allocation_callbacks]) -> void = c.ma_engine_node_uninit
|
|
1121
|
+
public foreign function sound_config_init() -> sound_config = c.ma_sound_config_init
|
|
1122
|
+
public foreign function sound_config_init_2(p_engine: ptr[engine]) -> sound_config = c.ma_sound_config_init_2
|
|
1123
|
+
public foreign function sound_group_config_init() -> sound_group_config = c.ma_sound_group_config_init
|
|
1124
|
+
public foreign function sound_group_config_init_2(p_engine: ptr[engine]) -> sound_group_config = c.ma_sound_group_config_init_2
|
|
1125
|
+
public foreign function engine_config_init() -> engine_config = c.ma_engine_config_init
|
|
1126
|
+
public foreign function engine_init(p_config: const_ptr[engine_config], p_engine: ptr[engine]) -> result = c.ma_engine_init
|
|
1127
|
+
public foreign function engine_uninit(p_engine: ptr[engine]) -> void = c.ma_engine_uninit
|
|
1128
|
+
public foreign function engine_read_pcm_frames(p_engine: ptr[engine], p_frames_out: ptr[void], frame_count: ulong, p_frames_read: ptr[uint64]) -> result = c.ma_engine_read_pcm_frames
|
|
1129
|
+
public foreign function engine_get_node_graph(p_engine: ptr[engine]) -> ptr[node_graph] = c.ma_engine_get_node_graph
|
|
1130
|
+
public foreign function engine_get_resource_manager(p_engine: ptr[engine]) -> ptr[resource_manager] = c.ma_engine_get_resource_manager
|
|
1131
|
+
public foreign function engine_get_device(p_engine: ptr[engine]) -> ptr[device] = c.ma_engine_get_device
|
|
1132
|
+
public foreign function engine_get_log(p_engine: ptr[engine]) -> ptr[log] = c.ma_engine_get_log
|
|
1133
|
+
public foreign function engine_get_endpoint(p_engine: ptr[engine]) -> ptr[node] = c.ma_engine_get_endpoint
|
|
1134
|
+
public foreign function engine_get_time_in_pcm_frames(p_engine: const_ptr[engine]) -> uint64 = c.ma_engine_get_time_in_pcm_frames
|
|
1135
|
+
public foreign function engine_get_time_in_milliseconds(p_engine: const_ptr[engine]) -> uint64 = c.ma_engine_get_time_in_milliseconds
|
|
1136
|
+
public foreign function engine_set_time_in_pcm_frames(p_engine: ptr[engine], global_time: ulong) -> result = c.ma_engine_set_time_in_pcm_frames
|
|
1137
|
+
public foreign function engine_set_time_in_milliseconds(p_engine: ptr[engine], global_time: ulong) -> result = c.ma_engine_set_time_in_milliseconds
|
|
1138
|
+
public foreign function engine_get_time(p_engine: const_ptr[engine]) -> uint64 = c.ma_engine_get_time
|
|
1139
|
+
public foreign function engine_set_time(p_engine: ptr[engine], global_time: ulong) -> result = c.ma_engine_set_time
|
|
1140
|
+
public foreign function engine_get_channels(p_engine: const_ptr[engine]) -> uint32 = c.ma_engine_get_channels
|
|
1141
|
+
public foreign function engine_get_sample_rate(p_engine: const_ptr[engine]) -> uint32 = c.ma_engine_get_sample_rate
|
|
1142
|
+
public foreign function engine_start(p_engine: ptr[engine]) -> result = c.ma_engine_start
|
|
1143
|
+
public foreign function engine_stop(p_engine: ptr[engine]) -> result = c.ma_engine_stop
|
|
1144
|
+
public foreign function engine_set_volume(p_engine: ptr[engine], volume: float) -> result = c.ma_engine_set_volume
|
|
1145
|
+
public foreign function engine_get_volume(p_engine: ptr[engine]) -> float = c.ma_engine_get_volume
|
|
1146
|
+
public foreign function engine_set_gain_db(p_engine: ptr[engine], gain_db: float) -> result = c.ma_engine_set_gain_db
|
|
1147
|
+
public foreign function engine_get_gain_db(p_engine: ptr[engine]) -> float = c.ma_engine_get_gain_db
|
|
1148
|
+
public foreign function engine_get_listener_count(p_engine: const_ptr[engine]) -> uint32 = c.ma_engine_get_listener_count
|
|
1149
|
+
public foreign function engine_find_closest_listener(p_engine: const_ptr[engine], absolute_pos_x: float, absolute_pos_y: float, absolute_pos_z: float) -> uint32 = c.ma_engine_find_closest_listener
|
|
1150
|
+
public foreign function engine_listener_set_position(p_engine: ptr[engine], listener_index: uint, x: float, y: float, z: float) -> void = c.ma_engine_listener_set_position
|
|
1151
|
+
public foreign function engine_listener_get_position(p_engine: const_ptr[engine], listener_index: uint) -> vec3f = c.ma_engine_listener_get_position
|
|
1152
|
+
public foreign function engine_listener_set_direction(p_engine: ptr[engine], listener_index: uint, x: float, y: float, z: float) -> void = c.ma_engine_listener_set_direction
|
|
1153
|
+
public foreign function engine_listener_get_direction(p_engine: const_ptr[engine], listener_index: uint) -> vec3f = c.ma_engine_listener_get_direction
|
|
1154
|
+
public foreign function engine_listener_set_velocity(p_engine: ptr[engine], listener_index: uint, x: float, y: float, z: float) -> void = c.ma_engine_listener_set_velocity
|
|
1155
|
+
public foreign function engine_listener_get_velocity(p_engine: const_ptr[engine], listener_index: uint) -> vec3f = c.ma_engine_listener_get_velocity
|
|
1156
|
+
public foreign function engine_listener_set_cone(p_engine: ptr[engine], listener_index: uint, inner_angle_in_radians: float, outer_angle_in_radians: float, outer_gain: float) -> void = c.ma_engine_listener_set_cone
|
|
1157
|
+
public foreign function engine_listener_get_cone(p_engine: const_ptr[engine], listener_index: uint, p_inner_angle_in_radians: ptr[float], p_outer_angle_in_radians: ptr[float], p_outer_gain: ptr[float]) -> void = c.ma_engine_listener_get_cone
|
|
1158
|
+
public foreign function engine_listener_set_world_up(p_engine: ptr[engine], listener_index: uint, x: float, y: float, z: float) -> void = c.ma_engine_listener_set_world_up
|
|
1159
|
+
public foreign function engine_listener_get_world_up(p_engine: const_ptr[engine], listener_index: uint) -> vec3f = c.ma_engine_listener_get_world_up
|
|
1160
|
+
public foreign function engine_listener_set_enabled(p_engine: ptr[engine], listener_index: uint, is_enabled: uint) -> void = c.ma_engine_listener_set_enabled
|
|
1161
|
+
public foreign function engine_listener_is_enabled(p_engine: const_ptr[engine], listener_index: uint) -> bool32 = c.ma_engine_listener_is_enabled
|
|
1162
|
+
public foreign function engine_play_sound_ex(p_engine: ptr[engine], p_file_path: str as cstr, p_node: ptr[node], node_input_bus_index: uint) -> result = c.ma_engine_play_sound_ex
|
|
1163
|
+
public foreign function engine_play_sound(p_engine: ptr[engine], p_file_path: str as cstr, p_group: ptr[sound_group]) -> result = c.ma_engine_play_sound
|
|
1164
|
+
public foreign function sound_init_from_file(p_engine: ptr[engine], p_file_path: str as cstr, flags_: uint, p_group: ptr[sound_group], p_done_fence: ptr[fence], p_sound: ptr[sound]) -> result = c.ma_sound_init_from_file
|
|
1165
|
+
public foreign function sound_init_from_file_w(p_engine: ptr[engine], p_file_path: const_ptr[int], flags_: uint, p_group: ptr[sound_group], p_done_fence: ptr[fence], p_sound: ptr[sound]) -> result = c.ma_sound_init_from_file_w
|
|
1166
|
+
public foreign function sound_init_copy(p_engine: ptr[engine], p_existing_sound: const_ptr[sound], flags_: uint, p_group: ptr[sound_group], p_sound: ptr[sound]) -> result = c.ma_sound_init_copy
|
|
1167
|
+
public foreign function sound_init_from_data_source(p_engine: ptr[engine], p_data_source: ptr[data_source], flags_: uint, p_group: ptr[sound_group], p_sound: ptr[sound]) -> result = c.ma_sound_init_from_data_source
|
|
1168
|
+
public foreign function sound_init_ex(p_engine: ptr[engine], p_config: const_ptr[sound_config], p_sound: ptr[sound]) -> result = c.ma_sound_init_ex
|
|
1169
|
+
public foreign function sound_uninit(p_sound: ptr[sound]) -> void = c.ma_sound_uninit
|
|
1170
|
+
public foreign function sound_get_engine(p_sound: const_ptr[sound]) -> ptr[engine] = c.ma_sound_get_engine
|
|
1171
|
+
public foreign function sound_get_data_source(p_sound: const_ptr[sound]) -> ptr[data_source] = c.ma_sound_get_data_source
|
|
1172
|
+
public foreign function sound_start(p_sound: ptr[sound]) -> result = c.ma_sound_start
|
|
1173
|
+
public foreign function sound_stop(p_sound: ptr[sound]) -> result = c.ma_sound_stop
|
|
1174
|
+
public foreign function sound_stop_with_fade_in_pcm_frames(p_sound: ptr[sound], fade_length_in_frames: ulong) -> result = c.ma_sound_stop_with_fade_in_pcm_frames
|
|
1175
|
+
public foreign function sound_stop_with_fade_in_milliseconds(p_sound: ptr[sound], fade_length_in_frames: ulong) -> result = c.ma_sound_stop_with_fade_in_milliseconds
|
|
1176
|
+
public foreign function sound_reset_start_time(p_sound: ptr[sound]) -> void = c.ma_sound_reset_start_time
|
|
1177
|
+
public foreign function sound_reset_stop_time(p_sound: ptr[sound]) -> void = c.ma_sound_reset_stop_time
|
|
1178
|
+
public foreign function sound_reset_fade(p_sound: ptr[sound]) -> void = c.ma_sound_reset_fade
|
|
1179
|
+
public foreign function sound_reset_stop_time_and_fade(p_sound: ptr[sound]) -> void = c.ma_sound_reset_stop_time_and_fade
|
|
1180
|
+
public foreign function sound_set_volume(p_sound: ptr[sound], volume: float) -> void = c.ma_sound_set_volume
|
|
1181
|
+
public foreign function sound_get_volume(p_sound: const_ptr[sound]) -> float = c.ma_sound_get_volume
|
|
1182
|
+
public foreign function sound_set_pan(p_sound: ptr[sound], pan: float) -> void = c.ma_sound_set_pan
|
|
1183
|
+
public foreign function sound_get_pan(p_sound: const_ptr[sound]) -> float = c.ma_sound_get_pan
|
|
1184
|
+
public foreign function sound_set_pan_mode(p_sound: ptr[sound], pan_mode: pan_mode) -> void = c.ma_sound_set_pan_mode
|
|
1185
|
+
public foreign function sound_get_pan_mode(p_sound: const_ptr[sound]) -> pan_mode = c.ma_sound_get_pan_mode
|
|
1186
|
+
public foreign function sound_set_pitch(p_sound: ptr[sound], pitch: float) -> void = c.ma_sound_set_pitch
|
|
1187
|
+
public foreign function sound_get_pitch(p_sound: const_ptr[sound]) -> float = c.ma_sound_get_pitch
|
|
1188
|
+
public foreign function sound_set_spatialization_enabled(p_sound: ptr[sound], enabled: uint) -> void = c.ma_sound_set_spatialization_enabled
|
|
1189
|
+
public foreign function sound_is_spatialization_enabled(p_sound: const_ptr[sound]) -> bool32 = c.ma_sound_is_spatialization_enabled
|
|
1190
|
+
public foreign function sound_set_pinned_listener_index(p_sound: ptr[sound], listener_index: uint) -> void = c.ma_sound_set_pinned_listener_index
|
|
1191
|
+
public foreign function sound_get_pinned_listener_index(p_sound: const_ptr[sound]) -> uint32 = c.ma_sound_get_pinned_listener_index
|
|
1192
|
+
public foreign function sound_get_listener_index(p_sound: const_ptr[sound]) -> uint32 = c.ma_sound_get_listener_index
|
|
1193
|
+
public foreign function sound_get_direction_to_listener(p_sound: const_ptr[sound]) -> vec3f = c.ma_sound_get_direction_to_listener
|
|
1194
|
+
public foreign function sound_set_position(p_sound: ptr[sound], x: float, y: float, z: float) -> void = c.ma_sound_set_position
|
|
1195
|
+
public foreign function sound_get_position(p_sound: const_ptr[sound]) -> vec3f = c.ma_sound_get_position
|
|
1196
|
+
public foreign function sound_set_direction(p_sound: ptr[sound], x: float, y: float, z: float) -> void = c.ma_sound_set_direction
|
|
1197
|
+
public foreign function sound_get_direction(p_sound: const_ptr[sound]) -> vec3f = c.ma_sound_get_direction
|
|
1198
|
+
public foreign function sound_set_velocity(p_sound: ptr[sound], x: float, y: float, z: float) -> void = c.ma_sound_set_velocity
|
|
1199
|
+
public foreign function sound_get_velocity(p_sound: const_ptr[sound]) -> vec3f = c.ma_sound_get_velocity
|
|
1200
|
+
public foreign function sound_set_attenuation_model(p_sound: ptr[sound], attenuation_model: attenuation_model) -> void = c.ma_sound_set_attenuation_model
|
|
1201
|
+
public foreign function sound_get_attenuation_model(p_sound: const_ptr[sound]) -> attenuation_model = c.ma_sound_get_attenuation_model
|
|
1202
|
+
public foreign function sound_set_positioning(p_sound: ptr[sound], positioning: positioning) -> void = c.ma_sound_set_positioning
|
|
1203
|
+
public foreign function sound_get_positioning(p_sound: const_ptr[sound]) -> positioning = c.ma_sound_get_positioning
|
|
1204
|
+
public foreign function sound_set_rolloff(p_sound: ptr[sound], rolloff: float) -> void = c.ma_sound_set_rolloff
|
|
1205
|
+
public foreign function sound_get_rolloff(p_sound: const_ptr[sound]) -> float = c.ma_sound_get_rolloff
|
|
1206
|
+
public foreign function sound_set_min_gain(p_sound: ptr[sound], min_gain: float) -> void = c.ma_sound_set_min_gain
|
|
1207
|
+
public foreign function sound_get_min_gain(p_sound: const_ptr[sound]) -> float = c.ma_sound_get_min_gain
|
|
1208
|
+
public foreign function sound_set_max_gain(p_sound: ptr[sound], max_gain: float) -> void = c.ma_sound_set_max_gain
|
|
1209
|
+
public foreign function sound_get_max_gain(p_sound: const_ptr[sound]) -> float = c.ma_sound_get_max_gain
|
|
1210
|
+
public foreign function sound_set_min_distance(p_sound: ptr[sound], min_distance: float) -> void = c.ma_sound_set_min_distance
|
|
1211
|
+
public foreign function sound_get_min_distance(p_sound: const_ptr[sound]) -> float = c.ma_sound_get_min_distance
|
|
1212
|
+
public foreign function sound_set_max_distance(p_sound: ptr[sound], max_distance: float) -> void = c.ma_sound_set_max_distance
|
|
1213
|
+
public foreign function sound_get_max_distance(p_sound: const_ptr[sound]) -> float = c.ma_sound_get_max_distance
|
|
1214
|
+
public foreign function sound_set_cone(p_sound: ptr[sound], inner_angle_in_radians: float, outer_angle_in_radians: float, outer_gain: float) -> void = c.ma_sound_set_cone
|
|
1215
|
+
public foreign function sound_get_cone(p_sound: const_ptr[sound], p_inner_angle_in_radians: ptr[float], p_outer_angle_in_radians: ptr[float], p_outer_gain: ptr[float]) -> void = c.ma_sound_get_cone
|
|
1216
|
+
public foreign function sound_set_doppler_factor(p_sound: ptr[sound], doppler_factor: float) -> void = c.ma_sound_set_doppler_factor
|
|
1217
|
+
public foreign function sound_get_doppler_factor(p_sound: const_ptr[sound]) -> float = c.ma_sound_get_doppler_factor
|
|
1218
|
+
public foreign function sound_set_directional_attenuation_factor(p_sound: ptr[sound], directional_attenuation_factor: float) -> void = c.ma_sound_set_directional_attenuation_factor
|
|
1219
|
+
public foreign function sound_get_directional_attenuation_factor(p_sound: const_ptr[sound]) -> float = c.ma_sound_get_directional_attenuation_factor
|
|
1220
|
+
public foreign function sound_set_fade_in_pcm_frames(p_sound: ptr[sound], volume_beg: float, volume_end: float, fade_length_in_frames: ulong) -> void = c.ma_sound_set_fade_in_pcm_frames
|
|
1221
|
+
public foreign function sound_set_fade_in_milliseconds(p_sound: ptr[sound], volume_beg: float, volume_end: float, fade_length_in_milliseconds: ulong) -> void = c.ma_sound_set_fade_in_milliseconds
|
|
1222
|
+
public foreign function sound_set_fade_start_in_pcm_frames(p_sound: ptr[sound], volume_beg: float, volume_end: float, fade_length_in_frames: ulong, absolute_global_time_in_frames: ulong) -> void = c.ma_sound_set_fade_start_in_pcm_frames
|
|
1223
|
+
public foreign function sound_set_fade_start_in_milliseconds(p_sound: ptr[sound], volume_beg: float, volume_end: float, fade_length_in_milliseconds: ulong, absolute_global_time_in_milliseconds: ulong) -> void = c.ma_sound_set_fade_start_in_milliseconds
|
|
1224
|
+
public foreign function sound_get_current_fade_volume(p_sound: const_ptr[sound]) -> float = c.ma_sound_get_current_fade_volume
|
|
1225
|
+
public foreign function sound_set_start_time_in_pcm_frames(p_sound: ptr[sound], absolute_global_time_in_frames: ulong) -> void = c.ma_sound_set_start_time_in_pcm_frames
|
|
1226
|
+
public foreign function sound_set_start_time_in_milliseconds(p_sound: ptr[sound], absolute_global_time_in_milliseconds: ulong) -> void = c.ma_sound_set_start_time_in_milliseconds
|
|
1227
|
+
public foreign function sound_set_stop_time_in_pcm_frames(p_sound: ptr[sound], absolute_global_time_in_frames: ulong) -> void = c.ma_sound_set_stop_time_in_pcm_frames
|
|
1228
|
+
public foreign function sound_set_stop_time_in_milliseconds(p_sound: ptr[sound], absolute_global_time_in_milliseconds: ulong) -> void = c.ma_sound_set_stop_time_in_milliseconds
|
|
1229
|
+
public foreign function sound_set_stop_time_with_fade_in_pcm_frames(p_sound: ptr[sound], stop_absolute_global_time_in_frames: ulong, fade_length_in_frames: ulong) -> void = c.ma_sound_set_stop_time_with_fade_in_pcm_frames
|
|
1230
|
+
public foreign function sound_set_stop_time_with_fade_in_milliseconds(p_sound: ptr[sound], stop_absolute_global_time_in_milliseconds: ulong, fade_length_in_milliseconds: ulong) -> void = c.ma_sound_set_stop_time_with_fade_in_milliseconds
|
|
1231
|
+
public foreign function sound_is_playing(p_sound: const_ptr[sound]) -> bool32 = c.ma_sound_is_playing
|
|
1232
|
+
public foreign function sound_get_time_in_pcm_frames(p_sound: const_ptr[sound]) -> uint64 = c.ma_sound_get_time_in_pcm_frames
|
|
1233
|
+
public foreign function sound_get_time_in_milliseconds(p_sound: const_ptr[sound]) -> uint64 = c.ma_sound_get_time_in_milliseconds
|
|
1234
|
+
public foreign function sound_set_looping(p_sound: ptr[sound], is_looping: uint) -> void = c.ma_sound_set_looping
|
|
1235
|
+
public foreign function sound_is_looping(p_sound: const_ptr[sound]) -> bool32 = c.ma_sound_is_looping
|
|
1236
|
+
public foreign function sound_at_end(p_sound: const_ptr[sound]) -> bool32 = c.ma_sound_at_end
|
|
1237
|
+
public foreign function sound_seek_to_pcm_frame(p_sound: ptr[sound], frame_index: ulong) -> result = c.ma_sound_seek_to_pcm_frame
|
|
1238
|
+
public foreign function sound_seek_to_second(p_sound: ptr[sound], seek_point_in_seconds: float) -> result = c.ma_sound_seek_to_second
|
|
1239
|
+
public foreign function sound_get_data_format(p_sound: const_ptr[sound], p_format: ptr[format], p_channels: ptr[uint32], p_sample_rate: ptr[uint32], p_channel_map: ptr[channel], channel_map_cap: ptr_uint) -> result = c.ma_sound_get_data_format
|
|
1240
|
+
public foreign function sound_get_cursor_in_pcm_frames(p_sound: const_ptr[sound], p_cursor: ptr[uint64]) -> result = c.ma_sound_get_cursor_in_pcm_frames
|
|
1241
|
+
public foreign function sound_get_length_in_pcm_frames(p_sound: const_ptr[sound], p_length: ptr[uint64]) -> result = c.ma_sound_get_length_in_pcm_frames
|
|
1242
|
+
public foreign function sound_get_cursor_in_seconds(p_sound: const_ptr[sound], p_cursor: ptr[float]) -> result = c.ma_sound_get_cursor_in_seconds
|
|
1243
|
+
public foreign function sound_get_length_in_seconds(p_sound: const_ptr[sound], p_length: ptr[float]) -> result = c.ma_sound_get_length_in_seconds
|
|
1244
|
+
public foreign function sound_set_end_callback(p_sound: ptr[sound], callback: fn(arg0: ptr[void], arg1: ptr[sound]) -> void, p_user_data: ptr[void]) -> result = c.ma_sound_set_end_callback
|
|
1245
|
+
public foreign function sound_group_init(p_engine: ptr[engine], flags_: uint, p_parent_group: ptr[sound_group], p_group: ptr[sound_group]) -> result = c.ma_sound_group_init
|
|
1246
|
+
public foreign function sound_group_init_ex(p_engine: ptr[engine], p_config: const_ptr[sound_group_config], p_group: ptr[sound_group]) -> result = c.ma_sound_group_init_ex
|
|
1247
|
+
public foreign function sound_group_uninit(p_group: ptr[sound_group]) -> void = c.ma_sound_group_uninit
|
|
1248
|
+
public foreign function sound_group_get_engine(p_group: const_ptr[sound_group]) -> ptr[engine] = c.ma_sound_group_get_engine
|
|
1249
|
+
public foreign function sound_group_start(p_group: ptr[sound_group]) -> result = c.ma_sound_group_start
|
|
1250
|
+
public foreign function sound_group_stop(p_group: ptr[sound_group]) -> result = c.ma_sound_group_stop
|
|
1251
|
+
public foreign function sound_group_set_volume(p_group: ptr[sound_group], volume: float) -> void = c.ma_sound_group_set_volume
|
|
1252
|
+
public foreign function sound_group_get_volume(p_group: const_ptr[sound_group]) -> float = c.ma_sound_group_get_volume
|
|
1253
|
+
public foreign function sound_group_set_pan(p_group: ptr[sound_group], pan: float) -> void = c.ma_sound_group_set_pan
|
|
1254
|
+
public foreign function sound_group_get_pan(p_group: const_ptr[sound_group]) -> float = c.ma_sound_group_get_pan
|
|
1255
|
+
public foreign function sound_group_set_pan_mode(p_group: ptr[sound_group], pan_mode: pan_mode) -> void = c.ma_sound_group_set_pan_mode
|
|
1256
|
+
public foreign function sound_group_get_pan_mode(p_group: const_ptr[sound_group]) -> pan_mode = c.ma_sound_group_get_pan_mode
|
|
1257
|
+
public foreign function sound_group_set_pitch(p_group: ptr[sound_group], pitch: float) -> void = c.ma_sound_group_set_pitch
|
|
1258
|
+
public foreign function sound_group_get_pitch(p_group: const_ptr[sound_group]) -> float = c.ma_sound_group_get_pitch
|
|
1259
|
+
public foreign function sound_group_set_spatialization_enabled(p_group: ptr[sound_group], enabled: uint) -> void = c.ma_sound_group_set_spatialization_enabled
|
|
1260
|
+
public foreign function sound_group_is_spatialization_enabled(p_group: const_ptr[sound_group]) -> bool32 = c.ma_sound_group_is_spatialization_enabled
|
|
1261
|
+
public foreign function sound_group_set_pinned_listener_index(p_group: ptr[sound_group], listener_index: uint) -> void = c.ma_sound_group_set_pinned_listener_index
|
|
1262
|
+
public foreign function sound_group_get_pinned_listener_index(p_group: const_ptr[sound_group]) -> uint32 = c.ma_sound_group_get_pinned_listener_index
|
|
1263
|
+
public foreign function sound_group_get_listener_index(p_group: const_ptr[sound_group]) -> uint32 = c.ma_sound_group_get_listener_index
|
|
1264
|
+
public foreign function sound_group_get_direction_to_listener(p_group: const_ptr[sound_group]) -> vec3f = c.ma_sound_group_get_direction_to_listener
|
|
1265
|
+
public foreign function sound_group_set_position(p_group: ptr[sound_group], x: float, y: float, z: float) -> void = c.ma_sound_group_set_position
|
|
1266
|
+
public foreign function sound_group_get_position(p_group: const_ptr[sound_group]) -> vec3f = c.ma_sound_group_get_position
|
|
1267
|
+
public foreign function sound_group_set_direction(p_group: ptr[sound_group], x: float, y: float, z: float) -> void = c.ma_sound_group_set_direction
|
|
1268
|
+
public foreign function sound_group_get_direction(p_group: const_ptr[sound_group]) -> vec3f = c.ma_sound_group_get_direction
|
|
1269
|
+
public foreign function sound_group_set_velocity(p_group: ptr[sound_group], x: float, y: float, z: float) -> void = c.ma_sound_group_set_velocity
|
|
1270
|
+
public foreign function sound_group_get_velocity(p_group: const_ptr[sound_group]) -> vec3f = c.ma_sound_group_get_velocity
|
|
1271
|
+
public foreign function sound_group_set_attenuation_model(p_group: ptr[sound_group], attenuation_model: attenuation_model) -> void = c.ma_sound_group_set_attenuation_model
|
|
1272
|
+
public foreign function sound_group_get_attenuation_model(p_group: const_ptr[sound_group]) -> attenuation_model = c.ma_sound_group_get_attenuation_model
|
|
1273
|
+
public foreign function sound_group_set_positioning(p_group: ptr[sound_group], positioning: positioning) -> void = c.ma_sound_group_set_positioning
|
|
1274
|
+
public foreign function sound_group_get_positioning(p_group: const_ptr[sound_group]) -> positioning = c.ma_sound_group_get_positioning
|
|
1275
|
+
public foreign function sound_group_set_rolloff(p_group: ptr[sound_group], rolloff: float) -> void = c.ma_sound_group_set_rolloff
|
|
1276
|
+
public foreign function sound_group_get_rolloff(p_group: const_ptr[sound_group]) -> float = c.ma_sound_group_get_rolloff
|
|
1277
|
+
public foreign function sound_group_set_min_gain(p_group: ptr[sound_group], min_gain: float) -> void = c.ma_sound_group_set_min_gain
|
|
1278
|
+
public foreign function sound_group_get_min_gain(p_group: const_ptr[sound_group]) -> float = c.ma_sound_group_get_min_gain
|
|
1279
|
+
public foreign function sound_group_set_max_gain(p_group: ptr[sound_group], max_gain: float) -> void = c.ma_sound_group_set_max_gain
|
|
1280
|
+
public foreign function sound_group_get_max_gain(p_group: const_ptr[sound_group]) -> float = c.ma_sound_group_get_max_gain
|
|
1281
|
+
public foreign function sound_group_set_min_distance(p_group: ptr[sound_group], min_distance: float) -> void = c.ma_sound_group_set_min_distance
|
|
1282
|
+
public foreign function sound_group_get_min_distance(p_group: const_ptr[sound_group]) -> float = c.ma_sound_group_get_min_distance
|
|
1283
|
+
public foreign function sound_group_set_max_distance(p_group: ptr[sound_group], max_distance: float) -> void = c.ma_sound_group_set_max_distance
|
|
1284
|
+
public foreign function sound_group_get_max_distance(p_group: const_ptr[sound_group]) -> float = c.ma_sound_group_get_max_distance
|
|
1285
|
+
public foreign function sound_group_set_cone(p_group: ptr[sound_group], inner_angle_in_radians: float, outer_angle_in_radians: float, outer_gain: float) -> void = c.ma_sound_group_set_cone
|
|
1286
|
+
public foreign function sound_group_get_cone(p_group: const_ptr[sound_group], p_inner_angle_in_radians: ptr[float], p_outer_angle_in_radians: ptr[float], p_outer_gain: ptr[float]) -> void = c.ma_sound_group_get_cone
|
|
1287
|
+
public foreign function sound_group_set_doppler_factor(p_group: ptr[sound_group], doppler_factor: float) -> void = c.ma_sound_group_set_doppler_factor
|
|
1288
|
+
public foreign function sound_group_get_doppler_factor(p_group: const_ptr[sound_group]) -> float = c.ma_sound_group_get_doppler_factor
|
|
1289
|
+
public foreign function sound_group_set_directional_attenuation_factor(p_group: ptr[sound_group], directional_attenuation_factor: float) -> void = c.ma_sound_group_set_directional_attenuation_factor
|
|
1290
|
+
public foreign function sound_group_get_directional_attenuation_factor(p_group: const_ptr[sound_group]) -> float = c.ma_sound_group_get_directional_attenuation_factor
|
|
1291
|
+
public foreign function sound_group_set_fade_in_pcm_frames(p_group: ptr[sound_group], volume_beg: float, volume_end: float, fade_length_in_frames: ulong) -> void = c.ma_sound_group_set_fade_in_pcm_frames
|
|
1292
|
+
public foreign function sound_group_set_fade_in_milliseconds(p_group: ptr[sound_group], volume_beg: float, volume_end: float, fade_length_in_milliseconds: ulong) -> void = c.ma_sound_group_set_fade_in_milliseconds
|
|
1293
|
+
public foreign function sound_group_get_current_fade_volume(p_group: ptr[sound_group]) -> float = c.ma_sound_group_get_current_fade_volume
|
|
1294
|
+
public foreign function sound_group_set_start_time_in_pcm_frames(p_group: ptr[sound_group], absolute_global_time_in_frames: ulong) -> void = c.ma_sound_group_set_start_time_in_pcm_frames
|
|
1295
|
+
public foreign function sound_group_set_start_time_in_milliseconds(p_group: ptr[sound_group], absolute_global_time_in_milliseconds: ulong) -> void = c.ma_sound_group_set_start_time_in_milliseconds
|
|
1296
|
+
public foreign function sound_group_set_stop_time_in_pcm_frames(p_group: ptr[sound_group], absolute_global_time_in_frames: ulong) -> void = c.ma_sound_group_set_stop_time_in_pcm_frames
|
|
1297
|
+
public foreign function sound_group_set_stop_time_in_milliseconds(p_group: ptr[sound_group], absolute_global_time_in_milliseconds: ulong) -> void = c.ma_sound_group_set_stop_time_in_milliseconds
|
|
1298
|
+
public foreign function sound_group_is_playing(p_group: const_ptr[sound_group]) -> bool32 = c.ma_sound_group_is_playing
|
|
1299
|
+
public foreign function sound_group_get_time_in_pcm_frames(p_group: const_ptr[sound_group]) -> uint64 = c.ma_sound_group_get_time_in_pcm_frames
|