Parser can now attempt to fix corrupted headers

Author: econoraptor

DemoInfo/DP/FastNetmessages/ServerInfo.cs

@@ -39,6 +39,7 @@ public void Parse(IBitStream bitstream, DemoParser parser)
 				if (wireType == 5) {
 					if (fieldnum == 14){
 						TickInterval = bitstream.ReadFloat();
+                        parser.TickInterval = TickInterval;
 					}
 					else {
 						var val = bitstream.ReadInt(32);

DemoInfo/DemoParser.cs

@@ -272,9 +272,12 @@ public IEnumerable<Player> PlayingParticipants {
 		/// <summary>
 		/// The stream of the demo - all the information go here
 		/// </summary>
-		private readonly IBitStream BitStream;
-
+		private IBitStream BitStream;
 
+        /// <summary>
+        /// The file stream read by BitStream
+        /// </summary>
+        private Stream Input;
 
 		/// <summary>
 		/// A parser for DataTables. This contains the ServerClasses and DataTables. 
@@ -432,15 +435,21 @@ public string TFlag
 		/// </summary>
 		/// <value>The tick rate.</value>
 		public float TickRate {
-            get { return 1 / ServerInfo.TickInterval; }
+            get { return this.Header.PlaybackFrames / this.Header.PlaybackTime; }
 		}
 
+        /// <summary>
+        /// Used to impute header time values when they're corrupted
+        /// TickInterval = 1/TickRate
+        /// </summary>
+        internal float TickInterval;
+
 		/// <summary>
 		/// How long a tick of the demo is in s^-1
 		/// </summary>
 		/// <value>The tick time.</value>
 		public float TickTime {
-            get { return ServerInfo.TickInterval; }
+            get { return this.Header.PlaybackTime / this.Header.PlaybackFrames;}
 		}
 
 		/// <summary>
@@ -463,6 +472,11 @@ public float ParsingProgess {
 		/// <value>The current tick.</value>
 		public int CurrentTick { get; private set; }
 
+        /// <summary>
+        /// The CurrentTick for the last tick where IngameTick == 0
+        /// </summary>
+        private int TickAtStart;
+
 		/// <summary>
 		/// The current ingame-tick as reported by the demo-file. 
 		/// </summary>
@@ -488,6 +502,8 @@ public float ParsingProgess {
 		/// <param name="input">An input-stream.</param>
 		public DemoParser(Stream input)
 		{
+            Input = input;
+
 			BitStream = BitStreamUtil.Create(input);
 
 			for (int i = 0; i < MAXPLAYERS; i++) {
@@ -512,10 +528,143 @@ public void ParseHeader()
 
 			Header = header;
 
-
 			if (HeaderParsed != null)
 				HeaderParsed(this, new HeaderParsedEventArgs(Header));
-		}
+
+            if (header.PlaybackTime == 0)  //header is corrupted
+                FixHeader();
+		}
+
+        void FixHeader()
+        {
+            ExpressParseToEnd();
+            Header.PlaybackTicks = IngameTick;
+            Header.PlaybackFrames = CurrentTick - (TickAtStart + 1);
+            Header.PlaybackTime = TickInterval * IngameTick;
+            
+            CurrentTick = 0;
+
+            //the ol' switcheroo
+            //It's probably safest and easiest to
+            //swap out for a fresh bitstream.
+            Input.Seek(0, System.IO.SeekOrigin.Begin);
+            BitStream = BitStreamUtil.Create(Input);
+            //Put the new stream back at the end of the header
+            ExpressParseHeader(BitStream);
+        }
+
+        //These express functions mirror functions without the express prefix,
+        //but all they do is read ticks and get ServerInfo.  They do not parse
+        //data from any other packets.
+        void ExpressParseToEnd()
+        {
+            while (true)
+            {
+                try
+                {
+                    if (!ExpressParseTick())
+                        break;
+                }
+                catch (System.IO.EndOfStreamException)
+                {
+                    break;
+                }
+            }
+        }
+
+
+        bool ExpressParseTick()
+        {
+            DemoCommand command = (DemoCommand)BitStream.ReadByte();
+
+            IngameTick = (int)BitStream.ReadInt(32); // tick number
+
+            if (IngameTick == 0)
+                TickAtStart = CurrentTick;
+
+            BitStream.ReadByte(); // player slot
+
+            this.CurrentTick++; // = TickNum;
+
+            switch (command)
+            {
+                case DemoCommand.Synctick:
+                    break;
+                case DemoCommand.Stop:
+                    return false;
+                case DemoCommand.ConsoleCommand:
+                    BitStream.BeginChunk(BitStream.ReadSignedInt(32) * 8);
+                    BitStream.EndChunk();
+                    break;
+                case DemoCommand.DataTables:
+                    BitStream.BeginChunk(BitStream.ReadSignedInt(32) * 8);
+                    BitStream.EndChunk();
+                    break;
+                case DemoCommand.StringTables:
+                    BitStream.BeginChunk(BitStream.ReadSignedInt(32) * 8);
+                    BitStream.EndChunk();
+                    break;
+                case DemoCommand.UserCommand:
+                    BitStream.ReadInt(32);
+                    BitStream.BeginChunk(BitStream.ReadSignedInt(32) * 8);
+                    BitStream.EndChunk();
+                    break;
+                case DemoCommand.Signon:
+                case DemoCommand.Packet:
+                    ExpressParseDemoPacket();
+                    break;
+                default:
+                    throw new Exception("Can't handle Demo-Command " + command);
+            }
+
+            return true;
+        }
+
+        void ExpressParseDemoPacket()
+        {
+            //Read a command-info. Contains no really useful information afaik. 
+            CommandInfo.Parse(BitStream);
+            BitStream.ReadInt(32); // SeqNrIn
+            BitStream.ReadInt(32); // SeqNrOut
+
+            BitStream.BeginChunk(BitStream.ReadSignedInt(32) * 8);
+            ExpressParsePacket(BitStream, this);
+            BitStream.EndChunk();
+        }
+
+        void ExpressParsePacket(IBitStream bitstream, DemoParser demo)
+        {
+            while (!bitstream.ChunkFinished)
+            {
+                int cmd = bitstream.ReadProtobufVarInt(); //What type of packet is this?
+                int length = bitstream.ReadProtobufVarInt(); //And how long is it?
+                bitstream.BeginChunk(length * 8); //read length bytes
+                if (cmd == (int)SVC_Messages.svc_ServerInfo)
+                {
+                    new ServerInfo().Parse(bitstream, demo);
+                }
+                bitstream.EndChunk();
+            }
+        }
+
+        void ExpressParseHeader(IBitStream reader)
+        {
+            var MAX_OSPATH = DemoHeader.MAX_OSPATH;
+
+            reader.ReadCString(8);
+            reader.ReadSignedInt(32);
+			reader.ReadSignedInt(32);
+            reader.ReadCString(MAX_OSPATH);
+
+            reader.ReadCString(MAX_OSPATH);
+            reader.ReadCString(MAX_OSPATH);
+            reader.ReadCString(MAX_OSPATH);
+			reader.ReadFloat();
+
+			reader.ReadSignedInt(32);
+			reader.ReadSignedInt(32);
+            reader.ReadSignedInt(32);
+        }
 
 		/// <summary>
 		/// Parses this file until the end of the demo is reached. 
@@ -599,6 +748,7 @@ private bool ParseTick()
 			DemoCommand command = (DemoCommand)BitStream.ReadByte();
 
 			IngameTick = (int)BitStream.ReadInt(32); // tick number
+
 			BitStream.ReadByte(); // player slot
 
 			this.CurrentTick++; // = TickNum;
@@ -652,7 +802,7 @@ private void ParseDemoPacket()
 		{
 			//Read a command-info. Contains no really useful information afaik. 
 			CommandInfo.Parse(BitStream);
-			BitStream.ReadInt(32); // SeqNrIn
+			uint seqin = BitStream.ReadInt(32); // SeqNrIn
 			BitStream.ReadInt(32); // SeqNrOut
 
 			BitStream.BeginChunk(BitStream.ReadSignedInt(32) * 8);

DemoInfo/Structs.cs

@@ -12,7 +12,7 @@ namespace DemoInfo
 	/// </summary>
 	public class DemoHeader
     {
-        const int MAX_OSPATH = 260;
+        internal const int MAX_OSPATH = 260;
 
 	    public string Filestamp { get; private set; }		// Should be HL2DEMO
 		public int Protocol { get; private set; }		// Should be DEMO_PROTOCOL (4)
@@ -30,9 +30,9 @@ public int NetworkProtocal {
         public string ClientName { get; private set; }		            // Name of client who recorded the game
         public string MapName { get; private set; }			        // Name of map
         public string GameDirectory { get; private set; }	            // Name of game directory (com_gamedir)
-        public float PlaybackTime { get; private set; }				// Time of track
-        public int PlaybackTicks { get; private set; }				// # of ticks in track
-        public int PlaybackFrames { get; private set; }			// # of frames in track
+        public float PlaybackTime { get; set; }				// Time of track
+        public int PlaybackTicks { get; set; }				// # of ticks in track
+        public int PlaybackFrames { get; set; }			// # of frames in track
         public int SignonLength { get; private set; }				// length of sigondata in bytes
 
         public static DemoHeader ParseFrom(IBitStream reader)