/**************************************************************************** * * Copyright (c) 2018 CRI Middleware Co., Ltd. * ****************************************************************************/ #if UNITY_EDITOR using System; using System.IO; using System.Linq; using System.Collections; using System.Collections.Generic; using System.Net; using System.Net.Sockets; using System.Threading; using System.Diagnostics; using UnityEngine; namespace CriWare { public partial class CriProfiler { private static CriProfiler singleton = new CriProfiler(); public static CriProfiler GetSingleton() { return singleton; } #region Structs and Classes // TCP connection parameters to be send to the thread protected struct TcpParams { public readonly IPAddress ipAddress; public readonly int port; public readonly int chunkSize; public readonly int connectionTimeoutMillisec; public readonly int connectionRetryIntervalMillisec; public readonly int connectionRetryLimit; public readonly int enBufferIntervalMillisec; public TcpParams( IPAddress ipAddress, int port, int chunkSize, int connectionTimeoutMillisec, int connectionRetryIntervalMillisec, int connectionRetryLimit, int enBufferIntervalMillisec) { this.ipAddress = ipAddress; this.port = port; this.chunkSize = chunkSize; this.connectionTimeoutMillisec = connectionTimeoutMillisec; this.connectionRetryIntervalMillisec = connectionRetryIntervalMillisec; this.connectionRetryLimit = connectionRetryLimit; this.enBufferIntervalMillisec = enBufferIntervalMillisec; } } // TCP data buffer private class RingBuffer { protected T[] data; protected int size; protected int head; protected int tail; protected int mask; /* for remainder operation */ static private int RegulateToPow2(uint n) { int res = 0; for (n -= 1; n != 0; n >>= 1) { res = (res << 1) + 1; } return res + 1; } // Specify the size of the buffer. // The resulted size will be rounded up to the nearest 2^n number for the sake of performance. public RingBuffer(int _size) { size = RegulateToPow2((uint)_size); data = new T[size]; head = 0; tail = 0; mask = size - 1; } // Get the number of elements in the buffer public int Count { get { int _count = this.tail - this.head; if (_count < 0) _count += this.size; return _count; } } public int Capacity { get { return size - 1; } } // Index access to the buffer. public T this[int i] { get { return this.data[(i + this.head) & this.mask]; } private set { this.data[(i + this.head) & this.mask] = value; } } // Copy [inputSize] of elements from inputData to the tail of the buffer. // return false if the buffer is full. public bool EnBuffer(T[] inputData, int inputSize) { if (this.Count + inputSize >= this.size) { return false; } for (int i = 0; i < inputSize; ++i) { this.data[this.tail] = inputData[i]; this.tail = (this.tail + 1) & this.mask; } return true; } // Read [outputSize] of elements and delete it from the head of the buffer. // Return null if there is nothing to read. // The resulted array may be smaller in length than requested. public T[] DeBuffer(int outputSize) { if (outputSize <= 0 || this.Count <= 0) { return null; } if (outputSize > this.Count) { return null; } T[] res = new T[outputSize]; for (int i = 0; i < outputSize; ++i) { res[i] = this[i]; } this.head = (this.head + outputSize) & this.mask; return res; } // Clear the buffer. Memory spaces will still be occupied. public void Clear() { this.head = 0; this.tail = 0; } } private class RingBufferAutoDequeue : RingBuffer { public RingBufferAutoDequeue(int size) : base(size) { } public new bool EnBuffer(T[] inputData, int inputSize) { if (this.Count + inputSize >= this.size) { this.DeBuffer(this.Count + inputSize - this.size + 1); } for (int i = 0; i < inputSize; ++i) { this.data[this.tail] = inputData[i]; this.tail = (this.tail + 1) & this.mask; } return true; } public void FillWithZeros() { T[] zeros = new T[Capacity]; this.EnBuffer(zeros, Capacity); } } #region Loading / Saving data from big-endian data stream public static Byte LoadBigEndianByte(Byte[] data, int ofst) { return data[ofst]; } public static void SaveBigEndianByte(Byte[] data, int ofst, Byte input) { data[ofst] = input; } public static UInt16 LoadBigEndianUInt16(Byte[] data, int ofst) { return (UInt16)( ((data[ofst + 0]) << 8) | (data[ofst + 1])); } public static void SaveBigEndianUInt16(Byte[] data, int ofst, UInt16 input) { data[ofst + 0] = (byte)((input >> 8) & 0xff); data[ofst + 1] = (byte)( input & 0xff); } public static UInt32 LoadBigEndianUInt32(Byte[] data, int ofst) { return (UInt32)( ((data[ofst + 0]) << 24) | ((data[ofst + 1]) << 16) | ((data[ofst + 2]) << 8) | (data[ofst + 3])); } public static void SaveBigEndianUInt32(Byte[] data, int ofst, UInt32 input) { data[ofst + 0] = (byte)((input >> 24) & 0xff); data[ofst + 1] = (byte)((input >> 16) & 0xff); data[ofst + 2] = (byte)((input >> 8) & 0xff); data[ofst + 3] = (byte)( input & 0xff); } public static Single LoadBigEndianSingle(Byte[] data, int ofst) { /* convert to little-endian for System.BitConverter */ byte[] byteVals = new[] { data[ofst + 3], data[ofst + 2], data[ofst + 1], data[ofst + 0] }; return BitConverter.ToSingle(byteVals, 0); } public static UInt64 LoadBigEndianUInt64(Byte[] data, int ofst) { return (UInt64)( ((data[ofst + 0]) << 56) | ((data[ofst + 1]) << 48) | ((data[ofst + 2]) << 40) | ((data[ofst + 3]) << 32) | ((data[ofst + 4]) << 24) | ((data[ofst + 5]) << 16) | ((data[ofst + 6]) << 8) | (data[ofst + 7])); } public static void SaveBigEndianUInt64(Byte[] data, int ofst, UInt64 input) { data[ofst + 0] = (byte)((input >> 56) & 0xff); data[ofst + 1] = (byte)((input >> 48) & 0xff); data[ofst + 2] = (byte)((input >> 40) & 0xff); data[ofst + 3] = (byte)((input >> 32) & 0xff); data[ofst + 4] = (byte)((input >> 24) & 0xff); data[ofst + 5] = (byte)((input >> 16) & 0xff); data[ofst + 6] = (byte)((input >> 8) & 0xff); data[ofst + 7] = (byte)( input & 0xff); } #endregion protected struct TcpLogHeader { public const int properSize /* = sizeof(UInt32) + sizeof(UInt16) + sizeof(Byte) + sizeof(Byte) + sizeof(UInt64) * + sizeof(UInt16) + sizeof(UInt16) + sizeof(UInt32) + sizeof(UInt64); */ = 32; public readonly UInt32 packetSize; public readonly UInt16 command; public readonly Byte ptr_size; public readonly Byte log_type; public readonly UInt64 time; public readonly UInt16 function_id; public readonly UInt16 padding_size; public readonly UInt32 control_id; public readonly UInt64 thread_id; public readonly bool isPtr64; public readonly int size; public TcpLogHeader(byte[] data) { int offset = 0; isPtr64 = false; packetSize = LoadBigEndianUInt32(data, offset); offset += sizeof(UInt32); command = LoadBigEndianUInt16(data, offset); offset += sizeof(UInt16); ptr_size = LoadBigEndianByte(data, offset); isPtr64 = ((ptr_size - sizeof(UInt32)) == 0) ? false : true; offset += sizeof(Byte); log_type = LoadBigEndianByte(data, offset); offset += sizeof(Byte); time = LoadBigEndianUInt64(data, offset); offset += sizeof(UInt64); function_id = LoadBigEndianUInt16(data, offset); offset += sizeof(UInt16); padding_size = LoadBigEndianUInt16(data, offset); offset += sizeof(UInt16); control_id = LoadBigEndianUInt32(data, offset); offset += sizeof(UInt32); if(isPtr64 == true) { thread_id = LoadBigEndianUInt64(data, offset); offset += sizeof(UInt64); } else { offset += sizeof(UInt32); thread_id = LoadBigEndianUInt32(data, offset); offset += sizeof(UInt32); } size = offset; if (size != properSize) { UnityEngine.Debug.LogError("[CRIWARE] (Profiler) Corrupted log header"); } } } private class ParamIdDoesNotMatchException : Exception { public ParamIdDoesNotMatchException() { } public ParamIdDoesNotMatchException(string message) : base(message) { } public ParamIdDoesNotMatchException(string message, Exception inner) : base(message, inner) { } } public class PlaybackInfo { public readonly UInt32 playbackId; public readonly String cueName; public readonly String cueSheetName; public readonly UInt64 timestamp; public int? StreamType; public PlaybackInfo(UInt32 playbackId, String cueName, String cueSheetName, UInt64 timestamp) { this.playbackId = playbackId; this.cueName = cueName; this.cueSheetName = cueSheetName; this.timestamp = timestamp; this.StreamType = null; } } public class VoicePoolInfo { public UInt32 soundFormat; public int numUsedVoices; public int? StreamType; public VoicePoolInfo(UInt32 soundFormat, int? StreamType = null) { this.soundFormat = soundFormat; this.StreamType = StreamType; this.numUsedVoices = -1; /* <0: no data yet */ } } public struct LevelInfo { public Single levelPeak; public Single levelRms; public Single levelPeakHold; public LevelInfo(Single levelPeak, Single levelRms, Single levelPeakHold) { this.levelPeak = levelPeak; this.levelRms = levelRms; this.levelPeakHold = levelPeakHold; } } #endregion #region Internal data private Thread threadTcpClient; private Thread threadPacketReading; private ManualResetEvent threadTerminator = new ManualResetEvent(false); private RingBuffer TcpBuffer = new RingBuffer(16384); private List eventLogList = new List(); private bool isProfiling = false; private bool isConnected = false; private bool isBufferCorrupted = false; private bool doSaveLog; private FileStream logStream = null; private const int cRwLockTimeoutMs = 100; public bool IsProfiling { get { return isProfiling; } } #endregion #region Fields / Properties public UInt64 timestamp { get; private set; } public UInt64 timestampStart { get; private set; } public Single cpu_load { get; private set; } private RingBufferAutoDequeue cpuLoadHistory = new RingBufferAutoDequeue(100); public Single[] CpuLoadHistory { get { lock (cpuLoadHistory) { Single[] histArray = new Single[cpuLoadHistory.Count]; for (int i = 0; i < cpuLoadHistory.Count; ++i) { histArray[i] = cpuLoadHistory[i]; } return histArray; } } } public UInt32 num_used_voices { get; private set; } private RingBufferAutoDequeue voiceUsageHistory = new RingBufferAutoDequeue(100); public UInt32[] VoiceUsageHistory { get { lock (voiceUsageHistory) { UInt32[] histArray = new UInt32[voiceUsageHistory.Count]; for (int i = 0; i < voiceUsageHistory.Count; ++i) { histArray[i] = voiceUsageHistory[i]; } return histArray; } } } public UInt32 num_used_streams { get; private set; } public Single total_bps { get; private set; } public UInt32 maxVoice_stdOnMemory { get; private set; } public UInt32 maxVoice_stdStreaming { get; private set; } public UInt32 maxVoice_hcamxOnMemory { get; private set; } public UInt32 maxVoice_hcamxStreaming { get; private set; } public Single loudness_momentary { get; private set; } public Single loudness_shortTerm { get; private set; } public Single loudness_integrated { get; private set; } public int numChMasterOut { get; private set; } private List levels = new List(); /* Channel => Levels */ public LevelInfo[] LevelsAllCh { get { if(levels.Count > 0) { LevelInfo[] levelsCopy; lock (levels) { levelsCopy = new LevelInfo[levels.Count]; levels.CopyTo(levelsCopy); } return levelsCopy; } else { return null; } } } public String cuename_lastPlayed { get; private set; } public String cuesheetName_lastPlayed { get; private set; } private Hashtable playbackHashtable = new Hashtable(); /* Playback ID => Playback Info */ public PlaybackInfo[] PlaybackList { get { lock (playbackHashtable) { PlaybackInfo[] playbackList = new PlaybackInfo[playbackHashtable.Count]; playbackHashtable.Values.CopyTo(playbackList, 0); return playbackList.OrderBy(x => x.timestamp).ToArray(); } } } private Dictionary multiLaneTimeline = new Dictionary(); private Hashtable voicePoolInfoTable = new Hashtable(); /* VoicePool Handle => VoicePool Info */ public enum VoicePoolFormat { Standard, HcaMx } public int GetVoicePoolUsage(VoicePoolFormat format) { int usage = 0; bool haveData = false; UInt32 formatBits = FORMAT_NONE; switch (format) { case VoicePoolFormat.Standard: formatBits = FORMAT_ADX | FORMAT_HCA; break; case VoicePoolFormat.HcaMx: formatBits = FORMAT_HCA_MX; break; default: break; } lock (voicePoolInfoTable) { foreach(VoicePoolInfo elem in voicePoolInfoTable.Values) { if (elem.soundFormat == formatBits && elem.numUsedVoices >= 0) { usage += (int)elem.numUsedVoices; haveData = true; } } } if(haveData) { return usage; } else { return -1; } } public List GetLogList() { return eventLogList; } public List GetLogList(int offset, int count) { try { offset = Mathf.Clamp(offset, 0, eventLogList.Count - 1); count = Mathf.Clamp(count, 0, eventLogList.Count - offset); return eventLogList.GetRange(offset, count); } catch { return new List(); } } public void ClearLog() { eventLogList.Clear(); } #endregion Fields / Properties #region Data Initialization private void ResetVals() { this.InitVals(); } private void InitVals() { this.timestamp = 0; this.timestampStart = 0; this.cpu_load = 0; this.cpuLoadHistory.FillWithZeros(); this.num_used_voices = 0; this.voiceUsageHistory.FillWithZeros(); this.num_used_streams = 0; this.total_bps = 0.0f; this.maxVoice_stdOnMemory = 0; this.maxVoice_stdStreaming = 0; this.maxVoice_hcamxOnMemory = 0; this.maxVoice_hcamxStreaming = 0; this.loudness_momentary = Mathf.NegativeInfinity; this.loudness_shortTerm = Mathf.NegativeInfinity; this.loudness_integrated = Mathf.NegativeInfinity; this.cuename_lastPlayed = ""; this.numChMasterOut = 0; this.voicePoolInfoTable.Clear(); this.playbackHashtable.Clear(); this.multiLaneTimeline.Clear(); this.levels.Clear(); this.eventLogList.Clear(); } #endregion #region Profiler Control /* connection settings */ private const int TCP_PORT = 2002; private const int TCP_CHUNK = 2048; private const int TCP_CONNECT_TIMEOUT_MS = 500; private const int TCP_RETRY_INTERVAL_MS = 2000; private const int TCP_RETRY = 5; private const int BUFFERING_INTERVAL_MS = 10; public const string LOG_FILE_EXTENSION = "crimon"; public string ipAddressString = "127.0.0.1"; public string LogFileSavePath { get; private set; } // Starting the TCP sub thread. public void StartProfiling(bool saveLog, string logDirPath = null) { IPAddress validIp; if(IPAddress.TryParse(ipAddressString, out validIp) == false) { UnityEngine.Debug.LogWarning("[CRIWARE] (Profiler) IP address not valid - connection aborted. "); return; } this.doSaveLog = saveLog; if (this.doSaveLog) { if (string.IsNullOrEmpty(logDirPath)) { /* default log file path */ logDirPath = Path.Combine(Directory.GetParent(Application.dataPath).ToString(), "CriWareProfilerLog"); } this.LogFileSavePath = logDirPath; if (Directory.Exists(LogFileSavePath) == false) { try { Directory.CreateDirectory(LogFileSavePath); } catch (Exception e) { UnityEngine.Debug.LogError("[CRIWARE] Profiler: failed to create directory for log files. Msg: " + e.Message); } } var filePath = Path.Combine(LogFileSavePath, "CriProfilerLog-" + DateTime.Now.ToString("yyyy-MM-dd-HHmmss") + "." + LOG_FILE_EXTENSION); try { this.logStream = new FileStream(filePath, FileMode.Create, FileAccess.Write); } catch (Exception e) { UnityEngine.Debug.LogError("[CRIWARE] Profiler: failed to create log file. Msg: " + e.Message); this.logStream = null; this.doSaveLog = false; } } TcpParams tcpParams = new TcpParams( validIp, TCP_PORT, TCP_CHUNK, TCP_CONNECT_TIMEOUT_MS, TCP_RETRY_INTERVAL_MS, TCP_RETRY, BUFFERING_INTERVAL_MS); const int READ_INTERVAL_MS = 0; if ((threadTcpClient == null || threadTcpClient.IsAlive == false) && (threadPacketReading == null || threadPacketReading.IsAlive == false) ) { InitVals(); threadTerminator.Reset(); threadTcpClient = new Thread(() => TaskTcpClient(tcpParams)); threadPacketReading = new Thread(() => TaskPacketReading(READ_INTERVAL_MS)); threadTcpClient.Start(); threadPacketReading.Start(); } } // Stopping the TCP sub thread. public void StopProfiling() { threadTerminator.Set(); ResetVals(); if (this.logStream != null) { this.doSaveLog = false; try { this.logStream.Flush(); this.logStream.Close(); this.logStream = null; } catch (Exception e) { UnityEngine.Debug.LogError("[CRIWARE] Profiler: failed to flush log file. Msg: " + e.Message); } } } private CriProfiler() { /* hide constructor for singleton */ InitVals(); } ~CriProfiler() { this.StopProfiling(); } #endregion #region TCP Connection Management // TCP connection sub thread task. private void TaskTcpClient(TcpParams tcpParams) { int failedConnectCnt = 0; this.isProfiling = true; using (var tcpClient = new TcpClient()) { while (true) { try { tcpClient.Connect(tcpParams.ipAddress, tcpParams.port); this.isConnected = true; UnityEngine.Debug.Log("[CRIWARE] CRI Profiler connected."); BufferingLoop(tcpClient, tcpParams); } catch { failedConnectCnt += 1; if(failedConnectCnt > tcpParams.connectionRetryLimit) { UnityEngine.Debug.LogWarning("[CRIWARE] Retry count exceeded limit(" + tcpParams.connectionRetryLimit + "); Stopped."); threadTerminator.Set(); } else { UnityEngine.Debug.LogWarning("[CRIWARE] Unable to connect CRI profiler. (Check if \"Uses In Game Preview\" is turned on)" +"\nWaiting for " + (tcpParams.connectionRetryIntervalMillisec / 1000.0f).ToString("F1") + " seconds to reconnect... (" + failedConnectCnt+ "/" + tcpParams.connectionRetryLimit + " tries)"); } } this.isConnected = false; if (threadTerminator.WaitOne(tcpParams.connectionRetryIntervalMillisec)) { UnityEngine.Debug.Log("[CRIWARE] CRI Profiler disconnected."); this.isProfiling = false; break; } } } } // Looping process to push the socket input to the buffer. private void BufferingLoop(TcpClient tcpClient, TcpParams tcpParams) { int numBytesRead = 0; byte[] chunk = new byte[tcpParams.chunkSize]; byte[] sendPacket; bool enbufferRes = true; this.TcpBuffer.Clear(); using (var netStream = tcpClient.GetStream()) { if (netStream == null) { UnityEngine.Debug.LogError("[CRIWARE] (Profiler) TCP connection not available."); return; } if (netStream.CanRead == false) { UnityEngine.Debug.LogError("[CRIWARE] (Profiler) TCP connection not readable."); return; } sendPacket = MakeLogPacket4StartStopLog(SendPacketType.StartLog); if (sendPacket != null && netStream.CanWrite) { netStream.Write(sendPacket, 0, sendPacket.Length); } while (true) { try { if (netStream.DataAvailable) { numBytesRead = netStream.Read(chunk, 0, chunk.Length); if (this.isBufferCorrupted == false) { lock (this.TcpBuffer) { enbufferRes = this.TcpBuffer.EnBuffer(chunk, numBytesRead); } } if (enbufferRes == false) { UnityEngine.Debug.LogWarning("[CRIWARE] TCP reading buffer overflowed."); // -- buffer corrupted -> prepare to reset -- // Enbuffer failure may cause incomplete packets in the packet queue. // The solution we take is skipping all incoming data until a "tail" chunk (followed by no data) arrives, // right after which the buffer will be reset. this.isBufferCorrupted = true; } } else { if (this.isBufferCorrupted == true) { lock (this.TcpBuffer) { /* reset the corrupted buffer when all available data are received */ this.TcpBuffer.Clear(); } this.isBufferCorrupted = false; } } } catch (System.IO.IOException) { threadTerminator.Set(); } if (threadTerminator.WaitOne(tcpParams.enBufferIntervalMillisec)) { break; } } sendPacket = MakeLogPacket4StartStopLog(SendPacketType.StopLog); if (sendPacket != null && netStream.CanWrite) { netStream.Write(sendPacket, 0, sendPacket.Length); } } } // Sending control packet to start / stop receiving log data private enum SendPacketType { StartLog, StopLog } private byte[] MakeLogPacket4StartStopLog(SendPacketType sendType) { int ptr_size = IntPtr.Size; const LogTypes log_type = LogTypes.NON; const UInt64 time = 0; const LogFuncId function_id = LogFuncId.LOG_COMMAND_Non; const UInt32 control_id = 0; const UInt64 thread_id = 0; int size; TcpCommandId command; int padding_size; switch (sendType) { case SendPacketType.StartLog: size = TcpLogHeader.properSize /* + sizeof(UInt16) * + CriProfiler.LogParams[(int)LogParamItems.LOG_STRINGS_ITEM_LogRecordMode].size32/64; */ + 6; command = TcpCommandId.CRITCP_MAIL_START_LOG_RECORD; padding_size = 2; /* 8 - (38 mod 8) */ size += padding_size; break; case SendPacketType.StopLog: size = TcpLogHeader.properSize; command = TcpCommandId.CRITCP_MAIL_STOP_LOG_RECORD; padding_size = 0; /* 8 - (32 mod 8) */ size += padding_size; break; default: return null; } byte[] packetBytes = new byte[size]; int offset = 0; SaveBigEndianUInt32(packetBytes, offset, (UInt32)size); offset += sizeof(UInt32); SaveBigEndianUInt16(packetBytes, offset, (UInt16)command); offset += sizeof(UInt16); SaveBigEndianByte(packetBytes, offset, (Byte)ptr_size); offset += sizeof(Byte); SaveBigEndianByte(packetBytes, offset, (Byte)log_type); offset += sizeof(Byte); SaveBigEndianUInt64(packetBytes, offset, (UInt64)time); offset += sizeof(UInt64); SaveBigEndianUInt16(packetBytes, offset, (UInt16)(function_id + CriProfiler.logFuncBaseNum)); offset += sizeof(UInt16); SaveBigEndianUInt16(packetBytes, offset, (UInt16)padding_size); offset += sizeof(UInt16); SaveBigEndianUInt32(packetBytes, offset, (UInt32)control_id); offset += sizeof(UInt32); SaveBigEndianUInt64(packetBytes, offset, (UInt64)thread_id); offset += sizeof(UInt64); switch (sendType) { case SendPacketType.StartLog: SaveBigEndianUInt16(packetBytes, offset, (UInt16)LogParamId.LOG_STRINGS_ITEM_LogRecordMode); offset += sizeof(UInt16); SaveBigEndianUInt32(packetBytes, offset, (UInt32)LOG_MODE_ALL); /* size of LOG_STRINGS_ITEM_LogRecordMode */ offset += sizeof(UInt32); break; case SendPacketType.StopLog: break; default: return null; } for (int i = 0; i < padding_size; ++i) { packetBytes[offset] = 0; offset += 1; } if (offset == size) { return packetBytes; } else { return null; } } #endregion #region Parser // Sub thread task to extract TCP packets from the buffer. private void TaskPacketReading(int readIntervalMillisec) { Stopwatch stopwatch = new Stopwatch(); const int threadMaxLifeMs = 20000; /* should be longer than total TCP retrying time */ const int threadRetryLifeMs = 500; byte[] data = null; TcpLogHeader packetHeader; int packetSize = 0; stopwatch.Start(); while (true) { if (this.isBufferCorrupted == false) { lock (this.TcpBuffer) { packetSize = GetPacketSize(TcpBuffer); data = this.TcpBuffer.DeBuffer(packetSize); } if (data != null) { stopwatch.Reset(); stopwatch.Start(); packetHeader = new TcpLogHeader(data); try { if (packetHeader.size > 0) { if (this.doSaveLog && this.logStream != null) { try { this.logStream.Write(data, 0, data.Length); } catch (Exception e) { UnityEngine.Debug.LogError("[CRIWARE] Profiler: failed to write logs. Msg: " + e.Message); this.doSaveLog = false; } } this.Parser(data, packetHeader); } /* if headerSize > 0 */ } catch (Exception ex) { /* Any parsing error */ if(ex is ParamIdDoesNotMatchException) { UnityEngine.Debug.LogWarning("[CRIWARE] " + ex.Message.ToString()); } UnityEngine.Debug.LogWarning("[CRIWARE] (Profiler) Packet parsing failed: buffer may be corrupted. Reconstructing buffer..." +"\nLog Function: " + GetLogFuncId(packetHeader.function_id).ToString()); this.isBufferCorrupted = true; } } else { /* kill all threads if waited for too long */ if (this.isConnected == true) { if (stopwatch.ElapsedMilliseconds > threadRetryLifeMs) { this.isProfiling = false; threadTerminator.Set(); } } else { if (stopwatch.ElapsedMilliseconds > threadMaxLifeMs) { this.isProfiling = false; threadTerminator.Set(); } } } /* if data != null */ } /* if isBufferCorrupted == false */ if (threadTerminator.WaitOne(readIntervalMillisec)) { this.isProfiling = false; break; } } } // Get the size of the packet from the header. // Return 0 if there is no enough data to determine the size. private int GetPacketSize(RingBuffer buffer) { if (buffer == null || buffer.Count < DATA_LENGTH_PARAM_SIZE) { return 0; } uint result = buffer[0]; for (int i = 1; i < DATA_LENGTH_PARAM_SIZE; ++i) { result <<= 8; result += buffer[i]; } return (int)result; } private int GetPacketSize(byte[] data, uint offset = 0) { if (data == null || data.Length - offset < DATA_LENGTH_PARAM_SIZE) { return 0; } uint result = data[offset]; for (int i = 0; i < DATA_LENGTH_PARAM_SIZE; i++) { result <<= 8; result += data[i + offset]; } return (int)result; } public void LoadLogFromFile(string path) { if (string.IsNullOrEmpty(path)) { UnityEngine.Debug.LogError("[CRIWARE] Profiler: Log file path cannot be empty"); } try { using (var fileStream = new FileStream(path, FileMode.Open, FileAccess.Read)) { if (fileStream.CanRead) { eventLogList.Clear(); byte[] reusedSizeData = new byte[DATA_LENGTH_PARAM_SIZE]; while (fileStream.Position + DATA_LENGTH_PARAM_SIZE < fileStream.Length) { var read = fileStream.Read(reusedSizeData, 0, DATA_LENGTH_PARAM_SIZE); /* roll back read position */ fileStream.Position -= read; /* get actual data size */ var dataSize = GetPacketSize(reusedSizeData); if (dataSize > 0) { byte[] data = new byte[dataSize]; fileStream.Read(data, 0, dataSize); this.LogParser(data); } else { UnityEngine.Debug.LogError("[CRIWARE] Profiler: Error while reading log"); break; } } } else { UnityEngine.Debug.LogError("[CRIWARE] Profiler: Log file cannot be read"); } } } catch (Exception e) { UnityEngine.Debug.LogError("[CRIWARE] Profiler: Error while opening log: " + e.Message); } } private void LogParser(byte[] data) { var header = new TcpLogHeader(data); switch ((TcpCommandId)header.command) { case TcpCommandId.CRITCP_MAIL_SEND_LOG: switch (GetLogFuncId(header.function_id)) { case LogFuncId.LOG_COMMAND_ExPlaybackId: this.AddEventLog(data); break; default: break; } break; case TcpCommandId.CRITCP_MAIL_MONITOR_ATOM_EXPLAYBACKINFO_PLAY_END: switch (GetLogFuncId(header.function_id)) { case LogFuncId.LOG_COMMAND_ExPlaybackInfo_FreeInfo: this.AddEventLog(data); break; default: break; } break; default: break; } } private void Parser(byte[] data, TcpLogHeader header) { int offset = 0; int offset2 = 0; int dataSize = 0; int dataSize2 = 0; UInt32 playbackId; StreamTypes streamType; VoicePoolInfo voicePoolInfo; UInt64 voicePoolHn; Single levelPeak; Single levelRms; Single levelPeakHold; int numCh = 0; int numOutputCh; int numMaxCh = 0; switch ((TcpCommandId)header.command) { case TcpCommandId.CRITCP_MAIL_PREVIEW_CPU_LOAD: this.timestamp = header.time; if (this.timestampStart == 0) { this.timestampStart = this.timestamp; } if (GetLogFuncId(header.function_id) == LogFuncId.LOG_COMMAND_CpuLoadAndNumUsedVoices) { this.cpu_load = LoadBigEndianSingle(data, FindParamOffset(data, header, LogParamId.LOG_STRINGS_ITEM_CpuLoad, out offset)); this.num_used_voices = LoadBigEndianUInt32(data, GetNextParamOffset(data, header, LogParamId.LOG_STRINGS_ITEM_NumUsedVoices, ref offset)); lock (cpuLoadHistory) { cpuLoadHistory.EnBuffer(new Single[] { cpu_load }, 1); } lock (voiceUsageHistory) { voiceUsageHistory.EnBuffer(new UInt32[] { num_used_voices }, 1); } } break; case TcpCommandId.CRITCP_MAIL_SEND_LOG: this.timestamp = header.time; if (this.timestampStart == 0) { this.timestampStart = this.timestamp; } switch (GetLogFuncId(header.function_id)) { case LogFuncId.LOG_COMMAND_LoudnessInfo: this.loudness_momentary = LoadBigEndianSingle(data, FindParamOffset(data, header, LogParamId.LOG_STRINGS_ITEM_MomentaryValue, out offset)); this.loudness_shortTerm = LoadBigEndianSingle(data, GetNextParamOffset(data, header, LogParamId.LOG_STRINGS_ITEM_ShortTermValue, ref offset)); this.loudness_integrated = LoadBigEndianSingle(data, GetNextParamOffset(data, header, LogParamId.LOG_STRINGS_ITEM_IntegratedValue, ref offset)); break; case LogFuncId.LOG_COMMAND_StreamingInfo: this.num_used_streams = LoadBigEndianUInt32(data, FindParamOffset(data, header, LogParamId.LOG_STRINGS_ITEM_NumUsedVoices, out offset)); this.total_bps = LoadBigEndianSingle(data, GetNextParamOffset(data, header, LogParamId.LOG_STRINGS_ITEM_TotalBps, ref offset)); break; case LogFuncId.LOG_COMMAND_AsrBusAnalyzeInfoAllCh: if (LoadBigEndianByte(data, FindParamOffset(data, header, LogParamId.LOG_STRINGS_ITEM_BusNo, out offset)) == 0) { /* if the bus is MasterOut(bus0) */ numCh = LoadBigEndianByte(data, FindParamOffset(data, header, LogParamId.LOG_STRINGS_ITEM_NumCh, out offset)); lock (levels) { if (numMaxCh == 0) { numMaxCh = numCh; levels.Clear(); for (int i = 0; i < numMaxCh; ++i) { levels.Add(new LevelInfo(Mathf.NegativeInfinity, Mathf.NegativeInfinity, Mathf.NegativeInfinity)); } } if (numMaxCh == numCh) { for (int i = 0; i < numCh; ++i) { levelPeak = LoadBigEndianSingle(data, GetNextParamOffset(data, header, LogParamId.LOG_STRINGS_ITEM_PeakLevel, ref offset)); levelRms = LoadBigEndianSingle(data, GetNextParamOffset(data, header, LogParamId.LOG_STRINGS_ITEM_RmsLevel, ref offset)); levelPeakHold = LoadBigEndianSingle(data, GetNextParamOffset(data, header, LogParamId.LOG_STRINGS_ITEM_PeakHoldLevel, ref offset)); levels[i] = new LevelInfo(levelPeak, levelRms, levelPeakHold); } } } } break; case LogFuncId.LOG_COMMAND_ExStandardVoicePoolConfig: if (Convert.ToBoolean(LoadBigEndianByte(data, FindParamOffset(data, header, LogParamId.LOG_STRINGS_ITEM_StreamingFlag, out offset))) == false) { this.maxVoice_stdOnMemory = LoadBigEndianUInt32(data, FindParamOffset(data, header, LogParamId.LOG_STRINGS_ITEM_NumVoices, out offset)); } else { this.maxVoice_stdStreaming = LoadBigEndianUInt32(data, FindParamOffset(data, header, LogParamId.LOG_STRINGS_ITEM_NumVoices, out offset)); } break; case LogFuncId.LOG_COMMAND_ExHcaMxVoicePoolConfig: if (Convert.ToBoolean(LoadBigEndianByte(data, FindParamOffset(data, header, LogParamId.LOG_STRINGS_ITEM_StreamingFlag, out offset))) == false) { this.maxVoice_hcamxOnMemory = LoadBigEndianUInt32(data, FindParamOffset(data, header, LogParamId.LOG_STRINGS_ITEM_NumVoices, out offset)); } else { this.maxVoice_hcamxStreaming = LoadBigEndianUInt32(data, FindParamOffset(data, header, LogParamId.LOG_STRINGS_ITEM_NumVoices, out offset)); } break; case LogFuncId.LOG_COMMAND_ExVoicePoolHn: try { voicePoolHn = LoadBigEndianUInt64(data, FindParamOffset(data, header, LogParamId.LOG_STRINGS_ITEM_ExVoicePoolHn, out offset)); voicePoolInfo = new VoicePoolInfo(LoadBigEndianUInt32(data, GetNextParamOffset(data, header, LogParamId.LOG_STRINGS_ITEM_SoundFormat, ref offset)), null); lock (voicePoolInfoTable) { voicePoolInfoTable.Add(voicePoolHn, voicePoolInfo); } } catch (ArgumentException) { /* Voice pool info already exists; Do nothing */ } break; case LogFuncId.LOG_COMMAND_ExVoicePool_Free: voicePoolHn = LoadBigEndianUInt64(data, FindParamOffset(data, header, LogParamId.LOG_STRINGS_ITEM_ExVoicePoolHn, out offset)); lock (voicePoolInfoTable) { voicePoolInfoTable.Remove(voicePoolHn); } break; case LogFuncId.LOG_COMMAND_PlayerPool_NumVoices: voicePoolHn = LoadBigEndianUInt64(data, FindParamOffset(data, header, LogParamId.LOG_STRINGS_ITEM_ExVoicePoolHn, out offset)); lock (voicePoolInfoTable) { if (voicePoolInfoTable[voicePoolHn] != null) { (voicePoolInfoTable[voicePoolHn] as VoicePoolInfo).numUsedVoices = (int)LoadBigEndianUInt32(data, GetNextParamOffset(data, header, LogParamId.LOG_STRINGS_ITEM_NumUsedVoices, ref offset)); } } break; case LogFuncId.LOG_COMMAND_ExPlaybackId: playbackId = LoadBigEndianUInt32(data, FindParamOffset(data, header, LogParamId.LOG_STRINGS_ITEM_ExPlaybackId, out offset)); dataSize = LoadBigEndianUInt16(data, FindParamOffset(data, header, LogParamId.LOG_STRINGS_ITEM_CueName, out offset)); /* cue name */ dataSize2 = LoadBigEndianUInt16(data, FindParamOffset(data, header, LogParamId.LOG_STRINGS_ITEM_ExAcbName, out offset2)); /* cuesheet name */ if (dataSize > 1 && dataSize2 > 1) { this.cuename_lastPlayed = System.Text.Encoding.Default.GetString(data, GetStrDataOffset(header, offset), dataSize); this.cuesheetName_lastPlayed = System.Text.Encoding.Default.GetString(data, GetStrDataOffset(header, offset2), dataSize2); try { lock (playbackHashtable) { this.playbackHashtable.Add(playbackId, new PlaybackInfo(playbackId, cuename_lastPlayed, cuesheetName_lastPlayed, header.time)); } } catch (ArgumentException) { /* Duplicated playback info received; Do nothing */ } this.AddEventLog(data); this.AddPlaybackToTimeline(new Playback(playbackId, header.time, true, cuename_lastPlayed, cuesheetName_lastPlayed)); } else { this.cuename_lastPlayed = ""; } break; case LogFuncId.LOG_COMMAND_SoundVoice_Allocate: playbackId = LoadBigEndianUInt32(data, FindParamOffset(data, header, LogParamId.LOG_STRINGS_ITEM_ExPlaybackId, out offset)); streamType = (StreamTypes)LoadBigEndianByte(data, FindParamOffset(data, header, LogParamId.LOG_STRINGS_ITEM_StreamType, out offset)); lock (playbackHashtable) { if (playbackHashtable.ContainsKey(playbackId)) { (playbackHashtable[playbackId] as PlaybackInfo).StreamType = (int)streamType; } } break; case LogFuncId.LOG_COMMAND_ExAsrConfig: numOutputCh = LoadBigEndianByte(data, FindParamOffset(data, header, LogParamId.LOG_STRINGS_ITEM_OutputChannels, out offset)); if (numOutputCh > this.numChMasterOut) { numChMasterOut = numOutputCh; } break; default: break; } break; case TcpCommandId.CRITCP_MAIL_MONITOR_ATOM_EXPLAYBACKINFO_PLAY_END: this.timestamp = header.time; if (this.timestampStart == 0) { this.timestampStart = this.timestamp; } switch (GetLogFuncId(header.function_id)) { case LogFuncId.LOG_COMMAND_ExPlaybackInfo_FreeInfo: playbackId = LoadBigEndianUInt32(data, FindParamOffset(data, header, LogParamId.LOG_STRINGS_ITEM_ExPlaybackId, out offset)); lock (playbackHashtable) { if (playbackHashtable.ContainsKey(playbackId)) { var info = playbackHashtable[playbackId] as PlaybackInfo; this.AddEventLog(data); this.AddPlaybackToTimeline(new Playback(playbackId, header.time, false, info.cueName, info.cueSheetName)); playbackHashtable.Remove(playbackId); } } break; default: break; } break; default: UserDefinedParser(data, header); break; } } // Override this method to add new parsing procedure protected virtual void UserDefinedParser(byte[] data, TcpLogHeader packetHeader) { // e.g. //int offset; //switch ((TcpCommandId)packetHeader.command) { // case TcpCommandId.: // switch (GetLogFuncId(packetHeader.function_id)) { // case LogFuncId.: // // break; // default: // break; // } // break; // default: // break; //} } private void AddEventLog(byte[] data) { this.eventLogList.Add(data); } static private LogFuncId GetLogFuncId(UInt16 rawId) { return (LogFuncId)(rawId - CriProfiler.logFuncBaseNum); } public string FilteredLog2String(byte[] data) { if (data == null || data.Length < TcpLogHeader.properSize) { return string.Empty; } var header = new TcpLogHeader(data); var funcId = GetLogFuncId(header.function_id); uint playbackId; int dataSize, dataSize2, offset, offset2; string str1, str2; string output = string.Empty; switch (funcId) { case LogFuncId.LOG_COMMAND_ExPlaybackId: playbackId = LoadBigEndianUInt32(data, FindParamOffset(data, header, LogParamId.LOG_STRINGS_ITEM_ExPlaybackId, out offset)); dataSize = LoadBigEndianUInt16(data, FindParamOffset(data, header, LogParamId.LOG_STRINGS_ITEM_CueName, out offset)); /* cue name */ dataSize2 = LoadBigEndianUInt16(data, FindParamOffset(data, header, LogParamId.LOG_STRINGS_ITEM_ExAcbName, out offset2)); /* cuesheet name */ str1 = System.Text.Encoding.Default.GetString(data, GetStrDataOffset(header, offset), dataSize); str2 = System.Text.Encoding.Default.GetString(data, GetStrDataOffset(header, offset2), dataSize2); output = MicroSec2String(header.time) + " | Start ID : " + playbackId + " | cuename : " + str1 + " | cuesheet : " + str2; break; case LogFuncId.LOG_COMMAND_ExPlaybackInfo_FreeInfo: playbackId = LoadBigEndianUInt32(data, FindParamOffset(data, header, LogParamId.LOG_STRINGS_ITEM_ExPlaybackId, out offset)); output = MicroSec2String(header.time) + " | End ID : " + playbackId; break; default: break; } return output; } static private string MicroSec2String(ulong microSec) { ulong hour = microSec / 3600000000; ulong min = (microSec % 3600000000) / 60000000; ulong sec = (microSec % 60000000) / 1000000; ulong msec = (microSec % 1000000) / 1000; return string.Format("{0}:{1}:{2}.{3}", hour, min, sec, msec); } #region Methods for data offset calculation private const int paramIdSize = 2; private int GetStrDataOffset(TcpLogHeader header, int paramIdOffset) { return paramIdOffset + CriProfiler.paramIdSize + (header.isPtr64 ? ParamTypeSizes64[(int)CriProfiler.LogParamTypes.TYPE_CHAR] : ParamTypeSizes32[(int)CriProfiler.LogParamTypes.TYPE_CHAR]); } private int FindParamOffset(byte[] data, TcpLogHeader header, LogParamId logParamId, out int currentOffset) { if (data.Length < TcpLogHeader.properSize) { throw new ParamIdDoesNotMatchException("Could not find parameter: " + logParamId.ToString()); } int offset = header.size; int paramId; int dataSize; while (offset < header.packetSize) { paramId = LoadBigEndianUInt16(data, offset); if ((LogParamId)paramId == logParamId) { currentOffset = offset; return offset + paramIdSize; } dataSize = header.isPtr64 ? LogParams[paramId].size64 : LogParams[paramId].size32; if (LogParams[paramId].type == LogParamTypes.TYPE_CHAR) { dataSize += LoadBigEndianUInt16(data, offset + paramIdSize); } offset += paramIdSize + dataSize; } throw new ParamIdDoesNotMatchException("Could not find parameter: " + logParamId.ToString()); } private int GetNextParamOffset(byte[] data, TcpLogHeader header, LogParamId logParamId, ref int currentOffset) { if (currentOffset >= header.packetSize) { throw new ParamIdDoesNotMatchException("Could not find parameter: " + logParamId.ToString()); } int paramId = LoadBigEndianUInt16(data, currentOffset); int dataSize = header.isPtr64 ? CriProfiler.LogParams[paramId].size64 : CriProfiler.LogParams[paramId].size32; if (CriProfiler.LogParams[paramId].type == LogParamTypes.TYPE_CHAR) { dataSize += LoadBigEndianUInt16(data, currentOffset + paramIdSize); } /* set parameter id offset */ currentOffset += paramIdSize + dataSize; if ((LogParamId)LoadBigEndianUInt16(data, currentOffset) != logParamId) { throw new ParamIdDoesNotMatchException("Parsed parameter ID does not match with " + logParamId.ToString()); } /* return parameter data offset */ return currentOffset + paramIdSize; } #endregion Methods for data offset calculation #endregion Parser #region Timeline /* CueSheet - Cue - Playback Lane (multiple non-overlapping playback lists) - Timestamp (true = start, false = end) */ private void AddPlaybackToTimeline(Playback playback) { CueSheetGroup group; if (multiLaneTimeline.TryGetValue(playback.cuesheet, out group) == false) { group = new CueSheetGroup(playback.cuesheet); multiLaneTimeline.Add(playback.cuesheet, group); } group.AddPlayback(playback); } public Dictionary TimelineDataSlice { get { var output = new Dictionary(); foreach (var elem in multiLaneTimeline) { output.Add(elem.Key, elem.Value.Clone()); } return output; } } public class CueSheetGroup : ICloneable { public string name; public Color cuesheetColor = Color.white; public Dictionary cueLaneDict; static private readonly Color baseColor = new Color(0.5412f, 1f, 0.3451f); public CueSheetGroup(string name) { this.name = name; {/* set distinguishing color */ float h, s, v; Color.RGBToHSV(baseColor, out h, out s, out v); System.Random rand = new System.Random(); this.cuesheetColor = Color.HSVToRGB(rand.Next(0, 10000) / 10000f, s, v); } cueLaneDict = new Dictionary(); } public CueSheetGroup(CueSheetGroup group) { this.name = group.name; this.cuesheetColor = group.cuesheetColor; this.cueLaneDict = new Dictionary(); foreach (var elem in group.cueLaneDict) { cueLaneDict.Add(elem.Key, elem.Value.Clone()); } } public CueSheetGroup Clone() { return new CueSheetGroup(this); } object ICloneable.Clone() { return Clone(); } public void AddPlayback(Playback playback) { CueLane lane; if (cueLaneDict.TryGetValue(playback.cuename, out lane) == false) { lane = new CueLane(playback.cuename, playback.cuesheet); cueLaneDict.Add(playback.cuename, lane); } lane.AddPlayback(playback); } public int TotalLaneCount { get { int cnt = 0; foreach (var elem in cueLaneDict) { cnt += elem.Value.playbackLaneList.Count; } return cnt; } } } public class CueLane : ICloneable { public string name; public string cuesheet; public Color cueColor; public List playbackLaneList; static private readonly Color baseColor = new Color(0.537f, 0.922f, 0.424f); private Dictionary playingDict; /* ; wont be cloned */ public CueLane(string name, string cuesheet) { this.name = name; this.cuesheet = cuesheet; {/* set distinguishing color */ float h, s, v; Color.RGBToHSV(baseColor, out h, out s, out v); System.Random rand = new System.Random(); this.cueColor = Color.HSVToRGB(rand.Next(0, 10000) / 10000f, s, v); } playbackLaneList = new List(); playingDict = new Dictionary(); } public CueLane(CueLane cuelane) { this.name = cuelane.name; this.cuesheet = cuelane.cuesheet; this.cueColor = cuelane.cueColor; this.playbackLaneList = new List(); this.playbackLaneList.AddRange(cuelane.playbackLaneList.Select(i => i.Clone())); } public CueLane Clone() { return new CueLane(this); } object ICloneable.Clone() { return Clone(); } public void AddPlayback(Playback playback) { if (playback.isStart) { /* playback start */ bool added = false; for (int i = 0; i < playbackLaneList.Count; ++i) { if (playbackLaneList[i].isPlaying == false) { if (playbackLaneList[i].AddPlayback(playback)) { playingDict.Add(playback.id, i); added = true; break; } } } if (added == false) { /* no empty lane */ playbackLaneList.Add(new PlaybackLane()); if (playbackLaneList[playbackLaneList.Count - 1].AddPlayback(playback)) { playingDict.Add(playback.id, playbackLaneList.Count - 1); } } } else { /* playback end */ int laneId; if (playingDict.TryGetValue(playback.id, out laneId)) { playbackLaneList[laneId].AddPlayback(playback); playingDict.Remove(playback.id); } } } } public class PlaybackLane : ICloneable { public List playbackList; private int balance; public bool isConsistent { get { if (balance > 1 || balance < 0) { return false; } return true; } } public PlaybackLane() { playbackList = new List(); balance = 0; } public PlaybackLane(PlaybackLane playbackLane) { this.playbackList = new List(playbackLane.playbackList); this.balance = playbackLane.balance; } public PlaybackLane Clone() { return new PlaybackLane(this); } object ICloneable.Clone() { return Clone(); } public bool AddPlayback(Playback playback) { if (playbackList.Count > 0 && (playbackList[playbackList.Count - 1].timestamp > playback.timestamp || playbackList[playbackList.Count - 1].isStart == playback.isStart)) { UnityEngine.Debug.LogError("[CRIWARE] Profiler internal: playback timestamp order error"); return false; } playbackList.Add(playback); balance += playback.isStart ? 1 : -1; return true; } public bool isPlaying { get { return playbackList[playbackList.Count - 1].isStart; } } } public struct Playback { public uint id; public ulong timestamp; public bool isStart; public string cuename; public string cuesheet; public Playback(uint id, ulong timestamp, bool isStart, string cuename, string cuesheet) { this.id = id; this.timestamp = timestamp; this.isStart = isStart; this.cuename = cuename; this.cuesheet = cuesheet; } } #endregion } } //namespace CriWare #endif