projects/birds.c

   1 #include "stdint.h"
   2 #include "stdio.h"
   3 #include "stdlib.h"
   4 #include "math.h"
   5
   6 #define SYNTH_BIRD_STDLIB
   7 #include "vg_audio_synth_bird.h"
   8 #include "vg_m.h"
   9
  10 #define WRAP1S( X ) (X)%44100
  11
  12 /*
  13  * clang birds.c -lm -o birds && ./birds | aplay -f cd /dev/stdin
  14  *
  15  * Performance measurements: (generate 30seconds audio)
  16  *
  17  *   DSP SINE_ACCURATE   -O3     x Realtime
  18  *
  19  *   on  yes             0.182s  164x
  20  *   on  no              0.134s  223x
  21  *   off yes             0.113s  265x
  22  *   off no              0.074s  405x
  23  *
  24  */
  25
  26 static void vg_dsp_init( void );
  27 static void vg_dsp_process( float *stereo_in, float *stereo_out );
  28
  29 static void write_profile( FILE *fp, struct synth_bird_settings *settings,
  30                            struct synth_bird_signature *pattern,
  31                            u32 pattern_count, const char *name )
  32 {
  33    struct synth_bird *bird =
  34       synth_bird_create( settings, pattern, pattern_count );
  35
  36    u32 size = synth_bird_save_size( bird );
  37    char save[ size*2 ];
  38    synth_bird_save( bird, save );
  39
  40    fprintf( fp, "%s:\n%.*s\n\n", name, size*2, save );
  41 }
  42
  43 #define _PROFILE( FP, SETTINGS, ARRAY ) \
  44    write_profile( FP, SETTINGS, ARRAY, sizeof(ARRAY)/sizeof(ARRAY[0]), \
  45                   #ARRAY )
  46
  47 static void export_all_profiles(void)
  48 {
  49    FILE *fp = fopen( "bird_profiles.txt", "w" );
  50
  51    struct synth_bird_settings *settings = &synth_bird__default_settings;
  52
  53    _PROFILE( fp, settings, synth_bird__warbling_vireo );
  54    _PROFILE( fp, settings, synth_bird__pied_monarch );
  55    _PROFILE( fp, settings, synth_bird__bridled_honeyeater );
  56    _PROFILE( fp, settings, synth_bird__cricket );
  57    _PROFILE( fp, settings, synth_bird__gray_shrikethrush );
  58    _PROFILE( fp, settings, synth_bird__boobook );
  59    _PROFILE( fp, settings, synth_bird__shrike_tit );
  60
  61    fclose( fp );
  62 }
  63
  64 int main( int argc, char *argv[] )
  65 {
  66    vg_dsp_init();
  67
  68    export_all_profiles();
  69
  70    struct synth_bird *warbling_vireo =
  71       synth_bird_create( &synth_bird__default_settings,
  72                           synth_bird__warbling_vireo,
  73                           sizeof(synth_bird__warbling_vireo)/
  74                           sizeof(struct synth_bird_signature) );
  75
  76    for(;;){
  77       float stereo[2] = { 0.0f, 0.0f };
  78
  79       float b[2];
  80
  81       synth_bird_generate_samples( warbling_vireo, b, 1 );
  82       stereo[0] += b[0];
  83       stereo[1] += b[1];
  84
  85 #if 0
  86       vg_dsp_process( stereo, stereo );
  87 #endif
  88
  89       int16_t l = stereo[0] * 14000.0f,
  90               r = stereo[1] * 14000.0f;
  91
  92       fwrite( &l, 2,1, stdout );
  93       fwrite( &r, 2,1, stdout );
  94    }
  95 }
  96
  97
  98 static float dsp_buffer[(1024*1024)/4];
  99 static int dsp_allocations = 0;
 100
 101 struct dsp_delay
 102 {
 103    int length, cur;
 104    float *buffer;
 105 };
 106
 107 struct dsp_lpf
 108 {
 109    float exponent;
 110    float *buffer;
 111 };
 112
 113 struct dsp_schroeder
 114 {
 115    struct dsp_delay M;
 116    float gain;
 117 };
 118
 119 static float *dsp_allocate( int l )
 120 {
 121    float *buf = &dsp_buffer[ dsp_allocations ];
 122    dsp_allocations += l;
 123    return buf;
 124 }
 125
 126 static inline void dsp_read_delay( struct dsp_delay *delay, float *s )
 127 {
 128    int index = delay->cur+1;
 129    if( index >= delay->length ) index = 0;
 130    *s = delay->buffer[ index ];
 131 }
 132
 133 static inline void dsp_write_delay( struct dsp_delay *delay, float *s )
 134 {
 135    int index = delay->cur;
 136    delay->buffer[ index ] = *s;
 137    delay->cur ++;
 138    if( delay->cur >= delay->length ) delay->cur = 0;
 139 }
 140
 141 static void dsp_init_delay( struct dsp_delay *delay, float length )
 142 {
 143    delay->length = 44100.0f * length;
 144    delay->cur = 0;
 145    delay->buffer = dsp_allocate( delay->length );
 146
 147    for( int i=0; i<delay->length; i++ )
 148       delay->buffer[i] = 0.0f;
 149 }
 150
 151 static void dsp_update_lpf( struct dsp_lpf *lpf, float freq )
 152 {
 153    lpf->exponent = 1.0f-expf( -(1.0f/44100.0f) *2.0f*3.1415926535897f*freq );
 154 }
 155
 156 static void dsp_init_lpf( struct dsp_lpf *lpf, float freq )
 157 {
 158    lpf->buffer = dsp_allocate( 4 );
 159    lpf->buffer[0] = 0.0f;
 160    dsp_update_lpf( lpf, freq );
 161 }
 162
 163 static inline void dsp_write_lpf( struct dsp_lpf *lpf, float *s )
 164 {
 165    float diff = *s - lpf->buffer[0];
 166    lpf->buffer[0] += diff * lpf->exponent;
 167 }
 168
 169 static inline void dsp_read_lpf( struct dsp_lpf *lpf, float *s )
 170 {
 171    *s = lpf->buffer[0];
 172 }
 173
 174 static void dsp_init_schroeder( struct dsp_schroeder *sch, float length,
 175                                 float gain )
 176 {
 177    dsp_init_delay( &sch->M, length );
 178    sch->gain = gain;
 179 }
 180
 181 static inline void dsp_process_schroeder( struct dsp_schroeder *sch,
 182                                           float *input, float *output )
 183 {
 184    float dry = *input;
 185
 186    float delay_output;
 187    dsp_read_delay( &sch->M, &delay_output );
 188
 189    float feedback_attenuated = delay_output * sch->gain,
 190          input_feedback_sum  = dry + feedback_attenuated;
 191
 192    dsp_write_delay( &sch->M, &input_feedback_sum );
 193
 194    *output = delay_output - input_feedback_sum*sch->gain;
 195 }
 196
 197 /* temporary global design */
 198 static struct dsp_lpf __lpf_mud_free,
 199                       __hpf_mud_free;
 200
 201 static struct dsp_delay __echos[8];
 202 static struct dsp_lpf   __echos_lpf[8];
 203 static struct dsp_schroeder __diffusion_chain[8];
 204
 205 static void vg_dsp_init( void )
 206 {
 207    /* temporary global design */
 208
 209    dsp_init_lpf( &__lpf_mud_free, 125.0f );
 210    dsp_init_lpf( &__hpf_mud_free, 500.0f );
 211
 212    float sizes[] =
 213          { 2.0f, 4.0f, 8.0f, 16.0f,   32.0f, 64.0f, 128.0f, 256.0f };
 214
 215    float reflection_variance = 0.04f;
 216
 217    for( int i=0; i<8; i++ )
 218    {
 219       float reflection_time = ((sizes[i])/343.0f) * 1000.0f;
 220
 221       float var   = 1.0f + vg_randf64_range(-1.0,1.0) * reflection_variance,
 222             total = reflection_time * var;
 223
 224       dsp_init_delay( &__echos[i], total / 1000.0f );
 225
 226       float freq = vg_lerpf( 800.0f, 350.0f, sizes[i] / 256.0f );
 227       dsp_init_lpf( &__echos_lpf[i], freq );
 228    }
 229
 230    float diffusions[] = { 187.0f, 159.0f, 143.0f, 121.0f,
 231                           79.0f,  57.0f,  27.0f,  11.0f };
 232
 233    for( int i=0; i<8; i++ )
 234    {
 235       dsp_init_schroeder( __diffusion_chain+i, diffusions[i]/1000.0f, 0.7f );
 236    }
 237 }
 238
 239 static void vg_dsp_process( float *stereo_in, float *stereo_out )
 240 {
 241    float in_total = (stereo_in[0]+stereo_in[1])*0.5f;
 242    float recieved = 0.0f;
 243
 244    float echo_tunings[] = { 0.05f, 0.05f, 0.1f, 0.1f,
 245                             0.1f, 0.1f, 0.2f, 0.3f };
 246
 247    for( int i=0; i<8; i++ )
 248    {
 249       float echo;
 250       dsp_read_delay(  __echos+i, &echo );
 251       dsp_write_lpf( __echos_lpf+i, &echo );
 252       dsp_read_lpf(  __echos_lpf+i, &echo );
 253
 254       recieved += echo * echo_tunings[i]*0.9;
 255    }
 256
 257    float diffused = recieved;
 258
 259    for( int i=0; i<8; i++ )
 260    {
 261       dsp_process_schroeder( __diffusion_chain+i, &diffused, &diffused );
 262    }
 263
 264    float total = in_total + (diffused*0.5f + recieved*0.5f);
 265
 266    dsp_write_lpf( &__hpf_mud_free, &total );
 267    dsp_read_lpf(  &__hpf_mud_free, &total );
 268
 269    float low_mud;
 270    dsp_write_lpf( &__lpf_mud_free, &total );
 271    dsp_read_lpf(  &__lpf_mud_free, &low_mud );
 272
 273    total -= low_mud;
 274
 275    for( int i=0; i<8; i++ )
 276       dsp_write_delay( __echos+i, &total );
 277
 278    stereo_out[0]  = stereo_in[0]*0.5f;
 279    stereo_out[1]  = stereo_in[1]*0.5f;
 280    stereo_out[0] += diffused*0.8f+recieved*0.9f;
 281    stereo_out[1] += diffused*0.8f+recieved*0.9f;
 282 }
 283