Показаны сообщения с ярлыком midi. Показать все сообщения
Показаны сообщения с ярлыком midi. Показать все сообщения

среда, 6 июня 2018 г.

MIDI музыка на C#. Часть 4-я.

  1. Пауза и воспроизведение с любого момента
  2. Фильтр по каналам
  3. Транспозиция

Пауза и воспроизведение с любого момента



Остановить воспроизведение несложно, надо только иметь в виду, что на момент остановки, какие-то звуки уже звучат и их неплохо было бы остановить, а стало быть простого уничтожения таймера будет недостаточно. Из возможных вариантов я пришел к выводу, что лучше всего просто закрыть инструмент. Другой вопрос, что при восстановлении звучания с того момента, на котором воспроизведение было остановлено или с любого другого момента, это обстоятельство тоже надо иметь в виду, то есть нужно вычислить, какие ноты звучали к тому моменту, с которого начинается воспроизведение. По всей видимости вычислять это придется пройдя все сообщения с самого начала, а стало быть и при остановке надо "убить" таймер, остановить инструмент и удалить все пакеты сообщений из очереди.
Код csharp Выделить
        public void Pause()
        {
            timer.Dispose();
            pkgqueue = null;
            Close();
        }
Для восстановления звучания можно просто обновить список пакетов и запустить воспроизведение, оставив значение таймлайна на том же месте, где оно было остановлено. Учитывая, что при каждом тике отправляются сообщения из всех пакетов, значение таймлана которых меньше или равно текущему значению таймлайна плеера, они и будут все отправлены немедленно, то есть ноты будут "включаться и тут же "отключаться" пока не будет отправлен последний на текущий момент пакет. Если такой вариант не устраивает, то можно написать что-то вроде такого
Код csharp Выделить
        void SendCurrentMessages()
        {
            var messages = new List<int>();
            var tline = 0;
            Action<Func<int, bool>> excludeMsgs = predicate =>
             {
                 var notesForExclude = messages.Where(predicate);
                 messages.RemoveAll(x => notesForExclude.Contains(x));
             };
            for (int i = 0; i < MsgList.Length; i++)
            {
                if (tline > TimeLine) return;
                if (MsgList[i] == 0)
                {
                    tline += MsgList[i + 1];
                    i += 2;
                }
                else
                {
                    var command = MsgList[i] >> 4 & 15;
                    switch (command)
                    {
                        case 8:
                            excludeMsgs(m => ((MsgList[i] & 15) == (m & 15)) && ((MsgList[i] >> 16 | 255) == (m >> 16 | 255)));
                            break;
                        case 9:
                            messages.Add(MsgList[i]);
                            break;
                        case 0xc:
                            excludeMsgs(m => (MsgList[i] & 15) == (m & 15));
                            messages.Add(MsgList[i]);
                            break;
                        default:
                            break;
                    }
                }
            }
            messages.ForEach(m => midiOutShortMsg(handle, m));
        }
Я этот метод не тестировал, так что правильную работу не гарантирую, но принцип его работы таков: обходятся сообщения, если это 9X (NoteOn), то оно просто добавляется в коллекцию, если 8X(NoteOff), то в коллекции находится 9X для того же канала и той же ноты и все такие сообщения извлекаются из коллекции. То же для CX: если в коллекции уже есть такая команда для того же канала, все они извлекаются из коллекции и добавляется новая. В конце, все что останется в коллекции messages отправляется с помощью midiOutShortMsg. До сего момента мы пользовались только тремя типами команд, но вообще этот метод придется сильно расширить, если будут использоваться и другие команды. В проекте из вложения этот метод есть, но я его там не использую.

Воспроизведение с любой позиции ничем не отличается от восстановления после паузы, для этого надо всего лишь установить нужное значение свойства TimeLine плеера.
Код csharp Выделить
        public void GoOn()
        {
            CreatePackageQueue();
            Open();
            timer = new Timer(TimerTick, null, 0, TimerInterval);
        }
 
        public override void Play()
        {
            TimeLine = 0;
            GoOn();
        }

Фильтр по каналам



Иногда бывает нужно воспроизвести партию отдельного инструмента или отдельного голоса. Если то, что нужно воспроизвести записано в отдельный канал (а обычно так и бывает), то выделить из всего потока сообщений только те, которые относятся к этому каналу совсем несложно: канал указан в последних четырех битах сообщения, поэтому мы легко можем получить его значение и отфильтровать сообщения. Единственная вещь о которой надо при этом помнить - в массиве сообщений мы размещаем не только сообщения, но и паузы. Следующий метод размещаем в классе MessageProcessor, он принимает массив сообщений и номер канала, возвращает отфильтрованный массив сообщений.
Код csharp Выделить
        public static int[] GetChannel(int[] sourceMessages, int channel)
        {
            var result = new List<int>();
            for (int i = 0; i < sourceMessages.Length; i++)
            {
                if(sourceMessages[i] == 0)
                {
                    i++;
                    result.Add(0);
                    result.Add(sourceMessages[i]);
                }
                else
                {
                    if ((sourceMessages[i] & 15) == channel) result.Add(sourceMessages[i]);
                }
            }
            return result.ToArray();
        }
В проекте во вложении можно прослушать отдельные партии нашей мелодии, то есть сначала мы их объединили, а теперь, с помощью этого метода, можно разделить обратно.

Транспозиция



Обычно процесс транспозиции (переноса в другую тональность) имеет некоторые сложности в силу того, что она является переносом всех нот на некоторое фиксированное количество хроматических интервалов, в то время как запись ведется в диатонической "системе координат". У нас же, для того, чтобы изменить тон ноты на определенное количество хроматических полутонов - достаточно просто прибавить к ее номеру количество полутонов, на которые надо ее повысить (или вычесть, если надо понизить). Соответственно весь процесс смещения мелодии будет похож на фильтрацию, только в результирующий массив мы будем добавлять все сообщения, предварительно изменив те, которые содержат информацию о ноте.
Код csharp Выделить
        public static int[] Traspose(int[] sourceMessages, int distance)
        {
            var result = new List<int>();
            for (int i = 0; i < sourceMessages.Length; i++)
            {
                var msg = sourceMessages[i];
                if (msg == 0)
                {
                    i++;
                    result.Add(0);
                    result.Add(msg);
                }
                else
                {
                    var command = (msg >> 4) & 15;
                    if (command == 8 || command == 9)
                    {
                        var note = (msg >> 8) & 255;
                        result.Add((msg >> 16) << 16 | (note + distance) << 8 | (msg & 255));
                    }
 
                }
            }
            return result.ToArray();
        }
В проекте во вложении можно прослушать пример, в котором наша мелодия исполняется на один тон выше, что достигнуто с помощью данной функции.
Вложения

MIDI музыка на C#. Часть 3-я.

  1. Шаблоны аккордов
  2. Другой подход к шаблонизации аккордов
  3. Воспроизведение с использованием таймера

Шаблоны аккордов



При написании GetChord мне пришлось несколько раз исправлять ошибки. Несмотря на то, что рисунок аккомпанемента был чрезвычайно простым, реализация его в виде потока сообщений оказалась задачей не такой уж и легкой. Поэтому было бы неплохо придумать способ упростить задачу, чтобы можно было описывать аккорд обычным текстом и при этом, чтобы не было никаких сложностей. То есть надо разработать специальный формат, с помощью которого можно будет записывать структуру аккорда и как он должен обыгрываться, а потом применять этот шаблон к разным аккордам и строить на этом аккомпанемент.

