Sound_Player

(accumulator: *Audio_Dest_Sample, num_samples: s64, source_cursor: float64, page: *void, page_start: s64, page_end: s64, stream: *Sound_Stream, no_overflow: bool) -> (cursor: float64, samples_written: s64)

accumulate_stream

(stream: *Sound_Stream, accumulator: [] Audio_Dest_Sample, num_samples: s64) -> bool

Panning#

invert

(m: *Matrix2, result: *Matrix2)

perceptual_to_linear

(x: float) -> float

clear_scale_accumulation

(stream: *Sound_Stream, index: s64)

update_listener

(camera_position: Vector3, camera_orientation: Quaternion)

Tells the player where the listener is, so sounds with a position can be panned and softened by distance.

get_plane_dir

(stream: *Sound_Stream, position: Vector3) -> Vector2

get_target_2_closeness

(stream: *Sound_Stream) -> float

adjust_stereo_dots_by_closeness

(dot_left: *float, dot_right: *float, closeness: float)

accum_scale_target_2_source_mono

(stream: *Sound_Stream, plane_dir: Vector2, gain_scale: float, target: *Scale_Mapping)

accum_scale_target_2_source_n

(stream: *Sound_Stream, plane_dir: Vector2, n: s64, gain_scale: float)

add_vbap_gain_for_direction

(target: *Scale_Mapping, plane_dir: Vector2, gain_scale: float)

skip_this_output_channel

(index: Audio_Channel, stream: *Sound_Stream) -> bool

accum_scale_target_all_source_mono

(stream: *Sound_Stream, plane_dir: Vector2, gain_scale: float, target: *Scale_Mapping)

accum_scale_target_all_source_n

(stream: *Sound_Stream, plane_dir: Vector2, n: s64, gain_scale: float)

source_dir_to_target_dir

(source_dir_index: Source_Direction) -> (Audio_Channel, success := true)

update_panning_helper_for_many_channel_music

(stream: *Sound_Stream, gain_scale: float)

update_panning_helper_for_locked_output

(stream: *Sound_Stream, gain_scale: float)

update_panning_helper

(stream: *Sound_Stream, gain_scale: float)

get_desired_volume_perceptual

(stream: *Sound_Stream, position: Vector3) -> float

set_master_volume

(value: float)

update_panning

(stream: *Sound_Stream)

Cache#

count_retired_decoders

() -> s64

get_base_address

(decoder: *Cached_Decoder, play_cursor: s64) -> s64

unmark_all_pages

(decoder: *Cached_Decoder)

mark_relevant_pages

(decoder: *Cached_Decoder, start: s64, end: s64)

free_unmarked_pages

(decoder: *Cached_Decoder)

find_page_by_base_address

(decoder: *Cached_Decoder, start_address: s64) -> *Cached_Decoder_Page

find_page_containing_cursor

(decoder: *Cached_Decoder, play_cursor: s64) -> (found: bool, start_address: s64, end_address: s64, data: *void)

deinit

(decoder: *Cached_Decoder)

ADPCM#

create_adpcm_decoder

(data: *Sound_Data) -> *Adpcm_Decoder

make_page_adpcm

(decoder: *Cached_Decoder) -> *Cached_Decoder_Page

recompute_page_adpcm

(decoder: *Cached_Decoder, page: *Cached_Decoder_Page)

Decode queue#

init_sound_player_decode_queue

()

process_one_page

(page: *Cached_Decoder_Page)

add_decode_queue_item

(page: *Cached_Decoder_Page)

get_next_completed_decode_queue_item

() -> *Cached_Decoder_Page

Vorbis#

get_compressed_rate_channels_and_size

(s: string) -> (num_samples: s64, num_channels: s64, sampling_rate: s64)

start_vorbis_file

(decoder: *Cached_Ogg_Decoder) -> bool

create_ogg_decoder

(data: *Sound_Data, _page_size_in_samples: s64) -> *Cached_Decoder

deinit_proc_ogg

(decoder: *Cached_Decoder)

make_page_ogg

(decoder: *Cached_Decoder) -> *Cached_Decoder_Page

recompute_page_ogg

(decoder: *Cached_Decoder, _page: *Cached_Decoder_Page)

Loading#

load_audio_file

(filename: string, optional := false) -> Sound_Data

Reads a sound file. The result has loaded set when it worked.

load_audio_data

(name_for_error_reporting: string, data: string) -> Sound_Data

Reads a sound from memory. The result has loaded set when it worked.

release_sound_datasince 0.31.0

(data: *Sound_Data)

Stops every stream that plays data, frees the bytes it was loaded from and clears it, so that nothing points into it any more.

samples: [64] s16;
data := Sound_Data.{ loaded = true, type = .LINEAR_SAMPLE_ARRAY, samples = samples.data, nsamples_times_nchannels = samples.count };
data.buffer = copy_string("stands in for the file bytes");

release_sound_data(*data);
assert(!data.loaded && data.buffer.count == 0);

Doesn't run in the browser (skipped on wasm).

replace_sound_datasince 0.31.0

(data: *Sound_Data, replacement: Sound_Data) -> bool

Swaps in a new sound for data without moving it: the streams playing the old one are stopped, its bytes are freed and replacement takes its place. Anything that holds the *Sound_Data keeps a valid pointer and gets the new sound from the next make_stream on. This is how to hot-reload a sound.

first := load_audio_data("first", copy_string("not audio"));
assert(!first.loaded); // too short to be a sound; its bytes are still ours
free(first.buffer.data);

samples: [64] s16;
data := Sound_Data.{ loaded = true, type = .LINEAR_SAMPLE_ARRAY, samples = samples.data, nsamples_times_nchannels = samples.count };
data.buffer = copy_string("old bytes");

louder: [64] s16;
louder[0] = 100;
replacement := Sound_Data.{ loaded = true, type = .LINEAR_SAMPLE_ARRAY, samples = louder.data, nsamples_times_nchannels = louder.count };
replacement.buffer = copy_string("new bytes");

assert(replace_sound_data(*data, replacement));
assert(data.samples == louder.data && data.buffer == "new bytes");
release_sound_data(*data);