#include <assert.h>
#include <math.h>
#include <errno.h>
+#ifdef PLATFORM_WINDOWS
+#include <winsock2.h>
+#else
#include <arpa/inet.h>
+#endif
#include "smf.h"
#include "smf_private.h"
{
int cantfail;
- smf_t *smf = malloc(sizeof(smf_t));
+ smf_t *smf = (smf_t*)malloc(sizeof(smf_t));
if (smf == NULL) {
g_critical("Cannot allocate smf_t structure: %s", strerror(errno));
return (NULL);
{
/* Remove all the tracks, from last to first. */
while (smf->tracks_array->len > 0)
- smf_track_delete(g_ptr_array_index(smf->tracks_array, smf->tracks_array->len - 1));
+ smf_track_delete((smf_track_t*)g_ptr_array_index(smf->tracks_array, smf->tracks_array->len - 1));
smf_fini_tempo(smf);
smf_track_t *
smf_track_new(void)
{
- smf_track_t *track = malloc(sizeof(smf_track_t));
+ smf_track_t *track = (smf_track_t*)malloc(sizeof(smf_track_t));
if (track == NULL) {
g_critical("Cannot allocate smf_track_t structure: %s", strerror(errno));
return (NULL);
}
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);
/* Remove all the events, from last to first. */
while (track->events_array->len > 0)
- smf_event_delete(g_ptr_array_index(track->events_array, track->events_array->len - 1));
+ smf_event_delete((smf_event_t*)g_ptr_array_index(track->events_array, track->events_array->len - 1));
if (track->smf)
smf_track_remove_from_smf(track);
void
smf_add_track(smf_t *smf, smf_track_t *track)
{
+#ifndef NDEBUG
int cantfail;
+#endif
assert(track->smf == NULL);
track->track_number = smf->number_of_tracks;
if (smf->number_of_tracks > 1) {
+#ifndef NDEBUG
cantfail = smf_set_format(smf, 1);
assert(!cantfail);
+#else
+ smf_set_format(smf, 1);
+#endif
+
}
}
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;
smf_event_t *
smf_event_new(void)
{
- smf_event_t *event = malloc(sizeof(smf_event_t));
+ smf_event_t *event = (smf_event_t*)malloc(sizeof(smf_event_t));
if (event == NULL) {
g_critical("Cannot allocate smf_event_t structure: %s", strerror(errno));
return (NULL);
* \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(const void *midi_data, size_t len)
{
smf_event_t *event;
return (NULL);
event->midi_buffer_length = len;
- event->midi_buffer = malloc(event->midi_buffer_length);
+ event->midi_buffer = (uint8_t*)malloc(event->midi_buffer_length);
if (event->midi_buffer == NULL) {
g_critical("Cannot allocate MIDI buffer structure: %s", strerror(errno));
smf_event_delete(event);
- return (NULL);
+ return (NULL);
}
memcpy(event->midi_buffer, midi_data, len);
* like this:
*
* smf_event_new_from_bytes(0xC0, 0x42, -1);
- *
+ *
* \param first_byte First byte of MIDI message. Must be valid status byte.
* \param second_byte Second byte of MIDI message or -1, if message is one byte long.
* \param third_byte Third byte of MIDI message or -1, if message is two bytes long.
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;
}
event->midi_buffer_length = len;
- event->midi_buffer = malloc(event->midi_buffer_length);
+ event->midi_buffer = (uint8_t*)malloc(event->midi_buffer_length);
if (event->midi_buffer == NULL) {
g_critical("Cannot allocate MIDI buffer structure: %s", strerror(errno));
smf_event_delete(event);
- return (NULL);
+ return (NULL);
}
event->midi_buffer[0] = first_byte;
static gint
events_array_compare_function(gconstpointer aa, gconstpointer bb)
{
- smf_event_t *a, *b;
-
+ const smf_event_t *a, *b;
+
/* "The comparison function for g_ptr_array_sort() doesn't take the pointers
from the array as arguments, it takes pointers to the pointers in the array." */
- a = (smf_event_t *)*(gpointer *)aa;
- b = (smf_event_t *)*(gpointer *)bb;
+ a = (const smf_event_t *)*(const gpointer *)aa;
+ b = (const smf_event_t *)*(const gpointer *)bb;
if (a->time_pulses < b->time_pulses)
return (-1);
* 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;
+ /* Track is empty? */
+ if (track->number_of_events == 0)
+ return (NULL);
+
/* End of track? */
- if (track->next_event_number == -1)
+ if (track->next_event_number == 0)
return (NULL);
assert(track->next_event_number >= 1);
- assert(track->number_of_events > 0);
event = smf_track_get_event_by_number(track, track->next_event_number);
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;
if (event_number > track->number_of_events)
return (NULL);
- event = g_ptr_array_index(track->events_array, event_number - 1);
+ event = (smf_event_t*)g_ptr_array_index(track->events_array, event_number - 1);
assert(event);
if (track->number_of_events == 0)
return (NULL);
-
+
event = smf_track_get_event_by_number(track, track->number_of_events);
return (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) {
}
event = smf_track_get_next_event(track);
-
+
assert(event != NULL);
event->track->smf->last_seek_position = -1.0;
void
smf_skip_next_event(smf_t *smf)
{
- void *notused;
-
- notused = smf_get_next_event(smf);
+ smf_event_t *ignored = smf_get_next_event(smf);
+ (void) ignored;
}
/**
}
event = smf_peek_next_event_from_track(track);
-
+
assert(event != NULL);
return (event);
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_skip_next_event(smf);
else
break;
- }
+ }
smf->last_seek_position = event->time_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
/**
* \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 = 0;
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);
projects / ardour.git / blobdiff