Вместо нот будем использовать числа, которые показывают хроматический интервал по отношению к условному основному тону. Условному потому что использовать его можно будет и для обращений аккордов и в этом случае в качестве основного тона будет задаваться не прима аккорда. То есть сам основной тон будет иметь значение 0, нота на квинту выше - 7, а на кварту ниже - -5 и так далее. После числа, обозначающего ноту, будет идти точка, за которой последует длительность, в формате описанном ранее ( 4 означает четвертинную ноту, 4,8 - четверть с точкой и т. д.). Для пауз но та будет отсутствовать, то есть пауза начинается с точки. Все это будет писаться через пробелы. Но, когда мы создавали формат для записи мелодий, там все было немного проще: одна нота заканчивает звучать - начинает звучать следующая. Здесь же ноты могут звучать одновременно или, например, "внахлест"(то есть одна еще не закончила звучать, а следующая уже начинает). Здесь решение в том, что каждый голос будет записываться на отдельной строке. Таким образом аккорды из второй части статьи будут иметь следующие шаблоны:
Для мажорного трезвучия
Код:
0.4               -5.4
.8 4.16 4.16      .8 4.8
.8 7.16 7.16      .8 7.8
.8 12.16 12.16   .8 12.8
Для минорного
Код:
0.4               -5.4
.8 3.16 3.16      .8 3.8
.8 7.16 7.16      .8 7.8
.8 12.16 12.16   .8 12.8
Создания коллекции сообщений на основе такого шаблона создадим следующий метод
Код csharp Выделить
        public static int[] CreateChordFromTemplate(string template, int prima, int fullNoteDuration, int velocity, int channel)
        {
            var re = new Regex(@"(?<position>(\-?\d+)?)\.(?<duration>\d+(,\d+)*)", RegexOptions.Compiled);
 
            Func<string, int[]> melodyFromLine = line =>
            {
                var matches = re.Matches(line);
                var res = new List<int>();
                foreach (Match m in matches)
                {
                    var position = m.Groups["position"].Value;
                    var duration = m.Groups["duration"].Value.Split(',').Select(d => fullNoteDuration / int.Parse(d)).Sum();
                    if(position == "")
                    {
                        res.Add(0);
                        res.Add(duration);
                    }
                    else
                    {
                        var note = prima + int.Parse(position);
                        res.Add(velocity << 16 | note << 8 | 0x90 | channel);
                        res.Add(0);
                        res.Add(duration);
                        res.Add(note << 8 | 0x80 | channel);
                    }
                }
                return res.ToArray();
            };
 
            var lines = template.Split("\r\n".ToCharArray(), StringSplitOptions.RemoveEmptyEntries).Select(melodyFromLine).ToArray();
            return MessageProcessor.MergeMessagesLists(lines);
        }
