Regen to remove size_t
This commit is contained in:
parent
2991b0e92c
commit
e793e84e11
|
|
@ -1,6 +1,5 @@
|
|||
#scope_module
|
||||
|
||||
size_t :: s64;
|
||||
DWORDLONG :: u64;
|
||||
|
||||
#import "Basic";
|
||||
|
|
|
|||
160
windows.jai
160
windows.jai
|
|
@ -332,8 +332,8 @@ ma_performance_profile :: enum s32 {
|
|||
|
||||
ma_allocation_callbacks :: struct {
|
||||
pUserData: *void;
|
||||
onMalloc: #type (sz: size_t, pUserData: *void) -> *void #c_call;
|
||||
onRealloc: #type (p: *void, sz: size_t, pUserData: *void) -> *void #c_call;
|
||||
onMalloc: #type (sz: u64, pUserData: *void) -> *void #c_call;
|
||||
onRealloc: #type (p: *void, sz: u64, pUserData: *void) -> *void #c_call;
|
||||
onFree: #type (p: *void, pUserData: *void) -> void #c_call;
|
||||
}
|
||||
|
||||
|
|
@ -486,7 +486,7 @@ ma_biquad :: struct {
|
|||
_ownsHeap: ma_bool32;
|
||||
}
|
||||
|
||||
ma_biquad_get_heap_size :: (pConfig: *ma_biquad_config, pHeapSizeInBytes: *size_t) -> ma_result #foreign miniaudio;
|
||||
ma_biquad_get_heap_size :: (pConfig: *ma_biquad_config, pHeapSizeInBytes: *u64) -> ma_result #foreign miniaudio;
|
||||
ma_biquad_init_preallocated :: (pConfig: *ma_biquad_config, pHeap: *void, pBQ: *ma_biquad) -> ma_result #foreign miniaudio;
|
||||
ma_biquad_init :: (pConfig: *ma_biquad_config, pAllocationCallbacks: *ma_allocation_callbacks, pBQ: *ma_biquad) -> ma_result #foreign miniaudio;
|
||||
ma_biquad_uninit :: (pBQ: *ma_biquad, pAllocationCallbacks: *ma_allocation_callbacks) -> void #foreign miniaudio;
|
||||
|
|
@ -529,7 +529,7 @@ ma_lpf1 :: struct {
|
|||
_ownsHeap: ma_bool32;
|
||||
}
|
||||
|
||||
ma_lpf1_get_heap_size :: (pConfig: *ma_lpf1_config, pHeapSizeInBytes: *size_t) -> ma_result #foreign miniaudio;
|
||||
ma_lpf1_get_heap_size :: (pConfig: *ma_lpf1_config, pHeapSizeInBytes: *u64) -> ma_result #foreign miniaudio;
|
||||
ma_lpf1_init_preallocated :: (pConfig: *ma_lpf1_config, pHeap: *void, pLPF: *ma_lpf1) -> ma_result #foreign miniaudio;
|
||||
ma_lpf1_init :: (pConfig: *ma_lpf1_config, pAllocationCallbacks: *ma_allocation_callbacks, pLPF: *ma_lpf1) -> ma_result #foreign miniaudio;
|
||||
ma_lpf1_uninit :: (pLPF: *ma_lpf1, pAllocationCallbacks: *ma_allocation_callbacks) -> void #foreign miniaudio;
|
||||
|
|
@ -542,7 +542,7 @@ ma_lpf2 :: struct {
|
|||
bq: ma_biquad; /* The second order low-pass filter is implemented as a biquad filter. */
|
||||
}
|
||||
|
||||
ma_lpf2_get_heap_size :: (pConfig: *ma_lpf2_config, pHeapSizeInBytes: *size_t) -> ma_result #foreign miniaudio;
|
||||
ma_lpf2_get_heap_size :: (pConfig: *ma_lpf2_config, pHeapSizeInBytes: *u64) -> ma_result #foreign miniaudio;
|
||||
ma_lpf2_init_preallocated :: (pConfig: *ma_lpf2_config, pHeap: *void, pHPF: *ma_lpf2) -> ma_result #foreign miniaudio;
|
||||
ma_lpf2_init :: (pConfig: *ma_lpf2_config, pAllocationCallbacks: *ma_allocation_callbacks, pLPF: *ma_lpf2) -> ma_result #foreign miniaudio;
|
||||
ma_lpf2_uninit :: (pLPF: *ma_lpf2, pAllocationCallbacks: *ma_allocation_callbacks) -> void #foreign miniaudio;
|
||||
|
|
@ -575,7 +575,7 @@ ma_lpf :: struct {
|
|||
_ownsHeap: ma_bool32;
|
||||
}
|
||||
|
||||
ma_lpf_get_heap_size :: (pConfig: *ma_lpf_config, pHeapSizeInBytes: *size_t) -> ma_result #foreign miniaudio;
|
||||
ma_lpf_get_heap_size :: (pConfig: *ma_lpf_config, pHeapSizeInBytes: *u64) -> ma_result #foreign miniaudio;
|
||||
ma_lpf_init_preallocated :: (pConfig: *ma_lpf_config, pHeap: *void, pLPF: *ma_lpf) -> ma_result #foreign miniaudio;
|
||||
ma_lpf_init :: (pConfig: *ma_lpf_config, pAllocationCallbacks: *ma_allocation_callbacks, pLPF: *ma_lpf) -> ma_result #foreign miniaudio;
|
||||
ma_lpf_uninit :: (pLPF: *ma_lpf, pAllocationCallbacks: *ma_allocation_callbacks) -> void #foreign miniaudio;
|
||||
|
|
@ -618,7 +618,7 @@ ma_hpf1 :: struct {
|
|||
_ownsHeap: ma_bool32;
|
||||
}
|
||||
|
||||
ma_hpf1_get_heap_size :: (pConfig: *ma_hpf1_config, pHeapSizeInBytes: *size_t) -> ma_result #foreign miniaudio;
|
||||
ma_hpf1_get_heap_size :: (pConfig: *ma_hpf1_config, pHeapSizeInBytes: *u64) -> ma_result #foreign miniaudio;
|
||||
ma_hpf1_init_preallocated :: (pConfig: *ma_hpf1_config, pHeap: *void, pLPF: *ma_hpf1) -> ma_result #foreign miniaudio;
|
||||
ma_hpf1_init :: (pConfig: *ma_hpf1_config, pAllocationCallbacks: *ma_allocation_callbacks, pHPF: *ma_hpf1) -> ma_result #foreign miniaudio;
|
||||
ma_hpf1_uninit :: (pHPF: *ma_hpf1, pAllocationCallbacks: *ma_allocation_callbacks) -> void #foreign miniaudio;
|
||||
|
|
@ -630,7 +630,7 @@ ma_hpf2 :: struct {
|
|||
bq: ma_biquad; /* The second order high-pass filter is implemented as a biquad filter. */
|
||||
}
|
||||
|
||||
ma_hpf2_get_heap_size :: (pConfig: *ma_hpf2_config, pHeapSizeInBytes: *size_t) -> ma_result #foreign miniaudio;
|
||||
ma_hpf2_get_heap_size :: (pConfig: *ma_hpf2_config, pHeapSizeInBytes: *u64) -> ma_result #foreign miniaudio;
|
||||
ma_hpf2_init_preallocated :: (pConfig: *ma_hpf2_config, pHeap: *void, pHPF: *ma_hpf2) -> ma_result #foreign miniaudio;
|
||||
ma_hpf2_init :: (pConfig: *ma_hpf2_config, pAllocationCallbacks: *ma_allocation_callbacks, pHPF: *ma_hpf2) -> ma_result #foreign miniaudio;
|
||||
ma_hpf2_uninit :: (pHPF: *ma_hpf2, pAllocationCallbacks: *ma_allocation_callbacks) -> void #foreign miniaudio;
|
||||
|
|
@ -662,7 +662,7 @@ ma_hpf :: struct {
|
|||
_ownsHeap: ma_bool32;
|
||||
}
|
||||
|
||||
ma_hpf_get_heap_size :: (pConfig: *ma_hpf_config, pHeapSizeInBytes: *size_t) -> ma_result #foreign miniaudio;
|
||||
ma_hpf_get_heap_size :: (pConfig: *ma_hpf_config, pHeapSizeInBytes: *u64) -> ma_result #foreign miniaudio;
|
||||
ma_hpf_init_preallocated :: (pConfig: *ma_hpf_config, pHeap: *void, pLPF: *ma_hpf) -> ma_result #foreign miniaudio;
|
||||
ma_hpf_init :: (pConfig: *ma_hpf_config, pAllocationCallbacks: *ma_allocation_callbacks, pHPF: *ma_hpf) -> ma_result #foreign miniaudio;
|
||||
ma_hpf_uninit :: (pHPF: *ma_hpf, pAllocationCallbacks: *ma_allocation_callbacks) -> void #foreign miniaudio;
|
||||
|
|
@ -689,7 +689,7 @@ ma_bpf2 :: struct {
|
|||
bq: ma_biquad; /* The second order band-pass filter is implemented as a biquad filter. */
|
||||
}
|
||||
|
||||
ma_bpf2_get_heap_size :: (pConfig: *ma_bpf2_config, pHeapSizeInBytes: *size_t) -> ma_result #foreign miniaudio;
|
||||
ma_bpf2_get_heap_size :: (pConfig: *ma_bpf2_config, pHeapSizeInBytes: *u64) -> ma_result #foreign miniaudio;
|
||||
ma_bpf2_init_preallocated :: (pConfig: *ma_bpf2_config, pHeap: *void, pBPF: *ma_bpf2) -> ma_result #foreign miniaudio;
|
||||
ma_bpf2_init :: (pConfig: *ma_bpf2_config, pAllocationCallbacks: *ma_allocation_callbacks, pBPF: *ma_bpf2) -> ma_result #foreign miniaudio;
|
||||
ma_bpf2_uninit :: (pBPF: *ma_bpf2, pAllocationCallbacks: *ma_allocation_callbacks) -> void #foreign miniaudio;
|
||||
|
|
@ -718,7 +718,7 @@ ma_bpf :: struct {
|
|||
_ownsHeap: ma_bool32;
|
||||
}
|
||||
|
||||
ma_bpf_get_heap_size :: (pConfig: *ma_bpf_config, pHeapSizeInBytes: *size_t) -> ma_result #foreign miniaudio;
|
||||
ma_bpf_get_heap_size :: (pConfig: *ma_bpf_config, pHeapSizeInBytes: *u64) -> ma_result #foreign miniaudio;
|
||||
ma_bpf_init_preallocated :: (pConfig: *ma_bpf_config, pHeap: *void, pBPF: *ma_bpf) -> ma_result #foreign miniaudio;
|
||||
ma_bpf_init :: (pConfig: *ma_bpf_config, pAllocationCallbacks: *ma_allocation_callbacks, pBPF: *ma_bpf) -> ma_result #foreign miniaudio;
|
||||
ma_bpf_uninit :: (pBPF: *ma_bpf, pAllocationCallbacks: *ma_allocation_callbacks) -> void #foreign miniaudio;
|
||||
|
|
@ -752,7 +752,7 @@ ma_notch2 :: struct {
|
|||
bq: ma_biquad;
|
||||
}
|
||||
|
||||
ma_notch2_get_heap_size :: (pConfig: *ma_notch2_config, pHeapSizeInBytes: *size_t) -> ma_result #foreign miniaudio;
|
||||
ma_notch2_get_heap_size :: (pConfig: *ma_notch2_config, pHeapSizeInBytes: *u64) -> ma_result #foreign miniaudio;
|
||||
ma_notch2_init_preallocated :: (pConfig: *ma_notch2_config, pHeap: *void, pFilter: *ma_notch2) -> ma_result #foreign miniaudio;
|
||||
ma_notch2_init :: (pConfig: *ma_notch2_config, pAllocationCallbacks: *ma_allocation_callbacks, pFilter: *ma_notch2) -> ma_result #foreign miniaudio;
|
||||
ma_notch2_uninit :: (pFilter: *ma_notch2, pAllocationCallbacks: *ma_allocation_callbacks) -> void #foreign miniaudio;
|
||||
|
|
@ -787,7 +787,7 @@ ma_peak2 :: struct {
|
|||
bq: ma_biquad;
|
||||
}
|
||||
|
||||
ma_peak2_get_heap_size :: (pConfig: *ma_peak2_config, pHeapSizeInBytes: *size_t) -> ma_result #foreign miniaudio;
|
||||
ma_peak2_get_heap_size :: (pConfig: *ma_peak2_config, pHeapSizeInBytes: *u64) -> ma_result #foreign miniaudio;
|
||||
ma_peak2_init_preallocated :: (pConfig: *ma_peak2_config, pHeap: *void, pFilter: *ma_peak2) -> ma_result #foreign miniaudio;
|
||||
ma_peak2_init :: (pConfig: *ma_peak2_config, pAllocationCallbacks: *ma_allocation_callbacks, pFilter: *ma_peak2) -> ma_result #foreign miniaudio;
|
||||
ma_peak2_uninit :: (pFilter: *ma_peak2, pAllocationCallbacks: *ma_allocation_callbacks) -> void #foreign miniaudio;
|
||||
|
|
@ -822,7 +822,7 @@ ma_loshelf2 :: struct {
|
|||
bq: ma_biquad;
|
||||
}
|
||||
|
||||
ma_loshelf2_get_heap_size :: (pConfig: *ma_loshelf2_config, pHeapSizeInBytes: *size_t) -> ma_result #foreign miniaudio;
|
||||
ma_loshelf2_get_heap_size :: (pConfig: *ma_loshelf2_config, pHeapSizeInBytes: *u64) -> ma_result #foreign miniaudio;
|
||||
ma_loshelf2_init_preallocated :: (pConfig: *ma_loshelf2_config, pHeap: *void, pFilter: *ma_loshelf2) -> ma_result #foreign miniaudio;
|
||||
ma_loshelf2_init :: (pConfig: *ma_loshelf2_config, pAllocationCallbacks: *ma_allocation_callbacks, pFilter: *ma_loshelf2) -> ma_result #foreign miniaudio;
|
||||
ma_loshelf2_uninit :: (pFilter: *ma_loshelf2, pAllocationCallbacks: *ma_allocation_callbacks) -> void #foreign miniaudio;
|
||||
|
|
@ -857,7 +857,7 @@ ma_hishelf2 :: struct {
|
|||
bq: ma_biquad;
|
||||
}
|
||||
|
||||
ma_hishelf2_get_heap_size :: (pConfig: *ma_hishelf2_config, pHeapSizeInBytes: *size_t) -> ma_result #foreign miniaudio;
|
||||
ma_hishelf2_get_heap_size :: (pConfig: *ma_hishelf2_config, pHeapSizeInBytes: *u64) -> ma_result #foreign miniaudio;
|
||||
ma_hishelf2_init_preallocated :: (pConfig: *ma_hishelf2_config, pHeap: *void, pFilter: *ma_hishelf2) -> ma_result #foreign miniaudio;
|
||||
ma_hishelf2_init :: (pConfig: *ma_hishelf2_config, pAllocationCallbacks: *ma_allocation_callbacks, pFilter: *ma_hishelf2) -> ma_result #foreign miniaudio;
|
||||
ma_hishelf2_uninit :: (pFilter: *ma_hishelf2, pAllocationCallbacks: *ma_allocation_callbacks) -> void #foreign miniaudio;
|
||||
|
|
@ -917,7 +917,7 @@ ma_gainer :: struct {
|
|||
_ownsHeap: ma_bool32;
|
||||
}
|
||||
|
||||
ma_gainer_get_heap_size :: (pConfig: *ma_gainer_config, pHeapSizeInBytes: *size_t) -> ma_result #foreign miniaudio;
|
||||
ma_gainer_get_heap_size :: (pConfig: *ma_gainer_config, pHeapSizeInBytes: *u64) -> ma_result #foreign miniaudio;
|
||||
ma_gainer_init_preallocated :: (pConfig: *ma_gainer_config, pHeap: *void, pGainer: *ma_gainer) -> ma_result #foreign miniaudio;
|
||||
ma_gainer_init :: (pConfig: *ma_gainer_config, pAllocationCallbacks: *ma_allocation_callbacks, pGainer: *ma_gainer) -> ma_result #foreign miniaudio;
|
||||
ma_gainer_uninit :: (pGainer: *ma_gainer, pAllocationCallbacks: *ma_allocation_callbacks) -> void #foreign miniaudio;
|
||||
|
|
@ -1034,7 +1034,7 @@ ma_spatializer_listener :: struct {
|
|||
_pHeap: *void;
|
||||
}
|
||||
|
||||
ma_spatializer_listener_get_heap_size :: (pConfig: *ma_spatializer_listener_config, pHeapSizeInBytes: *size_t) -> ma_result #foreign miniaudio;
|
||||
ma_spatializer_listener_get_heap_size :: (pConfig: *ma_spatializer_listener_config, pHeapSizeInBytes: *u64) -> ma_result #foreign miniaudio;
|
||||
ma_spatializer_listener_init_preallocated :: (pConfig: *ma_spatializer_listener_config, pHeap: *void, pListener: *ma_spatializer_listener) -> ma_result #foreign miniaudio;
|
||||
ma_spatializer_listener_init :: (pConfig: *ma_spatializer_listener_config, pAllocationCallbacks: *ma_allocation_callbacks, pListener: *ma_spatializer_listener) -> ma_result #foreign miniaudio;
|
||||
ma_spatializer_listener_uninit :: (pListener: *ma_spatializer_listener, pAllocationCallbacks: *ma_allocation_callbacks) -> void #foreign miniaudio;
|
||||
|
|
@ -1108,7 +1108,7 @@ ma_spatializer :: struct {
|
|||
_ownsHeap: ma_bool32;
|
||||
}
|
||||
|
||||
ma_spatializer_get_heap_size :: (pConfig: *ma_spatializer_config, pHeapSizeInBytes: *size_t) -> ma_result #foreign miniaudio;
|
||||
ma_spatializer_get_heap_size :: (pConfig: *ma_spatializer_config, pHeapSizeInBytes: *u64) -> ma_result #foreign miniaudio;
|
||||
ma_spatializer_init_preallocated :: (pConfig: *ma_spatializer_config, pHeap: *void, pSpatializer: *ma_spatializer) -> ma_result #foreign miniaudio;
|
||||
ma_spatializer_init :: (pConfig: *ma_spatializer_config, pAllocationCallbacks: *ma_allocation_callbacks, pSpatializer: *ma_spatializer) -> ma_result #foreign miniaudio;
|
||||
ma_spatializer_uninit :: (pSpatializer: *ma_spatializer, pAllocationCallbacks: *ma_allocation_callbacks) -> void #foreign miniaudio;
|
||||
|
|
@ -1184,7 +1184,7 @@ ma_linear_resampler :: struct {
|
|||
_ownsHeap: ma_bool32;
|
||||
}
|
||||
|
||||
ma_linear_resampler_get_heap_size :: (pConfig: *ma_linear_resampler_config, pHeapSizeInBytes: *size_t) -> ma_result #foreign miniaudio;
|
||||
ma_linear_resampler_get_heap_size :: (pConfig: *ma_linear_resampler_config, pHeapSizeInBytes: *u64) -> ma_result #foreign miniaudio;
|
||||
ma_linear_resampler_init_preallocated :: (pConfig: *ma_linear_resampler_config, pHeap: *void, pResampler: *ma_linear_resampler) -> ma_result #foreign miniaudio;
|
||||
ma_linear_resampler_init :: (pConfig: *ma_linear_resampler_config, pAllocationCallbacks: *ma_allocation_callbacks, pResampler: *ma_linear_resampler) -> ma_result #foreign miniaudio;
|
||||
ma_linear_resampler_uninit :: (pResampler: *ma_linear_resampler, pAllocationCallbacks: *ma_allocation_callbacks) -> void #foreign miniaudio;
|
||||
|
|
@ -1199,7 +1199,7 @@ ma_linear_resampler_reset :: (pResampler: *ma_linear_resampler) -> ma_result #fo
|
|||
|
||||
ma_resampling_backend :: void;
|
||||
ma_resampling_backend_vtable :: struct {
|
||||
onGetHeapSize: #type (pUserData: *void, pConfig: *ma_resampler_config, pHeapSizeInBytes: *size_t) -> ma_result #c_call;
|
||||
onGetHeapSize: #type (pUserData: *void, pConfig: *ma_resampler_config, pHeapSizeInBytes: *u64) -> ma_result #c_call;
|
||||
onInit: #type (pUserData: *void, pConfig: *ma_resampler_config, pHeap: *void, ppBackend: **ma_resampling_backend) -> ma_result #c_call;
|
||||
onUninit: #type (pUserData: *void, pBackend: *ma_resampling_backend, pAllocationCallbacks: *ma_allocation_callbacks) -> void #c_call;
|
||||
onProcess: #type (pUserData: *void, pBackend: *ma_resampling_backend, pFramesIn: *void, pFrameCountIn: *ma_uint64, pFramesOut: *void, pFrameCountOut: *ma_uint64) -> ma_result #c_call;
|
||||
|
|
@ -1248,7 +1248,7 @@ ma_resampler :: struct {
|
|||
_ownsHeap: ma_bool32;
|
||||
}
|
||||
|
||||
ma_resampler_get_heap_size :: (pConfig: *ma_resampler_config, pHeapSizeInBytes: *size_t) -> ma_result #foreign miniaudio;
|
||||
ma_resampler_get_heap_size :: (pConfig: *ma_resampler_config, pHeapSizeInBytes: *u64) -> ma_result #foreign miniaudio;
|
||||
ma_resampler_init_preallocated :: (pConfig: *ma_resampler_config, pHeap: *void, pResampler: *ma_resampler) -> ma_result #foreign miniaudio;
|
||||
|
||||
/*
|
||||
|
|
@ -1380,13 +1380,13 @@ ma_channel_converter :: struct {
|
|||
_ownsHeap: ma_bool32;
|
||||
}
|
||||
|
||||
ma_channel_converter_get_heap_size :: (pConfig: *ma_channel_converter_config, pHeapSizeInBytes: *size_t) -> ma_result #foreign miniaudio;
|
||||
ma_channel_converter_get_heap_size :: (pConfig: *ma_channel_converter_config, pHeapSizeInBytes: *u64) -> ma_result #foreign miniaudio;
|
||||
ma_channel_converter_init_preallocated :: (pConfig: *ma_channel_converter_config, pHeap: *void, pConverter: *ma_channel_converter) -> ma_result #foreign miniaudio;
|
||||
ma_channel_converter_init :: (pConfig: *ma_channel_converter_config, pAllocationCallbacks: *ma_allocation_callbacks, pConverter: *ma_channel_converter) -> ma_result #foreign miniaudio;
|
||||
ma_channel_converter_uninit :: (pConverter: *ma_channel_converter, pAllocationCallbacks: *ma_allocation_callbacks) -> void #foreign miniaudio;
|
||||
ma_channel_converter_process_pcm_frames :: (pConverter: *ma_channel_converter, pFramesOut: *void, pFramesIn: *void, frameCount: ma_uint64) -> ma_result #foreign miniaudio;
|
||||
ma_channel_converter_get_input_channel_map :: (pConverter: *ma_channel_converter, pChannelMap: *ma_channel, channelMapCap: size_t) -> ma_result #foreign miniaudio;
|
||||
ma_channel_converter_get_output_channel_map :: (pConverter: *ma_channel_converter, pChannelMap: *ma_channel, channelMapCap: size_t) -> ma_result #foreign miniaudio;
|
||||
ma_channel_converter_get_input_channel_map :: (pConverter: *ma_channel_converter, pChannelMap: *ma_channel, channelMapCap: u64) -> ma_result #foreign miniaudio;
|
||||
ma_channel_converter_get_output_channel_map :: (pConverter: *ma_channel_converter, pChannelMap: *ma_channel, channelMapCap: u64) -> ma_result #foreign miniaudio;
|
||||
|
||||
/**************************************************************************************************************************************************************
|
||||
|
||||
|
|
@ -1444,7 +1444,7 @@ ma_data_converter :: struct {
|
|||
_pHeap: *void;
|
||||
}
|
||||
|
||||
ma_data_converter_get_heap_size :: (pConfig: *ma_data_converter_config, pHeapSizeInBytes: *size_t) -> ma_result #foreign miniaudio;
|
||||
ma_data_converter_get_heap_size :: (pConfig: *ma_data_converter_config, pHeapSizeInBytes: *u64) -> ma_result #foreign miniaudio;
|
||||
ma_data_converter_init_preallocated :: (pConfig: *ma_data_converter_config, pHeap: *void, pConverter: *ma_data_converter) -> ma_result #foreign miniaudio;
|
||||
ma_data_converter_init :: (pConfig: *ma_data_converter_config, pAllocationCallbacks: *ma_allocation_callbacks, pConverter: *ma_data_converter) -> ma_result #foreign miniaudio;
|
||||
ma_data_converter_uninit :: (pConverter: *ma_data_converter, pAllocationCallbacks: *ma_allocation_callbacks) -> void #foreign miniaudio;
|
||||
|
|
@ -1455,8 +1455,8 @@ ma_data_converter_get_input_latency :: (pConverter: *ma_data_converter) -> ma_ui
|
|||
ma_data_converter_get_output_latency :: (pConverter: *ma_data_converter) -> ma_uint64 #foreign miniaudio;
|
||||
ma_data_converter_get_required_input_frame_count :: (pConverter: *ma_data_converter, outputFrameCount: ma_uint64, pInputFrameCount: *ma_uint64) -> ma_result #foreign miniaudio;
|
||||
ma_data_converter_get_expected_output_frame_count :: (pConverter: *ma_data_converter, inputFrameCount: ma_uint64, pOutputFrameCount: *ma_uint64) -> ma_result #foreign miniaudio;
|
||||
ma_data_converter_get_input_channel_map :: (pConverter: *ma_data_converter, pChannelMap: *ma_channel, channelMapCap: size_t) -> ma_result #foreign miniaudio;
|
||||
ma_data_converter_get_output_channel_map :: (pConverter: *ma_data_converter, pChannelMap: *ma_channel, channelMapCap: size_t) -> ma_result #foreign miniaudio;
|
||||
ma_data_converter_get_input_channel_map :: (pConverter: *ma_data_converter, pChannelMap: *ma_channel, channelMapCap: u64) -> ma_result #foreign miniaudio;
|
||||
ma_data_converter_get_output_channel_map :: (pConverter: *ma_data_converter, pChannelMap: *ma_channel, channelMapCap: u64) -> ma_result #foreign miniaudio;
|
||||
ma_data_converter_reset :: (pConverter: *ma_data_converter) -> ma_result #foreign miniaudio;
|
||||
|
||||
/************************************************************************************************************************************************************
|
||||
|
|
@ -1516,7 +1516,7 @@ Helper for retrieving a standard channel map.
|
|||
|
||||
The output channel map buffer must have a capacity of at least `channelMapCap`.
|
||||
*/
|
||||
ma_channel_map_init_standard :: (standardChannelMap: ma_standard_channel_map, pChannelMap: *ma_channel, channelMapCap: size_t, channels: ma_uint32) -> void #foreign miniaudio;
|
||||
ma_channel_map_init_standard :: (standardChannelMap: ma_standard_channel_map, pChannelMap: *ma_channel, channelMapCap: u64, channels: ma_uint32) -> void #foreign miniaudio;
|
||||
|
||||
/*
|
||||
Copies a channel map.
|
||||
|
|
@ -1530,7 +1530,7 @@ Copies a channel map if one is specified, otherwise copies the default channel m
|
|||
|
||||
The output buffer must have a capacity of at least `channels`. If not NULL, the input channel map must also have a capacity of at least `channels`.
|
||||
*/
|
||||
ma_channel_map_copy_or_default :: (pOut: *ma_channel, channelMapCapOut: size_t, pIn: *ma_channel, channels: ma_uint32) -> void #foreign miniaudio;
|
||||
ma_channel_map_copy_or_default :: (pOut: *ma_channel, channelMapCapOut: u64, pIn: *ma_channel, channels: ma_uint32) -> void #foreign miniaudio;
|
||||
|
||||
/*
|
||||
Determines whether or not a channel map is valid.
|
||||
|
|
@ -1584,7 +1584,7 @@ This is for printing and debugging purposes, not serialization/deserialization.
|
|||
|
||||
Returns the length of the string, not including the null terminator.
|
||||
*/
|
||||
ma_channel_map_to_string :: (pChannelMap: *ma_channel, channels: ma_uint32, pBufferOut: *u8, bufferCap: size_t) -> size_t #foreign miniaudio;
|
||||
ma_channel_map_to_string :: (pChannelMap: *ma_channel, channels: ma_uint32, pBufferOut: *u8, bufferCap: u64) -> u64 #foreign miniaudio;
|
||||
|
||||
/*
|
||||
Retrieves a human readable version of a channel position.
|
||||
|
|
@ -1613,7 +1613,7 @@ ma_data_source :: void;
|
|||
ma_data_source_vtable :: struct {
|
||||
onRead: #type (pDataSource: *ma_data_source, pFramesOut: *void, frameCount: ma_uint64, pFramesRead: *ma_uint64) -> ma_result #c_call;
|
||||
onSeek: #type (pDataSource: *ma_data_source, frameIndex: ma_uint64) -> ma_result #c_call;
|
||||
onGetDataFormat: #type (pDataSource: *ma_data_source, pFormat: *ma_format, pChannels: *ma_uint32, pSampleRate: *ma_uint32, pChannelMap: *ma_channel, channelMapCap: size_t) -> ma_result #c_call;
|
||||
onGetDataFormat: #type (pDataSource: *ma_data_source, pFormat: *ma_format, pChannels: *ma_uint32, pSampleRate: *ma_uint32, pChannelMap: *ma_channel, channelMapCap: u64) -> ma_result #c_call;
|
||||
onGetCursor: #type (pDataSource: *ma_data_source, pCursor: *ma_uint64) -> ma_result #c_call;
|
||||
onGetLength: #type (pDataSource: *ma_data_source, pLength: *ma_uint64) -> ma_result #c_call;
|
||||
onSetLooping: #type (pDataSource: *ma_data_source, isLooping: ma_bool32) -> ma_result #c_call;
|
||||
|
|
@ -1645,7 +1645,7 @@ ma_data_source_uninit :: (pDataSource: *ma_data_source) -> void #foreign miniaud
|
|||
ma_data_source_read_pcm_frames :: (pDataSource: *ma_data_source, pFramesOut: *void, frameCount: ma_uint64, pFramesRead: *ma_uint64) -> ma_result #foreign miniaudio;
|
||||
ma_data_source_seek_pcm_frames :: (pDataSource: *ma_data_source, frameCount: ma_uint64, pFramesSeeked: *ma_uint64) -> ma_result #foreign miniaudio;
|
||||
ma_data_source_seek_to_pcm_frame :: (pDataSource: *ma_data_source, frameIndex: ma_uint64) -> ma_result #foreign miniaudio;
|
||||
ma_data_source_get_data_format :: (pDataSource: *ma_data_source, pFormat: *ma_format, pChannels: *ma_uint32, pSampleRate: *ma_uint32, pChannelMap: *ma_channel, channelMapCap: size_t) -> ma_result #foreign miniaudio;
|
||||
ma_data_source_get_data_format :: (pDataSource: *ma_data_source, pFormat: *ma_format, pChannels: *ma_uint32, pSampleRate: *ma_uint32, pChannelMap: *ma_channel, channelMapCap: u64) -> ma_result #foreign miniaudio;
|
||||
ma_data_source_get_cursor_in_pcm_frames :: (pDataSource: *ma_data_source, pCursor: *ma_uint64) -> ma_result #foreign miniaudio;
|
||||
ma_data_source_get_length_in_pcm_frames :: (pDataSource: *ma_data_source, pLength: *ma_uint64) -> ma_result #foreign miniaudio;
|
||||
ma_data_source_get_cursor_in_seconds :: (pDataSource: *ma_data_source, pCursor: *float) -> ma_result #foreign miniaudio;
|
||||
|
|
@ -1778,23 +1778,23 @@ ma_rb :: struct {
|
|||
allocationCallbacks: ma_allocation_callbacks;
|
||||
}
|
||||
|
||||
ma_rb_init_ex :: (subbufferSizeInBytes: size_t, subbufferCount: size_t, subbufferStrideInBytes: size_t, pOptionalPreallocatedBuffer: *void, pAllocationCallbacks: *ma_allocation_callbacks, pRB: *ma_rb) -> ma_result #foreign miniaudio;
|
||||
ma_rb_init :: (bufferSizeInBytes: size_t, pOptionalPreallocatedBuffer: *void, pAllocationCallbacks: *ma_allocation_callbacks, pRB: *ma_rb) -> ma_result #foreign miniaudio;
|
||||
ma_rb_init_ex :: (subbufferSizeInBytes: u64, subbufferCount: u64, subbufferStrideInBytes: u64, pOptionalPreallocatedBuffer: *void, pAllocationCallbacks: *ma_allocation_callbacks, pRB: *ma_rb) -> ma_result #foreign miniaudio;
|
||||
ma_rb_init :: (bufferSizeInBytes: u64, pOptionalPreallocatedBuffer: *void, pAllocationCallbacks: *ma_allocation_callbacks, pRB: *ma_rb) -> ma_result #foreign miniaudio;
|
||||
ma_rb_uninit :: (pRB: *ma_rb) -> void #foreign miniaudio;
|
||||
ma_rb_reset :: (pRB: *ma_rb) -> void #foreign miniaudio;
|
||||
ma_rb_acquire_read :: (pRB: *ma_rb, pSizeInBytes: *size_t, ppBufferOut: **void) -> ma_result #foreign miniaudio;
|
||||
ma_rb_commit_read :: (pRB: *ma_rb, sizeInBytes: size_t) -> ma_result #foreign miniaudio;
|
||||
ma_rb_acquire_write :: (pRB: *ma_rb, pSizeInBytes: *size_t, ppBufferOut: **void) -> ma_result #foreign miniaudio;
|
||||
ma_rb_commit_write :: (pRB: *ma_rb, sizeInBytes: size_t) -> ma_result #foreign miniaudio;
|
||||
ma_rb_seek_read :: (pRB: *ma_rb, offsetInBytes: size_t) -> ma_result #foreign miniaudio;
|
||||
ma_rb_seek_write :: (pRB: *ma_rb, offsetInBytes: size_t) -> ma_result #foreign miniaudio;
|
||||
ma_rb_acquire_read :: (pRB: *ma_rb, pSizeInBytes: *u64, ppBufferOut: **void) -> ma_result #foreign miniaudio;
|
||||
ma_rb_commit_read :: (pRB: *ma_rb, sizeInBytes: u64) -> ma_result #foreign miniaudio;
|
||||
ma_rb_acquire_write :: (pRB: *ma_rb, pSizeInBytes: *u64, ppBufferOut: **void) -> ma_result #foreign miniaudio;
|
||||
ma_rb_commit_write :: (pRB: *ma_rb, sizeInBytes: u64) -> ma_result #foreign miniaudio;
|
||||
ma_rb_seek_read :: (pRB: *ma_rb, offsetInBytes: u64) -> ma_result #foreign miniaudio;
|
||||
ma_rb_seek_write :: (pRB: *ma_rb, offsetInBytes: u64) -> ma_result #foreign miniaudio;
|
||||
ma_rb_pointer_distance :: (pRB: *ma_rb) -> ma_int32 #foreign miniaudio;
|
||||
ma_rb_available_read :: (pRB: *ma_rb) -> ma_uint32 #foreign miniaudio;
|
||||
ma_rb_available_write :: (pRB: *ma_rb) -> ma_uint32 #foreign miniaudio;
|
||||
ma_rb_get_subbuffer_size :: (pRB: *ma_rb) -> size_t #foreign miniaudio;
|
||||
ma_rb_get_subbuffer_stride :: (pRB: *ma_rb) -> size_t #foreign miniaudio;
|
||||
ma_rb_get_subbuffer_offset :: (pRB: *ma_rb, subbufferIndex: size_t) -> size_t #foreign miniaudio;
|
||||
ma_rb_get_subbuffer_ptr :: (pRB: *ma_rb, subbufferIndex: size_t, pBuffer: *void) -> *void #foreign miniaudio;
|
||||
ma_rb_get_subbuffer_size :: (pRB: *ma_rb) -> u64 #foreign miniaudio;
|
||||
ma_rb_get_subbuffer_stride :: (pRB: *ma_rb) -> u64 #foreign miniaudio;
|
||||
ma_rb_get_subbuffer_offset :: (pRB: *ma_rb, subbufferIndex: u64) -> u64 #foreign miniaudio;
|
||||
ma_rb_get_subbuffer_ptr :: (pRB: *ma_rb, subbufferIndex: u64, pBuffer: *void) -> *void #foreign miniaudio;
|
||||
|
||||
ma_pcm_rb :: struct {
|
||||
ds: ma_data_source_base;
|
||||
|
|
@ -1856,17 +1856,17 @@ ma_result_description :: (result: ma_result) -> *u8 #foreign miniaudio;
|
|||
/*
|
||||
malloc()
|
||||
*/
|
||||
ma_malloc :: (sz: size_t, pAllocationCallbacks: *ma_allocation_callbacks) -> *void #foreign miniaudio;
|
||||
ma_malloc :: (sz: u64, pAllocationCallbacks: *ma_allocation_callbacks) -> *void #foreign miniaudio;
|
||||
|
||||
/*
|
||||
calloc()
|
||||
*/
|
||||
ma_calloc :: (sz: size_t, pAllocationCallbacks: *ma_allocation_callbacks) -> *void #foreign miniaudio;
|
||||
ma_calloc :: (sz: u64, pAllocationCallbacks: *ma_allocation_callbacks) -> *void #foreign miniaudio;
|
||||
|
||||
/*
|
||||
realloc()
|
||||
*/
|
||||
ma_realloc :: (p: *void, sz: size_t, pAllocationCallbacks: *ma_allocation_callbacks) -> *void #foreign miniaudio;
|
||||
ma_realloc :: (p: *void, sz: u64, pAllocationCallbacks: *ma_allocation_callbacks) -> *void #foreign miniaudio;
|
||||
|
||||
/*
|
||||
free()
|
||||
|
|
@ -1876,7 +1876,7 @@ ma_free :: (p: *void, pAllocationCallbacks: *ma_allocation_callbacks) -> void #f
|
|||
/*
|
||||
Performs an aligned malloc, with the assumption that the alignment is a power of 2.
|
||||
*/
|
||||
ma_aligned_malloc :: (sz: size_t, alignment: size_t, pAllocationCallbacks: *ma_allocation_callbacks) -> *void #foreign miniaudio;
|
||||
ma_aligned_malloc :: (sz: u64, alignment: u64, pAllocationCallbacks: *ma_allocation_callbacks) -> *void #foreign miniaudio;
|
||||
|
||||
/*
|
||||
Free's an aligned malloc'd buffer.
|
||||
|
|
@ -2073,7 +2073,7 @@ ma_slot_allocator :: struct {
|
|||
_pHeap: *void;
|
||||
}
|
||||
|
||||
ma_slot_allocator_get_heap_size :: (pConfig: *ma_slot_allocator_config, pHeapSizeInBytes: *size_t) -> ma_result #foreign miniaudio;
|
||||
ma_slot_allocator_get_heap_size :: (pConfig: *ma_slot_allocator_config, pHeapSizeInBytes: *u64) -> ma_result #foreign miniaudio;
|
||||
ma_slot_allocator_init_preallocated :: (pConfig: *ma_slot_allocator_config, pHeap: *void, pAllocator: *ma_slot_allocator) -> ma_result #foreign miniaudio;
|
||||
ma_slot_allocator_init :: (pConfig: *ma_slot_allocator_config, pAllocationCallbacks: *ma_allocation_callbacks, pAllocator: *ma_slot_allocator) -> ma_result #foreign miniaudio;
|
||||
ma_slot_allocator_uninit :: (pAllocator: *ma_slot_allocator, pAllocationCallbacks: *ma_allocation_callbacks) -> void #foreign miniaudio;
|
||||
|
|
@ -2249,7 +2249,7 @@ ma_job_queue :: struct {
|
|||
_ownsHeap: ma_bool32;
|
||||
}
|
||||
|
||||
ma_job_queue_get_heap_size :: (pConfig: *ma_job_queue_config, pHeapSizeInBytes: *size_t) -> ma_result #foreign miniaudio;
|
||||
ma_job_queue_get_heap_size :: (pConfig: *ma_job_queue_config, pHeapSizeInBytes: *u64) -> ma_result #foreign miniaudio;
|
||||
ma_job_queue_init_preallocated :: (pConfig: *ma_job_queue_config, pHeap: *void, pQueue: *ma_job_queue) -> ma_result #foreign miniaudio;
|
||||
ma_job_queue_init :: (pConfig: *ma_job_queue_config, pAllocationCallbacks: *ma_allocation_callbacks, pQueue: *ma_job_queue) -> ma_result #foreign miniaudio;
|
||||
ma_job_queue_uninit :: (pQueue: *ma_job_queue, pAllocationCallbacks: *ma_allocation_callbacks) -> void #foreign miniaudio;
|
||||
|
|
@ -2812,7 +2812,7 @@ ma_backend_callbacks :: struct {
|
|||
ma_context_config :: struct {
|
||||
pLog: *ma_log;
|
||||
threadPriority: ma_thread_priority;
|
||||
threadStackSize: size_t;
|
||||
threadStackSize: u64;
|
||||
pUserData: *void;
|
||||
allocationCallbacks: ma_allocation_callbacks;
|
||||
alsa: struct {
|
||||
|
|
@ -2869,7 +2869,7 @@ ma_context :: struct {
|
|||
pLog: *ma_log;
|
||||
log: ma_log; /* Only used if the log is owned by the context. The pLog member will be set to &log in this case. */
|
||||
threadPriority: ma_thread_priority;
|
||||
threadStackSize: size_t;
|
||||
threadStackSize: u64;
|
||||
pUserData: *void;
|
||||
allocationCallbacks: ma_allocation_callbacks;
|
||||
deviceEnumLock: ma_mutex; /* Used to make ma_context_get_devices() thread safe. */
|
||||
|
|
@ -3413,7 +3413,7 @@ Retrieves the size of the ma_context object.
|
|||
|
||||
This is mainly for the purpose of bindings to know how much memory to allocate.
|
||||
*/
|
||||
ma_context_sizeof :: () -> size_t #foreign miniaudio;
|
||||
ma_context_sizeof :: () -> u64 #foreign miniaudio;
|
||||
|
||||
/*
|
||||
Retrieves a pointer to the log object associated with this context.
|
||||
|
|
@ -4192,7 +4192,7 @@ most cases and will avoid the need for the inefficiency of calling this function
|
|||
|
||||
This is implemented in terms of `ma_device_get_info()`.
|
||||
*/
|
||||
ma_device_get_name :: (pDevice: *ma_device, type: ma_device_type, pName: *u8, nameCap: size_t, pLengthNotIncludingNullTerminator: *size_t) -> ma_result #foreign miniaudio;
|
||||
ma_device_get_name :: (pDevice: *ma_device, type: ma_device_type, pName: *u8, nameCap: u64, pLengthNotIncludingNullTerminator: *u64) -> ma_result #foreign miniaudio;
|
||||
|
||||
/*
|
||||
Starts the device. For playback devices this begins playback. For capture devices it begins recording.
|
||||
|
|
@ -4786,7 +4786,7 @@ See Also
|
|||
--------
|
||||
ma_is_backend_enabled()
|
||||
*/
|
||||
ma_get_enabled_backends :: (pBackends: *ma_backend, backendCap: size_t, pBackendCount: *size_t) -> ma_result #foreign miniaudio;
|
||||
ma_get_enabled_backends :: (pBackends: *ma_backend, backendCap: u64, pBackendCount: *u64) -> ma_result #foreign miniaudio;
|
||||
|
||||
/*
|
||||
Determines whether or not loopback mode is support by a backend.
|
||||
|
|
@ -4922,8 +4922,8 @@ ma_vfs_callbacks :: struct {
|
|||
onOpen: #type (pVFS: *ma_vfs, pFilePath: *u8, openMode: ma_uint32, pFile: *ma_vfs_file) -> ma_result #c_call;
|
||||
onOpenW: #type (pVFS: *ma_vfs, pFilePath: *s16, openMode: ma_uint32, pFile: *ma_vfs_file) -> ma_result #c_call;
|
||||
onClose: #type (pVFS: *ma_vfs, file: ma_vfs_file) -> ma_result #c_call;
|
||||
onRead: #type (pVFS: *ma_vfs, file: ma_vfs_file, pDst: *void, sizeInBytes: size_t, pBytesRead: *size_t) -> ma_result #c_call;
|
||||
onWrite: #type (pVFS: *ma_vfs, file: ma_vfs_file, pSrc: *void, sizeInBytes: size_t, pBytesWritten: *size_t) -> ma_result #c_call;
|
||||
onRead: #type (pVFS: *ma_vfs, file: ma_vfs_file, pDst: *void, sizeInBytes: u64, pBytesRead: *u64) -> ma_result #c_call;
|
||||
onWrite: #type (pVFS: *ma_vfs, file: ma_vfs_file, pSrc: *void, sizeInBytes: u64, pBytesWritten: *u64) -> ma_result #c_call;
|
||||
onSeek: #type (pVFS: *ma_vfs, file: ma_vfs_file, offset: ma_int64, origin: ma_seek_origin) -> ma_result #c_call;
|
||||
onTell: #type (pVFS: *ma_vfs, file: ma_vfs_file, pCursor: *ma_int64) -> ma_result #c_call;
|
||||
onInfo: #type (pVFS: *ma_vfs, file: ma_vfs_file, pInfo: *ma_file_info) -> ma_result #c_call;
|
||||
|
|
@ -4932,12 +4932,12 @@ ma_vfs_callbacks :: struct {
|
|||
ma_vfs_open :: (pVFS: *ma_vfs, pFilePath: *u8, openMode: ma_uint32, pFile: *ma_vfs_file) -> ma_result #foreign miniaudio;
|
||||
ma_vfs_open_w :: (pVFS: *ma_vfs, pFilePath: *s16, openMode: ma_uint32, pFile: *ma_vfs_file) -> ma_result #foreign miniaudio;
|
||||
ma_vfs_close :: (pVFS: *ma_vfs, file: ma_vfs_file) -> ma_result #foreign miniaudio;
|
||||
ma_vfs_read :: (pVFS: *ma_vfs, file: ma_vfs_file, pDst: *void, sizeInBytes: size_t, pBytesRead: *size_t) -> ma_result #foreign miniaudio;
|
||||
ma_vfs_write :: (pVFS: *ma_vfs, file: ma_vfs_file, pSrc: *void, sizeInBytes: size_t, pBytesWritten: *size_t) -> ma_result #foreign miniaudio;
|
||||
ma_vfs_read :: (pVFS: *ma_vfs, file: ma_vfs_file, pDst: *void, sizeInBytes: u64, pBytesRead: *u64) -> ma_result #foreign miniaudio;
|
||||
ma_vfs_write :: (pVFS: *ma_vfs, file: ma_vfs_file, pSrc: *void, sizeInBytes: u64, pBytesWritten: *u64) -> ma_result #foreign miniaudio;
|
||||
ma_vfs_seek :: (pVFS: *ma_vfs, file: ma_vfs_file, offset: ma_int64, origin: ma_seek_origin) -> ma_result #foreign miniaudio;
|
||||
ma_vfs_tell :: (pVFS: *ma_vfs, file: ma_vfs_file, pCursor: *ma_int64) -> ma_result #foreign miniaudio;
|
||||
ma_vfs_info :: (pVFS: *ma_vfs, file: ma_vfs_file, pInfo: *ma_file_info) -> ma_result #foreign miniaudio;
|
||||
ma_vfs_open_and_read_file :: (pVFS: *ma_vfs, pFilePath: *u8, ppData: **void, pSize: *size_t, pAllocationCallbacks: *ma_allocation_callbacks) -> ma_result #foreign miniaudio;
|
||||
ma_vfs_open_and_read_file :: (pVFS: *ma_vfs, pFilePath: *u8, ppData: **void, pSize: *u64, pAllocationCallbacks: *ma_allocation_callbacks) -> ma_result #foreign miniaudio;
|
||||
|
||||
ma_default_vfs :: struct {
|
||||
cb: ma_vfs_callbacks;
|
||||
|
|
@ -4946,7 +4946,7 @@ ma_default_vfs :: struct {
|
|||
|
||||
ma_default_vfs_init :: (pVFS: *ma_default_vfs, pAllocationCallbacks: *ma_allocation_callbacks) -> ma_result #foreign miniaudio;
|
||||
|
||||
ma_read_proc :: #type (pUserData: *void, pBufferOut: *void, bytesToRead: size_t, pBytesRead: *size_t) -> ma_result #c_call;
|
||||
ma_read_proc :: #type (pUserData: *void, pBufferOut: *void, bytesToRead: u64, pBytesRead: *u64) -> ma_result #c_call;
|
||||
ma_seek_proc :: #type (pUserData: *void, offset: ma_int64, origin: ma_seek_origin) -> ma_result #c_call;
|
||||
ma_tell_proc :: #type (pUserData: *void, pCursor: *ma_int64) -> ma_result #c_call;
|
||||
|
||||
|
|
@ -4969,11 +4969,11 @@ ma_decoding_backend_vtable :: struct {
|
|||
onInit: #type (pUserData: *void, onRead: ma_read_proc, onSeek: ma_seek_proc, onTell: ma_tell_proc, pReadSeekTellUserData: *void, pConfig: *ma_decoding_backend_config, pAllocationCallbacks: *ma_allocation_callbacks, ppBackend: **ma_data_source) -> ma_result #c_call;
|
||||
onInitFile: #type (pUserData: *void, pFilePath: *u8, pConfig: *ma_decoding_backend_config, pAllocationCallbacks: *ma_allocation_callbacks, ppBackend: **ma_data_source) -> ma_result #c_call; /* Optional. */
|
||||
onInitFileW: #type (pUserData: *void, pFilePath: *s16, pConfig: *ma_decoding_backend_config, pAllocationCallbacks: *ma_allocation_callbacks, ppBackend: **ma_data_source) -> ma_result #c_call; /* Optional. */
|
||||
onInitMemory: #type (pUserData: *void, pData: *void, dataSize: size_t, pConfig: *ma_decoding_backend_config, pAllocationCallbacks: *ma_allocation_callbacks, ppBackend: **ma_data_source) -> ma_result #c_call; /* Optional. */
|
||||
onInitMemory: #type (pUserData: *void, pData: *void, dataSize: u64, pConfig: *ma_decoding_backend_config, pAllocationCallbacks: *ma_allocation_callbacks, ppBackend: **ma_data_source) -> ma_result #c_call; /* Optional. */
|
||||
onUninit: #type (pUserData: *void, pBackend: *ma_data_source, pAllocationCallbacks: *ma_allocation_callbacks) -> void #c_call;
|
||||
}
|
||||
|
||||
ma_decoder_read_proc :: #type (pDecoder: *ma_decoder, pBufferOut: *void, bytesToRead: size_t, pBytesRead: *size_t) -> ma_result #c_call;
|
||||
ma_decoder_read_proc :: #type (pDecoder: *ma_decoder, pBufferOut: *void, bytesToRead: u64, pBytesRead: *u64) -> ma_result #c_call;
|
||||
ma_decoder_seek_proc :: #type (pDecoder: *ma_decoder, byteOffset: ma_int64, origin: ma_seek_origin) -> ma_result #c_call;
|
||||
ma_decoder_tell_proc :: #type (pDecoder: *ma_decoder, pCursor: *ma_int64) -> ma_result #c_call;
|
||||
|
||||
|
|
@ -5020,8 +5020,8 @@ ma_decoder :: struct {
|
|||
|
||||
memory: struct {
|
||||
pData: *ma_uint8;
|
||||
dataSize: size_t;
|
||||
currentReadPos: size_t;
|
||||
dataSize: u64;
|
||||
currentReadPos: u64;
|
||||
}; /* Only used for decoders that were opened against a block of memory. */
|
||||
};
|
||||
}
|
||||
|
|
@ -5030,7 +5030,7 @@ ma_decoder_config_init :: (outputFormat: ma_format, outputChannels: ma_uint32, o
|
|||
ma_decoder_config_init_default :: () -> ma_decoder_config #foreign miniaudio;
|
||||
|
||||
ma_decoder_init :: (onRead: ma_decoder_read_proc, onSeek: ma_decoder_seek_proc, pUserData: *void, pConfig: *ma_decoder_config, pDecoder: *ma_decoder) -> ma_result #foreign miniaudio;
|
||||
ma_decoder_init_memory :: (pData: *void, dataSize: size_t, pConfig: *ma_decoder_config, pDecoder: *ma_decoder) -> ma_result #foreign miniaudio;
|
||||
ma_decoder_init_memory :: (pData: *void, dataSize: u64, pConfig: *ma_decoder_config, pDecoder: *ma_decoder) -> ma_result #foreign miniaudio;
|
||||
ma_decoder_init_vfs :: (pVFS: *ma_vfs, pFilePath: *u8, pConfig: *ma_decoder_config, pDecoder: *ma_decoder) -> ma_result #foreign miniaudio;
|
||||
ma_decoder_init_vfs_w :: (pVFS: *ma_vfs, pFilePath: *s16, pConfig: *ma_decoder_config, pDecoder: *ma_decoder) -> ma_result #foreign miniaudio;
|
||||
ma_decoder_init_file :: (pFilePath: *u8, pConfig: *ma_decoder_config, pDecoder: *ma_decoder) -> ma_result #foreign miniaudio;
|
||||
|
|
@ -5058,7 +5058,7 @@ ma_decoder_seek_to_pcm_frame :: (pDecoder: *ma_decoder, frameIndex: ma_uint64) -
|
|||
/*
|
||||
Retrieves the decoder's output data format.
|
||||
*/
|
||||
ma_decoder_get_data_format :: (pDecoder: *ma_decoder, pFormat: *ma_format, pChannels: *ma_uint32, pSampleRate: *ma_uint32, pChannelMap: *ma_channel, channelMapCap: size_t) -> ma_result #foreign miniaudio;
|
||||
ma_decoder_get_data_format :: (pDecoder: *ma_decoder, pFormat: *ma_format, pChannels: *ma_uint32, pSampleRate: *ma_uint32, pChannelMap: *ma_channel, channelMapCap: u64) -> ma_result #foreign miniaudio;
|
||||
|
||||
/*
|
||||
Retrieves the current position of the read cursor in PCM frames.
|
||||
|
|
@ -5098,9 +5098,9 @@ pConfig should be set to what you want. On output it will be set to what you got
|
|||
*/
|
||||
ma_decode_from_vfs :: (pVFS: *ma_vfs, pFilePath: *u8, pConfig: *ma_decoder_config, pFrameCountOut: *ma_uint64, ppPCMFramesOut: **void) -> ma_result #foreign miniaudio;
|
||||
ma_decode_file :: (pFilePath: *u8, pConfig: *ma_decoder_config, pFrameCountOut: *ma_uint64, ppPCMFramesOut: **void) -> ma_result #foreign miniaudio;
|
||||
ma_decode_memory :: (pData: *void, dataSize: size_t, pConfig: *ma_decoder_config, pFrameCountOut: *ma_uint64, ppPCMFramesOut: **void) -> ma_result #foreign miniaudio;
|
||||
ma_decode_memory :: (pData: *void, dataSize: u64, pConfig: *ma_decoder_config, pFrameCountOut: *ma_uint64, ppPCMFramesOut: **void) -> ma_result #foreign miniaudio;
|
||||
|
||||
ma_encoder_write_proc :: #type (pEncoder: *ma_encoder, pBufferIn: *void, bytesToWrite: size_t, pBytesWritten: *size_t) -> ma_result #c_call;
|
||||
ma_encoder_write_proc :: #type (pEncoder: *ma_encoder, pBufferIn: *void, bytesToWrite: u64, pBytesWritten: *u64) -> ma_result #c_call;
|
||||
ma_encoder_seek_proc :: #type (pEncoder: *ma_encoder, offset: ma_int64, origin: ma_seek_origin) -> ma_result #c_call;
|
||||
ma_encoder_init_proc :: #type (pEncoder: *ma_encoder) -> ma_result #c_call;
|
||||
ma_encoder_uninit_proc :: #type (pEncoder: *ma_encoder) -> void #c_call;
|
||||
|
|
@ -5238,7 +5238,7 @@ ma_noise :: struct {
|
|||
_ownsHeap: ma_bool32;
|
||||
}
|
||||
|
||||
ma_noise_get_heap_size :: (pConfig: *ma_noise_config, pHeapSizeInBytes: *size_t) -> ma_result #foreign miniaudio;
|
||||
ma_noise_get_heap_size :: (pConfig: *ma_noise_config, pHeapSizeInBytes: *u64) -> ma_result #foreign miniaudio;
|
||||
ma_noise_init_preallocated :: (pConfig: *ma_noise_config, pHeap: *void, pNoise: *ma_noise) -> ma_result #foreign miniaudio;
|
||||
ma_noise_init :: (pConfig: *ma_noise_config, pAllocationCallbacks: *ma_allocation_callbacks, pNoise: *ma_noise) -> ma_result #foreign miniaudio;
|
||||
ma_noise_uninit :: (pNoise: *ma_noise, pAllocationCallbacks: *ma_allocation_callbacks) -> void #foreign miniaudio;
|
||||
|
|
@ -5303,7 +5303,7 @@ ma_resource_manager_data_supply :: struct {
|
|||
backend: union {
|
||||
encoded: struct {
|
||||
pData: *void;
|
||||
sizeInBytes: size_t;
|
||||
sizeInBytes: u64;
|
||||
};
|
||||
|
||||
decoded: struct {
|
||||
|
|
@ -5397,7 +5397,7 @@ ma_resource_manager_config :: struct {
|
|||
decodedChannels: ma_uint32; /* The decoded channel count to use. Set to 0 (default) to use the file's native channel count. */
|
||||
decodedSampleRate: ma_uint32; /* the decoded sample rate to use. Set to 0 (default) to use the file's native sample rate. */
|
||||
jobThreadCount: ma_uint32; /* Set to 0 if you want to self-manage your job threads. Defaults to 1. */
|
||||
jobThreadStackSize: size_t;
|
||||
jobThreadStackSize: u64;
|
||||
jobQueueCapacity: ma_uint32; /* The maximum number of jobs that can fit in the queue at a time. Defaults to MA_JOB_TYPE_RESOURCE_MANAGER_QUEUE_CAPACITY. Cannot be zero. */
|
||||
flags: ma_uint32;
|
||||
pVFS: *ma_vfs; /* Can be NULL in which case defaults will be used. */
|
||||
|
|
@ -5430,8 +5430,8 @@ ma_resource_manager_register_file :: (pResourceManager: *ma_resource_manager, pF
|
|||
ma_resource_manager_register_file_w :: (pResourceManager: *ma_resource_manager, pFilePath: *s16, flags: ma_uint32) -> ma_result #foreign miniaudio;
|
||||
ma_resource_manager_register_decoded_data :: (pResourceManager: *ma_resource_manager, pName: *u8, pData: *void, frameCount: ma_uint64, format: ma_format, channels: ma_uint32, sampleRate: ma_uint32) -> ma_result #foreign miniaudio;
|
||||
ma_resource_manager_register_decoded_data_w :: (pResourceManager: *ma_resource_manager, pName: *s16, pData: *void, frameCount: ma_uint64, format: ma_format, channels: ma_uint32, sampleRate: ma_uint32) -> ma_result #foreign miniaudio;
|
||||
ma_resource_manager_register_encoded_data :: (pResourceManager: *ma_resource_manager, pName: *u8, pData: *void, sizeInBytes: size_t) -> ma_result #foreign miniaudio;
|
||||
ma_resource_manager_register_encoded_data_w :: (pResourceManager: *ma_resource_manager, pName: *s16, pData: *void, sizeInBytes: size_t) -> ma_result #foreign miniaudio;
|
||||
ma_resource_manager_register_encoded_data :: (pResourceManager: *ma_resource_manager, pName: *u8, pData: *void, sizeInBytes: u64) -> ma_result #foreign miniaudio;
|
||||
ma_resource_manager_register_encoded_data_w :: (pResourceManager: *ma_resource_manager, pName: *s16, pData: *void, sizeInBytes: u64) -> ma_result #foreign miniaudio;
|
||||
ma_resource_manager_unregister_file :: (pResourceManager: *ma_resource_manager, pFilePath: *u8) -> ma_result #foreign miniaudio;
|
||||
ma_resource_manager_unregister_file_w :: (pResourceManager: *ma_resource_manager, pFilePath: *s16) -> ma_result #foreign miniaudio;
|
||||
ma_resource_manager_unregister_data :: (pResourceManager: *ma_resource_manager, pName: *u8) -> ma_result #foreign miniaudio;
|
||||
|
|
@ -5445,7 +5445,7 @@ ma_resource_manager_data_buffer_init_copy :: (pResourceManager: *ma_resource_man
|
|||
ma_resource_manager_data_buffer_uninit :: (pDataBuffer: *ma_resource_manager_data_buffer) -> ma_result #foreign miniaudio;
|
||||
ma_resource_manager_data_buffer_read_pcm_frames :: (pDataBuffer: *ma_resource_manager_data_buffer, pFramesOut: *void, frameCount: ma_uint64, pFramesRead: *ma_uint64) -> ma_result #foreign miniaudio;
|
||||
ma_resource_manager_data_buffer_seek_to_pcm_frame :: (pDataBuffer: *ma_resource_manager_data_buffer, frameIndex: ma_uint64) -> ma_result #foreign miniaudio;
|
||||
ma_resource_manager_data_buffer_get_data_format :: (pDataBuffer: *ma_resource_manager_data_buffer, pFormat: *ma_format, pChannels: *ma_uint32, pSampleRate: *ma_uint32, pChannelMap: *ma_channel, channelMapCap: size_t) -> ma_result #foreign miniaudio;
|
||||
ma_resource_manager_data_buffer_get_data_format :: (pDataBuffer: *ma_resource_manager_data_buffer, pFormat: *ma_format, pChannels: *ma_uint32, pSampleRate: *ma_uint32, pChannelMap: *ma_channel, channelMapCap: u64) -> ma_result #foreign miniaudio;
|
||||
ma_resource_manager_data_buffer_get_cursor_in_pcm_frames :: (pDataBuffer: *ma_resource_manager_data_buffer, pCursor: *ma_uint64) -> ma_result #foreign miniaudio;
|
||||
ma_resource_manager_data_buffer_get_length_in_pcm_frames :: (pDataBuffer: *ma_resource_manager_data_buffer, pLength: *ma_uint64) -> ma_result #foreign miniaudio;
|
||||
ma_resource_manager_data_buffer_result :: (pDataBuffer: *ma_resource_manager_data_buffer) -> ma_result #foreign miniaudio;
|
||||
|
|
@ -5460,7 +5460,7 @@ ma_resource_manager_data_stream_init_w :: (pResourceManager: *ma_resource_manage
|
|||
ma_resource_manager_data_stream_uninit :: (pDataStream: *ma_resource_manager_data_stream) -> ma_result #foreign miniaudio;
|
||||
ma_resource_manager_data_stream_read_pcm_frames :: (pDataStream: *ma_resource_manager_data_stream, pFramesOut: *void, frameCount: ma_uint64, pFramesRead: *ma_uint64) -> ma_result #foreign miniaudio;
|
||||
ma_resource_manager_data_stream_seek_to_pcm_frame :: (pDataStream: *ma_resource_manager_data_stream, frameIndex: ma_uint64) -> ma_result #foreign miniaudio;
|
||||
ma_resource_manager_data_stream_get_data_format :: (pDataStream: *ma_resource_manager_data_stream, pFormat: *ma_format, pChannels: *ma_uint32, pSampleRate: *ma_uint32, pChannelMap: *ma_channel, channelMapCap: size_t) -> ma_result #foreign miniaudio;
|
||||
ma_resource_manager_data_stream_get_data_format :: (pDataStream: *ma_resource_manager_data_stream, pFormat: *ma_format, pChannels: *ma_uint32, pSampleRate: *ma_uint32, pChannelMap: *ma_channel, channelMapCap: u64) -> ma_result #foreign miniaudio;
|
||||
ma_resource_manager_data_stream_get_cursor_in_pcm_frames :: (pDataStream: *ma_resource_manager_data_stream, pCursor: *ma_uint64) -> ma_result #foreign miniaudio;
|
||||
ma_resource_manager_data_stream_get_length_in_pcm_frames :: (pDataStream: *ma_resource_manager_data_stream, pLength: *ma_uint64) -> ma_result #foreign miniaudio;
|
||||
ma_resource_manager_data_stream_result :: (pDataStream: *ma_resource_manager_data_stream) -> ma_result #foreign miniaudio;
|
||||
|
|
@ -5476,7 +5476,7 @@ ma_resource_manager_data_source_init_copy :: (pResourceManager: *ma_resource_man
|
|||
ma_resource_manager_data_source_uninit :: (pDataSource: *ma_resource_manager_data_source) -> ma_result #foreign miniaudio;
|
||||
ma_resource_manager_data_source_read_pcm_frames :: (pDataSource: *ma_resource_manager_data_source, pFramesOut: *void, frameCount: ma_uint64, pFramesRead: *ma_uint64) -> ma_result #foreign miniaudio;
|
||||
ma_resource_manager_data_source_seek_to_pcm_frame :: (pDataSource: *ma_resource_manager_data_source, frameIndex: ma_uint64) -> ma_result #foreign miniaudio;
|
||||
ma_resource_manager_data_source_get_data_format :: (pDataSource: *ma_resource_manager_data_source, pFormat: *ma_format, pChannels: *ma_uint32, pSampleRate: *ma_uint32, pChannelMap: *ma_channel, channelMapCap: size_t) -> ma_result #foreign miniaudio;
|
||||
ma_resource_manager_data_source_get_data_format :: (pDataSource: *ma_resource_manager_data_source, pFormat: *ma_format, pChannels: *ma_uint32, pSampleRate: *ma_uint32, pChannelMap: *ma_channel, channelMapCap: u64) -> ma_result #foreign miniaudio;
|
||||
ma_resource_manager_data_source_get_cursor_in_pcm_frames :: (pDataSource: *ma_resource_manager_data_source, pCursor: *ma_uint64) -> ma_result #foreign miniaudio;
|
||||
ma_resource_manager_data_source_get_length_in_pcm_frames :: (pDataSource: *ma_resource_manager_data_source, pLength: *ma_uint64) -> ma_result #foreign miniaudio;
|
||||
ma_resource_manager_data_source_result :: (pDataSource: *ma_resource_manager_data_source) -> ma_result #foreign miniaudio;
|
||||
|
|
@ -5611,7 +5611,7 @@ ma_node_base :: struct {
|
|||
_ownsHeap: ma_bool32; /* If set to true, the node owns the heap allocation and _pHeap will be freed in ma_node_uninit(). */
|
||||
}
|
||||
|
||||
ma_node_get_heap_size :: (pNodeGraph: *ma_node_graph, pConfig: *ma_node_config, pHeapSizeInBytes: *size_t) -> ma_result #foreign miniaudio;
|
||||
ma_node_get_heap_size :: (pNodeGraph: *ma_node_graph, pConfig: *ma_node_config, pHeapSizeInBytes: *u64) -> ma_result #foreign miniaudio;
|
||||
ma_node_init_preallocated :: (pNodeGraph: *ma_node_graph, pConfig: *ma_node_config, pHeap: *void, pNode: *ma_node) -> ma_result #foreign miniaudio;
|
||||
ma_node_init :: (pNodeGraph: *ma_node_graph, pConfig: *ma_node_config, pAllocationCallbacks: *ma_allocation_callbacks, pNode: *ma_node) -> ma_result #foreign miniaudio;
|
||||
ma_node_uninit :: (pNode: *ma_node, pAllocationCallbacks: *ma_allocation_callbacks) -> void #foreign miniaudio;
|
||||
|
|
@ -5930,7 +5930,7 @@ ma_engine_node :: struct {
|
|||
_pHeap: *void;
|
||||
}
|
||||
|
||||
ma_engine_node_get_heap_size :: (pConfig: *ma_engine_node_config, pHeapSizeInBytes: *size_t) -> ma_result #foreign miniaudio;
|
||||
ma_engine_node_get_heap_size :: (pConfig: *ma_engine_node_config, pHeapSizeInBytes: *u64) -> ma_result #foreign miniaudio;
|
||||
ma_engine_node_init_preallocated :: (pConfig: *ma_engine_node_config, pHeap: *void, pEngineNode: *ma_engine_node) -> ma_result #foreign miniaudio;
|
||||
ma_engine_node_init :: (pConfig: *ma_engine_node_config, pAllocationCallbacks: *ma_allocation_callbacks, pEngineNode: *ma_engine_node) -> ma_result #foreign miniaudio;
|
||||
ma_engine_node_uninit :: (pEngineNode: *ma_engine_node, pAllocationCallbacks: *ma_allocation_callbacks) -> void #foreign miniaudio;
|
||||
|
|
@ -6161,7 +6161,7 @@ ma_sound_set_looping :: (pSound: *ma_sound, isLooping: ma_bool32) -> void #forei
|
|||
ma_sound_is_looping :: (pSound: *ma_sound) -> ma_bool32 #foreign miniaudio;
|
||||
ma_sound_at_end :: (pSound: *ma_sound) -> ma_bool32 #foreign miniaudio;
|
||||
ma_sound_seek_to_pcm_frame :: (pSound: *ma_sound, frameIndex: ma_uint64) -> ma_result #foreign miniaudio;
|
||||
ma_sound_get_data_format :: (pSound: *ma_sound, pFormat: *ma_format, pChannels: *ma_uint32, pSampleRate: *ma_uint32, pChannelMap: *ma_channel, channelMapCap: size_t) -> ma_result #foreign miniaudio;
|
||||
ma_sound_get_data_format :: (pSound: *ma_sound, pFormat: *ma_format, pChannels: *ma_uint32, pSampleRate: *ma_uint32, pChannelMap: *ma_channel, channelMapCap: u64) -> ma_result #foreign miniaudio;
|
||||
ma_sound_get_cursor_in_pcm_frames :: (pSound: *ma_sound, pCursor: *ma_uint64) -> ma_result #foreign miniaudio;
|
||||
ma_sound_get_length_in_pcm_frames :: (pSound: *ma_sound, pLength: *ma_uint64) -> ma_result #foreign miniaudio;
|
||||
ma_sound_get_cursor_in_seconds :: (pSound: *ma_sound, pCursor: *float) -> ma_result #foreign miniaudio;
|
||||
|
|
|
|||
Binary file not shown.
Loading…
Reference in New Issue
Block a user