comparison data/fileio/MIDIFileReader.cpp @ 1527:710e6250a401 zoom

Merge from default branch

 using std::map;
 using std::set;
 
 using namespace MIDIConstants;
 
-//#define MIDI_SVDEBUG 1
+//#define MIDI_DEBUG 1
 
 
 MIDIFileReader::MIDIFileReader(QString path,
                                MIDIFileImportPreferenceAcquirer *acquirer,
-			       sv_samplerate_t mainModelSampleRate) :
+                               sv_samplerate_t mainModelSampleRate,
+                               ProgressReporter *) : // we don't actually report progress
     m_smpte(false),
     m_timingDivision(0),
     m_fps(0),
     m_subframes(0),
     m_format(MIDI_FILE_BAD_FORMAT),

     m_fileSize(0),
     m_mainModelSampleRate(mainModelSampleRate),
     m_acquirer(acquirer)
 {
     if (parseFile()) {
-	m_error = "";
+        m_error = "";
     }
 }
 
 MIDIFileReader::~MIDIFileReader()
 {
     for (MIDIComposition::iterator i = m_midiComposition.begin();
-	 i != m_midiComposition.end(); ++i) {
-	
-	for (MIDITrack::iterator j = i->second.begin();
-	     j != i->second.end(); ++j) {
-	    delete *j;
-	}
-
-	i->second.clear();
+         i != m_midiComposition.end(); ++i) {
+        
+        for (MIDITrack::iterator j = i->second.begin();
+             j != i->second.end(); ++j) {
+            delete *j;
+        }
+
+        i->second.clear();
     }
 
     m_midiComposition.clear();
 }
 

 
 long
 MIDIFileReader::midiBytesToLong(const string& bytes)
 {
     if (bytes.length() != 4) {
-	throw MIDIException(tr("Wrong length for long data in MIDI stream (%1, should be %2)").arg(bytes.length()).arg(4));
+        throw MIDIException(tr("Wrong length for long data in MIDI stream (%1, should be %2)").arg(bytes.length()).arg(4));
     }
 
     long longRet = ((long)(((MIDIByte)bytes[0]) << 24)) |
                    ((long)(((MIDIByte)bytes[1]) << 16)) |
                    ((long)(((MIDIByte)bytes[2]) << 8)) |

 
 int
 MIDIFileReader::midiBytesToInt(const string& bytes)
 {
     if (bytes.length() != 2) {
-	throw MIDIException(tr("Wrong length for int data in MIDI stream (%1, should be %2)").arg(bytes.length()).arg(2));
+        throw MIDIException(tr("Wrong length for int data in MIDI stream (%1, should be %2)").arg(bytes.length()).arg(2));
     }
 
     int intRet = ((int)(((MIDIByte)bytes[0]) << 8)) |
                  ((int)(((MIDIByte)bytes[1])));
     return(intRet);

 //
 MIDIByte
 MIDIFileReader::getMIDIByte()
 {
     if (!m_midiFile) {
-	throw MIDIException(tr("getMIDIByte called but no MIDI file open"));
+        throw MIDIException(tr("getMIDIByte called but no MIDI file open"));
     }
 
     if (m_midiFile->eof()) {
         throw MIDIException(tr("End of MIDI file encountered while reading"));
     }

         throw MIDIException(tr("Attempt to get more bytes than expected on Track"));
     }
 
     char byte;
     if (m_midiFile->read(&byte, 1)) {
-	--m_trackByteCount;
-	return (MIDIByte)byte;
+        --m_trackByteCount;
+        return (MIDIByte)byte;
     }
 
     throw MIDIException(tr("Attempt to read past MIDI file end"));
 }
 

 //
 string
 MIDIFileReader::getMIDIBytes(unsigned long numberOfBytes)
 {
     if (!m_midiFile) {
-	throw MIDIException(tr("getMIDIBytes called but no MIDI file open"));
+        throw MIDIException(tr("getMIDIBytes called but no MIDI file open"));
     }
 
     if (m_midiFile->eof()) {
         throw MIDIException(tr("End of MIDI file encountered while reading"));
     }

 //
 long
 MIDIFileReader::getNumberFromMIDIBytes(int firstByte)
 {
     if (!m_midiFile) {
-	throw MIDIException(tr("getNumberFromMIDIBytes called but no MIDI file open"));
+        throw MIDIException(tr("getNumberFromMIDIBytes called but no MIDI file open"));
     }
 
     long longRet = 0;
     MIDIByte midiByte;
 
     if (firstByte >= 0) {
-	midiByte = (MIDIByte)firstByte;
+        midiByte = (MIDIByte)firstByte;
     } else if (m_midiFile->eof()) {
-	return longRet;
+        return longRet;
     } else {
-	midiByte = getMIDIByte();
+        midiByte = getMIDIByte();
     }
 
     longRet = midiByte;
     if (midiByte & 0x80) {
-	longRet &= 0x7F;
-	do {
-	    midiByte = getMIDIByte();
-	    longRet = (longRet << 7) + (midiByte & 0x7F);
-	} while (!m_midiFile->eof() && (midiByte & 0x80));
+        longRet &= 0x7F;
+        do {
+            midiByte = getMIDIByte();
+            longRet = (longRet << 7) + (midiByte & 0x7F);
+        } while (!m_midiFile->eof() && (midiByte & 0x80));
     }
 
     return longRet;
 }
 

 //
 bool
 MIDIFileReader::skipToNextTrack()
 {
     if (!m_midiFile) {
-	throw MIDIException(tr("skipToNextTrack called but no MIDI file open"));
+        throw MIDIException(tr("skipToNextTrack called but no MIDI file open"));
     }
 
     string buffer, buffer2;
     m_trackByteCount = -1;
     m_decrementCount = false;
 
     while (!m_midiFile->eof() && (m_decrementCount == false)) {
         buffer = getMIDIBytes(4); 
-	if (buffer.compare(0, 4, MIDI_TRACK_HEADER) == 0) {
-	    m_trackByteCount = midiBytesToLong(getMIDIBytes(4));
-	    m_decrementCount = true;
-	}
+        if (buffer.compare(0, 4, MIDI_TRACK_HEADER) == 0) {
+            m_trackByteCount = midiBytesToLong(getMIDIBytes(4));
+            m_decrementCount = true;
+        }
     }
 
     if (m_trackByteCount == -1) { // we haven't found a track
         return false;
     } else {

     SVDEBUG << "MIDIFileReader::open() : fileName = " << m_fileName.c_str() << endl;
 #endif
 
     // Open the file
     m_midiFile = new ifstream(m_path.toLocal8Bit().data(),
-			      ios::in | ios::binary);
+                              ios::in | ios::binary);
 
     if (!*m_midiFile) {
-	m_error = "File not found or not readable.";
-	m_format = MIDI_FILE_BAD_FORMAT;
-	delete m_midiFile;
+        m_error = "File not found or not readable.";
+        m_format = MIDI_FILE_BAD_FORMAT;
+        delete m_midiFile;
         m_midiFile = 0;
-	return false;
+        return false;
     }
 
     bool retval = false;
 
     try {
 
-	// Set file size so we can count it off
-	//
-	m_midiFile->seekg(0, ios::end);
+        // Set file size so we can count it off
+        //
+        m_midiFile->seekg(0, ios::end);
         std::streamoff off = m_midiFile->tellg();
-	m_fileSize = 0;
+        m_fileSize = 0;
         if (off > 0) m_fileSize = off;
-	m_midiFile->seekg(0, ios::beg);
-
-	// Parse the MIDI header first.  The first 14 bytes of the file.
-	if (!parseHeader(getMIDIBytes(14))) {
-	    m_format = MIDI_FILE_BAD_FORMAT;
-	    m_error = "Not a MIDI file.";
-	    goto done;
-	}
-
-	unsigned int i = 0;
-
-	for (unsigned int j = 0; j < m_numberOfTracks; ++j) {
-
-#ifdef MIDI_DEBUG
-	    SVDEBUG << "Parsing Track " << j << endl;
-#endif
-
-	    if (!skipToNextTrack()) {
-#ifdef MIDI_DEBUG
-		cerr << "Couldn't find Track " << j << endl;
-#endif
-		m_error = "File corrupted or in non-standard format?";
-		m_format = MIDI_FILE_BAD_FORMAT;
-		goto done;
-	    }
-
-#ifdef MIDI_DEBUG
-	    cerr << "Track has " << m_trackByteCount << " bytes" << endl;
-#endif
-
-	    // Run through the events taking them into our internal
-	    // representation.
-	    if (!parseTrack(i)) {
-#ifdef MIDI_DEBUG
-		cerr << "Track " << j << " parsing failed" << endl;
-#endif
-		m_error = "File corrupted or in non-standard format?";
-		m_format = MIDI_FILE_BAD_FORMAT;
-		goto done;
-	    }
-
-	    ++i; // j is the source track number, i the destination
-	}
-	
-	m_numberOfTracks = i;
-	retval = true;
-
-    } catch (MIDIException e) {
+        m_midiFile->seekg(0, ios::beg);
+
+        // Parse the MIDI header first.  The first 14 bytes of the file.
+        if (!parseHeader(getMIDIBytes(14))) {
+            m_format = MIDI_FILE_BAD_FORMAT;
+            m_error = "Not a MIDI file.";
+            goto done;
+        }
+
+        unsigned int i = 0;
+
+        for (unsigned int j = 0; j < m_numberOfTracks; ++j) {
+
+#ifdef MIDI_DEBUG
+            SVDEBUG << "Parsing Track " << j << endl;
+#endif
+
+            if (!skipToNextTrack()) {
+#ifdef MIDI_DEBUG
+                SVDEBUG << "Couldn't find Track " << j << endl;
+#endif
+                m_error = "File corrupted or in non-standard format?";
+                m_format = MIDI_FILE_BAD_FORMAT;
+                goto done;
+            }
+
+#ifdef MIDI_DEBUG
+            SVDEBUG << "Track has " << m_trackByteCount << " bytes" << endl;
+#endif
+
+            // Run through the events taking them into our internal
+            // representation.
+            if (!parseTrack(i)) {
+#ifdef MIDI_DEBUG
+                SVDEBUG << "Track " << j << " parsing failed" << endl;
+#endif
+                m_error = "File corrupted or in non-standard format?";
+                m_format = MIDI_FILE_BAD_FORMAT;
+                goto done;
+            }
+
+            ++i; // j is the source track number, i the destination
+        }
+        
+        m_numberOfTracks = i;
+        retval = true;
+
+    } catch (const MIDIException &e) {
 
         SVDEBUG << "MIDIFileReader::open() - caught exception - " << e.what() << endl;
-	m_error = e.what();
+        m_error = e.what();
     }
     
 done:
     m_midiFile->close();
     delete m_midiFile;

 
         // Convert the deltaTime to an absolute time since the track
         // start.  The addTime method returns the sum of the current
         // MIDI Event delta time plus the argument.
 
-	unsigned long acc = 0;
+        unsigned long acc = 0;
 
         for (MIDITrack::iterator i = m_midiComposition[track].begin();
              i != m_midiComposition[track].end(); ++i) {
             acc = (*i)->addTime(acc);
         }
 
         if (consolidateNoteOffEvents(track)) { // returns true if some notes exist
-	    m_loadableTracks.insert(track);
-	}
+            m_loadableTracks.insert(track);
+        }
     }
 
     for (unsigned int track = 0; track < m_numberOfTracks; ++track) {
         updateTempoMap(track);
     }

         return false;
     }
 
     if (midiHeader.compare(0, 4, MIDI_FILE_HEADER) != 0) {
 #ifdef MIDI_DEBUG
-	SVDEBUG << "MIDIFileReader::parseHeader()"
-	     << "- file header not found or malformed"
-	     << endl;
-#endif
-	return false;
+        SVDEBUG << "MIDIFileReader::parseHeader()"
+             << "- file header not found or malformed"
+             << endl;
+#endif
+        return false;
     }
 
     if (midiBytesToLong(midiHeader.substr(4,4)) != 6L) {
 #ifdef MIDI_DEBUG
         SVDEBUG << "MIDIFileReader::parseHeader()"
-	     << " - header length incorrect"
-	     << endl;
+             << " - header length incorrect"
+             << endl;
 #endif
         return false;
     }
 
     m_format = (MIDIFileFormatType) midiBytesToInt(midiHeader.substr(8,2));

 
     bool firstTrack = true;
 
     while (!m_midiFile->eof() && (m_trackByteCount > 0)) {
 
-	if (eventCode < 0x80) {
-#ifdef MIDI_DEBUG
-	    cerr << "WARNING: Invalid event code " << eventCode
-		 << " in MIDI file" << endl;
-#endif
-	    throw MIDIException(tr("Invalid event code %1 found").arg(int(eventCode)));
-	}
+        if (eventCode < 0x80) {
+#ifdef MIDI_DEBUG
+            SVDEBUG << "WARNING: Invalid event code " << eventCode
+                 << " in MIDI file" << endl;
+#endif
+            throw MIDIException(tr("Invalid event code %1 found").arg(int(eventCode)));
+        }
 
         deltaTime = getNumberFromMIDIBytes();
 
 #ifdef MIDI_DEBUG
-	cerr << "read delta time " << deltaTime << endl;
+        SVDEBUG << "read delta time " << deltaTime << endl;
 #endif
 
         // Get a single byte
         midiByte = getMIDIByte();
 
         if (!(midiByte & MIDI_STATUS_BYTE_MASK)) {
 
-	    if (runningStatus < 0) {
-		throw MIDIException(tr("Running status used for first event in track"));
-	    }
-
-	    eventCode = (MIDIByte)runningStatus;
-	    data1 = midiByte;
-
-#ifdef MIDI_DEBUG
-	    SVDEBUG << "using running status (byte " << int(midiByte) << " found)" << endl;
+            if (runningStatus < 0) {
+                throw MIDIException(tr("Running status used for first event in track"));
+            }
+
+            eventCode = (MIDIByte)runningStatus;
+            data1 = midiByte;
+
+#ifdef MIDI_DEBUG
+            SVDEBUG << "using running status (byte " << int(midiByte) << " found)" << endl;
 #endif
         } else {
 #ifdef MIDI_DEBUG
-	    cerr << "have new event code " << int(midiByte) << endl;
+            SVDEBUG << "have new event code " << int(midiByte) << endl;
 #endif
             eventCode = midiByte;
-	    data1 = getMIDIByte();
-	}
+            data1 = getMIDIByte();
+        }
 
         if (eventCode == MIDI_FILE_META_EVENT) {
 
-	    metaEventCode = data1;
+            metaEventCode = data1;
             messageLength = getNumberFromMIDIBytes();
 
 //#ifdef MIDI_DEBUG
-		cerr << "Meta event of type " << int(metaEventCode) << " and " << messageLength << " bytes found, putting on track " << metaTrack << endl;
+                SVDEBUG << "Meta event of type " << int(metaEventCode) << " and " << messageLength << " bytes found, putting on track " << metaTrack << endl;
 //#endif
             metaMessage = getMIDIBytes(messageLength);
 
-	    long gap = accumulatedTime - trackTimeMap[metaTrack];
-	    accumulatedTime += deltaTime;
-	    deltaTime += gap;
-	    trackTimeMap[metaTrack] = accumulatedTime;
+            long gap = accumulatedTime - trackTimeMap[metaTrack];
+            accumulatedTime += deltaTime;
+            deltaTime += gap;
+            trackTimeMap[metaTrack] = accumulatedTime;
 
             MIDIEvent *e = new MIDIEvent(deltaTime,
                                          MIDI_FILE_META_EVENT,
                                          metaEventCode,
                                          metaMessage);
 
-	    m_midiComposition[metaTrack].push_back(e);
-
-	    if (metaEventCode == MIDI_TRACK_NAME) {
-		m_trackNames[metaTrack] = metaMessage.c_str();
-	    }
+            m_midiComposition[metaTrack].push_back(e);
+
+            if (metaEventCode == MIDI_TRACK_NAME) {
+                m_trackNames[metaTrack] = metaMessage.c_str();
+            }
 
         } else { // non-meta events
 
-	    runningStatus = eventCode;
+            runningStatus = eventCode;
 
             MIDIEvent *midiEvent;
 
-	    int channel = (eventCode & MIDI_CHANNEL_NUM_MASK);
-	    if (channelTrackMap[channel] == -1) {
-		if (!firstTrack) ++lastTrackNum;
-		else firstTrack = false;
-		channelTrackMap[channel] = lastTrackNum;
-	    }
-
-	    unsigned int trackNum = channelTrackMap[channel];
-	    
-	    // accumulatedTime is abs time of last event on any track;
-	    // trackTimeMap[trackNum] is that of last event on this track
-	    
-	    long gap = accumulatedTime - trackTimeMap[trackNum];
-	    accumulatedTime += deltaTime;
-	    deltaTime += gap;
-	    trackTimeMap[trackNum] = accumulatedTime;
+            int channel = (eventCode & MIDI_CHANNEL_NUM_MASK);
+            if (channelTrackMap[channel] == -1) {
+                if (!firstTrack) ++lastTrackNum;
+                else firstTrack = false;
+                channelTrackMap[channel] = lastTrackNum;
+            }
+
+            unsigned int trackNum = channelTrackMap[channel];
+            
+            // accumulatedTime is abs time of last event on any track;
+            // trackTimeMap[trackNum] is that of last event on this track
+            
+            long gap = accumulatedTime - trackTimeMap[trackNum];
+            accumulatedTime += deltaTime;
+            deltaTime += gap;
+            trackTimeMap[trackNum] = accumulatedTime;
 
             switch (eventCode & MIDI_MESSAGE_TYPE_MASK) {
 
             case MIDI_NOTE_ON:
             case MIDI_NOTE_OFF:

 
                 // create and store our event
                 midiEvent = new MIDIEvent(deltaTime, eventCode, data1, data2);
 
                 /*
-		cerr << "MIDI event for channel " << channel << " (track "
-			  << trackNum << ")" << endl;
-		midiEvent->print();
+                SVDEBUG << "MIDI event for channel " << channel << " (track "
+                          << trackNum << ")" << endl;
+                midiEvent->print();
                           */
 
 
                 m_midiComposition[trackNum].push_back(midiEvent);
 
-		if (midiEvent->getChannelNumber() == MIDI_PERCUSSION_CHANNEL) {
-		    m_percussionTracks.insert(trackNum);
-		}
+                if (midiEvent->getChannelNumber() == MIDI_PERCUSSION_CHANNEL) {
+                    m_percussionTracks.insert(trackNum);
+                }
 
                 break;
 
             case MIDI_PITCH_BEND:
                 data2 = getMIDIByte();

 
             case MIDI_SYSTEM_EXCLUSIVE:
                 messageLength = getNumberFromMIDIBytes(data1);
 
 #ifdef MIDI_DEBUG
-		cerr << "SysEx of " << messageLength << " bytes found" << endl;
+                SVDEBUG << "SysEx of " << messageLength << " bytes found" << endl;
 #endif
 
                 metaMessage= getMIDIBytes(messageLength);
 
                 if (MIDIByte(metaMessage[metaMessage.length() - 1]) !=

             } 
         }
     }
 
     if (lastTrackNum > metaTrack) {
-	for (unsigned int track = metaTrack + 1; track <= lastTrackNum; ++track) {
-	    m_trackNames[track] = QString("%1 <%2>")
-		.arg(m_trackNames[metaTrack]).arg(track - metaTrack + 1);
-	}
+        for (unsigned int track = metaTrack + 1; track <= lastTrackNum; ++track) {
+            m_trackNames[track] = QString("%1 <%2>")
+                .arg(m_trackNames[metaTrack]).arg(track - metaTrack + 1);
+        }
     }
 
     return true;
 }
 

 {
     bool notesOnTrack = false;
     bool noteOffFound;
 
     for (MIDITrack::iterator i = m_midiComposition[track].begin();
-	 i != m_midiComposition[track].end(); i++) {
+         i != m_midiComposition[track].end(); i++) {
 
         if ((*i)->getMessageType() == MIDI_NOTE_ON && (*i)->getVelocity() > 0) {
 
-	    notesOnTrack = true;
+            notesOnTrack = true;
             noteOffFound = false;
 
             for (MIDITrack::iterator j = i;
-		 j != m_midiComposition[track].end(); j++) {
+                 j != m_midiComposition[track].end(); j++) {
 
                 if (((*j)->getChannelNumber() == (*i)->getChannelNumber()) &&
-		    ((*j)->getPitch() == (*i)->getPitch()) &&
+                    ((*j)->getPitch() == (*i)->getPitch()) &&
                     ((*j)->getMessageType() == MIDI_NOTE_OFF ||
                     ((*j)->getMessageType() == MIDI_NOTE_ON &&
                      (*j)->getVelocity() == 0x00))) {
 
                     (*i)->setDuration((*j)->getTime() - (*i)->getTime());

 
             // If no matching NOTE OFF has been found then set
             // Event duration to length of track
             //
             if (!noteOffFound) {
-		MIDITrack::iterator j = m_midiComposition[track].end();
-		--j;
+                MIDITrack::iterator j = m_midiComposition[track].end();
+                --j;
                 (*i)->setDuration((*j)->getTime() - (*i)->getTime());
-	    }
+            }
         }
     }
 
     return notesOnTrack;
 }

 // Add any tempo events found in the given track to the global tempo map.
 //
 void
 MIDIFileReader::updateTempoMap(unsigned int track)
 {
-    cerr << "updateTempoMap for track " << track << " (" << m_midiComposition[track].size() << " events)" << endl;
+    SVDEBUG << "updateTempoMap for track " << track << " (" << m_midiComposition[track].size() << " events)" << endl;
 
     for (MIDITrack::iterator i = m_midiComposition[track].begin();
-	 i != m_midiComposition[track].end(); ++i) {
+         i != m_midiComposition[track].end(); ++i) {
 
         if ((*i)->isMeta() &&
-	    (*i)->getMetaEventCode() == MIDI_SET_TEMPO) {
-
-	    MIDIByte m0 = (*i)->getMetaMessage()[0];
-	    MIDIByte m1 = (*i)->getMetaMessage()[1];
-	    MIDIByte m2 = (*i)->getMetaMessage()[2];
-	    
-	    long tempo = (((m0 << 8) + m1) << 8) + m2;
-
-	    cerr << "updateTempoMap: have tempo, it's " << tempo << " at " << (*i)->getTime() << endl;
-
-	    if (tempo != 0) {
-		double qpm = 60000000.0 / double(tempo);
-		m_tempoMap[(*i)->getTime()] =
-		    TempoChange(RealTime::zeroTime, qpm);
-	    }
+            (*i)->getMetaEventCode() == MIDI_SET_TEMPO) {
+
+            MIDIByte m0 = (*i)->getMetaMessage()[0];
+            MIDIByte m1 = (*i)->getMetaMessage()[1];
+            MIDIByte m2 = (*i)->getMetaMessage()[2];
+            
+            long tempo = (((m0 << 8) + m1) << 8) + m2;
+
+            SVDEBUG << "updateTempoMap: have tempo, it's " << tempo << " at " << (*i)->getTime() << endl;
+
+            if (tempo != 0) {
+                double qpm = 60000000.0 / double(tempo);
+                m_tempoMap[(*i)->getTime()] =
+                    TempoChange(RealTime::zeroTime, qpm);
+            }
         }
     }
 }
 
 void

     double tempo = 120.0;
     int td = m_timingDivision;
     if (td == 0) td = 96;
 
     for (TempoMap::iterator i = m_tempoMap.begin(); i != m_tempoMap.end(); ++i) {
-	
-	unsigned long mtime = i->first;
-	unsigned long melapsed = mtime - lastMIDITime;
-	double quarters = double(melapsed) / double(td);
-	double seconds = (60.0 * quarters) / tempo;
-
-	RealTime t = lastRealTime + RealTime::fromSeconds(seconds);
-
-	i->second.first = t;
-
-	lastRealTime = t;
-	lastMIDITime = mtime;
-	tempo = i->second.second;
+        
+        unsigned long mtime = i->first;
+        unsigned long melapsed = mtime - lastMIDITime;
+        double quarters = double(melapsed) / double(td);
+        double seconds = (60.0 * quarters) / tempo;
+
+        RealTime t = lastRealTime + RealTime::fromSeconds(seconds);
+
+        i->second.first = t;
+
+        lastRealTime = t;
+        lastMIDITime = mtime;
+        tempo = i->second.second;
     }
 }
 
 RealTime
 MIDIFileReader::getTimeForMIDITime(unsigned long midiTime) const

     RealTime tempoRealTime = RealTime::zeroTime;
     double tempo = 120.0;
 
     TempoMap::const_iterator i = m_tempoMap.lower_bound(midiTime);
     if (i != m_tempoMap.begin()) {
-	--i;
-	tempoMIDITime = i->first;
-	tempoRealTime = i->second.first;
-	tempo = i->second.second;
+        --i;
+        tempoMIDITime = i->first;
+        tempoRealTime = i->second.first;
+        tempo = i->second.second;
     }
 
     int td = m_timingDivision;
     if (td == 0) td = 96;
 

     double quarters = double(melapsed) / double(td);
     double seconds = (60.0 * quarters) / tempo;
 
 /*
     SVDEBUG << "MIDIFileReader::getTimeForMIDITime(" << midiTime << ")"
-	      << endl;
+              << endl;
     SVDEBUG << "timing division = " << td << endl;
-    cerr << "nearest tempo event (of " << m_tempoMap.size() << ") is at " << tempoMIDITime << " ("
-	      << tempoRealTime << ")" << endl;
-    cerr << "quarters since then = " << quarters << endl;
-    cerr << "tempo = " << tempo << " quarters per minute" << endl;
-    cerr << "seconds since then = " << seconds << endl;
+    SVDEBUG << "nearest tempo event (of " << m_tempoMap.size() << ") is at " << tempoMIDITime << " ("
+              << tempoRealTime << ")" << endl;
+    SVDEBUG << "quarters since then = " << quarters << endl;
+    SVDEBUG << "tempo = " << tempo << " quarters per minute" << endl;
+    SVDEBUG << "seconds since then = " << seconds << endl;
     SVDEBUG << "resulting time = " << (tempoRealTime + RealTime::fromSeconds(seconds)) << endl;
 */
 
     return tempoRealTime + RealTime::fromSeconds(seconds);
 }

     if (m_loadableTracks.empty()) {
         if (m_acquirer) {
             m_acquirer->showError
                 (tr("MIDI file \"%1\" has no notes in any track").arg(m_path));
         }
-	return 0;
+        return 0;
     }
 
     std::set<unsigned int> tracksToLoad;
 
     if (m_loadableTracks.size() == 1) {
 
-	tracksToLoad.insert(*m_loadableTracks.begin());
+        tracksToLoad.insert(*m_loadableTracks.begin());
 
     } else {
 
         QStringList displayNames;
 
-	for (set<unsigned int>::iterator i = m_loadableTracks.begin();
-	     i != m_loadableTracks.end(); ++i) {
-
-	    unsigned int trackNo = *i;
-	    QString label;
-
-	    QString perc;
-	    if (m_percussionTracks.find(trackNo) != m_percussionTracks.end()) {
-		perc = tr(" - uses GM percussion channel");
-	    }
-
-	    if (m_trackNames.find(trackNo) != m_trackNames.end()) {
-		label = tr("Track %1 (%2)%3")
-		    .arg(trackNo).arg(m_trackNames.find(trackNo)->second)
-		    .arg(perc);
-	    } else {
-		label = tr("Track %1 (untitled)%3").arg(trackNo).arg(perc);
-	    }
+        for (set<unsigned int>::iterator i = m_loadableTracks.begin();
+             i != m_loadableTracks.end(); ++i) {
+
+            unsigned int trackNo = *i;
+            QString label;
+
+            QString perc;
+            if (m_percussionTracks.find(trackNo) != m_percussionTracks.end()) {
+                perc = tr(" - uses GM percussion channel");
+            }
+
+            if (m_trackNames.find(trackNo) != m_trackNames.end()) {
+                label = tr("Track %1 (%2)%3")
+                    .arg(trackNo).arg(m_trackNames.find(trackNo)->second)
+                    .arg(perc);
+            } else {
+                label = tr("Track %1 (untitled)%3").arg(trackNo).arg(perc);
+            }
 
             displayNames << label;
-	}
+        }
 
         QString singleTrack;
 
         bool haveSomePercussion = 
             (!m_percussionTracks.empty() &&

             pref == MIDIFileImportPreferenceAcquirer::MergeAllNonPercussionTracks) {
             
             for (set<unsigned int>::iterator i = m_loadableTracks.begin();
                  i != m_loadableTracks.end(); ++i) {
                 
-		if (pref == MIDIFileImportPreferenceAcquirer::MergeAllTracks ||
-		    m_percussionTracks.find(*i) == m_percussionTracks.end()) {
+                if (pref == MIDIFileImportPreferenceAcquirer::MergeAllTracks ||
+                    m_percussionTracks.find(*i) == m_percussionTracks.end()) {
                     
-		    tracksToLoad.insert(*i);
-		}
-	    }
-
-	} else {
-	    
-	    int j = 0;
-
-	    for (set<unsigned int>::iterator i = m_loadableTracks.begin();
-		 i != m_loadableTracks.end(); ++i) {
-		
-		if (singleTrack == displayNames[j]) {
-		    tracksToLoad.insert(*i);
-		    break;
-		}
-		
-		++j;
-	    }
-	}
+                    tracksToLoad.insert(*i);
+                }
+            }
+
+        } else {
+            
+            int j = 0;
+
+            for (set<unsigned int>::iterator i = m_loadableTracks.begin();
+                 i != m_loadableTracks.end(); ++i) {
+                
+                if (singleTrack == displayNames[j]) {
+                    tracksToLoad.insert(*i);
+                    break;
+                }
+                
+                ++j;
+            }
+        }
     }
 
     if (tracksToLoad.empty()) return 0;
 
     int n = int(tracksToLoad.size()), count = 0;
     Model *model = 0;
 
     for (std::set<unsigned int>::iterator i = tracksToLoad.begin();
-	 i != tracksToLoad.end(); ++i) {
-
-	int minProgress = (100 * count) / n;
-	int progressAmount = 100 / n;
-
-	model = loadTrack(*i, model, minProgress, progressAmount);
-
-	++count;
+         i != tracksToLoad.end(); ++i) {
+
+        int minProgress = (100 * count) / n;
+        int progressAmount = 100 / n;
+
+        model = loadTrack(*i, model, minProgress, progressAmount);
+
+        ++count;
     }
 
     if (dynamic_cast<NoteModel *>(model)) {
-	dynamic_cast<NoteModel *>(model)->setCompletion(100);
+        dynamic_cast<NoteModel *>(model)->setCompletion(100);
     }
 
     return model;
 }
 
 Model *
 MIDIFileReader::loadTrack(unsigned int trackToLoad,
-			  Model *existingModel,
-			  int minProgress,
-			  int progressAmount) const
+                          Model *existingModel,
+                          int minProgress,
+                          int progressAmount) const
 {
     if (m_midiComposition.find(trackToLoad) == m_midiComposition.end()) {
-	return 0;
+        return 0;
     }
 
     NoteModel *model = 0;
 
     if (existingModel) {
-	model = dynamic_cast<NoteModel *>(existingModel);
-	if (!model) {
-	    cerr << "WARNING: MIDIFileReader::loadTrack: Existing model given, but it isn't a NoteModel -- ignoring it" << endl;
-	}
+        model = dynamic_cast<NoteModel *>(existingModel);
+        if (!model) {
+            SVDEBUG << "WARNING: MIDIFileReader::loadTrack: Existing model given, but it isn't a NoteModel -- ignoring it" << endl;
+        }
     }
 
     if (!model) {
-	model = new NoteModel(m_mainModelSampleRate, 1, 0.0, 0.0, false);
-	model->setValueQuantization(1.0);
+        model = new NoteModel(m_mainModelSampleRate, 1, 0.0, 0.0, false);
+        model->setValueQuantization(1.0);
         model->setObjectName(QFileInfo(m_path).fileName());
     }
 
     const MIDITrack &track = m_midiComposition.find(trackToLoad)->second;
 

             rt = RealTime::frame2RealTime(midiTime, m_fps * m_subframes);
         } else {
             rt = getTimeForMIDITime(midiTime);
         }
 
