Merge branch 'master' into cairocanvas
[ardour.git] / libs / evoral / src / libsmf / smf.c
1 /*-
2  * Copyright (c) 2007, 2008 Edward Tomasz NapieraƂa <trasz@FreeBSD.org>
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  *
14  * ALTHOUGH THIS SOFTWARE IS MADE OF WIN AND SCIENCE, IT IS PROVIDED BY THE
15  * AUTHOR AND CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
16  * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
17  * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
18  * THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
19  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
20  * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
21  * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
22  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
23  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
24  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25  *
26  */
27
28 /**
29  * \file
30  *
31  * Various functions.
32  *
33  */
34
35 /* Reference: http://www.borg.com/~jglatt/tech/midifile.htm */
36
37 #include <stdlib.h>
38 #include <string.h>
39 #include <assert.h>
40 #include <math.h>
41 #include <errno.h>
42 #include <arpa/inet.h>
43 #include "smf.h"
44 #include "smf_private.h"
45
46 /**
47  * Allocates new smf_t structure.
48  * \return pointer to smf_t or NULL.
49  */
50 smf_t *
51 smf_new(void)
52 {
53         int cantfail;
54
55         smf_t *smf = malloc(sizeof(smf_t));
56         if (smf == NULL) {
57                 g_critical("Cannot allocate smf_t structure: %s", strerror(errno));
58                 return (NULL);
59         }
60
61         memset(smf, 0, sizeof(smf_t));
62
63         smf->tracks_array = g_ptr_array_new();
64         assert(smf->tracks_array);
65
66         smf->tempo_array = g_ptr_array_new();
67         assert(smf->tempo_array);
68
69         cantfail = smf_set_ppqn(smf, 120);
70         assert(!cantfail);
71
72         cantfail = smf_set_format(smf, 0);
73         assert(!cantfail);
74
75         smf_init_tempo(smf);
76
77         return (smf);
78 }
79
80 /**
81  * Frees smf and all it's descendant structures.
82  */
83 void
84 smf_delete(smf_t *smf)
85 {
86         /* Remove all the tracks, from last to first. */
87         while (smf->tracks_array->len > 0)
88                 smf_track_delete(g_ptr_array_index(smf->tracks_array, smf->tracks_array->len - 1));
89
90         smf_fini_tempo(smf);
91
92         assert(smf->tracks_array->len == 0);
93         assert(smf->number_of_tracks == 0);
94         g_ptr_array_free(smf->tracks_array, TRUE);
95         g_ptr_array_free(smf->tempo_array, TRUE);
96
97         memset(smf, 0, sizeof(smf_t));
98         free(smf);
99 }
100
101 /**
102  * Allocates new smf_track_t structure.
103  * \return pointer to smf_track_t or NULL.
104  */
105 smf_track_t *
106 smf_track_new(void)
107 {
108         smf_track_t *track = malloc(sizeof(smf_track_t));
109         if (track == NULL) {
110                 g_critical("Cannot allocate smf_track_t structure: %s", strerror(errno));
111                 return (NULL);
112         }
113
114         memset(track, 0, sizeof(smf_track_t));
115         track->next_event_number = 0;
116
117         track->events_array = g_ptr_array_new();
118         assert(track->events_array);
119
120         return (track);
121 }
122
123 /**
124  * Detaches track from its smf and frees it.
125  */
126 void
127 smf_track_delete(smf_track_t *track)
128 {
129         assert(track);
130         assert(track->events_array);
131
132         /* Remove all the events, from last to first. */
133         while (track->events_array->len > 0)
134                 smf_event_delete(g_ptr_array_index(track->events_array, track->events_array->len - 1));
135
136         if (track->smf)
137                 smf_track_remove_from_smf(track);
138
139         assert(track->events_array->len == 0);
140         assert(track->number_of_events == 0);
141         g_ptr_array_free(track->events_array, TRUE);
142
143         memset(track, 0, sizeof(smf_track_t));
144         free(track);
145 }
146
147
148 /**
149  * Appends smf_track_t to smf.
150  */
151 void
152 smf_add_track(smf_t *smf, smf_track_t *track)
153 {
154 #ifndef NDEBUG
155         int cantfail;
156 #endif
157
158         assert(track->smf == NULL);
159
160         track->smf = smf;
161         g_ptr_array_add(smf->tracks_array, track);
162
163         smf->number_of_tracks++;
164         track->track_number = smf->number_of_tracks;
165
166         if (smf->number_of_tracks > 1) {
167 #ifndef NDEBUG
168                 cantfail = smf_set_format(smf, 1);
169                 assert(!cantfail);
170 #else
171                 smf_set_format(smf, 1);
172 #endif
173                 
174         }
175 }
176
177 /**
178  * Detaches track from the smf.
179  */
180 void
181 smf_track_remove_from_smf(smf_track_t *track)
182 {
183         int i;
184         size_t j;
185         smf_track_t *tmp;
186         smf_event_t *ev;
187
188         assert(track->smf != NULL);
189
190         track->smf->number_of_tracks--;
191
192         assert(track->smf->tracks_array);
193         g_ptr_array_remove(track->smf->tracks_array, track);
194
195         /* Renumber the rest of the tracks, so they are consecutively numbered. */
196         for (i = track->track_number; i <= track->smf->number_of_tracks; i++) {
197                 tmp = smf_get_track_by_number(track->smf, i);
198                 tmp->track_number = i;
199
200                 /*
201                  * Events have track numbers too.  I guess this wasn't a wise
202                  * decision.  ;-/
203                  */
204                 for (j = 1; j <= tmp->number_of_events; j++) {
205                         ev = smf_track_get_event_by_number(tmp, j);
206                         ev->track_number = i;
207                 }
208         }
209
210         track->track_number = -1;
211         track->smf = NULL;
212 }
213
214 /**
215  * Allocates new smf_event_t structure.  The caller is responsible for allocating
216  * event->midi_buffer, filling it with MIDI data and setting event->midi_buffer_length properly.
217  * Note that event->midi_buffer will be freed by smf_event_delete.
218  * \return pointer to smf_event_t or NULL.
219  */
220 smf_event_t *
221 smf_event_new(void)
222 {
223         smf_event_t *event = malloc(sizeof(smf_event_t));
224         if (event == NULL) {
225                 g_critical("Cannot allocate smf_event_t structure: %s", strerror(errno));
226                 return (NULL);
227         }
228
229         memset(event, 0, sizeof(smf_event_t));
230
231         event->delta_time_pulses = -1;
232         event->time_pulses = -1;
233         event->time_seconds = -1.0;
234         event->track_number = -1;
235
236         return (event);
237 }
238
239 /**
240  * Allocates an smf_event_t structure and fills it with "len" bytes copied
241  * from "midi_data".
242  * \param midi_data Pointer to MIDI data.  It sill be copied to the newly allocated event->midi_buffer.
243  * \param len Length of the buffer.  It must be proper MIDI event length, e.g. 3 for Note On event.
244  * \return Event containing MIDI data or NULL.
245  */
246 smf_event_t *
247 smf_event_new_from_pointer(const void *midi_data, size_t len)
248 {
249         smf_event_t *event;
250
251         event = smf_event_new();
252         if (event == NULL)
253                 return (NULL);
254
255         event->midi_buffer_length = len;
256         event->midi_buffer = malloc(event->midi_buffer_length);
257         if (event->midi_buffer == NULL) {
258                 g_critical("Cannot allocate MIDI buffer structure: %s", strerror(errno));
259                 smf_event_delete(event);
260
261                 return (NULL);
262         }
263
264         memcpy(event->midi_buffer, midi_data, len);
265
266         return (event);
267 }
268
269 /**
270  * Allocates an smf_event_t structure and fills it with at most three bytes of data.
271  * For example, if you need to create Note On event, do something like this:
272  *
273  * smf_event_new_from_bytes(0x90, 0x3C, 0x7f);
274  *
275  * To create event for MIDI message that is shorter than three bytes, do something
276  * like this:
277  *
278  * smf_event_new_from_bytes(0xC0, 0x42, -1);
279  *
280  * \param first_byte First byte of MIDI message.  Must be valid status byte.
281  * \param second_byte Second byte of MIDI message or -1, if message is one byte long.
282  * \param third_byte Third byte of MIDI message or -1, if message is two bytes long.
283  * \return Event containing MIDI data or NULL.
284  */
285 smf_event_t *
286 smf_event_new_from_bytes(int first_byte, int second_byte, int third_byte)
287 {
288         size_t len;
289
290         smf_event_t *event;
291
292         event = smf_event_new();
293         if (event == NULL)
294                 return (NULL);
295
296         if (first_byte < 0) {
297                 g_critical("First byte of MIDI message cannot be < 0");
298                 smf_event_delete(event);
299
300                 return (NULL);
301         }
302
303         if (first_byte > 255) {
304                 g_critical("smf_event_new_from_bytes: first byte is %d, which is larger than 255.", first_byte);
305                 return (NULL);
306         }
307
308         if (!is_status_byte(first_byte)) {
309                 g_critical("smf_event_new_from_bytes: first byte is not a valid status byte.");
310                 return (NULL);
311         }
312
313
314         if (second_byte < 0)
315                 len = 1;
316         else if (third_byte < 0)
317                 len = 2;
318         else
319                 len = 3;
320
321         if (len > 1) {
322                 if (second_byte > 255) {
323                         g_critical("smf_event_new_from_bytes: second byte is %d, which is larger than 255.", second_byte);
324                         return (NULL);
325                 }
326
327                 if (is_status_byte(second_byte)) {
328                         g_critical("smf_event_new_from_bytes: second byte cannot be a status byte.");
329                         return (NULL);
330                 }
331         }
332
333         if (len > 2) {
334                 if (third_byte > 255) {
335                         g_critical("smf_event_new_from_bytes: third byte is %d, which is larger than 255.", third_byte);
336                         return (NULL);
337                 }
338
339                 if (is_status_byte(third_byte)) {
340                         g_critical("smf_event_new_from_bytes: third byte cannot be a status byte.");
341                         return (NULL);
342                 }
343         }
344
345         event->midi_buffer_length = len;
346         event->midi_buffer = malloc(event->midi_buffer_length);
347         if (event->midi_buffer == NULL) {
348                 g_critical("Cannot allocate MIDI buffer structure: %s", strerror(errno));
349                 smf_event_delete(event);
350
351                 return (NULL);
352         }
353
354         event->midi_buffer[0] = first_byte;
355         if (len > 1)
356                 event->midi_buffer[1] = second_byte;
357         if (len > 2)
358                 event->midi_buffer[2] = third_byte;
359
360         return (event);
361 }
362
363 /**
364  * Detaches event from its track and frees it.
365  */
366 void
367 smf_event_delete(smf_event_t *event)
368 {
369         if (event->track != NULL)
370                 smf_event_remove_from_track(event);
371
372         if (event->midi_buffer != NULL) {
373                 memset(event->midi_buffer, 0, event->midi_buffer_length);
374                 free(event->midi_buffer);
375         }
376
377         memset(event, 0, sizeof(smf_event_t));
378         free(event);
379 }
380
381 /**
382  * Used for sorting track->events_array.
383  */
384 static gint
385 events_array_compare_function(gconstpointer aa, gconstpointer bb)
386 {
387         const smf_event_t *a, *b;
388
389         /* "The comparison function for g_ptr_array_sort() doesn't take the pointers
390             from the array as arguments, it takes pointers to the pointers in the array." */
391         a = (const smf_event_t *)*(const gpointer *)aa;
392         b = (const smf_event_t *)*(const gpointer *)bb;
393
394         if (a->time_pulses < b->time_pulses)
395                 return (-1);
396
397         if (a->time_pulses > b->time_pulses)
398                 return (1);
399
400         /*
401          * We need to preserve original order, otherwise things will break
402          * when there are several events with the same ->time_pulses.
403          * XXX: This is an ugly hack; we should remove sorting altogether.
404          */
405
406         if (a->event_number < b->event_number)
407                 return (-1);
408
409         if (a->event_number > b->event_number)
410                 return (1);
411
412         return (0);
413 }
414
415 /*
416  * An assumption here is that if there is an EOT event, it will be at the end of the track.
417  */
418 static void
419 remove_eot_if_before_pulses(smf_track_t *track, size_t pulses)
420 {
421         smf_event_t *event;
422
423         event = smf_track_get_last_event(track);
424
425         if (event == NULL)
426                 return;
427
428         if (!smf_event_is_eot(event))
429                 return;
430
431         if (event->time_pulses > pulses)
432                 return;
433
434         smf_event_remove_from_track(event);
435 }
436
437 /**
438  * Adds the event to the track and computes ->delta_pulses.  Note that it is faster
439  * to append events to the end of the track than to insert them in the middle.
440  * Usually you want to use smf_track_add_event_seconds or smf_track_add_event_pulses
441  * instead of this one.  Event needs to have ->time_pulses and ->time_seconds already set.
442  * If you try to add event after an EOT, EOT event will be automatically deleted.
443  */
444 void
445 smf_track_add_event(smf_track_t *track, smf_event_t *event)
446 {
447         size_t i, last_pulses = 0;
448
449         assert(track->smf != NULL);
450         assert(event->track == NULL);
451         assert(event->delta_time_pulses == -1);
452         assert(event->time_seconds >= 0.0);
453
454         remove_eot_if_before_pulses(track, event->time_pulses);
455
456         event->track = track;
457         event->track_number = track->track_number;
458
459         if (track->number_of_events == 0) {
460                 assert(track->next_event_number == 0);
461                 track->next_event_number = 1;
462         }
463
464         if (track->number_of_events > 0)
465                 last_pulses = smf_track_get_last_event(track)->time_pulses;
466
467         track->number_of_events++;
468
469         /* Are we just appending element at the end of the track? */
470         if (last_pulses <= event->time_pulses) {
471                 event->delta_time_pulses = event->time_pulses - last_pulses;
472                 assert(event->delta_time_pulses >= 0);
473                 g_ptr_array_add(track->events_array, event);
474                 event->event_number = track->number_of_events;
475
476         /* We need to insert in the middle of the track.  XXX: This is slow. */
477         } else {
478                 /* Append, then sort according to ->time_pulses. */
479                 g_ptr_array_add(track->events_array, event);
480                 g_ptr_array_sort(track->events_array, events_array_compare_function);
481
482                 /* Renumber entries and fix their ->delta_pulses. */
483                 for (i = 1; i <= track->number_of_events; i++) {
484                         smf_event_t *tmp = smf_track_get_event_by_number(track, i);
485                         tmp->event_number = i;
486
487                         if (tmp->delta_time_pulses != -1)
488                                 continue;
489
490                         if (i == 1) {
491                                 tmp->delta_time_pulses = tmp->time_pulses;
492                         } else {
493                                 tmp->delta_time_pulses = tmp->time_pulses -
494                                         smf_track_get_event_by_number(track, i - 1)->time_pulses;
495                                 assert(tmp->delta_time_pulses >= 0);
496                         }
497                 }
498
499                 /* Adjust ->delta_time_pulses of the next event. */
500                 if (event->event_number < track->number_of_events) {
501                         smf_event_t *next_event = smf_track_get_event_by_number(track, event->event_number + 1);
502                         assert(next_event);
503                         assert(next_event->time_pulses >= event->time_pulses);
504                         next_event->delta_time_pulses -= event->delta_time_pulses;
505                         assert(next_event->delta_time_pulses >= 0);
506                 }
507         }
508
509         if (smf_event_is_tempo_change_or_time_signature(event)) {
510                 if (smf_event_is_last(event))
511                         maybe_add_to_tempo_map(event);
512                 else
513                         smf_create_tempo_map_and_compute_seconds(event->track->smf);
514         }
515 }
516
517 /**
518  * Add End Of Track metaevent.  Using it is optional, libsmf will automatically
519  * add EOT to the tracks during smf_save, with delta_pulses 0.  If you try to add EOT
520  * in the middle of the track, it will fail and nonzero value will be returned.
521  * If you try to add EOT after another EOT event, it will be added, but the existing
522  * EOT event will be removed.
523  *
524  * \return 0 if everything went ok, nonzero otherwise.
525  */
526 int
527 smf_track_add_eot_delta_pulses(smf_track_t *track, uint32_t delta)
528 {
529         smf_event_t *event;
530
531         event = smf_event_new_from_bytes(0xFF, 0x2F, 0x00);
532         if (event == NULL)
533                 return (-1);
534
535         smf_track_add_event_delta_pulses(track, event, delta);
536
537         return (0);
538 }
539
540 int
541 smf_track_add_eot_pulses(smf_track_t *track, size_t pulses)
542 {
543         smf_event_t *event, *last_event;
544
545         last_event = smf_track_get_last_event(track);
546         if (last_event != NULL) {
547                 if (last_event->time_pulses > pulses)
548                         return (-2);
549         }
550
551         event = smf_event_new_from_bytes(0xFF, 0x2F, 0x00);
552         if (event == NULL)
553                 return (-3);
554
555         smf_track_add_event_pulses(track, event, pulses);
556
557         return (0);
558 }
559
560 int
561 smf_track_add_eot_seconds(smf_track_t *track, double seconds)
562 {
563         smf_event_t *event, *last_event;
564
565         last_event = smf_track_get_last_event(track);
566         if (last_event != NULL) {
567                 if (last_event->time_seconds > seconds)
568                         return (-2);
569         }
570
571         event = smf_event_new_from_bytes(0xFF, 0x2F, 0x00);
572         if (event == NULL)
573                 return (-1);
574
575         smf_track_add_event_seconds(track, event, seconds);
576
577         return (0);
578 }
579
580 /**
581  * Detaches event from its track.
582  */
583 void
584 smf_event_remove_from_track(smf_event_t *event)
585 {
586         size_t i;
587         int was_last;
588         smf_event_t *tmp;
589         smf_track_t *track;
590
591         assert(event->track != NULL);
592         assert(event->track->smf != NULL);
593
594         track = event->track;
595         was_last = smf_event_is_last(event);
596
597         /* Adjust ->delta_time_pulses of the next event. */
598         if (event->event_number < track->number_of_events) {
599                 tmp = smf_track_get_event_by_number(track, event->event_number + 1);
600                 assert(tmp);
601                 tmp->delta_time_pulses += event->delta_time_pulses;
602         }
603
604         track->number_of_events--;
605         g_ptr_array_remove(track->events_array, event);
606
607         if (track->number_of_events == 0)
608                 track->next_event_number = 0;
609
610         /* Renumber the rest of the events, so they are consecutively numbered. */
611         for (i = event->event_number; i <= track->number_of_events; i++) {
612                 tmp = smf_track_get_event_by_number(track, i);
613                 tmp->event_number = i;
614         }
615
616         if (smf_event_is_tempo_change_or_time_signature(event)) {
617                 /* XXX: This will cause problems, when there is more than one Tempo Change event at a given time. */
618                 if (was_last)
619                         remove_last_tempo_with_pulses(event->track->smf, event->time_pulses);
620                 else
621                         smf_create_tempo_map_and_compute_seconds(track->smf);
622         }
623
624         event->track = NULL;
625         event->event_number = 0;
626         event->delta_time_pulses = -1;
627         event->time_pulses = 0;
628         event->time_seconds = -1.0;
629 }
630
631 /**
632   * \return Nonzero if event is Tempo Change or Time Signature metaevent.
633   */
634 int
635 smf_event_is_tempo_change_or_time_signature(const smf_event_t *event)
636 {
637         if (!smf_event_is_metadata(event))
638                 return (0);
639
640         assert(event->midi_buffer_length >= 2);
641
642         if (event->midi_buffer[1] == 0x51 || event->midi_buffer[1] == 0x58)
643                 return (1);
644
645         return (0);
646 }
647
648 /**
649   * Sets "Format" field of MThd header to the specified value.  Note that you
650   * don't really need to use this, as libsmf will automatically change format
651   * from 0 to 1 when you add the second track.
652   * \param smf SMF.
653   * \param format 0 for one track per file, 1 for several tracks per file.
654   */
655 int
656 smf_set_format(smf_t *smf, int format)
657 {
658         assert(format == 0 || format == 1);
659
660         if (smf->number_of_tracks > 1 && format == 0) {
661                 g_critical("There is more than one track, cannot set format to 0.");
662                 return (-1);
663         }
664
665         smf->format = format;
666
667         return (0);
668 }
669
670 /**
671   * Sets the PPQN ("Division") field of MThd header.  This is mandatory, you
672   * should call it right after smf_new.  Note that changing PPQN will change time_seconds
673   * of all the events.
674   * \param smf SMF.
675   * \param ppqn New PPQN.
676   */
677 int
678 smf_set_ppqn(smf_t *smf, uint16_t ppqn)
679 {
680         smf->ppqn = ppqn;
681
682         return (0);
683 }
684
685 /**
686   * Returns next event from the track given and advances next event counter.
687   * Do not depend on End Of Track event being the last event on the track - it
688   * is possible that the track will not end with EOT if you haven't added it
689   * yet.  EOTs are added automatically during smf_save().
690   *
691   * \return Event or NULL, if there are no more events left in this track.
692   */
693 smf_event_t *
694 smf_track_get_next_event(smf_track_t *track)
695 {
696         smf_event_t *event, *next_event;
697
698         /* Track is empty? */
699         if (track->number_of_events == 0)
700                 return (NULL);
701
702         /* End of track? */
703         if (track->next_event_number == 0)
704                 return (NULL);
705
706         assert(track->next_event_number >= 1);
707
708         event = smf_track_get_event_by_number(track, track->next_event_number);
709
710         assert(event != NULL);
711
712         /* Is this the last event in the track? */
713         if (track->next_event_number < track->number_of_events) {
714                 next_event = smf_track_get_event_by_number(track, track->next_event_number + 1);
715                 assert(next_event);
716
717                 track->time_of_next_event = next_event->time_pulses;
718                 track->next_event_number++;
719         } else {
720                 track->next_event_number = 0;
721         }
722
723         return (event);
724 }
725
726 /**
727   * Returns next event from the track given.  Does not change next event counter,
728   * so repeatedly calling this routine will return the same event.
729   * \return Event or NULL, if there are no more events left in this track.
730   */
731 static smf_event_t *
732 smf_peek_next_event_from_track(smf_track_t *track)
733 {
734         smf_event_t *event;
735
736         /* End of track? */
737         if (track->next_event_number == 0)
738                 return (NULL);
739
740         assert(track->next_event_number >= 1);
741         assert(track->events_array->len != 0);
742
743         event = smf_track_get_event_by_number(track, track->next_event_number);
744
745         return (event);
746 }
747
748 /**
749  * \return Track with a given number or NULL, if there is no such track.
750  * Tracks are numbered consecutively starting from one.
751  */
752 smf_track_t *
753 smf_get_track_by_number(const smf_t *smf, int track_number)
754 {
755         smf_track_t *track;
756
757         assert(track_number >= 1);
758
759         if (track_number > smf->number_of_tracks)
760                 return (NULL);
761
762         track = (smf_track_t *)g_ptr_array_index(smf->tracks_array, track_number - 1);
763
764         assert(track);
765
766         return (track);
767 }
768
769 /**
770  * \return Event with a given number or NULL, if there is no such event.
771  * Events are numbered consecutively starting from one.
772  */
773 smf_event_t *
774 smf_track_get_event_by_number(const smf_track_t *track, size_t event_number)
775 {
776         smf_event_t *event;
777
778         assert(event_number >= 1);
779
780         if (event_number > track->number_of_events)
781                 return (NULL);
782
783         event = g_ptr_array_index(track->events_array, event_number - 1);
784
785         assert(event);
786
787         return (event);
788 }
789
790 /**
791  * \return Last event on the track or NULL, if track is empty.
792  */
793 smf_event_t *
794 smf_track_get_last_event(const smf_track_t *track)
795 {
796         smf_event_t *event;
797
798         if (track->number_of_events == 0)
799                 return (NULL);
800
801         event = smf_track_get_event_by_number(track, track->number_of_events);
802
803         return (event);
804 }
805
806 /**
807  * Searches for track that contains next event, in time order.  In other words,
808  * returns the track that contains event that should be played next.
809  * \return Track with next event or NULL, if there are no events left.
810  */
811 smf_track_t *
812 smf_find_track_with_next_event(smf_t *smf)
813 {
814         int i;
815         size_t min_time = 0;
816         smf_track_t *track = NULL, *min_time_track = NULL;
817
818         /* Find track with event that should be played next. */
819         for (i = 1; i <= smf->number_of_tracks; i++) {
820                 track = smf_get_track_by_number(smf, i);
821
822                 assert(track);
823
824                 /* No more events in this track? */
825                 if (track->next_event_number == 0)
826                         continue;
827
828                 if (track->time_of_next_event < min_time || min_time_track == NULL) {
829                         min_time = track->time_of_next_event;
830                         min_time_track = track;
831                 }
832         }
833
834         return (min_time_track);
835 }
836
837 /**
838   * \return Next event, in time order, or NULL, if there are none left.
839   */
840 smf_event_t *
841 smf_get_next_event(smf_t *smf)
842 {
843         smf_event_t *event;
844         smf_track_t *track = smf_find_track_with_next_event(smf);
845
846         if (track == NULL) {
847 #if 0
848                 g_debug("End of the song.");
849 #endif
850
851                 return (NULL);
852         }
853
854         event = smf_track_get_next_event(track);
855
856         assert(event != NULL);
857
858         event->track->smf->last_seek_position = -1.0;
859
860         return (event);
861 }
862
863 /**
864   * Advance the "next event counter".  This is functionally the same as calling
865   * smf_get_next_event and ignoring the return value.
866   */
867 void
868 smf_skip_next_event(smf_t *smf)
869 {
870         smf_event_t *ignored = smf_get_next_event(smf);
871         (void) ignored;
872 }
873
874 /**
875   * \return Next event, in time order, or NULL, if there are none left.  Does
876   * not advance position in song.
877   */
878 smf_event_t *
879 smf_peek_next_event(smf_t *smf)
880 {
881         smf_event_t *event;
882         smf_track_t *track = smf_find_track_with_next_event(smf);
883
884         if (track == NULL) {
885 #if 0
886                 g_debug("End of the song.");
887 #endif
888
889                 return (NULL);
890         }
891
892         event = smf_peek_next_event_from_track(track);
893
894         assert(event != NULL);
895
896         return (event);
897 }
898
899 /**
900   * Rewinds the SMF.  What that means is, after calling this routine, smf_get_next_event
901   * will return first event in the song.
902   */
903 void
904 smf_rewind(smf_t *smf)
905 {
906         int i;
907         smf_track_t *track = NULL;
908         smf_event_t *event;
909
910         assert(smf);
911
912         smf->last_seek_position = 0.0;
913
914         for (i = 1; i <= smf->number_of_tracks; i++) {
915                 track = smf_get_track_by_number(smf, i);
916
917                 assert(track != NULL);
918
919                 if (track->number_of_events > 0) {
920                         track->next_event_number = 1;
921                         event = smf_peek_next_event_from_track(track);
922                         assert(event);
923                         track->time_of_next_event = event->time_pulses;
924                 } else {
925                         track->next_event_number = 0;
926                         track->time_of_next_event = 0;
927 #if 0
928                         g_warning("Warning: empty track.");
929 #endif
930                 }
931         }
932 }
933
934 /**
935   * Seeks the SMF to the given event.  After calling this routine, smf_get_next_event
936   * will return the event that was the second argument of this call.
937   */
938 int
939 smf_seek_to_event(smf_t *smf, const smf_event_t *target)
940 {
941         smf_event_t *event;
942
943         smf_rewind(smf);
944
945 #if 0
946         g_debug("Seeking to event %d, track %d.", target->event_number, target->track->track_number);
947 #endif
948
949         for (;;) {
950                 event = smf_peek_next_event(smf);
951
952                 /* There can't be NULL here, unless "target" is not in this smf. */
953                 assert(event);
954
955                 if (event != target)
956                         smf_skip_next_event(smf);
957                 else
958                         break;
959         }
960
961         smf->last_seek_position = event->time_seconds;
962
963         return (0);
964 }
965
966 /**
967   * Seeks the SMF to the given position.  For example, after seeking to 1.0 seconds,
968   * smf_get_next_event will return first event that happens after the first second of song.
969   */
970 int
971 smf_seek_to_seconds(smf_t *smf, double seconds)
972 {
973         smf_event_t *event;
974
975         assert(seconds >= 0.0);
976
977         if (seconds == smf->last_seek_position) {
978 #if 0
979                 g_debug("Avoiding seek to %f seconds.", seconds);
980 #endif
981                 return (0);
982         }
983
984         smf_rewind(smf);
985
986 #if 0
987         g_debug("Seeking to %f seconds.", seconds);
988 #endif
989
990         for (;;) {
991                 event = smf_peek_next_event(smf);
992
993                 if (event == NULL) {
994                         g_critical("Trying to seek past the end of song.");
995                         return (-1);
996                 }
997
998                 if (event->time_seconds < seconds)
999                         smf_skip_next_event(smf);
1000                 else
1001                         break;
1002         }
1003
1004         smf->last_seek_position = seconds;
1005
1006         return (0);
1007 }
1008
1009 /**
1010   * Seeks the SMF to the given position.  For example, after seeking to 10 pulses,
1011   * smf_get_next_event will return first event that happens after the first ten pulses.
1012   */
1013 int
1014 smf_seek_to_pulses(smf_t *smf, size_t pulses)
1015 {
1016         smf_event_t *event;
1017
1018         smf_rewind(smf);
1019
1020 #if 0
1021         g_debug("Seeking to %d pulses.", pulses);
1022 #endif
1023
1024         for (;;) {
1025                 event = smf_peek_next_event(smf);
1026
1027                 if (event == NULL) {
1028                         g_critical("Trying to seek past the end of song.");
1029                         return (-1);
1030                 }
1031
1032                 if (event->time_pulses < pulses)
1033                         smf_skip_next_event(smf);
1034                 else
1035                         break;
1036         }
1037
1038         smf->last_seek_position = event->time_seconds;
1039
1040         return (0);
1041 }
1042
1043 /**
1044   * \return Length of SMF, in pulses.
1045   */
1046 size_t
1047 smf_get_length_pulses(const smf_t *smf)
1048 {
1049         int i;
1050         size_t pulses = 0;
1051
1052         for (i = 1; i <= smf->number_of_tracks; i++) {
1053                 smf_track_t *track;
1054                 smf_event_t *event;
1055
1056                 track = smf_get_track_by_number(smf, i);
1057                 assert(track);
1058
1059                 event = smf_track_get_last_event(track);
1060                 /* Empty track? */
1061                 if (event == NULL)
1062                         continue;
1063
1064                 if (event->time_pulses > pulses)
1065                         pulses = event->time_pulses;
1066         }
1067
1068         return (pulses);
1069 }
1070
1071 /**
1072   * \return Length of SMF, in seconds.
1073   */
1074 double
1075 smf_get_length_seconds(const smf_t *smf)
1076 {
1077         int i;
1078         double seconds = 0.0;
1079
1080         for (i = 1; i <= smf->number_of_tracks; i++) {
1081                 smf_track_t *track;
1082                 smf_event_t *event;
1083
1084                 track = smf_get_track_by_number(smf, i);
1085                 assert(track);
1086
1087                 event = smf_track_get_last_event(track);
1088                 /* Empty track? */
1089                 if (event == NULL)
1090                         continue;
1091
1092                 if (event->time_seconds > seconds)
1093                         seconds = event->time_seconds;
1094         }
1095
1096         return (seconds);
1097 }
1098
1099 /**
1100   * \return Nonzero, if there are no events in the SMF after this one.
1101   * Note that may be more than one "last event", if they occur at the same time.
1102   */
1103 int
1104 smf_event_is_last(const smf_event_t *event)
1105 {
1106         if (smf_get_length_pulses(event->track->smf) <= event->time_pulses)
1107                 return (1);
1108
1109         return (0);
1110 }
1111
1112 /**
1113   * \return Version of libsmf.
1114   */
1115 const char *
1116 smf_get_version(void)
1117 {
1118         return (SMF_VERSION);
1119 }
1120