c_kit_bindings_generated library

Classes

cJSON: The cJSON structure:
cJSON_Hooks
crypto_aead_ctx: Authenticated stream
crypto_argon2_config
crypto_argon2_extras
crypto_argon2_inputs
crypto_blake2b_ctx: Incremental interface
crypto_poly1305_ctx: Incremental interface
HexWave
HexWaveParameters: private:
http_parser
http_parser_settings
http_parser_url: Result structure for http_parser_parse_url().
ma_allocation_callbacks
ma_async_notification_callbacks
ma_async_notification_event: Event Notification
ma_async_notification_poll: Simple polling notification.
ma_atomic_bool32
ma_atomic_device_state
ma_atomic_float
ma_atomic_int32
ma_atomic_uint32
ma_atomic_uint64
ma_atomic_vec3f
ma_audio_buffer
ma_audio_buffer_config
ma_audio_buffer_ref
ma_backend_callbacks: These are the callbacks required to be implemented for a backend. These callbacks are grouped into two parts: context and device. There is one context to many devices. A device is created from a context.
ma_biquad
ma_biquad_coefficient: Biquad Filtering
ma_biquad_config
ma_biquad_node
ma_biquad_node_config: Biquad Node
ma_bpf
ma_bpf2
ma_bpf2_config: Band-Pass Filtering
ma_bpf_config
ma_bpf_node
ma_bpf_node_config: Band Pass Filter Node
ma_channel_converter
ma_channel_converter_config
ma_context
ma_context_command__wasapi: WASAPI specific structure for some commands which must run on a common thread due to bugs in WASAPI.
ma_context_config
ma_data_converter
ma_data_converter_config: Data Conversion
ma_data_source_base
ma_data_source_config
ma_data_source_node
ma_data_source_node_config: Data source node. 0 input buses, 1 output bus. Used for reading from a data source.
ma_data_source_vtable
ma_decoder
ma_decoder_config
ma_decoding_backend_config
ma_decoding_backend_vtable
ma_default_vfs
ma_delay
ma_delay_config: Delay
ma_delay_node
ma_delay_node_config
ma_device
ma_device_config
ma_device_descriptor: Describes some basic details about a playback or capture device.
ma_device_id
ma_device_info
ma_device_job_thread
ma_device_job_thread_config: Device job thread. This is used by backends that require asynchronous processing of certain operations. It is not used by all backends.
ma_device_notification
ma_duplex_rb: The idea of the duplex ring buffer is to act as the intermediary buffer when running two asynchronous devices in a duplex set up. The capture device writes to it, and then a playback device reads from it.
ma_encoder
ma_encoder_config
ma_engine
ma_engine_config
ma_engine_node: Base node object for both ma_sound and ma_sound_group.
ma_engine_node_config
ma_event
ma_fader
ma_fader_config: Fader.
ma_fence: Fence
ma_file_info
ma_gainer
ma_gainer_config: Gainer for smooth volume changes.
ma_hishelf2
ma_hishelf2_config: High Shelf Filter
ma_hishelf_node
ma_hishelf_node_config: High Shelf Filter Node
ma_hpf
ma_hpf1
ma_hpf1_config: High-Pass Filtering
ma_hpf2
ma_hpf_config
ma_hpf_node
ma_hpf_node_config: High Pass Filter Node
ma_job
ma_job_queue
ma_job_queue_config
ma_lcg
ma_linear_resampler
ma_linear_resampler_config: Resampling
ma_log
ma_log_callback
ma_loshelf2
ma_loshelf2_config: Low Shelf Filter
ma_loshelf_node
ma_loshelf_node_config: Low Shelf Filter Node
ma_lpf
ma_lpf1
ma_lpf1_config: Low-Pass Filtering
ma_lpf2
ma_lpf_config
ma_lpf_node
ma_lpf_node_config: Low Pass Filter Node
ma_node_base
ma_node_config
ma_node_graph
ma_node_graph_config
ma_node_input_bus
ma_node_output_bus
ma_node_vtable
ma_noise
ma_noise_config
ma_notch2
ma_notch2_config: Notching Filter
ma_notch_node
ma_notch_node_config: Notching Filter Node
ma_paged_audio_buffer
ma_paged_audio_buffer_config
ma_paged_audio_buffer_data
ma_paged_audio_buffer_page
ma_panner
ma_panner_config
ma_pcm_rb
ma_peak2
ma_peak2_config: Peaking EQ Filter
ma_peak_node
ma_peak_node_config: Peaking Filter Node
ma_pulsewave
ma_pulsewave_config
ma_rb: Ring Buffer
ma_resampler
ma_resampler_config
ma_resampling_backend_vtable
ma_resource_manager
ma_resource_manager_config
ma_resource_manager_data_buffer
ma_resource_manager_data_buffer_node
ma_resource_manager_data_source
ma_resource_manager_data_source_config
ma_resource_manager_data_stream
ma_resource_manager_data_supply
ma_resource_manager_pipeline_notifications
ma_resource_manager_pipeline_stage_notification: Pipeline notifications used by the resource manager. Made up of both an async notification and a fence, both of which are optional.
ma_semaphore
ma_slot_allocator
ma_slot_allocator_config: Slot Allocator
ma_slot_allocator_group
ma_sound
ma_sound_config
ma_sound_inlined
ma_spatializer
ma_spatializer_config
ma_spatializer_listener
ma_spatializer_listener_config
ma_splitter_node
ma_splitter_node_config: Splitter Node. 1 input, many outputs. Used for splitting/copying a stream so it can be as input into two separate output nodes.
ma_stack: For some internal memory management of ma_node_graph.
ma_timer
ma_vec3f: Spatializer.
ma_vfs_callbacks
ma_waveform
ma_waveform_config
mz_internal_state
mz_stream_s: Compression/decompression stream struct.
mz_zip_archive
mz_zip_archive_file_stat
mz_zip_internal_state_tag
mz_zip_reader_extract_iter_state
pthread_cond_t
pthread_mutex_t
st_stbcc_grid
stb_easy_font_color
stb_easy_font_info_struct
stb_lex_location
stb_lexer
STB_TexteditState
stbds_array_header
stbds_string_arena
stbds_string_block
stbhw_config: when requesting a template, you fill out this data
stbhw_tile: ///////////////////////////////////
stbhw_tileset
stbi_io_callbacks: load image by filename, open file, or memory buffer
stbir__info
STBIR_RESIZE
stbrp_context
stbrp_node: ///////////////////////////////////////////////////////////////////////////
stbrp_rect: Assign packed locations to rectangles. The rectangles are of type 'stbrp_rect' defined below, stored in the array 'rects', and there are 'num_rects' many of them.
stbte_tilemap
StbTexteditRow: result of layout query
stbtt__bitmap: @TODO: don't expose this structure
stbtt__buf: private structure
stbtt_aligned_quad: if return is positive, the first unused row of the bitmap if return is negative, returns the negative of the number of characters that fit if return is 0, no characters fit and no rows were used This uses a very crappy packing.
stbtt_bakedchar: ///////////////////////////////////////////////////////////////////////////
stbtt_fontinfo: The following structure is defined publicly so you can declare one on the stack or as a global or etc, but you should treat it as opaque.
stbtt_kerningentry: as above, but takes one or more glyph indices for greater efficiency
stbtt_pack_context: this is an opaque structure that you shouldn't mess with which holds all the context needed from PackBegin to PackEnd.
stbtt_pack_range: Creates character bitmaps from the font_index'th font found in fontdata (use font_index=0 if you don't know what that is). It creates num_chars_in_range bitmaps for characters with unicode values starting at first_unicode_char_in_range and increasing. Data for how to render them is stored in chardata_for_range; pass these to stbtt_GetPackedQuad to get back renderable quads.
stbtt_packedchar: ///////////////////////////////////////////////////////////////////////////
stbtt_vertex
StbUndoRecord
StbUndoState
stbvox_input_description: This is the data structure you fill out. Most of the arrays can be NULL, except when one is required to get the value to index another.
stbvox_mesh_maker: don't mess with this directly, it's just here so you can declare stbvox_mesh_maker on the stack or as a global
stbvox_rgb: 24-bit color
stbvox_uniform_info
tdefl_compressor: tdefl's compression state structure.
tinfl_decompressor_tag
UnnamedStruct
UnnamedStruct$1
UnnamedStruct$10
UnnamedStruct$11
UnnamedStruct$12
UnnamedStruct$13
UnnamedStruct$14
UnnamedStruct$15
UnnamedStruct$16
UnnamedStruct$17
UnnamedStruct$18
UnnamedStruct$19
UnnamedStruct$2
UnnamedStruct$20
UnnamedStruct$21
UnnamedStruct$22
UnnamedStruct$23
UnnamedStruct$24
UnnamedStruct$25
UnnamedStruct$26
UnnamedStruct$27
UnnamedStruct$28
UnnamedStruct$29
UnnamedStruct$3
UnnamedStruct$30
UnnamedStruct$31
UnnamedStruct$32
UnnamedStruct$33
UnnamedStruct$34
UnnamedStruct$35
UnnamedStruct$36
UnnamedStruct$37: Miscellaneous.
UnnamedStruct$38
UnnamedStruct$39
UnnamedStruct$4
UnnamedStruct$40
UnnamedStruct$41
UnnamedStruct$42
UnnamedStruct$43
UnnamedStruct$44
UnnamedStruct$45
UnnamedStruct$46
UnnamedStruct$47
UnnamedStruct$48
UnnamedStruct$49
UnnamedStruct$5
UnnamedStruct$50
UnnamedStruct$51
UnnamedStruct$52: When setting a fade, it's not done immediately in ma_sound_set_fade(). It's deferred to the audio thread which means we need to store the settings here.
UnnamedStruct$53
UnnamedStruct$54
UnnamedStruct$55
UnnamedStruct$56
UnnamedStruct$57
UnnamedStruct$6
UnnamedStruct$7
UnnamedStruct$8
UnnamedStruct$9
UnnamedUnion
UnnamedUnion$1
UnnamedUnion$10
UnnamedUnion$11
UnnamedUnion$12: Resource Manager
UnnamedUnion$13: Device.
UnnamedUnion$14
UnnamedUnion$15
UnnamedUnion$16
UnnamedUnion$17
UnnamedUnion$18
UnnamedUnion$19
UnnamedUnion$2
UnnamedUnion$20
UnnamedUnion$3
UnnamedUnion$4
UnnamedUnion$5
UnnamedUnion$6
UnnamedUnion$7
UnnamedUnion$8
UnnamedUnion$9

Enums

flags: Flag values for http_parser.flags field
http_errno
http_method: icecast
http_parser_type
http_parser_url_fields
http_status
ma_aaudio_allowed_capture_policy
ma_aaudio_content_type: AAudio content types.
ma_aaudio_input_preset: AAudio input presets.
ma_aaudio_usage: AAudio usage types.
ma_attenuation_model
ma_backend: Backend enums must be in priority order.
ma_channel_conversion_path: Channel Conversion
ma_channel_mix_mode
ma_data_converter_execution_path
ma_device_notification_type: Device notification types.
ma_device_state
ma_device_type
ma_dither_mode
ma_encoding_format
ma_engine_node_type
ma_format
ma_handedness
ma_ios_session_category: iOS/tvOS/watchOS session categories.
ma_ios_session_category_option: iOS/tvOS/watchOS session category options
ma_job_queue_flags: When set, ma_job_queue_next() will not wait and no semaphore will be signaled in ma_job_queue_post(). ma_job_queue_next() will return MA_NO_DATA_AVAILABLE if nothing is available.
ma_job_type: When a job type is added here an callback needs to be added go "g_jobVTable" in the implementation section.
ma_log_level: Logging Levels
ma_mono_expansion_mode
ma_node_flags: Node flags.
ma_node_state: The playback state of a node. Either started or stopped.
ma_noise_type
ma_open_mode_flags
ma_opensl_recording_preset: OpenSL recording presets.
ma_opensl_stream_type: OpenSL stream types.
ma_pan_mode: Stereo panner.
ma_performance_profile
ma_positioning
ma_resample_algorithm
ma_resource_manager_data_source_flags
ma_resource_manager_data_supply_type
ma_resource_manager_flags
ma_result
ma_seek_origin
ma_share_mode
ma_sound_flags: Sound flags.
ma_standard_channel_map
ma_standard_sample_rate
ma_stream_format
ma_stream_layout
ma_thread_priority: Thread priorities should be ordered such that the default priority of the worker thread is 0.
ma_wasapi_usage: WASAPI audio thread priority characteristics.
ma_waveform_type
mz_zip_error: miniz error codes. Be sure to update mz_zip_get_error_string() if you add or modify this enum.
mz_zip_flags
mz_zip_mode
mz_zip_type
stbir_datatype
stbir_edge: =============================================================== Medium-complexity API
stbir_filter
stbir_pixel_layout: stbir_pixel_layout specifies: number of channels order of channels whether color is premultiplied by alpha for back compatibility, you can cast the old channel count to an stbir_pixel_layout
stbte_action: for keyboard, define your own mapping from keys to the following actions. this is totally optional, as all features are accessible with the mouse
tdefl_flush: Must map to MZ_NO_FLUSH, MZ_SYNC_FLUSH, etc. enums
tdefl_status: The low-level tdefl functions below may be used directly if the above helper functions aren't flexible enough. The low-level functions don't make any heap allocations, unlike the above helper functions.
tinfl_status: Return status.

Constants

cJSON_Array → const int
CJSON_CIRCULAR_LIMIT → const int
cJSON_False → const int
cJSON_Invalid → const int
cJSON_IsReference → const int
CJSON_NESTING_LIMIT → const int
cJSON_NULL → const int
cJSON_Number → const int
cJSON_Object → const int
cJSON_Raw → const int
cJSON_String → const int
cJSON_StringIsConst → const int
cJSON_True → const int
CJSON_VERSION_MAJOR → const int
CJSON_VERSION_MINOR → const int
CJSON_VERSION_PATCH → const int
CLEX_andand → const int
CLEX_andeq → const int
CLEX_arrow → const int
CLEX_charlit → const int
CLEX_diveq → const int
CLEX_dqstring → const int
CLEX_eof → const int
CLEX_eq → const int
CLEX_eqarrow → const int
CLEX_first_unused_token → const int
CLEX_floatlit → const int
CLEX_greatereq → const int
CLEX_id → const int
CLEX_intlit → const int
CLEX_lesseq → const int
CLEX_minuseq → const int
CLEX_minusminus → const int
CLEX_modeq → const int
CLEX_muleq → const int
CLEX_noteq → const int
CLEX_oreq → const int
CLEX_oror → const int
CLEX_parse_error → const int
CLEX_pluseq → const int
CLEX_plusplus → const int
CLEX_shl → const int
CLEX_shleq → const int
CLEX_shr → const int
CLEX_shreq → const int
CLEX_sqstring → const int
CLEX_xoreq → const int
CRYPTO_ARGON2_D → const int
CRYPTO_ARGON2_I → const int
CRYPTO_ARGON2_ID → const int
HTTP_MAX_HEADER_SIZE → const int
HTTP_PARSER_STRICT → const int
HTTP_PARSER_VERSION_MAJOR → const int
HTTP_PARSER_VERSION_MINOR → const int
HTTP_PARSER_VERSION_PATCH → const int
MA_BACKEND_COUNT → const int
MA_CHANNEL_INDEX_NULL → const int
MA_DATA_FORMAT_FLAG_EXCLUSIVE_MODE → const int
MA_DATA_SOURCE_SELF_MANAGED_RANGE_AND_LOOP_POINT → const int
MA_ENGINE_MAX_LISTENERS → const int
MA_FALSE → const int
MA_JOB_TYPE_RESOURCE_MANAGER_QUEUE_FLAG_NON_BLOCKING → const int
MA_LISTENER_INDEX_CLOSEST → const int
MA_MAX_CHANNELS → const int
MA_MAX_DEVICE_NAME_LENGTH → const int
MA_MAX_FILTER_ORDER → const int
MA_MAX_LOG_CALLBACKS → const int
MA_MAX_NODE_BUS_COUNT → const int
MA_MAX_NODE_LOCAL_BUS_COUNT → const int
MA_MIN_CHANNELS → const int
MA_NODE_BUS_COUNT_UNKNOWN → const int
MA_RESOURCE_MANAGER_MAX_JOB_THREAD_COUNT → const int
MA_SIMD_ALIGNMENT → const int
MA_SIZE_MAX → const int
MA_SIZEOF_PTR → const int
MA_SOUND_SOURCE_CHANNEL_COUNT → const int
MA_TRUE → const int
MA_UINT64_MAX → const int
MA_VERSION_MAJOR → const int
MA_VERSION_MINOR → const int
MA_VERSION_REVISION → const int
MA_VERSION_STRING → const String
MAX_MEM_LEVEL → const int
MAX_WBITS → const int
MINIZ_HAS_64BIT_REGISTERS → const int
MINIZ_LITTLE_ENDIAN → const int
MINIZ_USE_UNALIGNED_LOADS_AND_STORES → const int
MINIZ_X86_OR_X64_CPU → const int
MZ_ADLER32_INIT → const int
MZ_BEST_COMPRESSION → const int
MZ_BEST_SPEED → const int
MZ_BLOCK → const int
MZ_BUF_ERROR → const int
MZ_CRC32_INIT → const int
MZ_DATA_ERROR → const int
MZ_DEFAULT_COMPRESSION → const int
MZ_DEFAULT_LEVEL → const int
MZ_DEFAULT_STRATEGY → const int
MZ_DEFAULT_WINDOW_BITS → const int
MZ_DEFLATED → const int
MZ_ERRNO → const int
MZ_FALSE → const int
MZ_FILTERED → const int
MZ_FINISH → const int
MZ_FIXED → const int
MZ_FULL_FLUSH → const int
MZ_HUFFMAN_ONLY → const int
MZ_MEM_ERROR → const int
MZ_NEED_DICT → const int
MZ_NO_COMPRESSION → const int
MZ_NO_FLUSH → const int
MZ_OK → const int
MZ_PARAM_ERROR → const int
MZ_PARTIAL_FLUSH → const int
MZ_RLE → const int
MZ_STREAM_END → const int
MZ_STREAM_ERROR → const int
MZ_SYNC_FLUSH → const int
MZ_TRUE → const int
MZ_UBER_COMPRESSION → const int
MZ_UINT16_MAX → const int
MZ_UINT32_MAX → const int
MZ_VER_MAJOR → const int
MZ_VER_MINOR → const int
MZ_VER_REVISION → const int
MZ_VER_SUBREVISION → const int
MZ_VERNUM → const int
MZ_VERSION → const String
MZ_VERSION_ERROR → const int
MZ_ZIP_MAX_ARCHIVE_FILE_COMMENT_SIZE → const int
MZ_ZIP_MAX_ARCHIVE_FILENAME_SIZE → const int
MZ_ZIP_MAX_IO_BUF_SIZE → const int
STB_DXT_DITHER → const int
STB_DXT_HIGHQUAL → const int
STB_DXT_NORMAL → const int
STB_HEXWAVE_MAX_BLEP_LENGTH → const int
STB_RECT_PACK_VERSION → const int
STB_SPRINTF_MIN → const int
STB_TEXTEDIT_UNDOCHARCOUNT → const int
STB_TEXTEDIT_UNDOSTATECOUNT → const int
STBCC_NULL_UNIQUE_ID → const int
STBDS_HM_BINARY → const int
STBDS_HM_STRING → const int
STBDS_SH_ARENA → const int
STBDS_SH_DEFAULT → const int
STBDS_SH_NONE → const int
STBDS_SH_STRDUP → const int
STBI_default → const int
STBI_grey → const int
STBI_grey_alpha → const int
STBI_rgb → const int
STBI_rgb_alpha → const int
STBI_VERSION → const int
STBRP__MAXVAL → const int
STBRP_HEURISTIC_Skyline_BF_sortHeight → const int
STBRP_HEURISTIC_Skyline_BL_sortHeight → const int
STBRP_HEURISTIC_Skyline_default → const int
STBTE_drawmode_deemphasize → const int
STBTE_drawmode_emphasize → const int
STBTE_drawmode_normal → const int
STBTE_EMPTY → const int
STBTE_PROP_bool → const int
STBTE_PROP_disabled → const int
STBTE_PROP_float → const int
STBTE_PROP_int → const int
STBTE_PROP_none → const int
STBTT_MAC_EID_ARABIC → const int
STBTT_MAC_EID_CHINESE_TRAD → const int
STBTT_MAC_EID_GREEK → const int
STBTT_MAC_EID_HEBREW → const int
STBTT_MAC_EID_JAPANESE → const int
STBTT_MAC_EID_KOREAN → const int
STBTT_MAC_EID_ROMAN → const int
STBTT_MAC_EID_RUSSIAN → const int
STBTT_MAC_LANG_ARABIC → const int
STBTT_MAC_LANG_CHINESE_SIMPLIFIED → const int
STBTT_MAC_LANG_CHINESE_TRAD → const int
STBTT_MAC_LANG_DUTCH → const int
STBTT_MAC_LANG_ENGLISH → const int
STBTT_MAC_LANG_FRENCH → const int
STBTT_MAC_LANG_GERMAN → const int
STBTT_MAC_LANG_HEBREW → const int
STBTT_MAC_LANG_ITALIAN → const int
STBTT_MAC_LANG_JAPANESE → const int
STBTT_MAC_LANG_KOREAN → const int
STBTT_MAC_LANG_RUSSIAN → const int
STBTT_MAC_LANG_SPANISH → const int
STBTT_MAC_LANG_SWEDISH → const int
STBTT_MACSTYLE_BOLD → const int
STBTT_MACSTYLE_DONTCARE → const int
STBTT_MACSTYLE_ITALIC → const int
STBTT_MACSTYLE_NONE → const int
STBTT_MACSTYLE_UNDERSCORE → const int
STBTT_MS_EID_SHIFTJIS → const int
STBTT_MS_EID_SYMBOL → const int
STBTT_MS_EID_UNICODE_BMP → const int
STBTT_MS_EID_UNICODE_FULL → const int
STBTT_MS_LANG_CHINESE → const int
STBTT_MS_LANG_DUTCH → const int
STBTT_MS_LANG_ENGLISH → const int
STBTT_MS_LANG_FRENCH → const int
STBTT_MS_LANG_GERMAN → const int
STBTT_MS_LANG_HEBREW → const int
STBTT_MS_LANG_ITALIAN → const int
STBTT_MS_LANG_JAPANESE → const int
STBTT_MS_LANG_KOREAN → const int
STBTT_MS_LANG_RUSSIAN → const int
STBTT_MS_LANG_SPANISH → const int
STBTT_MS_LANG_SWEDISH → const int
STBTT_PLATFORM_ID_ISO → const int
STBTT_PLATFORM_ID_MAC → const int
STBTT_PLATFORM_ID_MICROSOFT → const int
STBTT_PLATFORM_ID_UNICODE → const int
STBTT_UNICODE_EID_ISO_10646 → const int
STBTT_UNICODE_EID_UNICODE_1_0 → const int
STBTT_UNICODE_EID_UNICODE_1_1 → const int
STBTT_UNICODE_EID_UNICODE_2_0_BMP → const int
STBTT_UNICODE_EID_UNICODE_2_0_FULL → const int
STBTT_vcubic → const int
STBTT_vcurve → const int
STBTT_vline → const int
STBTT_vmove → const int
STBVOX_BLOCKTYPE_EMPTY → const int
STBVOX_BLOCKTYPE_HOLE → const int
STBVOX_COLOR_TEX1_ENABLE → const int
STBVOX_COLOR_TEX2_ENABLE → const int
STBVOX_FACE_count → const int
STBVOX_FACE_down → const int
STBVOX_FACE_east → const int
STBVOX_FACE_NONE → const int
STBVOX_FACE_north → const int
STBVOX_FACE_south → const int
STBVOX_FACE_up → const int
STBVOX_FACE_west → const int
STBVOX_GEOM_ceil_slope_north_is_bottom → const int
STBVOX_GEOM_ceil_slope_north_is_bottom_as_wall_UNIMPLEMENTED → const int
STBVOX_GEOM_ceil_vheight_03 → const int
STBVOX_GEOM_ceil_vheight_12 → const int
STBVOX_GEOM_count → const int
STBVOX_GEOM_crossed_pair → const int
STBVOX_GEOM_empty → const int
STBVOX_GEOM_floor_slope_north_is_top → const int
STBVOX_GEOM_floor_slope_north_is_top_as_wall_UNIMPLEMENTED → const int
STBVOX_GEOM_floor_vheight_03 → const int
STBVOX_GEOM_floor_vheight_12 → const int
STBVOX_GEOM_force → const int
STBVOX_GEOM_knockout → const int
STBVOX_GEOM_slab_lower → const int
STBVOX_GEOM_slab_upper → const int
STBVOX_GEOM_solid → const int
STBVOX_GEOM_transp → const int
STBVOX_MAX_MESH_SLOTS → const int
STBVOX_MAX_MESHES → const int
STBVOX_TEXLERP3_0_8 → const int
STBVOX_TEXLERP3_1_8 → const int
STBVOX_TEXLERP3_2_8 → const int
STBVOX_TEXLERP3_3_8 → const int
STBVOX_TEXLERP3_4_8 → const int
STBVOX_TEXLERP3_5_8 → const int
STBVOX_TEXLERP3_6_8 → const int
STBVOX_TEXLERP3_7_8 → const int
STBVOX_TEXLERP_BASE_0 → const int
STBVOX_TEXLERP_BASE_1 → const int
STBVOX_TEXLERP_BASE_2_7 → const int
STBVOX_TEXLERP_BASE_5_7 → const int
STBVOX_TEXLERP_FACE_0 → const int
STBVOX_TEXLERP_FACE_1 → const int
STBVOX_TEXLERP_FACE_half → const int
STBVOX_TEXLERP_FACE_use_vert → const int
STBVOX_UNIFORM_ambient → const int
STBVOX_UNIFORM_camera_pos → const int
STBVOX_UNIFORM_color_table → const int
STBVOX_UNIFORM_count → const int
STBVOX_UNIFORM_face_data → const int
STBVOX_UNIFORM_normals → const int
STBVOX_UNIFORM_tex_array → const int
STBVOX_UNIFORM_texgen → const int
STBVOX_UNIFORM_texscale → const int
STBVOX_UNIFORM_transform → const int
STBVOX_UNIFORM_TYPE_none → const int
STBVOX_UNIFORM_TYPE_sampler → const int
STBVOX_UNIFORM_TYPE_vec2 → const int
STBVOX_UNIFORM_TYPE_vec3 → const int
STBVOX_UNIFORM_TYPE_vec4 → const int
STBVOX_VERTEX_HEIGHT_0 → const int
STBVOX_VERTEX_HEIGHT_1 → const int
STBVOX_VERTEX_HEIGHT_half → const int
STBVOX_VERTEX_HEIGHT_one_and_a_half → const int
TDEFL_COMPUTE_ADLER32 → const int
TDEFL_DEFAULT_MAX_PROBES → const int
TDEFL_FILTER_MATCHES → const int
TDEFL_FORCE_ALL_RAW_BLOCKS → const int
TDEFL_FORCE_ALL_STATIC_BLOCKS → const int
TDEFL_GREEDY_PARSING_FLAG → const int
TDEFL_HUFFMAN_ONLY → const int
TDEFL_LESS_MEMORY → const int
TDEFL_LEVEL1_HASH_SIZE_MASK → const int
TDEFL_LZ_CODE_BUF_SIZE → const int
TDEFL_LZ_DICT_SIZE → const int
TDEFL_LZ_DICT_SIZE_MASK → const int
TDEFL_LZ_HASH_BITS → const int
TDEFL_LZ_HASH_SHIFT → const int
TDEFL_LZ_HASH_SIZE → const int
TDEFL_MAX_HUFF_SYMBOLS → const int
TDEFL_MAX_HUFF_SYMBOLS_0 → const int
TDEFL_MAX_HUFF_SYMBOLS_1 → const int
TDEFL_MAX_HUFF_SYMBOLS_2 → const int
TDEFL_MAX_HUFF_TABLES → const int
TDEFL_MAX_MATCH_LEN → const int
TDEFL_MAX_PROBES_MASK → const int
TDEFL_MIN_MATCH_LEN → const int
TDEFL_NONDETERMINISTIC_PARSING_FLAG → const int
TDEFL_OUT_BUF_SIZE → const int
TDEFL_RLE_MATCHES → const int
TDEFL_WRITE_ZLIB_HEADER → const int
TINFL_BITBUF_SIZE → const int
TINFL_DECOMPRESS_MEM_TO_MEM_FAILED → const int
TINFL_FAST_LOOKUP_BITS → const int
TINFL_FAST_LOOKUP_SIZE → const int
TINFL_FLAG_COMPUTE_ADLER32 → const int
TINFL_FLAG_HAS_MORE_INPUT → const int
TINFL_FLAG_PARSE_ZLIB_HEADER → const int
TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF → const int
TINFL_LZ_DICT_SIZE → const int
TINFL_MAX_HUFF_SYMBOLS_0 → const int
TINFL_MAX_HUFF_SYMBOLS_1 → const int
TINFL_MAX_HUFF_SYMBOLS_2 → const int
TINFL_MAX_HUFF_TABLES → const int
TINFL_USE_64BIT_BITBUF → const int
Z_BEST_COMPRESSION → const int
Z_BEST_SPEED → const int
Z_BLOCK → const int
Z_BUF_ERROR → const int
Z_DATA_ERROR → const int
Z_DEFAULT_COMPRESSION → const int
Z_DEFAULT_STRATEGY → const int
Z_DEFAULT_WINDOW_BITS → const int
Z_DEFLATED → const int
Z_ERRNO → const int
Z_FILTERED → const int
Z_FINISH → const int
Z_FIXED → const int
Z_FULL_FLUSH → const int
Z_HUFFMAN_ONLY → const int
Z_MEM_ERROR → const int
Z_NEED_DICT → const int
Z_NO_COMPRESSION → const int
Z_NO_FLUSH → const int
Z_NULL → const int
Z_OK → const int
Z_PARAM_ERROR → const int
Z_PARTIAL_FLUSH → const int
Z_RLE → const int
Z_STREAM_END → const int
Z_STREAM_ERROR → const int
Z_SYNC_FLUSH → const int
Z_VERSION_ERROR → const int
ZLIB_VER_MAJOR → const int
ZLIB_VER_MINOR → const int
ZLIB_VER_REVISION → const int
ZLIB_VER_SUBREVISION → const int
ZLIB_VERNUM → const int
ZLIB_VERSION → const String

Properties

crypto_argon2_no_extras → crypto_argon2_extras: final
stb_easy_font_charinfo ↔ Array<stb_easy_font_info_struct>: getter/setter pair
stb_easy_font_hseg ↔ Array<UnsignedChar>: getter/setter pair
stb_easy_font_spacing_val ↔ double: getter/setter pair
stb_easy_font_vseg ↔ Array<UnsignedChar>: getter/setter pair
stbi_write_force_png_filter ↔ int: getter/setter pair
stbi_write_png_compression_level ↔ int: getter/setter pair
stbi_write_tga_with_rle ↔ int: getter/setter pair

Functions

