### Basic SoundFlow MIDI Player Setup

Source: https://github.com/sinshu/meltysynth/blob/main/Examples/SoundFlow/README.md

Initializes the MiniAudio engine, creates a MidiPlayer, loads a SoundFont and a MIDI file, and plays the file. Requires a SoundFont file (e.g., TimGM6mb.sf2) and a MIDI file.

```csharp
using System;
using SoundFlow.Backends.MiniAudio;
using SoundFlow.Components;
using SoundFlow.Enums;
using MeltySynth;

class Program
{
    static void Main()
    {
        using (var engine = new MiniAudioEngine(44100, Capability.Playback))
        {
            var player = new MidiPlayer("TimGM6mb.sf2", engine.SampleRate);
            Mixer.Master.AddComponent(player);

            // Load the MIDI file.
            var midiFile = new MidiFile(@"C:\\Windows\\Media\\flourish.mid");

            // Play the MIDI file.
            player.Play(midiFile, true);

            // Wait until any key is pressed.
            Console.ReadKey();
        }
    }
}
```

--------------------------------

### Raylib-cs MIDI Player Implementation

Source: https://github.com/sinshu/meltysynth/blob/main/Examples/Raylib_cs/README.md

This C# code snippet shows a complete example of initializing Raylib, setting up an audio stream, and playing a MIDI file using MeltySynth. It handles audio buffer processing and rendering within the main game loop.

```csharp
using System;
using Raylib_cs;
using MeltySynth;

class Program
{
    static int sampleRate = 44100;
    static int bufferSize = 4096;

    unsafe static void Main()
    {
        Raylib.InitWindow(800, 450, "MIDI Player");

        Raylib.InitAudioDevice();
        Raylib.SetAudioStreamBufferSizeDefault(bufferSize);

        var stream = Raylib.LoadAudioStream((uint)sampleRate, 16, 2);
        var buffer = new short[2 * bufferSize];

        Raylib.PlayAudioStream(stream);

        var synthesizer = new Synthesizer("TimGM6mb.sf2", sampleRate);
        var sequencer = new MidiFileSequencer(synthesizer);
        var midiFile = new MidiFile(@"C:\\Windows\\Media\\flourish.mid");

        sequencer.Play(midiFile, true);

        Raylib.SetTargetFPS(60);

        while (!Raylib.WindowShouldClose())
        {
            if (Raylib.IsAudioStreamProcessed(stream))
            {
                sequencer.RenderInterleavedInt16(buffer);
                fixed (short* p = buffer)
                {
                    Raylib.UpdateAudioStream(stream, p, bufferSize);
                }
            }

            Raylib.BeginDrawing();
            Raylib.ClearBackground(Color.LIGHTGRAY);
            Raylib.DrawText("MUSIC SHOULD BE PLAYING!", 255, 200, 20, Color.DARKGRAY);
            Raylib.EndDrawing();
        }

        Raylib.CloseWindow();
    }
}
```

--------------------------------

### Synthesize Melody by Rendering Blocks

Source: https://github.com/sinshu/meltysynth/blob/main/README.md

This example synthesizes a melody by processing and rendering audio in short blocks. It defines a melody as a sequence of start time, end time, and pitch, then renders the audio over a specified duration. Requires a SoundFont file and sample rate.

```csharp
// Create the synthesizer.
var sampleRate = 44100;
var synthesizer = new Synthesizer("TimGM6mb.sf2", sampleRate);

// The length of a block is 0.1 sec.
var blockSize = sampleRate / 10;

// The entire output is 3 sec.
var blockCount = 30;

// Define the melody.
// A single row indicates the start timing, end timing, and pitch.
var data = new int[][]
{
    new int[] {  5, 10, 60 },
    new int[] { 10, 15, 64 },
    new int[] { 15, 25, 67 }
};

// The output buffer.
var left = new float[blockSize * blockCount];
var right = new float[blockSize * blockCount];

for (var t = 0; t < blockCount; t++)
{
    // Process the melody.
    foreach (var row in data)
    {
        if (t == row[0]) synthesizer.NoteOn(0, row[2], 100);
        if (t == row[1]) synthesizer.NoteOff(0, row[2]);
    }

    // Render the block.
    var blockLeft = left.AsSpan(blockSize * t, blockSize);
    var blockRight = right.AsSpan(blockSize * t, blockSize);
    synthesizer.Render(blockLeft, blockRight);
}
```

