1 /* Copyright (C) 2021-2023 Harry Godden (hgn) - All Rights Reserved */
9 #include "vg/vg_stdint.h"
10 #include "vg/vg_platform.h"
13 #include "vg/vg_console.h"
14 #include "vg/vg_store.h"
15 #include "vg/vg_profiler.h"
16 #include "vg/vg_audio_synth_bird.h"
20 #pragma GCC push_options
21 #pragma GCC optimize ("O3")
22 #pragma GCC diagnostic push
23 #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
27 #define STB_VORBIS_MAX_CHANNELS 2
28 #include "submodules/stb/stb_vorbis.c"
35 #pragma GCC pop_options
36 #pragma GCC diagnostic pop
40 #define AUDIO_FRAME_SIZE 512
41 #define AUDIO_MIX_FRAME_SIZE 256
43 #define AUDIO_CHANNELS 32
45 #define AUDIO_FILTERS 16
46 #define AUDIO_FLAG_LOOP 0x1
47 #define AUDIO_FLAG_NO_DOPPLER 0x2
48 #define AUDIO_FLAG_SPACIAL_3D 0x4
49 #define AUDIO_FLAG_AUTO_START 0x8
50 #define AUDIO_FLAG_FORMAT 0x1E00
54 k_audio_format_mono
= 0x000u
,
55 k_audio_format_stereo
= 0x200u
,
56 k_audio_format_vorbis
= 0x400u
,
57 k_audio_format_none0
= 0x600u
,
58 k_audio_format_none1
= 0x800u
,
59 k_audio_format_none2
= 0xA00u
,
60 k_audio_format_none3
= 0xC00u
,
61 k_audio_format_none4
= 0xE00u
,
63 k_audio_format_bird
= 0x1000u
,
64 k_audio_format_gen
= 0x1200u
,
65 k_audio_format_none6
= 0x1400u
,
66 k_audio_format_none7
= 0x1600u
,
67 k_audio_format_none8
= 0x1800u
,
68 k_audio_format_none9
= 0x1A00u
,
69 k_audio_format_none10
= 0x1C00u
,
70 k_audio_format_none11
= 0x1E00u
,
73 #define AUDIO_DECODE_SIZE (1024*256) /* 256 kb decoding buffers */
74 #define AUDIO_MUTE_VOLUME 0.0f
75 #define AUDIO_BASE_VOLUME 1.0f
77 typedef struct audio_clip audio_clip
;
78 typedef struct audio_channel audio_channel
;
79 typedef struct audio_lfo audio_lfo
;
82 union { /* TODO oof.. */
97 struct vg_audio_system
{
98 SDL_AudioDeviceID sdl_output_device
;
99 vg_str device_choice
; /* buffer is null? use default from OS */
108 SDL_SpinLock sl_checker
,
112 u32 time
, time_startframe
;
113 float sqrt_polynomial_coefficient
;
120 k_lfo_polynomial_bipolar
125 float polynomial_coefficient
;
128 u32 editble_state_write_mask
;
130 oscillators
[ AUDIO_LFOS
];
132 struct audio_channel
{
137 char name
[32]; /* only editable while allocated == 0 */
138 audio_clip
*source
; /* ... */
140 u32 colour
; /* ... */
142 /* internal non-readable state
143 * -----------------------------*/
144 u32 cursor
, source_length
;
146 float volume_movement_start
,
153 struct synth_bird
*bird_handle
;
154 stb_vorbis
*vorbis_handle
;
157 stb_vorbis_alloc vorbis_alloc
;
159 enum channel_activity
{
160 k_channel_activity_reset
, /* will advance if allocated==1, to wake */
161 k_channel_activity_wake
, /* will advance to either of next two */
162 k_channel_activity_alive
,
163 k_channel_activity_end
,
164 k_channel_activity_error
170 * editable structure, can be modified inside _lock and _unlock
171 * the edit mask tells which to copy into internal _, or to discard
172 * ----------------------------------------------------------------------
174 struct channel_state
{
177 float volume
, /* current volume */
178 volume_target
, /* target volume */
186 v4f spacial_falloff
; /* xyz, range */
192 u32 editble_state_write_mask
;
194 channels
[ AUDIO_CHANNELS
];
196 int debug_ui
, debug_ui_3d
, debug_dsp
;
198 v3f internal_listener_pos
,
199 internal_listener_ears
,
200 internal_listener_velocity
,
202 external_listener_pos
,
203 external_listener_ears
,
204 external_lister_velocity
;
206 float internal_global_volume
,
207 external_global_volume
;
209 static vg_audio
= { .external_global_volume
= 1.0f
};
211 #include "vg/vg_audio_dsp.h"
213 static struct vg_profile
214 _vg_prof_audio_decode
= {.mode
= k_profile_mode_accum
,
215 .name
= "[T2] audio_decode()"},
216 _vg_prof_audio_mix
= {.mode
= k_profile_mode_accum
,
217 .name
= "[T2] audio_mix()"},
218 _vg_prof_dsp
= {.mode
= k_profile_mode_accum
,
219 .name
= "[T2] dsp_process()"},
220 vg_prof_audio_decode
,
225 * These functions are called from the main thread and used to prevent bad
226 * access. TODO: They should be no-ops in release builds.
228 static int audio_lock_checker_load(void)
231 SDL_AtomicLock( &vg_audio
.sl_checker
);
232 value
= vg_audio
.sync_locked
;
233 SDL_AtomicUnlock( &vg_audio
.sl_checker
);
237 static void audio_lock_checker_store( int value
)
239 SDL_AtomicLock( &vg_audio
.sl_checker
);
240 vg_audio
.sync_locked
= value
;
241 SDL_AtomicUnlock( &vg_audio
.sl_checker
);
244 static void audio_require_lock(void)
246 if( audio_lock_checker_load() )
249 vg_error( "Modifying sound effects systems requires locking\n" );
253 static void audio_lock(void)
255 SDL_AtomicLock( &vg_audio
.sl_sync
);
256 audio_lock_checker_store(1);
259 static void audio_unlock(void)
261 audio_lock_checker_store(0);
262 SDL_AtomicUnlock( &vg_audio
.sl_sync
);
264 static void audio_mixer_callback( void *user
, u8
*stream
, int frame_count
);
266 static void vg_audio_device_init(void){
267 SDL_AudioSpec spec_desired
, spec_got
;
268 spec_desired
.callback
= audio_mixer_callback
;
269 spec_desired
.channels
= 2;
270 spec_desired
.format
= AUDIO_F32
;
271 spec_desired
.freq
= 44100;
272 spec_desired
.padding
= 0;
273 spec_desired
.samples
= AUDIO_FRAME_SIZE
;
274 spec_desired
.silence
= 0;
275 spec_desired
.size
= 0;
276 spec_desired
.userdata
= NULL
;
278 vg_audio
.sdl_output_device
=
279 SDL_OpenAudioDevice( vg_audio
.device_choice
.buffer
, 0,
280 &spec_desired
, &spec_got
,0 );
282 vg_info( "Start audio device (%u, F32, %u) @%s\n",
285 vg_audio
.device_choice
.buffer
);
287 if( vg_audio
.sdl_output_device
){
288 SDL_PauseAudioDevice( vg_audio
.sdl_output_device
, 0 );
289 vg_success( "Unpaused device %d.\n", vg_audio
.sdl_output_device
);
293 "SDL_OpenAudioDevice failed. Your default audio device must support:\n"
294 " Frequency: 44100 hz\n"
295 " Buffer size: 512\n"
297 " Format: s16 or f32\n" );
301 static void vg_audio_register(void){
302 vg_console_reg_var( "debug_audio", &vg_audio
.debug_ui
,
303 k_var_dtype_i32
, VG_VAR_CHEAT
);
304 vg_console_reg_var( "debug_dsp", &vg_audio
.debug_dsp
,
305 k_var_dtype_i32
, VG_VAR_CHEAT
);
306 vg_console_reg_var( "volume", &vg_audio
.external_global_volume
,
307 k_var_dtype_f32
, VG_VAR_PERSISTENT
);
308 vg_console_reg_var( "vg_audio_device", &vg_audio
.device_choice
,
309 k_var_dtype_str
, VG_VAR_PERSISTENT
);
312 static void vg_audio_init(void){
313 /* allocate memory */
315 vg_audio
.audio_pool
=
316 vg_create_linear_allocator( vg_mem
.rtmemory
, 1024*1024*32,
320 u32 decode_size
= AUDIO_DECODE_SIZE
* AUDIO_CHANNELS
;
321 vg_audio
.decode_buffer
= vg_linear_alloc( vg_mem
.rtmemory
, decode_size
);
324 vg_audio_device_init();
327 static void vg_audio_free(void)
330 SDL_CloseAudioDevice( vg_audio
.sdl_output_device
);
337 #define AUDIO_EDIT_VOLUME_SLOPE 0x1
338 #define AUDIO_EDIT_VOLUME 0x2
339 #define AUDIO_EDIT_LFO_PERIOD 0x4
340 #define AUDIO_EDIT_LFO_WAVE 0x8
341 #define AUDIO_EDIT_LFO_ATTACHMENT 0x10
342 #define AUDIO_EDIT_SPACIAL 0x20
343 #define AUDIO_EDIT_OWNERSHIP 0x40
344 #define AUDIO_EDIT_SAMPLING_RATE 0x80
346 static void audio_channel_init( audio_channel
*ch
, audio_clip
*clip
,
348 audio_require_lock();
353 ch
->colour
= 0x00333333;
355 if( (ch
->source
->flags
& AUDIO_FLAG_FORMAT
) == k_audio_format_bird
)
356 strcpy( ch
->name
, "[array]" );
357 else if( (ch
->source
->flags
& AUDIO_FLAG_FORMAT
) == k_audio_format_gen
)
358 strcpy( ch
->name
, "[program]" );
360 vg_strncpy( clip
->path
, ch
->name
, 32, k_strncpy_always_add_null
);
364 ch
->editable_state
.relinquished
= 0;
365 ch
->editable_state
.volume
= 1.0f
;
366 ch
->editable_state
.volume_target
= 1.0f
;
367 ch
->editable_state
.pan
= 0.0f
;
368 ch
->editable_state
.pan_target
= 0.0f
;
369 ch
->editable_state
.volume_rate
= 0;
370 ch
->editable_state
.pan_rate
= 0;
371 v4_copy((v4f
){0.0f
,0.0f
,0.0f
,1.0f
},ch
->editable_state
.spacial_falloff
);
372 ch
->editable_state
.lfo
= NULL
;
373 ch
->editable_state
.lfo_amount
= 0.0f
;
374 ch
->editable_state
.sampling_rate
= 1.0f
;
375 ch
->editble_state_write_mask
= 0x00;
378 static void audio_channel_group( audio_channel
*ch
, u16 group
)
380 audio_require_lock();
382 ch
->colour
= (((u32
)group
* 29986577) & 0x00ffffff) | 0xff000000;
385 static void audio_channel_world( audio_channel
*ch
, u8 world_id
)
387 audio_require_lock();
388 ch
->world_id
= world_id
;
391 static audio_channel
*audio_get_first_idle_channel(void)
393 audio_require_lock();
394 for( int i
=0; i
<AUDIO_CHANNELS
; i
++ ){
395 audio_channel
*ch
= &vg_audio
.channels
[i
];
397 if( !ch
->allocated
){
405 static audio_channel
*audio_get_group_idle_channel( u16 group
, u32 max_count
)
407 audio_require_lock();
409 audio_channel
*dest
= NULL
;
411 for( int i
=0; i
<AUDIO_CHANNELS
; i
++ ){
412 audio_channel
*ch
= &vg_audio
.channels
[i
];
415 if( ch
->group
== group
){
425 if( dest
&& (count
< max_count
) ){
432 static audio_channel
*audio_get_group_first_active_channel( u16 group
)
434 audio_require_lock();
435 for( int i
=0; i
<AUDIO_CHANNELS
; i
++ ){
436 audio_channel
*ch
= &vg_audio
.channels
[i
];
437 if( ch
->allocated
&& (ch
->group
== group
) )
443 static int audio_channel_finished( audio_channel
*ch
)
445 audio_require_lock();
446 if( ch
->readable_activity
== k_channel_activity_end
)
452 static audio_channel
*audio_relinquish_channel( audio_channel
*ch
)
454 audio_require_lock();
455 ch
->editable_state
.relinquished
= 1;
456 ch
->editble_state_write_mask
|= AUDIO_EDIT_OWNERSHIP
;
460 static void audio_channel_slope_volume( audio_channel
*ch
, float length
,
463 audio_require_lock();
464 ch
->editable_state
.volume_target
= new_volume
;
465 ch
->editable_state
.volume_rate
= length
* 44100.0f
;
466 ch
->editble_state_write_mask
|= AUDIO_EDIT_VOLUME_SLOPE
;
469 static void audio_channel_set_sampling_rate( audio_channel
*ch
, float rate
)
471 audio_require_lock();
472 ch
->editable_state
.sampling_rate
= rate
;
473 ch
->editble_state_write_mask
|= AUDIO_EDIT_SAMPLING_RATE
;
476 static void audio_channel_edit_volume( audio_channel
*ch
,
477 float new_volume
, int instant
)
479 audio_require_lock();
481 ch
->editable_state
.volume
= new_volume
;
482 ch
->editble_state_write_mask
|= AUDIO_EDIT_VOLUME
;
485 audio_channel_slope_volume( ch
, 0.05f
, new_volume
);
489 static audio_channel
*audio_channel_fadeout( audio_channel
*ch
, float length
)
491 audio_require_lock();
492 audio_channel_slope_volume( ch
, length
, 0.0f
);
493 return audio_relinquish_channel( ch
);
496 static void audio_channel_fadein( audio_channel
*ch
, float length
)
498 audio_require_lock();
499 audio_channel_edit_volume( ch
, 0.0f
, 1 );
500 audio_channel_slope_volume( ch
, length
, 1.0f
);
503 static audio_channel
*audio_channel_crossfade( audio_channel
*ch
,
504 audio_clip
*new_clip
,
505 float length
, u32 flags
)
507 audio_require_lock();
511 ch
= audio_channel_fadeout( ch
, length
);
513 audio_channel
*replacement
= audio_get_first_idle_channel();
516 audio_channel_init( replacement
, new_clip
, flags
);
517 audio_channel_fadein( replacement
, length
);
523 static void audio_channel_sidechain_lfo( audio_channel
*ch
, int lfo_id
,
526 audio_require_lock();
527 ch
->editable_state
.lfo
= &vg_audio
.oscillators
[ lfo_id
];
528 ch
->editable_state
.lfo_amount
= amount
;
529 ch
->editble_state_write_mask
|= AUDIO_EDIT_LFO_ATTACHMENT
;
532 static void audio_channel_set_spacial( audio_channel
*ch
, v3f co
, float range
)
534 audio_require_lock();
535 if( ch
->flags
& AUDIO_FLAG_SPACIAL_3D
){
536 v3_copy( co
, ch
->editable_state
.spacial_falloff
);
539 ch
->editable_state
.spacial_falloff
[3] = 1.0f
;
541 ch
->editable_state
.spacial_falloff
[3] = 1.0f
/range
;
543 ch
->editble_state_write_mask
|= AUDIO_EDIT_SPACIAL
;
546 vg_warn( "Tried to set spacialization paramaters for 2D channel (%s)\n",
551 static int audio_oneshot_3d( audio_clip
*clip
, v3f position
,
552 float range
, float volume
)
554 audio_require_lock();
555 audio_channel
*ch
= audio_get_first_idle_channel();
558 audio_channel_init( ch
, clip
, AUDIO_FLAG_SPACIAL_3D
);
559 audio_channel_set_spacial( ch
, position
, range
);
560 audio_channel_edit_volume( ch
, volume
, 1 );
561 ch
= audio_relinquish_channel( ch
);
569 static int audio_oneshot( audio_clip
*clip
, float volume
, float pan
)
571 audio_require_lock();
572 audio_channel
*ch
= audio_get_first_idle_channel();
575 audio_channel_init( ch
, clip
, 0x00 );
576 audio_channel_edit_volume( ch
, volume
, 1 );
577 ch
= audio_relinquish_channel( ch
);
585 static void audio_set_lfo_wave( int id
, enum lfo_wave_type type
,
588 audio_require_lock();
589 audio_lfo
*lfo
= &vg_audio
.oscillators
[ id
];
590 lfo
->editable_state
.polynomial_coefficient
= coefficient
;
591 lfo
->editable_state
.wave_type
= type
;
593 lfo
->editble_state_write_mask
|= AUDIO_EDIT_LFO_WAVE
;
596 static void audio_set_lfo_frequency( int id
, float freq
)
598 audio_require_lock();
599 audio_lfo
*lfo
= &vg_audio
.oscillators
[ id
];
600 lfo
->editable_state
.period
= 44100.0f
/ freq
;
601 lfo
->editble_state_write_mask
|= AUDIO_EDIT_LFO_PERIOD
;
607 * -----------------------------------------------------------------------------
609 static int audio_channel_load_source( audio_channel
*ch
)
611 u32 format
= ch
->source
->flags
& AUDIO_FLAG_FORMAT
;
613 if( format
== k_audio_format_vorbis
){
614 /* Setup vorbis decoder */
615 u32 index
= ch
- vg_audio
.channels
;
617 u8
*buf
= (u8
*)vg_audio
.decode_buffer
,
618 *loc
= &buf
[AUDIO_DECODE_SIZE
*index
];
620 stb_vorbis_alloc alloc
= {
621 .alloc_buffer
= (char *)loc
,
622 .alloc_buffer_length_in_bytes
= AUDIO_DECODE_SIZE
626 stb_vorbis
*decoder
= stb_vorbis_open_memory(
628 ch
->source
->size
, &err
, &alloc
);
631 vg_error( "stb_vorbis_open_memory failed on '%s' (%d)\n",
632 ch
->source
->path
, err
);
636 ch
->source_length
= stb_vorbis_stream_length_in_samples( decoder
);
637 ch
->vorbis_handle
= decoder
;
640 else if( format
== k_audio_format_bird
){
641 u32 index
= ch
- vg_audio
.channels
;
643 u8
*buf
= (u8
*)vg_audio
.decode_buffer
;
644 struct synth_bird
*loc
= (void *)&buf
[AUDIO_DECODE_SIZE
*index
];
646 memcpy( loc
, ch
->source
->data
, ch
->source
->size
);
647 synth_bird_reset( loc
);
649 ch
->bird_handle
= loc
;
650 ch
->source_length
= synth_bird_get_length_in_samples( loc
);
652 else if( format
== k_audio_format_stereo
){
653 ch
->source_length
= ch
->source
->size
/ 2;
655 else if( format
== k_audio_format_gen
){
656 ch
->source_length
= 0xffffffff;
659 ch
->source_length
= ch
->source
->size
;
665 static void audio_decode_uncompressed_mono( i16
*src
, u32 count
, float *dst
)
667 for( u32 i
=0; i
<count
; i
++ ){
668 dst
[ i
*2 + 0 ] = ((float)src
[i
]) * (1.0f
/32767.0f
);
669 dst
[ i
*2 + 1 ] = ((float)src
[i
]) * (1.0f
/32767.0f
);
674 * adapted from stb_vorbis.h, since the original does not handle mono->stereo
677 stb_vorbis_get_samples_float_interleaved_stereo( stb_vorbis
*f
, float *buffer
,
681 c
= VG_MIN( 1, f
->channels
- 1 );
684 int k
= f
->channel_buffer_end
- f
->channel_buffer_start
;
689 for( int j
=0; j
< k
; ++j
) {
690 *buffer
++ = f
->channel_buffers
[ 0 ][f
->channel_buffer_start
+j
];
691 *buffer
++ = f
->channel_buffers
[ c
][f
->channel_buffer_start
+j
];
695 f
->channel_buffer_start
+= k
;
700 if( !stb_vorbis_get_frame_float( f
, NULL
, NULL
))
708 * ........ more wrecked code sorry!
711 stb_vorbis_get_samples_i16_downmixed( stb_vorbis
*f
, i16
*buffer
, int len
)
714 c
= VG_MIN( 1, f
->channels
- 1 );
717 int k
= f
->channel_buffer_end
- f
->channel_buffer_start
;
722 for( int j
=0; j
< k
; ++j
) {
723 float sl
= f
->channel_buffers
[ 0 ][f
->channel_buffer_start
+j
],
724 sr
= f
->channel_buffers
[ c
][f
->channel_buffer_start
+j
];
726 *buffer
++ = vg_clampf( 0.5f
*(sl
+sr
), -1.0f
, 1.0f
) * 32767.0f
;
727 //*buffer++ = vg_clampf( sr, -1.0f, 1.0f ) * 32767.0f;
731 f
->channel_buffer_start
+= k
;
736 if( !stb_vorbis_get_frame_float( f
, NULL
, NULL
))
743 static inline float audio_lfo_pull_sample( audio_lfo
*lfo
)
747 if( lfo
->time
>= lfo
->_
.period
)
751 t
/= (float)lfo
->_
.period
;
753 if( lfo
->_
.wave_type
== k_lfo_polynomial_bipolar
){
769 return (( 2.0f
* lfo
->sqrt_polynomial_coefficient
* t
) /
770 /* --------------------------------------- */
771 ( 1.0f
+ lfo
->_
.polynomial_coefficient
* t
*t
)
780 static void audio_channel_get_samples( audio_channel
*ch
,
781 u32 count
, float *buf
)
783 vg_profile_begin( &_vg_prof_audio_decode
);
785 u32 remaining
= count
;
788 u32 format
= ch
->source
->flags
& AUDIO_FLAG_FORMAT
;
791 u32 samples_this_run
= VG_MIN(remaining
, ch
->source_length
- ch
->cursor
);
792 remaining
-= samples_this_run
;
794 float *dst
= &buf
[ buffer_pos
* 2 ];
796 if( format
== k_audio_format_stereo
){
797 for( int i
=0;i
<samples_this_run
; i
++ ){
802 else if( format
== k_audio_format_vorbis
){
803 int read_samples
= stb_vorbis_get_samples_float_interleaved_stereo(
808 if( read_samples
!= samples_this_run
){
809 vg_warn( "Invalid samples read (%s)\n", ch
->source
->path
);
811 for( int i
=0; i
<samples_this_run
; i
++ ){
817 else if( format
== k_audio_format_bird
){
818 synth_bird_generate_samples( ch
->bird_handle
, dst
, samples_this_run
);
820 else if( format
== k_audio_format_gen
){
821 void (*fn
)( void *data
, f32
*buf
, u32 count
) = ch
->source
->func
;
822 fn( ch
->source
->data
, dst
, samples_this_run
);
825 i16
*src_buffer
= ch
->source
->data
,
826 *src
= &src_buffer
[ch
->cursor
];
828 audio_decode_uncompressed_mono( src
, samples_this_run
, dst
);
831 ch
->cursor
+= samples_this_run
;
832 buffer_pos
+= samples_this_run
;
834 if( (ch
->flags
& AUDIO_FLAG_LOOP
) && remaining
){
835 if( format
== k_audio_format_vorbis
)
836 stb_vorbis_seek_start( ch
->vorbis_handle
);
837 else if( format
== k_audio_format_bird
)
838 synth_bird_reset( ch
->bird_handle
);
848 buf
[ buffer_pos
*2 + 0 ] = 0.0f
;
849 buf
[ buffer_pos
*2 + 1 ] = 0.0f
;
855 vg_profile_end( &_vg_prof_audio_decode
);
858 static void audio_channel_mix( audio_channel
*ch
, float *buffer
)
860 float framevol_l
= vg_audio
.internal_global_volume
,
861 framevol_r
= vg_audio
.internal_global_volume
;
863 float frame_samplerate
= ch
->_
.sampling_rate
;
865 if( ch
->flags
& AUDIO_FLAG_SPACIAL_3D
){
867 v3_sub( ch
->_
.spacial_falloff
, vg_audio
.internal_listener_pos
, delta
);
869 float dist
= v3_length( delta
),
870 vol
= vg_maxf( 0.0f
, 1.0f
- ch
->_
.spacial_falloff
[3]*dist
);
876 v3_muls( delta
, 1.0f
/dist
, delta
);
877 float pan
= v3_dot( vg_audio
.internal_listener_ears
, delta
);
878 vol
= powf( vol
, 5.0f
);
880 framevol_l
*= (vol
* 0.5f
) * (1.0f
- pan
);
881 framevol_r
*= (vol
* 0.5f
) * (1.0f
+ pan
);
883 if( !(ch
->source
->flags
& AUDIO_FLAG_NO_DOPPLER
) ){
884 const float vs
= 323.0f
;
886 float dv
= v3_dot(delta
,vg_audio
.internal_listener_velocity
);
887 float doppler
= (vs
+dv
)/vs
;
888 doppler
= vg_clampf( doppler
, 0.6f
, 1.4f
);
890 if( fabsf(doppler
-1.0f
) > 0.01f
)
891 frame_samplerate
*= doppler
;
895 if( !vg_validf( framevol_l
) ||
896 !vg_validf( framevol_r
) ||
897 !vg_validf( frame_samplerate
) ){
898 vg_fatal_error( "Invalid sampling conditions.\n"
899 "This crash is to protect your ears.\n"
900 " channel: %p (%s)\n"
903 " listener: %.2f %.2f %.2f [%.2f %.2f %.2f]\n",
904 ch
, ch
->name
, frame_samplerate
,
905 framevol_l
, framevol_r
,
906 vg_audio
.internal_listener_pos
[0],
907 vg_audio
.internal_listener_pos
[1],
908 vg_audio
.internal_listener_pos
[2],
909 vg_audio
.internal_listener_ears
[0],
910 vg_audio
.internal_listener_ears
[1],
911 vg_audio
.internal_listener_ears
[2]
916 u32 buffer_length
= AUDIO_MIX_FRAME_SIZE
;
917 if( frame_samplerate
!= 1.0f
){
918 float l
= ceilf( (float)(AUDIO_MIX_FRAME_SIZE
) * frame_samplerate
);
922 float pcf
[ AUDIO_MIX_FRAME_SIZE
* 2 * 2 ];
924 audio_channel_get_samples( ch
, buffer_length
, pcf
);
926 vg_profile_begin( &_vg_prof_audio_mix
);
928 float volume_movement
= ch
->volume_movement
;
929 float const fvolume_rate
= vg_maxf( 1.0f
, ch
->_
.volume_rate
);
930 const float inv_volume_rate
= 1.0f
/fvolume_rate
;
932 float volume
= ch
->_
.volume
;
933 const float volume_start
= ch
->volume_movement_start
;
934 const float volume_target
= ch
->_
.volume_target
;
936 for( u32 j
=0; j
<AUDIO_MIX_FRAME_SIZE
; j
++ ){
937 volume_movement
+= 1.0f
;
938 float movement_t
= volume_movement
* inv_volume_rate
;
939 movement_t
= vg_minf( movement_t
, 1.0f
);
940 volume
= vg_lerpf( volume_start
, volume_target
, movement_t
);
942 float vol_norm
= volume
* volume
;
945 vol_norm
*= 1.0f
+ audio_lfo_pull_sample(ch
->_
.lfo
) * ch
->_
.lfo_amount
;
947 float vol_l
= vol_norm
* framevol_l
,
948 vol_r
= vol_norm
* framevol_r
,
952 if( frame_samplerate
!= 1.0f
){
953 /* absolutely garbage resampling, but it will do
956 float sample_index
= frame_samplerate
* (float)j
;
957 float t
= vg_fractf( sample_index
);
959 u32 i0
= floorf( sample_index
),
962 sample_l
= pcf
[ i0
*2+0 ]*(1.0f
-t
) + pcf
[ i1
*2+0 ]*t
;
963 sample_r
= pcf
[ i0
*2+1 ]*(1.0f
-t
) + pcf
[ i1
*2+1 ]*t
;
966 sample_l
= pcf
[ j
*2+0 ];
967 sample_r
= pcf
[ j
*2+1 ];
970 buffer
[ j
*2+0 ] += sample_l
* vol_l
;
971 buffer
[ j
*2+1 ] += sample_r
* vol_r
;
974 ch
->volume_movement
+= AUDIO_MIX_FRAME_SIZE
;
975 ch
->volume_movement
= VG_MIN( ch
->volume_movement
, ch
->_
.volume_rate
);
976 ch
->_
.volume
= volume
;
978 vg_profile_end( &_vg_prof_audio_mix
);
981 static void audio_mixer_callback( void *user
, u8
*stream
, int byte_count
)
984 * Copy data and move edit flags to commit flags
985 * ------------------------------------------------------------- */
988 v3_copy( vg_audio
.external_listener_pos
, vg_audio
.internal_listener_pos
);
989 v3_copy( vg_audio
.external_listener_ears
, vg_audio
.internal_listener_ears
);
990 v3_copy( vg_audio
.external_lister_velocity
,
991 vg_audio
.internal_listener_velocity
);
992 vg_audio
.internal_global_volume
= vg_audio
.external_global_volume
;
994 for( int i
=0; i
<AUDIO_CHANNELS
; i
++ ){
995 audio_channel
*ch
= &vg_audio
.channels
[i
];
1000 if( ch
->activity
== k_channel_activity_alive
){
1001 if( (ch
->cursor
>= ch
->source_length
) &&
1002 !(ch
->flags
& AUDIO_FLAG_LOOP
) )
1004 ch
->activity
= k_channel_activity_end
;
1008 /* process relinquishments */
1009 if( (ch
->activity
!= k_channel_activity_reset
) && ch
->_
.relinquished
){
1010 if( (ch
->activity
== k_channel_activity_end
)
1011 || (ch
->_
.volume
== 0.0f
)
1012 || (ch
->activity
== k_channel_activity_error
) )
1014 ch
->_
.relinquished
= 0;
1016 ch
->activity
= k_channel_activity_reset
;
1021 /* process new channels */
1022 if( ch
->activity
== k_channel_activity_reset
){
1023 ch
->_
= ch
->editable_state
;
1025 ch
->source_length
= 0;
1026 ch
->activity
= k_channel_activity_wake
;
1029 if( ch
->editble_state_write_mask
& AUDIO_EDIT_OWNERSHIP
)
1030 ch
->_
.relinquished
= ch
->editable_state
.relinquished
;
1032 ch
->editable_state
.relinquished
= ch
->_
.relinquished
;
1035 if( ch
->editble_state_write_mask
& AUDIO_EDIT_VOLUME
){
1036 ch
->_
.volume
= ch
->editable_state
.volume
;
1037 ch
->_
.volume_target
= ch
->editable_state
.volume
;
1040 ch
->editable_state
.volume
= ch
->_
.volume
;
1044 if( ch
->editble_state_write_mask
& AUDIO_EDIT_VOLUME_SLOPE
){
1045 ch
->volume_movement_start
= ch
->_
.volume
;
1046 ch
->volume_movement
= 0;
1048 ch
->_
.volume_target
= ch
->editable_state
.volume_target
;
1049 ch
->_
.volume_rate
= ch
->editable_state
.volume_rate
;
1052 ch
->editable_state
.volume_target
= ch
->_
.volume_target
;
1053 ch
->editable_state
.volume_rate
= ch
->_
.volume_rate
;
1057 if( ch
->editble_state_write_mask
& AUDIO_EDIT_SAMPLING_RATE
)
1058 ch
->_
.sampling_rate
= ch
->editable_state
.sampling_rate
;
1060 ch
->editable_state
.sampling_rate
= ch
->_
.sampling_rate
;
1063 if( ch
->editble_state_write_mask
& AUDIO_EDIT_LFO_ATTACHMENT
){
1064 ch
->_
.lfo
= ch
->editable_state
.lfo
;
1065 ch
->_
.lfo_amount
= ch
->editable_state
.lfo_amount
;
1068 ch
->editable_state
.lfo
= ch
->_
.lfo
;
1069 ch
->editable_state
.lfo_amount
= ch
->_
.lfo_amount
;
1073 if( ch
->editble_state_write_mask
& AUDIO_EDIT_SPACIAL
)
1074 v4_copy( ch
->editable_state
.spacial_falloff
,ch
->_
.spacial_falloff
);
1076 v4_copy( ch
->_
.spacial_falloff
,ch
->editable_state
.spacial_falloff
);
1079 /* currently readonly, i guess */
1080 ch
->editable_state
.pan_target
= ch
->_
.pan_target
;
1081 ch
->editable_state
.pan
= ch
->_
.pan
;
1082 ch
->editble_state_write_mask
= 0x00;
1085 for( int i
=0; i
<AUDIO_LFOS
; i
++ ){
1086 audio_lfo
*lfo
= &vg_audio
.oscillators
[ i
];
1088 if( lfo
->editble_state_write_mask
& AUDIO_EDIT_LFO_WAVE
){
1089 lfo
->_
.wave_type
= lfo
->editable_state
.wave_type
;
1091 if( lfo
->_
.wave_type
== k_lfo_polynomial_bipolar
){
1092 lfo
->_
.polynomial_coefficient
=
1093 lfo
->editable_state
.polynomial_coefficient
;
1094 lfo
->sqrt_polynomial_coefficient
=
1095 sqrtf(lfo
->_
.polynomial_coefficient
);
1099 if( lfo
->editble_state_write_mask
& AUDIO_EDIT_LFO_PERIOD
){
1100 if( lfo
->_
.period
){
1101 float t
= lfo
->time
;
1102 t
/= (float)lfo
->_
.period
;
1104 lfo
->_
.period
= lfo
->editable_state
.period
;
1105 lfo
->time
= lfo
->_
.period
* t
;
1109 lfo
->_
.period
= lfo
->editable_state
.period
;
1113 lfo
->editble_state_write_mask
= 0x00;
1116 dsp_update_tunings();
1121 * ------------------------------------------------------------- */
1122 for( int i
=0; i
<AUDIO_CHANNELS
; i
++ ){
1123 audio_channel
*ch
= &vg_audio
.channels
[i
];
1125 if( ch
->activity
== k_channel_activity_wake
){
1126 if( audio_channel_load_source( ch
) )
1127 ch
->activity
= k_channel_activity_alive
;
1129 ch
->activity
= k_channel_activity_error
;
1135 * -------------------------------------------------------- */
1136 int frame_count
= byte_count
/(2*sizeof(float));
1139 float *pOut32F
= (float *)stream
;
1140 for( int i
=0; i
<frame_count
*2; i
++ )
1143 for( int i
=0; i
<AUDIO_LFOS
; i
++ ){
1144 audio_lfo
*lfo
= &vg_audio
.oscillators
[i
];
1145 lfo
->time_startframe
= lfo
->time
;
1148 for( int i
=0; i
<AUDIO_CHANNELS
; i
++ ){
1149 audio_channel
*ch
= &vg_audio
.channels
[i
];
1151 if( ch
->activity
== k_channel_activity_alive
){
1153 ch
->_
.lfo
->time
= ch
->_
.lfo
->time_startframe
;
1155 u32 remaining
= frame_count
,
1159 audio_channel_mix( ch
, pOut32F
+subpos
);
1160 remaining
-= AUDIO_MIX_FRAME_SIZE
;
1161 subpos
+= AUDIO_MIX_FRAME_SIZE
*2;
1166 vg_profile_begin( &_vg_prof_dsp
);
1168 for( int i
=0; i
<frame_count
; i
++ )
1169 vg_dsp_process( pOut32F
+ i
*2, pOut32F
+ i
*2 );
1171 vg_profile_end( &_vg_prof_dsp
);
1175 for( int i
=0; i
<AUDIO_CHANNELS
; i
++ ){
1176 audio_channel
*ch
= &vg_audio
.channels
[i
];
1177 ch
->readable_activity
= ch
->activity
;
1180 /* Profiling information
1181 * ----------------------------------------------- */
1182 vg_profile_increment( &_vg_prof_audio_decode
);
1183 vg_profile_increment( &_vg_prof_audio_mix
);
1184 vg_profile_increment( &_vg_prof_dsp
);
1186 vg_prof_audio_mix
= _vg_prof_audio_mix
;
1187 vg_prof_audio_decode
= _vg_prof_audio_decode
;
1188 vg_prof_audio_dsp
= _vg_prof_dsp
;
1190 vg_audio
.samples_last
= frame_count
;
1192 if( vg_audio
.debug_dsp
){
1193 vg_dsp_update_texture();
1199 static void audio_clip_load( audio_clip
*clip
, void *lin_alloc
)
1201 if( lin_alloc
== NULL
)
1202 lin_alloc
= vg_audio
.audio_pool
;
1204 #ifdef VG_AUDIO_FORCE_COMPRESSED
1206 if( (clip
->flags
& AUDIO_FLAG_FORMAT
) != k_audio_format_bird
){
1207 clip
->flags
&= ~AUDIO_FLAG_FORMAT
;
1208 clip
->flags
|= k_audio_format_vorbis
;
1213 /* load in directly */
1214 u32 format
= clip
->flags
& AUDIO_FLAG_FORMAT
;
1216 /* TODO: This contains audio_lock() and unlock, but i don't know why
1217 * can probably remove them. Low priority to check this */
1219 /* TODO: packed files for vorbis etc, should take from data if its not not
1220 * NULL when we get the clip
1223 if( format
== k_audio_format_vorbis
){
1225 vg_fatal_error( "No path specified, embeded vorbis unsupported" );
1229 clip
->data
= vg_file_read( lin_alloc
, clip
->path
, &clip
->size
);
1233 vg_fatal_error( "Audio failed to load" );
1235 float mb
= (float)(clip
->size
) / (1024.0f
*1024.0f
);
1236 vg_info( "Loaded audio clip '%s' (%.1fmb)\n", clip
->path
, mb
);
1238 else if( format
== k_audio_format_stereo
){
1239 vg_fatal_error( "Unsupported format (Stereo uncompressed)" );
1241 else if( format
== k_audio_format_bird
){
1243 vg_fatal_error( "No data, external birdsynth unsupported" );
1246 u32 total_size
= clip
->size
+ sizeof(struct synth_bird
);
1247 total_size
-= sizeof(struct synth_bird_settings
);
1248 total_size
= vg_align8( total_size
);
1250 if( total_size
> AUDIO_DECODE_SIZE
)
1251 vg_fatal_error( "Bird coding too long\n" );
1253 struct synth_bird
*bird
= vg_linear_alloc( lin_alloc
, total_size
);
1254 memcpy( &bird
->settings
, clip
->data
, clip
->size
);
1257 clip
->size
= total_size
;
1259 vg_info( "Loaded bird synthesis pattern (%u bytes)\n", total_size
);
1263 vg_fatal_error( "No path specified, embeded mono unsupported" );
1266 vg_linear_clear( vg_mem
.scratch
);
1269 stb_vorbis_alloc alloc
= {
1270 .alloc_buffer
= vg_linear_alloc( vg_mem
.scratch
, AUDIO_DECODE_SIZE
),
1271 .alloc_buffer_length_in_bytes
= AUDIO_DECODE_SIZE
1274 void *filedata
= vg_file_read( vg_mem
.scratch
, clip
->path
, &fsize
);
1277 stb_vorbis
*decoder
= stb_vorbis_open_memory(
1278 filedata
, fsize
, &err
, &alloc
);
1281 vg_error( "stb_vorbis_open_memory failed on '%s' (%d)\n",
1283 vg_fatal_error( "Vorbis decode error" );
1286 /* only mono is supported in uncompressed */
1287 u32 length_samples
= stb_vorbis_stream_length_in_samples( decoder
),
1288 data_size
= length_samples
* sizeof(i16
);
1291 clip
->data
= vg_linear_alloc( lin_alloc
, vg_align8(data_size
) );
1292 clip
->size
= length_samples
;
1295 int read_samples
= stb_vorbis_get_samples_i16_downmixed(
1296 decoder
, clip
->data
, length_samples
);
1298 if( read_samples
!= length_samples
)
1299 vg_fatal_error( "Decode error" );
1302 float mb
= (float)(data_size
) / (1024.0f
*1024.0f
);
1303 vg_info( "Loaded audio clip '%s' (%.1fmb) %u samples\n", clip
->path
, mb
,
1309 static void audio_clip_loadn( audio_clip
*arr
, int count
, void *lin_alloc
)
1311 for( int i
=0; i
<count
; i
++ )
1312 audio_clip_load( &arr
[i
], lin_alloc
);
1315 static void audio_require_clip_loaded( audio_clip
*clip
)
1317 if( clip
->data
&& clip
->size
)
1321 vg_fatal_error( "Must load audio clip before playing! \n" );
1328 static void audio_debug_ui(
1337 if( !vg_audio
.debug_ui
)
1342 glBindTexture( GL_TEXTURE_2D
, vg_dsp
.view_texture
);
1343 glTexSubImage2D( GL_TEXTURE_2D
, 0, 0, 0, 256, 256,
1344 GL_RGBA
, GL_UNSIGNED_BYTE
,
1345 vg_dsp
.view_texture_buffer
);
1349 * -----------------------------------------------------------------------
1352 float budget
= ((double)vg_audio
.samples_last
/ 44100.0) * 1000.0;
1353 vg_profile_drawn( (struct vg_profile
*[]){ &vg_prof_audio_decode
,
1355 &vg_prof_audio_dsp
}, 3,
1356 budget
, (ui_rect
){ 4, VG_PROFILE_SAMPLE_COUNT
*2 + 8,
1370 if( vg_audio
.debug_dsp
){
1371 ui_rect view_thing
= { 4, vg
.window_y
-512-4, 512, 512 };
1372 ui_image( view_thing
, vg_dsp
.view_texture
);
1375 ui_rect overlap_buffer
[ AUDIO_CHANNELS
];
1376 u32 overlap_length
= 0;
1378 /* Draw audio stack */
1379 for( int i
=0; i
<AUDIO_CHANNELS
; i
++ ){
1380 audio_channel
*ch
= &vg_audio
.channels
[i
];
1383 ui_split( window
, k_ui_axis_h
, 18, 1, row
, window
);
1385 if( !ch
->allocated
){
1386 ui_fill( row
, 0x50333333 );
1390 const char *formats
[] =
1410 const char *activties
[] =
1419 u32 format_index
= (ch
->source
->flags
& AUDIO_FLAG_FORMAT
)>>9;
1421 snprintf( perf
, 127, "%02d[%#04x.%#06x]%c%c%cD %s [%s] %4.2fv'%s'",
1423 ch
->world_id
, ch
->group
,
1424 (ch
->editable_state
.relinquished
)? 'r': '_',
1427 formats
[format_index
],
1428 activties
[ch
->readable_activity
],
1429 ch
->editable_state
.volume
,
1432 ui_fill( row
, 0xa0000000 | ch
->colour
);
1433 ui_text( row
, perf
, 1, k_ui_align_middle_left
, 0 );
1436 if( AUDIO_FLAG_SPACIAL_3D
){
1438 v3_copy( ch
->editable_state
.spacial_falloff
, wpos
);
1441 m4x4_mulv( mtx_pv
, wpos
, wpos
);
1443 if( wpos
[3] > 0.0f
){
1444 v2_muls( wpos
, (1.0f
/wpos
[3]) * 0.5f
, wpos
);
1445 v2_add( wpos
, (v2f
){ 0.5f
, 0.5f
}, wpos
);
1448 wr
[0] = vg_clampf(wpos
[0] * vg
.window_x
, -32000.0f
,32000.0f
);
1449 wr
[1] = vg_clampf((1.0f
-wpos
[1]) * vg
.window_y
,-32000.0f
,32000.0f
);
1453 for( int j
=0; j
<12; j
++ ){
1455 for( int k
=0; k
<overlap_length
; k
++ ){
1456 ui_px
*wk
= overlap_buffer
[k
];
1457 if( ((wr
[0] <= wk
[0]+wk
[2]) && (wr
[0]+wr
[2] >= wk
[0])) &&
1458 ((wr
[1] <= wk
[1]+wk
[3]) && (wr
[1]+wr
[3] >= wk
[1])) )
1471 ui_text( wr
, perf
, 1, k_ui_align_middle_left
, 0 );
1472 rect_copy( wr
, overlap_buffer
[ overlap_length
++ ] );
1481 #endif /* VG_AUDIO_H */