Merge remote branch 'upstream/master' into qtmidi

6 files changed, 278 insertions, 289 deletions

diff --git a/audio/midiparser.cpp b/audio/midiparser.cpp
index 943a6067a4..eec32c05d1 100644
--- a/audio/midiparser.cpp
+++ b/audio/midiparser.cpp
@@ -32,24 +32,24 @@
 //////////////////////////////////////////////////
 
 MidiParser::MidiParser() :
-_hanging_notes_count(0),
+_hangingNotesCount(0),
 _driver(0),
-_timer_rate(0x4A0000),
+_timerRate(0x4A0000),
 _ppqn(96),
 _tempo(500000),
-_psec_per_tick(5208), // 500000 / 96
+_psecPerTick(5208), // 500000 / 96
 _autoLoop(false),
 _smartJump(false),
 _centerPitchWheelOnUnload(false),
 _sendSustainOffOnNotesOff(false),
-_num_tracks(0),
-_active_track(255),
-_abort_parse(0) {
-	memset(_active_notes, 0, sizeof(_active_notes));
-	_next_event.start = NULL;
-	_next_event.delta = 0;
-	_next_event.event = 0;
-	_next_event.length = 0;
+_numTracks(0),
+_activeTrack(255),
+_abortParse(0) {
+	memset(_activeNotes, 0, sizeof(_activeNotes));
+	_nextEvent.start = NULL;
+	_nextEvent.delta = 0;
+	_nextEvent.event = 0;
+	_nextEvent.length = 0;
 }
 
 void MidiParser::property(int prop, int value) {
@@ -76,7 +76,7 @@ void MidiParser::sendToDriver(uint32 b) {
 void MidiParser::setTempo(uint32 tempo) {
 	_tempo = tempo;
 	if (_ppqn)
-		_psec_per_tick = (tempo + (_ppqn >> 2)) / _ppqn;
+		_psecPerTick = (tempo + (_ppqn >> 2)) / _ppqn;
 }
 
 // This is the conventional (i.e. SMF) variable length quantity
@@ -100,44 +100,44 @@ void MidiParser::activeNote(byte channel, byte note, bool active) {
 		return;
 
 	if (active)
-		_active_notes[note] |= (1 << channel);
+		_activeNotes[note] |= (1 << channel);
 	else
-		_active_notes[note] &= ~(1 << channel);
+		_activeNotes[note] &= ~(1 << channel);
 
 	// See if there are hanging notes that we can cancel
-	NoteTimer *ptr = _hanging_notes;
+	NoteTimer *ptr = _hangingNotes;
 	int i;
-	for (i = ARRAYSIZE(_hanging_notes); i; --i, ++ptr) {
-		if (ptr->channel == channel && ptr->note == note && ptr->time_left) {
-			ptr->time_left = 0;
-			--_hanging_notes_count;
+	for (i = ARRAYSIZE(_hangingNotes); i; --i, ++ptr) {
+		if (ptr->channel == channel && ptr->note == note && ptr->timeLeft) {
+			ptr->timeLeft = 0;
+			--_hangingNotesCount;
 			break;
 		}
 	}
 }
 
-void MidiParser::hangingNote(byte channel, byte note, uint32 time_left, bool recycle) {
+void MidiParser::hangingNote(byte channel, byte note, uint32 timeLeft, bool recycle) {
 	NoteTimer *best = 0;
-	NoteTimer *ptr = _hanging_notes;
+	NoteTimer *ptr = _hangingNotes;
 	int i;
 
-	if (_hanging_notes_count >= ARRAYSIZE(_hanging_notes)) {
+	if (_hangingNotesCount >= ARRAYSIZE(_hangingNotes)) {
 		warning("MidiParser::hangingNote(): Exceeded polyphony");
 		return;
 	}
 
-	for (i = ARRAYSIZE(_hanging_notes); i; --i, ++ptr) {
+	for (i = ARRAYSIZE(_hangingNotes); i; --i, ++ptr) {
 		if (ptr->channel == channel && ptr->note == note) {
-			if (ptr->time_left && ptr->time_left < time_left && recycle)
+			if (ptr->timeLeft && ptr->timeLeft < timeLeft && recycle)
 				return;
 			best = ptr;
-			if (ptr->time_left) {
+			if (ptr->timeLeft) {
 				if (recycle)
 					sendToDriver(0x80 | channel, note, 0);
-				--_hanging_notes_count;
+				--_hangingNotesCount;
 			}
 			break;
-		} else if (!best && ptr->time_left == 0) {
+		} else if (!best && ptr->timeLeft == 0) {
 			best = ptr;
 		}
 	}
@@ -146,14 +146,14 @@ void MidiParser::hangingNote(byte channel, byte note, uint32 time_left, bool rec
 	// length, if the note should be turned on and off in
 	// the same iteration. For now just set it to 1 and
 	// we'll turn it off in the next cycle.
-	if (!time_left || time_left & 0x80000000)
-		time_left = 1;
+	if (!timeLeft || timeLeft & 0x80000000)
+		timeLeft = 1;
 
 	if (best) {
 		best->channel = channel;
 		best->note = note;
-		best->time_left = time_left;
-		++_hanging_notes_count;
+		best->timeLeft = timeLeft;
+		++_hangingNotesCount;
 	} else {
 		// We checked this up top. We should never get here!
 		warning("MidiParser::hangingNote(): Internal error");
@@ -161,45 +161,45 @@ void MidiParser::hangingNote(byte channel, byte note, uint32 time_left, bool rec
 }
 
 void MidiParser::onTimer() {
-	uint32 end_time;
-	uint32 event_time;
+	uint32 endTime;
+	uint32 eventTime;
 
-	if (!_position._play_pos || !_driver)
+	if (!_position._playPos || !_driver)
 		return;
 
-	_abort_parse = false;
-	end_time = _position._play_time + _timer_rate;
+	_abortParse = false;
+	endTime = _position._playTime + _timerRate;
 
 	// Scan our hanging notes for any
 	// that should be turned off.
-	if (_hanging_notes_count) {
-		NoteTimer *ptr = &_hanging_notes[0];
+	if (_hangingNotesCount) {
+		NoteTimer *ptr = &_hangingNotes[0];
 		int i;
-		for (i = ARRAYSIZE(_hanging_notes); i; --i, ++ptr) {
-			if (ptr->time_left) {
-				if (ptr->time_left <= _timer_rate) {
+		for (i = ARRAYSIZE(_hangingNotes); i; --i, ++ptr) {
+			if (ptr->timeLeft) {
+				if (ptr->timeLeft <= _timerRate) {
 					sendToDriver(0x80 | ptr->channel, ptr->note, 0);
-					ptr->time_left = 0;
-					--_hanging_notes_count;
+					ptr->timeLeft = 0;
+					--_hangingNotesCount;
 				} else {
-					ptr->time_left -= _timer_rate;
+					ptr->timeLeft -= _timerRate;
 				}
 			}
 		}
 	}
 
-	while (!_abort_parse) {
-		EventInfo &info = _next_event;
+	while (!_abortParse) {
+		EventInfo &info = _nextEvent;
 
-		event_time = _position._last_event_time + info.delta * _psec_per_tick;
-		if (event_time > end_time)
+		eventTime = _position._lastEventTime + info.delta * _psecPerTick;
+		if (eventTime > endTime)
 			break;
 
 		// Process the next info.
-		_position._last_event_tick += info.delta;
+		_position._lastEventTick += info.delta;
 		if (info.event < 0x80) {
 			warning("Bad command or running status %02X", info.event);
-			_position._play_pos = 0;
+			_position._playPos = 0;
 			return;
 		}
 
@@ -217,7 +217,7 @@ void MidiParser::onTimer() {
 				// as well as sending it to the output device.
 				if (_autoLoop) {
 					jumpToTick(0);
-					parseNextEvent(_next_event);
+					parseNextEvent(_nextEvent);
 				} else {
 					stopPlaying();
 					_driver->metaEvent(info.ext.type, info.ext.data, (uint16)info.length);
@@ -234,7 +234,7 @@ void MidiParser::onTimer() {
 				activeNote(info.channel(), info.basic.param1, false);
 			} else if (info.command() == 0x9) {
 				if (info.length > 0)
-					hangingNote(info.channel(), info.basic.param1, info.length * _psec_per_tick - (end_time - event_time));
+					hangingNote(info.channel(), info.basic.param1, info.length * _psecPerTick - (endTime - eventTime));
 				else
 					activeNote(info.channel(), info.basic.param1, true);
 			}
@@ -242,15 +242,15 @@ void MidiParser::onTimer() {
 		}
 
 
-		if (!_abort_parse) {
-			_position._last_event_time = event_time;
-			parseNextEvent(_next_event);
+		if (!_abortParse) {
+			_position._lastEventTime = eventTime;
+			parseNextEvent(_nextEvent);
 		}
 	}
 
-	if (!_abort_parse) {
-		_position._play_time = end_time;
-		_position._play_tick = (_position._play_time - _position._last_event_time) / _psec_per_tick + _position._last_event_tick;
+	if (!_abortParse) {
+		_position._playTime = endTime;
+		_position._playTick = (_position._playTime - _position._lastEventTime) / _psecPerTick + _position._lastEventTick;
 	}
 }
 
@@ -263,20 +263,20 @@ void MidiParser::allNotesOff() {
 	// Turn off all active notes
 	for (i = 0; i < 128; ++i) {
 		for (j = 0; j < 16; ++j) {
-			if (_active_notes[i] & (1 << j)) {
+			if (_activeNotes[i] & (1 << j)) {
 				sendToDriver(0x80 | j, i, 0);
 			}
 		}
 	}
 
 	// Turn off all hanging notes
-	for (i = 0; i < ARRAYSIZE(_hanging_notes); i++) {
-		if (_hanging_notes[i].time_left) {
-			sendToDriver(0x80 | _hanging_notes[i].channel, _hanging_notes[i].note, 0);
-			_hanging_notes[i].time_left = 0;
+	for (i = 0; i < ARRAYSIZE(_hangingNotes); i++) {
+		if (_hangingNotes[i].timeLeft) {
+			sendToDriver(0x80 | _hangingNotes[i].channel, _hangingNotes[i].note, 0);
+			_hangingNotes[i].timeLeft = 0;
 		}
 	}
-	_hanging_notes_count = 0;
+	_hangingNotesCount = 0;
 
 	// To be sure, send an "All Note Off" event (but not all MIDI devices
 	// support this...).
@@ -287,7 +287,7 @@ void MidiParser::allNotesOff() {
 			sendToDriver(0xB0 | i, 0x40, 0); // Also send a sustain off event (bug #3116608)
 	}
 
-	memset(_active_notes, 0, sizeof(_active_notes));
+	memset(_activeNotes, 0, sizeof(_activeNotes));
 }
 
 void MidiParser::resetTracking() {
@@ -295,7 +295,7 @@ void MidiParser::resetTracking() {
 }
 
 bool MidiParser::setTrack(int track) {
-	if (track < 0 || track >= _num_tracks)
+	if (track < 0 || track >= _numTracks)
 		return false;
 	// We allow restarting the track via setTrack when
 	// it isn't playing anymore. This allows us to reuse
@@ -308,7 +308,7 @@ bool MidiParser::setTrack(int track) {
 	// TODO: Check if any engine has problem with this
 	// handling, if so we need to find a better way to handle
 	// track restarts. (KYRA relies on this working)
-	else if (track == _active_track && isPlaying())
+	else if (track == _activeTrack && isPlaying())
 		return true;
 
 	if (_smartJump)
@@ -317,10 +317,10 @@ bool MidiParser::setTrack(int track) {
 		allNotesOff();
 
 	resetTracking();
-	memset(_active_notes, 0, sizeof(_active_notes));
-	_active_track = track;
-	_position._play_pos = _tracks[track];
-	parseNextEvent(_next_event);
+	memset(_activeNotes, 0, sizeof(_activeNotes));
+	_activeTrack = track;
+	_position._playPos = _tracks[track];
+	parseNextEvent(_nextEvent);
 	return true;
 }
 
@@ -332,29 +332,29 @@ void MidiParser::stopPlaying() {
 void MidiParser::hangAllActiveNotes() {
 	// Search for note off events until we have
 	// accounted for every active note.
-	uint16 temp_active[128];
-	memcpy(temp_active, _active_notes, sizeof (temp_active));
+	uint16 tempActive[128];
+	memcpy(tempActive, _activeNotes, sizeof (tempActive));
 
-	uint32 advance_tick = _position._last_event_tick;
+	uint32 advanceTick = _position._lastEventTick;
 	while (true) {
 		int i;
 		for (i = 0; i < 128; ++i)
-			if (temp_active[i] != 0)
+			if (tempActive[i] != 0)
 				break;
 		if (i == 128)
 			break;
-		parseNextEvent(_next_event);
-		advance_tick += _next_event.delta;
-		if (_next_event.command() == 0x8) {
-			if (temp_active[_next_event.basic.param1] & (1 << _next_event.channel())) {
-				hangingNote(_next_event.channel(), _next_event.basic.param1, (advance_tick - _position._last_event_tick) * _psec_per_tick, false);
-				temp_active[_next_event.basic.param1] &= ~(1 << _next_event.channel());
+		parseNextEvent(_nextEvent);
+		advanceTick += _nextEvent.delta;
+		if (_nextEvent.command() == 0x8) {
+			if (tempActive[_nextEvent.basic.param1] & (1 << _nextEvent.channel())) {
+				hangingNote(_nextEvent.channel(), _nextEvent.basic.param1, (advanceTick - _position._lastEventTick) * _psecPerTick, false);
+				tempActive[_nextEvent.basic.param1] &= ~(1 << _nextEvent.channel());
 			}
-		} else if (_next_event.event == 0xFF && _next_event.ext.type == 0x2F) {
+		} else if (_nextEvent.event == 0xFF && _nextEvent.ext.type == 0x2F) {
 			// warning("MidiParser::hangAllActiveNotes(): Hit End of Track with active notes left");
 			for (i = 0; i < 128; ++i) {
 				for (int j = 0; j < 16; ++j) {
-					if (temp_active[i] & (1 << j)) {
+					if (tempActive[i] & (1 << j)) {
 						activeNote(j, i, false);
 						sendToDriver(0x80 | j, i, 0);
 					}
@@ -366,33 +366,33 @@ void MidiParser::hangAllActiveNotes() {
 }
 
 bool MidiParser::jumpToTick(uint32 tick, bool fireEvents, bool stopNotes, bool dontSendNoteOn) {
-	if (_active_track >= _num_tracks)
+	if (_activeTrack >= _numTracks)
 		return false;
 
 	Tracker currentPos(_position);
-	EventInfo currentEvent(_next_event);
+	EventInfo currentEvent(_nextEvent);
 
 	resetTracking();
-	_position._play_pos = _tracks[_active_track];
-	parseNextEvent(_next_event);
+	_position._playPos = _tracks[_activeTrack];
+	parseNextEvent(_nextEvent);
 	if (tick > 0) {
 		while (true) {
-			EventInfo &info = _next_event;
-			if (_position._last_event_tick + info.delta >= tick) {
-				_position._play_time += (tick - _position._last_event_tick) * _psec_per_tick;
-				_position._play_tick = tick;
+			EventInfo &info = _nextEvent;
+			if (_position._lastEventTick + info.delta >= tick) {
+				_position._playTime += (tick - _position._lastEventTick) * _psecPerTick;
+				_position._playTick = tick;
 				break;
 			}
 
-			_position._last_event_tick += info.delta;
-			_position._last_event_time += info.delta * _psec_per_tick;
-			_position._play_tick = _position._last_event_tick;
-			_position._play_time = _position._last_event_time;
+			_position._lastEventTick += info.delta;
+			_position._lastEventTime += info.delta * _psecPerTick;
+			_position._playTick = _position._lastEventTick;
+			_position._playTime = _position._lastEventTime;
 
 			if (info.event == 0xFF) {
 				if (info.ext.type == 0x2F) { // End of track
 					_position = currentPos;
-					_next_event = currentEvent;
+					_nextEvent = currentEvent;
 					return false;
 				} else {
 					if (info.ext.type == 0x51 && info.length >= 3) // Tempo
@@ -419,36 +419,36 @@ bool MidiParser::jumpToTick(uint32 tick, bool fireEvents, bool stopNotes, bool d
 				}
 			}
 
-			parseNextEvent(_next_event);
+			parseNextEvent(_nextEvent);
 		}
 	}
 
 	if (stopNotes) {
-		if (!_smartJump || !currentPos._play_pos) {
+		if (!_smartJump || !currentPos._playPos) {
 			allNotesOff();
 		} else {
-			EventInfo targetEvent(_next_event);
+			EventInfo targetEvent(_nextEvent);
 			Tracker targetPosition(_position);
 
 			_position = currentPos;
-			_next_event = currentEvent;
+			_nextEvent = currentEvent;
 			hangAllActiveNotes();
 
-			_next_event = targetEvent;
+			_nextEvent = targetEvent;
 			_position = targetPosition;
 		}
 	}
 
-	_abort_parse = true;
+	_abortParse = true;
 	return true;
 }
 
 void MidiParser::unloadMusic() {
 	resetTracking();
 	allNotesOff();
-	_num_tracks = 0;
-	_active_track = 255;
-	_abort_parse = true;
+	_numTracks = 0;
+	_activeTrack = 255;
+	_abortParse = true;
 
 	if (_centerPitchWheelOnUnload) {
 		// Center the pitch wheels in preparation for the next piece of
diff --git a/audio/midiparser.h b/audio/midiparser.h
index f26da456b6..bb9749b97f 100644
--- a/audio/midiparser.h
+++ b/audio/midiparser.h
@@ -49,33 +49,33 @@ class MidiDriver_BASE;
  * each Tracker location.
  */
 struct Tracker {
-	byte * _play_pos;        ///< A pointer to the next event to be parsed
-	uint32 _play_time;       ///< Current time in microseconds; may be in between event times
-	uint32 _play_tick;       ///< Current MIDI tick; may be in between event ticks
-	uint32 _last_event_time; ///< The time, in microseconds, of the last event that was parsed
-	uint32 _last_event_tick; ///< The tick at which the last parsed event occurs
-	byte   _running_status;  ///< Cached MIDI command, for MIDI streams that rely on implied event codes
+	byte * _playPos;        ///< A pointer to the next event to be parsed
+	uint32 _playTime;       ///< Current time in microseconds; may be in between event times
+	uint32 _playTick;       ///< Current MIDI tick; may be in between event ticks
+	uint32 _lastEventTime; ///< The time, in microseconds, of the last event that was parsed
+	uint32 _lastEventTick; ///< The tick at which the last parsed event occurs
+	byte   _runningStatus;  ///< Cached MIDI command, for MIDI streams that rely on implied event codes
 
 	Tracker() { clear(); }
 
 	/// Copy constructor for each duplication of Tracker information.
 	Tracker(const Tracker &copy) :
-	_play_pos(copy._play_pos),
-	_play_time(copy._play_time),
-	_play_tick(copy._play_tick),
-	_last_event_time(copy._last_event_time),
-	_last_event_tick(copy._last_event_tick),
-	_running_status(copy._running_status)
+	_playPos(copy._playPos),
+	_playTime(copy._playTime),
+	_playTick(copy._playTick),
+	_lastEventTime(copy._lastEventTime),
+	_lastEventTick(copy._lastEventTick),
+	_runningStatus(copy._runningStatus)
 	{ }
 
 	/// Clears all data; used by the constructor for initialization.
 	void clear() {
-		_play_pos = 0;
-		_play_time = 0;
-		_play_tick = 0;
-		_last_event_time = 0;
-		_last_event_tick = 0;
-		_running_status = 0;
+		_playPos = 0;
+		_playTime = 0;
+		_playTick = 0;
+		_lastEventTime = 0;
+		_lastEventTick = 0;
+		_runningStatus = 0;
 	}
 };
 
@@ -119,8 +119,8 @@ struct EventInfo {
 struct NoteTimer {
 	byte channel;     ///< The MIDI channel on which the note was played
 	byte note;        ///< The note number for the active note
-	uint32 time_left; ///< The time, in microseconds, remaining before the note should be turned off
-	NoteTimer() : channel(0), note(0), time_left(0) {}
+	uint32 timeLeft; ///< The time, in microseconds, remaining before the note should be turned off
+	NoteTimer() : channel(0), note(0), timeLeft(0) {}
 };
 
 
@@ -264,29 +264,29 @@ struct NoteTimer {
  */
 class MidiParser {
 protected:
-	uint16    _active_notes[128];   ///< Each uint16 is a bit mask for channels that have that note on.
-	NoteTimer _hanging_notes[32];   ///< Maintains expiration info for up to 32 notes.
+	uint16    _activeNotes[128];   ///< Each uint16 is a bit mask for channels that have that note on.
+	NoteTimer _hangingNotes[32];   ///< Maintains expiration info for up to 32 notes.
 	                                ///< Used for "Smart Jump" and MIDI formats that do not include explicit Note Off events.
-	byte      _hanging_notes_count; ///< Count of hanging notes, used to optimize expiration.
+	byte      _hangingNotesCount; ///< Count of hanging notes, used to optimize expiration.
 
 	MidiDriver_BASE *_driver;    ///< The device to which all events will be transmitted.
-	uint32 _timer_rate;     ///< The time in microseconds between onTimer() calls. Obtained from the MidiDriver.
+	uint32 _timerRate;     ///< The time in microseconds between onTimer() calls. Obtained from the MidiDriver.
 	uint32 _ppqn;           ///< Pulses Per Quarter Note. (We refer to "pulses" as "ticks".)
 	uint32 _tempo;          ///< Microseconds per quarter note.
-	uint32 _psec_per_tick;  ///< Microseconds per tick (_tempo / _ppqn).
+	uint32 _psecPerTick;  ///< Microseconds per tick (_tempo / _ppqn).
 	bool   _autoLoop;       ///< For lightweight clients that don't provide their own flow control.
 	bool   _smartJump;      ///< Support smart expiration of hanging notes when jumping
 	bool   _centerPitchWheelOnUnload;  ///< Center the pitch wheels when unloading a song
 	bool   _sendSustainOffOnNotesOff;   ///< Send a sustain off on a notes off event, stopping hanging notes
 	byte  *_tracks[120];    ///< Multi-track MIDI formats are supported, up to 120 tracks.
-	byte   _num_tracks;     ///< Count of total tracks for multi-track MIDI formats. 1 for single-track formats.
-	byte   _active_track;   ///< Keeps track of the currently active track, in multi-track formats.
+	byte   _numTracks;     ///< Count of total tracks for multi-track MIDI formats. 1 for single-track formats.
+	byte   _activeTrack;   ///< Keeps track of the currently active track, in multi-track formats.
 
 	Tracker _position;      ///< The current time/position in the active track.
-	EventInfo _next_event;  ///< The next event to transmit. Events are preparsed
+	EventInfo _nextEvent;  ///< The next event to transmit. Events are preparsed
 	                        ///< so each event is parsed only once; this permits
 	                        ///< simulated events in certain formats.
-	bool   _abort_parse;    ///< If a jump or other operation interrupts parsing, flag to abort.
+	bool   _abortParse;    ///< If a jump or other operation interrupts parsing, flag to abort.
 
 protected:
 	static uint32 readVLQ(byte * &data);
@@ -295,7 +295,7 @@ protected:
 	virtual void parseNextEvent(EventInfo &info) = 0;
 
 	void activeNote(byte channel, byte note, bool active);
-	void hangingNote(byte channel, byte note, uint32 ticks_left, bool recycle = true);
+	void hangingNote(byte channel, byte note, uint32 ticksLeft, bool recycle = true);
 	void hangAllActiveNotes();
 
 	virtual void sendToDriver(uint32 b);
@@ -377,18 +377,18 @@ public:
 	virtual void property(int prop, int value);
 
 	void setMidiDriver(MidiDriver_BASE *driver) { _driver = driver; }
-	void setTimerRate(uint32 rate) { _timer_rate = rate; }
+	void setTimerRate(uint32 rate) { _timerRate = rate; }
 	void setTempo(uint32 tempo);
 	void onTimer();
 
-	bool isPlaying() const { return (_position._play_pos != 0); }
+	bool isPlaying() const { return (_position._playPos != 0); }
 	void stopPlaying();
 
 	bool setTrack(int track);
 	bool jumpToTick(uint32 tick, bool fireEvents = false, bool stopNotes = true, bool dontSendNoteOn = false);
 
 	uint32 getPPQN() { return _ppqn; }
-	virtual uint32 getTick() { return _position._play_tick; }
+	virtual uint32 getTick() { return _position._playTick; }
 
 	static void defaultXMidiCallback(byte eventData, void *refCon);
 
diff --git a/audio/midiparser_qt.cpp b/audio/midiparser_qt.cpp
index d6440508df..2b8a02ba5e 100644
--- a/audio/midiparser_qt.cpp
+++ b/audio/midiparser_qt.cpp
@@ -110,17 +110,17 @@ void MidiParser_QT::resetTracking() {
 }
 
 void MidiParser_QT::parseNextEvent(EventInfo &info) {
-	if (_position._play_pos >= _trackInfo[_active_track].data + _trackInfo[_active_track].size) {
+	if (_position._playPos >= _trackInfo[_activeTrack].data + _trackInfo[_activeTrack].size) {
 		// Manually insert end of track when we reach the end
 		info.event = 0xFF;
 		info.ext.type = 0x2F;
 		return;
 	}
 
-	if (_loadedInstruments < _trackInfo[_active_track].noteRequests.size()) {
+	if (_loadedInstruments < _trackInfo[_activeTrack].noteRequests.size()) {
 		// Load instruments first
 		info.event = 0xC0 | _loadedInstruments;
-		info.basic.param1 = _trackInfo[_active_track].noteRequests[_loadedInstruments].tone.gmNumber;
+		info.basic.param1 = _trackInfo[_activeTrack].noteRequests[_loadedInstruments].tone.gmNumber;
 		_loadedInstruments++;
 		return;
 	}
@@ -290,8 +290,8 @@ void MidiParser_QT::initCommon() {
 	// Now we have all our info needed in _trackInfo from whatever container
 	// form, we can fill in the MidiParser tracks.
 
-	_num_tracks = _trackInfo.size();
-	assert(_num_tracks > 0);
+	_numTracks = _trackInfo.size();
+	assert(_numTracks > 0);
 
 	for (uint32 i = 0; i < _trackInfo.size(); i++)
 		MidiParser::_tracks[i] = _trackInfo[i].data;
@@ -332,8 +332,8 @@ byte *MidiParser_QT::readWholeTrack(Common::QuickTimeParser::Track *track, uint3
 }
 
 uint32 MidiParser_QT::readUint32() {
-	uint32 value = READ_BE_UINT32(_position._play_pos);
-	_position._play_pos += 4;
+	uint32 value = READ_BE_UINT32(_position._playPos);
+	_position._playPos += 4;
 	return value;
 }
 
diff --git a/audio/midiparser_smf.cpp b/audio/midiparser_smf.cpp
index e883471b54..4b0913cbfe 100644
--- a/audio/midiparser_smf.cpp
+++ b/audio/midiparser_smf.cpp
@@ -45,8 +45,8 @@ public:
 };
 
 
-static const byte command_lengths[8] = { 3, 3, 3, 3, 2, 2, 3, 0 };
-static const byte special_lengths[16] = { 0, 2, 3, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0 };
+static const byte commandLengths[8] = { 3, 3, 3, 3, 2, 2, 3, 0 };
+static const byte specialLengths[16] = { 0, 2, 3, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0 };
 
 MidiParser_SMF::~MidiParser_SMF() {
 	free(_buffer);
@@ -62,8 +62,8 @@ void MidiParser_SMF::property(int prop, int value) {
 }
 
 void MidiParser_SMF::parseNextEvent(EventInfo &info) {
-	info.start = _position._play_pos;
-	info.delta = readVLQ(_position._play_pos);
+	info.start = _position._playPos;
+	info.delta = readVLQ(_position._playPos);
 
 	// Process the next info. If mpMalformedPitchBends
 	// was set, we must skip over any pitch bend events
@@ -71,19 +71,19 @@ void MidiParser_SMF::parseNextEvent(EventInfo &info) {
 	// real pitch bend events, they're just two-byte
 	// prefixes before the real info.
 	do {
-		if ((_position._play_pos[0] & 0xF0) >= 0x80)
-			info.event = *(_position._play_pos++);
+		if ((_position._playPos[0] & 0xF0) >= 0x80)
+			info.event = *(_position._playPos++);
 		else
-			info.event = _position._running_status;
-	} while (_malformedPitchBends && (info.event & 0xF0) == 0xE0 && _position._play_pos++);
+			info.event = _position._runningStatus;
+	} while (_malformedPitchBends && (info.event & 0xF0) == 0xE0 && _position._playPos++);
 	if (info.event < 0x80)
 		return;
 
-	_position._running_status = info.event;
+	_position._runningStatus = info.event;
 	switch (info.command()) {
 	case 0x9: // Note On
-		info.basic.param1 = *(_position._play_pos++);
-		info.basic.param2 = *(_position._play_pos++);
+		info.basic.param1 = *(_position._playPos++);
+		info.basic.param2 = *(_position._playPos++);
 		if (info.basic.param2 == 0)
 			info.event = info.channel() | 0x80;
 		info.length = 0;
@@ -91,7 +91,7 @@ void MidiParser_SMF::parseNextEvent(EventInfo &info) {
 
 	case 0xC:
 	case 0xD:
-		info.basic.param1 = *(_position._play_pos++);
+		info.basic.param1 = *(_position._playPos++);
 		info.basic.param2 = 0;
 		break;
 
@@ -99,20 +99,20 @@ void MidiParser_SMF::parseNextEvent(EventInfo &info) {
 	case 0xA:
 	case 0xB:
 	case 0xE:
-		info.basic.param1 = *(_position._play_pos++);
-		info.basic.param2 = *(_position._play_pos++);
+		info.basic.param1 = *(_position._playPos++);
+		info.basic.param2 = *(_position._playPos++);
 		info.length = 0;
 		break;
 
 	case 0xF: // System Common, Meta or SysEx event
 		switch (info.event & 0x0F) {
 		case 0x2: // Song Position Pointer
-			info.basic.param1 = *(_position._play_pos++);
-			info.basic.param2 = *(_position._play_pos++);
+			info.basic.param1 = *(_position._playPos++);
+			info.basic.param2 = *(_position._playPos++);
 			break;
 
 		case 0x3: // Song Select
-			info.basic.param1 = *(_position._play_pos++);
+			info.basic.param1 = *(_position._playPos++);
 			info.basic.param2 = 0;
 			break;
 
@@ -126,16 +126,16 @@ void MidiParser_SMF::parseNextEvent(EventInfo &info) {
 			break;
 
 		case 0x0: // SysEx
-			info.length = readVLQ(_position._play_pos);
-			info.ext.data = _position._play_pos;
-			_position._play_pos += info.length;
+			info.length = readVLQ(_position._playPos);
+			info.ext.data = _position._playPos;
+			_position._playPos += info.length;
 			break;
 
 		case 0xF: // META event
-			info.ext.type = *(_position._play_pos++);
-			info.length = readVLQ(_position._play_pos);
-			info.ext.data = _position._play_pos;
-			_position._play_pos += info.length;
+			info.ext.type = *(_position._playPos++);
+			info.length = readVLQ(_position._playPos);
+			info.ext.data = _position._playPos;
+			_position._playPos += info.length;
 			break;
 
 		default:
@@ -146,8 +146,8 @@ void MidiParser_SMF::parseNextEvent(EventInfo &info) {
 
 bool MidiParser_SMF::loadMusic(byte *data, uint32 size) {
 	uint32 len;
-	byte midi_type;
-	uint32 total_size;
+	byte midiType;
+	uint32 totalSize;
 	bool isGMF;
 
 	unloadMusic();
@@ -171,10 +171,10 @@ bool MidiParser_SMF::loadMusic(byte *data, uint32 size) {
 		// Verify that this MIDI either is a Type 2
 		// or has only 1 track. We do not support
 		// multitrack Type 1 files.
-		_num_tracks = pos[2] << 8 | pos[3];
-		midi_type = pos[1];
-		if (midi_type > 2 /*|| (midi_type < 2 && _num_tracks > 1)*/) {
-			warning("No support for a Type %d MIDI with %d tracks", (int)midi_type, (int)_num_tracks);
+		_numTracks = pos[2] << 8 | pos[3];
+		midiType = pos[1];
+		if (midiType > 2 /*|| (midiType < 2 && _numTracks > 1)*/) {
+			warning("No support for a Type %d MIDI with %d tracks", (int)midiType, (int)_numTracks);
 			return false;
 		}
 		_ppqn = pos[4] << 8 | pos[5];
@@ -183,8 +183,8 @@ bool MidiParser_SMF::loadMusic(byte *data, uint32 size) {
 		// Older GMD/MUS file with no header info.
 		// Assume 1 track, 192 PPQN, and no MTrk headers.
 		isGMF = true;
-		midi_type = 0;
-		_num_tracks = 1;
+		midiType = 0;
+		_numTracks = 1;
 		_ppqn = 192;
 		pos += 7; // 'GMD\x1' + 3 bytes of useless (translate: unknown) information
 	} else {
@@ -193,14 +193,14 @@ bool MidiParser_SMF::loadMusic(byte *data, uint32 size) {
 	}
 
 	// Now we identify and store the location for each track.
-	if (_num_tracks > ARRAYSIZE(_tracks)) {
-		warning("Can only handle %d tracks but was handed %d", (int)ARRAYSIZE(_tracks), (int)_num_tracks);
+	if (_numTracks > ARRAYSIZE(_tracks)) {
+		warning("Can only handle %d tracks but was handed %d", (int)ARRAYSIZE(_tracks), (int)_numTracks);
 		return false;
 	}
 
-	total_size = 0;
-	int tracks_read = 0;
-	while (tracks_read < _num_tracks) {
+	totalSize = 0;
+	int tracksRead = 0;
+	while (tracksRead < _numTracks) {
 		if (memcmp(pos, "MTrk", 4) && !isGMF) {
 			warning("Position: %p ('%c')", pos, *pos);
 			warning("Hit invalid block '%c%c%c%c' while scanning for track locations", pos[0], pos[1], pos[2], pos[3]);
@@ -208,11 +208,11 @@ bool MidiParser_SMF::loadMusic(byte *data, uint32 size) {
 		}
 
 		// If needed, skip the MTrk and length bytes
-		_tracks[tracks_read] = pos + (isGMF ? 0 : 8);
+		_tracks[tracksRead] = pos + (isGMF ? 0 : 8);
 		if (!isGMF) {
 			pos += 4;
 			len = read4high(pos);
-			total_size += len;
+			totalSize += len;
 			pos += len;
 		} else {
 			// An SMF End of Track meta event must be placed
@@ -222,7 +222,7 @@ bool MidiParser_SMF::loadMusic(byte *data, uint32 size) {
 			data[size++] = 0x00;
 			data[size++] = 0x00;
 		}
-		++tracks_read;
+		++tracksRead;
 	}
 
 	// If this is a Type 1 MIDI, we need to now compress
@@ -230,13 +230,13 @@ bool MidiParser_SMF::loadMusic(byte *data, uint32 size) {
 	free(_buffer);
 	_buffer = 0;
 
-	if (midi_type == 1) {
+	if (midiType == 1) {
 		// FIXME: Doubled the buffer size to prevent crashes with the
 		// Inherit the Earth MIDIs. Jamieson630 said something about a
 		// better fix, but this will have to do in the meantime.
 		_buffer = (byte *)malloc(size * 2);
 		compressToType0();
-		_num_tracks = 1;
+		_numTracks = 1;
 		_tracks[0] = _buffer;
 	}
 
@@ -253,48 +253,48 @@ void MidiParser_SMF::compressToType0() {
 	// We assume that _buffer has been allocated
 	// to sufficient size for this operation.
 
-	// using 0xFF since it could write track_pos[0 to _num_tracks] here
+	// using 0xFF since it could write trackPos[0 to _numTracks] here
 	// this would cause some illegal writes and could lead to segfaults
 	// (it crashed for some midis for me, they're not used in any game
 	// scummvm supports though). *Maybe* handle this in another way,
 	// it's at the moment only to be sure, that nothing goes wrong.
-	byte *track_pos[0xFF];
-	byte running_status[0xFF];
-	uint32 track_timer[0xFF];
+	byte *trackPos[0xFF];
+	byte runningStatus[0xFF];
+	uint32 trackTimer[0xFF];
 	uint32 delta;
 	int i;
 
-	for (i = 0; i < _num_tracks; ++i) {
-		running_status[i] = 0;
-		track_pos[i] = _tracks[i];
-		track_timer[i] = readVLQ(track_pos[i]);
-		running_status[i] = 0;
+	for (i = 0; i < _numTracks; ++i) {
+		runningStatus[i] = 0;
+		trackPos[i] = _tracks[i];
+		trackTimer[i] = readVLQ(trackPos[i]);
+		runningStatus[i] = 0;
 	}
 
-	int best_i;
+	int bestTrack;
 	uint32 length;
 	byte *output = _buffer;
 	byte *pos, *pos2;
 	byte event;
-	uint32 copy_bytes;
+	uint32 copyBytes;
 	bool write;
-	byte active_tracks = (byte)_num_tracks;
+	byte activeTracks = (byte)_numTracks;
 
-	while (active_tracks) {
+	while (activeTracks) {
 		write = true;
-		best_i = 255;
-		for (i = 0; i < _num_tracks; ++i) {
-			if (track_pos[i] && (best_i == 255 || track_timer[i] < track_timer[best_i]))
-				best_i = i;
+		bestTrack = 255;
+		for (i = 0; i < _numTracks; ++i) {
+			if (trackPos[i] && (bestTrack == 255 || trackTimer[i] < trackTimer[bestTrack]))
+				bestTrack = i;
 		}
-		if (best_i == 255) {
+		if (bestTrack == 255) {
 			warning("Premature end of tracks");
 			break;
 		}
 
 		// Initial VLQ delta computation
 		delta = 0;
-		length = track_timer[best_i];
+		length = trackTimer[bestTrack];
 		for (i = 0; length; ++i) {
 			delta = (delta << 8) | (length & 0x7F) | (i ? 0x80 : 0);
 			length >>= 7;
@@ -302,55 +302,55 @@ void MidiParser_SMF::compressToType0() {
 
 		// Process MIDI event.
 		bool implicitEvent = false;
-		copy_bytes = 0;
-		pos = track_pos[best_i];
+		copyBytes = 0;
+		pos = trackPos[bestTrack];
 		do {
 			event = *(pos++);
 			if (event < 0x80) {
-				event = running_status[best_i];
+				event = runningStatus[bestTrack];
 				implicitEvent = true;
 			}
 		} while (_malformedPitchBends && (event & 0xF0) == 0xE0 && pos++);
-		running_status[best_i] = event;
+		runningStatus[bestTrack] = event;
 
-		if (command_lengths[(event >> 4) - 8] > 0) {
-			copy_bytes = command_lengths[(event >> 4) - 8];
-		} else if (special_lengths[(event & 0x0F)] > 0) {
-			copy_bytes = special_lengths[(event & 0x0F)];
+		if (commandLengths[(event >> 4) - 8] > 0) {
+			copyBytes = commandLengths[(event >> 4) - 8];
+		} else if (specialLengths[(event & 0x0F)] > 0) {
+			copyBytes = specialLengths[(event & 0x0F)];
 		} else if (event == 0xF0) {
 			// SysEx
 			pos2 = pos;
 			length = readVLQ(pos);
-			copy_bytes = 1 + (pos - pos2) + length;
+			copyBytes = 1 + (pos - pos2) + length;
 		} else if (event == 0xFF) {
 			// META
 			event = *(pos++);
-			if (event == 0x2F && active_tracks > 1) {
-				track_pos[best_i] = 0;
+			if (event == 0x2F && activeTracks > 1) {
+				trackPos[bestTrack] = 0;
 				write = false;
 			} else {
 				pos2 = pos;
 				length = readVLQ(pos);
-				copy_bytes = 2 + (pos - pos2) + length;
+				copyBytes = 2 + (pos - pos2) + length;
 			}
 			if (event == 0x2F)
-				--active_tracks;
+				--activeTracks;
 		} else {
 			warning("Bad MIDI command %02X", (int)event);
-			track_pos[best_i] = 0;
+			trackPos[bestTrack] = 0;
 		}
 
 		// Update all tracks' deltas
 		if (write) {
-			for (i = 0; i < _num_tracks; ++i) {
-				if (track_pos[i] && i != best_i)
-					track_timer[i] -= track_timer[best_i];
+			for (i = 0; i < _numTracks; ++i) {
+				if (trackPos[i] && i != bestTrack)
+					trackTimer[i] -= trackTimer[bestTrack];
 			}
 		}
 
-		if (track_pos[best_i]) {
+		if (trackPos[bestTrack]) {
 			if (write) {
-				track_timer[best_i] = 0;
+				trackTimer[bestTrack] = 0;
 
 				// Write VLQ delta
 				while (delta & 0x80) {
@@ -361,17 +361,17 @@ void MidiParser_SMF::compressToType0() {
 
 				// Write MIDI data
 				if (!implicitEvent)
-					++track_pos[best_i];
-				--copy_bytes;
-				*output++ = running_status[best_i];
-				memcpy(output, track_pos[best_i], copy_bytes);
-				output += copy_bytes;
+					++trackPos[bestTrack];
+				--copyBytes;
+				*output++ = runningStatus[bestTrack];
+				memcpy(output, trackPos[bestTrack], copyBytes);
+				output += copyBytes;
 			}
 
 			// Fetch new VLQ delta for winning track
-			track_pos[best_i] += copy_bytes;
-			if (active_tracks)
-				track_timer[best_i] += readVLQ(track_pos[best_i]);
+			trackPos[bestTrack] += copyBytes;
+			if (activeTracks)
+				trackTimer[bestTrack] += readVLQ(trackPos[bestTrack]);
 		}
 	}
 
diff --git a/audio/midiparser_xmidi.cpp b/audio/midiparser_xmidi.cpp
index 85491faaf8..11690b0214 100644
--- a/audio/midiparser_xmidi.cpp
+++ b/audio/midiparser_xmidi.cpp
@@ -32,9 +32,6 @@
  */
 class MidiParser_XMIDI : public MidiParser {
 protected:
-	NoteTimer _notes_cache[32];
-	uint32 _inserted_delta; // Track simulated deltas for note-off events
-
 	struct Loop {
 		byte *pos;
 		byte repeat;
@@ -48,11 +45,10 @@ protected:
 
 protected:
 	uint32 readVLQ2(byte * &data);
-	void resetTracking();
 	void parseNextEvent(EventInfo &info);
 
 public:
-	MidiParser_XMIDI(XMidiCallbackProc proc, void *data) : _inserted_delta(0), _callbackProc(proc), _callbackData(data) {}
+	MidiParser_XMIDI(XMidiCallbackProc proc, void *data) : _callbackProc(proc), _callbackData(data) {}
 	~MidiParser_XMIDI() { }
 
 	bool loadMusic(byte *data, uint32 size);
@@ -69,17 +65,16 @@ uint32 MidiParser_XMIDI::readVLQ2(byte * &pos) {
 }
 
 void MidiParser_XMIDI::parseNextEvent(EventInfo &info) {
-	info.start = _position._play_pos;
-	info.delta = readVLQ2(_position._play_pos) - _inserted_delta;
+	info.start = _position._playPos;
+	info.delta = readVLQ2(_position._playPos);
 
 	// Process the next event.
-	_inserted_delta = 0;
-	info.event = *(_position._play_pos++);
+	info.event = *(_position._playPos++);
 	switch (info.event >> 4) {
 	case 0x9: // Note On
-		info.basic.param1 = *(_position._play_pos++);
-		info.basic.param2 = *(_position._play_pos++);
-		info.length = readVLQ(_position._play_pos);
+		info.basic.param1 = *(_position._playPos++);
+		info.basic.param2 = *(_position._playPos++);
+		info.length = readVLQ(_position._playPos);
 		if (info.basic.param2 == 0) {
 			info.event = info.channel() | 0x80;
 			info.length = 0;
@@ -88,20 +83,20 @@ void MidiParser_XMIDI::parseNextEvent(EventInfo &info) {
 
 	case 0xC:
 	case 0xD:
-		info.basic.param1 = *(_position._play_pos++);
+		info.basic.param1 = *(_position._playPos++);
 		info.basic.param2 = 0;
 		break;
 
 	case 0x8:
 	case 0xA:
 	case 0xE:
-		info.basic.param1 = *(_position._play_pos++);
-		info.basic.param2 = *(_position._play_pos++);
+		info.basic.param1 = *(_position._playPos++);
+		info.basic.param2 = *(_position._playPos++);
 		break;
 
 	case 0xB:
-		info.basic.param1 = *(_position._play_pos++);
-		info.basic.param2 = *(_position._play_pos++);
+		info.basic.param1 = *(_position._playPos++);
+		info.basic.param2 = *(_position._playPos++);
 
 		// This isn't a full XMIDI implementation, but it should
 		// hopefully be "good enough" for most things.
@@ -109,7 +104,7 @@ void MidiParser_XMIDI::parseNextEvent(EventInfo &info) {
 		switch (info.basic.param1) {
 		// Simplified XMIDI looping.
 		case 0x74: {	// XMIDI_CONTROLLER_FOR_LOOP
-				byte *pos = _position._play_pos;
+				byte *pos = _position._playPos;
 				if (_loopCount < ARRAYSIZE(_loop) - 1)
 					_loopCount++;
 				else
@@ -131,9 +126,9 @@ void MidiParser_XMIDI::parseNextEvent(EventInfo &info) {
 						if (--_loop[_loopCount].repeat == 0)
 							_loopCount--;
 						else
-							_position._play_pos = _loop[_loopCount].pos;
+							_position._playPos = _loop[_loopCount].pos;
 					} else {
-						_position._play_pos = _loop[_loopCount].pos;
+						_position._playPos = _loop[_loopCount].pos;
 					}
 				}
 			}
@@ -169,12 +164,12 @@ void MidiParser_XMIDI::parseNextEvent(EventInfo &info) {
 	case 0xF: // Meta or SysEx event
 		switch (info.event & 0x0F) {
 		case 0x2: // Song Position Pointer
-			info.basic.param1 = *(_position._play_pos++);
-			info.basic.param2 = *(_position._play_pos++);
+			info.basic.param1 = *(_position._playPos++);
+			info.basic.param2 = *(_position._playPos++);
 			break;
 
 		case 0x3: // Song Select
-			info.basic.param1 = *(_position._play_pos++);
+			info.basic.param1 = *(_position._playPos++);
 			info.basic.param2 = 0;
 			break;
 
@@ -188,16 +183,16 @@ void MidiParser_XMIDI::parseNextEvent(EventInfo &info) {
 			break;
 
 		case 0x0: // SysEx
-			info.length = readVLQ(_position._play_pos);
-			info.ext.data = _position._play_pos;
-			_position._play_pos += info.length;
+			info.length = readVLQ(_position._playPos);
+			info.ext.data = _position._playPos;
+			_position._playPos += info.length;
 			break;
 
 		case 0xF: // META event
-			info.ext.type = *(_position._play_pos++);
-			info.length = readVLQ(_position._play_pos);
-			info.ext.data = _position._play_pos;
-			_position._play_pos += info.length;
+			info.ext.type = *(_position._playPos++);
+			info.length = readVLQ(_position._playPos);
+			info.ext.data = _position._playPos;
+			_position._playPos += info.length;
 			if (info.ext.type == 0x51 && info.length == 3) {
 				// Tempo event. We want to make these constant 500,000.
 				info.ext.data[0] = 0x07;
@@ -216,7 +211,7 @@ bool MidiParser_XMIDI::loadMusic(byte *data, uint32 size) {
 	uint32 i = 0;
 	byte *start;
 	uint32 len;
-	uint32 chunk_len;
+	uint32 chunkLen;
 	char buf[32];
 
 	_loopCount = -1;
@@ -235,7 +230,7 @@ bool MidiParser_XMIDI::loadMusic(byte *data, uint32 size) {
 		if (!memcmp(pos, "XMID", 4)) {
 			warning("XMIDI doesn't have XDIR");
 			pos += 4;
-			_num_tracks = 1;
+			_numTracks = 1;
 		} else if (memcmp(pos, "XDIR", 4)) {
 			// Not an XMIDI that we recognize
 			warning("Expected 'XDIR' but found '%c%c%c%c'", pos[0], pos[1], pos[2], pos[3]);
@@ -243,7 +238,7 @@ bool MidiParser_XMIDI::loadMusic(byte *data, uint32 size) {
 		} else {
 			// Seems Valid
 			pos += 4;
-			_num_tracks = 0;
+			_numTracks = 0;
 
 			for (i = 4; i < len; i++) {
 				// Read 4 bytes of type
@@ -251,34 +246,34 @@ bool MidiParser_XMIDI::loadMusic(byte *data, uint32 size) {
 				pos += 4;
 
 				// Read length of chunk
-				chunk_len = read4high(pos);
+				chunkLen = read4high(pos);
 
 				// Add eight bytes
 				i += 8;
 
 				if (memcmp(buf, "INFO", 4) == 0) {
 					// Must be at least 2 bytes long
-					if (chunk_len < 2) {
-						warning("Invalid chunk length %d for 'INFO' block", (int)chunk_len);
+					if (chunkLen < 2) {
+						warning("Invalid chunk length %d for 'INFO' block", (int)chunkLen);
 						return false;
 					}
 
-					_num_tracks = (byte)read2low(pos);
+					_numTracks = (byte)read2low(pos);
 
-					if (chunk_len > 2) {
-						warning("Chunk length %d is greater than 2", (int)chunk_len);
-						//pos += chunk_len - 2;
+					if (chunkLen > 2) {
+						warning("Chunk length %d is greater than 2", (int)chunkLen);
+						//pos += chunkLen - 2;
 					}
 					break;
 				}
 
 				// Must align
-				pos += (chunk_len + 1) & ~1;
-				i += (chunk_len + 1) & ~1;
+				pos += (chunkLen + 1) & ~1;
+				i += (chunkLen + 1) & ~1;
 			}
 
 			// Didn't get to fill the header
-			if (_num_tracks == 0) {
+			if (_numTracks == 0) {
 				warning("Didn't find a valid track count");
 				return false;
 			}
@@ -308,13 +303,13 @@ bool MidiParser_XMIDI::loadMusic(byte *data, uint32 size) {
 
 		// Ok it's an XMIDI.
 		// We're going to identify and store the location for each track.
-		if (_num_tracks > ARRAYSIZE(_tracks)) {
-			warning("Can only handle %d tracks but was handed %d", (int)ARRAYSIZE(_tracks), (int)_num_tracks);
+		if (_numTracks > ARRAYSIZE(_tracks)) {
+			warning("Can only handle %d tracks but was handed %d", (int)ARRAYSIZE(_tracks), (int)_numTracks);
 			return false;
 		}
 
-		int tracks_read = 0;
-		while (tracks_read < _num_tracks) {
+		int tracksRead = 0;
+		while (tracksRead < _numTracks) {
 			if (!memcmp(pos, "FORM", 4)) {
 				// Skip this plus the 4 bytes after it.
 				pos += 8;
@@ -330,11 +325,11 @@ bool MidiParser_XMIDI::loadMusic(byte *data, uint32 size) {
 				pos += (len + 1) & ~1;
 			} else if (!memcmp(pos, "EVNT", 4)) {
 				// Ahh! What we're looking for at last.
-				_tracks[tracks_read] = pos + 8; // Skip the EVNT and length bytes
+				_tracks[tracksRead] = pos + 8; // Skip the EVNT and length bytes
 				pos += 4;
 				len = read4high(pos);
 				pos += (len + 1) & ~1;
-				++tracks_read;
+				++tracksRead;
 			} else {
 				warning("Hit invalid block '%c%c%c%c' while scanning for track locations", pos[0], pos[1], pos[2], pos[3]);
 				return false;
@@ -349,7 +344,6 @@ bool MidiParser_XMIDI::loadMusic(byte *data, uint32 size) {
 		_ppqn = 60;
 		resetTracking();
 		setTempo(500000);
-		_inserted_delta = 0;
 		setTrack(0);
 		return true;
 	}
@@ -357,11 +351,6 @@ bool MidiParser_XMIDI::loadMusic(byte *data, uint32 size) {
 	return false;
 }
 
-void MidiParser_XMIDI::resetTracking() {
-	MidiParser::resetTracking();
-	_inserted_delta = 0;
-}
-
 void MidiParser::defaultXMidiCallback(byte eventData, void *data) {
 	warning("MidiParser: defaultXMidiCallback(%d)", eventData);
 }
diff --git a/audio/softsynth/mt32/TVA.cpp b/audio/softsynth/mt32/TVA.cpp
index c3be6db591..f3e3f7bbc7 100644
--- a/audio/softsynth/mt32/TVA.cpp
+++ b/audio/softsynth/mt32/TVA.cpp
@@ -274,7 +274,7 @@ void TVA::nextPhase() {
 	}
 
 	int newTarget;
-	int newIncrement;
+	int newIncrement = 0;
 	int envPointIndex = phase;
 
 	if (!allLevelsZeroFromNowOn) {