libsmf

- Main Page
- Data Structures
- Files

- File List
- Globals

smf_decode.c
Go to the documentation of this file.
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
35 #include <stdlib.h>
36 #include <string.h>
37 #include <assert.h>
38 #include <math.h>
39 #include <errno.h>
40 #ifdef __MINGW32__
41 #include <windows.h>
42 #else /* ! __MINGW32__ */
43 #include <arpa/inet.h>
44 #endif /* ! __MINGW32__ */
45 #include <stdint.h>
46 #include "smf.h"
47 #include "smf_private.h"
48
49 #define BUFFER_SIZE 1024
50
56 int
57 smf_event_is_metadata(const smf_event_t *event)
58 {
59 assert(event->midi_buffer);
60 assert(event->midi_buffer_length > 0);
61
62 if (event->midi_buffer[0] == 0xFF)
63 return (1);
64
65 return (0);
66 }
67
71 int
72 smf_event_is_system_realtime(const smf_event_t *event)
73 {
74 assert(event->midi_buffer);
75 assert(event->midi_buffer_length > 0);
76
77 if (smf_event_is_metadata(event))
78 return (0);
79
80 if (event->midi_buffer[0] >= 0xF8)
81 return (1);
82
83 return (0);
84 }
85
89 int
90 smf_event_is_system_common(const smf_event_t *event)
91 {
92 assert(event->midi_buffer);
93 assert(event->midi_buffer_length > 0);
94
95 if (event->midi_buffer[0] >= 0xF0 && event->midi_buffer[0] <= 0xF7)
96 return (1);
97
98 return (0);
99 }
103 int
104 smf_event_is_sysex(const smf_event_t *event)
105 {
106 assert(event->midi_buffer);
107 assert(event->midi_buffer_length > 0);
108
109 if (event->midi_buffer[0] == 0xF0)
110 return (1);
111
112 return (0);
113 }
114
115 static char *
116 smf_event_decode_textual(const smf_event_t *event, const char *name)
117 {
118 int off = 0;
119 char *buf, *extracted;
120
121 buf = malloc(BUFFER_SIZE);
122 if (buf == NULL) {
123 g_critical("smf_event_decode_textual: malloc failed.");
124 return (NULL);
125 }
126
127 extracted = smf_event_extract_text(event);
128 if (extracted == NULL) {
129 free(buf);
130 return (NULL);
131 }
132
133 snprintf(buf + off, BUFFER_SIZE - off, "%s: %s", name, extracted);
134
135 return (buf);
136 }
137
138 static char *
139 smf_event_decode_metadata(const smf_event_t *event)
140 {
141 int off = 0, mspqn, flats, isminor;
142 char *buf;
143
144 static const char *const major_keys[] = {"Fb", "Cb", "Gb", "Db", "Ab",
145 "Eb", "Bb", "F", "C", "G", "D", "A", "E", "B", "F#", "C#", "G#"};
146
147 static const char *const minor_keys[] = {"Dbm", "Abm", "Ebm", "Bbm", "Fm",
148 "Cm", "Gm", "Dm", "Am", "Em", "Bm", "F#m", "C#m", "G#m", "D#m", "A#m", "E#m"};
149
150 assert(smf_event_is_metadata(event));
151
152 switch (event->midi_buffer[1]) {
153 case 0x01:
154 return (smf_event_decode_textual(event, "Text"));
155
156 case 0x02:
157 return (smf_event_decode_textual(event, "Copyright"));
158
159 case 0x03:
160 return (smf_event_decode_textual(event, "Sequence/Track Name"));
161
162 case 0x04:
163 return (smf_event_decode_textual(event, "Instrument"));
164
165 case 0x05:
166 return (smf_event_decode_textual(event, "Lyric"));
167
168 case 0x06:
169 return (smf_event_decode_textual(event, "Marker"));
170
171 case 0x07:
172 return (smf_event_decode_textual(event, "Cue Point"));
173
174 case 0x08:
175 return (smf_event_decode_textual(event, "Program Name"));
176
177 case 0x09:
178 return (smf_event_decode_textual(event, "Device (Port) Name"));
179
180 default:
181 break;
182 }
183
184 buf = malloc(BUFFER_SIZE);
185 if (buf == NULL) {
186 g_critical("smf_event_decode_metadata: malloc failed.");
187 return (NULL);
188 }
189
190 switch (event->midi_buffer[1]) {
191 case 0x00:
192 off += snprintf(buf + off, BUFFER_SIZE - off, "Sequence number");
193 break;
194
195 /* http://music.columbia.edu/pipermail/music-dsp/2004-August/061196.html */
196 case 0x20:
197 if (event->midi_buffer_length < 4) {
198 g_critical("smf_event_decode_metadata: truncated MIDI message.");
199 goto error;
200 }
201
202 off += snprintf(buf + off, BUFFER_SIZE - off, "Channel Prefix: %d", event->midi_buffer[3]);
203 break;
204
205 case 0x21:
206 if (event->midi_buffer_length < 4) {
207 g_critical("smf_event_decode_metadata: truncated MIDI message.");
208 goto error;
209 }
210
211 off += snprintf(buf + off, BUFFER_SIZE - off, "MIDI Port: %d", event->midi_buffer[3]);
212 break;
213
214 case 0x2F:
215 off += snprintf(buf + off, BUFFER_SIZE - off, "End Of Track");
216 break;
217
218 case 0x51:
219 if (event->midi_buffer_length < 6) {
220 g_critical("smf_event_decode_metadata: truncated MIDI message.");
221 goto error;
222 }
223
224 mspqn = (event->midi_buffer[3] << 16) + (event->midi_buffer[4] << 8) + event->midi_buffer[5];
225
226 off += snprintf(buf + off, BUFFER_SIZE - off, "Tempo: %d microseconds per quarter note, %.2f BPM",
227 mspqn, 60000000.0 / (double)mspqn);
228 break;
229
230 case 0x54:
231 off += snprintf(buf + off, BUFFER_SIZE - off, "SMPTE Offset");
232 break;
233
234 case 0x58:
235 if (event->midi_buffer_length < 7) {
236 g_critical("smf_event_decode_metadata: truncated MIDI message.");
237 goto error;
238 }
239
240 off += snprintf(buf + off, BUFFER_SIZE - off,
241 "Time Signature: %d/%d, %d clocks per click, %d notated 32nd notes per quarter note",
242 event->midi_buffer[3], (int)pow(2, event->midi_buffer[4]), event->midi_buffer[5],
243 event->midi_buffer[6]);
244 break;
245
246 case 0x59:
247 if (event->midi_buffer_length < 5) {
248 g_critical("smf_event_decode_metadata: truncated MIDI message.");
249 goto error;
250 }
251
252 flats = event->midi_buffer[3];
253 isminor = event->midi_buffer[4];
254
255 if (isminor != 0 && isminor != 1) {
256 g_critical("smf_event_decode_metadata: last byte of the Key Signature event has invalid value %d.", isminor);
257 goto error;
258 }
259
260 off += snprintf(buf + off, BUFFER_SIZE - off, "Key Signature: ");
261
262 if (flats > 8 && flats < 248) {
263 off += snprintf(buf + off, BUFFER_SIZE - off, "%d %s, %s key", abs((int8_t)flats),
264 flats > 127 ? "flats" : "sharps", isminor ? "minor" : "major");
265 } else {
266 int i = (flats - 248) & 255;
267
268 assert(i >= 0 && i < sizeof(minor_keys) / sizeof(*minor_keys));
269 assert(i >= 0 && i < sizeof(major_keys) / sizeof(*major_keys));
270
271 if (isminor)
272 off += snprintf(buf + off, BUFFER_SIZE - off, "%s", minor_keys[i]);
273 else
274 off += snprintf(buf + off, BUFFER_SIZE - off, "%s", major_keys[i]);
275 }
276
277 break;
278
279 case 0x7F:
280 off += snprintf(buf + off, BUFFER_SIZE - off, "Proprietary (aka Sequencer) Event, length %d",
281 event->midi_buffer_length);
282 break;
283
284 default:
285 goto error;
286 }
287
288 return (buf);
289
290 error:
291 free(buf);
292
293 return (NULL);
294 }
295
296 static char *
297 smf_event_decode_system_realtime(const smf_event_t *event)
298 {
299 int off = 0;
300 char *buf;
301
302 assert(smf_event_is_system_realtime(event));
303
304 if (event->midi_buffer_length != 1) {
305 g_critical("smf_event_decode_system_realtime: event length is not 1.");
306 return (NULL);
307 }
308
309 buf = malloc(BUFFER_SIZE);
310 if (buf == NULL) {
311 g_critical("smf_event_decode_system_realtime: malloc failed.");
312 return (NULL);
313 }
314
315 switch (event->midi_buffer[0]) {
316 case 0xF8:
317 off += snprintf(buf + off, BUFFER_SIZE - off, "MIDI Clock (realtime)");
318 break;
319
320 case 0xF9:
321 off += snprintf(buf + off, BUFFER_SIZE - off, "Tick (realtime)");
322 break;
323
324 case 0xFA:
325 off += snprintf(buf + off, BUFFER_SIZE - off, "MIDI Start (realtime)");
326 break;
327
328 case 0xFB:
329 off += snprintf(buf + off, BUFFER_SIZE - off, "MIDI Continue (realtime)");
330 break;
331
332 case 0xFC:
333 off += snprintf(buf + off, BUFFER_SIZE - off, "MIDI Stop (realtime)");
334 break;
335
336 case 0xFE:
337 off += snprintf(buf + off, BUFFER_SIZE - off, "Active Sense (realtime)");
338 break;
339
340 default:
341 free(buf);
342 return (NULL);
343 }
344
345 return (buf);
346 }
347
348 static char *
349 smf_event_decode_sysex(const smf_event_t *event)
350 {
351 int off = 0;
352 char *buf, manufacturer, subid, subid2;
353
354 assert(smf_event_is_sysex(event));
355
356 if (event->midi_buffer_length < 5) {
357 g_critical("smf_event_decode_sysex: truncated MIDI message.");
358 return (NULL);
359 }
360
361 buf = malloc(BUFFER_SIZE);
362 if (buf == NULL) {
363 g_critical("smf_event_decode_sysex: malloc failed.");
364 return (NULL);
365 }
366
367 manufacturer = event->midi_buffer[1];
368
369 if (manufacturer == 0x7F) {
370 off += snprintf(buf + off, BUFFER_SIZE - off, "SysEx, realtime, channel %d", event->midi_buffer[2]);
371 } else if (manufacturer == 0x7E) {
372 off += snprintf(buf + off, BUFFER_SIZE - off, "SysEx, non-realtime, channel %d", event->midi_buffer[2]);
373 } else {
374 off += snprintf(buf + off, BUFFER_SIZE - off, "SysEx, manufacturer 0x%x", manufacturer);
375
376 return (buf);
377 }
378
379 subid = event->midi_buffer[3];
380 subid2 = event->midi_buffer[4];
381
382 if (subid == 0x01)
383 off += snprintf(buf + off, BUFFER_SIZE - off, ", Sample Dump Header");
384
385 else if (subid == 0x02)
386 off += snprintf(buf + off, BUFFER_SIZE - off, ", Sample Dump Data Packet");
387
388 else if (subid == 0x03)
389 off += snprintf(buf + off, BUFFER_SIZE - off, ", Sample Dump Request");
390
391 else if (subid == 0x04 && subid2 == 0x01)
392 off += snprintf(buf + off, BUFFER_SIZE - off, ", Master Volume");
393
394 else if (subid == 0x05 && subid2 == 0x01)
395 off += snprintf(buf + off, BUFFER_SIZE - off, ", Sample Dump Loop Point Retransmit");
396
397 else if (subid == 0x05 && subid2 == 0x02)
398 off += snprintf(buf + off, BUFFER_SIZE - off, ", Sample Dump Loop Point Request");
399
400 else if (subid == 0x06 && subid2 == 0x01)
401 off += snprintf(buf + off, BUFFER_SIZE - off, ", Identity Request");
402
403 else if (subid == 0x06 && subid2 == 0x02)
404 off += snprintf(buf + off, BUFFER_SIZE - off, ", Identity Reply");
405
406 else if (subid == 0x08 && subid2 == 0x00)
407 off += snprintf(buf + off, BUFFER_SIZE - off, ", Bulk Tuning Dump Request");
408
409 else if (subid == 0x08 && subid2 == 0x01)
410 off += snprintf(buf + off, BUFFER_SIZE - off, ", Bulk Tuning Dump");
411
412 else if (subid == 0x08 && subid2 == 0x02)
413 off += snprintf(buf + off, BUFFER_SIZE - off, ", Single Note Tuning Change");
414
415 else if (subid == 0x08 && subid2 == 0x03)
416 off += snprintf(buf + off, BUFFER_SIZE - off, ", Bulk Tuning Dump Request (Bank)");
417
418 else if (subid == 0x08 && subid2 == 0x04)
419 off += snprintf(buf + off, BUFFER_SIZE - off, ", Key Based Tuning Dump");
420
421 else if (subid == 0x08 && subid2 == 0x05)
422 off += snprintf(buf + off, BUFFER_SIZE - off, ", Scale/Octave Tuning Dump, 1 byte format");
423
424 else if (subid == 0x08 && subid2 == 0x06)
425 off += snprintf(buf + off, BUFFER_SIZE - off, ", Scale/Octave Tuning Dump, 2 byte format");
426
427 else if (subid == 0x08 && subid2 == 0x07)
428 off += snprintf(buf + off, BUFFER_SIZE - off, ", Single Note Tuning Change (Bank)");
429
430 else if (subid == 0x09)
431 off += snprintf(buf + off, BUFFER_SIZE - off, ", General MIDI %s", subid2 == 0 ? "disable" : "enable");
432
433 else if (subid == 0x7C)
434 off += snprintf(buf + off, BUFFER_SIZE - off, ", Sample Dump Wait");
435
436 else if (subid == 0x7D)
437 off += snprintf(buf + off, BUFFER_SIZE - off, ", Sample Dump Cancel");
438
439 else if (subid == 0x7E)
440 off += snprintf(buf + off, BUFFER_SIZE - off, ", Sample Dump NAK");
441
442 else if (subid == 0x7F)
443 off += snprintf(buf + off, BUFFER_SIZE - off, ", Sample Dump ACK");
444
445 else
446 off += snprintf(buf + off, BUFFER_SIZE - off, ", Unknown");
447
448 return (buf);
449 }
450
451 static char *
452 smf_event_decode_system_common(const smf_event_t *event)
453 {
454 int off = 0;
455 char *buf;
456
457 assert(smf_event_is_system_common(event));
458
459 if (smf_event_is_sysex(event))
460 return (smf_event_decode_sysex(event));
461
462 buf = malloc(BUFFER_SIZE);
463 if (buf == NULL) {
464 g_critical("smf_event_decode_system_realtime: malloc failed.");
465 return (NULL);
466 }
467
468 switch (event->midi_buffer[0]) {
469 case 0xF1:
470 off += snprintf(buf + off, BUFFER_SIZE - off, "MTC Quarter Frame");
471 break;
472
473 case 0xF2:
474 off += snprintf(buf + off, BUFFER_SIZE - off, "Song Position Pointer");
475 break;
476
477 case 0xF3:
478 off += snprintf(buf + off, BUFFER_SIZE - off, "Song Select");
479 break;
480
481 case 0xF6:
482 off += snprintf(buf + off, BUFFER_SIZE - off, "Tune Request");
483 break;
484
485 default:
486 free(buf);
487 return (NULL);
488 }
489
490 return (buf);
491 }
492
493 static void
494 note_from_int(char *buf, int note_number)
495 {
496 int note, octave;
497 char *names[] = {"C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B"};
498
499 octave = note_number / 12 - 1;
500 note = note_number % 12;
501
502 sprintf(buf, "%s%d", names[note], octave);
503 }
504
513 char *
514 smf_event_decode(const smf_event_t *event)
515 {
516 int off = 0, channel;
517 char *buf, note[5];
518
519 if (smf_event_is_metadata(event))
520 return (smf_event_decode_metadata(event));
521
522 if (smf_event_is_system_realtime(event))
523 return (smf_event_decode_system_realtime(event));
524
525 if (smf_event_is_system_common(event))
526 return (smf_event_decode_system_common(event));
527
528 if (!smf_event_length_is_valid(event)) {
529 g_critical("smf_event_decode: incorrect MIDI message length.");
530 return (NULL);
531 }
532
533 buf = malloc(BUFFER_SIZE);
534 if (buf == NULL) {
535 g_critical("smf_event_decode: malloc failed.");
536 return (NULL);
537 }
538
539 /* + 1, because user-visible channels used to be in range <1-16>. */
540 channel = (event->midi_buffer[0] & 0x0F) + 1;
541
542 switch (event->midi_buffer[0] & 0xF0) {
543 case 0x80:
544 note_from_int(note, event->midi_buffer[1]);
545 off += snprintf(buf + off, BUFFER_SIZE - off, "Note Off, channel %d, note %s, velocity %d",
546 channel, note, event->midi_buffer[2]);
547 break;
548
549 case 0x90:
550 note_from_int(note, event->midi_buffer[1]);
551 off += snprintf(buf + off, BUFFER_SIZE - off, "Note On, channel %d, note %s, velocity %d",
552 channel, note, event->midi_buffer[2]);
553 break;
554
555 case 0xA0:
556 note_from_int(note, event->midi_buffer[1]);
557 off += snprintf(buf + off, BUFFER_SIZE - off, "Aftertouch, channel %d, note %s, pressure %d",
558 channel, note, event->midi_buffer[2]);
559 break;
560
561 case 0xB0:
562 off += snprintf(buf + off, BUFFER_SIZE - off, "Controller, channel %d, controller %d, value %d",
563 channel, event->midi_buffer[1], event->midi_buffer[2]);
564 break;
565
566 case 0xC0:
567 off += snprintf(buf + off, BUFFER_SIZE - off, "Program Change, channel %d, controller %d",
568 channel, event->midi_buffer[1]);
569 break;
570
571 case 0xD0:
572 off += snprintf(buf + off, BUFFER_SIZE - off, "Channel Pressure, channel %d, pressure %d",
573 channel, event->midi_buffer[1]);
574 break;
575
576 case 0xE0:
577 off += snprintf(buf + off, BUFFER_SIZE - off, "Pitch Wheel, channel %d, value %d",
578 channel, ((int)event->midi_buffer[2] << 7) | (int)event->midi_buffer[2]);
579 break;
580
581 default:
582 free(buf);
583 return (NULL);
584 }
585
586 return (buf);
587 }
588
597 char *
598 smf_decode(const smf_t *smf)
599 {
600 int off = 0;
601 char *buf;
602
603 buf = malloc(BUFFER_SIZE);
604 if (buf == NULL) {
605 g_critical("smf_event_decode: malloc failed.");
606 return (NULL);
607 }
608
609 off += snprintf(buf + off, BUFFER_SIZE - off, "format: %d ", smf->format);
610
611 switch (smf->format) {
612 case 0:
613 off += snprintf(buf + off, BUFFER_SIZE - off, "(single track)");
614 break;
615
616 case 1:
617 off += snprintf(buf + off, BUFFER_SIZE - off, "(several simultaneous tracks)");
618 break;
619
620 case 2:
621 off += snprintf(buf + off, BUFFER_SIZE - off, "(several independent tracks)");
622 break;
623
624 default:
625 off += snprintf(buf + off, BUFFER_SIZE - off, "(INVALID FORMAT)");
626 break;
627 }
628
629 off += snprintf(buf + off, BUFFER_SIZE - off, "; number of tracks: %d", smf->number_of_tracks);
630
631 if (smf->ppqn != 0)
632 off += snprintf(buf + off, BUFFER_SIZE - off, "; division: %d PPQN", smf->ppqn);
633 else
634 off += snprintf(buf + off, BUFFER_SIZE - off, "; division: %d FPS, %d resolution", smf->frames_per_second, smf->resolution);
635
636 return (buf);
637 }
638
smf_struct::format
int format
Definition: smf.h:231
smf_decode
char * smf_decode(const smf_t *smf)
Definition: smf_decode.c:598
smf_event_is_system_common
int smf_event_is_system_common(const smf_event_t *event)
Definition: smf_decode.c:90
smf_event_struct::midi_buffer
unsigned char * midi_buffer
Pointer to the buffer containing MIDI message.
Definition: smf.h:322
smf_struct
Represents a "song", that is, collection of one or more tracks.
Definition: smf.h:230
smf_struct::ppqn
int ppqn
These fields are extracted from "division" field of MThd header.
Definition: smf.h:234
smf_event_is_sysex
int smf_event_is_sysex(const smf_event_t *event)
Definition: smf_decode.c:104
smf_event_is_system_realtime
int smf_event_is_system_realtime(const smf_event_t *event)
Definition: smf_decode.c:72
smf_event_length_is_valid
int smf_event_length_is_valid(const smf_event_t *event)
Definition: smf_load.c:718
smf_event_struct::midi_buffer_length
int midi_buffer_length
Length of the MIDI message in the buffer, in bytes.
Definition: smf.h:325
smf_struct::frames_per_second
int frames_per_second
Definition: smf.h:235
smf_struct::number_of_tracks
int number_of_tracks
Definition: smf.h:237
smf.h
Public interface declaration for libsmf, Standard MIDI File format library.
smf_struct::resolution
int resolution
Definition: smf.h:236
smf_event_extract_text
char * smf_event_extract_text(const smf_event_t *event) WARN_UNUSED_RESULT
Extracts text from "textual metaevents", such as Text or Lyric.
Definition: smf_load.c:647
smf_event_struct
Represents a single MIDI event or metaevent.
Definition: smf.h:301
smf_event_is_metadata
int smf_event_is_metadata(const smf_event_t *event)
Definition: smf_decode.c:57
smf_private.h
Private header.
smf_event_decode
char * smf_event_decode(const smf_event_t *event)
Definition: smf_decode.c:514
smf
smf_t * smf
Definition: smfsh.c:56