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( dur.type_i_ );
  28         str += String( '.', dur.dots_i_ );
  29         if ( dur.plet_b())
  30                 str += String( "*" ) + String( dur.plet_.iso_i_ )
  31                         + String( "/" ) + String( dur.plet_.type_i_ );
  32         return str;
  33 }
  34
  35 #if 0
  36 int
  37 Duration_convert::dur2_i( Duration dur, int division_1_i )
  38 {
  39         return dur2_mom( dur ) * Moment( division_1_i );
  40 }
  41 #endif
  42
  43 int
  44 Duration_convert::dur2ticks_i( Duration dur )
  45 {
  46         if ( dur.ticks_i_ )
  47                 return dur.ticks_i_;
  48         return dur2_mom( dur ) * Moment( Duration::division_1_i_s );
  49 }
  50
  51 Moment
  52 Duration_convert::dur2_mom( Duration dur )
  53 {
  54         if ( dur.ticks_i_ )
  55                 return Moment( dur.ticks_i_, Duration::division_1_i_s );
  56
  57         // or simply assert?
  58         if ( !dur.type_i_ )
  59                 return Moment( 0 );
  60
  61         Moment mom = Moment( 1 , dur.type_i_ );
  62
  63         Moment delta = mom;
  64         while ( dur.dots_i_-- ) {
  65                 delta /= 2.0;
  66                 mom += delta;
  67         }
  68
  69         return mom * plet_factor_mom( dur );
  70 }
  71
  72 #if 0
  73 Moment
  74 Duration_convert::i2_mom( int time_i, int division_1_i )
  75 {
  76         if ( !time_i )
  77                 return Moment( 0 );
  78
  79         if ( division_1_i > 0 )
  80                 return Moment( time_i, division_1_i );
  81         else
  82                 return Moment( -division_1_i, time_i );
  83 }
  84 #endif
  85
  86 Duration
  87 Duration_convert::mom2_dur( Moment mom )
  88 {
  89     if (!mom) {
  90         Duration dur;
  91         dur.set_plet(0,1);
  92         return dur;
  93     }
  94
  95
  96         Duration dur = mom2standardised_dur( mom );
  97 //      if ( !dur.mom() || ( dur.mom() == mom ) )
  98         if ( !dur.length() || ( dur.length() == mom ) )
  99                 return dur;
 100         assert( midi_as_plet_b_s );
 101
 102 //      dur.set_plet( type_mom, Duration::division_1_i_s / 4 );
 103
 104 //      Moment as_plet_mom = mom / dur.mom();
 105         Moment as_plet_mom = mom / dur.length();
 106         as_plet_mom *= dur.plet_.mom();
 107         long num = as_plet_mom.numerator().as_long();
 108         long den = as_plet_mom.denominator().as_long();
 109         dur.set_plet( num, den );
 110         return dur;
 111 }
 112
 113 Duration
 114 Duration_convert::mom2standardised_dur( Moment mom )
 115 {
 116 //      if ( !dur_array_s.length_i() )
 117         if ( !dur_array_s.size() )
 118                 set_array();
 119         assert( dur_array_s.size() );
 120         for ( int i = 0; i < dur_array_s.size() - 1; i++ ) {
 121                 Moment lower_mom = dur2_mom( dur_array_s[ i ] );
 122                 if ( mom <= lower_mom ) {
 123                         // all arbitrary, but 3/4 will get rid of the noise...
 124                         // kinda ok
 125                         if ( i || ( mom / lower_mom > Moment( 3, 4 ) ) )
 126                                 return dur_array_s[ i ];
 127                         else {
 128                             Duration d;
 129                             d.type_i_ = 0;
 130                             return d;
 131                         }
 132                 }
 133                 Moment upper_mom = dur2_mom( dur_array_s[ i + 1 ] );
 134                 if ( ( mom < upper_mom )
 135                          && ( ( mom - lower_mom ) / lower_mom
 136                                 < ( upper_mom - mom ) / upper_mom ) )
 137                         return dur_array_s[ i ];
 138         }
 139         return dur_array_s[ dur_array_s.size() - 1 ];
 140 }
 141
 142 void
 143 Duration_convert::set_array()
 144 {
 145         dur_array_s.clear();
 146
 147         Duration_iterator iter_dur;
 148         assert( iter_dur );
 149         while ( iter_dur )
 150                 dur_array_s.push( iter_dur++ );
 151 }
 152
 153
 154 Moment
 155 Duration_convert::plet_factor_mom( Duration dur )
 156 {
 157         return dur.plet_.mom();
 158 }
 159
 160 Real
 161 Duration_convert::sync_f( Duration dur, Moment mom )
 162 {
 163         return mom / dur2_mom( dur );
 164 }
 165
 166 Duration
 167 Duration_convert::ticks2_dur( int ticks_i )
 168 {
 169 //              Duration dur( 4, 0 );
 170 //              dur.set_plet( ticks_i, Duration::division_1_i_s / 4 );
 171
 172         Moment mom( ticks_i, Duration::division_1_i_s );
 173         if ( midi_as_plet_b_s )
 174                 return mom2_dur( mom );
 175
 176         Duration dur = mom2standardised_dur( mom );
 177
 178 //      if ( dur.mom() == mom )
 179         if ( dur.length() == mom )
 180                 return dur;
 181
 182 // huh?
 183 #if 0
 184         dur.type_i_ = 0;
 185         dur.dots_i_ = 0;
 186         dur.set_ticks( ticks_i );
 187         return dur;
 188 #else
 189         return mom2_dur( mom );
 190 #endif
 191 }
 192
 193 Duration
 194 Duration_convert::ticks2standardised_dur( int ticks_i )
 195 {
 196         Moment mom( ticks_i, Duration::division_1_i_s );
 197         Duration dur = mom2standardised_dur( mom );
 198         return dur;
 199 }
 200
 201 Duration_iterator::Duration_iterator()
 202 {
 203         cursor_dur_.type_i_ = 128;
 204         if ( Duration_convert::no_smaller_than_i_s )
 205                 cursor_dur_.type_i_ = Duration_convert::no_smaller_than_i_s;
 206 //      cursor_dur_.set_plet( 1, 1 );
 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                 cursor_dur_.type_i_ *= 2;
 253                 cursor_dur_.dots_i_ = 2;
 254         }
 255         else if ( cursor_dur_.dots_i_ == 2 ) {
 256                 assert( !cursor_dur_.plet_b() );
 257                 cursor_dur_.dots_i_ = 0;
 258                 cursor_dur_.type_i_ /= 4;
 259                 cursor_dur_.set_plet( 2, 3 );
 260         }
 261         else if ( cursor_dur_.plet_b()
 262                 && ( cursor_dur_.plet_.iso_i_ == 2 )
 263                 && ( cursor_dur_.plet_.type_i_ == 3 ) ) {
 264                 assert( !cursor_dur_.dots_i_ );
 265                 cursor_dur_.set_plet( 1, 1 );
 266                 cursor_dur_.type_i_ *= 2;
 267                 cursor_dur_.dots_i_ = 1;
 268         }
 269         else if ( cursor_dur_.dots_i_ == 1 ) {
 270                 assert( !cursor_dur_.plet_b() );
 271                 cursor_dur_.dots_i_ = 0;
 272                 cursor_dur_.type_i_ /= 2;
 273         }
 274
 275         if ( Duration_convert::no_triplets_b_s
 276              && cursor_dur_.plet_b() && ok() )
 277             forward_dur();
 278         if ( Duration_convert::no_double_dots_b_s
 279              && ( cursor_dur_.dots_i_ == 2 ) && ok() )
 280                 forward_dur();
 281         if ( Duration_convert::no_smaller_than_i_s
 282              && ( cursor_dur_.type_i_ > Duration_convert::no_smaller_than_i_s ) && ok() )
 283                 forward_dur();
 284         if ( Duration_convert::no_smaller_than_i_s
 285              && cursor_dur_.dots_i_
 286              && ( cursor_dur_.type_i_ >= Duration_convert::no_smaller_than_i_s )
 287              && ok() )
 288                 forward_dur();
 289         if ( Duration_convert::no_smaller_than_i_s
 290              && ( cursor_dur_.dots_i_ == 2 )
 291              && ( cursor_dur_.type_i_ >= Duration_convert::no_smaller_than_i_s / 2 )
 292              && ok() )
 293                 forward_dur();
 294
 295         return dur;
 296 }
 297
 298 bool
 299 Duration_iterator::ok()
 300 {
 301         return ( cursor_dur_.type_i_
 302                 && !( ( cursor_dur_.type_i_ == 1 ) && ( cursor_dur_.dots_i_ > 2 ) ) );
 303 }