mirrors/pipewire
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/pipewire/pipewire.git synced 2025-10-29 05:40:27 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

control: improve UMP to Midi conversiom

Browse source 
Improve the spa_ump_to_midi function so that it can consume multiple UMP
messages and produce multiple midi messages.

Some UMP messages (like program changes) need to be translated into up
to 3 midi messages. Do this byt adding a state to the function and by
making it consume the input bytes, just like the spa_ump_from_midi
function.

Adapt code to this new world. This is a little API break..
This commit is contained in:
Wim Taymans 2025-08-19 17:41:03 +02:00
parent bf10458604
commit e35a8554f8
13 changed files with 307 additions and 228 deletions
Download patch file Download diff file Expand all files Collapse all files

42
pipewire-jack/src/pipewire-jack.c
View file

@ -1610,7 +1610,6 @@ static inline int midi_event_write(void *port_buffer,
static void convert_to_event(struct mix_info **mix, uint32_t n_mix, void *midi, bool fix, uint32_t type) static void convert_to_event(struct mix_info **mix, uint32_t n_mix, void *midi, bool fix, uint32_t type)
{ {
uint64_t state = 0;
uint32_t i; uint32_t i;
int res = 0; int res = 0;
bool in_sysex = false; bool in_sysex = false;
@ -1621,6 +1620,7 @@ static void convert_to_event(struct mix_info **mix, uint32_t n_mix, void *midi,
struct spa_pod_control *control; struct spa_pod_control *control;
size_t size; size_t size;
uint8_t *data; uint8_t *data;
uint64_t state = 0;
for (i = 0; i < n_mix; i++) { for (i = 0; i < n_mix; i++) {
struct mix_info *m = mix[i]; struct mix_info *m = mix[i];
@ -1664,34 +1664,36 @@ static void convert_to_event(struct mix_info **mix, uint32_t n_mix, void *midi,
} }
case SPA_CONTROL_UMP: case SPA_CONTROL_UMP:
{ {
uint8_t ev[32];
bool was_sysex = in_sysex;
if (type == TYPE_ID_MIDI) { if (type == TYPE_ID_MIDI) {
uint32_t *d = (uint32_t*)data; uint8_t ev[32];
int ev_size = spa_ump_to_midi(d, size, ev, sizeof(ev)); const uint32_t *d = (uint32_t*)data;
if (ev_size <= 0)
break;
size = ev_size; while (size > 0) {
data = ev; bool was_sysex = in_sysex;
int ev_size = spa_ump_to_midi(&d, &size, ev, sizeof(ev), &state);
if (ev_size <= 0)
break;
if (!in_sysex && ev[0] == 0xf0) if (!in_sysex && ev[0] == 0xf0)
in_sysex = true; in_sysex = true;
if (in_sysex && ev[ev_size-1] == 0xf7) if (in_sysex && ev[ev_size-1] == 0xf7)
in_sysex = false; in_sysex = false;
} else if (type != TYPE_ID_UMP) if (was_sysex)
break; res = midi_event_append(midi, ev, ev_size);
else
res = midi_event_write(midi, control->offset, ev, ev_size, fix);
if (res < 0)
break;
if (was_sysex) }
res = midi_event_append(midi, data, size); } else if (type == TYPE_ID_UMP) {
else
res = midi_event_write(midi, control->offset, data, size, fix); res = midi_event_write(midi, control->offset, data, size, fix);
}
if (res < 0) if (res < 0)
pw_log_warn("midi %p: can't write event: %s", midi, pw_log_warn("midi %p: can't write event: %s", midi,
spa_strerror(res)); spa_strerror(res));
break;
} }
} }
if (spa_pod_parser_get_control_body(&next->parser, if (spa_pod_parser_get_control_body(&next->parser,

80
spa/include/spa/control/ump-utils.h
View file

@ -48,72 +48,98 @@ SPA_API_CONTROL_UMP_UTILS size_t spa_ump_message_size(uint8_t message_type)
return ump_sizes[message_type & 0xf]; return ump_sizes[message_type & 0xf];
} }
SPA_API_CONTROL_UMP_UTILS int spa_ump_to_midi(const uint32_t *ump, size_t ump_size, SPA_API_CONTROL_UMP_UTILS int spa_ump_to_midi(const uint32_t **ump, size_t *ump_size,
uint8_t *midi, size_t midi_maxsize) uint8_t *midi, size_t midi_maxsize, uint64_t *state)
{ {
int size = 0; int size = 0;
uint32_t to_consume = 0;
const uint32_t *u = *ump;
if (ump_size < 4) if (*ump_size < 4 ||
return 0; (to_consume = (spa_ump_message_size(u[0]>>28) * 4)) > *ump_size) {
to_consume = *ump_size;
goto done;
}
if (midi_maxsize < 8) if (midi_maxsize < 8)
return -ENOSPC; return -ENOSPC;
switch (ump[0] >> 28) { switch (u[0] >> 28) {
case 0x1: /* System Real Time and System Common Messages (except System Exclusive) */ case 0x1: /* System Real Time and System Common Messages (except System Exclusive) */
midi[size++] = (ump[0] >> 16) & 0xff; midi[size++] = (u[0] >> 16) & 0xff;
if (midi[0] >= 0xf1 && midi[0] <= 0xf3) { if (midi[0] >= 0xf1 && midi[0] <= 0xf3) {
midi[size++] = (ump[0] >> 8) & 0x7f; midi[size++] = (u[0] >> 8) & 0x7f;
if (midi[0] == 0xf2) if (midi[0] == 0xf2)
midi[size++] = ump[0] & 0x7f; midi[size++] = u[0] & 0x7f;
} }
break; break;
case 0x2: /* MIDI 1.0 Channel Voice Messages */ case 0x2: /* MIDI 1.0 Channel Voice Messages */
midi[size++] = (ump[0] >> 16); midi[size++] = (u[0] >> 16);
midi[size++] = (ump[0] >> 8); midi[size++] = (u[0] >> 8);
if (midi[0] < 0xc0 || midi[0] > 0xdf) if (midi[0] < 0xc0 || midi[0] > 0xdf)
midi[size++] = (ump[0]); midi[size++] = (u[0]);
break; break;
case 0x3: /* Data Messages (including System Exclusive) */ case 0x3: /* Data Messages (including System Exclusive) */
{ {
uint8_t status, i, bytes; uint8_t status, i, bytes;
if (ump_size < 8) status = (u[0] >> 20) & 0xf;
return 0; bytes = SPA_CLAMP((u[0] >> 16) & 0xf, 0u, 6u);
status = (ump[0] >> 20) & 0xf;
bytes = SPA_CLAMP((ump[0] >> 16) & 0xf, 0u, 6u);
if (status == 0 || status == 1) if (status == 0 || status == 1)
midi[size++] = 0xf0; midi[size++] = 0xf0;
for (i = 0 ; i < bytes; i++) for (i = 0 ; i < bytes; i++)
/* ump[0] >> 8 | ump[0] | ump[1] >> 24 | ump[1] >>16 ... */ /* u[0] >> 8 | u[0] | u[1] >> 24 | u[1] >>16 ... */
midi[size++] = ump[(i+2)/4] >> ((5-i)%4 * 8); midi[size++] = u[(i+2)/4] >> ((5-i)%4 * 8);
if (status == 0 || status == 3) if (status == 0 || status == 3)
midi[size++] = 0xf7; midi[size++] = 0xf7;
break; break;
} }
case 0x4: /* MIDI 2.0 Channel Voice Messages */ case 0x4: /* MIDI 2.0 Channel Voice Messages */
if (ump_size < 8) {
return 0; uint8_t status = (u[0] >> 16) | 0x80;
midi[size++] = (ump[0] >> 16) | 0x80; switch (status & 0xf0) {
switch (midi[0] & 0xf0) {
case 0xc0: case 0xc0:
midi[size++] = (ump[1] >> 24); /* program/bank change */
if (!(u[0] & 1))
*state = 2;
if (*state == 0) {
midi[size++] = (status & 0xf) | 0xb0;
midi[size++] = 0;
midi[size++] = (u[1] >> 8);
to_consume = 0;
*state = 1;
}
else if (*state == 1) {
midi[size++] = (status & 0xf) | 0xb0;
midi[size++] = 32;
midi[size++] = u[1];
to_consume = 0;
*state = 2;
}
else if (*state == 2) {
midi[size++] = status;
midi[size++] = (u[1] >> 24);
*state = 0;
}
break; break;
default: default:
midi[size++] = (ump[0] >> 8) & 0x7f; midi[size++] = status;
midi[size++] = (u[0] >> 8) & 0x7f;
SPA_FALLTHROUGH; SPA_FALLTHROUGH;
case 0xd0: case 0xd0:
midi[size++] = (ump[1] >> 25); midi[size++] = (u[1] >> 25);
break; break;
} }
break; break;
}
case 0x0: /* Utility Messages */ case 0x0: /* Utility Messages */
case 0x5: /* Data Messages */ case 0x5: /* Data Messages */
default: default:
return 0; break;
} }
done:
(*ump_size) -= to_consume;
(*ump) = SPA_PTROFF(*ump, to_consume, uint32_t);
return size; return size;
} }

53
spa/plugins/alsa/alsa-seq.c
View file

@ -880,34 +880,41 @@ static int process_write(struct seq_state *state)
snd_seq_event_t ev; snd_seq_event_t ev;
uint8_t data[MAX_EVENT_SIZE]; uint8_t data[MAX_EVENT_SIZE];
int size; int size;
uint64_t st = 0;
if ((size = spa_ump_to_midi((uint32_t *)body, body_size, data, sizeof(data))) <= 0) while (body_size > 0) {
continue; if ((size = spa_ump_to_midi((const uint32_t **)&body, &body_size,
data, sizeof(data), &st)) <= 0)
break;
if (first) if (first)
snd_seq_ev_clear(&ev); snd_seq_ev_clear(&ev);
if ((size = snd_midi_event_encode(stream->codec, data, size, &ev)) < 0) { if ((size = snd_midi_event_encode(stream->codec, data, size, &ev)) < 0) {
spa_log_warn(state->log, "failed to encode event: %s", snd_strerror(size)); spa_log_warn(state->log, "failed to encode event: %s",
snd_midi_event_reset_encode(stream->codec); snd_strerror(size));
snd_midi_event_reset_encode(stream->codec);
first = true;
continue;
}
first = false;
if (ev.type == SND_SEQ_EVENT_NONE)
/* this can happen when the event is not complete yet, like
* a sysex message and we need to encode some more data. */
continue;
snd_seq_ev_set_source(&ev, state->event.addr.port);
snd_seq_ev_set_dest(&ev, port->addr.client, port->addr.port);
snd_seq_ev_schedule_real(&ev, state->event.queue_id, 0, &out_rt);
debug_event(state, "send", &ev);
if ((err = snd_seq_event_output(state->event.hndl, &ev)) < 0) {
spa_log_warn(state->log, "failed to output event: %s",
snd_strerror(err));
}
first = true; first = true;
continue;
} }
first = false;
if (ev.type == SND_SEQ_EVENT_NONE)
/* this can happen when the event is not complete yet, like
* a sysex message and we need to encode some more data. */
continue;
snd_seq_ev_set_source(&ev, state->event.addr.port);
snd_seq_ev_set_dest(&ev, port->addr.client, port->addr.port);
snd_seq_ev_schedule_real(&ev, state->event.queue_id, 0, &out_rt);
if ((err = snd_seq_event_output(state->event.hndl, &ev)) < 0) {
spa_log_warn(state->log, "failed to output event: %s",
snd_strerror(err));
}
first = true;
} }
} }
} }

