X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=lily%2Fbeaming-pattern.cc;h=46a46a5d2ea529aa4c1e09836413f4ee0b708d05;hb=97a0169312a260933246ab224e4f8b0969871dd5;hp=a0fa25e7f7a782b2aeba4fa045492ec6c89cfb9a;hpb=bb8a0a5387af94dd2702877256334b160575a730;p=lilypond.git diff --git a/lily/beaming-pattern.cc b/lily/beaming-pattern.cc index a0fa25e7f7..46a46a5d2e 100644 --- a/lily/beaming-pattern.cc +++ b/lily/beaming-pattern.cc @@ -1,7 +1,7 @@ /* This file is part of LilyPond, the GNU music typesetter. - Copyright (C) 1999--2011 Han-Wen Nienhuys + Copyright (C) 1999--2015 Han-Wen Nienhuys LilyPond is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -19,6 +19,7 @@ #include "context.hh" #include "beaming-pattern.hh" +#include "misc.hh" /* Represents a stem belonging to a beam. Sometimes (for example, if the stem @@ -39,16 +40,20 @@ Beam_rhythmic_element::Beam_rhythmic_element () beam_count_drul_[LEFT] = 0; beam_count_drul_[RIGHT] = 0; invisible_ = false; - + factor_ = Rational (1); + tuplet_start_ = false; } -Beam_rhythmic_element::Beam_rhythmic_element (Moment m, int i, bool inv) +Beam_rhythmic_element::Beam_rhythmic_element (Moment m, int i, bool inv, + Rational factor, bool tuplet_start) { start_moment_ = m; rhythmic_importance_ = 0; beam_count_drul_[LEFT] = i; beam_count_drul_[RIGHT] = i; invisible_ = inv; + factor_ = factor; + tuplet_start_ = tuplet_start; } void @@ -97,16 +102,19 @@ Beaming_pattern::flag_direction (Beaming_options const &options, vsize i) const if (count <= left_count && count <= right_count) return CENTER; - - // Try to avoid sticking-out flags as much as possible by pointing my flags - // at the neighbour with the most flags. - else if (right_count > left_count) - return RIGHT; - else if (left_count > right_count) - return LEFT; + else if (!options.strict_beat_beaming_) + { + // Try to avoid sticking-out flags as much as possible by pointing + // my flags at the neighbor with the most flags. + if (right_count > left_count) + return RIGHT; + else if (left_count > right_count) + return LEFT; + } // If all else fails, point the beamlet away from the important moment. - return (infos_[i].rhythmic_importance_ <= infos_[i + 1].rhythmic_importance_) ? RIGHT : LEFT; + return (infos_[i].rhythmic_importance_ < infos_[i + 1].rhythmic_importance_) + ? RIGHT : LEFT; } void @@ -121,11 +129,11 @@ Beaming_pattern::de_grace () void Beaming_pattern::beamify (Beaming_options const &options) { - unbeam_invisible_stems (); - if (infos_.size () <= 1) return; + unbeam_invisible_stems (); + if (infos_[0].start_moment_.grace_part_) de_grace (); @@ -135,68 +143,173 @@ Beaming_pattern::beamify (Beaming_options const &options) find_rhythmic_importance (options); + vector flag_directions; + // Get the initial flag directions + for (vsize i = 0; i < infos_.size (); i++) + flag_directions.push_back (flag_direction (options, i)); + + // Correct flag directions for subdivision for (vsize i = 1; i < infos_.size () - 1; i++) { - Direction non_flag_dir = other_dir (flag_direction (options, i)); - if (non_flag_dir) + if ((flag_directions[i] == CENTER) && (flag_directions[i - 1] == LEFT)) + flag_directions[i] = RIGHT; + if ((flag_directions[i] == CENTER) && (flag_directions[i + 1] == RIGHT)) + flag_directions[i] = LEFT; + } + + // Set the count on each side of the stem + // We need to run this code twice to make both the + // left and the right counts work properly + for (int i = 0; i < 2; i++) + for (vsize i = 1; i < infos_.size () - 1; i++) + { + Direction non_flag_dir = -flag_directions[i]; + if (non_flag_dir) + { + int count = + (infos_[i + 1].rhythmic_importance_ < 0 && + options.subdivide_beams_) + // we're left of a subdivision + ? (i != infos_.size () - 2) + // respect the beam count for shortened beams ... + ? max (beam_count_for_rhythmic_position (i + 1), + beam_count_for_length (remaining_length (i + 1))) + // ... except if there's only one trailing stem + : beam_count_for_rhythmic_position (i + 1) + + // we're at any other stem + : min (min (infos_[i].count (non_flag_dir), + infos_[i + non_flag_dir].count (-non_flag_dir)), + infos_[i - non_flag_dir].count (non_flag_dir)); + + // Ensure at least one beam is left, even for groups longer than 1/8 + count = max (count, 1); + + infos_[i].beam_count_drul_[non_flag_dir] = count; + } + } +} + +/* + Set the tuplet start moment as necessary +*/ +void +update_tuplet (Moment start_moment, Rational factor, Moment *tuplet_start_moment) +{ + int tuplet_number = (int) factor.den (); + if ((tuplet_number > 1) && (tuplet_start_moment->num () < 0)) + *tuplet_start_moment = start_moment; + else if (tuplet_number == 1) + *tuplet_start_moment = Moment (-1, 1); +} + +/* + Get the group start position, the next group starting position, and the + next beat starting position, given start_moment, base_moment, + grouping, and factor +*/ +void +find_location (SCM grouping, Moment base_moment, Moment start_moment, + Rational factor, Moment *group_pos, Moment *next_group_pos, + Moment *next_beat_pos) +{ + *group_pos = Moment (0); + *next_group_pos = Moment (0); + *next_beat_pos = base_moment; + + while (*next_beat_pos <= start_moment) + *next_beat_pos += base_moment; + + while (*next_group_pos < *next_beat_pos) + { + I64 group_count = 1; //default -- 1 base moments in a beam + if (scm_is_pair (grouping)) { - int importance = (non_flag_dir == LEFT) - ? infos_[i].rhythmic_importance_ : infos_[i + 1].rhythmic_importance_; - int count = (importance < 0 && options.subdivide_beams_) - ? 1 : min (infos_[i].count (non_flag_dir), - infos_[i + non_flag_dir].count (-non_flag_dir)); + group_count = scm_to_int (scm_car (grouping)); + grouping = scm_cdr (grouping); + } - infos_[i].beam_count_drul_[non_flag_dir] = count; + // If we have a tuplet, the count should be determined from + // the maximum tuplet size for beamed tuplets. + U64 tuplet_number = factor.den (); + if (tuplet_number > 1U) + { + // We use 1/8 as the base moment for the tuplet because it's + // the largest beamed value. If the tuplet is shorter, it's + // OK, the code still works + I64 test_count = ( Moment (Rational (1, 8) / factor) / base_moment).num (); + if (test_count > group_count) group_count = test_count; } + *group_pos = *next_group_pos; + *next_group_pos = *group_pos + Rational(group_count) * base_moment; } } void Beaming_pattern::find_rhythmic_importance (Beaming_options const &options) { - Moment measure_pos (0); + Moment group_pos (0); // 0 is the start of the first group + Moment next_group_pos (0); + Moment next_beat_pos (options.base_moment_); + Moment tuplet_start_moment (-1, 1); + I64 tuplet_number = 1; + SCM grouping = options.grouping_; vsize i = 0; + // Find where we are in the beat structure of the measure + if (infos_.size ()) + find_location (grouping, options.base_moment_, infos_[i].start_moment_, + infos_[i].factor_, &group_pos, &next_group_pos, &next_beat_pos); + // Mark the importance of stems that start at a beat or a beat group. while (i < infos_.size ()) { - // If a beat grouping is not specified, default to 2 beats per group. - int count = 2; - if (scm_is_pair (grouping)) - { - count = scm_to_int (scm_car (grouping)); - grouping = scm_cdr (grouping); - } - + if ((next_beat_pos > next_group_pos) + || (infos_[i].start_moment_ > next_beat_pos)) + // Find the new group ending point + find_location (grouping, options.base_moment_, infos_[i].start_moment_, + infos_[i].factor_, &group_pos, &next_group_pos, &next_beat_pos); // Mark the start of this beat group - if (infos_[i].start_moment_ == measure_pos) + if (infos_[i].start_moment_ == group_pos) infos_[i].rhythmic_importance_ = -2; - - // Mark the start of each unit up to the end of this beat group. - for (int unit = 1; unit <= count; unit++) + // Work through the end of the beat group or the end of the beam + while (i < infos_.size () && infos_[i].start_moment_ < next_group_pos) { - Moment next_measure_pos = measure_pos + options.base_moment_; - - while (i < infos_.size () && infos_[i].start_moment_ < next_measure_pos) + // Set the tuplet start as necessary + update_tuplet (infos_[i].start_moment_, infos_[i].factor_, &tuplet_start_moment); + Moment dt = infos_[i].start_moment_ - group_pos; + Rational tuplet = infos_[i].factor_; + Moment tuplet_moment (tuplet); + Moment tuplet_dt = infos_[i].start_moment_ - tuplet_start_moment; + tuplet_number = tuplet.den (); + // set the beat end and increment the next beat + if (infos_[i].start_moment_ == next_beat_pos) { - Moment dt = infos_[i].start_moment_ - measure_pos; - - // The rhythmic importance of a stem between beats depends on its fraction - // of a beat: those stems with a lower denominator are deemed more - // important. - // FIXME: This is not the right way to do things for tuplets. For example, - // in an 8th-note triplet with a quarter-note beat, 1/3 of a beat should be - // more important than 1/2. - if (infos_[i].rhythmic_importance_ >= 0) - infos_[i].rhythmic_importance_ = (int) (dt / options.base_moment_).den (); - - i++; + infos_[i].rhythmic_importance_ = -1; + next_beat_pos += options.base_moment_; } + // The rhythmic importance of a stem between beats depends on its fraction + // of a beat: those stems with a lower denominator are deemed more + // important. For tuplets, we need to make sure that we use + // the fraction of the tuplet, instead of the fraction of + // a beat. + Moment ratio = (tuplet_number == 1) + ? dt / options.base_moment_ + : tuplet_dt / Moment (1, 8) / tuplet_moment; + if (infos_[i].rhythmic_importance_ >= 0) + infos_[i].rhythmic_importance_ = (int) ratio.den (); + + i++; + } - measure_pos = next_measure_pos; - if (i < infos_.size () && infos_[i].start_moment_ == measure_pos) + if (i < infos_.size () && infos_[i].start_moment_ == next_beat_pos) + { + if (tuplet_number == 1) infos_[i].rhythmic_importance_ = -1; + next_beat_pos += options.base_moment_; + if (infos_[i].start_moment_ == next_group_pos) + infos_[i].rhythmic_importance_ = -2; } } } @@ -217,19 +330,20 @@ Beaming_pattern::unbeam_invisible_stems () infos_[i].beam_count_drul_[RIGHT] = b; } - for (vsize i = infos_.size (); i--;) - if (infos_[i].invisible_) - { - int b = min (infos_[i].count (LEFT), infos_[i + 1].count (LEFT)); - infos_[i].beam_count_drul_[LEFT] = b; - infos_[i].beam_count_drul_[RIGHT] = b; - } + if (infos_.size () > 1) + for (vsize i = infos_.size () - 1; i--;) + if (infos_[i].invisible_) + { + int b = min (infos_[i].count (LEFT), infos_[i + 1].count (LEFT)); + infos_[i].beam_count_drul_[LEFT] = b; + infos_[i].beam_count_drul_[RIGHT] = b; + } } void -Beaming_pattern::add_stem (Moment m, int b, bool invisible) +Beaming_pattern::add_stem (Moment m, int b, bool invisible, Rational factor, bool tuplet_start) { - infos_.push_back (Beam_rhythmic_element (m, b, invisible)); + infos_.push_back (Beam_rhythmic_element (m, b, invisible, factor, tuplet_start)); } Beaming_pattern::Beaming_pattern () @@ -251,11 +365,31 @@ Beaming_pattern::start_moment (int i) const Moment Beaming_pattern::end_moment (int i) const { - Duration *dur = new Duration (2 + max (beamlet_count (i, LEFT), - beamlet_count (i, RIGHT)), - 0); + Duration dur (2 + max (beamlet_count (i, LEFT), + beamlet_count (i, RIGHT)), + 0); + + return infos_.at (i).start_moment_ + + infos_.at (i).factor_ * dur.get_length (); +} + +Moment +Beaming_pattern::remaining_length (int i) const +{ + return end_moment (infos_.size () - 1) - infos_[i].start_moment_; +} + +int +Beaming_pattern::beam_count_for_rhythmic_position (int idx) const +{ + // Calculate number of beams representing the rhythmic position of given stem + return intlog2(infos_[idx].start_moment_.main_part_.den()) - 2; +} - return infos_.at (i).start_moment_ + dur->get_length (); +int +Beaming_pattern::beam_count_for_length (Moment len) const +{ + return intlog2(len.main_part_.den()) - 2 - intlog2(len.main_part_.num()); } bool @@ -264,8 +398,20 @@ Beaming_pattern::invisibility (int i) const return infos_.at (i).invisible_; } +Rational +Beaming_pattern::factor (int i) const +{ + return infos_.at (i).factor_; +} + +bool +Beaming_pattern::tuplet_start (int i) const +{ + return infos_.at (i).tuplet_start_; +} + /* - Split a beamin pattern at index i and return a new + Split a beaming pattern at index i and return a new Beaming_pattern containing the removed elements */ Beaming_pattern * @@ -280,7 +426,9 @@ Beaming_pattern::split_pattern (int i) count = max (beamlet_count (j, LEFT), beamlet_count (j, RIGHT)); new_pattern->add_stem (start_moment (j), count, - invisibility (j)); + invisibility (j), + factor (j), + tuplet_start (j)); } for (vsize j = i + 1; j < infos_.size ();) infos_.pop_back (); @@ -292,6 +440,7 @@ Beaming_options::from_context (Context *context) { grouping_ = context->get_property ("beatStructure"); subdivide_beams_ = to_boolean (context->get_property ("subdivideBeams")); + strict_beat_beaming_ = to_boolean (context->get_property ("strictBeatBeaming")); base_moment_ = robust_scm2moment (context->get_property ("baseMoment"), Moment (1, 4)); measure_length_ = robust_scm2moment (context->get_property ("measureLength"), @@ -302,4 +451,5 @@ Beaming_options::Beaming_options () { grouping_ = SCM_EOL; subdivide_beams_ = false; + strict_beat_beaming_ = false; }