将洛奇的MML乐谱转为beep（蜂鸣器）乐谱

超、凢脫俗 2022-04-16 06:07 521阅读 0赞

### 将洛奇的MML乐谱转为beep（蜂鸣器）乐谱 ###

*  转换器制作
 *   *  音高频率表
     *  词法分析、语法分析
     *  token转换为beep谱
     *  用法
 *  使用C++播放

最近对蜂鸣器音乐感兴趣，但是找不到乐谱，于是想把其他乐谱转为蜂鸣器乐谱。直接用MIDI转换很困难，因为MIDI一个音轨可以同时发出不同的音，所以我想到了用以前玩过的游戏中的乐谱（[MML乐谱参考][MML]）

[本文完整源码][Link 1]

# 转换器制作 #

## 音高频率表 ##

首先要知道每个音高对应的频率，按照十二平均律算，标准音高A4是440Hz，一个半音相差21/12倍，一个八度相差2倍

FREQ_TABLE = [[0 for scale in range(12)] for octave in range(9)]
    
    
    def gen_freq_table():
        global FREQ_TABLE
        # A4标准音高
        FREQ_TABLE[4][9] = 440
        # 十二平均律
        for scale in range(8, -1, -1):
            FREQ_TABLE[4][scale] = FREQ_TABLE[4][scale + 1] / 2 ** (1 / 12)
        for scale in range(10, 12):
            FREQ_TABLE[4][scale] = FREQ_TABLE[4][scale - 1] * 2 ** (1 / 12)
        for octave in range(3, -1, -1):
            for scale in range(12):
                FREQ_TABLE[octave][scale] = FREQ_TABLE[octave + 1][scale] / 2
        for octave in range(5, 9):
            for scale in range(12):
                FREQ_TABLE[octave][scale] = FREQ_TABLE[octave - 1][scale] * 2
        for octave in range(9):
            for scale in range(12):
                FREQ_TABLE[octave][scale] = round(FREQ_TABLE[octave][scale])
    
    
    gen_freq_table()

生成表后直接硬编码即可

# 音程 -> 音阶 -> 频率，按十二平均律算
    FREQ_TABLE = [
        [16, 17, 18, 19, 21, 22, 23, 24, 26, 28, 29, 31],  # C0~B0（未使用）
        [33, 35, 37, 39, 41, 44, 46, 49, 52, 55, 58, 62],  # C1~B1
        [65, 69, 73, 78, 82, 87, 92, 98, 104, 110, 117, 123],
        [131, 139, 147, 156, 165, 175, 185, 196, 208, 220, 233, 247],
        [262, 277, 294, 311, 330, 349, 370, 392, 415, 440, 466, 494],  # C4~B4
        [523, 554, 587, 622, 659, 698, 740, 784, 831, 880, 932, 988],
        [1047, 1109, 1175, 1245, 1319, 1397, 1480, 1568, 1661, 1760, 1865, 1976],
        [2093, 2217, 2349, 2489, 2637, 2794, 2960, 3136, 3322, 3520, 3729, 3951],
        [4186, 4435, 4699, 4978, 5274, 5588, 5920, 6272, 6645, 7040, 7459, 7902]
    ]

## 词法分析、语法分析 ##

因为宏语言比较简单，这两部分就和在一起写了。输入MML字符串，输出音符、预设音长等token