16
spa/plugins/audioconvert/audioconvert.c
View file

@ -1824,18 +1824,20 @@ static int apply_props(struct impl *this, const struct spa_pod *param)
static int apply_midi(struct impl *this, const struct spa_pod *value) static int apply_midi(struct impl *this, const struct spa_pod *value)
{ {
struct props *p = &this->props; struct props *p = &this->props;
uint8_t data[8]; uint8_t ev[8];
int size; int ev_size;
const uint32_t *body = SPA_POD_BODY_CONST(value);
size_t size = SPA_POD_BODY_SIZE(value);
uint64_t state = 0;
size = spa_ump_to_midi(SPA_POD_BODY(value), SPA_POD_BODY_SIZE(value), ev_size = spa_ump_to_midi(&body, &size, ev, sizeof(ev), &state);
data, sizeof(data)); if (ev_size < 3)
if (size < 3)
return -EINVAL; return -EINVAL;
if ((data[0] & 0xf0) != 0xb0 || data[1] != 7) if ((ev[0] & 0xf0) != 0xb0 || ev[1] != 7)
return 0; return 0;
p->volume = data[2] / 127.0f; p->volume = ev[2] / 127.0f;
set_volume(this); set_volume(this);
return 1; return 1;
} }

37
spa/plugins/bluez5/midi-node.c
View file

