Guide pratique du MIDI sous Linux

Ce document traite des points suivants :

Copyright © 2002 Phil Kerr.

This HOWTO is copyrighted 2002 Phil Kerr.

Copyright © 2002 Frank Barknecht pour la la section intitulée «  Guide d'utilisation de séquenceurs MIDI avec des synthétiseurs virtuels  ».

The "HOWTO Use MIDI Sequencers With Softsynths" is copyright 2002 Frank Barknecht.

Copyright © 2004 Jean-Marc Legrand, Éric Madesclair, Jean-Philippe Guérard pour la version française.

Ce guide pratique est distribué sous la licence de documentation libre GNU (GFDL). Vous devriez avoir reçu une copie de cette licence avec celui-ci. Si tel n'est pas le cas, vous pouvez vous la procurer en version originale anglophone à cette adresse :

This document is distributed under the terms of the GNU Free Documentation License. You should have received a copy along with it. If not, it is available from:

http://www.fsf.org/licenses/fdl.html

Il en existe une version française non-officielle à cette adresse :

http://cesarx.free.fr/gfdlf.html

La dernière version française officielle de ce guide est disponible sur : http://www.traduc.org/docs/howto/lecture/MIDI-HOWTO.html.

La dernière version originale de ce guide pratique est publiée sur : http://www.midi-howto.com.

Ce guide est basé sur le petit guide du MIDI-SB (MIDI-SB mini-HOWTO) écrit par Hideki Saito. Tous mes remerciements pour sa contribution à la communauté Linux.

Ce guide contient désormais le « Guide d'utilisation des Séquenceurs MIDI avec des Synthétiseurs virtuels » écrit par Frank. Tous mes remerciements, Frank.

Une grande partie des exemples de code contenus dans ce guide provient de la liste de discussions LAD (Développeurs Audio Linux). Merci à eux pour m'avoir permis de les reprendre dans ce guide.

L'utilisation des informations de ce document est de votre responsabilité.

Use the information in this document at your own risk.

Je décline toute responsabilité quant au contenu de ce document.

I disavow any potential liability for the contents of this document.

L'utilisation des principes, exemples, et autres contenus de ce document sera entièrement de votre responsabilité.

Use of the concepts, examples, and/or other content of this document is entirely at your own risk.

Tous les droits d'auteur et de copyright sont la propriété de leurs détenteurs respectifs, sauf indication contraire.

All copyrights are owned by their owners, unless specifically noted otherwise.

Aucune remarque contenue dans ce document ne pourra être considérée comme un jugement de valeur contre telle ou telle marque.

Use of a term in this document should not be regarded as affecting the validity of any trademark or service mark.

Le fait de citer une marque ou un produit particulier ne saurait être considérée comme une recommandation.

Naming of particular products or brands should not be seen as endorsements.

Il vous est fortement recommandé d'effectuer une sauvegarde de votre système avant toute installation d'importance et de le sauvegarder régulièrement au cours de votre travail.

You are strongly recommended to take a backup of your system before major installation and backups at regular intervals.

Le MIDI est un ensemble de protocoles matériels et logiciels permettant à des instruments de musique électroniques de communiquer entre eux. Le MIDI est apparu pour la première fois en 1982, et s'est imposé comme le standard de communication pour ce type d'instruments. Ce protocole fixe les paramètres physiques du matériel (connexions et interfaces matérielles), et permet de disposer d'un éventail précis de protocoles de communication pour l'échange de données musicales et rythmiques.

Avant le MIDI, il existait d'autres protocoles de connexion, tout d'abord analogiques, puis numériques. Le plus ancien, au alentours de 1974, permettait de transmettre des informations musicales sous forme de tension électrique via les câbles de liaison entre les différents claviers. Plus tard, en 1980-1981, Roland créa un protocole numérique de référence, le DCB. L'association des fabricants d'instruments MIDI (MIDI Manufacturers Association ‐ MMA) a défini, à partir de leurs propres équipements, un protocole et un câblage standards pour des matériels compatibles, qui permettait à tous les matériels issus de fabricants adhérent à ce standard de se connecter et de communiquer entre eux.

À partir de 1985, les interfaces MIDI commencèrent à apparaître sur les PC personnels et peu après apparurent les premiers séquenceurs virtuels.

