287 lines
8.7 KiB
C
287 lines
8.7 KiB
C
/* miditime.c -- a test program that sends midi clock and MTC */
|
|
|
|
#include "portmidi.h"
|
|
#include "porttime.h"
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <assert.h>
|
|
#include <ctype.h>
|
|
|
|
#ifndef false
|
|
#define false 0
|
|
#define true 1
|
|
#endif
|
|
|
|
#define private static
|
|
typedef int boolean;
|
|
|
|
#define MIDI_TIME_CLOCK 0xf8
|
|
#define MIDI_START 0xfa
|
|
#define MIDI_CONTINUE 0xfb
|
|
#define MIDI_STOP 0xfc
|
|
#define MIDI_Q_FRAME 0xf1
|
|
|
|
#define OUTPUT_BUFFER_SIZE 0
|
|
#define DRIVER_INFO NULL
|
|
#define TIME_PROC ((int32_t (*)(void *)) Pt_Time)
|
|
#define TIME_INFO NULL
|
|
#define LATENCY 0
|
|
#define TIME_START Pt_Start(1, 0, 0) /* timer started w/millisecond accuracy */
|
|
|
|
#define STRING_MAX 80 /* used for console input */
|
|
|
|
/* to determine ms per clock:
|
|
* time per beat in seconds = 60 / tempo
|
|
* multiply by 1000 to get time per beat in ms: 60000 / tempo
|
|
* divide by 24 CLOCKs per beat: (60000/24) / tempo
|
|
* simplify: 2500 / tempo
|
|
*/
|
|
#define TEMPO_TO_CLOCK 2500.0
|
|
|
|
boolean done = false;
|
|
PmStream *midi;
|
|
/* shared flags to control callback output generation: */
|
|
boolean clock_running = false;
|
|
boolean send_start_stop = false;
|
|
boolean time_code_running = false;
|
|
boolean active = false; /* tells callback to do its thing */
|
|
float tempo = 60.0F;
|
|
/* protocol for handing off portmidi to callback thread:
|
|
main owns portmidi
|
|
main sets active = true: ownership transfers to callback
|
|
main sets active = false: main requests ownership
|
|
callback sees active == false, yields ownership back to main
|
|
main waits 2ms to make sure callback has a chance to yield
|
|
(stop making PortMidi calls), then assumes it can close
|
|
PortMidi
|
|
*/
|
|
|
|
/* timer_poll -- the timer callback function */
|
|
/*
|
|
* All MIDI sends take place here
|
|
*/
|
|
void timer_poll(PtTimestamp timestamp, void *userData)
|
|
{
|
|
static int callback_owns_portmidi = false;
|
|
static PmTimestamp clock_start_time = 0;
|
|
static double next_clock_time = 0;
|
|
/* SMPTE time */
|
|
static int frames = 0;
|
|
static int seconds = 0;
|
|
static int minutes = 0;
|
|
static int hours = 0;
|
|
static int mtc_count = 0; /* where are we in quarter frame sequence? */
|
|
static int smpte_start_time = 0;
|
|
static double next_smpte_time = 0;
|
|
#define QUARTER_FRAME_PERIOD (1.0 / 120.0) /* 30fps, 1/4 frame */
|
|
|
|
if (callback_owns_portmidi && !active) {
|
|
/* main is requesting (by setting active to false) that we shut down */
|
|
callback_owns_portmidi = false;
|
|
return;
|
|
}
|
|
if (!active) return; /* main still getting ready or it's closing down */
|
|
callback_owns_portmidi = true; /* main is ready, we have portmidi */
|
|
if (send_start_stop) {
|
|
if (clock_running) {
|
|
Pm_WriteShort(midi, 0, MIDI_STOP);
|
|
} else {
|
|
Pm_WriteShort(midi, 0, MIDI_START);
|
|
clock_start_time = timestamp;
|
|
next_clock_time = TEMPO_TO_CLOCK / tempo;
|
|
}
|
|
clock_running = !clock_running;
|
|
send_start_stop = false; /* until main sets it again */
|
|
/* note that there's a slight race condition here: main could
|
|
set send_start_stop asynchronously, but we assume user is
|
|
typing slower than the clock rate */
|
|
}
|
|
if (clock_running) {
|
|
if ((timestamp - clock_start_time) > next_clock_time) {
|
|
Pm_WriteShort(midi, 0, MIDI_TIME_CLOCK);
|
|
next_clock_time += TEMPO_TO_CLOCK / tempo;
|
|
}
|
|
}
|
|
if (time_code_running) {
|
|
int data = 0; // initialization avoids compiler warning
|
|
if ((timestamp - smpte_start_time) < next_smpte_time)
|
|
return;
|
|
switch (mtc_count) {
|
|
case 0: /* frames low nibble */
|
|
data = frames;
|
|
break;
|
|
case 1: /* frames high nibble */
|
|
data = frames >> 4;
|
|
break;
|
|
case 2: /* frames seconds low nibble */
|
|
data = seconds;
|
|
break;
|
|
case 3: /* frames seconds high nibble */
|
|
data = seconds >> 4;
|
|
break;
|
|
case 4: /* frames minutes low nibble */
|
|
data = minutes;
|
|
break;
|
|
case 5: /* frames minutes high nibble */
|
|
data = minutes >> 4;
|
|
break;
|
|
case 6: /* hours low nibble */
|
|
data = hours;
|
|
break;
|
|
case 7: /* hours high nibble */
|
|
data = hours >> 4;
|
|
break;
|
|
}
|
|
data &= 0xF; /* take only 4 bits */
|
|
Pm_WriteShort(midi, 0,
|
|
Pm_Message(MIDI_Q_FRAME, (mtc_count << 4) + data, 0));
|
|
mtc_count = (mtc_count + 1) & 7; /* wrap around */
|
|
if (mtc_count == 0) { /* update time by two frames */
|
|
frames += 2;
|
|
if (frames >= 30) {
|
|
frames = 0;
|
|
seconds++;
|
|
if (seconds >= 60) {
|
|
seconds = 0;
|
|
minutes++;
|
|
if (minutes >= 60) {
|
|
minutes = 0;
|
|
hours++;
|
|
/* just let hours wrap if it gets that far */
|
|
}
|
|
}
|
|
}
|
|
}
|
|
next_smpte_time += QUARTER_FRAME_PERIOD;
|
|
} else { /* time_code_running is false */
|
|
smpte_start_time = timestamp;
|
|
/* so that when it finally starts, we'll be in sync */
|
|
}
|
|
}
|
|
|
|
|
|
/* read a number from console */
|
|
/**/
|
|
int get_number(char *prompt)
|
|
{
|
|
char line[STRING_MAX];
|
|
int n = 0, i;
|
|
printf(prompt);
|
|
while (n != 1) {
|
|
n = scanf("%d", &i);
|
|
fgets(line, STRING_MAX, stdin);
|
|
|
|
}
|
|
return i;
|
|
}
|
|
|
|
/****************************************************************************
|
|
* showhelp
|
|
* Effect: print help text
|
|
****************************************************************************/
|
|
|
|
private void showhelp()
|
|
{
|
|
printf("\n");
|
|
printf("t toggles sending MIDI Time Code (MTC)\n");
|
|
printf("c toggles sending MIDI CLOCK (initially on)\n");
|
|
printf("m to set tempo (from 1bpm to 300bpm)\n");
|
|
printf("q quits\n");
|
|
printf("\n");
|
|
}
|
|
|
|
/****************************************************************************
|
|
* doascii
|
|
* Inputs:
|
|
* char c: input character
|
|
* Effect: interpret to control output
|
|
****************************************************************************/
|
|
|
|
private void doascii(char c)
|
|
{
|
|
if (isupper(c)) c = tolower(c);
|
|
if (c == 'q') done = true;
|
|
else if (c == 'c') {
|
|
printf("%s MIDI CLOCKs\n", (clock_running ? "Stopping" : "Starting"));
|
|
send_start_stop = true;
|
|
} else if (c == 't') {
|
|
printf("%s MIDI Time Code\n",
|
|
(time_code_running ? "Stopping" : "Starting"));
|
|
time_code_running = !time_code_running;
|
|
} else if (c == 'm') {
|
|
int input_tempo = get_number("Enter new tempo (bpm): ");
|
|
if (input_tempo >= 1 && input_tempo <= 300) {
|
|
printf("Changing tempo to %d\n", input_tempo);
|
|
tempo = (float) input_tempo;
|
|
} else {
|
|
printf("Tempo range is 1 to 300, current tempo is %g bpm\n",
|
|
tempo);
|
|
}
|
|
} else {
|
|
showhelp();
|
|
}
|
|
}
|
|
|
|
|
|
/* main - prompt for parameters, start processing */
|
|
/*
|
|
* Prompt user to type return.
|
|
* Then send START and MIDI CLOCK for 60 beats/min.
|
|
* Commands:
|
|
* t - toggle sending MIDI Time Code (MTC)
|
|
* c - toggle sending MIDI CLOCK
|
|
* m - set tempo
|
|
* q - quit
|
|
*/
|
|
int main(int argc, char **argv)
|
|
{
|
|
char s[STRING_MAX]; /* console input */
|
|
int outp;
|
|
PmError err;
|
|
int i;
|
|
if (argc > 1) {
|
|
printf("Warning: command line arguments ignored\n");
|
|
}
|
|
showhelp();
|
|
/* use porttime callback to send midi */
|
|
Pt_Start(1, timer_poll, 0);
|
|
/* list device information */
|
|
printf("MIDI output devices:\n");
|
|
for (i = 0; i < Pm_CountDevices(); i++) {
|
|
const PmDeviceInfo *info = Pm_GetDeviceInfo(i);
|
|
if (info->output) printf("%d: %s, %s\n", i, info->interf, info->name);
|
|
}
|
|
outp = get_number("Type output device number: ");
|
|
err = Pm_OpenOutput(&midi, outp, DRIVER_INFO, OUTPUT_BUFFER_SIZE,
|
|
TIME_PROC, TIME_INFO, LATENCY);
|
|
if (err) {
|
|
printf(Pm_GetErrorText(err));
|
|
goto error_exit_no_device;
|
|
}
|
|
active = true;
|
|
|
|
printf("Type RETURN to start MIDI CLOCK:\n");
|
|
if (!fgets(s, STRING_MAX, stdin)) goto error_exit;
|
|
send_start_stop = true; /* send START and then CLOCKs */
|
|
|
|
while (!done) {
|
|
if (fgets(s, STRING_MAX, stdin)) {
|
|
doascii(s[0]);
|
|
}
|
|
}
|
|
|
|
error_exit:
|
|
active = false;
|
|
Pt_Sleep(2); /* this is to allow callback to complete -- it's
|
|
real time, so it's either ok and it runs on
|
|
time, or there's no point to synchronizing
|
|
with it */
|
|
/* now we "own" portmidi again */
|
|
Pm_Close(midi);
|
|
error_exit_no_device:
|
|
Pt_Stop();
|
|
Pm_Terminate();
|
|
exit(0);
|
|
}
|
|
|