Here are the examples of the csharp api System.BitConverter.GetBytes(double) taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.
1061 Examples
19
Source : HealingStatsExtensionHandler.cs
with MIT License
from baaron4
with MIT License
from baaron4
internal virtual void SetVersion(Combareplacedem c)
{
var size = (c.SrcAgent & 0xFF00000000000000) >> 56;
byte[] bytes = new byte[size * 1]; // 32 * sizeof(char), char as in C not C#
uint offset = 0;
// 8 bytes
foreach (byte bt in BitConverter.GetBytes(c.DstAgent))
{
if (offset == size)
{
break;
}
bytes[offset++] = bt;
}
// 4 bytes
foreach (byte bt in BitConverter.GetBytes(c.Value))
{
if (offset == size)
{
break;
}
bytes[offset++] = bt;
}
// 4 bytes
foreach (byte bt in BitConverter.GetBytes(c.BuffDmg))
{
if (offset == size)
{
break;
}
bytes[offset++] = bt;
}
// 4 bytes
foreach (byte bt in BitConverter.GetBytes(c.OverstackValue))
{
if (offset == size)
{
break;
}
bytes[offset++] = bt;
}
// 4 bytes
foreach (byte bt in BitConverter.GetBytes(c.SkillID))
{
if (offset == size)
{
break;
}
bytes[offset++] = bt;
}
// 2 bytes
foreach (byte bt in BitConverter.GetBytes(c.SrcInstid))
{
if (offset == size)
{
break;
}
bytes[offset++] = bt;
}
// 2 bytes
foreach (byte bt in BitConverter.GetBytes(c.DstInstid))
{
if (offset == size)
{
break;
}
bytes[offset++] = bt;
}
// 2 bytes
foreach (byte bt in BitConverter.GetBytes(c.SrcMasterInstid))
{
if (offset == size)
{
break;
}
bytes[offset++] = bt;
}
// 2 bytes
foreach (byte bt in BitConverter.GetBytes(c.DstMasterInstid))
{
if (offset == size)
{
break;
}
bytes[offset++] = bt;
}
Version = System.Text.Encoding.UTF8.GetString(bytes);
}
19
Source : SkillInfoEvent.cs
with MIT License
from baaron4
with MIT License
from baaron4
private void BuildFromSkillInfo(Combareplacedem evtcItem)
{
byte[] skillInfoBytes = new byte[4 * sizeof(float)];
int offset = 0;
// 2
foreach (byte bt in BitConverter.GetBytes(evtcItem.Time))
{
skillInfoBytes[offset++] = bt;
}
// 2
foreach (byte bt in BitConverter.GetBytes(evtcItem.SrcAgent))
{
skillInfoBytes[offset++] = bt;
}
//
float[] skillInfoFloats = new float[4];
Buffer.BlockCopy(skillInfoBytes, 0, skillInfoFloats, 0, skillInfoBytes.Length);
Recharge = skillInfoFloats[0];
Range0 = skillInfoFloats[1];
Range1 = skillInfoFloats[2];
}
19
Source : EndianAwareBinaryWriter.cs
with MIT License
from bamcis-io
with MIT License
from bamcis-io
public void Write(double value, Endianness endianness) => this.WriteForEndianness(BitConverter.GetBytes(value), endianness);
19
Source : WCH7.cs
with The Unlicense
from BAndysc
with The Unlicense
from BAndysc
public new Dictionary<int, byte[]> ReadOffsetData(BinaryReader dbReader, long pos)
{
var CopyTable = new Dictionary<int, byte[]>();
var offsetmap = new List<OffsetEntry>();
long indexTablePos = dbReader.BaseStream.Length - (HasIndexTable ? RecordCount * 4 : 0);
long wch7TablePos = indexTablePos - UnknownWCH7 * 4;
int[] m_indexes = null;
//Offset table - Contains the index, offset and length meaning the index table is not used
if (HasOffsetTable)
{
// Records table
if (StringBlockSize > 0)
dbReader.Scrub(StringBlockSize);
for (var i = 0; i < RecordCount; i++)
{
int id = dbReader.ReadInt32();
int offset = dbReader.ReadInt32();
short length = dbReader.ReadInt16();
if (offset == 0 || length == 0)
continue;
offsetmap.Add(new OffsetEntry(id, offset, length));
}
}
//New WCH7 table
if (UnknownWCH7 > 0)
{
WCH7Table = new int[UnknownWCH7];
dbReader.Scrub(wch7TablePos);
for (var i = 0; i < UnknownWCH7; i++)
WCH7Table[i] = dbReader.ReadInt32();
}
//Index table
if (HasIndexTable)
{
if (!HasOffsetTable || HasRelationshipData)
dbReader.Scrub(indexTablePos);
m_indexes = new int[RecordCount];
for (var i = 0; i < RecordCount; i++)
m_indexes[i] = dbReader.ReadInt32();
}
//Extract record data
for (var i = 0; i < Math.Max(RecordCount, offsetmap.Count); i++)
{
if (HasOffsetTable)
{
OffsetEntry map = offsetmap[i];
dbReader.Scrub(map.Offset);
var recordbytes = BitConverter.GetBytes(map.Id).Concat(dbReader.ReadBytes(map.Length));
CopyTable.Add(map.Id, recordbytes.ToArray());
}
else
{
dbReader.Scrub(pos + i * RecordSize);
byte[] recordbytes = dbReader.ReadBytes((int) RecordSize);
if (HasIndexTable)
{
var newrecordbytes = BitConverter.GetBytes(m_indexes[i]).Concat(recordbytes);
CopyTable.Add(m_indexes[i], newrecordbytes.ToArray());
}
else
{
int bytecount = FieldStructure[IdIndex].ByteCount;
int offset = FieldStructure[IdIndex].Offset;
var id = 0;
for (var j = 0; j < bytecount; j++)
id |= recordbytes[offset + j] << (j * 8);
CopyTable.Add(id, recordbytes);
}
}
}
return CopyTable;
}
19
Source : WDC1.cs
with The Unlicense
from BAndysc
with The Unlicense
from BAndysc
public new Dictionary<int, byte[]> ReadOffsetData(BinaryReader dbReader, long pos)
{
var CopyTable = new Dictionary<int, byte[]>();
var offsetmap = new List<Tuple<int, short>>();
var firstindex = new Dictionary<int, OffsetDuplicate>();
var OffsetDuplicates = new Dictionary<int, int>();
var Copies = new Dictionary<int, List<int>>();
int[] m_indexes = null;
// OffsetTable
if (HasOffsetTable && OffsetTableOffset > 0)
{
dbReader.BaseStream.Position = OffsetTableOffset;
for (var i = 0; i < MaxId - MinId + 1; i++)
{
int offset = dbReader.ReadInt32();
short length = dbReader.ReadInt16();
if (offset == 0 || length == 0)
continue;
// special case, may contain duplicates in the offset map that we don't want
if (CopyTableSize == 0)
{
if (!firstindex.ContainsKey(offset))
firstindex.Add(offset, new OffsetDuplicate(offsetmap.Count, firstindex.Count));
else
{
OffsetDuplicates.Add(MinId + i, firstindex[offset].VisibleIndex);
continue;
}
}
offsetmap.Add(new Tuple<int, short>(offset, length));
}
}
// IndexTable
if (HasIndexTable)
{
m_indexes = new int[RecordCount];
for (var i = 0; i < RecordCount; i++)
m_indexes[i] = dbReader.ReadInt32();
}
// Copytable
if (CopyTableSize > 0)
{
long end = dbReader.BaseStream.Position + CopyTableSize;
while (dbReader.BaseStream.Position < end)
{
int id = dbReader.ReadInt32();
int idcopy = dbReader.ReadInt32();
if (!Copies.ContainsKey(idcopy))
Copies.Add(idcopy, new List<int>());
Copies[idcopy].Add(id);
}
}
// ColumnMeta
ColumnMeta = new List<ColumnStructureEntry>();
for (var i = 0; i < FieldCount; i++)
{
ColumnStructureEntry column = new ColumnStructureEntry
{
RecordOffset = dbReader.ReadUInt16(),
Size = dbReader.ReadUInt16(),
AdditionalDataSize = dbReader.ReadUInt32(), // size of pallet / sparse values
CompressionType = (CompressionType) dbReader.ReadUInt32(),
BitOffset = dbReader.ReadInt32(),
BitWidth = dbReader.ReadInt32(),
Cardinality = dbReader.ReadInt32()
};
// preload arraysizes
if (column.CompressionType == CompressionType.None)
column.ArraySize = Math.Max(column.Size / FieldStructure[i].BitCount, 1);
else if (column.CompressionType == CompressionType.PalletArray)
column.ArraySize = Math.Max(column.Cardinality, 1);
ColumnMeta.Add(column);
}
// Pallet values
for (var i = 0; i < ColumnMeta.Count; i++)
{
if (ColumnMeta[i].CompressionType == CompressionType.Pallet ||
ColumnMeta[i].CompressionType == CompressionType.PalletArray)
{
int elements = (int) ColumnMeta[i].AdditionalDataSize / 4;
int cardinality = Math.Max(ColumnMeta[i].Cardinality, 1);
ColumnMeta[i].PalletValues = new List<byte[]>();
for (var j = 0; j < elements / cardinality; j++)
ColumnMeta[i].PalletValues.Add(dbReader.ReadBytes(cardinality * 4));
}
}
// Sparse values
for (var i = 0; i < ColumnMeta.Count; i++)
{
if (ColumnMeta[i].CompressionType == CompressionType.Sparse)
{
ColumnMeta[i].SparseValues = new Dictionary<int, byte[]>();
for (var j = 0; j < ColumnMeta[i].AdditionalDataSize / 8; j++)
ColumnMeta[i].SparseValues[dbReader.ReadInt32()] = dbReader.ReadBytes(4);
}
}
// Relationships
if (RelationshipDataSize > 0)
{
RelationShipData = new RelationShipData
{
Records = dbReader.ReadUInt32(),
MinId = dbReader.ReadUInt32(),
MaxId = dbReader.ReadUInt32(),
Entries = new Dictionary<uint, byte[]>()
};
for (var i = 0; i < RelationShipData.Records; i++)
{
byte[] foreignKey = dbReader.ReadBytes(4);
uint index = dbReader.ReadUInt32();
// has duplicates just like the copy table does... why?
if (!RelationShipData.Entries.ContainsKey(index))
RelationShipData.Entries.Add(index, foreignKey);
}
FieldStructure.Add(new FieldStructureEntry(0, 0));
ColumnMeta.Add(new ColumnStructureEntry());
}
// Record Data
BitStream bitStream = new(recordData);
for (var i = 0; i < RecordCount; i++)
{
var id = 0;
if (HasOffsetTable && HasIndexTable)
{
id = m_indexes[CopyTable.Count];
var map = offsetmap[i];
if (CopyTableSize == 0 && firstindex[map.Item1].HiddenIndex != i) //Ignore duplicates
continue;
dbReader.BaseStream.Position = map.Item1;
byte[] data = dbReader.ReadBytes(map.Item2);
var recordbytes = BitConverter.GetBytes(id).Concat(data);
// append relationship id
if (RelationShipData != null)
{
// seen cases of missing indicies
if (RelationShipData.Entries.TryGetValue((uint) i, out byte[] foreignData))
recordbytes = recordbytes.Concat(foreignData);
else
recordbytes = recordbytes.Concat(new byte[4]);
}
CopyTable.Add(id, recordbytes.ToArray());
if (Copies.ContainsKey(id))
{
foreach (int copy in Copies[id])
CopyTable.Add(copy, BitConverter.GetBytes(copy).Concat(data).ToArray());
}
}
else
{
bitStream.Seek(i * RecordSize, 0);
var idOffset = 0;
var data = new List<byte>();
if (HasIndexTable)
{
id = m_indexes[i];
data.AddRange(BitConverter.GetBytes(id));
}
int c = HasIndexTable ? 1 : 0;
for (var f = 0; f < FieldCount; f++)
{
int bitOffset = ColumnMeta[f].BitOffset;
int bitWidth = ColumnMeta[f].BitWidth;
int cardinality = ColumnMeta[f].Cardinality;
uint palletIndex;
int take = columnSizes[c] * ColumnMeta[f].ArraySize;
switch (ColumnMeta[f].CompressionType)
{
case CompressionType.None:
int bitSize = FieldStructure[f].BitCount;
if (!HasIndexTable && f == IdIndex)
{
idOffset = data.Count;
id = bitStream.ReadInt32(bitSize); // always read Ids as ints
data.AddRange(BitConverter.GetBytes(id));
}
else
data.AddRange(bitStream.ReadBytes(bitSize * ColumnMeta[f].ArraySize, false, take));
break;
case CompressionType.Immediate:
case CompressionType.SignedImmediate:
if (!HasIndexTable && f == IdIndex)
{
idOffset = data.Count;
id = bitStream.ReadInt32(bitWidth); // always read Ids as ints
data.AddRange(BitConverter.GetBytes(id));
}
else
data.AddRange(bitStream.ReadBytes(bitWidth, false, take));
break;
case CompressionType.Sparse:
if (ColumnMeta[f].SparseValues.TryGetValue(id, out byte[] valBytes))
data.AddRange(valBytes.Take(take));
else
data.AddRange(BitConverter.GetBytes(ColumnMeta[f].BitOffset).Take(take));
break;
case CompressionType.Pallet:
case CompressionType.PalletArray:
palletIndex = bitStream.ReadUInt32(bitWidth);
data.AddRange(ColumnMeta[f].PalletValues[(int) palletIndex].Take(take));
break;
default:
throw new Exception($"Unknown compression {ColumnMeta[f].CompressionType}");
}
c += ColumnMeta[f].ArraySize;
}
// append relationship id
if (RelationShipData != null)
{
// seen cases of missing indicies
if (RelationShipData.Entries.TryGetValue((uint) i, out byte[] foreignData))
data.AddRange(foreignData);
else
data.AddRange(new byte[4]);
}
CopyTable.Add(id, data.ToArray());
if (Copies.ContainsKey(id))
{
foreach (int copy in Copies[id])
{
byte[] newrecord = CopyTable[id].ToArray();
Buffer.BlockCopy(BitConverter.GetBytes(copy), 0, newrecord, idOffset, 4);
CopyTable.Add(copy, newrecord);
}
}
}
}
if (HasIndexTable)
{
FieldStructure.Insert(0, new FieldStructureEntry(0, 0));
ColumnMeta.Insert(0, new ColumnStructureEntry());
}
offsetmap.Clear();
firstindex.Clear();
OffsetDuplicates.Clear();
Copies.Clear();
Array.Resize(ref recordData, 0);
bitStream.Dispose();
ColumnMeta.ForEach(x =>
{
x.PalletValues?.Clear();
x.SparseValues?.Clear();
});
InternalRecordSize = (uint) CopyTable.First().Value.Length;
if (CopyTableSize > 0)
CopyTable = CopyTable.OrderBy(x => x.Key).ToDictionary(x => x.Key, x => x.Value);
return CopyTable;
}
19
Source : WDC2.cs
with The Unlicense
from BAndysc
with The Unlicense
from BAndysc
public new Dictionary<int, byte[]> ReadOffsetData(BinaryReader dbReader, long pos)
{
var CopyTable = new Dictionary<int, byte[]>();
var offsetmap = new List<Tuple<int, short>>();
var firstindex = new Dictionary<int, OffsetDuplicate>();
var Copies = new Dictionary<int, List<int>>();
columnOffsets = new List<int>();
recordOffsets = new List<int>();
int[] m_indexes = null;
// OffsetTable
if (HasOffsetTable && OffsetTableOffset > 0)
{
dbReader.BaseStream.Position = OffsetTableOffset;
for (var i = 0; i < MaxId - MinId + 1; i++)
{
int offset = dbReader.ReadInt32();
short length = dbReader.ReadInt16();
if (offset == 0 || length == 0)
continue;
// special case, may contain duplicates in the offset map that we don't want
if (CopyTableSize == 0)
{
if (!firstindex.ContainsKey(offset))
firstindex.Add(offset, new OffsetDuplicate(offsetmap.Count, firstindex.Count));
else
continue;
}
offsetmap.Add(new Tuple<int, short>(offset, length));
}
}
// IndexTable
if (HasIndexTable)
{
m_indexes = new int[RecordCount];
for (var i = 0; i < RecordCount; i++)
m_indexes[i] = dbReader.ReadInt32();
}
// Copytable
if (CopyTableSize > 0)
{
long end = dbReader.BaseStream.Position + CopyTableSize;
while (dbReader.BaseStream.Position < end)
{
int id = dbReader.ReadInt32();
int idcopy = dbReader.ReadInt32();
if (!Copies.ContainsKey(idcopy))
Copies.Add(idcopy, new List<int>());
Copies[idcopy].Add(id);
}
}
// Relationships
if (RelationshipDataSize > 0)
{
RelationShipData = new RelationShipData
{
Records = dbReader.ReadUInt32(),
MinId = dbReader.ReadUInt32(),
MaxId = dbReader.ReadUInt32(),
Entries = new Dictionary<uint, byte[]>()
};
for (var i = 0; i < RelationShipData.Records; i++)
{
byte[] foreignKey = dbReader.ReadBytes(4);
uint index = dbReader.ReadUInt32();
// has duplicates just like the copy table does... why?
if (!RelationShipData.Entries.ContainsKey(index))
RelationShipData.Entries.Add(index, foreignKey);
}
FieldStructure.Add(new FieldStructureEntry(0, 0));
ColumnMeta.Add(new ColumnStructureEntry());
}
// Record Data
BitStream bitStream = new(recordData);
for (var i = 0; i < RecordCount; i++)
{
var id = 0;
if (HasOffsetTable && HasIndexTable)
{
id = m_indexes[CopyTable.Count];
var map = offsetmap[i];
if (CopyTableSize == 0 && firstindex[map.Item1].HiddenIndex != i) //Ignore duplicates
continue;
dbReader.BaseStream.Position = map.Item1;
byte[] data = dbReader.ReadBytes(map.Item2);
var recordbytes = BitConverter.GetBytes(id).Concat(data);
// append relationship id
if (RelationShipData != null)
{
// seen cases of missing indicies
if (RelationShipData.Entries.TryGetValue((uint) i, out byte[] foreignData))
recordbytes = recordbytes.Concat(foreignData);
else
recordbytes = recordbytes.Concat(new byte[4]);
}
CopyTable.Add(id, recordbytes.ToArray());
if (Copies.ContainsKey(id))
{
foreach (int copy in Copies[id])
CopyTable.Add(copy, BitConverter.GetBytes(copy).Concat(data).ToArray());
}
}
else
{
bitStream.Seek(i * RecordSize, 0);
var idOffset = 0;
if (StringBlockSize > 0)
recordOffsets.Add((int) bitStream.Offset);
var data = new List<byte>();
if (HasIndexTable)
{
id = m_indexes[i];
data.AddRange(BitConverter.GetBytes(id));
}
int c = HasIndexTable ? 1 : 0;
for (var f = 0; f < FieldCount; f++)
{
int bitOffset = ColumnMeta[f].BitOffset;
int bitWidth = ColumnMeta[f].BitWidth;
int cardinality = ColumnMeta[f].Cardinality;
uint palletIndex;
int take = columnSizes[c] * ColumnMeta[f].ArraySize;
switch (ColumnMeta[f].CompressionType)
{
case CompressionType.None:
int bitSize = FieldStructure[f].BitCount;
if (!HasIndexTable && f == IdIndex)
{
idOffset = data.Count;
id = bitStream.ReadInt32(bitSize); // always read Ids as ints
data.AddRange(BitConverter.GetBytes(id));
}
else
{
for (var x = 0; x < ColumnMeta[f].ArraySize; x++)
{
if (i == 0)
columnOffsets.Add((int) (bitStream.Offset + (bitStream.BitPosition >> 3)));
data.AddRange(bitStream.ReadBytes(bitSize, false, columnSizes[c]));
}
}
break;
case CompressionType.Immediate:
case CompressionType.SignedImmediate:
if (!HasIndexTable && f == IdIndex)
{
idOffset = data.Count;
id = bitStream.ReadInt32(bitWidth); // always read Ids as ints
data.AddRange(BitConverter.GetBytes(id));
}
else
{
if (i == 0)
columnOffsets.Add((int) (bitStream.Offset + (bitStream.BitPosition >> 3)));
data.AddRange(bitStream.ReadBytes(bitWidth, false, take));
}
break;
case CompressionType.Sparse:
if (i == 0)
columnOffsets.Add((int) (bitStream.Offset + (bitStream.BitPosition >> 3)));
if (ColumnMeta[f].SparseValues.TryGetValue(id, out byte[] valBytes))
data.AddRange(valBytes.Take(take));
else
data.AddRange(BitConverter.GetBytes(ColumnMeta[f].BitOffset).Take(take));
break;
case CompressionType.Pallet:
case CompressionType.PalletArray:
if (i == 0)
columnOffsets.Add((int) (bitStream.Offset + (bitStream.BitPosition >> 3)));
palletIndex = bitStream.ReadUInt32(bitWidth);
data.AddRange(ColumnMeta[f].PalletValues[(int) palletIndex].Take(take));
break;
default:
throw new Exception($"Unknown compression {ColumnMeta[f].CompressionType}");
}
c += ColumnMeta[f].ArraySize;
}
// append relationship id
if (RelationShipData != null)
{
// seen cases of missing indicies
if (RelationShipData.Entries.TryGetValue((uint) i, out byte[] foreignData))
data.AddRange(foreignData);
else
data.AddRange(new byte[4]);
}
CopyTable.Add(id, data.ToArray());
if (Copies.ContainsKey(id))
{
foreach (int copy in Copies[id])
{
byte[] newrecord = CopyTable[id].ToArray();
Buffer.BlockCopy(BitConverter.GetBytes(copy), 0, newrecord, idOffset, 4);
CopyTable.Add(copy, newrecord);
if (StringBlockSize > 0)
recordOffsets.Add(recordOffsets.Last());
}
}
}
}
if (HasIndexTable)
{
FieldStructure.Insert(0, new FieldStructureEntry(0, 0));
ColumnMeta.Insert(0, new ColumnStructureEntry());
}
offsetmap.Clear();
firstindex.Clear();
OffsetDuplicates.Clear();
Copies.Clear();
Array.Resize(ref recordData, 0);
bitStream.Dispose();
ColumnMeta.ForEach(x =>
{
x.PalletValues?.Clear();
x.SparseValues?.Clear();
});
InternalRecordSize = (uint) CopyTable.First().Value.Length;
if (CopyTableSize > 0)
{
var sort = CopyTable.Select((x, i) => new {CT = x, Off = recordOffsets[i]}).OrderBy(x => x.CT.Key);
recordOffsets = sort.Select(x => x.Off).ToList();
CopyTable = sort.ToDictionary(x => x.CT.Key, x => x.CT.Value);
}
return CopyTable;
}
19
Source : ArgumentSerializer.cs
with MIT License
from Bannerlord-Coop-Team
with MIT License
from Bannerlord-Coop-Team
[Encoder]
public static void EncodeEventArg(this RailBitBuffer buffer, Argument arg)
{
buffer.Write(NumberOfBitsForArgType, Convert.ToByte(arg.EventType));
switch (arg.EventType)
{
case EventArgType.MBObject:
buffer.WriteMBGUID(arg.MbGUID.Value);
break;
case EventArgType.Null:
// Empty
break;
case EventArgType.MBObjectManager:
// Empty
break;
case EventArgType.Int:
buffer.WriteInt(arg.Int.Value);
break;
case EventArgType.Float:
buffer.WriteUInt(
BitConverter.ToUInt32(BitConverter.GetBytes(arg.Float.Value), 0));
break;
case EventArgType.Bool:
buffer.WriteBool(arg.Bool.Value);
break;
case EventArgType.StoreObjectId:
buffer.WriteUInt(arg.StoreObjectId.Value.Value);
break;
case EventArgType.CurrentCampaign:
// Empty
break;
case EventArgType.CampaignBehavior:
List<CampaignBehaviorBase> behaviors = GetCampaignBehaviors();
buffer.WriteInt(behaviors.IndexOf(arg.CampaignBehavior));
break;
case EventArgType.SmallObjectRaw:
buffer.WriteByteArray(arg.Raw);
break;
default:
throw new ArgumentOutOfRangeException();
}
}
19
Source : ArgumentSerializer.cs
with MIT License
from Bannerlord-Coop-Team
with MIT License
from Bannerlord-Coop-Team
[Decoder]
public static Argument DecodeEventArg(this RailBitBuffer buffer)
{
var eType = (EventArgType) buffer.Read(NumberOfBitsForArgType);
switch (eType)
{
case EventArgType.MBObject:
return new Argument(buffer.ReadMBGUID());
case EventArgType.MBObjectManager:
return Argument.MBObjectManager;
case EventArgType.Null:
return Argument.Null;
case EventArgType.Int:
return new Argument(buffer.ReadInt());
case EventArgType.Float:
var ui = buffer.ReadUInt();
var f = BitConverter.ToSingle(BitConverter.GetBytes(ui), 0);
return new Argument(f);
case EventArgType.Bool:
var b = buffer.ReadBool();
return new Argument(b);
case EventArgType.StoreObjectId:
return new Argument(new ObjectId(buffer.ReadUInt()));
case EventArgType.CurrentCampaign:
return Argument.CurrentCampaign;
case EventArgType.CampaignBehavior:
int behaviorIdx = buffer.ReadInt();
List<CampaignBehaviorBase> behaviors = GetCampaignBehaviors();
return new Argument(behaviors[behaviorIdx]);
case EventArgType.SmallObjectRaw:
return new Argument(buffer.ReadByteArray());
default:
throw new ArgumentOutOfRangeException();
}
}
19
Source : UI_MapTerrain.cs
with GNU General Public License v3.0
from berichan
with GNU General Public License v3.0
from berichan
public void SetPlaza()
{
if (uint.TryParse(PlazaX.text, out var plX))
{
if (uint.TryParse(PlazaY.text, out var plY))
{
var xb = BitConverter.GetBytes(plX);
var yb = BitConverter.GetBytes(plY);
Array.Copy(xb, 0, acre_plaza, AcreSizeAll + 4, xb.Length);
Array.Copy(yb, 0, acre_plaza, AcreSizeAll + 8, yb.Length);
UI_Popup.CurrentInstance.CreatePopupMessage(1f, "Updating plaza.", () =>
{
MapParent.CurrentConnection.WriteBytes(acre_plaza, OffsetHelper.OutsideFieldStart);
generateAll();
});
return;
}
}
UI_Popup.CurrentInstance.CreatePopupMessage(1f, "Unable to parse plaza values as u32.", () => {});
}
19
Source : ProjectFile.cs
with MIT License
from BleuBleu
with MIT License
from BleuBleu
public bool Save(Project project, string filename)
{
try
{
var serializer = new ProjectSaveBuffer(project);
project.SerializeState(serializer);
var buffer = serializer.GetBuffer();
using (var stream = File.Create(filename))
{
stream.Write(BitConverter.GetBytes(MagicNumber), 0, 4);
stream.Write(BitConverter.GetBytes(Project.Version), 0, 4);
buffer = Compression.CompressBytes(buffer, CompressionLevel.Optimal);
stream.Write(buffer, 0, buffer.Length);
stream.Flush();
stream.Close();
project.Filename = filename;
return true;
}
}
catch
{
return false;
}
}
19
Source : DataView.cs
with MIT License
from blockcoli
with MIT License
from blockcoli
public void SetFloat64(int byteOffset, double value, bool? littleEndian = null)
{
var bytes = BitConverter.GetBytes(value);
if (!littleEndian.HasValue || !littleEndian.Value) Array.Reverse(bytes);
Array.Copy(bytes, 0, Buffer, byteOffset, bytes.Length);
}
19
Source : LibraCanonicalDeserialization.cs
with MIT License
from blockcoli
with MIT License
from blockcoli
public byte[] TransactionArgumentToByte(TransactionArgumentLCS source)
{
var len = U32ToByte((uint)source.ArgType);
byte[] data;
switch (source.ArgType)
{
case Types.TransactionArgument.Types.ArgType.Address:
data = LCSCore.LCSDeserialization(source.Address);
return len.Concat(data).ToArray();
case Types.TransactionArgument.Types.ArgType.Bytearray:
data = ByteArrayToByte(source.ByteArray);
return len.Concat(data).ToArray();
case Types.TransactionArgument.Types.ArgType.String:
data = StringToByte(source.String);
return len.Concat(data).ToArray();
case Types.TransactionArgument.Types.ArgType.U64:
data = BitConverter.GetBytes(source.U64);
return len.Concat(data).ToArray();
}
throw new InvalidOperationException();
}
19
Source : SerumProgramData.cs
with MIT License
from bmresearch
with MIT License
from bmresearch
internal static byte[] DeriveVaultSignerAddress(Market market)
{
byte[] buffer = new byte[8];
buffer.WriteU64(market.VaultSignerNonce, 0);
List<byte[]> seeds = new () { market.OwnAddress.KeyBytes, BitConverter.GetBytes(market.VaultSignerNonce) };
bool success = AddressExtensions.TryCreateProgramAddress(seeds,
SerumProgram.ProgramIdKey.KeyBytes, out byte[] vaultSignerAddress);
return !success ? null : vaultSignerAddress;
}
19
Source : TextElement.cs
with MIT License
from BobLd
with MIT License
from BobLd
public override int GetHashCode()
{
const int prime = 31;
int result = base.GetHashCode();
result = prime * result + BitConverter.ToInt32(BitConverter.GetBytes(Direction), 0);
result = prime * result + ((Font?.GetHashCode()) ?? 0);
result = prime * result + BitConverter.ToInt32(BitConverter.GetBytes(FontSize), 0);
result = prime * result + ((text?.GetHashCode()) ?? 0);
result = prime * result + BitConverter.ToInt32(BitConverter.GetBytes(WidthOfSpace), 0);
return result;
}
19
Source : TextElement.cs
with MIT License
from BobLd
with MIT License
from BobLd
public override bool Equals(object obj)
{
if (obj is TextElement other)
{
if (BitConverter.ToInt32(BitConverter.GetBytes(Direction), 0) != BitConverter.ToInt32(BitConverter.GetBytes(other.Direction), 0))
{
return false;
}
if (Font == null)
{
if (other.Font != null) return false;
}
else if (!Font.Equals(other.Font))
{
return false;
}
if (BitConverter.ToInt32(BitConverter.GetBytes(FontSize), 0) != BitConverter.ToInt32(BitConverter.GetBytes(other.FontSize), 0))
{
return false;
}
if (text == null)
{
if (other.text != null) return false;
}
else if (!text.Equals(other.text))
{
return false;
}
return BitConverter.ToInt32(BitConverter.GetBytes(WidthOfSpace), 0) != BitConverter.ToInt32(BitConverter.GetBytes(other.WidthOfSpace), 0);
}
return false;
}
19
Source : TableRectangle.cs
with MIT License
from BobLd
with MIT License
from BobLd
public override int GetHashCode()
{
int prime = 31;
int result = base.GetHashCode();
// need to implement hash and equal in PdfPig's PdfRectangle
result = prime * result + BoundingBox.BottomLeft.GetHashCode();
result = prime * result + BoundingBox.TopLeft.GetHashCode();
result = prime * result + BoundingBox.TopRight.GetHashCode();
result = prime * result + BoundingBox.BottomRight.GetHashCode();
result = prime * result + BitConverter.ToInt32(BitConverter.GetBytes(BoundingBox.Rotation), 0);
return result;
}
19
Source : Ext.cs
with MIT License
from bonzaiferroni
with MIT License
from bonzaiferroni
public static byte [] ToByteArray<T> (this T value, ByteOrder order)
where T : struct
{
var type = typeof (T);
var bytes = type == typeof (Boolean)
? BitConverter.GetBytes ((Boolean)(object) value)
: type == typeof (Byte)
? new byte [] { (Byte)(object) value }
: type == typeof (Char)
? BitConverter.GetBytes ((Char)(object) value)
: type == typeof (Double)
? BitConverter.GetBytes ((Double)(object) value)
: type == typeof (Int16)
? BitConverter.GetBytes ((Int16)(object) value)
: type == typeof (Int32)
? BitConverter.GetBytes ((Int32)(object) value)
: type == typeof (Int64)
? BitConverter.GetBytes ((Int64)(object) value)
: type == typeof (Single)
? BitConverter.GetBytes ((Single)(object) value)
: type == typeof (UInt16)
? BitConverter.GetBytes ((UInt16)(object) value)
: type == typeof (UInt32)
? BitConverter.GetBytes ((UInt32)(object) value)
: type == typeof (UInt64)
? BitConverter.GetBytes ((UInt64)(object) value)
: new byte [0];
if (bytes.Length > 1 && !order.IsHostOrder ())
Array.Reverse (bytes);
return bytes;
}
19
Source : CompactBinaryProtocolWriter.cs
with Apache License 2.0
from bphillips09
with Apache License 2.0
from bphillips09
public void WriteDouble(double value)
{
WriteBlob(BitConverter.GetBytes(value), 8);
}
19
Source : RegistrationToken.cs
with MIT License
from BreezeHub
with MIT License
from BreezeHub
public byte[] GetRegistrationTokenBytes(RsaKey rsaKey, BitcoinSecret privateKeyEcdsa)
{
var token = GetHeaderBytes();
CryptoUtils cryptoUtils = new CryptoUtils(rsaKey, privateKeyEcdsa);
// Sign header (excluding preliminary length marker bytes) with RSA
RsaSignature = cryptoUtils.SignDataRSA(token.ToArray());
byte[] rsaLength = BitConverter.GetBytes(RsaSignature.Length);
// Sign header (excluding preliminary length marker bytes) with ECDSA
EcdsaSignature = cryptoUtils.SignDataECDSA(token.ToArray());
byte[] ecdsaLength = BitConverter.GetBytes(EcdsaSignature.Length);
// TODO: Check if the lengths are >2 bytes. Should not happen
// for most conceivable signature schemes at current key lengths
token.Add(rsaLength[0]);
token.Add(rsaLength[1]);
token.AddRange(RsaSignature);
token.Add(ecdsaLength[0]);
token.Add(ecdsaLength[1]);
token.AddRange(EcdsaSignature);
// Server configuration hash
token.AddRange(Encoding.ASCII.GetBytes(ConfigurationHash));
byte[] ecdsaPubKeyLength = BitConverter.GetBytes(EcdsaPubKey.ToBytes().Length);
token.Add(ecdsaPubKeyLength[0]);
token.Add(ecdsaPubKeyLength[1]);
token.AddRange(EcdsaPubKey.ToBytes());
// Finally add protocol byte and computed length to beginning of header
byte[] protocolVersionByte = BitConverter.GetBytes(ProtocolVersion);
byte[] headerLength = BitConverter.GetBytes(token.Count);
token.Insert(0, protocolVersionByte[0]);
token.Insert(1, headerLength[0]);
token.Insert(2, headerLength[1]);
return token.ToArray();
}
19
Source : ByteBuffer.cs
with MIT License
from BtbN
with MIT License
from BtbN
public void AddDouble(double input)
{
AddBytesEndian(BitConverter.GetBytes(input));
}
19
Source : Helpers.cs
with MIT License
from BtbN
with MIT License
from BtbN
public static byte[] ToBytes(this double i)
{
byte[] res = BitConverter.GetBytes(i);
if (BitConverter.IsLittleEndian)
Array.Reverse(res);
return res;
}
19
Source : Abi.cs
with Apache License 2.0
from bugbytesinc
with Apache License 2.0
from bugbytesinc
internal static ReadOnlyMemory<byte> EncodeAddressPart(object value)
{
// For 20 bytes total (aka uint160)
// byte 0 to 3 are shard
// byte 4 to 11 are realm
// byte 12 to 19 are account number
// Note: packed in 32 bytes, right aligned
if (value is Address address)
{
var bytes = new byte[32];
var shard = BitConverter.GetBytes(address.ShardNum);
if (BitConverter.IsLittleEndian)
{
Array.Reverse(shard);
}
shard[^4..^0].CopyTo(bytes, 12);
var realm = BitConverter.GetBytes(address.RealmNum);
if (BitConverter.IsLittleEndian)
{
Array.Reverse(realm);
}
realm.CopyTo(bytes, 16);
var num = BitConverter.GetBytes(address.AccountNum);
if (BitConverter.IsLittleEndian)
{
Array.Reverse(num);
}
num.CopyTo(bytes, 24);
return bytes;
}
throw new ArgumentException("Argument was not an address.", nameof(value));
}
19
Source : CreatureRaw.cs
with GNU General Public License v3.0
from caioavidal
with GNU General Public License v3.0
from caioavidal
public static byte[] Convert(IPlayer playerRequesting, IWalkableCreature creature)
{
//optimize this method
var cache = new List<byte>();
var known = playerRequesting.KnowsCreatureWithId(creature.CreatureId);
if (known)
{
cache.AddRange(BitConverter.GetBytes((ushort) 0x62));
cache.AddRange(BitConverter.GetBytes(creature.CreatureId));
}
else
{
cache.AddRange(BitConverter.GetBytes((ushort) 0x61));
cache.AddRange(BitConverter.GetBytes(playerRequesting.ChooseToRemoveFromKnownSet()));
cache.AddRange(BitConverter.GetBytes(creature.CreatureId));
var creatureNameBytes = Encoding.Default.GetBytes(creature.Name);
cache.AddRange(BitConverter.GetBytes((ushort) creatureNameBytes.Length));
cache.AddRange(creatureNameBytes);
}
cache.Add((byte) Math.Min(100, creature.HealthPoints * 100 / creature.MaxHealthPoints));
cache.Add((byte) creature.SafeDirection);
if (playerRequesting.CanSee(creature))
{
// Add creature outfit
cache.AddRange(BitConverter.GetBytes(creature.Outfit.LookType));
if (creature.Outfit.LookType > 0)
{
cache.Add(creature.Outfit.Head);
cache.Add(creature.Outfit.Body);
cache.Add(creature.Outfit.Legs);
cache.Add(creature.Outfit.Feet);
cache.Add(creature.Outfit.Addon);
}
else
{
cache.AddRange(BitConverter.GetBytes(creature.Outfit.LookType));
}
}
else
{
cache.AddRange(BitConverter.GetBytes((ushort) 0));
cache.AddRange(BitConverter.GetBytes((ushort) 0));
}
cache.Add(creature.LightBrightness);
cache.Add(creature.LightColor);
cache.AddRange(BitConverter.GetBytes(creature.Speed));
cache.Add(creature.Skull);
cache.Add((byte) GetPartyEmblem(playerRequesting, creature));
if (!known)
{
if (creature is IPlayer player)
{
if (player.GuildId == 0) cache.Add((byte) GuildEmblem.None); //guild emblem
else if (playerRequesting.GuildId == player.GuildId) cache.Add((byte) GuildEmblem.Ally);
else cache.Add((byte) GuildEmblem.Neutral); //guild emblem
}
else
{
cache.Add((byte) GuildEmblem.None);
}
}
cache.Add(0x01);
return cache.ToArray();
}
19
Source : XteaBenchmark.cs
with GNU General Public License v3.0
from caioavidal
with GNU General Public License v3.0
from caioavidal
private static byte[] ConvertToBytes(Span<uint> array)
{
var bytes = new byte[array.Length * 4];
var index = 0;
for (var i = 0; i < array.Length; i++)
{
var newBytes = BitConverter.GetBytes(array[i]);
bytes[index] = newBytes[0];
bytes[index + 1] = newBytes[1];
bytes[index + 2] = newBytes[2];
bytes[index + 3] = newBytes[3];
index += 4;
}
return bytes;
}
19
Source : Cumulative.cs
with GNU General Public License v3.0
from caioavidal
with GNU General Public License v3.0
from caioavidal
public Span<byte> GetRaw()
{
Span<byte> cache = stackalloc byte[3];
var idBytes = BitConverter.GetBytes(Metadata.ClientId);
cache[0] = idBytes[0];
cache[1] = idBytes[1];
cache[2] = Amount;
return cache.ToArray();
}
19
Source : StaticTile.cs
with GNU General Public License v3.0
from caioavidal
with GNU General Public License v3.0
from caioavidal
public byte[] GetRaw(IItem[] items)
{
var ground = new List<byte>();
var top1 = new List<byte>();
var downRawItems = new List<byte>();
foreach (var item in items)
{
if (item is IGround groundItem)
{
_topItemOnStack = groundItem;
ground.AddRange(BitConverter.GetBytes(item.ClientId));
continue;
}
if (item.IsAlwaysOnTop)
{
if (item.FloorDirection != default) FloorDirection = item.FloorDirection;
_topItemOnStack = item;
top1.AddRange(BitConverter.GetBytes(item.ClientId));
}
else
{
_topItemOnStack = item;
downRawItems.AddRange(BitConverter.GetBytes(item.ClientId));
}
}
return ground.Concat(top1).Concat(downRawItems).ToArray();
}
19
Source : Tile.cs
with GNU General Public License v3.0
from caioavidal
with GNU General Public License v3.0
from caioavidal
public byte[] GetRaw(IPlayer playerRequesting)
{
if (_cache != null && !(Creatures?.Any() ?? false)) return _cache;
Span<byte> stream = stackalloc byte[930]; //max possible length
var countThings = 0;
var countBytes = 0;
if (Ground != default)
{
BitConverter.GetBytes(Ground.ClientId).replacedpan().CopyTo(stream);
countThings++;
countBytes += 2;
}
if (TopItems is not null)
foreach (var item in TopItems.Reverse()) //todo: remove reverse
{
if (countThings == 9) break;
var raw = item.GetRaw();
raw.CopyTo(stream.Slice(countBytes, raw.Length));
countThings++;
countBytes += raw.Length;
}
if (Creatures is not null)
foreach (var creature in Creatures)
{
if (!playerRequesting.CanSee(creature.Value)) continue;
if (countThings == 9) break;
var raw = creature.Value.GetRaw(playerRequesting);
playerRequesting.AddKnownCreature(creature.Key);
raw.CopyTo(stream.Slice(countBytes, raw.Length));
countThings++;
countBytes += raw.Length;
}
if (DownItems is not null)
foreach (var item in DownItems)
{
if (countThings == 9) break;
var raw = item.GetRaw();
raw.CopyTo(stream.Slice(countBytes, raw.Length));
countThings++;
countBytes += raw.Length;
}
_cache = stream.Slice(0, countBytes).ToArray();
return _cache;
}
19
Source : SaleItemListPacket.cs
with GNU General Public License v3.0
from caioavidal
with GNU General Public License v3.0
from caioavidal
public override void WriteToMessage(INetworkMessage message)
{
if (Player is null || ShopItems is null) return;
var map = Player.Inventory.Map;
var totalMoney = Player.Inventory.GetTotalMoney(_coinTypeStore) + Player.BankAmount;
message.AddByte((byte) GameOutgoingPacketType.SaleItemList);
message.AddUInt32((uint) Math.Min(totalMoney, uint.MaxValue));
byte itemsToSend = 0;
var temp = new List<byte>();
foreach (var shopItem in ShopItems)
{
if (shopItem.SellPrice == 0) continue;
var index = (int) shopItem.Item.TypeId;
//if (Item::items[shopInfo.itemId].isFluidContainer()) //todo
//{
// index |= (static_cast<uint32_t>(shopInfo.subType) << 16);
//}
if (!map.TryGetValue(shopItem.Item.TypeId, out var itemAmount)) continue;
temp.AddRange(BitConverter.GetBytes(shopItem.Item.ClientId));
temp.Add((byte) Math.Min(itemAmount, byte.MaxValue));
if (++itemsToSend >= byte.MaxValue) break;
}
message.AddByte(itemsToSend);
message.AddBytes(temp.ToArray());
}
19
Source : NetworkMessage.cs
with GNU General Public License v3.0
from caioavidal
with GNU General Public License v3.0
from caioavidal
private byte[] GetHeader(bool addChecksum = true)
{
var checkSumBytes = new byte[4];
if (addChecksum)
{
var adlerChecksum = AdlerChecksum.Checksum(Buffer, 0, Length); //todo: 6 is the header length
checkSumBytes = BitConverter.GetBytes(adlerChecksum);
}
var lengthInBytes = BitConverter.GetBytes((ushort) (Length + checkSumBytes.Length));
var header = new byte[6];
System.Buffer.BlockCopy(lengthInBytes, 0, header, 0, 2);
System.Buffer.BlockCopy(checkSumBytes, 0, header, 2, 4);
return header;
}
19
Source : ByteBuffer.cs
with MIT License
from CatLib
with MIT License
from CatLib
public void WriteDouble (double value)
{
var bytes = BitConverter.GetBytes (value);
if (!BitConverter.IsLittleEndian)
Array.Reverse (bytes);
WriteBytes (bytes);
}
19
Source : MsgPackWriter.cs
with GNU Affero General Public License v3.0
from cc004
with GNU Affero General Public License v3.0
from cc004
public void Write(double x)
{
byte[] bytes = BitConverter.GetBytes(x);
byte[] tmp = _tmp;
tmp[0] = 203;
if (BitConverter.IsLittleEndian)
{
tmp[1] = bytes[7];
tmp[2] = bytes[6];
tmp[3] = bytes[5];
tmp[4] = bytes[4];
tmp[5] = bytes[3];
tmp[6] = bytes[2];
tmp[7] = bytes[1];
tmp[8] = bytes[0];
}
else
{
tmp[1] = bytes[0];
tmp[2] = bytes[1];
tmp[3] = bytes[2];
tmp[4] = bytes[3];
tmp[5] = bytes[4];
tmp[6] = bytes[5];
tmp[7] = bytes[6];
tmp[8] = bytes[7];
}
_strm.Write(tmp, 0, 9);
}
19
Source : DriverRunner.cs
with Apache License 2.0
from cdy816
with Apache License 2.0
from cdy816
protected byte[] ConvertToBytes(object value,byte valuetype)
{
switch ((TagType)valuetype)
{
case TagType.Bool:
return BitConverter.GetBytes((bool)value);
case TagType.Byte:
return BitConverter.GetBytes(Convert.ToByte(value));
case TagType.DateTime:
return BitConverter.GetBytes(Convert.ToInt64(value));
case TagType.Double:
return BitConverter.GetBytes(Convert.ToDouble(value));
case TagType.Float:
return BitConverter.GetBytes(Convert.ToSingle(value));
case TagType.Int:
return BitConverter.GetBytes(Convert.ToInt32(value));
case TagType.Long:
return BitConverter.GetBytes(Convert.ToInt64(value));
case TagType.Short:
return BitConverter.GetBytes(Convert.ToInt16(value));
case TagType.String:
return Encoding.UTF8.GetBytes(value.ToString());
case TagType.UInt:
return BitConverter.GetBytes(Convert.ToUInt32(value));
case TagType.ULong:
return BitConverter.GetBytes(Convert.ToUInt64(value));
case TagType.UShort:
return BitConverter.GetBytes(Convert.ToUInt16(value));
case TagType.IntPoint:
IntPoint ival = (IntPoint)value;
byte[] val = new byte[8];
BitConverter.GetBytes(ival.X).CopyTo(val, 0);
BitConverter.GetBytes(ival.Y).CopyTo(val, 4);
return val;
case TagType.IntPoint3:
IntPoint3 ival3 = (IntPoint3)value;
val = new byte[12];
BitConverter.GetBytes(ival3.X).CopyTo(val, 0);
BitConverter.GetBytes(ival3.Y).CopyTo(val, 4);
BitConverter.GetBytes(ival3.Z).CopyTo(val, 8);
return val;
case TagType.UIntPoint3:
UIntPoint3 uival3 = (UIntPoint3)value;
val = new byte[12];
BitConverter.GetBytes(uival3.X).CopyTo(val, 0);
BitConverter.GetBytes(uival3.Y).CopyTo(val, 4);
BitConverter.GetBytes(uival3.Z).CopyTo(val, 8);
return val;
case TagType.UIntPoint:
UIntPoint uival = (UIntPoint)value;
val = new byte[8];
BitConverter.GetBytes(uival.X).CopyTo(val, 0);
BitConverter.GetBytes(uival.Y).CopyTo(val, 4);
return val;
case TagType.LongPoint:
LongPoint lval = (LongPoint)value;
val = new byte[16];
BitConverter.GetBytes(lval.X).CopyTo(val, 0);
BitConverter.GetBytes(lval.Y).CopyTo(val, 8);
return val;
case TagType.LongPoint3:
LongPoint3 lval3 = (LongPoint3)value;
val = new byte[24];
BitConverter.GetBytes(lval3.X).CopyTo(val, 0);
BitConverter.GetBytes(lval3.Y).CopyTo(val, 8);
BitConverter.GetBytes(lval3.Z).CopyTo(val, 16);
return val;
case TagType.ULongPoint:
ULongPoint ulval = (ULongPoint)value;
val = new byte[16];
BitConverter.GetBytes(ulval.X).CopyTo(val, 0);
BitConverter.GetBytes(ulval.Y).CopyTo(val, 8);
return val;
case TagType.ULongPoint3:
ULongPoint3 ulval3 = (ULongPoint3)value;
val = new byte[24];
BitConverter.GetBytes(ulval3.X).CopyTo(val, 0);
BitConverter.GetBytes(ulval3.Y).CopyTo(val, 8);
BitConverter.GetBytes(ulval3.Z).CopyTo(val, 16);
return val;
}
return null;
}
19
Source : DriverRunner.cs
with Apache License 2.0
from cdy816
with Apache License 2.0
from cdy816
protected byte[] ConvertToBytes(object value,byte valuetype)
{
switch ((TagType)valuetype)
{
case TagType.Bool:
return BitConverter.GetBytes((bool)value);
case TagType.Byte:
return BitConverter.GetBytes(Convert.ToByte(value));
case TagType.DateTime:
return BitConverter.GetBytes(Convert.ToInt64(value));
case TagType.Double:
return BitConverter.GetBytes(Convert.ToDouble(value));
case TagType.Float:
return BitConverter.GetBytes(Convert.ToSingle(value));
case TagType.Int:
return BitConverter.GetBytes(Convert.ToInt32(value));
case TagType.Long:
return BitConverter.GetBytes(Convert.ToInt64(value));
case TagType.Short:
return BitConverter.GetBytes(Convert.ToInt16(value));
case TagType.String:
return Encoding.UTF8.GetBytes(value.ToString());
case TagType.UInt:
return BitConverter.GetBytes(Convert.ToUInt32(value));
case TagType.ULong:
return BitConverter.GetBytes(Convert.ToUInt64(value));
case TagType.UShort:
return BitConverter.GetBytes(Convert.ToUInt16(value));
case TagType.IntPoint:
IntPoint ival = (IntPoint)value;
byte[] val = new byte[8];
BitConverter.GetBytes(ival.X).CopyTo(val, 0);
BitConverter.GetBytes(ival.Y).CopyTo(val, 4);
return val;
case TagType.IntPoint3:
IntPoint3 ival3 = (IntPoint3)value;
val = new byte[12];
BitConverter.GetBytes(ival3.X).CopyTo(val, 0);
BitConverter.GetBytes(ival3.Y).CopyTo(val, 4);
BitConverter.GetBytes(ival3.Z).CopyTo(val, 8);
return val;
case TagType.UIntPoint3:
UIntPoint3 uival3 = (UIntPoint3)value;
val = new byte[12];
BitConverter.GetBytes(uival3.X).CopyTo(val, 0);
BitConverter.GetBytes(uival3.Y).CopyTo(val, 4);
BitConverter.GetBytes(uival3.Z).CopyTo(val, 8);
return val;
case TagType.UIntPoint:
UIntPoint uival = (UIntPoint)value;
val = new byte[8];
BitConverter.GetBytes(uival.X).CopyTo(val, 0);
BitConverter.GetBytes(uival.Y).CopyTo(val, 4);
return val;
case TagType.LongPoint:
LongPoint lval = (LongPoint)value;
val = new byte[16];
BitConverter.GetBytes(lval.X).CopyTo(val, 0);
BitConverter.GetBytes(lval.Y).CopyTo(val, 8);
return val;
case TagType.LongPoint3:
LongPoint3 lval3 = (LongPoint3)value;
val = new byte[24];
BitConverter.GetBytes(lval3.X).CopyTo(val, 0);
BitConverter.GetBytes(lval3.Y).CopyTo(val, 8);
BitConverter.GetBytes(lval3.Z).CopyTo(val, 16);
return val;
case TagType.ULongPoint:
ULongPoint ulval = (ULongPoint)value;
val = new byte[16];
BitConverter.GetBytes(ulval.X).CopyTo(val, 0);
BitConverter.GetBytes(ulval.Y).CopyTo(val, 8);
return val;
case TagType.ULongPoint3:
ULongPoint3 ulval3 = (ULongPoint3)value;
val = new byte[24];
BitConverter.GetBytes(ulval3.X).CopyTo(val, 0);
BitConverter.GetBytes(ulval3.Y).CopyTo(val, 8);
BitConverter.GetBytes(ulval3.Z).CopyTo(val, 16);
return val;
}
return null;
}
19
Source : ModbusIpDriver.cs
with Apache License 2.0
from cdy816
with Apache License 2.0
from cdy816
private ushort[] DoubleToByte(double value)
{
var btmp = BitConverter.GetBytes(value);
return ConvertByteToUnshort(btmp, mData.DoubleFormate);
}
19
Source : ModbusIpDriver.cs
with Apache License 2.0
from cdy816
with Apache License 2.0
from cdy816
public string ToStringValue(Span<ushort> datas)
{
IEnumerable<byte> bvals=null;
foreach(var vv in datas)
{
if (bvals == null)
{
bvals = BitConverter.GetBytes(vv);
}
else
{
bvals = bvals.Concat(BitConverter.GetBytes(vv));
}
}
if(bvals!=null)
{
switch (mData.StringEncoding)
{
case StringEncoding.Ascii:
return Encoding.ASCII.GetString(bvals.ToArray());
case StringEncoding.Utf8:
return Encoding.UTF8.GetString(bvals.ToArray());
case StringEncoding.Unicode:
return Encoding.Unicode.GetString(bvals.ToArray());
}
return Encoding.Default.GetString(bvals.ToArray());
}
else
{
return string.Empty;
}
}
19
Source : ModbusSeriseDriver.cs
with Apache License 2.0
from cdy816
with Apache License 2.0
from cdy816
public string ToStringValue(Span<ushort> datas)
{
IEnumerable<byte> bvals = null;
foreach (var vv in datas)
{
if (bvals == null)
{
bvals = BitConverter.GetBytes(vv);
}
else
{
bvals = bvals.Concat(BitConverter.GetBytes(vv));
}
}
if (bvals != null)
{
switch (mData.StringEncoding)
{
case StringEncoding.Ascii:
return Encoding.ASCII.GetString(bvals.ToArray());
case StringEncoding.Utf8:
return Encoding.UTF8.GetString(bvals.ToArray());
case StringEncoding.Unicode:
return Encoding.Unicode.GetString(bvals.ToArray());
}
return Encoding.Default.GetString(bvals.ToArray());
}
else
{
return string.Empty;
}
}
19
Source : HepPacket.cs
with MIT License
from chatop2020
with MIT License
from chatop2020
private static byte[] InitBuffer(ChunkTypeEnum chunkType, ushort length)
{
byte[] buf = new byte[length];
if (BitConverter.IsLittleEndian)
{
Buffer.BlockCopy(BitConverter.GetBytes(NetConvert.DoReverseEndian(GENERIC_VENDOR_ID)), 0, buf, 0, 2);
Buffer.BlockCopy(BitConverter.GetBytes(NetConvert.DoReverseEndian((ushort)chunkType)), 0, buf, 2, 2);
Buffer.BlockCopy(BitConverter.GetBytes(NetConvert.DoReverseEndian(length)), 0, buf, 4, 2);
}
else
{
Buffer.BlockCopy(BitConverter.GetBytes(GENERIC_VENDOR_ID), 0, buf, 0, 2);
Buffer.BlockCopy(BitConverter.GetBytes((ushort)chunkType), 0, buf, 2, 2);
Buffer.BlockCopy(BitConverter.GetBytes(length), 0, buf, 4, 2);
}
return buf;
}
19
Source : HepPacket.cs
with MIT License
from chatop2020
with MIT License
from chatop2020
public static byte[] GetBytes(ChunkTypeEnum chunkType, ushort val)
{
byte[] buf = InitBuffer(chunkType, MINIMUM_CHUNK_LENGTH + 2);
if (BitConverter.IsLittleEndian)
{
Buffer.BlockCopy(BitConverter.GetBytes(NetConvert.DoReverseEndian(val)), 0, buf, MINIMUM_CHUNK_LENGTH, 2);
}
else
{
Buffer.BlockCopy(BitConverter.GetBytes(val), 0, buf, MINIMUM_CHUNK_LENGTH, 2);
}
return buf;
}
19
Source : HepPacket.cs
with MIT License
from chatop2020
with MIT License
from chatop2020
public static byte[] GetBytes(ChunkTypeEnum chunkType, uint val)
{
byte[] buf = InitBuffer(chunkType, MINIMUM_CHUNK_LENGTH + 4);
if (BitConverter.IsLittleEndian)
{
Buffer.BlockCopy(BitConverter.GetBytes(NetConvert.DoReverseEndian(val)), 0, buf, MINIMUM_CHUNK_LENGTH, 4);
}
else
{
Buffer.BlockCopy(BitConverter.GetBytes(val), 0, buf, MINIMUM_CHUNK_LENGTH, 4);
}
return buf;
}
19
Source : Mjpeg.cs
with MIT License
from chatop2020
with MIT License
from chatop2020
static byte[] CreateQuantizationTables(uint type, uint Q, byte precision)
{
Q &= 128;
//Factor restricted to range of 1 and 99
int factor = (int)Math.Max(Math.Min(1, Q), 99);
//Seed quantization value
int q = (Q < 50 ? q = 5000 / factor : 200 - factor * 2);
//Create 2 quantization tables from Seed quality value using the RFC quantizers
int tableSize = defaultQuantizers.Length / 2;
byte[] resultTables = new byte[tableSize * 2];
for (int i = 0, j = tableSize; i < tableSize; ++i, ++j)
{
if (precision == 0)
{
//Clamp with Min, Max
//Luma
resultTables[i] = (byte)Math.Min(Math.Max((defaultQuantizers[i] * q + 50) / 100, 1), byte.MaxValue);
//Chroma
resultTables[j] = (byte)Math.Min(Math.Max((defaultQuantizers[j] * q + 50) / 100, 1), byte.MaxValue);
}
else
{
//Luma
BitConverter.GetBytes(NetConvert.DoReverseEndian((ushort)Math.Min(Math.Max((defaultQuantizers[i] * q + 50) / 100, 1), byte.MaxValue))).CopyTo(resultTables, i);
i++;
//Chroma
BitConverter.GetBytes(NetConvert.DoReverseEndian((ushort)Math.Min(Math.Max((defaultQuantizers[j] * q + 50) / 100, 1), byte.MaxValue))).CopyTo(resultTables, j);
j++;
}
}
return resultTables;
}
19
Source : HepPacket.cs
with MIT License
from chatop2020
with MIT License
from chatop2020
public static byte[] GetBytes(SIPEndPoint srcEndPoint, SIPEndPoint dstEndPoint, DateTime timestamp, uint agentID, string preplacedword, string payload)
{
byte[] packetBuffer = new byte[MAX_HEP_PACKET_LENGTH];
int offset = 0;
// HEP3 ASCII code to start the packet.
packetBuffer[0] = 0x48;
packetBuffer[1] = 0x45;
packetBuffer[2] = 0x50;
packetBuffer[3] = 0x33;
offset = 6;
// IP family.
var familyChunkBuffer = HepChunk.GetBytes(ChunkTypeEnum.IPFamily, (byte)srcEndPoint.Address.AddressFamily);
Buffer.BlockCopy(familyChunkBuffer, 0, packetBuffer, offset, familyChunkBuffer.Length);
offset += familyChunkBuffer.Length;
// IP transport layer protocol.
var protocolChunkBuffer = HepChunk.GetBytes(ChunkTypeEnum.IPProtocolID, GetProtocolNumber(srcEndPoint.Protocol));
Buffer.BlockCopy(protocolChunkBuffer, 0, packetBuffer, offset, protocolChunkBuffer.Length);
offset += protocolChunkBuffer.Length;
// Source IP address.
ChunkTypeEnum srcChunkType = srcEndPoint.Address.AddressFamily == AddressFamily.InterNetwork ? ChunkTypeEnum.IPv4SourceAddress : ChunkTypeEnum.IPv6SourceAddress;
var srcIPAddress = HepChunk.GetBytes(srcChunkType, srcEndPoint.Address);
Buffer.BlockCopy(srcIPAddress, 0, packetBuffer, offset, srcIPAddress.Length);
offset += srcIPAddress.Length;
// Destination IP address.
ChunkTypeEnum dstChunkType = dstEndPoint.Address.AddressFamily == AddressFamily.InterNetwork ? ChunkTypeEnum.IPv4DesinationAddress : ChunkTypeEnum.IPv6DesinationAddress;
var dstIPAddress = HepChunk.GetBytes(dstChunkType, dstEndPoint.Address);
Buffer.BlockCopy(dstIPAddress, 0, packetBuffer, offset, dstIPAddress.Length);
offset += dstIPAddress.Length;
// Source port.
var srcPortBuffer = HepChunk.GetBytes(ChunkTypeEnum.SourcePort, (ushort)srcEndPoint.Port);
Buffer.BlockCopy(srcPortBuffer, 0, packetBuffer, offset, srcPortBuffer.Length);
offset += srcPortBuffer.Length;
// Destination port.
var dstPortBuffer = HepChunk.GetBytes(ChunkTypeEnum.DestinationPort, (ushort)dstEndPoint.Port);
Buffer.BlockCopy(dstPortBuffer, 0, packetBuffer, offset, dstPortBuffer.Length);
offset += dstPortBuffer.Length;
// Timestamp.
var timestampBuffer = HepChunk.GetBytes(ChunkTypeEnum.TimestampSeconds, (uint)timestamp.GetEpoch());
Buffer.BlockCopy(timestampBuffer, 0, packetBuffer, offset, timestampBuffer.Length);
offset += timestampBuffer.Length;
// Timestamp micro seconds (.NET only has millisecond resolution).
var timestampMicrosBuffer = HepChunk.GetBytes(ChunkTypeEnum.TimestampMicroSeconds, (uint)(timestamp.Millisecond * 1000));
Buffer.BlockCopy(timestampMicrosBuffer, 0, packetBuffer, offset, timestampMicrosBuffer.Length);
offset += timestampMicrosBuffer.Length;
// Protocol type, only interested in SIP at this point.
var protocolTypeBuffer = HepChunk.GetBytes(ChunkTypeEnum.ProtocolType, (byte)CaptureProtocolTypeEnum.SIP);
Buffer.BlockCopy(protocolTypeBuffer, 0, packetBuffer, offset, protocolTypeBuffer.Length);
offset += protocolTypeBuffer.Length;
// Capture agent ID.
var agentIDBuffer = HepChunk.GetBytes(ChunkTypeEnum.CaptureAgentID, agentID);
Buffer.BlockCopy(agentIDBuffer, 0, packetBuffer, offset, agentIDBuffer.Length);
offset += agentIDBuffer.Length;
// Auth key
if (!String.IsNullOrEmpty(preplacedword))
{
var preplacedwordBuffer = HepChunk.GetBytes(ChunkTypeEnum.AuthenticationKey, Encoding.UTF8.GetBytes(preplacedword));
Buffer.BlockCopy(preplacedwordBuffer, 0, packetBuffer, offset, preplacedwordBuffer.Length);
offset += preplacedwordBuffer.Length;
}
// Payload
var payloadBuffer = HepChunk.GetBytes(ChunkTypeEnum.CapturedPayload, Encoding.UTF8.GetBytes(payload));
// If we don't have enough space left truncate the payload.
int payloadLength = (payloadBuffer.Length > packetBuffer.Length - offset) ? packetBuffer.Length - offset : payloadBuffer.Length;
Buffer.BlockCopy(payloadBuffer, 0, packetBuffer, offset, payloadLength);
offset += payloadLength;
// Length
if (BitConverter.IsLittleEndian)
{
Buffer.BlockCopy(BitConverter.GetBytes(NetConvert.DoReverseEndian((ushort)offset)), 0, packetBuffer, 4, 2);
}
else
{
Buffer.BlockCopy(BitConverter.GetBytes((ushort)offset), 0, packetBuffer, 4, 2);
}
return packetBuffer.Take(offset).ToArray();
}
19
Source : ReceptionReport.cs
with MIT License
from chatop2020
with MIT License
from chatop2020
public byte[] GetBytes()
{
byte[] payload = new byte[24];
if (BitConverter.IsLittleEndian)
{
Buffer.BlockCopy(BitConverter.GetBytes(NetConvert.DoReverseEndian(SSRC)), 0, payload, 0, 4);
payload[4] = FractionLost;
Buffer.BlockCopy(BitConverter.GetBytes(NetConvert.DoReverseEndian(PacketsLost)), 1, payload, 5, 3);
Buffer.BlockCopy(BitConverter.GetBytes(NetConvert.DoReverseEndian(ExtendedHighestSequenceNumber)), 0, payload, 8, 4);
Buffer.BlockCopy(BitConverter.GetBytes(NetConvert.DoReverseEndian(Jitter)), 0, payload, 12, 4);
Buffer.BlockCopy(BitConverter.GetBytes(NetConvert.DoReverseEndian(LastSenderReportTimestamp)), 0, payload, 16, 4);
Buffer.BlockCopy(BitConverter.GetBytes(NetConvert.DoReverseEndian(DelaySinceLastSenderReport)), 0, payload, 20, 4);
}
else
{
Buffer.BlockCopy(BitConverter.GetBytes(SSRC), 0, payload, 0, 4);
payload[4] = FractionLost;
Buffer.BlockCopy(BitConverter.GetBytes(PacketsLost), 1, payload, 5, 3);
Buffer.BlockCopy(BitConverter.GetBytes(ExtendedHighestSequenceNumber), 0, payload, 8, 4);
Buffer.BlockCopy(BitConverter.GetBytes(Jitter), 0, payload, 12, 4);
Buffer.BlockCopy(BitConverter.GetBytes(LastSenderReportTimestamp), 0, payload, 16, 4);
Buffer.BlockCopy(BitConverter.GetBytes(DelaySinceLastSenderReport), 0, payload, 20, 4);
}
return payload;
}
19
Source : RTCPBye.cs
with MIT License
from chatop2020
with MIT License
from chatop2020
public byte[] GetBytes()
{
byte[] reasonBytes = (Reason != null) ? Encoding.UTF8.GetBytes(Reason) : null;
int reasonLength = (reasonBytes != null) ? reasonBytes.Length : 0;
byte[] buffer = new byte[RTCPHeader.HEADER_BYTES_LENGTH + GetPaddedLength(reasonLength)];
Header.SetLength((ushort)(buffer.Length / 4 - 1));
Buffer.BlockCopy(Header.GetBytes(), 0, buffer, 0, RTCPHeader.HEADER_BYTES_LENGTH);
int payloadIndex = RTCPHeader.HEADER_BYTES_LENGTH;
if (BitConverter.IsLittleEndian)
{
Buffer.BlockCopy(BitConverter.GetBytes(NetConvert.DoReverseEndian(SSRC)), 0, buffer, payloadIndex, 4);
}
else
{
Buffer.BlockCopy(BitConverter.GetBytes(SSRC), 0, buffer, payloadIndex, 4);
}
if (reasonLength > 0)
{
buffer[payloadIndex + 4] = (byte)reasonLength;
Buffer.BlockCopy(reasonBytes, 0, buffer, payloadIndex + 5, reasonBytes.Length);
}
return buffer;
}
19
Source : RTCPFeedback.cs
with MIT License
from chatop2020
with MIT License
from chatop2020
public byte[] GetBytes()
{
byte[] buffer = new byte[RTCPHeader.HEADER_BYTES_LENGTH + SENDER_PAYLOAD_SIZE];
Header.SetLength((ushort)(buffer.Length / 4 - 1));
Buffer.BlockCopy(Header.GetBytes(), 0, buffer, 0, RTCPHeader.HEADER_BYTES_LENGTH);
int payloadIndex = RTCPHeader.HEADER_BYTES_LENGTH;
// All feedback packets require the Sender and Media SSRC's to be set.
if (BitConverter.IsLittleEndian)
{
Buffer.BlockCopy(BitConverter.GetBytes(NetConvert.DoReverseEndian(SenderSSRC)), 0, buffer, payloadIndex, 4);
Buffer.BlockCopy(BitConverter.GetBytes(NetConvert.DoReverseEndian(MedireplacedRC)), 0, buffer, payloadIndex + 4, 4);
}
else
{
Buffer.BlockCopy(BitConverter.GetBytes(SenderSSRC), 0, buffer, payloadIndex, 4);
Buffer.BlockCopy(BitConverter.GetBytes(MedireplacedRC), 0, buffer, payloadIndex + 4, 4);
}
switch (Header)
{
case var x when x.PacketType == RTCPReportTypesEnum.RTPFB && x.FeedbackMessageType == RTCPFeedbackTypesEnum.RTCP_SR_REQ:
// PLI feedback reports do no have any additional parameters.
break;
case var x when x.PacketType == RTCPReportTypesEnum.RTPFB:
if (BitConverter.IsLittleEndian)
{
Buffer.BlockCopy(BitConverter.GetBytes(NetConvert.DoReverseEndian(PID)), 0, buffer, payloadIndex + 6, 2);
Buffer.BlockCopy(BitConverter.GetBytes(NetConvert.DoReverseEndian(BLP)), 0, buffer, payloadIndex + 8, 2);
}
else
{
Buffer.BlockCopy(BitConverter.GetBytes(PID), 0, buffer, payloadIndex + 6, 2);
Buffer.BlockCopy(BitConverter.GetBytes(BLP), 0, buffer, payloadIndex + 8, 2);
}
break;
case var x when x.PacketType == RTCPReportTypesEnum.PSFB && x.PayloadFeedbackMessageType == PSFBFeedbackTypesEnum.PLI:
break;
default:
throw new NotImplementedException($"Serialisation for feedback report {Header.PacketType} not yet implemented.");
}
return buffer;
}
19
Source : RTCPHeader.cs
with MIT License
from chatop2020
with MIT License
from chatop2020
public byte[] GetBytes()
{
byte[] header = new byte[4];
UInt32 firstWord = ((uint)Version << 30) + ((uint)PaddingFlag << 29) + ((uint)PacketType << 16) + Length;
if (IsFeedbackReport())
{
if (PacketType == RTCPReportTypesEnum.RTPFB)
{
firstWord += (uint)FeedbackMessageType << 24;
}
else
{
firstWord += (uint)PayloadFeedbackMessageType << 24;
}
}
else
{
firstWord += (uint)ReceptionReportCount << 24;
}
if (BitConverter.IsLittleEndian)
{
Buffer.BlockCopy(BitConverter.GetBytes(NetConvert.DoReverseEndian(firstWord)), 0, header, 0, 4);
}
else
{
Buffer.BlockCopy(BitConverter.GetBytes(firstWord), 0, header, 0, 4);
}
return header;
}
19
Source : RTCPReceiverReport.cs
with MIT License
from chatop2020
with MIT License
from chatop2020
public byte[] GetBytes()
{
int rrCount = (ReceptionReports != null) ? ReceptionReports.Count : 0;
byte[] buffer = new byte[RTCPHeader.HEADER_BYTES_LENGTH + 4 + rrCount * ReceptionReportSample.PAYLOAD_SIZE];
Header.SetLength((ushort)(buffer.Length / 4 - 1));
Buffer.BlockCopy(Header.GetBytes(), 0, buffer, 0, RTCPHeader.HEADER_BYTES_LENGTH);
int payloadIndex = RTCPHeader.HEADER_BYTES_LENGTH;
if (BitConverter.IsLittleEndian)
{
Buffer.BlockCopy(BitConverter.GetBytes(NetConvert.DoReverseEndian(SSRC)), 0, buffer, payloadIndex, 4);
}
else
{
Buffer.BlockCopy(BitConverter.GetBytes(SSRC), 0, buffer, payloadIndex, 4);
}
int bufferIndex = payloadIndex + 4;
for (int i = 0; i < rrCount; i++)
{
var receptionReportBytes = ReceptionReports[i].GetBytes();
Buffer.BlockCopy(receptionReportBytes, 0, buffer, bufferIndex, ReceptionReportSample.PAYLOAD_SIZE);
bufferIndex += ReceptionReportSample.PAYLOAD_SIZE;
}
return buffer;
}
19
Source : RTCPSdesReport.cs
with MIT License
from chatop2020
with MIT License
from chatop2020
public byte[] GetBytes()
{
byte[] cnameBytes = Encoding.UTF8.GetBytes(CNAME);
byte[] buffer = new byte[RTCPHeader.HEADER_BYTES_LENGTH + GetPaddedLength(cnameBytes.Length)]; // Array automatically initialised with 0x00 values.
Header.SetLength((ushort)(buffer.Length / 4 - 1));
Buffer.BlockCopy(Header.GetBytes(), 0, buffer, 0, RTCPHeader.HEADER_BYTES_LENGTH);
int payloadIndex = RTCPHeader.HEADER_BYTES_LENGTH;
if (BitConverter.IsLittleEndian)
{
Buffer.BlockCopy(BitConverter.GetBytes(NetConvert.DoReverseEndian(SSRC)), 0, buffer, payloadIndex, 4);
}
else
{
Buffer.BlockCopy(BitConverter.GetBytes(SSRC), 0, buffer, payloadIndex, 4);
}
buffer[payloadIndex + 4] = CNAME_ID;
buffer[payloadIndex + 5] = (byte)cnameBytes.Length;
Buffer.BlockCopy(cnameBytes, 0, buffer, payloadIndex + 6, cnameBytes.Length);
return buffer;
}
19
Source : RTCPSenderReport.cs
with MIT License
from chatop2020
with MIT License
from chatop2020
public byte[] GetBytes()
{
int rrCount = (ReceptionReports != null) ? ReceptionReports.Count : 0;
byte[] buffer = new byte[RTCPHeader.HEADER_BYTES_LENGTH + 4 + SENDER_PAYLOAD_SIZE + rrCount * ReceptionReportSample.PAYLOAD_SIZE];
Header.SetLength((ushort)(buffer.Length / 4 - 1));
Buffer.BlockCopy(Header.GetBytes(), 0, buffer, 0, RTCPHeader.HEADER_BYTES_LENGTH);
int payloadIndex = RTCPHeader.HEADER_BYTES_LENGTH;
if (BitConverter.IsLittleEndian)
{
Buffer.BlockCopy(BitConverter.GetBytes(NetConvert.DoReverseEndian(SSRC)), 0, buffer, payloadIndex, 4);
Buffer.BlockCopy(BitConverter.GetBytes(NetConvert.DoReverseEndian(NtpTimestamp)), 0, buffer, payloadIndex + 4, 8);
Buffer.BlockCopy(BitConverter.GetBytes(NetConvert.DoReverseEndian(RtpTimestamp)), 0, buffer, payloadIndex + 12, 4);
Buffer.BlockCopy(BitConverter.GetBytes(NetConvert.DoReverseEndian(PacketCount)), 0, buffer, payloadIndex + 16, 4);
Buffer.BlockCopy(BitConverter.GetBytes(NetConvert.DoReverseEndian(OctetCount)), 0, buffer, payloadIndex + 20, 4);
}
else
{
Buffer.BlockCopy(BitConverter.GetBytes(SSRC), 0, buffer, payloadIndex, 4);
Buffer.BlockCopy(BitConverter.GetBytes(NtpTimestamp), 0, buffer, payloadIndex + 4, 8);
Buffer.BlockCopy(BitConverter.GetBytes(RtpTimestamp), 0, buffer, payloadIndex + 12, 4);
Buffer.BlockCopy(BitConverter.GetBytes(PacketCount), 0, buffer, payloadIndex + 16, 4);
Buffer.BlockCopy(BitConverter.GetBytes(OctetCount), 0, buffer, payloadIndex + 20, 4);
}
int bufferIndex = payloadIndex + 24;
for (int i = 0; i < rrCount; i++)
{
var receptionReportBytes = ReceptionReports[i].GetBytes();
Buffer.BlockCopy(receptionReportBytes, 0, buffer, bufferIndex, ReceptionReportSample.PAYLOAD_SIZE);
bufferIndex += ReceptionReportSample.PAYLOAD_SIZE;
}
return buffer;
}
19
Source : RTPEvent.cs
with MIT License
from chatop2020
with MIT License
from chatop2020
public byte[] GetEventPayload()
{
byte[] payload = new byte[DTMF_PACKET_LENGTH];
payload[0] = EventID;
payload[1] = (byte)(EndOfEvent ? 0x80 : 0x00);
payload[1] += (byte)(Volume & 0xcf); // The Volume field uses 6 bits.
if (BitConverter.IsLittleEndian)
{
Buffer.BlockCopy(BitConverter.GetBytes(NetConvert.DoReverseEndian(Duration)), 0, payload, 2, 2);
}
else
{
Buffer.BlockCopy(BitConverter.GetBytes(Duration), 0, payload, 2, 2);
}
return payload;
}
19
Source : RTPHeader.cs
with MIT License
from chatop2020
with MIT License
from chatop2020
public byte[] GetBytes()
{
byte[] header = new byte[Length];
UInt16 firstWord = Convert.ToUInt16(Version * 16384 + PaddingFlag * 8192 + HeaderExtensionFlag * 4096 + CSRCCount * 256 + MarkerBit * 128 + PayloadType);
if (BitConverter.IsLittleEndian)
{
Buffer.BlockCopy(BitConverter.GetBytes(NetConvert.DoReverseEndian(firstWord)), 0, header, 0, 2);
Buffer.BlockCopy(BitConverter.GetBytes(NetConvert.DoReverseEndian(SequenceNumber)), 0, header, 2, 2);
Buffer.BlockCopy(BitConverter.GetBytes(NetConvert.DoReverseEndian(Timestamp)), 0, header, 4, 4);
Buffer.BlockCopy(BitConverter.GetBytes(NetConvert.DoReverseEndian(SyncSource)), 0, header, 8, 4);
if (HeaderExtensionFlag == 1)
{
Buffer.BlockCopy(BitConverter.GetBytes(NetConvert.DoReverseEndian(ExtensionProfile)), 0, header, 12 + 4 * CSRCCount, 2);
Buffer.BlockCopy(BitConverter.GetBytes(NetConvert.DoReverseEndian(ExtensionLength)), 0, header, 14 + 4 * CSRCCount, 2);
}
}
else
{
Buffer.BlockCopy(BitConverter.GetBytes(firstWord), 0, header, 0, 2);
Buffer.BlockCopy(BitConverter.GetBytes(SequenceNumber), 0, header, 2, 2);
Buffer.BlockCopy(BitConverter.GetBytes(Timestamp), 0, header, 4, 4);
Buffer.BlockCopy(BitConverter.GetBytes(SyncSource), 0, header, 8, 4);
if (HeaderExtensionFlag == 1)
{
Buffer.BlockCopy(BitConverter.GetBytes(ExtensionProfile), 0, header, 12 + 4 * CSRCCount, 2);
Buffer.BlockCopy(BitConverter.GetBytes(ExtensionLength), 0, header, 14 + 4 * CSRCCount, 2);
}
}
if (ExtensionLength > 0 && ExtensionPayload != null)
{
Buffer.BlockCopy(ExtensionPayload, 0, header, 16 + 4 * CSRCCount, ExtensionLength * 4);
}
return header;
}
See More Examples