@ -788,30 +788,35 @@ static int write_data(struct impl *this, struct spa_data *d)
while (spa_pod_parser_get_control_body(&parser, &c, &c_body) >= 0) { while (spa_pod_parser_get_control_body(&parser, &c, &c_body) >= 0) {
int size; int size;
uint8_t event[32]; uint8_t event[32];
const uint32_t *ump = c_body;
size_t ump_size = c.value.size;
uint64_t state = 0;
if (c.type != SPA_CONTROL_UMP) if (c.type != SPA_CONTROL_UMP)
continue; continue;
time = SPA_MAX(time, this->current_time + c.offset * SPA_NSEC_PER_SEC / this->rate); time = SPA_MAX(time, this->current_time + c.offset * SPA_NSEC_PER_SEC / this->rate);
size = spa_ump_to_midi(c_body, c.value.size, event, sizeof(event)); while (ump_size > 0) {
if (size <= 0) size = spa_ump_to_midi(&ump, &ump_size, event, sizeof(event), &state);
continue; if (size <= 0)
break;
spa_log_trace(this->log, "%p: output event:0x%x time:%"PRIu64, this, spa_log_trace(this->log, "%p: output event:0x%x time:%"PRIu64, this,
(size > 0) ? event[0] : 0, time); (size > 0) ? event[0] : 0, time);
do { do {
res = spa_bt_midi_writer_write(&this->writer, res = spa_bt_midi_writer_write(&this->writer,
time, event, size); time, event, size);
if (res < 0) { if (res < 0) {
return res; return res;
} else if (res) { } else if (res) {
int res2; int res2;
if ((res2 = flush_packet(this)) < 0) if ((res2 = flush_packet(this)) < 0)
return res2; return res2;
} }
} while (res); } while (res);
}
} }
if ((res = flush_packet(this)) < 0) if ((res = flush_packet(this)) < 0)