--------------------------------

### Install MeltySynth NuGet Package

Source: https://github.com/sinshu/meltysynth/blob/main/README.md

Use this PowerShell command to install the MeltySynth NuGet package into your .NET project.

```powershell
Install-Package MeltySynth
```

--------------------------------

### MonoGame MIDI Player Implementation

Source: https://github.com/sinshu/meltysynth/blob/main/Examples/MonoGame/README.md

This C# code snippet shows a basic MonoGame application setup for playing MIDI files. It initializes the MidiPlayer with a SoundFont, loads a MIDI file, and handles playback within the game's Update loop. Ensure the SoundFont and MIDI file paths are correct.

```csharp
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Audio;
using Microsoft.Xna.Framework.Graphics;
using MeltySynth;

public class Game1 : Game
{
    private GraphicsDeviceManager graphics;

    private MidiPlayer midiPlayer;
    private MidiFile midiFile;

    public Game1()
    {
        graphics = new GraphicsDeviceManager(this);
    }

    protected override void LoadContent()
    {
        midiPlayer = new MidiPlayer("TimGM6mb.sf2");
        midiFile = new MidiFile(@"C:\Windows\Media\flourish.mid");
    }

    protected override void UnloadContent()
    {
        midiPlayer.Dispose();
    }

    protected override void Update(GameTime gameTime)
    {
        if (midiPlayer.State == SoundState.Stopped)
        {
            midiPlayer.Play(midiFile, true);
        }

        base.Update(gameTime);
    }

    protected override void Draw(GameTime gameTime)
    {
        GraphicsDevice.Clear(Color.CornflowerBlue);

        base.Draw(gameTime);
    }
}
```

--------------------------------

### Mute MIDI Track by Channel

Source: https://github.com/sinshu/meltysynth/blob/main/README.md

Mutes a specific MIDI track by intercepting and discarding messages on the percussion channel (channel 9). Requires synthesizer and sequencer setup.

```csharp
var sampleRate = 44100;
var synthesizer = new Synthesizer("TimGM6mb.sf2", sampleRate);
var midiFile = new MidiFile(@"C:\\Windows\\Media\\flourish.mid");
var sequencer = new MidiFileSequencer(synthesizer);
sequencer.OnSendMessage = (synthesizer, channel, command, data1, data2) =>
{
    if (channel == 9)
    {
        return;
    }
    synthesizer.ProcessMidiMessage(channel, command, data1, data2);
};
sequencer.Play(midiFile, false);
var left = new float[(int)(sampleRate * midiFile.Length.TotalSeconds)];
var right = new float[(int)(sampleRate * midiFile.Length.TotalSeconds)];
sequencer.Render(left, right);
```

--------------------------------

### Initialize and Play MIDI with CSCore

Source: https://github.com/sinshu/meltysynth/blob/main/Examples/CSCore/README.md

Initializes a MidiWaveSource with a soundfont, plays a MIDI file, and manages audio output using WaveOut. Ensure 'TimGM6mb.sf2' and the MIDI file path are valid.

```csharp
using System;
using CSCore.SoundOut;
using MeltySynth;

class Program
{
    static void Main()
    {
        var player = new MidiWaveSource("TimGM6mb.sf2");

        using (var waveOut = new WaveOut())
        {
            waveOut.Initialize(player);
            waveOut.Play();

            // Load the MIDI file.
            var midiFile = new MidiFile(@"C:\Windows\Media\flourish.mid");

            // Play the MIDI file.
            player.Play(midiFile, true);

            // Wait until any key is pressed.
            Console.ReadKey();
        }
    }
}
```

--------------------------------

### Synthesize MIDI Audio with Program Change

Source: https://github.com/sinshu/meltysynth/blob/main/README.md

Demonstrates initializing a synthesizer with a SoundFont, changing the instrument using a MIDI program change command, and rendering a short audio buffer. Requires a SoundFont file and a sample rate.