# Token等定义略
    
    class SyntaxAnalyzer:
        """语法分析器（兼词法分析器）"""
    
        # 字符 -> 音阶索引
        SCALE = { 
            'C': 0, 'D': 2, 'E': 4, 'F': 5, 'G': 7, 'A': 9, 'B': 11
        }
    
        def __init__(self):
            self._mml = ''
            self._index = 0
            self._line = 1
            self._col = 1
    
            self._res = [[]]
    
        def _preprocess(self):
            self._mml = self._mml.upper()
            self._index = 0
            self._line = 1
            self._col = 1
            if self._mml.startswith('MML@'):
                self._index += 4
                self._col += 4
    
            self._res = [[]]
    
        def parse(self, mml: str) -> List[List[Token]]:
            """返回音轨数组，每个音轨包含多个Token"""
    
            self._mml = mml
            self._preprocess()
    
            while self._index < len(self._mml):
                line = self._line
                col = self._col
                if self._cur_char == ',':
                    # 新音轨
                    self._read_char()
                    self._res.append([])
    
                elif self._cur_char == ';':
                    # 结束
                    self._read_char()
                    break
    
                elif self._cur_char in 'CDEFGAB':
                    # 音符
                    self._output(self._read_note())
    
                elif self._cur_char == 'R':
                    # 休止符
                    self._read_char()
                    self._output(Pause(line, col, self._read_length()))
    
                elif self._cur_char == '&':
                    # 连接
                    self._read_char()
                    self._output(Joiner(line, col))
    
                elif self._cur_char == 'L':
                    # 预设音长
                    self._read_char()
                    self._output(DefaultLength(line, col, self._read_length()))
    
                elif self._cur_char == 'T':
                    # 播放速度
                    self._read_char()
                    tempo = self._read_number()
                    if tempo is not None and not 32 <= tempo <= 255:
                        raise MmlError(line, col, f'tempo = {tempo}，速度超出范围')
                    self._output(Tempo(line, col, tempo))
    
                elif self._cur_char == 'V':
                    # 音量
                    self._read_char()
                    volume = self._read_number()
                    if volume is not None and not 0 <= volume <= 15:
                        raise MmlError(line, col, f'volume = {volume}，音量超出范围')
                    self._output(Volume(line, col, volume))
    
                elif self._cur_char == 'O':
                    # 音程
                    self._read_char()
                    octave = self._read_number()
                    if octave is not None and not 1 <= octave <= 8:
                        raise MmlError(line, col, f'octave = {octave}，音程超出范围')
                    self._output(Octave(line, col, octave))
    
                elif self._cur_char in '><':
                    # 改变音程
                    self._output(ChangeOctave(line, col, 1 if self._cur_char == '>' else -1))
                    self._read_char()
    
                elif self._cur_char == 'N':
                    # 绝对音高
                    self._read_char()
                    note_index = self._read_number()
                    if note_index is None or not 1 <= note_index <= 96:
                        raise MmlError(line, col, f'note_index = {note_index}，绝对音高超出范围')
                    self._output(AbsoluteNote(line, col, note_index))
    
                elif self._cur_char in ' \t\r':
                    # 空白
                    self._read_char()
    
                elif self._cur_char == '\n':
                    # 新行
                    self._read_char()
                    self._line += 1
                    self._col = 1
    
                else:
                    # 错误字符
                    raise MmlError(line, col, f'未预料到的字符"{self._cur_char}"')
    
            return self._res
        
        def _output(self, token):
            self._res[-1].append(token)
        
        def _read_char(self):
            res = self._mml[self._index]
            self._index += 1
            self._col += 1
            return res
        
        @property
        def _cur_char(self):
            return self._mml[self._index]
    
        def _read_number(self):
            """读数字，非数字则返回None"""
    
            if self._index >= len(self._mml) or not '0' <= self._cur_char <= '9':
                return None
            res = 0
            while self._index < len(self._mml) and '0' <= self._cur_char <= '9':
                res = res * 10 + int(self._cur_char)
                self._read_char()
            return res
    
        def _read_length(self):
            length = self._read_number()
            has_dot = False
            if self._index < len(self._mml) and self._cur_char == '.':
                has_dot = True
                self._read_char()
            return Length(length, has_dot)
    
        def _read_note(self):
            line = self._line
            col = self._col
    
            scale = self.SCALE[self._cur_char]
            self._read_char()
            if self._index < len(self._mml):
                if self._cur_char in '+#':
                    scale += 1
                    self._read_char()
                elif self._cur_char == '-':
                    scale -= 1
                    self._read_char()
            return Note(line, col, scale, self._read_length())

## token转换为beep谱 ##

这里要考虑tempo是所有音轨共用的，后面的音轨优先，所以每次选时间最小的音轨处理，如果时间相同则选择后面的音轨

按照4分音符为一拍，持续时间计算方法： d u r a t i o n ( m s ) = 6 0 ( s / m i n ) / t e m p o ( b e a t / m i n ) ∗ 4 ( b e a t / 全 音 符 ) / l e n g t h ( 全 音 符 − 1 ) ∗ 100 0 ( m s / s ) duration\_\{(ms)\} = 60\_\{(s/min)\} / tempo\_\{(beat/min)\} \* 4\_\{(beat/全音符)\} / length\_\{(全音符^\{-1\})\} \* 1000\_\{(ms/s)\} duration(ms)=60(s/min)/tempo(beat/min)∗4(beat/全音符)/length(全音符−1)∗1000(ms/s)