Les périphériques MIDI sont soit intégrés à la carte son, soit inclus dans un matériel séparé. Les interfaces MIDI externes sont reliées soit au port série, soit à un port USB.

La première chose à faire — et la plus importante — est de vérifier la compatibilité de votre carte son !

Les adresses suivantes peuvent vous y aider :

http://www.alsa-project.org/alsa-doc/

http://www.4front-tech.com/osshw.html

La façon de configurer ses périphériques MIDI varie d'une distribution Linux à l'autre. Normalement, une carte son compatible sera configurée correctement à l'installation du système d'exploitation.

Le noyau Linux contient les pilotes OSS, et, depuis les versions 2.5, les pilotes ALSA. La plupart des distributions offrent un outil de configuration (essentiellement dédié aux cartes son). Toutefois, si vous utilisez le port MIDI d'une carte son, il devra être configuré manuellement. Sous RedHat, il faut utiliser sndconfig, sous SuSE : yast, et sous Mandrake : DrakConf.

Si aucun de ces outils n'est utilisable, ou si vous rencontrez des problèmes, suivez les étapes suivantes :

Est-ce que la commande lsmod montre des modules spécifiques au MIDI ? Voici ce que l'on peut obtenir sur un système basé sur OSS :

[root@beatbox]# lsmod
Module                  Size  Used by
lockd                  32208   1  (autoclean)
sunrpc                 54640   1  (autoclean) [lockd]
autofs                  9456   2  (autoclean)
usb-ohci               12624   0  (unused)
usbcore                43632   1  [usb-ohci]
hisax                 470096   0  (autoclean) (unused)
isdn                  104208   0  (autoclean) [hisax]
slhc                    4544   0  (autoclean) [isdn]
eepro100               16144   1  (autoclean)

#---- modules de cartes son
    opl3                   11376   2 
    mad16                   7968   1 
    ad1848                 16848   1  [mad16]
    sb                     34752   1  [mad16]
    uart401                 6384   1  [mad16 sb]
    sound                  58368   0  [opl3 mad16 ad1848 sb uart401]

soundlow                 464   0  [sound]
soundcore               2800   6  [sb sound]
nls_cp437               3952   2  (autoclean)
vfat                    9408   1  (autoclean)
fat                    30432   1  (autoclean) [vfat]
ide-scsi                7664   0 

Recherchez les modules mpu401, olp3, uart401 et oss.

Si vous utilisez une interface USB, n'oubliez pas de vérifier que les modules USB correspondants apparaissent bien.

Pour vérifier la configuration, faites un cat du fichier sndstat :

[root@beatbox]# cat /dev/sndstat 
OSS/Free:3.8s2++-971130
Load type: Driver loaded as a module
Kernel: Linux mega 2.2.17-21mdk #1 Thu Oct 5 13:16:08 CEST 2000 i686
Config options: 0

Installed drivers: 

Card config: 

Audio devices:
0: MAD16 WSS (82C930) (DUPLEX)

Synth devices:
0: Yamaha OPL3

Midi devices:
0: Mad16/Mozart

Timers:
0: System clock

Mixers:
0: MAD16 WSS (82C930)

Nous voyons ici que le périphérique MIDI est mad16, ce qui correspond au lsmod effectué plus haut.

Si rien n'apparaît concernant le MIDI, vérifiez le contenu de votre fichier /etc/modules.conf.

[root@beatbox]# cat /etc/modules.conf
alias net-pf-4 ipx 
pre-install pcmcia_core /etc/rc.d/init.d/pcmcia start 
alias usb-interface usb-ohci 
alias parport_lowlevel parport_pc 
alias block-major-11 scsi_hostadapter 
pre-install plip modprobe parport_pc ; echo 7 > /proc/parport/0/irq 
alias scsi_hostadapter ide-scsi 
alias eth0 eepro100 
alias eth1 hisax 

#---- Carte Son
    alias sound-slot-0 mad16 
    options sound dmabuf=1 
    alias midi opl3 
    options opl3 io=0x388 
    options sb support=1 
    options mad16 io=0x530 irq=5 dma=0 dma16=1 mpu_io=0x300 mpu_irq=7 joystick=1

