/// <summary>
/// Serializes a data reference composed of raw bytes.
/// </summary>
/// <param name="tagStream">The stream to write completed blocks of tag data to.</param>
/// <param name="block">The temporary block to write incomplete tag data to.</param>
/// <param name="data">The data.</param>
/// <param name="valueInfo">Information about the value. Can be <c>null</c>.</param>
private static void SerializeDataReference(MemoryStream tagStream, IDataBlock block, byte[] data, TagFieldAttribute valueInfo)
{
var writer = block.Writer;
uint offset = 0;
uint size = 0;
if (data != null && data.Length > 0)
{
// Ensure the block is aligned correctly
var align = Math.Max(DefaultBlockAlign, (valueInfo != null) ? valueInfo.DataAlign : 0);
StreamUtil.Align(tagStream, (int)align);
// Write its data
offset = (uint)tagStream.Position;
size = (uint)data.Length;
tagStream.Write(data, 0, data.Length);
StreamUtil.Align(tagStream, DefaultBlockAlign);
}
// Write the reference data
writer.Write(size);
writer.Write(0);
writer.Write(0);
if (size > 0)
block.WritePointer(offset, typeof(byte[]));
else
writer.Write(0);
writer.Write(0);
}
public void Add(IDataBlock data)
{
if (saveData.ContainsKey(data.DataId)) {
// Override if exists
saveData[data.DataId] = new SaveFileEntry(data);
}
else {
// new one otherwise
saveData.Add(data.DataId, new SaveFileEntry(data));
}
}
/// <summary>
/// Creates an independent <see cref="DataBlockInfo"/> instance
/// base on another one.
/// </summary>
/// <param name="other">The object to copy.</param>
/// <returns>Independent <see cref="DataBlockInfo"/> whose
/// properties match the submitted instance.</returns>
/// <exception cref="ArgumentNullException">If <paramref name="other"/>
/// is a null reference.</exception>
public static DataBlockInfo FromDataBlock(IDataBlock other)
{
Ensure.ArgumentNotNull(other, "other");
return new DataBlockInfo
{
TransferTokenId = other.TransferTokenId,
BlockNumber = other.BlockNumber,
BlockLength = other.BlockLength,
Offset = other.Offset,
IsLastBlock = other.IsLastBlock
};
}
public static void SerializeMatrix(IDataBlock block, Matrix4x3 mat)
{
block.Writer.Write(mat.m11);
block.Writer.Write(mat.m12);
block.Writer.Write(mat.m13);
block.Writer.Write(mat.m21);
block.Writer.Write(mat.m22);
block.Writer.Write(mat.m23);
block.Writer.Write(mat.m31);
block.Writer.Write(mat.m32);
block.Writer.Write(mat.m33);
block.Writer.Write(mat.m41);
block.Writer.Write(mat.m42);
block.Writer.Write(mat.m43);
}
/// <summary>
/// Serializes a structure into a temporary memory block.
/// </summary>
/// <param name="context">The serialization context to use.</param>
/// <param name="tagStream">The stream to write completed blocks of tag data to.</param>
/// <param name="block">The temporary block to write incomplete tag data to.</param>
/// <param name="info">Information about the tag structure type.</param>
/// <param name="structure">The structure to serialize.</param>
/// <exception cref="System.InvalidOperationException">Structure type must have TagStructureAttribute</exception>
private void SerializeStruct(ISerializationContext context, MemoryStream tagStream, IDataBlock block, TagStructureInfo info, object structure)
{
var baseOffset = block.Stream.Position;
var enumerator = new TagFieldEnumerator(info);
while (enumerator.Next())
SerializeProperty(context, tagStream, block, structure, enumerator, baseOffset);
// Honor the struct size if it's defined
if (info.TotalSize > 0)
{
block.Stream.Position = baseOffset + info.TotalSize;
if (block.Stream.Position > block.Stream.Length)
block.Stream.SetLength(block.Stream.Position);
}
// Honor alignment
if (info.Structure.Align > 0)
block.SuggestAlignment(info.Structure.Align);
}
private void SerializeEulerAngles(IDataBlock block, RealEulerAngles2d angles)
{
block.Writer.Write(angles.Yaw.Radians);
block.Writer.Write(angles.Pitch.Radians);
}
private void listBox1_DoubleClick(object sender, EventArgs e)
{
if (lstListBox.SelectedItem == null)
return;
viewBlockList.Visible = false;
if (lstListBox.SelectedItem is ProjectBlockInfo)
{
viewBlockList.Visible = false;
lblStatus.Text = ((ProjectBlockInfo) lstListBox.SelectedItem).ToString();
Block tmp;
if (blkFld is BlocksOfflineFolder)
tmp = ((BlocksOfflineFolder) blkFld).GetBlock((ProjectBlockInfo) lstListBox.SelectedItem,
new S7ConvertingOptions(MnemonicLanguage.German)
{
GenerateCallsfromUCs = convertCallsToolStripMenuItem.Checked
});
else tmp = blkFld.GetBlock((ProjectBlockInfo) lstListBox.SelectedItem);
if (tmp != null)
{
if (tmp.BlockType == PLCBlockType.UDT || tmp.BlockType == PLCBlockType.DB ||
tmp.BlockType == PLCBlockType.S5_DV || tmp.BlockType == PLCBlockType.S5_DB)
{
//dataBlockViewControl.DataBlockRows = ((PLCDataBlock) tmp).Structure;
myBlk = (IDataBlock) tmp;
//expRow = myBlk.Structure;
//if (mnuExpandDatablockArrays.Checked)
// expRow = myBlk.GetArrayExpandedStructure(new S7DataBlockExpandOptions() { ExpandCharArrays = false });
dataBlockViewControl.ExpandDataBlockArrays = mnuExpandDatablockArrays.Checked;
dataBlockViewControl.DataBlock = myBlk;
datablockView.Visible = true;
}
else
{
txtTextBox.Text = tmp.ToString();
txtTextBox.Visible = true;
}
}
}
else if (lstListBox.SelectedItem.GetType() == typeof (S7ProjectSourceInfo))
{
var tmp = (S7ProjectSourceInfo) lstListBox.SelectedItem;
if (tmp != null)
{
string fnm = tmp.Filename;
if (fnm != null && fnm != "")
if (System.IO.File.Exists(fnm))
txtTextBox.Text = new System.IO.StreamReader(tmp.Filename).ReadToEnd();
}
txtTextBox.Visible = true;
//lstListBox.Visible = false;
}
}
/// <summary>
/// Serializes a value.
/// </summary>
/// <param name="context">The serialization context to use.</param>
/// <param name="tagStream">The stream to write completed blocks of tag data to.</param>
/// <param name="block">The temporary block to write incomplete tag data to.</param>
/// <param name="val">The value.</param>
/// <param name="valueInfo">Information about the value. Can be <c>null</c>.</param>
/// <param name="valueType">Type of the value.</param>
private void SerializeValue(ISerializationContext context, MemoryStream tagStream, IDataBlock block, object val, TagFieldAttribute valueInfo, Type valueType)
{
// Call the data block's PreSerialize callback to determine if the value should be mutated
val = block.PreSerialize(valueInfo, val);
if (val != null)
valueType = val.GetType(); // TODO: Fix hax
if (valueType.IsPrimitive)
SerializePrimitiveValue(block.Writer, val, valueType);
else
SerializeComplexValue(context, tagStream, block, val, valueInfo, valueType);
}
private void SerializeIndirectValue(CacheVersion version, ISerializationContext context, MemoryStream tagStream, IDataBlock block, object val, Type valueType)
{
var writer = block.Writer;
if (val == null)
{
writer.Write(0);
return;
}
// Serialize the value to a temporary block
var valueBlock = context.CreateBlock();
SerializeValue(version, context, tagStream, valueBlock, val, null, valueType);
// Finalize the block and write the pointer
block.WritePointer(valueBlock.Finalize(tagStream), valueType);
}
private static void SerializeTag(IDataBlock block, Tag tag)
{
block.Writer.Write(tag.Value);
}
/// <summary>
/// Serializes an inline array.
/// </summary>
/// <param name="context">The serialization context to use.</param>
/// <param name="tagStream">The stream to write completed blocks of tag data to.</param>
/// <param name="block">The temporary block to write incomplete tag data to.</param>
/// <param name="data">The array.</param>
/// <param name="valueInfo">Information about the value. Can be <c>null</c>.</param>
private void SerializeInlineArray(ISerializationContext context, MemoryStream tagStream, IDataBlock block, Array data, TagFieldAttribute valueInfo)
{
if (valueInfo == null || valueInfo.Count == 0)
throw new ArgumentException("Cannot serialize an inline array with no count set");
if (data == null || data.Length != valueInfo.Count)
throw new ArgumentException("Array length does not match the fixed count of " + valueInfo.Count);
// Serialize each element into the current block
var elementType = data.GetType().GetElementType();
foreach (var elem in data)
SerializeValue(context, tagStream, block, elem, null, elementType);
}
public void Visit(IDataBlock dataBlock)
{
var data = dataBlock.Data;
_callback(data);
}
/// <inheritdoc/>
public void SetBlock(int x, int y, int z, IDataBlock block)
{
cache = GetChunk(x, y, z);
if (cache == null || !Check(x, y, z)) {
return;
}
cache.Blocks.SetBlock(x, y, z, block);
}
public DataBlockStatistics(IDataBlock dataBlock)
{
_dataBlock = dataBlock;
}
private bool GetNextDataBlock(IInputFile file, IDataReader dataReader, IScanContext scanContext, out IDataBlock volBlock, out IDataBlockBuilder volBuilder)
{
IDataBlock volBlockAttempt = null;
IDataBlockBuilder volBlockAttemptBuilder = null;
while (volBlockAttempt == null && dataReader.State == DataReaderState.Ready)
{
volBlockAttemptBuilder = CreateBuilder(file);
scanContext.Detectors = new[] { _detector };
volBlockAttempt = _detector.DetectData(dataReader, volBlockAttemptBuilder, scanContext);
}
volBlock = volBlockAttempt;
volBuilder = volBlockAttemptBuilder;
return(volBlock != null);
}
/// <inheritdoc/>
public void SetBlock(int x, int y, int z, IDataBlock block)
{
SetID(x, y, z, block.ID);
SetData(x, y, z, block.Data);
}
public void Visit(IDataBlock dataBlock)
{
dataBlock.Data = _data;
_observers.ForEach(o => o.OnNext(true));
}
public void Visit(IDataBlock dataBlock)
{
var data = dataBlock.Data;
_observers.ForEach(o => o.OnNext(data));
}
/// <inheritdoc/>
public void SetBlock(int x, int y, int z, IDataBlock block)
{
cache.Blocks.SetBlock(x, y, z, block);
}
/// <summary>
/// Serializes a property.
/// </summary>
/// <param name="version"></param>
/// <param name="context">The serialization context to use.</param>
/// <param name="tagStream">The stream to write completed blocks of tag data to.</param>
/// <param name="block">The temporary block to write incomplete tag data to.</param>
/// <param name="instance">The object that the property belongs to.</param>
/// <param name="tagFieldInfo">The field enumerator.</param>
/// <param name="baseOffset">The base offset of the structure from the start of its block.</param>
/// <exception cref="System.InvalidOperationException">Offset for property \ + property.Name + \ is outside of its structure</exception>
private void SerializeProperty(CacheVersion version, ISerializationContext context, MemoryStream tagStream, IDataBlock block, object instance, TagFieldInfo tagFieldInfo, long baseOffset)
{
if (tagFieldInfo.Attribute.Flags.HasFlag(Runtime))
{
return;
}
object objectValue = tagFieldInfo.GetValue(instance);
// second condition is a hack to prevent exceptions when encountering cached tags
if (objectValue != null)
{
if (objectValue.GetType() == tagFieldInfo.FieldType || tagFieldInfo.FieldType == typeof(CachedTag))
{
SerializeValue(version, context, tagStream, block,
objectValue, tagFieldInfo.Attribute, tagFieldInfo.FieldType);
}
else
{
throw new Exception($"TagFieldInfo.GetValue return type {objectValue.GetType().ToString()} is not the same as the FieldInfo Type {tagFieldInfo.FieldType.ToString()}!");
}
}
else
{
SerializeValue(version, context, tagStream, block,
objectValue, tagFieldInfo.Attribute, tagFieldInfo.FieldType);
}
}
public SaveFileEntry(IDataBlock dblock)
{
this.typeName = dblock.GetType().AssemblyQualifiedName;
this.rawData = DataSerializer.SerializeProtoObject(dblock);
}
public virtual void SerializeTagData(ISerializationContext context, MemoryStream tagStream, IDataBlock block, TagData tagData, TagFieldAttribute valueInfo)
{
var writer = block.Writer;
uint offset = 0;
uint size = 0;
var data = tagData.Data;
if (data != null && data.Length > 0)
{
// Ensure the block is aligned correctly
var align = Math.Max(DefaultBlockAlign, (valueInfo != null) ? valueInfo.Align : 0);
StreamUtil.Align(tagStream, (int)align);
// Write its data
offset = (uint)tagStream.Position;
size = (uint)data.Length;
tagStream.Write(data, 0, data.Length);
StreamUtil.Align(tagStream, DefaultBlockAlign);
}
// Write the reference data
writer.Write(size);
writer.Write(0);
writer.Write(0);
if (size > 0)
{
block.WritePointer(offset, typeof(byte[]));
}
else
{
writer.Write(0);
}
writer.Write(0);
}
private static void SerializeRange(IDataBlock block, object val)
{
var type = val.GetType();
var boundsType = type.GenericTypeArguments[0];
var min = type.GetField("Min").GetValue(val);
var max = type.GetField("Max").GetValue(val);
SerializePrimitiveValue(block.Writer, min, boundsType);
SerializePrimitiveValue(block.Writer, max, boundsType);
}
/// <summary>
/// Serializes a structure into a temporary memory block.
/// </summary>
/// <param name="context">The serialization context to use.</param>
/// <param name="tagStream">The stream to write completed blocks of tag data to.</param>
/// <param name="block">The temporary block to write incomplete tag data to.</param>
/// <param name="info">Information about the tag structure type.</param>
/// <param name="structure">The structure to serialize.</param>
/// <exception cref="System.InvalidOperationException">Structure type must have TagStructureAttribute</exception>
public void SerializeStruct(ISerializationContext context, MemoryStream tagStream, IDataBlock block, TagStructureInfo info, object structure)
{
var baseOffset = block.Stream.Position;
foreach (var tagFieldInfo in TagStructure.GetTagFieldEnumerable(info))
{
SerializeProperty(info.Version, context, tagStream, block, structure, tagFieldInfo, baseOffset);
}
// Honor the struct size if it's defined
if (info.TotalSize > 0)
{
block.Stream.Position = baseOffset + info.TotalSize;
if (block.Stream.Position > block.Stream.Length)
{
block.Stream.SetLength(block.Stream.Position);
}
}
// Honor alignment
if (info.Structure.Align > 0)
{
block.SuggestAlignment(info.Structure.Align);
}
}
/// <summary>
/// Serializes a complex value.
/// </summary>
/// <param name="context">The serialization context to use.</param>
/// <param name="tagStream">The stream to write completed blocks of tag data to.</param>
/// <param name="block">The temporary block to write incomplete tag data to.</param>
/// <param name="val">The value.</param>
/// <param name="valueInfo">Information about the value. Can be <c>null</c>.</param>
/// <param name="valueType">Type of the value.</param>
private void SerializeComplexValue(ISerializationContext context, MemoryStream tagStream, IDataBlock block, object val, TagFieldAttribute valueInfo, Type valueType)
{
if (valueInfo != null && ((valueInfo.Flags & TagFieldFlags.Indirect) != 0 || valueType == typeof(ResourceReference)))
SerializeIndirectValue(context, tagStream, block, val, valueType);
else if (valueType.IsEnum)
SerializePrimitiveValue(block.Writer, val, valueType.GetEnumUnderlyingType());
else if (valueType == typeof(string))
SerializeString(block.Writer, (string)val, valueInfo);
else if (valueType == typeof(Tag))
SerializeTag(block, (Tag)val);
else if (valueType == typeof(TagInstance))
SerializeTagReference(block.Writer, (TagInstance)val, valueInfo);
else if (valueType == typeof(ResourceAddress))
block.Writer.Write(((ResourceAddress)val).Value);
else if (valueType == typeof(byte[]))
SerializeDataReference(tagStream, block, (byte[])val, valueInfo);
else if (valueType == typeof(Euler2))
SerializeEulerAngles(block, (Euler2)val);
else if (valueType == typeof(Euler3))
SerializeEulerAngles(block, (Euler3)val);
else if (valueType == typeof(Vector2))
SerializeVector(block, (Vector2)val);
else if (valueType == typeof(Vector3))
SerializeVector(block, (Vector3)val);
else if (valueType == typeof(Vector4))
SerializeVector(block, (Vector4)val);
else if (valueType == typeof(RealQuaternion))
SerializeRealQuaternion(block, (RealQuaternion)val);
else if (valueType == typeof(Matrix4x3))
SerializeMatrix(block, (Matrix4x3)val);
else if (valueType == typeof(StringID))
block.Writer.Write(((StringID)val).Value);
else if (valueType == typeof(Angle))
block.Writer.Write(((Angle)val).Radians);
else if (valueType.IsArray)
SerializeInlineArray(context, tagStream, block, (Array)val, valueInfo);
else if (valueType.IsGenericType && valueType.GetGenericTypeDefinition() == typeof(List<>))
SerializeTagBlock(context, tagStream, block, val, valueType, valueInfo);
else if (valueType.IsGenericType && valueType.GetGenericTypeDefinition() == typeof(Range<>))
SerializeRange(block, val);
else
SerializeStruct(context, tagStream, block, new TagStructureInfo(val.GetType(), _version), val);
}
private void SerializePoint(IDataBlock block, Point2d point)
{
block.Writer.Write(point.X);
block.Writer.Write(point.Y);
}
/// <summary>
/// Checks whether the <paramref name="newDataBlock"/> are not different from
/// the initially detected <paramref name="initialDataBlock"/>.
/// </summary>
/// <param name="initialDataBlock">the initially detected data block</param>
/// <param name="newDataBlock">the new data block to compare</param>
/// <returns>whether the data block is correct</returns>
private static bool IsDataBlockCorrect(IDataBlock initialDataBlock, IDataBlock newDataBlock)
{
if (newDataBlock == null)
{
return(false);
}
if (newDataBlock.InputFile != initialDataBlock.InputFile)
{
return(false);
}
if (newDataBlock.StartOffset != 0L)
{
return(false);
}
if (newDataBlock.Length != initialDataBlock.Length)
{
return(false); // Size of data block differs
}
if (newDataBlock.IsFullFile != initialDataBlock.IsFullFile)
{
return(false); // IsFullFile property differs
}
if (newDataBlock.CodecStreams == null)
{
return(initialDataBlock.CodecStreams.Count == 0);
}
// Codec streams can be divided into fragments when a maximum header count is reached
// The data block object contains the fragmented codec streams,
// the newDataBlock object contains the unfragmented codec streams.
// This is handled by the 'Where' clause.
// Also, codec streams that are split into multiple parts in the data block
// are represented by a single codec stream in the 'newDataBlock' object.
// This is handled by the 'GroupBy' clause.
int initialCodecStreamCount = initialDataBlock.CodecStreams.Where(c => (c.FragmentIndex == 0)).GroupBy(c => c.StreamNumber).Count();
if (initialCodecStreamCount != newDataBlock.CodecStreams.Count)
{
return(false); // Codec stream count differs
}
// Check the codec and container stream detectors used
foreach (ICodecStream initialCodecStream in initialDataBlock.CodecStreams)
{
if (initialCodecStream.FragmentIndex == 0)
{
int streamNumber = initialCodecStream.StreamNumber;
ICodecStream newCodecStream = newDataBlock.CodecStreams.Where(c => c.StreamNumber == streamNumber).FirstOrDefault();
if (newCodecStream == null)
{
return(false); // Codec stream not found in rescanned data block
}
IDetector initialDetector = initialCodecStream.Detectors.FirstOrDefault();
if (!IsCompatibleCodec(initialDetector, newCodecStream.DataFormat))
{
//It is possible that the container reports an incorrect format of the datastream
//Therefore disabled:
//return false;
}
}
}
return(true);
}
private void SerializePoint(IDataBlock block, RealPoint3d point)
{
block.Writer.Write(point.X);
block.Writer.Write(point.Y);
block.Writer.Write(point.Z);
}
public DataBlockVerification(IDataBlock block, IResultNode resultNode, String description)
{
_dataBlock = block;
_resultNode = resultNode;
_description = description;
}
private void SerializeVector(IDataBlock block, RealVector3d vec)
{
block.Writer.Write(vec.I);
block.Writer.Write(vec.J);
block.Writer.Write(vec.K);
}
private void SerializeColor(IDataBlock block, RealRgbColor color)
{
block.Writer.Write(color.Red);
block.Writer.Write(color.Green);
block.Writer.Write(color.Blue);
}
private void SerializePlane(IDataBlock block, RealPlane2d plane)
{
block.Writer.Write(plane.I);
block.Writer.Write(plane.J);
block.Writer.Write(plane.D);
}
public void OnMessage(IDataBlock message)
{
// Handle incorrect protocol version.
if (message is ProtocolInitiation)
{
string error = String.Format("Protocol mismatch - {0}", message.ToString());
AMQException e = new AMQProtocolHeaderException(error);
_log.Error("Closing connection because of protocol mismatch", e);
//_protocolSession.CloseProtocolSession();
_stateManager.Error(e);
return;
}
AMQFrame frame = (AMQFrame)message;
// Console.WriteLine(">>> AMQFrame frame received: " + frame); //KHC
if (frame.BodyFrame is AMQMethodBody)
{
if (_log.IsDebugEnabled)
{
_log.Debug("Method frame received: " + frame);
}
AMQMethodEvent evt = new AMQMethodEvent(frame.Channel, (AMQMethodBody)frame.BodyFrame, _protocolSession);
try
{
bool wasAnyoneInterested = false;
lock (_frameListeners.SyncRoot)
{
foreach (IAMQMethodListener listener in _frameListeners)
{
wasAnyoneInterested = listener.MethodReceived(evt) || wasAnyoneInterested;
}
}
if (!wasAnyoneInterested)
{
throw new AMQException("AMQMethodEvent " + evt + " was not processed by any listener.");
}
}
catch (Exception e)
{
foreach (IAMQMethodListener listener in _frameListeners)
{
listener.Error(e);
}
}
}
else if (frame.BodyFrame is ContentHeaderBody)
{
_protocolSession.MessageContentHeaderReceived(frame.Channel,
(ContentHeaderBody)frame.BodyFrame);
}
else if (frame.BodyFrame is ContentBody)
{
_protocolSession.MessageContentBodyReceived(frame.Channel,
(ContentBody)frame.BodyFrame);
}
else if (frame.BodyFrame is HeartbeatBody)
{
_log.Debug("HeartBeat received");
}
else
{
Console.WriteLine("***** UNHANDLED FRAME ******");
}
}
private void SerializeRange(CacheVersion version, ISerializationContext context, MemoryStream tagStream, IDataBlock block, object val)
{
var type = val.GetType();
var boundsType = type.GenericTypeArguments[0];
var lower = type.GetProperty("Lower").GetValue(val);
var upper = type.GetProperty("Upper").GetValue(val);
SerializeValue(version, context, tagStream, block, lower, null, boundsType);
SerializeValue(version, context, tagStream, block, upper, null, boundsType);
}
public CompositeAMQDataBlock(IDataBlock[] blocks)
{
_blocks = blocks;
}
private void ResetFixAndReportDataBlock(long startOffset)
{
_fixedDataBlockStartOffset = startOffset;
_fixedDataBlock = null;
}
public static void CompaireActivityPeriod(IDataTree dataTree, IDataBlock activityPeriodDataBlock, IDataBlock activityPeriodDataBlock2)
{
IDsnNode current = dataTree.DsnTree.Find(ActivityPeriod.KeyActivityPeriodBlock);
Stack <IDsnNode> stack = new Stack <IDsnNode>();
stack.Push(current);
while (stack.Count > 0)
{
current = stack.Pop();
for (var i = current.Children.Count - 1; i >= 0; i--)
{
stack.Push(current.Children[i]);
}
}
}
private void ScanCodecStreams(DataBlockDetectedEventArgs e, IDataBlock dataBlock)
{
IProgressReporter dataBlockProgressReporter = _createSubProgressReporter(_codecProgressReporter, dataBlock.StartOffset, dataBlock.Length, dataBlock.InputFile.Length);
long totalStreamBytes = dataBlock.CodecStreams.Sum(x => x.Length);
long streamBytesScanned = 0L;
bool hasCompleteCodecStream = false;
IDetector detector = null;
IDataBlockBuilder dataBlockBuilder = _createDataBlockBuilder();
dataBlockBuilder.DataFormat = dataBlock.DataFormat;
dataBlockBuilder.Detectors = dataBlock.Detectors;
dataBlockBuilder.InputFile = dataBlock.InputFile;
dataBlockBuilder.IsFullFile = dataBlock.IsFullFile;
dataBlockBuilder.IsFragmented = dataBlock.IsFragmented;
dataBlockBuilder.PreviousFragment = LastDataBlock;
dataBlockBuilder.StartOffset = dataBlock.StartOffset;
dataBlockBuilder.EndOffset = dataBlock.EndOffset;
dataBlockBuilder.ReferenceHeaderOffset = dataBlock.ReferenceHeaderOffset;
dataBlockBuilder.ReferenceHeader = dataBlock.ReferenceHeader;
foreach (ICodecStream completeCodecStream in dataBlock.CodecStreams)
{
IProgressReporter codecStreamProgressReporter = _createSubProgressReporter(dataBlockProgressReporter, streamBytesScanned, completeCodecStream.Length, totalStreamBytes);
var completeCodecStreamScanner = new CompleteCodecStreamScanner(_codecStreamDataScanner, dataBlockBuilder, completeCodecStream, codecStreamProgressReporter);
// Note: The container detector that was used is not available to the codec detector!
// NOTE: We assume that a file never uses multiple codec formats that are supported by Defraser.
// So, if at any time for example audio codecs will be supported, this code should be revised!
using (IDataReader dataReader = _dataReaderPool.CreateDataReader(completeCodecStream, completeCodecStreamScanner))
{
if (detector != null)
{
// Only scan other streams with the detector that already produced a valid and complete result
if (!completeCodecStreamScanner.ScanForNearlyCompleteCodecStream(dataReader))
{
AddUnknownCodecStream(dataBlockBuilder, completeCodecStream);
}
}
else
{
detector = completeCodecStreamScanner.ScanDetectForNearlyCompleteCodecStream(dataReader, CodecDetectors);
if (detector == null)
{
AddUnknownCodecStream(dataBlockBuilder, completeCodecStream);
}
}
hasCompleteCodecStream |= completeCodecStreamScanner.HasCompleteCodecStream;
}
streamBytesScanned += completeCodecStream.Length;
}
if (!hasCompleteCodecStream)
{
e.DoubleScanPayload = true;
}
LastDataBlock = dataBlockBuilder.Build();
ReportDataBlock(LastDataBlock);
}
/// <inheritdoc/>
public void SetBlock(int x, int y, int z, IDataBlock block)
{
SetID(x, y, z, block.ID);
SetData(x, y, z, block.Data);
}
internal static IDataBlock CreateDataBlock(IDetector detector, IDataPacket data, bool isFullFile, IDataBlock lastDataBlock)
{
IDataBlockBuilder dataBlockBuilder = CreateDataBlockBuilder();
dataBlockBuilder.DataFormat = CodecID.Unknown;
dataBlockBuilder.Detectors = new[] { detector };
dataBlockBuilder.InputFile = data.InputFile;
dataBlockBuilder.StartOffset = data.StartOffset;
dataBlockBuilder.EndOffset = data.EndOffset;
dataBlockBuilder.IsFullFile = isFullFile;
dataBlockBuilder.IsFragmented = false;
return(dataBlockBuilder.Build());
}
private static void SerializeEulerAngles(IDataBlock block, Euler3 angles)
{
block.Writer.Write(angles.Yaw.Radians);
block.Writer.Write(angles.Pitch.Radians);
block.Writer.Write(angles.Roll.Radians);
}
/// <summary>
/// Serializes a property.
/// </summary>
/// <param name="version"></param>
/// <param name="context">The serialization context to use.</param>
/// <param name="tagStream">The stream to write completed blocks of tag data to.</param>
/// <param name="block">The temporary block to write incomplete tag data to.</param>
/// <param name="instance">The object that the property belongs to.</param>
/// <param name="tagFieldInfo">The field enumerator.</param>
/// <param name="baseOffset">The base offset of the structure from the start of its block.</param>
/// <exception cref="System.InvalidOperationException">Offset for property \ + property.Name + \ is outside of its structure</exception>
private void SerializeProperty(CacheVersion version, ISerializationContext context, MemoryStream tagStream, IDataBlock block, object instance, TagFieldInfo tagFieldInfo, long baseOffset)
{
if (tagFieldInfo.Attribute.Flags.HasFlag(TagFieldFlags.Runtime))
{
return;
}
SerializeValue(version, context, tagStream, block,
tagFieldInfo.GetValue(instance), tagFieldInfo.Attribute, tagFieldInfo.FieldType);
}
private static void SerializeRealQuaternion(IDataBlock block, RealQuaternion quat)
{
block.Writer.Write(quat.I);
block.Writer.Write(quat.J);
block.Writer.Write(quat.K);
block.Writer.Write(quat.W);
}
/// <summary>
/// Serializes a value.
/// </summary>
/// <param name="version"></param>
/// <param name="context">The serialization context to use.</param>
/// <param name="tagStream">The stream to write completed blocks of tag data to.</param>
/// <param name="block">The temporary block to write incomplete tag data to.</param>
/// <param name="val">The value.</param>
/// <param name="valueInfo">Information about the value. Can be <c>null</c>.</param>
/// <param name="valueType">Type of the value.</param>
private void SerializeValue(CacheVersion version, ISerializationContext context, MemoryStream tagStream, IDataBlock block, object val, TagFieldAttribute valueInfo, Type valueType)
{
// Call the data block's PreSerialize callback to determine if the value should be mutated
val = block.PreSerialize(valueInfo, val);
if (val != null)
{
valueType = val.GetType(); // TODO: Fix hax
}
if (valueType.IsPrimitive)
{
SerializePrimitiveValue(block.Writer, val, valueType);
}
else
{
SerializeComplexValue(version, context, tagStream, block, val, valueInfo, valueType);
}
}
private static void SerializeVector(IDataBlock block, Vector4 vec)
{
block.Writer.Write(vec.X);
block.Writer.Write(vec.Y);
block.Writer.Write(vec.Z);
block.Writer.Write(vec.W);
}
/// <summary>
/// Serializes a complex value.
/// </summary>
/// <param name="version"></param>
/// <param name="context">The serialization context to use.</param>
/// <param name="tagStream">The stream to write completed blocks of tag data to.</param>
/// <param name="block">The temporary block to write incomplete tag data to.</param>
/// <param name="value">The value.</param>
/// <param name="valueInfo">Information about the value. Can be <c>null</c>.</param>
/// <param name="valueType">Type of the value.</param>
private void SerializeComplexValue(CacheVersion version, ISerializationContext context, MemoryStream tagStream, IDataBlock block, object value, TagFieldAttribute valueInfo, Type valueType)
{
if (valueInfo != null && valueInfo.Flags.HasFlag(TagFieldFlags.Pointer))
{
SerializeIndirectValue(version, context, tagStream, block, value, valueType);
}
else if (valueType.IsEnum)
{
SerializePrimitiveValue(block.Writer, value, valueType.GetEnumUnderlyingType());
}
else if (valueType == typeof(string))
{
SerializeString(block.Writer, (string)value, valueInfo);
}
else if (valueType == typeof(Tag))
{
SerializeTag(block, (Tag)value);
}
else if (valueType == typeof(CachedTagInstance))
{
SerializeTagReference(context, block.Writer, (CachedTagInstance)value, valueInfo);
}
else if (valueType == typeof(CacheAddress))
{
block.Writer.Write(((CacheAddress)value).Value);
}
else if (valueType == typeof(byte[]))
{
if (valueInfo.Flags.HasFlag(TagFieldFlags.Padding) || (value == null && valueInfo.Length > 0))
{
block.Writer.Write(new byte[valueInfo.Length]);
}
else if (valueInfo.Length > 0)
{
block.Writer.Write((byte[])value);
}
else
{
SerializeDataReference(tagStream, block, (byte[])value, valueInfo);
}
}
else if (valueType == typeof(RealRgbColor))
{
SerializeColor(block, (RealRgbColor)value);
}
else if (valueType == typeof(RealArgbColor))
{
SerializeColor(block, (RealArgbColor)value);
}
else if (valueType == typeof(ArgbColor))
{
SerializeColor(block, (ArgbColor)value);
}
else if (valueType == typeof(ArgbColor))
{
SerializeColor(block, (ArgbColor)value);
}
else if (valueType == typeof(RealEulerAngles2d))
{
SerializeEulerAngles(block, (RealEulerAngles2d)value);
}
else if (valueType == typeof(RealEulerAngles3d))
{
SerializeEulerAngles(block, (RealEulerAngles3d)value);
}
else if (valueType == typeof(Point2d))
{
SerializePoint(block, (Point2d)value);
}
else if (valueType == typeof(Rectangle2d))
{
SerializeRectangle(block, (Rectangle2d)value);
}
else if (valueType == typeof(RealPoint2d))
{
SerializePoint(block, (RealPoint2d)value);
}
else if (valueType == typeof(RealPoint3d))
{
SerializePoint(block, (RealPoint3d)value);
}
else if (valueType == typeof(RealVector2d))
{
SerializeVector(block, (RealVector2d)value);
}
else if (valueType == typeof(RealVector3d))
{
SerializeVector(block, (RealVector3d)value);
}
else if (valueType == typeof(RealQuaternion))
{
SerializeVector(block, (RealQuaternion)value);
}
else if (valueType == typeof(RealPlane2d))
{
SerializePlane(block, (RealPlane2d)value);
}
else if (valueType == typeof(RealPlane3d))
{
SerializePlane(block, (RealPlane3d)value);
}
else if (valueType == typeof(RealMatrix4x3))
{
SerializeMatrix(block, (RealMatrix4x3)value);
}
else if (valueType == typeof(StringId))
{
block.Writer.Write(((StringId)value).Value);
}
else if (valueType == typeof(Angle))
{
block.Writer.Write(((Angle)value).Radians);
}
else if (valueType == typeof(DatumIndex))
{
block.Writer.Write(((DatumIndex)value).Value);
}
else if (valueType == typeof(VertexShaderReference))
{
block.Writer.Write(0); // TODO: fix (not used in halo online)
}
else if (valueType == typeof(PixelShaderReference))
{
block.Writer.Write(0); // TODO: fix (not used in halo online)
}
else if (valueType.IsArray)
{
SerializeInlineArray(version, context, tagStream, block, (Array)value, valueInfo, valueType);
}
else if (valueType.IsGenericType && valueType.GetGenericTypeDefinition() == typeof(List <>))
{
SerializeTagBlock(version, context, tagStream, block, value, valueType, valueInfo);
}
else if (valueType.IsGenericType && valueType.GetGenericTypeDefinition() == typeof(Bounds <>))
{
SerializeRange(version, context, tagStream, block, value);
}
else
{
if (value == null)
{
value = Activator.CreateInstance(valueType);
}
SerializeStruct(context, tagStream, block, TagStructure.GetTagStructureInfo(valueType, version), value);
}
}
private void SerializeIndirectValue(ISerializationContext context, MemoryStream tagStream, IDataBlock block, object val, Type valueType)
{
var writer = block.Writer;
if (val == null)
{
writer.Write(0);
return;
}
// Serialize the value to a temporary block
var valueBlock = context.CreateBlock();
SerializeValue(context, tagStream, valueBlock, val, null, valueType);
// Finalize the block and write the pointer
block.WritePointer(valueBlock.Finalize(tagStream), valueType);
}
public void WriteFrame(IDataBlock frame)
{
_protocolWriter.Write(frame);
}
/// <summary>
/// Serializes a property.
/// </summary>
/// <param name="context">The serialization context to use.</param>
/// <param name="tagStream">The stream to write completed blocks of tag data to.</param>
/// <param name="block">The temporary block to write incomplete tag data to.</param>
/// <param name="instance">The object that the property belongs to.</param>
/// <param name="structInfo">The structure information.</param>
/// <param name="property">The property.</param>
/// <param name="baseOffset">The base offset of the structure from the start of its block.</param>
/// <exception cref="System.InvalidOperationException">Offset for property \ + property.Name + \ is outside of its structure</exception>
private void SerializeProperty(ISerializationContext context, MemoryStream tagStream, IDataBlock block, object instance, TagFieldEnumerator enumerator, long baseOffset)
{
// Seek to the value if it has an offset specified and write it
var valueInfo = enumerator.Attribute;
if (enumerator.Attribute.Offset >= 0)
block.Stream.Position = baseOffset + valueInfo.Offset;
var startOffset = block.Stream.Position;
var val = enumerator.Field.GetValue(instance);
SerializeValue(context, tagStream, block, val, valueInfo, enumerator.Field.FieldType);
if (valueInfo.Size > 0)
block.Stream.Position = startOffset + valueInfo.Size;
}
/// <summary>
/// Serializes an inline array.
/// </summary>
/// <param name="version"></param>
/// <param name="context">The serialization context to use.</param>
/// <param name="tagStream">The stream to write completed blocks of tag data to.</param>
/// <param name="block">The temporary block to write incomplete tag data to.</param>
/// <param name="data">The array.</param>
/// <param name="valueInfo">Information about the value. Can be <c>null</c>.</param>
/// <param name="valueType">The type of the value.</param>
private void SerializeInlineArray(CacheVersion version, ISerializationContext context, MemoryStream tagStream, IDataBlock block, Array data, TagFieldAttribute valueInfo, Type valueType)
{
if (valueInfo == null || valueInfo.Length == 0)
{
throw new ArgumentException("Cannot serialize an inline array with no count set");
}
var elementType = valueType.GetElementType();
if (data == null)
{
data = Array.CreateInstance(elementType, valueInfo.Length);
}
if (data == null || data.Length != valueInfo.Length)
{
throw new ArgumentException("Array length does not match the fixed count of " + valueInfo.Length);
}
// Serialize each element into the current block
foreach (var element in data)
{
SerializeValue(version, context, tagStream, block, element, null, elementType);
}
}
/// <summary>
/// Serializes a tag block.
/// </summary>
/// <param name="context">The serialization context to use.</param>
/// <param name="tagStream">The stream to write completed blocks of tag data to.</param>
/// <param name="block">The temporary block to write incomplete tag data to.</param>
/// <param name="list">The list of values in the tag block.</param>
/// <param name="listType">Type of the list.</param>
/// <param name="valueInfo">Information about the value. Can be <c>null</c>.</param>
private void SerializeTagBlock(ISerializationContext context, MemoryStream tagStream, IDataBlock block, object list, Type listType, TagFieldAttribute valueInfo)
{
var writer = block.Writer;
var listCount = 0;
if (list != null)
{
// Use reflection to get the number of elements in the list
var countProperty = listType.GetProperty("Count");
listCount = (int)countProperty.GetValue(list);
}
if (listCount == 0)
{
writer.Write(0);
writer.Write(0);
writer.Write(0);
return;
}
// Serialize each value in the list to a data block
var tagBlock = context.CreateBlock();
var enumerableList = (System.Collections.IEnumerable)list;
var valueType = listType.GenericTypeArguments[0];
foreach (var val in enumerableList)
SerializeValue(context, tagStream, tagBlock, val, null, valueType);
// Ensure the block is aligned correctly
var align = Math.Max(DefaultBlockAlign, (valueInfo != null) ? valueInfo.DataAlign : 0);
StreamUtil.Align(tagStream, (int)align);
// Finalize the block and write the tag block reference
writer.Write(listCount);
block.WritePointer(tagBlock.Finalize(tagStream), listType);
writer.Write(0);
}
/// <summary>
/// Serializes a tag block.
/// </summary>
/// <param name="version"></param>
/// <param name="context">The serialization context to use.</param>
/// <param name="tagStream">The stream to write completed blocks of tag data to.</param>
/// <param name="block">The temporary block to write incomplete tag data to.</param>
/// <param name="list">The list of values in the tag block.</param>
/// <param name="listType">Type of the list.</param>
/// <param name="valueInfo">Information about the value. Can be <c>null</c>.</param>
private void SerializeTagBlock(CacheVersion version, ISerializationContext context, MemoryStream tagStream, IDataBlock block, object list, Type listType, TagFieldAttribute valueInfo)
{
var writer = block.Writer;
var count = 0;
if (list != null)
{
// Use reflection to get the number of elements in the list
var countProperty = listType.GetProperty("Count");
count = (int)countProperty.GetValue(list);
}
if (count == 0)
{
writer.Write(0);
writer.Write(0);
writer.Write(0);
return;
}
var elementType = listType.GenericTypeArguments[0];
TagStructureAttribute structure;
try
{
structure = TagStructure.GetTagStructureInfo(elementType, Version).Structure;
}
catch
{
structure = null;
}
// Serialize each value in the list to a data block
var tagBlock = context.CreateBlock();
var enumerableList = (System.Collections.IEnumerable)list;
foreach (var val in enumerableList)
{
SerializeValue(version, context, tagStream, tagBlock, val, null, elementType);
}
// Ensure the block is aligned correctly
var align = Math.Max(DefaultBlockAlign, (valueInfo != null) ? valueInfo.Align : 0);
StreamUtil.Align(tagStream, (int)align);
// Finalize the block and write the tag block reference
writer.Write(count);
block.WritePointer(tagBlock.Finalize(tagStream), listType);
writer.Write(0);
}
private void SerializeTag(IDataBlock block, Tag tag)
{
block.Writer.Write(tag.Value);
}
/// <summary>
/// Convenience method that writes a frame to the protocol session. Equivalent
/// to calling getProtocolSession().write().
/// </summary>
/// <param name="frame">the frame to write</param>
public void WriteFrame(IDataBlock frame)
{
_protocolWriter.Write(frame);
}
