Versione delle 16:48, 23 gen 2022

Per essere in grado di inviare dati Midi via ALSA dal nostro applicativo ad un altro programma, è necessario che entrambi i programmi si rapportino ad ALSA come suoi Client. Il sistema ALSA, pertanto, diventa Server dei due suoi Client.

Riferendoci al capitolo che stiamo trattando, quello relativo dell'invio dati Midi ad ALSA, la fattispecie più evidente e probabile è quella dell'invio di dati Midi a un Softsynth, affinché siano emessi i suoni e gli effetti connessi agli eventi Midi prodotti. In tal caso, dunque, anche il programma Softsynth prescelto, per poter ricevere i dati Midi, dovrà diventare un Client di ALSA, e il nostro applicativo, capace di inviare eventi Midi, dovrà connettersi a detto Softsynth.
In vero, la connessione avviene tra le porte dei due Client di ALSA, ed avviene sempre e comunque attraverso il sistema e le risorse di ALSA.

La connessione delle porte del nostro applicativo con quella del Client Softsynth ^{[nota 1]} può essere effettuata mediante la funzione:

int snd_seq_connect_to(snd_seq_t *seq, int myport, int src_client, int src_port)

Nel nostro codice Gambas la dichiareremo con la consueta funzione Extern:

Private EXTERN  snd_seq_connect_to(seq As Pointer, myport As Integer, src_client As Integer, src_port As Integer) As Integer

Questa funzione sarà utilizzata in routine come segue:

 err = snd_seq_connect_to(handle, outport, dclient, dport)

A questo punto, lanciando da terminale il comando: cat /proc/asound/seq/clients, possiamo verificare:

• il numero identificativo e il nome del nostro Client;
• il numero ed il nome della porta del nostro Client;
• il numero identificativo del device (ad esempio QSynth) e della sua porta (con relativa indicazione delle capacità), al quale il Client si è connesso.

Cercando il nostro Client avremo infatti informazioni simili alle seguenti:

Client 129 : "Nome del nostro applicativo Client" [User]

Port   0 : "Nome della Porta" (--e-)

Connecting To: 128:0

che ovviamente vanno così interpretate: il Client avente numero identificativo 129 e chiamato "Nome del nostro applicativo Client", è connesso tramite la sua Porta, avente numero identificativo 0 e chiamata "Nome della porta", alla porta avente numero identificativo 0 di un altro Client di ALSA avente numero identificativo 128.

V'è da sottolineare che ai fini pratici dell'invio degli Eventi Midi ALSA la connessione così realizzata mediante la funzione esterna "snd_seq_connect_to()" si rende necessaria se ai membri client e port del membro snd_seq_addr_t dellaa Struttura degli Eventi Midi ALSA snd_seq_event_t sono rispettivamente valorizzati con le Costanti di ALSA:

SND_SEQ_ADDRESS_SUBSCRIBERS = 254
SND_SEQ_ADDRESS_UNKNOWN = 253

Esempio pratico

Library "libasound:2.0.0"

Public Struct snd_seq_event_t
 type As Byte              '  byte indice n° 0
 flags As Byte
 tag As Byte
 queue As Byte
 tick_o_tv_sec As Integer
 tv_nsec As Integer
 source_client As Byte
 source_port As Byte
 dest_client As Byte
 dest_port As Byte        ' byte n° 15
   channel As Byte           ' byte n° 16
   note As Byte              ' byte n° 17
   velocity As Byte          ' byte n° 18
   off_velocity As Byte      ' byte n° 19
     param As Integer          ' byte n° 20
     value As Integer          ' byte n° 24
End Struct