Теперь нам нужен способ записать последовательность аккордов, использующих эти шаблоны. Здесь все просто: запись аккорда будет состоять из номера октавы(как он определен для MIDI-инструментов (от 0 до 9). После чего символ ноты в нижнем регистре, далее плюс или минус, в случае, если нужен диез или бемоль, далее точка и имя шаблона. Шаблоны в тестовом примере я разместил в ресурсы под именами ChordTemplate_TemplateName, где вместо TemplateName идет реальное имя шаблона, которое будет использоваться в записи аккордов. У меня имена простые: 1, 2, 3, 4. Но, если их много, то проще будет давать осмысленные имена. Имена могут состоять из букв, цифр и знаков подчеркивания.
Код csharp Выделить
        public static int[] ParseChords(string chords, int fullDuration, int velocity, int channel)
        {
            var re = new Regex(@"(?<octave>\d)(?<note>[a-g])(?<alter>[\+\-]?)\.(?<template>\w+)", RegexOptions.Compiled);
            Func<Match, int[]> getmsgs = match =>
            {
                var note = CalculateNote0(match.Groups["note"].Value[0]) + int.Parse(match.Groups["octave"].Value) * 12 + (match.Groups["alter"].Value == "+" ? 1 : -1 );
                var template = Properties.Resources.ResourceManager.GetString("ChordTemplate_" + match.Groups["template"].Value);
                return CreateChordFromTemplate(template, note, fullDuration, velocity, channel);
            };
            return (from Match m in re.Matches(chords) select m).SelectMany(getmsgs).ToArray();
        }
 
        static int CalculateNote0(char n)
        {
            switch (char.ToLower(n))
            {
                case 'a': return 9;
                case 'b': return 11;
                case 'c': return 0;
                case 'd': return 2;
                case 'e': return 4;
                case 'f': return 5;
                case 'g': return 7;
                default:
                    throw new ArgumentException();
            }
        }

В примере из вложения используется следующий код
Код csharp Выделить
            var parser = new MusicFileParser();
 
            var chords = ChordMaster.ParseChords(@"5a.2 5a.2 5d.2 5d.2 5b-.1 5e.1 5a.2 5a.2", 3000, 127, 1);
            chords = new int[] { 25 << 8 | 0xC1, 0, 3000 / 4 }.Concat(chords).ToArray();
            var player = new MelodyPlayer();
            player.MsgList = chords;
            player.Open();
            player.Play();
            player.Close();
и
Код csharp Выделить
            var parser = new MusicFileParser();
 
            var chords = ChordMaster.ParseChords(@"4a.4 4a.4 4d.4 4d.4 4b-.3 4e.3 4a.4 4a.4", 3000, 127, 1);
            chords = new int[] { 25 << 8 | 0xC1, 0, 3000 / 4 }.Concat(chords).ToArray();
            var player = new MelodyPlayer();
            player.MsgList = chords;
            player.Open();
            player.Play();
            player.Close();
Шаблоны 1 и 2 приведены выше, а 3 и 4 есть в ресурсах проекта.


Другой подход к шаблонизации аккордов



Описанный в предыдущем параграфе метод имеет один существенный недостаток. Если мы сравним два представленных шаблона, то несложно заметить, что они в принципе совершенно одинаковы и отличаются только одной нотой, то есть способ обыгрывания аккорда один и тот же, а аккорды разные, в данном случае минорный и мажорный аккорды, которые отличаются только положением терции. Естественно разумно было бы придумать такие шаблоны, которые можно было бы применить к любым аккордам.

В данном случае сделать это - совсем несложно. Просто в шаблонах мы обозначали ноты числами, соответствующими количеству хроматических полутонов на которые нота отстоит от основного тона, а в метод обработки передавали основной тон. Вместо этого можно в метод обработки передавать коллекцию нот аккорда, при этом числа в шаблонах будут обозначать индекс ноты в этой коллекции. Например возьмем такой шаблон
Код:
0.4             1.4
.8 2.16 2.16      .8 2.8
.8 3.16 3.16      .8 3.8
.8 4.16 4.16    .8 4.8
Если мы передадим ему ноты мажорного аккорда, то он будет работать как первый шаблон из предыдущего параграфа, а если минорного - как второй. Но теперь у нас появляется возможность передавать ему множество других аккордов.

Естественно, для обработки таких шаблонов нам нужно добавить перегрузку метода CreateChordFromTemplate, которая вместо примы аккорда будет принимать массив, содержащий все звуки, упомянутые в шаблоне. Собственно изменения в коде метода тоже будут минимальными, всего лишь придется изменить строку, вычисляющую номер ноты.
Код csharp Выделить
        public static int[] CreateChordFromTemplate(string template, int[] notes, int fullNoteDuration, int velocity, int channel)
        {
            var re = new Regex(@"(?<position>(\-?\d+)?)\.(?<duration>\d+(,\d+)*)", RegexOptions.Compiled);
 
            Func<string, int[]> melodyFromLine = line =>
            {
                var matches = re.Matches(line);
                var res = new List<int>();
                foreach (Match m in matches)
                {
                    var position = m.Groups["position"].Value;
                    var duration = m.Groups["duration"].Value.Split(',').Select(d => fullNoteDuration / int.Parse(d)).Sum();
                    if (position == "")
                    {
                        res.Add(0);
                        res.Add(duration);
                    }
                    else
                    {
                        var note = notes[int.Parse(position)];
                        res.Add(velocity << 16 | note << 8 | 0x90 | channel);
                        res.Add(0);
                        res.Add(duration);
                        res.Add(note << 8 | 0x80 | channel);
                    }
                }
                return res.ToArray();
            };
 
            var lines = template.Split("\r\n".ToCharArray(), StringSplitOptions.RemoveEmptyEntries).Select(melodyFromLine).ToArray();
            return MessageProcessor.MergeMessagesLists(lines);
        }
Теперь можно ввести обозначения для аккордов, похожие на стандартные обозначения, но такие, чтобы их можно было легко записать как обычный текст и легко парсить. Ну например:
  1. Большая буква - мажорный аккорд, малая - минорный (избавляемся от необходимости писать и парсить букву m)
  2. Все обозначение ступеней, присутствующие в стандартной записи, пишем в формате [+-]?\d\d?(,[+-]?\d\d?)*
  3. При этом заменяем обозначения типа maj dim sus2 sus4 и т. д. обозначениями из п. 2. То есть, вместо Csus2 будем писать c-3, вместо Csus4 - С+3, вместо Cdim7 - c-5,-7, вместо Cmaj7 - C+7 и т. д.

В двух словах формат выглядит так:
Буква аккорда (большая или малая, в зависимости от того минор это или мажор), далее идут через запятую все альтерированные ступени. Ступень с самым большим интервалом подразумевает, что все предшествующие терцовые (нечетные) ступени тоже присутствуют. Секста используется как добавочный звук, поэтому она присутствует только там, где указана. Для парсинга таких аккордов можно использовать такой код:
Код csharp Выделить
        public static int[] ParseChord(string chord)
        {
            var re = new Regex(@"(?<note>[a-gA-G])(?<steps>[+-]?\d\d?(,[+-]?\d\d?)*)?", RegexOptions.Compiled);
            var match = re.Match(chord);
            var note = match.Groups["note"].Value;
            var steps = match.Groups["steps"].Value.Split(',');
            var intSteps = steps.Where(s => s != "").Select(x => Math.Abs(int.Parse(x)));
            var result = new List<int>() { CalculateNote0(note[0]) };
            Action<int, int> addStep = (step, norm) =>
            {
                var ss = steps.FirstOrDefault(s => s == "+" + step.ToString() || s == "-" + step.ToString() || s == step.ToString());
                if (ss == null)
                {
                    result.Add(result[0] + norm);
                }
                else
                {
                    switch (ss.Substring(0, 1))
                    {
                        case "+": result.Add(result[0] + norm + 1); break;
                        case "-": result.Add(result[0] + norm - 1); break;
                        default: result.Add(result[0] + norm); break;
                    }
                }
            };
 
            addStep(3, char.IsLower(note[0]) ? 3 : 4);
            addStep(5, 7);
            var maxStep = intSteps.Count() == 0 ? 5 : intSteps.Max();
            var restSteps = "6:9 7:11 9:14 11:17 13:19".Split(' ').ToDictionary(s => int.Parse(s.Split(':')[0]), s => int.Parse(s.Split(':')[1]));
            foreach (int rs in restSteps.Keys)
            {
                if (rs > maxStep) break;
                if (intSteps.Contains(rs))
                    addStep(rs, restSteps[rs]);
            }
            return result.ToArray();
        }
Он возвратит массив чисел, соответсвующих нотам аккорда на нулевой октаве.
В проекте во вложении есть специальная форма, которая позволяет протестировать аккорды. Там в одном текстовом поле можно ввести код аккорда, а во втором - код шаблона, для того, чтобы аккорд можно было обыграть. Естественно, для реальной работы с аккордами лучше было бы создать отдельный класс, в который можно было бы заложить основные принципы работы аккорда. Шаблон обычно рассчитан на определенное количество нот, в то время как у разных аккордов их количество может отличаться. Кроме того, там могут быть предусмотрены повторения некоторых нот на разных октавах.

Таким образом, того, что здесь представленно - недостаточно, но по крайней мере уже есть от чего оттолкнуться. Далее углубляться в эту тему не буду.

Воспроизведение с использованием таймера



Описанный ранее способ воспроизведения потока сообщений, при котором отправлялся пакет сообщений, после чего "усыплялся" поток на некоторое время до отправки следующего пакета - возможно не самый лучший способ решения задачи. Конечно, можно запускать код в специально созданном потоке, чтобы не блокировать основной, но это не решает всех проблем. Этот способ прост и понятен, благодаря чему его удобно использовать для объяснения материала, но на практике, скорей всего, лучше использовать таймер.

Для экспериментов с таймером мы сначала выполним некоторые преобразования существующего кода. Нам понадобится новый класс для воспроизведения мелодий, но частично он будет содержать прежний код. Поэтому мы вынесем часть кода из класса MelodyPlayer в новый класс PlayerBase, заменим модификаторы private на protected и унаследуем MelodyPlayer от этого нового класса.
Кликните здесь для просмотра всего текста
Код csharp Выделить
using System.Runtime.InteropServices;
 
namespace midi
{
    public abstract class PlayerBase
    {
        [DllImport("winmm.dll")]
        protected static extern int midiOutOpen(ref int handle,
int deviceID, MidiCallBack proc, int instance, int flags);
 
        [DllImport("winmm.dll")]
        protected static extern int midiOutShortMsg(int handle,
           int message);
 
        [DllImport("winmm.dll")]
        protected static extern int midiOutClose(int handle);
 
        protected delegate void MidiCallBack(int handle, int msg,
   int instance, int param1, int param2);
 
 
        protected int handle = 0;
 
        public int[] MsgList { get; set; }
 
        public void Open()
        {
            midiOutOpen(ref handle, 0, null, 0, 0);
        }
 
        public void Close()
        {
            midiOutClose(handle);
        }
 
        public abstract void Play();
 
    }
}
Код csharp Выделить
using System.Runtime.InteropServices;
using System.Threading;
 
namespace midi
{
using System.Runtime.InteropServices;
using System.Threading;
 
namespace midi
{
    class MelodyPlayer : PlayerBase
    {
        public void SetInstrument(int id)
        {
            midiOutShortMsg(handle, id << 8 | 0x000000C0);
        }
 
        public void PlayNote(int note, int duration)
        {
            midiOutShortMsg(handle, 127 << 16 | note << 8 | 0x00000090);
            Thread.Sleep(duration);
            midiOutShortMsg(handle, 127 << 16 | note << 8 | 0x00000080);
        }
 
        public void SetInstrument(MusicalInstruments id)
        {
            midiOutShortMsg(handle, (int)id << 8 | 0x000000C0);
        }
 
        public override void Play()
        {
            for (int i = 0; i < MsgList.Length; i++)
            {
                if (MsgList[i] == 0)
                {
                    i++;
                    Thread.Sleep(MsgList[i]);
                }
                else
                {
                    midiOutShortMsg(handle, MsgList[i]);
 
                };
            }
        }
    }
}


Создадим новый класс TimerPlayer, который также будет наследовать PlayerBase. Теперь нам надо решить одну небольшую проблему. Когда будет происходить срабатывание таймера в методе-коллбеке нам надо будет решить, что именно надо отправить из имеющихся сообщений. Ну допустим создадим мы счетчик, который будет указывать на последнее отправленное сообщение, но в таком случае, дойдем мы до паузы, а она может иметь различную длительность. В этом случае придется пропустить несколько тиков таймера и их тоже надо будет как-то учитывать. Сделать это возможно, но по-моему идея не очень хорошая. Поэтому я решил сделать иначе. Ранее для объединения нескольких наборов сообщений мы создали вспомогательный класс MessagesPackage. Этот класс хорош тем, что в нем есть свойство из которого можно точно узнать в какой момент времени нужно отправлять содержащиеся в нем сообщения. Таким образом если мы будем вести учет времени - то есть прост считать, сколько прошло от начала воспроизведения - то, сравнив текущее значение таймлайна со значением данного свойства нашего пакета мы будем точно знать, следует ли отправить сообщения пакета в данный момент. Кроме того, в дальнейшем это поможет нам воспроизводить произведение с любого момента таймлайна и организовывать паузы. Ну и опять-таки код преобразования массива сообщений в список пакетов мы уже написали ранее. На данный момент код нашего плеера будет следующим.
Кликните здесь для просмотра всего текста
Код csharp Выделить
using System.Collections.Generic;
using System.Threading;
namespace midi
{
    class TimerPlayer : PlayerBase
    {
 
        private Queue<MessagesPackage> pkgqueue;
        private Timer timer;
 
 
        public int TimeLine { get; set; }
        public int TimerInterval { get; set; } = 50;
        private void TimerTick(object state)
        {
            if (pkgqueue.Peek() == null)
            {
                timer.Dispose();
                TimeLine = 0;
                Close();
                return;
            }
            while (pkgqueue.Peek().TimeLine <= TimeLine)
            {
                pkgqueue.Dequeue().MessagesList.ForEach(msg => midiOutShortMsg(handle, msg));
            }
            TimeLine += TimerInterval;
        }
 
 
 
        private void CreatePackageQueue()
        {
            var msglist = MessageProcessor.GetPackagesList(this.MsgList);
            pkgqueue = new Queue<midi.MessagesPackage>(msglist);
        }
 
 
        public void GoOn()
        {
 
        }
 
        public override void Play()
        {
            TimeLine = 0;
            CreatePackageQueue();
            timer = new Timer(TimerTick, null, 0, TimerInterval);
        }
    }
}
А запустить это можно будет так
Код csharp Выделить
            var player = new TimerPlayer();
            var parser = new MusicFileParser();
            player.MsgList = new int[] { 78 << 8 | 0xC0 }.Concat(FormatConverter.BeepToMidiMessages(parser.Parse(Properties.Resources.ElCondorPasa))).ToArray();
            player.Open();
            player.Play();
В проекте из вложения можно посмотреть этот код в работе.
Вложения

MIDI музыка на C#. Часть 2-я.

  1. Воспроизведение потока сообщений
  2. Аккомпанемент
  3. Объединение коллекций сообщений

Воспроизведение потока сообщений



Описанный выше метод воспроизведения мелодии - на самом деле не очень хорош. Он довольно просто реализуется и хорош тем, что в результате мы получаем методику очень похожую на исполнение мелодий на бипере, когда для каждой ноты вызывается метод, которому передается информация о ноте и ее длительности. Это было хорошо для целей демонстрации, но если мы захотим немного расширить наши возможности, то метод придется пересмотреть. Я уже написал, что для воспроизведения полноценной музыки наша программа должна в определенные моменты времени посылать определенные сообщения, причем сообщений может быть достаточно много и они совсем не обязательно должны требовать нажатия или отпускания клавиш или работать на одном лишь канале.

Поскольку все сообщения имеют формат целого числа, равно как и продолжительность пауз между отправкой этих сообщений, конечный формат, который нужно будет воспроизвести, можно представить в виде коллекции целых чисел. Каждое число в этой коллекции будет отдельным сообщением, а для пауз можно использовать опять-таки нуль, который будет означать, что следующее за ним число - продолжительность паузы. То есть при воспроизведении мы будем отправлять все сообщения до тех пор пока не наткнемся на нуль, после чего остановим процесс на время указанное числом, следующим за нулем и далее со следующими сообщениями будем делать то же самое пока коллекция не закончится. Для воспроизведения такого потока сообщений создадим в нашем классе MelodyPlayer свойство
Код csharp Выделить
public int[] MsgList { get; set; }
И метод
Код csharp Выделить
        public void Play()
        {
            for (int i = 0; i < MsgList.Length; i++)
            {
                if (MsgList[i] == 0)
                {
                    i++;
                    Thread.Sleep(MsgList[i]);
                }
                else
                {
                    midiOutShortMsg(handle, MsgList[i]);
 
                };
            }
        }
Можно обойтись без свойства и передавать массив сообщений как аргумент метода (дело вкуса).

Далее эксперименты будем проводить с известной мелодией "Полет кондора", ноты которой приведены во вложении. Используя формат описанный раннее, из этих нот мы получаем следующий код
Код:
0 3000 
1e4 |
1a8 1g+8 1a8 1b8 2c8 1b8 2c8 2d8 | 2e2,4 2g4 |   2e2,4 2a8 2g8 | 2e2,8 2e8 2d8 2c8 | 2d16 2c16 1a2 x8 2c4 | 1a2,4,8 1e8 |
1a8 1g+8 1a8 1b8 2c8 1b8 2c8 2d8 | 2e2,4 2g4 |   2e2,4 2a8 2g8 | 2e2,8 2e8 2d8 2c8 | 2d16 2c16 1a2 x8 2c4 | 1a2,4,8 2e8 |

2a4,8 2g+8 2a8,16 2g16 2a8,16 2b16 | 3c2 x8 2a8 3c8 2a8 | 2g2 x4 2a8 2g8 | 2e2,4 2e4 |
2a4,8 2g+8 2a8,16 2g16 2a8,16 2b16 | 3c2 x8 2a8 3c8 2a8 | 2g2 x4 2a8 2g8 | 2e2 x8 2e8 2d8 2c8 | 2d16 2c16 1a2 x8 2c4 | 1a2,4,8 2e8

2a4,8 2g+8 2a8,16 2g16 2a8,16 2b16 | 3c2 x8 2a8 3c8 2a8 | 2g2 x4 2a8 2g8 | 2e2,4 2e4 |
2a4,8 2g+8 2a8,16 2g16 2a8,16 2b16 | 3c2 x8 2a8 3c8 2a8 | 2g2 x4 2a8 2g8 | 2e2 x8 2e8 2d8 2c8 | 2d16 2c16 1a2 x8 2c4 | 1a2,4
Для обработки этого кода используем парсер, также описанный ранее. В результате обработки парсером, мы получим код для бипера, а нам нужна коллекция сообщений. Для преобразования кодов бипера в коллекцию сообщения добавим вот такой метод.
Код csharp Выделить
        public static int[] BeepToMidiMessages(string beep)
        {
            var result = new List<int>();
            var b = beep.Split(" \t\r\n".ToCharArray(), StringSplitOptions.RemoveEmptyEntries);
            for (int i = 0; i < b.Length; i += 2)
            {
                var duration = int.Parse(b[i + 1]);
                if (b[i] == "0")
                {
                    result.Add(0);
                    result.Add(duration);
                }
                else
                {
                    var note = NoteNumberFromFriquency(double.Parse(b[i]));
                    var msg = 64 << 16 | note << 8 | 0x90;
                    result.Add(msg);
                    result.Add(0);
                    result.Add(duration);
                    result.Add(note << 8 | 0x80);
 
                }
            }
            return result.ToArray();
        }
Теперь добавим код мелодии в ресурсы под именем ElCondorPasa и для воспроизведения нам потребуется следующий код
Код csharp Выделить
        public static void PlayElCondorPasaWithMessages()
        {
            var player = new MelodyPlayer();
            var parser = new MusicFileParser();
            player.MsgList = FormatConverter.BeepToMidiMessages(parser.Parse(Properties.Resources.ElCondorPasa));
            player.Open();
            player.Play();
            player.Close();
        }
Здесь FormatConverter - это класс, в котором я разместил статический метод BeepToMidiMessages, приведенный выше.

Здесь все записывается в первый канал, но это легко исправить, а для демонстрации лучше не усложнять код подробностями, на которых пока не стоит сосредотачиваться.

Теперь нам, например, не нужно вызывать SetInstrument, поскольку мы можем встроить в коллекцию соответствующее сообщение. В строке, где мы инициируем свойство MsgList можно написать так
Код csharp Выделить
            player.MsgList = new int[] { 78 << 8 | 0xC0 }.Concat(  FormatConverter.BeepToMidiMessages(parser.Parse(Properties.Resources.ElCondorPasa))).ToArray();
И мелодия будет исполнена на сякухати, получается очень красиво.

Аккомпанемент



Мелодия - это замечательно, но ведь хотелось бы и гармонию услышать, да и какой-нибудь тыц-тыц-тыдыдыц - тоже не помешал бы.

Мелодия "Полета кондора" достаточно проста, да и гармония тоже. Обыграть ее можно тремя аккордами: ля-минор, до-мажор и фа-мажор. Для того чтобы упростить задачу создания аккомпанемента создадим метод который будет создавать коллекцию сообщений, необходимых для обыгрывания одного аккорда.
Код csharp Выделить
        int[] GetChord(string chord)
        {
            var velocity = 64;
            var full = 3000;
            var prima = CalculateNote3(chord[0]) + 12;
            if (chord.Length > 1)
            {
                switch (chord[1])
                {
                    case '+': prima++; break;
                    case '-': prima--; break;
                    default:
                        break;
                }
            }
            var maj = char.IsUpper(chord[0]);
            var b2 = prima - 5;
            var ter = prima + (maj ? 4 : 3);
            var qu = prima + 7;
            var oct = prima + 12;
            var result = new List<int>();
            result.Add(velocity << 16 | prima << 8 | 0x91);
            result.Add(0);
            result.Add(full / 8);
            result.Add(velocity << 16 | ter << 8 | 0x91);
            result.Add(velocity << 16 | qu << 8 | 0x91);
            result.Add(velocity << 16 | oct << 8 | 0x91);
            result.Add(0);
            result.Add(full / 16);
            result.Add(ter << 8 | 0x81);
            result.Add(qu << 8 | 0x81);
            result.Add(oct << 8 | 0x81);
            result.Add(velocity << 16 | ter << 8 | 0x91);
            result.Add(velocity << 16 | qu << 8 | 0x91);
            result.Add(velocity << 16 | oct << 8 | 0x91);
            result.Add(0);
            result.Add(full / 16);
            result.Add(ter << 8 | 0x81);
            result.Add(qu << 8 | 0x81);
            result.Add(oct << 8 | 0x81);
            result.Add(prima << 8 | 0x81);
 
            result.Add(velocity << 16 | b2 << 8 | 0x91);
            result.Add(0);
            result.Add(full / 8);
            result.Add(velocity << 16 | ter << 8 | 0x91);
            result.Add(velocity << 16 | qu << 8 | 0x91);
            result.Add(velocity << 16 | oct << 8 | 0x91);
            result.Add(0);
            result.Add(full / 8);
            result.Add(ter << 8 | 0x81);
            result.Add(qu << 8 | 0x81);
            result.Add(oct << 8 | 0x81);
            result.Add(b2 << 8 | 0x81);
            return result.ToArray();
        }
 
        int CalculateNote3(char n)
        {
            switch (char.ToLower(n))
            {
                case 'a': return 45;
                case 'b': return 47;
                case 'c': return 48;
                case 'd': return 50;
                case 'e': return 52;
                case 'f': return 53;
                case 'g': return 55;
                default:
                    throw new ArgumentException();
            }
        }
Рисунок, который он выдает - достаточно прост и занимает полтакта. Чтобы послушать, что этот метод делает, можно запустить такой код
Код csharp Выделить
            var player = new MelodyPlayer();
            var list = "a a d d B- E a a".Split(" \r\n\t".ToCharArray(), StringSplitOptions.RemoveEmptyEntries).SelectMany(i => GetChord(i));
            player.MsgList = new int[] { 25 << 8 | 0xC1 }.Concat(list).ToArray();
            player.Open();
            player.Play();
            player.Close();
Здесь a a d d B- E a a - последовательность аккордов. Малая буква - аккорд минорный, Большая - мажорный, плюс после буквы - диез, минус - бемоль.

Я здесь жестко закодировал продолжительность целой ноты и метод выдающий номер клавиши по букве, выдает номер ноты на конкретной октаве. Кроме того, сообщения создаются для первого канала. Естественно, впоследствии надо будет это все немного переделать, но сейчас, дабы не отвлекаться от основных вопросов, лучше все немного упростить.

Ну и собственно гармония для нашей мелодии будет выглядеть так
Код:
a a C C C C C C a a a a 
a a C C C C C C a a a a
F F F F C C C C 
F F F F C C C C a a a a
А весь код, который ее проигрывает - так
Код csharp Выделить
            var player = new MelodyPlayer();
            var list = @"
a a C C C C C C a a a a 
a a C C C C C C a a a a
F F F F C C C C 
F F F F C C C C a a a a".Split(" \r\n\t".ToCharArray(), StringSplitOptions.RemoveEmptyEntries).SelectMany(i => GetChord(i));
            player.MsgList = new int[] { 25 << 8 | 0xC1, 0 , 3000 / 4 }.Concat(list).ToArray();
            player.Open();
            player.Play();
            player.Close();
Здесь еще в коллекцию сообщений добавлена установка инструмента №25 - это акустическая гитара с нейлоновыми струнами и пауза на одну четверть вначале, поскольку мелодия начинается с затакта длительностью в одну четверть, а аккорды будут начинать звучать в начале такта.


Объединение коллекций сообщений



На данный момент мы можем проиграть мелодию и аккорды к ней. Одна беда - сделать мы можем это раздельно. Теперь нам нужно объединить две коллекции сообщений в одну.

Для того, чтобы упростить алгоритм объединения, создадим вспомогательный класс
Код csharp Выделить
    class MessagesPackage
    {
        public int TimeLine { get; set; }
        public List<int> MessagesList { get; set; } = new List<int>();
    }
В экземпляр этого класса будут размещаться сообщения, которые надо отправить одновременно (свойство MessageesList), а свойство Timeline будет хранить количество миллисекунд, прошедших с начала воспроизведения. То есть благодаря такому объекту мы будем точно знать в какой момент времени пакет сообщений должен быть отправлен.

Далее, нам надо конвертировать коллекцию сообщений с которой мы работали ранее в коллекцию экземпляров MessagePackage.
Код csharp Выделить
        List<MessagesPackage> GetPackagesList(int[] msgs)
        {
            int timeline = 0;
            int counter = 0;
            List<MessagesPackage> result = new List<midi.MessagesPackage>();
 
            while (true)
            {
                if (msgs.Length <= counter) break;
                if (msgs[counter] == 0)
                {
                    counter++;
                    timeline += msgs[counter];
                    result.Add(new midi.MessagesPackage() { TimeLine = timeline });
                }
                else
                {
                    if (result.Count == 0) result.Add(new MessagesPackage() { TimeLine = 0 });
                    result.Last().MessagesList.Add(msgs[counter]);
                }
                counter++;
            }
 
            return result;
        }
Алгоритм довольно прост: коллекцию сообщений пакета образуют все сообщения между двумя паузами, а состояние таймлайна определяется как сумма продолжительностей всей пауз, предшествующих данному блоку сообщений.

Теперь для слияния нескольких коллекций сообщений, их все надо преобразовать в коллекции пакетов, объединить, отсортировать по значению свойства TimeLine и объединить сообщения, вставляя на границах пакетов паузы. Продолжительность пауз определяется разностью между значением состояния таймланов текущего и предыдущего пакетов(если она равна нулю - пауза не вставляется).
Код csharp Выделить
        public int[] MergeMessagesLists(params int[][] lists)
        {
            var mplist = lists.SelectMany(GetPackagesList).OrderBy(mp => mp.TimeLine).ToArray();
            for (int i = 0; i < mplist.Count(); i++)
            {
                if (i > 0 && mplist[i].TimeLine == mplist[i - 1].TimeLine) continue;
                mplist[i].MessagesList.InsertRange(0, new int[] { 0, i == 0 ? mplist[i].TimeLine : mplist[i].TimeLine - mplist[i - 1].TimeLine });
            }
            return mplist.SelectMany(mp => mp.MessagesList).ToArray();
        }
Ну и теперь, наконец, мы можем объединить мелодию и аккорды и уже послушать, что получилось.

Код csharp Выделить
            var parser = new MusicFileParser();
 
            var chords = @"
a a C C C C C C a a a a 
a a C C C C C C a a a a
F F F F C C C C 
F F F F C C C C a a a a
F F F F C C C C 
F F F F C C C C a a a a
".Split(" \r\n\t".ToCharArray(), StringSplitOptions.RemoveEmptyEntries).SelectMany(GetChord).ToArray();
            chords = new int[] { 25 << 8 | 0xC1, 0, 3000 / 4 }.Concat(chords).ToArray();
            var melody = new int[] { 78 << 8 | 0xC0 }.Concat(FormatConverter.BeepToMidiMessages(parser.Parse(Properties.Resources.ElCondorPasa))).ToArray();
            var player = new MelodyPlayer();
            player.MsgList = MergeMessagesLists(chords, melody);
            player.Open();
            player.Play();
            player.Close();
Во вложении проект, содержащий коды из статей с возможностью проиграть мелодии.

Третья часть статьи - в планах. ))
Миниатюры
Вложения

