fixed math error and plumbed the needed metadata through (#51)

Author: jim-wordelman-msft

CtfPlayback/CtfPlayback.cs

@@ -91,7 +91,8 @@ public void Playback(
                     streamPlayback.CurrentEvent, 
                     streamPlayback.CurrentPacket, 
                     this.streamToTrace[streamPlayback], 
-                    streamPlayback.EventStream);
+                    streamPlayback.EventStream,
+                    streamPlayback.Metadata);
 
                 this.eventCount++;
 

CtfPlayback/EventStreams/CtfEvent.cs

@@ -14,11 +14,13 @@ internal class CtfEvent
     {
         private readonly PacketReader packetReader;
         private readonly ICtfPacket owningPacket;
+        private readonly ICtfMetadata metadata;
 
-        public CtfEvent(PacketReader packetReader, ICtfPacket owningPacket)
+        public CtfEvent(PacketReader packetReader, ICtfMetadata metadata, ICtfPacket owningPacket)
         {
             this.packetReader = packetReader;
             this.owningPacket = owningPacket;
+            this.metadata = metadata;
         }
 
         public ulong ByteOffsetWithinPacket { get; private set; }
@@ -49,7 +51,7 @@ public void ReadEventMetadata()
 
             this.ReadStreamEventContext();
 
-            this.Timestamp = this.packetReader.PlaybackCustomization.GetTimestampFromEventHeader(this, this.owningPacket.CurrentEvent?.Timestamp);
+            this.Timestamp = this.packetReader.PlaybackCustomization.GetTimestampFromEventHeader(this, this.metadata, this.owningPacket.CurrentEvent?.Timestamp);
 
             this.DiscardedEvents = this.owningPacket.StreamPacketContext.ReadFieldAsUInt32("events_discarded");
 
@@ -79,7 +81,7 @@ public void ReadEventMetadata()
 
         public void Read()
         {
-            this.EventDescriptor = this.packetReader.PlaybackCustomization.GetEventDescriptor(this);
+            this.EventDescriptor = this.packetReader.PlaybackCustomization.GetEventDescriptor(this, this.metadata);
             if (this.EventDescriptor == null)
             {
                 throw new CtfPlaybackException("Missing event descriptor for event.");

CtfPlayback/EventStreams/CtfPacket.cs

@@ -73,7 +73,7 @@ public bool ReadPacketMetadata()
             this.PacketTimestampsAreValid = false;
 
             if (this.packetReader.PlaybackCustomization.GetTimestampsFromPacketContext(
-                this, out var startValue, out var endValue))
+                this, this.Metadata, out var startValue, out var endValue))
             {
                 this.Start = startValue;
                 this.End = endValue;
@@ -92,7 +92,7 @@ public bool MoveToNextEvent()
                 return false;
             }
 
-            var nextEvent = new CtfEvent(this.packetReader, this);
+            var nextEvent = new CtfEvent(this.packetReader, this.Metadata, this);
             nextEvent.ReadEventMetadata();
 
             this.CurrentEvent = nextEvent;

CtfPlayback/FieldValues/CtfTimestamp.cs

@@ -30,8 +30,9 @@ public class CtfTimestamp
         /// Constructor
         /// </summary>
         /// <param name="metadataCustomization">Extensibility points</param>
+        /// <param name="metadata">The active metadata relevant to this timestamp</param>
         /// <param name="integerValue">integer representation of the timestamp</param>
-        public CtfTimestamp(ICtfMetadataCustomization metadataCustomization, CtfIntegerValue integerValue)
+        public CtfTimestamp(ICtfMetadataCustomization metadataCustomization, ICtfMetadata metadata, CtfIntegerValue integerValue)
         {
             this.BaseIntegerValue = integerValue;
 
@@ -44,9 +45,9 @@ public CtfTimestamp(ICtfMetadataCustomization metadataCustomization, CtfIntegerV
                     throw new CtfPlaybackException($"Unable to parse integer map value as a clock: {integerValue.MapValue}");
                 }
 
-                if (metadataCustomization.Metadata.Clocks?.Count == 1)
+                if (metadata.Clocks?.Count == 1)
                 {
-                    clockName = metadataCustomization.Metadata.Clocks[0].Name;
+                    clockName = metadata.Clocks[0].Name;
                 }
                 else
                 {
@@ -55,7 +56,7 @@ public CtfTimestamp(ICtfMetadataCustomization metadataCustomization, CtfIntegerV
                 }
             }
 
-            if (!metadataCustomization.Metadata.ClocksByName.TryGetValue(clockName, out var clockDescriptor))
+            if (!metadata.ClocksByName.TryGetValue(clockName, out var clockDescriptor))
             {
                 throw new CtfPlaybackException($"Unable to retrieve clock descriptor for timestamp value: {integerValue.MapValue}");
             }
@@ -77,10 +78,11 @@ public CtfTimestamp(ICtfMetadataCustomization metadataCustomization, CtfIntegerV
         /// Constructor
         /// </summary>
         /// <param name="metadataCustomization">Extensibility points</param>
+        /// <param name="metadata">The active metadata relevant to this timestamp</param>
         /// <param name="integerValue">Integer representation of the timestamp</param>
         /// <param name="timestampValue">Timestamp value in units specified by the ClockDescriptor</param>
-        public CtfTimestamp(ICtfMetadataCustomization metadataCustomization, CtfIntegerValue integerValue, long timestampValue)
-            : this(metadataCustomization, integerValue)
+        public CtfTimestamp(ICtfMetadataCustomization metadataCustomization, ICtfMetadata metadata, CtfIntegerValue integerValue, long timestampValue)
+            : this(metadataCustomization, metadata, integerValue)
         {
             if (timestampValue < 0)
             {

CtfPlayback/ICtfPlaybackCustomization.cs

@@ -30,19 +30,21 @@ public interface ICtfPlaybackCustomization
         /// Allows for customized parsing of a packet to determine its start and end timestamps.
         /// </summary>
         /// <param name="ctfPacket"></param>
+        /// <param name="metadata"></param>
         /// <param name="start"></param>
         /// <param name="end"></param>
         /// <returns></returns>
         bool GetTimestampsFromPacketContext(
             ICtfPacket ctfPacket,
+            ICtfMetadata metadata,
             out CtfTimestamp start,
             out CtfTimestamp end);
 
         /// <summary>
         /// Allows for customized parsing of an event header data to determine a timestamp
         ///  for the event.
         /// </summary>
-        CtfTimestamp GetTimestampFromEventHeader(ICtfEvent ctfEvent, CtfTimestamp previousTimestamp);
+        CtfTimestamp GetTimestampFromEventHeader(ICtfEvent ctfEvent, ICtfMetadata metadata, CtfTimestamp previousTimestamp);
 
         /// <summary>
         /// Used to retrieve the total number of bits in a packet.
@@ -62,8 +64,9 @@ bool GetTimestampsFromPacketContext(
         /// Reads the event at the current location from packetReader 
         /// </summary>
         /// <param name="ctfEvent">Event with its context and header filled in</param>
+        /// <param name="metadata">The metadata for the event</param>
         /// <returns></returns>
-        ICtfEventDescriptor GetEventDescriptor(ICtfEvent ctfEvent);
+        ICtfEventDescriptor GetEventDescriptor(ICtfEvent ctfEvent, ICtfMetadata metadata);
 
         /// <summary>
         /// Called during trace playback for the current event.
@@ -72,6 +75,7 @@ bool GetTimestampsFromPacketContext(
         /// <param name="eventPacket">Packet which contains the event</param>
         /// <param name="ctfTraceInput">Trace which contains the event</param>
         /// <param name="ctfEventStream">Stream which contains the event</param>
-        void ProcessEvent(ICtfEvent ctfEvent, ICtfPacket eventPacket, ICtfTraceInput ctfTraceInput, ICtfInputStream ctfEventStream);
+        /// <param name="metadata">The metadata for the event</param>
+        void ProcessEvent(ICtfEvent ctfEvent, ICtfPacket eventPacket, ICtfTraceInput ctfTraceInput, ICtfInputStream ctfEventStream, ICtfMetadata metadata);
     }
 }

CtfPlayback/Metadata/Interfaces/ICtfEventDescriptor.cs

@@ -10,6 +10,11 @@ namespace CtfPlayback.Metadata.Interfaces
     /// </summary>
     public interface ICtfEventDescriptor
     {
+        /// <summary>
+        /// The id of the event
+        /// </summary>
+        public uint Id { get; }
+
         /// <summary>
         /// Event context type
         /// </summary>

CtfPlayback/PacketReader.cs

@@ -323,7 +323,7 @@ public void Align(uint bitCount)
 
             // progress by entire bytes, we should be byte aligned at this point
             Debug.Assert(this.bitsConsumedInCurrentByte == 0);
-            while (bitsToProgress > 8)
+            while (bitsToProgress >= 8)
             {
                 if (this.bufferByteIndex + 1 >= this.bufferByteCount)
                 {

LTTngCds/CtfExtensions/LTTngPlaybackCustomization.cs

@@ -4,6 +4,7 @@
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
+using System.Linq;
 using CtfPlayback;
 using CtfPlayback.EventStreams.Interfaces;
 using CtfPlayback.FieldValues;
@@ -45,6 +46,7 @@ public virtual ICtfMetadataParser CreateMetadataParser(
 
         public bool GetTimestampsFromPacketContext(
             ICtfPacket ctfPacket, 
+            ICtfMetadata metadata,
             out CtfTimestamp start, 
             out CtfTimestamp end)
         {
@@ -76,8 +78,8 @@ public bool GetTimestampsFromPacketContext(
                 return false;
             }
 
-            start = new CtfTimestamp(this.MetadataCustomization, startFieldInteger);
-            end = new CtfTimestamp(this.MetadataCustomization, endFieldInteger);
+            start = new CtfTimestamp(this.MetadataCustomization, metadata, startFieldInteger);
+            end = new CtfTimestamp(this.MetadataCustomization, metadata, endFieldInteger);
             return true;
         }
 
@@ -86,7 +88,7 @@ public void RegisterEventCallback(Action<LTTngEvent, LTTngContext> eventCallback
             this.eventCallbacks.Add(eventCallback);
         }
 
-        public virtual CtfTimestamp GetTimestampFromEventHeader(ICtfEvent ctfEvent, CtfTimestamp previousTimestamp)
+        public virtual CtfTimestamp GetTimestampFromEventHeader(ICtfEvent ctfEvent, ICtfMetadata metadata, CtfTimestamp previousTimestamp)
         {
             var variantStruct = GetStreamEventHeaderStructure(ctfEvent);
             Debug.Assert(variantStruct != null);
@@ -107,7 +109,7 @@ public virtual CtfTimestamp GetTimestampFromEventHeader(ICtfEvent ctfEvent, CtfT
                 // todo:I think we need to do something else for this case, especially if the integer size is < 64
                 // not sure what yet. maybe base it on the clock's offset?
 
-                return new CtfTimestamp(this.MetadataCustomization, timestampInteger);
+                return new CtfTimestamp(this.MetadataCustomization, metadata, timestampInteger);
             }
 
             // Timestamps aren't actually absolute values. To quote from CTF spec 1.8.2 section 8:
@@ -139,10 +141,10 @@ public virtual CtfTimestamp GetTimestampFromEventHeader(ICtfEvent ctfEvent, CtfT
                     Debug.Assert(newTimestamp > previous);
                 }
 
-                return new CtfTimestamp(this.MetadataCustomization, timestampInteger, newTimestamp);
+                return new CtfTimestamp(this.MetadataCustomization, metadata, timestampInteger, newTimestamp);
             }
 
-            return new CtfTimestamp(this.MetadataCustomization, timestampInteger);
+            return new CtfTimestamp(this.MetadataCustomization, metadata, timestampInteger);
         }
 
         /// <inheritdoc />
@@ -218,20 +220,31 @@ public ulong GetPacketContentBitCount(ICtfPacket ctfPacket)
         }
 
         /// <inheritdoc />
-        public ICtfEventDescriptor GetEventDescriptor(
-            ICtfEvent ctfEvent)
+        public ICtfEventDescriptor GetEventDescriptor(ICtfEvent ctfEvent, ICtfMetadata metadata)
         {
             uint id = this.GetEventId(ctfEvent);
 
-            if (!this.metadataCustomization.LTTngMetadata.EventByEventId.TryGetValue(id, out var eventDescriptor))
+            ICtfEventDescriptor eventDescriptor;
+            if (metadata is LTTngMetadata typedMetadata)
+            {
+                // optimization if we got our own typed metadata back
+                // we check for success below
+                typedMetadata.EventByEventId.TryGetValue(id, out eventDescriptor);
+            }
+            else
+            {
+                eventDescriptor = metadata.Events.FirstOrDefault(x => x.Id == id);
+            }
+
+            if (eventDescriptor == null)
             {
                 throw new LTTngPlaybackException($"Unable to find event descriptor for event id={id}.");
             }
 
             return eventDescriptor;
         }
 
-        public void ProcessEvent(ICtfEvent ctfEvent, ICtfPacket eventPacket, ICtfTraceInput traceInput, ICtfInputStream ctfEventStream)
+        public void ProcessEvent(ICtfEvent ctfEvent, ICtfPacket eventPacket, ICtfTraceInput traceInput, ICtfInputStream ctfEventStream, ICtfMetadata metadata)
         {
             var eventDescriptor = ctfEvent.EventDescriptor as EventDescriptor;
             Debug.Assert(eventDescriptor != null);
@@ -255,7 +268,7 @@ public void ProcessEvent(ICtfEvent ctfEvent, ICtfPacket eventPacket, ICtfTraceIn
 
             if (!this.traceContexts.TryGetValue(traceInput, out var traceContext))
             {
-                traceContext = new TraceContext(this.metadataCustomization.LTTngMetadata);
+                traceContext = new TraceContext(metadata);
                 this.traceContexts.Add(traceInput, traceContext);
             }
 

LTTngCds/CtfExtensions/TraceContext.cs

@@ -1,11 +1,13 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
+using CtfPlayback.Metadata.Interfaces;
+
 namespace LTTngCds.CtfExtensions
 {
     internal class TraceContext
     {
-        internal TraceContext(LTTngMetadata metadata)
+        internal TraceContext(ICtfMetadata metadata)
         {
             if (metadata.EnvironmentDescriptor.Properties.TryGetValue("hostname", out string hostName))
             {