Private Const SND_SEQ_OPEN_DUPLEX As Integer = 3
Private Const SND_SEQ_PORT_TYPE_MIDI_GENERIC As Integer = 2
Private Const SND_SEQ_PORT_TYPE_APPLICATION As Integer = 1048576
Private Const SND_SEQ_ADDRESS_UNKNOWN As Byte = 253
Private Const SND_SEQ_ADDRESS_SUBSCRIBERS As Byte = 254
Private Enum SND_SEQ_EVENT_NOTEON = 6, SND_SEQ_EVENT_NOTEOFF, SND_SEQ_EVENT_KEYPRESS,
             SND_SEQ_EVENT_CONTROLLER = 10, SND_SEQ_EVENT_PGMCHANGE, SND_SEQ_EVENT_CHANPRESS, SND_SEQ_EVENT_PITCHBEND

' int snd_seq_open (snd_seq_t **seqp, const char * name, int streams, int mode)
' Open the ALSA sequencer.
Private Extern snd_seq_open(seqp As Pointer, name As String, streams As Integer, mode As Integer) As Integer

' int snd_seq_set_client_name (snd_seq_t* seq, const char* name)
' Set client name.
Private Extern snd_seq_set_client_name(seq As Pointer, name As String) As Integer

' int snd_seq_create_simple_port (snd_seq_t* seq, const char* name, unsigned int caps, unsigned int type)
' Creates a port with the given capability and type bits.
Private Extern snd_seq_create_simple_port(seq As Pointer, name As String, caps As Integer, type As Integer) As Integer

' int snd_seq_client_id (snd_seq_t * seq)
' Get the client id.
Private Extern snd_seq_client_id(seq As Pointer) As Integer

' int snd_seq_connect_to ( snd_seq_t * seq, int myport, int dest_client, int dest_port )
' Connect from the given receiver port in the current client to the given destination client:port.
Private Extern snd_seq_connect_to(seq As Pointer, myport As Integer, dest_client As Integer, dest_port As Integer) As Integer

' int snd_seq_alloc_named_queue (snd_seq_t * seq, CONST char * name)
' Allocate a queue.
Private Extern snd_seq_alloc_queue(seq As Pointer, name As String) As Integer
 
' int snd_seq_event_output (snd_seq_t * seq, snd_seq_event_t *ev)
' Output an event.
Private Extern snd_seq_event_output(seq As Pointer, ev As Snd_seq_event_t) As Integer

' int snd_seq_drain_output (snd_seq_t * seq)
' Drain output buffer to sequencer.
Private Extern snd_seq_drain_output(seq As Pointer) As Integer

' const char * snd_strerror (int errnum)
' Returns the message for an error code.
Private Extern snd_strerror(errnum As Integer) As String

' int snd_seq_close (snd_seq_t * seq)
' Close the sequencer.
Private Extern snd_seq_close(seq As Pointer) As Integer


Public Sub Main()

 Dim handle As Pointer
 Dim err, id, porta, que As Integer
 Dim ev_midi As New Snd_seq_event_t   ' Dichiara la variabile del tipo della Struttura "snd_seq_event_t"

 err = snd_seq_open(VarPtr(handle), "default", SND_SEQ_OPEN_DUPLEX, 0)
 Print "Apertura del subsistema 'seq' di ALSA = "; IIf(err == 0, "corretta !", "errata !")
 If err < 0 Then error.RAISE("Errore: " & snd_strerror(err))

 snd_seq_set_client_name(handle, "Test")
 id = snd_seq_client_id(handle)
 Print "Alsa ClientID = "; id

 porta = snd_seq_create_simple_port(handle, "Uscita", 0, SND_SEQ_PORT_TYPE_MIDI_GENERIC + SND_SEQ_PORT_TYPE_APPLICATION) 
 Print "Porta del programma = "; porta
 If porta < 0 Then error.Raise("Errore: " & snd_strerror(porta))

 que = snd_seq_alloc_queue(handle, "queue")
 If que < 0 Then error.Raise("Errore: " & snd_strerror(que))

