juce/source/src/audio/midi/juce_MidiFile.cpp

   1 /*
   2   ==============================================================================
   3
   4    This file is part of the JUCE library - "Jules' Utility Class Extensions"
   5    Copyright 2004-11 by Raw Material Software Ltd.
   6
   7   ------------------------------------------------------------------------------
   8
   9    JUCE can be redistributed and/or modified under the terms of the GNU General
  10    Public License (Version 2), as published by the Free Software Foundation.
  11    A copy of the license is included in the JUCE distribution, or can be found
  12    online at www.gnu.org/licenses.
  13
  14    JUCE is distributed in the hope that it will be useful, but WITHOUT ANY
  15    WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  16    A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
  17
  18   ------------------------------------------------------------------------------
  19
  20    To release a closed-source product which uses JUCE, commercial licenses are
  21    available: visit www.rawmaterialsoftware.com/juce for more information.
  22
  23   ==============================================================================
  24 */
  25
  26 #include "../../core/juce_StandardHeader.h"
  27
  28 BEGIN_JUCE_NAMESPACE
  29
  30 #include "juce_MidiFile.h"
  31 #include "../../io/streams/juce_MemoryOutputStream.h"
  32
  33
  34 //==============================================================================
  35 namespace MidiFileHelpers
  36 {
  37     void writeVariableLengthInt (OutputStream& out, unsigned int v)
  38     {
  39         unsigned int buffer = v & 0x7F;
  40
  41         while ((v >>= 7) != 0)
  42         {
  43             buffer <<= 8;
  44             buffer |= ((v & 0x7F) | 0x80);
  45         }
  46
  47         for (;;)
  48         {
  49             out.writeByte ((char) buffer);
  50
  51             if (buffer & 0x80)
  52                 buffer >>= 8;
  53             else
  54                 break;
  55         }
  56     }
  57
  58     bool parseMidiHeader (const uint8* &data, short& timeFormat, short& fileType, short& numberOfTracks) noexcept
  59     {
  60         unsigned int ch = (int) ByteOrder::bigEndianInt (data);
  61         data += 4;
  62
  63         if (ch != ByteOrder::bigEndianInt ("MThd"))
  64         {
  65             bool ok = false;
  66
  67             if (ch == ByteOrder::bigEndianInt ("RIFF"))
  68             {
  69                 for (int i = 0; i < 8; ++i)
  70                 {
  71                     ch = ByteOrder::bigEndianInt (data);
  72                     data += 4;
  73
  74                     if (ch == ByteOrder::bigEndianInt ("MThd"))
  75                     {
  76                         ok = true;
  77                         break;
  78                     }
  79                 }
  80             }
  81
  82             if (! ok)
  83                 return false;
  84         }
  85
  86         unsigned int bytesRemaining = ByteOrder::bigEndianInt (data);
  87         data += 4;
  88         fileType = (short) ByteOrder::bigEndianShort (data);
  89         data += 2;
  90         numberOfTracks = (short) ByteOrder::bigEndianShort (data);
  91         data += 2;
  92         timeFormat = (short) ByteOrder::bigEndianShort (data);
  93         data += 2;
  94         bytesRemaining -= 6;
  95         data += bytesRemaining;
  96
  97         return true;
  98     }
  99
 100     double convertTicksToSeconds (const double time,
 101                                   const MidiMessageSequence& tempoEvents,
 102                                   const int timeFormat)
 103     {
 104         if (timeFormat > 0)
 105         {
 106             int numer = 4, denom = 4;
 107             double tempoTime = 0.0, correctedTempoTime = 0.0;
 108             const double tickLen = 1.0 / (timeFormat & 0x7fff);
 109             double secsPerTick = 0.5 * tickLen;
 110             const int numEvents = tempoEvents.getNumEvents();
 111
 112             for (int i = 0; i < numEvents; ++i)
 113             {
 114                 const MidiMessage& m = tempoEvents.getEventPointer(i)->message;
 115
 116                 if (time <= m.getTimeStamp())
 117                     break;
 118
 119                 if (timeFormat > 0)
 120                 {
 121                     correctedTempoTime = correctedTempoTime
 122                                             + (m.getTimeStamp() - tempoTime) * secsPerTick;
 123                 }
 124                 else
 125                 {
 126                     correctedTempoTime = tickLen * m.getTimeStamp() / (((timeFormat & 0x7fff) >> 8) * (timeFormat & 0xff));
 127                 }
 128
 129                 tempoTime = m.getTimeStamp();
 130
 131                 if (m.isTempoMetaEvent())
 132                     secsPerTick = tickLen * m.getTempoSecondsPerQuarterNote();
 133                 else if (m.isTimeSignatureMetaEvent())
 134                     m.getTimeSignatureInfo (numer, denom);
 135
 136                 while (i + 1 < numEvents)
 137                 {
 138                     const MidiMessage& m2 = tempoEvents.getEventPointer(i + 1)->message;
 139                     if (m2.getTimeStamp() == tempoTime)
 140                     {
 141                         ++i;
 142
 143                         if (m2.isTempoMetaEvent())
 144                             secsPerTick = tickLen * m2.getTempoSecondsPerQuarterNote();
 145                         else if (m2.isTimeSignatureMetaEvent())
 146                             m2.getTimeSignatureInfo (numer, denom);
 147                     }
 148                     else
 149                     {
 150                         break;
 151                     }
 152                 }
 153             }
 154
 155             return correctedTempoTime + (time - tempoTime) * secsPerTick;
 156         }
 157         else
 158         {
 159             return time / (((timeFormat & 0x7fff) >> 8) * (timeFormat & 0xff));
 160         }
 161     }
 162
 163     // a comparator that puts all the note-offs before note-ons that have the same time
 164     struct Sorter
 165     {
 166         static int compareElements (const MidiMessageSequence::MidiEventHolder* const first,
 167                                     const MidiMessageSequence::MidiEventHolder* const second) noexcept
 168         {
 169             const double diff = (first->message.getTimeStamp() - second->message.getTimeStamp());
 170
 171             if (diff > 0) return 1;
 172             if (diff < 0) return -1;
 173             if (first->message.isNoteOff() && second->message.isNoteOn())   return -1;
 174             if (first->message.isNoteOn()  && second->message.isNoteOff())  return 1;
 175
 176             return 0;
 177         }
 178     };
 179 }
 180
 181 //==============================================================================
 182 MidiFile::MidiFile()
 183    : timeFormat ((short) (unsigned short) 0xe728)
 184 {
 185 }
 186
 187 MidiFile::~MidiFile()
 188 {
 189     clear();
 190 }
 191
 192 void MidiFile::clear()
 193 {
 194     tracks.clear();
 195 }
 196
 197 //==============================================================================
 198 int MidiFile::getNumTracks() const noexcept
 199 {
 200     return tracks.size();
 201 }
 202
 203 const MidiMessageSequence* MidiFile::getTrack (const int index) const noexcept
 204 {
 205     return tracks [index];
 206 }
 207
 208 void MidiFile::addTrack (const MidiMessageSequence& trackSequence)
 209 {
 210     tracks.add (new MidiMessageSequence (trackSequence));
 211 }
 212
 213 //==============================================================================
 214 short MidiFile::getTimeFormat() const noexcept
 215 {
 216     return timeFormat;
 217 }
 218
 219 void MidiFile::setTicksPerQuarterNote (const int ticks) noexcept
 220 {
 221     timeFormat = (short) ticks;
 222 }
 223
 224 void MidiFile::setSmpteTimeFormat (const int framesPerSecond,
 225                                    const int subframeResolution) noexcept
 226 {
 227     timeFormat = (short) (((-framesPerSecond) << 8) | subframeResolution);
 228 }
 229
 230 //==============================================================================
 231 void MidiFile::findAllTempoEvents (MidiMessageSequence& tempoChangeEvents) const
 232 {
 233     for (int i = tracks.size(); --i >= 0;)
 234     {
 235         const int numEvents = tracks.getUnchecked(i)->getNumEvents();
 236
 237         for (int j = 0; j < numEvents; ++j)
 238         {
 239             const MidiMessage& m = tracks.getUnchecked(i)->getEventPointer (j)->message;
 240
 241             if (m.isTempoMetaEvent())
 242                 tempoChangeEvents.addEvent (m);
 243         }
 244     }
 245 }
 246
 247 void MidiFile::findAllTimeSigEvents (MidiMessageSequence& timeSigEvents) const
 248 {
 249     for (int i = tracks.size(); --i >= 0;)
 250     {
 251         const int numEvents = tracks.getUnchecked(i)->getNumEvents();
 252
 253         for (int j = 0; j < numEvents; ++j)
 254         {
 255             const MidiMessage& m = tracks.getUnchecked(i)->getEventPointer (j)->message;
 256
 257             if (m.isTimeSignatureMetaEvent())
 258                 timeSigEvents.addEvent (m);
 259         }
 260     }
 261 }
 262
 263 double MidiFile::getLastTimestamp() const
 264 {
 265     double t = 0.0;
 266
 267     for (int i = tracks.size(); --i >= 0;)
 268         t = jmax (t, tracks.getUnchecked(i)->getEndTime());
 269
 270     return t;
 271 }
 272
 273 //==============================================================================
 274 bool MidiFile::readFrom (InputStream& sourceStream)
 275 {
 276     clear();
 277     MemoryBlock data;
 278
 279     const int maxSensibleMidiFileSize = 2 * 1024 * 1024;
 280
 281     // (put a sanity-check on the file size, as midi files are generally small)
 282     if (sourceStream.readIntoMemoryBlock (data, maxSensibleMidiFileSize))
 283     {
 284         size_t size = data.getSize();
 285         const uint8* d = static_cast <const uint8*> (data.getData());
 286         short fileType, expectedTracks;
 287
 288         if (size > 16 && MidiFileHelpers::parseMidiHeader (d, timeFormat, fileType, expectedTracks))
 289         {
 290             size -= (int) (d - static_cast <const uint8*> (data.getData()));
 291
 292             int track = 0;
 293
 294             while (size > 0 && track < expectedTracks)
 295             {
 296                 const int chunkType = (int) ByteOrder::bigEndianInt (d);
 297                 d += 4;
 298                 const int chunkSize = (int) ByteOrder::bigEndianInt (d);
 299                 d += 4;
 300
 301                 if (chunkSize <= 0)
 302                     break;
 303
 304                 if (chunkType == (int) ByteOrder::bigEndianInt ("MTrk"))
 305                 {
 306                     readNextTrack (d, chunkSize);
 307                 }
 308
 309                 size -= chunkSize + 8;
 310                 d += chunkSize;
 311                 ++track;
 312             }
 313
 314             return true;
 315         }
 316     }
 317
 318     return false;
 319 }
 320
 321 void MidiFile::readNextTrack (const uint8* data, int size)
 322 {
 323     double time = 0;
 324     char lastStatusByte = 0;
 325
 326     MidiMessageSequence result;
 327
 328     while (size > 0)
 329     {
 330         int bytesUsed;
 331         const int delay = MidiMessage::readVariableLengthVal (data, bytesUsed);
 332         data += bytesUsed;
 333         size -= bytesUsed;
 334         time += delay;
 335
 336         int messSize = 0;
 337         const MidiMessage mm (data, size, messSize, lastStatusByte, time);
 338
 339         if (messSize <= 0)
 340             break;
 341
 342         size -= messSize;
 343         data += messSize;
 344
 345         result.addEvent (mm);
 346
 347         const char firstByte = *(mm.getRawData());
 348         if ((firstByte & 0xf0) != 0xf0)
 349             lastStatusByte = firstByte;
 350     }
 351
 352     // use a sort that puts all the note-offs before note-ons that have the same time
 353     MidiFileHelpers::Sorter sorter;
 354     result.list.sort (sorter, true);
 355
 356     result.updateMatchedPairs();
 357
 358     addTrack (result);
 359 }
 360
 361 //==============================================================================
 362 void MidiFile::convertTimestampTicksToSeconds()
 363 {
 364     MidiMessageSequence tempoEvents;
 365     findAllTempoEvents (tempoEvents);
 366     findAllTimeSigEvents (tempoEvents);
 367
 368     for (int i = 0; i < tracks.size(); ++i)
 369     {
 370         MidiMessageSequence& ms = *tracks.getUnchecked(i);
 371
 372         for (int j = ms.getNumEvents(); --j >= 0;)
 373         {
 374             MidiMessage& m = ms.getEventPointer(j)->message;
 375
 376             m.setTimeStamp (MidiFileHelpers::convertTicksToSeconds (m.getTimeStamp(),
 377                                                                     tempoEvents,
 378                                                                     timeFormat));
 379         }
 380     }
 381 }
 382
 383 //==============================================================================
 384 bool MidiFile::writeTo (OutputStream& out)
 385 {
 386     out.writeIntBigEndian ((int) ByteOrder::bigEndianInt ("MThd"));
 387     out.writeIntBigEndian (6);
 388     out.writeShortBigEndian (1); // type
 389     out.writeShortBigEndian ((short) tracks.size());
 390     out.writeShortBigEndian (timeFormat);
 391
 392     for (int i = 0; i < tracks.size(); ++i)
 393         writeTrack (out, i);
 394
 395     out.flush();
 396     return true;
 397 }
 398
 399 void MidiFile::writeTrack (OutputStream& mainOut, const int trackNum)
 400 {
 401     MemoryOutputStream out;
 402
 403     const MidiMessageSequence& ms = *tracks[trackNum];
 404
 405     int lastTick = 0;
 406     char lastStatusByte = 0;
 407
 408     for (int i = 0; i < ms.getNumEvents(); ++i)
 409     {
 410         const MidiMessage& mm = ms.getEventPointer(i)->message;
 411
 412         const int tick = roundToInt (mm.getTimeStamp());
 413         const int delta = jmax (0, tick - lastTick);
 414         MidiFileHelpers::writeVariableLengthInt (out, delta);
 415         lastTick = tick;
 416
 417         const char statusByte = *(mm.getRawData());
 418
 419         if ((statusByte == lastStatusByte)
 420              && ((statusByte & 0xf0) != 0xf0)
 421              && i > 0
 422              && mm.getRawDataSize() > 1)
 423         {
 424             out.write (mm.getRawData() + 1, mm.getRawDataSize() - 1);
 425         }
 426         else
 427         {
 428             out.write (mm.getRawData(), mm.getRawDataSize());
 429         }
 430
 431         lastStatusByte = statusByte;
 432     }
 433
 434     out.writeByte (0);
 435     const MidiMessage m (MidiMessage::endOfTrack());
 436     out.write (m.getRawData(),
 437                m.getRawDataSize());
 438
 439     mainOut.writeIntBigEndian ((int) ByteOrder::bigEndianInt ("MTrk"));
 440     mainOut.writeIntBigEndian ((int) out.getDataSize());
 441     mainOut << out;
 442 }
 443
 444 END_JUCE_NAMESPACE