MIDI музыка на C#. Часть 1-я.

  1. Воспроизводим ноту
  2. Сыграем мелодию
  3. Воспользуемся старыми наработками
Разбираясь в вопросах темы "Мелодии на бипере", решил не останавливаться на достигнутом и пошел дальше. Наиболее естественным способом что-то сыграть на компьютере является использование MIDI. Естественно, для разработки профессионального музыкального софта пришлось бы изучать все спецификации и разбираться во множестве технических моментов. Но для того, чтобы написать что-то небольшое и несложное, достаточно иметь базовые представления о том, как это все работает. Вот в этом мы сейчас и будем разбираться.

Воспроизводим ноту



В деталях этот вопрос описан в статье Making Music with MIDI and C#, так что пересказывать подробно здесь все не буду, опишу тезисно только то, что понадобится для дальнейшего развития темы.

Для реализации задуманного нам понадобится три WinAPI функции
Код csharp Выделить
using System.Runtime.InteropServices;
Код csharp Выделить
        [DllImport("winmm.dll")]
        private static extern int midiOutOpen(ref int handle,
   int deviceID, MidiCallBack proc, int instance, int flags);
 
        [DllImport("winmm.dll")]
        protected static extern int midiOutShortMsg(int handle,
           int message);
 
        [DllImport("winmm.dll")]
        protected static extern int midiOutClose(int handle);
