System.BitConverter.GetBytes(double)

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 7

19 Source : HealingStatsExtensionHandler.cs
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

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

public void Write(double value, Endianness endianness) => this.WriteForEndianness(BitConverter.GetBytes(value), endianness);

19 Source : WCH7.cs
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

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

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

[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

[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

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

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

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

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

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

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

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

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

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

public void WriteDouble(double value)
        {
            WriteBlob(BitConverter.GetBytes(value), 8);
        }

19 Source : RegistrationToken.cs
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

public void AddDouble(double input)
        {
            AddBytesEndian(BitConverter.GetBytes(input));
        }

19 Source : Helpers.cs
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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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