Voici les données de sortie à vérifier dans le module /proc/modules pour voir si les modules MIDI sont bien chargés dans le noyau.

[root@mega /proc]# cat modules
0000-001f : dma1
0020-003f : pic1
0040-005f : timer
0060-006f : keyboard
0070-007f : rtc
0080-008f : dma page reg
00a0-00bf : pic2
00c0-00df : dma2
00f0-00ff : fpu
0170-0177 : ide1
01f0-01f7 : ide0
02f8-02ff : serial(auto)

#---- Périphérique MIDI
    0300-0303 : MPU-401 UART

0376-0376 : ide1
0388-038b : Yamaha OPL3
03c0-03df : vga+
03f6-03f6 : ide0
03f8-03ff : serial(auto)
0530-0533 : MAD16 WSS config
0534-0537 : MAD16 WSS
de00-de1f : Intel Speedo3 Ethernet
f000-f007 : ide0
f008-f00f : ide1

Vous devriez trouver quelque chose ressemblant à cela. Si tel n'est pas le cas, vous devrez installer manuellement les pilotes MIDI.

Si vous êtes amenés à utiliser les pilotes ALSA 0.5x, — ce que je vous déconseille — je vous suggère de lire auparavant le Petit guide du son avec ALSA (Alsa-sound-mini-HOWTO) de Valentijn Sessink que vous trouverez au lien suivant :

http://www.traduc.org/docs/howto/lecture/Alsa-sound.html

Je vous recommande vivement d'utiliser des versions d'ALSA supérieures à la version 0.9. Pour des pilotes ALSA plus récents que les versions 0.9x, je vous conseille de lire le Guide ALSA (Alsa HOWTO) de Madhu Maddy.

http://www.alsa-project.org/alsa-doc/alsa-howto/

[root@beatbox] # tar jxvf alsa-driver....tar.bz2
[root@beatbox] # cd alsa-driver.....
[root@beatbox] # ./configure

messages - no errors

[root@beatbox] # make

messages - no errors

[root@beatbox] # make install

messages - no errors

[root@beatbox] # ./snddevices

alias char-major-116 snd
alias char-major-14 soundcore

alias snd-card-0 (carte son/MIDI)
alias sound-slot-0 snd-card-0

alias sound-service-0-0 snd-mixer-oss
alias sound-service-0-1 snd-seq-oss
alias sound-service-0-3 snd-pcm-oss
alias sound-service-0-12 snd-pcm-oss

[root@beatbox] # tar jxvf alsa-libs....tar.bz2
[root@beatbox] # cd alsa-libs.....
[root@beatbox] # ./configure

messages - no errors

[root@beatbox] # make

messages - no errors

[root@beatbox] # make install

// Compilez ce programme test ainsi : gcc alsatest.c -o alsatest -lasound

#include <stdio.h>
#include <alsa/asoundlib.h>

int main (int argc, char *argv[])
{
  snd_seq_t *seq_handle;

  if (snd_seq_open(&seq_handle, "hw", SND_SEQ_OPEN_DUPLEX, 0) < 0) {
    fprintf(stderr, "Error opening ALSA sequencer.\n");
    exit(1);
  }

printf("The ALSA libraries are installed.\n");
return 0;
}

L'intérêt pour des solutions MIDI basées sur Linux étant croissant, la liste suivante ne sera probablement pas exhaustive, mais vous donnera un choix représentatif d'applications MIDI.

Si vous êtes développeur ou utilisateur d'autres applications MIDI non listées, merci de m'en avertir par courrier électronique.

Ceux qui souhaitent développer des applications MIDI ont souvent besoin de bons exemples pour démarrer.

Les exemples suivants proviennent de la liste de discussions LAD.

[phil@beatbox] $ gcc seqdemo.c -o seqdemo -lasound


#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <alsa/asoundlib.h>

snd_seq_t *open_seq();
void midi_action(snd_seq_t *seq_handle);

