From 8249cfb6a7335c6f2729bbfcf80948827936db3a Mon Sep 17 00:00:00 2001 From: David Robillard Date: Sat, 14 Feb 2009 22:22:55 +0000 Subject: [PATCH] Fix types to be warning clean on 64 bit. git-svn-id: svn://localhost/ardour2/branches/3.0@4560 d708f5d6-7413-0410-9779-e7cbd77b26cf --- libs/evoral/src/libsmf/smf.c | 59 +++++++++++----------- libs/evoral/src/libsmf/smf.h | 53 ++++++++++---------- libs/evoral/src/libsmf/smf_decode.c | 6 +-- libs/evoral/src/libsmf/smf_load.c | 75 +++++++++++++++------------- libs/evoral/src/libsmf/smf_private.h | 2 +- libs/evoral/src/libsmf/smf_save.c | 7 +-- libs/evoral/src/libsmf/smf_tempo.c | 42 +++++++--------- 7 files changed, 121 insertions(+), 123 deletions(-) diff --git a/libs/evoral/src/libsmf/smf.c b/libs/evoral/src/libsmf/smf.c index 88206511dc..227ea8c263 100644 --- a/libs/evoral/src/libsmf/smf.c +++ b/libs/evoral/src/libsmf/smf.c @@ -112,7 +112,7 @@ smf_track_new(void) } 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); @@ -173,7 +173,8 @@ smf_add_track(smf_t *smf, smf_track_t *track) 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; @@ -236,7 +237,7 @@ smf_event_new(void) * \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; @@ -277,7 +278,7 @@ smf_event_new_from_pointer(void *midi_data, int len) 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; @@ -408,7 +409,7 @@ events_array_compare_function(gconstpointer aa, gconstpointer bb) * 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; @@ -436,12 +437,11 @@ remove_eot_if_before_pulses(smf_track_t *track, int pulses) 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); @@ -450,7 +450,7 @@ smf_track_add_event(smf_track_t *track, smf_event_t *event) 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; } @@ -517,7 +517,7 @@ smf_track_add_event(smf_track_t *track, smf_event_t *event) * \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; @@ -531,7 +531,7 @@ smf_track_add_eot_delta_pulses(smf_track_t *track, int delta) } 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; @@ -576,7 +576,8 @@ smf_track_add_eot_seconds(smf_track_t *track, double seconds) 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; @@ -597,7 +598,7 @@ smf_event_remove_from_track(smf_event_t *event) 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++) { @@ -614,9 +615,9 @@ smf_event_remove_from_track(smf_event_t *event) } 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; } @@ -667,10 +668,8 @@ smf_set_format(smf_t *smf, int format) * \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); @@ -690,7 +689,7 @@ smf_track_get_next_event(smf_track_t *track) 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); @@ -708,7 +707,7 @@ smf_track_get_next_event(smf_track_t *track) 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); @@ -725,7 +724,7 @@ smf_peek_next_event_from_track(smf_track_t *track) 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); @@ -762,7 +761,7 @@ smf_get_track_by_number(const smf_t *smf, int track_number) * 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; @@ -802,7 +801,8 @@ smf_track_get_last_event(const smf_track_t *track) 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. */ @@ -812,7 +812,7 @@ smf_find_track_with_next_event(smf_t *smf) 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) { @@ -913,7 +913,7 @@ smf_rewind(smf_t *smf) 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."); @@ -1002,12 +1002,10 @@ smf_seek_to_seconds(smf_t *smf, double seconds) * 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 @@ -1036,16 +1034,17 @@ smf_seek_to_pulses(smf_t *smf, int pulses) /** * \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); diff --git a/libs/evoral/src/libsmf/smf.h b/libs/evoral/src/libsmf/smf.h index e2a0c3b8a4..8bd0722766 100644 --- a/libs/evoral/src/libsmf/smf.h +++ b/libs/evoral/src/libsmf/smf.h @@ -218,6 +218,7 @@ extern "C" { #endif #include +#include #include #if defined(__GNUC__) && __GNUC__ >= 4 @@ -231,7 +232,7 @@ struct smf_struct { 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; @@ -239,8 +240,8 @@ struct smf_struct { /** 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. */ @@ -256,7 +257,7 @@ typedef struct smf_struct smf_t; /** 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; @@ -272,20 +273,20 @@ struct smf_track_struct { 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; }; @@ -297,14 +298,14 @@ struct smf_event_struct { 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; @@ -313,10 +314,10 @@ struct smf_event_struct { 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; @@ -326,7 +327,7 @@ smf_t *smf_new(void) WARN_UNUSED_RESULT; 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; @@ -338,10 +339,10 @@ void smf_skip_next_event(smf_t *smf); 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; @@ -353,20 +354,20 @@ smf_track_t *smf_track_new(void) 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); @@ -383,15 +384,15 @@ char *smf_event_extract_text(const smf_event_t *event) WARN_UNUSED_RESULT; /* 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; diff --git a/libs/evoral/src/libsmf/smf_decode.c b/libs/evoral/src/libsmf/smf_decode.c index 1c1b91e292..0951a6e2f8 100644 --- a/libs/evoral/src/libsmf/smf_decode.c +++ b/libs/evoral/src/libsmf/smf_decode.c @@ -261,8 +261,8 @@ smf_event_decode_metadata(const smf_event_t *event) } 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]); @@ -273,7 +273,7 @@ smf_event_decode_metadata(const smf_event_t *event) 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; diff --git a/libs/evoral/src/libsmf/smf_load.c b/libs/evoral/src/libsmf/smf_load.c index 98c7789dce..857f3d485f 100644 --- a/libs/evoral/src/libsmf/smf_load.c +++ b/libs/evoral/src/libsmf/smf_load.c @@ -56,7 +56,6 @@ next_chunk(smf_t *smf) 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."); @@ -208,13 +207,11 @@ parse_mthd_chunk(smf_t *smf) * 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()."); @@ -229,6 +226,7 @@ extract_vlq(const unsigned char *buf, const int buffer_length, int *value, int * break; }; + assert(c >= buf); *value = val; *len = c - buf + 1; @@ -274,10 +272,10 @@ is_escape_byte(const unsigned char status) * 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); @@ -295,8 +293,8 @@ expected_sysex_length(const unsigned char status, const unsigned char *second_by 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); @@ -307,8 +305,8 @@ expected_escaped_length(const unsigned char status, const unsigned char *second_ * 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)); @@ -319,9 +317,6 @@ expected_message_length(unsigned char status, const unsigned char *second_byte, /* 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) { @@ -382,9 +377,10 @@ expected_message_length(unsigned char status, const unsigned char *second_byte, } 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; @@ -400,7 +396,7 @@ extract_sysex_event(const unsigned char *buf, const int buffer_length, smf_event 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); } @@ -421,9 +417,10 @@ extract_sysex_event(const unsigned char *buf, const int buffer_length, smf_event } 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; @@ -439,7 +436,7 @@ extract_escaped_event(const unsigned char *buf, const int buffer_length, smf_eve 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); } @@ -474,9 +471,10 @@ extract_escaped_event(const unsigned char *buf, const int buffer_length, smf_eve * 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); @@ -508,7 +506,7 @@ extract_midi_event(const unsigned char *buf, const int buffer_length, smf_event_ 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); } @@ -537,7 +535,9 @@ extract_midi_event(const unsigned char *buf, const int buffer_length, smf_event_ 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(); @@ -588,7 +588,7 @@ error: * 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; @@ -641,7 +641,7 @@ smf_event_is_textual(const smf_event_t *event) 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); @@ -714,6 +714,8 @@ smf_event_length_is_valid(const smf_event_t *event) { assert(event); assert(event->midi_buffer); + + int32_t expected; if (event->midi_buffer_length < 1) return (0); @@ -722,9 +724,10 @@ smf_event_length_is_valid(const smf_event_t *event) 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); } @@ -790,9 +793,10 @@ parse_mtrk_chunk(smf_track_t *track) * 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)); @@ -806,12 +810,13 @@ load_file_into_buffer(void **file_buffer, int *file_buffer_length, const char *f 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)); @@ -846,7 +851,7 @@ load_file_into_buffer(void **file_buffer, int *file_buffer_length, const char *f * \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; @@ -886,7 +891,7 @@ smf_load_from_memory(const void *buffer, const int buffer_length) smf->file_buffer = NULL; smf->file_buffer_length = 0; - smf->next_chunk_offset = -1; + smf->next_chunk_offset = 0; return (smf); } @@ -900,7 +905,7 @@ smf_load_from_memory(const void *buffer, const int buffer_length) smf_t * smf_load(const char *file_name) { - int file_buffer_length; + size_t file_buffer_length; void *file_buffer; smf_t *smf; diff --git a/libs/evoral/src/libsmf/smf_private.h b/libs/evoral/src/libsmf/smf_private.h index 0cd273e73a..537a29b889 100644 --- a/libs/evoral/src/libsmf/smf_private.h +++ b/libs/evoral/src/libsmf/smf_private.h @@ -71,7 +71,7 @@ void smf_init_tempo(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; diff --git a/libs/evoral/src/libsmf/smf_save.c b/libs/evoral/src/libsmf/smf_save.c index 95ed14b1d7..1a7a726675 100644 --- a/libs/evoral/src/libsmf/smf_save.c +++ b/libs/evoral/src/libsmf/smf_save.c @@ -487,7 +487,8 @@ smf_event_is_eot(const smf_event_t *event) 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; @@ -522,7 +523,7 @@ smf_validate(smf_t *smf) 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); } @@ -565,7 +566,7 @@ assert_smf_event_is_identical(const smf_event_t *a, const smf_event_t *b) 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); diff --git a/libs/evoral/src/libsmf/smf_tempo.c b/libs/evoral/src/libsmf/smf_tempo.c index d328b3a2b7..c24e7460c1 100644 --- a/libs/evoral/src/libsmf/smf_tempo.c +++ b/libs/evoral/src/libsmf/smf_tempo.c @@ -39,7 +39,7 @@ #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, @@ -47,7 +47,7 @@ static double seconds_from_pulses(const smf_t *smf, int pulses); * 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; @@ -170,7 +170,7 @@ maybe_add_to_tempo_map(smf_event_t *event) * 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; @@ -194,7 +194,7 @@ remove_last_tempo_with_pulses(smf_t *smf, int pulses) } 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; @@ -254,10 +254,8 @@ smf_create_tempo_map_and_compute_seconds(smf_t *smf) } 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); @@ -268,20 +266,18 @@ smf_get_tempo_by_number(const smf_t *smf, int number) * 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) @@ -297,7 +293,7 @@ smf_get_tempo_by_pulses(const smf_t *smf, int 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); @@ -307,8 +303,8 @@ smf_get_tempo_by_seconds(const smf_t *smf, double seconds) 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) @@ -327,6 +323,7 @@ smf_get_last_tempo(const smf_t *smf) { smf_tempo_t *tempo; + assert(smf->tempo_array->len > 0); tempo = smf_get_tempo_by_number(smf, smf->tempo_array->len - 1); assert(tempo); @@ -371,8 +368,9 @@ smf_init_tempo(smf_t *smf) smf_fini_tempo(smf); tempo = new_tempo(smf, 0); - if (tempo == NULL) + if (tempo == NULL) { g_error("tempo_init failed, sorry."); + } } /** @@ -385,7 +383,6 @@ last_event_pulses(const smf_track_t *track) 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); } @@ -400,10 +397,8 @@ last_event_pulses(const smf_track_t *track) * 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); @@ -420,10 +415,8 @@ smf_track_add_event_delta_pulses(smf_track_t *track, smf_event_t *event, int del * 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); @@ -441,7 +434,6 @@ void 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);