Exemple #1
0
        public static SdpDataElement CreateAlternative(IEnumerable <SdpDataElement> value)
        {
            SdpDataElement e = new SdpDataElement(value);

            e._type = SdpDataElementType.Alternative;
            return(e);
        }
Exemple #2
0
        public static SdpDataElement CreateUuid16(ushort value)
        {
            SdpDataElement e = new SdpDataElement(value);

            e._type = SdpDataElementType.Uuid16;
            return(e);
        }
Exemple #3
0
        private static SdpDataElement FromByteArray(byte[] rawData, ref int offset, int len)
        {
            SdpDataElement element = new SdpDataElement();

            element._type = (SdpDataElementType)rawData[offset];

            switch (element._type)
            {
            case SdpDataElementType.Boolean:
                element._value = false;
                offset        += 1;
                break;

            case SdpDataElementType.BooleanTrue:
                element._value = true;
                element._type  = SdpDataElementType.Boolean;
                offset        += 1;
                break;

            case SdpDataElementType.Byte:
                element._value = rawData[offset + 1];
                offset        += 2;
                break;

            case SdpDataElementType.Uuid16:
            case SdpDataElementType.UInt16:
                element._value = BitConverter.ToUInt16(rawData, offset + 1);
                offset        += 3;
                break;

            case SdpDataElementType.UInt32:
            case SdpDataElementType.Uuid32:
                element._value = BitConverter.ToUInt32(rawData, offset + 1);
                offset        += 5;
                break;

            case SdpDataElementType.UInt64:
                element._value = BitConverter.ToUInt64(rawData, offset + 1);
                offset        += 9;
                break;

            case SdpDataElementType.UInt128:
            case SdpDataElementType.Int128:
            case SdpDataElementType.Uuid128:
                byte[] guidBytes = new byte[16];
                Buffer.BlockCopy(rawData, offset + 1, guidBytes, 0, 16);
                element._value = new Guid(guidBytes);
                offset        += 17;
                break;

            case SdpDataElementType.SByte:
                element._value = Convert.ToSByte(rawData[offset + 1]);
                offset        += 2;
                break;

            case SdpDataElementType.Int16:
                element._value = BitConverter.ToInt16(rawData, offset + 1);
                offset        += 3;
                break;

            case SdpDataElementType.Int32:
                element._value = BitConverter.ToInt32(rawData, offset + 1);
                offset        += 5;
                break;

            case SdpDataElementType.Int64:
                element._value = BitConverter.ToInt64(rawData, offset + 1);
                offset        += 9;
                break;

            case SdpDataElementType.Alternative:
            case SdpDataElementType.Sequence:
                byte qlen    = rawData[offset + 1];
                int  soffset = offset + 2;
                int  end     = soffset + qlen;
                List <SdpDataElement> elements = new List <SdpDataElement> {
                    SdpDataElement.FromByteArray(rawData, ref soffset, end)
                };
                while (soffset < end)
                {
                    elements.Add(SdpDataElement.FromByteArray(rawData, ref soffset, end));
                }
                element._value = elements;
                offset        += (2 + qlen);
                break;

            case SdpDataElementType.String:
                byte   slen = rawData[offset + 1];
                string sval = System.Text.Encoding.UTF8.GetString(rawData, offset + 2, slen);
                element._value = sval;
                offset        += (2 + slen);
                break;

            case SdpDataElementType.Uri:
                byte   ulen = rawData[offset + 1];
                string uval = System.Text.Encoding.UTF8.GetString(rawData, offset + 2, ulen);
                element._value = new Uri(uval);
                offset        += (2 + ulen);
                break;

            case SdpDataElementType.LongAlternative:
            case SdpDataElementType.LongSequence:
                ushort lqlen    = BitConverter.ToUInt16(rawData, offset + 1);
                int    lsoffset = offset + 3;
                int    lend     = lsoffset + lqlen;
                List <SdpDataElement> lelements = new List <SdpDataElement> {
                    SdpDataElement.FromByteArray(rawData, ref lsoffset, lend)
                };
                while (lsoffset < lend)
                {
                    lelements.Add(SdpDataElement.FromByteArray(rawData, ref lsoffset, lend));
                }
                element._value = lelements;
                offset        += (3 + lqlen);
                break;

            case SdpDataElementType.LongString:
                ushort lslen = BitConverter.ToUInt16(rawData, offset + 1);
                string lsval = System.Text.Encoding.UTF8.GetString(rawData, offset + 3, lslen);
                element._value = lsval;
                offset        += (3 + lslen);
                break;

            case SdpDataElementType.LongUri:
                ushort lulen = BitConverter.ToUInt16(rawData, offset + 1);
                string luval = System.Text.Encoding.UTF8.GetString(rawData, offset + 3, lulen);
                element._value = new Uri(luval);
                offset        += (3 + lulen);
                break;

            case SdpDataElementType.HugeAlternative:
            case SdpDataElementType.HugeSequence:
                int hqlen    = BitConverter.ToInt32(rawData, offset + 1);
                int hsoffset = offset + 5;
                int hend     = hsoffset + hqlen;
                List <SdpDataElement> helements = new List <SdpDataElement> {
                    SdpDataElement.FromByteArray(rawData, ref hsoffset, hend)
                };
                while (hsoffset < hend)
                {
                    helements.Add(SdpDataElement.FromByteArray(rawData, ref hsoffset, hend));
                }
                element._value = helements;
                offset        += (5 + hqlen);
                break;

            case SdpDataElementType.HugeString:
                int    hslen = BitConverter.ToInt32(rawData, offset + 1);
                string hsval = System.Text.Encoding.UTF8.GetString(rawData, offset + 5, hslen);
                element._value = hsval;
                offset        += (5 + hslen);
                break;

            case SdpDataElementType.HugeUri:
                int    hulen = BitConverter.ToInt32(rawData, offset + 1);
                string huval = System.Text.Encoding.UTF8.GetString(rawData, offset + 5, hulen);
                element._value = new Uri(huval);
                offset        += (5 + hulen);
                break;
            }

            return(element);
        }