---- ../lilypond-1.3.76/CHANGES Fri Aug 4 02:29:02 2000
+--- ../lilypond-1.3.76/CHANGES Thu Aug 3 20:29:02 2000
+++ b/CHANGES Tue Aug 8 13:56:35 2000
+@@ -1,3 +1,14 @@
+1.3.76.jcn1
+===========
+
+* Midi2ly bugfix: don't correct quantised durations, don't use tuplets,
+ double dots etc. when user doesn't want them. It probably used to
+ work like this, a long time ago. For some unknown reason, all
+ corrections made by Duration_convert were junked if the corrected
+ duration != exact duration. Duh.
+
+* Midi2ly: added a new option: --no-rests.
+
+ 1.3.76
+ ======
+ --- ../lilypond-1.3.76/CHANGES Fri Aug 4 02:29:02 2000
++ b/CHANGES Mon Aug 7 00:19:35 2000
@@ -1,3 +1,12 @@
1.3.76.gp1
MAJOR_VERSION=1
MINOR_VERSION=3
PATCH_LEVEL=76
-MY_PATCH_LEVEL=gp1
+MY_PATCH_LEVEL=jcn1
# use the above to send patches: MY_PATCH_LEVEL is always empty for a
# released version.
#include "warn.hh"
// statics Duration_convert
-bool const Duration_convert::midi_as_plet_b_s = true;
bool Duration_convert::no_quantify_b_s = false;
bool Duration_convert::no_double_dots_b_s = false;
-bool Duration_convert::no_triplets_b_s = false;
+bool Duration_convert::no_tuplets_b_s = false;
int Duration_convert::no_smaller_than_i_s = 0;
Array<Duration> Duration_convert::dur_array_s;
dur.set_plet (0,1);
return dur;
}
-
- Duration dur = mom2standardised_dur (mom);
- // if (!dur.mom () || (dur.mom () == mom))
- if (!dur.length_mom () || (dur.length_mom () == mom))
- return dur;
- assert (midi_as_plet_b_s);
-
- // dur.set_plet (type_mom, Duration::division_1_i_s / 4);
-
- // Rational as_plet_mom = mom / dur.mom ();
- Rational as_plet_mom = mom / dur.length_mom ();
- as_plet_mom *= dur.plet_.mom ();
- long num = as_plet_mom.num ();
- long den = as_plet_mom.den ();
- dur.set_plet (num, den);
- return dur;
+ return mom2standardised_dur (mom);
}
Duration
{
dur_array_s.clear ();
- Duration_iterator iter_dur;
- assert (iter_dur);
- while (iter_dur)
- dur_array_s.push (iter_dur++);
+ Duration_iterator i;
+ dur_array_s.push (i.dur ());
+ while (i.ok ())
+ dur_array_s.push (i.forward_dur ());
}
Duration_convert::ticks2_dur (int ticks_i)
{
Rational mom (ticks_i, Duration::division_1_i_s);
- if (midi_as_plet_b_s)
- return mom2_dur (mom);
-
- Duration dur = mom2standardised_dur (mom);
-
- if (dur.length_mom () == mom)
- return dur;
-
- return mom2_dur (mom);
+ return mom2standardised_dur (mom);
}
Duration
return forward_dur ();
}
-Duration
-Duration_iterator::operator ()()
-{
- return dur ();
-}
-
-Duration_iterator::operator bool ()
-{
- return ok ();
-}
-
Duration
Duration_iterator::dur ()
{
*/
assert (ok ());
- Duration dur = cursor_dur_;
-
if (!cursor_dur_.dots_i_ && !cursor_dur_.plet_b ())
{
cursor_dur_.durlog_i_ += 1;
cursor_dur_.durlog_i_ -= 1;
}
- if (Duration_convert::no_triplets_b_s
+ if (Duration_convert::no_tuplets_b_s
&& cursor_dur_.plet_b () && ok ())
- forward_dur ();
+ return forward_dur ();
if (Duration_convert::no_double_dots_b_s
&& (cursor_dur_.dots_i_ == 2) && ok ())
- forward_dur ();
+ return forward_dur ();
if (Duration_convert::no_smaller_than_i_s
&& (cursor_dur_.durlog_i_ > Duration_convert::no_smaller_than_i_s) && ok ())
- forward_dur ();
+ return forward_dur ();
if (Duration_convert::no_smaller_than_i_s
&& cursor_dur_.dots_i_
&& (cursor_dur_.durlog_i_ >= Duration_convert::no_smaller_than_i_s)
&& ok ())
- forward_dur ();
+ return forward_dur ();
if (Duration_convert::no_smaller_than_i_s
&& (cursor_dur_.dots_i_ == 2)
&& (cursor_dur_.durlog_i_ >= Duration_convert::no_smaller_than_i_s / 2)
&& ok ())
- forward_dur ();
+ return forward_dur ();
- return dur;
+ return dur ();
}
bool
/* Urgh. statics.
*/
- static bool const midi_as_plet_b_s;
static bool no_quantify_b_s;
static bool no_double_dots_b_s;
- static bool no_triplets_b_s;
+ static bool no_tuplets_b_s;
static int no_smaller_than_i_s;
static Array<Duration> dur_array_s;
/// start at shortest: 128:2/3
Duration_iterator ();
- // **** what about these three here ?
/// return forward_dur ();
Duration operator ++(int);
- /// return ok ()
- operator bool ();
-
- /// return dur ()
- Duration operator ()();
-
-
/// return current dur
Duration dur ();
String midi2ly_version_str();
extern bool no_timestamps_b_g;;
+extern bool no_rests_b_g;;
#endif // MIDI2LY_GLOBAL_HH
void output (Mudela_stream& mudela_stream_r);
String get_clef () const;
Mudela_item * last_item_l_;
+ Mudela_note * last_note_l_;
private:
Mudela_staff* mudela_staff_l_;
Cons_list<Mudela_item> mudela_item_l_list_;
Mudela_score* mudela_score_l_g = 0;
bool no_timestamps_b_g = false;
+bool no_rests_b_g = false;
Sources source;
{0, "debug", 'd', _i ("enable debugging output")},
{0, "help", 'h', _i ("this help")},
{_i ("ACC[:MINOR]"), "key", 'k', _i ("set key: ACC +sharps/-flats; :1 minor")},
- {0, "no-silly", 'n', _i ("don't output tuplets or double dots, smallest is 32")},
+ {0, "no-silly", 'n', _i ("don't output tuplets, double dots or rests, smallest is 32")},
{_i ("FILE"), "output", 'o', _i ("set FILE as default output")},
{0, "no-tuplets", 'p', _i ("don't output tuplets")},
{0, "quiet", 'q', _i ("be quiet")},
+ {0, "no-rests", 'r', _i ("don't output rests or skips")},
{_i ("DUR"), "smallest", 's', _i ("set smallest duration")},
{0, "no-timestamps", 'T', _i ("don't timestamp the output")},
{0, "version", 'V', _i ("print version number")},
}
case 'n':
Duration_convert::no_double_dots_b_s = true;
- Duration_convert::no_triplets_b_s = true;
+ Duration_convert::no_tuplets_b_s = true;
Duration_convert::no_smaller_than_i_s = 5;
+ no_rests_b_g = true;
break;
case 'o':
output_str = getopt_long.optional_argument_ch_C_;
break;
case 'p':
- Duration_convert::no_triplets_b_s = true;
+ Duration_convert::no_tuplets_b_s = true;
break;
case 'q':
level_ver = QUIET_ver;
break;
+ case 'r':
+ no_rests_b_g = true;
+ break;
case 'T':
no_timestamps_b_g = true;
break;
source.set_binary (true);
source.set_path (&path);
+ LOGOUT (NORMAL_ver) << "\n";
+ LOGOUT (NORMAL_ver) << _f ("no_double_dots: %d\n",
+ Duration_convert::no_double_dots_b_s);
+ LOGOUT (NORMAL_ver) << _f ("no_rests: %d\n",
+ no_rests_b_g);
+ LOGOUT (NORMAL_ver) << _f ("no_quantify_b_s: %d\n",
+ Duration_convert::no_quantify_b_s);
+ LOGOUT (NORMAL_ver) << _f ("no_smaller_than: %d (1/%d)\n",
+ Duration_convert::no_smaller_than_i_s,
+ Duration_convert::type2_i (Duration_convert::no_smaller_than_i_s));
+ LOGOUT (NORMAL_ver) << _f ("no_tuplets: %d\n",
+ Duration_convert::no_tuplets_b_s);
+
char const* arg_sz = 0;
while ( (arg_sz = getopt_long.get_next_arg ()))
{
/**
Walk ITEMS and find voices. Remove categorised items.
- TODO: collect all channels into separate voices. Use chords for sim
- notes on same channel.
+ TODO:
+
+ * collect all channels into separate voices. Use chords for sim
+ notes on same channel.
+ * assume voices/assume chords modes.
*/
void
Cons<Mudela_item>* i = *pp;
if (i->car_->at_mom () > mom)
{
- Rational dur = i->car_->at_mom () - mom;
- // ugh, need score
- Mudela_column* start = mudela_score_l_g->find_column_l (mom);
- voice_p->add_item (new Mudela_skip (start, dur));
+ if (no_rests_b_g && voice_p->last_note_l_)
+ {
+ voice_p->last_note_l_->end_column_l_ = i->car_->mudela_column_l_;
+ }
+ else
+ {
+ /* uh, what about quantisation? This should probably
+ use mom2standardised_dur ()
+ arg, urg: skip should get duration from start/end columns!
+ */
+
+ Rational r = i->car_->at_mom () - mom;
+ // ugh, need score
+ Mudela_column* start = mudela_score_l_g->find_column_l (mom);
+ voice_p->add_item (new Mudela_skip (start, r));
+ }
+
mom = i->car_->at_mom ();
continue; // unnecessary
}
for (Cons<Mudela_item> *cp = i; cp && cp->car_->at_mom () == mom; cp = cp->next_)
now_items.push (i->car_);
+#if 0
+ /*
+ Why don't we use <note>, if voice has:
+
+ <note> <key-change>
+
+ we'd get last_item == key_change -> last_note == 0;
+ */
Mudela_note * last_note = dynamic_cast<Mudela_note*> (voice_p->last_item_l_);
+#else
+ /*
+ Not sure, is this better?
+ */
+ Mudela_note * last_note = voice_p->last_note_l_;
+#endif
+
Link_array<Mudela_item> candidates;
for (int i=0; last_note && i < now_items.size (); i++)
{
mudela_staff_l_ = mudela_staff_l;
last_item_l_ =0;
+ last_note_l_ =0;
}
void
Mudela_voice::add_item (Mudela_item* mudela_item_l)
{
last_item_l_ = mudela_item_l;
+ if (Mudela_note* n = dynamic_cast<Mudela_note*> (mudela_item_l))
+ {
+ last_note_l_ = n;
+ }
mudela_item_l_list_.append (new Cons<Mudela_item> (mudela_item_l, 0));
}