src/mididriver/MidiInputDeviceAlsa.cpp

/***************************************************************************
 *                                                                         *
 *   LinuxSampler - modular, streaming capable sampler                     *
 *                                                                         *
 *   Copyright (C) 2003, 2004 by Benno Senoner and Christian Schoenebeck   *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the Free Software           *
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
 *   MA  02111-1307  USA                                                   *
 ***************************************************************************/

#include "MidiInputDeviceAlsa.h"

namespace LinuxSampler {

    /**
     * Create Alsa MIDI input device for LinuxSampler. Opens and initializes
     * Alsa sequencer client and creates one Alsa MIDI input port for
     * LinuxSampler. The optional argument allows to auto connect to a Alsa
     * MIDI source (e.g. a software sequencer or a hardware MIDI input
     * port).
     *
     * @param AutoConnectPortID - (optional) Alsa client and port ID of a
     *                            MIDI source we should auto connect to
     *                            (e.g. "64:0")
     * @throws MidiInputException  if initialization failed
     */
    MidiInputDeviceAlsa::MidiInputDeviceAlsa(char* AutoConnectPortID) : MidiInputDevice(MidiInputDevice::type_alsa), Thread(true, 1, -1) {
        if (snd_seq_open(&hAlsaSeq, "default", SND_SEQ_OPEN_INPUT, 0) < 0) {
            throw MidiInputException("Error opening ALSA sequencer");
        }
        this->hAlsaSeqClient = snd_seq_client_id(hAlsaSeq);
        snd_seq_set_client_name(hAlsaSeq, "LinuxSampler");
        if ((this->hAlsaSeqPort = snd_seq_create_simple_port(hAlsaSeq, "LinuxSampler",
                                                             SND_SEQ_PORT_CAP_WRITE|SND_SEQ_PORT_CAP_SUBS_WRITE,
                                                             SND_SEQ_PORT_TYPE_APPLICATION)) < 0) {
            throw MidiInputException("Error creating sequencer port");
        }

        if (AutoConnectPortID) ConnectToAlsaMidiSource(AutoConnectPortID);
    }

    void MidiInputDeviceAlsa::SetInputPort(const char * MidiSource) {
            ConnectToAlsaMidiSource(MidiSource);
    }

    MidiInputDeviceAlsa::~MidiInputDeviceAlsa() {
        //TODO: close Alsa seq
    }

    void MidiInputDeviceAlsa::Listen() {
        StartThread();
    }

    void MidiInputDeviceAlsa::StopListen() {
        StopThread();
    }

    /**
    * Connects this Alsa midi input device with an Alsa MIDI source.
    *
    * @param Client - Alsa sequencer client and port ID of a MIDI source
    *                (e.g. "64:0")
    * @throws MidiInputException  if connection cannot be established
    */
    void MidiInputDeviceAlsa::ConnectToAlsaMidiSource(const char* MidiSource) {
        snd_seq_addr_t sender, dest;
        snd_seq_port_subscribe_t* subs;
        int hExtClient, hExtPort;

        sscanf(MidiSource, "%d:%d", &hExtClient, &hExtPort);
        sender.client = (char) hExtClient;
        sender.port   = (char) hExtPort;
        dest.client   = (char) this->hAlsaSeqClient;
        dest.port     = (char) this->hAlsaSeqPort;
        snd_seq_port_subscribe_alloca(&subs);
        snd_seq_port_subscribe_set_sender(subs, &sender);
        snd_seq_port_subscribe_set_dest(subs, &dest);
        snd_seq_port_subscribe_set_queue(subs, 1);
        snd_seq_port_subscribe_set_time_update(subs, 1);
        snd_seq_port_subscribe_set_time_real(subs, 1);
        if (snd_seq_subscribe_port(this->hAlsaSeq, subs) < 0)
            throw MidiInputException(String("Unable to connect to Alsa seq client \'") + MidiSource + "\' (" + snd_strerror(errno) + ")");
    }