14
spa/plugins/control/mixer.c
View file

@ -826,11 +826,15 @@ static int impl_node_process(void *object)
case SPA_CONTROL_UMP: case SPA_CONTROL_UMP:
{ {
uint8_t ev[8]; uint8_t ev[8];
int ev_size = spa_ump_to_midi((uint32_t*)body, size, ev, sizeof(ev)); const uint32_t *ump = (const uint32_t*)body;
if (ev_size <= 0) uint64_t state = 0;
break; while (size > 0) {
spa_pod_builder_control(&builder, control->offset, SPA_CONTROL_Midi); int ev_size = spa_ump_to_midi(&ump, &size, ev, sizeof(ev), &state);
spa_pod_builder_bytes(&builder, ev, ev_size); if (ev_size <= 0)
break;
spa_pod_builder_control(&builder, control->offset, SPA_CONTROL_Midi);
spa_pod_builder_bytes(&builder, ev, ev_size);
}
break; break;
} }
} }

31
src/modules/module-ffado-driver.c
View file

@ -345,27 +345,32 @@ static void midi_to_ffado(struct port *p, float *src, uint32_t n_samples)
while (spa_pod_parser_get_control_body(&parser, &c, &c_body) >= 0) { while (spa_pod_parser_get_control_body(&parser, &c, &c_body) >= 0) {
uint8_t data[16]; uint8_t data[16];
int j, size; int j, size;
size_t c_size = c.value.size;
uint64_t state = 0;
if (c.type != SPA_CONTROL_UMP) if (c.type != SPA_CONTROL_UMP)
continue; continue;
size = spa_ump_to_midi(c_body, c.value.size, data, sizeof(data));
if (size <= 0)
continue;
if (index < c.offset) if (index < c.offset)
index = SPA_ROUND_UP_N(c.offset, 8); index = SPA_ROUND_UP_N(c.offset, 8);
for (j = 0; j < size; j++) {
if (index >= n_samples) { while (c_size > 0) {
/* keep events that don't fit for the next cycle */ size = spa_ump_to_midi((const uint32_t**)&c_body, &c_size, data, sizeof(data), &state);
if (p->event_pos < sizeof(p->event_buffer)) if (size <= 0)
p->event_buffer[p->event_pos++] = data[j]; break;
for (j = 0; j < size; j++) {
if (index >= n_samples) {
/* keep events that don't fit for the next cycle */
if (p->event_pos < sizeof(p->event_buffer))
p->event_buffer[p->event_pos++] = data[j];
else
unhandled++;
}
else else
unhandled++; dst[index] = 0x01000000 | (uint32_t) data[j];
index += 8;
} }
else
dst[index] = 0x01000000 | (uint32_t) data[j];
index += 8;
} }
} }
if (unhandled > 0) if (unhandled > 0)