С помощью первой мы будем открывать MIDI-устройство и получать его дескриптор (hadle), с помощью последнего - закрывать, а функция midiOutShortMsg - это как раз и есть основная функция с помощью которой и будет воспроизводиться музыка.
Простейший код, который позволит нам воспроизвести ноту до первой октавы будет выглядеть так
Код csharp Выделить
int handle = 0; // Переменная для хранения дескриптора устройства
res = midiOutOpen(ref handle, 0, null, 0, 0); // Открываем устройство  и получаем его дескриптор
res = midiOutShortMsg(handle, 0x007F3C90); // Воспроизводим ноту
Функция midiOutShortMsg может выполнять огромное количество всевозможных операций и что именно будет делать эта функция - зависит от значения второго аргумента. В общем и целом она посылает устройству с дескриптором, передаваемым первым аргументом сообщение - второй аргумент.

Теперь немного о сообщении. Хоть оно и имеет тип int, тем не менее оно состоит из трех частей, по одному байту каждая.
  1. Первый байт (читаем справа-налево, то есть в сообщении 0x007F3C90 это будут шестнадцатиричные цифры 90) - это так называемый статус-байт, он содержит команду и номер канала. В данном случае команда - 9 означает взятие ноты NoteOn. Она будет воспроизведена на первом канале. Если надо воспроизвести ноту на втором канале мы будем использовать команду 91 и так далее, всего шестнадцать каналов.
  2. Второй байт( в данном случае 3C) - собственно нота, которую мы хотим воспроизвести. Все ноты пронумерованы от 0 до 127. Таблица нот есть в статье, упоминавшейся вначале.
  3. Ну и третий байт - сила с которой взята нота. Обычно этот параметр влияет на громкость, но если речь идет, например, о фортепианной ноте, то это будет сила удара и т.д. (в конечном итоге все равно будет громче). Эта величина также может принимать значения от 0 до 127.