cJSON_AddArrayToObject(Pointer<cJSON> object, Pointer<Char> name) → Pointer<cJSON>
cJSON_AddBoolToObject(Pointer<cJSON> object, Pointer<Char> name, int boolean) → Pointer<cJSON>
cJSON_AddFalseToObject(Pointer<cJSON> object, Pointer<Char> name) → Pointer<cJSON>
cJSON_AddItemReferenceToArray(Pointer<cJSON> array, Pointer<cJSON> item) → int: Append reference to item to the specified array/object. Use this when you want to add an existing cJSON to a new cJSON, but don't want to corrupt your existing cJSON.
cJSON_AddItemReferenceToObject(Pointer<cJSON> object, Pointer<Char> string, Pointer<cJSON> item) → int
cJSON_AddItemToArray(Pointer<cJSON> array, Pointer<cJSON> item) → int: Append item to the specified array/object.
cJSON_AddItemToObject(Pointer<cJSON> object, Pointer<Char> string, Pointer<cJSON> item) → int
cJSON_AddItemToObjectCS(Pointer<cJSON> object, Pointer<Char> string, Pointer<cJSON> item) → int: Use this when string is definitely const (i.e. a literal, or as good as), and will definitely survive the cJSON object. WARNING: When this function was used, make sure to always check that (item->type & cJSON_StringIsConst) is zero before writing to item->string
cJSON_AddNullToObject(Pointer<cJSON> object, Pointer<Char> name) → Pointer<cJSON>: Helper functions for creating and adding items to an object at the same time. They return the added item or NULL on failure.
cJSON_AddNumberToObject(Pointer<cJSON> object, Pointer<Char> name, double number) → Pointer<cJSON>
cJSON_AddObjectToObject(Pointer<cJSON> object, Pointer<Char> name) → Pointer<cJSON>
cJSON_AddRawToObject(Pointer<cJSON> object, Pointer<Char> name, Pointer<Char> raw) → Pointer<cJSON>
cJSON_AddStringToObject(Pointer<cJSON> object, Pointer<Char> name, Pointer<Char> string) → Pointer<cJSON>
cJSON_AddTrueToObject(Pointer<cJSON> object, Pointer<Char> name) → Pointer<cJSON>
cJSON_Compare(Pointer<cJSON> a, Pointer<cJSON> b, int case_sensitive) → int: Duplicate will create a new, identical cJSON item to the one you pass, in new memory that will need to be released. With recurse!=0, it will duplicate any children connected to the item. The item->next and ->prev pointers are always zero on return from Duplicate. / / Recursively compare two cJSON items for equality. If either a or b is NULL or invalid, they will be considered unequal. case_sensitive determines if object keys are treated case sensitive (1) or case insensitive (0)
cJSON_CreateArray() → Pointer<cJSON>
cJSON_CreateArrayReference(Pointer<cJSON> child) → Pointer<cJSON>
cJSON_CreateBool(int boolean) → Pointer<cJSON>
cJSON_CreateDoubleArray(Pointer<Double> numbers, int count) → Pointer<cJSON>
cJSON_CreateFalse() → Pointer<cJSON>
cJSON_CreateFloatArray(Pointer<Float> numbers, int count) → Pointer<cJSON>
cJSON_CreateIntArray(Pointer<Int> numbers, int count) → Pointer<cJSON>: These utilities create an Array of count items. The parameter count cannot be greater than the number of elements in the number array, otherwise array access will be out of bounds.
cJSON_CreateNull() → Pointer<cJSON>: These calls create a cJSON item of the appropriate type.
cJSON_CreateNumber(double num) → Pointer<cJSON>
cJSON_CreateObject() → Pointer<cJSON>
cJSON_CreateObjectReference(Pointer<cJSON> child) → Pointer<cJSON>: Create an object/array that only references it's elements so they will not be freed by cJSON_Delete
cJSON_CreateRaw(Pointer<Char> raw) → Pointer<cJSON>: raw json
cJSON_CreateString(Pointer<Char> string) → Pointer<cJSON>
cJSON_CreateStringArray(Pointer<Pointer<Char>> strings, int count) → Pointer<cJSON>
cJSON_CreateStringReference(Pointer<Char> string) → Pointer<cJSON>: Create a string where valuestring references a string so it will not be freed by cJSON_Delete
cJSON_CreateTrue() → Pointer<cJSON>
cJSON_Delete(Pointer<cJSON> item) → void: Delete a cJSON entity and all subentities.
cJSON_DeleteItemFromArray(Pointer<cJSON> array, int which) → void
cJSON_DeleteItemFromObject(Pointer<cJSON> object, Pointer<Char> string) → void
cJSON_DeleteItemFromObjectCaseSensitive(Pointer<cJSON> object, Pointer<Char> string) → void
cJSON_DetachItemFromArray(Pointer<cJSON> array, int which) → Pointer<cJSON>
cJSON_DetachItemFromObject(Pointer<cJSON> object, Pointer<Char> string) → Pointer<cJSON>
cJSON_DetachItemFromObjectCaseSensitive(Pointer<cJSON> object, Pointer<Char> string) → Pointer<cJSON>
cJSON_DetachItemViaPointer(Pointer<cJSON> parent, Pointer<cJSON> item) → Pointer<cJSON>: Remove/Detach items from Arrays/Objects.
cJSON_Duplicate(Pointer<cJSON> item, int recurse) → Pointer<cJSON>: Duplicate a cJSON item
cJSON_free(Pointer<Void> object) → void
cJSON_GetArrayItem(Pointer<cJSON> array, int index) → Pointer<cJSON>: Retrieve item number "index" from array "array". Returns NULL if unsuccessful.
cJSON_GetArraySize(Pointer<cJSON> array) → int: Returns the number of items in an array (or object).
cJSON_GetErrorPtr() → Pointer<Char>: For analysing failed parses. This returns a pointer to the parse error. You'll probably need to look a few chars back to make sense of it. Defined when cJSON_Parse() returns 0. 0 when cJSON_Parse() succeeds.
cJSON_GetNumberValue(Pointer<cJSON> item) → double
cJSON_GetObjectItem(Pointer<cJSON> object, Pointer<Char> string) → Pointer<cJSON>: Get item "string" from object. Case insensitive.
cJSON_GetObjectItemCaseSensitive(Pointer<cJSON> object, Pointer<Char> string) → Pointer<cJSON>
cJSON_GetStringValue(Pointer<cJSON> item) → Pointer<Char>: Check item type and return its value
cJSON_HasObjectItem(Pointer<cJSON> object, Pointer<Char> string) → int
cJSON_InitHooks(Pointer<cJSON_Hooks> hooks) → void: Supply malloc, realloc and free functions to cJSON
cJSON_InsertItemInArray(Pointer<cJSON> array, int which, Pointer<cJSON> newitem) → int: Update array items.
cJSON_IsArray(Pointer<cJSON> item) → int
cJSON_IsBool(Pointer<cJSON> item) → int
cJSON_IsFalse(Pointer<cJSON> item) → int
cJSON_IsInvalid(Pointer<cJSON> item) → int: These functions check the type of an item
cJSON_IsNull(Pointer<cJSON> item) → int
cJSON_IsNumber(Pointer<cJSON> item) → int
cJSON_IsObject(Pointer<cJSON> item) → int
cJSON_IsRaw(Pointer<cJSON> item) → int
cJSON_IsString(Pointer<cJSON> item) → int
cJSON_IsTrue(Pointer<cJSON> item) → int
cJSON_malloc(int size) → Pointer<Void>: malloc/free objects using the malloc/free functions that have been set with cJSON_InitHooks
cJSON_Minify(Pointer<Char> json) → void: Minify a strings, remove blank characters(such as ' ', '\t', '\r', '\n') from strings. The input pointer json cannot point to a read-only address area, such as a string constant, but should point to a readable and writable address area.
cJSON_Parse(Pointer<Char> value) → Pointer<cJSON>: Memory Management: the caller is always responsible to free the results from all variants of cJSON_Parse (with cJSON_Delete) and cJSON_Print (with stdlib free, cJSON_Hooks.free_fn, or cJSON_free as appropriate). The exception is cJSON_PrintPreallocated, where the caller has full responsibility of the buffer. / / Supply a block of JSON, and this returns a cJSON object you can interrogate.
cJSON_ParseWithLength(Pointer<Char> value, int buffer_length) → Pointer<cJSON>
cJSON_ParseWithLengthOpts(Pointer<Char> value, int buffer_length, Pointer<Pointer<Char>> return_parse_end, int require_null_terminated) → Pointer<cJSON>
cJSON_ParseWithOpts(Pointer<Char> value, Pointer<Pointer<Char>> return_parse_end, int require_null_terminated) → Pointer<cJSON>: ParseWithOpts allows you to require (and check) that the JSON is null terminated, and to retrieve the pointer to the final byte parsed. / / If you supply a ptr in return_parse_end and parsing fails, then return_parse_end will contain a pointer to the error so will match cJSON_GetErrorPtr().
cJSON_Print(Pointer<cJSON> item) → Pointer<Char>: Render a cJSON entity to text for transfer/storage.
cJSON_PrintBuffered(Pointer<cJSON> item, int prebuffer, int fmt) → Pointer<Char>: Render a cJSON entity to text using a buffered strategy. prebuffer is a guess at the final size. guessing well reduces reallocation. fmt=0 gives unformatted, =1 gives formatted
cJSON_PrintPreallocated(Pointer<cJSON> item, Pointer<Char> buffer, int length, int format) → int: Render a cJSON entity to text using a buffer already allocated in memory with given length. Returns 1 on success and 0 on failure. / / NOTE: cJSON is not always 100% accurate in estimating how much memory it will use, so to be safe allocate 5 bytes more than you actually need
cJSON_PrintUnformatted(Pointer<cJSON> item) → Pointer<Char>: Render a cJSON entity to text for transfer/storage without any formatting.
cJSON_ReplaceItemInArray(Pointer<cJSON> array, int which, Pointer<cJSON> newitem) → int
cJSON_ReplaceItemInObject(Pointer<cJSON> object, Pointer<Char> string, Pointer<cJSON> newitem) → int
cJSON_ReplaceItemInObjectCaseSensitive(Pointer<cJSON> object, Pointer<Char> string, Pointer<cJSON> newitem) → int
cJSON_ReplaceItemViaPointer(Pointer<cJSON> parent, Pointer<cJSON> item, Pointer<cJSON> replacement) → int
cJSON_SetNumberHelper(Pointer<cJSON> object, double number) → double: helper for the cJSON_SetNumberValue macro
cJSON_SetValuestring(Pointer<cJSON> object, Pointer<Char> valuestring) → Pointer<Char>: Change the valuestring of a cJSON_String object, only takes effect when type of object is cJSON_String
cJSON_Version() → Pointer<Char>: returns the version of cJSON as a string
crypto_aead_init_djb(Pointer<crypto_aead_ctx> ctx, Pointer<Uint8> key, Pointer<Uint8> nonce) → void
crypto_aead_init_ietf(Pointer<crypto_aead_ctx> ctx, Pointer<Uint8> key, Pointer<Uint8> nonce) → void
crypto_aead_init_x(Pointer<crypto_aead_ctx> ctx, Pointer<Uint8> key, Pointer<Uint8> nonce) → void
crypto_aead_lock(Pointer<Uint8> cipher_text, Pointer<Uint8> mac, Pointer<Uint8> key, Pointer<Uint8> nonce, Pointer<Uint8> ad, int ad_size, Pointer<Uint8> plain_text, int text_size) → void: Authenticated encryption
crypto_aead_read(Pointer<crypto_aead_ctx> ctx, Pointer<Uint8> plain_text, Pointer<Uint8> mac, Pointer<Uint8> ad, int ad_size, Pointer<Uint8> cipher_text, int text_size) → int
crypto_aead_unlock(Pointer<Uint8> plain_text, Pointer<Uint8> mac, Pointer<Uint8> key, Pointer<Uint8> nonce, Pointer<Uint8> ad, int ad_size, Pointer<Uint8> cipher_text, int text_size) → int
crypto_aead_write(Pointer<crypto_aead_ctx> ctx, Pointer<Uint8> cipher_text, Pointer<Uint8> mac, Pointer<Uint8> ad, int ad_size, Pointer<Uint8> plain_text, int text_size) → void
crypto_argon2(Pointer<Uint8> hash, int hash_size, Pointer<Void> work_area, crypto_argon2_config config, crypto_argon2_inputs inputs, crypto_argon2_extras extras) → void
crypto_blake2b(Pointer<Uint8> hash, int hash_size, Pointer<Uint8> message, int message_size) → void: Direct interface
crypto_blake2b_final(Pointer<crypto_blake2b_ctx> ctx, Pointer<Uint8> hash) → void
crypto_blake2b_init(Pointer<crypto_blake2b_ctx> ctx, int hash_size) → void
crypto_blake2b_keyed(Pointer<Uint8> hash, int hash_size, Pointer<Uint8> key, int key_size, Pointer<Uint8> message, int message_size) → void
crypto_blake2b_keyed_init(Pointer<crypto_blake2b_ctx> ctx, int hash_size, Pointer<Uint8> key, int key_size) → void
crypto_blake2b_update(Pointer<crypto_blake2b_ctx> ctx, Pointer<Uint8> message, int message_size) → void
crypto_chacha20_djb(Pointer<Uint8> cipher_text, Pointer<Uint8> plain_text, int text_size, Pointer<Uint8> key, Pointer<Uint8> nonce, int ctr) → int: Unauthenticated stream cipher. Don't forget to add authentication.
crypto_chacha20_h(Pointer<Uint8> out, Pointer<Uint8> key, Pointer<Uint8> in$) → void: Specialised hash. Used to hash X25519 shared secrets.
crypto_chacha20_ietf(Pointer<Uint8> cipher_text, Pointer<Uint8> plain_text, int text_size, Pointer<Uint8> key, Pointer<Uint8> nonce, int ctr) → int
crypto_chacha20_x(Pointer<Uint8> cipher_text, Pointer<Uint8> plain_text, int text_size, Pointer<Uint8> key, Pointer<Uint8> nonce, int ctr) → int
crypto_eddsa_check(Pointer<Uint8> signature, Pointer<Uint8> public_key, Pointer<Uint8> message, int message_size) → int
crypto_eddsa_check_equation(Pointer<Uint8> signature, Pointer<Uint8> public_key, Pointer<Uint8> h_ram) → int
crypto_eddsa_key_pair(Pointer<Uint8> secret_key, Pointer<Uint8> public_key, Pointer<Uint8> seed) → void: EdDSA with curve25519 + BLAKE2b
crypto_eddsa_mul_add(Pointer<Uint8> r, Pointer<Uint8> a, Pointer<Uint8> b, Pointer<Uint8> c) → void
crypto_eddsa_reduce(Pointer<Uint8> reduced, Pointer<Uint8> expanded) → void
crypto_eddsa_scalarbase(Pointer<Uint8> point, Pointer<Uint8> scalar) → void
crypto_eddsa_sign(Pointer<Uint8> signature, Pointer<Uint8> secret_key, Pointer<Uint8> message, int message_size) → void
crypto_eddsa_to_x25519(Pointer<Uint8> x25519, Pointer<Uint8> eddsa) → void: Conversion to X25519
crypto_eddsa_trim_scalar(Pointer<Uint8> out, Pointer<Uint8> in$) → void: EdDSA building blocks
crypto_elligator_key_pair(Pointer<Uint8> hidden, Pointer<Uint8> secret_key, Pointer<Uint8> seed) → void: Easy to use key pair generation
crypto_elligator_map(Pointer<Uint8> curve, Pointer<Uint8> hidden) → void: Elligator mappings proper
crypto_elligator_rev(Pointer<Uint8> hidden, Pointer<Uint8> curve, int tweak) → int
crypto_poly1305(Pointer<Uint8> mac, Pointer<Uint8> message, int message_size, Pointer<Uint8> key) → void: Direct interface
crypto_poly1305_final(Pointer<crypto_poly1305_ctx> ctx, Pointer<Uint8> mac) → void
crypto_poly1305_init(Pointer<crypto_poly1305_ctx> ctx, Pointer<Uint8> key) → void
crypto_poly1305_update(Pointer<crypto_poly1305_ctx> ctx, Pointer<Uint8> message, int message_size) → void
crypto_verify16(Pointer<Uint8> a, Pointer<Uint8> b) → int: Return 0 if a and b are equal, -1 otherwise
crypto_verify32(Pointer<Uint8> a, Pointer<Uint8> b) → int
crypto_verify64(Pointer<Uint8> a, Pointer<Uint8> b) → int
crypto_wipe(Pointer<Void> secret, int size) → void: Erase sensitive data
crypto_x25519(Pointer<Uint8> raw_shared_secret, Pointer<Uint8> your_secret_key, Pointer<Uint8> their_public_key) → void
crypto_x25519_dirty_fast(Pointer<Uint8> pk, Pointer<Uint8> sk) → void
crypto_x25519_dirty_small(Pointer<Uint8> pk, Pointer<Uint8> sk) → void: "Dirty" versions of x25519_public_key(). Use with crypto_elligator_rev(). Leaks 3 bits of the private key.
crypto_x25519_inverse(Pointer<Uint8> blind_salt, Pointer<Uint8> private_key, Pointer<Uint8> curve_point) → void: scalar "division" Used for OPRF. Be aware that exponential blinding is less secure than Diffie-Hellman key exchange.
crypto_x25519_public_key(Pointer<Uint8> public_key, Pointer<Uint8> secret_key) → void: Shared secrets are not quite random. Hash them to derive an actual shared key.
crypto_x25519_to_eddsa(Pointer<Uint8> eddsa, Pointer<Uint8> x25519) → void: Conversion to EdDSA
hexwave_change(Pointer<HexWave> hex, int reflect, double peak_time, double half_height, double zero_wait) → void: see docs above for description
hexwave_create(Pointer<HexWave> hex, int reflect, double peak_time, double half_height, double zero_wait) → void: user_buffer: pass in same parameter as passed to hexwave_init
hexwave_generate_samples(Pointer<Float> output, int num_samples, Pointer<HexWave> hex, double freq) → void: see docs
hexwave_init(int width, int oversample, Pointer<Float> user_buffer) → void
hexwave_shutdown(Pointer<Float> user_buffer) → void: width: size of BLEP, from 4..64, larger is slower & more memory but less aliasing oversample: 2+, number of subsample positions, larger uses more memory but less noise user_buffer: optional, if provided the library will perform no allocations. 16width(oversample+1) bytes, must stay allocated as long as library is used technically it only needs: 8*( width * (oversample + 1))
http_body_is_final(Pointer<http_parser> parser) → int: Checks if this is the final chunk of the body.
http_errno_description(http_errno err) → Pointer<Char>
http_errno_name(http_errno err) → Pointer<Char>
http_method_str(http_method m) → Pointer<Char>
http_parser_execute(Pointer<http_parser> parser, Pointer<http_parser_settings> settings, Pointer<Char> data, int len) → int: Executes the parser. Returns number of parsed bytes. Sets parser->http_errno on error.
http_parser_init(Pointer<http_parser> parser, http_parser_type type) → void
http_parser_parse_url(Pointer<Char> buf, int buflen, int is_connect, Pointer<http_parser_url> u) → int: Parse a URL; return nonzero on failure
http_parser_pause(Pointer<http_parser> parser, int paused) → void: Pause or un-pause the parser; a nonzero value pauses
http_parser_set_max_header_size(int size) → void: Change the maximum header size provided at compile time.
http_parser_settings_init(Pointer<http_parser_settings> settings) → void: Initialize http_parser_settings members to 0
http_parser_url_init(Pointer<http_parser_url> u) → void: Initialize all http_parser_url members to 0
http_parser_version() → int: Returns the library version. Bits 16-23 contain the major version number, bits 8-15 the minor version number and bits 0-7 the patch level. Usage example:
http_should_keep_alive(Pointer<http_parser> parser) → int: If http_should_keep_alive() in the on_headers_complete or on_message_complete callback returns 0, then this should be the last message on the connection. If you are the server, respond with the "Connection: close" header. If you are the client, close the connection.
http_status_str(http_status s) → Pointer<Char>
ma_aligned_free(Pointer<Void> p, Pointer<ma_allocation_callbacks> pAllocationCallbacks) → void: Free's an aligned malloc'd buffer.
ma_aligned_malloc(int sz, int alignment, Pointer<ma_allocation_callbacks> pAllocationCallbacks) → Pointer<Void>: Performs an aligned malloc, with the assumption that the alignment is a power of 2.
ma_apply_volume_factor_f32(Pointer<Float> pSamples, int sampleCount, double factor) → void
ma_apply_volume_factor_pcm_frames(Pointer<Void> pFrames, Dartma_uint64 frameCount, ma_format format, Dartma_uint32 channels, double factor) → void
ma_apply_volume_factor_pcm_frames_f32(Pointer<Float> pFrames, int frameCount, int channels, double factor) → void
ma_apply_volume_factor_pcm_frames_s16(Pointer<ma_int16> pFrames, int frameCount, int channels, double factor) → void
ma_apply_volume_factor_pcm_frames_s24(Pointer<Void> pFrames, int frameCount, int channels, double factor) → void
ma_apply_volume_factor_pcm_frames_s32(Pointer<Int> pFrames, int frameCount, int channels, double factor) → void
ma_apply_volume_factor_pcm_frames_u8(Pointer<ma_uint8> pFrames, int frameCount, int channels, double factor) → void
ma_apply_volume_factor_s16(Pointer<ma_int16> pSamples, int sampleCount, double factor) → void
ma_apply_volume_factor_s24(Pointer<Void> pSamples, int sampleCount, double factor) → void
ma_apply_volume_factor_s32(Pointer<Int> pSamples, int sampleCount, double factor) → void
ma_apply_volume_factor_u8(Pointer<ma_uint8> pSamples, int sampleCount, double factor) → void
ma_async_notification_event_init(Pointer<ma_async_notification_event> pNotificationEvent) → ma_result
ma_async_notification_event_signal(Pointer<ma_async_notification_event> pNotificationEvent) → ma_result
ma_async_notification_event_uninit(Pointer<ma_async_notification_event> pNotificationEvent) → ma_result
ma_async_notification_event_wait(Pointer<ma_async_notification_event> pNotificationEvent) → ma_result
ma_async_notification_poll_init(Pointer<ma_async_notification_poll> pNotificationPoll) → ma_result
ma_async_notification_poll_is_signalled(Pointer<ma_async_notification_poll> pNotificationPoll) → int
ma_async_notification_signal(Pointer<Void> pNotification) → ma_result
ma_audio_buffer_alloc_and_init(Pointer<ma_audio_buffer_config> pConfig, Pointer<Pointer<ma_audio_buffer>> ppAudioBuffer) → ma_result
ma_audio_buffer_at_end(Pointer<ma_audio_buffer> pAudioBuffer) → int
ma_audio_buffer_config_init(ma_format format, Dartma_uint32 channels, Dartma_uint64 sizeInFrames, Pointer<Void> pData, Pointer<ma_allocation_callbacks> pAllocationCallbacks) → ma_audio_buffer_config
ma_audio_buffer_get_available_frames(Pointer<ma_audio_buffer> pAudioBuffer, Pointer<ma_uint64> pAvailableFrames) → ma_result
ma_audio_buffer_get_cursor_in_pcm_frames(Pointer<ma_audio_buffer> pAudioBuffer, Pointer<ma_uint64> pCursor) → ma_result
ma_audio_buffer_get_length_in_pcm_frames(Pointer<ma_audio_buffer> pAudioBuffer, Pointer<ma_uint64> pLength) → ma_result
ma_audio_buffer_init(Pointer<ma_audio_buffer_config> pConfig, Pointer<ma_audio_buffer> pAudioBuffer) → ma_result
ma_audio_buffer_init_copy(Pointer<ma_audio_buffer_config> pConfig, Pointer<ma_audio_buffer> pAudioBuffer) → ma_result
ma_audio_buffer_map(Pointer<ma_audio_buffer> pAudioBuffer, Pointer<Pointer<Void>> ppFramesOut, Pointer<ma_uint64> pFrameCount) → ma_result
ma_audio_buffer_read_pcm_frames(Pointer<ma_audio_buffer> pAudioBuffer, Pointer<Void> pFramesOut, int frameCount, int loop) → int
ma_audio_buffer_ref_at_end(Pointer<ma_audio_buffer_ref> pAudioBufferRef) → int
ma_audio_buffer_ref_get_available_frames(Pointer<ma_audio_buffer_ref> pAudioBufferRef, Pointer<ma_uint64> pAvailableFrames) → ma_result
ma_audio_buffer_ref_get_cursor_in_pcm_frames(Pointer<ma_audio_buffer_ref> pAudioBufferRef, Pointer<ma_uint64> pCursor) → ma_result
ma_audio_buffer_ref_get_length_in_pcm_frames(Pointer<ma_audio_buffer_ref> pAudioBufferRef, Pointer<ma_uint64> pLength) → ma_result
ma_audio_buffer_ref_init(ma_format format, Dartma_uint32 channels, Pointer<Void> pData, Dartma_uint64 sizeInFrames, Pointer<ma_audio_buffer_ref> pAudioBufferRef) → ma_result
ma_audio_buffer_ref_map(Pointer<ma_audio_buffer_ref> pAudioBufferRef, Pointer<Pointer<Void>> ppFramesOut, Pointer<ma_uint64> pFrameCount) → ma_result
ma_audio_buffer_ref_read_pcm_frames(Pointer<ma_audio_buffer_ref> pAudioBufferRef, Pointer<Void> pFramesOut, int frameCount, int loop) → int
ma_audio_buffer_ref_seek_to_pcm_frame(Pointer<ma_audio_buffer_ref> pAudioBufferRef, Dartma_uint64 frameIndex) → ma_result
ma_audio_buffer_ref_set_data(Pointer<ma_audio_buffer_ref> pAudioBufferRef, Pointer<Void> pData, Dartma_uint64 sizeInFrames) → ma_result
ma_audio_buffer_ref_uninit(Pointer<ma_audio_buffer_ref> pAudioBufferRef) → void
ma_audio_buffer_ref_unmap(Pointer<ma_audio_buffer_ref> pAudioBufferRef, Dartma_uint64 frameCount) → ma_result
ma_audio_buffer_seek_to_pcm_frame(Pointer<ma_audio_buffer> pAudioBuffer, Dartma_uint64 frameIndex) → ma_result
ma_audio_buffer_uninit(Pointer<ma_audio_buffer> pAudioBuffer) → void
ma_audio_buffer_uninit_and_free(Pointer<ma_audio_buffer> pAudioBuffer) → void
ma_audio_buffer_unmap(Pointer<ma_audio_buffer> pAudioBuffer, Dartma_uint64 frameCount) → ma_result
ma_biquad_clear_cache(Pointer<ma_biquad> pBQ) → ma_result
ma_biquad_config_init(ma_format format, Dartma_uint32 channels, double b0, double b1, double b2, double a0, double a1, double a2) → ma_biquad_config
ma_biquad_get_heap_size(Pointer<ma_biquad_config> pConfig, Pointer<Size> pHeapSizeInBytes) → ma_result
ma_biquad_get_latency(Pointer<ma_biquad> pBQ) → int
ma_biquad_init(Pointer<ma_biquad_config> pConfig, Pointer<ma_allocation_callbacks> pAllocationCallbacks, Pointer<ma_biquad> pBQ) → ma_result
ma_biquad_init_preallocated(Pointer<ma_biquad_config> pConfig, Pointer<Void> pHeap, Pointer<ma_biquad> pBQ) → ma_result
ma_biquad_node_config_init(int channels, double b0, double b1, double b2, double a0, double a1, double a2) → ma_biquad_node_config
ma_biquad_node_init(Pointer<ma_node_graph> pNodeGraph, Pointer<ma_biquad_node_config> pConfig, Pointer<ma_allocation_callbacks> pAllocationCallbacks, Pointer<ma_biquad_node> pNode) → ma_result
ma_biquad_node_reinit(Pointer<ma_biquad_config> pConfig, Pointer<ma_biquad_node> pNode) → ma_result
ma_biquad_node_uninit(Pointer<ma_biquad_node> pNode, Pointer<ma_allocation_callbacks> pAllocationCallbacks) → void
ma_biquad_process_pcm_frames(Pointer<ma_biquad> pBQ, Pointer<Void> pFramesOut, Pointer<Void> pFramesIn, Dartma_uint64 frameCount) → ma_result
ma_biquad_reinit(Pointer<ma_biquad_config> pConfig, Pointer<ma_biquad> pBQ) → ma_result
ma_biquad_uninit(Pointer<ma_biquad> pBQ, Pointer<ma_allocation_callbacks> pAllocationCallbacks) → void
ma_blend_f32(Pointer<Float> pOut, Pointer<Float> pInA, Pointer<Float> pInB, double factor, int channels) → void: Blends two frames in floating point format.
ma_bpf2_config_init(ma_format format, Dartma_uint32 channels, Dartma_uint32 sampleRate, double cutoffFrequency, double q) → ma_bpf2_config
ma_bpf2_get_heap_size(Pointer<ma_bpf2_config> pConfig, Pointer<Size> pHeapSizeInBytes) → ma_result
ma_bpf2_get_latency(Pointer<ma_bpf2> pBPF) → int
ma_bpf2_init(Pointer<ma_bpf2_config> pConfig, Pointer<ma_allocation_callbacks> pAllocationCallbacks, Pointer<ma_bpf2> pBPF) → ma_result
ma_bpf2_init_preallocated(Pointer<ma_bpf2_config> pConfig, Pointer<Void> pHeap, Pointer<ma_bpf2> pBPF) → ma_result
ma_bpf2_process_pcm_frames(Pointer<ma_bpf2> pBPF, Pointer<Void> pFramesOut, Pointer<Void> pFramesIn, Dartma_uint64 frameCount) → ma_result
ma_bpf2_reinit(Pointer<ma_bpf2_config> pConfig, Pointer<ma_bpf2> pBPF) → ma_result
ma_bpf2_uninit(Pointer<ma_bpf2> pBPF, Pointer<ma_allocation_callbacks> pAllocationCallbacks) → void
ma_bpf_config_init(ma_format format, Dartma_uint32 channels, Dartma_uint32 sampleRate, double cutoffFrequency, Dartma_uint32 order) → ma_bpf_config
ma_bpf_get_heap_size(Pointer<ma_bpf_config> pConfig, Pointer<Size> pHeapSizeInBytes) → ma_result
ma_bpf_get_latency(Pointer<ma_bpf> pBPF) → int
ma_bpf_init(Pointer<ma_bpf_config> pConfig, Pointer<ma_allocation_callbacks> pAllocationCallbacks, Pointer<ma_bpf> pBPF) → ma_result
ma_bpf_init_preallocated(Pointer<ma_bpf_config> pConfig, Pointer<Void> pHeap, Pointer<ma_bpf> pBPF) → ma_result
ma_bpf_node_config_init(int channels, int sampleRate, double cutoffFrequency, int order) → ma_bpf_node_config
ma_bpf_node_init(Pointer<ma_node_graph> pNodeGraph, Pointer<ma_bpf_node_config> pConfig, Pointer<ma_allocation_callbacks> pAllocationCallbacks, Pointer<ma_bpf_node> pNode) → ma_result
ma_bpf_node_reinit(Pointer<ma_bpf_config> pConfig, Pointer<ma_bpf_node> pNode) → ma_result
ma_bpf_node_uninit(Pointer<ma_bpf_node> pNode, Pointer<ma_allocation_callbacks> pAllocationCallbacks) → void
ma_bpf_process_pcm_frames(Pointer<ma_bpf> pBPF, Pointer<Void> pFramesOut, Pointer<Void> pFramesIn, Dartma_uint64 frameCount) → ma_result
ma_bpf_reinit(Pointer<ma_bpf_config> pConfig, Pointer<ma_bpf> pBPF) → ma_result
ma_bpf_uninit(Pointer<ma_bpf> pBPF, Pointer<ma_allocation_callbacks> pAllocationCallbacks) → void
ma_calculate_buffer_size_in_frames_from_descriptor(Pointer<ma_device_descriptor> pDescriptor, Dartma_uint32 nativeSampleRate, ma_performance_profile performanceProfile) → Dartma_uint32
ma_calculate_buffer_size_in_frames_from_milliseconds(int bufferSizeInMilliseconds, int sampleRate) → int: Calculates a buffer size in frames from the specified number of milliseconds and sample rate.
ma_calculate_buffer_size_in_milliseconds_from_frames(int bufferSizeInFrames, int sampleRate) → int: Calculates a buffer size in milliseconds (rounded up) from the specified number of frames and sample rate.
ma_calloc(int sz, Pointer<ma_allocation_callbacks> pAllocationCallbacks) → Pointer<Void>: calloc()
ma_channel_converter_config_init(ma_format format, Dartma_uint32 channelsIn, Pointer<ma_uint8> pChannelMapIn, Dartma_uint32 channelsOut, Pointer<ma_uint8> pChannelMapOut, ma_channel_mix_mode mixingMode) → ma_channel_converter_config
ma_channel_converter_get_heap_size(Pointer<ma_channel_converter_config> pConfig, Pointer<Size> pHeapSizeInBytes) → ma_result
ma_channel_converter_get_input_channel_map(Pointer<ma_channel_converter> pConverter, Pointer<ma_uint8> pChannelMap, int channelMapCap) → ma_result
ma_channel_converter_get_output_channel_map(Pointer<ma_channel_converter> pConverter, Pointer<ma_uint8> pChannelMap, int channelMapCap) → ma_result
ma_channel_converter_init(Pointer<ma_channel_converter_config> pConfig, Pointer<ma_allocation_callbacks> pAllocationCallbacks, Pointer<ma_channel_converter> pConverter) → ma_result
ma_channel_converter_init_preallocated(Pointer<ma_channel_converter_config> pConfig, Pointer<Void> pHeap, Pointer<ma_channel_converter> pConverter) → ma_result
ma_channel_converter_process_pcm_frames(Pointer<ma_channel_converter> pConverter, Pointer<Void> pFramesOut, Pointer<Void> pFramesIn, Dartma_uint64 frameCount) → ma_result
ma_channel_converter_uninit(Pointer<ma_channel_converter> pConverter, Pointer<ma_allocation_callbacks> pAllocationCallbacks) → void
ma_channel_map_contains_channel_position(int channels, Pointer<ma_uint8> pChannelMap, int channelPosition) → int: Helper for determining whether or not a channel is present in the given channel map.
ma_channel_map_copy(Pointer<ma_uint8> pOut, Pointer<ma_uint8> pIn, int channels) → void: Copies a channel map.
ma_channel_map_copy_or_default(Pointer<ma_uint8> pOut, int channelMapCapOut, Pointer<ma_uint8> pIn, int channels) → void: Copies a channel map if one is specified, otherwise copies the default channel map.
ma_channel_map_find_channel_position(int channels, Pointer<ma_uint8> pChannelMap, int channelPosition, Pointer<ma_uint32> pChannelIndex) → int: Find a channel position in the given channel map. Returns MA_TRUE if the channel is found; MA_FALSE otherwise. The index of the channel is output to pChannelIndex.
ma_channel_map_get_channel(Pointer<ma_uint8> pChannelMap, int channelCount, int channelIndex) → int: Retrieves the channel position of the specified channel in the given channel map.
ma_channel_map_init_blank(Pointer<ma_uint8> pChannelMap, int channels) → void: Initializes a blank channel map.
ma_channel_map_init_standard(ma_standard_channel_map standardChannelMap, Pointer<ma_uint8> pChannelMap, int channelMapCap, Dartma_uint32 channels) → void
ma_channel_map_is_blank(Pointer<ma_uint8> pChannelMap, int channels) → int: Helper for determining if a channel map is blank (all channels set to MA_CHANNEL_NONE).
ma_channel_map_is_equal(Pointer<ma_uint8> pChannelMapA, Pointer<ma_uint8> pChannelMapB, int channels) → int: Helper for comparing two channel maps for equality.
ma_channel_map_is_valid(Pointer<ma_uint8> pChannelMap, int channels) → int: Determines whether or not a channel map is valid.
ma_channel_map_to_string(Pointer<ma_uint8> pChannelMap, int channels, Pointer<Char> pBufferOut, int bufferCap) → int: Generates a string representing the given channel map.
ma_channel_position_to_string(int channel) → Pointer<Char>: Retrieves a human readable version of a channel position.
ma_clip_pcm_frames(Pointer<Void> pDst, Pointer<Void> pSrc, Dartma_uint64 frameCount, ma_format format, Dartma_uint32 channels) → void
ma_clip_samples_f32(Pointer<Float> pDst, Pointer<Float> pSrc, int count) → void
ma_clip_samples_s16(Pointer<ma_int16> pDst, Pointer<Int> pSrc, int count) → void
ma_clip_samples_s24(Pointer<ma_uint8> pDst, Pointer<ma_int64> pSrc, int count) → void
ma_clip_samples_s32(Pointer<Int> pDst, Pointer<ma_int64> pSrc, int count) → void
ma_clip_samples_u8(Pointer<ma_uint8> pDst, Pointer<ma_int16> pSrc, int count) → void: Clips samples.
ma_context_config_init() → ma_context_config: Initializes a ma_context_config object.
ma_context_enumerate_devices(Pointer<ma_context> pContext, ma_enum_devices_callback_proc callback, Pointer<Void> pUserData) → ma_result
ma_context_get_device_info(Pointer<ma_context> pContext, ma_device_type deviceType, Pointer<ma_device_id> pDeviceID, Pointer<ma_device_info> pDeviceInfo) → ma_result
ma_context_get_devices(Pointer<ma_context> pContext, Pointer<Pointer<ma_device_info>> ppPlaybackDeviceInfos, Pointer<ma_uint32> pPlaybackDeviceCount, Pointer<Pointer<ma_device_info>> ppCaptureDeviceInfos, Pointer<ma_uint32> pCaptureDeviceCount) → ma_result
ma_context_get_log(Pointer<ma_context> pContext) → Pointer<ma_log>: Retrieves a pointer to the log object associated with this context.
ma_context_init(Pointer<ma_uint32> backends, Dartma_uint32 backendCount, Pointer<ma_context_config> pConfig, Pointer<ma_context> pContext) → ma_result
ma_context_is_loopback_supported(Pointer<ma_context> pContext) → int: Determines if the given context supports loopback mode.
ma_context_sizeof() → int: Retrieves the size of the ma_context object.
ma_context_uninit(Pointer<ma_context> pContext) → ma_result
ma_convert_frames(Pointer<Void> pOut, Dartma_uint64 frameCountOut, ma_format formatOut, Dartma_uint32 channelsOut, Dartma_uint32 sampleRateOut, Pointer<Void> pIn, Dartma_uint64 frameCountIn, ma_format formatIn, Dartma_uint32 channelsIn, Dartma_uint32 sampleRateIn) → Dartma_uint64
ma_convert_frames_ex(Pointer<Void> pOut, int frameCountOut, Pointer<Void> pIn, int frameCountIn, Pointer<ma_data_converter_config> pConfig) → int
ma_convert_pcm_frames_format(Pointer<Void> pOut, ma_format formatOut, Pointer<Void> pIn, ma_format formatIn, Dartma_uint64 frameCount, Dartma_uint32 channels, ma_dither_mode ditherMode) → void
ma_copy_and_apply_volume_and_clip_pcm_frames(Pointer<Void> pDst, Pointer<Void> pSrc, Dartma_uint64 frameCount, ma_format format, Dartma_uint32 channels, double volume) → void
ma_copy_and_apply_volume_and_clip_samples_f32(Pointer<Float> pDst, Pointer<Float> pSrc, int count, double volume) → void
ma_copy_and_apply_volume_and_clip_samples_s16(Pointer<ma_int16> pDst, Pointer<Int> pSrc, int count, double volume) → void
ma_copy_and_apply_volume_and_clip_samples_s24(Pointer<ma_uint8> pDst, Pointer<ma_int64> pSrc, int count, double volume) → void
ma_copy_and_apply_volume_and_clip_samples_s32(Pointer<Int> pDst, Pointer<ma_int64> pSrc, int count, double volume) → void
ma_copy_and_apply_volume_and_clip_samples_u8(Pointer<ma_uint8> pDst, Pointer<ma_int16> pSrc, int count, double volume) → void
ma_copy_and_apply_volume_factor_f32(Pointer<Float> pSamplesOut, Pointer<Float> pSamplesIn, int sampleCount, double factor) → void
ma_copy_and_apply_volume_factor_pcm_frames(Pointer<Void> pFramesOut, Pointer<Void> pFramesIn, Dartma_uint64 frameCount, ma_format format, Dartma_uint32 channels, double factor) → void
ma_copy_and_apply_volume_factor_pcm_frames_f32(Pointer<Float> pFramesOut, Pointer<Float> pFramesIn, int frameCount, int channels, double factor) → void
ma_copy_and_apply_volume_factor_pcm_frames_s16(Pointer<ma_int16> pFramesOut, Pointer<ma_int16> pFramesIn, int frameCount, int channels, double factor) → void
ma_copy_and_apply_volume_factor_pcm_frames_s24(Pointer<Void> pFramesOut, Pointer<Void> pFramesIn, int frameCount, int channels, double factor) → void
ma_copy_and_apply_volume_factor_pcm_frames_s32(Pointer<Int> pFramesOut, Pointer<Int> pFramesIn, int frameCount, int channels, double factor) → void
ma_copy_and_apply_volume_factor_pcm_frames_u8(Pointer<ma_uint8> pFramesOut, Pointer<ma_uint8> pFramesIn, int frameCount, int channels, double factor) → void
ma_copy_and_apply_volume_factor_per_channel_f32(Pointer<Float> pFramesOut, Pointer<Float> pFramesIn, int frameCount, int channels, Pointer<Float> pChannelGains) → void
ma_copy_and_apply_volume_factor_s16(Pointer<ma_int16> pSamplesOut, Pointer<ma_int16> pSamplesIn, int sampleCount, double factor) → void
ma_copy_and_apply_volume_factor_s24(Pointer<Void> pSamplesOut, Pointer<Void> pSamplesIn, int sampleCount, double factor) → void
ma_copy_and_apply_volume_factor_s32(Pointer<Int> pSamplesOut, Pointer<Int> pSamplesIn, int sampleCount, double factor) → void
ma_copy_and_apply_volume_factor_u8(Pointer<ma_uint8> pSamplesOut, Pointer<ma_uint8> pSamplesIn, int sampleCount, double factor) → void: Helper for applying a volume factor to samples.
ma_copy_pcm_frames(Pointer<Void> dst, Pointer<Void> src, Dartma_uint64 frameCount, ma_format format, Dartma_uint32 channels) → void
ma_data_converter_config_init(ma_format formatIn, ma_format formatOut, Dartma_uint32 channelsIn, Dartma_uint32 channelsOut, Dartma_uint32 sampleRateIn, Dartma_uint32 sampleRateOut) → ma_data_converter_config
ma_data_converter_config_init_default() → ma_data_converter_config
ma_data_converter_get_expected_output_frame_count(Pointer<ma_data_converter> pConverter, Dartma_uint64 inputFrameCount, Pointer<ma_uint64> pOutputFrameCount) → ma_result
ma_data_converter_get_heap_size(Pointer<ma_data_converter_config> pConfig, Pointer<Size> pHeapSizeInBytes) → ma_result
ma_data_converter_get_input_channel_map(Pointer<ma_data_converter> pConverter, Pointer<ma_uint8> pChannelMap, int channelMapCap) → ma_result
ma_data_converter_get_input_latency(Pointer<ma_data_converter> pConverter) → int
ma_data_converter_get_output_channel_map(Pointer<ma_data_converter> pConverter, Pointer<ma_uint8> pChannelMap, int channelMapCap) → ma_result
ma_data_converter_get_output_latency(Pointer<ma_data_converter> pConverter) → int
ma_data_converter_get_required_input_frame_count(Pointer<ma_data_converter> pConverter, Dartma_uint64 outputFrameCount, Pointer<ma_uint64> pInputFrameCount) → ma_result
ma_data_converter_init(Pointer<ma_data_converter_config> pConfig, Pointer<ma_allocation_callbacks> pAllocationCallbacks, Pointer<ma_data_converter> pConverter) → ma_result
ma_data_converter_init_preallocated(Pointer<ma_data_converter_config> pConfig, Pointer<Void> pHeap, Pointer<ma_data_converter> pConverter) → ma_result
ma_data_converter_process_pcm_frames(Pointer<ma_data_converter> pConverter, Pointer<Void> pFramesIn, Pointer<ma_uint64> pFrameCountIn, Pointer<Void> pFramesOut, Pointer<ma_uint64> pFrameCountOut) → ma_result
ma_data_converter_reset(Pointer<ma_data_converter> pConverter) → ma_result
ma_data_converter_set_rate(Pointer<ma_data_converter> pConverter, Dartma_uint32 sampleRateIn, Dartma_uint32 sampleRateOut) → ma_result
ma_data_converter_set_rate_ratio(Pointer<ma_data_converter> pConverter, double ratioInOut) → ma_result
ma_data_converter_uninit(Pointer<ma_data_converter> pConverter, Pointer<ma_allocation_callbacks> pAllocationCallbacks) → void
ma_data_source_config_init() → ma_data_source_config
ma_data_source_get_current(Pointer<Void> pDataSource) → Pointer<Void>
ma_data_source_get_cursor_in_pcm_frames(Pointer<Void> pDataSource, Pointer<ma_uint64> pCursor) → ma_result
ma_data_source_get_cursor_in_seconds(Pointer<Void> pDataSource, Pointer<Float> pCursor) → ma_result
ma_data_source_get_data_format(Pointer<Void> pDataSource, Pointer<ma_uint32> pFormat, Pointer<ma_uint32> pChannels, Pointer<ma_uint32> pSampleRate, Pointer<ma_uint8> pChannelMap, int channelMapCap) → ma_result
ma_data_source_get_length_in_pcm_frames(Pointer<Void> pDataSource, Pointer<ma_uint64> pLength) → ma_result
ma_data_source_get_length_in_seconds(Pointer<Void> pDataSource, Pointer<Float> pLength) → ma_result
ma_data_source_get_loop_point_in_pcm_frames(Pointer<Void> pDataSource, Pointer<ma_uint64> pLoopBegInFrames, Pointer<ma_uint64> pLoopEndInFrames) → void
ma_data_source_get_next(Pointer<Void> pDataSource) → Pointer<Void>
ma_data_source_get_next_callback(Pointer<Void> pDataSource) → ma_data_source_get_next_proc
ma_data_source_get_range_in_pcm_frames(Pointer<Void> pDataSource, Pointer<ma_uint64> pRangeBegInFrames, Pointer<ma_uint64> pRangeEndInFrames) → void
ma_data_source_init(Pointer<ma_data_source_config> pConfig, Pointer<Void> pDataSource) → ma_result
ma_data_source_is_looping(Pointer<Void> pDataSource) → int
ma_data_source_node_config_init(Pointer<Void> pDataSource) → ma_data_source_node_config
ma_data_source_node_init(Pointer<ma_node_graph> pNodeGraph, Pointer<ma_data_source_node_config> pConfig, Pointer<ma_allocation_callbacks> pAllocationCallbacks, Pointer<ma_data_source_node> pDataSourceNode) → ma_result
ma_data_source_node_is_looping(Pointer<ma_data_source_node> pDataSourceNode) → int
ma_data_source_node_set_looping(Pointer<ma_data_source_node> pDataSourceNode, Dartma_uint32 isLooping) → ma_result
ma_data_source_node_uninit(Pointer<ma_data_source_node> pDataSourceNode, Pointer<ma_allocation_callbacks> pAllocationCallbacks) → void
ma_data_source_read_pcm_frames(Pointer<Void> pDataSource, Pointer<Void> pFramesOut, Dartma_uint64 frameCount, Pointer<ma_uint64> pFramesRead) → ma_result
ma_data_source_seek_pcm_frames(Pointer<Void> pDataSource, Dartma_uint64 frameCount, Pointer<ma_uint64> pFramesSeeked) → ma_result
ma_data_source_seek_seconds(Pointer<Void> pDataSource, double secondCount, Pointer<Float> pSecondsSeeked) → ma_result
ma_data_source_seek_to_pcm_frame(Pointer<Void> pDataSource, Dartma_uint64 frameIndex) → ma_result
ma_data_source_seek_to_second(Pointer<Void> pDataSource, double seekPointInSeconds) → ma_result
ma_data_source_set_current(Pointer<Void> pDataSource, Pointer<Void> pCurrentDataSource) → ma_result
ma_data_source_set_loop_point_in_pcm_frames(Pointer<Void> pDataSource, Dartma_uint64 loopBegInFrames, Dartma_uint64 loopEndInFrames) → ma_result
ma_data_source_set_looping(Pointer<Void> pDataSource, Dartma_uint32 isLooping) → ma_result
ma_data_source_set_next(Pointer<Void> pDataSource, Pointer<Void> pNextDataSource) → ma_result
ma_data_source_set_next_callback(Pointer<Void> pDataSource, ma_data_source_get_next_proc onGetNext) → ma_result
ma_data_source_set_range_in_pcm_frames(Pointer<Void> pDataSource, Dartma_uint64 rangeBegInFrames, Dartma_uint64 rangeEndInFrames) → ma_result
ma_data_source_uninit(Pointer<Void> pDataSource) → void
ma_decode_file(Pointer<Char> pFilePath, Pointer<ma_decoder_config> pConfig, Pointer<ma_uint64> pFrameCountOut, Pointer<Pointer<Void>> ppPCMFramesOut) → ma_result
ma_decode_from_vfs(Pointer<Void> pVFS, Pointer<Char> pFilePath, Pointer<ma_decoder_config> pConfig, Pointer<ma_uint64> pFrameCountOut, Pointer<Pointer<Void>> ppPCMFramesOut) → ma_result
ma_decode_memory(Pointer<Void> pData, int dataSize, Pointer<ma_decoder_config> pConfig, Pointer<ma_uint64> pFrameCountOut, Pointer<Pointer<Void>> ppPCMFramesOut) → ma_result
ma_decoder_config_init(ma_format outputFormat, Dartma_uint32 outputChannels, Dartma_uint32 outputSampleRate) → ma_decoder_config
ma_decoder_config_init_default() → ma_decoder_config
ma_decoder_get_available_frames(Pointer<ma_decoder> pDecoder, Pointer<ma_uint64> pAvailableFrames) → ma_result
ma_decoder_get_cursor_in_pcm_frames(Pointer<ma_decoder> pDecoder, Pointer<ma_uint64> pCursor) → ma_result
ma_decoder_get_data_format(Pointer<ma_decoder> pDecoder, Pointer<ma_uint32> pFormat, Pointer<ma_uint32> pChannels, Pointer<ma_uint32> pSampleRate, Pointer<ma_uint8> pChannelMap, int channelMapCap) → ma_result
ma_decoder_get_length_in_pcm_frames(Pointer<ma_decoder> pDecoder, Pointer<ma_uint64> pLength) → ma_result
ma_decoder_init(ma_decoder_read_proc onRead, ma_decoder_seek_proc onSeek, Pointer<Void> pUserData, Pointer<ma_decoder_config> pConfig, Pointer<ma_decoder> pDecoder) → ma_result
ma_decoder_init_file(Pointer<Char> pFilePath, Pointer<ma_decoder_config> pConfig, Pointer<ma_decoder> pDecoder) → ma_result
ma_decoder_init_file_w(Pointer<WChar> pFilePath, Pointer<ma_decoder_config> pConfig, Pointer<ma_decoder> pDecoder) → ma_result
ma_decoder_init_memory(Pointer<Void> pData, int dataSize, Pointer<ma_decoder_config> pConfig, Pointer<ma_decoder> pDecoder) → ma_result
ma_decoder_init_vfs(Pointer<Void> pVFS, Pointer<Char> pFilePath, Pointer<ma_decoder_config> pConfig, Pointer<ma_decoder> pDecoder) → ma_result
ma_decoder_init_vfs_w(Pointer<Void> pVFS, Pointer<WChar> pFilePath, Pointer<ma_decoder_config> pConfig, Pointer<ma_decoder> pDecoder) → ma_result
ma_decoder_read_pcm_frames(Pointer<ma_decoder> pDecoder, Pointer<Void> pFramesOut, Dartma_uint64 frameCount, Pointer<ma_uint64> pFramesRead) → ma_result
ma_decoder_seek_to_pcm_frame(Pointer<ma_decoder> pDecoder, Dartma_uint64 frameIndex) → ma_result
ma_decoder_uninit(Pointer<ma_decoder> pDecoder) → ma_result
ma_decoding_backend_config_init(ma_format preferredFormat, Dartma_uint32 seekPointCount) → ma_decoding_backend_config
ma_default_vfs_init(Pointer<ma_default_vfs> pVFS, Pointer<ma_allocation_callbacks> pAllocationCallbacks) → ma_result
ma_deinterleave_pcm_frames(ma_format format, Dartma_uint32 channels, Dartma_uint64 frameCount, Pointer<Void> pInterleavedPCMFrames, Pointer<Pointer<Void>> ppDeinterleavedPCMFrames) → void
ma_delay_config_init(int channels, int sampleRate, int delayInFrames, double decay) → ma_delay_config
ma_delay_get_decay(Pointer<ma_delay> pDelay) → double
ma_delay_get_dry(Pointer<ma_delay> pDelay) → double
ma_delay_get_wet(Pointer<ma_delay> pDelay) → double
ma_delay_init(Pointer<ma_delay_config> pConfig, Pointer<ma_allocation_callbacks> pAllocationCallbacks, Pointer<ma_delay> pDelay) → ma_result
ma_delay_node_config_init(int channels, int sampleRate, int delayInFrames, double decay) → ma_delay_node_config
ma_delay_node_get_decay(Pointer<ma_delay_node> pDelayNode) → double
ma_delay_node_get_dry(Pointer<ma_delay_node> pDelayNode) → double
ma_delay_node_get_wet(Pointer<ma_delay_node> pDelayNode) → double
ma_delay_node_init(Pointer<ma_node_graph> pNodeGraph, Pointer<ma_delay_node_config> pConfig, Pointer<ma_allocation_callbacks> pAllocationCallbacks, Pointer<ma_delay_node> pDelayNode) → ma_result
ma_delay_node_set_decay(Pointer<ma_delay_node> pDelayNode, double value) → void
ma_delay_node_set_dry(Pointer<ma_delay_node> pDelayNode, double value) → void
ma_delay_node_set_wet(Pointer<ma_delay_node> pDelayNode, double value) → void
ma_delay_node_uninit(Pointer<ma_delay_node> pDelayNode, Pointer<ma_allocation_callbacks> pAllocationCallbacks) → void
ma_delay_process_pcm_frames(Pointer<ma_delay> pDelay, Pointer<Void> pFramesOut, Pointer<Void> pFramesIn, Dartma_uint32 frameCount) → ma_result
ma_delay_set_decay(Pointer<ma_delay> pDelay, double value) → void
ma_delay_set_dry(Pointer<ma_delay> pDelay, double value) → void
ma_delay_set_wet(Pointer<ma_delay> pDelay, double value) → void
ma_delay_uninit(Pointer<ma_delay> pDelay, Pointer<ma_allocation_callbacks> pAllocationCallbacks) → void
ma_device_config_init(ma_device_type deviceType) → ma_device_config
ma_device_get_context(Pointer<ma_device> pDevice) → Pointer<ma_context>: Retrieves a pointer to the context that owns the given device.
ma_device_get_info(Pointer<ma_device> pDevice, ma_device_type type, Pointer<ma_device_info> pDeviceInfo) → ma_result
ma_device_get_log(Pointer<ma_device> pDevice) → Pointer<ma_log>: Helper function for retrieving the log object associated with the context that owns this device.
ma_device_get_master_volume(Pointer<ma_device> pDevice, Pointer<Float> pVolume) → ma_result
ma_device_get_master_volume_db(Pointer<ma_device> pDevice, Pointer<Float> pGainDB) → ma_result
ma_device_get_name(Pointer<ma_device> pDevice, ma_device_type type, Pointer<Char> pName, int nameCap, Pointer<Size> pLengthNotIncludingNullTerminator) → ma_result
ma_device_get_state(Pointer<ma_device> pDevice) → ma_device_state
ma_device_handle_backend_data_callback(Pointer<ma_device> pDevice, Pointer<Void> pOutput, Pointer<Void> pInput, Dartma_uint32 frameCount) → ma_result
ma_device_id_equal(Pointer<ma_device_id> pA, Pointer<ma_device_id> pB) → int
ma_device_init(Pointer<ma_context> pContext, Pointer<ma_device_config> pConfig, Pointer<ma_device> pDevice) → ma_result
ma_device_init_ex(Pointer<ma_uint32> backends, Dartma_uint32 backendCount, Pointer<ma_context_config> pContextConfig, Pointer<ma_device_config> pConfig, Pointer<ma_device> pDevice) → ma_result
ma_device_is_started(Pointer<ma_device> pDevice) → int: Determines whether or not the device is started.
ma_device_job_thread_config_init() → ma_device_job_thread_config
ma_device_job_thread_init(Pointer<ma_device_job_thread_config> pConfig, Pointer<ma_allocation_callbacks> pAllocationCallbacks, Pointer<ma_device_job_thread> pJobThread) → ma_result
ma_device_job_thread_next(Pointer<ma_device_job_thread> pJobThread, Pointer<ma_job> pJob) → ma_result
ma_device_job_thread_post(Pointer<ma_device_job_thread> pJobThread, Pointer<ma_job> pJob) → ma_result
ma_device_job_thread_uninit(Pointer<ma_device_job_thread> pJobThread, Pointer<ma_allocation_callbacks> pAllocationCallbacks) → void
ma_device_post_init(Pointer<ma_device> pDevice, ma_device_type deviceType, Pointer<ma_device_descriptor> pPlaybackDescriptor, Pointer<ma_device_descriptor> pCaptureDescriptor) → ma_result
ma_device_set_master_volume(Pointer<ma_device> pDevice, double volume) → ma_result
ma_device_set_master_volume_db(Pointer<ma_device> pDevice, double gainDB) → ma_result
ma_device_start(Pointer<ma_device> pDevice) → ma_result
ma_device_stop(Pointer<ma_device> pDevice) → ma_result
ma_device_uninit(Pointer<ma_device> pDevice) → void: Uninitializes a device.
ma_duplex_rb_init(ma_format captureFormat, Dartma_uint32 captureChannels, Dartma_uint32 sampleRate, Dartma_uint32 captureInternalSampleRate, Dartma_uint32 captureInternalPeriodSizeInFrames, Pointer<ma_allocation_callbacks> pAllocationCallbacks, Pointer<ma_duplex_rb> pRB) → ma_result
ma_duplex_rb_uninit(Pointer<ma_duplex_rb> pRB) → ma_result
ma_encoder_config_init(ma_encoding_format encodingFormat, ma_format format, Dartma_uint32 channels, Dartma_uint32 sampleRate) → ma_encoder_config
ma_encoder_init(ma_encoder_write_proc onWrite, ma_encoder_seek_proc onSeek, Pointer<Void> pUserData, Pointer<ma_encoder_config> pConfig, Pointer<ma_encoder> pEncoder) → ma_result
ma_encoder_init_file(Pointer<Char> pFilePath, Pointer<ma_encoder_config> pConfig, Pointer<ma_encoder> pEncoder) → ma_result
ma_encoder_init_file_w(Pointer<WChar> pFilePath, Pointer<ma_encoder_config> pConfig, Pointer<ma_encoder> pEncoder) → ma_result
ma_encoder_init_vfs(Pointer<Void> pVFS, Pointer<Char> pFilePath, Pointer<ma_encoder_config> pConfig, Pointer<ma_encoder> pEncoder) → ma_result
ma_encoder_init_vfs_w(Pointer<Void> pVFS, Pointer<WChar> pFilePath, Pointer<ma_encoder_config> pConfig, Pointer<ma_encoder> pEncoder) → ma_result
ma_encoder_uninit(Pointer<ma_encoder> pEncoder) → void
ma_encoder_write_pcm_frames(Pointer<ma_encoder> pEncoder, Pointer<Void> pFramesIn, Dartma_uint64 frameCount, Pointer<ma_uint64> pFramesWritten) → ma_result
ma_engine_config_init() → ma_engine_config
ma_engine_find_closest_listener(Pointer<ma_engine> pEngine, double absolutePosX, double absolutePosY, double absolutePosZ) → int
ma_engine_get_channels(Pointer<ma_engine> pEngine) → int
ma_engine_get_device(Pointer<ma_engine> pEngine) → Pointer<ma_device>
ma_engine_get_endpoint(Pointer<ma_engine> pEngine) → Pointer<Void>
ma_engine_get_gain_db(Pointer<ma_engine> pEngine) → double
ma_engine_get_listener_count(Pointer<ma_engine> pEngine) → int
ma_engine_get_log(Pointer<ma_engine> pEngine) → Pointer<ma_log>
ma_engine_get_node_graph(Pointer<ma_engine> pEngine) → Pointer<ma_node_graph>
ma_engine_get_resource_manager(Pointer<ma_engine> pEngine) → Pointer<ma_resource_manager>
ma_engine_get_sample_rate(Pointer<ma_engine> pEngine) → int
ma_engine_get_time(Pointer<ma_engine> pEngine) → int
ma_engine_get_time_in_milliseconds(Pointer<ma_engine> pEngine) → int
ma_engine_get_time_in_pcm_frames(Pointer<ma_engine> pEngine) → int
ma_engine_get_volume(Pointer<ma_engine> pEngine) → double
ma_engine_init(Pointer<ma_engine_config> pConfig, Pointer<ma_engine> pEngine) → ma_result
ma_engine_listener_get_cone(Pointer<ma_engine> pEngine, int listenerIndex, Pointer<Float> pInnerAngleInRadians, Pointer<Float> pOuterAngleInRadians, Pointer<Float> pOuterGain) → void
ma_engine_listener_get_direction(Pointer<ma_engine> pEngine, int listenerIndex) → ma_vec3f
ma_engine_listener_get_position(Pointer<ma_engine> pEngine, int listenerIndex) → ma_vec3f
ma_engine_listener_get_velocity(Pointer<ma_engine> pEngine, int listenerIndex) → ma_vec3f
ma_engine_listener_get_world_up(Pointer<ma_engine> pEngine, int listenerIndex) → ma_vec3f
ma_engine_listener_is_enabled(Pointer<ma_engine> pEngine, int listenerIndex) → int
ma_engine_listener_set_cone(Pointer<ma_engine> pEngine, int listenerIndex, double innerAngleInRadians, double outerAngleInRadians, double outerGain) → void
ma_engine_listener_set_direction(Pointer<ma_engine> pEngine, int listenerIndex, double x, double y, double z) → void
ma_engine_listener_set_enabled(Pointer<ma_engine> pEngine, int listenerIndex, int isEnabled) → void
ma_engine_listener_set_position(Pointer<ma_engine> pEngine, int listenerIndex, double x, double y, double z) → void
ma_engine_listener_set_velocity(Pointer<ma_engine> pEngine, int listenerIndex, double x, double y, double z) → void
ma_engine_listener_set_world_up(Pointer<ma_engine> pEngine, int listenerIndex, double x, double y, double z) → void
ma_engine_node_config_init(Pointer<ma_engine> pEngine, ma_engine_node_type type, Dartma_uint32 flags$1) → ma_engine_node_config
ma_engine_node_get_heap_size(Pointer<ma_engine_node_config> pConfig, Pointer<Size> pHeapSizeInBytes) → ma_result
ma_engine_node_init(Pointer<ma_engine_node_config> pConfig, Pointer<ma_allocation_callbacks> pAllocationCallbacks, Pointer<ma_engine_node> pEngineNode) → ma_result
ma_engine_node_init_preallocated(Pointer<ma_engine_node_config> pConfig, Pointer<Void> pHeap, Pointer<ma_engine_node> pEngineNode) → ma_result
ma_engine_node_uninit(Pointer<ma_engine_node> pEngineNode, Pointer<ma_allocation_callbacks> pAllocationCallbacks) → void
ma_engine_play_sound(Pointer<ma_engine> pEngine, Pointer<Char> pFilePath, Pointer<ma_sound_group> pGroup) → ma_result
ma_engine_play_sound_ex(Pointer<ma_engine> pEngine, Pointer<Char> pFilePath, Pointer<Void> pNode, Dartma_uint32 nodeInputBusIndex) → ma_result
ma_engine_read_pcm_frames(Pointer<ma_engine> pEngine, Pointer<Void> pFramesOut, Dartma_uint64 frameCount, Pointer<ma_uint64> pFramesRead) → ma_result
ma_engine_set_gain_db(Pointer<ma_engine> pEngine, double gainDB) → ma_result
ma_engine_set_time(Pointer<ma_engine> pEngine, Dartma_uint64 globalTime) → ma_result
ma_engine_set_time_in_milliseconds(Pointer<ma_engine> pEngine, Dartma_uint64 globalTime) → ma_result
ma_engine_set_time_in_pcm_frames(Pointer<ma_engine> pEngine, Dartma_uint64 globalTime) → ma_result
ma_engine_set_volume(Pointer<ma_engine> pEngine, double volume) → ma_result
ma_engine_start(Pointer<ma_engine> pEngine) → ma_result
ma_engine_stop(Pointer<ma_engine> pEngine) → ma_result
ma_engine_uninit(Pointer<ma_engine> pEngine) → void
ma_event_init(Pointer<ma_event> pEvent) → ma_result
ma_event_signal(Pointer<ma_event> pEvent) → ma_result
ma_event_uninit(Pointer<ma_event> pEvent) → void: Uninitializes an auto-reset event.
ma_event_wait(Pointer<ma_event> pEvent) → ma_result
ma_fader_config_init(ma_format format, Dartma_uint32 channels, Dartma_uint32 sampleRate) → ma_fader_config
ma_fader_get_current_volume(Pointer<ma_fader> pFader) → double
ma_fader_get_data_format(Pointer<ma_fader> pFader, Pointer<ma_uint32> pFormat, Pointer<ma_uint32> pChannels, Pointer<ma_uint32> pSampleRate) → void
ma_fader_init(Pointer<ma_fader_config> pConfig, Pointer<ma_fader> pFader) → ma_result
ma_fader_process_pcm_frames(Pointer<ma_fader> pFader, Pointer<Void> pFramesOut, Pointer<Void> pFramesIn, Dartma_uint64 frameCount) → ma_result
ma_fader_set_fade(Pointer<ma_fader> pFader, double volumeBeg, double volumeEnd, int lengthInFrames) → void
ma_fader_set_fade_ex(Pointer<ma_fader> pFader, double volumeBeg, double volumeEnd, int lengthInFrames, int startOffsetInFrames) → void
ma_fence_acquire(Pointer<ma_fence> pFence) → ma_result
ma_fence_init(Pointer<ma_fence> pFence) → ma_result
ma_fence_release(Pointer<ma_fence> pFence) → ma_result
ma_fence_uninit(Pointer<ma_fence> pFence) → void
ma_fence_wait(Pointer<ma_fence> pFence) → ma_result
ma_free(Pointer<Void> p, Pointer<ma_allocation_callbacks> pAllocationCallbacks) → void: free()
ma_gainer_config_init(int channels, int smoothTimeInFrames) → ma_gainer_config
ma_gainer_get_heap_size(Pointer<ma_gainer_config> pConfig, Pointer<Size> pHeapSizeInBytes) → ma_result
ma_gainer_get_master_volume(Pointer<ma_gainer> pGainer, Pointer<Float> pVolume) → ma_result
ma_gainer_init(Pointer<ma_gainer_config> pConfig, Pointer<ma_allocation_callbacks> pAllocationCallbacks, Pointer<ma_gainer> pGainer) → ma_result
ma_gainer_init_preallocated(Pointer<ma_gainer_config> pConfig, Pointer<Void> pHeap, Pointer<ma_gainer> pGainer) → ma_result
ma_gainer_process_pcm_frames(Pointer<ma_gainer> pGainer, Pointer<Void> pFramesOut, Pointer<Void> pFramesIn, Dartma_uint64 frameCount) → ma_result
ma_gainer_set_gain(Pointer<ma_gainer> pGainer, double newGain) → ma_result
ma_gainer_set_gains(Pointer<ma_gainer> pGainer, Pointer<Float> pNewGains) → ma_result
ma_gainer_set_master_volume(Pointer<ma_gainer> pGainer, double volume) → ma_result
ma_gainer_uninit(Pointer<ma_gainer> pGainer, Pointer<ma_allocation_callbacks> pAllocationCallbacks) → void
ma_get_backend_from_name(Pointer<Char> pBackendName, Pointer<ma_uint32> pBackend) → ma_result
ma_get_backend_name(ma_backend backend) → Pointer<Char>
ma_get_bytes_per_sample(ma_format format) → Dartma_uint32
ma_get_enabled_backends(Pointer<ma_uint32> pBackends, int backendCap, Pointer<Size> pBackendCount) → ma_result
ma_get_format_name(ma_format format) → Pointer<Char>
ma_hishelf2_config_init(ma_format format, Dartma_uint32 channels, Dartma_uint32 sampleRate, double gainDB, double shelfSlope, double frequency) → ma_hishelf2_config
ma_hishelf2_get_heap_size(Pointer<ma_hishelf2_config> pConfig, Pointer<Size> pHeapSizeInBytes) → ma_result
ma_hishelf2_get_latency(Pointer<ma_hishelf2> pFilter) → int
ma_hishelf2_init(Pointer<ma_hishelf2_config> pConfig, Pointer<ma_allocation_callbacks> pAllocationCallbacks, Pointer<ma_hishelf2> pFilter) → ma_result
ma_hishelf2_init_preallocated(Pointer<ma_hishelf2_config> pConfig, Pointer<Void> pHeap, Pointer<ma_hishelf2> pFilter) → ma_result
ma_hishelf2_process_pcm_frames(Pointer<ma_hishelf2> pFilter, Pointer<Void> pFramesOut, Pointer<Void> pFramesIn, Dartma_uint64 frameCount) → ma_result
ma_hishelf2_reinit(Pointer<ma_hishelf2_config> pConfig, Pointer<ma_hishelf2> pFilter) → ma_result
ma_hishelf2_uninit(Pointer<ma_hishelf2> pFilter, Pointer<ma_allocation_callbacks> pAllocationCallbacks) → void
ma_hishelf_node_config_init(int channels, int sampleRate, double gainDB, double q, double frequency) → ma_hishelf_node_config
ma_hishelf_node_init(Pointer<ma_node_graph> pNodeGraph, Pointer<ma_hishelf_node_config> pConfig, Pointer<ma_allocation_callbacks> pAllocationCallbacks, Pointer<ma_hishelf_node> pNode) → ma_result
ma_hishelf_node_reinit(Pointer<ma_hishelf2_config> pConfig, Pointer<ma_hishelf_node> pNode) → ma_result
ma_hishelf_node_uninit(Pointer<ma_hishelf_node> pNode, Pointer<ma_allocation_callbacks> pAllocationCallbacks) → void
ma_hpf1_config_init(ma_format format, Dartma_uint32 channels, Dartma_uint32 sampleRate, double cutoffFrequency) → ma_hpf1_config
ma_hpf1_get_heap_size(Pointer<ma_hpf1_config> pConfig, Pointer<Size> pHeapSizeInBytes) → ma_result
ma_hpf1_get_latency(Pointer<ma_hpf1> pHPF) → int
ma_hpf1_init(Pointer<ma_hpf1_config> pConfig, Pointer<ma_allocation_callbacks> pAllocationCallbacks, Pointer<ma_hpf1> pHPF) → ma_result
ma_hpf1_init_preallocated(Pointer<ma_hpf1_config> pConfig, Pointer<Void> pHeap, Pointer<ma_hpf1> pLPF) → ma_result
ma_hpf1_process_pcm_frames(Pointer<ma_hpf1> pHPF, Pointer<Void> pFramesOut, Pointer<Void> pFramesIn, Dartma_uint64 frameCount) → ma_result
ma_hpf1_reinit(Pointer<ma_hpf1_config> pConfig, Pointer<ma_hpf1> pHPF) → ma_result
ma_hpf1_uninit(Pointer<ma_hpf1> pHPF, Pointer<ma_allocation_callbacks> pAllocationCallbacks) → void
ma_hpf2_config_init(ma_format format, Dartma_uint32 channels, Dartma_uint32 sampleRate, double cutoffFrequency, double q) → ma_hpf2_config
ma_hpf2_get_heap_size(Pointer<ma_hpf1_config> pConfig, Pointer<Size> pHeapSizeInBytes) → ma_result
ma_hpf2_get_latency(Pointer<ma_hpf2> pHPF) → int
ma_hpf2_init(Pointer<ma_hpf1_config> pConfig, Pointer<ma_allocation_callbacks> pAllocationCallbacks, Pointer<ma_hpf2> pHPF) → ma_result
ma_hpf2_init_preallocated(Pointer<ma_hpf1_config> pConfig, Pointer<Void> pHeap, Pointer<ma_hpf2> pHPF) → ma_result
ma_hpf2_process_pcm_frames(Pointer<ma_hpf2> pHPF, Pointer<Void> pFramesOut, Pointer<Void> pFramesIn, Dartma_uint64 frameCount) → ma_result
ma_hpf2_reinit(Pointer<ma_hpf1_config> pConfig, Pointer<ma_hpf2> pHPF) → ma_result
ma_hpf2_uninit(Pointer<ma_hpf2> pHPF, Pointer<ma_allocation_callbacks> pAllocationCallbacks) → void
ma_hpf_config_init(ma_format format, Dartma_uint32 channels, Dartma_uint32 sampleRate, double cutoffFrequency, Dartma_uint32 order) → ma_hpf_config
ma_hpf_get_heap_size(Pointer<ma_hpf_config> pConfig, Pointer<Size> pHeapSizeInBytes) → ma_result
ma_hpf_get_latency(Pointer<ma_hpf> pHPF) → int
ma_hpf_init(Pointer<ma_hpf_config> pConfig, Pointer<ma_allocation_callbacks> pAllocationCallbacks, Pointer<ma_hpf> pHPF) → ma_result
ma_hpf_init_preallocated(Pointer<ma_hpf_config> pConfig, Pointer<Void> pHeap, Pointer<ma_hpf> pLPF) → ma_result
ma_hpf_node_config_init(int channels, int sampleRate, double cutoffFrequency, int order) → ma_hpf_node_config
ma_hpf_node_init(Pointer<ma_node_graph> pNodeGraph, Pointer<ma_hpf_node_config> pConfig, Pointer<ma_allocation_callbacks> pAllocationCallbacks, Pointer<ma_hpf_node> pNode) → ma_result
ma_hpf_node_reinit(Pointer<ma_hpf_config> pConfig, Pointer<ma_hpf_node> pNode) → ma_result
ma_hpf_node_uninit(Pointer<ma_hpf_node> pNode, Pointer<ma_allocation_callbacks> pAllocationCallbacks) → void
ma_hpf_process_pcm_frames(Pointer<ma_hpf> pHPF, Pointer<Void> pFramesOut, Pointer<Void> pFramesIn, Dartma_uint64 frameCount) → ma_result
ma_hpf_reinit(Pointer<ma_hpf_config> pConfig, Pointer<ma_hpf> pHPF) → ma_result
ma_hpf_uninit(Pointer<ma_hpf> pHPF, Pointer<ma_allocation_callbacks> pAllocationCallbacks) → void
ma_interleave_pcm_frames(ma_format format, Dartma_uint32 channels, Dartma_uint64 frameCount, Pointer<Pointer<Void>> ppDeinterleavedPCMFrames, Pointer<Void> pInterleavedPCMFrames) → void
ma_is_backend_enabled(ma_backend backend) → Dartma_uint32
ma_is_loopback_supported(ma_backend backend) → Dartma_uint32
ma_job_init(int code) → ma_job
ma_job_process(Pointer<ma_job> pJob) → ma_result
ma_job_queue_config_init(int flags$1, int capacity) → ma_job_queue_config
ma_job_queue_get_heap_size(Pointer<ma_job_queue_config> pConfig, Pointer<Size> pHeapSizeInBytes) → ma_result
ma_job_queue_init(Pointer<ma_job_queue_config> pConfig, Pointer<ma_allocation_callbacks> pAllocationCallbacks, Pointer<ma_job_queue> pQueue) → ma_result
ma_job_queue_init_preallocated(Pointer<ma_job_queue_config> pConfig, Pointer<Void> pHeap, Pointer<ma_job_queue> pQueue) → ma_result
ma_job_queue_next(Pointer<ma_job_queue> pQueue, Pointer<ma_job> pJob) → ma_result
ma_job_queue_post(Pointer<ma_job_queue> pQueue, Pointer<ma_job> pJob) → ma_result
ma_job_queue_uninit(Pointer<ma_job_queue> pQueue, Pointer<ma_allocation_callbacks> pAllocationCallbacks) → void
ma_linear_resampler_config_init(ma_format format, Dartma_uint32 channels, Dartma_uint32 sampleRateIn, Dartma_uint32 sampleRateOut) → ma_linear_resampler_config
ma_linear_resampler_get_expected_output_frame_count(Pointer<ma_linear_resampler> pResampler, Dartma_uint64 inputFrameCount, Pointer<ma_uint64> pOutputFrameCount) → ma_result
ma_linear_resampler_get_heap_size(Pointer<ma_linear_resampler_config> pConfig, Pointer<Size> pHeapSizeInBytes) → ma_result
ma_linear_resampler_get_input_latency(Pointer<ma_linear_resampler> pResampler) → int
ma_linear_resampler_get_output_latency(Pointer<ma_linear_resampler> pResampler) → int
ma_linear_resampler_get_required_input_frame_count(Pointer<ma_linear_resampler> pResampler, Dartma_uint64 outputFrameCount, Pointer<ma_uint64> pInputFrameCount) → ma_result
ma_linear_resampler_init(Pointer<ma_linear_resampler_config> pConfig, Pointer<ma_allocation_callbacks> pAllocationCallbacks, Pointer<ma_linear_resampler> pResampler) → ma_result
ma_linear_resampler_init_preallocated(Pointer<ma_linear_resampler_config> pConfig, Pointer<Void> pHeap, Pointer<ma_linear_resampler> pResampler) → ma_result
ma_linear_resampler_process_pcm_frames(Pointer<ma_linear_resampler> pResampler, Pointer<Void> pFramesIn, Pointer<ma_uint64> pFrameCountIn, Pointer<Void> pFramesOut, Pointer<ma_uint64> pFrameCountOut) → ma_result
ma_linear_resampler_reset(Pointer<ma_linear_resampler> pResampler) → ma_result
ma_linear_resampler_set_rate(Pointer<ma_linear_resampler> pResampler, Dartma_uint32 sampleRateIn, Dartma_uint32 sampleRateOut) → ma_result
ma_linear_resampler_set_rate_ratio(Pointer<ma_linear_resampler> pResampler, double ratioInOut) → ma_result
ma_linear_resampler_uninit(Pointer<ma_linear_resampler> pResampler, Pointer<ma_allocation_callbacks> pAllocationCallbacks) → void
ma_log_callback_init(ma_log_callback_proc onLog, Pointer<Void> pUserData) → ma_log_callback
ma_log_init(Pointer<ma_allocation_callbacks> pAllocationCallbacks, Pointer<ma_log> pLog) → ma_result
ma_log_level_to_string(int logLevel) → Pointer<Char>: Converts a log level to a string.
ma_log_post(Pointer<ma_log> pLog, Dartma_uint32 level, Pointer<Char> pMessage) → ma_result
ma_log_postf(Pointer<ma_log> pLog, Dartma_uint32 level, Pointer<Char> pFormat) → ma_result
ma_log_postv(Pointer<ma_log> pLog, Dartma_uint32 level, Pointer<Char> pFormat, Pointer<__va_list_tag> args) → ma_result
ma_log_register_callback(Pointer<ma_log> pLog, ma_log_callback callback) → ma_result
ma_log_uninit(Pointer<ma_log> pLog) → void
ma_log_unregister_callback(Pointer<ma_log> pLog, ma_log_callback callback) → ma_result
ma_loshelf2_config_init(ma_format format, Dartma_uint32 channels, Dartma_uint32 sampleRate, double gainDB, double shelfSlope, double frequency) → ma_loshelf2_config
ma_loshelf2_get_heap_size(Pointer<ma_loshelf2_config> pConfig, Pointer<Size> pHeapSizeInBytes) → ma_result
ma_loshelf2_get_latency(Pointer<ma_loshelf2> pFilter) → int
ma_loshelf2_init(Pointer<ma_loshelf2_config> pConfig, Pointer<ma_allocation_callbacks> pAllocationCallbacks, Pointer<ma_loshelf2> pFilter) → ma_result
ma_loshelf2_init_preallocated(Pointer<ma_loshelf2_config> pConfig, Pointer<Void> pHeap, Pointer<ma_loshelf2> pFilter) → ma_result
ma_loshelf2_process_pcm_frames(Pointer<ma_loshelf2> pFilter, Pointer<Void> pFramesOut, Pointer<Void> pFramesIn, Dartma_uint64 frameCount) → ma_result
ma_loshelf2_reinit(Pointer<ma_loshelf2_config> pConfig, Pointer<ma_loshelf2> pFilter) → ma_result
ma_loshelf2_uninit(Pointer<ma_loshelf2> pFilter, Pointer<ma_allocation_callbacks> pAllocationCallbacks) → void
ma_loshelf_node_config_init(int channels, int sampleRate, double gainDB, double q, double frequency) → ma_loshelf_node_config
ma_loshelf_node_init(Pointer<ma_node_graph> pNodeGraph, Pointer<ma_loshelf_node_config> pConfig, Pointer<ma_allocation_callbacks> pAllocationCallbacks, Pointer<ma_loshelf_node> pNode) → ma_result
ma_loshelf_node_reinit(Pointer<ma_loshelf2_config> pConfig, Pointer<ma_loshelf_node> pNode) → ma_result
ma_loshelf_node_uninit(Pointer<ma_loshelf_node> pNode, Pointer<ma_allocation_callbacks> pAllocationCallbacks) → void
ma_lpf1_clear_cache(Pointer<ma_lpf1> pLPF) → ma_result
ma_lpf1_config_init(ma_format format, Dartma_uint32 channels, Dartma_uint32 sampleRate, double cutoffFrequency) → ma_lpf1_config
ma_lpf1_get_heap_size(Pointer<ma_lpf1_config> pConfig, Pointer<Size> pHeapSizeInBytes) → ma_result
ma_lpf1_get_latency(Pointer<ma_lpf1> pLPF) → int
ma_lpf1_init(Pointer<ma_lpf1_config> pConfig, Pointer<ma_allocation_callbacks> pAllocationCallbacks, Pointer<ma_lpf1> pLPF) → ma_result
ma_lpf1_init_preallocated(Pointer<ma_lpf1_config> pConfig, Pointer<Void> pHeap, Pointer<ma_lpf1> pLPF) → ma_result
ma_lpf1_process_pcm_frames(Pointer<ma_lpf1> pLPF, Pointer<Void> pFramesOut, Pointer<Void> pFramesIn, Dartma_uint64 frameCount) → ma_result
ma_lpf1_reinit(Pointer<ma_lpf1_config> pConfig, Pointer<ma_lpf1> pLPF) → ma_result
ma_lpf1_uninit(Pointer<ma_lpf1> pLPF, Pointer<ma_allocation_callbacks> pAllocationCallbacks) → void
ma_lpf2_clear_cache(Pointer<ma_lpf2> pLPF) → ma_result
ma_lpf2_config_init(ma_format format, Dartma_uint32 channels, Dartma_uint32 sampleRate, double cutoffFrequency, double q) → ma_lpf2_config
ma_lpf2_get_heap_size(Pointer<ma_lpf1_config> pConfig, Pointer<Size> pHeapSizeInBytes) → ma_result
ma_lpf2_get_latency(Pointer<ma_lpf2> pLPF) → int
ma_lpf2_init(Pointer<ma_lpf1_config> pConfig, Pointer<ma_allocation_callbacks> pAllocationCallbacks, Pointer<ma_lpf2> pLPF) → ma_result
ma_lpf2_init_preallocated(Pointer<ma_lpf1_config> pConfig, Pointer<Void> pHeap, Pointer<ma_lpf2> pHPF) → ma_result
ma_lpf2_process_pcm_frames(Pointer<ma_lpf2> pLPF, Pointer<Void> pFramesOut, Pointer<Void> pFramesIn, Dartma_uint64 frameCount) → ma_result
ma_lpf2_reinit(Pointer<ma_lpf1_config> pConfig, Pointer<ma_lpf2> pLPF) → ma_result
ma_lpf2_uninit(Pointer<ma_lpf2> pLPF, Pointer<ma_allocation_callbacks> pAllocationCallbacks) → void
ma_lpf_clear_cache(Pointer<ma_lpf> pLPF) → ma_result
ma_lpf_config_init(ma_format format, Dartma_uint32 channels, Dartma_uint32 sampleRate, double cutoffFrequency, Dartma_uint32 order) → ma_lpf_config
ma_lpf_get_heap_size(Pointer<ma_lpf_config> pConfig, Pointer<Size> pHeapSizeInBytes) → ma_result
ma_lpf_get_latency(Pointer<ma_lpf> pLPF) → int
ma_lpf_init(Pointer<ma_lpf_config> pConfig, Pointer<ma_allocation_callbacks> pAllocationCallbacks, Pointer<ma_lpf> pLPF) → ma_result
ma_lpf_init_preallocated(Pointer<ma_lpf_config> pConfig, Pointer<Void> pHeap, Pointer<ma_lpf> pLPF) → ma_result
ma_lpf_node_config_init(int channels, int sampleRate, double cutoffFrequency, int order) → ma_lpf_node_config
ma_lpf_node_init(Pointer<ma_node_graph> pNodeGraph, Pointer<ma_lpf_node_config> pConfig, Pointer<ma_allocation_callbacks> pAllocationCallbacks, Pointer<ma_lpf_node> pNode) → ma_result
ma_lpf_node_reinit(Pointer<ma_lpf_config> pConfig, Pointer<ma_lpf_node> pNode) → ma_result
ma_lpf_node_uninit(Pointer<ma_lpf_node> pNode, Pointer<ma_allocation_callbacks> pAllocationCallbacks) → void
ma_lpf_process_pcm_frames(Pointer<ma_lpf> pLPF, Pointer<Void> pFramesOut, Pointer<Void> pFramesIn, Dartma_uint64 frameCount) → ma_result
ma_lpf_reinit(Pointer<ma_lpf_config> pConfig, Pointer<ma_lpf> pLPF) → ma_result
ma_lpf_uninit(Pointer<ma_lpf> pLPF, Pointer<ma_allocation_callbacks> pAllocationCallbacks) → void
ma_malloc(int sz, Pointer<ma_allocation_callbacks> pAllocationCallbacks) → Pointer<Void>: malloc()
ma_mix_pcm_frames_f32(Pointer<Float> pDst, Pointer<Float> pSrc, Dartma_uint64 frameCount, Dartma_uint32 channels, double volume) → ma_result
ma_mutex_init(Pointer<ma_mutex> pMutex) → ma_result
ma_mutex_lock(Pointer<ma_mutex> pMutex) → void: Locks a mutex with an infinite timeout.
ma_mutex_uninit(Pointer<ma_mutex> pMutex) → void: Deletes a mutex.
ma_mutex_unlock(Pointer<ma_mutex> pMutex) → void: Unlocks a mutex.
ma_node_attach_output_bus(Pointer<Void> pNode, Dartma_uint32 outputBusIndex, Pointer<Void> pOtherNode, Dartma_uint32 otherNodeInputBusIndex) → ma_result
ma_node_config_init() → ma_node_config
ma_node_detach_all_output_buses(Pointer<Void> pNode) → ma_result
ma_node_detach_output_bus(Pointer<Void> pNode, Dartma_uint32 outputBusIndex) → ma_result
ma_node_get_heap_size(Pointer<ma_node_graph> pNodeGraph, Pointer<ma_node_config> pConfig, Pointer<Size> pHeapSizeInBytes) → ma_result
ma_node_get_input_bus_count(Pointer<Void> pNode) → int
ma_node_get_input_channels(Pointer<Void> pNode, int inputBusIndex) → int
ma_node_get_node_graph(Pointer<Void> pNode) → Pointer<ma_node_graph>
ma_node_get_output_bus_count(Pointer<Void> pNode) → int
ma_node_get_output_bus_volume(Pointer<Void> pNode, int outputBusIndex) → double
ma_node_get_output_channels(Pointer<Void> pNode, int outputBusIndex) → int
ma_node_get_state(Pointer<Void> pNode) → ma_node_state
ma_node_get_state_by_time(Pointer<Void> pNode, Dartma_uint64 globalTime) → ma_node_state
ma_node_get_state_by_time_range(Pointer<Void> pNode, Dartma_uint64 globalTimeBeg, Dartma_uint64 globalTimeEnd) → ma_node_state
ma_node_get_state_time(Pointer<Void> pNode, ma_node_state state) → Dartma_uint64
ma_node_get_time(Pointer<Void> pNode) → int
ma_node_graph_config_init(int channels) → ma_node_graph_config
ma_node_graph_get_channels(Pointer<ma_node_graph> pNodeGraph) → int
ma_node_graph_get_endpoint(Pointer<ma_node_graph> pNodeGraph) → Pointer<Void>
ma_node_graph_get_processing_size_in_frames(Pointer<ma_node_graph> pNodeGraph) → int
ma_node_graph_get_time(Pointer<ma_node_graph> pNodeGraph) → int
ma_node_graph_init(Pointer<ma_node_graph_config> pConfig, Pointer<ma_allocation_callbacks> pAllocationCallbacks, Pointer<ma_node_graph> pNodeGraph) → ma_result
ma_node_graph_read_pcm_frames(Pointer<ma_node_graph> pNodeGraph, Pointer<Void> pFramesOut, Dartma_uint64 frameCount, Pointer<ma_uint64> pFramesRead) → ma_result
ma_node_graph_set_time(Pointer<ma_node_graph> pNodeGraph, Dartma_uint64 globalTime) → ma_result
ma_node_graph_uninit(Pointer<ma_node_graph> pNodeGraph, Pointer<ma_allocation_callbacks> pAllocationCallbacks) → void
ma_node_init(Pointer<ma_node_graph> pNodeGraph, Pointer<ma_node_config> pConfig, Pointer<ma_allocation_callbacks> pAllocationCallbacks, Pointer<Void> pNode) → ma_result
ma_node_init_preallocated(Pointer<ma_node_graph> pNodeGraph, Pointer<ma_node_config> pConfig, Pointer<Void> pHeap, Pointer<Void> pNode) → ma_result
ma_node_set_output_bus_volume(Pointer<Void> pNode, Dartma_uint32 outputBusIndex, double volume) → ma_result
ma_node_set_state(Pointer<Void> pNode, ma_node_state state) → ma_result
ma_node_set_state_time(Pointer<Void> pNode, ma_node_state state, Dartma_uint64 globalTime) → ma_result
ma_node_set_time(Pointer<Void> pNode, Dartma_uint64 localTime) → ma_result
ma_node_uninit(Pointer<Void> pNode, Pointer<ma_allocation_callbacks> pAllocationCallbacks) → void
ma_noise_config_init(ma_format format, Dartma_uint32 channels, ma_noise_type type, Dartma_int32 seed, double amplitude) → ma_noise_config
ma_noise_get_heap_size(Pointer<ma_noise_config> pConfig, Pointer<Size> pHeapSizeInBytes) → ma_result
ma_noise_init(Pointer<ma_noise_config> pConfig, Pointer<ma_allocation_callbacks> pAllocationCallbacks, Pointer<ma_noise> pNoise) → ma_result
ma_noise_init_preallocated(Pointer<ma_noise_config> pConfig, Pointer<Void> pHeap, Pointer<ma_noise> pNoise) → ma_result
ma_noise_read_pcm_frames(Pointer<ma_noise> pNoise, Pointer<Void> pFramesOut, Dartma_uint64 frameCount, Pointer<ma_uint64> pFramesRead) → ma_result
ma_noise_set_amplitude(Pointer<ma_noise> pNoise, double amplitude) → ma_result
ma_noise_set_seed(Pointer<ma_noise> pNoise, Dartma_int32 seed) → ma_result
ma_noise_set_type(Pointer<ma_noise> pNoise, ma_noise_type type) → ma_result
ma_noise_uninit(Pointer<ma_noise> pNoise, Pointer<ma_allocation_callbacks> pAllocationCallbacks) → void
ma_notch2_config_init(ma_format format, Dartma_uint32 channels, Dartma_uint32 sampleRate, double q, double frequency) → ma_notch2_config
ma_notch2_get_heap_size(Pointer<ma_notch2_config> pConfig, Pointer<Size> pHeapSizeInBytes) → ma_result
ma_notch2_get_latency(Pointer<ma_notch2> pFilter) → int
ma_notch2_init(Pointer<ma_notch2_config> pConfig, Pointer<ma_allocation_callbacks> pAllocationCallbacks, Pointer<ma_notch2> pFilter) → ma_result
ma_notch2_init_preallocated(Pointer<ma_notch2_config> pConfig, Pointer<Void> pHeap, Pointer<ma_notch2> pFilter) → ma_result
ma_notch2_process_pcm_frames(Pointer<ma_notch2> pFilter, Pointer<Void> pFramesOut, Pointer<Void> pFramesIn, Dartma_uint64 frameCount) → ma_result
ma_notch2_reinit(Pointer<ma_notch2_config> pConfig, Pointer<ma_notch2> pFilter) → ma_result
ma_notch2_uninit(Pointer<ma_notch2> pFilter, Pointer<ma_allocation_callbacks> pAllocationCallbacks) → void
ma_notch_node_config_init(int channels, int sampleRate, double q, double frequency) → ma_notch_node_config
ma_notch_node_init(Pointer<ma_node_graph> pNodeGraph, Pointer<ma_notch_node_config> pConfig, Pointer<ma_allocation_callbacks> pAllocationCallbacks, Pointer<ma_notch_node> pNode) → ma_result
ma_notch_node_reinit(Pointer<ma_notch2_config> pConfig, Pointer<ma_notch_node> pNode) → ma_result
ma_notch_node_uninit(Pointer<ma_notch_node> pNode, Pointer<ma_allocation_callbacks> pAllocationCallbacks) → void
ma_offset_pcm_frames_const_ptr(Pointer<Void> p, Dartma_uint64 offsetInFrames, ma_format format, Dartma_uint32 channels) → Pointer<Void>
ma_offset_pcm_frames_ptr(Pointer<Void> p, Dartma_uint64 offsetInFrames, ma_format format, Dartma_uint32 channels) → Pointer<Void>
ma_paged_audio_buffer_config_init(Pointer<ma_paged_audio_buffer_data> pData) → ma_paged_audio_buffer_config
ma_paged_audio_buffer_data_allocate_and_append_page(Pointer<ma_paged_audio_buffer_data> pData, Dartma_uint32 pageSizeInFrames, Pointer<Void> pInitialData, Pointer<ma_allocation_callbacks> pAllocationCallbacks) → ma_result
ma_paged_audio_buffer_data_allocate_page(Pointer<ma_paged_audio_buffer_data> pData, Dartma_uint64 pageSizeInFrames, Pointer<Void> pInitialData, Pointer<ma_allocation_callbacks> pAllocationCallbacks, Pointer<Pointer<ma_paged_audio_buffer_page>> ppPage) → ma_result
ma_paged_audio_buffer_data_append_page(Pointer<ma_paged_audio_buffer_data> pData, Pointer<ma_paged_audio_buffer_page> pPage) → ma_result
ma_paged_audio_buffer_data_free_page(Pointer<ma_paged_audio_buffer_data> pData, Pointer<ma_paged_audio_buffer_page> pPage, Pointer<ma_allocation_callbacks> pAllocationCallbacks) → ma_result
ma_paged_audio_buffer_data_get_head(Pointer<ma_paged_audio_buffer_data> pData) → Pointer<ma_paged_audio_buffer_page>
ma_paged_audio_buffer_data_get_length_in_pcm_frames(Pointer<ma_paged_audio_buffer_data> pData, Pointer<ma_uint64> pLength) → ma_result
ma_paged_audio_buffer_data_get_tail(Pointer<ma_paged_audio_buffer_data> pData) → Pointer<ma_paged_audio_buffer_page>
ma_paged_audio_buffer_data_init(ma_format format, Dartma_uint32 channels, Pointer<ma_paged_audio_buffer_data> pData) → ma_result
ma_paged_audio_buffer_data_uninit(Pointer<ma_paged_audio_buffer_data> pData, Pointer<ma_allocation_callbacks> pAllocationCallbacks) → void
ma_paged_audio_buffer_get_cursor_in_pcm_frames(Pointer<ma_paged_audio_buffer> pPagedAudioBuffer, Pointer<ma_uint64> pCursor) → ma_result
ma_paged_audio_buffer_get_length_in_pcm_frames(Pointer<ma_paged_audio_buffer> pPagedAudioBuffer, Pointer<ma_uint64> pLength) → ma_result
ma_paged_audio_buffer_init(Pointer<ma_paged_audio_buffer_config> pConfig, Pointer<ma_paged_audio_buffer> pPagedAudioBuffer) → ma_result
ma_paged_audio_buffer_read_pcm_frames(Pointer<ma_paged_audio_buffer> pPagedAudioBuffer, Pointer<Void> pFramesOut, Dartma_uint64 frameCount, Pointer<ma_uint64> pFramesRead) → ma_result
ma_paged_audio_buffer_seek_to_pcm_frame(Pointer<ma_paged_audio_buffer> pPagedAudioBuffer, Dartma_uint64 frameIndex) → ma_result
ma_paged_audio_buffer_uninit(Pointer<ma_paged_audio_buffer> pPagedAudioBuffer) → void
ma_panner_config_init(ma_format format, Dartma_uint32 channels) → ma_panner_config
ma_panner_get_mode(Pointer<ma_panner> pPanner) → ma_pan_mode
ma_panner_get_pan(Pointer<ma_panner> pPanner) → double
ma_panner_init(Pointer<ma_panner_config> pConfig, Pointer<ma_panner> pPanner) → ma_result
ma_panner_process_pcm_frames(Pointer<ma_panner> pPanner, Pointer<Void> pFramesOut, Pointer<Void> pFramesIn, Dartma_uint64 frameCount) → ma_result
ma_panner_set_mode(Pointer<ma_panner> pPanner, ma_pan_mode mode) → void
ma_panner_set_pan(Pointer<ma_panner> pPanner, double pan) → void
ma_pcm_convert(Pointer<Void> pOut, ma_format formatOut, Pointer<Void> pIn, ma_format formatIn, Dartma_uint64 sampleCount, ma_dither_mode ditherMode) → void
ma_pcm_f32_to_s16(Pointer<Void> pOut, Pointer<Void> pIn, Dartma_uint64 count, ma_dither_mode ditherMode) → void
ma_pcm_f32_to_s24(Pointer<Void> pOut, Pointer<Void> pIn, Dartma_uint64 count, ma_dither_mode ditherMode) → void
ma_pcm_f32_to_s32(Pointer<Void> pOut, Pointer<Void> pIn, Dartma_uint64 count, ma_dither_mode ditherMode) → void
ma_pcm_f32_to_u8(Pointer<Void> pOut, Pointer<Void> pIn, Dartma_uint64 count, ma_dither_mode ditherMode) → void
ma_pcm_rb_acquire_read(Pointer<ma_pcm_rb> pRB, Pointer<ma_uint32> pSizeInFrames, Pointer<Pointer<Void>> ppBufferOut) → ma_result
ma_pcm_rb_acquire_write(Pointer<ma_pcm_rb> pRB, Pointer<ma_uint32> pSizeInFrames, Pointer<Pointer<Void>> ppBufferOut) → ma_result
ma_pcm_rb_available_read(Pointer<ma_pcm_rb> pRB) → int
ma_pcm_rb_available_write(Pointer<ma_pcm_rb> pRB) → int
ma_pcm_rb_commit_read(Pointer<ma_pcm_rb> pRB, Dartma_uint32 sizeInFrames) → ma_result
ma_pcm_rb_commit_write(Pointer<ma_pcm_rb> pRB, Dartma_uint32 sizeInFrames) → ma_result
ma_pcm_rb_get_channels(Pointer<ma_pcm_rb> pRB) → int
ma_pcm_rb_get_format(Pointer<ma_pcm_rb> pRB) → ma_format
ma_pcm_rb_get_sample_rate(Pointer<ma_pcm_rb> pRB) → int
ma_pcm_rb_get_subbuffer_offset(Pointer<ma_pcm_rb> pRB, int subbufferIndex) → int
ma_pcm_rb_get_subbuffer_ptr(Pointer<ma_pcm_rb> pRB, int subbufferIndex, Pointer<Void> pBuffer) → Pointer<Void>
ma_pcm_rb_get_subbuffer_size(Pointer<ma_pcm_rb> pRB) → int
ma_pcm_rb_get_subbuffer_stride(Pointer<ma_pcm_rb> pRB) → int
ma_pcm_rb_init(ma_format format, Dartma_uint32 channels, Dartma_uint32 bufferSizeInFrames, Pointer<Void> pOptionalPreallocatedBuffer, Pointer<ma_allocation_callbacks> pAllocationCallbacks, Pointer<ma_pcm_rb> pRB) → ma_result
ma_pcm_rb_init_ex(ma_format format, Dartma_uint32 channels, Dartma_uint32 subbufferSizeInFrames, Dartma_uint32 subbufferCount, Dartma_uint32 subbufferStrideInFrames, Pointer<Void> pOptionalPreallocatedBuffer, Pointer<ma_allocation_callbacks> pAllocationCallbacks, Pointer<ma_pcm_rb> pRB) → ma_result
ma_pcm_rb_pointer_distance(Pointer<ma_pcm_rb> pRB) → int
ma_pcm_rb_reset(Pointer<ma_pcm_rb> pRB) → void
ma_pcm_rb_seek_read(Pointer<ma_pcm_rb> pRB, Dartma_uint32 offsetInFrames) → ma_result
ma_pcm_rb_seek_write(Pointer<ma_pcm_rb> pRB, Dartma_uint32 offsetInFrames) → ma_result
ma_pcm_rb_set_sample_rate(Pointer<ma_pcm_rb> pRB, int sampleRate) → void
ma_pcm_rb_uninit(Pointer<ma_pcm_rb> pRB) → void
ma_pcm_s16_to_f32(Pointer<Void> pOut, Pointer<Void> pIn, Dartma_uint64 count, ma_dither_mode ditherMode) → void
ma_pcm_s16_to_s24(Pointer<Void> pOut, Pointer<Void> pIn, Dartma_uint64 count, ma_dither_mode ditherMode) → void
ma_pcm_s16_to_s32(Pointer<Void> pOut, Pointer<Void> pIn, Dartma_uint64 count, ma_dither_mode ditherMode) → void
ma_pcm_s16_to_u8(Pointer<Void> pOut, Pointer<Void> pIn, Dartma_uint64 count, ma_dither_mode ditherMode) → void
ma_pcm_s24_to_f32(Pointer<Void> pOut, Pointer<Void> pIn, Dartma_uint64 count, ma_dither_mode ditherMode) → void
ma_pcm_s24_to_s16(Pointer<Void> pOut, Pointer<Void> pIn, Dartma_uint64 count, ma_dither_mode ditherMode) → void
ma_pcm_s24_to_s32(Pointer<Void> pOut, Pointer<Void> pIn, Dartma_uint64 count, ma_dither_mode ditherMode) → void
ma_pcm_s24_to_u8(Pointer<Void> pOut, Pointer<Void> pIn, Dartma_uint64 count, ma_dither_mode ditherMode) → void
ma_pcm_s32_to_f32(Pointer<Void> pOut, Pointer<Void> pIn, Dartma_uint64 count, ma_dither_mode ditherMode) → void
ma_pcm_s32_to_s16(Pointer<Void> pOut, Pointer<Void> pIn, Dartma_uint64 count, ma_dither_mode ditherMode) → void
ma_pcm_s32_to_s24(Pointer<Void> pOut, Pointer<Void> pIn, Dartma_uint64 count, ma_dither_mode ditherMode) → void
ma_pcm_s32_to_u8(Pointer<Void> pOut, Pointer<Void> pIn, Dartma_uint64 count, ma_dither_mode ditherMode) → void
ma_pcm_u8_to_f32(Pointer<Void> pOut, Pointer<Void> pIn, Dartma_uint64 count, ma_dither_mode ditherMode) → void
ma_pcm_u8_to_s16(Pointer<Void> pOut, Pointer<Void> pIn, Dartma_uint64 count, ma_dither_mode ditherMode) → void
ma_pcm_u8_to_s24(Pointer<Void> pOut, Pointer<Void> pIn, Dartma_uint64 count, ma_dither_mode ditherMode) → void
ma_pcm_u8_to_s32(Pointer<Void> pOut, Pointer<Void> pIn, Dartma_uint64 count, ma_dither_mode ditherMode) → void
ma_peak2_config_init(ma_format format, Dartma_uint32 channels, Dartma_uint32 sampleRate, double gainDB, double q, double frequency) → ma_peak2_config
ma_peak2_get_heap_size(Pointer<ma_peak2_config> pConfig, Pointer<Size> pHeapSizeInBytes) → ma_result
ma_peak2_get_latency(Pointer<ma_peak2> pFilter) → int
ma_peak2_init(Pointer<ma_peak2_config> pConfig, Pointer<ma_allocation_callbacks> pAllocationCallbacks, Pointer<ma_peak2> pFilter) → ma_result
ma_peak2_init_preallocated(Pointer<ma_peak2_config> pConfig, Pointer<Void> pHeap, Pointer<ma_peak2> pFilter) → ma_result
ma_peak2_process_pcm_frames(Pointer<ma_peak2> pFilter, Pointer<Void> pFramesOut, Pointer<Void> pFramesIn, Dartma_uint64 frameCount) → ma_result
ma_peak2_reinit(Pointer<ma_peak2_config> pConfig, Pointer<ma_peak2> pFilter) → ma_result
ma_peak2_uninit(Pointer<ma_peak2> pFilter, Pointer<ma_allocation_callbacks> pAllocationCallbacks) → void
ma_peak_node_config_init(int channels, int sampleRate, double gainDB, double q, double frequency) → ma_peak_node_config
ma_peak_node_init(Pointer<ma_node_graph> pNodeGraph, Pointer<ma_peak_node_config> pConfig, Pointer<ma_allocation_callbacks> pAllocationCallbacks, Pointer<ma_peak_node> pNode) → ma_result
ma_peak_node_reinit(Pointer<ma_peak2_config> pConfig, Pointer<ma_peak_node> pNode) → ma_result
ma_peak_node_uninit(Pointer<ma_peak_node> pNode, Pointer<ma_allocation_callbacks> pAllocationCallbacks) → void
ma_pulsewave_config_init(ma_format format, Dartma_uint32 channels, Dartma_uint32 sampleRate, double dutyCycle, double amplitude, double frequency) → ma_pulsewave_config
ma_pulsewave_init(Pointer<ma_pulsewave_config> pConfig, Pointer<ma_pulsewave> pWaveform) → ma_result
ma_pulsewave_read_pcm_frames(Pointer<ma_pulsewave> pWaveform, Pointer<Void> pFramesOut, Dartma_uint64 frameCount, Pointer<ma_uint64> pFramesRead) → ma_result
ma_pulsewave_seek_to_pcm_frame(Pointer<ma_pulsewave> pWaveform, Dartma_uint64 frameIndex) → ma_result
ma_pulsewave_set_amplitude(Pointer<ma_pulsewave> pWaveform, double amplitude) → ma_result
ma_pulsewave_set_duty_cycle(Pointer<ma_pulsewave> pWaveform, double dutyCycle) → ma_result
ma_pulsewave_set_frequency(Pointer<ma_pulsewave> pWaveform, double frequency) → ma_result
ma_pulsewave_set_sample_rate(Pointer<ma_pulsewave> pWaveform, Dartma_uint32 sampleRate) → ma_result
ma_pulsewave_uninit(Pointer<ma_pulsewave> pWaveform) → void
ma_rb_acquire_read(Pointer<ma_rb> pRB, Pointer<Size> pSizeInBytes, Pointer<Pointer<Void>> ppBufferOut) → ma_result
ma_rb_acquire_write(Pointer<ma_rb> pRB, Pointer<Size> pSizeInBytes, Pointer<Pointer<Void>> ppBufferOut) → ma_result
ma_rb_available_read(Pointer<ma_rb> pRB) → int
ma_rb_available_write(Pointer<ma_rb> pRB) → int
ma_rb_commit_read(Pointer<ma_rb> pRB, int sizeInBytes) → ma_result
ma_rb_commit_write(Pointer<ma_rb> pRB, int sizeInBytes) → ma_result
ma_rb_get_subbuffer_offset(Pointer<ma_rb> pRB, int subbufferIndex) → int
ma_rb_get_subbuffer_ptr(Pointer<ma_rb> pRB, int subbufferIndex, Pointer<Void> pBuffer) → Pointer<Void>
ma_rb_get_subbuffer_size(Pointer<ma_rb> pRB) → int
ma_rb_get_subbuffer_stride(Pointer<ma_rb> pRB) → int
ma_rb_init(int bufferSizeInBytes, Pointer<Void> pOptionalPreallocatedBuffer, Pointer<ma_allocation_callbacks> pAllocationCallbacks, Pointer<ma_rb> pRB) → ma_result
ma_rb_init_ex(int subbufferSizeInBytes, int subbufferCount, int subbufferStrideInBytes, Pointer<Void> pOptionalPreallocatedBuffer, Pointer<ma_allocation_callbacks> pAllocationCallbacks, Pointer<ma_rb> pRB) → ma_result
ma_rb_pointer_distance(Pointer<ma_rb> pRB) → int
ma_rb_reset(Pointer<ma_rb> pRB) → void
ma_rb_seek_read(Pointer<ma_rb> pRB, int offsetInBytes) → ma_result
ma_rb_seek_write(Pointer<ma_rb> pRB, int offsetInBytes) → ma_result
ma_rb_uninit(Pointer<ma_rb> pRB) → void
ma_realloc(Pointer<Void> p, int sz, Pointer<ma_allocation_callbacks> pAllocationCallbacks) → Pointer<Void>: realloc()
ma_resampler_config_init(ma_format format, Dartma_uint32 channels, Dartma_uint32 sampleRateIn, Dartma_uint32 sampleRateOut, ma_resample_algorithm algorithm) → ma_resampler_config
ma_resampler_get_expected_output_frame_count(Pointer<ma_resampler> pResampler, Dartma_uint64 inputFrameCount, Pointer<ma_uint64> pOutputFrameCount) → ma_result
ma_resampler_get_heap_size(Pointer<ma_resampler_config> pConfig, Pointer<Size> pHeapSizeInBytes) → ma_result
ma_resampler_get_input_latency(Pointer<ma_resampler> pResampler) → int: Retrieves the latency introduced by the resampler in input frames.
ma_resampler_get_output_latency(Pointer<ma_resampler> pResampler) → int: Retrieves the latency introduced by the resampler in output frames.
ma_resampler_get_required_input_frame_count(Pointer<ma_resampler> pResampler, Dartma_uint64 outputFrameCount, Pointer<ma_uint64> pInputFrameCount) → ma_result
ma_resampler_init(Pointer<ma_resampler_config> pConfig, Pointer<ma_allocation_callbacks> pAllocationCallbacks, Pointer<ma_resampler> pResampler) → ma_result
ma_resampler_init_preallocated(Pointer<ma_resampler_config> pConfig, Pointer<Void> pHeap, Pointer<ma_resampler> pResampler) → ma_result
ma_resampler_process_pcm_frames(Pointer<ma_resampler> pResampler, Pointer<Void> pFramesIn, Pointer<ma_uint64> pFrameCountIn, Pointer<Void> pFramesOut, Pointer<ma_uint64> pFrameCountOut) → ma_result
ma_resampler_reset(Pointer<ma_resampler> pResampler) → ma_result
ma_resampler_set_rate(Pointer<ma_resampler> pResampler, Dartma_uint32 sampleRateIn, Dartma_uint32 sampleRateOut) → ma_result
ma_resampler_set_rate_ratio(Pointer<ma_resampler> pResampler, double ratio) → ma_result
ma_resampler_uninit(Pointer<ma_resampler> pResampler, Pointer<ma_allocation_callbacks> pAllocationCallbacks) → void: Uninitializes a resampler.
ma_resource_manager_config_init() → ma_resource_manager_config
ma_resource_manager_data_buffer_get_available_frames(Pointer<ma_resource_manager_data_buffer> pDataBuffer, Pointer<ma_uint64> pAvailableFrames) → ma_result
ma_resource_manager_data_buffer_get_cursor_in_pcm_frames(Pointer<ma_resource_manager_data_buffer> pDataBuffer, Pointer<ma_uint64> pCursor) → ma_result
ma_resource_manager_data_buffer_get_data_format(Pointer<ma_resource_manager_data_buffer> pDataBuffer, Pointer<ma_uint32> pFormat, Pointer<ma_uint32> pChannels, Pointer<ma_uint32> pSampleRate, Pointer<ma_uint8> pChannelMap, int channelMapCap) → ma_result
ma_resource_manager_data_buffer_get_length_in_pcm_frames(Pointer<ma_resource_manager_data_buffer> pDataBuffer, Pointer<ma_uint64> pLength) → ma_result
ma_resource_manager_data_buffer_init(Pointer<ma_resource_manager> pResourceManager, Pointer<Char> pFilePath, Dartma_uint32 flags$1, Pointer<ma_resource_manager_pipeline_notifications> pNotifications, Pointer<ma_resource_manager_data_buffer> pDataBuffer) → ma_result
ma_resource_manager_data_buffer_init_copy(Pointer<ma_resource_manager> pResourceManager, Pointer<ma_resource_manager_data_buffer> pExistingDataBuffer, Pointer<ma_resource_manager_data_buffer> pDataBuffer) → ma_result
ma_resource_manager_data_buffer_init_ex(Pointer<ma_resource_manager> pResourceManager, Pointer<ma_resource_manager_data_source_config> pConfig, Pointer<ma_resource_manager_data_buffer> pDataBuffer) → ma_result
ma_resource_manager_data_buffer_init_w(Pointer<ma_resource_manager> pResourceManager, Pointer<WChar> pFilePath, Dartma_uint32 flags$1, Pointer<ma_resource_manager_pipeline_notifications> pNotifications, Pointer<ma_resource_manager_data_buffer> pDataBuffer) → ma_result
ma_resource_manager_data_buffer_is_looping(Pointer<ma_resource_manager_data_buffer> pDataBuffer) → int
ma_resource_manager_data_buffer_read_pcm_frames(Pointer<ma_resource_manager_data_buffer> pDataBuffer, Pointer<Void> pFramesOut, Dartma_uint64 frameCount, Pointer<ma_uint64> pFramesRead) → ma_result
ma_resource_manager_data_buffer_result(Pointer<ma_resource_manager_data_buffer> pDataBuffer) → ma_result
ma_resource_manager_data_buffer_seek_to_pcm_frame(Pointer<ma_resource_manager_data_buffer> pDataBuffer, Dartma_uint64 frameIndex) → ma_result
ma_resource_manager_data_buffer_set_looping(Pointer<ma_resource_manager_data_buffer> pDataBuffer, Dartma_uint32 isLooping) → ma_result
ma_resource_manager_data_buffer_uninit(Pointer<ma_resource_manager_data_buffer> pDataBuffer) → ma_result
ma_resource_manager_data_source_config_init() → ma_resource_manager_data_source_config
ma_resource_manager_data_source_get_available_frames(Pointer<ma_resource_manager_data_source> pDataSource, Pointer<ma_uint64> pAvailableFrames) → ma_result
ma_resource_manager_data_source_get_cursor_in_pcm_frames(Pointer<ma_resource_manager_data_source> pDataSource, Pointer<ma_uint64> pCursor) → ma_result
ma_resource_manager_data_source_get_data_format(Pointer<ma_resource_manager_data_source> pDataSource, Pointer<ma_uint32> pFormat, Pointer<ma_uint32> pChannels, Pointer<ma_uint32> pSampleRate, Pointer<ma_uint8> pChannelMap, int channelMapCap) → ma_result
ma_resource_manager_data_source_get_length_in_pcm_frames(Pointer<ma_resource_manager_data_source> pDataSource, Pointer<ma_uint64> pLength) → ma_result
ma_resource_manager_data_source_init(Pointer<ma_resource_manager> pResourceManager, Pointer<Char> pName, Dartma_uint32 flags$1, Pointer<ma_resource_manager_pipeline_notifications> pNotifications, Pointer<ma_resource_manager_data_source> pDataSource) → ma_result
ma_resource_manager_data_source_init_copy(Pointer<ma_resource_manager> pResourceManager, Pointer<ma_resource_manager_data_source> pExistingDataSource, Pointer<ma_resource_manager_data_source> pDataSource) → ma_result
ma_resource_manager_data_source_init_ex(Pointer<ma_resource_manager> pResourceManager, Pointer<ma_resource_manager_data_source_config> pConfig, Pointer<ma_resource_manager_data_source> pDataSource) → ma_result
ma_resource_manager_data_source_init_w(Pointer<ma_resource_manager> pResourceManager, Pointer<WChar> pName, Dartma_uint32 flags$1, Pointer<ma_resource_manager_pipeline_notifications> pNotifications, Pointer<ma_resource_manager_data_source> pDataSource) → ma_result
ma_resource_manager_data_source_is_looping(Pointer<ma_resource_manager_data_source> pDataSource) → int
ma_resource_manager_data_source_read_pcm_frames(Pointer<ma_resource_manager_data_source> pDataSource, Pointer<Void> pFramesOut, Dartma_uint64 frameCount, Pointer<ma_uint64> pFramesRead) → ma_result
ma_resource_manager_data_source_result(Pointer<ma_resource_manager_data_source> pDataSource) → ma_result
ma_resource_manager_data_source_seek_to_pcm_frame(Pointer<ma_resource_manager_data_source> pDataSource, Dartma_uint64 frameIndex) → ma_result
ma_resource_manager_data_source_set_looping(Pointer<ma_resource_manager_data_source> pDataSource, Dartma_uint32 isLooping) → ma_result
ma_resource_manager_data_source_uninit(Pointer<ma_resource_manager_data_source> pDataSource) → ma_result
ma_resource_manager_data_stream_get_available_frames(Pointer<ma_resource_manager_data_stream> pDataStream, Pointer<ma_uint64> pAvailableFrames) → ma_result
ma_resource_manager_data_stream_get_cursor_in_pcm_frames(Pointer<ma_resource_manager_data_stream> pDataStream, Pointer<ma_uint64> pCursor) → ma_result
ma_resource_manager_data_stream_get_data_format(Pointer<ma_resource_manager_data_stream> pDataStream, Pointer<ma_uint32> pFormat, Pointer<ma_uint32> pChannels, Pointer<ma_uint32> pSampleRate, Pointer<ma_uint8> pChannelMap, int channelMapCap) → ma_result
ma_resource_manager_data_stream_get_length_in_pcm_frames(Pointer<ma_resource_manager_data_stream> pDataStream, Pointer<ma_uint64> pLength) → ma_result
ma_resource_manager_data_stream_init(Pointer<ma_resource_manager> pResourceManager, Pointer<Char> pFilePath, Dartma_uint32 flags$1, Pointer<ma_resource_manager_pipeline_notifications> pNotifications, Pointer<ma_resource_manager_data_stream> pDataStream) → ma_result
ma_resource_manager_data_stream_init_ex(Pointer<ma_resource_manager> pResourceManager, Pointer<ma_resource_manager_data_source_config> pConfig, Pointer<ma_resource_manager_data_stream> pDataStream) → ma_result
ma_resource_manager_data_stream_init_w(Pointer<ma_resource_manager> pResourceManager, Pointer<WChar> pFilePath, Dartma_uint32 flags$1, Pointer<ma_resource_manager_pipeline_notifications> pNotifications, Pointer<ma_resource_manager_data_stream> pDataStream) → ma_result
ma_resource_manager_data_stream_is_looping(Pointer<ma_resource_manager_data_stream> pDataStream) → int
ma_resource_manager_data_stream_read_pcm_frames(Pointer<ma_resource_manager_data_stream> pDataStream, Pointer<Void> pFramesOut, Dartma_uint64 frameCount, Pointer<ma_uint64> pFramesRead) → ma_result
ma_resource_manager_data_stream_result(Pointer<ma_resource_manager_data_stream> pDataStream) → ma_result
ma_resource_manager_data_stream_seek_to_pcm_frame(Pointer<ma_resource_manager_data_stream> pDataStream, Dartma_uint64 frameIndex) → ma_result
ma_resource_manager_data_stream_set_looping(Pointer<ma_resource_manager_data_stream> pDataStream, Dartma_uint32 isLooping) → ma_result
ma_resource_manager_data_stream_uninit(Pointer<ma_resource_manager_data_stream> pDataStream) → ma_result
ma_resource_manager_get_log(Pointer<ma_resource_manager> pResourceManager) → Pointer<ma_log>
ma_resource_manager_init(Pointer<ma_resource_manager_config> pConfig, Pointer<ma_resource_manager> pResourceManager) → ma_result
ma_resource_manager_next_job(Pointer<ma_resource_manager> pResourceManager, Pointer<ma_job> pJob) → ma_result
ma_resource_manager_pipeline_notifications_init() → ma_resource_manager_pipeline_notifications
ma_resource_manager_post_job(Pointer<ma_resource_manager> pResourceManager, Pointer<ma_job> pJob) → ma_result
ma_resource_manager_post_job_quit(Pointer<ma_resource_manager> pResourceManager) → ma_result
ma_resource_manager_process_job(Pointer<ma_resource_manager> pResourceManager, Pointer<ma_job> pJob) → ma_result
ma_resource_manager_process_next_job(Pointer<ma_resource_manager> pResourceManager) → ma_result
ma_resource_manager_register_decoded_data(Pointer<ma_resource_manager> pResourceManager, Pointer<Char> pName, Pointer<Void> pData, Dartma_uint64 frameCount, ma_format format, Dartma_uint32 channels, Dartma_uint32 sampleRate) → ma_result
ma_resource_manager_register_decoded_data_w(Pointer<ma_resource_manager> pResourceManager, Pointer<WChar> pName, Pointer<Void> pData, Dartma_uint64 frameCount, ma_format format, Dartma_uint32 channels, Dartma_uint32 sampleRate) → ma_result
ma_resource_manager_register_encoded_data(Pointer<ma_resource_manager> pResourceManager, Pointer<Char> pName, Pointer<Void> pData, int sizeInBytes) → ma_result
ma_resource_manager_register_encoded_data_w(Pointer<ma_resource_manager> pResourceManager, Pointer<WChar> pName, Pointer<Void> pData, int sizeInBytes) → ma_result
ma_resource_manager_register_file(Pointer<ma_resource_manager> pResourceManager, Pointer<Char> pFilePath, Dartma_uint32 flags$1) → ma_result
ma_resource_manager_register_file_w(Pointer<ma_resource_manager> pResourceManager, Pointer<WChar> pFilePath, Dartma_uint32 flags$1) → ma_result
ma_resource_manager_uninit(Pointer<ma_resource_manager> pResourceManager) → void
ma_resource_manager_unregister_data(Pointer<ma_resource_manager> pResourceManager, Pointer<Char> pName) → ma_result
ma_resource_manager_unregister_data_w(Pointer<ma_resource_manager> pResourceManager, Pointer<WChar> pName) → ma_result
ma_resource_manager_unregister_file(Pointer<ma_resource_manager> pResourceManager, Pointer<Char> pFilePath) → ma_result
ma_resource_manager_unregister_file_w(Pointer<ma_resource_manager> pResourceManager, Pointer<WChar> pFilePath) → ma_result
ma_result_description(ma_result result) → Pointer<Char>
ma_semaphore_init(int initialValue, Pointer<ma_semaphore> pSemaphore) → ma_result
ma_semaphore_release(Pointer<ma_semaphore> pSemaphore) → ma_result
ma_semaphore_uninit(Pointer<ma_semaphore> pSemaphore) → void
ma_semaphore_wait(Pointer<ma_semaphore> pSemaphore) → ma_result
ma_silence_pcm_frames(Pointer<Void> p, Dartma_uint64 frameCount, ma_format format, Dartma_uint32 channels) → void
ma_slot_allocator_alloc(Pointer<ma_slot_allocator> pAllocator, Pointer<ma_uint64> pSlot) → ma_result
ma_slot_allocator_config_init(int capacity) → ma_slot_allocator_config
ma_slot_allocator_free(Pointer<ma_slot_allocator> pAllocator, Dartma_uint64 slot) → ma_result
ma_slot_allocator_get_heap_size(Pointer<ma_slot_allocator_config> pConfig, Pointer<Size> pHeapSizeInBytes) → ma_result
ma_slot_allocator_init(Pointer<ma_slot_allocator_config> pConfig, Pointer<ma_allocation_callbacks> pAllocationCallbacks, Pointer<ma_slot_allocator> pAllocator) → ma_result
ma_slot_allocator_init_preallocated(Pointer<ma_slot_allocator_config> pConfig, Pointer<Void> pHeap, Pointer<ma_slot_allocator> pAllocator) → ma_result
ma_slot_allocator_uninit(Pointer<ma_slot_allocator> pAllocator, Pointer<ma_allocation_callbacks> pAllocationCallbacks) → void
ma_sound_at_end(Pointer<ma_sound_group> pSound) → int
ma_sound_config_init() → ma_sound_config
ma_sound_config_init_2(Pointer<ma_engine> pEngine) → ma_sound_config
ma_sound_get_attenuation_model(Pointer<ma_sound_group> pSound) → ma_attenuation_model
ma_sound_get_cone(Pointer<ma_sound_group> pSound, Pointer<Float> pInnerAngleInRadians, Pointer<Float> pOuterAngleInRadians, Pointer<Float> pOuterGain) → void
ma_sound_get_current_fade_volume(Pointer<ma_sound_group> pSound) → double
ma_sound_get_cursor_in_pcm_frames(Pointer<ma_sound_group> pSound, Pointer<ma_uint64> pCursor) → ma_result
ma_sound_get_cursor_in_seconds(Pointer<ma_sound_group> pSound, Pointer<Float> pCursor) → ma_result
ma_sound_get_data_format(Pointer<ma_sound_group> pSound, Pointer<ma_uint32> pFormat, Pointer<ma_uint32> pChannels, Pointer<ma_uint32> pSampleRate, Pointer<ma_uint8> pChannelMap, int channelMapCap) → ma_result
ma_sound_get_data_source(Pointer<ma_sound_group> pSound) → Pointer<Void>
ma_sound_get_direction(Pointer<ma_sound_group> pSound) → ma_vec3f
ma_sound_get_direction_to_listener(Pointer<ma_sound_group> pSound) → ma_vec3f
ma_sound_get_directional_attenuation_factor(Pointer<ma_sound_group> pSound) → double
ma_sound_get_doppler_factor(Pointer<ma_sound_group> pSound) → double
ma_sound_get_engine(Pointer<ma_sound_group> pSound) → Pointer<ma_engine>
ma_sound_get_length_in_pcm_frames(Pointer<ma_sound_group> pSound, Pointer<ma_uint64> pLength) → ma_result
ma_sound_get_length_in_seconds(Pointer<ma_sound_group> pSound, Pointer<Float> pLength) → ma_result
ma_sound_get_listener_index(Pointer<ma_sound_group> pSound) → int
ma_sound_get_max_distance(Pointer<ma_sound_group> pSound) → double
ma_sound_get_max_gain(Pointer<ma_sound_group> pSound) → double
ma_sound_get_min_distance(Pointer<ma_sound_group> pSound) → double
ma_sound_get_min_gain(Pointer<ma_sound_group> pSound) → double
ma_sound_get_pan(Pointer<ma_sound_group> pSound) → double
ma_sound_get_pan_mode(Pointer<ma_sound_group> pSound) → ma_pan_mode
ma_sound_get_pinned_listener_index(Pointer<ma_sound_group> pSound) → int
ma_sound_get_pitch(Pointer<ma_sound_group> pSound) → double
ma_sound_get_position(Pointer<ma_sound_group> pSound) → ma_vec3f
ma_sound_get_positioning(Pointer<ma_sound_group> pSound) → ma_positioning
ma_sound_get_rolloff(Pointer<ma_sound_group> pSound) → double
ma_sound_get_time_in_milliseconds(Pointer<ma_sound_group> pSound) → int
ma_sound_get_time_in_pcm_frames(Pointer<ma_sound_group> pSound) → int
ma_sound_get_velocity(Pointer<ma_sound_group> pSound) → ma_vec3f
ma_sound_get_volume(Pointer<ma_sound_group> pSound) → double
ma_sound_group_config_init() → ma_sound_config
ma_sound_group_config_init_2(Pointer<ma_engine> pEngine) → ma_sound_config
ma_sound_group_get_attenuation_model(Pointer<ma_sound_group> pGroup) → ma_attenuation_model
ma_sound_group_get_cone(Pointer<ma_sound_group> pGroup, Pointer<Float> pInnerAngleInRadians, Pointer<Float> pOuterAngleInRadians, Pointer<Float> pOuterGain) → void
ma_sound_group_get_current_fade_volume(Pointer<ma_sound_group> pGroup) → double
ma_sound_group_get_direction(Pointer<ma_sound_group> pGroup) → ma_vec3f
ma_sound_group_get_direction_to_listener(Pointer<ma_sound_group> pGroup) → ma_vec3f
ma_sound_group_get_directional_attenuation_factor(Pointer<ma_sound_group> pGroup) → double
ma_sound_group_get_doppler_factor(Pointer<ma_sound_group> pGroup) → double
ma_sound_group_get_engine(Pointer<ma_sound_group> pGroup) → Pointer<ma_engine>
ma_sound_group_get_listener_index(Pointer<ma_sound_group> pGroup) → int
ma_sound_group_get_max_distance(Pointer<ma_sound_group> pGroup) → double
ma_sound_group_get_max_gain(Pointer<ma_sound_group> pGroup) → double
ma_sound_group_get_min_distance(Pointer<ma_sound_group> pGroup) → double
ma_sound_group_get_min_gain(Pointer<ma_sound_group> pGroup) → double
ma_sound_group_get_pan(Pointer<ma_sound_group> pGroup) → double
ma_sound_group_get_pan_mode(Pointer<ma_sound_group> pGroup) → ma_pan_mode
ma_sound_group_get_pinned_listener_index(Pointer<ma_sound_group> pGroup) → int
ma_sound_group_get_pitch(Pointer<ma_sound_group> pGroup) → double
ma_sound_group_get_position(Pointer<ma_sound_group> pGroup) → ma_vec3f
ma_sound_group_get_positioning(Pointer<ma_sound_group> pGroup) → ma_positioning
ma_sound_group_get_rolloff(Pointer<ma_sound_group> pGroup) → double
ma_sound_group_get_time_in_pcm_frames(Pointer<ma_sound_group> pGroup) → int
ma_sound_group_get_velocity(Pointer<ma_sound_group> pGroup) → ma_vec3f
ma_sound_group_get_volume(Pointer<ma_sound_group> pGroup) → double
ma_sound_group_init(Pointer<ma_engine> pEngine, Dartma_uint32 flags$1, Pointer<ma_sound_group> pParentGroup, Pointer<ma_sound_group> pGroup) → ma_result
ma_sound_group_init_ex(Pointer<ma_engine> pEngine, Pointer<ma_sound_group_config> pConfig, Pointer<ma_sound_group> pGroup) → ma_result
ma_sound_group_is_playing(Pointer<ma_sound_group> pGroup) → int
ma_sound_group_is_spatialization_enabled(Pointer<ma_sound_group> pGroup) → int
ma_sound_group_set_attenuation_model(Pointer<ma_sound_group> pGroup, ma_attenuation_model attenuationModel) → void
ma_sound_group_set_cone(Pointer<ma_sound_group> pGroup, double innerAngleInRadians, double outerAngleInRadians, double outerGain) → void
ma_sound_group_set_direction(Pointer<ma_sound_group> pGroup, double x, double y, double z) → void
ma_sound_group_set_directional_attenuation_factor(Pointer<ma_sound_group> pGroup, double directionalAttenuationFactor) → void
ma_sound_group_set_doppler_factor(Pointer<ma_sound_group> pGroup, double dopplerFactor) → void
ma_sound_group_set_fade_in_milliseconds(Pointer<ma_sound_group> pGroup, double volumeBeg, double volumeEnd, int fadeLengthInMilliseconds) → void
ma_sound_group_set_fade_in_pcm_frames(Pointer<ma_sound_group> pGroup, double volumeBeg, double volumeEnd, int fadeLengthInFrames) → void
ma_sound_group_set_max_distance(Pointer<ma_sound_group> pGroup, double maxDistance) → void
ma_sound_group_set_max_gain(Pointer<ma_sound_group> pGroup, double maxGain) → void
ma_sound_group_set_min_distance(Pointer<ma_sound_group> pGroup, double minDistance) → void
ma_sound_group_set_min_gain(Pointer<ma_sound_group> pGroup, double minGain) → void
ma_sound_group_set_pan(Pointer<ma_sound_group> pGroup, double pan) → void
ma_sound_group_set_pan_mode(Pointer<ma_sound_group> pGroup, ma_pan_mode panMode) → void
ma_sound_group_set_pinned_listener_index(Pointer<ma_sound_group> pGroup, int listenerIndex) → void
ma_sound_group_set_pitch(Pointer<ma_sound_group> pGroup, double pitch) → void
ma_sound_group_set_position(Pointer<ma_sound_group> pGroup, double x, double y, double z) → void
ma_sound_group_set_positioning(Pointer<ma_sound_group> pGroup, ma_positioning positioning) → void
ma_sound_group_set_rolloff(Pointer<ma_sound_group> pGroup, double rolloff) → void
ma_sound_group_set_spatialization_enabled(Pointer<ma_sound_group> pGroup, int enabled) → void
ma_sound_group_set_start_time_in_milliseconds(Pointer<ma_sound_group> pGroup, int absoluteGlobalTimeInMilliseconds) → void
ma_sound_group_set_start_time_in_pcm_frames(Pointer<ma_sound_group> pGroup, int absoluteGlobalTimeInFrames) → void
ma_sound_group_set_stop_time_in_milliseconds(Pointer<ma_sound_group> pGroup, int absoluteGlobalTimeInMilliseconds) → void
ma_sound_group_set_stop_time_in_pcm_frames(Pointer<ma_sound_group> pGroup, int absoluteGlobalTimeInFrames) → void
ma_sound_group_set_velocity(Pointer<ma_sound_group> pGroup, double x, double y, double z) → void
ma_sound_group_set_volume(Pointer<ma_sound_group> pGroup, double volume) → void
ma_sound_group_start(Pointer<ma_sound_group> pGroup) → ma_result
ma_sound_group_stop(Pointer<ma_sound_group> pGroup) → ma_result
ma_sound_group_uninit(Pointer<ma_sound_group> pGroup) → void
ma_sound_init_copy(Pointer<ma_engine> pEngine, Pointer<ma_sound_group> pExistingSound, Dartma_uint32 flags$1, Pointer<ma_sound_group> pGroup, Pointer<ma_sound_group> pSound) → ma_result
ma_sound_init_ex(Pointer<ma_engine> pEngine, Pointer<ma_sound_group_config> pConfig, Pointer<ma_sound_group> pSound) → ma_result
ma_sound_init_from_data_source(Pointer<ma_engine> pEngine, Pointer<Void> pDataSource, Dartma_uint32 flags$1, Pointer<ma_sound_group> pGroup, Pointer<ma_sound_group> pSound) → ma_result
ma_sound_init_from_file(Pointer<ma_engine> pEngine, Pointer<Char> pFilePath, Dartma_uint32 flags$1, Pointer<ma_sound_group> pGroup, Pointer<ma_fence> pDoneFence, Pointer<ma_sound_group> pSound) → ma_result
ma_sound_init_from_file_w(Pointer<ma_engine> pEngine, Pointer<WChar> pFilePath, Dartma_uint32 flags$1, Pointer<ma_sound_group> pGroup, Pointer<ma_fence> pDoneFence, Pointer<ma_sound_group> pSound) → ma_result
ma_sound_is_looping(Pointer<ma_sound_group> pSound) → int
ma_sound_is_playing(Pointer<ma_sound_group> pSound) → int
ma_sound_is_spatialization_enabled(Pointer<ma_sound_group> pSound) → int
ma_sound_reset_fade(Pointer<ma_sound_group> pSound) → void
ma_sound_reset_start_time(Pointer<ma_sound_group> pSound) → void
ma_sound_reset_stop_time(Pointer<ma_sound_group> pSound) → void
ma_sound_reset_stop_time_and_fade(Pointer<ma_sound_group> pSound) → void
ma_sound_seek_to_pcm_frame(Pointer<ma_sound_group> pSound, Dartma_uint64 frameIndex) → ma_result
ma_sound_seek_to_second(Pointer<ma_sound_group> pSound, double seekPointInSeconds) → ma_result
ma_sound_set_attenuation_model(Pointer<ma_sound_group> pSound, ma_attenuation_model attenuationModel) → void
ma_sound_set_cone(Pointer<ma_sound_group> pSound, double innerAngleInRadians, double outerAngleInRadians, double outerGain) → void
ma_sound_set_direction(Pointer<ma_sound_group> pSound, double x, double y, double z) → void
ma_sound_set_directional_attenuation_factor(Pointer<ma_sound_group> pSound, double directionalAttenuationFactor) → void
ma_sound_set_doppler_factor(Pointer<ma_sound_group> pSound, double dopplerFactor) → void
ma_sound_set_end_callback(Pointer<ma_sound_group> pSound, ma_sound_end_proc callback, Pointer<Void> pUserData) → ma_result
ma_sound_set_fade_in_milliseconds(Pointer<ma_sound_group> pSound, double volumeBeg, double volumeEnd, int fadeLengthInMilliseconds) → void
ma_sound_set_fade_in_pcm_frames(Pointer<ma_sound_group> pSound, double volumeBeg, double volumeEnd, int fadeLengthInFrames) → void
ma_sound_set_fade_start_in_milliseconds(Pointer<ma_sound_group> pSound, double volumeBeg, double volumeEnd, int fadeLengthInMilliseconds, int absoluteGlobalTimeInMilliseconds) → void
ma_sound_set_fade_start_in_pcm_frames(Pointer<ma_sound_group> pSound, double volumeBeg, double volumeEnd, int fadeLengthInFrames, int absoluteGlobalTimeInFrames) → void
ma_sound_set_looping(Pointer<ma_sound_group> pSound, int isLooping) → void
ma_sound_set_max_distance(Pointer<ma_sound_group> pSound, double maxDistance) → void
ma_sound_set_max_gain(Pointer<ma_sound_group> pSound, double maxGain) → void
ma_sound_set_min_distance(Pointer<ma_sound_group> pSound, double minDistance) → void
ma_sound_set_min_gain(Pointer<ma_sound_group> pSound, double minGain) → void
ma_sound_set_pan(Pointer<ma_sound_group> pSound, double pan) → void
ma_sound_set_pan_mode(Pointer<ma_sound_group> pSound, ma_pan_mode panMode) → void
ma_sound_set_pinned_listener_index(Pointer<ma_sound_group> pSound, int listenerIndex) → void
ma_sound_set_pitch(Pointer<ma_sound_group> pSound, double pitch) → void
ma_sound_set_position(Pointer<ma_sound_group> pSound, double x, double y, double z) → void
ma_sound_set_positioning(Pointer<ma_sound_group> pSound, ma_positioning positioning) → void
ma_sound_set_rolloff(Pointer<ma_sound_group> pSound, double rolloff) → void
ma_sound_set_spatialization_enabled(Pointer<ma_sound_group> pSound, int enabled) → void
ma_sound_set_start_time_in_milliseconds(Pointer<ma_sound_group> pSound, int absoluteGlobalTimeInMilliseconds) → void
ma_sound_set_start_time_in_pcm_frames(Pointer<ma_sound_group> pSound, int absoluteGlobalTimeInFrames) → void
ma_sound_set_stop_time_in_milliseconds(Pointer<ma_sound_group> pSound, int absoluteGlobalTimeInMilliseconds) → void
ma_sound_set_stop_time_in_pcm_frames(Pointer<ma_sound_group> pSound, int absoluteGlobalTimeInFrames) → void
ma_sound_set_stop_time_with_fade_in_milliseconds(Pointer<ma_sound_group> pSound, int stopAbsoluteGlobalTimeInMilliseconds, int fadeLengthInMilliseconds) → void
ma_sound_set_stop_time_with_fade_in_pcm_frames(Pointer<ma_sound_group> pSound, int stopAbsoluteGlobalTimeInFrames, int fadeLengthInFrames) → void
ma_sound_set_velocity(Pointer<ma_sound_group> pSound, double x, double y, double z) → void
ma_sound_set_volume(Pointer<ma_sound_group> pSound, double volume) → void
ma_sound_start(Pointer<ma_sound_group> pSound) → ma_result
ma_sound_stop(Pointer<ma_sound_group> pSound) → ma_result
ma_sound_stop_with_fade_in_milliseconds(Pointer<ma_sound_group> pSound, Dartma_uint64 fadeLengthInFrames) → ma_result
ma_sound_stop_with_fade_in_pcm_frames(Pointer<ma_sound_group> pSound, Dartma_uint64 fadeLengthInFrames) → ma_result
ma_sound_uninit(Pointer<ma_sound_group> pSound) → void
ma_spatializer_config_init(int channelsIn, int channelsOut) → ma_spatializer_config
ma_spatializer_get_attenuation_model(Pointer<ma_spatializer> pSpatializer) → ma_attenuation_model
ma_spatializer_get_cone(Pointer<ma_spatializer> pSpatializer, Pointer<Float> pInnerAngleInRadians, Pointer<Float> pOuterAngleInRadians, Pointer<Float> pOuterGain) → void
ma_spatializer_get_direction(Pointer<ma_spatializer> pSpatializer) → ma_vec3f
ma_spatializer_get_directional_attenuation_factor(Pointer<ma_spatializer> pSpatializer) → double
ma_spatializer_get_doppler_factor(Pointer<ma_spatializer> pSpatializer) → double
ma_spatializer_get_heap_size(Pointer<ma_spatializer_config> pConfig, Pointer<Size> pHeapSizeInBytes) → ma_result
ma_spatializer_get_input_channels(Pointer<ma_spatializer> pSpatializer) → int
ma_spatializer_get_master_volume(Pointer<ma_spatializer> pSpatializer, Pointer<Float> pVolume) → ma_result
ma_spatializer_get_max_distance(Pointer<ma_spatializer> pSpatializer) → double
ma_spatializer_get_max_gain(Pointer<ma_spatializer> pSpatializer) → double
ma_spatializer_get_min_distance(Pointer<ma_spatializer> pSpatializer) → double
ma_spatializer_get_min_gain(Pointer<ma_spatializer> pSpatializer) → double
ma_spatializer_get_output_channels(Pointer<ma_spatializer> pSpatializer) → int
ma_spatializer_get_position(Pointer<ma_spatializer> pSpatializer) → ma_vec3f
ma_spatializer_get_positioning(Pointer<ma_spatializer> pSpatializer) → ma_positioning
ma_spatializer_get_relative_position_and_direction(Pointer<ma_spatializer> pSpatializer, Pointer<ma_spatializer_listener> pListener, Pointer<ma_vec3f> pRelativePos, Pointer<ma_vec3f> pRelativeDir) → void
ma_spatializer_get_rolloff(Pointer<ma_spatializer> pSpatializer) → double
ma_spatializer_get_velocity(Pointer<ma_spatializer> pSpatializer) → ma_vec3f
ma_spatializer_init(Pointer<ma_spatializer_config> pConfig, Pointer<ma_allocation_callbacks> pAllocationCallbacks, Pointer<ma_spatializer> pSpatializer) → ma_result
ma_spatializer_init_preallocated(Pointer<ma_spatializer_config> pConfig, Pointer<Void> pHeap, Pointer<ma_spatializer> pSpatializer) → ma_result
ma_spatializer_listener_config_init(int channelsOut) → ma_spatializer_listener_config
ma_spatializer_listener_get_channel_map(Pointer<ma_spatializer_listener> pListener) → Pointer<ma_uint8>
ma_spatializer_listener_get_cone(Pointer<ma_spatializer_listener> pListener, Pointer<Float> pInnerAngleInRadians, Pointer<Float> pOuterAngleInRadians, Pointer<Float> pOuterGain) → void
ma_spatializer_listener_get_direction(Pointer<ma_spatializer_listener> pListener) → ma_vec3f
ma_spatializer_listener_get_heap_size(Pointer<ma_spatializer_listener_config> pConfig, Pointer<Size> pHeapSizeInBytes) → ma_result
ma_spatializer_listener_get_position(Pointer<ma_spatializer_listener> pListener) → ma_vec3f
ma_spatializer_listener_get_speed_of_sound(Pointer<ma_spatializer_listener> pListener) → double
ma_spatializer_listener_get_velocity(Pointer<ma_spatializer_listener> pListener) → ma_vec3f
ma_spatializer_listener_get_world_up(Pointer<ma_spatializer_listener> pListener) → ma_vec3f
ma_spatializer_listener_init(Pointer<ma_spatializer_listener_config> pConfig, Pointer<ma_allocation_callbacks> pAllocationCallbacks, Pointer<ma_spatializer_listener> pListener) → ma_result
ma_spatializer_listener_init_preallocated(Pointer<ma_spatializer_listener_config> pConfig, Pointer<Void> pHeap, Pointer<ma_spatializer_listener> pListener) → ma_result
ma_spatializer_listener_is_enabled(Pointer<ma_spatializer_listener> pListener) → int
ma_spatializer_listener_set_cone(Pointer<ma_spatializer_listener> pListener, double innerAngleInRadians, double outerAngleInRadians, double outerGain) → void
ma_spatializer_listener_set_direction(Pointer<ma_spatializer_listener> pListener, double x, double y, double z) → void
ma_spatializer_listener_set_enabled(Pointer<ma_spatializer_listener> pListener, int isEnabled) → void
ma_spatializer_listener_set_position(Pointer<ma_spatializer_listener> pListener, double x, double y, double z) → void
ma_spatializer_listener_set_speed_of_sound(Pointer<ma_spatializer_listener> pListener, double speedOfSound) → void
ma_spatializer_listener_set_velocity(Pointer<ma_spatializer_listener> pListener, double x, double y, double z) → void
ma_spatializer_listener_set_world_up(Pointer<ma_spatializer_listener> pListener, double x, double y, double z) → void
ma_spatializer_listener_uninit(Pointer<ma_spatializer_listener> pListener, Pointer<ma_allocation_callbacks> pAllocationCallbacks) → void
ma_spatializer_process_pcm_frames(Pointer<ma_spatializer> pSpatializer, Pointer<ma_spatializer_listener> pListener, Pointer<Void> pFramesOut, Pointer<Void> pFramesIn, Dartma_uint64 frameCount) → ma_result
ma_spatializer_set_attenuation_model(Pointer<ma_spatializer> pSpatializer, ma_attenuation_model attenuationModel) → void
ma_spatializer_set_cone(Pointer<ma_spatializer> pSpatializer, double innerAngleInRadians, double outerAngleInRadians, double outerGain) → void
ma_spatializer_set_direction(Pointer<ma_spatializer> pSpatializer, double x, double y, double z) → void
ma_spatializer_set_directional_attenuation_factor(Pointer<ma_spatializer> pSpatializer, double directionalAttenuationFactor) → void
ma_spatializer_set_doppler_factor(Pointer<ma_spatializer> pSpatializer, double dopplerFactor) → void
ma_spatializer_set_master_volume(Pointer<ma_spatializer> pSpatializer, double volume) → ma_result
ma_spatializer_set_max_distance(Pointer<ma_spatializer> pSpatializer, double maxDistance) → void
ma_spatializer_set_max_gain(Pointer<ma_spatializer> pSpatializer, double maxGain) → void
ma_spatializer_set_min_distance(Pointer<ma_spatializer> pSpatializer, double minDistance) → void
ma_spatializer_set_min_gain(Pointer<ma_spatializer> pSpatializer, double minGain) → void
ma_spatializer_set_position(Pointer<ma_spatializer> pSpatializer, double x, double y, double z) → void
ma_spatializer_set_positioning(Pointer<ma_spatializer> pSpatializer, ma_positioning positioning) → void
ma_spatializer_set_rolloff(Pointer<ma_spatializer> pSpatializer, double rolloff) → void
ma_spatializer_set_velocity(Pointer<ma_spatializer> pSpatializer, double x, double y, double z) → void
ma_spatializer_uninit(Pointer<ma_spatializer> pSpatializer, Pointer<ma_allocation_callbacks> pAllocationCallbacks) → void
ma_spinlock_lock(Pointer<ma_uint32> pSpinlock) → ma_result
ma_spinlock_lock_noyield(Pointer<ma_uint32> pSpinlock) → ma_result
ma_spinlock_unlock(Pointer<ma_uint32> pSpinlock) → ma_result
ma_splitter_node_config_init(int channels) → ma_splitter_node_config
ma_splitter_node_init(Pointer<ma_node_graph> pNodeGraph, Pointer<ma_splitter_node_config> pConfig, Pointer<ma_allocation_callbacks> pAllocationCallbacks, Pointer<ma_splitter_node> pSplitterNode) → ma_result
ma_splitter_node_uninit(Pointer<ma_splitter_node> pSplitterNode, Pointer<ma_allocation_callbacks> pAllocationCallbacks) → void
ma_version(Pointer<ma_uint32> pMajor, Pointer<ma_uint32> pMinor, Pointer<ma_uint32> pRevision) → void: Retrieves the version of miniaudio as separated integers. Each component can be NULL if it's not required.
ma_version_string() → Pointer<Char>: Retrieves the version of miniaudio as a string which can be useful for logging purposes.
ma_vfs_close(Pointer<Void> pVFS, ma_vfs_file file) → ma_result
ma_vfs_info(Pointer<Void> pVFS, ma_vfs_file file, Pointer<ma_file_info> pInfo) → ma_result
ma_vfs_open(Pointer<Void> pVFS, Pointer<Char> pFilePath, Dartma_uint32 openMode, Pointer<Pointer<Void>> pFile) → ma_result
ma_vfs_open_and_read_file(Pointer<Void> pVFS, Pointer<Char> pFilePath, Pointer<Pointer<Void>> ppData, Pointer<Size> pSize, Pointer<ma_allocation_callbacks> pAllocationCallbacks) → ma_result
ma_vfs_open_w(Pointer<Void> pVFS, Pointer<WChar> pFilePath, Dartma_uint32 openMode, Pointer<Pointer<Void>> pFile) → ma_result
ma_vfs_read(Pointer<Void> pVFS, ma_vfs_file file, Pointer<Void> pDst, int sizeInBytes, Pointer<Size> pBytesRead) → ma_result
ma_vfs_seek(Pointer<Void> pVFS, ma_vfs_file file, Dartma_int64 offset, ma_seek_origin origin) → ma_result
ma_vfs_tell(Pointer<Void> pVFS, ma_vfs_file file, Pointer<ma_int64> pCursor) → ma_result
ma_vfs_write(Pointer<Void> pVFS, ma_vfs_file file, Pointer<Void> pSrc, int sizeInBytes, Pointer<Size> pBytesWritten) → ma_result
ma_volume_db_to_linear(double gain) → double: Helper for converting gain in decibels to a linear factor.
ma_volume_linear_to_db(double factor) → double: Helper for converting a linear factor to gain in decibels.
ma_waveform_config_init(ma_format format, Dartma_uint32 channels, Dartma_uint32 sampleRate, ma_waveform_type type, double amplitude, double frequency) → ma_waveform_config
ma_waveform_init(Pointer<ma_waveform_config> pConfig, Pointer<ma_waveform> pWaveform) → ma_result
ma_waveform_read_pcm_frames(Pointer<ma_waveform> pWaveform, Pointer<Void> pFramesOut, Dartma_uint64 frameCount, Pointer<ma_uint64> pFramesRead) → ma_result
ma_waveform_seek_to_pcm_frame(Pointer<ma_waveform> pWaveform, Dartma_uint64 frameIndex) → ma_result
ma_waveform_set_amplitude(Pointer<ma_waveform> pWaveform, double amplitude) → ma_result
ma_waveform_set_frequency(Pointer<ma_waveform> pWaveform, double frequency) → ma_result
ma_waveform_set_sample_rate(Pointer<ma_waveform> pWaveform, Dartma_uint32 sampleRate) → ma_result
ma_waveform_set_type(Pointer<ma_waveform> pWaveform, ma_waveform_type type) → ma_result
ma_waveform_uninit(Pointer<ma_waveform> pWaveform) → void
miniz_def_alloc_func(Pointer<Void> opaque, int items, int size) → Pointer<Void>
miniz_def_free_func(Pointer<Void> opaque, Pointer<Void> address) → void
miniz_def_realloc_func(Pointer<Void> opaque, Pointer<Void> address, int items, int size) → Pointer<Void>
mz_adler32(int adler, Pointer<ma_uint8> ptr, int buf_len) → int: mz_adler32() returns the initial adler-32 value to use when called with ptr==NULL.
mz_compress(Pointer<ma_uint8> pDest, Pointer<mz_ulong> pDest_len, Pointer<ma_uint8> pSource, int source_len) → int: Single-call compression functions mz_compress() and mz_compress2(): / / Returns MZ_OK on success, or one of the error codes from mz_deflate() on failure.
mz_compress2(Pointer<ma_uint8> pDest, Pointer<mz_ulong> pDest_len, Pointer<ma_uint8> pSource, int source_len, int level) → int
mz_compressBound(int source_len) → int: mz_compressBound() returns a (very) conservative upper bound on the amount of data that could be generated by calling mz_compress().
mz_crc32(int crc, Pointer<ma_uint8> ptr, int buf_len) → int: mz_crc32() returns the initial CRC-32 value to use when called with ptr==NULL.
mz_deflate(mz_streamp pStream, int flush) → int: mz_deflate() compresses the input to output, consuming as much of the input and producing as much output as possible. / / Parameters: / / pStream is the stream to read from and write to. You must initialize/update the next_in, avail_in, next_out, and avail_out members. / / flush may be MZ_NO_FLUSH, MZ_PARTIAL_FLUSH/MZ_SYNC_FLUSH, MZ_FULL_FLUSH, or MZ_FINISH. / / Return values: / / MZ_OK on success (when flushing, or if more input is needed but not available, and/or there's more output to be written but the output buffer is full). / / MZ_STREAM_END if all input has been consumed and all output bytes have been written. Don't call mz_deflate() on the stream anymore. / / MZ_STREAM_ERROR if the stream is bogus. / / MZ_PARAM_ERROR if one of the parameters is invalid. / / MZ_BUF_ERROR if no forward progress is possible because the input and/or output buffers are empty. (Fill up the input buffer or free up some output space and try again.)
mz_deflateBound(mz_streamp pStream, int source_len) → int: mz_deflateBound() returns a (very) conservative upper bound on the amount of data that could be generated by deflate(), assuming flush is set to only MZ_NO_FLUSH or MZ_FINISH.
mz_deflateEnd(mz_streamp pStream) → int: mz_deflateEnd() deinitializes a compressor: / / Return values: / / MZ_OK on success. / / MZ_STREAM_ERROR if the stream is bogus.
mz_deflateInit(mz_streamp pStream, int level) → int: mz_deflateInit() initializes a compressor with default options: / / Parameters: / / pStream must point to an initialized mz_stream struct. / / level must be between MZ_NO_COMPRESSION, MZ_BEST_COMPRESSION. / / level 1 enables a specially optimized compression function that's been optimized purely for performance, not ratio. / / (This special func. is currently only enabled when MINIZ_USE_UNALIGNED_LOADS_AND_STORES and MINIZ_LITTLE_ENDIAN are defined.) / / Return values: / / MZ_OK on success. / / MZ_STREAM_ERROR if the stream is bogus. / / MZ_PARAM_ERROR if the input parameters are bogus. / / MZ_MEM_ERROR on out of memory.
mz_deflateInit2(mz_streamp pStream, int level, int method, int window_bits, int mem_level, int strategy) → int: mz_deflateInit2() is like mz_deflate(), except with more control: / / Additional parameters: / / method must be MZ_DEFLATED / / window_bits must be MZ_DEFAULT_WINDOW_BITS (to wrap the deflate stream with zlib header/adler-32 footer) or -MZ_DEFAULT_WINDOW_BITS (raw deflate/no header or footer) / / mem_level must be between 1, 9 (it's checked but ignored by miniz.c)
mz_deflateReset(mz_streamp pStream) → int: Quickly resets a compressor without having to reallocate anything. Same as calling mz_deflateEnd() followed by mz_deflateInit()/mz_deflateInit2().
mz_error(int err) → Pointer<Char>: Returns a string description of the specified error code, or NULL if the error code is invalid.
mz_free(Pointer<Void> p) → void: mz_free() internally uses the MZ_FREE() macro (which by default calls free() unless you've modified the MZ_MALLOC macro) to release a block allocated from the heap.
mz_inflate(mz_streamp pStream, int flush) → int: Decompresses the input stream to the output, consuming only as much of the input as needed, and writing as much to the output as possible. / / Parameters: / / pStream is the stream to read from and write to. You must initialize/update the next_in, avail_in, next_out, and avail_out members. / / flush may be MZ_NO_FLUSH, MZ_SYNC_FLUSH, or MZ_FINISH. / / On the first call, if flush is MZ_FINISH it's assumed the input and output buffers are both sized large enough to decompress the entire stream in a single call (this is slightly faster). / / MZ_FINISH implies that there are no more source bytes available beside what's already in the input buffer, and that the output buffer is large enough to hold the rest of the decompressed data. / / Return values: / / MZ_OK on success. Either more input is needed but not available, and/or there's more output to be written but the output buffer is full. / / MZ_STREAM_END if all needed input has been consumed and all output bytes have been written. For zlib streams, the adler-32 of the decompressed data has also been verified. / / MZ_STREAM_ERROR if the stream is bogus. / / MZ_DATA_ERROR if the deflate stream is invalid. / / MZ_PARAM_ERROR if one of the parameters is invalid. / / MZ_BUF_ERROR if no forward progress is possible because the input buffer is empty but the inflater needs more input to continue, or if the output buffer is not large enough. Call mz_inflate() again / / with more input data, or with more room in the output buffer (except when using single call decompression, described above).
mz_inflateEnd(mz_streamp pStream) → int: Deinitializes a decompressor.
mz_inflateInit(mz_streamp pStream) → int: Initializes a decompressor.
mz_inflateInit2(mz_streamp pStream, int window_bits) → int: mz_inflateInit2() is like mz_inflateInit() with an additional option that controls the window size and whether or not the stream has been wrapped with a zlib header/footer: / / window_bits must be MZ_DEFAULT_WINDOW_BITS (to parse zlib header/footer) or -MZ_DEFAULT_WINDOW_BITS (raw deflate).
mz_inflateReset(mz_streamp pStream) → int: Quickly resets a compressor without having to reallocate anything. Same as calling mz_inflateEnd() followed by mz_inflateInit()/mz_inflateInit2().
mz_uncompress(Pointer<ma_uint8> pDest, Pointer<mz_ulong> pDest_len, Pointer<ma_uint8> pSource, int source_len) → int: Single-call decompression. / / Returns MZ_OK on success, or one of the error codes from mz_inflate() on failure.
mz_uncompress2(Pointer<ma_uint8> pDest, Pointer<mz_ulong> pDest_len, Pointer<ma_uint8> pSource, Pointer<mz_ulong> pSource_len) → int
mz_version() → Pointer<Char>: Returns the version string of miniz.c.
mz_zip_add_mem_to_archive_file_in_place(Pointer<Char> pZip_filename, Pointer<Char> pArchive_name, Pointer<Void> pBuf, int buf_size, Pointer<Void> pComment, int comment_size, int level_and_flags) → int: mz_zip_add_mem_to_archive_file_in_place() efficiently (but not atomically) appends a memory blob to a ZIP archive. / / Note this is NOT a fully safe operation. If it crashes or dies in some way your archive can be left in a screwed up state (without a central directory). / / level_and_flags - compression level (0-10, see MZ_BEST_SPEED, MZ_BEST_COMPRESSION, etc.) logically OR'd with zero or more mz_zip_flags, or just set to MZ_DEFAULT_COMPRESSION. / / TODO: Perhaps add an option to leave the existing central dir in place in case the add dies? We could then truncate the file (so the old central dir would be at the end) if something goes wrong.
mz_zip_add_mem_to_archive_file_in_place_v2(Pointer<Char> pZip_filename, Pointer<Char> pArchive_name, Pointer<Void> pBuf, int buf_size, Pointer<Void> pComment, int comment_size, int level_and_flags, Pointer<ma_uint32> pErr) → int
mz_zip_clear_last_error(Pointer<mz_zip_archive> pZip) → mz_zip_error
mz_zip_end(Pointer<mz_zip_archive> pZip) → int: Universal end function - calls either mz_zip_reader_end() or mz_zip_writer_end().
mz_zip_extract_archive_file_to_heap(Pointer<Char> pZip_filename, Pointer<Char> pArchive_name, Pointer<Size> pSize, int flags$1) → Pointer<Void>: Reads a single file from an archive into a heap block. / / If pComment is not NULL, only the file with the specified comment will be extracted. / / Returns NULL on failure.
mz_zip_extract_archive_file_to_heap_v2(Pointer<Char> pZip_filename, Pointer<Char> pArchive_name, Pointer<Char> pComment, Pointer<Size> pSize, int flags$1, Pointer<ma_uint32> pErr) → Pointer<Void>
mz_zip_get_archive_file_start_offset(Pointer<mz_zip_archive> pZip) → int
mz_zip_get_archive_size(Pointer<mz_zip_archive> pZip) → int
mz_zip_get_central_dir_size(Pointer<mz_zip_archive> pZip) → int: Returns the total central directory size in bytes. / / The current max supported size is <= MZ_UINT32_MAX.
mz_zip_get_cfile(Pointer<mz_zip_archive> pZip) → Pointer<FILE>
mz_zip_get_error_string(mz_zip_error mz_err) → Pointer<Char>
mz_zip_get_last_error(Pointer<mz_zip_archive> pZip) → mz_zip_error
mz_zip_get_mode(Pointer<mz_zip_archive> pZip) → mz_zip_mode
mz_zip_get_type(Pointer<mz_zip_archive> pZip) → mz_zip_type
mz_zip_is_zip64(Pointer<mz_zip_archive> pZip) → int: MZ_TRUE if the file is in zip64 format. / / A file is considered zip64 if it contained a zip64 end of central directory marker, or if it contained any zip64 extended file information fields in the central directory.
mz_zip_peek_last_error(Pointer<mz_zip_archive> pZip) → mz_zip_error
mz_zip_read_archive_data(Pointer<mz_zip_archive> pZip, int file_ofs, Pointer<Void> pBuf, int n) → int: Reads n bytes of raw archive data, starting at file offset file_ofs, to pBuf.
mz_zip_reader_end(Pointer<mz_zip_archive> pZip) → int: Ends archive reading, freeing all allocations, and closing the input archive file if mz_zip_reader_init_file() was used.
mz_zip_reader_extract_file_iter_new(Pointer<mz_zip_archive> pZip, Pointer<Char> pFilename, int flags$1) → Pointer<mz_zip_reader_extract_iter_state>
mz_zip_reader_extract_file_to_callback(Pointer<mz_zip_archive> pZip, Pointer<Char> pFilename, mz_file_write_func pCallback, Pointer<Void> pOpaque, int flags$1) → int
mz_zip_reader_extract_file_to_cfile(Pointer<mz_zip_archive> pZip, Pointer<Char> pArchive_filename, Pointer<FILE> pFile, int flags$1) → int
mz_zip_reader_extract_file_to_file(Pointer<mz_zip_archive> pZip, Pointer<Char> pArchive_filename, Pointer<Char> pDst_filename, int flags$1) → int
mz_zip_reader_extract_file_to_heap(Pointer<mz_zip_archive> pZip, Pointer<Char> pFilename, Pointer<Size> pSize, int flags$1) → Pointer<Void>
mz_zip_reader_extract_file_to_mem(Pointer<mz_zip_archive> pZip, Pointer<Char> pFilename, Pointer<Void> pBuf, int buf_size, int flags$1) → int
mz_zip_reader_extract_file_to_mem_no_alloc(Pointer<mz_zip_archive> pZip, Pointer<Char> pFilename, Pointer<Void> pBuf, int buf_size, int flags$1, Pointer<Void> pUser_read_buf, int user_read_buf_size) → int
mz_zip_reader_extract_iter_free(Pointer<mz_zip_reader_extract_iter_state> pState) → int
mz_zip_reader_extract_iter_new(Pointer<mz_zip_archive> pZip, int file_index, int flags$1) → Pointer<mz_zip_reader_extract_iter_state>: Extract a file iteratively
mz_zip_reader_extract_iter_read(Pointer<mz_zip_reader_extract_iter_state> pState, Pointer<Void> pvBuf, int buf_size) → int
mz_zip_reader_extract_to_callback(Pointer<mz_zip_archive> pZip, int file_index, mz_file_write_func pCallback, Pointer<Void> pOpaque, int flags$1) → int: Extracts a archive file using a callback function to output the file's data.
mz_zip_reader_extract_to_cfile(Pointer<mz_zip_archive> pZip, int file_index, Pointer<FILE> File, int flags$1) → int: Extracts a archive file starting at the current position in the destination FILE stream.
mz_zip_reader_extract_to_file(Pointer<mz_zip_archive> pZip, int file_index, Pointer<Char> pDst_filename, int flags$1) → int: Extracts a archive file to a disk file and sets its last accessed and modified times. / / This function only extracts files, not archive directory records.
mz_zip_reader_extract_to_heap(Pointer<mz_zip_archive> pZip, int file_index, Pointer<Size> pSize, int flags$1) → Pointer<Void>: Extracts a archive file to a dynamically allocated heap buffer. / / The memory will be allocated via the mz_zip_archive's alloc/realloc functions. / / Returns NULL and sets the last error on failure.
mz_zip_reader_extract_to_mem(Pointer<mz_zip_archive> pZip, int file_index, Pointer<Void> pBuf, int buf_size, int flags$1) → int: Extracts a archive file to a memory buffer.
mz_zip_reader_extract_to_mem_no_alloc(Pointer<mz_zip_archive> pZip, int file_index, Pointer<Void> pBuf, int buf_size, int flags$1, Pointer<Void> pUser_read_buf, int user_read_buf_size) → int: Extracts a archive file to a memory buffer using no memory allocation. / / There must be at least enough room on the stack to store the inflator's state (~34KB or so).
mz_zip_reader_file_stat(Pointer<mz_zip_archive> pZip, int file_index, Pointer<mz_zip_archive_file_stat> pStat) → int: Returns detailed information about an archive file entry.
mz_zip_reader_get_filename(Pointer<mz_zip_archive> pZip, int file_index, Pointer<Char> pFilename, int filename_buf_size) → int: Retrieves the filename of an archive file entry. / / Returns the number of bytes written to pFilename, or if filename_buf_size is 0 this function returns the number of bytes needed to fully store the filename.
mz_zip_reader_get_num_files(Pointer<mz_zip_archive> pZip) → int: Returns the total number of files in the archive.
mz_zip_reader_init(Pointer<mz_zip_archive> pZip, int size, int flags$1) → int: Inits a ZIP archive reader. / / These functions read and validate the archive's central directory.
mz_zip_reader_init_cfile(Pointer<mz_zip_archive> pZip, Pointer<FILE> pFile, int archive_size, int flags$1) → int: Read an archive from an already opened FILE, beginning at the current file position. / / The archive is assumed to be archive_size bytes long. If archive_size is 0, then the entire rest of the file is assumed to contain the archive. / / The FILE will NOT be closed when mz_zip_reader_end() is called.
mz_zip_reader_init_file(Pointer<mz_zip_archive> pZip, Pointer<Char> pFilename, int flags$1) → int: Read a archive from a disk file. / / file_start_ofs is the file offset where the archive actually begins, or 0. / / actual_archive_size is the true total size of the archive, which may be smaller than the file's actual size on disk. If zero the entire file is treated as the archive.
mz_zip_reader_init_file_v2(Pointer<mz_zip_archive> pZip, Pointer<Char> pFilename, int flags$1, int file_start_ofs, int archive_size) → int
mz_zip_reader_init_mem(Pointer<mz_zip_archive> pZip, Pointer<Void> pMem, int size, int flags$1) → int
mz_zip_reader_is_file_a_directory(Pointer<mz_zip_archive> pZip, int file_index) → int: MZ_TRUE if the archive file entry is a directory entry.
mz_zip_reader_is_file_encrypted(Pointer<mz_zip_archive> pZip, int file_index) → int: MZ_TRUE if the file is encrypted/strong encrypted.
mz_zip_reader_is_file_supported(Pointer<mz_zip_archive> pZip, int file_index) → int: MZ_TRUE if the compression method is supported, and the file is not encrypted, and the file is not a compressed patch file.
mz_zip_reader_locate_file(Pointer<mz_zip_archive> pZip, Pointer<Char> pName, Pointer<Char> pComment, int flags$1) → int: Attempts to locates a file in the archive's central directory. / / Valid flags: MZ_ZIP_FLAG_CASE_SENSITIVE, MZ_ZIP_FLAG_IGNORE_PATH / / Returns -1 if the file cannot be found.
mz_zip_reader_locate_file_v2(Pointer<mz_zip_archive> pZip, Pointer<Char> pName, Pointer<Char> pComment, int flags$1, Pointer<mz_uint32> file_index) → int
mz_zip_set_last_error(Pointer<mz_zip_archive> pZip, mz_zip_error err_num) → mz_zip_error
mz_zip_validate_archive(Pointer<mz_zip_archive> pZip, int flags$1) → int: Validates an entire archive by calling mz_zip_validate_file() on each file.
mz_zip_validate_file(Pointer<mz_zip_archive> pZip, int file_index, int flags$1) → int: This function compares the archive's local headers, the optional local zip64 extended information block, and the optional descriptor following the compressed data vs. the data in the central directory. / / It also validates that each file can be successfully uncompressed unless the MZ_ZIP_FLAG_VALIDATE_HEADERS_ONLY is specified.
mz_zip_validate_file_archive(Pointer<Char> pFilename, int flags$1, Pointer<ma_uint32> pErr) → int
mz_zip_validate_mem_archive(Pointer<Void> pMem, int size, int flags$1, Pointer<ma_uint32> pErr) → int: Misc utils/helpers, valid for ZIP reading or writing
mz_zip_writer_add_cfile(Pointer<mz_zip_archive> pZip, Pointer<Char> pArchive_name, Pointer<FILE> pSrc_file, int max_size, Pointer<time_t> pFile_time, Pointer<Void> pComment, int comment_size, int level_and_flags, Pointer<Char> user_extra_data_local, int user_extra_data_local_len, Pointer<Char> user_extra_data_central, int user_extra_data_central_len) → int: Like mz_zip_writer_add_file(), except the file data is read from the specified FILE stream.
mz_zip_writer_add_file(Pointer<mz_zip_archive> pZip, Pointer<Char> pArchive_name, Pointer<Char> pSrc_filename, Pointer<Void> pComment, int comment_size, int level_and_flags) → int: Adds the contents of a disk file to an archive. This function also records the disk file's modified time into the archive. / / level_and_flags - compression level (0-10, see MZ_BEST_SPEED, MZ_BEST_COMPRESSION, etc.) logically OR'd with zero or more mz_zip_flags, or just set to MZ_DEFAULT_COMPRESSION.
mz_zip_writer_add_from_zip_reader(Pointer<mz_zip_archive> pZip, Pointer<mz_zip_archive> pSource_zip, int src_file_index) → int: Adds a file to an archive by fully cloning the data from another archive. / / This function fully clones the source file's compressed data (no recompression), along with its full filename, extra data (it may add or modify the zip64 local header extra data field), and the optional descriptor following the compressed data.
mz_zip_writer_add_mem(Pointer<mz_zip_archive> pZip, Pointer<Char> pArchive_name, Pointer<Void> pBuf, int buf_size, int level_and_flags) → int: Adds the contents of a memory buffer to an archive. These functions record the current local time into the archive. / / To add a directory entry, call this method with an archive name ending in a forwardslash with an empty buffer. / / level_and_flags - compression level (0-10, see MZ_BEST_SPEED, MZ_BEST_COMPRESSION, etc.) logically OR'd with zero or more mz_zip_flags, or just set to MZ_DEFAULT_COMPRESSION.
mz_zip_writer_add_mem_ex(Pointer<mz_zip_archive> pZip, Pointer<Char> pArchive_name, Pointer<Void> pBuf, int buf_size, Pointer<Void> pComment, int comment_size, int level_and_flags, int uncomp_size, int uncomp_crc32) → int: Like mz_zip_writer_add_mem(), except you can specify a file comment field, and optionally supply the function with already compressed data. / / uncomp_size/uncomp_crc32 are only used if the MZ_ZIP_FLAG_COMPRESSED_DATA flag is specified.
mz_zip_writer_add_mem_ex_v2(Pointer<mz_zip_archive> pZip, Pointer<Char> pArchive_name, Pointer<Void> pBuf, int buf_size, Pointer<Void> pComment, int comment_size, int level_and_flags, int uncomp_size, int uncomp_crc32, Pointer<time_t> last_modified, Pointer<Char> user_extra_data_local, int user_extra_data_local_len, Pointer<Char> user_extra_data_central, int user_extra_data_central_len) → int
mz_zip_writer_add_read_buf_callback(Pointer<mz_zip_archive> pZip, Pointer<Char> pArchive_name, mz_file_read_func read_callback, Pointer<Void> callback_opaque, int max_size, Pointer<time_t> pFile_time, Pointer<Void> pComment, int comment_size, int level_and_flags, Pointer<Char> user_extra_data_local, int user_extra_data_local_len, Pointer<Char> user_extra_data_central, int user_extra_data_central_len) → int: Adds the contents of a file to an archive. This function also records the disk file's modified time into the archive. / / File data is supplied via a read callback function. User mz_zip_writer_add_(c)file to add a file directly.
mz_zip_writer_end(Pointer<mz_zip_archive> pZip) → int: Ends archive writing, freeing all allocations, and closing the output file if mz_zip_writer_init_file() was used. / / Note for the archive to be valid, it must have been finalized before ending (this function will not do it for you).
mz_zip_writer_finalize_archive(Pointer<mz_zip_archive> pZip) → int: Finalizes the archive by writing the central directory records followed by the end of central directory record. / / After an archive is finalized, the only valid call on the mz_zip_archive struct is mz_zip_writer_end(). / / An archive must be manually finalized by calling this function for it to be valid.
mz_zip_writer_finalize_heap_archive(Pointer<mz_zip_archive> pZip, Pointer<Pointer<Void>> ppBuf, Pointer<Size> pSize) → int: Finalizes a heap archive, returning a pointer to the heap block and its size. / / The heap block will be allocated using the mz_zip_archive's alloc/realloc callbacks.
mz_zip_writer_init(Pointer<mz_zip_archive> pZip, int existing_size) → int: Inits a ZIP archive writer. */ /Set pZip->m_pWrite (and pZip->m_pIO_opaque) before calling mz_zip_writer_init or mz_zip_writer_init_v2/ /*The output is streamable, i.e. file_ofs in mz_file_write_func always increases only by n
mz_zip_writer_init_cfile(Pointer<mz_zip_archive> pZip, Pointer<FILE> pFile, int flags$1) → int
mz_zip_writer_init_file(Pointer<mz_zip_archive> pZip, Pointer<Char> pFilename, int size_to_reserve_at_beginning) → int
mz_zip_writer_init_file_v2(Pointer<mz_zip_archive> pZip, Pointer<Char> pFilename, int size_to_reserve_at_beginning, int flags$1) → int
mz_zip_writer_init_from_reader(Pointer<mz_zip_archive> pZip, Pointer<Char> pFilename) → int: Converts a ZIP archive reader object into a writer object, to allow efficient in-place file appends to occur on an existing archive. / / For archives opened using mz_zip_reader_init_file, pFilename must be the archive's filename so it can be reopened for writing. If the file can't be reopened, mz_zip_reader_end() will be called. / / For archives opened using mz_zip_reader_init_mem, the memory block must be growable using the realloc callback (which defaults to realloc unless you've overridden it). / / Finally, for archives opened using mz_zip_reader_init, the mz_zip_archive's user provided m_pWrite function cannot be NULL. / / Note: In-place archive modification is not recommended unless you know what you're doing, because if execution stops or something goes wrong before / / the archive is finalized the file's central directory will be hosed.
mz_zip_writer_init_from_reader_v2(Pointer<mz_zip_archive> pZip, Pointer<Char> pFilename, int flags$1) → int
mz_zip_writer_init_heap(Pointer<mz_zip_archive> pZip, int size_to_reserve_at_beginning, int initial_allocation_size) → int
mz_zip_writer_init_heap_v2(Pointer<mz_zip_archive> pZip, int size_to_reserve_at_beginning, int initial_allocation_size, int flags$1) → int
mz_zip_writer_init_v2(Pointer<mz_zip_archive> pZip, int existing_size, int flags$1) → int
mz_zip_zero_struct(Pointer<mz_zip_archive> pZip) → void: Clears a mz_zip_archive struct to all zeros. / / Important: This must be done before passing the struct to any mz_zip functions.
stb_c_lexer_get_location(Pointer<stb_lexer> lexer, Pointer<Char> where, Pointer<stb_lex_location> loc) → void: this function returns non-zero if a token is parsed, or 0 if at EOF Output:
stb_c_lexer_get_token(Pointer<stb_lexer> lexer) → int: this function initialize the 'lexer' structure Input:
stb_c_lexer_init(Pointer<stb_lexer> lexer, Pointer<Char> input_stream, Pointer<Char> input_stream_end, Pointer<Char> string_store, int store_length) → void
stb_compress_bc4_block(Pointer<ma_uint8> dest, Pointer<ma_uint8> src_r_one_byte_per_pixel) → void
stb_compress_bc5_block(Pointer<ma_uint8> dest, Pointer<ma_uint8> src_rg_two_byte_per_pixel) → void
stb_compress_dxt_block(Pointer<ma_uint8> dest, Pointer<ma_uint8> src_rgba_four_bytes_per_pixel, int alpha, int mode) → void
stb_div_eucl(int value_to_be_divided, int value_to_divide_by) → int
stb_div_floor(int value_to_be_divided, int value_to_divide_by) → int
stb_div_trunc(int value_to_be_divided, int value_to_divide_by) → int
stb_easy_font_draw_segs(double x, double y, Pointer<ma_uint8> segs, int num_segs, int vertical, stb_easy_font_color c, Pointer<Char> vbuf, int vbuf_size, int offset) → int
stb_easy_font_height(Pointer<Char> text) → int
stb_easy_font_print(double x, double y, Pointer<Char> text, Pointer<ma_uint8> color, Pointer<Void> vertex_buffer, int vbuf_size) → int
stb_easy_font_spacing(double spacing) → void
stb_easy_font_width(Pointer<Char> text) → int
stb_include_file(Pointer<Char> filename, Pointer<Char> inject, Pointer<Char> path_to_includes, Pointer<Char> error) → Pointer<Char>: Load the file 'filename' and do include-processing on the string therein. note that 'filename' is opened directly; 'path_to_includes' is not used. To free the return value, pass it to free()
stb_include_string(Pointer<Char> str, Pointer<Char> inject, Pointer<Char> path_to_includes, Pointer<Char> filename_for_line_directive, Pointer<Char> error) → Pointer<Char>: Do include-processing on the string 'str'. To free the return value, pass it to free()
stb_include_strings(Pointer<Pointer<Char>> strs, int count, Pointer<Char> inject, Pointer<Char> path_to_includes, Pointer<Char> filename_for_line_directive, Pointer<Char> error) → Pointer<Char>: Concatenate the strings 'strs' and do include-processing on the result. To free the return value, pass it to free()
stb_leakcheck_dumpmem() → void
stb_leakcheck_free(Pointer<Void> ptr) → void
stb_leakcheck_malloc(int sz, Pointer<Char> file, int line) → Pointer<Void>
stb_leakcheck_realloc(Pointer<Void> ptr, int sz, Pointer<Char> file, int line) → Pointer<Void>
stb_mod_eucl(int value_to_be_divided, int value_to_divide_by) → int
stb_mod_floor(int value_to_be_divided, int value_to_divide_by) → int
stb_mod_trunc(int value_to_be_divided, int value_to_divide_by) → int
stb_perlin_fbm_noise3(double x, double y, double z, double lacunarity, double gain, int octaves) → double
stb_perlin_noise3(double x, double y, double z, int x_wrap, int y_wrap, int z_wrap) → double
stb_perlin_noise3_seed(double x, double y, double z, int x_wrap, int y_wrap, int z_wrap, int seed) → double
stb_perlin_noise3_wrap_nonpow2(double x, double y, double z, int x_wrap, int y_wrap, int z_wrap, int seed) → double
stb_perlin_ridge_noise3(double x, double y, double z, double lacunarity, double gain, double offset, int octaves) → double
stb_perlin_turbulence_noise3(double x, double y, double z, double lacunarity, double gain, int octaves) → double
stbcc_get_unique_id(Pointer<stbcc_grid> g, int x, int y) → int: get a unique id for the connected component this is in; it's not necessarily small, you'll need a hash table or something to remap it (or just use
stbcc_grid_sizeof() → int: you allocate the grid data structure to this size (note that it will be very big!!!)
stbcc_init_grid(Pointer<stbcc_grid> g, Pointer<ma_uint8> map, int w, int h) → void: initialize the grid, value of map[] is 0 = traversable, non-0 is solid
stbcc_query_grid_node_connection(Pointer<stbcc_grid> g, int x1, int y1, int x2, int y2) → int: query if two grid squares are reachable from each other
stbcc_query_grid_open(Pointer<stbcc_grid> g, int x, int y) → int: query the grid data structure for whether a given square is open or not
stbcc_update_batch_begin(Pointer<stbcc_grid> g) → void: wrap multiple stbcc_update_grid calls in these function to compute multiple updates more efficiently; cannot make queries inside batch
stbcc_update_batch_end(Pointer<stbcc_grid> g) → void
stbcc_update_grid(Pointer<stbcc_grid> g, int x, int y, int solid) → void: update a grid square state, 0 = traversable, non-0 is solid i can add a batch-update if it's needed
stbds_arrfreef(Pointer<Void> a) → void
stbds_arrgrowf(Pointer<Void> a, int elemsize, int addlen, int min_cap) → Pointer<Void>: ////////////
stbds_hash_bytes(Pointer<Void> p, int len, int seed) → int: these are the hash functions used internally if you want to test them or use them for other purposes
stbds_hash_string(Pointer<Char> str, int seed) → int
stbds_hmdel_key(Pointer<Void> a, int elemsize, Pointer<Void> key, int keysize, int keyoffset, int mode) → Pointer<Void>
stbds_hmfree_func(Pointer<Void> p, int elemsize) → void
stbds_hmget_key(Pointer<Void> a, int elemsize, Pointer<Void> key, int keysize, int mode) → Pointer<Void>
stbds_hmget_key_ts(Pointer<Void> a, int elemsize, Pointer<Void> key, int keysize, Pointer<time_t> temp, int mode) → Pointer<Void>
stbds_hmput_default(Pointer<Void> a, int elemsize) → Pointer<Void>
stbds_hmput_key(Pointer<Void> a, int elemsize, Pointer<Void> key, int keysize, int mode) → Pointer<Void>
stbds_rand_seed(int seed) → void: for security against attackers, seed the library with a random number, at least time() but stronger is better
stbds_shmode_func(int elemsize, int mode) → Pointer<Void>
stbds_stralloc(Pointer<stbds_string_arena> a, Pointer<Char> str) → Pointer<Char>
stbds_strreset(Pointer<stbds_string_arena> a) → void
stbds_unit_tests() → void: have to #define STBDS_UNIT_TESTS to call this
stbhw_build_tileset_from_image(Pointer<stbhw_tileset> ts, Pointer<ma_uint8> pixels, int stride_in_bytes, int w, int h) → int: build a tileset from an image that conforms to a template created by this library. (you allocate storage for stbhw_tileset and function fills it out; memory for individual tiles are malloc()ed). returns non-zero on success, 0 on error
stbhw_free_tileset(Pointer<stbhw_tileset> ts) → void: free a tileset built by stbhw_build_tileset_from_image
stbhw_generate_image(Pointer<stbhw_tileset> ts, Pointer<Pointer<Int>> weighting, Pointer<ma_uint8> pixels, int stride_in_bytes, int w, int h) → int: generate a map that is w * h pixels (3-bytes each) returns non-zero on success, 0 on error not thread-safe (uses a global data structure to avoid memory management) weighting should be NULL, as non-NULL weighting is currently untested
stbhw_get_last_error() → Pointer<Char>: returns description of last error produced by any function (not thread-safe)
stbhw_get_template_size(Pointer<stbhw_config> c, Pointer<Int> w, Pointer<Int> h) → void: computes the size needed for the template image
stbhw_make_template(Pointer<stbhw_config> c, Pointer<ma_uint8> data, int w, int h, int stride_in_bytes) → int: generates a template image, assuming data is 3wh bytes long, RGB format
stbi_convert_iphone_png_to_rgb(int flag_true_if_should_convert) → void: indicate whether we should process iphone images back to canonical format, or just pass them through "as-is"
stbi_convert_iphone_png_to_rgb_thread(int flag_true_if_should_convert) → void
stbi_failure_reason() → Pointer<Char>: get a VERY brief reason for failure on most compilers (and ALL modern mainstream compilers) this is threadsafe
stbi_flip_vertically_on_write(int flip_boolean) → void
stbi_hdr_to_ldr_gamma(double gamma) → void
stbi_hdr_to_ldr_scale(double scale) → void
stbi_image_free(Pointer<Void> retval_from_stbi_load) → void: free the loaded image -- this is just free()
stbi_info(Pointer<Char> filename, Pointer<Int> x, Pointer<Int> y, Pointer<Int> comp) → int
stbi_info_from_callbacks(Pointer<stbi_io_callbacks> clbk, Pointer<Void> user, Pointer<Int> x, Pointer<Int> y, Pointer<Int> comp) → int
stbi_info_from_file(Pointer<FILE> f, Pointer<Int> x, Pointer<Int> y, Pointer<Int> comp) → int
stbi_info_from_memory(Pointer<ma_uint8> buffer, int len, Pointer<Int> x, Pointer<Int> y, Pointer<Int> comp) → int: get image dimensions & components without fully decoding
stbi_is_16_bit(Pointer<Char> filename) → int
stbi_is_16_bit_from_callbacks(Pointer<stbi_io_callbacks> clbk, Pointer<Void> user) → int
stbi_is_16_bit_from_file(Pointer<FILE> f) → int
stbi_is_16_bit_from_memory(Pointer<ma_uint8> buffer, int len) → int
stbi_is_hdr(Pointer<Char> filename) → int
stbi_is_hdr_from_callbacks(Pointer<stbi_io_callbacks> clbk, Pointer<Void> user) → int: stbi_is_hdr is always defined, but always returns false if STBI_NO_HDR
stbi_is_hdr_from_file(Pointer<FILE> f) → int
stbi_is_hdr_from_memory(Pointer<ma_uint8> buffer, int len) → int
stbi_ldr_to_hdr_gamma(double gamma) → void
stbi_ldr_to_hdr_scale(double scale) → void
stbi_load(Pointer<Char> filename, Pointer<Int> x, Pointer<Int> y, Pointer<Int> channels_in_file, int desired_channels) → Pointer<ma_uint8>
stbi_load_16(Pointer<Char> filename, Pointer<Int> x, Pointer<Int> y, Pointer<Int> channels_in_file, int desired_channels) → Pointer<stbi_us>
stbi_load_16_from_callbacks(Pointer<stbi_io_callbacks> clbk, Pointer<Void> user, Pointer<Int> x, Pointer<Int> y, Pointer<Int> channels_in_file, int desired_channels) → Pointer<stbi_us>
stbi_load_16_from_memory(Pointer<ma_uint8> buffer, int len, Pointer<Int> x, Pointer<Int> y, Pointer<Int> channels_in_file, int desired_channels) → Pointer<stbi_us>: /////////////////////////////////
stbi_load_from_callbacks(Pointer<stbi_io_callbacks> clbk, Pointer<Void> user, Pointer<Int> x, Pointer<Int> y, Pointer<Int> channels_in_file, int desired_channels) → Pointer<ma_uint8>
stbi_load_from_file(Pointer<FILE> f, Pointer<Int> x, Pointer<Int> y, Pointer<Int> channels_in_file, int desired_channels) → Pointer<ma_uint8>
stbi_load_from_file_16(Pointer<FILE> f, Pointer<Int> x, Pointer<Int> y, Pointer<Int> channels_in_file, int desired_channels) → Pointer<stbi_us>
stbi_load_from_memory(Pointer<ma_uint8> buffer, int len, Pointer<Int> x, Pointer<Int> y, Pointer<Int> channels_in_file, int desired_channels) → Pointer<ma_uint8>: /////////////////////////////////
stbi_load_gif_from_memory(Pointer<ma_uint8> buffer, int len, Pointer<Pointer<Int>> delays, Pointer<Int> x, Pointer<Int> y, Pointer<Int> z, Pointer<Int> comp, int req_comp) → Pointer<ma_uint8>
stbi_loadf(Pointer<Char> filename, Pointer<Int> x, Pointer<Int> y, Pointer<Int> channels_in_file, int desired_channels) → Pointer<Float>
stbi_loadf_from_callbacks(Pointer<stbi_io_callbacks> clbk, Pointer<Void> user, Pointer<Int> x, Pointer<Int> y, Pointer<Int> channels_in_file, int desired_channels) → Pointer<Float>
stbi_loadf_from_file(Pointer<FILE> f, Pointer<Int> x, Pointer<Int> y, Pointer<Int> channels_in_file, int desired_channels) → Pointer<Float>
stbi_loadf_from_memory(Pointer<ma_uint8> buffer, int len, Pointer<Int> x, Pointer<Int> y, Pointer<Int> channels_in_file, int desired_channels) → Pointer<Float>
stbi_set_flip_vertically_on_load(int flag_true_if_should_flip) → void: flip the image vertically, so the first pixel in the output array is the bottom left
stbi_set_flip_vertically_on_load_thread(int flag_true_if_should_flip) → void
stbi_set_unpremultiply_on_load(int flag_true_if_should_unpremultiply) → void: for image formats that explicitly notate that they have premultiplied alpha, we just return the colors as stored in the file. set this flag to force unpremultiplication. results are undefined if the unpremultiply overflow.
stbi_set_unpremultiply_on_load_thread(int flag_true_if_should_unpremultiply) → void: as above, but only applies to images loaded on the thread that calls the function this function is only available if your compiler supports thread-local variables; calling it will fail to link if your compiler doesn't
stbi_write_bmp(Pointer<Char> filename, int w, int h, int comp, Pointer<Void> data) → int
stbi_write_bmp_to_func(Pointer<stbi_write_func> func, Pointer<Void> context, int w, int h, int comp, Pointer<Void> data) → int
stbi_write_hdr(Pointer<Char> filename, int w, int h, int comp, Pointer<Float> data) → int
stbi_write_hdr_to_func(Pointer<stbi_write_func> func, Pointer<Void> context, int w, int h, int comp, Pointer<Float> data) → int
stbi_write_jpg(Pointer<Char> filename, int x, int y, int comp, Pointer<Void> data, int quality) → int
stbi_write_jpg_to_func(Pointer<stbi_write_func> func, Pointer<Void> context, int x, int y, int comp, Pointer<Void> data, int quality) → int
stbi_write_png(Pointer<Char> filename, int w, int h, int comp, Pointer<Void> data, int stride_in_bytes) → int
stbi_write_png_to_func(Pointer<stbi_write_func> func, Pointer<Void> context, int w, int h, int comp, Pointer<Void> data, int stride_in_bytes) → int
stbi_write_tga(Pointer<Char> filename, int w, int h, int comp, Pointer<Void> data) → int
stbi_write_tga_to_func(Pointer<stbi_write_func> func, Pointer<Void> context, int w, int h, int comp, Pointer<Void> data) → int
stbi_zlib_decode_buffer(Pointer<Char> obuffer, int olen, Pointer<Char> ibuffer, int ilen) → int
stbi_zlib_decode_malloc(Pointer<Char> buffer, int len, Pointer<Int> outlen) → Pointer<Char>
stbi_zlib_decode_malloc_guesssize(Pointer<Char> buffer, int len, int initial_size, Pointer<Int> outlen) → Pointer<Char>: ZLIB client - used by PNG, available for other purposes
stbi_zlib_decode_malloc_guesssize_headerflag(Pointer<Char> buffer, int len, int initial_size, Pointer<Int> outlen, int parse_header) → Pointer<Char>
stbi_zlib_decode_noheader_buffer(Pointer<Char> obuffer, int olen, Pointer<Char> ibuffer, int ilen) → int
stbi_zlib_decode_noheader_malloc(Pointer<Char> buffer, int len, Pointer<Int> outlen) → Pointer<Char>
stbir_build_samplers(Pointer<STBIR_RESIZE> resize) → int: This builds the samplers and does one allocation
stbir_build_samplers_with_splits(Pointer<STBIR_RESIZE> resize, int try_splits) → int: This will build samplers for threading. You can pass in the number of threads you'd like to use (try_splits). It returns the number of splits (threads) that you can call it with. It might be less if the image resize can't be split up that many ways.
stbir_free_samplers(Pointer<STBIR_RESIZE> resize) → void: You MUST call this, if you call stbir_build_samplers or stbir_build_samplers_with_splits
stbir_resize(Pointer<Void> input_pixels, int input_w, int input_h, int input_stride_in_bytes, Pointer<Void> output_pixels, int output_w, int output_h, int output_stride_in_bytes, stbir_pixel_layout pixel_layout, stbir_datatype data_type, stbir_edge edge, stbir_filter filter) → Pointer<Void>
stbir_resize_extended(Pointer<STBIR_RESIZE> resize) → int: And this is the main function to perform the resize synchronously on one thread.
stbir_resize_extended_split(Pointer<STBIR_RESIZE> resize, int split_start, int split_count) → int: Usually, you will always call stbir_resize_split with split_start as the thread_index and "1" for the split_count. But, if you have a weird situation where you MIGHT want 8 threads, but sometimes only 4 threads, you can use 0,2,4,6 for the split_start's and use "2" for the split_count each time to turn in into a 4 thread resize. (This is unusual).
stbir_resize_float_linear(Pointer<Float> input_pixels, int input_w, int input_h, int input_stride_in_bytes, Pointer<Float> output_pixels, int output_w, int output_h, int output_stride_in_bytes, stbir_pixel_layout pixel_type) → Pointer<Float>
stbir_resize_init(Pointer<STBIR_RESIZE> resize, Pointer<Void> input_pixels, int input_w, int input_h, int input_stride_in_bytes, Pointer<Void> output_pixels, int output_w, int output_h, int output_stride_in_bytes, stbir_pixel_layout pixel_layout, stbir_datatype data_type) → void
stbir_resize_uint8_linear(Pointer<ma_uint8> input_pixels, int input_w, int input_h, int input_stride_in_bytes, Pointer<ma_uint8> output_pixels, int output_w, int output_h, int output_stride_in_bytes, stbir_pixel_layout pixel_type) → Pointer<ma_uint8>
stbir_resize_uint8_srgb(Pointer<ma_uint8> input_pixels, int input_w, int input_h, int input_stride_in_bytes, Pointer<ma_uint8> output_pixels, int output_w, int output_h, int output_stride_in_bytes, stbir_pixel_layout pixel_type) → Pointer<ma_uint8>
stbir_set_buffer_ptrs(Pointer<STBIR_RESIZE> resize, Pointer<Void> input_pixels, int input_stride_in_bytes, Pointer<Void> output_pixels, int output_stride_in_bytes) → void
stbir_set_datatypes(Pointer<STBIR_RESIZE> resize, stbir_datatype input_type, stbir_datatype output_type) → void
stbir_set_edgemodes(Pointer<STBIR_RESIZE> resize, stbir_edge horizontal_edge, stbir_edge vertical_edge) → int
stbir_set_filter_callbacks(Pointer<STBIR_RESIZE> resize, Pointer<stbir__kernel_callback> horizontal_filter, Pointer<stbir__support_callback> horizontal_support, Pointer<stbir__kernel_callback> vertical_filter, Pointer<stbir__support_callback> vertical_support) → int
stbir_set_filters(Pointer<STBIR_RESIZE> resize, stbir_filter horizontal_filter, stbir_filter vertical_filter) → int
stbir_set_input_subrect(Pointer<STBIR_RESIZE> resize, double s0, double t0, double s1, double t1) → int
stbir_set_non_pm_alpha_speed_over_quality(Pointer<STBIR_RESIZE> resize, int non_pma_alpha_speed_over_quality) → int: when inputting AND outputting non-premultiplied alpha pixels, we use a slower but higher quality technique that fills the zero alpha pixel's RGB values with something plausible. If you don't care about areas of zero alpha, you can call this function to get about a 25% speed improvement for STBIR_RGBA to STBIR_RGBA types of resizes.
stbir_set_output_pixel_subrect(Pointer<STBIR_RESIZE> resize, int subx, int suby, int subw, int subh) → int
stbir_set_pixel_callbacks(Pointer<STBIR_RESIZE> resize, Pointer<stbir_input_callback> input_cb, Pointer<stbir_output_callback> output_cb) → void
stbir_set_pixel_layouts(Pointer<STBIR_RESIZE> resize, stbir_pixel_layout input_pixel_layout, stbir_pixel_layout output_pixel_layout) → int
stbir_set_pixel_subrect(Pointer<STBIR_RESIZE> resize, int subx, int suby, int subw, int subh) → int
stbir_set_user_data(Pointer<STBIR_RESIZE> resize, Pointer<Void> user_data) → void
stbrp_init_target(Pointer<stbrp_context> context, int width, int height, Pointer<stbrp_node> nodes, int num_nodes) → void
stbrp_pack_rects(Pointer<stbrp_context> context, Pointer<stbrp_rect> rects, int num_rects) → int: Mostly for internal use, but this is the maximum supported coordinate value.
stbrp_setup_allow_out_of_mem(Pointer<stbrp_context> context, int allow_out_of_mem) → void: Initialize a rectangle packer to: pack a rectangle that is 'width' by 'height' in dimensions using temporary storage provided by the array 'nodes', which is 'num_nodes' long
stbrp_setup_heuristic(Pointer<stbrp_context> context, int heuristic) → void: Optionally call this function after init but before doing any packing to change the handling of the out-of-temp-memory scenario, described above. If you call init again, this will be reset to the default (false).
stbsp_set_separators(int comma, int period) → void
stbsp_snprintf(Pointer<Char> buf, int count, Pointer<Char> fmt) → int
stbsp_sprintf(Pointer<Char> buf, Pointer<Char> fmt) → int
stbsp_vsnprintf(Pointer<Char> buf, int count, Pointer<Char> fmt, Pointer<__va_list_tag> va) → int
stbsp_vsprintf(Pointer<Char> buf, Pointer<Char> fmt, Pointer<__va_list_tag> va) → int
stbsp_vsprintfcb(Pointer<STBSP_SPRINTFCB> callback, Pointer<Void> user, Pointer<Char> buf, Pointer<Char> fmt, Pointer<__va_list_tag> va) → int
stbte_action$1(Pointer<stbte_tilemap> tm, stbte_action act) → void
stbte_clear_map(Pointer<stbte_tilemap> tm) → void: set the dimensions of the level, overrides previous stbte_create_map() values or anything the user has changed
stbte_create_map(int map_x, int map_y, int map_layers, int spacing_x, int spacing_y, int max_tiles) → Pointer<stbte_tilemap>: /////
stbte_define_tile(Pointer<stbte_tilemap> tm, int id, int layermask, Pointer<Char> category) → void: create an editable tilemap map_x : dimensions of map horizontally (user can change this in editor), <= STBTE_MAX_TILEMAP_X map_y : dimensions of map vertically (user can change this in editor) <= STBTE_MAX_TILEMAP_Y map_layers : number of layers to use (fixed), <= STBTE_MAX_LAYERS spacing_x : initial horizontal distance between left edges of map tiles in stb_tilemap_editor pixels spacing_y : initial vertical distance between top edges of map tiles in stb_tilemap_editor pixels max_tiles : maximum number of tiles that can defined
stbte_draw(Pointer<stbte_tilemap> tm) → void: //////
stbte_get_dimensions(Pointer<stbte_tilemap> tm, Pointer<Int> max_x, Pointer<Int> max_y) → void
stbte_get_link(Pointer<stbte_tilemap> tm, int x, int y, Pointer<Int> destx, Pointer<Int> desty) → void: get the property array associated with the tile at x,y. this is an array of floats that is STBTE_MAX_PROPERTIES in length; you have to interpret the slots according to the semantics you've chosen
stbte_get_properties(Pointer<stbte_tilemap> tm, int x, int y) → Pointer<Float>: returns an array of shorts that is 'map_layers' in length. each short is either one of the tile_id values from define_tile, or STBTE_EMPTY.
stbte_get_tile(Pointer<stbte_tilemap> tm, int x, int y) → Pointer<ma_int16>: get the dimensions of the level, since the user can change them
stbte_mouse_button(Pointer<stbte_tilemap> tm, int x, int y, int right, int down, int shifted, int scrollkey) → void
stbte_mouse_move(Pointer<stbte_tilemap> tm, int x, int y, int shifted, int scrollkey) → void: otherwise, hook these up explicitly:
stbte_mouse_sdl(Pointer<stbte_tilemap> tm, Pointer<Void> sdl_event, double xscale, double yscale, int xoffset, int yoffset) → void: if you're using SDL, call the next function for SDL_MOUSEMOTION, SDL_MOUSEBUTTONDOWN, SDL_MOUSEBUTTONUP, SDL_MOUSEWHEEL; the transformation lets you scale from SDL mouse coords to stb_tilemap_editor coords
stbte_mouse_wheel(Pointer<stbte_tilemap> tm, int x, int y, int vscroll) → void
stbte_set_background_tile(Pointer<stbte_tilemap> tm, int id) → void: /////
stbte_set_dimensions(Pointer<stbte_tilemap> tm, int max_x, int max_y) → void: gets the link associated with the tile at x,y.
stbte_set_display(int x0, int y0, int x1, int y1) → void: call this repeatedly for each tile to install the tile definitions into the editable tilemap tm : tilemap created by stbte_create_map id : unique identifier for each tile, 0 <= id < 32768 layermask : bitmask of which layers tile is allowed on: 1 = layer 0, 255 = layers 0..7 (note that onscreen, the editor numbers the layers from 1 not 0) layer 0 is the furthest back, layer 1 is just in front of layer 0, etc category : which category this tile is grouped in
stbte_set_layername(Pointer<stbte_tilemap> tm, int layer, Pointer<Char> layername) → void: call this to set the spacing of map tiles and the spacing of palette tiles. if you rescale your display, call it again (e.g. you can implement map zooming yourself)
stbte_set_link(Pointer<stbte_tilemap> tm, int x, int y, int destx, int desty) → void: set the value of the n'th slot of the tile at x,y
stbte_set_property(Pointer<stbte_tilemap> tm, int x, int y, int n, double val) → void: tile is your tile_id from define_tile, or STBTE_EMPTY
stbte_set_sidewidths(int left, int right) → void: selects the tile to fill the bottom layer with and used to clear bottom tiles to; should be same ID as
stbte_set_spacing(Pointer<stbte_tilemap> tm, int spacing_x, int spacing_y, int palette_spacing_x, int palette_spacing_y) → void: call this once to set the left & right side widths. don't call it again since the user can change it
stbte_set_tile(Pointer<stbte_tilemap> tm, int x, int y, int layer, int tile) → void: clears the map, including the region outside the defined region, so if the user expands the map, they won't see garbage there
stbte_tick(Pointer<stbte_tilemap> tm, double time_in_seconds_since_last_frame) → void
stbtt_BakeFontBitmap(Pointer<ma_uint8> data, int offset, double pixel_height, Pointer<ma_uint8> pixels, int pw, int ph, int first_char, int num_chars, Pointer<stbtt_bakedchar> chardata) → int
stbtt_CompareUTF8toUTF16_bigendian(Pointer<Char> s1, int len1, Pointer<Char> s2, int len2) → int
stbtt_FindGlyphIndex(Pointer<stbtt_fontinfo> info, int unicode_codepoint) → int: ///////////////////////////////////////////////////////////////////////////
stbtt_FindMatchingFont(Pointer<ma_uint8> fontdata, Pointer<Char> name, int flags$1) → int: ///////////////////////////////////////////////////////////////////////////
stbtt_FindSVGDoc(Pointer<stbtt_fontinfo> info, int gl) → Pointer<ma_uint8>: frees the data allocated above
stbtt_FreeBitmap(Pointer<ma_uint8> bitmap, Pointer<Void> userdata) → void: ///////////////////////////////////////////////////////////////////////////
stbtt_FreeSDF(Pointer<ma_uint8> bitmap, Pointer<Void> userdata) → void: ///////////////////////////////////////////////////////////////////////////
stbtt_FreeShape(Pointer<stbtt_fontinfo> info, Pointer<stbtt_vertex> vertices) → void: returns # of vertices and fills *vertices with the pointer to them these are expressed in "unscaled" coordinates
stbtt_GetBakedQuad(Pointer<stbtt_bakedchar> chardata, int pw, int ph, int char_index, Pointer<Float> xpos, Pointer<Float> ypos, Pointer<stbtt_aligned_quad> q, int opengl_fillrule) → void
stbtt_GetCodepointBitmap(Pointer<stbtt_fontinfo> info, double scale_x, double scale_y, int codepoint, Pointer<Int> width, Pointer<Int> height, Pointer<Int> xoff, Pointer<Int> yoff) → Pointer<ma_uint8>: frees the bitmap allocated below
stbtt_GetCodepointBitmapBox(Pointer<stbtt_fontinfo> font, int codepoint, double scale_x, double scale_y, Pointer<Int> ix0, Pointer<Int> iy0, Pointer<Int> ix1, Pointer<Int> iy1) → void: same as stbtt_MakeCodepointBitmapSubpixel, but prefiltering is performed (see stbtt_PackSetOversampling)
stbtt_GetCodepointBitmapBoxSubpixel(Pointer<stbtt_fontinfo> font, int codepoint, double scale_x, double scale_y, double shift_x, double shift_y, Pointer<Int> ix0, Pointer<Int> iy0, Pointer<Int> ix1, Pointer<Int> iy1) → void: get the bbox of the bitmap centered around the glyph origin; so the bitmap width is ix1-ix0, height is iy1-iy0, and location to place the bitmap top left is (leftSideBearing*scale,iy0). (Note that the bitmap uses y-increases-down, but the shape uses y-increases-up, so CodepointBitmapBox and CodepointBox are inverted.)
stbtt_GetCodepointBitmapSubpixel(Pointer<stbtt_fontinfo> info, double scale_x, double scale_y, double shift_x, double shift_y, int codepoint, Pointer<Int> width, Pointer<Int> height, Pointer<Int> xoff, Pointer<Int> yoff) → Pointer<ma_uint8>: allocates a large-enough single-channel 8bpp bitmap and renders the specified character/glyph at the specified scale into it, with antialiasing. 0 is no coverage (transparent), 255 is fully covered (opaque). *width & *height are filled out with the width & height of the bitmap, which is stored left-to-right, top-to-bottom.
stbtt_GetCodepointBox(Pointer<stbtt_fontinfo> info, int codepoint, Pointer<Int> x0, Pointer<Int> y0, Pointer<Int> x1, Pointer<Int> y1) → int: an additional amount to add to the 'advance' value between ch1 and ch2
stbtt_GetCodepointHMetrics(Pointer<stbtt_fontinfo> info, int codepoint, Pointer<Int> advanceWidth, Pointer<Int> leftSideBearing) → void: the bounding box around all possible characters
stbtt_GetCodepointKernAdvance(Pointer<stbtt_fontinfo> info, int ch1, int ch2) → int: leftSideBearing is the offset from the current horizontal position to the left edge of the character advanceWidth is the offset from the current horizontal position to the next horizontal position these are expressed in unscaled coordinates
stbtt_GetCodepointSDF(Pointer<stbtt_fontinfo> info, double scale, int codepoint, int padding, int onedge_value, double pixel_dist_scale, Pointer<Int> width, Pointer<Int> height, Pointer<Int> xoff, Pointer<Int> yoff) → Pointer<ma_uint8>
stbtt_GetCodepointShape(Pointer<stbtt_fontinfo> info, int unicode_codepoint, Pointer<Pointer<stbtt_vertex>> vertices) → int: returns non-zero if nothing is drawn for this glyph
stbtt_GetCodepointSVG(Pointer<stbtt_fontinfo> info, int unicode_codepoint, Pointer<Pointer<Char>> svg) → int
stbtt_GetFontBoundingBox(Pointer<stbtt_fontinfo> info, Pointer<Int> x0, Pointer<Int> y0, Pointer<Int> x1, Pointer<Int> y1) → void: analogous to GetFontVMetrics, but returns the "typographic" values from the OS/2 table (specific to MS/Windows TTF files).
stbtt_GetFontNameString(Pointer<stbtt_fontinfo> font, Pointer<Int> length, int platformID, int encodingID, int languageID, int nameID) → Pointer<Char>: returns 1/0 whether the first string interpreted as utf8 is identical to the second string interpreted as big-endian utf16... useful for strings from next func
stbtt_GetFontOffsetForIndex(Pointer<ma_uint8> data, int index) → int: This function will determine the number of fonts in a font file. TrueType collection (.ttc) files may contain multiple fonts, while TrueType font (.ttf) files only contain one font. The number of fonts can be used for indexing with the previous function where the index is between zero and one less than the total fonts. If an error occurs, -1 is returned.
stbtt_GetFontVMetrics(Pointer<stbtt_fontinfo> info, Pointer<Int> ascent, Pointer<Int> descent, Pointer<Int> lineGap) → void: computes a scale factor to produce a font whose EM size is mapped to 'pixels' tall. This is probably what traditional APIs compute, but I'm not positive.
stbtt_GetFontVMetricsOS2(Pointer<stbtt_fontinfo> info, Pointer<Int> typoAscent, Pointer<Int> typoDescent, Pointer<Int> typoLineGap) → int: ascent is the coordinate above the baseline the font extends; descent is the coordinate below the baseline the font extends (i.e. it is typically negative) lineGap is the spacing between one row's descent and the next row's ascent... so you should advance the vertical position by "*ascent - *descent + *lineGap" these are expressed in unscaled coordinates, so you must multiply by the scale factor for a given size
stbtt_GetGlyphBitmap(Pointer<stbtt_fontinfo> info, double scale_x, double scale_y, int glyph, Pointer<Int> width, Pointer<Int> height, Pointer<Int> xoff, Pointer<Int> yoff) → Pointer<ma_uint8>: the following functions are equivalent to the above functions, but operate on glyph indices instead of Unicode codepoints (for efficiency)
stbtt_GetGlyphBitmapBox(Pointer<stbtt_fontinfo> font, int glyph, double scale_x, double scale_y, Pointer<Int> ix0, Pointer<Int> iy0, Pointer<Int> ix1, Pointer<Int> iy1) → void
stbtt_GetGlyphBitmapBoxSubpixel(Pointer<stbtt_fontinfo> font, int glyph, double scale_x, double scale_y, double shift_x, double shift_y, Pointer<Int> ix0, Pointer<Int> iy0, Pointer<Int> ix1, Pointer<Int> iy1) → void
stbtt_GetGlyphBitmapSubpixel(Pointer<stbtt_fontinfo> info, double scale_x, double scale_y, double shift_x, double shift_y, int glyph, Pointer<Int> width, Pointer<Int> height, Pointer<Int> xoff, Pointer<Int> yoff) → Pointer<ma_uint8>
stbtt_GetGlyphBox(Pointer<stbtt_fontinfo> info, int glyph_index, Pointer<Int> x0, Pointer<Int> y0, Pointer<Int> x1, Pointer<Int> y1) → int
stbtt_GetGlyphHMetrics(Pointer<stbtt_fontinfo> info, int glyph_index, Pointer<Int> advanceWidth, Pointer<Int> leftSideBearing) → void: Gets the bounding box of the visible part of the glyph, in unscaled coordinates
stbtt_GetGlyphKernAdvance(Pointer<stbtt_fontinfo> info, int glyph1, int glyph2) → int
stbtt_GetGlyphSDF(Pointer<stbtt_fontinfo> info, double scale, int glyph, int padding, int onedge_value, double pixel_dist_scale, Pointer<Int> width, Pointer<Int> height, Pointer<Int> xoff, Pointer<Int> yoff) → Pointer<ma_uint8>: frees the SDF bitmap allocated below
stbtt_GetGlyphShape(Pointer<stbtt_fontinfo> info, int glyph_index, Pointer<Pointer<stbtt_vertex>> vertices) → int
stbtt_GetGlyphSVG(Pointer<stbtt_fontinfo> info, int gl, Pointer<Pointer<Char>> svg) → int
stbtt_GetKerningTable(Pointer<stbtt_fontinfo> info, Pointer<stbtt_kerningentry> table, int table_length) → int
stbtt_GetKerningTableLength(Pointer<stbtt_fontinfo> info) → int
stbtt_GetNumberOfFonts(Pointer<ma_uint8> data) → int: ///////////////////////////////////////////////////////////////////////////
stbtt_GetPackedQuad(Pointer<stbtt_packedchar> chardata, int pw, int ph, int char_index, Pointer<Float> xpos, Pointer<Float> ypos, Pointer<stbtt_aligned_quad> q, int align_to_integer) → void: If skip != 0, this tells stb_truetype to skip any codepoints for which there is no corresponding glyph. If skip=0, which is the default, then codepoints without a glyph recived the font's "missing character" glyph, typically an empty box by convention.
stbtt_GetScaledFontVMetrics(Pointer<ma_uint8> fontdata, int index, double size, Pointer<Float> ascent, Pointer<Float> descent, Pointer<Float> lineGap) → void: Call GetBakedQuad with char_index = 'character - first_char', and it creates the quad you need to draw and advances the current position.
stbtt_InitFont(Pointer<stbtt_fontinfo> info, Pointer<ma_uint8> data, int offset) → int
stbtt_IsGlyphEmpty(Pointer<stbtt_fontinfo> info, int glyph_index) → int
stbtt_MakeCodepointBitmap(Pointer<stbtt_fontinfo> info, Pointer<ma_uint8> output, int out_w, int out_h, int out_stride, double scale_x, double scale_y, int codepoint) → void: the same as stbtt_GetCodepoitnBitmap, but you can specify a subpixel shift for the character
stbtt_MakeCodepointBitmapSubpixel(Pointer<stbtt_fontinfo> info, Pointer<ma_uint8> output, int out_w, int out_h, int out_stride, double scale_x, double scale_y, double shift_x, double shift_y, int codepoint) → void: the same as stbtt_GetCodepointBitmap, but you pass in storage for the bitmap in the form of 'output', with row spacing of 'out_stride' bytes. the bitmap is clipped to out_w/out_h bytes. Call stbtt_GetCodepointBitmapBox to get the width and height and positioning info for it first.
stbtt_MakeCodepointBitmapSubpixelPrefilter(Pointer<stbtt_fontinfo> info, Pointer<ma_uint8> output, int out_w, int out_h, int out_stride, double scale_x, double scale_y, double shift_x, double shift_y, int oversample_x, int oversample_y, Pointer<Float> sub_x, Pointer<Float> sub_y, int codepoint) → void: same as stbtt_MakeCodepointBitmap, but you can specify a subpixel shift for the character
stbtt_MakeGlyphBitmap(Pointer<stbtt_fontinfo> info, Pointer<ma_uint8> output, int out_w, int out_h, int out_stride, double scale_x, double scale_y, int glyph) → void
stbtt_MakeGlyphBitmapSubpixel(Pointer<stbtt_fontinfo> info, Pointer<ma_uint8> output, int out_w, int out_h, int out_stride, double scale_x, double scale_y, double shift_x, double shift_y, int glyph) → void
stbtt_MakeGlyphBitmapSubpixelPrefilter(Pointer<stbtt_fontinfo> info, Pointer<ma_uint8> output, int out_w, int out_h, int out_stride, double scale_x, double scale_y, double shift_x, double shift_y, int oversample_x, int oversample_y, Pointer<Float> sub_x, Pointer<Float> sub_y, int glyph) → void
stbtt_PackBegin(Pointer<stbtt_pack_context> spc, Pointer<ma_uint8> pixels, int width, int height, int stride_in_bytes, int padding, Pointer<Void> alloc_context) → int
stbtt_PackEnd(Pointer<stbtt_pack_context> spc) → void: Initializes a packing context stored in the passed-in stbtt_pack_context. Future calls using this context will pack characters into the bitmap passed in here: a 1-channel bitmap that is width * height. stride_in_bytes is the distance from one row to the next (or 0 to mean they are packed tightly together). "padding" is the amount of padding to leave between each character (normally you want '1' for bitmaps you'll use as textures with bilinear filtering).
stbtt_PackFontRange(Pointer<stbtt_pack_context> spc, Pointer<ma_uint8> fontdata, int font_index, double font_size, int first_unicode_char_in_range, int num_chars_in_range, Pointer<stbtt_packedchar> chardata_for_range) → int
stbtt_PackFontRanges(Pointer<stbtt_pack_context> spc, Pointer<ma_uint8> fontdata, int font_index, Pointer<stbtt_pack_range> ranges, int num_ranges) → int
stbtt_PackFontRangesGatherRects(Pointer<stbtt_pack_context> spc, Pointer<stbtt_fontinfo> info, Pointer<stbtt_pack_range> ranges, int num_ranges, Pointer<stbrp_rect> rects) → int
stbtt_PackFontRangesPackRects(Pointer<stbtt_pack_context> spc, Pointer<stbrp_rect> rects, int num_rects) → void
stbtt_PackFontRangesRenderIntoRects(Pointer<stbtt_pack_context> spc, Pointer<stbtt_fontinfo> info, Pointer<stbtt_pack_range> ranges, int num_ranges, Pointer<stbrp_rect> rects) → int
stbtt_PackSetOversampling(Pointer<stbtt_pack_context> spc, int h_oversample, int v_oversample) → void: Creates character bitmaps from multiple ranges of characters stored in ranges. This will usually create a better-packed bitmap than multiple calls to stbtt_PackFontRange. Note that you can call this multiple times within a single PackBegin/PackEnd.
stbtt_PackSetSkipMissingCodepoints(Pointer<stbtt_pack_context> spc, int skip) → void: Oversampling a font increases the quality by allowing higher-quality subpixel positioning, and is especially valuable at smaller text sizes.
stbtt_Rasterize(Pointer<stbtt__bitmap> result, double flatness_in_pixels, Pointer<stbtt_vertex> vertices, int num_verts, double scale_x, double scale_y, double shift_x, double shift_y, int x_off, int y_off, int invert, Pointer<Void> userdata) → void: rasterize a shape with quadratic beziers into a bitmap
stbtt_ScaleForMappingEmToPixels(Pointer<stbtt_fontinfo> info, double pixels) → double: computes a scale factor to produce a font whose "height" is 'pixels' tall. Height is measured as the distance from the highest ascender to the lowest descender; in other words, it's equivalent to calling stbtt_GetFontVMetrics and computing: scale = pixels / (ascent - descent) so if you prefer to measure height by the ascent only, use a similar calculation.
stbtt_ScaleForPixelHeight(Pointer<stbtt_fontinfo> info, double pixels) → double: ///////////////////////////////////////////////////////////////////////////
stbvox_get_bounds(Pointer<stbvox_mesh_maker> mm, Pointer<Pointer<Float>> bounds) → void: Sets the global coordinates for this chunk, such that (0,0,0) relative coordinates will be at (x,y,z) in global coordinates.
stbvox_get_buffer_count(Pointer<stbvox_mesh_maker> mm) → int: Call this to set the buffer into which stbvox will write the mesh it creates. It can build more than one mesh in parallel (distinguished by the 'mesh' parameter), and each mesh can be made up of more than one buffer (distinguished by the 'slot' parameter).
stbvox_get_buffer_size_per_quad(Pointer<stbvox_mesh_maker> mm, int slot) → int: Returns the number of buffers needed per mesh as described above.
stbvox_get_fragment_shader() → Pointer<Char>: Returns the (currently GLSL-only) vertex shader.
stbvox_get_fragment_shader_alpha_only() → Pointer<Char>: Returns the (currently GLSL-only) fragment shader. You can override the lighting and fogging calculations by appending data to the end of these; see the #define documentation for more information.
stbvox_get_input_description(Pointer<stbvox_mesh_maker> mm) → Pointer<stbvox_input_description>: Selects which mesh the mesher will output to (see previous function) if the input doesn't specify a per-voxel selector. (I doubt this is useful, but it's here just in case.)
stbvox_get_quad_count(Pointer<stbvox_mesh_maker> mm, int mesh) → int: Once you're done creating a mesh into a given buffer, consider the following functions:
stbvox_get_transform(Pointer<stbvox_mesh_maker> mm, Pointer<Pointer<Float>> transform) → void: Returns the bounds for the mesh in global coordinates. Use this for e.g. frustum culling the mesh. @BUG: this just uses the values from stbvox_set_input_range(), so if you build by appending multiple values, this will be wrong, and you need to set stbvox_set_input_range() to the full size. Someday this will switch to tracking the actual bounds of the mesh, though.
stbvox_get_uniform_info(Pointer<stbvox_uniform_info> info, int uniform) → int
stbvox_get_vertex_shader() → Pointer<Char>: ///////////////////////////////////////////////////////////////////////////
stbvox_init_mesh_maker(Pointer<stbvox_mesh_maker> mm) → void: ///////////////////////////////////////////////////////////////////////////
stbvox_make_mesh(Pointer<stbvox_mesh_maker> mm) → int: This sets the range of values in the 3D array for the voxels that the mesh generator will convert. The lower values are inclusive, the higher values are exclusive, so (0,0,0) to (16,16,16) generates mesh data associated with voxels up to (15,15,15) but no higher.
stbvox_reset_buffers(Pointer<stbvox_mesh_maker> mm) → void: Returns the 'transform' data for the shader uniforms. It is your job to set this to the shader before drawing the mesh. It is the only uniform that needs to change per-mesh. Note that it is not a 3x3 matrix, but rather a scale to decode fixed point numbers as floats, a translate from relative to global space, and a special translation for texture coordinate generation that avoids floating-point precision issues. @TODO: currently we add the global translation to the vertex, than multiply by modelview, but this means if camera location and vertex are far from the origin, we lose precision. Need to make a special modelview with the translation (or some of it) factored out to avoid this.
stbvox_set_buffer(Pointer<stbvox_mesh_maker> mm, int mesh, int slot, Pointer<Void> buffer, int len) → void: Call this function to initialize a mesh-maker context structure used to build meshes. You should have one context per thread that's building meshes.
stbvox_set_default_mesh(Pointer<stbvox_mesh_maker> mm, int mesh) → void: Returns how much of a given buffer will get used per quad. This allows you to choose correct relative sizes for each buffer, although the values are fixed based on the configuration you've selected at compile time, and the details are described in stbvox_set_buffer.
stbvox_set_input_range(Pointer<stbvox_mesh_maker> mm, int x0, int y0, int z0, int x1, int y1, int z1) → void: This sets the stride between successive elements of the 3D arrays in the stbvox_input_description. Z values are always stored consecutively. (The preferred coordinate system for stbvox is X right, Y forwards, Z up.)
stbvox_set_input_stride(Pointer<stbvox_mesh_maker> mm, int x_stride_in_elements, int y_stride_in_elements) → void: This function call returns a pointer to the stbvox_input_description part of stbvox_mesh_maker (which you should otherwise treat as opaque). You zero this structure, then fill out the relevant pointers to the data describing your voxel object/world.
stbvox_set_mesh_coordinates(Pointer<stbvox_mesh_maker> mm, int x, int y, int z) → void: Returns the number of quads in the mesh currently generated by mm. This is the sum of all consecutive stbvox_make_mesh runs appending to the same buffer. 'mesh' distinguishes between the multiple user meshes available via 'selector' or stbvox_set_default_mesh.
tdefl_compress(Pointer<tdefl_compressor> d, Pointer<Void> pIn_buf, Pointer<Size> pIn_buf_size, Pointer<Void> pOut_buf, Pointer<Size> pOut_buf_size, tdefl_flush flush) → tdefl_status
tdefl_compress_buffer(Pointer<tdefl_compressor> d, Pointer<Void> pIn_buf, int in_buf_size, tdefl_flush flush) → tdefl_status
tdefl_compress_mem_to_heap(Pointer<Void> pSrc_buf, int src_buf_len, Pointer<Size> pOut_len, int flags$1) → Pointer<Void>: High level compression functions: / / tdefl_compress_mem_to_heap() compresses a block in memory to a heap block allocated via malloc(). / / On entry: / / pSrc_buf, src_buf_len: Pointer and size of source block to compress. / / flags: The max match finder probes (default is 128) logically OR'd against the above flags. Higher probes are slower but improve compression. / / On return: / / Function returns a pointer to the compressed data, or NULL on failure. / / *pOut_len will be set to the compressed data's size, which could be larger than src_buf_len on uncompressible data. / / The caller must free() the returned block when it's no longer needed.
tdefl_compress_mem_to_mem(Pointer<Void> pOut_buf, int out_buf_len, Pointer<Void> pSrc_buf, int src_buf_len, int flags$1) → int: tdefl_compress_mem_to_mem() compresses a block in memory to another block in memory. / / Returns 0 on failure.
tdefl_compress_mem_to_output(Pointer<Void> pBuf, int buf_len, tdefl_put_buf_func_ptr pPut_buf_func, Pointer<Void> pPut_buf_user, int flags$1) → int: tdefl_compress_mem_to_output() compresses a block to an output stream. The above helpers use this function internally.
tdefl_compressor_alloc() → Pointer<tdefl_compressor>: Allocate the tdefl_compressor structure in C so that / / non-C language bindings to tdefl_ API don't need to worry about / / structure size and allocation mechanism.
tdefl_compressor_free(Pointer<tdefl_compressor> pComp) → void
tdefl_create_comp_flags_from_zip_params(int level, int window_bits, int strategy) → int: Create tdefl_compress() flags given zlib-style compression parameters. / / level may range from 0,10 (where 10 is absolute max compression, but may be much slower on some files) / / window_bits may be -15 (raw deflate) or 15 (zlib) / / strategy may be either MZ_DEFAULT_STRATEGY, MZ_FILTERED, MZ_HUFFMAN_ONLY, MZ_RLE, or MZ_FIXED
tdefl_get_adler32(Pointer<tdefl_compressor> d) → int
tdefl_get_prev_return_status(Pointer<tdefl_compressor> d) → tdefl_status
tdefl_init(Pointer<tdefl_compressor> d, tdefl_put_buf_func_ptr pPut_buf_func, Pointer<Void> pPut_buf_user, int flags$1) → tdefl_status
tdefl_write_image_to_png_file_in_memory(Pointer<Void> pImage, int w, int h, int num_chans, Pointer<Size> pLen_out) → Pointer<Void>
tdefl_write_image_to_png_file_in_memory_ex(Pointer<Void> pImage, int w, int h, int num_chans, Pointer<Size> pLen_out, int level, int flip) → Pointer<Void>: Compresses an image to a compressed PNG file in memory. / / On entry: / / pImage, w, h, and num_chans describe the image to compress. num_chans may be 1, 2, 3, or 4. / / The image pitch in bytes per scanline will be w*num_chans. The leftmost pixel on the top scanline is stored first in memory. / / level may range from 0,10, use MZ_NO_COMPRESSION, MZ_BEST_SPEED, MZ_BEST_COMPRESSION, etc. or a decent default is MZ_DEFAULT_LEVEL / / If flip is true, the image will be flipped on the Y axis (useful for OpenGL apps). / / On return: / / Function returns a pointer to the compressed data, or NULL on failure. / / *pLen_out will be set to the size of the PNG image file. / / The caller must mz_free() the returned heap block (which will typically be larger than *pLen_out) when it's no longer needed.
tinfl_decompress(Pointer<tinfl_decompressor> r, Pointer<ma_uint8> pIn_buf_next, Pointer<Size> pIn_buf_size, Pointer<ma_uint8> pOut_buf_start, Pointer<ma_uint8> pOut_buf_next, Pointer<Size> pOut_buf_size, Dartmz_uint32 decomp_flags) → tinfl_status
tinfl_decompress_mem_to_callback(Pointer<Void> pIn_buf, Pointer<Size> pIn_buf_size, tinfl_put_buf_func_ptr pPut_buf_func, Pointer<Void> pPut_buf_user, int flags$1) → int
tinfl_decompress_mem_to_heap(Pointer<Void> pSrc_buf, int src_buf_len, Pointer<Size> pOut_len, int flags$1) → Pointer<Void>: High level decompression functions: / / tinfl_decompress_mem_to_heap() decompresses a block in memory to a heap block allocated via malloc(). / / On entry: / / pSrc_buf, src_buf_len: Pointer and size of the Deflate or zlib source data to decompress. / / On return: / / Function returns a pointer to the decompressed data, or NULL on failure. / / *pOut_len will be set to the decompressed data's size, which could be larger than src_buf_len on uncompressible data. / / The caller must call mz_free() on the returned block when it's no longer needed.
tinfl_decompress_mem_to_mem(Pointer<Void> pOut_buf, int out_buf_len, Pointer<Void> pSrc_buf, int src_buf_len, int flags$1) → int
tinfl_decompressor_alloc() → Pointer<tinfl_decompressor>: Allocate the tinfl_decompressor structure in C so that / / non-C language bindings to tinfl_ API don't need to worry about / / structure size and allocation mechanism.
tinfl_decompressor_free(Pointer<tinfl_decompressor> pDecomp) → void

Typedefs

alloc_func = Pointer<NativeFunction<alloc_funcFunction>>: See mz_alloc_func
alloc_funcFunction = Pointer<Void> Function(Pointer<Void> opaque, Size items, Size size)
Byte = UnsignedChar
Bytef = Byte
charf = Char
cJSON_bool = Int
Dart__off64_t = int
Dart__off_t = int
Dart__time_t = int
Dart_IO_lock_t = void
Dartalloc_funcFunction = Pointer<Void> Function(Pointer<Void> opaque, int items, int size)
DartByte = int
Dartcharf = int
DartcJSON_bool = int
Dartfree_funcFunction = void Function(Pointer<Void> opaque, Pointer<Void> address)
Darthttp_cbFunction = int Function(Pointer<http_parser> parser)
Darthttp_data_cbFunction = int Function(Pointer<http_parser>, Pointer<Char>, int)
Dartintf = int
Dartma_async_notification = void
Dartma_data_source = void
Dartma_decoder_read_procFunction = ma_result Function(Pointer<ma_decoder> pDecoder, Pointer<Void> pBufferOut, int bytesToRead, Pointer<Size> pBytesRead)
Dartma_decoder_seek_procFunction = ma_result Function(Pointer<ma_decoder> pDecoder, Dartma_int64 byteOffset, ma_seek_origin origin)
Dartma_decoder_tell_procFunction = ma_result Function(Pointer<ma_decoder> pDecoder, Pointer<ma_int64> pCursor)
Dartma_device_data_procFunction = void Function(Pointer<ma_device> pDevice, Pointer<Void> pOutput, Pointer<Void> pInput, Dartma_uint32 frameCount)
Dartma_device_notification_procFunction = void Function(Pointer<ma_device_notification> pNotification)
Dartma_double = double
Dartma_encoder_init_procFunction = ma_result Function(Pointer<ma_encoder> pEncoder)
Dartma_encoder_seek_procFunction = ma_result Function(Pointer<ma_encoder> pEncoder, Dartma_int64 offset, ma_seek_origin origin)
Dartma_encoder_uninit_procFunction = void Function(Pointer<ma_encoder> pEncoder)
Dartma_encoder_write_pcm_frames_procFunction = ma_result Function(Pointer<ma_encoder> pEncoder, Pointer<Void> pFramesIn, Dartma_uint64 frameCount, Pointer<ma_uint64> pFramesWritten)
Dartma_encoder_write_procFunction = ma_result Function(Pointer<ma_encoder> pEncoder, Pointer<Void> pBufferIn, int bytesToWrite, Pointer<Size> pBytesWritten)
Dartma_engine_process_procFunction = void Function(Pointer<Void> pUserData, Pointer<Float> pFramesOut, Dartma_uint64 frameCount)
Dartma_enum_devices_callback_procFunction = Dartma_uint32 Function(Pointer<ma_context> pContext, ma_device_type deviceType, Pointer<ma_device_info> pInfo, Pointer<Void> pUserData)
Dartma_float = double
Dartma_int16 = int
Dartma_int32 = int
Dartma_int64 = int
Dartma_int8 = int
Dartma_job_procFunction = ma_result Function(Pointer<ma_job> pJob)
Dartma_log_callback_procFunction = void Function(Pointer<Void> pUserData, Dartma_uint32 level, Pointer<Char> pMessage)
Dartma_node = void
Dartma_procFunction = void Function()
Dartma_read_procFunction = ma_result Function(Pointer<Void> pUserData, Pointer<Void> pBufferOut, int bytesToRead, Pointer<Size> pBytesRead)
Dartma_resampling_backend = void
Dartma_seek_procFunction = ma_result Function(Pointer<Void> pUserData, Dartma_int64 offset, ma_seek_origin origin)
Dartma_sound_end_procFunction = void Function(Pointer<Void> pUserData, Pointer<ma_sound_group> pSound)
Dartma_stop_procFunction = void Function(Pointer<ma_device> pDevice)
Dartma_tell_procFunction = ma_result Function(Pointer<Void> pUserData, Pointer<ma_int64> pCursor)
Dartma_uint16 = int
Dartma_uint32 = int
Dartma_uint64 = int
Dartma_uint8 = int
Dartma_vfs = void
Dartmz_alloc_funcFunction = Pointer<Void> Function(Pointer<Void> opaque, int items, int size)
Dartmz_bool = int
Dartmz_file_needs_keepaliveFunction = int Function(Pointer<Void> pDataSource)
Dartmz_file_read_funcFunction = int Function(Pointer<Void> pOpaque, Dartmz_uint64 file_ofs, Pointer<Void> pBuf, int n)
Dartmz_file_write_funcFunction = int Function(Pointer<Void> pOpaque, Dartmz_uint64 file_ofs, Pointer<Void> pBuf, int n)
Dartmz_free_funcFunction = void Function(Pointer<Void> opaque, Pointer<Void> address)
Dartmz_int16 = int
Dartmz_int64 = int
Dartmz_realloc_funcFunction = Pointer<Void> Function(Pointer<Void> opaque, Pointer<Void> address, int items, int size)
Dartmz_uint = int
Dartmz_uint16 = int
Dartmz_uint32 = int
Dartmz_uint64 = int
Dartmz_uint8 = int
Dartmz_ulong = int
Dartpthread_t = int
Dartptrdiff_t = int
Dartstbi_uc = int
Dartstbi_us = int
Dartstbir_uint16 = int
Dartstbir_uint32 = int
Dartstbir_uint64 = int
Dartstbir_uint8 = int
Dartstbrp_coord = int
Dartstbvox_block_type = int
Darttdefl_put_buf_func_ptrFunction = Dartmz_bool Function(Pointer<Void> pBuf, int len, Pointer<Void> pUser)
Darttinfl_put_buf_func_ptrFunction = Dartmz_bool Function(Pointer<Void> pBuf, int len, Pointer<Void> pUser)
DartuInt = int
FILE = _IO_FILE
free_func = Pointer<NativeFunction<free_funcFunction>>: See mz_free_func
free_funcFunction = Void Function(Pointer<Void> opaque, Pointer<Void> address)
http_cb = Pointer<NativeFunction<http_cbFunction>>
http_cbFunction = Int Function(Pointer<http_parser>)
http_data_cb = Pointer<NativeFunction<http_data_cbFunction>>: Callbacks should return non-zero to indicate an error. The parser will then halt execution.
http_data_cbFunction = Int Function(Pointer<http_parser>, Pointer<Char>, Size)
intf = Int
ma_async_notification = Void: Notification callback for asynchronous operations.
ma_bool32 = ma_uint32
ma_bool8 = ma_uint8
ma_channel = ma_uint8
ma_data_source = Void: Data Source
ma_data_source_get_next_proc = Pointer<NativeFunction<ma_data_source_get_next_procFunction>>
ma_data_source_get_next_procFunction = Pointer<Void> Function(Pointer<Void> pDataSource)
ma_decoder_read_proc = Pointer<NativeFunction<ma_decoder_read_procFunction>>
ma_decoder_read_procFunction = Int Function(Pointer<ma_decoder> pDecoder, Pointer<Void> pBufferOut, Size bytesToRead, Pointer<Size> pBytesRead)
ma_decoder_seek_proc = Pointer<NativeFunction<ma_decoder_seek_procFunction>>
ma_decoder_seek_procFunction = Int Function(Pointer<ma_decoder> pDecoder, ma_int64 byteOffset, UnsignedInt origin)
ma_decoder_tell_proc = Pointer<NativeFunction<ma_decoder_tell_procFunction>>
ma_decoder_tell_procFunction = Int Function(Pointer<ma_decoder> pDecoder, Pointer<ma_int64> pCursor)
ma_device_data_proc = Pointer<NativeFunction<ma_device_data_procFunction>>: The callback for processing audio data from the device.
ma_device_data_procFunction = Void Function(Pointer<ma_device> pDevice, Pointer<Void> pOutput, Pointer<Void> pInput, ma_uint32 frameCount)
ma_device_notification_proc = Pointer<NativeFunction<ma_device_notification_procFunction>>: The notification callback for when the application should be notified of a change to the device.
ma_device_notification_procFunction = Void Function(Pointer<ma_device_notification> pNotification)
ma_double = Double
ma_encoder_init_proc = Pointer<NativeFunction<ma_encoder_init_procFunction>>
ma_encoder_init_procFunction = Int Function(Pointer<ma_encoder> pEncoder)
ma_encoder_seek_proc = Pointer<NativeFunction<ma_encoder_seek_procFunction>>
ma_encoder_seek_procFunction = Int Function(Pointer<ma_encoder> pEncoder, ma_int64 offset, UnsignedInt origin)
ma_encoder_uninit_proc = Pointer<NativeFunction<ma_encoder_uninit_procFunction>>
ma_encoder_uninit_procFunction = Void Function(Pointer<ma_encoder> pEncoder)
ma_encoder_write_pcm_frames_proc = Pointer<NativeFunction<ma_encoder_write_pcm_frames_procFunction>>
ma_encoder_write_pcm_frames_procFunction = Int Function(Pointer<ma_encoder> pEncoder, Pointer<Void> pFramesIn, ma_uint64 frameCount, Pointer<ma_uint64> pFramesWritten)
ma_encoder_write_proc = Pointer<NativeFunction<ma_encoder_write_procFunction>>
ma_encoder_write_procFunction = Int Function(Pointer<ma_encoder> pEncoder, Pointer<Void> pBufferIn, Size bytesToWrite, Pointer<Size> pBytesWritten)
ma_engine_process_proc = Pointer<NativeFunction<ma_engine_process_procFunction>>
ma_engine_process_procFunction = Void Function(Pointer<Void> pUserData, Pointer<Float> pFramesOut, ma_uint64 frameCount)
ma_enum_devices_callback_proc = Pointer<NativeFunction<ma_enum_devices_callback_procFunction>>: The callback for handling device enumeration. This is fired from ma_context_enumerate_devices().
ma_enum_devices_callback_procFunction = ma_bool32 Function(Pointer<ma_context> pContext, UnsignedInt deviceType, Pointer<ma_device_info> pInfo, Pointer<Void> pUserData)
ma_float = Float: These float types are not used universally by miniaudio. It's to simplify some macro expansion for atomic types.
ma_handle = Pointer<Void>
ma_hishelf_config = ma_hishelf2_config
ma_hpf2_config = ma_hpf1_config
ma_int16 = Short
ma_int32 = Int
ma_int64 = LongLong
ma_int8 = SignedChar
ma_job_proc = Pointer<NativeFunction<ma_job_procFunction>>: Callback for processing a job. Each job type will have their own processing callback which will be called by ma_job_process().
ma_job_procFunction = Int Function(Pointer<ma_job> pJob)
ma_log_callback_proc = Pointer<NativeFunction<ma_log_callback_procFunction>>: The callback for handling log messages.
ma_log_callback_procFunction = Void Function(Pointer<Void> pUserData, ma_uint32 level, Pointer<Char> pMessage)
ma_loshelf_config = ma_loshelf2_config
ma_lpf2_config = ma_lpf1_config
ma_mutex = ma_pthread_mutex_t
ma_node = Void
ma_notch_config = ma_notch2_config
ma_peak_config = ma_peak2_config
ma_proc = Pointer<NativeFunction<ma_procFunction>>
ma_procFunction = Void Function()
ma_pthread_cond_t = pthread_cond_t
ma_pthread_mutex_t = pthread_mutex_t
ma_pthread_t = pthread_t
ma_ptr = Pointer<Void>
ma_read_proc = Pointer<NativeFunction<ma_read_procFunction>>
ma_read_procFunction = Int Function(Pointer<Void> pUserData, Pointer<Void> pBufferOut, Size bytesToRead, Pointer<Size> pBytesRead)
ma_resampling_backend = Void
ma_seek_proc = Pointer<NativeFunction<ma_seek_procFunction>>
ma_seek_procFunction = Int Function(Pointer<Void> pUserData, ma_int64 offset, UnsignedInt origin)
ma_sound_end_proc = Pointer<NativeFunction<ma_sound_end_procFunction>>: Callback for when a sound reaches the end.
ma_sound_end_procFunction = Void Function(Pointer<Void> pUserData, Pointer<ma_sound_group> pSound)
ma_sound_group = ma_sound
ma_sound_group_config = ma_sound_config: A sound group is just a sound.
ma_spinlock = ma_uint32: Spinlocks are 32-bit for compatibility reasons.
ma_stop_proc = Pointer<NativeFunction<ma_stop_procFunction>>: DEPRECATED. Use ma_device_notification_proc instead.
ma_stop_procFunction = Void Function(Pointer<ma_device> pDevice)
ma_tell_proc = Pointer<NativeFunction<ma_tell_procFunction>>
ma_tell_procFunction = Int Function(Pointer<Void> pUserData, Pointer<ma_int64> pCursor)
ma_thread = ma_pthread_t
ma_uint16 = UnsignedShort
ma_uint32 = UnsignedInt
ma_uint64 = UnsignedLongLong
ma_uint8 = UnsignedChar
ma_uintptr = ma_uint64
ma_vfs = Void: VFS
ma_vfs_file = ma_handle
ma_wchar_win32 = ma_uint16
mz_alloc_func = Pointer<NativeFunction<alloc_funcFunction>>: Heap allocation callbacks. Note that mz_alloc_func parameter types purposely differ from zlib's: items/size is size_t, not unsigned long.
mz_alloc_funcFunction = Pointer<Void> Function(Pointer<Void> opaque, Size items, Size size)
mz_bool = Int
mz_file_needs_keepalive = Pointer<NativeFunction<mz_file_needs_keepaliveFunction>>
mz_file_needs_keepaliveFunction = mz_bool Function(Pointer<Void> pOpaque)
mz_file_read_func = Pointer<NativeFunction<mz_file_read_funcFunction>>
mz_file_read_funcFunction = Size Function(Pointer<Void> pOpaque, mz_uint64 file_ofs, Pointer<Void> pBuf, Size n)
mz_file_write_func = Pointer<NativeFunction<mz_file_read_funcFunction>>
mz_file_write_funcFunction = Size Function(Pointer<Void> pOpaque, mz_uint64 file_ofs, Pointer<Void> pBuf, Size n)
mz_free_func = Pointer<NativeFunction<free_funcFunction>>
mz_free_funcFunction = Void Function(Pointer<Void> opaque, Pointer<Void> address)
mz_int16 = Int16
mz_int64 = Int64
mz_realloc_func = Pointer<NativeFunction<mz_realloc_funcFunction>>
mz_realloc_funcFunction = Pointer<Void> Function(Pointer<Void> opaque, Pointer<Void> address, Size items, Size size)
mz_stream = mz_stream_s
mz_streamp = Pointer<mz_stream>
mz_uint = Uint32
mz_uint16 = Uint16
mz_uint32 = Uint32
mz_uint64 = Uint64
mz_uint8 = UnsignedChar: ------------------- Types and macros
mz_ulong = UnsignedLong: For more compatibility with zlib, miniz.c uses unsigned long for some parameters/struct members. Beware: mz_ulong can be either 32 or 64-bits!
mz_zip_internal_state = mz_zip_internal_state_tag
pthread_t = UnsignedLong
ptrdiff_t = Long
stbcc_grid = st_stbcc_grid
stbi_uc = UnsignedChar
stbi_us = UnsignedShort
stbi_write_func = NativeFunction<Void Function(Pointer<Void> context, Pointer<Void> data, Int size)>
stbir__kernel_callback = NativeFunction<Float Function(Float x, Float scale, Pointer<Void> user_data)>: callbacks for user installed filters
stbir__support_callback = NativeFunction<Float Function(Float scale, Pointer<Void> user_data)>
stbir_input_callback = NativeFunction<Pointer<Void> Function(Pointer<Void> optional_output, Pointer<Void> input_ptr, Int num_pixels, Int x, Int y, Pointer<Void> context)>: INPUT CALLBACK: this callback is used for input scanlines
stbir_output_callback = NativeFunction<Void Function(Pointer<Void> output_ptr, Int num_pixels, Int y, Pointer<Void> context)>: OUTPUT CALLBACK: this callback is used for output scanlines
stbir_uint16 = Uint16
stbir_uint32 = Uint32
stbir_uint64 = Uint64
stbir_uint8 = Uint8
stbrp_coord = Int
STBSP_SPRINTFCB = NativeFunction<Pointer<Char> Function(Pointer<Char> buf, Pointer<Void> user, Int len)>
stbvox_block_type = UnsignedChar
tdefl_put_buf_func_ptr = Pointer<NativeFunction<tdefl_put_buf_func_ptrFunction>>: Output stream interface. The compressor uses this interface to write compressed data. It'll typically be called TDEFL_OUT_BUF_SIZE at a time.
tdefl_put_buf_func_ptrFunction = mz_bool Function(Pointer<Void> pBuf, Int len, Pointer<Void> pUser)
time_t = __time_t
tinfl_bit_buf_t = mz_uint64
tinfl_decompressor = tinfl_decompressor_tag
tinfl_put_buf_func_ptr = Pointer<NativeFunction<tdefl_put_buf_func_ptrFunction>>: tinfl_decompress_mem_to_callback() decompresses a block in memory to an internal 32KB buffer, and a user provided callback function will be called to flush the buffer. / / Returns 1 on success or 0 on failure.
tinfl_put_buf_func_ptrFunction = mz_bool Function(Pointer<Void> pBuf, Int len, Pointer<Void> pUser)
uInt = UnsignedInt
uIntf = uInt
uLong = mz_ulong
uLongf = uLong
voidp = Pointer<Void>
voidpc = Pointer<Void>
voidpf = Pointer<Void>

c_kit_bindings_generated library

Classes

Enums

Constants

Properties

Functions

Typedefs

c_kit package

c_kit_bindings_generated library