Parking Site

A castle on the cloud.

0%

Synthesize：模拟读谱进行音乐合成

Posted on Edited on In

tl;dr

  1. 阅读乐谱

  2. 阅读源代码

  3. 将乐谱转换成频率

  4. 模拟合成一段音乐

Background

一支乐曲是一系列音符构成的，在乐谱上每个音符是一个具备时间长度、音高的标志。在西方音乐记谱中，每一个音符使用字母A-G表示。这些音在钢琴上位于白键上，因此称为自然音。

A-（la） B-（si） C-（do） D-（re）E-（mi）F-（fa）G-（so）

升降符号（#／b）用于表示与白键的接近程度。
键盘上的相邻音之间为半音的间隔（semitone）。

semitone

钢琴共有88个键，其中52个为白键，仅用七个字母表示并不充分。八度（octaves）一组，即连续的七个音组成的音阶可以和音名一起表示键盘上的某个音。

octaves

按动琴键，琴槌会敲击琴弦，琴弦振动产生波，波抵达人耳，就能听见乐音。
波动的频率越大，音高越高。

source：(奇妙的音乐数学)[https://plus.maths.org/content/magical-mathematics-music]

A4

1
2
3
4
5
6
C4 = midle C
A3 = 220 Hz
A4 = 440 Hz = A440
A5 = 440 * 2 Hz
……
f = (2^n/12) × 440

Visual Notation

一般的记谱并不使用频率或符号，而是用视觉化方法表示——五线谱。位置代表音高，时值是音持续的时间长度。

Analyze music.zip

  1. songs／ 目录下均为文本文件，存储的是不同歌曲的谱面。空行代表 1/8 休止符

  2. notes.c输出note：频率，（如A#4:440），并在wav中输出对应音高的音符。
    同时对错误信息给出输出提示。
    使用到的函数song_open, frequency, note_write, song_close在其他文件中定义。

  3. synthesize.c从用户处获取一系列音符，写入文件。
    get_string 获取一系列音符直至 EOF ，分辨作为休止符的空行。
    使用 strtok() 匹配str note 和str duration （分数）。
    使用 note_write 写入文件。

  4. wav.h 是 notes.c 和 synthesize.c 中都会使用到的头文件。
    定义了结构体 note 和 song 。
    定义了 note_write, rest_write, song_close, 以及 song_open 函数。

  5. wav.c

  6. Makefiles是 make命令编译时配置文件，编译 notes 和 synthesize 涉及多个文件。

  7. helpers.h 定义duration,frequency 和 is_rest函数。

  8. helpters.c

Specification

  1. 经过读谱，在bday.txt中写入机器可读取的内容
  2. 在 cs50.h 中找到 get_string 上的注释，发现
    1
    2
    3
    4
    5
    6
    7
    8
    /**
     * Prompts user for a line of text from standard input and returns
     * it as a string (char *), sans trailing line ending. Supports
     * CR (\r), LF (\n), and CRLF (\r\n) as line endings. If user
     * inputs only a line ending, returns "", not NULL. Returns NULL
     * upon error or no input whatsoever (i.e., just EOF). Stores string
     * on heap, but library's destructor frees memory on program's exit.
     */
    也就是说 get_string 方法读取空行时，得到的是“”而非NULL。而 EOF 时得到的是 NULL。

小结

  1. 补全 duration 函数，得到谱面音符的相对时值（1/8）
  2. 频率计算
    按照获取的string note（如A#4）
    得到 octave = 4
    name（与标准音的半音差） = 0
    half = +1
    得到
    output = 440 * ( 2 ^ ( ( name + half ) / 12 ) ) * (2 ^ ( octave - 4 ) );
  3. 进行小的单元测试，按照功能进行调试，然后进行下一步。
    特别是在调整模拟频率上，分别按照音高、半音、音阶进行调整。
  4. 最后，注意精度(round)和类型转换！

Code Solution

helpers.c []
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85

// Converts a fraction formatted as X/Y to eighths
int duration(string fraction)
{
    string X = strtok(fraction, "/");
    int x = atoi(X);
    string Y = strtok(NULL, "/");
    int y = atoi(Y);
    int output = x * pow(2, 3 - log2(y)) ;
    return output;
}

// Calculates frequency (in Hz) of a note
int frequency(string note)
{
    // set octave to store how to */ 2
    // set half to store whether or not should * 2 ^ 1/12
    // set hame to store how much it relate to A
    int octave = 4;
    int half = 0;
    int name = 0;
    // if the note is semi like A#4
    if (strlen(note) == 3)
    {
        //get octave on A#4,minus char '4'
        octave = note[2] - '4';
        // set half = 1 if #
        if (note[1] == '#')
        {
            half = 1;
        }
        // set half = -1 if b
        if (note[1] == 'b')
        {
            half = -1;
        }
    }
    // if no semi, the length of note is 2, like A4
    if (strlen(note) == 2)
    {
        //get octave
        octave = note[1] - '4';
    }
    // get name by char note[0]
    switch (note[0])
    {
        case 'C':
            name = -9;
            break;
        case 'D':
            name = -7;
            break;
        case 'E':
            name = -5;
            break;
        case 'F':
            name = -4;
            break;
        case 'G':
            name = -2;
            break;
        case 'A':
            name = 0;
            break;
        case 'B':
            name = 2;
    }
    //calculate the frequency and return the int output
    int freq = 0;
    freq = round(440 * pow(2.00, (name + half) / 12 + octave));
    return  freq;
}
// Determines whether a string represents a rest
bool is_rest(string s)
{
    // if it is "" return false
    if (strncmp(s, "", 1))
    {
        return false;
    }
    else
    {
        return true;
    }
}

其他

synthesize.c []
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
int main(int argc, string argv[])
{
    // Check command line arguments
    if (argc != 2)
    {
        fprintf(stderr, "Usage: synthesize FILE\n");
        return 1;
    }
    string filename = argv[1];
    // Open file for writing
    song s = song_open(filename);
    // Expect notes from user until EOF
    while (true)
    {
        // Expect note
        string line = get_string("");
        // Check for EOF
        if (line == NULL)
        {
            break;
        }
        // Check if line is rest
        if (is_rest(line))
        {
            rest_write(s, 1);
        }
        else
        {
            // Parse line into note and duration
            string note = strtok(line, "@");
            string fraction = strtok(NULL, "@");
            // Write note to song
            note_write(s, frequency(note), duration(fraction));
        }
    }
    // Close file
    song_close(s);
}

另一个

note.c []
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
// Notes in an octave
const string NOTES[] = {"C", "C#", "D", "D#", "E", "F",
                        "F#", "G", "G#", "A", "A#", "B"
                       };

// Default octave
#define OCTAVE 4

int main(int argc, string argv[])
{
    // Override default octave if specified at command line
    int octave = OCTAVE;
    if (argc == 2)
    {
        octave = atoi(argv[1]);
        if (octave < 0 || octave > 8)
        {
            //unvalid input actave
            fprintf(stderr, "Invalid octave\n");
            return 1;
        }
    }
    else if (argc > 2)
    {
        //too much arguments
        fprintf(stderr, "Usage: notes [OCTAVE]\n");
        return 1;
    }

    // Open file for writing
    song s = song_open("notes.wav");

    // Add each semitone
    for (int i = 0, n = sizeof(NOTES) / sizeof(string); i < n; i++)
    {
        // Append octave to note
        char note[4];
        sprintf(note, "%s%i", NOTES[i], octave);

        // Calculate frequency of note
        int f = frequency(note);

        // Print note to screen
        //as A#4:440
        printf("%3s: %i\n", note, f);

        // Write (eighth) note to file
        note_write(s, f, 1);// note_write()
    }

    // Close file
    song_close(s);// song_close()
}