```csharp
// Create the synthesizer.
var sampleRate = 44100;
var synthesizer = new Synthesizer("TimGM6mb.sf2", sampleRate);

// Change the instrument to electric guitar (#30).
synthesizer.ProcessMidiMessage(0, 0xC0, 30, 0);

// Play some notes (middle C, E, G).
synthesizer.NoteOn(0, 60, 100);
synthesizer.NoteOn(0, 64, 100);
synthesizer.NoteOn(0, 67, 100);

// The output buffer (3 seconds).
var left = new float[3 * sampleRate];
var right = new float[3 * sampleRate];

// Render the waveform.
synthesizer.Render(left, right);
```

--------------------------------

### SDL2# MIDI Player Initialization and Playback

Source: https://github.com/sinshu/meltysynth/blob/main/Examples/SDL2/README.md

This C# snippet shows how to initialize an SDL2 audio device and play a MIDI file using the MeltySynth library. Ensure you have a SoundFont file (e.g., TimGM6mb.sf2) and a MIDI file available.

```cs
using System;
using SDL2;
using MeltySynth;

class Program
{
    static void Main()
    {
        var player = new MidiPlayer("TimGM6mb.sf2");

        SDL.SDL_InitSubSystem(SDL.SDL_INIT_AUDIO);

        var desired = new SDL.SDL_AudioSpec();
        desired.freq = 44100;
        desired.format = SDL.AUDIO_F32;
        desired.channels = 2;
        desired.samples = 4096;
        desired.callback = player.ProcessAudio;

        var obtained = new SDL.SDL_AudioSpec();

        var name = SDL.SDL_GetAudioDeviceName(0, 0);
        var device = SDL.SDL_OpenAudioDevice(name, 0, ref desired, out obtained, (int)SDL.SDL_AUDIO_ALLOW_ANY_CHANGE);
        if (device == 0)
        {
            throw new Exception("Failed to open the audio device.");
        }

        SDL.SDL_PauseAudioDevice(device, 0);

        // Load the MIDI file.
        var midiFile = new MidiFile(@"C:\\Windows\\Media\\flourish.mid");

        // Play the MIDI file.
        player.Play(midiFile, true);

        // Wait until any key is pressed.
        Console.ReadKey();

        SDL.SDL_CloseAudioDevice(device);

        SDL.SDL_QuitSubSystem(SDL.SDL_INIT_AUDIO);
    }
}
```

--------------------------------

### Basic DrippyAL MIDI Player Implementation

Source: https://github.com/sinshu/meltysynth/blob/main/Examples/DrippyAL/README.md

This C# snippet shows how to initialize a MidiPlayer with a SoundFont, set up an AudioDevice and AudioStream, load a MIDI file, and play it using DrippyAL.

```csharp
using System;
using DrippyAL;
using MeltySynth;

class Program
{
    static void Main()
    {
        var midiPlayer = new MidiPlayer("TimGM6mb.sf2");

        using (var device = new AudioDevice())
        using (var stream = new AudioStream(device, 44100, 2))
        {
            stream.Play(midiPlayer.FillBlock);

            // Load the MIDI file.
            var midiFile = new MidiFile(@"C:\Windows\Media\flourish.mid");

            // Play the MIDI file.
            midiPlayer.Play(midiFile, true);

            // Wait until any key is pressed.
            Console.ReadKey();
        }
    }
}
```

--------------------------------

### NAudio MIDI Player with SoundFont

Source: https://github.com/sinshu/meltysynth/blob/main/Examples/NAudio/README.md

This C# snippet shows how to initialize a MidiSampleProvider with a SoundFont, play a MIDI file using WaveOut, and handle playback.

```csharp
using System;
using NAudio.Wave;
using MeltySynth;

class Program
{
    static void Main()
    {
        var player = new MidiSampleProvider("TimGM6mb.sf2");

        using (var waveOut = new WaveOut(WaveCallbackInfo.FunctionCallback()))
        {
            waveOut.Init(player);
            waveOut.Play();

            // Load the MIDI file.
            var midiFile = new MidiFile(@"C:\Windows\Media\flourish.mid");

            // Play the MIDI file.
            player.Play(midiFile, true);

            // Wait until any key is pressed.
            Console.ReadKey();
        }
    }
}
```