Первый байт сообщения это всегда команда, а вот следующие два - параметры команды и они могут быть, а может их и не быть, или, например может быть только один параметр. Зависит от команды. Например команда, устанавливающая инструмент для канала имеет только один параметр - собственно номер инструмента.

Сыграем мелодию



Казалось бы, вот теперь выдавай себе команды на взятие клавиш и получай мелодию, как это было на бипере. Единственное, что непонятно, так это как долго будет звучать взятая нота, прежде чем будет взята следующая. Но на самом деле, если мы захотим проиграть последовательно ноты до, ми и соль первой октавы (60, 64 и 67 соответственно) и для этого выполним вот такой код
Код csharp Выделить
int handle = 0; 
res = midiOutOpen(ref handle, 0, null, 0, 0);
midiOutShortMsg(handle, 127 << 16 | 60 << 8 | 0x00000090);
midiOutShortMsg(handle, 127 << 16 | 64 << 8 | 0x00000090);
midiOutShortMsg(handle, 127 << 16 | 67 << 8 | 0x00000090);
То эти ноты воспроизведутся одновременно и мы услышим аккорд до-мажор. Продолжительность же звучания будет сколь угодно долгой. Хотя на некоторых инструментах звучание скоро прекратится, но это связано с тем, что они имитируют инструменты с угасающими колебаниями. Например гитарный или фортепианный звуки со временем угасают из-за того, что струны, которые их воспроизводят просто перестают колебаться. А вот если выбрать инструмент типа органа, то взятая нота будет звучать пока ее эту вакханалию не прекратишь тем или иным способом.

