util.c

   1 /* -*- Mode: C ; c-basic-offset: 2 -*- */
   2 /*****************************************************************************
   3  *
   4  *   Copyright (C) 2006,2007,2008,2009 Nedko Arnaudov <nedko@arnaudov.name>
   5  *
   6  *   This program is free software; you can redistribute it and/or modify
   7  *   it under the terms of the GNU General Public License as published by
   8  *   the Free Software Foundation; version 2 of the License
   9  *
  10  *   This program is distributed in the hope that it will be useful,
  11  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  *   GNU General Public License for more details.
  14  *
  15  *   You should have received a copy of the GNU General Public License
  16  *   along with this program; if not, write to the Free Software
  17  *   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  *****************************************************************************/
  20
  21 #include <math.h>
  22 #include <stdlib.h>
  23
  24 #include "common.h"
  25 #include "util.h"
  26
  27 /*
  28  * Transform the velocity according the scaling parameter (velocity sensing)
  29  */
  30 float
  31 VelF(REALTYPE velocity,unsigned char scaling)
  32 {
  33   float x;
  34
  35   x = (64.0 - scaling) / 64.0;  /* 0 .. 127 -> 1 .. -1 */
  36
  37   x = pow(VELOCITY_MAX_SCALE, x);
  38
  39   if (scaling == 127 || velocity > 0.99)
  40   {
  41     return 1.0;
  42   }
  43   else
  44   {
  45     return pow(velocity, x);
  46   }
  47 }
  48
  49 float
  50 zyn_velocity_scale(float velocity, float scaling)
  51 {
  52   float x;
  53
  54   x = pow(VELOCITY_MAX_SCALE, scaling);
  55
  56   if (scaling < -0.99 || velocity > 0.99)
  57   {
  58     return 1.0;
  59   }
  60   else
  61   {
  62     return pow(velocity, x);
  63   }
  64 }
  65
  66 /*
  67  * Get the detune in cents
  68  */
  69 REALTYPE
  70 getdetune(
  71   unsigned char type,
  72   unsigned short int coarsedetune,
  73   unsigned short int finedetune)
  74 {
  75   REALTYPE det=0.0,octdet=0.0,cdet=0.0,findet=0.0;
  76
  77   //Get Octave
  78   int octave=coarsedetune/1024;
  79   if (octave>=8) octave-=16;
  80   octdet=octave*1200.0;
  81
  82   //Coarse and fine detune
  83   int cdetune=coarsedetune%1024;
  84   if (cdetune>512) cdetune-=1024;
  85
  86   int fdetune=finedetune-8192;
  87
  88   switch (type){
  89 //  case 1: is used for the default (see below)
  90   case 2: cdet=fabs(cdetune*10.0);
  91     findet=fabs(fdetune/8192.0)*10.0;
  92     break;
  93   case 3: cdet=fabs(cdetune*100);
  94     findet=pow(10,fabs(fdetune/8192.0)*3.0)/10.0-0.1;
  95     break;
  96   case 4: cdet=fabs(cdetune*701.95500087); //perfect fifth
  97     findet=(pow(2,fabs(fdetune/8192.0)*12.0)-1.0)/4095*1200;
  98     break;
  99     //case ...: need to update N_DETUNE_TYPES, if you'll add more
 100   default:cdet=fabs(cdetune*50.0);
 101     findet=fabs(fdetune/8192.0)*35.0;//almost like "Paul's Sound Designer 2"
 102     break;
 103   };
 104   if (finedetune<8192) findet=-findet;
 105   if (cdetune<0) cdet=-cdet;
 106
 107   det=octdet+cdet+findet;
 108   return(det);
 109 }
 110
 111 void
 112 silence_buffer(
 113   zyn_sample_type * buffer,
 114   size_t size)
 115 {
 116   while (size)
 117   {
 118     size--;
 119     buffer[size] = 0.0;
 120   }
 121 }
 122
 123 void
 124 silence_two_buffers(
 125   zyn_sample_type * buffer1,
 126   zyn_sample_type * buffer2,
 127   size_t size)
 128 {
 129   while (size)
 130   {
 131     size--;
 132     buffer1[size] = 0.0;
 133     buffer2[size] = 0.0;
 134   }
 135 }
 136
 137 void
 138 mix_add_two_buffers(
 139   zyn_sample_type * buffer_mix_1,
 140   zyn_sample_type * buffer_mix_2,
 141   zyn_sample_type * buffer1,
 142   zyn_sample_type * buffer2,
 143   size_t size)
 144 {
 145   while (size)
 146   {
 147     size--;
 148     buffer_mix_1[size] += buffer1[size];
 149     buffer_mix_2[size] += buffer2[size];
 150   }
 151 }
 152
 153 void
 154 fadeout_two_buffers(
 155   zyn_sample_type * buffer1,
 156   zyn_sample_type * buffer2,
 157   size_t size)
 158 {
 159   zyn_sample_type fade;
 160
 161   while (size)
 162   {
 163     fade = 1.0 - (zyn_sample_type)size / (zyn_sample_type)SOUND_BUFFER_SIZE;
 164     size--;
 165     buffer1[size] *= fade;
 166     buffer2[size] *= fade;
 167   }
 168 }
 169
 170 void
 171 copy_buffer(
 172   zyn_sample_type * buffer_dest,
 173   zyn_sample_type * buffer_src,
 174   size_t size)
 175 {
 176   while (size)
 177   {
 178     size--;
 179     buffer_dest[size] = buffer_src[size];
 180   }
 181 }
 182
 183 void
 184 multiply_buffer(
 185   zyn_sample_type * buffer,
 186   float multiplyer,
 187   size_t size)
 188 {
 189   while (size)
 190   {
 191     size--;
 192     buffer[size] *= multiplyer;
 193   }
 194 }
 195
 196 float
 197 zyn_random()
 198 {
 199   return rand() / (RAND_MAX + 1.0);
 200 }