}
memset(track, 0, sizeof(smf_track_t));
- track->next_event_number = -1;
+ track->next_event_number = 0;
track->events_array = g_ptr_array_new();
assert(track->events_array);
void
smf_track_remove_from_smf(smf_track_t *track)
{
- int i, j;
+ int i;
+ size_t j;
smf_track_t *tmp;
smf_event_t *ev;
* \return Event containing MIDI data or NULL.
*/
smf_event_t *
-smf_event_new_from_pointer(void *midi_data, int len)
+smf_event_new_from_pointer(void *midi_data, size_t len)
{
smf_event_t *event;
smf_event_t *
smf_event_new_from_bytes(int first_byte, int second_byte, int third_byte)
{
- int len;
+ size_t len;
smf_event_t *event;
* An assumption here is that if there is an EOT event, it will be at the end of the track.
*/
static void
-remove_eot_if_before_pulses(smf_track_t *track, int pulses)
+remove_eot_if_before_pulses(smf_track_t *track, size_t pulses)
{
smf_event_t *event;
void
smf_track_add_event(smf_track_t *track, smf_event_t *event)
{
- int i, last_pulses = 0;
+ size_t i, last_pulses = 0;
assert(track->smf != NULL);
assert(event->track == NULL);
assert(event->delta_time_pulses == -1);
- assert(event->time_pulses >= 0);
assert(event->time_seconds >= 0.0);
remove_eot_if_before_pulses(track, event->time_pulses);
event->track_number = track->track_number;
if (track->number_of_events == 0) {
- assert(track->next_event_number == -1);
+ assert(track->next_event_number == 0);
track->next_event_number = 1;
}
* \return 0 if everything went ok, nonzero otherwise.
*/
int
-smf_track_add_eot_delta_pulses(smf_track_t *track, int delta)
+smf_track_add_eot_delta_pulses(smf_track_t *track, uint32_t delta)
{
smf_event_t *event;
}
int
-smf_track_add_eot_pulses(smf_track_t *track, int pulses)
+smf_track_add_eot_pulses(smf_track_t *track, size_t pulses)
{
smf_event_t *event, *last_event;
void
smf_event_remove_from_track(smf_event_t *event)
{
- int i, was_last;
+ size_t i;
+ int was_last;
smf_event_t *tmp;
smf_track_t *track;
g_ptr_array_remove(track->events_array, event);
if (track->number_of_events == 0)
- track->next_event_number = -1;
+ track->next_event_number = 0;
/* Renumber the rest of the events, so they are consecutively numbered. */
for (i = event->event_number; i <= track->number_of_events; i++) {
}
event->track = NULL;
- event->event_number = -1;
+ event->event_number = 0;
event->delta_time_pulses = -1;
- event->time_pulses = -1;
+ event->time_pulses = 0;
event->time_seconds = -1.0;
}
* \param ppqn New PPQN.
*/
int
-smf_set_ppqn(smf_t *smf, int ppqn)
+smf_set_ppqn(smf_t *smf, uint16_t ppqn)
{
- assert(ppqn > 0);
-
smf->ppqn = ppqn;
return (0);
smf_event_t *event, *next_event;
/* End of track? */
- if (track->next_event_number == -1)
+ if (track->next_event_number == 0)
return (NULL);
assert(track->next_event_number >= 1);
track->time_of_next_event = next_event->time_pulses;
track->next_event_number++;
} else {
- track->next_event_number = -1;
+ track->next_event_number = 0;
}
return (event);
smf_event_t *event;
/* End of track? */
- if (track->next_event_number == -1)
+ if (track->next_event_number == 0)
return (NULL);
assert(track->next_event_number >= 1);
* Events are numbered consecutively starting from one.
*/
smf_event_t *
-smf_track_get_event_by_number(const smf_track_t *track, int event_number)
+smf_track_get_event_by_number(const smf_track_t *track, size_t event_number)
{
smf_event_t *event;
smf_track_t *
smf_find_track_with_next_event(smf_t *smf)
{
- int i, min_time = 0;
+ int i;
+ size_t min_time = 0;
smf_track_t *track = NULL, *min_time_track = NULL;
/* Find track with event that should be played next. */
assert(track);
/* No more events in this track? */
- if (track->next_event_number == -1)
+ if (track->next_event_number == 0)
continue;
if (track->time_of_next_event < min_time || min_time_track == NULL) {
assert(event);
track->time_of_next_event = event->time_pulses;
} else {
- track->next_event_number = -1;
+ track->next_event_number = 0;
track->time_of_next_event = 0;
#if 0
g_warning("Warning: empty track.");
* smf_get_next_event will return first event that happens after the first ten pulses.
*/
int
-smf_seek_to_pulses(smf_t *smf, int pulses)
+smf_seek_to_pulses(smf_t *smf, size_t pulses)
{
smf_event_t *event;
- assert(pulses >= 0);
-
smf_rewind(smf);
#if 0
/**
* \return Length of SMF, in pulses.
*/
-int
+size_t
smf_get_length_pulses(const smf_t *smf)
{
- int pulses = 0, i;
+ int i;
+ size_t pulses;
for (i = 1; i <= smf->number_of_tracks; i++) {
smf_track_t *track;
smf_event_t *event;
- track = smf_get_track_by_number(smf, i);
+ track = smf_get_track_by_number(smf, i);
assert(track);
event = smf_track_get_last_event(track);
#endif
#include <stdio.h>
+#include <stdint.h>
#include <glib.h>
#if defined(__GNUC__) && __GNUC__ >= 4
int format;
/** These fields are extracted from "division" field of MThd header. Valid is _either_ ppqn or frames_per_second/resolution. */
- int ppqn;
+ uint16_t ppqn;
int frames_per_second;
int resolution;
int number_of_tracks;
/** These are private fields using only by loading and saving routines. */
FILE *stream;
void *file_buffer;
- int file_buffer_length;
- int next_chunk_offset;
+ size_t file_buffer_length;
+ size_t next_chunk_offset;
int expected_number_of_tracks;
/** Private, used by smf.c. */
/** Describes a single tempo or time signature change. */
struct smf_tempo_struct {
- int time_pulses;
+ size_t time_pulses;
double time_seconds;
int microseconds_per_quarter_note;
int numerator;
smf_t *smf;
int track_number;
- int number_of_events;
+ size_t number_of_events;
/** These are private fields using only by loading and saving routines. */
void *file_buffer;
- int file_buffer_length;
+ size_t file_buffer_length;
int last_status; /* Used for "running status". */
/** Private, used by smf.c. */
/** Offset into buffer, used in parse_next_event(). */
- int next_event_offset;
- int next_event_number;
+ size_t next_event_offset;
+ size_t next_event_number;
/** Absolute time of next event on events_queue. */
- int time_of_next_event;
+ size_t time_of_next_event;
GPtrArray *events_array;
};
smf_track_t *track;
/** Number of this event in the track. Events are numbered consecutively, starting from one. */
- int event_number;
+ size_t event_number;
/** Note that the time fields are invalid, if event is not attached to a track. */
/** Time, in pulses, since the previous event on this track. */
- int delta_time_pulses;
+ int32_t delta_time_pulses;
/** Time, in pulses, since the start of the song. */
- int time_pulses;
+ size_t time_pulses;
/** Time, in seconds, since the start of the song. */
double time_seconds;
int track_number;
/** Pointer to the buffer containing MIDI message. This is freed by smf_event_delete. */
- unsigned char *midi_buffer;
+ uint8_t *midi_buffer;
/** Length of the MIDI message in the buffer, in bytes. */
- int midi_buffer_length;
+ size_t midi_buffer_length;
};
typedef struct smf_event_struct smf_event_t;
void smf_delete(smf_t *smf);
int smf_set_format(smf_t *smf, int format) WARN_UNUSED_RESULT;
-int smf_set_ppqn(smf_t *smf, int format) WARN_UNUSED_RESULT;
+int smf_set_ppqn(smf_t *smf, uint16_t ppqn) WARN_UNUSED_RESULT;
char *smf_decode(const smf_t *smf) WARN_UNUSED_RESULT;
void smf_rewind(smf_t *smf);
int smf_seek_to_seconds(smf_t *smf, double seconds) WARN_UNUSED_RESULT;
-int smf_seek_to_pulses(smf_t *smf, int pulses) WARN_UNUSED_RESULT;
+int smf_seek_to_pulses(smf_t *smf, size_t pulses) WARN_UNUSED_RESULT;
int smf_seek_to_event(smf_t *smf, const smf_event_t *event) WARN_UNUSED_RESULT;
-int smf_get_length_pulses(const smf_t *smf) WARN_UNUSED_RESULT;
+size_t smf_get_length_pulses(const smf_t *smf) WARN_UNUSED_RESULT;
double smf_get_length_seconds(const smf_t *smf) WARN_UNUSED_RESULT;
int smf_event_is_last(const smf_event_t *event) WARN_UNUSED_RESULT;
void smf_track_delete(smf_track_t *track);
smf_event_t *smf_track_get_next_event(smf_track_t *track) WARN_UNUSED_RESULT;
-smf_event_t *smf_track_get_event_by_number(const smf_track_t *track, int event_number) WARN_UNUSED_RESULT;
+smf_event_t *smf_track_get_event_by_number(const smf_track_t *track, size_t event_number) WARN_UNUSED_RESULT;
smf_event_t *smf_track_get_last_event(const smf_track_t *track) WARN_UNUSED_RESULT;
-void smf_track_add_event_delta_pulses(smf_track_t *track, smf_event_t *event, int pulses);
-void smf_track_add_event_pulses(smf_track_t *track, smf_event_t *event, int pulses);
+void smf_track_add_event_delta_pulses(smf_track_t *track, smf_event_t *event, uint32_t delta);
+void smf_track_add_event_pulses(smf_track_t *track, smf_event_t *event, size_t pulses);
void smf_track_add_event_seconds(smf_track_t *track, smf_event_t *event, double seconds);
-int smf_track_add_eot_delta_pulses(smf_track_t *track, int delta) WARN_UNUSED_RESULT;
-int smf_track_add_eot_pulses(smf_track_t *track, int pulses) WARN_UNUSED_RESULT;
+int smf_track_add_eot_delta_pulses(smf_track_t *track, uint32_t delta) WARN_UNUSED_RESULT;
+int smf_track_add_eot_pulses(smf_track_t *track, size_t pulses) WARN_UNUSED_RESULT;
int smf_track_add_eot_seconds(smf_track_t *track, double seconds) WARN_UNUSED_RESULT;
void smf_event_remove_from_track(smf_event_t *event);
/* Routines for manipulating smf_event_t. */
smf_event_t *smf_event_new(void) WARN_UNUSED_RESULT;
-smf_event_t *smf_event_new_from_pointer(void *midi_data, int len) WARN_UNUSED_RESULT;
+smf_event_t *smf_event_new_from_pointer(void *midi_data, size_t len) WARN_UNUSED_RESULT;
smf_event_t *smf_event_new_from_bytes(int first_byte, int second_byte, int third_byte) WARN_UNUSED_RESULT;
smf_event_t *smf_event_new_textual(int type, const char *text);
void smf_event_delete(smf_event_t *event);
/* Routines for loading SMF files. */
smf_t *smf_load(const char *file_name) WARN_UNUSED_RESULT;
-smf_t *smf_load_from_memory(const void *buffer, const int buffer_length) WARN_UNUSED_RESULT;
+smf_t *smf_load_from_memory(const void *buffer, const size_t buffer_length) WARN_UNUSED_RESULT;
/* Routine for writing SMF files. */
int smf_save(smf_t *smf, const char *file_name) WARN_UNUSED_RESULT;
/* Routines for manipulating smf_tempo_t. */
-smf_tempo_t *smf_get_tempo_by_pulses(const smf_t *smf, int pulses) WARN_UNUSED_RESULT;
+smf_tempo_t *smf_get_tempo_by_pulses(const smf_t *smf, size_t pulses) WARN_UNUSED_RESULT;
smf_tempo_t *smf_get_tempo_by_seconds(const smf_t *smf, double seconds) WARN_UNUSED_RESULT;
-smf_tempo_t *smf_get_tempo_by_number(const smf_t *smf, int number) WARN_UNUSED_RESULT;
+smf_tempo_t *smf_get_tempo_by_number(const smf_t *smf, size_t number) WARN_UNUSED_RESULT;
smf_tempo_t *smf_get_last_tempo(const smf_t *smf) WARN_UNUSED_RESULT;
const char *smf_get_version(void) WARN_UNUSED_RESULT;
} else {
int i = (flats - 248) & 255;
- assert(i >= 0 && i < sizeof(minor_keys) / sizeof(*minor_keys));
- assert(i >= 0 && i < sizeof(major_keys) / sizeof(*major_keys));
+ assert(i >= 0 && (size_t)i < sizeof(minor_keys) / sizeof(*minor_keys));
+ assert(i >= 0 && (size_t)i < sizeof(major_keys) / sizeof(*major_keys));
if (isminor)
off += snprintf(buf + off, BUFFER_SIZE - off, "%s", minor_keys[i]);
break;
case 0x7F:
- off += snprintf(buf + off, BUFFER_SIZE - off, "Proprietary (aka Sequencer) Event, length %d",
+ off += snprintf(buf + off, BUFFER_SIZE - off, "Proprietary (aka Sequencer) Event, length %zu",
event->midi_buffer_length);
break;
assert(smf->file_buffer != NULL);
assert(smf->file_buffer_length > 0);
- assert(smf->next_chunk_offset >= 0);
if (smf->next_chunk_offset + sizeof(struct chunk_header_struct) >= smf->file_buffer_length) {
g_critical("SMF warning: no more chunks left.");
* Returns 0 iff everything went OK, different value in case of error.
*/
static int
-extract_vlq(const unsigned char *buf, const int buffer_length, int *value, int *len)
+extract_vlq(const unsigned char *buf, const size_t buffer_length, uint32_t *value, uint32_t *len)
{
- int val = 0;
+ uint32_t val = 0;
const unsigned char *c = buf;
- assert(buffer_length > 0);
-
for (;;) {
if (c >= buf + buffer_length) {
g_critical("End of buffer in extract_vlq().");
break;
};
+ assert(c >= buf);
*value = val;
*len = c - buf + 1;
* contains VLQ telling how many bytes it takes, "on the wire" format does not have
* this.
*/
-static int
-expected_sysex_length(const unsigned char status, const unsigned char *second_byte, const int buffer_length, int *consumed_bytes)
+static int32_t
+expected_sysex_length(const unsigned char status, const unsigned char *second_byte, const size_t buffer_length, int32_t *consumed_bytes)
{
- int sysex_length, len;
+ uint32_t sysex_length, len;
assert(status == 0xF0);
return (sysex_length + 1);
}
-static int
-expected_escaped_length(const unsigned char status, const unsigned char *second_byte, const int buffer_length, int *consumed_bytes)
+static int32_t
+expected_escaped_length(const unsigned char status, const unsigned char *second_byte, const size_t buffer_length, int32_t *consumed_bytes)
{
/* -1, because we do not want to account for 0x7F status. */
return (expected_sysex_length(status, second_byte, buffer_length, consumed_bytes) - 1);
* The "second_byte" points to the expected second byte of the MIDI message. "buffer_length" is the buffer
* length limit, counting from "second_byte". Returns value < 0 iff there was an error.
*/
-static int
-expected_message_length(unsigned char status, const unsigned char *second_byte, const int buffer_length)
+static int32_t
+expected_message_length(unsigned char status, const unsigned char *second_byte, const size_t buffer_length)
{
/* Make sure this really is a valid status byte. */
assert(is_status_byte(status));
/* We cannot use this routine for escaped events. */
assert(!is_escape_byte(status));
- /* Buffer length may be zero, for e.g. realtime messages. */
- assert(buffer_length >= 0);
-
/* Is this a metamessage? */
if (status == 0xFF) {
if (buffer_length < 2) {
}
static int
-extract_sysex_event(const unsigned char *buf, const int buffer_length, smf_event_t *event, int *len, int last_status)
+extract_sysex_event(const unsigned char *buf, const size_t buffer_length, smf_event_t *event, uint32_t *len, int last_status)
{
- int status, message_length, vlq_length;
+ int status;
+ int32_t vlq_length, message_length;
const unsigned char *c = buf;
status = *buf;
c += vlq_length;
- if (vlq_length + message_length >= buffer_length) {
+ if (vlq_length + (size_t)message_length >= buffer_length) {
g_critical("End of buffer in extract_sysex_event().");
return (-5);
}
}
static int
-extract_escaped_event(const unsigned char *buf, const int buffer_length, smf_event_t *event, int *len, int last_status)
+extract_escaped_event(const unsigned char *buf, const size_t buffer_length, smf_event_t *event, uint32_t *len, int last_status)
{
- int status, message_length, vlq_length;
+ int status;
+ int32_t message_length, vlq_length;
const unsigned char *c = buf;
status = *buf;
c += vlq_length;
- if (vlq_length + message_length >= buffer_length) {
+ if (vlq_length + (size_t)message_length >= buffer_length) {
g_critical("End of buffer in extract_escaped_event().");
return (-5);
}
* Returns 0 iff everything went OK, value < 0 in case of error.
*/
static int
-extract_midi_event(const unsigned char *buf, const int buffer_length, smf_event_t *event, int *len, int last_status)
+extract_midi_event(const unsigned char *buf, const size_t buffer_length, smf_event_t *event, uint32_t *len, int last_status)
{
- int status, message_length;
+ int status;
+ int32_t message_length;
const unsigned char *c = buf;
assert(buffer_length > 0);
if (message_length < 0)
return (-3);
- if (message_length - 1 > buffer_length - (c - buf)) {
+ if ((size_t)message_length > buffer_length - (c - buf) + 1) {
g_critical("End of buffer in extract_midi_event().");
return (-5);
}
static smf_event_t *
parse_next_event(smf_track_t *track)
{
- int time = 0, len, buffer_length;
+ uint32_t time = 0;
+ uint32_t len;
+ size_t buffer_length;
unsigned char *c, *start;
smf_event_t *event = smf_event_new();
* and makes ordinary, zero-terminated string from it. May return NULL if there was any problem.
*/
static char *
-make_string(const unsigned char *buf, const int buffer_length, int len)
+make_string(const unsigned char *buf, const size_t buffer_length, uint32_t len)
{
char *str;
char *
smf_event_extract_text(const smf_event_t *event)
{
- int string_length = -1, length_length = -1;
+ uint32_t string_length, length_length;
if (!smf_event_is_textual(event))
return (NULL);
{
assert(event);
assert(event->midi_buffer);
+
+ int32_t expected;
if (event->midi_buffer_length < 1)
return (0);
if (smf_event_is_sysex(event))
return (1);
- if (event->midi_buffer_length != expected_message_length(event->midi_buffer[0],
- &(event->midi_buffer[1]), event->midi_buffer_length - 1)) {
+ expected = expected_message_length(event->midi_buffer[0],
+ &(event->midi_buffer[1]), event->midi_buffer_length - 1);
+ if (expected < 0 || event->midi_buffer_length != (size_t)expected) {
return (0);
}
* Allocate buffer of proper size and read file contents into it. Close file afterwards.
*/
static int
-load_file_into_buffer(void **file_buffer, int *file_buffer_length, const char *file_name)
+load_file_into_buffer(void **file_buffer, size_t *file_buffer_length, const char *file_name)
{
FILE *stream = fopen(file_name, "r");
+ long offset;
if (stream == NULL) {
g_critical("Cannot open input file: %s", strerror(errno));
return (-2);
}
- *file_buffer_length = ftell(stream);
- if (*file_buffer_length == -1) {
+ offset = ftell(stream);
+ if (offset < 0) {
g_critical("ftell(3) failed: %s", strerror(errno));
return (-3);
}
+ *file_buffer_length = (size_t)offset;
if (fseek(stream, 0, SEEK_SET)) {
g_critical("fseek(3) failed: %s", strerror(errno));
* \return SMF or NULL, if loading failed.
*/
smf_t *
-smf_load_from_memory(const void *buffer, const int buffer_length)
+smf_load_from_memory(const void *buffer, const size_t buffer_length)
{
int i;
smf->file_buffer = NULL;
smf->file_buffer_length = 0;
- smf->next_chunk_offset = -1;
+ smf->next_chunk_offset = 0;
return (smf);
}
smf_t *
smf_load(const char *file_name)
{
- int file_buffer_length;
+ size_t file_buffer_length;
void *file_buffer;
smf_t *smf;
void smf_fini_tempo(smf_t *smf);
void smf_create_tempo_map_and_compute_seconds(smf_t *smf);
void maybe_add_to_tempo_map(smf_event_t *event);
-void remove_last_tempo_with_pulses(smf_t *smf, int pulses);
+void remove_last_tempo_with_pulses(smf_t *smf, size_t pulses);
int smf_event_is_tempo_change_or_time_signature(const smf_event_t *event) WARN_UNUSED_RESULT;
int smf_event_length_is_valid(const smf_event_t *event) WARN_UNUSED_RESULT;
int is_status_byte(const unsigned char status) WARN_UNUSED_RESULT;
static int
smf_validate(smf_t *smf)
{
- int trackno, eventno, eot_found;
+ int trackno, eot_found;
+ size_t eventno;
smf_track_t *track;
smf_event_t *event;
assert(event);
if (!smf_event_is_valid(event)) {
- g_critical("Event #%d on track #%d is invalid.", eventno, trackno);
+ g_critical("Event #%zu on track #%d is invalid.", eventno, trackno);
return (-5);
}
static void
assert_smf_track_is_identical(const smf_track_t *a, const smf_track_t *b)
{
- int i;
+ size_t i;
assert(a->track_number == b->track_number);
assert(a->number_of_events == b->number_of_events);
#include "smf.h"
#include "smf_private.h"
-static double seconds_from_pulses(const smf_t *smf, int pulses);
+static double seconds_from_pulses(const smf_t *smf, size_t pulses);
/**
* If there is tempo starting at "pulses" already, return it. Otherwise,
* if there is no previous one) and attach it to "smf".
*/
static smf_tempo_t *
-new_tempo(smf_t *smf, int pulses)
+new_tempo(smf_t *smf, size_t pulses)
{
smf_tempo_t *tempo, *previous_tempo = NULL;
* after that one.
*/
void
-remove_last_tempo_with_pulses(smf_t *smf, int pulses)
+remove_last_tempo_with_pulses(smf_t *smf, size_t pulses)
{
smf_tempo_t *tempo;
}
static double
-seconds_from_pulses(const smf_t *smf, int pulses)
+seconds_from_pulses(const smf_t *smf, size_t pulses)
{
double seconds;
smf_tempo_t *tempo;
}
smf_tempo_t *
-smf_get_tempo_by_number(const smf_t *smf, int number)
+smf_get_tempo_by_number(const smf_t *smf, size_t number)
{
- assert(number >= 0);
-
if (number >= smf->tempo_array->len)
return (NULL);
* Return last tempo (i.e. tempo with greatest time_pulses) that happens before "pulses".
*/
smf_tempo_t *
-smf_get_tempo_by_pulses(const smf_t *smf, int pulses)
+smf_get_tempo_by_pulses(const smf_t *smf, size_t pulses)
{
- int i;
+ size_t i;
smf_tempo_t *tempo;
- assert(pulses >= 0);
-
if (pulses == 0)
return (smf_get_tempo_by_number(smf, 0));
assert(smf->tempo_array != NULL);
- for (i = smf->tempo_array->len - 1; i >= 0; i--) {
- tempo = smf_get_tempo_by_number(smf, i);
+ for (i = smf->tempo_array->len; i > 0; i--) {
+ tempo = smf_get_tempo_by_number(smf, i - 1);
assert(tempo);
if (tempo->time_pulses < pulses)
smf_tempo_t *
smf_get_tempo_by_seconds(const smf_t *smf, double seconds)
{
- int i;
+ size_t i;
smf_tempo_t *tempo;
assert(seconds >= 0.0);
assert(smf->tempo_array != NULL);
- for (i = smf->tempo_array->len - 1; i >= 0; i--) {
- tempo = smf_get_tempo_by_number(smf, i);
+ for (i = smf->tempo_array->len; i > 0; i--) {
+ tempo = smf_get_tempo_by_number(smf, i - 1);
assert(tempo);
if (tempo->time_seconds < seconds)
{
smf_tempo_t *tempo;
+ assert(smf->tempo_array->len > 0);
tempo = smf_get_tempo_by_number(smf, smf->tempo_array->len - 1);
assert(tempo);
smf_fini_tempo(smf);
tempo = new_tempo(smf, 0);
- if (tempo == NULL)
+ if (tempo == NULL) {
g_error("tempo_init failed, sorry.");
+ }
}
/**
if (track->number_of_events > 0) {
smf_event_t *previous_event = smf_track_get_last_event(track);
assert(previous_event);
- assert(previous_event->time_pulses >= 0);
return (previous_event->time_pulses);
}
* not here.
*/
void
-smf_track_add_event_delta_pulses(smf_track_t *track, smf_event_t *event, int delta)
+smf_track_add_event_delta_pulses(smf_track_t *track, smf_event_t *event, uint32_t delta)
{
- assert(delta >= 0);
- assert(event->time_pulses == -1);
assert(event->time_seconds == -1.0);
assert(track->smf != NULL);
* and current tempo map.
*/
void
-smf_track_add_event_pulses(smf_track_t *track, smf_event_t *event, int pulses)
+smf_track_add_event_pulses(smf_track_t *track, smf_event_t *event, size_t pulses)
{
- assert(pulses >= 0);
- assert(event->time_pulses == -1);
assert(event->time_seconds == -1.0);
assert(track->smf != NULL);
smf_track_add_event_seconds(smf_track_t *track, smf_event_t *event, double seconds)
{
assert(seconds >= 0.0);
- assert(event->time_pulses == -1);
assert(event->time_seconds == -1.0);
assert(track->smf != NULL);
projects / ardour.git / commitdiff