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="\\breve";
  30         else
  31             str= String( type2_i(dur.durlog_i_) );
  32         str += String( '.', dur.dots_i_ );
  33         if ( dur.plet_b())
  34                 str += String( "*" ) + String( dur.plet_.iso_i_ )
  35                         + String( "/" ) + String( dur.plet_.type_i_ );
  36         return str;
  37 }
  38
  39 #if 0
  40 int
  41 Duration_convert::dur2_i( Duration dur, int division_1_i )
  42 {
  43         return dur2_mom( dur ) * Moment( division_1_i );
  44 }
  45 #endif
  46
  47 int
  48 Duration_convert::dur2ticks_i( Duration dur )
  49 {
  50         if ( dur.ticks_i_ )
  51                 return dur.ticks_i_;
  52         return dur2_mom( dur ) * Moment( Duration::division_1_i_s );
  53 }
  54
  55
  56 int
  57 Duration_convert::i2_type(int i)
  58 {
  59     int t=0;
  60     while (!(i & 1)) {
  61         i >>= 1;
  62         t++;
  63             }
  64     return t;
  65 }
  66
  67 int
  68 Duration_convert::type2_i(int type)
  69 {
  70     if (type<0)
  71         return 0;
  72     else
  73         return 1 << type;
  74 }
  75
  76 Moment
  77 Duration_convert::dur2_mom( Duration dur )
  78 {
  79         if ( dur.ticks_i_ )
  80                 return Moment( dur.ticks_i_, Duration::division_1_i_s );
  81
  82         // or simply assert?
  83         if ( dur.durlog_i_<-10 )
  84                 return Moment( 0 );
  85         Moment mom;
  86         if (dur.durlog_i_<0)
  87             mom = Moment( type2_i( -dur.durlog_i_ ), 1 );
  88         else
  89             mom = Moment( 1 , type2_i( dur.durlog_i_ ) );
  90
  91         Moment delta = mom;
  92         while ( dur.dots_i_-- )
  93           {
  94                 delta /= 2.0;
  95                 mom += delta;
  96           }
  97
  98         return mom * plet_factor_mom( dur );
  99 }
 100
 101 #if 0
 102 Moment
 103 Duration_convert::i2_mom( int time_i, int division_1_i )
 104 {
 105         if ( !time_i )
 106                 return Moment( 0 );
 107
 108         if ( division_1_i > 0 )
 109                 return Moment( time_i, division_1_i );
 110         else
 111                 return Moment( -division_1_i, time_i );
 112 }
 113 #endif
 114
 115 Duration
 116 Duration_convert::mom2_dur( Moment mom )
 117 {
 118     if (!mom)
 119       {
 120         Duration dur;
 121         dur.set_plet(0,1);
 122         return dur;
 123       }
 124
 125
 126         Duration dur = mom2standardised_dur( mom );
 127 //      if ( !dur.mom() || ( dur.mom() == mom ) )
 128         if ( !dur.length() || ( dur.length() == mom ) )
 129                 return dur;
 130         assert( midi_as_plet_b_s );
 131
 132 //      dur.set_plet( type_mom, Duration::division_1_i_s / 4 );
 133
 134 //      Moment as_plet_mom = mom / dur.mom();
 135         Moment as_plet_mom = mom / dur.length();
 136         as_plet_mom *= dur.plet_.mom();
 137         long num = as_plet_mom.numerator().as_long();
 138         long den = as_plet_mom.denominator().as_long();
 139         dur.set_plet( num, den );
 140         return dur;
 141 }
 142
 143 Duration
 144 Duration_convert::mom2standardised_dur( Moment mom )
 145 {
 146 //      if ( !dur_array_s.length_i() )
 147         if ( !dur_array_s.size() )
 148                 set_array();
 149         assert( dur_array_s.size() );
 150         for ( int i = 0; i < dur_array_s.size() - 1; i++ )
 151           {
 152                 Moment lower_mom = dur2_mom( dur_array_s[ i ] );
 153                 if ( mom <= lower_mom )
 154                   {
 155                         // all arbitrary, but 3/4 will get rid of the noise...
 156                         // kinda ok
 157                         if ( i || ( mom / lower_mom > Moment( 3, 4 ) ) )
 158                                 return dur_array_s[ i ];
 159                         else
 160                           {
 161                             Duration d;
 162                             d.durlog_i_ = -100;
 163                             return d;
 164                           }
 165                   }
 166                 Moment upper_mom = dur2_mom( dur_array_s[ i + 1 ] );
 167                 if ( ( mom < upper_mom )
 168                          && ( ( mom - lower_mom ) / lower_mom
 169                                 < ( upper_mom - mom ) / upper_mom ) )
 170                         return dur_array_s[ i ];
 171           }
 172         return dur_array_s[ dur_array_s.size() - 1 ];
 173 }
 174
 175 void
 176 Duration_convert::set_array()
 177 {
 178         dur_array_s.clear();
 179
 180         Duration_iterator iter_dur;
 181         assert( iter_dur );
 182         while ( iter_dur )
 183                 dur_array_s.push( iter_dur++ );
 184 }
 185
 186
 187 Moment
 188 Duration_convert::plet_factor_mom( Duration dur )
 189 {
 190         return dur.plet_.mom();
 191 }
 192
 193 Real
 194 Duration_convert::sync_f( Duration dur, Moment mom )
 195 {
 196         return mom / dur2_mom( dur );
 197 }
 198
 199 Duration
 200 Duration_convert::ticks2_dur( int ticks_i )
 201 {
 202 //              Duration dur( 4, 0 );
 203 //              dur.set_plet( ticks_i, Duration::division_1_i_s / 4 );
 204
 205         Moment mom( ticks_i, Duration::division_1_i_s );
 206         if ( midi_as_plet_b_s )
 207                 return mom2_dur( mom );
 208
 209         Duration dur = mom2standardised_dur( mom );
 210
 211 //      if ( dur.mom() == mom )
 212         if ( dur.length() == mom )
 213                 return dur;
 214
 215 // huh?
 216 #if 0
 217         dur.durlog_i_ = -100;
 218         dur.dots_i_ = 0;
 219         dur.set_ticks( ticks_i );
 220         return dur;
 221 #else
 222         return mom2_dur( mom );
 223 #endif
 224 }
 225
 226 Duration
 227 Duration_convert::ticks2standardised_dur( int ticks_i )
 228 {
 229         Moment mom( ticks_i, Duration::division_1_i_s );
 230         Duration dur = mom2standardised_dur( mom );
 231         return dur;
 232 }
 233
 234 Duration_iterator::Duration_iterator()
 235 {
 236         cursor_dur_.durlog_i_ = 7;
 237         if ( Duration_convert::no_smaller_than_i_s )
 238                 cursor_dur_.durlog_i_ = Duration_convert::no_smaller_than_i_s;
 239 //      cursor_dur_.set_plet( 1, 1 );
 240 }
 241
 242 Duration
 243 Duration_iterator::operator ++(int)
 244 {
 245         return forward_dur();
 246 }
 247
 248 Duration
 249 Duration_iterator::operator ()()
 250 {
 251         return dur();
 252 }
 253
 254 Duration_iterator::operator bool()
 255 {
 256         return ok();
 257 }
 258
 259 Duration
 260 Duration_iterator::dur()
 261 {
 262         return cursor_dur_;
 263 }
 264
 265 Duration
 266 Duration_iterator::forward_dur()
 267 {
 268         /* should do smart table? guessing:
 269                 duration wholes
 270                 16      0.0625
 271                 32..    0.0703
 272                 8:2/3   0.0833
 273                 16.     0.0938
 274                 8       0.1250
 275                 16..    0.1406
 276         4:2/3   0.1667
 277                 8.      0.1875
 278
 279         */
 280         assert( ok() );
 281
 282         Duration dur = cursor_dur_;
 283
 284         if ( !cursor_dur_.dots_i_ && !cursor_dur_.plet_b() )
 285           {
 286                 cursor_dur_.durlog_i_ += 1;
 287                 cursor_dur_.dots_i_ = 2;
 288           }
 289         else if ( cursor_dur_.dots_i_ == 2 )
 290           {
 291                 assert( !cursor_dur_.plet_b() );
 292                 cursor_dur_.dots_i_ = 0;
 293                 cursor_dur_.durlog_i_ -=2;
 294                 cursor_dur_.set_plet( 2, 3 );
 295           }
 296         else if ( cursor_dur_.plet_b()
 297                 && ( cursor_dur_.plet_.iso_i_ == 2 )
 298                 && ( cursor_dur_.plet_.type_i_ == 3 ) )
 299                   {
 300                 assert( !cursor_dur_.dots_i_ );
 301                 cursor_dur_.set_plet( 1, 1 );
 302                 cursor_dur_.durlog_i_ += 1;
 303                 cursor_dur_.dots_i_ = 1;
 304           }
 305         else if ( cursor_dur_.dots_i_ == 1 )
 306           {
 307                 assert( !cursor_dur_.plet_b() );
 308                 cursor_dur_.dots_i_ = 0;
 309                 cursor_dur_.durlog_i_ -= 1;
 310           }
 311
 312         if ( Duration_convert::no_triplets_b_s
 313              && cursor_dur_.plet_b() && ok() )
 314             forward_dur();
 315         if ( Duration_convert::no_double_dots_b_s
 316              && ( cursor_dur_.dots_i_ == 2 ) && ok() )
 317                 forward_dur();
 318         if ( Duration_convert::no_smaller_than_i_s
 319              && ( cursor_dur_.durlog_i_ > Duration_convert::no_smaller_than_i_s ) && ok() )
 320                 forward_dur();
 321         if ( Duration_convert::no_smaller_than_i_s
 322              && cursor_dur_.dots_i_
 323              && ( cursor_dur_.durlog_i_ >= Duration_convert::no_smaller_than_i_s )
 324              && ok() )
 325                 forward_dur();
 326         if ( Duration_convert::no_smaller_than_i_s
 327              && ( cursor_dur_.dots_i_ == 2 )
 328              && ( cursor_dur_.durlog_i_ >= Duration_convert::no_smaller_than_i_s / 2 )
 329              && ok() )
 330                 forward_dur();
 331
 332         return dur;
 333 }
 334
 335 bool
 336 Duration_iterator::ok()
 337 {
 338         return ( cursor_dur_.durlog_i_
 339                 && !( ( cursor_dur_.durlog_i_ == 0 ) && ( cursor_dur_.dots_i_ > 2 ) ) );
 340 }