snd_seq_t *open_seq() {

  snd_seq_t *seq_handle;
  int portid;

  if (snd_seq_open(&seq_handle, "hw", SND_SEQ_OPEN_DUPLEX, 0) < 0) {
    fprintf(stderr, "Error opening ALSA sequencer.\n");
    exit(1);
  }
  snd_seq_set_client_name(seq_handle, "ALSA Sequencer Demo");
  if ((portid = snd_seq_create_simple_port(seq_handle, "ALSA Sequencer Demo",
            SND_SEQ_PORT_CAP_WRITE|SND_SEQ_PORT_CAP_SUBS_WRITE,
            SND_SEQ_PORT_TYPE_APPLICATION)) < 0) {
    fprintf(stderr, "Error creating sequencer port.\n");
    exit(1);
  }
  return(seq_handle);
}

void midi_action(snd_seq_t *seq_handle) {

  snd_seq_event_t *ev;

  do {
    snd_seq_event_input(seq_handle, &ev);
    switch (ev->type) {
      case SND_SEQ_EVENT_CONTROLLER: 
        fprintf(stderr, "Control event on Channel %2d: %5d       \r",
                ev->data.control.channel, ev->data.control.value);
        break;
      case SND_SEQ_EVENT_PITCHBEND:
        fprintf(stderr, "Pitchbender event on Channel %2d: %5d   \r", 
                ev->data.control.channel, ev->data.control.value);
        break;
      case SND_SEQ_EVENT_NOTEON:
        fprintf(stderr, "Note On event on Channel %2d: %5d       \r",
                ev->data.control.channel, ev->data.note.note);
        break;        
      case SND_SEQ_EVENT_NOTEOFF: 
        fprintf(stderr, "Note Off event on Channel %2d: %5d      \r",         
                ev->data.control.channel, ev->data.note.note);           
        break;        
    }
    snd_seq_free_event(ev);
  } while (snd_seq_event_input_pending(seq_handle, 0) > 0);
}

int main(int argc, char *argv[]) {

  snd_seq_t *seq_handle;
  int npfd;
  struct pollfd *pfd;
    
  seq_handle = open_seq();
  npfd = snd_seq_poll_descriptors_count(seq_handle, POLLIN);
  pfd = (struct pollfd *)alloca(npfd * sizeof(struct pollfd));
  snd_seq_poll_descriptors(seq_handle, pfd, npfd, POLLIN);
  while (1) {
    if (poll(pfd, npfd, 100000) > 0) {
      midi_action(seq_handle);
    }  
  }
}

/* Aiguilleur pour séquenceur ALSA.
   Aiguille les données d'entrée vers les sorties définies
   par le canal MIDI (à la demande de Nathaniel Virgo sur 
   Linux-Audio-Dev ;o)). Est basé sur l'exemple de fonction
   séquenceur ALSA écrit par Dr. Matthias Nagorni.
   
   Nick Dowell <nixx CHEZ nixx POINT org POINT uk>    */

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <alsa/asoundlib.h>

int
main()
{
  snd_seq_t *seq_handle;
  snd_seq_event_t *ev;
  int i;
  int portid;              /* port d'entrée (input) */
  int oportid[16];         /* ports de sortie (outputs) */
  int npfd;
  struct pollfd *pfd;
  char txt[20];

  if (snd_seq_open(&seq_handle, "hw", SND_SEQ_OPEN_DUPLEX, 0) < 0) {
    fprintf(stderr, "Error opening ALSA sequencer.\n");
    exit(1);
  }

  snd_seq_set_client_name(seq_handle, "MIDI Redirect");
  
  /* open one input port */
  if ((portid = snd_seq_create_simple_port
       (seq_handle, "Input",
        SND_SEQ_PORT_CAP_WRITE | SND_SEQ_PORT_CAP_SUBS_WRITE,
        SND_SEQ_PORT_TYPE_APPLICATION)) < 0) {
    fprintf(stderr, "fatal error: could not open input port.\n");
    exit(1);
  }
  /* open 16 output ports for the MIDI channels */
  for (i=0; i<16; i++){
    sprintf( txt, "MIDI Channel %d", i );
    if ((oportid[i] = snd_seq_create_simple_port
         (seq_handle, txt,
          SND_SEQ_PORT_CAP_READ | SND_SEQ_PORT_CAP_SUBS_READ,
          SND_SEQ_PORT_TYPE_APPLICATION)) < 0) {
      fprintf(stderr, "fatal error: could not open output port.\n");
      exit(1);
    }
  }

  npfd = snd_seq_poll_descriptors_count(seq_handle, POLLIN);
  pfd = (struct pollfd *)alloca(npfd * sizeof(struct pollfd));
  snd_seq_poll_descriptors(seq_handle, pfd, npfd, POLLIN);

  while (1)  /* main loop */
    if (poll(pfd, npfd, 1000000) > 0){
      do {
        snd_seq_event_input(seq_handle, &ev);
        snd_seq_ev_set_source( ev, oportid[ev->data.control.channel] );
        snd_seq_ev_set_subs( ev );
        snd_seq_ev_set_direct( ev );
        snd_seq_event_output_direct( seq_handle, ev );
        snd_seq_free_event(ev);
      } while (snd_seq_event_input_pending(seq_handle, 0) > 0);
    }
  return 0;
}

