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

@@ -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);

libs/evoral/src/libsmf/smf.h

@@ -218,6 +218,7 @@ extern "C" {
 #endif
 
 #include <stdio.h>
+#include <stdint.h>
 #include <glib.h>
 
 #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;
+	size_t		file_buffer_length;
-	int		next_chunk_offset;
+	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;
+	size_t		next_event_offset;
-	int		next_event_number;
+	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_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, int pulses);
+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_delta_pulses(smf_track_t *track, uint32_t delta) WARN_UNUSED_RESULT;
-int smf_track_add_eot_pulses(smf_track_t *track, int pulses) 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;

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 && (size_t)i < sizeof(minor_keys) / sizeof(*minor_keys));
-				assert(i >= 0 && i < sizeof(major_keys) / sizeof(*major_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;
 

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
+static int32_t
-expected_sysex_length(const unsigned char status, const unsigned char *second_byte, const int buffer_length, int *consumed_bytes)
+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
+static int32_t
-expected_escaped_length(const unsigned char status, const unsigned char *second_byte, const int buffer_length, int *consumed_bytes)
+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
+static int32_t
-expected_message_length(unsigned char status, const unsigned char *second_byte, const int buffer_length)
+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);
+	offset = ftell(stream);
-	if (*file_buffer_length == -1) {
+	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;
 

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;

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);

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--) {
+	for (i = smf->tempo_array->len; i > 0; i--) {
-		tempo = smf_get_tempo_by_number(smf, 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--) {
+	for (i = smf->tempo_array->len; i > 0; i--) {
-		tempo = smf_get_tempo_by_number(smf, 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);