Для того, чтобы понять как именно работает MIDI-устройство, можно представить себе синтезатор, на котором есть куча клавиш, всевозможных функциональных кнопок, переключателей, ручек, слайдеров. Также к нему может быть подключена педаль и прочие прибамбасы. Для того, чтобы зазвучала музыка, человеку приходится нажимать клавиши, что-то переключать, жать на педаль и так далее. Кроме того, все это делается во времени, и каждое действие должно быть выполнено в определенный момент. Так вот MIDI-устройство - это то же самое, только вместо всех этих нажатий, отпусканий поворотов и т. д. просто отправляются сообщения. Нажал клавишу - отправилось сообщение о нажатии клавиши, отпустил клавишу - сообщение об отпускании клавиши, сменил тембр... дальше ясно.

Таким образом, если мы хотим чтобы ноты из примера сверху звучали по полсекунды каждая и сменяли друг друга, то нам надо отправлять сообщения не только о нажатии клавиш, но об их отпускании, причем выдерживая интервалы между этим операциями, чтобы дать нотам позвучать.

Команда NoteOff задается как 8x, в отличие от 9x для NoteOn. Здесь также вместо x нужно указать канал на котором надо прекратить звучание ноты, то есть для первого канала это будет 80. И таким образом код, проигрывающий три ноты подряд будет выглядеть так.
Код csharp Выделить
midiOutShortMsg(handle, 127 << 16 | 60 << 8 | 0x00000090);
Thread.Sleep(500);
midiOutShortMsg(handle,  60 << 8 | 0x00000080);
midiOutShortMsg(handle, 127 << 16 | 64 << 8 | 0x00000090);
Thread.Sleep(500);
midiOutShortMsg(handle,  64 << 8 | 0x00000080);
midiOutShortMsg(handle, 127 << 16 | 67 << 8 | 0x00000090);
Thread.Sleep(500);
midiOutShortMsg(handle,  67 << 8 | 0x00000080);
Thread.Sleep(500);
midiOutClose(handle);
В конце я закрыл устройство. Это необходимо делать, поскольку, если оно остается открытым, то открыть его снова нельзя и надо будет либо использовать ранее полученный дескриптор, либо устройство будет закрыто только вместе приложением, открывшим его. В предыдущих примерах я этого не делал из-за того, что, закрыв устройство сразу после открытия, мы бы ничего не услышали. Здесь же выдержаны паузы и устройство закрывается своевременно.

Воспользуемся старыми наработками



Коль скоро мы выяснили, как исполнять мелодии, было бы неплохо иметь возможность воспроизвести все, что было сделано в предыдущей статье, где речь шла о мелодиях для бипера. В конце концов мелодии подобраны, известны частоты звуков и длительности звуков и пауз, что еще нужно-то?

Создадим небольшой плеер для воспроизведения мелодий.
Код csharp Выделить
using System.Runtime.InteropServices;
using System.Threading;
 
namespace midi
{
    class MelodyPlayer
    {
 
        [DllImport("winmm.dll")]
        private static extern int midiOutOpen(ref int handle,
   int deviceID, MidiCallBack proc, int instance, int flags);
 
        [DllImport("winmm.dll")]
        protected static extern int midiOutShortMsg(int handle,
           int message);
 
        [DllImport("winmm.dll")]
        protected static extern int midiOutClose(int handle);
 
        private delegate void MidiCallBack(int handle, int msg,
   int instance, int param1, int param2);
 
 
        int handle = 0;
        public void Open()
        {
            var res = midiOutOpen(ref handle, 0, null, 0, 0);
        }
 
        public void Close()
        {
            var res = midiOutClose(handle);
        }
 
        public void SetInstrument(int id)
        {
            var res = midiOutShortMsg(handle, id << 8 | 0x000000C0);
        }
 
        public void PlayNote(int note, int duration)
        {
            var res = midiOutShortMsg(handle, 127 << 16 | note << 8 | 0x00000090);
            Thread.Sleep(duration);
            res = midiOutShortMsg(handle, 127 << 16 | note << 8 | 0x00000080);
        }
    }
}
Здесь у нас есть метод Open, открывающий устройство 0. Метод Close, закрывающий открытое устройство. Метод SetInstrument устанавливает интсрумент для первого канала. Здесь мы используем еще одну команду Cx. Опять-таки вместо x используется номер канала, а второй байт представляет из себя номер инструмента, из списка, приведенного здесь.
GM 1 Sound Set
Для того, чтобы было удобнее пользоваться этим списком, лучше оформить его в виде перечисления. Я воспользовался расширением CustomButtons для Firefox и создал кнопку со следующим кодом
Код javascript Выделить
var headerRow = Array.prototype.filter.call( content.document.querySelectorAll("tr"), function(tr){return tr.textContent.search("Instrument Name") > -1;})[0];
var rows = headerRow.parentElement.querySelectorAll("tr");
var s = "public enum MusicalInstruments\r\n{\r\n";
for(var i = 3; i < rows.length; i++ )
{
  var row = rows[i];
  var tds = row.querySelectorAll("td");
  var name = tds[1].textContent.replace(/[\s\(\)\-\+]+/g, "_").replace(/_$/, "");
  var value = tds[0].textContent.substr(0, tds[0].textContent.length - 1);
  s += "    " + name + " = " + value + ",\r\n";
}
s += "}";
 
gClipboard.write(s);
Далее, открыл страницу и выполнил код кнопки. В результате в буфер обмена скопировался почти готовый код перечисления(там только запятую лишнюю в конце убрать надо).