' Assume che l'ID/porta dell'altro Client (Softsynth) sia 128:0
 err = snd_seq_connect_to(handle, porta, 128, 0)
 If err < 0 Then error.Raise("Errore: " & snd_strerror(err))

' Program Change
 ev_midi.type = SND_SEQ_EVENT_PGMCHANGE
 ev_midi.flags = 0
 ev_midi.tag = 0
 ev_midi.queue = que
 ev_midi.tick_o_tv_sec = 0
 ev_midi.source_client = id
 ev_midi.source_port = porta
 ev_midi.dest_client = SND_SEQ_ADDRESS_SUBSCRIBERS
 ev_midi.dest_port = SND_SEQ_ADDRESS_UNKNOWN
 ev_midi.channel = 0
 ev_midi.value = 44    ' Imposta il suono dello strumento musicale da usare

 InviaEventoMidi(handle, ev_midi)

' Note ON
 ev_midi.type = SND_SEQ_EVENT_NOTEON
 ev_midi.flags = 0
 ev_midi.tag = 0
 ev_midi.queue = que
 ev_midi.tick_o_tv_sec = 0
 ev_midi.source_client = id
 ev_midi.source_port = porta
 ev_midi.dest_client = SND_SEQ_ADDRESS_SUBSCRIBERS
 ev_midi.dest_port = SND_SEQ_ADDRESS_UNKNOWN
 ev_midi.channel = 0
 ev_midi.note = 64       ' Imposta una nota Midi da eseguire
 ev_midi.velocity = 100  ' Imposta la velocità di tocco
 
 InviaEventoMidi(handle, ev_midi)

' Imposta la durata dell'esecuzione della nota.
' Va precisato che l'uso della funzione "Wait" NON è un modo coerente con il protocollo di ALSA per la temporizzazione degli Eventi Midi: dato che ALSA usa a tale fine la cosiddetta "marcatura degli Eventi Midi" assegnando degli opportuni valori nel membro "flags" e in quelli del "Timestamp" della Struttura "snd_seq_event_t".
' Qui si fa uso della funzione "Wait" soltanto per meri motivi didattici ed esemplificativi del funzionamento degli altri aspetti trattati in questa pagina.
 Wait 3

' Note OFF
 ev_midi.type = SND_SEQ_EVENT_NOTEOFF
 ev_midi.flags = 0
 ev_midi.tag = 0
 ev_midi.queue = que
 ev_midi.tick_o_tv_sec = 0
 ev_midi.source_client = id
 ev_midi.source_port = porta
 ev_midi.dest_client = SND_SEQ_ADDRESS_SUBSCRIBERS
 ev_midi.dest_port = SND_SEQ_ADDRESS_UNKNOWN
 ev_midi.channel = 0
 ev_midi.note = 64       ' Imposta una nota Midi da eseguire
 ev_midi.velocity = 0    ' Imposta la velocità di tocco
 
 InviaEventoMidi(handle, ev_midi)

' Va in Chiusura:
 snd_seq_close(handle)

End

Private Procedure InviaEventoMidi(p As Pointer, ev As Snd_seq_event_t)

 Dim err As Integer

 err = snd_seq_event_output(p, ev)
 If err < 0 Then error.Raise("Errore: " & snd_strerror(err))

 err = snd_seq_drain_output(p)
 If err < 0 Then error.Raise("Errore: " & snd_strerror(err))

End

Note

[1] Qualora la connessione sia invece impostata esplicitamente con il subsistema ALSA:

client 14: 'Midi Through' [type=kernel]
0 'Midi Through Port-0'

(solitamente 14:0), bisognerà ricordare, dopo aver lanciato il nostro applicativo, di connettere - ad esempio con il comando aconnect da terminale - il sistema ALSA con il softsynth. In sostanza la catena di connessione risulterà in questo caso essere la seguente: Applicativo-->ALSA-->Softsynth.

[2] Corrispondenza tra "Note MIDI", frequenza sonora e note sul pentragramma