lily/scale.cc

   1 /*
   2   This file is part of LilyPond, the GNU music typesetter.
   3
   4   Copyright (C) 2006--2015 Han-Wen Nienhuys <hanwen@lilypond.org>
   5       2007--2008 Rune Zedeler
   6       2008       Joe Neeman <joeneeman@gmail.com>
   7
   8   LilyPond is free software: you can redistribute it and/or modify
   9   it under the terms of the GNU General Public License as published by
  10   the Free Software Foundation, either version 3 of the License, or
  11   (at your option) any later version.
  12
  13   LilyPond is distributed in the hope that it will be useful,
  14   but WITHOUT ANY WARRANTY; without even the implied warranty of
  15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16   GNU General Public License for more details.
  17
  18   You should have received a copy of the GNU General Public License
  19   along with LilyPond.  If not, see <http://www.gnu.org/licenses/>.
  20 */
  21
  22 #include "scale.hh"
  23 #include "protected-scm.hh"
  24
  25
  26 /*
  27   todo: put string <-> pitch here too.
  28 */
  29 LY_DEFINE (ly_make_scale, "ly:make-scale",
  30            1, 0, 0, (SCM steps),
  31            "Create a scale."
  32            "  The argument is a vector of rational numbers, each of which"
  33            " represents the number of 200 cent tones of a pitch above the"
  34            " tonic.")
  35 {
  36   bool type_ok = scm_is_vector (steps);
  37
  38   vector<Rational> tones;
  39   if (type_ok)
  40     {
  41       int len = scm_c_vector_length (steps);
  42       for (int i = 0; i < len; i++)
  43         {
  44           SCM step = scm_c_vector_ref (steps, i);
  45           type_ok = type_ok && scm_is_rational (step);
  46           if (type_ok)
  47             {
  48               Rational from_c (scm_to_int (scm_numerator (step)),
  49                                scm_to_int (scm_denominator (step)));
  50               tones.push_back (from_c);
  51             }
  52         }
  53     }
  54
  55   SCM_ASSERT_TYPE (type_ok, steps, SCM_ARG1, __FUNCTION__, "vector of rational");
  56
  57   return (new Scale (tones))->unprotect ();
  58 }
  59
  60 Scale *default_global_scale = 0;
  61 Protected_scm default_global_scale_scm (SCM_BOOL_F);
  62
  63 // TODO: This is somewhat fishy: pitches protect their scale via a
  64 // mark_smob hook.  But since pitches are of Simple_smob variety, they
  65 // are unknown to GUILE unless a smobbed_copy has been created.  So
  66 // changing the default scale might cause some existing pitches to
  67 // lose their scale's protection.
  68
  69 LY_DEFINE (ly_default_scale, "ly:default-scale",
  70            0, 0, 0, (),
  71            "Get the global default scale.")
  72 {
  73   return default_global_scale_scm;
  74 }
  75
  76 LY_DEFINE (ly_set_default_scale, "ly:set-default-scale",
  77            1, 0, 0, (SCM scale),
  78            "Set the global default scale.  This determines the tuning of"
  79            " pitches with no accidentals or key signatures.  The first"
  80            " pitch is C.  Alterations are calculated relative to this"
  81            " scale.  The number of pitches in this scale determines the"
  82            " number of scale steps that make up an octave.  Usually the"
  83            " 7-note major scale.")
  84 {
  85   LY_ASSERT_SMOB (Scale, scale, 1);
  86
  87   default_global_scale_scm = scale;
  88   default_global_scale = unsmob<Scale> (scale);
  89
  90   return SCM_UNSPECIFIED;
  91 }
  92
  93 int
  94 Scale::step_count () const
  95 {
  96   return step_tones_.size ();
  97 }
  98
  99 Rational
 100 Scale::tones_at_step (int step, int octave) const
 101 {
 102   int normalized_step = normalize_step (step);
 103
 104   octave += (step - normalized_step) / step_count ();
 105
 106   // There are 6 tones in an octave.
 107   return step_tones_[normalized_step] + Rational (octave * 6);
 108 }
 109
 110 Rational
 111 Scale::step_size (int step) const
 112 {
 113   int normalized_step = normalize_step (step);
 114
 115   // Wrap around if we are asked for the final note of the
 116   // scale (6 is the number of tones of the octave above the
 117   // first note).
 118   if (normalized_step + 1 == step_count ())
 119     return Rational (6) - step_tones_[normalized_step];
 120
 121   return step_tones_[normalized_step + 1] - step_tones_[normalized_step];
 122 }
 123
 124 int
 125 Scale::normalize_step (int step) const
 126 {
 127   int ret = step % step_count ();
 128   if (ret < 0)
 129     ret += step_count ();
 130
 131   return ret;
 132 }
 133
 134
 135
 136 Scale::Scale (vector<Rational> const &tones)
 137 {
 138   step_tones_ = tones;
 139
 140   smobify_self ();
 141 }
 142
 143 Scale::Scale (Scale const &src)
 144   : Smob<Scale> ()
 145 {
 146   step_tones_ = src.step_tones_;
 147   smobify_self ();
 148 }
 149
 150 Scale::~Scale ()
 151 {
 152 }