Кликните здесь для просмотра всего текста
Код csharp Выделить
    public enum MusicalInstruments
    {
        Acoustic_Grand_Piano = 1,
        Bright_Acoustic_Piano = 2,
        Electric_Grand_Piano = 3,
        Honky_tonk_Piano = 4,
        Electric_Piano_1 = 5,
        Electric_Piano_2 = 6,
        Harpsichord = 7,
        Clavi = 8,
        Celesta = 9,
        Glockenspiel = 10,
        Music_Box = 11,
        Vibraphone = 12,
        Marimba = 13,
        Xylophone = 14,
        Tubular_Bells = 15,
        Dulcimer = 16,
        Drawbar_Organ = 17,
        Percussive_Organ = 18,
        Rock_Organ = 19,
        Church_Organ = 20,
        Reed_Organ = 21,
        Accordion = 22,
        Harmonica = 23,
        Tango_Accordion = 24,
        Acoustic_Guitar_nylon = 25,
        Acoustic_Guitar_steel = 26,
        Electric_Guitar_jazz = 27,
        Electric_Guitar_clean = 28,
        Electric_Guitar_muted = 29,
        Overdriven_Guitar = 30,
        Distortion_Guitar = 31,
        Guitar_harmonics = 32,
        Acoustic_Bass = 33,
        Electric_Bass_finger = 34,
        Electric_Bass_pick = 35,
        Fretless_Bass = 36,
        Slap_Bass_1 = 37,
        Slap_Bass_2 = 38,
        Synth_Bass_1 = 39,
        Synth_Bass_2 = 40,
        Violin = 41,
        Viola = 42,
        Cello = 43,
        Contrabass = 44,
        Tremolo_Strings = 45,
        Pizzicato_Strings = 46,
        Orchestral_Harp = 47,
        Timpani = 48,
        String_Ensemble_1 = 49,
        String_Ensemble_2 = 50,
        SynthStrings_1 = 51,
        SynthStrings_2 = 52,
        Choir_Aahs = 53,
        Voice_Oohs = 54,
        Synth_Voice = 55,
        Orchestra_Hit = 56,
        Trumpet = 57,
        Trombone = 58,
        Tuba = 59,
        Muted_Trumpet = 60,
        French_Horn = 61,
        Brass_Section = 62,
        SynthBrass_1 = 63,
        SynthBrass_2 = 64,
        Soprano_Sax = 65,
        Alto_Sax = 66,
        Tenor_Sax = 67,
        Baritone_Sax = 68,
        Oboe = 69,
        English_Horn = 70,
        Bassoon = 71,
        Clarinet = 72,
        Piccolo = 73,
        Flute = 74,
        Recorder = 75,
        Pan_Flute = 76,
        Blown_Bottle = 77,
        Shakuhachi = 78,
        Whistle = 79,
        Ocarina = 80,
        Lead_1_square = 81,
        Lead_2_sawtooth = 82,
        Lead_3_calliope = 83,
        Lead_4_chiff = 84,
        Lead_5_charang = 85,
        Lead_6_voice = 86,
        Lead_7_fifths = 87,
        Lead_8_bass_lead = 88,
        Pad_1_new_age = 89,
        Pad_2_warm = 90,
        Pad_3_polysynth = 91,
        Pad_4_choir = 92,
        Pad_5_bowed = 93,
        Pad_6_metallic = 94,
        Pad_7_halo = 95,
        Pad_8_sweep = 96,
        FX_1_rain = 97,
        FX_2_soundtrack = 98,
        FX_3_crystal = 99,
        FX_4_atmosphere = 100,
        FX_5_brightness = 101,
        FX_6_goblins = 102,
        FX_7_echoes = 103,
        FX_8_sci_fi = 104,
        Sitar = 105,
        Banjo = 106,
        Shamisen = 107,
        Koto = 108,
        Kalimba = 109,
        Bag_pipe = 110,
        Fiddle = 111,
        Shanai = 112,
        Tinkle_Bell = 113,
        Agogo = 114,
        Steel_Drums = 115,
        Woodblock = 116,
        Taiko_Drum = 117,
        Melodic_Tom = 118,
        Synth_Drum = 119,
        Reverse_Cymbal = 120,
        Guitar_Fret_Noise = 121,
        Breath_Noise = 122,
        Seashore = 123,
        Bird_Tweet = 124,
        Telephone_Ring = 125,
        Helicopter = 126,
        Applause = 127,
        Gunshot = 128
    }

Имея такое перечисление можно перегрузить метод SetInstrument вот таким методом.
Код csharp Выделить
       public void SetInstrument(MusicalInstruments id)
        {
            midiOutShortMsg(handle, (int)id << 8 | 0x000000C0);
        }
Пользоваться им намного удобнее.

Ну и наконец метод PlayNote я сделал похожим на метод Console.Beep, за исключением того, что первый аргумент - это не частота, а номер ноты. Таким образом примеры из предыдущей статьи сначала придется обработать, вычислив номер ноты по ее частоте. Вычисление это несложное, метод выглядит так
Код csharp Выделить
        int NoteNumberFromFriquency(double friquency)
        {
            return (int)Math.Round(69.0 + 12.0 * (Math.Log(friquency / 440.0) / Math.Log(2.0)));
        }
Теперь для того, чтобы преобразовать строку с числами для бипера, в которой у нас частоты чередуются с длительностями мы создадим следующий метод
Код csharp Выделить
        int[] BeepToMidi(string beep)
        {
            var result = new List<int>();
            var b = beep.Split(" \t\r\n".ToCharArray(), StringSplitOptions.RemoveEmptyEntries);
            for (int i = 0; i < b.Length; i += 2)
            {
                if (b[i] == "0")
                {
                    result.Add(-1);
                }
                else
                {
                    result.Add(NoteNumberFromFriquency(double.Parse(b[i])));
                }
                result.Add(int.Parse(b[i + 1]));
            }
            return result.ToArray();
        }
Он получает строку, а возвращает массив чисел, которые мы можем использовать. Вот так можно проиграть "Имперский марш" из статьи о бипере(инструмент, разумеется, можно выбрать и другой).
Код csharp Выделить
        void PlayImperialWithNotes()
        {
            var song = "440 500 440 500 440 500 349 350 523 150 440 500 349 350 523 150 440 1000 659 500 659 500 659 500 698 350 523 150 415 500 349 350 523 150 440 1000 880 500 440 350 440 150 880 500 830 250 784 250 740 125 698 125 740 250 0 250 455 250 622 500 587 250 554 250 523 125 466 125 523 250 0 250 349 125 415 500 349 375 440 125 523 500 440 375 523 125 659 1000 880 500 440 350 440 150 880 500 830 250 784 250 740 125 698 125 740 250 0 250 455 250 622 500 587 250 554 250 523 125 466 125 523 250 0 250 349 250 415 500 349 375 523 125 440 500 349 375 261 125 440 1000 0 100";
            var songInt = BeepToMidi(song);
            var player = new MelodyPlayer();
                player.Open();
                player.SetInstrument(44);
                for (int i = 0; i < songInt.Length; i += 2)
                {
                    if (songInt[i] == -1)
                    {
                        Thread.Sleep(songInt[i + 1]);
                    }
                    else
                    {
                        player.PlayNote(songInt[i], songInt[i + 1]);
                    }
                }
                player.Close();
        }
Формат, придуманный для "снятия" мелодий с нотного листа, тоже можно использовать, поскольку можно сначала пропустить его через парсер, а уже результат использовать в методах, описанных выше.