1 /*
2 This file is part of LilyPond, the GNU music typesetter.
3
4 Copyright (C) 2006--2021 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 #include <limits>
26
27 using std::vector;
28
29 /*
30 todo: put string <-> pitch here too.
31 */
32 LY_DEFINE (ly_make_scale, "ly:make-scale",
33 1, 0, 0, (SCM steps),
34 "Create a scale."
35 " The argument is a vector of rational numbers, each of which"
36 " represents the number of 200-cent tones of a pitch above the"
37 " tonic.")
38 {
39 bool type_ok = scm_is_vector (steps);
40
41 vector<Rational> tones;
42 if (type_ok)
43 {
44 vsize len = scm_c_vector_length (steps);
45 for (vsize i = 0; i < len; i++)
46 {
47 SCM step = scm_c_vector_ref (steps, i);
48 type_ok = type_ok && scm_is_rational (step);
49 if (type_ok)
50 {
51 Rational from_c (scm_to_int (scm_numerator (step)),
52 scm_to_int (scm_denominator (step)));
53 tones.push_back (from_c);
54 }
55 }
56 }
57
58 SCM_ASSERT_TYPE (type_ok, steps, SCM_ARG1, __FUNCTION__, "vector of rational");
59
60 return (new Scale (tones))->unprotect ();
61 }
62
63 Scale *default_global_scale = 0;
64 Protected_scm default_global_scale_scm (SCM_BOOL_F);
65
66 // TODO: This is somewhat fishy: pitches protect their scale via a
67 // mark_smob hook. But since pitches are of Simple_smob variety, they
68 // are unknown to GUILE unless a smobbed_copy has been created. So
69 // changing the default scale might cause some existing pitches to
70 // lose their scale's protection.
71
72 LY_DEFINE (ly_default_scale, "ly:default-scale",
73 0, 0, 0, (),
74 "Get the global default scale.")
75 {
76 return default_global_scale_scm;
77 }
78
79 LY_DEFINE (ly_set_default_scale, "ly:set-default-scale",
80 1, 0, 0, (SCM scale),
81 "Set the global default scale. This determines the tuning of"
82 " pitches with no accidentals or key signatures. The first"
83 " pitch is C. Alterations are calculated relative to this"
84 " scale. The number of pitches in this scale determines the"
85 " number of scale steps that make up an octave. Usually the"
86 " 7-note major scale.")
87 {
88 auto *const s = LY_ASSERT_SMOB (Scale, scale, 1);
89
90 default_global_scale_scm = scale;
91 default_global_scale = s;
92
93 return SCM_UNSPECIFIED;
94 }
95
96 int
step_count() const97 Scale::step_count () const
98 {
99 return static_cast<int> (step_tones_.size ());
100 }
101
102 Rational
tones_at_step(int step,int octave) const103 Scale::tones_at_step (int step, int octave) const
104 {
105 int normalized_step = normalize_step (step);
106
107 octave += (step - normalized_step) / step_count ();
108
109 // There are 6 tones in an octave.
110 return step_tones_[normalized_step] + Rational (octave * 6);
111 }
112
113 Rational
step_size(int step) const114 Scale::step_size (int step) const
115 {
116 int normalized_step = normalize_step (step);
117
118 // Wrap around if we are asked for the final note of the
119 // scale (6 is the number of tones of the octave above the
120 // first note).
121 if (normalized_step + 1 == step_count ())
122 return Rational (6) - step_tones_[normalized_step];
123
124 return step_tones_[normalized_step + 1] - step_tones_[normalized_step];
125 }
126
127 int
normalize_step(int step) const128 Scale::normalize_step (int step) const
129 {
130 int ret = step % step_count ();
131 if (ret < 0)
132 ret += step_count ();
133
134 return ret;
135 }
136
Scale(vector<Rational> const & tones)137 Scale::Scale (vector<Rational> const &tones)
138 {
139 assert (tones.size () <= std::numeric_limits<int>::max ());
140 step_tones_ = tones;
141
142 smobify_self ();
143 }
144
Scale(Scale const & src)145 Scale::Scale (Scale const &src)
146 : Smob<Scale> ()
147 {
148 step_tones_ = src.step_tones_;
149 smobify_self ();
150 }
151
~Scale()152 Scale::~Scale ()
153 {
154 }
155