class MmlParser:
        class _Track:
            def __init__(self, tokens):
                self.tokens = tokens
                self.index = 0
                # 音程
                self.octave = DEFAULT_OCTAVE
                # 预设音长
                self.default_length = DEFAULT_LENGTH
                # 播放速度（BPM，一分钟几拍）
                self.tempo = None
                # 下一个音符开始时间
                self.time = 0
                # 前面有一个连接符，正在连接状态
                self.is_joining = False
                self.beep_res = []
    
            def output(self, frequency, duration):
                self.time += duration
                if not self.is_joining:
                    self.beep_res.append([frequency, duration])
                    return
                if not self.beep_res:
                    raise MmlError(self.tokens[self.index].line, self.tokens[self.index].col, '缺少被连接的音符')
                if self.beep_res[-1][0] == frequency:
                    self.beep_res[-1][1] += duration
                else:
                    self.beep_res.append([frequency, duration])
                self.is_joining = False
    
        def __init__(self):
            self._tracks = []
    
        def parse(self, mml: str) -> List[List[List[int]]]:
            """转换MML乐谱到beep谱 返回音轨数组，每个音轨包含多个音符，每个音符为[频率(Hz), 持续时间(ms)]，频率为0代表延时 """
    
            self._tracks = [self._Track(tokens) for tokens in SyntaxAnalyzer().parse(mml)]
    
            track = self._get_next_track_to_process()
            while track is not None:
                token = track.tokens[track.index]
                if isinstance(token, Note):
                    # 音符
                    octave = track.octave
                    scale = token.scale
                    if scale < 0:
                        scale = 11
                        octave -= 1
                    elif scale >= 12:
                        scale = 0
                        octave += 1
                    if not 1 <= octave <= 8:
                        raise MmlError(token.line, token.col, f'octave = {octave}，音程超出范围')
                    track.output(FREQ_TABLE[octave][scale], self._get_duration(track, token.length))
    
                elif isinstance(token, Pause):
                    # 休止符
                    track.output(0, self._get_duration(track, token.length))
    
                elif isinstance(token, Joiner):
                    # 连接
                    track.is_joining = True
    
                elif isinstance(token, DefaultLength):
                    # 预设音长
                    length = token.length.length or DEFAULT_LENGTH
                    if token.length.has_dot:
                        length /= 1.5
                    track.default_length = length
    
                elif isinstance(token, Tempo):
                    # 播放速度
                    track.tempo = token.tempo
    
                elif isinstance(token, Octave):
                    # 音程
                    track.octave = token.octave or DEFAULT_OCTAVE
    
                elif isinstance(token, ChangeOctave):
                    # 改变音程
                    track.octave += token.delta_octave
    
                elif isinstance(token, AbsoluteNote):
                    # 绝对音高
                    note_index = token.note_index - 1
                    octave = note_index // 12 + 1
                    scale = note_index % 12
                    track.output(FREQ_TABLE[octave][scale], self._get_duration(track, Length()))
    
                track.index += 1
                track = self._get_next_track_to_process()
    
            return [track.beep_res for track in self._tracks]
    
        def _get_next_track_to_process(self):
            res = None
            for track in self._tracks:
                if track.index >= len(track.tokens):
                    # 这条音轨已经处理完
                    continue
                if res is None or track.time <= res.time:
                    # 时间小的先处理，如果时间一样先处理后面的音轨
                    res = track
            return res
    
        def _get_duration(self, track, length: Length):
            tempo = None
            # tempo共用，后面的音轨优先
            for track_ in reversed(self._tracks):
                if track_.tempo is not None:
                    tempo = track_.tempo
                    break
            if tempo is None:
                tempo = DEFAULT_TEMPO
    
            length_ = length.length or track.default_length
            if length.has_dot:
                length_ /= 1.5
    
            return round(60 / tempo * 4 / length_ * 1000)

## 用法 ##

with open(args.mml_file) as f:
            mml = f.read()
        res = MmlParser().parse(mml)
        with open(args.beep_file, 'w') as f:
            json.dump(res[args.track], f)

# 使用C++播放 #

不推荐在Windows7以及更新版本的Windows系统玩beep音乐，因为Win7以上的Beep是用声卡模拟的（[API参考][API]），和蜂鸣器声音相差大，而且播放太快会不发声

#include <Windows.h>
    
    struct Note { 
        unsigned int frequency;
        unsigned int duration;
    };
    
    extern std::vector<Note> notes; // 定义在另一个cpp文件
    
    int main() { 
        for (auto [frequency, duration] : notes) { 
            if (frequency == 0) // 延时
                Sleep(duration);
            else
                Beep(frequency, duration);
        }
    
        return 0;
    }

[MML]: https://mabinogi.fws.tw/ac_com_annzyral.php
[Link 1]: https://github.com/xfgryujk/mml2beep
[API]: https://msdn.microsoft.com/zh-cn/library/windows/desktop/ms679277%28v=vs.85%29.aspx