Subversion Repositories Kolibri OS

Rev

Rev 5225 | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

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