--------------------------------

### MIDI Player with Silk.NET and SDL

Source: https://github.com/sinshu/meltysynth/blob/main/Examples/Silk.NET.SDL/README.md

This C# code snippet shows how to initialize SDL audio, open an audio device, and play a MIDI file using Silk.NET and MeltySynth. Ensure you have the 'TimGM6mb.sf2' SoundFont and a MIDI file available.

```csharp
using System;
using Silk.NET.SDL;
using MeltySynth;

class Program
{
    unsafe static void Main()
    {
        var player = new MidiPlayer("TimGM6mb.sf2");

        using (var sdl = Sdl.GetApi())
        {
            sdl.InitSubSystem(Sdl.InitAudio);

            var desired = new AudioSpec();
            desired.Freq = 44100;
            desired.Format = Sdl.AudioF32;
            desired.Channels = 2;
            desired.Samples = 4096;
            desired.Callback = new PfnAudioCallback(new AudioCallback(player.ProcessAudio));

            var device = sdl.OpenAudioDevice((string)null, 0, ref desired, null, (int)Sdl.AudioAllowAnyChange);
            if (device == 0)
            {
                throw sdl.GetErrorAsException();
            }

            sdl.PauseAudioDevice(device, 0);

            // Load the MIDI file.
            var midiFile = new MidiFile(@"C:\\Windows\\Media\\flourish.mid");

            // Play the MIDI file.
            player.Play(midiFile, true);

            // Wait until any key is pressed.
            Console.ReadKey();

            sdl.CloseAudioDevice(device);

            sdl.QuitSubSystem(Sdl.InitAudio);
        }
    }
}
```

--------------------------------

### MIDI Player with TinyAudio and DirectSound

Source: https://github.com/sinshu/meltysynth/blob/main/Examples/TinyAudio/README.md

This C# snippet shows how to initialize a MidiPlayer with a SoundFont, configure DirectSound for audio playback, and play a MIDI file. Ensure you have a SoundFont file (e.g., TimGM6mb.sf2) and a MIDI file (e.g., flourish.mid) available.

```cs
using System;
using TinyAudio;
using MeltySynth;

class Program
{
    static void Main()
    {
        var midiPlayer = new MidiPlayer("TimGM6mb.sf2");

        var format = new AudioFormat(44100, 2, SampleFormat.SignedPcm16);
        var bufferLength = TimeSpan.FromMilliseconds(200);

        using (var player = new DirectSoundAudioPlayer(format, bufferLength))
        {
            player.BeginPlayback(midiPlayer.ProcessAudio);

            // Load the MIDI file.
            var midiFile = new MidiFile(@"C:\\Windows\\Media\\flourish.mid");

            // Play the MIDI file.
            midiPlayer.Play(midiFile, true);

            // Wait until any key is pressed.
            Console.ReadKey();
        }
    }
}
```

--------------------------------

### Play MIDI File with OpenTK and MeltySynth

Source: https://github.com/sinshu/meltysynth/blob/main/Examples/OpenTK/README.md

This C# snippet shows how to initialize OpenAL, load a SoundFont and a MIDI file, and play the MIDI file using the MidiPlayer class. Ensure you have a SoundFont file (e.g., TimGM6mb.sf2) and a MIDI file available.

```cs
using System;
using OpenTK.Audio.OpenAL;
using MeltySynth;

class Program
{
    unsafe static void Main()
    {
        var device = ALC.OpenDevice(null);
        var context = ALC.CreateContext(device, (int*)null);
        ALC.MakeContextCurrent(context);
        AL.GetError();

        using (var player = new MidiPlayer("TimGM6mb.sf2"))
        {
            // Load the MIDI file.
            var midiFile = new MidiFile(@"C:\Windows\Media\flourish.mid");

            // Play the MIDI file.
            player.Play(midiFile, true);

            // Wait until any key is pressed.
            Console.ReadKey();
        }

        ALC.DestroyContext(context);
        ALC.CloseDevice(device);
    }
}
```