35
src/modules/module-jack-tunnel.c
View file

@ -273,29 +273,34 @@ static void midi_to_jack(struct impl *impl, float *dst, float *src, uint32_t n_s
while (spa_pod_parser_get_control_body(&parser, &c, &c_body) >= 0) { while (spa_pod_parser_get_control_body(&parser, &c, &c_body) >= 0) {
int size; int size;
size_t c_size = c.value.size;
uint64_t state = 0;
if (c.type != SPA_CONTROL_UMP) if (c.type != SPA_CONTROL_UMP)
continue; continue;
size = spa_ump_to_midi(c_body, c.value.size, &tmp[tmp_size], sizeof(tmp) - tmp_size); while (c_size > 0) {
if (size <= 0) size = spa_ump_to_midi((const uint32_t**)&c_body, &c_size,
continue; &tmp[tmp_size], sizeof(tmp) - tmp_size, &state);
if (size <= 0)
break;
if (impl->fix_midi) if (impl->fix_midi)
fix_midi_event(&tmp[tmp_size], size); fix_midi_event(&tmp[tmp_size], size);
if (!in_sysex && tmp[tmp_size] == 0xf0) if (!in_sysex && tmp[tmp_size] == 0xf0)
in_sysex = true; in_sysex = true;
tmp_size += size; tmp_size += size;
if (in_sysex && tmp[tmp_size-1] == 0xf7) if (in_sysex && tmp[tmp_size-1] == 0xf7)
in_sysex = false; in_sysex = false;
if (!in_sysex) { if (!in_sysex) {
if ((res = jack.midi_event_write(dst, c.offset, tmp, tmp_size)) < 0) if ((res = jack.midi_event_write(dst, c.offset, tmp, tmp_size)) < 0)
pw_log_warn("midi %p: can't write event: %s", dst, pw_log_warn("midi %p: can't write event: %s", dst,
spa_strerror(res)); spa_strerror(res));
tmp_size = 0; tmp_size = 0;
}
} }
} }
} }

44
src/modules/module-netjack2/peer.c
View file

