util.c

   1 /* -*- Mode: C ; c-basic-offset: 2 -*- */
   2 /*****************************************************************************
   3  *
   4  *   Copyright (C) 2006,2007 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_two_buffers(
 113   zyn_sample_type * buffer1,
 114   zyn_sample_type * buffer2,
 115   size_t size)
 116 {
 117   while (size)
 118   {
 119     size--;
 120     buffer1[size] = 0.0;
 121     buffer2[size] = 0.0;
 122   }
 123 }
 124
 125 void
 126 mix_add_two_buffers(
 127   zyn_sample_type * buffer_mix_1,
 128   zyn_sample_type * buffer_mix_2,
 129   zyn_sample_type * buffer1,
 130   zyn_sample_type * buffer2,
 131   size_t size)
 132 {
 133   while (size)
 134   {
 135     size--;
 136     buffer_mix_1[size] += buffer1[size];
 137     buffer_mix_2[size] += buffer2[size];
 138   }
 139 }
 140
 141 void
 142 fadeout_two_buffers(
 143   zyn_sample_type * buffer1,
 144   zyn_sample_type * buffer2,
 145   size_t size)
 146 {
 147   zyn_sample_type fade;
 148
 149   while (size)
 150   {
 151     fade = 1.0 - (zyn_sample_type)size / (zyn_sample_type)SOUND_BUFFER_SIZE;
 152     size--;
 153     buffer1[size] *= fade;
 154     buffer2[size] *= fade;
 155   }
 156 }
 157
 158 void
 159 copy_buffer(
 160   zyn_sample_type * buffer_dest,
 161   zyn_sample_type * buffer_src,
 162   size_t size)
 163 {
 164   while (size)
 165   {
 166     size--;
 167     buffer_dest[size] = buffer_src[size];
 168   }
 169 }
 170
 171 void
 172 multiply_buffer(
 173   zyn_sample_type * buffer,
 174   float multiplyer,
 175   size_t size)
 176 {
 177   while (size)
 178   {
 179     size--;
 180     buffer[size] *= multiplyer;
 181   }
 182 }
 183
 184 float
 185 zyn_random()
 186 {
 187   return rand() / (RAND_MAX + 1.0);
 188 }