--------------------------------

### MIDI Player Implementation

Source: https://github.com/sinshu/meltysynth/blob/main/Examples/Raylib_CsLo/README.md

This C# code snippet shows how to set up a MIDI player with Raylib-CsLo. It initializes the window and audio device, loads a MIDI file, and plays it using a synthesizer and sequencer. The audio stream is updated in a loop.

```csharp
using System;
using Raylib_CsLo;
using MeltySynth;

class Program
{
    static int sampleRate = 44100;
    static int bufferSize = 4096;

    static void Main()
    {
        Raylib.InitWindow(800, 450, "MIDI Player");

        Raylib.InitAudioDevice();
        Raylib.SetAudioStreamBufferSizeDefault(bufferSize);

        var stream = Raylib.LoadAudioStream((uint)sampleRate, 16, 2);
        var buffer = new short[2 * bufferSize];

        Raylib.PlayAudioStream(stream);

        var synthesizer = new Synthesizer("TimGM6mb.sf2", sampleRate);
        var sequencer = new MidiFileSequencer(synthesizer);
        var midiFile = new MidiFile(@"C:\\Windows\\Media\\flourish.mid");

        sequencer.Play(midiFile, true);

        Raylib.SetTargetFPS(60);

        while (!Raylib.WindowShouldClose())
        {
            if (Raylib.IsAudioStreamProcessed(stream))
            {
                sequencer.RenderInterleavedInt16(buffer);
                Raylib.UpdateAudioStream(stream, buffer.AsSpan(), bufferSize);
            }

            Raylib.BeginDrawing();
            Raylib.ClearBackground(Raylib.LIGHTGRAY);
            Raylib.DrawText("MUSIC SHOULD BE PLAYING!", 255, 200, 20, Raylib.DARKGRAY);
            Raylib.EndDrawing();
        }

        Raylib.CloseWindow();
    }
}
```

--------------------------------

### MIDI Player with Silk.NET and OpenAL

Source: https://github.com/sinshu/meltysynth/blob/main/Examples/Silk.NET.OpenAL/README.md

This C# code snippet shows how to initialize OpenAL using Silk.NET, load a SoundFont, play a MIDI file, and handle resource management. It requires the 'Silk.NET.OpenAL' and 'MeltySynth' libraries.

```csharp
using System;
using Silk.NET.OpenAL;
using MeltySynth;

class Program
{
    unsafe static void Main()
    {
        using (var alc = ALContext.GetApi(true))
        using (var al = AL.GetApi(true))
        {
            var device = alc.OpenDevice("");
            var context = alc.CreateContext(device, null);
            alc.MakeContextCurrent(context);
            al.GetError();

            using (var player = new MidiPlayer(al, "TimGM6mb.sf2"))
            {
                // Load the MIDI file.
                var midiFile = new MidiFile(@"C:\Windows\Media\flourish.mid");

                // Play the MIDI file.
                player.Play(midiFile, true);

                // Wait until any key is pressed.
                Console.ReadKey();
            }

            alc.DestroyContext(context);
            alc.CloseDevice(device);
        }
    }
}
```

--------------------------------

### Play MIDI File with SFML.Net

Source: https://github.com/sinshu/meltysynth/blob/main/Examples/SFML.Net/README.md

Loads a SoundFont and a MIDI file, then plays the MIDI file using SFML.Net. Ensure 'TimGM6mb.sf2' and the specified MIDI file exist.

```csharp
using System;
using MeltySynth;

class Program
{
    static void Main()
    {
        using (var player = new MidiPlayer("TimGM6mb.sf2"))
        {
            // Load the MIDI file.
            var midiFile = new MidiFile(@"C:\Windows\Media\flourish.mid");

            // Play the MIDI file.
            player.Play(midiFile, true);

            // Wait until any key is pressed.
            Console.ReadKey();
        }
    }
}
```

--------------------------------

### Sokol_csharp MIDI Player Implementation

Source: https://github.com/sinshu/meltysynth/blob/main/Examples/Sokol/README.md

