projects / vg.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
terrible!
[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 static 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 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 ) ) vg_fatal_error( "NaN left channel" );
854 if( !vg_validf( framevol_r ) ) vg_fatal_error( "NaN right channel" );
855 if( !vg_validf( frame_samplerate ) )
856 vg_fatal_error( "NaN sample rate" );
857 }
858
859 u32 buffer_length = AUDIO_MIX_FRAME_SIZE;
860 if( frame_samplerate != 1.0f ){
861 float l = ceilf( (float)(AUDIO_MIX_FRAME_SIZE) * frame_samplerate );
862 buffer_length = l+1;
863 }
864
865 float pcf[ AUDIO_MIX_FRAME_SIZE * 2 * 2 ];
866
867 audio_channel_get_samples( ch, buffer_length, pcf );
868
869 vg_profile_begin( &_vg_prof_audio_mix );
870
871 float volume_movement = ch->volume_movement;
872 float const fvolume_rate = vg_maxf( 1.0f, ch->_.volume_rate );
873 const float inv_volume_rate = 1.0f/fvolume_rate;
874
875 float volume = ch->_.volume;
876 const float volume_start = ch->volume_movement_start;
877 const float volume_target = ch->_.volume_target;
878
879 for( u32 j=0; j<AUDIO_MIX_FRAME_SIZE; j++ ){
880 volume_movement += 1.0f;
881 float movement_t = volume_movement * inv_volume_rate;
882 movement_t = vg_minf( movement_t, 1.0f );
883 volume = vg_lerpf( volume_start, volume_target, movement_t );
884
885 float vol_norm = volume * volume;
886
887 if( ch->_.lfo )
888 vol_norm *= 1.0f + audio_lfo_pull_sample(ch->_.lfo) * ch->_.lfo_amount;
889
890 float vol_l = vol_norm * framevol_l,
891 vol_r = vol_norm * framevol_r,
892 sample_l,
893 sample_r;
894
895 if( frame_samplerate != 1.0f ){
896 /* absolutely garbage resampling, but it will do
897 */
898
899 float sample_index = frame_samplerate * (float)j;
900 float t = vg_fractf( sample_index );
901
902 u32 i0 = floorf( sample_index ),
903 i1 = i0+1;
904
905 sample_l = pcf[ i0*2+0 ]*(1.0f-t) + pcf[ i1*2+0 ]*t;
906 sample_r = pcf[ i0*2+1 ]*(1.0f-t) + pcf[ i1*2+1 ]*t;
907 }
908 else{
909 sample_l = pcf[ j*2+0 ];
910 sample_r = pcf[ j*2+1 ];
911 }
912
913 buffer[ j*2+0 ] += sample_l * vol_l;
914 buffer[ j*2+1 ] += sample_r * vol_r;
915 }
916
917 ch->volume_movement += AUDIO_MIX_FRAME_SIZE;
918 ch->volume_movement = VG_MIN( ch->volume_movement, ch->_.volume_rate );
919 ch->_.volume = volume;
920
921 vg_profile_end( &_vg_prof_audio_mix );
922 }
923
924 VG_STATIC void audio_mixer_callback( void *user, u8 *stream, int byte_count )
925 {
926 /*
927 * Copy data and move edit flags to commit flags
928 * ------------------------------------------------------------- */
929 audio_lock();
930
931 v3_copy( vg_audio.external_listener_pos, vg_audio.internal_listener_pos );
932 v3_copy( vg_audio.external_listener_ears, vg_audio.internal_listener_ears );
933 v3_copy( vg_audio.external_lister_velocity,
934 vg_audio.internal_listener_velocity );
935 vg_audio.internal_global_volume = vg_audio.external_global_volume;
936
937 for( int i=0; i<AUDIO_CHANNELS; i++ ){
938 audio_channel *ch = &vg_audio.channels[i];
939
940 if( !ch->allocated )
941 continue;
942
943 if( ch->activity == k_channel_activity_alive ){
944 if( (ch->cursor >= ch->source_length) &&
945 !(ch->flags & AUDIO_FLAG_LOOP) )
946 {
947 ch->activity = k_channel_activity_end;
948 }
949 }
950
951 /* process relinquishments */
952 if( (ch->activity != k_channel_activity_reset) && ch->_.relinquished ){
953 if( (ch->activity == k_channel_activity_end)
954 || (ch->_.volume == 0.0f)
955 || (ch->activity == k_channel_activity_error) )
956 {
957 ch->_.relinquished = 0;
958 ch->allocated = 0;
959 ch->activity = k_channel_activity_reset;
960 continue;
961 }
962 }
963
964 /* process new channels */
965 if( ch->activity == k_channel_activity_reset ){
966 ch->_ = ch->editable_state;
967 ch->cursor = 0;
968 ch->source_length = 0;
969 ch->activity = k_channel_activity_wake;
970 }
971
972 if( ch->editble_state_write_mask & AUDIO_EDIT_OWNERSHIP )
973 ch->_.relinquished = ch->editable_state.relinquished;
974 else
975 ch->editable_state.relinquished = ch->_.relinquished;
976
977
978 if( ch->editble_state_write_mask & AUDIO_EDIT_VOLUME ){
979 ch->_.volume = ch->editable_state.volume;
980 ch->_.volume_target = ch->editable_state.volume;
981 }
982 else{
983 ch->editable_state.volume = ch->_.volume;
984 }
985
986
987 if( ch->editble_state_write_mask & AUDIO_EDIT_VOLUME_SLOPE ){
988 ch->volume_movement_start = ch->_.volume;
989 ch->volume_movement = 0;
990
991 ch->_.volume_target = ch->editable_state.volume_target;
992 ch->_.volume_rate = ch->editable_state.volume_rate;
993 }
994 else{
995 ch->editable_state.volume_target = ch->_.volume_target;
996 ch->editable_state.volume_rate = ch->_.volume_rate;
997 }
998
999
1000 if( ch->editble_state_write_mask & AUDIO_EDIT_SAMPLING_RATE )
1001 ch->_.sampling_rate = ch->editable_state.sampling_rate;
1002 else
1003 ch->editable_state.sampling_rate = ch->_.sampling_rate;
1004
1005
1006 if( ch->editble_state_write_mask & AUDIO_EDIT_LFO_ATTACHMENT ){
1007 ch->_.lfo = ch->editable_state.lfo;
1008 ch->_.lfo_amount = ch->editable_state.lfo_amount;
1009 }
1010 else{
1011 ch->editable_state.lfo = ch->_.lfo;
1012 ch->editable_state.lfo_amount = ch->_.lfo_amount;
1013 }
1014
1015
1016 if( ch->editble_state_write_mask & AUDIO_EDIT_SPACIAL )
1017 v4_copy( ch->editable_state.spacial_falloff,ch->_.spacial_falloff );
1018 else
1019 v4_copy( ch->_.spacial_falloff,ch->editable_state.spacial_falloff );
1020
1021
1022 /* currently readonly, i guess */
1023 ch->editable_state.pan_target = ch->_.pan_target;
1024 ch->editable_state.pan = ch->_.pan;
1025 ch->editble_state_write_mask = 0x00;
1026 }
1027
1028 for( int i=0; i<AUDIO_LFOS; i++ ){
1029 audio_lfo *lfo = &vg_audio.oscillators[ i ];
1030
1031 if( lfo->editble_state_write_mask & AUDIO_EDIT_LFO_WAVE ){
1032 lfo->_.wave_type = lfo->editable_state.wave_type;
1033
1034 if( lfo->_.wave_type == k_lfo_polynomial_bipolar ){
1035 lfo->_.polynomial_coefficient =
1036 lfo->editable_state.polynomial_coefficient;
1037 lfo->sqrt_polynomial_coefficient =
1038 sqrtf(lfo->_.polynomial_coefficient);
1039 }
1040 }
1041
1042 if( lfo->editble_state_write_mask & AUDIO_EDIT_LFO_PERIOD ){
1043 if( lfo->_.period ){
1044 float t = lfo->time;
1045 t/= (float)lfo->_.period;
1046
1047 lfo->_.period = lfo->editable_state.period;
1048 lfo->time = lfo->_.period * t;
1049 }
1050 else{
1051 lfo->time = 0;
1052 lfo->_.period = lfo->editable_state.period;
1053 }
1054 }
1055
1056 lfo->editble_state_write_mask = 0x00;
1057 }
1058
1059 dsp_update_tunings();
1060 audio_unlock();
1061
1062 /*
1063 * Process spawns
1064 * ------------------------------------------------------------- */
1065 for( int i=0; i<AUDIO_CHANNELS; i++ ){
1066 audio_channel *ch = &vg_audio.channels[i];
1067
1068 if( ch->activity == k_channel_activity_wake ){
1069 if( audio_channel_load_source( ch ) )
1070 ch->activity = k_channel_activity_alive;
1071 else
1072 ch->activity = k_channel_activity_error;
1073 }
1074 }
1075
1076 /*
1077 * Mix everything
1078 * -------------------------------------------------------- */
1079 int frame_count = byte_count/(2*sizeof(float));
1080
1081 /* Clear buffer */
1082 float *pOut32F = (float *)stream;
1083 for( int i=0; i<frame_count*2; i ++ )
1084 pOut32F[i] = 0.0f;
1085
1086 for( int i=0; i<AUDIO_LFOS; i++ ){
1087 audio_lfo *lfo = &vg_audio.oscillators[i];
1088 lfo->time_startframe = lfo->time;
1089 }
1090
1091 for( int i=0; i<AUDIO_CHANNELS; i ++ ){
1092 audio_channel *ch = &vg_audio.channels[i];
1093
1094 if( ch->activity == k_channel_activity_alive ){
1095 if( ch->_.lfo )
1096 ch->_.lfo->time = ch->_.lfo->time_startframe;
1097
1098 u32 remaining = frame_count,
1099 subpos = 0;
1100
1101 while( remaining ){
1102 audio_channel_mix( ch, pOut32F+subpos );
1103 remaining -= AUDIO_MIX_FRAME_SIZE;
1104 subpos += AUDIO_MIX_FRAME_SIZE*2;
1105 }
1106 }
1107 }
1108
1109 vg_profile_begin( &_vg_prof_dsp );
1110
1111 for( int i=0; i<frame_count; i++ )
1112 vg_dsp_process( pOut32F + i*2, pOut32F + i*2 );
1113
1114 vg_profile_end( &_vg_prof_dsp );
1115
1116 audio_lock();
1117
1118 for( int i=0; i<AUDIO_CHANNELS; i ++ ){
1119 audio_channel *ch = &vg_audio.channels[i];
1120 ch->readable_activity = ch->activity;
1121 }
1122
1123 /* Profiling information
1124 * ----------------------------------------------- */
1125 vg_profile_increment( &_vg_prof_audio_decode );
1126 vg_profile_increment( &_vg_prof_audio_mix );
1127 vg_profile_increment( &_vg_prof_dsp );
1128
1129 vg_prof_audio_mix = _vg_prof_audio_mix;
1130 vg_prof_audio_decode = _vg_prof_audio_decode;
1131 vg_prof_audio_dsp = _vg_prof_dsp;
1132
1133 vg_audio.samples_last = frame_count;
1134
1135 if( vg_audio.debug_dsp ){
1136 vg_dsp_update_texture();
1137 }
1138
1139 audio_unlock();
1140 }
1141
1142 VG_STATIC void audio_clip_load( audio_clip *clip, void *lin_alloc )
1143 {
1144 if( lin_alloc == NULL )
1145 lin_alloc = vg_audio.audio_pool;
1146
1147 /* load in directly */
1148 u32 format = clip->flags & AUDIO_FLAG_FORMAT;
1149
1150 /* TODO: This contains audio_lock() and unlock, but i don't know why
1151 * can probably remove them. Low priority to check this */
1152
1153 /* TODO: packed files for vorbis etc, should take from data if its not not
1154 * NULL when we get the clip
1155 */
1156
1157 if( format == k_audio_format_vorbis ){
1158 if( !clip->path ){
1159 vg_fatal_error( "No path specified, embeded vorbis unsupported" );
1160 }
1161
1162 audio_lock();
1163 clip->data = vg_file_read( lin_alloc, clip->path, &clip->size );
1164 audio_unlock();
1165
1166 if( !clip->data )
1167 vg_fatal_error( "Audio failed to load" );
1168
1169 float mb = (float)(clip->size) / (1024.0f*1024.0f);
1170 vg_info( "Loaded audio clip '%s' (%.1fmb)\n", clip->path, mb );
1171 }
1172 else if( format == k_audio_format_stereo ){
1173 vg_fatal_error( "Unsupported format (Stereo uncompressed)" );
1174 }
1175 else if( format == k_audio_format_bird ){
1176 if( !clip->data ){
1177 vg_fatal_error( "No data, external birdsynth unsupported" );
1178 }
1179
1180 u32 total_size = clip->size + sizeof(struct synth_bird);
1181 total_size -= sizeof(struct synth_bird_settings);
1182 total_size = vg_align8( total_size );
1183
1184 if( total_size > AUDIO_DECODE_SIZE )
1185 vg_fatal_error( "Bird coding too long\n" );
1186
1187 struct synth_bird *bird = vg_linear_alloc( lin_alloc, total_size );
1188 memcpy( &bird->settings, clip->data, clip->size );
1189
1190 clip->data = bird;
1191 clip->size = total_size;
1192
1193 vg_info( "Loaded bird synthesis pattern (%u bytes)\n", total_size );
1194 }
1195 else{
1196 if( !clip->path ){
1197 vg_fatal_error( "No path specified, embeded mono unsupported" );
1198 }
1199
1200 vg_linear_clear( vg_mem.scratch );
1201 u32 fsize;
1202
1203 stb_vorbis_alloc alloc = {
1204 .alloc_buffer = vg_linear_alloc( vg_mem.scratch, AUDIO_DECODE_SIZE ),
1205 .alloc_buffer_length_in_bytes = AUDIO_DECODE_SIZE
1206 };
1207
1208 void *filedata = vg_file_read( vg_mem.scratch, clip->path, &fsize );
1209
1210 int err;
1211 stb_vorbis *decoder = stb_vorbis_open_memory(
1212 filedata, fsize, &err, &alloc );
1213
1214 if( !decoder ){
1215 vg_error( "stb_vorbis_open_memory failed on '%s' (%d)\n",
1216 clip->path, err );
1217 vg_fatal_error( "Vorbis decode error" );
1218 }
1219
1220 /* only mono is supported in uncompressed */
1221 u32 length_samples = stb_vorbis_stream_length_in_samples( decoder ),
1222 data_size = length_samples * sizeof(i16);
1223
1224 audio_lock();
1225 clip->data = vg_linear_alloc( lin_alloc, vg_align8(data_size) );
1226 clip->size = length_samples;
1227 audio_unlock();
1228
1229 int read_samples = stb_vorbis_get_samples_i16_downmixed(
1230 decoder, clip->data, length_samples );
1231
1232 if( read_samples != length_samples )
1233 vg_fatal_error( "Decode error" );
1234
1235 float mb = (float)(data_size) / (1024.0f*1024.0f);
1236 vg_info( "Loaded audio clip '%s' (%.1fmb) %u samples\n", clip->path, mb,
1237 length_samples );
1238 }
1239 }
1240
1241 VG_STATIC void audio_clip_loadn( audio_clip *arr, int count, void *lin_alloc )
1242 {
1243 for( int i=0; i<count; i++ )
1244 audio_clip_load( &arr[i], lin_alloc );
1245 }
1246
1247 VG_STATIC void audio_require_clip_loaded( audio_clip *clip )
1248 {
1249 if( clip->data && clip->size )
1250 return;
1251
1252 audio_unlock();
1253 vg_fatal_error( "Must load audio clip before playing! \n" );
1254 }
1255
1256 /*
1257 * Debugging
1258 */
1259
1260 VG_STATIC void audio_debug_ui( m4x4f mtx_pv )
1261 {
1262 if( !vg_audio.debug_ui )
1263 return;
1264
1265 audio_lock();
1266
1267 glBindTexture( GL_TEXTURE_2D, vg_dsp.view_texture );
1268 glTexSubImage2D( GL_TEXTURE_2D, 0, 0, 0, 256, 256,
1269 GL_RGBA, GL_UNSIGNED_BYTE,
1270 vg_dsp.view_texture_buffer );
1271
1272 /*
1273 * Profiler
1274 * -----------------------------------------------------------------------
1275 */
1276
1277 float budget = ((double)vg_audio.samples_last / 44100.0) * 1000.0;
1278 #if 0
1279 vg_profile_drawn( (struct vg_profile *[]){ &vg_prof_audio_decode,
1280 &vg_prof_audio_mix,
1281 &vg_prof_audio_dsp}, 3,
1282 budget, (ui_rect){ 4, VG_PROFILE_SAMPLE_COUNT*2 + 8,
1283 512, 0 }, 3 );
1284 #endif
1285
1286
1287 char perf[128];
1288
1289 /* Draw UI */
1290 ui_rect window = {
1291 0,
1292 0,
1293 800,
1294 AUDIO_CHANNELS * 18
1295 };
1296
1297 if( vg_audio.debug_dsp ){
1298 ui_rect view_thing = { 4, vg.window_y-512-4, 512, 512 };
1299 ui_image( view_thing, vg_dsp.view_texture );
1300 }
1301
1302 ui_rect overlap_buffer[ AUDIO_CHANNELS ];
1303 u32 overlap_length = 0;
1304
1305 /* Draw audio stack */
1306 for( int i=0; i<AUDIO_CHANNELS; i ++ ){
1307 audio_channel *ch = &vg_audio.channels[i];
1308
1309 ui_rect row;
1310 ui_split( window, k_ui_axis_h, 18, 1, row, window );
1311
1312 if( !ch->allocated ){
1313 ui_fill( row, 0x50333333 );
1314 continue;
1315 }
1316
1317 const char *formats[] =
1318 {
1319 " mono ",
1320 " stereo ",
1321 " vorbis ",
1322 " none0 ",
1323 " none1 ",
1324 " none2 ",
1325 " none3 ",
1326 " none4 ",
1327 "synth:bird",
1328 " none5 ",
1329 " none6 ",
1330 " none7 ",
1331 " none8 ",
1332 " none9 ",
1333 " none10 ",
1334 " none11 ",
1335 };
1336
1337 const char *activties[] =
1338 {
1339 "reset",
1340 "wake ",
1341 "alive",
1342 "end ",
1343 "error"
1344 };
1345
1346 u32 format_index = (ch->source->flags & AUDIO_FLAG_FORMAT)>>9;
1347
1348 snprintf( perf, 127, "%02d[%#04x.%#06x]%c%c%cD %s [%s] %4.2fv'%s'",
1349 i,
1350 ch->world_id, ch->group,
1351 (ch->editable_state.relinquished)? 'r': '_',
1352 0? 'r': '_',
1353 0? '3': '2',
1354 formats[format_index],
1355 activties[ch->readable_activity],
1356 ch->editable_state.volume,
1357 ch->name );
1358
1359 ui_fill( row, 0xa0000000 | ch->colour );
1360 ui_text( row, perf, 1, k_ui_align_middle_left, 0 );
1361
1362 if( AUDIO_FLAG_SPACIAL_3D ){
1363 v4f wpos;
1364 v3_copy( ch->editable_state.spacial_falloff, wpos );
1365
1366 wpos[3] = 1.0f;
1367 m4x4_mulv( mtx_pv, wpos, wpos );
1368
1369 if( wpos[3] > 0.0f ){
1370 v2_muls( wpos, (1.0f/wpos[3]) * 0.5f, wpos );
1371 v2_add( wpos, (v2f){ 0.5f, 0.5f }, wpos );
1372
1373 ui_rect wr;
1374 wr[0] = vg_clampf(wpos[0] * vg.window_x, -32000.0f,32000.0f);
1375 wr[1] = vg_clampf((1.0f-wpos[1]) * vg.window_y,-32000.0f,32000.0f);
1376 wr[2] = 1000;
1377 wr[3] = 17;
1378
1379 for( int j=0; j<12; j++ ){
1380 int collide = 0;
1381 for( int k=0; k<overlap_length; k++ ){
1382 ui_px *wk = overlap_buffer[k];
1383 if( ((wr[0] <= wk[0]+wk[2]) && (wr[0]+wr[2] >= wk[0])) &&
1384 ((wr[1] <= wk[1]+wk[3]) && (wr[1]+wr[3] >= wk[1])) )
1385 {
1386 collide = 1;
1387 break;
1388 }
1389 }
1390
1391 if( !collide )
1392 break;
1393 else
1394 wr[1] += 18;
1395 }
1396
1397 ui_text( wr, perf, 1, k_ui_align_middle_left, 0 );
1398 rect_copy( wr, overlap_buffer[ overlap_length ++ ] );
1399 }
1400 }
1401 }
1402
1403 audio_unlock();
1404 }
1405
1406 #endif /* VG_AUDIO_H */
Voyager Game Engine