lib/duration-convert.cc

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