@ -333,32 +333,36 @@ static void midi_to_netjack2(struct netjack2_peer *peer,
int size; int size;
uint8_t data[16]; uint8_t data[16];
bool was_sysex = in_sysex; bool was_sysex = in_sysex;
size_t c_size = c.value.size;
uint64_t state = 0;
if (c.type != SPA_CONTROL_UMP) if (c.type != SPA_CONTROL_UMP)
continue; continue;
size = spa_ump_to_midi(c_body, c.value.size, data, sizeof(data)); while (c_size > 0) {
if (size <= 0) size = spa_ump_to_midi((const uint32_t**)&c_body, &c_size, data, sizeof(data), &state);
continue; if (size <= 0)
break;
if (c.offset >= n_samples) { if (c.offset >= n_samples) {
buf->lost_events++; buf->lost_events++;
continue; continue;
}
if (!in_sysex && data[0] == 0xf0)
in_sysex = true;
if (!in_sysex && peer->fix_midi)
fix_midi_event(data, size);
if (in_sysex && data[size-1] == 0xf7)
in_sysex = false;
if (was_sysex)
n2j_midi_buffer_append(buf, data, size);
else
n2j_midi_buffer_write(buf, c.offset, data, size);
} }
if (!in_sysex && data[0] == 0xf0)
in_sysex = true;
if (!in_sysex && peer->fix_midi)
fix_midi_event(data, size);
if (in_sysex && data[size-1] == 0xf7)
in_sysex = false;
if (was_sysex)
n2j_midi_buffer_append(buf, data, size);
else
n2j_midi_buffer_write(buf, c.offset, data, size);
} }
if (buf->write_pos > 0) if (buf->write_pos > 0)
memmove(SPA_PTROFF(buf, sizeof(*buf) + buf->event_count * sizeof(struct nj2_midi_event), void), memmove(SPA_PTROFF(buf, sizeof(*buf) + buf->event_count * sizeof(struct nj2_midi_event), void),

90
src/modules/module-rtp/midi.c
View file

@ -437,57 +437,61 @@ static void rtp_midi_flush_packets(struct impl *impl,
while (spa_pod_parser_get_control_body(parser, &c, &c_body) >= 0) { while (spa_pod_parser_get_control_body(parser, &c, &c_body) >= 0) {
uint32_t delta, offset; uint32_t delta, offset;
uint8_t event[16]; uint8_t event[16];
size_t size; int size;
size_t c_size = c.value.size;
uint64_t state = 0;
if (c.type != SPA_CONTROL_UMP) if (c.type != SPA_CONTROL_UMP)
continue; continue;
size = spa_ump_to_midi(c_body, c.value.size, event, sizeof(event)); while (c_size > 0) {
if (size <= 0) size = spa_ump_to_midi((const uint32_t **)&c_body, &c_size, event, sizeof(event), &state);
continue; if (size <= 0)
break;
offset = c.offset * impl->rate / rate; offset = c.offset * impl->rate / rate;
if (len > 0 && (len + size > max_size || if (len > 0 && (len + size > max_size ||
offset - base > impl->psamples)) { offset - base > impl->psamples)) {
/* flush packet when we have one and when it's either /* flush packet when we have one and when it's either
* too large or has too much data. */ * too large or has too much data. */
if (len < 16) { if (len < 16) {
midi_header.b = 0; midi_header.b = 0;
midi_header.len = len; midi_header.len = len;
iov[1].iov_len = sizeof(midi_header) - 1; iov[1].iov_len = sizeof(midi_header) - 1;
} else { } else {
midi_header.b = 1; midi_header.b = 1;
midi_header.len = (len >> 8) & 0xf; midi_header.len = (len >> 8) & 0xf;
midi_header.len_b = len & 0xff; midi_header.len_b = len & 0xff;
iov[1].iov_len = sizeof(midi_header); iov[1].iov_len = sizeof(midi_header);
}
iov[2].iov_len = len;
pw_log_trace("sending %d timestamp:%d %u %u",
len, timestamp + base,
offset, impl->psamples);
rtp_stream_emit_send_packet(impl, iov, 3);
impl->seq++;
len = 0;
} }
iov[2].iov_len = len; if ((unsigned int)size > BUFFER_SIZE || len > BUFFER_SIZE - size) {
pw_log_error("Buffer overflow prevented!");
return; // FIXME: what to do instead?
}
if (len == 0) {
/* start new packet */
base = prev_offset = offset;
header.sequence_number = htons(impl->seq);
header.timestamp = htonl(impl->ts_offset + timestamp + base);
pw_log_trace("sending %d timestamp:%d %u %u", memcpy(&impl->buffer[len], event, size);
len, timestamp + base, len += size;
offset, impl->psamples); } else {
rtp_stream_emit_send_packet(impl, iov, 3); delta = offset - prev_offset;
prev_offset = offset;
impl->seq++; len += write_event(&impl->buffer[len], BUFFER_SIZE - len, delta, event, size);
len = 0; }
}
if (size > BUFFER_SIZE || len > BUFFER_SIZE - size) {
pw_log_error("Buffer overflow prevented!");
return; // FIXME: what to do instead?
}
if (len == 0) {
/* start new packet */
base = prev_offset = offset;
header.sequence_number = htons(impl->seq);
header.timestamp = htonl(impl->ts_offset + timestamp + base);
memcpy(&impl->buffer[len], event, size);
len += size;
} else {
delta = offset - prev_offset;
prev_offset = offset;
len += write_event(&impl->buffer[len], BUFFER_SIZE - len, delta, event, size);
} }
} }
if (len > 0) { if (len > 0) {

33
src/modules/module-vban/midi.c
View file

@ -239,27 +239,32 @@ static void vban_midi_flush_packets(struct impl *impl,
while (spa_pod_parser_get_control_body(parser, &c, &c_body) >= 0) { while (spa_pod_parser_get_control_body(parser, &c, &c_body) >= 0) {
int size; int size;
uint8_t event[16]; uint8_t event[16];
uint64_t state = 0;
size_t c_size = c.value.size;
if (c.type != SPA_CONTROL_UMP) if (c.type != SPA_CONTROL_UMP)
continue; continue;
size = spa_ump_to_midi(c_body, c.value.size, event, sizeof(event)); while (c_size > 0) {
if (size <= 0) size = spa_ump_to_midi((const uint32_t**)&c_body,
continue; &c_size, event, sizeof(event), &state);
if (size <= 0)
break;
if (len == 0) { if (len == 0) {
/* start new packet */ /* start new packet */
header.n_frames++; header.n_frames++;
} else if (len + size > impl->mtu) { } else if (len + size > impl->mtu) {
/* flush packet when we have one and when it's too large */ /* flush packet when we have one and when it's too large */
iov[1].iov_len = len; iov[1].iov_len = len;
pw_log_debug("sending %d", len); pw_log_debug("sending %d", len);
vban_stream_emit_send_packet(impl, iov, 2); vban_stream_emit_send_packet(impl, iov, 2);
len = 0; len = 0;
}
memcpy(&impl->buffer[len], event, size);
len += size;
} }
memcpy(&impl->buffer[len], event, size);
len += size;
} }
if (len > 0) { if (len > 0) {
/* flush last packet */ /* flush last packet */

47
src/tools/midifile.c
View file

@ -496,41 +496,46 @@ int midi_file_write_event(struct midi_file *mf, const struct midi_event *event)
{ {
struct midi_track *tr; struct midi_track *tr;
uint32_t tick; uint32_t tick;
void *data; void *data, *ev_data;
size_t size; size_t size;
int res; int res, ev_size;
uint8_t ev[32]; uint8_t ev[32];
uint64_t state = 0;
spa_return_val_if_fail(event != NULL, -EINVAL); spa_return_val_if_fail(event != NULL, -EINVAL);
spa_return_val_if_fail(mf != NULL, -EINVAL); spa_return_val_if_fail(mf != NULL, -EINVAL);
spa_return_val_if_fail(event->track == 0, -EINVAL); spa_return_val_if_fail(event->track == 0, -EINVAL);
spa_return_val_if_fail(event->size > 1, -EINVAL); spa_return_val_if_fail(event->size > 1, -EINVAL);
switch (event->type) { data = event->data;
case MIDI_EVENT_TYPE_MIDI1: size = event->size;
data = event->data;
size = event->size;
break;
case MIDI_EVENT_TYPE_UMP:
data = ev;
size = spa_ump_to_midi((uint32_t*)event->data, event->size, ev, sizeof(ev));
if (size == 0)
return 0;
break;
default:
return -EINVAL;
}
tr = &mf->tracks[event->track]; tr = &mf->tracks[event->track];
tick = (uint32_t)(event->sec * (1000000.0 * mf->info.division) / (double)mf->tempo); tick = (uint32_t)(event->sec * (1000000.0 * mf->info.division) / (double)mf->tempo);
CHECK_RES(write_varlen(mf, tr, tick - tr->tick)); while (size > 0) {
tr->tick = tick; switch (event->type) {
case MIDI_EVENT_TYPE_MIDI1:
ev_data = data;
ev_size = size;
size = 0;
break;
case MIDI_EVENT_TYPE_UMP:
ev_size = spa_ump_to_midi((const uint32_t**)&data, &size, ev, sizeof(ev), &state);
if (ev_size <= 0)
return ev_size;
ev_data = ev;
break;
default:
return -EINVAL;
}
CHECK_RES(write_n(mf->file, data, size)); CHECK_RES(write_varlen(mf, tr, tick - tr->tick));
tr->size += size; tr->tick = tick;
CHECK_RES(write_n(mf->file, ev_data, ev_size));
tr->size += ev_size;
}
return 0; return 0;
} }

13
test/test-spa-control.c
View file

@ -123,6 +123,7 @@ static int do_ump_to_midi_test(char *ump, char *midi)
size_t m_size, u_size, m_offs = 0; size_t m_size, u_size, m_offs = 0;
uint8_t *m_data = alloca(strlen(midi) / 2); uint8_t *m_data = alloca(strlen(midi) / 2);
uint32_t *u_data = alloca(strlen(ump) / 2); uint32_t *u_data = alloca(strlen(ump) / 2);
uint64_t state = 0;
u_size = parse_ump(ump, u_data, sizeof(u_data)); u_size = parse_ump(ump, u_data, sizeof(u_data));
m_size = parse_midi(midi, m_data, sizeof(m_data)); m_size = parse_midi(midi, m_data, sizeof(m_data));
@ -133,8 +134,9 @@ static int do_ump_to_midi_test(char *ump, char *midi)
while (u_size > 0) { while (u_size > 0) {
uint8_t midi[32]; uint8_t midi[32];
fprintf(stdout, "%zd %08x\n", u_size, *u_data); fprintf(stdout, "%zd %08x\n", u_size, *u_data);
int midi_size = spa_ump_to_midi(u_data, u_size,
midi, sizeof(midi)); int midi_size = spa_ump_to_midi((const uint32_t**)&u_data, &u_size,
midi, sizeof(midi), &state);
if (midi_size <= 0) if (midi_size <= 0)
return midi_size; return midi_size;
@ -145,8 +147,6 @@ static int do_ump_to_midi_test(char *ump, char *midi)
fprintf(stdout, "%08x %08x\n", m_data[m_offs], midi[i]); fprintf(stdout, "%08x %08x\n", m_data[m_offs], midi[i]);
spa_assert(m_data[m_offs++] == midi[i]); spa_assert(m_data[m_offs++] == midi[i]);
} }
u_size -= spa_ump_message_size(*u_data >> 28) * 4;
u_data += spa_ump_message_size(*u_data >> 28);
} }
return 0; return 0;
} }
@ -160,6 +160,11 @@ PWTEST(control_ump_to_midi)
spa_assert(do_ump_to_midi_test("30160102 03040506 30260708 09101112 30311300 00000000", spa_assert(do_ump_to_midi_test("30160102 03040506 30260708 09101112 30311300 00000000",
"f0 01 02 03 04 05 06 07 08 09 10 11 12 13 f7") >= 0); "f0 01 02 03 04 05 06 07 08 09 10 11 12 13 f7") >= 0);
spa_assert(do_ump_to_midi_test("40cf0000 11000000", "cf 11") >= 0);
spa_assert(do_ump_to_midi_test("40cf0001 11002233", "bf 00 22 bf 20 33 cf 11") >= 0);
return PWTEST_PASS; return PWTEST_PASS;
} }