Change doxygen inline comments from "//!" to "///" as proposed on -devel

svn-id: r44802

2 files changed, 63 insertions, 63 deletions

diff --git a/sound/midiparser.h b/sound/midiparser.h
index e8595f90c2..2e0824c943 100644
--- a/sound/midiparser.h
+++ b/sound/midiparser.h
@@ -23,7 +23,7 @@
  *
  */
 
-//! \brief Declarations related to the MidiParser class
+/// \brief Declarations related to the MidiParser class
 
 #ifndef SOUND_MIDIPARSER_H
 #define SOUND_MIDIPARSER_H
@@ -53,16 +53,16 @@ class MidiDriver;
  * 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 * _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
 
 	Tracker() { clear(); }
 
-	//! Copy constructor for each duplication of Tracker information.
+	/// Copy constructor for each duplication of Tracker information.
 	Tracker(const Tracker &copy) :
 	_play_pos(copy._play_pos),
 	_play_time(copy._play_time),
@@ -72,7 +72,7 @@ struct Tracker {
 	_running_status(copy._running_status)
 	{ }
 
-	//! Clears all data; used by the constructor for initialization.
+	/// Clears all data; used by the constructor for initialization.
 	void clear() {
 		_play_pos = 0;
 		_play_time = 0;
@@ -89,28 +89,28 @@ struct Tracker {
  * of MidiParser::parseNextEvent() each time another event is needed.
  */
 struct EventInfo {
-	byte * start; //!< Position in the MIDI stream where the event starts.
-	              //!< For delta-based MIDI streams (e.g. SMF and XMIDI), this points to the delta.
-	uint32 delta; //!< The number of ticks after the previous event that this event should occur.
-	byte   event; //!< Upper 4 bits are the command code, lower 4 bits are the MIDI channel.
-	              //!< For META, event == 0xFF. For SysEx, event == 0xF0.
+	byte * start; ///< Position in the MIDI stream where the event starts.
+	              ///< For delta-based MIDI streams (e.g. SMF and XMIDI), this points to the delta.
+	uint32 delta; ///< The number of ticks after the previous event that this event should occur.
+	byte   event; ///< Upper 4 bits are the command code, lower 4 bits are the MIDI channel.
+	              ///< For META, event == 0xFF. For SysEx, event == 0xF0.
 	union {
 		struct {
-			byte param1; //!< The first parameter in a simple MIDI message.
-			byte param2; //!< The second parameter in a simple MIDI message.
+			byte param1; ///< The first parameter in a simple MIDI message.
+			byte param2; ///< The second parameter in a simple MIDI message.
 		} basic;
 		struct {
-			byte   type; //!< For META events, this indicates the META type.
-			byte * data; //!< For META and SysEx events, this points to the start of the data.
+			byte   type; ///< For META events, this indicates the META type.
+			byte * data; ///< For META and SysEx events, this points to the start of the data.
 		} ext;
 	};
-	uint32 length; //!< For META and SysEx blocks, this indicates the length of the data.
-	               //!< For Note On events, a non-zero value indicates that no Note Off event
-	               //!< will occur, and the MidiParser will have to generate one itself.
-	               //!< For all other events, this value should always be zero.
+	uint32 length; ///< For META and SysEx blocks, this indicates the length of the data.
+	               ///< For Note On events, a non-zero value indicates that no Note Off event
+	               ///< will occur, and the MidiParser will have to generate one itself.
+	               ///< For all other events, this value should always be zero.
 
-	byte channel() { return event & 0x0F; } //!< Separates the MIDI channel from the event.
-	byte command() { return event >> 4; }   //!< Separates the command code from the event.
+	byte channel() { return event & 0x0F; } ///< Separates the MIDI channel from the event.
+	byte command() { return event >> 4; }   ///< Separates the command code from the event.
 };
 
 /**
@@ -121,9 +121,9 @@ struct EventInfo {
  * longer a note should remain active before being turned off.
  */
 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
+	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) {}
 };
 
@@ -268,30 +268,30 @@ struct NoteTimer {
  */
 class MidiParser {
 private:
-	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.
-	                                //!< 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.
+	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.
+	                                ///< 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.
 
 protected:
-	MidiDriver *_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 _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).
-	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
-
-	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.
-
-	Tracker _position;      //!< The current time/position in the active track.
-	EventInfo _next_event;  //!< 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.
+	MidiDriver *_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 _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).
+	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
+
+	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.
+
+	Tracker _position;      ///< The current time/position in the active track.
+	EventInfo _next_event;  ///< 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.
 
 protected:
 	static uint32 readVLQ(byte * &data);
diff --git a/sound/mods/tfmx.h b/sound/mods/tfmx.h
index 26018d9466..8b66ea83fe 100644
--- a/sound/mods/tfmx.h
+++ b/sound/mods/tfmx.h
@@ -89,8 +89,8 @@ private:
 	enum { kNumVoices = 4, kNumChannels = 8, kNumSubsongs = 32, kMaxPatternOffsets = 128, kMaxMacroOffsets = 128 };
 
 	struct MdatResource {
-		const byte *mdatAlloc;	//!< allocated Block of Memory
-		const byte *mdatData;  	//!< Start of mdat-File, might point before mdatAlloc to correct Offset
+		const byte *mdatAlloc;	///< allocated Block of Memory
+		const byte *mdatData;  	///< Start of mdat-File, might point before mdatAlloc to correct Offset
 		uint32 mdatLen;
 
 		uint16 headerFlags;
@@ -98,16 +98,16 @@ private:
 //		char textField[6 * 40];
 
 		struct Subsong {
-			uint16 songstart;	//!< Index in Trackstep-Table
-			uint16 songend;		//!< Last index in Trackstep-Table
+			uint16 songstart;	///< Index in Trackstep-Table
+			uint16 songend;		///< Last index in Trackstep-Table
 			uint16 tempo;
 		} subsong[kNumSubsongs];
 
-		uint32 trackstepOffset;	//!< Offset in mdat
+		uint32 trackstepOffset;	///< Offset in mdat
 		uint32 sfxTableOffset;
 
-		uint32 patternOffset[kMaxPatternOffsets];	//!< Offset in mdat
-		uint32 macroOffset[kMaxMacroOffsets];	//!< Offset in mdat
+		uint32 patternOffset[kMaxPatternOffsets];	///< Offset in mdat
+		uint32 macroOffset[kMaxMacroOffsets];	///< Offset in mdat
 
 		void boundaryCheck(const void *address, size_t accessLen = 1) const {
 			assert(mdatAlloc <= address && (const byte *)address + accessLen <= (const byte *)mdatData + mdatLen);
@@ -115,7 +115,7 @@ private:
 	} const *_resource;
 
 	struct SampleResource {
-		const int8 *sampleData;	//!< The whole sample-File
+		const int8 *sampleData;	///< The whole sample-File
 		uint32 sampleLen;
 
 		void boundaryCheck(const void *address, size_t accessLen = 2) const {
@@ -140,7 +140,7 @@ private:
 		uint16	macroReturnStep;
 		uint8	macroLoopCount;
 		bool	macroRun;
-		int8	macroSfxRun;	//!< values are the folowing: -1 macro disabled, 0 macro init, 1 macro running
+		int8	macroSfxRun;	///< values are the folowing: -1 macro disabled, 0 macro init, 1 macro running
 
 		uint32	customMacro;
 		uint8	customMacroIndex;
@@ -193,7 +193,7 @@ private:
 		uint8	command;
 		int8	expose; 
 		uint8	loopCount;
-		uint8	wait;	//!< how many ticks to wait before next Command
+		uint8	wait;	///< how many ticks to wait before next Command
 	} _patternCtx[kNumChannels];
 
 	struct TrackStepContext {
@@ -204,12 +204,12 @@ private:
 	} _trackCtx;
 
 	struct PlayerContext {
-		int8	song;	//!< >= 0 if Song is running (means process Patterns)
+		int8	song;	///< >= 0 if Song is running (means process Patterns)
 
 		uint16	patternCount;
-		uint16	patternSkip;	//!< skip that amount of CIA-Interrupts
+		uint16	patternSkip;	///< skip that amount of CIA-Interrupts
 
-		int8	volume;	//!< Master Volume
+		int8	volume;	///< Master Volume
 
 		uint8	fadeSkip;
 		uint8	fadeCount;
@@ -221,7 +221,7 @@ private:
 		uint16	*signal;
 		uint16	numSignals;
 
-		bool	stopWithLastPattern; //!< hack to automatically stop the whole player if no Pattern is running
+		bool	stopWithLastPattern; ///< hack to automatically stop the whole player if no Pattern is running
 	} _playerCtx;
 
 	const byte *getSfxPtr(uint16 index = 0) const {