Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  1. #include "rssoundgen.h"
  2.  
  3. /*
  4.  
  5. #include "rsnoise.h"
  6.  
  7. #include "rs/rsmx.h"
  8.  
  9. #include <math.h>
  10. #include <string.h>
  11.  
  12. rs_sgen_reg_t rs_sgen_reg;
  13.  
  14. void rs_sgen_init(int waves_count, int wave_length) {
  15.     rs_sgen_reg.waves_count = waves_count;
  16.     rs_sgen_reg.wave_length = wave_length;
  17.     rs_sgen_reg.wave = malloc(waves_count * wave_length * 4); // float
  18.     rs_sgen_reg.wave_out = malloc(wave_length * 2); // signed short
  19.    
  20.     memset(rs_sgen_reg.wave, 0, waves_count * wave_length * 4);
  21.     memset(rs_sgen_reg.wave_out, 0, wave_length * 2);
  22. };
  23.  
  24. void rs_sgen_term() {
  25.     free(rs_sgen_reg.wave);
  26.     free(rs_sgen_reg.wave_out);
  27. };
  28.  
  29. int wave_shot_index = 0;
  30.  
  31. void rs_sgen_wave_out(int index) {
  32.     int i;
  33.     for (i = 0; i < rs_sgen_reg.wave_length; i++) {
  34.         rs_sgen_reg.wave_out[i] = 32767* (rs_clamp (rs_sgen_reg.wave[index*rs_sgen_reg.wave_length + i], -1.0, 1.0 ));
  35.     };
  36.  
  37.  
  38. //    char cmd[330];
  39. //    memset(cmd, 0, 330);
  40. //    sprintf(cmd, "/home/romik/temp/images/sound%d.data", wave_shot_index);
  41. //
  42. //    RS_IO_FILE* fp = rs_io_fopen( cmd, "wb");
  43. //
  44. //    rs_io_fwrite(fp, rs_sgen_reg.wave_out, rs_sgen_reg.wave_length*2);
  45. //    rs_io_fclose(fp);
  46. //
  47. //    wave_shot_index++;
  48.  
  49.  
  50.  
  51. };
  52.  
  53. // --------------------
  54.  
  55.  
  56. //float rs_sgen_osc_sin(int i, float freq, float p) {
  57. //    //
  58. //};
  59.  
  60.  
  61.  
  62.  
  63. float phaser_alps_a1[6];
  64. float phaser_alps_zm1[6];
  65.  
  66. float phaser_dmin, phaser_dmax; //range
  67. float phaser_fb; //feedback
  68. float phaser_lfoPhase;
  69. float phaser_lfoInc;
  70. float phaser_depth;
  71. float phaser_sample_rate;
  72. int   phaser_value_index = -1;
  73.  
  74. float phaser_zm1;
  75.  
  76. void phaser_set_range(float f1, float f2);
  77. void phaser_set_rate(float f);
  78. void phaser_alps_delay(int i, float f);
  79. float phaser_alps_update(int i, float f);
  80.  
  81. void phaser_reset( float fb, float lfoPhase, float depth, float range_start, float range_end, float rate ) {
  82.     memset(phaser_alps_a1, 0, 6*4);
  83.     memset(phaser_alps_zm1, 0, 6*4);
  84.  
  85.     phaser_sample_rate = 44100.0; // !!!!
  86.  
  87.     phaser_fb = fb;
  88.     phaser_lfoPhase = lfoPhase;
  89.     phaser_depth = depth;
  90.     phaser_zm1 = 0.0;
  91. //    phaser_set_range( 440.f, 1600.f );
  92.     phaser_set_range( range_start, range_end );
  93.     phaser_set_rate( rate );
  94.  
  95. };
  96.  
  97. void phaser_set_range(float fMin, float fMax) { // Hz
  98.     phaser_dmin = fMin / (phaser_sample_rate/2.f);
  99.     phaser_dmax = fMax / (phaser_sample_rate/2.f);
  100. };
  101.  
  102. void phaser_set_rate( float rate ){ // cps
  103.     phaser_lfoInc = 2.0f * M_PI * (rate / phaser_sample_rate);
  104. };
  105.  
  106. float phaser_update_sample( float inSamp, int ind ){
  107.     //calculate and update phaser sweep lfo...
  108.     float d;
  109.     if (phaser_value_index == -1) {
  110.         d  = phaser_dmin + (phaser_dmax-phaser_dmin) * ((sin( phaser_lfoPhase ) + 1.0f)/2.0f);
  111.     }
  112.     else {
  113.         d = phaser_dmin + (phaser_dmax-phaser_dmin) * (0.5+0.5*rs_sgen_reg.wave[ phaser_value_index*rs_sgen_reg.wave_length + ind ]);
  114.     };
  115.  
  116.     phaser_lfoPhase += phaser_lfoInc;
  117.     if( phaser_lfoPhase >= M_PI * 2.0f )
  118.         phaser_lfoPhase -= M_PI * 2.0f;
  119.  
  120.     //update filter coeffs
  121.     int i;
  122.     for(i = 0; i < 6; i++) {
  123.         phaser_alps_delay(i, d);
  124.     };
  125.  
  126.     //calculate output
  127.     float y = phaser_alps_update(0,
  128.                     phaser_alps_update(1,
  129.                         phaser_alps_update(2,
  130.                             phaser_alps_update(3,
  131.                                 phaser_alps_update(4,
  132.                                     phaser_alps_update(5,
  133.                                         inSamp + phaser_zm1 * phaser_fb
  134.                                     )
  135.                                 )
  136.                             )
  137.                         )
  138.                     )
  139.               );
  140.  
  141. //    float y =         _alps[0].Update(
  142. //                 _alps[1].Update(
  143. //                  _alps[2].Update(
  144. //                   _alps[3].Update(
  145. //                    _alps[4].Update(
  146. //                     _alps[5].Update( inSamp + _zm1 * _fb ))))));
  147.     phaser_zm1 = y;
  148.  
  149. //    return sin(440.0*phaser_lfoPhase);
  150.  
  151.     return inSamp + y * phaser_depth;
  152. }
  153.  
  154. void phaser_alps_delay(int i, float delay) {
  155.     phaser_alps_a1[i] = (1.0f - delay) / (1.0f + delay);
  156. };
  157.  
  158. float phaser_alps_update(int i, float inSamp) {
  159.     float y = inSamp * - phaser_alps_a1[i] + phaser_alps_zm1[i];
  160.     phaser_alps_zm1[i] = y * phaser_alps_a1[i] + inSamp;
  161.     return y;
  162. };
  163.  
  164. // -----------------------
  165.  
  166.  
  167. void rs_sgen_func_speaker(int index) {
  168.  
  169.  
  170.  
  171.     int i;
  172.  
  173.     float alpha = 0.3 ;// dt / (RC+dt)
  174.  
  175.  
  176.     for (i = 0; i < rs_sgen_reg.wave_length; i++) {
  177.  
  178.  
  179.         if (i == 0) {
  180.             rs_sgen_reg.wave[ rs_sgen_reg.wave_length * index + i] = 0.4 * rs_noise(i, 0);
  181.             continue;
  182.         };
  183.  
  184.  
  185.         // Low-pass
  186. //        rs_sgen_reg.wave[ rs_sgen_reg.wave_length * index + i] =
  187. //            alpha *  0.4 * rs_noise(i, 0) + (1.0 - alpha) * (rs_sgen_reg.wave[ rs_sgen_reg.wave_length * index + i - 1 ]);
  188.  
  189.  
  190.         // High-pass
  191.         rs_sgen_reg.wave[ rs_sgen_reg.wave_length * index + i] =
  192.             alpha * ( rs_sgen_reg.wave[ rs_sgen_reg.wave_length * index + i - 1 ] + 0.4 * rs_noise(i, 0) - 0.4 * rs_noise(i-1, 0) );
  193.  
  194.  
  195.  
  196. ////        rs_sgen_reg.wave[ rs_sgen_reg.wave_length * index + i] =  0.1 * sin( (2.0f * M_PI * 440.0 * i ) / 44100.0 + 9.0*sin(0.12*i) );
  197. //        int t = i + 4*65536;
  198. //        int p = (unsigned char) ((((t * (t >> 8 | t >> 9) & 46 & t >> 8)) ^ (t & t >> 13 | t >> 6)) & 0xFF);
  199. ////        rs_sgen_reg.wave[ rs_sgen_reg.wave_length * index + i] = (float)(p-128) / 128.0; // (float) 1.0 / 256.0 * (p);
  200.     };
  201.  
  202. //    rs_sound_create_from_data(&game.test_sound, 688200, audiodata);
  203.  
  204. //    for (i = 0; i < 20; i++) {
  205. //        rs_sound_create_from_data(& (sounds[i]), 11025 * (1 + i % 3) , audiodata2);
  206. //        rs_sound_adjust_pitch( &sounds[i], 0.5 + 1.0f * i / 20.0f );
  207. //    };
  208.  
  209. //    DEBUG10f("sound is created. length = %d \n", game.test_sound.Length);
  210.  
  211.  
  212. //    memset(audiodata, 0, 688200);
  213. //    free(audiodata);
  214.  
  215. };
  216.  
  217.  
  218. void rs_sgen_func_noise(int index, int seed) {
  219.     int i;
  220.     for (i = 0; i < rs_sgen_reg.wave_length; i++) {
  221.        rs_sgen_reg.wave[ rs_sgen_reg.wave_length * index + i] = rs_noise(seed + i, 0);
  222.     };
  223. };
  224.  
  225.  
  226.  
  227. void rs_sgen_func_sin(int index, float freq, float p) {
  228.     int i;
  229.     float f;
  230.  
  231.     for (i = 0; i < rs_sgen_reg.wave_length; i++) {
  232.         f = sin( (2.0f * M_PI * freq * i ) / 44100.0 ); // !!! Only for 44100 kHz
  233.         rs_sgen_reg.wave[ rs_sgen_reg.wave_length * index + i] = rs_sign(f) * pow( fabs(f) , p );  // remove koef!
  234.         // rs_sgen_reg.wave[ rs_sgen_reg.wave_length * index + i] =  0.1 * sin( (2.0f * M_PI * 440.0 * i ) / 44100.0 + 9.0*sin(0.12*i) );
  235. //        rs_sgen_reg.wave[ rs_sgen_reg.wave_length * index + i] = -1.0 + 2.0 * (  (44100.0 / freq)  ) sin( (2.0f * M_PI * freq * i ) / 44100.0 ); // !!! Only for 44100 kHz
  236.     };
  237. };
  238.  
  239.  
  240.  
  241. void rs_sgen_func_pm(int index, float freq, float p, float k, float freq2, float p2) {
  242.     int i;
  243.     float f;
  244.  
  245.     for (i = 0; i < rs_sgen_reg.wave_length; i++) {
  246.         f = sin( (2.0f * M_PI * freq * i ) / 44100.0 + k*rs_pow(sin( 2.0f * M_PI * freq2 * i / 44100.0 ), p2) ); // !!! Only for 44100 kHz
  247.         rs_sgen_reg.wave[ rs_sgen_reg.wave_length * index + i] = rs_pow(f, p);
  248.         // rs_sgen_reg.wave[ rs_sgen_reg.wave_length * index + i] =  0.1 * sin( (2.0f * M_PI * 440.0 * i ) / 44100.0 + 9.0*sin(0.12*i) );
  249. //        rs_sgen_reg.wave[ rs_sgen_reg.wave_length * index + i] = -1.0 + 2.0 * (  (44100.0 / freq)  ) sin( (2.0f * M_PI * freq * i ) / 44100.0 ); // !!! Only for 44100 kHz
  250.     };
  251. };
  252.  
  253. void rs_sgen_func_add(int dest, int src1, int src2, float k1, float k2) {
  254.     int i;
  255.  
  256.     for (i = 0; i < rs_sgen_reg.wave_length; i++) {
  257.         rs_sgen_reg.wave[ rs_sgen_reg.wave_length * dest + i] =
  258.             k1 * rs_sgen_reg.wave[ rs_sgen_reg.wave_length * src1 + i]
  259.             + k2 * rs_sgen_reg.wave[ rs_sgen_reg.wave_length * src2 + i];
  260.     };
  261.  
  262. };
  263.  
  264. void rs_sgen_func_mult(int dest, int src1, int src2) {
  265.     int i;
  266.  
  267.     for (i = 0; i < rs_sgen_reg.wave_length; i++) {
  268.         rs_sgen_reg.wave[ rs_sgen_reg.wave_length * dest + i] =
  269.             rs_sgen_reg.wave[ rs_sgen_reg.wave_length * src1 + i]
  270.             * rs_sgen_reg.wave[ rs_sgen_reg.wave_length * src2 + i];
  271.     };
  272.  
  273. };
  274.  
  275.  
  276. void rs_sgen_func_normalize(int dest, float amp) {
  277.  
  278. //    DEBUG10("Normalize...");
  279.  
  280.     float val_max = 0.0; // fabs(rs_sgen_reg.wave[ rs_sgen_reg.wave_length * dest ]);
  281.     float f;
  282.  
  283.     int i;  
  284.    
  285.     // Step 1: Normalize Mid-line
  286.    
  287.     const int mar_samples_count = 512;
  288.    
  289.     float *mar = malloc( 4 * (2 + rs_sgen_reg.wave_length / mar_samples_count) );
  290.     memset(mar, 0, 4 * (2 + rs_sgen_reg.wave_length / mar_samples_count) );
  291.    
  292. //    DEBUG10("label 1");
  293.    
  294.     int length_512 = mar_samples_count*(rs_sgen_reg.wave_length/mar_samples_count); // 1024 for 1027
  295.    
  296.     int last_length = rs_sgen_reg.wave_length - length_512;
  297.     if (!last_length) {
  298.         last_length = length_512;
  299.     };
  300.    
  301.     float koef[2] = { 1.0/mar_samples_count, 1.0/(last_length) };
  302.    
  303. //    DEBUG10f("\nkoef 0: %.6f\nkoef 1: %.6f (last_length = %d)\n", koef[0], koef[1], last_length);
  304.    
  305.     for (i = 0; i < rs_sgen_reg.wave_length; i++) {
  306.         mar[1+i/mar_samples_count] += koef[ i / (length_512) ] * rs_sgen_reg.wave[ rs_sgen_reg.wave_length * dest + i];
  307.     };
  308.    
  309. //    DEBUG10("label 2");
  310.    
  311.    
  312.     for (i = 0; i < rs_sgen_reg.wave_length; i++) {
  313.         rs_sgen_reg.wave[ rs_sgen_reg.wave_length * dest + i] -= //mar[i/mar_samples_count];
  314.            rs_linear_interpolate( mar[i/mar_samples_count], mar[1+i/mar_samples_count], rs_fract(1.0*i/mar_samples_count) );
  315.     };
  316. //    
  317. //    DEBUG10("label 3");
  318.    
  319.     free(mar);
  320.    
  321. //    DEBUG10("label 4");
  322.    
  323.    
  324.     // Step 2: Normalize Amplitude
  325.  
  326.     for (i = 0; i < rs_sgen_reg.wave_length; i++) {
  327.         f = rs_sgen_reg.wave[ rs_sgen_reg.wave_length * dest + i];
  328.         val_max = rs_max(val_max, fabs(f) );
  329.     };
  330.  
  331.     float val_scale = amp / val_max;
  332.  
  333. //    DEBUG10f("SGEN Normalize: val_max %.3f, val_scale = %.3f \n", val_max, val_scale);
  334.  
  335.     for (i = 0; i < rs_sgen_reg.wave_length; i++) {
  336.         rs_sgen_reg.wave[ rs_sgen_reg.wave_length * dest + i] = val_scale * rs_sgen_reg.wave[ rs_sgen_reg.wave_length * dest + i];
  337.     };
  338.    
  339.    
  340.  
  341. };
  342.  
  343.  
  344.  
  345. void rs_sgen_func_limiter(int dest, float val) {
  346.    
  347.     rs_sgen_func_normalize(dest, 1.0/val);
  348.    
  349.     int i;
  350.     for (i = 0; i < rs_sgen_reg.wave_length; i++) {
  351.         rs_sgen_reg.wave[ rs_sgen_reg.wave_length * dest + i] = rs_clamp(
  352.             rs_sgen_reg.wave[ rs_sgen_reg.wave_length * dest + i ], -1.0, 1.0 );                                                                        
  353.     };
  354.  
  355. //    float val_scale = amp / val_max;
  356. //
  357. //    DEBUG10f("SGEN Normalize: val_max %.3f, val_scale = %.3f \n", val_max, val_scale);
  358. //
  359. //    for (i = 0; i < rs_sgen_reg.wave_length; i++) {
  360. //        rs_sgen_reg.wave[ rs_sgen_reg.wave_length * dest + i] = val_scale * rs_sgen_reg.wave[ rs_sgen_reg.wave_length * dest + i];
  361. //    };
  362. };
  363.  
  364.  
  365. void rs_sgen_func_reverb(int dest, int src, int echo_delay, float echo_decay_koef) {
  366.    
  367.     //
  368.    
  369.     int i;
  370.     for (i = 0; i < rs_sgen_reg.wave_length; i++) {
  371.            
  372.         if (i + echo_delay > rs_sgen_reg.wave_length-1) {
  373.             break;
  374.         };
  375.            
  376.         rs_sgen_reg.wave[ rs_sgen_reg.wave_length * dest + i + echo_delay] +=
  377.             echo_decay_koef * rs_sgen_reg.wave[ rs_sgen_reg.wave_length * dest + i];
  378.     };
  379.    
  380. };
  381.  
  382.  
  383. void rs_sgen_func_lowpass(int dest, int src, float alpha_start, float alpha_end, float alpha_pow) {
  384.  
  385.     int i;
  386.     float alpha, t;
  387.  
  388.     for (i = 0; i < rs_sgen_reg.wave_length; i++) {
  389.  
  390.         if (i == 0) {
  391.             rs_sgen_reg.wave[ rs_sgen_reg.wave_length * dest + i] =
  392.                 0; // rs_sgen_reg.wave[ rs_sgen_reg.wave_length * src + i];
  393.             continue;
  394.         };
  395.  
  396.         t = (float) i / rs_sgen_reg.wave_length;
  397.         alpha = (1.0 - t) * alpha_start + t * alpha_end;
  398.         alpha = pow(alpha, alpha_pow);
  399.  
  400.         // Low-pass
  401.         rs_sgen_reg.wave[ rs_sgen_reg.wave_length * dest + i] =
  402.             alpha * rs_sgen_reg.wave[ rs_sgen_reg.wave_length * src + i]
  403.             + (1.0 - alpha) * (rs_sgen_reg.wave[ rs_sgen_reg.wave_length * dest + i - 1 ]);
  404.  
  405.     };
  406. };
  407.  
  408.  
  409. void rs_sgen_func_highpass(int dest, int src, float alpha_start, float alpha_end, float alpha_pow) {
  410.  
  411.     int i;
  412.     float t, alpha;
  413.  
  414.     for (i = 0; i < rs_sgen_reg.wave_length; i++) {
  415.  
  416.         if (i == 0) {
  417.             rs_sgen_reg.wave[ rs_sgen_reg.wave_length * dest + i] = 0; // rs_sgen_reg.wave[ rs_sgen_reg.wave_length * src + i];
  418.             continue;
  419.         };
  420.  
  421.         t = (float) i / rs_sgen_reg.wave_length;
  422.         alpha = (1.0 - t) * alpha_start + t * alpha_end;
  423.         alpha = pow(alpha, alpha_pow);
  424.  
  425.         // High-pass
  426.         rs_sgen_reg.wave[ rs_sgen_reg.wave_length * dest + i] =
  427.             alpha * ( rs_sgen_reg.wave[ rs_sgen_reg.wave_length * dest + i - 1]
  428.             + rs_sgen_reg.wave[ rs_sgen_reg.wave_length * src + i]
  429.             - rs_sgen_reg.wave[ rs_sgen_reg.wave_length * src + i - 1] );
  430.  
  431.     };
  432.  
  433. };
  434.  
  435. void rs_sgen_func_phaser(int dest, int src, float fb, float lfoPhase, float depth, float range_start, float range_end, float rate) {
  436.  
  437.     //phaser_reset(0.97, 1.67, 0.5, 1.0, 22050.0, 1.5);
  438.     phaser_reset(fb, lfoPhase, depth, range_start, range_end, rate);
  439.  
  440.     int i;
  441. //    float t, alpha;
  442.  
  443.     for (i = 0; i < rs_sgen_reg.wave_length + 12; i++) {
  444.         rs_sgen_reg.wave[ rs_sgen_reg.wave_length * dest + i%rs_sgen_reg.wave_length] = phaser_update_sample( rs_sgen_reg.wave[ rs_sgen_reg.wave_length * src + i%rs_sgen_reg.wave_length], i%rs_sgen_reg.wave_length );
  445.     };
  446.  
  447. };
  448.  
  449. void rs_sgen_func_shift(int dest, int src) {
  450.     int i;
  451.     for (i = 0; i < rs_sgen_reg.wave_length; i++) {
  452.         rs_sgen_reg.wave[ rs_sgen_reg.wave_length * dest + i % rs_sgen_reg.wave_length]
  453.             = rs_sgen_reg.wave[ rs_sgen_reg.wave_length * src + (i + rs_sgen_reg.wave_length/2 )%rs_sgen_reg.wave_length];
  454.     };
  455. };
  456.  
  457. */
  458.