//
// Programmeur:            Craig Stuart Sapp
// Adresse électronique :  craig CHEZ ccrma POINT standford POINT edu
// Date de Création :	   Lundi 21 décembre 1998 18:00:42
// Dernière modification : Lundi 21 décembre 1998 18:00:42
// Nom de fichier :      ...linuxmidi/output/method1.c
// Langage :             C 
// $Smake: gcc -O -o devmidiout devmidiout.c && strip devmidiout
//

#include <linux/soundcard.h>
#include <unistd.h>
#include <fcntl.h>
#include <stdio.h>

int main(void) {
   char* device =  "/dev/midi" ;
   unsigned char data[3] = {0x90, 60, 127};

   // étape 1: ouvre le module OSS pour écriture
   int fd = open(device, O_WRONLY, 0);
   if (fd < 0) {
      printf("Error: cannot open %s\n", device);
      exit(1);
   }

   // étape 2: écrit les données MIDI dans le module OSS
   write(fd, data, sizeof(data));

   // étape 3: (en option) ferme le module OSS
   close(fd);

   return 0;
}

http://linux-sound.org/quick-toots/4-sequencers_and_softsynths/quick-toot-midisynth_howto.html

Ce guide décrit les réglages nécessaires pour contrôler un synthétiseur MIDI virtuel à partir d'un séquenceur MIDI et via une connexion MIDI virtuelle sous ALSA 0.9. Ce document peut être librement traduit et diffusé. Il est soumis à la licence de documentation libre GNU.

$ modprobe snd-virmidi snd_index=1

# Configure les supports pour OSS /dev/sequencer et 
# /dev/music (aussi appelé /dev/sequencer2)
#
# (Takashi Iwai nous indique qu'il n'est pas nécessaire  
# de créer des alias pour des cartes au-delà de la première
# carte, i.e., la carte 0)
#
alias sound-service-0-1 snd-seq-oss
alias sound-service-0-8 snd-seq-oss

# Configure la carte 1 (deuxième carte) en tant que carte MIDI virtuelle
alias sound-slot-1 snd-card-1
alias snd-card-1 snd-virmidi

# Configure la carte d'index 2 (troisième carte) en tant que
# carte MIDI virtuelle
alias sound-slot-2 snd-card-2
alias snd-card-2 snd-virmidi

$ cat /proc/asound/cards 
0 [card0          ]: ICE1712 - M Audio Audiophile 24/96
                     M Audio Audiophile 24/96 at 0xb800, irq 5
1 [card1          ]: EMU10K1 - Sound Blaster Live!
                     Sound Blaster Live! at 0xc800, irq 11
2 [card2          ]: VirMIDI - VirMIDI
                     Virtual MIDI Card 1

$ cat /proc/asound/devices 
 8: [0- 0]: raw MIDI
41: [1- 1]: raw MIDI
42: [1- 2]: raw MIDI
75: [2- 3]: raw MIDI
74: [2- 2]: raw MIDI
73: [2- 1]: raw MIDI
72: [2- 0]: raw MIDI

$ aconnect -o
[...]
client 80: 'Virtual Raw MIDI 2-0' [type=kernel]
    0 'VirMIDI 2-0     '
client 81: 'Virtual Raw MIDI 2-1' [type=kernel]
    0 'VirMIDI 2-1     '
client 82: 'Virtual Raw MIDI 2-2' [type=kernel]
    0 'VirMIDI 2-2     '
