lib/duration.cc

   1 //
   2 // duration.cc -- implement Duration, Plet, Duration_convert, Duration_iterator
   3 //
   4 // copyright 1997 Jan Nieuwenhuizen <jan@digicash.com>
   5
   6 // split into 4?
   7
   8 #include "proto.hh"
   9 #include "plist.hh"
  10 #include "string.hh"
  11 #include "source-file.hh"
  12 #include "source.hh"
  13 #include "moment.hh"
  14 #include "duration.hh"
  15 #include "debug.hh"  //ugh
  16
  17 // statics Duration
  18 int Duration::division_1_i_s = 384 * 4;
  19
  20 Duration::Duration( int type_i, int dots_i = 0, Plet* plet_l )
  21 {
  22         type_i_ = type_i;
  23         dots_i_ = dots_i;
  24         plet_p_ = 0;
  25         ticks_i_ = 0;
  26         set_plet( plet_l );
  27 }
  28
  29 Duration::Duration( Duration const& dur_c_r )
  30 {
  31         type_i_ = 0;
  32         dots_i_ = 0;
  33         plet_p_ = 0;
  34         ticks_i_ = 0;
  35         *this = dur_c_r;
  36 }
  37
  38 Duration::~Duration()
  39 {
  40         delete plet_p_;
  41 }
  42
  43 Duration const&
  44 Duration::operator =( Duration const& dur_c_r )
  45 {
  46         if ( &dur_c_r == this )
  47                 return *this;
  48
  49         type_i_ = dur_c_r.type_i_;
  50         dots_i_ = dur_c_r.dots_i_;
  51         ticks_i_ = dur_c_r.ticks_i_;
  52         set_plet( dur_c_r.plet_p_ );
  53
  54         return *this;
  55 }
  56
  57 void
  58 Duration::set_plet( Plet* plet_l )
  59 {
  60         delete plet_p_;
  61         plet_p_ = 0;
  62         if ( plet_l )
  63                 plet_p_ = new Plet( *plet_l );
  64 }
  65
  66 void
  67 Duration::set_ticks( int ticks_i )
  68 {
  69         assert( !type_i_ );
  70         assert( !dots_i_ );
  71         assert( !plet_p_ );
  72         ticks_i_ = ticks_i;
  73 }
  74
  75 Plet::Plet( int iso_i, int type_i )
  76 {
  77         iso_i_ = iso_i;
  78         type_i_ = type_i;
  79 }
  80
  81 Plet::Plet( Plet const& plet_c_r )
  82 {
  83         iso_i_ = plet_c_r.iso_i_;
  84         type_i_ = plet_c_r.type_i_;
  85 }
  86
  87 // statics Duration_convert
  88 bool Duration_convert::be_blonde_b_s = false;
  89 bool Duration_convert::no_double_dots_b_s = false;
  90 bool Duration_convert::no_triplets_b_s = false;
  91 int Duration_convert::no_smaller_than_i_s = 0;
  92
  93 String
  94 Duration_convert::dur2_str( Duration dur )
  95 {
  96         if ( dur.ticks_i_ )
  97                 return String( "["  ) + String( dur.ticks_i_ ) + "]";
  98
  99         String str( dur.type_i_ );
 100         str += String( '.', dur.dots_i_ );
 101         if ( dur.plet_p_ )
 102                 str += String( "*" ) + String( dur.plet_p_->iso_i_ )
 103                         + String( "/" ) + String( dur.plet_p_->type_i_ );
 104         return str;
 105 }
 106
 107 #if 0
 108 int
 109 Duration_convert::dur2_i( Duration dur, int division_1_i )
 110 {
 111         return dur2_mom( dur ) * Moment( division_1_i );
 112 }
 113 #endif
 114
 115 int
 116 Duration_convert::dur2ticks_i( Duration dur )
 117 {
 118         if ( dur.ticks_i_ )
 119                 return dur.ticks_i_;
 120         return dur2_mom( dur ) * Moment( Duration::division_1_i_s );
 121 }
 122
 123 Moment
 124 Duration_convert::dur2_mom( Duration dur )
 125 {
 126         if ( dur.ticks_i_ )
 127                 return Moment( dur.ticks_i_, Duration::division_1_i_s );
 128
 129         // or simply assert?
 130         if ( !dur.type_i_ )
 131                 return Moment( 0 );
 132
 133         Moment mom = Moment( 1 , dur.type_i_ );
 134
 135         Moment delta = mom;
 136         while ( dur.dots_i_-- ) {
 137                 delta /= 2.0;
 138                 mom += delta;
 139         }
 140
 141         return mom * plet_factor_mom( dur );
 142 }
 143
 144 #if 0
 145 Moment
 146 Duration_convert::i2_mom( int time_i, int division_1_i )
 147 {
 148         if ( !time_i )
 149                 return Moment( 0 );
 150
 151         if ( division_1_i > 0 )
 152                 return Moment( time_i, division_1_i );
 153         else
 154                 return Moment( -division_1_i, time_i );
 155 }
 156 #endif
 157
 158 #if 0
 159 Duration
 160 Duration_convert::mom2_dur( Moment mom )
 161 {
 162         /* this is cute,
 163            but filling an array using Duration_iterator
 164            might speed things up, a little
 165            */
 166         Duration_iterator iter_dur;
 167         assert( iter_dur );
 168         while ( iter_dur ) {
 169                 Duration lower_dur = iter_dur++;
 170                 Duration upper_dur( 0 );
 171                 if ( iter_dur )
 172                         upper_dur = iter_dur();
 173                 Moment lower_mom = dur2_mom( lower_dur );
 174                 Moment upper_mom = dur2_mom( upper_dur );
 175                 if ( mom == lower_mom )
 176                         return lower_dur;
 177                 if ( mom == upper_mom ) // don-t miss last (sic)
 178                         return upper_dur;
 179                 if ( ( mom >= lower_mom ) && ( mom <= upper_mom ) ) {
 180                         warning( String( "duration not exact: " ) + String( (Real)mom ) , 0 );
 181                         if ( abs( mom - lower_mom ) < abs( mom - upper_mom ) )
 182                                 return lower_dur;
 183                         else
 184                                 return upper_dur;
 185                 }
 186                 lower_dur = upper_dur;
 187         }
 188         return Duration( 0 );
 189 }
 190 #endif
 191
 192 Moment
 193 Duration_convert::plet_factor_mom( Duration dur )
 194 {
 195         if ( !dur.plet_p_ )
 196                 return 1;
 197         return Moment( dur.plet_p_->iso_i_, dur.plet_p_->type_i_ );
 198 }
 199
 200 Real
 201 Duration_convert::sync_f( Duration dur, Moment mom )
 202 {
 203         return mom / dur2_mom( dur );
 204 }
 205
 206 Duration
 207 Duration_convert::ticks2_dur( int ticks_i )
 208 {
 209         /* this is cute,
 210            but filling an array using Duration_iterator
 211            might speed things up, a little
 212            */
 213         Moment mom( ticks_i, Duration::division_1_i_s );
 214         Duration_iterator iter_dur;
 215         assert( iter_dur );
 216         while ( iter_dur ) {
 217                 Duration dur = iter_dur++;
 218                 if ( mom == dur2_mom( dur ) )
 219                         return dur;
 220         }
 221         Duration dur( 0 );
 222         dur.set_ticks( ticks_i );
 223         return dur;
 224 }
 225
 226 Duration
 227 Duration_convert::ticks2standardised_dur( int ticks_i )
 228 {
 229         /* this is cute,
 230            but filling an array using Duration_iterator
 231            might speed things up, a little
 232            */
 233         Moment mom( ticks_i, Duration::division_1_i_s );
 234         Duration_iterator iter_dur;
 235         assert( iter_dur );
 236         while ( iter_dur ) {
 237                 Duration lower_dur = iter_dur++;
 238 //              Duration upper_dur( 0 );
 239                 Duration upper_dur( 1, 1 );
 240                 if ( iter_dur )
 241                         upper_dur = iter_dur();
 242                 Moment lower_mom = dur2_mom( lower_dur );
 243                 Moment upper_mom = dur2_mom( upper_dur );
 244                 if ( mom < lower_mom )
 245                         return lower_dur;
 246                 if ( mom == lower_mom )
 247                         return lower_dur;
 248                 if ( mom == upper_mom ) // don-t miss last (sic)
 249                         return upper_dur;
 250                 if ( ( mom >= lower_mom ) && ( mom <= upper_mom ) ) {
 251                         warning( String( "duration not exact: " ) + String( (Real)mom ) , 0 );
 252                         if ( abs( mom - lower_mom ) < abs( mom - upper_mom ) )
 253                                 return lower_dur;
 254                         else
 255                                 return upper_dur;
 256                 }
 257                 lower_dur = upper_dur;
 258         }
 259         return iter_dur();
 260 }
 261
 262 Duration_iterator::Duration_iterator()
 263 {
 264         cursor_dur_.type_i_ = 128;
 265         if ( Duration_convert::no_smaller_than_i_s )
 266                 cursor_dur_.type_i_ = Duration_convert::no_smaller_than_i_s;
 267         cursor_dur_.set_plet( 0 );
 268 }
 269
 270 Duration
 271 Duration_iterator::operator ++(int)
 272 {
 273         return forward_dur();
 274 }
 275
 276 Duration
 277 Duration_iterator::operator ()()
 278 {
 279         return dur();
 280 }
 281
 282 Duration_iterator::operator bool()
 283 {
 284         return ok();
 285 }
 286
 287 Duration
 288 Duration_iterator::dur()
 289 {
 290         return cursor_dur_;
 291 }
 292
 293 Duration
 294 Duration_iterator::forward_dur()
 295 {
 296         // should do smart table? guessing:
 297         //      duration wholes
 298         //      16      0.0625
 299         //      32..    0.0703
 300         //      8:2/3   0.0833
 301         //      16.     0.0938
 302         //      8       0.1250
 303         //      16..    0.1406
 304         //      4:2/3   0.1667
 305         //      8.      0.1875
 306
 307         assert( ok() );
 308
 309         Duration dur = cursor_dur_;
 310
 311         if ( !cursor_dur_.dots_i_ && !cursor_dur_.plet_p_ ) {
 312                 cursor_dur_.type_i_ *= 2;
 313                 cursor_dur_.dots_i_ = 2;
 314         }
 315         else if ( cursor_dur_.dots_i_ == 2 ) {
 316                 assert( !cursor_dur_.plet_p_ );
 317                 cursor_dur_.dots_i_ = 0;
 318                 cursor_dur_.type_i_ /= 4;
 319                 cursor_dur_.set_plet( &Plet( 2, 3 ) );
 320         }
 321         else if ( cursor_dur_.plet_p_
 322                 && ( cursor_dur_.plet_p_->iso_i_ == 2 )
 323                 && ( cursor_dur_.plet_p_->type_i_ == 3 ) ) {
 324                 assert( !cursor_dur_.dots_i_ );
 325                 cursor_dur_.set_plet( 0 );
 326                 cursor_dur_.type_i_ *= 2;
 327                 cursor_dur_.dots_i_ = 1;
 328         }
 329         else if ( cursor_dur_.dots_i_ == 1 ) {
 330                 assert( !cursor_dur_.plet_p_ );
 331                 cursor_dur_.dots_i_ = 0;
 332                 cursor_dur_.type_i_ /= 2;
 333         }
 334
 335         if ( Duration_convert::no_triplets_b_s && cursor_dur_.plet_p_ && ok() )
 336                 forward_dur();
 337         if ( Duration_convert::no_double_dots_b_s && ( cursor_dur_.dots_i_ == 2 ) && ok() )
 338                 forward_dur();
 339         if ( Duration_convert::no_smaller_than_i_s && ( cursor_dur_.type_i_ > Duration_convert::no_smaller_than_i_s ) && ok() )
 340                 forward_dur();
 341         if ( Duration_convert::no_smaller_than_i_s && cursor_dur_.dots_i_ && ( cursor_dur_.type_i_ >= Duration_convert::no_smaller_than_i_s ) && ok() )
 342                 forward_dur();
 343         if ( Duration_convert::no_smaller_than_i_s && ( cursor_dur_.dots_i_ == 2 ) && ( cursor_dur_.type_i_ >= Duration_convert::no_smaller_than_i_s / 2 ) && ok() )
 344                 forward_dur();
 345
 346         return dur;
 347 }
 348
 349 bool
 350 Duration_iterator::ok()
 351 {
 352         return ( cursor_dur_.type_i_
 353                 && !( ( cursor_dur_.type_i_ == 1 ) && ( cursor_dur_.dots_i_ > 2 ) ) );
 354 }