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 Han-Wen Nienhuys <hanwen@stack.nl>
   7            Jan Nieuwenhuizen <jan@digicash.com>
   8 */
   9 #include <assert.h>
  10 #include "duration-convert.hh"
  11 #include "warn.hh"
  12
  13 // statics Duration_convert
  14 bool const Duration_convert::midi_as_plet_b_s = true;
  15 bool Duration_convert::no_quantify_b_s = false;
  16 bool Duration_convert::no_double_dots_b_s = false;
  17 bool Duration_convert::no_triplets_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 ("[") + String (dur.ticks_i_) + "]";
  26
  27   String str;
  28   if (dur.durlog_i_ >= 0)
  29     str = String ( 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 += String ('.', dur.dots_i_);
  35   if (dur.plet_b ())
  36     str += String ("*") + String (dur.plet_.iso_i_)
  37       + String ("/") + String (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) * Moment (Duration::division_1_i_s);
  47 }
  48
  49
  50 int
  51 Duration_convert::i2_type (int i)
  52 {
  53   int t=0;
  54   while (!(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 Moment
  71 Duration_convert::dur2_mom (Duration dur)
  72 {
  73   if (dur.ticks_i_)
  74     return Moment (dur.ticks_i_, Duration::division_1_i_s);
  75
  76   // or simply assert?
  77   if (dur.durlog_i_<-10)
  78     return Moment (0);
  79   Moment mom;
  80   if (dur.durlog_i_<0)
  81     mom = Moment (type2_i (-dur.durlog_i_), 1);
  82   else
  83     mom = Moment (1 , type2_i (dur.durlog_i_));
  84
  85   Moment 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 (Moment 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 () || (dur.length () == 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   //    Moment as_plet_mom = mom / dur.mom ();
 115   Moment as_plet_mom = mom / dur.length ();
 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 (Moment 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       Moment 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 > Moment (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       Moment 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 Moment
 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, Moment mom)
 175 {
 176   return mom / dur2_mom (dur);
 177 }
 178
 179 Duration
 180 Duration_convert::ticks2_dur (int ticks_i)
 181 {
 182   Moment 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)
 189     return dur;
 190
 191   return mom2_dur (mom);
 192 }
 193
 194 Duration
 195 Duration_convert::ticks2standardised_dur (int ticks_i)
 196 {
 197   Moment mom (ticks_i, Duration::division_1_i_s);
 198   Duration dur = mom2standardised_dur (mom);
 199   return dur;
 200 }
 201
 202 Duration_iterator::Duration_iterator ()
 203 {
 204   cursor_dur_.durlog_i_ = 7;
 205   if (Duration_convert::no_smaller_than_i_s)
 206     cursor_dur_.durlog_i_ = Duration_convert::no_smaller_than_i_s;
 207 }
 208
 209 Duration
 210 Duration_iterator::operator ++(int)
 211 {
 212   return forward_dur ();
 213 }
 214
 215 Duration
 216 Duration_iterator::operator ()()
 217 {
 218   return dur ();
 219 }
 220
 221 Duration_iterator::operator bool ()
 222 {
 223   return ok ();
 224 }
 225
 226 Duration
 227 Duration_iterator::dur ()
 228 {
 229   return cursor_dur_;
 230 }
 231
 232 Duration
 233 Duration_iterator::forward_dur ()
 234 {
 235   /* should do smart table? guessing:
 236      duration wholes
 237      16         0.0625
 238      32..       0.0703
 239      8:2/3      0.0833
 240      16.        0.0938
 241      8  0.1250
 242      16..       0.1406
 243      4:2/3      0.1667
 244      8. 0.1875
 245
 246      */
 247   assert (ok ());
 248
 249   Duration dur = cursor_dur_;
 250
 251   if (!cursor_dur_.dots_i_ && !cursor_dur_.plet_b ())
 252     {
 253       cursor_dur_.durlog_i_ += 1;
 254       cursor_dur_.dots_i_ = 2;
 255     }
 256   else if (cursor_dur_.dots_i_ == 2)
 257     {
 258       assert (!cursor_dur_.plet_b ());
 259       cursor_dur_.dots_i_ = 0;
 260       cursor_dur_.durlog_i_ -=2;
 261       cursor_dur_.set_plet (2, 3);
 262     }
 263   else if (cursor_dur_.plet_b ()
 264            && (cursor_dur_.plet_.iso_i_ == 2)
 265            && (cursor_dur_.plet_.type_i_ == 3))
 266     {
 267       assert (!cursor_dur_.dots_i_);
 268       cursor_dur_.set_plet (1, 1);
 269       cursor_dur_.durlog_i_ += 1;
 270       cursor_dur_.dots_i_ = 1;
 271     }
 272   else if (cursor_dur_.dots_i_ == 1)
 273     {
 274       assert (!cursor_dur_.plet_b ());
 275       cursor_dur_.dots_i_ = 0;
 276       cursor_dur_.durlog_i_ -= 1;
 277     }
 278
 279   if (Duration_convert::no_triplets_b_s
 280       && cursor_dur_.plet_b () && ok ())
 281     forward_dur ();
 282   if (Duration_convert::no_double_dots_b_s
 283       && (cursor_dur_.dots_i_ == 2) && ok ())
 284     forward_dur ();
 285   if (Duration_convert::no_smaller_than_i_s
 286       && (cursor_dur_.durlog_i_ > Duration_convert::no_smaller_than_i_s) && ok ())
 287     forward_dur ();
 288   if (Duration_convert::no_smaller_than_i_s
 289       && cursor_dur_.dots_i_
 290       && (cursor_dur_.durlog_i_ >= Duration_convert::no_smaller_than_i_s)
 291       && ok ())
 292     forward_dur ();
 293   if (Duration_convert::no_smaller_than_i_s
 294       && (cursor_dur_.dots_i_ == 2)
 295       && (cursor_dur_.durlog_i_ >= Duration_convert::no_smaller_than_i_s / 2)
 296       && ok ())
 297     forward_dur ();
 298
 299   return dur;
 300 }
 301
 302 bool
 303 Duration_iterator::ok ()
 304 {
 305   return (cursor_dur_.durlog_i_
 306           && !((cursor_dur_.durlog_i_ == 0) && (cursor_dur_.dots_i_ > 2)));
 307 }