projects / vg.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
fixed nan propogation error
[vg.git] / vg_audio.h
1 /* Copyright (C) 2021-2023 Harry Godden (hgn) - All Rights Reserved */
2
3 #ifndef VG_AUDIO_H
4 #define VG_AUDIO_H
5
6 #define VG_GAME
7
8 #include "vg/vg.h"
9 #include "vg/vg_stdint.h"
10 #include "vg/vg_platform.h"
11 #include "vg/vg_io.h"
12 #include "vg/vg_m.h"
13 #include "vg/vg_ui.h"
14 #include "vg/vg_console.h"
15 #include "vg/vg_store.h"
16 #include "vg/vg_profiler.h"
17 #include "vg/vg_audio_synth_bird.h"
18
19 #ifdef __GNUC__
20 #ifndef __clang__
21 #pragma GCC push_options
22 #pragma GCC optimize ("O3")
23 #pragma GCC diagnostic push
24 #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
25 #endif
26 #endif
27
28 #define STB_VORBIS_MAX_CHANNELS 2
29 #include "submodules/stb/stb_vorbis.c"
30 #undef L
31 #undef R
32 #undef C
33
34 #ifdef __GNUC__
35 #ifndef __clang__
36 #pragma GCC pop_options
37 #pragma GCC diagnostic pop
38 #endif
39 #endif
40
41 #define AUDIO_FRAME_SIZE 512
42 #define AUDIO_MIX_FRAME_SIZE 256
43
44 #define AUDIO_CHANNELS 32
45 #define AUDIO_LFOS 8
46 #define AUDIO_FILTERS 16
47 #define AUDIO_FLAG_LOOP 0x1
48 #define AUDIO_FLAG_NO_DOPPLER 0x2
49 #define AUDIO_FLAG_SPACIAL_3D 0x4
50 #define AUDIO_FLAG_AUTO_START 0x8
51 #define AUDIO_FLAG_FORMAT 0x1E00
52
53 enum audio_format
54 {
55 k_audio_format_mono = 0x000u,
56 k_audio_format_stereo = 0x200u,
57 k_audio_format_vorbis = 0x400u,
58 k_audio_format_none0 = 0x600u,
59 k_audio_format_none1 = 0x800u,
60 k_audio_format_none2 = 0xA00u,
61 k_audio_format_none3 = 0xC00u,
62 k_audio_format_none4 = 0xE00u,
63
64 k_audio_format_bird = 0x1000u,
65 k_audio_format_none5 = 0x1200u,
66 k_audio_format_none6 = 0x1400u,
67 k_audio_format_none7 = 0x1600u,
68 k_audio_format_none8 = 0x1800u,
69 k_audio_format_none9 = 0x1A00u,
70 k_audio_format_none10 = 0x1C00u,
71 k_audio_format_none11 = 0x1E00u,
72 };
73
74 #define AUDIO_DECODE_SIZE (1024*256) /* 256 kb decoding buffers */
75 #define AUDIO_MUTE_VOLUME 0.0f
76 #define AUDIO_BASE_VOLUME 1.0f
77
78 typedef struct audio_clip audio_clip;
79 typedef struct audio_channel audio_channel;
80 typedef struct audio_lfo audio_lfo;
81
82 struct audio_clip{
83 union { /* TODO oof.. */
84 u64 _p64_;
85 const char *path;
86 };
87
88 u32 flags;
89 u32 size;
90
91 union{
92 u64 _p64;
93 void *data;
94 };
95 };
96
97 struct vg_audio_system{
98 SDL_AudioDeviceID sdl_output_device;
99
100 void *audio_pool,
101 *decode_buffer;
102 u32 samples_last;
103
104 /* synchro */
105 int sync_locked;
106
107 SDL_SpinLock sl_checker,
108 sl_sync;
109
110 struct audio_lfo{
111 u32 time, time_startframe;
112 float sqrt_polynomial_coefficient;
113
114 struct{
115 enum lfo_wave_type{
116 k_lfo_triangle,
117 k_lfo_square,
118 k_lfo_saw,
119 k_lfo_polynomial_bipolar
120 }
121 wave_type;
122
123 u32 period;
124 float polynomial_coefficient;
125 }
126 _, editable_state;
127 u32 editble_state_write_mask;
128 }
129 oscillators[ AUDIO_LFOS ];
130
131 struct audio_channel{
132 int allocated;
133 u16 group;
134 u8 world_id;
135
136 char name[32]; /* only editable while allocated == 0 */
137 audio_clip *source; /* ... */
138 u32 flags; /* ... */
139 u32 colour; /* ... */
140
141 /* internal non-readable state
142 * -----------------------------*/
143 u32 cursor, source_length;
144
145 float volume_movement_start,
146 pan_movement_start;
147
148 u32 volume_movement,
149 pan_movement;
150
151 union{
152 struct synth_bird *bird_handle;
153 stb_vorbis *vorbis_handle;
154 };
155
156 stb_vorbis_alloc vorbis_alloc;
157
158 enum channel_activity{
159 k_channel_activity_reset, /* will advance if allocated==1, to wake */
160 k_channel_activity_wake, /* will advance to either of next two */
161 k_channel_activity_alive,
162 k_channel_activity_end,
163 k_channel_activity_error
164 }
165 activity,
166 readable_activity;
167
168 /*
169 * editable structure, can be modified inside _lock and _unlock
170 * the edit mask tells which to copy into internal _, or to discard
171 * ----------------------------------------------------------------------
172 */
173 struct channel_state{
174 int relinquished;
175
176 float volume, /* current volume */
177 volume_target, /* target volume */
178 pan,
179 pan_target,
180 sampling_rate;
181
182 u32 volume_rate,
183 pan_rate;
184
185 v4f spacial_falloff; /* xyz, range */
186
187 audio_lfo *lfo;
188 float lfo_amount;
189 }
190 _, editable_state;
191 u32 editble_state_write_mask;
192 }
193 channels[ AUDIO_CHANNELS ];
194
195 int debug_ui, debug_ui_3d, debug_dsp;
196
197 v3f internal_listener_pos,
198 internal_listener_ears,
199 internal_listener_velocity,
200
201 external_listener_pos,
202 external_listener_ears,
203 external_lister_velocity;
204
205 float internal_global_volume,
206 external_global_volume;
207 }
208 static vg_audio = { .external_global_volume = 1.0f };
209
210 #include "vg/vg_audio_dsp.h"
211
212 static struct vg_profile
213 _vg_prof_audio_decode = {.mode = k_profile_mode_accum,
214 .name = "[T2] audio_decode()"},
215 _vg_prof_audio_mix = {.mode = k_profile_mode_accum,
216 .name = "[T2] audio_mix()"},
217 _vg_prof_dsp = {.mode = k_profile_mode_accum,
218 .name = "[T2] dsp_process()"},
219 vg_prof_audio_decode,
220 vg_prof_audio_mix,
221 vg_prof_audio_dsp;
222
223 /*
224 * These functions are called from the main thread and used to prevent bad
225 * access. TODO: They should be no-ops in release builds.
226 */
227 VG_STATIC int audio_lock_checker_load(void)
228 {
229 int value;
230 SDL_AtomicLock( &vg_audio.sl_checker );
231 value = vg_audio.sync_locked;
232 SDL_AtomicUnlock( &vg_audio.sl_checker );
233 return value;
234 }
235
236 VG_STATIC void audio_lock_checker_store( int value )
237 {
238 SDL_AtomicLock( &vg_audio.sl_checker );
239 vg_audio.sync_locked = value;
240 SDL_AtomicUnlock( &vg_audio.sl_checker );
241 }
242
243 VG_STATIC void audio_require_lock(void)
244 {
245 if( audio_lock_checker_load() )
246 return;
247
248 vg_error( "Modifying sound effects systems requires locking\n" );
249 abort();
250 }
251
252 VG_STATIC void audio_lock(void)
253 {
254 SDL_AtomicLock( &vg_audio.sl_sync );
255 audio_lock_checker_store(1);
256 }
257
258 VG_STATIC void audio_unlock(void)
259 {
260 audio_lock_checker_store(0);
261 SDL_AtomicUnlock( &vg_audio.sl_sync );
262 }
263
264 VG_STATIC void audio_mixer_callback( void *user, u8 *stream, int frame_count );
265 VG_STATIC void vg_audio_init(void)
266 {
267 /* TODO: Move here? */
268 vg_console_reg_var( "debug_audio", &vg_audio.debug_ui,
269 k_var_dtype_i32, VG_VAR_CHEAT );
270 vg_console_reg_var( "debug_dsp", &vg_audio.debug_dsp,
271 k_var_dtype_i32, VG_VAR_CHEAT );
272 vg_console_reg_var( "volume", &vg_audio.external_global_volume,
273 k_var_dtype_f32, VG_VAR_PERSISTENT );
274
275 /* allocate memory */
276 /* 32mb fixed */
277 vg_audio.audio_pool =
278 vg_create_linear_allocator( vg_mem.rtmemory, 1024*1024*32,
279 VG_MEMORY_SYSTEM );
280
281 /* fixed */
282 u32 decode_size = AUDIO_DECODE_SIZE * AUDIO_CHANNELS;
283 vg_audio.decode_buffer = vg_linear_alloc( vg_mem.rtmemory, decode_size );
284
285 vg_dsp_init();
286
287 SDL_AudioSpec spec_desired, spec_got;
288 spec_desired.callback = audio_mixer_callback;
289 spec_desired.channels = 2;
290 spec_desired.format = AUDIO_F32;
291 spec_desired.freq = 44100;
292 spec_desired.padding = 0;
293 spec_desired.samples = AUDIO_FRAME_SIZE;
294 spec_desired.silence = 0;
295 spec_desired.size = 0;
296 spec_desired.userdata = NULL;
297
298 vg_audio.sdl_output_device =
299 SDL_OpenAudioDevice( NULL, 0, &spec_desired, &spec_got,0 );
300
301 if( vg_audio.sdl_output_device ){
302 SDL_PauseAudioDevice( vg_audio.sdl_output_device, 0 );
303 }
304 else{
305 vg_fatal_error(
306 "SDL_OpenAudioDevice failed. Your default audio device must support:\n"
307 " Frequency: 44100 hz\n"
308 " Buffer size: 512\n"
309 " Channels: 2\n"
310 " Format: s16 or f32\n" );
311 }
312 }
313
314 VG_STATIC void vg_audio_free(void)
315 {
316 vg_dsp_free();
317 SDL_CloseAudioDevice( vg_audio.sdl_output_device );
318 }
319
320 /*
321 * thread 1
322 */
323
324 #define AUDIO_EDIT_VOLUME_SLOPE 0x1
325 #define AUDIO_EDIT_VOLUME 0x2
326 #define AUDIO_EDIT_LFO_PERIOD 0x4
327 #define AUDIO_EDIT_LFO_WAVE 0x8
328 #define AUDIO_EDIT_LFO_ATTACHMENT 0x10
329 #define AUDIO_EDIT_SPACIAL 0x20
330 #define AUDIO_EDIT_OWNERSHIP 0x40
331 #define AUDIO_EDIT_SAMPLING_RATE 0x80
332
333 static void audio_channel_init( audio_channel *ch, audio_clip *clip, u32 flags )
334 {
335 ch->group = 0;
336 ch->world_id = 0;
337 ch->source = clip;
338 ch->flags = flags;
339 ch->colour = 0x00333333;
340
341 if( (ch->source->flags & AUDIO_FLAG_FORMAT) == k_audio_format_bird )
342 strcpy( ch->name, "[array]" );
343 else
344 vg_strncpy( clip->path, ch->name, 32, k_strncpy_always_add_null );
345
346 ch->allocated = 1;
347
348 ch->editable_state.relinquished = 0;
349 ch->editable_state.volume = 1.0f;
350 ch->editable_state.volume_target = 1.0f;
351 ch->editable_state.pan = 0.0f;
352 ch->editable_state.pan_target = 0.0f;
353 ch->editable_state.volume_rate = 0;
354 ch->editable_state.pan_rate = 0;
355 v4_copy((v4f){0.0f,0.0f,0.0f,1.0f},ch->editable_state.spacial_falloff);
356 ch->editable_state.lfo = NULL;
357 ch->editable_state.lfo_amount = 0.0f;
358 ch->editable_state.sampling_rate = 1.0f;
359 ch->editble_state_write_mask = 0x00;
360 }
361
362 static void audio_channel_group( audio_channel *ch, u16 group )
363 {
364 ch->group = group;
365 ch->colour = (((u32)group * 29986577) & 0x00ffffff) | 0xff000000;
366 }
367
368 static void audio_channel_world( audio_channel *ch, u8 world_id )
369 {
370 ch->world_id = world_id;
371 }
372
373 static audio_channel *audio_get_first_idle_channel(void)
374 {
375 for( int i=0; i<AUDIO_CHANNELS; i++ ){
376 audio_channel *ch = &vg_audio.channels[i];
377
378 if( !ch->allocated ){
379 return ch;
380 }
381 }
382
383 return NULL;
384 }
385
386 static audio_channel *audio_get_group_idle_channel( u16 group, u32 max_count )
387 {
388 u32 count = 0;
389 audio_channel *dest = NULL;
390
391 for( int i=0; i<AUDIO_CHANNELS; i++ ){
392 audio_channel *ch = &vg_audio.channels[i];
393
394 if( ch->allocated ){
395 if( ch->group == group ){
396 count ++;
397 }
398 }
399 else{
400 if( !dest )
401 dest = ch;
402 }
403 }
404
405 if( dest && (count < max_count) ){
406 return dest;
407 }
408
409 return NULL;
410 }
411
412 static audio_channel *audio_get_group_first_active_channel( u16 group )
413 {
414 for( int i=0; i<AUDIO_CHANNELS; i++ ){
415 audio_channel *ch = &vg_audio.channels[i];
416 if( ch->allocated && (ch->group == group) )
417 return ch;
418 }
419 return NULL;
420 }
421
422 static int audio_channel_finished( audio_channel *ch )
423 {
424 if( ch->readable_activity == k_channel_activity_end )
425 return 1;
426 else
427 return 0;
428 }
429
430 static audio_channel *audio_relinquish_channel( audio_channel *ch )
431 {
432 ch->editable_state.relinquished = 1;
433 ch->editble_state_write_mask |= AUDIO_EDIT_OWNERSHIP;
434 return NULL;
435 }
436
437 static void audio_channel_slope_volume( audio_channel *ch, float length,
438 float new_volume )
439 {
440 ch->editable_state.volume_target = new_volume;
441 ch->editable_state.volume_rate = length * 44100.0f;
442 ch->editble_state_write_mask |= AUDIO_EDIT_VOLUME_SLOPE;
443 }
444
445 static void audio_channel_set_sampling_rate( audio_channel *ch, float rate )
446 {
447 ch->editable_state.sampling_rate = rate;
448 ch->editble_state_write_mask |= AUDIO_EDIT_SAMPLING_RATE;
449 }
450
451 static void audio_channel_edit_volume( audio_channel *ch,
452 float new_volume, int instant )
453 {
454 if( instant ){
455 ch->editable_state.volume = new_volume;
456 ch->editble_state_write_mask |= AUDIO_EDIT_VOLUME;
457 }
458 else{
459 audio_channel_slope_volume( ch, 0.05f, new_volume );
460 }
461 }
462
463 static audio_channel *audio_channel_fadeout( audio_channel *ch, float length )
464 {
465 audio_channel_slope_volume( ch, length, 0.0f );
466 return audio_relinquish_channel( ch );
467 }
468
469 static void audio_channel_fadein( audio_channel *ch, float length )
470 {
471 audio_channel_edit_volume( ch, 0.0f, 1 );
472 audio_channel_slope_volume( ch, length, 1.0f );
473 }
474
475 static audio_channel *audio_channel_crossfade( audio_channel *ch,
476 audio_clip *new_clip,
477 float length, u32 flags )
478 {
479 u32 cursor = 0;
480
481 if( ch )
482 ch = audio_channel_fadeout( ch, length );
483
484 audio_channel *replacement = audio_get_first_idle_channel();
485
486 if( replacement ){
487 audio_channel_init( replacement, new_clip, flags );
488 audio_channel_fadein( replacement, length );
489 }
490
491 return replacement;
492 }
493
494 static void audio_channel_sidechain_lfo( audio_channel *ch, int lfo_id,
495 float amount )
496 {
497 ch->editable_state.lfo = &vg_audio.oscillators[ lfo_id ];
498 ch->editable_state.lfo_amount = amount;
499 ch->editble_state_write_mask |= AUDIO_EDIT_LFO_ATTACHMENT;
500 }
501
502 static void audio_channel_set_spacial( audio_channel *ch, v3f co, float range )
503 {
504 if( ch->flags & AUDIO_FLAG_SPACIAL_3D ){
505 v3_copy( co, ch->editable_state.spacial_falloff );
506
507 if( range == 0.0f )
508 ch->editable_state.spacial_falloff[3] = 1.0f;
509 else
510 ch->editable_state.spacial_falloff[3] = 1.0f/range;
511
512 ch->editble_state_write_mask |= AUDIO_EDIT_SPACIAL;
513 }
514 else{
515 vg_warn( "Tried to set spacialization paramaters for 2D channel (%s)\n",
516 ch->name );
517 }
518 }
519
520 static int audio_oneshot_3d( audio_clip *clip, v3f position,
521 float range, float volume )
522 {
523 audio_channel *ch = audio_get_first_idle_channel();
524
525 if( ch ){
526 audio_channel_init( ch, clip, AUDIO_FLAG_SPACIAL_3D );
527 audio_channel_set_spacial( ch, position, range );
528 audio_channel_edit_volume( ch, volume, 1 );
529 ch = audio_relinquish_channel( ch );
530
531 return 1;
532 }
533 else
534 return 0;
535 }
536
537 static int audio_oneshot( audio_clip *clip, float volume, float pan )
538 {
539 audio_channel *ch = audio_get_first_idle_channel();
540
541 if( ch ){
542 audio_channel_init( ch, clip, 0x00 );
543 audio_channel_edit_volume( ch, volume, 1 );
544 ch = audio_relinquish_channel( ch );
545
546 return 1;
547 }
548 else
549 return 0;
550 }
551
552 static void audio_set_lfo_wave( int id, enum lfo_wave_type type,
553 float coefficient )
554 {
555 audio_lfo *lfo = &vg_audio.oscillators[ id ];
556 lfo->editable_state.polynomial_coefficient = coefficient;
557 lfo->editable_state.wave_type = type;
558
559 lfo->editble_state_write_mask |= AUDIO_EDIT_LFO_WAVE;
560 }
561
562 static void audio_set_lfo_frequency( int id, float freq )
563 {
564 audio_lfo *lfo = &vg_audio.oscillators[ id ];
565 lfo->editable_state.period = 44100.0f / freq;
566 lfo->editble_state_write_mask |= AUDIO_EDIT_LFO_PERIOD;
567 }
568
569
570 /*
571 * Committers
572 * -----------------------------------------------------------------------------
573 */
574 static int audio_channel_load_source( audio_channel *ch )
575 {
576 u32 format = ch->source->flags & AUDIO_FLAG_FORMAT;
577
578 if( format == k_audio_format_vorbis ){
579 /* Setup vorbis decoder */
580 u32 index = ch - vg_audio.channels;
581
582 u8 *buf = (u8*)vg_audio.decode_buffer,
583 *loc = &buf[AUDIO_DECODE_SIZE*index];
584
585 stb_vorbis_alloc alloc = {
586 .alloc_buffer = (char *)loc,
587 .alloc_buffer_length_in_bytes = AUDIO_DECODE_SIZE
588 };
589
590 int err;
591 stb_vorbis *decoder = stb_vorbis_open_memory(
592 ch->source->data,
593 ch->source->size, &err, &alloc );
594
595 if( !decoder ){
596 vg_error( "stb_vorbis_open_memory failed on '%s' (%d)\n",
597 ch->source->path, err );
598 return 0;
599 }
600 else{
601 ch->source_length = stb_vorbis_stream_length_in_samples( decoder );
602 ch->vorbis_handle = decoder;
603 }
604 }
605 else if( format == k_audio_format_bird ){
606 u32 index = ch - vg_audio.channels;
607
608 u8 *buf = (u8*)vg_audio.decode_buffer;
609 struct synth_bird *loc = (void *)&buf[AUDIO_DECODE_SIZE*index];
610
611 memcpy( loc, ch->source->data, ch->source->size );
612 synth_bird_reset( loc );
613
614 ch->bird_handle = loc;
615 ch->source_length = synth_bird_get_length_in_samples( loc );
616 }
617 else if( format == k_audio_format_stereo ){
618 ch->source_length = ch->source->size / 2;
619 }
620 else{
621 ch->source_length = ch->source->size;
622 }
623
624 return 1;
625 }
626
627 VG_STATIC void audio_decode_uncompressed_mono( i16 *src, u32 count, float *dst )
628 {
629 for( u32 i=0; i<count; i++ ){
630 dst[ i*2 + 0 ] = ((float)src[i]) * (1.0f/32767.0f);
631 dst[ i*2 + 1 ] = ((float)src[i]) * (1.0f/32767.0f);
632 }
633 }
634
635 /*
636 * adapted from stb_vorbis.h, since the original does not handle mono->stereo
637 */
638 VG_STATIC int
639 stb_vorbis_get_samples_float_interleaved_stereo( stb_vorbis *f, float *buffer,
640 int len )
641 {
642 int n = 0,
643 c = VG_MIN( 1, f->channels - 1 );
644
645 while( n < len ) {
646 int k = f->channel_buffer_end - f->channel_buffer_start;
647
648 if( n+k >= len )
649 k = len - n;
650
651 for( int j=0; j < k; ++j ) {
652 *buffer++ = f->channel_buffers[ 0 ][f->channel_buffer_start+j];
653 *buffer++ = f->channel_buffers[ c ][f->channel_buffer_start+j];
654 }
655
656 n += k;
657 f->channel_buffer_start += k;
658
659 if( n == len )
660 break;
661
662 if( !stb_vorbis_get_frame_float( f, NULL, NULL ))
663 break;
664 }
665
666 return n;
667 }
668
669 /*
670 * ........ more wrecked code sorry!
671 */
672 VG_STATIC int
673 stb_vorbis_get_samples_i16_downmixed( stb_vorbis *f, i16 *buffer, int len )
674 {
675 int n = 0,
676 c = VG_MIN( 1, f->channels - 1 );
677
678 while( n < len ) {
679 int k = f->channel_buffer_end - f->channel_buffer_start;
680
681 if( n+k >= len )
682 k = len - n;
683
684 for( int j=0; j < k; ++j ) {
685 float sl = f->channel_buffers[ 0 ][f->channel_buffer_start+j],
686 sr = f->channel_buffers[ c ][f->channel_buffer_start+j];
687
688 *buffer++ = vg_clampf( 0.5f*(sl+sr), -1.0f, 1.0f ) * 32767.0f;
689 //*buffer++ = vg_clampf( sr, -1.0f, 1.0f ) * 32767.0f;
690 }
691
692 n += k;
693 f->channel_buffer_start += k;
694
695 if( n == len )
696 break;
697
698 if( !stb_vorbis_get_frame_float( f, NULL, NULL ))
699 break;
700 }
701
702 return n;
703 }
704
705 static inline float audio_lfo_pull_sample( audio_lfo *lfo )
706 {
707 lfo->time ++;
708
709 if( lfo->time >= lfo->_.period )
710 lfo->time = 0;
711
712 float t = lfo->time;
713 t /= (float)lfo->_.period;
714
715 if( lfo->_.wave_type == k_lfo_polynomial_bipolar ){
716 /*
717 * #
718 * # #
719 * # #
720 * # #
721 * ### # ###
722 * ## #
723 * # #
724 * # #
725 * ##
726 */
727
728 t *= 2.0f;
729 t -= 1.0f;
730
731 return (( 2.0f * lfo->sqrt_polynomial_coefficient * t ) /
732 /* --------------------------------------- */
733 ( 1.0f + lfo->_.polynomial_coefficient * t*t )
734
735 ) * (1.0f-fabsf(t));
736 }
737 else{
738 return 0.0f;
739 }
740 }
741
742 static void audio_channel_get_samples( audio_channel *ch,
743 u32 count, float *buf )
744 {
745 vg_profile_begin( &_vg_prof_audio_decode );
746
747 u32 remaining = count;
748 u32 buffer_pos = 0;
749
750 u32 format = ch->source->flags & AUDIO_FLAG_FORMAT;
751
752 while( remaining ){
753 u32 samples_this_run = VG_MIN(remaining, ch->source_length - ch->cursor);
754 remaining -= samples_this_run;
755
756 float *dst = &buf[ buffer_pos * 2 ];
757
758 if( format == k_audio_format_stereo ){
759 for( int i=0;i<samples_this_run; i++ ){
760 dst[i*2+0] = 0.0f;
761 dst[i*2+1] = 0.0f;
762 }
763 }
764 else if( format == k_audio_format_vorbis ){
765 int read_samples = stb_vorbis_get_samples_float_interleaved_stereo(
766 ch->vorbis_handle,
767 dst,
768 samples_this_run );
769
770 if( read_samples != samples_this_run ){
771 vg_warn( "Invalid samples read (%s)\n", ch->source->path );
772
773 for( int i=0; i<samples_this_run; i++ ){
774 dst[i*2+0] = 0.0f;
775 dst[i*2+1] = 0.0f;
776 }
777 }
778 }
779 else if( format == k_audio_format_bird ){
780 synth_bird_generate_samples( ch->bird_handle, dst, samples_this_run );
781 }
782 else{
783 i16 *src_buffer = ch->source->data,
784 *src = &src_buffer[ch->cursor];
785
786 audio_decode_uncompressed_mono( src, samples_this_run, dst );
787 }
788
789 ch->cursor += samples_this_run;
790 buffer_pos += samples_this_run;
791
792 if( (ch->flags & AUDIO_FLAG_LOOP) && remaining ){
793 if( format == k_audio_format_vorbis )
794 stb_vorbis_seek_start( ch->vorbis_handle );
795 else if( format == k_audio_format_bird )
796 synth_bird_reset( ch->bird_handle );
797
798 ch->cursor = 0;
799 continue;
800 }
801 else
802 break;
803 }
804
805 while( remaining ){
806 buf[ buffer_pos*2 + 0 ] = 0.0f;
807 buf[ buffer_pos*2 + 1 ] = 0.0f;
808 buffer_pos ++;
809
810 remaining --;
811 }
812
813 vg_profile_end( &_vg_prof_audio_decode );
814 }
815
816 static void audio_channel_mix( audio_channel *ch, float *buffer )
817 {
818 float framevol_l = vg_audio.internal_global_volume,
819 framevol_r = vg_audio.internal_global_volume;
820
821 float frame_samplerate = ch->_.sampling_rate;
822
823 if( ch->flags & AUDIO_FLAG_SPACIAL_3D ){
824 v3f delta;
825 v3_sub( ch->_.spacial_falloff, vg_audio.internal_listener_pos, delta );
826
827 float dist = v3_length( delta ),
828 vol = vg_maxf( 0.0f, 1.0f - ch->_.spacial_falloff[3]*dist );
829
830 if( dist <= 0.01f ){
831
832 }
833 else{
834 v3_muls( delta, 1.0f/dist, delta );
835 float pan = v3_dot( vg_audio.internal_listener_ears, delta );
836 vol = powf( vol, 5.0f );
837
838 framevol_l *= (vol * 0.5f) * (1.0f - pan);
839 framevol_r *= (vol * 0.5f) * (1.0f + pan);
840
841 if( !(ch->source->flags & AUDIO_FLAG_NO_DOPPLER) ){
842 const float vs = 323.0f;
843
844 float dv = v3_dot(delta,vg_audio.internal_listener_velocity);
845 float doppler = (vs+dv)/vs;
846 doppler = vg_clampf( doppler, 0.6f, 1.4f );
847
848 if( fabsf(doppler-1.0f) > 0.01f )
849 frame_samplerate *= doppler;
850 }
851 }
852
853 if( !vg_validf( framevol_l ) ||
854 !vg_validf( framevol_r ) ||
855 !vg_validf( frame_samplerate ) ){
856 vg_fatal_error( "Invalid sampling conditions.\n"
857 "This crash is to protect your ears.\n"
858 " channel: %p (%s)\n"
859 " sample_rate: %f\n"
860 " volume: L%f R%f\n"
861 " listener: %.2f %.2f %.2f [%.2f %.2f %.2f]\n",
862 ch, ch->name, frame_samplerate,
863 framevol_l, framevol_r,
864 vg_audio.internal_listener_pos[0],
865 vg_audio.internal_listener_pos[1],
866 vg_audio.internal_listener_pos[2],
867 vg_audio.internal_listener_ears[0],
868 vg_audio.internal_listener_ears[1],
869 vg_audio.internal_listener_ears[2]
870 );
871 }
872 }
873
874 u32 buffer_length = AUDIO_MIX_FRAME_SIZE;
875 if( frame_samplerate != 1.0f ){
876 float l = ceilf( (float)(AUDIO_MIX_FRAME_SIZE) * frame_samplerate );
877 buffer_length = l+1;
878 }
879
880 float pcf[ AUDIO_MIX_FRAME_SIZE * 2 * 2 ];
881
882 audio_channel_get_samples( ch, buffer_length, pcf );
883
884 vg_profile_begin( &_vg_prof_audio_mix );
885
886 float volume_movement = ch->volume_movement;
887 float const fvolume_rate = vg_maxf( 1.0f, ch->_.volume_rate );
888 const float inv_volume_rate = 1.0f/fvolume_rate;
889
890 float volume = ch->_.volume;
891 const float volume_start = ch->volume_movement_start;
892 const float volume_target = ch->_.volume_target;
893
894 for( u32 j=0; j<AUDIO_MIX_FRAME_SIZE; j++ ){
895 volume_movement += 1.0f;
896 float movement_t = volume_movement * inv_volume_rate;
897 movement_t = vg_minf( movement_t, 1.0f );
898 volume = vg_lerpf( volume_start, volume_target, movement_t );
899
900 float vol_norm = volume * volume;
901
902 if( ch->_.lfo )
903 vol_norm *= 1.0f + audio_lfo_pull_sample(ch->_.lfo) * ch->_.lfo_amount;
904
905 float vol_l = vol_norm * framevol_l,
906 vol_r = vol_norm * framevol_r,
907 sample_l,
908 sample_r;
909
910 if( frame_samplerate != 1.0f ){
911 /* absolutely garbage resampling, but it will do
912 */
913
914 float sample_index = frame_samplerate * (float)j;
915 float t = vg_fractf( sample_index );
916
917 u32 i0 = floorf( sample_index ),
918 i1 = i0+1;
919
920 sample_l = pcf[ i0*2+0 ]*(1.0f-t) + pcf[ i1*2+0 ]*t;
921 sample_r = pcf[ i0*2+1 ]*(1.0f-t) + pcf[ i1*2+1 ]*t;
922 }
923 else{
924 sample_l = pcf[ j*2+0 ];
925 sample_r = pcf[ j*2+1 ];
926 }
927
928 buffer[ j*2+0 ] += sample_l * vol_l;
929 buffer[ j*2+1 ] += sample_r * vol_r;
930 }
931
932 ch->volume_movement += AUDIO_MIX_FRAME_SIZE;
933 ch->volume_movement = VG_MIN( ch->volume_movement, ch->_.volume_rate );
934 ch->_.volume = volume;
935
936 vg_profile_end( &_vg_prof_audio_mix );
937 }
938
939 VG_STATIC void audio_mixer_callback( void *user, u8 *stream, int byte_count )
940 {
941 /*
942 * Copy data and move edit flags to commit flags
943 * ------------------------------------------------------------- */
944 audio_lock();
945
946 v3_copy( vg_audio.external_listener_pos, vg_audio.internal_listener_pos );
947 v3_copy( vg_audio.external_listener_ears, vg_audio.internal_listener_ears );
948 v3_copy( vg_audio.external_lister_velocity,
949 vg_audio.internal_listener_velocity );
950 vg_audio.internal_global_volume = vg_audio.external_global_volume;
951
952 for( int i=0; i<AUDIO_CHANNELS; i++ ){
953 audio_channel *ch = &vg_audio.channels[i];
954
955 if( !ch->allocated )
956 continue;
957
958 if( ch->activity == k_channel_activity_alive ){
959 if( (ch->cursor >= ch->source_length) &&
960 !(ch->flags & AUDIO_FLAG_LOOP) )
961 {
962 ch->activity = k_channel_activity_end;
963 }
964 }
965
966 /* process relinquishments */
967 if( (ch->activity != k_channel_activity_reset) && ch->_.relinquished ){
968 if( (ch->activity == k_channel_activity_end)
969 || (ch->_.volume == 0.0f)
970 || (ch->activity == k_channel_activity_error) )
971 {
972 ch->_.relinquished = 0;
973 ch->allocated = 0;
974 ch->activity = k_channel_activity_reset;
975 continue;
976 }
977 }
978
979 /* process new channels */
980 if( ch->activity == k_channel_activity_reset ){
981 ch->_ = ch->editable_state;
982 ch->cursor = 0;
983 ch->source_length = 0;
984 ch->activity = k_channel_activity_wake;
985 }
986
987 if( ch->editble_state_write_mask & AUDIO_EDIT_OWNERSHIP )
988 ch->_.relinquished = ch->editable_state.relinquished;
989 else
990 ch->editable_state.relinquished = ch->_.relinquished;
991
992
993 if( ch->editble_state_write_mask & AUDIO_EDIT_VOLUME ){
994 ch->_.volume = ch->editable_state.volume;
995 ch->_.volume_target = ch->editable_state.volume;
996 }
997 else{
998 ch->editable_state.volume = ch->_.volume;
999 }
1000
1001
1002 if( ch->editble_state_write_mask & AUDIO_EDIT_VOLUME_SLOPE ){
1003 ch->volume_movement_start = ch->_.volume;
1004 ch->volume_movement = 0;
1005
1006 ch->_.volume_target = ch->editable_state.volume_target;
1007 ch->_.volume_rate = ch->editable_state.volume_rate;
1008 }
1009 else{
1010 ch->editable_state.volume_target = ch->_.volume_target;
1011 ch->editable_state.volume_rate = ch->_.volume_rate;
1012 }
1013
1014
1015 if( ch->editble_state_write_mask & AUDIO_EDIT_SAMPLING_RATE )
1016 ch->_.sampling_rate = ch->editable_state.sampling_rate;
1017 else
1018 ch->editable_state.sampling_rate = ch->_.sampling_rate;
1019
1020
1021 if( ch->editble_state_write_mask & AUDIO_EDIT_LFO_ATTACHMENT ){
1022 ch->_.lfo = ch->editable_state.lfo;
1023 ch->_.lfo_amount = ch->editable_state.lfo_amount;
1024 }
1025 else{
1026 ch->editable_state.lfo = ch->_.lfo;
1027 ch->editable_state.lfo_amount = ch->_.lfo_amount;
1028 }
1029
1030
1031 if( ch->editble_state_write_mask & AUDIO_EDIT_SPACIAL )
1032 v4_copy( ch->editable_state.spacial_falloff,ch->_.spacial_falloff );
1033 else
1034 v4_copy( ch->_.spacial_falloff,ch->editable_state.spacial_falloff );
1035
1036
1037 /* currently readonly, i guess */
1038 ch->editable_state.pan_target = ch->_.pan_target;
1039 ch->editable_state.pan = ch->_.pan;
1040 ch->editble_state_write_mask = 0x00;
1041 }
1042
1043 for( int i=0; i<AUDIO_LFOS; i++ ){
1044 audio_lfo *lfo = &vg_audio.oscillators[ i ];
1045
1046 if( lfo->editble_state_write_mask & AUDIO_EDIT_LFO_WAVE ){
1047 lfo->_.wave_type = lfo->editable_state.wave_type;
1048
1049 if( lfo->_.wave_type == k_lfo_polynomial_bipolar ){
1050 lfo->_.polynomial_coefficient =
1051 lfo->editable_state.polynomial_coefficient;
1052 lfo->sqrt_polynomial_coefficient =
1053 sqrtf(lfo->_.polynomial_coefficient);
1054 }
1055 }
1056
1057 if( lfo->editble_state_write_mask & AUDIO_EDIT_LFO_PERIOD ){
1058 if( lfo->_.period ){
1059 float t = lfo->time;
1060 t/= (float)lfo->_.period;
1061
1062 lfo->_.period = lfo->editable_state.period;
1063 lfo->time = lfo->_.period * t;
1064 }
1065 else{
1066 lfo->time = 0;
1067 lfo->_.period = lfo->editable_state.period;
1068 }
1069 }
1070
1071 lfo->editble_state_write_mask = 0x00;
1072 }
1073
1074 dsp_update_tunings();
1075 audio_unlock();
1076
1077 /*
1078 * Process spawns
1079 * ------------------------------------------------------------- */
1080 for( int i=0; i<AUDIO_CHANNELS; i++ ){
1081 audio_channel *ch = &vg_audio.channels[i];
1082
1083 if( ch->activity == k_channel_activity_wake ){
1084 if( audio_channel_load_source( ch ) )
1085 ch->activity = k_channel_activity_alive;
1086 else
1087 ch->activity = k_channel_activity_error;
1088 }
1089 }
1090
1091 /*
1092 * Mix everything
1093 * -------------------------------------------------------- */
1094 int frame_count = byte_count/(2*sizeof(float));
1095
1096 /* Clear buffer */
1097 float *pOut32F = (float *)stream;
1098 for( int i=0; i<frame_count*2; i ++ )
1099 pOut32F[i] = 0.0f;
1100
1101 for( int i=0; i<AUDIO_LFOS; i++ ){
1102 audio_lfo *lfo = &vg_audio.oscillators[i];
1103 lfo->time_startframe = lfo->time;
1104 }
1105
1106 for( int i=0; i<AUDIO_CHANNELS; i ++ ){
1107 audio_channel *ch = &vg_audio.channels[i];
1108
1109 if( ch->activity == k_channel_activity_alive ){
1110 if( ch->_.lfo )
1111 ch->_.lfo->time = ch->_.lfo->time_startframe;
1112
1113 u32 remaining = frame_count,
1114 subpos = 0;
1115
1116 while( remaining ){
1117 audio_channel_mix( ch, pOut32F+subpos );
1118 remaining -= AUDIO_MIX_FRAME_SIZE;
1119 subpos += AUDIO_MIX_FRAME_SIZE*2;
1120 }
1121 }
1122 }
1123
1124 vg_profile_begin( &_vg_prof_dsp );
1125
1126 for( int i=0; i<frame_count; i++ )
1127 vg_dsp_process( pOut32F + i*2, pOut32F + i*2 );
1128
1129 vg_profile_end( &_vg_prof_dsp );
1130
1131 audio_lock();
1132
1133 for( int i=0; i<AUDIO_CHANNELS; i ++ ){
1134 audio_channel *ch = &vg_audio.channels[i];
1135 ch->readable_activity = ch->activity;
1136 }
1137
1138 /* Profiling information
1139 * ----------------------------------------------- */
1140 vg_profile_increment( &_vg_prof_audio_decode );
1141 vg_profile_increment( &_vg_prof_audio_mix );
1142 vg_profile_increment( &_vg_prof_dsp );
1143
1144 vg_prof_audio_mix = _vg_prof_audio_mix;
1145 vg_prof_audio_decode = _vg_prof_audio_decode;
1146 vg_prof_audio_dsp = _vg_prof_dsp;
1147
1148 vg_audio.samples_last = frame_count;
1149
1150 if( vg_audio.debug_dsp ){
1151 vg_dsp_update_texture();
1152 }
1153
1154 audio_unlock();
1155 }
1156
1157 VG_STATIC void audio_clip_load( audio_clip *clip, void *lin_alloc )
1158 {
1159 if( lin_alloc == NULL )
1160 lin_alloc = vg_audio.audio_pool;
1161
1162 /* load in directly */
1163 u32 format = clip->flags & AUDIO_FLAG_FORMAT;
1164
1165 /* TODO: This contains audio_lock() and unlock, but i don't know why
1166 * can probably remove them. Low priority to check this */
1167
1168 /* TODO: packed files for vorbis etc, should take from data if its not not
1169 * NULL when we get the clip
1170 */
1171
1172 if( format == k_audio_format_vorbis ){
1173 if( !clip->path ){
1174 vg_fatal_error( "No path specified, embeded vorbis unsupported" );
1175 }
1176
1177 audio_lock();
1178 clip->data = vg_file_read( lin_alloc, clip->path, &clip->size );
1179 audio_unlock();
1180
1181 if( !clip->data )
1182 vg_fatal_error( "Audio failed to load" );
1183
1184 float mb = (float)(clip->size) / (1024.0f*1024.0f);
1185 vg_info( "Loaded audio clip '%s' (%.1fmb)\n", clip->path, mb );
1186 }
1187 else if( format == k_audio_format_stereo ){
1188 vg_fatal_error( "Unsupported format (Stereo uncompressed)" );
1189 }
1190 else if( format == k_audio_format_bird ){
1191 if( !clip->data ){
1192 vg_fatal_error( "No data, external birdsynth unsupported" );
1193 }
1194
1195 u32 total_size = clip->size + sizeof(struct synth_bird);
1196 total_size -= sizeof(struct synth_bird_settings);
1197 total_size = vg_align8( total_size );
1198
1199 if( total_size > AUDIO_DECODE_SIZE )
1200 vg_fatal_error( "Bird coding too long\n" );
1201
1202 struct synth_bird *bird = vg_linear_alloc( lin_alloc, total_size );
1203 memcpy( &bird->settings, clip->data, clip->size );
1204
1205 clip->data = bird;
1206 clip->size = total_size;
1207
1208 vg_info( "Loaded bird synthesis pattern (%u bytes)\n", total_size );
1209 }
1210 else{
1211 if( !clip->path ){
1212 vg_fatal_error( "No path specified, embeded mono unsupported" );
1213 }
1214
1215 vg_linear_clear( vg_mem.scratch );
1216 u32 fsize;
1217
1218 stb_vorbis_alloc alloc = {
1219 .alloc_buffer = vg_linear_alloc( vg_mem.scratch, AUDIO_DECODE_SIZE ),
1220 .alloc_buffer_length_in_bytes = AUDIO_DECODE_SIZE
1221 };
1222
1223 void *filedata = vg_file_read( vg_mem.scratch, clip->path, &fsize );
1224
1225 int err;
1226 stb_vorbis *decoder = stb_vorbis_open_memory(
1227 filedata, fsize, &err, &alloc );
1228
1229 if( !decoder ){
1230 vg_error( "stb_vorbis_open_memory failed on '%s' (%d)\n",
1231 clip->path, err );
1232 vg_fatal_error( "Vorbis decode error" );
1233 }
1234
1235 /* only mono is supported in uncompressed */
1236 u32 length_samples = stb_vorbis_stream_length_in_samples( decoder ),
1237 data_size = length_samples * sizeof(i16);
1238
1239 audio_lock();
1240 clip->data = vg_linear_alloc( lin_alloc, vg_align8(data_size) );
1241 clip->size = length_samples;
1242 audio_unlock();
1243
1244 int read_samples = stb_vorbis_get_samples_i16_downmixed(
1245 decoder, clip->data, length_samples );
1246
1247 if( read_samples != length_samples )
1248 vg_fatal_error( "Decode error" );
1249
1250 float mb = (float)(data_size) / (1024.0f*1024.0f);
1251 vg_info( "Loaded audio clip '%s' (%.1fmb) %u samples\n", clip->path, mb,
1252 length_samples );
1253 }
1254 }
1255
1256 VG_STATIC void audio_clip_loadn( audio_clip *arr, int count, void *lin_alloc )
1257 {
1258 for( int i=0; i<count; i++ )
1259 audio_clip_load( &arr[i], lin_alloc );
1260 }
1261
1262 VG_STATIC void audio_require_clip_loaded( audio_clip *clip )
1263 {
1264 if( clip->data && clip->size )
1265 return;
1266
1267 audio_unlock();
1268 vg_fatal_error( "Must load audio clip before playing! \n" );
1269 }
1270
1271 /*
1272 * Debugging
1273 */
1274
1275 VG_STATIC void audio_debug_ui( m4x4f mtx_pv )
1276 {
1277 if( !vg_audio.debug_ui )
1278 return;
1279
1280 audio_lock();
1281
1282 glBindTexture( GL_TEXTURE_2D, vg_dsp.view_texture );
1283 glTexSubImage2D( GL_TEXTURE_2D, 0, 0, 0, 256, 256,
1284 GL_RGBA, GL_UNSIGNED_BYTE,
1285 vg_dsp.view_texture_buffer );
1286
1287 /*
1288 * Profiler
1289 * -----------------------------------------------------------------------
1290 */
1291
1292 float budget = ((double)vg_audio.samples_last / 44100.0) * 1000.0;
1293 #if 0
1294 vg_profile_drawn( (struct vg_profile *[]){ &vg_prof_audio_decode,
1295 &vg_prof_audio_mix,
1296 &vg_prof_audio_dsp}, 3,
1297 budget, (ui_rect){ 4, VG_PROFILE_SAMPLE_COUNT*2 + 8,
1298 512, 0 }, 3 );
1299 #endif
1300
1301
1302 char perf[128];
1303
1304 /* Draw UI */
1305 ui_rect window = {
1306 0,
1307 0,
1308 800,
1309 AUDIO_CHANNELS * 18
1310 };
1311
1312 if( vg_audio.debug_dsp ){
1313 ui_rect view_thing = { 4, vg.window_y-512-4, 512, 512 };
1314 ui_image( view_thing, vg_dsp.view_texture );
1315 }
1316
1317 ui_rect overlap_buffer[ AUDIO_CHANNELS ];
1318 u32 overlap_length = 0;
1319
1320 /* Draw audio stack */
1321 for( int i=0; i<AUDIO_CHANNELS; i ++ ){
1322 audio_channel *ch = &vg_audio.channels[i];
1323
1324 ui_rect row;
1325 ui_split( window, k_ui_axis_h, 18, 1, row, window );
1326
1327 if( !ch->allocated ){
1328 ui_fill( row, 0x50333333 );
1329 continue;
1330 }
1331
1332 const char *formats[] =
1333 {
1334 " mono ",
1335 " stereo ",
1336 " vorbis ",
1337 " none0 ",
1338 " none1 ",
1339 " none2 ",
1340 " none3 ",
1341 " none4 ",
1342 "synth:bird",
1343 " none5 ",
1344 " none6 ",
1345 " none7 ",
1346 " none8 ",
1347 " none9 ",
1348 " none10 ",
1349 " none11 ",
1350 };
1351
1352 const char *activties[] =
1353 {
1354 "reset",
1355 "wake ",
1356 "alive",
1357 "end ",
1358 "error"
1359 };
1360
1361 u32 format_index = (ch->source->flags & AUDIO_FLAG_FORMAT)>>9;
1362
1363 snprintf( perf, 127, "%02d[%#04x.%#06x]%c%c%cD %s [%s] %4.2fv'%s'",
1364 i,
1365 ch->world_id, ch->group,
1366 (ch->editable_state.relinquished)? 'r': '_',
1367 0? 'r': '_',
1368 0? '3': '2',
1369 formats[format_index],
1370 activties[ch->readable_activity],
1371 ch->editable_state.volume,
1372 ch->name );
1373
1374 ui_fill( row, 0xa0000000 | ch->colour );
1375 ui_text( row, perf, 1, k_ui_align_middle_left, 0 );
1376
1377 if( AUDIO_FLAG_SPACIAL_3D ){
1378 v4f wpos;
1379 v3_copy( ch->editable_state.spacial_falloff, wpos );
1380
1381 wpos[3] = 1.0f;
1382 m4x4_mulv( mtx_pv, wpos, wpos );
1383
1384 if( wpos[3] > 0.0f ){
1385 v2_muls( wpos, (1.0f/wpos[3]) * 0.5f, wpos );
1386 v2_add( wpos, (v2f){ 0.5f, 0.5f }, wpos );
1387
1388 ui_rect wr;
1389 wr[0] = vg_clampf(wpos[0] * vg.window_x, -32000.0f,32000.0f);
1390 wr[1] = vg_clampf((1.0f-wpos[1]) * vg.window_y,-32000.0f,32000.0f);
1391 wr[2] = 1000;
1392 wr[3] = 17;
1393
1394 for( int j=0; j<12; j++ ){
1395 int collide = 0;
1396 for( int k=0; k<overlap_length; k++ ){
1397 ui_px *wk = overlap_buffer[k];
1398 if( ((wr[0] <= wk[0]+wk[2]) && (wr[0]+wr[2] >= wk[0])) &&
1399 ((wr[1] <= wk[1]+wk[3]) && (wr[1]+wr[3] >= wk[1])) )
1400 {
1401 collide = 1;
1402 break;
1403 }
1404 }
1405
1406 if( !collide )
1407 break;
1408 else
1409 wr[1] += 18;
1410 }
1411
1412 ui_text( wr, perf, 1, k_ui_align_middle_left, 0 );
1413 rect_copy( wr, overlap_buffer[ overlap_length ++ ] );
1414 }
1415 }
1416 }
1417
1418 audio_unlock();
1419 }
1420
1421 #endif /* VG_AUDIO_H */
Voyager Game Engine