int main(int argc, char **argv)
{
int argi, i;
char *arg, *nextarg;
PmError perr;
PtError pterr;
PmDeviceID dev = -1;
int list = 0;
for (argi = 1; argi < argc; argi++) {
arg = argv[argi];
nextarg = argv[argi+1];
if (arg[0] == '-') {
if (!strcmp(arg, "-l")) {
list = 1;
} else if (!strcmp(arg, "-i") && nextarg) {
dev = atoi(nextarg);
argi++;
} else {
fprintf(stderr, "Invalid invocation.\n");
exit(1);
}
}
}
PSF(perr, Pm_Initialize, ());
PTSF(pterr, Pt_Start, (1, dump, NULL));
/* list devices */
if (list) {
int ct = Pm_CountDevices();
PmDeviceID def = Pm_GetDefaultInputDeviceID();
const PmDeviceInfo *devinf;
for (i = 0; i < ct; i++) {
devinf = Pm_GetDeviceInfo(i);
printf("%d%s: %s%s %s\n", i, (def == i) ? "*" : "",
(devinf->input) ? "I" : "",
(devinf->output) ? "O" : "",
devinf->name);
}
}
/* choose device */
if (dev == -1) {
fprintf(stderr, "Warning: Using default device.\n");
dev = Pm_GetDefaultInputDeviceID();
}
/* open it for input */
PSF(perr, Pm_OpenInput, (&stream, dev, NULL, 1024, NULL, NULL));
PSF(perr, Pm_SetFilter, (stream, PM_FILT_ACTIVE | PM_FILT_SYSEX));
while (1) Pt_Sleep(1<<31);
return 0;
}
void pm_module::list_midi_devices(void)
{
int num_devs = Pm_CountDevices();
const PmDeviceInfo *pmInfo;
printf("\n");
if (num_devs == 0)
{
printf("No MIDI ports were found\n");
return;
}
printf("MIDI input ports:\n");
for (int i = 0; i < num_devs; i++)
{
pmInfo = Pm_GetDeviceInfo(i);
if (pmInfo->input)
{
printf("%s %s\n", pmInfo->name, (i == Pm_GetDefaultInputDeviceID()) ? "(default)" : "");
}
}
printf("\nMIDI output ports:\n");
for (int i = 0; i < num_devs; i++)
{
pmInfo = Pm_GetDeviceInfo(i);
if (pmInfo->output)
{
printf("%s %s\n", pmInfo->name, (i == Pm_GetDefaultOutputDeviceID()) ? "(default)" : "");
}
}
}
bool PortMidiDriver::init()
{
inputId = getDeviceIn(preferences.getString(PREF_IO_PORTMIDI_INPUTDEVICE));
if (inputId == -1)
inputId = Pm_GetDefaultInputDeviceID();
if (inputId == pmNoDevice)
return false;
outputId = getDeviceOut(preferences.getString(PREF_IO_PORTMIDI_OUTPUTDEVICE)); // Note: allow init even if outputId == pmNoDevice, since input is more important than output.
static const int DRIVER_INFO = 0;
static const int TIME_INFO = 0;
Pt_Start(20, 0, 0); // timer started, 20 millisecond accuracy
PmError error = Pm_OpenInput(&inputStream,
inputId,
(void*)DRIVER_INFO,
preferences.getInt(PREF_IO_PORTMIDI_INPUTBUFFERCOUNT),
((PmTimeProcPtr) Pt_Time),
(void*)TIME_INFO);
if (error != pmNoError) {
const char* p = Pm_GetErrorText(error);
qDebug("PortMidi: open input (id=%d) failed: %s", int(inputId), p);
Pt_Stop();
return false;
}
Pm_SetFilter(inputStream, PM_FILT_ACTIVE | PM_FILT_CLOCK | PM_FILT_SYSEX);
PmEvent buffer[1];
while (Pm_Poll(inputStream))
Pm_Read(inputStream, buffer, 1);
if (outputId != pmNoDevice) {
error = Pm_OpenOutput(&outputStream,
outputId,
(void*)DRIVER_INFO,
preferences.getInt(PREF_IO_PORTMIDI_OUTPUTBUFFERCOUNT),
((PmTimeProcPtr) Pt_Time),
(void*)TIME_INFO,
preferences.getInt(PREF_IO_PORTMIDI_OUTPUTLATENCYMILLISECONDS));
if (error != pmNoError) {
const char* p = Pm_GetErrorText(error);
qDebug("PortMidi: open output (id=%d) failed: %s", int(outputId), p);
Pt_Stop();
return false;
}
}
timer = new QTimer();
timer->setInterval(20); // 20 msec
timer->start();
timer->connect(timer, SIGNAL(timeout()), seq, SLOT(midiInputReady()));
return true;
}
PyObject *
portmidi_get_default_input() {
PmDeviceID i;
i = Pm_GetDefaultInputDeviceID();
if (i < 0)
printf("pm_get_default_input: no midi input device found.\n");
return PyInt_FromLong(i);
}
MidiWindow::MidiWindow(QWidget *parent) :
QWidget(parent),
ui(new Ui::MidiWindow)
{
ui->setupUi(this);
Pm_Initialize();
m_sequencer = NULL;
emit refreshHardware();
emit newMidiSequencer( Pm_GetDefaultInputDeviceID());
//Read profil box ...
{
QDir dir("./data/config/midi");
QStringList files = dir.entryList();
for(int i=0; i<files.size(); i++)
{
QString item = files.at(i).toLocal8Bit().constData();
if( item != "." && item != ".." && item != ".svn" )
{
item.remove(item.length()-5,5);
ui->profilBox->addItem(item);
}
}
}
//readConf();
connect(ui->btnBassTimeSpeed, SIGNAL(clicked()), this, SLOT(learnBassTimeSpeedCC()));
connect(ui->btnGamma, SIGNAL(clicked()), this, SLOT(learnGammaCC()));
connect(ui->btnBrightness, SIGNAL(clicked()), this, SLOT(learnBrightnessCC()));
connect(ui->btnContrast, SIGNAL(clicked()), this, SLOT(learnContrastCC()));
connect(ui->btnDesaturate, SIGNAL(clicked()), this, SLOT(learnDesaturateCC()));
connect(ui->btnBlackFade, SIGNAL(clicked()), this, SLOT(learnBlackFade()));
connect(ui->btnTimeSpeed, SIGNAL(clicked()), this, SLOT(learnTimeSpeedCC()));
connect(ui->btn1Effect1, SIGNAL(clicked()), this, SLOT(learn1Effect1CC()));
connect(ui->btn1Effect2, SIGNAL(clicked()), this, SLOT(learn1Effect2CC()));
connect(ui->btn1Effect3, SIGNAL(clicked()), this, SLOT(learn1Effect3CC()));
connect(ui->btn1Effect4, SIGNAL(clicked()), this, SLOT(learn1Effect4CC()));
connect(ui->btn2Effect1, SIGNAL(clicked()), this, SLOT(learn2Effect1CC()));
connect(ui->btn2Effect2, SIGNAL(clicked()), this, SLOT(learn2Effect2CC()));
connect(ui->btn2Effect3, SIGNAL(clicked()), this, SLOT(learn2Effect3CC()));
connect(ui->btn2Effect4, SIGNAL(clicked()), this, SLOT(learn2Effect4CC()));
connect(ui->btnSwitchDisplay, SIGNAL(clicked()), this, SLOT(learnSwitchDisplay()));
connect(ui->btnSceneNext, SIGNAL(clicked()), this, SLOT(learnSceneUp()));
connect(ui->btnSceneBack, SIGNAL(clicked()), this, SLOT(learnSceneDown()));
connect(ui->btnTransitionUp, SIGNAL(clicked()), this, SLOT(learnTransitionUp()));
connect(ui->btnTransitionDown, SIGNAL(clicked()), this, SLOT(learnTransitionDown()));
connect(ui->cloneFaderCheck, SIGNAL(clicked()), this, SLOT(setCloneFader()));
connect(ui->profilBox, SIGNAL(currentIndexChanged(int)), this, SLOT(readConf()));
connect(ui->newProfilButton, SIGNAL(clicked()), this, SLOT(addProfil()));
connect(ui->refreshButton, SIGNAL(clicked()), this, SLOT(refreshHardware()));
connect(ui->hardwareComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(newMidiSequencer(int)));
isLearning = false;
learningCC = NULL;
}
PmDeviceID
get_portmidi_device_id (char const *name, gboolean output)
{
PmError err = Pm_InitializeWrapper ();
if (err != pmNoError)
{
return pmNoDevice;
}
PmDeviceID ret = pmNoDevice;
if (g_strcmp0 (name, "default") == 0)
{
if (output)
{
ret = Pm_GetDefaultOutputDeviceID ();
goto out;
}
else
{
ret = Pm_GetDefaultInputDeviceID ();
goto out;
}
}
int num = Pm_CountDevices ();
int i;
for (i = 0; i < num; ++i)
{
PmDeviceInfo const *info = Pm_GetDeviceInfo (i);
char *s = g_strdup_printf ("%s: %s", info->interf, info->name);
// check if the device type (input/output) and name matches
if (((output && info->output) || (!output && info->input)) && g_strcmp0 (name, s) == 0)
{
ret = i;
g_free (s);
break;
}
g_free (s);
}
out:
Pm_TerminateWrapper ();
return ret;
}
osd_midi_device *osd_open_midi_input(const char *devname)
{
int num_devs = Pm_CountDevices();
int found_dev = -1;
const PmDeviceInfo *pmInfo;
PortMidiStream *stm;
osd_midi_device *ret;
if (!strcmp("default", devname))
{
found_dev = Pm_GetDefaultInputDeviceID();
}
else
{
for (int i = 0; i < num_devs; i++)
{
pmInfo = Pm_GetDeviceInfo(i);
if (pmInfo->input)
{
if (!strcmp(devname, pmInfo->name))
{
found_dev = i;
break;
}
}
}
}
if (found_dev >= 0)
{
if (Pm_OpenInput(&stm, found_dev, NULL, RX_EVENT_BUF_SIZE, NULL, NULL) == pmNoError)
{
ret = (osd_midi_device *)osd_malloc(sizeof(osd_midi_device));
memset(ret, 0, sizeof(osd_midi_device));
ret->pmStream = stm;
return ret;
}
else
{
printf("Couldn't open PM device\n");
return NULL;
}
}
else
{
return NULL;
}
}
bool osd_midi_device_pm::open_input(const char *devname)
{
int num_devs = Pm_CountDevices();
int found_dev = -1;
const PmDeviceInfo *pmInfo;
PortMidiStream *stm;
if (!strcmp("default", devname))
{
found_dev = Pm_GetDefaultInputDeviceID();
}
else
{
for (int i = 0; i < num_devs; i++)
{
pmInfo = Pm_GetDeviceInfo(i);
if (pmInfo->input)
{
if (!strcmp(devname, pmInfo->name))
{
found_dev = i;
break;
}
}
}
}
if (found_dev >= 0)
{
if (Pm_OpenInput(&stm, found_dev, nullptr, RX_EVENT_BUF_SIZE, nullptr, nullptr) == pmNoError)
{
pmStream = stm;
return true;
}
else
{
printf("Couldn't open PM device\n");
return false;
}
}
else
{
return false;
}
}
bool PortMidiDriver::init()
{
inputId = getDeviceIn(preferences.portMidiInput);
if(inputId == -1)
inputId = Pm_GetDefaultInputDeviceID();
outputId = Pm_GetDefaultOutputDeviceID();
if (inputId == pmNoDevice)
return false;
static const int INPUT_BUFFER_SIZE = 100;
static const int DRIVER_INFO = 0;
static const int TIME_INFO = 0;
Pt_Start(20, 0, 0); // timer started, 20 millisecond accuracy
PmError error = Pm_OpenInput(&inputStream,
inputId,
(void*)DRIVER_INFO, INPUT_BUFFER_SIZE,
((long (*)(void*)) Pt_Time),
(void*)TIME_INFO);
if (error != pmNoError) {
const char* p = Pm_GetErrorText(error);
qDebug("PortMidi: open input (id=%d) failed: %s", int(inputId), p);
Pt_Stop();
return false;
}
Pm_SetFilter(inputStream, PM_FILT_ACTIVE | PM_FILT_CLOCK | PM_FILT_SYSEX);
PmEvent buffer[1];
while (Pm_Poll(inputStream))
Pm_Read(inputStream, buffer, 1);
timer = new QTimer();
timer->setInterval(20); // 20 msec
timer->start();
timer->connect(timer, SIGNAL(timeout()), seq, SLOT(midiInputReady()));
return true;
}
void osd_list_midi_devices(void)
{
#ifndef DISABLE_MIDI
int num_devs = Pm_CountDevices();
const PmDeviceInfo *pmInfo;
printf("\n");
if (num_devs == 0)
{
printf("No MIDI ports were found\n");
return;
}
printf("MIDI input ports:\n");
for (int i = 0; i < num_devs; i++)
{
pmInfo = Pm_GetDeviceInfo(i);
if (pmInfo->input)
{
printf("%s %s\n", pmInfo->name, (i == Pm_GetDefaultInputDeviceID()) ? "(default)" : "");
}
}
printf("\nMIDI output ports:\n");
for (int i = 0; i < num_devs; i++)
{
pmInfo = Pm_GetDeviceInfo(i);
if (pmInfo->output)
{
printf("%s %s\n", pmInfo->name, (i == Pm_GetDefaultOutputDeviceID()) ? "(default)" : "");
}
}
#else
printf("\nMIDI is not supported in this build\n");
#endif
}
int main()
{
int id;
long n;
const PmDeviceInfo *info;
char line[STRING_MAX];
int spin;
int done = FALSE;
/* determine what type of test to run */
printf("begin PortMidi multithread test...\n");
/* note that it is safe to call PortMidi from the main thread for
initialization and opening devices. You should not make any
calls to PortMidi from this thread once the midi thread begins.
to make PortMidi calls.
*/
/* make the message queues */
/* messages can be of any size and any type, but all messages in
* a given queue must have the same size. We'll just use long's
* for our messages in this simple example
*/
midi_to_main = Pm_QueueCreate(32, sizeof(long));
assert(midi_to_main != NULL);
main_to_midi = Pm_QueueCreate(32, sizeof(long));
assert(main_to_midi != NULL);
/* a little test of enqueue and dequeue operations. Ordinarily,
* you would call Pm_Enqueue from one thread and Pm_Dequeue from
* the other. Since the midi thread is not running, this is safe.
*/
n = 1234567890;
Pm_Enqueue(midi_to_main, &n);
n = 987654321;
Pm_Enqueue(midi_to_main, &n);
Pm_Dequeue(midi_to_main, &n);
if (n != 1234567890) {
exit_with_message("Pm_Dequeue produced unexpected result.");
}
Pm_Dequeue(midi_to_main, &n);
if(n != 987654321) {
exit_with_message("Pm_Dequeue produced unexpected result.");
}
/* always start the timer before you start midi */
Pt_Start(1, &process_midi, 0); /* start a timer with millisecond accuracy */
/* the timer will call our function, process_midi() every millisecond */
Pm_Initialize();
id = Pm_GetDefaultOutputDeviceID();
info = Pm_GetDeviceInfo(id);
if (info == NULL) {
printf("Could not open default output device (%d).", id);
exit_with_message("");
}
printf("Opening output device %s %s\n", info->interf, info->name);
/* use zero latency because we want output to be immediate */
Pm_OpenOutput(&midi_out,
id,
DRIVER_INFO,
OUTPUT_BUFFER_SIZE,
TIME_PROC,
TIME_INFO,
LATENCY);
id = Pm_GetDefaultInputDeviceID();
info = Pm_GetDeviceInfo(id);
if (info == NULL) {
printf("Could not open default input device (%d).", id);
exit_with_message("");
}
printf("Opening input device %s %s\n", info->interf, info->name);
Pm_OpenInput(&midi_in,
id,
DRIVER_INFO,
INPUT_BUFFER_SIZE,
TIME_PROC,
TIME_INFO);
active = TRUE; /* enable processing in the midi thread -- yes, this
is a shared variable without synchronization, but
this simple assignment is safe */
printf("Enter midi input; it will be transformed as specified by...\n");
printf("%s\n%s\n%s\n",
"Type 'q' to quit, 'm' to monitor next pitch, t to toggle thru or",
"type a number to specify transposition.",
"Must terminate with [ENTER]");
while (!done) {
long msg;
int len;
fgets(line, STRING_MAX, stdin);
/* remove the newline: */
len = strlen(line);
if (len > 0) line[len - 1] = 0; /* overwrite the newline char */
if (strcmp(line, "q") == 0) {
msg = QUIT_MSG;
Pm_Enqueue(main_to_midi, &msg);
/* wait for acknowlegement */
do {
spin = Pm_Dequeue(midi_to_main, &msg);
} while (spin == 0); /* spin */ ;
done = TRUE; /* leave the command loop and wrap up */
} else if (strcmp(line, "m") == 0) {
msg = MONITOR_MSG;
Pm_Enqueue(main_to_midi, &msg);
printf("Waiting for note...\n");
do {
spin = Pm_Dequeue(midi_to_main, &msg);
} while (spin == 0); /* spin */ ;
printf("... pitch is %ld\n", msg);
} else if (strcmp(line, "t") == 0) {
/* reading midi_thru asynchronously could give incorrect results,
e.g. if you type "t" twice before the midi thread responds to
the first one, but we'll do it this way anyway. Perhaps a more
correct way would be to wait for an acknowledgement message
containing the new state. */
printf("Setting THRU %s\n", (midi_thru ? "off" : "on"));
msg = THRU_MSG;
Pm_Enqueue(main_to_midi, &msg);
} else if (sscanf(line, "%ld", &msg) == 1) {
if (msg >= -127 && msg <= 127) {
/* send transposition value */
printf("Transposing by %ld\n", msg);
Pm_Enqueue(main_to_midi, &msg);
} else {
printf("Transposition must be within -127...127\n");
}
} else {
printf("%s\n%s\n%s\n",
"Type 'q' to quit, 'm' to monitor next pitch, or",
"type a number to specify transposition.",
"Must terminate with [ENTER]");
}
}
/* at this point, midi thread is inactive and we need to shut down
* the midi input and output
*/
Pt_Stop(); /* stop the timer */
Pm_QueueDestroy(midi_to_main);
Pm_QueueDestroy(main_to_midi);
/* Belinda! if close fails here, some memory is deleted, right??? */
Pm_Close(midi_in);
Pm_Close(midi_out);
printf("finished portMidi multithread test...enter any character to quit [RETURN]...");
fgets(line, STRING_MAX, stdin);
return 0;
}
static int OpenMidiInDevice_(CSOUND *csound, void **userData, const char *dev)
{
int cntdev, devnum, opendevs, i;
PmEvent buffer;
PmError retval;
PmDeviceInfo *info;
// PortMidiStream *midistream;
pmall_data *data = NULL;
pmall_data *next = NULL;
if (start_portmidi(csound) != 0)
return -1;
/* check if there are any devices available */
cntdev = portMidi_getDeviceCount(0);
portMidi_listDevices(csound, 0);
/* look up device in list */
if (dev == NULL || dev[0] == '\0')
devnum =
portMidi_getPackedDeviceID((int)Pm_GetDefaultInputDeviceID(), 0);
else if (UNLIKELY((dev[0] < '0' || dev[0] > '9') && dev[0] != 'a')) {
portMidiErrMsg(csound,
Str("error: must specify a device number (>=0) or"
" 'a' for all, not a name"));
return -1;
}
else if (dev[0] != 'a') {
devnum = (int)atoi(dev);
if (UNLIKELY(devnum < 0 || devnum >= cntdev)) {
portMidiErrMsg(csound, Str("error: device number is out of range"));
return -1;
}
}
else {
// allow to proceed if 'a' is given even if there are no MIDI devices
devnum = -1;
}
if (UNLIKELY(cntdev < 1 && (dev==NULL || dev[0] != 'a'))) {
return portMidiErrMsg(csound, Str("no input devices are available"));
}
opendevs = 0;
for (i = 0; i < cntdev; i++) {
if (devnum == i || devnum == -1) {
if (opendevs == 0) {
data = (pmall_data *) malloc(sizeof(pmall_data));
next = data;
data->next = NULL;
opendevs++;
}
else {
next->next = (pmall_data *) malloc(sizeof(pmall_data));
next = next->next;
next->next = NULL;
opendevs++;
}
info = portMidi_getDeviceInfo(i, 0);
if (info->interf != NULL)
csound->Message(csound,
Str("PortMIDI: Activated input device %d: '%s' (%s)\n"),
i, info->name, info->interf);
else
csound->Message(csound,
Str("PortMIDI: Activated input device %d: '%s'\n"),
i, info->name);
retval = Pm_OpenInput(&next->midistream,
(PmDeviceID) portMidi_getRealDeviceID(i, 0),
NULL, 512L, (PmTimeProcPtr) NULL, NULL);
if (UNLIKELY(retval != pmNoError)) {
// Prevent leaking memory from "data"
if (data) {
next = data->next;
free(data);
}
return portMidiErrMsg(csound, Str("error opening input device %d: %s"),
i, Pm_GetErrorText(retval));
}
/* only interested in channel messages (note on, control change, etc.) */
/* GAB: fixed for portmidi v.23Aug06 */
Pm_SetFilter(next->midistream, (PM_FILT_ACTIVE | PM_FILT_SYSEX));
/* empty the buffer after setting filter */
while (Pm_Poll(next->midistream) == TRUE) {
Pm_Read(next->midistream, &buffer, 1);
}
}
}
*userData = (void*) data;
/* report success */
return 0;
}
int
Server_pm_init(Server *self)
{
int i = 0, ret = 0;
PmError pmerr;
if (self->midiActive == 0) {
self->withPortMidi = 0;
self->withPortMidiOut = 0;
return 0;
}
pmerr = Pm_Initialize();
if (pmerr) {
Server_warning(self, "Portmidi warning: could not initialize Portmidi: %s\n", Pm_GetErrorText(pmerr));
self->withPortMidi = 0;
self->withPortMidiOut = 0;
return -1;
}
else {
Server_debug(self, "Portmidi initialized.\n");
self->withPortMidi = 1;
self->withPortMidiOut = 1;
}
PyoPmBackendData *be_data = (PyoPmBackendData *) malloc(sizeof(PyoPmBackendData *));
self->midi_be_data = (void *) be_data;
if (self->withPortMidi == 1) {
self->midiin_count = self->midiout_count = 0;
int num_devices = Pm_CountDevices();
Server_debug(self, "Portmidi number of devices: %d.\n", num_devices);
if (num_devices > 0) {
if (self->midi_input < num_devices) {
if (self->midi_input == -1)
self->midi_input = Pm_GetDefaultInputDeviceID();
Server_debug(self, "Midi input device : %d.\n", self->midi_input);
const PmDeviceInfo *info = Pm_GetDeviceInfo(self->midi_input);
if (info != NULL) {
if (info->input) {
pmerr = Pm_OpenInput(&be_data->midiin[0], self->midi_input, NULL, 100, NULL, NULL);
if (pmerr) {
Server_warning(self,
"Portmidi warning: could not open midi input %d (%s): %s\n",
self->midi_input, info->name, Pm_GetErrorText(pmerr));
self->withPortMidi = 0;
}
else {
Server_debug(self, "Midi input (%s) opened.\n", info->name);
self->midiin_count = 1;
}
}
else {
Server_warning(self, "Portmidi warning: Midi Device (%s), not an input device!\n", info->name);
self->withPortMidi = 0;
}
}
}
else if (self->midi_input >= num_devices) {
Server_debug(self, "Midi input device : all!\n");
self->midiin_count = 0;
for (i=0; i<num_devices; i++) {
const PmDeviceInfo *info = Pm_GetDeviceInfo(i);
if (info != NULL) {
if (info->input) {
pmerr = Pm_OpenInput(&be_data->midiin[self->midiin_count], i, NULL, 100, NULL, NULL);
if (pmerr) {
Server_warning(self,
"Portmidi warning: could not open midi input %d (%s): %s\n",
0, info->name, Pm_GetErrorText(pmerr));
}
else {
Server_debug(self, "Midi input (%s) opened.\n", info->name);
self->midiin_count++;
}
}
}
}
if (self->midiin_count == 0)
self->withPortMidi = 0;
}
else {
Server_warning(self, "Portmidi warning: no input device!\n");
self->withPortMidi = 0;
}
if (self->midi_output < num_devices) {
if (self->midi_output == -1)
self->midi_output = Pm_GetDefaultOutputDeviceID();
Server_debug(self, "Midi output device : %d.\n", self->midi_output);
const PmDeviceInfo *outinfo = Pm_GetDeviceInfo(self->midi_output);
if (outinfo != NULL) {
if (outinfo->output) {
Pt_Start(1, 0, 0); /* start a timer with millisecond accuracy */
pmerr = Pm_OpenOutput(&be_data->midiout[0], self->midi_output, NULL, 0, NULL, NULL, 1);
if (pmerr) {
Server_warning(self,
"Portmidi warning: could not open midi output %d (%s): %s\n",
self->midi_output, outinfo->name, Pm_GetErrorText(pmerr));
self->withPortMidiOut = 0;
if (Pt_Started())
Pt_Stop();
}
else {
Server_debug(self, "Midi output (%s) opened.\n", outinfo->name);
self->midiout_count = 1;
}
}
else {
Server_warning(self, "Portmidi warning: Midi Device (%s), not an output device!\n", outinfo->name);
self->withPortMidiOut = 0;
}
}
}
else if (self->midi_output >= num_devices) {
Server_debug(self, "Midi output device : all!\n");
self->midiout_count = 0;
Pt_Start(1, 0, 0); /* start a timer with millisecond accuracy */
for (i=0; i<num_devices; i++) {
const PmDeviceInfo *outinfo = Pm_GetDeviceInfo(i);
if (outinfo != NULL) {
if (outinfo->output) {
pmerr = Pm_OpenOutput(&be_data->midiout[self->midiout_count], i, NULL, 100, NULL, NULL, 1);
if (pmerr) {
Server_warning(self,
"Portmidi warning: could not open midi output %d (%s): %s\n",
0, outinfo->name, Pm_GetErrorText(pmerr));
}
else {
Server_debug(self, "Midi output (%s) opened.\n", outinfo->name);
self->midiout_count++;
}
}
}
}
if (self->midiout_count == 0) {
if (Pt_Started())
Pt_Stop();
self->withPortMidiOut = 0;
}
}
else {
Server_warning(self, "Portmidi warning: no output device!\n");
self->withPortMidiOut = 0;
}
if (self->withPortMidi == 0 && self->withPortMidiOut == 0) {
Pm_Terminate();
Server_warning(self, "Portmidi closed.\n");
ret = -1;
}
}
else {
Server_warning(self, "Portmidi warning: no midi device found!\nPortmidi closed.\n");
self->withPortMidi = 0;
self->withPortMidiOut = 0;
Pm_Terminate();
ret = -1;
}
}
if (self->withPortMidi == 1) {
self->midi_count = 0;
for (i=0; i<self->midiin_count; i++) {
Pm_SetFilter(be_data->midiin[i], PM_FILT_ACTIVE | PM_FILT_CLOCK);
}
}
return ret;
}
static PyObject * MidiListener_play(MidiListener *self) {
int i, num_devices;
PmError pmerr;
/* always start the timer before you start midi */
Pt_Start(1, &process_midi, (void *)self);
pmerr = Pm_Initialize();
if (pmerr) {
PySys_WriteStdout("Portmidi warning: could not initialize Portmidi: %s\n", Pm_GetErrorText(pmerr));
}
num_devices = Pm_CountDevices();
if (num_devices > 0) {
if (self->mididev < num_devices) {
if (self->mididev == -1)
self->mididev = Pm_GetDefaultInputDeviceID();
const PmDeviceInfo *info = Pm_GetDeviceInfo(self->mididev);
if (info != NULL) {
if (info->input) {
pmerr = Pm_OpenInput(&self->midiin[0], self->mididev, NULL, 100, NULL, NULL);
if (pmerr) {
PySys_WriteStdout("Portmidi warning: could not open midi input %d (%s): %s\n",
self->mididev, info->name, Pm_GetErrorText(pmerr));
}
else {
self->midicount = 1;
}
}
}
}
else if (self->mididev >= num_devices) {
self->midicount = 0;
for (i=0; i<num_devices; i++) {
const PmDeviceInfo *info = Pm_GetDeviceInfo(i);
if (info != NULL) {
if (info->input) {
pmerr = Pm_OpenInput(&self->midiin[self->midicount], i, NULL, 100, NULL, NULL);
if (pmerr) {
PySys_WriteStdout("Portmidi warning: could not open midi input %d (%s): %s\n",
i, info->name, Pm_GetErrorText(pmerr));
}
else {
self->midicount++;
}
}
}
}
}
}
for (i=0; i<self->midicount; i++) {
Pm_SetFilter(self->midiin[i], PM_FILT_ACTIVE | PM_FILT_CLOCK);
}
if (self->midicount > 0)
self->active = 1;
Py_INCREF(Py_None);
return Py_None;
};
int main(int argc, char *argv[])
{
int default_in;
int default_out;
int i = 0, n = 0;
char line[STRING_MAX];
int test_input = 0, test_output = 0, test_both = 0, somethingStupid = 0;
int stream_test = 0;
int latency_valid = FALSE;
if (sizeof(void *) == 8)
printf("Apparently this is a 64-bit machine.\n");
else if (sizeof(void *) == 4)
printf ("Apparently this is a 32-bit machine.\n");
for (i = 1; i < argc; i++) {
if (strcmp(argv[i], "-h") == 0) {
show_usage();
} else if (strcmp(argv[i], "-l") == 0 && (i + 1 < argc)) {
i = i + 1;
latency = atoi(argv[i]);
printf("Latency will be %ld\n", (long) latency);
latency_valid = TRUE;
} else {
show_usage();
}
}
while (!latency_valid) {
int lat; // declared int to match "%d"
printf("Latency in ms: ");
if (scanf("%d", &lat) == 1) {
latency = (int32_t) lat; // coerce from "%d" to known size
latency_valid = TRUE;
}
}
/* determine what type of test to run */
printf("begin portMidi test...\n");
printf("%s%s%s%s%s",
"enter your choice...\n 1: test input\n",
" 2: test input (fail w/assert)\n",
" 3: test input (fail w/NULL assign)\n",
" 4: test output\n 5: test both\n",
" 6: stream test\n");
while (n != 1) {
n = scanf("%d", &i);
fgets(line, STRING_MAX, stdin);
switch(i) {
case 1:
test_input = 1;
break;
case 2:
test_input = 1;
somethingStupid = 1;
break;
case 3:
test_input = 1;
somethingStupid = 2;
break;
case 4:
test_output = 1;
break;
case 5:
test_both = 1;
break;
case 6:
stream_test = 1;
break;
default:
printf("got %d (invalid input)\n", n);
break;
}
}
/* list device information */
default_in = Pm_GetDefaultInputDeviceID();
default_out = Pm_GetDefaultOutputDeviceID();
for (i = 0; i < Pm_CountDevices(); i++) {
char *deflt;
const PmDeviceInfo *info = Pm_GetDeviceInfo(i);
if (((test_input | test_both) & info->input) |
((test_output | test_both | stream_test) & info->output)) {
printf("%d: %s, %s", i, info->interf, info->name);
if (info->input) {
deflt = (i == default_in ? "default " : "");
printf(" (%sinput)", deflt);
}
if (info->output) {
deflt = (i == default_out ? "default " : "");
printf(" (%soutput)", deflt);
}
printf("\n");
}
}
/* run test */
if (stream_test) {
main_test_stream();
} else if (test_input) {
main_test_input(somethingStupid);
} else if (test_output) {
main_test_output();
} else if (test_both) {
main_test_both();
}
printf("finished portMidi test...type ENTER to quit...");
fgets(line, STRING_MAX, stdin);
return 0;
}
int main(int argc, char **argv)
{
FILE *f;
PmError perr;
PtError pterr;
MfFile *pf;
int argi, i;
char *arg, *nextarg, *file;
PmDeviceID dev = -1;
int list = 0;
file = NULL;
for (argi = 1; argi < argc; argi++) {
arg = argv[argi];
nextarg = argv[argi+1];
if (arg[0] == '-') {
if (!strcmp(arg, "-l")) {
list = 1;
} else if (!strcmp(arg, "-o") && nextarg) {
dev = atoi(nextarg);
argi++;
} else {
fprintf(stderr, "Invalid invocation.\n");
exit(1);
}
} else {
file = arg;
}
}
PSF(perr, Pm_Initialize, ());
PSF(perr, Mf_Initialize, ());
PTSF(pterr, Pt_Start, (1, play, NULL));
/* list devices */
if (list) {
int ct = Pm_CountDevices();
PmDeviceID def = Pm_GetDefaultInputDeviceID();
const PmDeviceInfo *devinf;
for (i = 0; i < ct; i++) {
devinf = Pm_GetDeviceInfo(i);
printf("%d%s: %s%s %s\n", i, (def == i) ? "*" : "",
(devinf->input) ? "I" : "",
(devinf->output) ? "O" : "",
devinf->name);
}
}
/* choose device */
if (dev == -1) {
fprintf(stderr, "No device selected.\n");
exit(1);
}
/* open it for input */
PSF(perr, Pm_OpenOutput, (&ostream, dev, NULL, 1024, NULL, NULL, 0));
/* open it for input */
f = fopen(file, "rb");
if (f == NULL) {
perror(file);
exit(1);
}
/* and read it */
PSF(perr, Mf_ReadMidiFile, (&pf, f));
fclose(f);
/* now start running */
stream = Mf_OpenStream(pf);
Mf_StartStream(stream, Pt_Time());
/* FIXME: I sure hope this doesn't get reordered >_> */
ready = 1;
while (1) Pt_Sleep(1<<30);
return 0;
}
/*
* Method: Pm_GetDefaultInputDeviceID
*/
JNIEXPORT jint JNICALL Java_jportmidi_JPortMidiApi_Pm_1GetDefaultInputDeviceID
(JNIEnv *env, jclass cl)
{
return Pm_GetDefaultInputDeviceID();
}
