Initial commit
[virtualtones] / midiengine.cpp
1 // midiengine.cpp - Class to play to a sequencer or write to a MIDI file
2 // Written by James Bunton <james@delx.cjb.net>
3 // Licensed under the GPL, see COPYING.txt for more details
4
5
6 #include "midiengine.h"
7
8
9 /* |---------------------------| */
10 /* | Code for class MidiEngine | */
11 /* |---------------------------| */
12
13
14 bool MidiEngine::initSuccess()
15 {
16 return !error;
17 }
18
19 QString MidiEngine::getError()
20 {
21 return errorMessage;
22 }
23
24 bool MidiEngine::stopNote(int num)
25 {
26 return playNote(num, 0, 0);
27 }
28
29 void MidiEngine::stopAll()
30 {
31 // For all notes that have and ending, end them now
32 for(int i = 0; i <= 127; i++) {
33 if(noteEndings[i] != 0)
34 stopNote(i);
35 }
36 }
37
38 void MidiEngine::timerEvent(QTimerEvent *)
39 {
40 // Increment the timer
41 timer += 10;
42
43 // For all notes that expired after the current time, or on the current time:
44 // send a stop note
45 for(int i = 0; i <= 127; i++) {
46 if(noteEndings[i] <= timer && noteEndings[i] != 0) {
47 playNote(i, 0, 0);
48 }
49 }
50 }
51
52
53
54
55
56 /* |-------------------------| */
57 /* | Code for class MidiReal | */
58 /* |-------------------------| */
59
60
61 /* Linux code */
62
63 #ifdef Q_WS_X11
64
65 #include <linux/soundcard.h>
66 #include <sys/ioctl.h>
67 #include <fcntl.h>
68 #include <unistd.h>
69
70
71 class MidiReal::Private {
72 public:
73 // For setting up the midi output
74 int seqfd;
75 QString seqDevice;
76 int midiDevice;
77 unsigned char outpacket[12];
78 };
79
80
81 MidiReal::MidiReal()
82 {
83 // Use to set the sequencer and device
84 QString dev = "/dev/sequencer";
85 int devicenum = 0;
86
87 d = new Private();
88
89 d->seqfd = -1;
90 d->seqDevice = dev;
91 d->midiDevice = devicenum;
92 error = true;
93 timer = 0;
94
95 // Open the sequencer file
96 d->seqfd = open(d->seqDevice.latin1(), O_WRONLY, 0);
97 if (d->seqfd < 0) {
98 errorMessage = "Cannot open sequencer: " + d->seqDevice;
99 return;
100 }
101
102 // Check if we can access the midi devices
103 int maxMidi = 0;
104 if(ioctl(d->seqfd, SNDCTL_SEQ_NRMIDIS, &maxMidi) != 0) {
105 errorMessage = "Cannot access MIDI devices on soundcard.";
106 return;
107 }
108 if(d->midiDevice >= maxMidi) {
109 errorMessage = "Invalid MIDI device. Valid devices are 0-" + QString::number(maxMidi - 1);
110 return;
111 }
112
113
114 // Good, no errors so far
115 error = false;
116
117
118 // Set all the note endings to zero
119 for(int i = 0; i <= 127; i++) {
120 noteEndings[i] = 0;
121 }
122
123 // Setup the outpacket
124 // The note on command
125 d->outpacket[0] = SEQ_MIDIPUTC;
126 d->outpacket[1] = 0x90;
127 d->outpacket[2] = d->midiDevice;
128 d->outpacket[3] = 0;
129
130 // Specify the note
131 d->outpacket[4] = SEQ_MIDIPUTC;
132 d->outpacket[5] = 0; // note number
133 d->outpacket[6] = d->midiDevice;
134 d->outpacket[7] = 0;
135
136 // Specify the volume
137 d->outpacket[8] = SEQ_MIDIPUTC;
138 d->outpacket[9] = 0; // volume
139 d->outpacket[10] = d->midiDevice;
140 d->outpacket[11] = 0;
141
142 // Start the timer so that we can end the notes
143 startTimer(10);
144 }
145
146 MidiReal::~MidiReal()
147 {
148 // Stop all the notes
149 stopAll();
150
151 // Close the sequencer
152 if(d->seqfd > 0) {
153 close(d->seqfd);
154 }
155
156 delete d;
157 }
158
159
160 void MidiReal::setInstrument(int num)
161 {
162 // Setup the MIDI packet
163 unsigned char outpacket[4];
164 outpacket[0] = SEQ_MIDIPUTC;
165 outpacket[2] = d->midiDevice;
166 outpacket[3] = 0;
167
168 // Write the "Change Patch" packet
169 outpacket[1] = 0xc0;
170 write(d->seqfd, outpacket, 4);
171
172 // Write the patch number packet
173 outpacket[1] = num & 0xff;
174 write(d->seqfd, outpacket, 4);
175 }
176
177 bool MidiReal::playNote(int num, int vel, int len)
178 {
179 // Check the note and volume are in range
180 if(num > 127 || num < 0)
181 return false;
182
183 if(vel > 127 || vel < 0)
184 return false;
185
186 // Specify the note
187 d->outpacket[5] = num;
188
189 // Specify the volume
190 d->outpacket[9] = vel;
191
192 // Send it on it's way
193 write(d->seqfd, d->outpacket, 12);
194
195 // Set it up to turn off
196 if(len != 0 && vel != 0) {
197 noteEndings[num] = timer + len;
198 }
199
200 // if(vel != 0)
201 // printf("Playing note: %d\n", num);
202
203 return true;
204 }
205
206 #endif
207
208
209 /* Windows code */
210
211 #ifdef Q_WS_WIN
212
213 #include <windows.h>
214 #include <mmsystem.h>
215 #include <mmreg.h>
216
217
218 class MidiReal::Private {
219 public:
220 HMIDIOUT handle;
221
222 union {
223 DWORD dwData;
224 UCHAR bData[4];
225 } u;
226 };
227
228 MidiReal::MidiReal()
229 {
230 d = new Private();
231
232 error = false;
233 timer = 0;
234
235 /* Open default MIDI Out device */
236 unsigned long err;
237 if(err = midiOutOpen(&(d->handle), (UINT)-1, 0, 0, CALLBACK_NULL)) {
238 error = true;
239 errorMessage = "Error opening MIDI: " + QString::number(err);
240 return;
241 }
242
243 // Set all the note endings to zero
244 for(int i = 0; i <= 127; i++) {
245 noteEndings[i] = 0;
246 }
247
248 // Start the timer so that we can end the notes
249 startTimer(10);
250 }
251
252 MidiReal::~MidiReal()
253 {
254 // Stop all the notes
255 stopAll();
256
257 /* Close the MIDI device */
258 midiOutClose(d->handle);
259
260 delete d;
261 }
262
263
264 void MidiReal::setInstrument(int num)
265 {
266 // Setup the MIDI packet
267 d->u.bData[0] = 0xc0;
268 d->u.bData[1] = num & 0xff;
269 d->u.bData[2] = 0;
270 d->u.bData[3] = 0;
271
272 // Write it
273 midiOutShortMsg(d->handle, d->u.dwData);
274 }
275
276 bool MidiReal::playNote(int num, int vel, int len)
277 {
278 // Check the note and volume are in range
279 if(num > 127 || num < 0)
280 return false;
281
282 if(vel > 127 || vel < 0)
283 return false;
284
285 // Setup the MIDI packet
286 d->u.bData[0] = 0x90;
287 d->u.bData[1] = num;
288 d->u.bData[2] = vel;
289 d->u.bData[3] = 0;
290
291 // Write it
292 midiOutShortMsg(d->handle, d->u.dwData);
293
294 // Set it up to turn off
295 if(len != 0 && vel != 0) {
296 noteEndings[num] = timer + len;
297 }
298
299 // if(vel != 0)
300 // printf("Playing note: %d\n", num);
301
302 return true;
303 }
304
305 #endif
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321 /* |-------------------------| */
322 /* | Code for class MidiFile | */
323 /* |-------------------------| */
324
325
326 #include <stdio.h>
327
328 #include <qvaluelist.h>
329
330
331
332
333 class MidiFile::Private {
334 public:
335 /* This information found at http://www.borg.com/~jglatt/tech/midifile.htm */
336
337 struct MThd_Chunk
338 {
339 /* Here's the 8 byte header that all chunks must have */
340 char ID[4]; /* This will be 'M','T','h','d' */
341 unsigned long Length; /* This will be 6 */
342
343 /* Here are the 6 bytes */
344 unsigned short Format;
345 unsigned short NumTracks;
346 unsigned short Division;
347 };
348
349 struct MTrk_Chunk
350 {
351 /* Here's the 8 byte header that all chunks must have */
352 char ID[4]; /* This will be 'M','T','r','k' */
353 unsigned long Length; /* This will be the actual size of Data[] */
354
355 /* Here are the data bytes */
356 unsigned char *Data; /* Its actual size is Data[Length] */
357 };
358
359 struct MTrk_Packet
360 {
361 unsigned long deltaTime; /* The delta time - 4 bytes*/
362
363 /* The midi packet data */
364 unsigned char midiData[7];
365
366 int lastGood;
367 };
368
369
370 /* A place to store the MTrk_Packets as we wait for them */
371 QValueList<struct MTrk_Packet> packets;
372
373 /* The time the last note was played, relative to MidiEngine::timer */
374 long int prevNoteTime;
375
376 /* Where we save the file to */
377 QString filename;
378 FILE *file;
379
380
381 /* Functions */
382 int twistVarLen(register unsigned long value, unsigned char str[4]); // 4 bytes
383 void convertLong2Array(unsigned long value, unsigned char str[4]);
384 void convertShort2Array(unsigned short value, unsigned char str[2]);
385 void writeBytes(unsigned char *str, int num);
386 void writeBytes(char *str, int num);
387 void writeMIDI();
388 };
389
390 int MidiFile::Private::twistVarLen(register unsigned long value, unsigned char str[4])
391 {
392 register unsigned long buffer;
393 int i = 0;
394 buffer = value & 0x7F;
395
396 for(i = 0; i < 4; i++) str[i] = 0;
397
398 while ( (value >>= 7) )
399 {
400 buffer <<= 8;
401 buffer |= ((value & 0x7F) | 0x80);
402 }
403
404 for(i = 0;; i++)
405 {
406 str[i] = (unsigned char)buffer;
407 if (buffer & 0x80)
408 buffer >>= 8;
409 else
410 return i;
411 }
412 }
413
414 void MidiFile::Private::convertLong2Array(unsigned long value, unsigned char str[4])
415 {
416 union {
417 char c[4];
418 unsigned long num;
419 } u;
420 u.num = value;
421 for(int i = 0, j = 3; i < 4; i++, j--)
422 str[i] = u.c[j];
423 }
424
425 void MidiFile::Private::convertShort2Array(unsigned short value, unsigned char str[2])
426 {
427 union {
428 char c[2];
429 unsigned short num;
430 } u;
431 u.num = value;
432 str[1] = u.c[0];
433 str[0] = u.c[1];
434 }
435
436 void MidiFile::Private::writeBytes(unsigned char *str, int num)
437 {
438 for(int i = 0; i < num; i++)
439 fputc(str[i], file);
440 }
441
442 void MidiFile::Private::writeBytes(char *str, int num)
443 {
444 for(int i = 0; i < num; i++)
445 fputc(str[i], file);
446 }
447
448 void MidiFile::Private::writeMIDI()
449 {
450 if(file == 0)
451 return;
452
453 unsigned char str[4];
454 int i = 0;
455 int j = 0;
456
457 // Create the MThd header
458 struct MThd_Chunk h;
459 h.ID[0] = 'M';
460 h.ID[1] = 'T';
461 h.ID[2] = 'h';
462 h.ID[3] = 'd';
463 h.Length = 6;
464 h.Format = 0;
465 h.NumTracks = 1;
466 h.Division = 500;
467
468 // Create the MTrk chunk and allocate space for the MIDI packets
469 struct MTrk_Chunk t;
470 t.ID[0] = 'M';
471 t.ID[1] = 'T';
472 t.ID[2] = 'r';
473 t.ID[3] = 'k';
474 t.Length = packets.count() * sizeof(struct MTrk_Packet); // Only an approximation
475 t.Data = new unsigned char[t.Length];
476
477
478 // Store the MIDI packets in the MTrk chunk
479 QValueList<struct MTrk_Packet>::Iterator it;
480 int pos = 0;
481 for(it = packets.begin(); it != packets.end(); ++it) {
482 // Twist the deltaTime, then copy it
483 j = twistVarLen((*it).deltaTime, str);
484 // Copy now..
485 for(i = 0; i <= j; i++) t.Data[pos + i] = str[i];
486
487 pos = pos + i; // New position
488
489
490 // Copy the MIDI bytes also
491 for(i = 0; i <= (*it).lastGood; i++)
492 t.Data[pos + i] = (*it).midiData[i];
493
494 pos = pos + i;
495 }
496 t.Length = pos;
497
498
499
500 /* Write all the MIDI packets to disk */
501
502 // Writing the header
503 // Write h.ID
504 writeBytes(h.ID, 4);
505 // Write h.Length
506 convertLong2Array(h.Length, str);
507 writeBytes(str, 4);
508 // Write the format
509 convertShort2Array(h.Format, str);
510 writeBytes(str, 2);
511 // Write the NumTracks
512 convertShort2Array(h.NumTracks, str);
513 writeBytes(str, 2);
514 // Hack hack, write the Division
515 convertShort2Array(h.Division, str);
516 writeBytes(str, 2);
517 // fputc(-25, file);
518 // fputc(40, file);
519
520
521 // Now writing the track
522 // Write t.ID
523 writeBytes(t.ID, 4);
524 // Write the length
525 convertLong2Array(t.Length, str);
526 writeBytes(str, 4);
527 // Copy the track data
528 writeBytes(t.Data, t.Length);
529
530
531 // Free it again
532 delete [] t.Data;
533 }
534
535
536 MidiFile::MidiFile(QString file)
537 {
538 d = new Private();
539
540 d->filename = file;
541
542 error = false;
543 timer = 0;
544 d->prevNoteTime = -1;
545
546 // Open the MIDI file to send output to
547 d->file = fopen(d->filename.latin1(), "wb");
548 if (d->file == 0) {
549 errorMessage = "Cannot open output MIDI file: " + d->filename;
550 return;
551 }
552
553 // Set all the note endings to zero
554 for(int i = 0; i <= 127; i++) {
555 noteEndings[i] = 0;
556 }
557
558 // Start the timer so that we can end the notes
559 startTimer(10);
560 }
561
562 MidiFile::~MidiFile()
563 {
564 // Stop all the notes
565 stopAll();
566
567 // End track note
568 struct Private::MTrk_Packet pak;
569 pak.deltaTime = 0;
570 pak.midiData[0] = 0xff;
571 pak.midiData[1] = 0x2f;
572 pak.midiData[2] = 0x00;
573 pak.lastGood = 2;
574 d->packets.append(pak);
575
576 // Write the MIDI
577 d->writeMIDI();
578
579 // Close the MIDI file
580 if(d->file != 0) {
581 fclose(d->file);
582 }
583
584 delete d;
585 }
586
587
588 void MidiFile::setInstrument(int num)
589 {
590 // Setup the MIDI packet
591 struct Private::MTrk_Packet pak;
592
593 // Set the deltaTime
594 if(d->prevNoteTime == -1) // If we're the first note, start from 0, but don't let us count (only a patch change)
595 pak.deltaTime = 0;
596 else
597 d->prevNoteTime = timer;
598
599 pak.midiData[0] = 0xc0;
600 pak.midiData[1] = num & 0xff;
601 pak.lastGood = 1; // Last byte with data
602
603 d->packets.append(pak);
604 }
605
606 bool MidiFile::playNote(int num, int vel, int len)
607 {
608 // Check the note and volume are in range
609 if(num > 127 || num < 0)
610 return false;
611
612 if(vel > 127 || vel < 0)
613 return false;
614
615
616 // Setup the MIDI packet
617 struct Private::MTrk_Packet pak;
618
619 // Set the deltaTime
620 if(d->prevNoteTime == -1 && vel != 0) // If we're the first note, start from 0
621 d->prevNoteTime = timer;
622 pak.deltaTime = timer - d->prevNoteTime;
623 d->prevNoteTime = timer;
624
625 if(vel > 0) {
626 // Setup the MIDI packet
627 pak.midiData[0] = 0x90;
628 pak.midiData[1] = num;
629 pak.midiData[2] = vel;
630 pak.lastGood = 2; // Last byte with good data
631 }
632 else {
633 // Setup the MIDI packet
634 pak.midiData[0] = 0x80;
635 pak.midiData[1] = num;
636 pak.midiData[2] = 64; // How quickly the note goes away
637 pak.lastGood = 2; // Last byte with good data
638 }
639
640 // Set it up to turn off
641 if(len != 0 && vel != 0) {
642 noteEndings[num] = timer + len;
643 }
644
645 // if(vel != 0)
646 // printf("Appending note: %d with deltaTime: %d\n", num, pak.deltaTime);
647
648 d->packets.append(pak);
649
650 return true;
651 }
652
653