client 83: 'Virtual Raw MIDI 2-3' [type=kernel]
    0 'VirMIDI 2-3     '
$ aconnect -i
[...]
client 80: 'Virtual Raw MIDI 2-0' [type=kernel]
    0 'VirMIDI 2-0     '
client 81: 'Virtual Raw MIDI 2-1' [type=kernel]
    0 'VirMIDI 2-1     '
client 82: 'Virtual Raw MIDI 2-2' [type=kernel]
    0 'VirMIDI 2-2     '
client 83: 'Virtual Raw MIDI 2-3' [type=kernel]
    0 'VirMIDI 2-3     '

$ ln -s /dev/snd/midiC2D0 /dev/midi20
$ ln -s /dev/snd/midiC2D1 /dev/midi21
[...]

$ aconnect port_d_envoi port_de_reception
$ aconnect 80:0 81:0

$ aconnect -lo
client 72: 'Virtual Raw MIDI 1-0' [type=kernel]
    0 'VirMIDI 1-0     '
client 73: 'Virtual Raw MIDI 1-1' [type=kernel]
    0 'VirMIDI 1-1     '
client 74: 'Virtual Raw MIDI 1-2' [type=kernel]
    0 'VirMIDI 1-2     '
client 75: 'Virtual Raw MIDI 1-3' [type=kernel]
    0 'VirMIDI 1-3   

$ aconnect 72:0 73:0

$ aconnect -lo
client 72: 'Virtual Raw MIDI 1-0' [type=kernel]
    0 'VirMIDI 1-0     '
        Connecting To: 73:0
client 73: 'Virtual Raw MIDI 1-1' [type=kernel]
    0 'VirMIDI 1-1     '
        Connected From: 72:0
client 74: 'Virtual Raw MIDI 1-2' [type=kernel]
    0 'VirMIDI 1-2     '                       
client 75: 'Virtual Raw MIDI 1-3' [type=kernel]
    0 'VirMIDI 1-3

 $ aconnect 72:0 73:0
 $ aconnect 72:0 74:0

$ aconnect -x 

$ aconnect -d 72:0 74:0

client 128: 'MIDI Viewer' [type=user] 
   0 'Viewer Port 0 ' 

$ aseqview -d 73:0 &

$ aconnect 80:0 81:0

#!/bin/sh
aseqview -d 81:0 &
# sleep 2 seconds to let aseqview do its work:
sleep 2
shaketracker

$ csound -M /dev/midi22 -o devaudio midi.csd

Vous trouverez ci-dessous une liste de liens vers des sites traitant du MIDI sous Linux.

http://www.linux-sound.org/ Logiciels audio et MIDI sous Linux. Une mine de renseignements sur le MIDI et l'audio.

http://www.linuxdj.com/audio/lad/ La liste de discussions des développeurs Audio sous Linux. Pour toute discussion sur le développement MIDI.

http://www.linuxdj.com/audio/quality Le guide Linux de la qualité audio. Un bon chapitre sur les cartes MIDI, essentiel pour créer son studio Linux.

http://www.alsa-project.org/ Le projet ALSA — Pilotes audio et MIDI.

http://www.4front-tech.com/ OSS — Pilotes audio et MIDI.

http://www.gardena.net/benno/linux/audio/ Correctif de minimisation des temps de latence.

http://ccrma-www.stanford.edu/~craig/articles/linuxmidi/ Introduction à la programmation MIDI sous Linux. Craig Stuart Sapp décrit les outils de base pour écrire du MIDI en C ou C++ pour des pilotes OSS.

http://www.suse.de/~mana Excellente collection de programmes C pour ALSA 0.9 MIDI et PCM, par Dr. Matthias Nagorni.

Comme toujours, un guide évolue dans le temps. Je vous encourage à me transmettre (en anglais) vos suggestions ou informations sur les nouvelles applications et les développements intéressants du MIDI sous Linux.

Par leur grande variété, les cartes son sont parfois difficiles à configurer, notamment parce qu'elles ont plusieurs niveaux de pilotes et d'options de configuration. Les meilleures sources de renseignement en cas de dysfonctionnement sont les sites web de ALSA et OSS, mais aussi les forums, ainsi que les listes de discussions consacrées à l'audio sous Linux.