/// <summary>
        /// Decode segment data to an array of server Pdus
        /// </summary>
        /// <param name="data"></param>
        /// <returns></returns>
        public static RdpegfxPdu[] Decode(byte[] data)
        {
            RDP_SEGMENTED_DATA segData = new RDP_SEGMENTED_DATA();
            bool fResult = PduMarshaler.Unmarshal(data, segData);

            if (fResult)
            {
                if (segData.descriptor == DescriptorTypes.SINGLE)
                {
                    byte[] rawData = Compressor.Decompress(segData.bulkData.data, segData.bulkData.header);;


                    return(DecodePdus(rawData));
                }
                else
                {
                    List <byte>        dataList = new List <byte>();
                    byte[]             rawData  = null;
                    RDP_DATA_SEGMENT[] dataSegs = segData.segmentArray;
                    for (int i = 0; i < dataSegs.Length; i++)
                    {
                        RDP8_BULK_ENCODED_DATA bulkData = dataSegs[i].bulkData;
                        rawData = Compressor.Decompress(bulkData.data, bulkData.header);
                        dataList.AddRange(rawData);
                    }

                    if (segData.uncompressedSize == dataList.Count)
                    {
                        return(DecodePdus(dataList.ToArray()));
                    }
                }
            }

            return(null);
        }
        /// <summary>
        /// Decode this PDU from the PduMarshaler.
        /// </summary>
        /// <param name="marshaler">This is used to decode the fields of this PDU.</param>
        public override bool Decode(PduMarshaler marshaler)
        {
            try
            {
                this.descriptor = (DescriptorTypes)marshaler.ReadByte();

                if (this.descriptor == DescriptorTypes.SINGLE)
                {
                    this.bulkData = new RDP8_BULK_ENCODED_DATA();
                    this.bulkData.header = marshaler.ReadByte();
                    this.bulkData.data = marshaler.ReadToEnd();
                }
                else
                {
                    this.segmentCount = marshaler.ReadUInt16();
                    this.uncompressedSize = marshaler.ReadUInt32();
                    if (this.segmentCount > 0)
                    {
                        this.segmentArray = new RDP_DATA_SEGMENT[this.segmentCount];
                        for (int i = 0; i < this.segmentCount; i++)
                        {
                            this.segmentArray[i].size = marshaler.ReadUInt32();
                            if (this.segmentArray[i].size > 0)
                            {
                                this.segmentArray[i].bulkData = new RDP8_BULK_ENCODED_DATA();
                                this.segmentArray[i].bulkData.header = marshaler.ReadByte();
                                this.segmentArray[i].bulkData.data = marshaler.ReadBytes((int)this.segmentArray[i].size - 1);
                            }
                        }
                    }
                }

                return true;
            }
            catch
            {
                marshaler.Reset();
                throw new PDUDecodeException(this.GetType(), marshaler.ReadToEnd());
            }
        }