public void SetEndian(EEndian endian)
{
if (endian == EEndian.BIG_ENDIAN)
{
m_bSwapEndian = true;
}
}
public static UInt64 ToUInt64(byte[] b, int p, EEndian srcEndian)
{
UInt64 i = BitConverter.ToUInt64(b, p);
if (srcEndian != m_destEndian)
{
unsafe
{
SwapEndian8((ulong *)&i);
}
}
return(i);
}
public static UInt32 ToUInt32(byte[] b, int p, EEndian srcEndian)
{
UInt32 i = BitConverter.ToUInt32(b, p);
if (srcEndian != m_destEndian)
{
unsafe
{
SwapEndian4((uint *)&i);
}
}
return(i);
}
public static UInt16 ToUInt16(byte[] b, int p, EEndian srcEndian)
{
UInt16 i = BitConverter.ToUInt16(b, p);
if (srcEndian != m_destEndian)
{
unsafe
{
SwapEndian2((ushort *)&i);
}
}
return(i);
}
public static float ToSingle(byte[] b, int p, EEndian srcEndian)
{
if (srcEndian != m_destEndian)
{
UInt32 i = BitConverter.ToUInt32(b, p);
unsafe
{
SwapEndian4((uint *)&i);
return(*(float *)&i);
}
}
return(BitConverter.ToSingle(b, p));
}
private void ReadModifyIntervalBit(Int64 timeStamp, int eventLength, IBinaryLogDataStream stream)
{
UInt64 ivId = stream.ReadUInt64();
UInt32 classId = stream.ReadUInt32();
UInt32 field = stream.ReadUInt32();
UInt32 fieldId = field & 0x7fffffff;
UInt32 splitInterval = field & 0x80000000;
byte[] values = stream.ReadBytes(eventLength - 16);
if (m_pendingIntervals.ContainsKey(ivId))
{
EventClassDesc classDesc = m_classDescs[classId];
PendingInterval pi = m_pendingIntervals[ivId];
Interval iv = pi.iv;
if (splitInterval != 0)
{
iv.EndUs = timeStamp;
Interval ivClone = (Interval)iv.Clone();
pi.sink.OnFinalisedInterval(ivId, iv, true);
iv = ivClone;
pi.iv = iv;
iv.StartUs = timeStamp;
iv.EndUs = Int64.MaxValue;
}
EEndian srcEndian = stream.Endianness;
object valMask = null, valOr = null;
switch (classDesc.properties[fieldId].type)
{
case EFrameElementType.Int:
valMask = EndianBitConverter.ToInt32(values, 0, srcEndian);
valOr = EndianBitConverter.ToInt32(values, 4, srcEndian);
break;
case EFrameElementType.Int64:
valMask = EndianBitConverter.ToInt64(values, 0, srcEndian);
valOr = EndianBitConverter.ToInt64(values, 8, srcEndian);
break;
default:
throw new ApplicationException("Unhandled property type");
}
if (classDesc.properties[fieldId].field != null)
{
object oldVal = classDesc.properties[fieldId].field.GetValue(iv);
switch (classDesc.properties[fieldId].type)
{
case EFrameElementType.Int:
classDesc.properties[fieldId].field.SetValue(iv, ((int)oldVal & (int)valMask) | ((int)valOr));
break;
case EFrameElementType.Int64:
classDesc.properties[fieldId].field.SetValue(iv, ((long)oldVal & (long)valMask) | ((long)valOr));
break;
}
}
if (splitInterval != 0)
{
pi.sink.OnBegunInterval(ivId, iv);
}
}
else
{
//throw new ApplicationException("Unknown interval");
}
}
private void ReadModifyInterval(Int64 timeStamp, int eventLength, IBinaryLogDataStream stream)
{
UInt64 ivId = stream.ReadUInt64();
UInt32 classId = stream.ReadUInt32();
UInt32 field = stream.ReadUInt32();
UInt32 fieldId = field & 0x7fffffff;
UInt32 splitInterval = field & 0x80000000;
byte[] values = stream.ReadBytes(eventLength - 16);
if (m_pendingIntervals.ContainsKey(ivId))
{
EventClassDesc classDesc = m_classDescs[classId];
PendingInterval pi = m_pendingIntervals[ivId];
Interval iv = pi.iv;
if (splitInterval != 0)
{
iv.EndUs = timeStamp;
Interval ivClone = (Interval)iv.Clone();
pi.sink.OnFinalisedInterval(ivId, iv, true);
iv = ivClone;
pi.iv = iv;
iv.StartUs = timeStamp;
iv.EndUs = Int64.MaxValue;
}
EEndian srcEndian = stream.Endianness;
object val = null;
switch (classDesc.properties[fieldId].type)
{
case EFrameElementType.Float:
val = EndianBitConverter.ToSingle(values, 0, srcEndian);
break;
case EFrameElementType.Int:
val = EndianBitConverter.ToInt32(values, 0, srcEndian);
break;
case EFrameElementType.String:
{
int nullTerm = Array.IndexOf <byte>(values, 0, 0);
string s = System.Text.Encoding.ASCII.GetString(values, 0, nullTerm);
val = s;
}
break;
case EFrameElementType.Int64:
val = EndianBitConverter.ToInt64(values, 0, srcEndian);
break;
default:
throw new ApplicationException("Unhandled property type");
}
if (classDesc.properties[fieldId].field != null)
{
classDesc.properties[fieldId].field.SetValue(iv, val);
}
if (splitInterval != 0)
{
pi.sink.OnBegunInterval(ivId, iv);
}
}
else
{
//throw new ApplicationException("Unknown interval");
}
}
/// <summary>
/// NetStreamWrite
/// </summary>
/// <param name="len">len</param>
/// <param name="endian">endian</param>
public NetStreamWrite(int len = 4096, EEndian endian = EEndian.BigEndian)
{
this.endian = endian;
ms = new MemoryStream(len);
}
/// <summary>
/// NetStreamRead
/// </summary>
/// <param name="buf">buf</param>
/// <param name="offset">offset</param>
/// <param name="len">len</param>
/// <param name="endian">endian</param>
public NetStreamRead(byte[] buf, int offset, int len, EEndian endian = EEndian.BigEndian)
{
this.endian = endian;
ms = new MemoryStream(buf, offset, len);
}
public void ProcessDataStream()
{
CultureInfo decimalCulture = new CultureInfo("en-US");
Regex callstackAddressesRegex = new Regex(@"0x[0-9|a-f|A-F]*");
IIntervalSink[] ivSinks = new IIntervalSink[] {
new StreamingIntervalSink(m_logData),
new StreamingObjectSink(m_logData, "/Objects", 111),
new StreamingTextureSink(m_logData, "/Textures", 116),
};
EventReader eventReader = new EventReader(ivSinks);
try
{
//Endian
byte[] endianByte = m_logDataStream.ReadBytes(1);
EEndian endian = (EEndian)endianByte[0];
m_logDataStream.SetEndian(endian);
//Version
UInt32 version = m_logDataStream.ReadUInt32();
if (version > STATOSCOPE_BINARY_VERSION)
{
throw new Exception("Binary file version mismatch");
}
m_logVersion = version;
//Using string pool?
m_bUsingStringPool = m_logDataStream.ReadBool();
List <KeyValuePair <string, EItemType> > newmds = new List <KeyValuePair <string, EItemType> >();
FrameRecordPathCollection paths = new FrameRecordPathCollection();
while (!m_logDataStream.IsEndOfStream)
{
// header present
if (m_logDataStream.ReadBool())
{
// modules present
if (m_logDataStream.ReadBool())
{
ReadModules();
}
ReadFormat();
}
//FRAME RECORD BEGIN
FrameRecordValues values = new FrameRecordValues(paths);
float frameTimeInS = 0.0f;
MemoryStream screenshotImage = null;
List <UserMarker> userMarkers = new List <UserMarker>();
List <Callstack> callstacks = new List <Callstack>();
//check for fps or screen shot
float frameTimeValue = m_logDataStream.ReadFloat();
if (frameTimeValue > 0)
{
frameTimeInS = (float)Convert.ToDouble(frameTimeValue, decimalCulture);
}
EFrameElementType type = ReadFrameElementType();
if (type == EFrameElementType.B64Texture)
{
//process texture
int size = m_logDataStream.ReadInt32();
byte[] screenShotBytes = m_logDataStream.ReadBytes(size);
screenshotImage = ImageProcessor.CreateImageStreamFromScreenshotBytes(screenShotBytes);
}
//On to specific data groups
foreach (PerfStatLogLineDescriptor lld in m_logLineDescriptors)
{
//number of stats, so records have a variable number of entries, like frame profiler
int nStats = m_logDataStream.ReadInt32();
for (int i = 0; i < nStats; i++)
{
string path = lld.m_path;
foreach (PerfStatFrameElement fe in lld.m_formatElements)
{
if (fe.m_type == EFrameElementType.String && fe.m_name.Equals("path"))
{
// Replace first occurrence of "$" in path with its placeholder value
string valueString = ReadString();
StringBuilder sbModifiedString = new StringBuilder(path);
sbModifiedString.Replace("$", valueString, path.IndexOf("$"), 1);
path = sbModifiedString.ToString();
}
else
{
switch (fe.m_type)
{
case EFrameElementType.Float:
{
float value = m_logDataStream.ReadFloat();
string itemname = path + fe.m_name;
values[itemname] += value; // += as there may be duplicate records per frame
newmds.Add(new KeyValuePair <string, EItemType>(itemname, EItemType.Float));
}
break;
case EFrameElementType.Int:
{
int value = m_logDataStream.ReadInt32();
string itemname = path + fe.m_name;
values[itemname] += (float)value; // += as there may be duplicate records per frame
newmds.Add(new KeyValuePair <string, EItemType>(itemname, EItemType.Int));
}
break;
case EFrameElementType.B64Texture:
throw new Exception("Screen shot in frame profiler not supported");
//break;
case EFrameElementType.String:
string userMarkersInitialPath = "/UserMarkers/";
string callstacksInitialPath = "/Callstacks/";
string valueString = ReadString();
if (path.StartsWith(userMarkersInitialPath))
{
string pathNoEndSlash = path.TrimEnd(new char[] { '/' }); // old format compatibility
UserMarker userMarker = new UserMarker(pathNoEndSlash, valueString);
userMarkers.Add(userMarker);
}
else if (path.StartsWith(callstacksInitialPath))
{
Callstack callstack = new Callstack(path.Substring(callstacksInitialPath.Length));
MatchCollection addressesMatches = callstackAddressesRegex.Matches(valueString);
foreach (Match addressMatch in addressesMatches)
{
UInt32 address = Convert.ToUInt32(addressMatch.Value, 16);
callstack.m_functions.Add(GetSymbolNameFromAddress(address));
}
callstack.m_functions.Reverse();
callstacks.Add(callstack);
}
break;
}
}
}
}
}
if (version > 1)
{
eventReader.ReadEvents(m_logDataStream);
}
UInt32 magic = m_logDataStream.ReadUInt32();
if (magic != 0xdeadbeef)
{
throw new Exception("Frame Record is corrupt");
}
for (int si = 0, sc = ivSinks.Length; si != sc; ++si)
{
ivSinks[si].OnFrameRecord(values);
}
FrameRecord fr = new FrameRecord(m_logData.FrameRecords.Count, frameTimeInS, screenshotImage, m_logData.CreateNewFrameRecordValues(values), userMarkers, callstacks);
m_logData.AddFrameRecord(fr, newmds);
m_logDataStream.FlushWriteStream();
newmds.Clear();
}
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
foreach (var resolver in m_symbolResolvers)
{
resolver.Dispose();
}
m_symbolResolvers.Clear();
m_logDataStream.CloseWriteStream();
}
