init

Common/DTS.Common.Serialization/.svn/pristine/1f/1fed5fa645c38d178f36efa289dd60b23f969f6b.svn-base

@@ -0,0 +1,120 @@
+using DTS.Serialization.IRIGCH10.Enums;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace DTS.Serialization.IRIGCH10
+{
+    /// <summary>
+    /// this packet just points to specific time data packets as part of an indexing system
+    /// </summary>
+    public class RecorderIndexPacket : AbstractDataPacket, IDataPacket
+    {
+        //not confident on breaking out the individual properties of this dataword yet
+        //(root index, file size, presence of data header, etc, so just use a 
+        //prefilled one for now ...
+        private readonly byte [] ChannelSpecificDataWord = new byte[] {0x8D, 0x02, 0x00, 0xE0};
+        private readonly byte [] RootPacketAddress = new byte [8];
+        public void SetRootPacketAddress(long address)
+        {
+            var bits = BitConverter.GetBytes(address);
+            Buffer.BlockCopy(bits, 0, RootPacketAddress, 0, bits.Length);
+        }
+
+        private List<RecordingIndex> _indices = new List<RecordingIndex>();
+
+        public DateTime GetDateTime()
+        {
+            return _indices.First().GetDateTime();
+        }
+        public int NumberOfEntries => _indices.Count;
+        public void AddRecordingIndex(RecordingIndex index)
+        {
+            _indices.Add(index);
+        }
+
+        public RecorderIndexPacket()
+            : base(DataFileDataTypes.ComputerGeneratedDataFormat3)
+        {
+            _CheckSum = new byte[4];
+        }
+        public override byte[] GetBytes()
+        {
+            //we just need to make sure data bytes is populated then we can let the base class do it's thing
+            _dataBytes = new byte[_indices.Count * RecordingIndex.SIZE + RootPacketAddress.Length +
+                                  ChannelSpecificDataWord.Length];
+            Buffer.BlockCopy(ChannelSpecificDataWord, 0, _dataBytes, 0, ChannelSpecificDataWord.Length);
+            Buffer.BlockCopy(RootPacketAddress, 0, _dataBytes, ChannelSpecificDataWord.Length, RootPacketAddress.Length);
+            var offset = ChannelSpecificDataWord.Length + RootPacketAddress.Length;
+            foreach (var index in _indices)
+            {
+                var bytes = index.GetBytes();
+                Buffer.BlockCopy(bytes, 0, _dataBytes, offset, bytes.Length);
+                offset += bytes.Length;
+            }
+            return base.GetBytes();
+        }
+    }
+    /// <summary>
+    /// here's a structure for the recording indicies in the recording index packet
+    /// </summary>
+    public class RecordingIndex
+    {
+        public const int SIZE = 8+8+2+1+1+8;
+        private byte [] RTC  = new byte [8];
+        private byte [] TimeDate = new byte[8];
+        private DateTime _dt;
+        private readonly ushort ChannelId = ushort.MaxValue;
+        private readonly byte DataType = 0x11;
+        private readonly byte Reserved = 0x00;
+        private byte[] DataPacketOffset = new byte[8];
+        
+        private void SetRTC(long rtc)
+        {
+            var bits = BitConverter.GetBytes(rtc);
+            Buffer.BlockCopy(bits, 0, RTC, 0, bits.Length);
+        }
+
+        private void SetDataPacketOffset(long offset)
+        {
+            var bits = BitConverter.GetBytes(offset);
+            Buffer.BlockCopy(bits, 0, DataPacketOffset, 0, bits.Length);
+        }
+        public DateTime GetDateTime(){ return _dt; }
+        private void SetDateTime(DateTime dt)
+        {
+            _dt = dt;
+            TimeDate[0] = Utils.Utils.GetBCDBytes(dt.Millisecond/10)[0];
+            TimeDate[1] = Utils.Utils.GetBCDBytes(dt.Second)[0];
+            TimeDate[2] = Utils.Utils.GetBCDBytes(dt.Minute)[0];
+            TimeDate[3] = Utils.Utils.GetBCDBytes(dt.Hour)[0];
+            TimeDate[4] = Utils.Utils.GetBCDBytes(dt.Day)[0];
+            TimeDate[5] = Utils.Utils.GetBCDBytes(dt.Month)[0];
+            TimeDate[6] = Utils.Utils.GetBCDBytes(dt.Year)[0];
+            TimeDate[7] = Utils.Utils.GetBCDBytes(dt.Year)[1];
+        }
+
+        public RecordingIndex(long rtc, long offset, DateTime dt)
+        {
+            SetDataPacketOffset(offset);
+            SetRTC(rtc);
+            SetDateTime(dt);
+        }
+        public byte[] GetBytes()
+        {
+            var data = new byte[8 + 8 + 2 + 1 + 1 + 8];
+            var curOffset = 0;
+            Buffer.BlockCopy(RTC, 0, data, 0, RTC.Length);
+            curOffset += RTC.Length;
+            Buffer.BlockCopy(TimeDate, 0, data, curOffset, TimeDate.Length);
+            curOffset += TimeDate.Length;
+            var bytes = BitConverter.GetBytes(ChannelId);
+            Buffer.BlockCopy(bytes, 0, data, curOffset, 2);
+            curOffset += 2;
+            data[curOffset++] = DataType;
+            data[curOffset++] = Reserved;
+            Buffer.BlockCopy(DataPacketOffset, 0, data, curOffset, DataPacketOffset.Length);
+            return data;
+        }
+    }
+}