From 5a5c2953ea15ad10027619b0609d8873e4e66bbe Mon Sep 17 00:00:00 2001 From: Jaroslav Kysela Date: Tue, 24 Aug 2021 11:36:30 +0200 Subject: [PATCH] rawmidi: define more abstract API for the timestamp reads The frame structure is a bit internal thing for the kernel data transfer implementation. Introduce snd_rawmidi_tread() function which is straight for the application usage and hides the framing data transfers (kernel space API). The current code implements the read cache and does the merging of the frame reads with the similar timestamps (opposite to the kernel data split for big chunks). If the application wants to use super-duper-lighting-fast reads, the snd_rawmidi_read() may be used, but the structure must be defined on it's own, because this mechanism is not preferred and unsupported. BugLink: https://github.com/alsa-project/alsa-lib/issues/172 Signed-off-by: Jaroslav Kysela --- include/rawmidi.h | 21 +------ src/rawmidi/rawmidi.c | 19 +++++++ src/rawmidi/rawmidi_hw.c | 106 ++++++++++++++++++++++++++++++++++++ src/rawmidi/rawmidi_local.h | 1 + test/rawmidi.c | 34 ++++++------ 5 files changed, 144 insertions(+), 37 deletions(-) diff --git a/include/rawmidi.h b/include/rawmidi.h index 5866d133..5f44d3d9 100644 --- a/include/rawmidi.h +++ b/include/rawmidi.h @@ -93,26 +93,6 @@ typedef enum _snd_rawmidi_framing { SND_RAWMIDI_FRAMING_TSTAMP = 1, } snd_rawmidi_framing_t; -#define SND_RAWMIDI_FRAME_TYPE_DEFAULT 0 - -#define SND_RAWMIDI_FRAMING_DATA_LENGTH 16 - -/** Incoming RawMidi bytes is put inside this container if tstamp type framing is enabled. */ -struct _snd_rawmidi_framing_tstamp { - /** - * For now, frame_type is always SND_RAWMIDI_FRAME_TYPE_DEFAULT. - * Midi 2.0 is expected to add new types here. - * Applications are expected to skip unknown frame types. - */ - uint8_t frame_type; - uint8_t length; /* number of valid bytes in data field */ - uint8_t reserved[2]; - uint32_t tv_nsec; /* nanoseconds */ - uint64_t tv_sec; /* seconds */ - uint8_t data[SND_RAWMIDI_FRAMING_DATA_LENGTH]; -} __attribute__((packed)); -typedef struct _snd_rawmidi_framing_tstamp snd_rawmidi_framing_tstamp_t; - int snd_rawmidi_open(snd_rawmidi_t **in_rmidi, snd_rawmidi_t **out_rmidi, const char *name, int mode); int snd_rawmidi_open_lconf(snd_rawmidi_t **in_rmidi, snd_rawmidi_t **out_rmidi, @@ -184,6 +164,7 @@ int snd_rawmidi_drain(snd_rawmidi_t *rmidi); int snd_rawmidi_drop(snd_rawmidi_t *rmidi); ssize_t snd_rawmidi_write(snd_rawmidi_t *rmidi, const void *buffer, size_t size); ssize_t snd_rawmidi_read(snd_rawmidi_t *rmidi, void *buffer, size_t size); +ssize_t snd_rawmidi_tread(snd_rawmidi_t *rmidi, struct timespec *tstamp, void *buffer, size_t size); const char *snd_rawmidi_name(snd_rawmidi_t *rmidi); snd_rawmidi_type_t snd_rawmidi_type(snd_rawmidi_t *rmidi); snd_rawmidi_stream_t snd_rawmidi_stream(snd_rawmidi_t *rawmidi); diff --git a/src/rawmidi/rawmidi.c b/src/rawmidi/rawmidi.c index 43619a14..bbb025e3 100644 --- a/src/rawmidi/rawmidi.c +++ b/src/rawmidi/rawmidi.c @@ -1071,11 +1071,30 @@ ssize_t snd_rawmidi_write(snd_rawmidi_t *rawmidi, const void *buffer, size_t siz * \param rawmidi RawMidi handle * \param buffer buffer to store the input MIDI bytes * \param size input buffer size in bytes + * \retval count of MIDI bytes otherwise a negative error code */ ssize_t snd_rawmidi_read(snd_rawmidi_t *rawmidi, void *buffer, size_t size) { assert(rawmidi); assert(rawmidi->stream == SND_RAWMIDI_STREAM_INPUT); + if ((rawmidi->params_mode & SNDRV_RAWMIDI_MODE_FRAMING_MASK) == SNDRV_RAWMIDI_MODE_FRAMING_TSTAMP) + size &= ~(sizeof(struct snd_rawmidi_framing_tstamp) - 1); assert(buffer || size == 0); return (rawmidi->ops->read)(rawmidi, buffer, size); } + +/** + * \brief read MIDI bytes from MIDI stream with timestamp + * \param rawmidi RawMidi handle + * \param[out] tstamp timestamp for the returned MIDI bytes + * \param buffer buffer to store the input MIDI bytes + * \param size input buffer size in bytes + * \retval count of MIDI bytes otherwise a negative error code + */ +ssize_t snd_rawmidi_tread(snd_rawmidi_t *rawmidi, struct timespec *tstamp, void *buffer, size_t size) +{ + assert(rawmidi); + assert(rawmidi->stream == SND_RAWMIDI_STREAM_INPUT); + assert(buffer || size == 0); + return (rawmidi->ops->tread)(rawmidi, tstamp, buffer, size); +} diff --git a/src/rawmidi/rawmidi_hw.c b/src/rawmidi/rawmidi_hw.c index 6bfbc1f3..c6afec10 100644 --- a/src/rawmidi/rawmidi_hw.c +++ b/src/rawmidi/rawmidi_hw.c @@ -42,9 +42,21 @@ typedef struct { int open; int fd; int card, device, subdevice; + unsigned char *buf; + size_t buf_size; /* total buffer size in bytes */ + size_t buf_fill; /* filled buffer size in bytes */ + size_t buf_pos; /* offset to frame in the read buffer (bytes) */ + size_t buf_fpos; /* offset to the frame data array (bytes 0-16) */ } snd_rawmidi_hw_t; #endif +static void buf_reset(snd_rawmidi_hw_t *hw) +{ + hw->buf_fill = 0; + hw->buf_pos = 0; + hw->buf_fpos = 0; +} + static int snd_rawmidi_hw_close(snd_rawmidi_t *rmidi) { snd_rawmidi_hw_t *hw = rmidi->private_data; @@ -57,6 +69,7 @@ static int snd_rawmidi_hw_close(snd_rawmidi_t *rmidi) err = -errno; SYSERR("close failed\n"); } + free(hw->buf); free(hw); return err; } @@ -100,6 +113,7 @@ static int snd_rawmidi_hw_params(snd_rawmidi_t *rmidi, snd_rawmidi_params_t * pa SYSERR("SNDRV_RAWMIDI_IOCTL_PARAMS failed"); return -errno; } + buf_reset(hw); return 0; } @@ -122,6 +136,7 @@ static int snd_rawmidi_hw_drop(snd_rawmidi_t *rmidi) SYSERR("SNDRV_RAWMIDI_IOCTL_DROP failed"); return -errno; } + buf_reset(hw); return 0; } @@ -156,6 +171,96 @@ static ssize_t snd_rawmidi_hw_read(snd_rawmidi_t *rmidi, void *buffer, size_t si return result; } +static ssize_t read_from_ts_buf(snd_rawmidi_hw_t *hw, struct timespec *tstamp, + void *buffer, size_t size) +{ + struct snd_rawmidi_framing_tstamp *f; + size_t flen; + ssize_t result = 0; + + f = (struct snd_rawmidi_framing_tstamp *)(hw->buf + hw->buf_pos); + while (hw->buf_fill >= sizeof(*f)) { + if (f->frame_type == 0) { + tstamp->tv_sec = f->tv_sec; + tstamp->tv_nsec = f->tv_nsec; + break; + } + hw->buf_pos += sizeof(*f); + hw->buf_fill -= sizeof(*f); + f++; + } + while (size > 0 && hw->buf_fill >= sizeof(*f)) { + /* skip other frames */ + if (f->frame_type != 0) + goto __next; + if (f->length == 0 || f->length > SNDRV_RAWMIDI_FRAMING_DATA_LENGTH) + return -EINVAL; + if (tstamp->tv_sec != (time_t)f->tv_sec || + tstamp->tv_nsec != f->tv_nsec) + break; + flen = f->length - hw->buf_fpos; + if (size < flen) { + /* partial copy */ + memcpy(buffer, f->data + hw->buf_fpos, size); + hw->buf_fpos += size; + result += size; + break; + } + memcpy(buffer, f->data + hw->buf_fpos, flen); + hw->buf_fpos = 0; + buffer += flen; + size -= flen; + result += flen; + __next: + hw->buf_pos += sizeof(*f); + hw->buf_fill -= sizeof(*f); + f++; + } + return result; +} + +static ssize_t snd_rawmidi_hw_tread(snd_rawmidi_t *rmidi, struct timespec *tstamp, + void *buffer, size_t size) +{ + snd_rawmidi_hw_t *hw = rmidi->private_data; + ssize_t result = 0, ret; + size_t alloc_size; + + /* no timestamp */ + tstamp->tv_sec = tstamp->tv_nsec = 0; + + /* copy buffered frames */ + if (hw->buf_fill > 0) { + result = read_from_ts_buf(hw, tstamp, buffer, size); + if (result < 0 || size == (size_t)result || + hw->buf_fill >= sizeof(struct snd_rawmidi_framing_tstamp)) + return result; + buffer += result; + size -= result; + } + + alloc_size = page_align(size * 2); /* keep room for the frame meta data */ + if (alloc_size > hw->buf_size) { + void *buf = realloc(hw->buf, alloc_size); + if (buf == NULL) + return result > 0 ? result : -ENOMEM; + hw->buf = buf; + hw->buf_size = alloc_size; + } + + buf_reset(hw); + ret = read(hw->fd, hw->buf, hw->buf_size); + if (ret < 0) + return result > 0 ? result : -errno; + if (ret < (ssize_t)sizeof(struct snd_rawmidi_framing_tstamp)) + return result; + hw->buf_fill = ret; + ret = read_from_ts_buf(hw, tstamp, buffer, size); + if (ret < 0 && result > 0) + return result; + return ret + result; +} + static const snd_rawmidi_ops_t snd_rawmidi_hw_ops = { .close = snd_rawmidi_hw_close, .nonblock = snd_rawmidi_hw_nonblock, @@ -166,6 +271,7 @@ static const snd_rawmidi_ops_t snd_rawmidi_hw_ops = { .drain = snd_rawmidi_hw_drain, .write = snd_rawmidi_hw_write, .read = snd_rawmidi_hw_read, + .tread = snd_rawmidi_hw_tread }; diff --git a/src/rawmidi/rawmidi_local.h b/src/rawmidi/rawmidi_local.h index c4068d7c..4a88e7e4 100644 --- a/src/rawmidi/rawmidi_local.h +++ b/src/rawmidi/rawmidi_local.h @@ -34,6 +34,7 @@ typedef struct { int (*drain)(snd_rawmidi_t *rawmidi); ssize_t (*write)(snd_rawmidi_t *rawmidi, const void *buffer, size_t size); ssize_t (*read)(snd_rawmidi_t *rawmidi, void *buffer, size_t size); + ssize_t (*tread)(snd_rawmidi_t *rawmidi, struct timespec *tstamp, void *buffer, size_t size); } snd_rawmidi_ops_t; struct _snd_rawmidi { diff --git a/test/rawmidi.c b/test/rawmidi.c index 1090d44b..357abbe4 100644 --- a/test/rawmidi.c +++ b/test/rawmidi.c @@ -179,27 +179,27 @@ int main(int argc,char** argv) } if (handle_in) { - unsigned char ch; - snd_rawmidi_framing_tstamp_t frame; + unsigned char buf[1024]; + ssize_t ret; while (!stop) { if (clock_type != -1) { - snd_rawmidi_read(handle_in, &frame, sizeof(frame)); - if (verbose) { - int i; - if (frame.frame_type) { - fprintf(stderr, "read unknown frame %d", frame.frame_type); - continue; - } - fprintf(stderr, "read [%lld:%09d]", frame.tv_sec, frame.tv_nsec); - for (i = 0; i < frame.length; i++) - fprintf(stderr, " %02x", frame.data[i]); + struct timespec tstamp; + ret = snd_rawmidi_tread(handle_in, &tstamp, buf, sizeof(buf)); + if (ret < 0) + fprintf(stderr, "read timestamp error: %d - %s\n", (int)ret, snd_strerror(ret)); + if (ret > 0 && verbose) { + fprintf(stderr, "read [%lld:%09lld]", (long long)tstamp.tv_sec, (long long)tstamp.tv_nsec); + for (i = 0; i < ret; i++) + fprintf(stderr, " %02x", buf[i]); fprintf(stderr, "\n"); } - } - else { - snd_rawmidi_read(handle_in,&ch,1); - if (verbose) - fprintf(stderr,"read %02x\n",ch); + } else { + ret = snd_rawmidi_read(handle_in, buf, sizeof(buf)); + if (ret < 0) + fprintf(stderr, "read error: %d - %s\n", (int)ret, snd_strerror(ret)); + if (ret > 0 && verbose) + for (i = 0; i < ret; i++) + fprintf(stderr,"read %02x\n",buf[i]); } } } -- 2.47.3