This C# code sets up an audio stream using Sokol_csharp and plays a MIDI file using MeltySynth. It includes audio processing callback and playback control.

```cs
using System;
using System.Runtime.InteropServices;
using Sokol;
using MeltySynth;

class Program
{
    static Synthesizer synthesizer = new Synthesizer("TimGM6mb.sf2", 44100);
    static MidiFileSequencer sequencer = new MidiFileSequencer(synthesizer);
    static object mutex = new object();

    unsafe static void Main()
    {
        var desc = new Audio.Desc();
        desc.SampleRate = synthesizer.SampleRate;
        desc.NumChannels = 2;
        desc.StreamCb = (delegate* unmanaged<float*, int, int, void>)&ProcessAudio;

        Audio.Setup(in desc);

        if (!Audio.Isvalid())
        {
            throw new Exception("Failed to setup audio.");
        }

        // Load the MIDI file.
        var midiFile = new MidiFile(@"C:\\Windows\\Media\\flourish.mid");

        // Play the MIDI file.
        Play(midiFile, true);

        // Wait until any key is pressed.
        Console.ReadKey();

        Audio.Shutdown();
    }

    [UnmanagedCallersOnly]
    unsafe static void ProcessAudio(float* buffer, int numFrames, int numChannels)
    {
        lock (mutex)
        {
            sequencer.RenderInterleaved(new Span<float>(buffer, 2 * numFrames));
        }
    }

    static void Play(MidiFile midiFile, bool loop)
    {
        lock (mutex)
        {
            sequencer.Play(midiFile, loop);
        }
    }

    static void Stop()
    {
        lock (mutex)
        {
            sequencer.Stop();
        }
    }
}
```

--------------------------------

### Enumerate Presets in SoundFont

Source: https://github.com/sinshu/meltysynth/blob/main/README.md

This snippet shows how to list all presets within a SoundFont, displaying their bank and patch numbers along with their names. The SoundFont file must be accessible.

```csharp
var soundFont = new SoundFont("TimGM6mb.sf2");

foreach (var preset in soundFont.Presets)
{
    var bankNumber = preset.BankNumber.ToString("000");
    var patchNumber = preset.PatchNumber.ToString("000");

    Console.WriteLine($"{bankNumber}:{patchNumber} {preset.Name}");
}
```

--------------------------------

### Enumerate Samples in SoundFont

Source: https://github.com/sinshu/meltysynth/blob/main/README.md

Use this snippet to list all sample names contained within a SoundFont file. Ensure the SoundFont file is accessible.

```csharp
var soundFont = new SoundFont("TimGM6mb.sf2");

foreach (var sample in soundFont.SampleHeaders)
{
    Console.WriteLine(sample.Name);
}
```

--------------------------------

### MIDI Player Scene Implementation

Source: https://github.com/sinshu/meltysynth/blob/main/Examples/DotFeather/README.md

This C# code defines a scene for DotFeather that plays a MIDI file. It requires a SoundFont file (TimGM6mb.sf2) and a MIDI file. Ensure the SoundFont is accessible and the MIDI file path is correct.

```csharp
using System;
using System.Collections.Generic;
using System.Drawing;
using DotFeather;
using MeltySynth;

class MidiExampleScene : Scene
{
    private AudioPlayer audioPlayer;
    private MidiAudioStream audioStream;

    public MidiExampleScene()
    {
        audioPlayer = new AudioPlayer();
        audioStream = new MidiAudioStream("TimGM6mb.sf2");

        // Load the MIDI file.
        var midiFile = new MidiFile(@"C:\\Windows\\Media\\flourish.mid");

        // Play the MIDI file.
        audioStream.Play(midiFile, true);
    }

    public override void OnStart(Dictionary<string, object> args)
    {
        Title = "MIDI file playback example";

        DF.Window.BackgroundColor = Color.LightGray;

        DF.Root.Add(
            new TextElement("Music should be playing!", DFFont.GetDefault(30), Color.DimGray)
            {
                Location = new Vector(10, 10)
            });

        audioPlayer.Play(audioStream);
    }

    public override void OnDestroy()
    {
        audioPlayer.Stop();
        audioPlayer.Dispose();
    }

    static void Main()
    {
        DF.Run<MidiExampleScene>();
    }
}
```