    int MidiInputDeviceAlsa::Main() {
        int npfd;
        struct pollfd* pfd;
        snd_seq_event_t* ev;

        npfd = snd_seq_poll_descriptors_count(hAlsaSeq, POLLIN);
        pfd = (struct pollfd*) alloca(npfd * sizeof(struct pollfd));
        snd_seq_poll_descriptors(hAlsaSeq, pfd, npfd, POLLIN);
        while (true) {
            if (poll(pfd, npfd, 100000) > 0) {
                do {
                    snd_seq_event_input(hAlsaSeq, &ev);
                    switch (ev->type) {
                        case SND_SEQ_EVENT_CONTROLLER:
                            DispatchControlChange(ev->data.control.param, ev->data.control.value, ev->data.control.channel);
                            break;

                        case SND_SEQ_EVENT_PITCHBEND:
                          //  fprintf(stderr, "Pitchbender event on Channel %2d: %5d   \n",
                          //          ev->data.control.channel, ev->data.control.value);
                            DispatchPitchbend(ev->data.control.value, ev->data.control.channel);
                            break;

                        case SND_SEQ_EVENT_NOTEON:
                            if (ev->data.note.velocity != 0) {
                                DispatchNoteOn(ev->data.note.note, ev->data.note.velocity, ev->data.control.channel);
                            }
                            else {
                                DispatchNoteOff(ev->data.note.note, 0, ev->data.control.channel);
                            }
                            break;

                        case SND_SEQ_EVENT_NOTEOFF:
                            DispatchNoteOff(ev->data.note.note, ev->data.note.velocity, ev->data.control.channel);
                            break;
                    }
                    snd_seq_free_event(ev);
                } while (snd_seq_event_input_pending(hAlsaSeq, 0) > 0);
            }
        }
    }

} // namespace LinuxSampler
1	schoenebeck	53	/***************************************************************************
2			* *
3			* LinuxSampler - modular, streaming capable sampler *
4			* *
5	schoenebeck	56	* Copyright (C) 2003, 2004 by Benno Senoner and Christian Schoenebeck *
6	schoenebeck	53	* *
7			* This program is free software; you can redistribute it and/or modify *
8			* it under the terms of the GNU General Public License as published by *
9			* the Free Software Foundation; either version 2 of the License, or *
10			* (at your option) any later version. *
11			* *
12			* This program is distributed in the hope that it will be useful, *
13			* but WITHOUT ANY WARRANTY; without even the implied warranty of *
14			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
15			* GNU General Public License for more details. *
16			* *
17			* You should have received a copy of the GNU General Public License *
18			* along with this program; if not, write to the Free Software *
19			* Foundation, Inc., 59 Temple Place, Suite 330, Boston, *
20			* MA 02111-1307 USA *
21			***************************************************************************/
22
23			#include "MidiInputDeviceAlsa.h"
24
25			namespace LinuxSampler {
26
27			/**
28			* Create Alsa MIDI input device for LinuxSampler. Opens and initializes
29			* Alsa sequencer client and creates one Alsa MIDI input port for
30			* LinuxSampler. The optional argument allows to auto connect to a Alsa
31			* MIDI source (e.g. a software sequencer or a hardware MIDI input
32			* port).
33			*
34			* @param AutoConnectPortID - (optional) Alsa client and port ID of a
35			* MIDI source we should auto connect to
36			* (e.g. "64:0")
37			* @throws MidiInputException if initialization failed
38			*/
39	schoenebeck	64	MidiInputDeviceAlsa::MidiInputDeviceAlsa(char* AutoConnectPortID) : MidiInputDevice(MidiInputDevice::type_alsa), Thread(true, 1, -1) {
40	schoenebeck	53	if (snd_seq_open(&hAlsaSeq, "default", SND_SEQ_OPEN_INPUT, 0) < 0) {
41			throw MidiInputException("Error opening ALSA sequencer");
42			}
43			this->hAlsaSeqClient = snd_seq_client_id(hAlsaSeq);
44			snd_seq_set_client_name(hAlsaSeq, "LinuxSampler");
45			if ((this->hAlsaSeqPort = snd_seq_create_simple_port(hAlsaSeq, "LinuxSampler",
46			SND_SEQ_PORT_CAP_WRITE\|SND_SEQ_PORT_CAP_SUBS_WRITE,
47			SND_SEQ_PORT_TYPE_APPLICATION)) < 0) {
48			throw MidiInputException("Error creating sequencer port");
49			}
50
51			if (AutoConnectPortID) ConnectToAlsaMidiSource(AutoConnectPortID);
52			}
53
54	senkov	68	void MidiInputDeviceAlsa::SetInputPort(const char * MidiSource) {
55			ConnectToAlsaMidiSource(MidiSource);
56			}
57
58	schoenebeck	53	MidiInputDeviceAlsa::~MidiInputDeviceAlsa() {
59			//TODO: close Alsa seq
60			}
61
62			void MidiInputDeviceAlsa::Listen() {
63			StartThread();
64			}
65
66			void MidiInputDeviceAlsa::StopListen() {
67			StopThread();
68			}
69
70			/**
71			* Connects this Alsa midi input device with an Alsa MIDI source.
72			*
73			* @param Client - Alsa sequencer client and port ID of a MIDI source
74			* (e.g. "64:0")
75			* @throws MidiInputException if connection cannot be established
76			*/
77			void MidiInputDeviceAlsa::ConnectToAlsaMidiSource(const char* MidiSource) {
78			snd_seq_addr_t sender, dest;
79			snd_seq_port_subscribe_t* subs;
80			int hExtClient, hExtPort;
81
82			sscanf(MidiSource, "%d:%d", &hExtClient, &hExtPort);
83			sender.client = (char) hExtClient;
84			sender.port = (char) hExtPort;
85			dest.client = (char) this->hAlsaSeqClient;
86			dest.port = (char) this->hAlsaSeqPort;
87			snd_seq_port_subscribe_alloca(&subs);
88			snd_seq_port_subscribe_set_sender(subs, &sender);
89			snd_seq_port_subscribe_set_dest(subs, &dest);
90			snd_seq_port_subscribe_set_queue(subs, 1);
91			snd_seq_port_subscribe_set_time_update(subs, 1);
92			snd_seq_port_subscribe_set_time_real(subs, 1);
93			if (snd_seq_subscribe_port(this->hAlsaSeq, subs) < 0)
94			throw MidiInputException(String("Unable to connect to Alsa seq client \'") + MidiSource + "\' (" + snd_strerror(errno) + ")");
95			}
96
97			int MidiInputDeviceAlsa::Main() {
98			int npfd;
99			struct pollfd* pfd;
100			snd_seq_event_t* ev;
101
102			npfd = snd_seq_poll_descriptors_count(hAlsaSeq, POLLIN);
103			pfd = (struct pollfd) alloca(npfd sizeof(struct pollfd));
104			snd_seq_poll_descriptors(hAlsaSeq, pfd, npfd, POLLIN);
105			while (true) {
106			if (poll(pfd, npfd, 100000) > 0) {
107			do {
108			snd_seq_event_input(hAlsaSeq, &ev);
109			switch (ev->type) {
110			case SND_SEQ_EVENT_CONTROLLER:
111			DispatchControlChange(ev->data.control.param, ev->data.control.value, ev->data.control.channel);
112			break;
113
114			case SND_SEQ_EVENT_PITCHBEND:
115			// fprintf(stderr, "Pitchbender event on Channel %2d: %5d \n",
116			// ev->data.control.channel, ev->data.control.value);
117			DispatchPitchbend(ev->data.control.value, ev->data.control.channel);
118			break;
119
120			case SND_SEQ_EVENT_NOTEON:
121			if (ev->data.note.velocity != 0) {
122			DispatchNoteOn(ev->data.note.note, ev->data.note.velocity, ev->data.control.channel);
123			}
124			else {
125			DispatchNoteOff(ev->data.note.note, 0, ev->data.control.channel);
126			}
127			break;
128
129			case SND_SEQ_EVENT_NOTEOFF:
130			DispatchNoteOff(ev->data.note.note, ev->data.note.velocity, ev->data.control.channel);
131			break;
132			}
133			snd_seq_free_event(ev);
134			} while (snd_seq_event_input_pending(hAlsaSeq, 0) > 0);
135			}
136			}
137			}
138
139			} // namespace LinuxSampler