1
//=========================================================
4
// $Id: midi.cpp,v 1.2 2002/02/05 14:15:56 muse Exp $
6
// (C) Copyright 1999/2000 Werner Schweer (ws@seh.de)
7
//=========================================================
18
#include "marker/marker.h"
22
extern void dump(const unsigned char* p, int n);
24
unsigned const char gmOnMsg[] = { 0x7e, 0x7f, 0x09, 0x01 };
25
unsigned const char gsOnMsg[] = { 0x41, 0x10, 0x42, 0x12, 0x40, 0x00, 0x7f, 0x00, 0x41 };
26
unsigned const char xgOnMsg[] = { 0x43, 0x10, 0x4c, 0x00, 0x00, 0x7e, 0x00 };
27
unsigned const int gmOnMsgLen = sizeof(gmOnMsg);
28
unsigned const int gsOnMsgLen = sizeof(gsOnMsg);
29
unsigned const int xgOnMsgLen = sizeof(xgOnMsg);
31
/*---------------------------------------------------------
33
*---------------------------------------------------------*/
35
QString midiMetaName(int meta)
39
case 0: s = "Sequence Number"; break;
40
case 1: s = "Text Event"; break;
41
case 2: s = "Copyright"; break;
42
case 3: s = "Sequence/Track Name"; break;
43
case 4: s = "Instrument Name"; break;
44
case 5: s = "Lyric"; break;
45
case 6: s = "Marker"; break;
46
case 7: s = "Cue Point"; break;
54
case 0x0f: s = "Text"; break;
55
case 0x20: s = "Channel Prefix"; break;
56
case 0x21: s = "Port Change"; break;
57
case 0x2f: s = "End of Track"; break;
58
case 0x51: s = "Set Tempo"; break;
59
case 0x54: s = "SMPTE Offset"; break;
60
case 0x58: s = "Time Signature"; break;
61
case 0x59: s = "Key Signature"; break;
62
case 0x74: s = "Sequencer-Specific1"; break;
63
case 0x7f: s = "Sequencer-Specific2"; break;
70
//---------------------------------------------------------
72
//---------------------------------------------------------
74
QString nameSysex(unsigned int len, const unsigned char* buf)
79
if (buf[1] == 0 && buf[2] == 0x41)
82
case 0x01: s = "Sequential Circuits: "; break;
83
case 0x02: s = "Big Briar: "; break;
84
case 0x03: s = "Octave / Plateau: "; break;
85
case 0x04: s = "Moog: "; break;
86
case 0x05: s = "Passport Designs: "; break;
87
case 0x06: s = "Lexicon: "; break;
88
case 0x07: s = "Kurzweil"; break;
89
case 0x08: s = "Fender"; break;
90
case 0x09: s = "Gulbransen"; break;
91
case 0x0a: s = "Delta Labas"; break;
92
case 0x0b: s = "Sound Comp."; break;
93
case 0x0c: s = "General Electro"; break;
94
case 0x0d: s = "Techmar"; break;
95
case 0x0e: s = "Matthews Research"; break;
96
case 0x10: s = "Oberheim"; break;
97
case 0x11: s = "PAIA: "; break;
98
case 0x12: s = "Simmons: "; break;
99
case 0x13: s = "DigiDesign"; break;
100
case 0x14: s = "Fairlight: "; break;
101
case 0x15: s = "JL Cooper"; break;
102
case 0x16: s = "Lowery"; break;
103
case 0x17: s = "Lin"; break;
104
case 0x18: s = "Emu"; break;
105
case 0x1b: s = "Peavy"; break;
106
case 0x20: s = "Bon Tempi: "; break;
107
case 0x21: s = "S.I.E.L: "; break;
108
case 0x23: s = "SyntheAxe: "; break;
109
case 0x24: s = "Hohner"; break;
110
case 0x25: s = "Crumar"; break;
111
case 0x26: s = "Solton"; break;
112
case 0x27: s = "Jellinghaus Ms"; break;
113
case 0x28: s = "CTS"; break;
114
case 0x29: s = "PPG"; break;
115
case 0x2f: s = "Elka"; break;
116
case 0x36: s = "Cheetah"; break;
117
case 0x3e: s = "Waldorf"; break;
118
case 0x40: s = "Kawai: "; break;
119
case 0x41: s = "Roland: "; break;
120
case 0x42: s = "Korg: "; break;
121
case 0x43: s = "Yamaha: "; break;
122
case 0x44: s = "Casio"; break;
123
case 0x45: s = "Akai"; break;
124
case 0x7c: s = "MusE Soft Synth"; break;
125
case 0x7d: s = "Educational Use"; break;
126
case 0x7e: s = "Universal: Non Real Time"; break;
127
case 0x7f: s = "Universal: Real Time"; break;
128
default: s = "??: "; break;
131
// following messages should not show up in event list
132
// they are filtered while importing midi files
134
if ((len == gmOnMsgLen) && memcmp(buf, gmOnMsg, gmOnMsgLen) == 0)
136
else if ((len == gsOnMsgLen) && memcmp(buf, gsOnMsg, gsOnMsgLen) == 0)
138
else if ((len == xgOnMsgLen) && memcmp(buf, xgOnMsg, xgOnMsgLen) == 0)
143
//---------------------------------------------------------
145
//---------------------------------------------------------
147
MidiFile::MidiFile(FILE* f)
156
/*---------------------------------------------------------
159
*---------------------------------------------------------*/
161
bool MidiFile::read(void* p, size_t len)
165
size_t rv = fread(p, 1, len, fp);
178
//---------------------------------------------------------
180
//---------------------------------------------------------
182
bool MidiFile::write(const void* p, size_t len)
184
size_t rv = fwrite(p, 1, len, fp);
187
printf("write midifile failed: %s\n", strerror(errno));
192
//---------------------------------------------------------
194
//---------------------------------------------------------
196
int MidiFile::readShort()
200
return BE_SHORT(format);
203
//---------------------------------------------------------
205
//---------------------------------------------------------
207
void MidiFile::writeShort(int i)
209
int format = BE_SHORT(i);
213
//---------------------------------------------------------
216
//---------------------------------------------------------
218
int MidiFile::readLong()
222
return BE_LONG(format);
225
//---------------------------------------------------------
227
//---------------------------------------------------------
229
void MidiFile::writeLong(int i)
231
int format = BE_LONG(i);
235
/*---------------------------------------------------------
237
* This is meant for skipping a few bytes in a
239
*---------------------------------------------------------*/
241
bool MidiFile::skip(size_t len)
244
return read(tmp, len);
247
/*---------------------------------------------------------
249
* Read variable-length number (7 bits per byte, MSB first)
250
*---------------------------------------------------------*/
252
int MidiFile::getvl()
255
for (int i = 0;i < 16; i++) {
267
/*---------------------------------------------------------
269
* Write variable-length number (7 bits per byte, MSB first)
270
*---------------------------------------------------------*/
272
void MidiFile::putvl(unsigned val)
274
unsigned long buf = val & 0x7f;
275
while ((val >>= 7) > 0) {
289
//---------------------------------------------------------
291
//---------------------------------------------------------
293
void MidiFile::writeEvent(MidiEvent* event)
295
int c = event->channel();
298
switch (event->type()) {
299
case MidiEvent::NoteOff: nstat = 0x80; break;
300
case MidiEvent::Note: nstat = 0x90; break;
301
case MidiEvent::PAfter: nstat = 0xa0; break;
302
case MidiEvent::Ctrl7: nstat = 0xb0; break;
303
case MidiEvent::Program: nstat = 0xc0; break;
304
case MidiEvent::CAfter: nstat = 0xd0; break;
305
case MidiEvent::Pitch: nstat = 0xe0; break;
306
case MidiEvent::Sysex: nstat = 0xf0; break;
307
case MidiEvent::Meta: nstat = 0xff; break;
309
case MidiEvent::NRPN:
311
case MidiEvent::Ctrl14:
315
case MidiEvent::NoEvent:
316
case MidiEvent::Symbol:
317
case MidiEvent::Clock:
318
case MidiEvent::Quantize:
323
// running status; except for Sysex- and Meta Events
325
if (((nstat & 0xf0) != 0xf0) && (nstat != status)) {
329
switch (event->type()) {
330
case MidiEvent::NoteOff:
332
put(event->veloOff());
334
case MidiEvent::Note:
335
case MidiEvent::PAfter:
336
case MidiEvent::Ctrl7:
340
case MidiEvent::Pitch:
342
int lval = (event->dataA()-8192) & 0x7f;
343
int hval = ((event->dataA()-8192)>>7) & 0x7f;
348
case MidiEvent::Program:
349
case MidiEvent::CAfter:
352
case MidiEvent::Sysex:
354
putvl(event->dataLen()+1); // 0xf7 ber�cksichtigen
355
write(event->data(), event->dataLen());
357
status = -1; // invalidate running status
359
case MidiEvent::Meta:
362
putvl(event->dataLen());
363
write(event->data(), event->dataLen());
367
case MidiEvent::Ctrl14:
368
put(event->dataC()); // send least significant bits
370
put(event->dataA()); // send msb
371
put(event->dataB() >> 7);
374
case MidiEvent::NRPN: // TODO: support running status
379
put(event->dataB() >> 7);
393
put(event->dataB() >> 7);
402
case MidiEvent::NoEvent:
403
case MidiEvent::Symbol:
404
case MidiEvent::Clock:
405
case MidiEvent::Quantize:
410
//---------------------------------------------------------
412
// return false, if Sysex is detected and can be removed
414
//---------------------------------------------------------
416
bool MidiFile::checkSysex(MidiTrack* track, unsigned int len, unsigned char* buf)
418
if ((len == gmOnMsgLen) && memcmp(buf, gmOnMsg, gmOnMsgLen) == 0) {
419
song->setMType(MT_GM);
422
if ((len == gsOnMsgLen) && memcmp(buf, gsOnMsg, gsOnMsgLen) == 0) {
423
song->setMType(MT_GS);
426
if (buf[0] == 0x41) { // Roland
427
if (song->mtype() != MT_XG)
428
song->setMType(MT_GS);
431
else if (buf[0] == 0x43) { // Yamaha
432
song->setMType(MT_XG);
433
int type = buf[1] & 0xf0;
435
case 0x00: // bulk dump
439
if (buf[1] != 0x10) {
440
// printf("SYSEX Device changed from %d(0x%x) to 1\n", (buf[1] & 0xf) + 1, buf[1]);
441
buf[1] = 0x10; // fix to Device 1
443
if (len == 7 && buf[2] == 0x4c && buf[3] == 0x08 && buf[5] == 7) {
451
printf("xg part mode channel %d to %d\n", buf[4], buf[6]);
453
track->setType(Track::DRUM);
457
printf("YAMAHA DUMP REQUEST\n");
460
printf("YAMAHA PARAMETER REQUEST\n");
463
printf("YAMAHA unknown SYSEX: data[2]=%02x\n", buf[1]);
468
else if (buf[0] == 0x42) { // Korg
469
// int device = buf[1] & 0xf;
470
if ((buf[1] & 0xf0) != 0x30) {
471
printf("KORG SYSEX??\n");
473
// buf[1] &= 0xf; // fest auf Device 1 klemmen
476
else if (buf[0] == 0x41) { // Korg
477
// int device = buf[1] & 0xf;
478
if ((buf[1] & 0xf0) != 0x10) {
479
printf("GM SYSEX??\n");
481
// buf[1] &= 0xf; // fest auf Device 1 klemmen
485
if ((len == xgOnMsgLen) && memcmp(buf, xgOnMsg, xgOnMsgLen) == 0) {
486
song->setMType(MT_XG);
492
//---------------------------------------------------------
494
// return true on error
495
//---------------------------------------------------------
497
bool MidiFile::readTrack(bool mergeChannels)
501
if (memcmp(tmp, "MTrk", 4)) {
502
printf("BAD FILE, MTrk expected at track %d, error %d <%s>\n",
503
-1, error, strerror(error));
506
int len = readLong(); // len
507
int endPos = curPos + len;
509
sstatus = -1; // running status, der nicht bei meta oder sysex zur�ckgesetzt wird
516
MidiTrack* track = new MidiTrack();
517
song->tracks()->add(track);
518
EventList* el = track->events();
521
MidiEvent* event = readEvent(track);
524
if (int(event) == -1)
526
if (int(event) == -2) // error
528
if (lastchan == -1) {
529
el->add(event); // kann kein channel event sein
530
event->setPort(track->outPort());
531
event->setChannel(track->outChannel());
535
if (lastport == -1) {
541
track->setOutPort(port);
546
if ((lastport != -1) && (lastport != port)) {
547
printf("PORT CHANGE in Midi File\n");
549
track->setOutPort(port);
553
if (port >= MIDI_PORTS) {
554
printf("port %d >= %d, reset to 1\n", port, MIDI_PORTS);
559
track->setOutChannel(channel);
560
if (port != track->outPort())
561
printf("2 HALOOOO %d %d\n", port, track->outPort());
563
event->setPort(track->outPort());
564
event->setChannel(track->outChannel());
567
if (lastchan != channel) {
568
mergeChannels = true; // DEBUG
569
if (!mergeChannels) {
571
// try to insert in approp track
573
TrackList* tl = song->tracks();
576
for (t = tl->begin(); t != tl->end(); ++t) {
577
mtrack = dynamic_cast<MidiTrack*>(*t);
580
if (mtrack->outChannel() == lastchan) {
581
mtrack->events()->add(event);
582
event->setPort(mtrack->outPort());
583
event->setChannel(mtrack->outChannel());
588
printf("no approp. track found\n");
592
// event with new channel in track
593
// try to find channel with appropr. track
594
// or create new track
596
TrackList* tl = song->tracks();
598
MidiTrack* mtrack = 0;
599
for (t = tl->begin(); t != tl->end(); ++t) {
600
mtrack = dynamic_cast<MidiTrack*>(*t);
603
if (mtrack->outChannel() == lastchan)
606
if (t == tl->end()) {
607
mtrack = new MidiTrack();
608
mtrack->setOutChannel(lastchan);
609
mtrack->setOutPort(port);
610
song->tracks()->add(mtrack);
614
el = track->events();
617
event->setPort(track->outPort());
618
event->setChannel(track->outChannel());
623
printf("TRACKLAENGE pass nicht %d+%d != %d, %d zu viel\n",
624
endPos-len, len, end, endPos-end);
631
//---------------------------------------------------------
633
//---------------------------------------------------------
636
static void printKaraoke(char* p)
642
else if (*p == '/') {
653
//---------------------------------------------------------
659
//---------------------------------------------------------
661
MidiEvent* MidiFile::readEvent(MidiTrack* track)
663
uchar me, type, a, b;
665
int nclick = getvl();
667
printf("readEvent: error 1\n");
673
printf("readEvent: error 2\n");
682
// 0xfe active sensing
684
if (me >= 0xf8 && me <= 0xfe) {
685
printf("Midi: Real Time Message 0x%02x\n", me & 0xff);
691
int t = (click * ::division + division/2) / division;
692
MidiEvent* event = new MidiEvent;
693
event->setPosTick(t);
699
case 0xf1: // undefined
700
case 0xf2: // song position, 2 - 14 bit value, least significant byte first
701
case 0xf3: // song select 1 - song number
702
case 0xf4: // undefined
703
case 0xf5: // Device Select + Parameter 0, 1, 2, 3
704
case 0xf6: // tune request 0
705
printf("Midi: unknown Message 0x%02x\n", me & 0xff);
707
case ME_SYSEX: // 0xf0
709
status = -1; // no running status
712
printf("readEvent: error 3\n");
714
return (MidiEvent*)-2;
716
buffer = new uchar[len];
717
if (read(buffer, len)) {
718
printf("readEvent: error 4\n");
721
return (MidiEvent*)-2;
723
if (buffer[len-1] != 0xf7) {
724
printf("SYSEX endet nicht mit 0xf7!\n");
725
// Forstsetzung folgt?
728
--len; // don't count 0xf7
729
if (checkSysex(track, len, buffer)) {
730
event->setType(MidiEvent::Sysex);
731
event->setDataLen(len);
732
event->setData(buffer);
737
return (MidiEvent*)-1;
740
case ME_META: // 0xff
741
status = -1; // no running status
742
if (read(&type, 1)) { // read type
743
printf("readEvent: error 5\n");
745
return (MidiEvent*)-2;
747
len = getvl(); // read len
749
printf("readEvent: error 6\n");
751
return (MidiEvent*)-2;
753
buffer = new uchar[len+1];
755
if (read(buffer, len)) {
756
printf("readEvent: error 7\n");
759
return (MidiEvent*)-2;
763
if (type == 0x2f) { // End of Track
769
case 0x03: // Sequence-/TrackName
771
QString s((char*)buffer);
776
return (MidiEvent*)-1; // DEBUG: eigentlich n�chsten Event lesen
777
case 0x0f: // Track Comment
779
QString s((char*)buffer);
780
track->setComment(s);
784
return (MidiEvent*)-1; // DEBUG: eigentlich n�chsten Event lesen
785
case 0x22: // Channel Prefix
787
channelprefix = buffer[0];
790
return (MidiEvent*)-1;
793
case 0x21: // Port Change
795
lastport = buffer[0];
800
return (MidiEvent*)-1;
805
int tempo = buffer[2] + (buffer[1] << 8) + (buffer[0] <<16);
806
tempomap.addTempo(t, tempo);
810
return (MidiEvent*)-1; // DEBUG: eigentlich n�chsten Event lesen
811
case 0x58: // Time Signature
813
timesig_z = buffer[0];
816
for (int i = 0; i < n; i++)
818
sigmap.add(t, timesig_z, timesig_n);
822
return (MidiEvent*)-1; // DEBUG: eigentlich n�chsten Event lesen
823
case 0x59: // Key Signature
825
track->scale.set(buffer[0]);
826
track->scale.setMajorMinor(buffer[1]);
830
return (MidiEvent*)-1; // DEBUG: eigentlich n�chsten Event lesen
832
song->addMarker(QString((const char*)(buffer)), event->posTick(), false);
835
return (MidiEvent*)-1; // DEBUG: eigentlich n�chsten Event lesen
837
case 0: // Sequence Number
838
case 1: // Text Event
840
case 4: // Instrument Name
843
case 0x20: // Channel Prefix
844
case 0x54: // SMPTE Offset
845
case 0x74: // Seq. Spezific 1
846
case 0x7f: // Seq. Spezific 1
849
event->setType(MidiEvent::Meta);
850
event->setDataLen(len+1);
851
event->setData(buffer);
857
if (me & 0x80) { // status byte
858
lastchan = me & 0x0f;
862
printf("readEvent: error 9\n");
864
return (MidiEvent*)-2;
870
printf("readEvent: no running status, read 0x%02x\n", me);
871
printf("sstatus ist 0x%02x\n", sstatus);
874
return (MidiEvent*)-1;
881
switch (status & 0xf0) {
882
case 0x80: // Taste loslassen
883
case 0x90: // Taste anschlagen
884
case 0xa0: // Polyphoner Aftertouch
885
case 0xb0: // Controller
886
case 0xe0: // Pitch Bender
888
printf("readEvent: error 15\n");
890
return (MidiEvent*)-2;
892
if ((status & 0xf0) == 0xe0)
893
event->setA(((((b & 0x80) ? 0 : b) << 7) + a) - 8192);
895
event->setB(b & 0x80 ? 0 : b);
897
case 0xc0: // Program Change
898
case 0xd0: // Channel Aftertouch
900
default: // f1 f2 f3 f4 f5 f6 f7 f8 f9
901
printf("BAD STATUS 0x%02x, me 0x%02x\n", status, me);
903
return (MidiEvent*)-2;
906
switch (status & 0xf0) {
907
case 0x80: // Taste loslassen
908
event->setType(MidiEvent::NoteOff);
910
case 0x90: // Taste anschlagen
911
event->setType(event->velo() == 0 ? MidiEvent::NoteOff : MidiEvent::Note);
913
case 0xa0: // Polyphoner Aftertouch
914
event->setType(MidiEvent::PAfter);
916
case 0xb0: // Controller
917
event->setType(MidiEvent::Ctrl7);
919
case 0xc0: // Program Change
920
event->setType(MidiEvent::Program);
922
case 0xd0: // Channel Aftertouch
923
event->setType(MidiEvent::CAfter);
925
case 0xe0: // Pitch Bender
926
event->setType(MidiEvent::Pitch);
932
if ((a & 0x80) || (b & 0x80)) {
933
printf("8'tes Bit in Daten(%02x %02x): tick %d read 0x%02x status:0x%02x channel:0x%02x\n",
934
a & 0xff, b & 0xff, click, me, status, lastchan);
935
printf("readEvent: error 16\n");
937
// Try to fix: interpret as channel byte
944
return (MidiEvent*)-1;
951
//---------------------------------------------------------
953
//---------------------------------------------------------
955
bool MidiFile::writeTrack(MidiTrack* track)
958
int lenpos = ftell(fp);
959
writeLong(0); // dummy len
961
int port = track->outPort();
962
int channel = track->outChannel();
964
EventList* events = new EventList;
966
//-------------------------------------------------------------
968
// Trackname, Comment, Instrument, Volume, Pan
970
if (!track->tname().isEmpty()) {
971
const char* name = track->tname().latin1();
972
int len = strlen(name);
973
MidiEvent* ev = new MidiEvent(port, channel, 0, MidiEvent::Meta, len, (unsigned char*)name);
974
ev->setA(0x3); // Meta Sequence/Track Name
977
if (!track->comment().isEmpty()) {
978
const char* comment = track->comment().latin1();
979
int len = strlen(comment);
980
MidiEvent* ev = new MidiEvent(port, channel, 0, MidiEvent::Meta, len, (unsigned char*)comment);
981
ev->setA(0x0f); // Meta Text
985
ChannelState* state = midiPorts[port].iState(track->outChannel()); // Initial State
988
if (state->controller[CTRL_HBANK] != -1) {
989
events->add(new MidiEvent(port, channel, tick, MidiEvent::Ctrl7, CTRL_HBANK,
990
state->controller[CTRL_HBANK], 0, 0));
993
if (state->controller[CTRL_LBANK] != -1) {
994
events->add(new MidiEvent(port, channel, tick, MidiEvent::Ctrl7, CTRL_LBANK,
995
state->controller[CTRL_LBANK], 0, 0));
998
if (state->program != -1) {
999
events->add(new MidiEvent(port, channel, tick, MidiEvent::Program, state->program,
1003
if (state->controller[CTRL_VOLUME] != -1) {
1004
events->add(new MidiEvent(port, channel, tick, MidiEvent::Ctrl7, CTRL_VOLUME,
1005
state->controller[CTRL_VOLUME], 0, 0));
1008
if (state->controller[CTRL_PANPOT] != -1) {
1009
events->add(new MidiEvent(port, channel, tick, MidiEvent::Ctrl7, CTRL_PANPOT,
1010
state->controller[CTRL_PANPOT], 0, 0));
1014
//---------------------------------------------------
1015
// generate Note Off Events
1018
PartList* parts = track->parts();
1019
for (iPart p = parts->begin(); p != parts->end(); ++p) {
1020
MidiPart* part = (MidiPart*) (p->second);
1021
EventList* evlist = part->events();
1022
for (iEvent i = evlist->begin(); i != evlist->end(); ++i) {
1023
MidiEvent* ev = (MidiEvent*)i->second;
1025
if (ev->velo() == 0) {
1026
printf("Warning: midi note has velocity 0, (ignored)\n");
1029
MidiEvent* event = new MidiEvent(*ev);
1030
int len = ev->lenTick();
1032
//---------------------------------------
1033
// apply trackinfo values
1034
//---------------------------------------
1036
if (track->transposition
1038
|| track->compression != 100
1039
|| track->len != 100) {
1040
int pitch = ev->pitch();
1041
int velo = ev->velo();
1042
pitch += track->transposition;
1048
velo += track->velocity;
1049
velo = (velo * track->compression) / 100;
1052
if (velo < 1) // no off event
1055
len = (len * track->len) / 100;
1056
event->setPitch(pitch);
1057
event->setVelo(velo);
1060
MidiEvent* off = new MidiEvent(*event);
1061
int tick = off->posTick();
1064
off->setPosTick(tick + len);
1066
if (off->veloOff()) {
1067
// this is a "real" note off event
1068
off->setType(MidiEvent::NoteOff);
1069
off->setVelo(off->veloOff());
1078
//---------------------------------------------------
1079
// only first midi track contains
1084
// - GM/GS/XG Initialization
1086
for (iTrack i = song->tracks()->begin(); i != song->tracks()->end(); ++i) {
1087
MidiTrack* t = dynamic_cast<MidiTrack*>(*i);
1093
//---------------------------------------------------
1094
// Write Track Marker
1096
MarkerList* ml = song->marker();
1097
for (ciMarker m = ml->begin(); m != ml->end(); ++m) {
1098
const char* name = m->second.name().latin1();
1099
int len = strlen(name);
1100
MidiEvent* ev = new MidiEvent(port, channel,
1101
m->first, MidiEvent::Meta,
1102
len, (unsigned char*)name);
1107
//---------------------------------------------------
1110
const char* copyright = song->copyright().latin1();
1111
if (copyright && *copyright) {
1112
int len = strlen(copyright);
1113
MidiEvent* ev = new MidiEvent(port, channel, 0, MidiEvent::Meta,
1114
len, (unsigned char*)copyright);
1118
//---------------------------------------------------
1119
// Write Songtype SYSEX: GM/GS/XG
1121
switch(song->mtype()) {
1123
events->add(new MidiEvent(port, channel, 0, MidiEvent::Sysex, gmOnMsgLen, gmOnMsg));
1126
events->add(new MidiEvent(port, channel, 0, MidiEvent::Sysex, gmOnMsgLen, gmOnMsg));
1127
events->add(new MidiEvent(port, channel, 250, MidiEvent::Sysex, gsOnMsgLen, gsOnMsg));
1130
events->add(new MidiEvent(port, channel, 0, MidiEvent::Sysex, gmOnMsgLen, gmOnMsg));
1131
events->add(new MidiEvent(port, channel, 250, MidiEvent::Sysex, xgOnMsgLen, xgOnMsg));
1136
//---------------------------------------------------
1139
TempoList* tl = &tempomap;
1140
for (ciTEvent e = tl->begin(); e != tl->end(); ++e) {
1141
TEvent* event = e->second;
1142
unsigned char data[3];
1143
int tempo = event->tempo;
1144
data[2] = tempo & 0xff;
1145
data[1] = (tempo >> 8) & 0xff;
1146
data[0] = (tempo >> 16) & 0xff;
1147
MidiEvent* ev = new MidiEvent(
1149
event->tick, MidiEvent::Meta, 3, data);
1153
//---------------------------------------------------
1156
const SigList* sl = &sigmap;
1157
for (ciSigEvent e = sl->begin(); e != sl->end(); ++e) {
1158
SigEvent* event = e->second;
1159
unsigned char data[2];
1162
case 1: data[1] = 0; break;
1163
case 2: data[1] = 1; break;
1164
case 4: data[1] = 2; break;
1165
case 8: data[1] = 3; break;
1166
case 16: data[1] = 4; break;
1167
case 32: data[1] = 5; break;
1168
case 64: data[1] = 6; break;
1170
fprintf(stderr, "falsche Signatur; nenner %d\n", event->n);
1173
MidiEvent* ev = new MidiEvent(
1175
event->tick, MidiEvent::Meta, 2, data);
1178
printf("write meta %d/%d\n", data[0], data[1]);
1182
//---------------------------------------------------
1183
// write Events to file
1188
for (iEvent i = events->begin(); i != events->end(); ++i) {
1189
putvl(((i->first-tick) * midiDivision + ::division/2)/::division);
1191
writeEvent((MidiEvent*)i->second);
1195
//---------------------------------------------------
1196
// write "End Of Track" Meta
1204
int endpos = ftell(fp);
1205
fseek(fp, lenpos, SEEK_SET);
1206
writeLong(endpos-lenpos-4); // tracklen
1207
fseek(fp, endpos, SEEK_SET);
1211
//---------------------------------------------------------
1213
//---------------------------------------------------------
1215
bool MidiFile::save()
1217
division = midiDivision;
1219
writeLong(6); // header len
1220
writeShort(1); // format
1221
TrackList* tracks = song->tracks();
1222
writeShort(tracks->size());
1223
writeShort(division);
1225
for (iTrack i = tracks->begin(); i != tracks->end(); ++i) {
1226
MidiTrack* track = dynamic_cast<MidiTrack*>(*i);
1234
//---------------------------------------------------------
1236
//---------------------------------------------------------
1238
void MidiFile::processTrack1(MidiTrack* track)
1240
if (track->outChannel() == 9 && song->mtype() != MT_UNKNOWN)
1241
track->setType(Track::DRUM);
1243
MidiPort* port = &midiPorts[track->outPort()];
1244
int channel = track->outChannel();
1245
port->resetIstate(channel, false);
1247
int trackno = song->tracks()->index(track);
1248
bool karaoke = song->karaokeFlag();
1250
//---------------------------------------------------
1251
// get initial controller state
1252
//---------------------------------------------------
1254
int karaokeState = 0;
1255
EventList* tevents = track->events();
1257
for (iEvent i = tevents->begin(); i != tevents->end();) {
1260
MidiEvent* ev = (MidiEvent*)i->second;
1261
switch(ev->type()) {
1262
case MidiEvent::Note:
1264
case MidiEvent::Program:
1265
if (port->iState(channel)->program == -1) {
1266
port->iState(channel)->program = ev->program();
1270
case MidiEvent::Ctrl7:
1271
switch(ev->cntrl()) {
1280
if (port->iState(channel)->controller[ev->cntrl()] == -1) {
1281
port->iState(channel)->controller[ev->cntrl()] = ev->cntrlVal();
1282
// add to controller list
1283
addMidiController(MidiController::Controller7, ev->cntrl(), 0);
1289
case MidiEvent::Meta:
1290
switch(ev->dataA()) {
1291
case 0x1: // text event
1292
if (trackno == 1 && memcmp(ev->data(), "@KMID", 5) == 0) {
1294
song->setKaraokeFlag(true);
1295
song->setKaraokeChannel(ev->channel());
1298
if ((trackno == 2) && karaoke) {
1299
char* p = (char*)(ev->data());
1302
switch(karaokeState) {
1303
case 0: // expect language
1306
case 1: // expect titel
1307
++karaokeState; // language
1310
case 2: // expect interpret
1312
song->setKomponist1(p+2);
1315
printf("unexpected @ in karaoke\n");
1319
else if (karaokeState == 3) {
1321
song->karaoke()->add(ev);
1326
case 0x2: // Copyright
1327
song->setCopyright(QString((const char*)(ev->data())));
1341
//---------------------------------------------------
1342
// NoteOff Events aufl�sen
1343
//---------------------------------------------------
1345
for (iEvent i = tevents->begin(); i != tevents->end(); ++i) {
1346
MidiEvent* event = (MidiEvent*)i->second;
1347
if (event->isNote())
1348
event->setLenTick(-1);
1351
for (iEvent i = tevents->begin(); i != tevents->end(); ++i) {
1352
MidiEvent* ev = (MidiEvent*)i->second;
1354
if (ev->isNoteOff()) {
1355
printf("NOTE OFF without Note ON\n");
1358
for (k = tevents->lower_bound(ev->posTick()); k != tevents->end(); ++k) {
1359
MidiEvent* event = (MidiEvent*)k->second;
1360
if (ev->isNoteOff(event)) {
1361
int t = k->first - i->first;
1364
printf("Note len is (%d-%d)=%d, set to 1\n",
1365
k->first, i->first, k->first - i->first);
1372
ev->setVeloOff(event->veloOff());
1376
if (k == tevents->end()) {
1377
printf("-kein note-off! %d channel %d pitch %d velo %d\n",
1378
i->first, ev->channel(), ev->pitch(), ev->velo());
1380
// ton am Taktende abschalten
1382
int endTick = song->roundUpBar(ev->posTick()+1);
1383
ev->setLenTick(endTick-ev->posTick());
1391
// DEBUG: any note offs left?
1393
for (iEvent i = tevents->begin(); i != tevents->end(); ++i) {
1394
MidiEvent* ev = (MidiEvent*)i->second;
1395
if (ev->isNoteOff()) {
1396
printf("+extra note-off! %d channel %d pitch %d velo %d\n",
1397
i->first, ev->channel(), ev->pitch(), ev->velo());
1403
//---------------------------------------------------------
1405
// divide events into parts
1406
//---------------------------------------------------------
1408
void MidiFile::processTrack2(MidiTrack* track)
1410
EventList* tevents = track->events();
1411
if (tevents->empty())
1414
//---------------------------------------------------
1416
// die Midi-Spuren werden in Parts aufgebrochen;
1417
// ein neuer Part wird bei einer L�cke von einem
1418
// Takt gebildet; die L�nge wird jeweils auf
1419
// Takte aufgerundet und aligned
1420
//---------------------------------------------------
1422
PartList* pl = track->parts();
1425
for (iEvent i = tevents->begin(); i != tevents->end(); ++i) {
1426
Event* event = i->second;
1427
int epos = event->posTick() + event->lenTick();
1428
if (epos > lastTick)
1432
int len = song->roundUpBar(lastTick+1);
1433
int bar2, beat, tick;
1434
sigmap.tickValues(len, &bar2, &beat, &tick);
1436
QString partname = track->name();
1439
int st = -1; // start tick current part
1440
int x1 = 0; // start tick current measure
1441
int x2 = 0; // end tick current measure
1443
for (int bar = 0; bar < bar2; ++bar, x1 = x2) {
1444
x2 = sigmap.bar2tick(bar+1, 0, 0);
1446
// this measure is busy!
1449
iEvent i1 = tevents->lower_bound(x1);
1450
iEvent i2 = tevents->lower_bound(x2);
1452
if (i1 == i2) { // empty?
1454
MidiPart* part = new MidiPart(track);
1455
part->setPosTick(st);
1456
part->setLenTick(x1-st);
1457
part->setName(partname);
1464
st = x1; // begin new part
1467
for (iEvent i = i1; i != i2; ++i) {
1468
MidiEvent* event = (MidiEvent*)i->second;
1469
if (event->type() == MidiEvent::Note) {
1470
int off = event->posTick() + event->lenTick();
1478
MidiPart* part = new MidiPart(track);
1479
part->setPosTick(st);
1480
part->setLenTick(x2-st);
1481
part->setName(partname);
1485
//-------------------------------------------------------------
1486
// assign events to parts
1487
//-------------------------------------------------------------
1489
for (iPart p = pl->begin(); p != pl->end(); ++p) {
1490
MidiPart* part = (MidiPart*)(p->second);
1491
int stick = part->posTick();
1492
int etick = part->posTick() + part->lenTick();
1493
iEvent r1 = tevents->lower_bound(stick);
1494
iEvent r2 = tevents->lower_bound(etick);
1495
part->events()->insert(r1, r2);
1496
tevents->erase(r1, r2);
1499
if (tevents->size())
1500
printf("-----------events left: %d\n", tevents->size());
1501
for (iEvent i = tevents->begin(); i != tevents->end(); ++i) {
1502
printf("%d===\n", i->first);
1505
// all events should be processed:
1506
assert(tevents->empty());
1509
//---------------------------------------------------------
1511
// returns true on error
1512
//---------------------------------------------------------
1514
bool MidiFile::read()
1520
int len = readLong();
1521
if (memcmp(tmp, "MThd", 4) || len < 6) {
1522
fprintf(stderr, "bad Midifile: MThd expected\n");
1526
int format = readShort();
1527
ntracks = readShort();
1528
division = readShort();
1531
division = (-(division/256)) * (division & 0xff);
1533
skip(len-6); // skip the excess
1535
// reset midi ports to "unknown state"
1536
for (int i = 0; i < MIDI_PORTS; ++i) {
1537
for (int k = 0; k < MIDI_CHANNELS; ++k) {
1538
midiPorts[i].resetIstate(k, false);
1543
if (readTrack(true)) {
1544
printf("read midifile failed at pos %d: %s\n", curPos, strerror(error));
1549
for (i = 0; i < ntracks; i++) {
1550
if (readTrack(false)) {
1551
printf("read midifile failed at pos %d: %s\n", curPos, strerror(error));
1558
printf("midi fileformat %d not implemented!\n", format);
1562
TrackList* tl = song->tracks();
1563
for (iTrack t = tl->begin(); t != tl->end(); ++t) {
1564
MidiTrack* track = dynamic_cast<MidiTrack*>(*t);
1567
processTrack1(track);
1570
//-------------------------------------------------------------
1571
// calculate tick offset
1573
int tickOffset = MAXINT;
1574
for (iTrack t = tl->begin(); t != tl->end(); ++t) {
1575
MidiTrack* track = dynamic_cast<MidiTrack*>(*t);
1578
EventList* events = track->events();
1579
if (!events->empty()) {
1580
MidiEvent* event = (MidiEvent*)events->begin()->second;
1581
int tick = event->posTick();
1582
if (tick < tickOffset)
1586
// printf("OFFSET %d %d\n", tickOffset, tickOffset/::division);
1588
for (iTrack t = tl->begin(); t != tl->end(); ++t) {
1589
MidiTrack* track = dynamic_cast<MidiTrack*>(*t);
1592
processTrack2(track);
1595
if (song->karaokeFlag()) {
1596
for (iTrack t = tl->begin(); t != tl->end(); ++t) {
1597
MidiTrack* track = dynamic_cast<MidiTrack*>(*t);
1600
if (track->outChannel() == song->karaokeChannel()) {
1609
//---------------------------------------------------------
1611
//---------------------------------------------------------
1613
void MidiFile::addKaraoke(MidiTrack*)
1616
EventList* el = song->karaoke();
1617
for (iEvent i = el->begin(); i != el->end(); ++i) {
1618
MidiEvent* event = (MidiEvent*)i->second;
1619
char* p = (char*)(event->data());
1620
if (*p == '\\' || *p == '/')
1624
PartList* pl = track->parts();
1625
for (iPart ip = pl->begin(); ip != pl->end(); ++ip) {
1626
EventList* nel = ((MidiPart*)*ip)->events();