-	// We ignore most of these event types for now, though in
-	// theory some of the text ones could usefully be incorporated
-
-	if ((*i)->isMeta()) {
-
-	    switch((*i)->getMetaEventCode()) {
-
-	    case MIDI_KEY_SIGNATURE:
-		// minorKey = (int((*i)->getMetaMessage()[1]) != 0);
-		sharpKey = (int((*i)->getMetaMessage()[0]) >= 0);
-		break;
-
-	    case MIDI_TEXT_EVENT:
-	    case MIDI_LYRIC:
-	    case MIDI_TEXT_MARKER:
-	    case MIDI_COPYRIGHT_NOTICE:
-	    case MIDI_TRACK_NAME:
-		// The text events that we could potentially use
-		break;
-
-	    case MIDI_SET_TEMPO:
-		// Already dealt with in a separate pass previously
-		break;
-
-	    case MIDI_TIME_SIGNATURE:
-		// Not yet!
-		break;
-
-	    case MIDI_SEQUENCE_NUMBER:
-	    case MIDI_CHANNEL_PREFIX_OR_PORT:
-	    case MIDI_INSTRUMENT_NAME:
-	    case MIDI_CUE_POINT:
-	    case MIDI_CHANNEL_PREFIX:
-	    case MIDI_SEQUENCER_SPECIFIC:
-	    case MIDI_SMPTE_OFFSET:
-	    default:
-		break;
-	    }
-
-	} else {
-
-	    switch ((*i)->getMessageType()) {
-
-	    case MIDI_NOTE_ON:
+        // We ignore most of these event types for now, though in
+        // theory some of the text ones could usefully be incorporated
+
+        if ((*i)->isMeta()) {
+
+            switch((*i)->getMetaEventCode()) {
+
+            case MIDI_KEY_SIGNATURE:
+                // minorKey = (int((*i)->getMetaMessage()[1]) != 0);
+                sharpKey = (int((*i)->getMetaMessage()[0]) >= 0);
+                break;
+
+            case MIDI_TEXT_EVENT:
+            case MIDI_LYRIC:
+            case MIDI_TEXT_MARKER:
+            case MIDI_COPYRIGHT_NOTICE:
+            case MIDI_TRACK_NAME:
+                // The text events that we could potentially use
+                break;
+
+            case MIDI_SET_TEMPO:
+                // Already dealt with in a separate pass previously
+                break;
+
+            case MIDI_TIME_SIGNATURE:
+                // Not yet!
+                break;
+
+            case MIDI_SEQUENCE_NUMBER:
+            case MIDI_CHANNEL_PREFIX_OR_PORT:
+            case MIDI_INSTRUMENT_NAME:
+            case MIDI_CUE_POINT:
+            case MIDI_CHANNEL_PREFIX:
+            case MIDI_SEQUENCER_SPECIFIC:
+            case MIDI_SMPTE_OFFSET:
+            default:
+                break;
+            }
+
+        } else {
+
+            switch ((*i)->getMessageType()) {
+
+            case MIDI_NOTE_ON:
 
                 if ((*i)->getVelocity() == 0) break; // effective note-off
-		else {
-		    RealTime endRT;
+                else {
+                    RealTime endRT;
                     unsigned long endMidiTime = (*i)->getTime() + (*i)->getDuration();
                     if (m_smpte) {
                         endRT = RealTime::frame2RealTime(endMidiTime, m_fps * m_subframes);
                     } else {
                         endRT = getTimeForMIDITime(endMidiTime);
                     }
 
-		    long startFrame = RealTime::realTime2Frame
-			(rt, model->getSampleRate());
-
-		    long endFrame = RealTime::realTime2Frame
-			(endRT, model->getSampleRate());
-
-		    QString pitchLabel = Pitch::getPitchLabel((*i)->getPitch(),
-							      0, 
-							      !sharpKey);
-
-		    QString noteLabel = tr("%1 - vel %2")
-			.arg(pitchLabel).arg(int((*i)->getVelocity()));
+                    long startFrame = RealTime::realTime2Frame
+                        (rt, model->getSampleRate());
+
+                    long endFrame = RealTime::realTime2Frame
+                        (endRT, model->getSampleRate());
+
+                    QString pitchLabel = Pitch::getPitchLabel((*i)->getPitch(),
+                                                              0, 
+                                                              !sharpKey);
+
+                    QString noteLabel = tr("%1 - vel %2")
+                        .arg(pitchLabel).arg(int((*i)->getVelocity()));
 
                     float level = float((*i)->getVelocity()) / 128.f;
 
-		    Note note(startFrame, (*i)->getPitch(),
-			      endFrame - startFrame, level, noteLabel);
-
-//		    SVDEBUG << "Adding note " << startFrame << "," << (endFrame-startFrame) << " : " << int((*i)->getPitch()) << endl;
-
-		    model->addPoint(note);
-		    break;
-		}
+                    Note note(startFrame, (*i)->getPitch(),
+                              endFrame - startFrame, level, noteLabel);
+
+//                    SVDEBUG << "Adding note " << startFrame << "," << (endFrame-startFrame) << " : " << int((*i)->getPitch()) << endl;
+
+                    model->addPoint(note);
+                    break;
+                }
 
             case MIDI_PITCH_BEND:
-		// I guess we could make some use of this...
+                // I guess we could make some use of this...
                 break;
 
             case MIDI_NOTE_OFF:
             case MIDI_PROG_CHANGE:
             case MIDI_CTRL_CHANGE:

                 break;
 
             default:
                 break;
             }
-	}
-
-	model->setCompletion(minProgress +
-			     (count * progressAmount) / totalEvents);
-	++count;
+        }
+
+        model->setCompletion(minProgress +
+                             (count * progressAmount) / totalEvents);
+        ++count;
     }
 
     return model;
 }