--------------------------------

### Synthesize a Simple Chord

Source: https://github.com/sinshu/meltysynth/blob/main/README.md

This snippet demonstrates how to synthesize a simple chord by playing individual notes. Ensure the SoundFont file is accessible.

```csharp
var sampleRate = 44100;
var synthesizer = new Synthesizer("TimGM6mb.sf2", sampleRate);

synthesizer.NoteOn(0, 60, 100);
synthesizer.NoteOn(0, 64, 100);
synthesizer.NoteOn(0, 67, 100);

var left = new float[3 * sampleRate];
var right = new float[3 * sampleRate];

synthesizer.Render(left, right);
```

--------------------------------

### Enumerate Instruments in SoundFont

Source: https://github.com/sinshu/meltysynth/blob/main/README.md

This code iterates through and prints the names of all instruments defined in a SoundFont. The SoundFont file must be present.

```csharp
var soundFont = new SoundFont("TimGM6mb.sf2");

foreach (var instrument in soundFont.Instruments)
{
    Console.WriteLine(instrument.Name);
}
```

--------------------------------

### Synthesize a MIDI File

Source: https://github.com/sinshu/meltysynth/blob/main/README.md

This snippet shows how to synthesize an entire MIDI file. It requires a MIDI file and a SoundFont. The output buffer size is determined by the MIDI file's length.

```csharp
var sampleRate = 44100;
var synthesizer = new Synthesizer("TimGM6mb.sf2", sampleRate);

var midiFile = new MidiFile("flourish.mid");
var sequencer = new MidiFileSequencer(synthesizer);
sequencer.Play(midiFile, false);

var left = new float[(int)(sampleRate * midiFile.Length.TotalSeconds)];
var right = new float[(int)(sampleRate * midiFile.Length.TotalSeconds)];

sequencer.Render(left, right);
```

--------------------------------

### Include MeltySynth Namespace

Source: https://github.com/sinshu/meltysynth/blob/main/README.md

Add this using statement to access all classes within the MeltySynth namespace in your C# code.

```csharp
using MeltySynth;
```

--------------------------------

### Change MIDI Instruments

Source: https://github.com/sinshu/meltysynth/blob/main/README.md

Replaces the default instrument for all MIDI messages on a given channel with a specified instrument (e.g., electric guitar, instrument index 30). This is achieved by overriding the OnSendMessage event.

```csharp
var sampleRate = 44100;
var synthesizer = new Synthesizer("TimGM6mb.sf2", sampleRate);
var midiFile = new MidiFile(@"C:\\Windows\\Media\\flourish.mid");
var sequencer = new MidiFileSequencer(synthesizer);
sequencer.OnSendMessage = (synthesizer, channel, command, data1, data2) =>
{
    if (command == 0xC0)
    {
        data1 = 30;
    }
    synthesizer.ProcessMidiMessage(channel, command, data1, data2);
};
sequencer.Play(midiFile, false);
var left = new float[(int)(sampleRate * midiFile.Length.TotalSeconds)];
var right = new float[(int)(sampleRate * midiFile.Length.TotalSeconds)];
sequencer.Render(left, right);
```

--------------------------------

### Change MIDI Playback Speed

Source: https://github.com/sinshu/meltysynth/blob/main/README.md

Adjusts the playback speed of a MIDI file. Ensure the synthesizer and sequencer are initialized before use. The output buffer size is calculated based on the new speed.

```csharp
var sampleRate = 44100;
var synthesizer = new Synthesizer("TimGM6mb.sf2", sampleRate);
var midiFile = new MidiFile(@"C:\\Windows\\Media\\flourish.mid");
var sequencer = new MidiFileSequencer(synthesizer);
sequencer.Play(midiFile, false);
sequencer.Speed = 1.5F;
var left = new float[(int)(sampleRate * midiFile.Length.TotalSeconds / sequencer.Speed)];
var right = new float[(int)(sampleRate * midiFile.Length.TotalSeconds / sequencer.Speed)];
sequencer.Render(left, right);
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.