#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);
assert(track);
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));
+ /* Remove all the events */
+ unsigned int i;
+ for (i = 0; i < track->events_array->len; ++i) {
+ smf_event_t* ev = (smf_event_t*)g_ptr_array_index(track->events_array, i);
+ free (ev->midi_buffer);
+ free (ev);
+ }
+
+ g_ptr_array_remove_range(track->events_array, 0, track->events_array->len);
+ track->number_of_events = 0;
if (track->smf)
smf_track_remove_from_smf(track);
assert(track->events_array->len == 0);
- assert(track->number_of_events == 0);
g_ptr_array_free(track->events_array, TRUE);
memset(track, 0, sizeof(smf_track_t));
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
+
}
}
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, size_t 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.
}
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);
{
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 == 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);
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);
}
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);
smf_skip_next_event(smf);
else
break;
- }
+ }
smf->last_seek_position = event->time_seconds;
smf_get_length_pulses(const smf_t *smf)
{
int i;
- size_t pulses;
+ size_t pulses = 0;
for (i = 1; i <= smf->number_of_tracks; i++) {
smf_track_t *track;
projects / ardour.git / blobdiff