midi2ly/duration-convert.cc

   1 /*
   2   duration-convert.cc -- implement Duration_convert
   3
   4   source file of the LilyPond music typesetter
   5
   6   (c)  1997--2000 Han-Wen Nienhuys <hanwen@cs.uu.nl>
   7            Jan Nieuwenhuizen <janneke@gnu.org>
   8 */
   9 #include <assert.h>
  10 #include "duration-convert.hh"
  11 #include "duration-iter.hh"
  12 #include "warn.hh"
  13
  14 // statics Duration_convert
  15 bool Duration_convert::no_quantify_b_s = false;
  16 bool Duration_convert::no_double_dots_b_s = false;
  17 bool Duration_convert::no_tuplets_b_s = false;
  18 int Duration_convert::no_smaller_than_i_s = 0;
  19 Array<Duration> Duration_convert::dur_array_s;
  20
  21 String
  22 Duration_convert::dur2_str (Duration dur)
  23 {
  24   if (dur.ticks_i_)
  25     return String ("[") + to_str (dur.ticks_i_) + "]";
  26
  27   String str;
  28   if (dur.durlog_i_ >= 0)
  29     str = to_str ( type2_i (dur.durlog_i_) );
  30   else if (dur.durlog_i_ == -1)
  31     str = "\\breve";
  32   else if (dur.durlog_i_ == -2)
  33     str = "\\longa";
  34   str += to_str ('.', dur.dots_i_);
  35   if (dur.plet_b ())
  36     str += String ("*") + to_str (dur.plet_.iso_i_)
  37       + String ("/") + to_str (dur.plet_.type_i_);
  38   return str;
  39 }
  40
  41 int
  42 Duration_convert::dur2ticks_i (Duration dur)
  43 {
  44   if (dur.ticks_i_)
  45     return dur.ticks_i_;
  46   return dur2_mom (dur) * Rational (Duration::division_1_i_s);
  47 }
  48
  49 int
  50 Duration_convert::i2_type (int i)
  51 {
  52   int t=0;
  53   while (i && !(i & 1)) {
  54     i >>= 1;
  55     t++;
  56   }
  57   return t;
  58 }
  59
  60 int
  61 Duration_convert::type2_i (int type)
  62 {
  63   if (type<0)
  64     return 0;
  65   else
  66     return 1 << type;
  67 }
  68
  69 Rational
  70 Duration_convert::dur2_mom (Duration dur)
  71 {
  72   if (dur.ticks_i_)
  73     return Rational (dur.ticks_i_, Duration::division_1_i_s);
  74
  75   // or simply assert?
  76   if (dur.durlog_i_<-10)
  77     return Rational (0);
  78   Rational mom;
  79   if (dur.durlog_i_<0)
  80     mom = Rational (type2_i (-dur.durlog_i_), 1);
  81   else
  82     mom = Rational (1 , type2_i (dur.durlog_i_));
  83
  84   Rational delta = mom;
  85   while (dur.dots_i_--)
  86     {
  87       delta /= 2.0;
  88       mom += delta;
  89     }
  90
  91   return mom * plet_factor_mom (dur);
  92 }
  93
  94 Duration
  95 Duration_convert::mom2_dur (Rational mom)
  96 {
  97   if (!mom)
  98     {
  99       Duration dur;
 100       dur.set_plet (0,1);
 101       return dur;
 102     }
 103
 104   return mom2standardised_dur (mom);
 105 }
 106
 107 Duration
 108 Duration_convert::mom2standardised_dur (Rational mom)
 109 {
 110   //    if (!dur_array_s.length_i ())
 111   if (!dur_array_s.size ())
 112     set_array ();
 113   assert (dur_array_s.size ());
 114   for (int i = 0; i < dur_array_s.size () - 1; i++)
 115     {
 116       Rational lower_mom = dur2_mom (dur_array_s[ i ]);
 117       if (mom <= lower_mom)
 118         {
 119           // all arbitrary, but 3/4 will get rid of the noise...
 120           // kinda ok
 121           if (i || (mom / lower_mom > Rational (3, 4)))
 122             return dur_array_s[ i ];
 123           else
 124             {
 125               Duration d;
 126               d.durlog_i_ = -100;
 127               return d;
 128             }
 129         }
 130       Rational upper_mom = dur2_mom (dur_array_s[ i + 1 ]);
 131       if ((mom < upper_mom)
 132           && ((mom - lower_mom) / lower_mom
 133               < (upper_mom - mom) / upper_mom))
 134         return dur_array_s[ i ];
 135     }
 136   return dur_array_s[ dur_array_s.size () - 1 ];
 137 }
 138
 139 void
 140 Duration_convert::set_array ()
 141 {
 142   dur_array_s.clear ();
 143
 144   Duration_iterator i;
 145   dur_array_s.push (i.dur ());
 146   while (i.ok ())
 147     dur_array_s.push (i.forward_dur ());
 148 }
 149
 150
 151 Rational
 152 Duration_convert::plet_factor_mom (Duration dur)
 153 {
 154   return dur.plet_.mom ();
 155 }
 156
 157 Real
 158 Duration_convert::sync_f (Duration dur, Rational mom)
 159 {
 160   return mom / dur2_mom (dur);
 161 }
 162
 163 Duration
 164 Duration_convert::ticks2_dur (int ticks_i)
 165 {
 166   Rational mom (ticks_i, Duration::division_1_i_s);
 167   return mom2standardised_dur (mom);
 168 }
 169
 170 Duration
 171 Duration_convert::ticks2standardised_dur (int ticks_i)
 172 {
 173   Rational mom (ticks_i, Duration::division_1_i_s);
 174   Duration dur = mom2standardised_dur (mom);
 175   return dur;
 176 }